Remove Cursor and CursorReset

Print now accepts mandatory x,y position instead. Cursor, CursorReset functions were removed.

It still possible to print multi-line text by using special '\n' character inside the string text.

Author: elgopher

examples/boot/main.go

@@ -14,8 +14,7 @@ func main() {
 	pi.MustBoot()
 
 	// once boot is executed all drawing functions are available:
-	pi.Cursor(0, 18)
-	pi.Print("TINY SCREEN", 7) // print text on the screen before game loop
+	pi.Print("TINY SCREEN", 0, 18, 7) // print text on the screen before game loop
 
 	// Run the game loop.
 	pi.MustRun()

examples/keyboard/main.go

@@ -69,8 +69,7 @@ func drawKey(x, y, w int, b key.Button) {
 
 	str := b.String()
 	if len(str) == 1 {
-		pi.Cursor(x+2, y+2)
-		pi.Print(str, 15)
+		pi.Print(str, x+2, y+2, 15)
 	}
 
 }

examples/print/custom-font.png

@@ -2,15 +2,18 @@
 package main
 
 import (
+	"embed"
+
 	"github.com/elgopher/pi"
 )
 
+//go:embed custom-font.png
+var resources embed.FS
+
 func main() {
+	pi.Resources = resources
 	pi.Draw = func() {
-		pi.CursorReset()      // set cursor to 0,0
-		pi.Cursor(50, 58)     // set cursor position
-		pi.Print("HELLO,", 9) // print yellow text and go to next line
-		pi.Print("GOPHER!", 12)
+		pi.Print("HELLO,\nWORLD!", 50, 58, 9) // print two lines of yellow text using system font
 	}
 	pi.MustRun()
 }

examples/print/main.go

@@ -23,33 +23,37 @@ var drawFunctions = []func(x0, y0, x1, y1 int){
 	func(x0, y0, x1, y1 int) {
 		pi.Rect(x0, y0, x1, y1, shapeColor)
 		command := fmt.Sprintf("Rect(%d,%d,%d,%d,%d)", x0, y0, x1, y1, shapeColor)
-		pi.Print(command, textColor)
+		printCmd(command)
 	},
 	func(x0, y0, x1, y1 int) {
 		pi.RectFill(x0, y0, x1, y1, shapeColor)
 		command := fmt.Sprintf("RectFill(%d,%d,%d,%d,%d)", x0, y0, x1, y1, shapeColor)
-		pi.Print(command, textColor)
+		printCmd(command)
 	},
 	func(x0, y0, x1, y1 int) {
 		pi.Line(x0, y0, x1, y1, shapeColor)
 		command := fmt.Sprintf("Line(%d,%d,%d,%d,%d)", x0, y0, x1, y1, shapeColor)
-		pi.Print(command, textColor)
+		printCmd(command)
 	},
 	func(x0, y0, x1, y1 int) {
 		r := radius(x0, y0, x1, y1)
 		pi.Circ(x0, y0, r, shapeColor)
 
 		command := fmt.Sprintf("Circ(%d,%d,%d,%d)", x0, y0, r, shapeColor)
-		pi.Print(command, textColor)
+		printCmd(command)
 	},
 	func(x0, y0, x1, y1 int) {
 		r := radius(x0, y0, x1, y1)
 		pi.CircFill(x0, y0, r, shapeColor)
 		command := fmt.Sprintf("CircFill(%d,%d,%d,%d)", x0, y0, r, shapeColor)
-		pi.Print(command, textColor)
+		printCmd(command)
 	},
 }
 
+func printCmd(command string) {
+	pi.Print(command, 8, 128-6-6, textColor)
+}
+
 var current = 0
 
 var x0, y0 int
@@ -74,8 +78,6 @@ func main() {
 
 		}
 
-		pi.Cursor(8, 128-6-6)
-
 		// set coordinates during dragging
 		if drawShape != nil {
 			x1, y1 := pi.MousePos()

examples/shapes/main.go

@@ -12,14 +12,13 @@ import (
 func BenchmarkPrint(b *testing.B) {
 	runBenchmarks(b, func(r Resolution) {
 		for j := 0; j < 10; j++ {
-			pi.Cursor(0, 0)
-			pi.Print("Hello", color)
+			pi.Print("Hello", 0, 0, color)
 		}
 	})
 }
 
 func BenchmarkPrintWithScroll(b *testing.B) {
 	runBenchmarks(b, func(r Resolution) {
-		pi.Print("Hello", color)
+		pi.Print("Hello", 0, 0, color)
 	})
 }

internal/bench/print_bench_test.go

@@ -16,7 +16,6 @@ func FuzzPrint(f *testing.F) {
 	pi.ScreenHeight = 24
 	pi.MustBoot()
 	f.Fuzz(func(t *testing.T, x, y int) {
-		pi.Cursor(x, y)
-		pi.Print("A", color)
+		pi.Print("A", x, y, color)
 	})
 }

internal/fuzz/print_test.go

@@ -117,7 +117,7 @@ func Boot() error {
 		return err
 	}
 
-	if err := loadSystemFont(); err != nil {
+	if err := loadFontData(systemFontPNG, systemFont.Data[:]); err != nil {
 		return err
 	}
 
@@ -146,7 +146,6 @@ func Boot() error {
 	CameraReset()
 	PaltReset()
 	PalReset()
-	CursorReset()
 
 	booted = true
 
@@ -172,7 +171,11 @@ func validateUserParameters() error {
 }
 
 func loadResources(resources fs.ReadFileFS) error {
-	return loadSpriteSheet(resources)
+	if err := loadSpriteSheet(resources); err != nil {
+		return err
+	}
+
+	return nil
 }
 
 // MustBoot does the same as Boot, but panics instead of returning an error.

internal/testimage/print/clip-bottom-cursory.png renamed to internal/testimage/print/clip-bottom-posy.png

@@ -31,116 +31,56 @@ type Font struct {
 	Width int
 	// WidthSpecial is a with of all special characters (code>=128)
 	WidthSpecial int
-	Height       int
+	// Height of line
+	Height int
 }
 
-func loadSystemFont() error {
-	img, err := image.DecodePNG(bytes.NewReader(systemFontPNG))
-	if err != nil {
-		return fmt.Errorf("decoding system font failed: %w", err)
-	}
-
-	if err = font.Load(img, systemFont.Data[:]); err != nil {
-		return fmt.Errorf("error loading system font: %w", err)
-	}
-
-	return nil
-}
-
-var cursor pos
-
-// Cursor set cursor position (in pixels) used by Print.
-//
-// Cursor returns previously set cursor position.
-func Cursor(x, y int) (prevX, prevY int) {
-	prevX, prevY = cursor.x, cursor.y
-	cursor.x = x
-	cursor.y = y
-	return
-}
-
-// CursorReset resets cursor position used by Print to 0,0.
-//
-// CursorReset returns previously set cursor position.
-func CursorReset() (prevX, prevY int) {
-	return Cursor(0, 0)
-}
-
-// Print prints text on the screen. It takes into consideration cursor position,
+// Print prints text on the screen at given coordinates. It takes into account
 // clipping region and camera position.
 //
-// After printing all characters Print goes to the next line. When there is no space
-// left on screen the clipping region is scrolled to make room.
-//
 // Only unicode characters with code < 256 are supported. Unsupported chars
 // are printed as question mark. The entire table of available chars can be
 // found here: https://github.com/elgopher/pi/blob/master/internal/system-font.png
 //
 // Print returns the right-most x position that occurred while printing.
-func Print(text string, color byte) (x int) {
-	if cursor.y > scrHeight-systemFont.Height {
-		lines := systemFont.Height - (scrHeight - cursor.y)
-		scroll(lines)
-	}
+func (f Font) Print(text string, x, y int, color byte) int {
+	startX := x
 
-	startingX := cursor.x
 	for _, r := range text {
-		printRune(r, color)
-	}
-
-	x = cursor.x
-	cursor.x = startingX
-	cursor.y += systemFont.Height
-	if cursor.y > scrHeight-systemFont.Height {
-		scroll(systemFont.Height)
-	}
-
-	return
-}
-
-func scroll(lines int) {
-	if scrHeight <= lines {
-		cls()
-		cursor.y = scrHeight - systemFont.Height
-		return
-	}
-
-	for y := clippingRegion.y; y < scrHeight-lines; y++ {
-		srcOffset := y*scrWidth + clippingRegion.x
-		dstOffset := srcOffset + lines*scrWidth
-		copy(ScreenData[srcOffset:], ScreenData[dstOffset:dstOffset+clippingRegion.w])
-	}
-
-	for y := scrHeight - lines; y < clippingRegion.y+clippingRegion.h; y++ {
-		offset := y*scrWidth + clippingRegion.x
-		copy(ScreenData[offset:], zeroScreenData[:clippingRegion.w])
+		if r != '\n' {
+			width := f.printRune(r, x, y, color)
+			x += width
+		} else {
+			x = startX
+			y += f.Height
+		}
 	}
 
-	cursor.y -= lines
+	return x
 }
 
-func printRune(r rune, color byte) {
+func (f Font) printRune(r rune, sx, sy int, color byte) int {
 	if r > 255 {
 		r = '?'
 	}
 
 	index := int(r) * 8
 
 	for y := 0; y < 8; y++ {
-		if clippingRegion.y > cursor.y+y-camera.y {
+		if clippingRegion.y > sy+y-camera.y {
 			continue
 		}
-		if clippingRegion.y+clippingRegion.h <= cursor.y+y-camera.y {
+		if clippingRegion.y+clippingRegion.h <= sy+y-camera.y {
 			continue
 		}
 
-		offset := scrWidth*y + cursor.x + cursor.y*scrWidth - camera.y*scrWidth - camera.x
-		line := systemFont.Data[index+y]
+		offset := scrWidth*y + sx + sy*scrWidth - camera.y*scrWidth - camera.x
+		line := f.Data[index+y]
 		for bit := 0; bit < 8; bit++ {
-			if clippingRegion.x > cursor.x+bit-camera.x {
+			if clippingRegion.x > sx+bit-camera.x {
 				continue
 			}
-			if clippingRegion.x+clippingRegion.w <= cursor.x+bit-camera.x {
+			if clippingRegion.x+clippingRegion.w <= sx+bit-camera.x {
 				continue
 			}
 			if line&(1<<bit) == 1<<bit {
@@ -150,8 +90,41 @@ func printRune(r rune, color byte) {
 	}
 
 	if r < 128 {
-		cursor.x += systemFont.Width
+		return f.Width
 	} else {
-		cursor.x += systemFont.WidthSpecial
+		return f.WidthSpecial
+	}
+}
+
+// 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
+}
+
+// Print prints text on the screen using system font. It takes into consideration
+// clipping region and camera position.
+//
+// Only unicode characters with code < 256 are supported. Unsupported chars
+// are printed as question mark. The entire table of available chars can be
+// found here: https://github.com/elgopher/pi/blob/master/internal/system-font.png
+//
+// Print returns the right-most x position that occurred while printing.
+func Print(text string, x, y int, color byte) (rightMostX int) {
+	return systemFont.Print(text, x, y, color)
 }