Create package vm

Package vm is low-level package for directly accessing virtual
machine data, such as screen pixels, sprite-sheet, fonts or buttons state.
This data can be manipulated by backend, console, utility functions,
or a game itself. It is very useful for writing custom tools, new
backends or even entire new API to be used by games. Code using vm package
directly could be very fast, because it can use low-level Go functions such as
copy.

Please note though, that with great power comes great responsibility.
You can easily shoot yourself in the foot if you are not careful enough
how you change the data. For example, increasing the SpriteSheetWidth
without adjusting the SpriteSheetData will likely result in a panic
during sprite-drawing operations.

Author: elgopher

controller.go

@@ -4,9 +4,8 @@
 package pi
 
 import (
-	"github.com/hajimehoshi/ebiten/v2"
-
 	"github.com/elgopher/pi/internal/input"
+	"github.com/elgopher/pi/vm"
 )
 
 // Button is a virtual button on any game controller. The game controller can be a gamepad or a keyboard.
@@ -22,12 +21,12 @@ 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  Button = 0
-	Right Button = 1
-	Up    Button = 2
-	Down  Button = 3
-	O     Button = 4 // O is a first fire button
-	X     Button = 5 // X is a second fire button
+	Left  = vm.ControllerLeft
+	Right = vm.ControllerRight
+	Up    = vm.ControllerUp
+	Down  = vm.ControllerDown
+	O     = vm.ControllerO // O is a first fire button
+	X     = vm.ControllerX // X is a second fire button
 )
 
 // Btn returns true if a controller button is being pressed at this moment by player 0.
@@ -64,7 +63,7 @@ func BtnpPlayer(button Button, player int) bool {
 //
 // A bit of 1 means the button is pressed.
 func BtnBits() int {
-	return controllers[0].bits(isPressed) + controllers[1].bits(isPressed)<<8
+	return buttonBits(0, isPressed) + buttonBits(1, isPressed)<<8
 }
 
 // BtnpBits returns the state of all controller buttons for players 0 and 1 as bitset.
@@ -76,10 +75,10 @@ func BtnBits() int {
 //
 // A bit of 1 means the button has just been pressed.
 func BtnpBits() int {
-	return controllers[0].bits(input.IsPressedRepeatably) + controllers[1].bits(input.IsPressedRepeatably)<<8
+	return buttonBits(0, input.IsPressedRepeatably) + buttonBits(1, input.IsPressedRepeatably)<<8
 }
 
-func buttonDuration(player int, button Button) int {
+func buttonDuration(player int, button Button) uint {
 	if button < Left || button > X {
 		return 0
 	}
@@ -88,130 +87,20 @@ func buttonDuration(player int, button Button) int {
 		return 0
 	}
 
-	return controllers[player].buttonDuration[button]
+	return vm.Controllers[player].BtnDuration[button]
 }
 
-func isPressed(duration int) bool {
+func isPressed(duration uint) bool {
 	return duration > 0
 }
 
-func updateController() {
-	for player := 0; player < 8; player++ {
-		controllers[player].update(player)
-	}
-}
-
-var controllers [8]controller
-
-type controller struct {
-	buttonDuration [6]int // 	left, right, up, down, o, x
-}
-
-func (c *controller) update(player int) {
-	c.updateDirections(player)
-	c.updateFireButtons(player)
-}
-
-func (c *controller) updateDirections(player int) {
-	gamepadID := ebiten.GamepadID(player)
-
-	axisX := ebiten.StandardGamepadAxisValue(gamepadID, ebiten.StandardGamepadAxisLeftStickHorizontal)
-	axisY := ebiten.StandardGamepadAxisValue(gamepadID, ebiten.StandardGamepadAxisLeftStickVertical)
-
-	if axisX < -0.5 ||
-		ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonLeftLeft) ||
-		isKeyboardPressed(player, Left) {
-		c.buttonDuration[Left] += 1
-		c.buttonDuration[Right] = 0
-	} else if axisX > 0.5 ||
-		ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonLeftRight) ||
-		isKeyboardPressed(player, Right) {
-		c.buttonDuration[Right] += 1
-		c.buttonDuration[Left] = 0
-	} else {
-		c.buttonDuration[Right] = 0
-		c.buttonDuration[Left] = 0
-	}
-
-	if axisY < -0.5 ||
-		ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonLeftTop) ||
-		isKeyboardPressed(player, Up) {
-		c.buttonDuration[Up] += 1
-		c.buttonDuration[Down] = 0
-	} else if axisY > 0.5 ||
-		ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonLeftBottom) ||
-		isKeyboardPressed(player, Down) {
-		c.buttonDuration[Down] += 1
-		c.buttonDuration[Up] = 0
-	} else {
-		c.buttonDuration[Up] = 0
-		c.buttonDuration[Down] = 0
-	}
-}
-
-func (c *controller) updateFireButtons(player int) {
-	gamepadID := ebiten.GamepadID(player)
-
-	if ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonRightBottom) ||
-		ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonRightTop) ||
-		isKeyboardPressed(player, O) {
-		c.buttonDuration[O] += 1
-	} else {
-		c.buttonDuration[O] = 0
-	}
-
-	if ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonRightRight) ||
-		ebiten.IsStandardGamepadButtonPressed(gamepadID, ebiten.StandardGamepadButtonRightLeft) ||
-		isKeyboardPressed(player, X) {
-		c.buttonDuration[X] += 1
-	} else {
-		c.buttonDuration[X] = 0
-	}
-}
-
-func (c *controller) bits(isSet func(int) bool) int {
+func buttonBits(player int, isSet func(uint) bool) int {
+	c := vm.Controllers[player]
 	var b int
-	for i := 0; i <= int(X); i++ {
-		if isSet(c.buttonDuration[i]) {
+	for i := 0; i <= X; i++ {
+		if isSet(c.BtnDuration[i]) {
 			b += 1 << i
 		}
 	}
 	return b
 }
-
-// first array is player, then π key, then slice of Ebitengine keys.
-var keyboardMapping = [...][6][]ebiten.Key{
-	// player0:
-	{
-		{ebiten.KeyLeft},                        // left
-		{ebiten.KeyRight},                       // right
-		{ebiten.KeyUp},                          // up
-		{ebiten.KeyDown},                        // down
-		{ebiten.KeyZ, ebiten.KeyC, ebiten.KeyN}, // o
-		{ebiten.KeyX, ebiten.KeyV, ebiten.KeyM}, // x
-	},
-	// player1:
-	{
-		{ebiten.KeyS},         // left
-		{ebiten.KeyF},         // right
-		{ebiten.KeyE},         // up
-		{ebiten.KeyD},         // down
-		{ebiten.KeyShiftLeft}, // o
-		{ebiten.KeyTab, ebiten.KeyW, ebiten.KeyQ, ebiten.KeyA}, // x
-	},
-}
-
-func isKeyboardPressed(player int, button Button) bool {
-	if player >= len(keyboardMapping) {
-		return false
-	}
-
-	keys := keyboardMapping[player][button]
-	for _, k := range keys {
-		if ebiten.IsKeyPressed(k) {
-			return true
-		}
-	}
-
-	return false
-}

defaults.go

@@ -0,0 +1,35 @@
+// (c) 2022 Jacek Olszak
+// This code is licensed under MIT license (see LICENSE for details)
+
+package pi
+
+import "github.com/elgopher/pi/vm"
+
+const (
+	defaultSpriteSheetWidth  = 128
+	defaultSpriteSheetHeight = 128
+	defaultScreenWidth       = 128
+	defaultScreenHeight      = 128
+)
+
+var (
+	//nolint:govet
+	defaultPalette = [256]vm.RGB{
+		{0, 0, 0},          // 0 - black
+		{0x1D, 0x2B, 0x53}, // 1 - dark blue
+		{0x7E, 0x25, 0x53}, // 2 - dark purple
+		{0x00, 0x87, 0x51}, // 3 - dark green
+		{0xAB, 0x52, 0x36}, // 4 - brown
+		{0x5F, 0x57, 0x4F}, // 5 - dark gray
+		{0xC2, 0xC3, 0xC7}, // 6 - light gray
+		{0xff, 0xf1, 0xe8}, // 7 - white
+		{0xFF, 0x00, 0x4D}, // 8 - red
+		{0xFF, 0xA3, 0x00}, // 9 - orange
+		{0xFF, 0xEC, 0x27}, // 10 - yellow
+		{0x00, 0xE4, 0x36}, // 11 - green
+		{0x29, 0xAD, 0xFF}, // 12 - blue
+		{0x83, 0x76, 0x9C}, // 13 - indigo
+		{0xFF, 0x77, 0xA8}, // 14 - pink
+		{0xFF, 0xCC, 0xAA}, // 15 - peach
+	}
+)