Cómo hacer un videojuego con PICO-8

1. Introducción

PICO-8 es un motor de videojuegos relativamente conocido creado por Joseph White, aka zep. Con PICO-8, Joseph quería crear una consola con la que poder jugar videojuegos sencillos y a la vez poder desarrollarlos en la misma consola, como en una Commodore 64. Buscaba que fuera fácil de manejar, simple y, sobre todo, autosuficiente: que contenga todo lo necesario para desarrollar un videojuego sin necesidad de usar programas externos. Así nació el concepto de fantasy console, que vendría a ser un emulador de una consola que no existe, con todas las limitaciones que podría tener. Debido al minimaslismo y su potencial, PICO-8 se volvió muy usado en Game Jams. Puede entrar a su página oficial y jugar algunos videojuegos hechos por la comunidad (figura 1).

Lo que nos interesa de todo esto es que, el año pasado, Joseph publicó una versión de PICO-8 totalmente gratuita que funciona en la web, que es con la que voy a trabajar durante todo este artículo.

Para hacer un videojuego se necesitan conocimientos en diversas materias, pero aquí solo nos centraremos en la programación. Si no ha programado nada en su vida, no se preocupe pues haré una breve y rápida introducción. No indagaré en cuestiones muy técnicas y me centraré principalmente en lo que se vaya usar para el juego que se planea desarrollar al final de este artículo. Por lo pronto, lo único que tiene que saber es que va a programar en Lua.

2. Fundamentos de Programación

Entre al siguiente enlace: https://www.pico-8-edu.com. Al principio solo verá unas letras blancas sobre un fondo negro (figura 2), está en el Modo Comando. Si escribe help verá una lista de comandos y, abajo del todo, verá que dice que presione ESC para cambiar al Modo Editor. Si hace lo que se dice verá una pantalla tal y como se muestra en la figura 3. También verá diferentes pestañas, en la que está usted ahora mismo es el Editor de Código.

2.1. Funciones y tipos de datos

A continuación, escriba lo siguiente (figura 4):

1
print("hello, world!")

No utilice mayúsculas, el tipo de fuente de PICO-8 por defecto solo utiliza las minúsculas para las letras, en cambio las mayúsculas están reservadas para otros caracteres especiales. Por ahora, presione ESC, escriba run en la línea de comandos y presiones la tecla ENTER. Tendría que ver algo como se muestra en la figura 5, si es así, ¡felicidades!, ahora puede presumir oficialmente de haber programado algo, sino es así revise si ha seguido bien todos lo pasos.

A lo mejor se está preguntando: ¿Qué es lo que acaba de pasar? Para ello necesita saber que en programación es fundamental el concepto de función. Puede que le hayan venido flashbacks de sus clases de matemáticas, pero no tema, no necesita saber exactamente que es una función en matemáticas para entender estas. En programación, una función es una sección de código dedicado ha realizar cierta tarea (o función), estas reciben parámetros y retornan valores. Puede reconer funciones facilmente pues siempre llevan paréntesis. Lo que hizo hace un momento fue llamar a la función print, le pasó un parámetro, hello, world!, y, cuando el programa fue ejecutado (> run), esta función desempeñó el papel por el cual fue creada: imprimir en pantalla lo que le pasen por parámetro.

Notese que el parámetro que recibe print va entre comillas. Si escribe print(hello, world!) y ejecuta el programa, verá que le sale el siguiente error:

1
syntax error line 1 (tab 0)
2
print(hello, world!)
3
')' expected near '!'

En los lenguajes de programación hay diferentes tipos de datos, uno de ellos son los string —una manera fancy de llamar a los textos de toda la vida—. Además de los string, existen los datos de tipo int —de integer— que son los números enteros (…, -2, -1, 0, 1, 2,…), y los de tipo float —de coma flotante— que son los números con decimales. El asunto es que los lenguajes de programación distinguen los datos de tipo string gracias a las comillas, así saben que eso es un bloque de texto y lo interpretan como tal.

Ahora que conoce diferentes tipos de datos, unos ejemplos de como operar con cada uno de ellos. Escriba lo siguiente:

1
print("hello, world!")
2
print(2 + 3)
3
print(2 / 3)
4
print(2 * 3)
5
print(2 ^ 3)
6
print(2 % 3)

1
> run
2
hello, world!
3
5
4
0.6667
5
6
6
8
7
2

Los operadores son los símbolos que realizan operaciones matemáticas: la suma, la resta, la división, la multiplicación y la exponenciación; el último operador puede parecer un poco misterioso pero simplemente es el resto de dividir 2 por 3.

Ahora escriba:

1
print((2 - 3) * 2)
2
--(int - int) * int
3

4
print((2 + 2) ^ 3 .. " es de tipo int")
5
--(int + int) ^ int + string

1
> run
2
-2
3
64 es de tipo int

Hay tres cosas importantes en lo que acaba de escribir:

1. La primera es que, al igual que en matemáticas, los paréntesis agrupan.
2. La segunda es que para comentar código —poner anotaciones— se utilizan dos guiones: --comentario (todo lo que siga a los guiones no será interpretado como parte del programa y, por tanto, no será ejecutado).
3. Por último, cuando entre dos tipos de datos se colocan dos puntos, estos se concatenan —al menos en Lua—, es decir: se enlazan. En este caso un int (64) con un string (es de tipo int).

Existe otro tipo de dato, los de tipo bool. Pero de ellos hablaré más tarde.

2.2. Variables

Una variable es, en esencia, una forma de almacenar datos. Esta se compone del nombre de la variable y el dato que almacena. Para declarar una variable se escribe el nombre de la variable, el signo de igual y el dato que se quiere que almacene: x = 3.

Aunque hay similitud entre una variable y una incógnita en matemáticas, estas son conceptualmente diferentes. La expresión $x=3$ significa que la incógnita $x$ es equivalente al número 3. No parece ser muy diferente, pero en matemáticas no tiene sentido la expresión $x = x + 3$, pues no hay ningún valor que sea igual a él mismo más tres. En cambio, en programación la expreción x = x + 3 significa que se le asigna a la variable x el valor anterior de x más 3. Esta expresión no solo no es absurda, sino que es tan fundamental que se ha inventado una manera corta de escribirlo: x += 3.

Ahora, escriba lo siguiente:

1
x = 3
2
y = 10
3
print("x: "..x)
4
print("y: "..y)
5
print("x + y = "..x + y)

1
> run
2
x: 3
3
y: 10
4
x + y = 13

Recuerde que con .. está concatenando, en este caso x: y el valor de la variable x, que en este caso es 3.

2.3. Condicionales

Otro concepto sustancial: los condicionales. Existen tres tipos de condicionales:

1. los if (si),
2. los else (sino) y
3. los elseif (sino si).

La razón de existencia de los condicionales es evaluar casos: si se cumple esto, entonces se hará aquello; sino, se hará esto otro.

Escriba lo siguiente:

1
n = 2
2
if n == 4 then
3
  print("n es igual a 4")
4
else
5
  print("n no es igual a 4")
6
end

1
> run
2
n no es igual a 4

El código se leería como: si n es igual a 4, entonces se llama a la función print para imprimir en pantalla n es igual a 4; sino (todos los casos en los que n no sea igual a 4), se imprimirá en pantala n no es igual a 4.

Notese que el símbolo = indica asignación, por el contrario, el símbolo == indica comparación. Esta comparación solo puede tener dos resultados: true o false, los conocidos como datos de tipo bool. Si n no es igual a 4, entonces la sentencia n == 4 dará false y cuando el if lo detecte sabrá que la condición no se cumple y se pasará a la siguiente instrucción, en este caso el else.

Habrá notado que en el ejemplo anterior no se hizo uso de uno de los tres tipos de condicionales. No se preocupe pues ahora escribirá lo siguiente:

1
n = 4
2
if n == 2 then
3
  print("n es igual a 2")
4
elseif n == 3 then
5
  print("n es igual a 3")
6
else
7
  print("n no es igual a 2 o a 3")
8
end

1
> run
2
n no es igual a 2 o a 3

2.4. Funciones, otra vez

Las funciones son una herramienta muy útil, sobretodo porque permiten reciclar código, como en el ejemplo siguiente:

1
--se crea la función even()
2
function even(n)
3
  if n % 2 == 0 then
4
    print(n.." es par")
5
  else
6
    print(n.." no es par")
7
  end
8
end
9

10
even(2)
11
even(3)
12
even(4)
13
even(5)

1
> run
2
2 es par
3
3 no es par
4
4 es par
5
5 no es par

¡Qué útiles son las funciones que nos salvan de escribir el mismo código constantemente!

Pero hay algo aún más importante de las funciones y es que, al igual que print es una función propia de PICO-8 para imprimir cosas en pantalla, hay otras muchas funciones para realizar diferentes tareas. Una de estas funciones es _update, que es especialmente importante pues se ejecuta 30 veces por segundo. ¿De qué nos sirve que esta función se ejecute 30 veces por segundo? Es útil porque, como en todo motor de videojuegos, se necesitan funciones que estén constantemente comprobando cosas como: la posición del jugador, la tecla que está pulsando, la posición de objetos, sus movimientos… etc. Además de esta, la función btn detecta si el jugador a pulsado el botón que se le pase por parámetro, ¡vayamos a comprobarlo! Para ello escriba lo siguiente:

1
function buttons()
2
  if btn(5) then
3
    print("Has presionado un x")
4
  else
5
    print("__")
6
  end
7
end
8

9
function _update()
10
  buttons()
11
end

Si presiona X verá como aparece Has presionado x. En la figura 6 podrá ver los números que tiene asignado cada tecla, aunque… ¿se acuerda que anteriormente dije que las mayúsculas estaban reservadas para caracteres especiales? (figura 7).

Viendo la figura 8, nos damos cuenta de que podemos ampliar el programa anterior para las flechas, pero en ese caso tendríamos en la función buttons algo así:

1
txt = "Has presionado "
2
if btn(5) then
3
  print(txt.." 5")
4
elseif btn(4) then
5
  print(txt.." 4")
6
elseif btn(0) then
7
  print(txt.." 0")
8
elseif btn(1) then
9
  print(txt.." 1")
10
elseif btn(2) then
11
  print(txt.." 2")
12
elseif btn(3) then
13
  print(txt.." 3")
14
else
15
  print("__")
16
end

Pero también podríamos escribir un programa que simplemente distinga si se está pulsando uno de los cinco botones, sin importar cual sea:

1
if btn(0) or btn(1) or
2
  btn(2) or btn(3) or
3
  btn(4) or btn(5) then
4
  print("Has presionado un boton")
5
else print("__") end

Nuevo concepto importante: los operadores lógicos. Los operadores lógicos son, valga la redundancia, operadores que comparan dos resultados de tipo bool y, dependiendo de las combinaciones de estos, devuelven true o false.

Hay dos operadores lógicos imprescindibles: and y or. El operador and devuelve true si, y solo si los operandos son true. En cambio, or devuelve true si por lo menos uno de los operandos es true.

Sabiendo esto, el código anterior se leería como: si el botón 0, o el botón 1, o el botón 2, o el botón 3, o el botón 4, o el botón 5 es pulsado, entonces se imprimirá en pantalla “Has presionado un boton”, sino se imprimirá en pantalla __.

2.5. Dibujar cosas en pantalla

Al igual que existe la función _update, que se ejecuta 30 veces por segundo, también existe la función _draw, que actualiza la pantalla cada vez que se ejecuta la función _update. Pero que _draw actualice la pantalla 30 veces por segundo no quiere decir que vaya a eliminar lo que se había dibujado antes, para este fin se utiliza la función cls —que tal vez ya haya utilizado para limpiar la pantalla de comandos.

Conociendo todo esto, se puede reescribir el programa anterior:

1
function buttons()
2
  if btn(0) or btn(1) or
3
    btn(2) or btn(3) or
4
    btn(4) or btn(5) then
5
    print("Has presionado un boton")
6
  else print("__") end
7
end
8

9
function _draw()
10
  cls()
11
  buttons()
12
end

Para empezar a hacer cosas más interesantes vaya a la segunda pestaña: el Editor de Sprites (figura 8). Una vez ahí, puede dibujar —con una resolución de 8 por 8 píxeles— el personaje que quiera, en mi caso dibujé un conejito al que llamaré Bunny (figura 9).

Para hacer que este sprite se dibuje en pantalla deberá escribir lo siguiente:

1
function _draw()
2
  cls()
3
  spr(1)
4
end

La función spr se encarga de dibujar un sprite, y el 1 que se le pasa como parámetro simplemente indica el número del sprite. Este número, empezando desde cero, viene indicado por la posición del sprite en las “casillas” que puede ver en la figura 8 y 9.

La función spr puede recibir más parámetros como la posición del sprite —por defecto es (0,0).

La posición de un punto viene determinado por una coordenada en el eje x y en el eje y. El valor de x es la distancia del punto al lado izquiero de la pantalla, mientras que el valor de y es la distancia del punto al lado superior de la pantalla (figura 10). Así, la esquina superior izquierda es el punto de origen o punto (0,0). Por defecto, el punto de un sprite no es el centro del sprite, es su esquina superior izquierda (figura 11).

Sabiendo todo esto, ahora podemos hacer que Bunny se mueva por la pantalla:

1
x = 60
2
y = 60
3
function move_bunny()
4
  if (btn(0)) then x -= 1 end
5
  if (btn(1)) then x += 1 end
6
  if (btn(2)) then y -= 1 end
7
  if (btn(3)) then y += 1 end
8
end
9

10
function _update()
11
  move_bunny()
12
end
13

14
function _draw()
15
  cls()
16
  spr(1, x, y)
17
end

2.6. Bucles

Ya para acabar con esta sección, voy a hablar de los bucles o loops.

Un bucle es una sección de código que se repetirá siempre y cuando se cumpla una condición.

Existen diferentes tipos de bucles, pero el único que nos importa ahora es el bucle for:

1
n = 3
2
for i = 0, n do
3
  print(i)
4
end

1
> run
2
0
3
1
4
2
5
3

En estos bucles siempre hay que declarar una variable índice i, esta aumentará en uno su valor cuando se acabe una repetición. La variable n significa que el bucle se repetirá n-i veces, en este caso 3 - 0 = 3 veces.

Aquí otro ejemplo:

1
function _draw()
2
  cls()
3

4
  for i = 1, 10 do
5
    spr(1, i^2, 60)
6
    print(i^2)
7
  end
8
end

En este caso, el bucle se repetirá 10 - 1 = 9 veces y dibujará al sprite con una coordenada x que aumentará en potencias de 2, además imprime en pantalla las diferentes posiciones en x del sprite.

Por último, un ejemplo que no tiene por qué entender, pero que es interesante:

1
function _draw()
2
  cls()
3

4
  for i = 0, 15 do
5
    x = 64 + cos(t() / 2 + i / 16) * 40
6
    y = 64 + sin(t() / 4 + i / 16) * 40
7
    spr(1, x, y)
8
  end
9

10
  s = "★ hi! ★"
11
  print(s, 64 - #s * 2, 64, 7)
12
end

3. Squashy

Ahora vamos a crear un videojuego tipo Pong (figura 12).

Para empezar, acceda al Modo Comando y escriba save squashy para guardar el proyecto. Para asegurarse de no perder el progreso, cada cierto tiempo tendrá que presionar CTRL + S y para ejecutar el programa, en lugar de escribir run en la consola, puede presionar CTRL + R.

3.1. Moviendo la paleta

Lo primero que vamos a hacer será crear la paleta paddle y conseguir que se mueva por la parte inferior de la pantalla.

1
--squashy
2

3
--paddle
4
padx = 52
5
pady = 122
6
padw = 24
7
padh = 4
8
steps = 3
9

10
function movepaddle()
11
  if btn(0) then
12
    padx -= steps
13
  elseif btn(1) then
14
    padx += steps
15
  end
16
end
17

18
function _update()
19
  movepaddle()
20
end
21

22
function _draw()
23
  --clear the screen
24
  rectfill(0, 0, 128, 128, 3)
25

26
  --draw the paddle
27
  rectfill(padx, pady, padx + padw, pady + padh, 15)
28
end

La función rectfill sirve para dibujar rectángulos, esta además recibe diferentes parámetros: los dos primeros indican la posición de la esquina superior izquierda del rectángulo —padx y pady—, los otros dos indican la posición de la esquina inferior derecha del rectángulo —padx + padw y pady + padh—, y el último indica el color —15— (figura 13).

3.2. Añadiendo la pelota

Debajo de las variables de paddle, escriba las variables de la pelota:

1
--ball
2
ballx = 64
3
bally = 64
4
ballsize = 3
5
ballxdir = 3
6
ballydir = -2

Y luego añada al final de la función _draw lo siguiente:

1
--draw ball
2
circfill(ballx, bally, ballsize, 15)

La función circfill es como la función rectfill, solo que hay que pasarle por parámetros la posición del centro del círculo —ballx y bally—, su tamaño —ballsize— y su color —15—.

3.3. Una pelota estática es una pelota aburrida

Para que la pelota se mueva, escriba una nueva función debajo de movepaddle:

1
function moveball()
2
  ballx += ballxdir
3
  bally += ballydir
4
end

Y luego llámela en la función _update:

1
function _update()
2
  movepaddle()
3
  moveball()
4
end

3.4. Rebote de la pelota

Si ejecuta el programa verá que la pelota sale volando por la esquina superior derecha de la pantalla, para solucionar este ligero inconveniente tendrá que crear una nueva función debajo de la función moveball y luego llamarla en _update:

1
function bounceball()
2
  --left
3
  if ballx < ballsize then
4
    ballxdir = -ballxdir
5
    sfx(0)
6
  end
7
  --right
8
  if ballx > 128 - ballsize then
9
    ballxdir = -ballxdir
10
    sfx(0)
11
  end
12
  --top
13
  if bally < ballsize then
14
    ballydir = -ballydir
15
    sfx(0)
16
  end
17
end
18

19
function _update()
20
  movepaddle()
21
  moveball()
22
  bounceball()
23
end

Como la función bounceball puede ser un poco complicada para el principiante, la explicaré a continuación.

Dentro de la función bounceball hay un primer apartado —--left—, donde se comprueba si la pelota ha alcanzado la parte izquierda de la pantalla: si la posición en el eje x de la pelota —ballx— es menor al ancho de la pelota —es decir, si ballx < 3; parecería más intuitivo decir “si la posición horizontal de la pelota es menor a cero…”, pero en ese caso se vería a la pelota atravesar un poco la pantalla antes de rebotar—, entonces se cambia la dirección de la pelota —ballxdir = -ballxdir— y se llama a la función sfx.

La función sfx se utiliza para que suene un efecto de sonido. Para ello tiene que irse a la cuarta pestaña, el Editor de Efectos, y crear un efecto de sonido, en mi caso creé el que se puede ver en la figura 14.

3.5. Golpear a la pelota

Ahora que la pelota se mueve y rebota contra los bordes, es el momento de hacer que rebote cuando choque contra la paleta. Para esta empresa hay que crear una nueva función debajo de bounceball y llamarla en _update:

1
function bouncepaddle()
2
  if ballx >= padx and
3
    ballx <= padx + padw and
4
    bally > pady - padh and
5
    bally < pady then
6
    sfx(0)
7
    ballydir = -ballydir
8
  end
9
end
10

11
function _update()
12
  movepaddle()
13
  moveball()
14
  bounceball()
15
  bouncepaddle()
16
end

La función bouncepaddle funciona de la siguiente manera: si la posición en x de la pelota es mayor o igual a la posición en x de la esquina izquierda de la paleta y a su vez es menor o igual a la posición en x de la esquina derecha de la paleta, además de que si la posición en y de la pelota es mayor a la posición en y de la base de la paleta y a su vez es menor a la posición en y del lado superior de la paleta, entonces se llama a la función sfx y se le cambia la dirección vertical de la pelota.

3.6. La pelota retorna

Cuando la pelota llega a la parte inferior de la pantalla, esta desaparece sin dejar rastro. Ante esta desgracia tendrá que escribir una nueva función que hará reaparecer a la pelota en medio de la pantalla —también tendrá que llamar esta función en _update, pero espero que eso ya lo vaya pillando—:

1
function losedeadball()
2
  if bally > 128 then
3
    sfx(1)
4
    bally = 24
5
  end
6
end
7

8
function _update()
9
  movepaddle()
10
  moveball()
11
  bounceball()
12
  bouncepaddle()
13
  losedeadball()
14
end

En esta nueva función se llama a sfx(1) y no al sfx de siempre, esto es así porque reproducirá un efecto de sonido diferente y por esa misma razón tendrá que crear un nuevo efecto de sonido, en mi caso creé el que se puede ver en la figura 15.

3.7. Puntuación

Para añadir una puntuación, hace falta crear una variable score = 0 y hacer una pequeña modificación a la función bouncepaddle:

1
score = 0
2

3
function bouncepaddle()
4
  if ballx >= padx and
5
    ballx <= padx + padw and
6
    bally > pady then
7
    sfx(0)
8
    ballydir = -ballydir
9
    score += 10
10
  end
11
end

Ahora hay que imprimir en pantalla la puntuación, para ello hay que añadir lo siguiente a la función _draw:

1
--draw score
2
print(score, 12, 6, 15)

Aunque no lo mencioné anteriormente, la función print también puede recibir de parámetros una posición —en este caso (12,6)— y un color —15—.

3.8. Corazones

Para indicar la vida del jugador vamos a usar corazones, como se muestra en la figura 16 —aunque para ello se tendrá que borrar a Bunny—. Para esta tarea se debe crear una una variable lives = 3 y modificar la función _draw:

1
lives = 3
2
function _draw()
3
  --clear the screen
4
  rectfill(0, 0, 128, 128, 3)
5
  if lives > 0 then
6
    --draw the lives
7
    for i=1, lives do
8
      spr(1, 124 - i * 8, 4)
9
    end
10
    --draw score
11
    print(score, 12, 6, 15)
12
    --draw paddle
13
    rectfill(padx, pady, padx + padw, pady + padh, 15)
14
    --draw ball
15
    circfill(ballx, bally, ballsize, 15)
16
  else
17
    --draw game over
18
    print("game over", 48, 64, 15)
19
  end
20
end

Además, hay que complicar un poco —solo un poco— la función losedeadball:

1
function losedeadball()
2
  if bally > 128 then
3
    if lives > 0 then
4
      --next live
5
      sfx(1)
6
      bally = 24
7
      lives -= 1
8
    else
9
      --game over
10
      ballxdir = 0
11
      ballydir = 0
12
    end
13
  end
14
end

Y por último, cambiar ligeramente la función _update:

1
function _update()
2
  if lives > 0 then
3
    movepaddle()
4
    moveball()
5
    bounceball()
6
    bouncepaddle()
7
    losedeadball()
8
  end
9
end

4. Final

Con todo, el código debería quedar tal que así:

1
--squashy
2

3
--paddle
4
padx = 52
5
pady = 122
6
padw = 24
7
padh = 4
8
steps = 3
9

10
--ball
11
ballx = 64
12
bally = 64
13
ballsize = 3
14
ballxdir = 3
15
ballydir = -2
16

17
score = 0
18
lives = 3
19

20
function movepaddle()
21
  if btn(0) then
22
    padx -= steps
23
  elseif btn(1) then
24
    padx += steps
25
  end
26
end
27

28
function moveball()
29
  ballx += ballxdir
30
  bally += ballydir
31
end
32

33
function bounceball()
34
  --left
35
  if ballx < ballsize then
36
    ballxdir = -ballxdir
37
    sfx(0)
38
  end
39
  --right
40
  if ballx > 128 - ballsize then
41
    ballxdir = -ballxdir
42
    sfx(0)
43
  end
44
  --top
45
  if bally < ballsize then
46
    ballydir = -ballydir
47
    sfx(0)
48
  end
49
end
50

51
function bouncepaddle()
52
  if ballx >= padx and
53
    ballx <= padx + padw and
54
    bally > pady then
55
    sfx(0)
56
    ballydir = -ballydir
57
    score += 10
58
  end
59
end
60

61
function losedeadball()
62
  if bally > 128 then
63
    if lives > 0 then
64
      --next live
65
      sfx(1)
66
      bally = 24
67
      lives -= 1
68
    else
69
      --game over
70
      ballxdir = 0
71
      ballydir = 0
72
    end
73
  end
74
end
75

76
function _update()
77
  if lives > 0 then
78
    movepaddle()
79
    moveball()
80
    bounceball()
81
    bouncepaddle()
82
    losedeadball()
83
  end
84
end
85

86
function _draw()
87
  --clear the screen
88
  rectfill(0, 0, 128, 128, 3)
89
  if lives > 0 then
90
    --draw the lives
91
    for i=1, lives do
92
      spr(1, 124 - i * 8, 4)
93
    end
94
    --draw score
95
    print(score, 12, 6, 15)
96
    --draw paddle
97
    rectfill(padx, pady, padx + padw, pady + padh, 15)
98
    --draw ball
99
    circfill(ballx, bally, ballsize, 15)
100
  else
101
    --draw game over
102
    print("game over", 48, 64, 15)
103
  end
104
end

Para exportar ejecute el juego y presione CTRL + 7, después vaya al Modo Comando y escriba save squashy.png, así se le descargará un archivo .png, si ese mismo archivo lo arrastra hasta PICO-8 se le cargará el juego (figura 17).

Referencias

1. White, J. (s.f.). PICO-8 User Manual. https://www.lexaloffle.com/dl/docs/pico-8_manual.html
2. De Bock, A. (agosto de 2015). PICO-8 Zine #1. https://sectordub.itch.io/pico-8-fanzine-1