Make low-level API safer to use

mem package is unsafe to use. User might set screen size without updating data slice. Same for sprite-sheet.

Also, mem package duplicates a lot information which might be confusing for user (for example which package mem or pi the source of truth?)

Also, functions like pi.Boot() or pi.Run() are hard to understand. User has to remember than after specifying the new screen size he has to boot the game again.

This change is a huge one. It removes mem package completely and instead it introduces new functions:

* SetScreenSize
* UseEmptySpriteSheet
* SetCustomFontWidth
* SetCustomFontSpecialWidth
* SetCustomFontHeight

Author: elgopher

controller.go

@@ -5,7 +5,6 @@ package pi
 
 import (
 	"github.com/elgopher/pi/internal/input"
-	"github.com/elgopher/pi/mem"
 )
 
 // Button is a virtual button on any game controller. The game controller can be a gamepad or a keyboard.
@@ -21,14 +20,22 @@ type Button int
 // First connected gamepad controller is player 0, second player 1 and so on.
 // On XBox controller [O] is A and Y, [X] is B and X.
 const (
-	Left  = mem.ControllerLeft
-	Right = mem.ControllerRight
-	Up    = mem.ControllerUp
-	Down  = mem.ControllerDown
-	O     = mem.ControllerO // O is a first fire button
-	X     = mem.ControllerX // X is a second fire button
+	Left  = 0
+	Right = 1
+	Up    = 2
+	Down  = 3
+	O     = 4 // O is a first fire button
+	X     = 5 // X is a second fire button
 )
 
+var Controllers [8]Controller // 0th element is for Player 0, 1st for Player 1 etc.
+
+type Controller struct {
+	// BtnDuration is how many frames button was pressed:
+	// Index of array is equal to controller button constant.
+	BtnDuration [6]uint
+}
+
 // Btn returns true if a controller button is being pressed at this moment by player 0.
 func Btn(button Button) bool {
 	return BtnPlayer(button, 0)
@@ -87,15 +94,15 @@ func buttonDuration(player int, button Button) uint {
 		return 0
 	}
 
-	return mem.Controllers[player].BtnDuration[button]
+	return Controllers[player].BtnDuration[button]
 }
 
 func isPressed(duration uint) bool {
 	return duration > 0
 }
 
 func buttonBits(player int, isSet func(uint) bool) int {
-	c := mem.Controllers[player]
+	c := Controllers[player]
 	var b int
 	for i := 0; i <= X; i++ {
 		if isSet(c.BtnDuration[i]) {

defaults.go

@@ -3,7 +3,9 @@
 
 package pi
 
-import "github.com/elgopher/pi/mem"
+import (
+	"github.com/elgopher/pi/image"
+)
 
 const (
 	defaultSpriteSheetWidth  = 128
@@ -14,7 +16,7 @@ const (
 
 var (
 	//nolint:govet
-	defaultPalette = [256]mem.RGB{
+	defaultPalette = [256]image.RGB{
 		{0, 0, 0},          // 0 - black
 		{0x1D, 0x2B, 0x53}, // 1 - dark blue
 		{0x7E, 0x25, 0x53}, // 2 - dark purple

devtools/control.go

@@ -4,8 +4,8 @@
 package devtools
 
 import (
+	"github.com/elgopher/pi"
 	"github.com/elgopher/pi/devtools/internal/snapshot"
-	"github.com/elgopher/pi/mem"
 )
 
 var (
@@ -15,12 +15,12 @@ var (
 
 func pauseGame() {
 	gamePaused = true
-	timeWhenPaused = mem.TimeSeconds
+	timeWhenPaused = pi.TimeSeconds
 	snapshot.Take()
 }
 
 func resumeGame() {
 	gamePaused = false
-	mem.TimeSeconds = timeWhenPaused
+	pi.TimeSeconds = timeWhenPaused
 	snapshot.Draw()
 }

devtools/devtools.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/elgopher/pi"
 	"github.com/elgopher/pi/devtools/internal/inspector"
-	"github.com/elgopher/pi/mem"
 )
 
 var (
@@ -18,7 +17,7 @@ var (
 	FgColor byte = 7
 )
 
-// MustRun runs the game using backend, similarly to pi.MustRun.
+// MustRun runs the game with devtools.
 //
 // Any time you can pause them game by pressing F12. This will
 // show screen inspector. F12 again resumes the game.
@@ -47,12 +46,14 @@ func MustRun(runBackend func() error) {
 		}
 	}
 
-	pi.MustRun(runBackend)
+	if err := runBackend(); err != nil {
+		panic(fmt.Sprintf("Something terrible happened! Pi cannot be run: %v\n", err))
+	}
 }
 
 func handleStoppedGame() {
-	if mem.GameLoopStopped {
+	if pi.GameLoopStopped {
 		pauseGame()
-		mem.GameLoopStopped = false
+		pi.GameLoopStopped = false
 	}
 }

devtools/internal/icons/icons.go

@@ -20,12 +20,14 @@ var iconsPng []byte
 
 var icons = pi.Font{
 	Width:        4,
-	WidthSpecial: 8,
+	SpecialWidth: 8,
 	Height:       8,
 }
 
 func init() {
-	if err := font.Load(iconsPng, icons.Data[:]); err != nil {
+	var err error
+	icons.Data, err = font.Load(iconsPng)
+	if err != nil {
 		panic(fmt.Sprintf("problem loading devtools icons %s", err))
 	}
 }

devtools/internal/inspector/draw.go

@@ -11,7 +11,6 @@ import (
 	"github.com/elgopher/pi/devtools/internal/rgb"
 	"github.com/elgopher/pi/devtools/internal/snapshot"
 	"github.com/elgopher/pi/key"
-	"github.com/elgopher/pi/mem"
 	"github.com/elgopher/pi/snap"
 )
 
@@ -37,17 +36,19 @@ func Draw() {
 
 func cursorOutOfWindow() bool {
 	x, y := pi.MousePos()
-	return x < 0 || x >= mem.ScreenWidth || y < 0 || y >= mem.ScreenHeight
+	screen := pi.Scr()
+	return x < 0 || x >= screen.W || y < 0 || y >= screen.H
 }
 
 func drawBar() {
+	screen := pi.Scr()
 	mouseX, mouseY := pi.MousePos()
 	var barY int
 	if !isBarOnTop {
-		barY = mem.ScreenHeight - 7
+		barY = screen.H - 7
 	}
 
-	pi.RectFill(0, barY, mem.ScreenWidth, barY+6, BgColor)
+	pi.RectFill(0, barY, screen.W, barY+6, BgColor)
 
 	textX := 1
 	textY := barY + 1
@@ -77,7 +78,7 @@ func drawPointer() {
 
 func choosePointerColor(x, y int) byte {
 	c := pixelColorAtMouseCoords
-	if rgb.BrightnessDelta(mem.Palette[FgColor], mem.Palette[c]) >= rgb.BrightnessDelta(mem.Palette[BgColor], mem.Palette[c]) {
+	if rgb.BrightnessDelta(pi.Palette[FgColor], pi.Palette[c]) >= rgb.BrightnessDelta(pi.Palette[BgColor], pi.Palette[c]) {
 		return FgColor
 	}
 

devtools/internal/inspector/inspector.go

@@ -5,7 +5,6 @@ package inspector
 
 import (
 	"github.com/elgopher/pi"
-	"github.com/elgopher/pi/mem"
 )
 
 var isBarOnTop bool
@@ -15,7 +14,7 @@ func moveBarIfNeeded() {
 	switch {
 	case isBarOnTop && mouseY <= 12:
 		isBarOnTop = false
-	case !isBarOnTop && mouseY >= mem.ScreenHeight-12:
+	case !isBarOnTop && mouseY >= pi.Scr().H-12:
 		isBarOnTop = true
 	}
 }

devtools/internal/rgb/rgb.go

@@ -1,12 +1,14 @@
 package rgb
 
-import "github.com/elgopher/pi/mem"
+import (
+	"github.com/elgopher/pi/image"
+)
 
-func BrightnessIndex(rgb mem.RGB) byte {
+func BrightnessIndex(rgb image.RGB) byte {
 	return byte((299*int(rgb.R) + 587*int(rgb.G) + 114*int(rgb.B)) / 1000)
 }
 
-func BrightnessDelta(rgb1, rgb2 mem.RGB) byte {
+func BrightnessDelta(rgb1, rgb2 image.RGB) byte {
 	i1 := BrightnessIndex(rgb1)
 	i2 := BrightnessIndex(rgb2)
 	if i1 > i2 {

devtools/internal/snapshot/snapshot.go

@@ -4,18 +4,19 @@
 package snapshot
 
 import (
-	"github.com/elgopher/pi/mem"
+	"github.com/elgopher/pi"
 )
 
 var snapshot []byte
 
 func Take() {
+	screen := pi.Scr()
 	if snapshot == nil {
-		snapshot = make([]byte, len(mem.ScreenData))
+		snapshot = make([]byte, len(screen.Pix))
 	}
-	copy(snapshot, mem.ScreenData)
+	copy(snapshot, screen.Pix)
 }
 
 func Draw() {
-	copy(mem.ScreenData, snapshot)
+	copy(pi.Scr().Pix, snapshot)
 }

ebitengine/controller.go

@@ -6,7 +6,7 @@ package ebitengine
 import (
 	"github.com/hajimehoshi/ebiten/v2"
 
-	"github.com/elgopher/pi/mem"
+	"github.com/elgopher/pi"
 )
 
 func updateController() {
@@ -16,12 +16,12 @@ func updateController() {
 }
 
 func getController(player int) *controller {
-	c := controller{&mem.Controllers[player]}
+	c := controller{&pi.Controllers[player]}
 	return &c
 }
 
 type controller struct {
-	*mem.Controller
+	*pi.Controller
 }
 
 func (c *controller) update(player int) {
@@ -37,32 +37,32 @@ func (c *controller) updateDirections(player int) {
 
 	if axisX < -0.5 ||
 		ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonLeftLeft) ||
-		isKeyboardPressed(player, mem.ControllerLeft) {
-		c.BtnDuration[mem.ControllerLeft] += 1
-		c.BtnDuration[mem.ControllerRight] = 0
+		isKeyboardPressed(player, pi.Left) {
+		c.BtnDuration[pi.Left] += 1
+		c.BtnDuration[pi.Right] = 0
 	} else if axisX > 0.5 ||
 		ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonLeftRight) ||
-		isKeyboardPressed(player, mem.ControllerRight) {
-		c.BtnDuration[mem.ControllerRight] += 1
-		c.BtnDuration[mem.ControllerLeft] = 0
+		isKeyboardPressed(player, pi.Right) {
+		c.BtnDuration[pi.Right] += 1
+		c.BtnDuration[pi.Left] = 0
 	} else {
-		c.BtnDuration[mem.ControllerRight] = 0
-		c.BtnDuration[mem.ControllerLeft] = 0
+		c.BtnDuration[pi.Right] = 0
+		c.BtnDuration[pi.Left] = 0
 	}
 
 	if axisY < -0.5 ||
 		ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonLeftTop) ||
-		isKeyboardPressed(player, mem.ControllerUp) {
-		c.BtnDuration[mem.ControllerUp] += 1
-		c.BtnDuration[mem.ControllerDown] = 0
+		isKeyboardPressed(player, pi.Up) {
+		c.BtnDuration[pi.Up] += 1
+		c.BtnDuration[pi.Down] = 0
 	} else if axisY > 0.5 ||
 		ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonLeftBottom) ||
-		isKeyboardPressed(player, mem.ControllerDown) {
-		c.BtnDuration[mem.ControllerDown] += 1
-		c.BtnDuration[mem.ControllerUp] = 0
+		isKeyboardPressed(player, pi.Down) {
+		c.BtnDuration[pi.Down] += 1
+		c.BtnDuration[pi.Up] = 0
 	} else {
-		c.BtnDuration[mem.ControllerUp] = 0
-		c.BtnDuration[mem.ControllerDown] = 0
+		c.BtnDuration[pi.Up] = 0
+		c.BtnDuration[pi.Down] = 0
 	}
 }
 
@@ -71,18 +71,18 @@ func (c *controller) updateFireButtons(player int) {
 
 	if ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonRightBottom) ||
 		ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonRightTop) ||
-		isKeyboardPressed(player, mem.ControllerO) {
-		c.BtnDuration[mem.ControllerO] += 1
+		isKeyboardPressed(player, pi.O) {
+		c.BtnDuration[pi.O] += 1
 	} else {
-		c.BtnDuration[mem.ControllerO] = 0
+		c.BtnDuration[pi.O] = 0
 	}
 
 	if ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonRightRight) ||
 		ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonRightLeft) ||
-		isKeyboardPressed(player, mem.ControllerX) {
-		c.BtnDuration[mem.ControllerX] += 1
+		isKeyboardPressed(player, pi.X) {
+		c.BtnDuration[pi.X] += 1
 	} else {
-		c.BtnDuration[mem.ControllerX] = 0
+		c.BtnDuration[pi.X] = 0
 	}
 }