Pikuseru Console

Pikuseru Console (previously known as PX8 or Unicorn Console) is a fantasy engine that let you do quickly any sort of game, application with a default resolution of 128x128 pixels, 32bits color. The console allow you to load what is called a 'cartridge' that looks like a text file, that contains the code, the graphics and the sounds.

The main engine is not dependant of a specific graphic library so you can use it where you want:

pikuseru: Main core engine
pikuseru-console: Launcher for all cartridge, based on EGUI + Pixels
pikuseru-editor: Editor of the cartridge (graphics, sound, code), based on EGUI
pikuseru-rs: Wasm binding crate
pikuseru-examples: a non exhausitve list of Pikuseru cartrdige for testing

Features

Display: 128x128 pixels by default, 8 bits colors with available list of predefined palettes (16 colors) (pico-8, commodore, atari2600 etc)
32 bits color could be added directly via the API, with alpha channel (for transparency)
Font: predefined list of fonts (pico8, bbc, trollmini, etc)
Sprites: Single bank of 128 8x8 sprites that is directly in the cartridge
Dynamic sprites: create sprites dynamically with the API
Map: 128x32 8-bit cells
Code: No limit size in the cartridge, and support of the following languages: Lua (optional), Python (optional), Rhai (default), WASM (default)
Sound: 8 channels, tracker, FM synthetizer, 16-bit Wavetables (from GamerCade console)
Screenshot / Gif Recording (image feature)

Examples

See the console for more examples.

Limitations

The console is somewhat compatible with pico-8 (buy it !), most of current functions from pico8 is implemented and the cartridge is the same format. However some pico8/lua language syntax is supported like:

compound assignment operators (+=, -=, etc)
"!=" like "~="
binary literals

But see the pikuseru-examples, I did some modifications of good games to use it with Pikuseru too.

Build

Cargo feature:

cpython: enable python support
rlua: enable lua support

You can build the console directly the main UI to play games:

cd pikuseru
cargo build --release --features=cpython,rlua,image

File format

File format	Read	Write
Pico8 .PNG	X	/
Pico8 .P8	X	X
Pikuseru (.PIK)	X	X

Pikuseru file format is exactly the same as PICO8 P8 format, except that new sections are available, like python, rhai, wasm, code etc.

Create

API

The API is available for Lua/Python.

Graphics
- camera
- circ
- circfill
- clip
- cls
- color
- ellipse
- ellipsefill
- fget
- font
- line
- mode
- pal
- palt
- pget
- print
- pset
- rect
- rectfill
- sget
- spr
- sset
- sspr
- trigon
MAP
- map
- mget
- mset
Math
Memory
Mouse Input
Palettes
Cart Data

Graphics

camera

camera([x, y])

Set the camera position.

x/y are the coordinates to set the camera, and they could be optional (in this case, 0/0 will be used)

circ

circ(x, y, r, [col])

Draw a circle:

x/y are the coordinates
r is the radius of the circle
col is the color of the circle

circfill

circfill(x, y, r, [col])

Draw a filled circle:

x/y are the coordinates
r is the radius of the circle
col is the color of the circle

clip

clip([x, y, w, h])

Set a screen clipping region where:

x/y are the coordinate
w is the width
h is the height

cls

Clear the screen.

color

color(col)

set default color

ellipse

ellipse(x, y, rx, ry, [col])

Draw an ellipse

ellipsefill

ellipsefill(x, y, rx, ry, [col])

draw filled ellipse

fget

fget(n, [f])

get values of sprite flags

font

font(name)

Change the font policy ("pico8", "bbc", "cbmII", "appleII")

fset

fset(n, [f], v)

set values of sprite flags

line

line(x0, y0, x1, y1, [col])

draw line

pal

pal(c0, c1)

Switch the color c0 to color c1.

palt

palt(col, t)

Set the transparency for color 'col', where 't' is a boolean

pget

pget(x, y)

Get the pixel color in x/y coordinate

print

print (str, [x, y, [col]])

Display a string on the screen

pset

pset(x, y, col)

Set the pixel color with the value 'col' in x/y coordinate

rect

rect(x0, y0, x1, y1, [col])

draw a rectangle

rectfill

rectfill(x0, y0, x1, y1, [col])

draw filled rectangle

sget

sget(x, y)

get spritesheet pixel colour

spr

spr(n, x, y, [w, h], [flip_x], [flip_y])

Draw a sprite:

n is the sprite number
x/y are the coordinate
w and h specify how many sprites wide to blit and are 1/1 values by default
flip_x to flip horizontally the sprite
flip_y to flip vertically the sprite

Color 0 will be transparent by default (see "palt" API).

sset

sset(x, y, [col])

set spritesheet pixel colour

sspr

sspr(sx, sy, sw, sh, dx, dy, [dw, dh], [flip_x], [flip_y])

draw texture from spritesheet

trigon

trigon(x1, y1, x2, y2, x3, y3, [col])

draw trigon

Keyboard Input

btn([i, [p]])

get button i state for player p

btnp([i, [p]])

only true when the button was not pressed the last frame; repeats every 4 frames after button held for 15 frames

Map

map

map(cel_x, cel_y, sx, sy, cel_w, cel_h, [layer])

[Python: spr_map]

Draw map; layers from flags; sprite 0 is empty

mget

mget(x, y)

Get a map value

mset

mset(x, y, v)

Set a map value

scambier/pikuseru