Welcome to the documentation for 🧸 Tiny, the virtual console that offers an easy and efficient way to build games and other applications with its Lua programming support, hot reloading, and 256-color maximum.

Tiny Engine

Despite its modest capabilities, 🧸 Tiny is designed to help you create and test your ideas quickly and effectively. Not only can you run your games on your desktop computer, but you can also export them for the web, making it easy to share your creations with others.

With 🧸 Tiny, you’ll be able to get started right away and see your progress in real-time, thanks to its hot reloading feature. This documentation will guide you through the setup and usage of 🧸 Tiny as well as provide you with helpful tips and tricks to make the most out of this powerful tool.

Let’s get started and unleash your creativity!

The code source of this sample is available in the Tiny git repository.

Tiny Sandbox

You can try to create a game right away 🧸 Tiny using the Sandbox or you can just try it by updating examples available in this page.

Tiny is open source

🧸 Tiny is an open-source project. Users can contribute to the project by reporting issues, suggesting improvements, and even submitting code changes. Check the code source on Github.

Contributions from the community are welcome, and can help to improve the overall functionality and usability of the game engine!

You can improve this documentation by updating the code of this documentation

Tiny Install

🧸 Tiny is a game engine that can be run through its client. Once installed, you can run and develop games in no time!

  • Download Tiny CLI from the release Github page

  • Unzip it and put the bin directory in your path (ie: export PATH=$PATH:<tiny-cli-path>/bin)

  • Create your first game using tiny-cli create my-first-game

What’s next? You can check the Tiny Tutorial, Tiny API or get more information about the Tiny CLI.

Tiny Tutorial

In this tutorial, we’ll be creating a simple Pong game using the Lua programming language and 🧸 Tiny.

Pong is a classic 2D arcade game where two players control paddles on opposite sides of the screen, and try to hit a ball back and forth without letting it pass their paddle. The game ends when one player misses the ball, and the other player scores a point.

Our implementation of Pong will have a fixed screen size of 256 pixels for width and height, and we’ll use the ctrl.pressing() function to check for key presses. Check the Tiny API to know more about the Tiny Engine API.

We’ll cover four main steps: initializing the game state with the _init() function, updating the game state with the _update() function and drawing the game with the _draw() function.

By the end of this tutorial, you should have a basic Pong game that you can customize and build upon.

Step 1: Initialize the Game State

First, we need to initialize the game state. We’ll define the position and size of the paddles, the position and size of the ball, and the initial velocity of the ball.

function _init()
    paddle_width = 4
    paddle_height = 32
    ball_radius = 4
    ball_speed = 2
    ball_velocity = { x = ball_speed, y = ball_speed }
    player1_pos = { x = 8, y = 96 - paddle_height / 2 }
    player2_pos = { x = 244, y = 96 - paddle_height / 2 }
    ball_pos = { x = 128, y = 96 }
end

Step 2: Update the Game State

In the _update() callback, we’ll update the game state by moving the paddles and the ball. We’ll also check for collisions between the ball and the paddles, and update the ball’s velocity accordingly.

-- convert bool to number
function num(var)
    return var and 1 or 0
end

function _update()
    -- Update game state
    player1_pos.y = player1_pos.y - 4 * num(ctrl.pressing(keys.up))
    player1_pos.y = player1_pos.y + 4 * num(ctrl.pressing(keys.down))
    player2_pos.y = player2_pos.y - 4 * num(ctrl.pressing(keys.z))
    player2_pos.y = player2_pos.y + 4 * num(ctrl.pressing(keys.s))

    ball_pos.x = ball_pos.x + ball_velocity.x
    ball_pos.y = ball_pos.y + ball_velocity.y

    -- Check for collisions with walls
    if ball_pos.y < ball_radius or ball_pos.y > 256 - ball_radius then
        ball_velocity.y = -ball_velocity.y
    end

    -- Check for collisions with paddles
    if ball_pos.x < player1_pos.x + paddle_width and
            ball_pos.y > player1_pos.y and
            ball_pos.y < player1_pos.y + paddle_height then
        ball_velocity.x = -ball_velocity.x
    end

    if ball_pos.x > player2_pos.x - ball_radius and
            ball_pos.y > player2_pos.y and
            ball_pos.y < player2_pos.y + paddle_height then
        ball_velocity.x = -ball_velocity.x
    end

    -- Check if the ball is inside the screen
    if ball_pos.x ~= math.clamp(0, ball_pos.x, 256) or ball_pos.y ~= math.clamp(0, ball_pos.y, 256) then
        _init()
    end
end

Step 3: Draw the Game

In the _draw() callback, we’ll draw the paddles and the ball using the shape.rectf() and shape.circlef() functions.

function _draw()
  -- Draw game
  gfx.cls()
  shape.rectf(player1_pos.x, player1_pos.y, paddle_width, paddle_height, 7)
  shape.rectf(player2_pos.x, player2_pos.y, paddle_width, paddle_height, 7)
  shape.circlef(ball_pos.x, ball_pos.y, ball_radius, 7)
end

And that’s it! With these three steps, you should have a basic Pong game up and running in Lua. Feel free to experiment with the game state, update function, and drawing function to customize the game to your liking.

function _init() paddle_width = 4 paddle_height = 32 ball_radius = 4 ball_speed = 2 ball_velocity = { x = ball_speed, y = ball_speed } player1_pos = { x = 8, y = 96 - paddle_height / 2 } player2_pos = { x = 244, y = 96 - paddle_height / 2 } ball_pos = { x = 128, y = 96 } end -- convert bool to number function num(var) return var and 1 or 0 end function _update() -- Update game state player1_pos.y = player1_pos.y - 4 * num(ctrl.pressing(keys.up)) player1_pos.y = player1_pos.y + 4 * num(ctrl.pressing(keys.down)) player2_pos.y = player2_pos.y - 4 * num(ctrl.pressing(keys.z)) player2_pos.y = player2_pos.y + 4 * num(ctrl.pressing(keys.s)) ball_pos.x = ball_pos.x + ball_velocity.x ball_pos.y = ball_pos.y + ball_velocity.y -- Check for collisions with walls if ball_pos.y < ball_radius or ball_pos.y > 256 - ball_radius then ball_velocity.y = -ball_velocity.y end -- Check for collisions with paddles if ball_pos.x < player1_pos.x + paddle_width and ball_pos.y > player1_pos.y and ball_pos.y < player1_pos.y + paddle_height then ball_velocity.x = -ball_velocity.x end if ball_pos.x > player2_pos.x - ball_radius and ball_pos.y > player2_pos.y and ball_pos.y < player2_pos.y + paddle_height then ball_velocity.x = -ball_velocity.x end -- Check if the ball is inside the screen if ball_pos.x ~= math.clamp(0, ball_pos.x, 256) or ball_pos.y ~= math.clamp(0, ball_pos.y, 256) then _init() end end function _draw() -- Draw game gfx.cls() shape.rectf(player1_pos.x, player1_pos.y, paddle_width, paddle_height, 7) shape.rectf(player2_pos.x, player2_pos.y, paddle_width, paddle_height, 7) shape.circlef(ball_pos.x, ball_pos.y, ball_radius, 7) end

Tiny Showcase

Here are a fews examples of game created using 🧸 Tiny.

camping level up

Want your game to appear here? Create a post about it in the Show and tell board and share all information about it.

Tiny CLI

Introducing the Tiny CLI, a powerful command-line interface that allows you to easily create, run, develop, and export games using the Tiny 2D game engine. With the Tiny CLI, you can quickly and easily create a new game project, add assets, and start developing your game in no time.

To get started, simply install the Tiny CLI on your system and create a new project using the tiny-cli create command. This will generate a new project directory with all the necessary files and folder structure to start building your game. You can then add assets to your game using the tiny-cli add command, which allows you to import images, audio files, and other resources into your project.

The Tiny CLI also includes a powerful development server that allows you to preview your game in real-time as you develop it. Simply run the tiny command and start to update your game.

When you’re ready to share your game with the world, the Tiny CLI makes it easy to export your game for web browsers. You can use the tiny-cli export command to generate a distributable version of your game that can be published on the web. You can also try the export result by using the command tiny-cli serve.

Whether you’re a seasoned game developer or just getting started, the Tiny CLI is a powerful tool that can help you create, run, develop, and export amazing 2D games with the Tiny engine. With its intuitive command-line interface and powerful features, the Tiny CLI is the ultimate tool for building your next great game.

the tiny-cli create command

The tiny-cli create command is a helpful tool for creating new games for the tiny game engine. This command allows you to easily create a new game by prompting you for a few details about the game you want to create.

Usage

To use the tiny-cli create command, simply open your terminal and type the following command:

tiny-cli create

This will launch the game creation process and prompt you to enter a name for your new game, along with other parameters to configure it.

Creating a New Game

To create a new game using the tiny-cli create command, follow these steps:

  1. Open your terminal and navigate to the directory where you want to create your new game.

  2. Type the following command and press Enter: `tiny-cli create `

  3. Follow the prompts to enter a name for your new game and configure other parameters such as the game’s screen resolution, background color, and more.

  4. Once you have entered all the required information, the tiny-cli create command will create a new folder with the name of your game in the current directory.

  5. You can now open this folder and begin developing your new game using the tiny game engine.

Running Your Game

To run your newly created game, use the tiny-cli command followed by the name of your game’s folder. For example:

tiny-cli my-game

This will launch your game and allow you to begin testing and refining your gameplay mechanics.

Adding Resources

You can also add resources such as images, sounds, and other assets to your game using the tiny-cli add command. For more information on how to use this command, please refer to the associated documentation.

With the tiny-cli create command, you can quickly and easily create new games for the tiny game engine, giving you the flexibility and control you need to bring your game ideas to life.

The tiny-cli run command

The tiny-cli run command is a command line tool for running and testing your tiny game. This command takes only one parameter: the path to the directory containing your game’s assets and _tiny.json file.

If the command is run on Mac OS and some JRE/JDK, the command might not work as it requires to use the JVM option -XstartOnFirstThread. In such case, instead of tiny-cli, use tiny-cli-mac which add this option.

Usage

To use the tiny-cli run command, simply open your terminal and type the following command:

tiny-cli run <game folder>

where <game folder> is the path to the directory containing your game’s assets and _tiny.json file.

Running a Game

To run your game using the tiny-cli run command, follow these steps:

  1. Open your terminal and navigate to the directory where your game’s _tiny.json file is located.

  2. Type the following command and press Enter, replacing <game folder> with the path to your game’s folder: tiny-cli run <game folder>

  3. The tiny-cli command will start your game and display it in a new window.

  4. If you make changes to your game’s Lua scripts or update any spritesheets, the game will automatically reload to use the latest version of those resources.

With the tiny-cli run command, you can quickly test and run your tiny game, making it easy to iterate and refine your game as you develop it.

Using tiny-cli run, You can press Ctrl + R (or ⌘ + R) to record a GIF of the last 8 seconds of your game or Ctrl + S (or ⌘ + S) to take a screenshot.

The tiny-cli add command

The tiny-cli add command allows you to quickly and easily add new spritesheets, sounds, and other assets to your game, making it easy to customize and improve your game’s functionality.

Usage

To use the tiny-cli add command, simply open your terminal and type the following command:

tiny-cli add <resource>

where <resource> is the path to the resource you want to add to your game. The resource can be a png file (which will be added as a spritesheet), a midi file (which will be added as a sound), or any other asset that can be used in the tiny game engine.

Adding a Resource

To add a resource to your game using the tiny-cli add command, follow these steps:

  1. Open your terminal and navigate to the directory where your game’s _tiny.json file is located.

  2. Type the following command and press Enter, replacing <resource> with the path to the resource you want to add: tiny-cli add <resource>

  3. The tiny-cli add command will automatically detect the type of resource you are adding and add it to your game accordingly. For example, if you add a png file, it will be added as a spritesheet.

  4. The added resource will be reflected in the _tiny.json file in the "spritesheets", "sounds", or "levels" array, depending on the type of resource you added.

Note that the added resource is not automatically copied to your game’s folder and needs to be in the same directory as the _tiny.json file.

Editing the _tiny.json File

Alternatively, you can also manually add resources to your game by editing the _tiny.json file directly. Simply open the file in a text editor and add the resource to the appropriate array.

With the tiny-cli add command, you can easily add new resources to your game and customize its functionality and appearance. Whether you are adding new spritesheets, sounds, or fonts, this command makes it easy to create the game of your dreams with the tiny game engine.

The tiny-cli export command

The tiny-cli export command is a tool for exporting your tiny game to a zip file, which includes all the assets needed to run the game in a browser. This command makes it easy to distribute your game and share it with others.

Usage

To use the tiny-cli export command, simply open your terminal and type the following command:

tiny-cli export <game folder>

where <game folder> is the path to the folder containing your game’s assets and _tiny.json file.

Exporting a Game

To export your game using the tiny-cli export command, follow these steps:

  1. Open your terminal and navigate to the directory where your game’s _tiny.json file is located.

  2. Type the following command and press Enter, replacing <game folder> with the path to your game’s folder: tiny-cli export <game folder>

  3. The tiny-cli export command will generate a zip file containing all the assets needed to run your game in a browser.

  4. The generated zip file will be saved in the same directory as the _tiny.json file with the name <game folder>.zip.

  5. You can now upload the generated zip file to a game hosting platform like itch.io to share your game with others.

  6. To run the exported game in a browser, use the tiny-cli serve command, which will serve the game from a local server. Type the following command and press Enter: tiny-cli serve <game folder>.zip

  7. Open your browser and navigate to http://localhost:8080 to play the exported game.

With the tiny-cli export command, you can easily export your tiny game and share it with others. Whether you want to distribute your game on itch.io or share it with friends, this command makes it easy to package your game and get it into the hands of others.

the tiny-cli serve command

The tiny serve command is used to launch a local web server that allows you to test a game that has been exported using the tiny export command. This is useful for testing and debugging a game locally before publishing it online.

Syntax

To use the tiny serve command, open a terminal or command prompt and navigate to the directory containing the exported game zip file. Then, type the following command:

tiny-cli serve [options] game.zip

Where:

[options]: Optional arguments to modify the behavior of the command. game.zip: The path to the exported game zip file.

Options

--port [port number]: Allows you to specify a custom port number to run the server on. The default port number is 8080.

Example Usage

To run the tiny serve command, you can use the following examples:

tiny-cli serve myGame.zip

This will launch the local web server on the default port number (8080) and serve the game located in the myGame.zip file.

tiny-cli serve MyGame.zip --port 8081

This will launch the local web server on port number 8081 and serve the game located in the MyGame.zip file.

Once the server is running, you can access the game in your web browser by navigating to the URL port number/. For example, if you used the default port number, you would navigate to http://localhost:8080/ in your web browser to access the game.

The tiny serve command is intended for local testing only and should not be used to serve your game online. When you are ready to publish your game, you should upload the exported game files to a web server and serve them from there.

the tiny-cli lib command

The tiny-cli lib command is used to download and add Lua libraries to your 🧸 Tiny game. This command provides an easy way to enhance the functionality of your game by incorporating libraries.

Usage

To use the tiny-cli lib command, follow the syntax:

tiny-cli lib <library_name>
Replace <library_name> with the name of the library you want to download and add to your game.

For example, to download and add the particles library to your game, you would run the following command:

tiny-cli lib particles
This command will download the particles library and add it to your game.

Library Repository

The libraries are downloaded from the following URL:

https://github.com/minigdx/tiny/tree/main/tiny-repository-libs

This repository contains a collection of Lua libraries that can be used with Tiny games. Each library is maintained separately and provides additional features and functionality to enhance your game development process.

Examples

Here are a few examples to illustrate how to use the tiny-cli lib command:

Download and add the particles library to your game:

tiny-cli lib particles
This command will download the particles library from the repository and add it to your game.

Tiny API

ctrl

Access to controllers like touch/mouse events or accessing which key is pressed by the user.

ctrl.touch()

Get coordinates of the current touch/mouse. If the mouse/touch is out-of the screen, the coordinates will be the last mouse position/touch. The function return those coordinates as a table {x, y}. A sprite can be draw directly on the mouse position by passing the sprite number.

ctrl.touch() -- Get the mouse coordinates.
ctrl.touch(sprN) -- Get the mouse coordinate and draw a sprite on those coordinates.
function _draw() gfx.cls(2) p = ctrl.touch() print("coordinates: "..p.x .. "x"..p.y, 1, 1, 4) shape.rectf(p.x, p.y, 5,5, p.x + p.y) end

ctrl.pressed()

Return true if the key was pressed during the last frame. If you need to check that the key is still pressed, see ctrl.pressing instead.

ctrl.pressed(key) -- Is the key was pressed?

ctrl.pressing()

Return true if the key is still pressed.

ctrl.pressing(key) -- Is the key is still pressed?
function _init() circle = { x = 256 * 0.5, y = 256 * 0.5, radius = 10 } end function _update() -- check keys for horizontal move if (ctrl.pressing(keys.left)) then circle.x = math.max(circle.x - 1, 0) elseif (ctrl.pressing(keys.right)) then circle.x = math.min(circle.x + 1, 256) end -- check keys for vertical move if (ctrl.pressing(keys.up)) then circle.y = math.max(circle.y - 1, 0) elseif (ctrl.pressing(keys.down)) then circle.y = math.min(circle.y + 1, 256) end -- check keys for update circle size if (ctrl.pressing(keys.space)) then circle.radius = math.min(circle.radius + 1, 256) elseif (ctrl.pressing(keys.enter)) then circle.radius = math.max(circle.radius - 1, 0) end end function _draw() gfx.cls(1) shape.circlef(circle.x, circle.y, circle.radius, 8) shape.circle(circle.x, circle.y, 2, 9) end

ctrl.touched()

Return the position of the touch (as {x, y})if the screen was touched or the mouse button was pressed during the last frame. nil otherwise. The touch can be :

  • 0: left click or one finger

  • 1: right click or two fingers

  • 2: middle click or three fingers

If you need to check that the touch/mouse button is still active, see ctrl.touching instead.

ctrl.touched(touch) -- Is the screen was touched or mouse button was pressed?

ctrl.touching()

Return the position of the touch (as {x, y})if the screen is still touched or the mouse button is still pressed. nil otherwise. The touch can be :

  • 0: left click or one finger

  • 1: right click or two fingers

  • 2: middle click or three fingers

ctrl.touching(touch) -- Is the screen is still touched or mouse button is still pressed?
function _init() t = {} end function _update() local touch = ctrl.touching(0) if(touch) then table.insert(t, {str = " touching "..touch.x.."-"..touch.y, ttl = 3}) end for i,s in rpairs(t) do s.ttl = s.ttl - 1/60 if s.ttl < 0 then table.remove(t, i) end end end function _draw() gfx.cls() local p = 0 for i, s in rpairs(t) do print(i..s.str, 10, 6 * p, 2) p = p + 1 end local touch = ctrl.touch() shape.circlef(touch.x, touch.y, 2, 8) end

gfx

Access to graphical API like updating the color palette or applying a dithering pattern.

gfx.cls()

clear the screen

gfx.cls() -- Clear the screen with a default color.
gfx.cls(color) -- Clear the screen with a color.

gfx.pset()

Set the color index at the coordinate (x,y).

gfx.pset(x, y, color) -- set the color index at the coordinate (x,y).

gfx.pget()

Get the color index at the coordinate (x,y).

gfx.pget(x, y) -- get the color index at the coordinate (x,y).

gfx.to_sheet()

Transform the current frame buffer into a spritesheeet.

  • If the index of the spritesheet already exist, the spritesheet will be replaced

  • If the index of the spritesheet doesn’t exist, a new spritesheet at this index will be created

  • If the index of the spritesheet is negative, a new spritesheet will be created at the last positive index.

gfx.to_sheet(sheet) -- Copy the current frame buffer to an new or existing sheet index.
function _draw() gfx.cls(1) -- draw a transparent circle (like a hole) shape.circlef(64, 128, 20, 0) -- keep the result as spritesheet 0 gfx.to_sheet(0) gfx.cls(1) -- draw some circles shape.circlef(64, 108, 20, 8) shape.circlef(44, 128, 20, 9) shape.circlef(64, 148, 20, 10) shape.circlef(84, 128, 20, 11) -- draw over the circles -- the mask generated before. spr.sheet(0) spr.sdraw() end

gfx.pal()

Change a color from the palette to another color.

gfx.pal() -- Reset all previous color changes.
gfx.pal(a, b) -- Replace the color a for the color b.
function _draw() gfx.cls() print("example", 10, 10, 2) -- print using the color index 2 gfx.pal(2, 3) -- switch the text color to another color print("example", 10, 20, 2) -- print using the color index 2 gfx.pal() -- reset the palette print("example", 10, 30, 2) -- print using the color index 2 end

gfx.camera()

Move the game camera.

gfx.camera() -- Reset the game camera to it's default position (0,0).
gfx.camera(x, y) -- Set game camera to the position x, y.

gfx.dither()

Apply a dithering pattern on every new draw call. The pattern is using the bits value of a 2 octet value. The first bits is the one on the far left and represent the pixel of the top left of a 4x4 matrix. The last bit is the pixel from the bottom right of this matrix.

gfx.dither() -- Reset dithering pattern. The previous dithering pattern is returned.
gfx.dither(pattern) -- Apply dithering pattern. The previous dithering pattern is returned.
function _draw() gfx.cls() gfx.dither() shape.circlef(30, 30, 30, 2) gfx.dither(0xA5A5) -- set a dithering pattern shape.circlef(50, 50, 30, 3) gfx.dither(0x0842) -- set another dithering pattern shape.circlef(70, 70, 30, 2) end

gfx.clip()

Clip the draw surface (ie: limit the drawing area).

gfx.clip() -- Reset the clip and draw on the fullscreen.
gfx.clip(x, y, width, height) -- Clip and limit the drawing area.
function _init() c = {} for i=1,100 do table.insert(c, {x=math.rnd(256), y=math.rnd(256), c = math.rnd(1,12)}) end end function _draw() gfx.cls() local pos = ctrl.touch() -- set a clip area to crop circles gfx.clip(pos.x - 20, pos.y - 20, 40, 40) for circle in all(c) do shape.circlef(circle.x, circle.y, 10, circle.c) end end

juice

Easing functions to 'juice' a game. Interpolation to juice your game. All interpolations available:

  • pow2, pow3, pow4, pow5,

  • powIn2, powIn3, powIn4, powIn5,

  • powOut2, powOut3, powOut4, powOut5,

  • sine, sineIn, sineOut,

  • circle, circleIn, circleOut,

  • elastic, elasticIn, elasticOut,

  • swing, swingIn, swingOut,

  • bounce, bounceIn, bounceOut,

  • exp10, expIn10, expOut10,

  • exp5, expIn5, expOut5,

  • linear

juice.pow2()

juice.pow2(progress) -- Give a percentage (progress) of the interpolation
juice.pow2(start, end, progress) -- Interpolate the value given a start and an end value.
function _init() t = 0 end function _update() t = t + 1/60 end function _draw() gfx.cls() progress = math.abs(math.cos(t)) print("pow", 0, 0) shape.circlef(juice.pow2(20, 236, progress), 10, 10, 2) shape.circlef(juice.pow3(20, 236, progress), 20, 10, 3) shape.circlef(juice.pow4(20, 236, progress), 30, 10, 4) print("bounce", 0, 50) shape.circlef(juice.bounce(20, 236, progress), 60, 10, 5) print("exp", 0, 80) shape.circlef(juice.exp10(20, 236, progress), 90, 10, 6) print("swing", 0, 110) shape.circlef(juice.swing(20, 236, progress), 120, 10, 7) print("sine", 0, 140) shape.circlef(juice.sine(20, 236, progress), 150, 10, 8) print("circle", 0, 170) shape.circlef(juice.circle(20, 236, progress), 180, 10, 9) print("elastic", 0, 200) shape.circlef(juice.elastic(20, 236, progress), 210, 10, 10) print("linear", 0, 230) shape.circlef(juice.linear(20, 236, progress), 240, 10, 1) end

juice.pow3()

juice.pow3(progress) -- Give a percentage (progress) of the interpolation
juice.pow3(start, end, progress) -- Interpolate the value given a start and an end value.

juice.pow4()

juice.pow4(progress) -- Give a percentage (progress) of the interpolation
juice.pow4(start, end, progress) -- Interpolate the value given a start and an end value.

juice.pow5()

juice.pow5(progress) -- Give a percentage (progress) of the interpolation
juice.pow5(start, end, progress) -- Interpolate the value given a start and an end value.

juice.powIn2()

juice.powIn2(progress) -- Give a percentage (progress) of the interpolation
juice.powIn2(start, end, progress) -- Interpolate the value given a start and an end value.

juice.powIn3()

juice.powIn3(progress) -- Give a percentage (progress) of the interpolation
juice.powIn3(start, end, progress) -- Interpolate the value given a start and an end value.

juice.powIn4()

juice.powIn4(progress) -- Give a percentage (progress) of the interpolation
juice.powIn4(start, end, progress) -- Interpolate the value given a start and an end value.

juice.powIn5()

juice.powIn5(progress) -- Give a percentage (progress) of the interpolation
juice.powIn5(start, end, progress) -- Interpolate the value given a start and an end value.

juice.powOut2()

juice.powOut2(progress) -- Give a percentage (progress) of the interpolation
juice.powOut2(start, end, progress) -- Interpolate the value given a start and an end value.

juice.powOut3()

juice.powOut3(progress) -- Give a percentage (progress) of the interpolation
juice.powOut3(start, end, progress) -- Interpolate the value given a start and an end value.

juice.powOut4()

juice.powOut4(progress) -- Give a percentage (progress) of the interpolation
juice.powOut4(start, end, progress) -- Interpolate the value given a start and an end value.

juice.powOut5()

juice.powOut5(progress) -- Give a percentage (progress) of the interpolation
juice.powOut5(start, end, progress) -- Interpolate the value given a start and an end value.

juice.sine()

juice.sine(progress) -- Give a percentage (progress) of the interpolation
juice.sine(start, end, progress) -- Interpolate the value given a start and an end value.

juice.sineIn()

juice.sineIn(progress) -- Give a percentage (progress) of the interpolation
juice.sineIn(start, end, progress) -- Interpolate the value given a start and an end value.

juice.sineOut()

juice.sineOut(progress) -- Give a percentage (progress) of the interpolation
juice.sineOut(start, end, progress) -- Interpolate the value given a start and an end value.

juice.circle()

juice.circle(progress) -- Give a percentage (progress) of the interpolation
juice.circle(start, end, progress) -- Interpolate the value given a start and an end value.

juice.circleIn()

juice.circleIn(progress) -- Give a percentage (progress) of the interpolation
juice.circleIn(start, end, progress) -- Interpolate the value given a start and an end value.

juice.circleOut()

juice.circleOut(progress) -- Give a percentage (progress) of the interpolation
juice.circleOut(start, end, progress) -- Interpolate the value given a start and an end value.

juice.elastic()

juice.elastic(progress) -- Give a percentage (progress) of the interpolation
juice.elastic(start, end, progress) -- Interpolate the value given a start and an end value.

juice.elasticIn()

juice.elasticIn(progress) -- Give a percentage (progress) of the interpolation
juice.elasticIn(start, end, progress) -- Interpolate the value given a start and an end value.

juice.elasticOut()

juice.elasticOut(progress) -- Give a percentage (progress) of the interpolation
juice.elasticOut(start, end, progress) -- Interpolate the value given a start and an end value.

juice.swing()

juice.swing(progress) -- Give a percentage (progress) of the interpolation
juice.swing(start, end, progress) -- Interpolate the value given a start and an end value.

juice.swingIn()

juice.swingIn(progress) -- Give a percentage (progress) of the interpolation
juice.swingIn(start, end, progress) -- Interpolate the value given a start and an end value.

juice.swingOut()

juice.swingOut(progress) -- Give a percentage (progress) of the interpolation
juice.swingOut(start, end, progress) -- Interpolate the value given a start and an end value.

juice.bounce()

juice.bounce(progress) -- Give a percentage (progress) of the interpolation
juice.bounce(start, end, progress) -- Interpolate the value given a start and an end value.

juice.bounceIn()

juice.bounceIn(progress) -- Give a percentage (progress) of the interpolation
juice.bounceIn(start, end, progress) -- Interpolate the value given a start and an end value.

juice.bounceOut()

juice.bounceOut(progress) -- Give a percentage (progress) of the interpolation
juice.bounceOut(start, end, progress) -- Interpolate the value given a start and an end value.

juice.exp10()

juice.exp10(progress) -- Give a percentage (progress) of the interpolation
juice.exp10(start, end, progress) -- Interpolate the value given a start and an end value.

juice.expIn10()

juice.expIn10(progress) -- Give a percentage (progress) of the interpolation
juice.expIn10(start, end, progress) -- Interpolate the value given a start and an end value.

juice.expOut10()

juice.expOut10(progress) -- Give a percentage (progress) of the interpolation
juice.expOut10(start, end, progress) -- Interpolate the value given a start and an end value.

juice.exp5()

juice.exp5(progress) -- Give a percentage (progress) of the interpolation
juice.exp5(start, end, progress) -- Interpolate the value given a start and an end value.

juice.expIn5()

juice.expIn5(progress) -- Give a percentage (progress) of the interpolation
juice.expIn5(start, end, progress) -- Interpolate the value given a start and an end value.

juice.expOut5()

juice.expOut5(progress) -- Give a percentage (progress) of the interpolation
juice.expOut5(start, end, progress) -- Interpolate the value given a start and an end value.

juice.linear()

juice.linear(progress) -- Give a percentage (progress) of the interpolation
juice.linear(start, end, progress) -- Interpolate the value given a start and an end value.

keys

List of the available keys. To be used with ctrl.

  • keys.up, keys.down, keys.left, keys.right for directions.

  • keys.a to keys.z and keys.0 to keys.9 for letters and numbers.

  • keys.space and keys.enter for other keys.

map

Map API to accessing maps data configured in a game. Map can be created using LDTk ( https://ldtk.io/ ).

Projects need to be exported using 'Super simple export'

map.level()

Set the current level to use.

map.level() -- Return the index of the current level.
map.level(level) -- Set the current level to use. The level can be an index or the id defined by LDTK. Return the previous index level.

map.layer()

Set the current layer to draw.

map.layer(layer_index) -- Set the current index layer to draw. Return the previous layer index.
map.layer() -- Reset the current layer to draw to the first available layer (index 0).

map.from()

Convert cell coordinates cx, cy into map screen coordinates x, y.

map.from(arg1, arg2) -- Convert the cell coordinates into coordinates as a table [x,y].
map.from(cell) -- Convert the cell coordinates from a table [cx,cy] into screen coordinates as a table [x,y].

map.to()

Convert screen coordinates x, y into map cell coordinates cx, cy. For example, coordinates of the player can be converted to cell coordinates to access the flag of the tile matching the player coordinates.

map.to(x, y) -- Convert the coordinates into cell coordinates as a table [cx,cy].
map.to(coordinates) -- Convert the coordinates from a table [x,y] into cell coordinates as a table [cx,cy].

map.flag()

Get the flag from a tile.

map.flag(cx, cy) -- Get the flag from the tile at the coordinate cx,cy.
map.flag(cell) -- Get the flag from the tile at the coordinate table [cx,cy].

map.entities()

Table with all entities by type (ie: map.entities["player"]).

local players = map.entities["player"]
local entity = players[1] -- get the first player
shape.rectf(entity.x, entity.y, entity.width, entity.height, 8) -- display an entity using a rectangle
[...]
entity.customFields -- access custom field of the entity

map.draw()

Draw map tiles on the screen.

map.draw() -- Draw the default layer on the screen.
map.draw(x, y) -- Draw the default layer on the screen at the x/y coordinates.
map.draw(x, y, sx, sy) -- Draw the default layer on the screen at the x/y coordinates.
map.draw(layer) -- Draw the layer on the screen by it's index.

math

Math functions. Please note that standard Lua math methods are also available.

math.pi

value of pi (~3.14)

function _update() gfx.cls() print(math.pi, 10, 10) -- value of pi (~3.14) end

math.huge

positive infinity value.

function _update() gfx.cls() print(math.huge, 10, 10) -- positive infinity value. end

math.sign()

Return the sign of the number: -1 if negative. 1 otherwise.

math.sign(number) -- Return the sign of the number.

math.clamp()

Clamp the value between 2 values.

math.clamp(a, value, b) -- Clamp the value between a and b. If a is greater than b, then b will be returned.

math.dst()

Compute the distance between two points.

math.dst(x1, y1, x2, y2) -- Distance between (x1, y1) and (x2, y2).

math.dst2()

Compute the distance between two points not squared. Use this method to know if an coordinate is closer than another.

math.dst2(x1, y1, x2, y2) -- Distance not squared between (x1, y1) and (x2, y2).

math.rnd()

Generate random values

math.rnd() -- Generate a random int (negative or positive value)
math.rnd(until) -- Generate a random value between 1 until the argument. If a table is passed, it'll return a random element of the table.
math.rnd(a, b) -- Generate a random value between a and b.

math.roverlap()

Check if two (r)ectangles overlaps.

math.roverlap(rect1, rect2) -- Check if the rectangle rect1 overlaps with the rectangle rect2.

math.perlin()

Perlin noise. The random generated value is between 0 and 1.

math.perlin(x, y, z) -- Generate a random value regarding the parameters x,y and z.

sfx

Sound API to play/loop/stop a sound.

sfx.play()

Play a sound by it’s index. The index of a sound is given by it’s position in the sounds field from the _tiny.json file.The first sound is at the index 0.

sfx.play() -- Play the sound at the index 0.
sfx.play(sound) -- Play the sound by it's index.

sfx.loop()

Play a sound and loop over it.

sfx.loop() -- Play the sound at the index 0.
sfx.loop(sound) -- Play the sound by it's index.

sfx.stop()

Stop a sound.

sfx.stop() -- Stop the sound at the index 0.
sfx.stop(sound) -- Stop the sound by it's index.

shape

Shape API to draw…​shapes. Those shapes can be circle, rectangle, line or oval.All shapes can be draw filed or not filed.

shape.rect()

Draw a rectangle.

shape.rect(x, y, width, height, color) -- Draw a rectangle.

shape.oval()

Draw an oval.

shape.oval(centerX, centerY, radiusX, radiusY) -- Draw an oval using the default color.
shape.oval(centerX, centerY, radiusX, radiusY, color) -- Draw an oval using the specified color.

shape.ovalf()

Draw an oval filled.

shape.ovalf(centerX, centerY, radiusX, radiusY) -- Draw a filled oval using the default color.
shape.ovalf(centerX, centerY, radiusX, radiusY, color) -- Draw a filled oval using the specified color.

shape.rectf()

Draw a filled rectangle.

shape.rectf(x, y, width, height, color) -- Draw a filled rectangle.
function _draw() gfx.cls() -- filled rectangle print("filled rectangle", 20, 10) shape.rectf(20, 20, 20, 20, 4) shape.rectf(30, 30, 20, 20, 5) shape.rectf(40, 40, 20, 20, 6) print("non filled rectangle", 20, 65) -- non filled rectangle shape.rect(50, 70, 20, 20, 7) shape.rect(60, 80, 20, 20, 8) shape.rect(70, 90, 20, 20, 9) print("rectangle with different width", 20, 115) shape.rect(20, 120, 30, 20, 10) shape.rect(20, 140, 40, 20, 12) shape.rect(20, 160, 60, 20, 13) end

shape.circlef()

Draw a filled circle.

shape.circlef(centerX, centerY, radius, color) -- Draw a circle at the coordinate (centerX, centerY) with the radius and the color.
function _draw() gfx.cls() -- filled circle shape.circlef(20, 20, 20, 4) shape.circlef(30, 30, 20, 5) shape.circlef(40, 40, 20, 6) print("filled circle", 20, 10) -- non filled circle shape.circle(50, 70, 10, 7) shape.circle(60, 80, 10, 8) shape.circle(70, 90, 10, 9) print("non filled circle", 20, 65) shape.circle(80, 120, 15, 10) shape.circle(80, 140, 20, 16) shape.circle(80, 160, 30, 14) print("circle with different radius", 20, 115) end

shape.line()

Draw a line.

shape.line(x0, y0, x1, y2, color) -- Draw a line.
shape.line(x0, y0, x1, y1) -- Draw a line with a default color.

shape.circle()

Draw a circle.

shape.circle(a, b, c) -- Draw a circle with the default color.
shape.circle(centerX, centerY, radius, color) -- Draw a circle.

shape.trianglef()

Draw a filled triangle using the coordinates of (x1, y1), (x2, y2) and (x3, y3) and color.

shape.trianglef(x1, y1, x2, y2, x3, y3, color) -- Draw a filled triangle using the coordinates of (x1, y1), (x2, y2) and (x3, y3).

shape.triangle()

Draw a triangle using the coordinates of (x1, y1), (x2, y2) and (x3, y3) and color.

shape.triangle(x1, y1, x2, y2, x3, y3, color) -- Draw a triangle using the coordinates of (x1, y1), (x2, y2) and (x3, y3).

shape.gradient()

Draw a gradient using dithering, only from color c1 to color c2.

shape.gradient(x, y, width, height, color1, color2, is_horizontal) -- Draw a gradient using dithering, only from color c1 to color c2.
function _draw() local c1 = 2 local c2 = 3 gfx.cls(c1) shape.rectf(0, 256 - 16, 256, 16, c2) for x=0,240,16 do shape.gradient(x, 16 * math.cos(2 * 3.14 * (x / 256) + tiny.t * 2), 16, 256, c1, c2, false) end end

spr

Sprite API to draw or update sprites.

spr.pget()

Get the color index at the coordinate (x,y) from the current spritesheet.

spr.pget(x, y) -- get the color index at the coordinate (x,y) from the current spritesheet.

spr.pset()

Set the color index at the coordinate (x,y) in the current spritesheet.

spr.pset(x, y, color) -- Set the color index at the coordinate (x,y) in the current spritesheet.

spr.sheet()

Switch to another spritesheet. The index of the spritesheet is given by it’s position in the spritesheets field from the _tiny.json file.The first spritesheet is at the index 0.

spr.sheet() -- Switch to the first spritesheet
spr.sheet(spritesheetN) -- Switch to the N spritesheet

spr.sdraw()

S(uper) Draw a fragment from the spritesheet.

spr.sdraw() -- Draw the full spritesheet at default coordinate (0, 0)
spr.sdraw(x, y) -- Draw the full spritesheet at default coordinate (x, y)
spr.sdraw(x, y, sprX, sprY) -- Draw the full spritesheet at default coordinate (x, y) from the sprite (sprX, sprY)
spr.sdraw(x, y, sprX, sprY, width, height, flipX, flipY) -- Draw a fragment from the spritesheet.

spr.draw()

Draw a sprite.

spr.draw(sprN, x, y) -- Draw a sprite.
spr.draw(sprN, x, y, flipX, flipY) -- Draw a sprite and allow flip on x or y axis.

std

Standard library.

new()

Create new instance of a class by creating a new table and setting the metatable. It allow to create kind of Object Oriented Programming.

new(class) -- Create new instance of class.
new(class, default) -- Create new instance of class using default values.
local Player = { x = 128, y = 128, color = 8 } function Player:draw() shape.rectf(self.x, self.y, 10, 10, self.color) end function _init() -- create a new player player = new(Player) -- create a new player with default vaules player2 = new(Player, {x = 200, y = 200, color = 9}) end function _draw() gfx.cls() player:draw() -- call the draw method on the player instance. player2:draw() -- call the draw method on the player2 instance. end

all()

Iterate over values of a table.

  • If you want to iterate over keys, use pairs(table).

  • If you want to iterate over index, use ipairs(table).

  • If you want to iterate in reverse, use rpairs(table).

all(table) -- Iterate over the values of the table

rpairs()

Iterate over values of a table in reverse order. The iterator return an index and the value. The method is useful to remove elements from a table while iterating on it.

rpairs(table) -- Iterate over the values of the table
function _draw() gfx.cls() local data = { { name = "riri" }, { name = "fifi" }, { name = "loulou" } } local y = 0 for index, key in rpairs(data) do print(index .. " - " .. key.name, 10, y) y = y + 10 end end

debug()

Print in the console a value to help debugging

debug(arg) -- Print in the console a value

print()

Print on the screen a string.

print(str) -- print on the screen a string at (0,0) with a default color.
print(str, x, y) -- print on the screen a string with a default color.
print(str, x, y, color) -- print on the screen a string with a specific color.
function _draw() gfx.cls() -- every character is a sprite 4x4 pixels. print("hello") print("world", 10, 10) print("how", 10, 20, 4) print("are", 26, 20, 5) print("you", 42, 20, 6) print("...", 58, 20, math.rnd(10)) end

tiny

Tiny Lib which offer offer the current frame (tiny.frame), the current time (tiny.time), delta time (tiny.dt) and to switch to another script using exit.

tiny.dt

Delta time between two frame. As Tiny is a fixed frame engine, it’s always equal to 1/60

function _update() gfx.cls() print(tiny.dt, 10, 10) -- Delta time between two frame. As Tiny is a fixed frame engine, it's always equal to 1/60 end

tiny.t

Time elapsed since the start of the game.

function _update() gfx.cls() print(tiny.t, 10, 10) -- Time elapsed since the start of the game. end

tiny.frame

Number of frames elapsed since the start of the game.

function _update() gfx.cls() print(tiny.frame, 10, 10) -- Number of frames elapsed since the start of the game. end

tiny.exit()

Exit the actual script to switch to another one. The next script to use is identified by it’s index. The index of the script is the index of it in the list of scripts from the _tiny.json file.The first script is at the index 0.

tiny.exit(scriptIndex) -- Exit the actual script to switch to another one.

Links