tinycoffee

sumary

• tico
  • getVersion
  • class
  • color
    • norm
  • audio
    • setVolume
    • newSound
  • input
    • isDown
    • isPressed
    • isUp
    • isReleased
    • isKeyDown
    • isKeyPressed
    • isKeyUp
    • isKeyReleased
    • isMouseDown
    • isMousePressed
    • isMouseUp
    • isMouseReleased
    • getMousePos
    • mouseScroll
    • isJoyDown
    • isJoyPressed
    • isJoyUp
    • isJoyReleased
  • graphics
    • getSize
    • clear
    • newImage
    • newCanvas
    • newRectangle
    • newFont
    • drawRectangle
    • fillRectangle
    • drawCircle
    • fillCircle
    • drawTriangle
    • fillTriangle
    • line
    • print
    • printf
  • window
    • getSize
    • getTitle
    • setTitle
    • getWidth
    • setWidth
    • getHeight
    • setHeight
  • timer
    • delta
    • fps
  • math
    • lerp
    • round
    • clamp
    • angle
    • distance
    • sign
  • filesystem
    • read
    • write
    • fileExists
    • setPath
    • getPath
    • exePath
    • resolvePath
    • mkdir
    • rmdir
  • json
    • decode
    • encode
    • load
    • save

tico module

tico.getVersion()

• return:
  • version: string

audio module

tico.audio.setVolume(volume)

Set the master volume

• args:
  • volume: number

tico.audio.newSound(filename)

Create a new Sound

The current supported formats are: mp3, ogg, wav and flac

• args:
  • filename: string
• return:
  • Sound: userdata

Sound functions:

• Sound:play
• Sound:pause
• Sound:stop
• Sound:volume
• Sound:isPlaying
• Sound:isPaused

:play()

Play the current sound

:pause()

Pause the current sound (don’t rewind)

:stop()

Stop the current sound (rewind sound)

:volume(volume)

Set and get the volume of the sound

• args:
  • volume: number
• return:
  • volume: number

:isPlaying()

Get if sound is playing

• return:
  • playing: boolean

:isPaused()

Get if sound is paused

• return:
  • paused: boolean

function tico.load()
	sound = tico.audio.newSound("sound.mp3")
end


function tico.update(dt)
	if tico.input.isDown("mouse1") then sound:play() end
end

input module

tico.input.isDown(name)

Return true if the key/mouse button with the given name is pressed

• args:
  • name: string (see input names)
• return:
  • isDown: boolean

tico.input.isPressed(name)

Return true if the key/mouse button with the given name was pressed

• args:
  • name: string (see input names)
• return:
  • isPressed: boolean

tico.input.isUp(name)

Return true if the key/mouse button with the given name is not pressed

• args:
  • name: string (see input names)
• return:
  • isUp: boolean

tico.input.isReleased(name)

Return true if the key/mouse button with the given name was released

• args:
  • name: string (see input names)
• return:
  • isReleased: boolean

tico.input.isKeyDown(key)

Return true if the given key is pressed

• args:
  • key: string (see input names)
• return:
  • isKeyDown: boolean

tico.input.isKeyPressed(key)

Return true if the given key was pressed

• args:
  • key: string (see input names)
• return:
  • isKeyPressed: boolean

tico.input.isKeyUp(key)

Return true if the given key is not pressed

• args:
  • key: string (see input names)
• return:
  • isKeyUp: boolean

tico.input.isKeyReleased(key)

Return true if the given key was released

• args:
  • key: string (see input names)
• return:
  • isKeyReleased: boolean

tico.input.isMouseDown(button)

Return true if the given mouse button is pressed

• args:
  • button: string (see input names)
• return:
  • isMouseDown: boolean

tico.input.isMousePressed(button)

Return true if the given mouse button was pressed

• args:
  • button: number (see input names)
• return:
  • isMousePressed: boolean

tico.input.isMouseUp(button)

Return true if the given mouse button is not pressed

• args:
  • button: number (see input names)
• return:
  • isMouseUp: boolean

tico.input.isReleased(button)

Return true if the given mouse button was released

• args:
  • button: number (see input names)
• return:
  • isReleased: boolean

tico.input.isJoyDown(jid, name)

Return true if the joystick/gamepad button is pressed, jid is the number of the joystick

• args:
  • jid: number
  • name: string (see input names)
• return:
  • isJoyDown: boolean

tico.input.isJoyPressed(name)

Return true if the joystick/gamepad button was pressed, jid is the number of the joystick

• args:
  • jid: number
  • name: string (see input names)
• return:
  • isJoyPressed: boolean

tico.input.isJoyUp(name)

Return true if the joystick/gamepad button is not pressed, jid is the number of the joystick

• args:
  • jid: number
  • name: string (see input names)
• return:
  • isJoyUp: boolean

tico.input.isJoyReleased(name)

Return true if the joystick/gamepad button was released, jid is the number of the joystick

• args:
  • jid: number
  • name: string (see input names)
• return:
  • isJoyReleased: boolean

math module

tico.math.lerp(init, end, t)

Return the linear interpolation between init and end for the given t

• args:
  • init: number
  • end: number
  • t: number
• return:
  • lerpVal: number

tico.math.clamp(v, min, max)

Bounds v between min and max.

if x < min returns min if x > max returns max

• args:
  • v: number
  • min: number
  • max: number
• return:
  • val: number

tico.math.round(value)

Round value

• args:
  • value: number
• return:
  • roundedNumber: number

tico.math.sign(value)

Sign value if x < 0 return -1 if x > 0 return 1 if x == 0 return 0

• args:
  • value: number
• return:
  • signedValue: number

tico.math.distance(val1, val2)

Returns the distance between val1 and val2

• args:
  • val1: number
  • val2: number
• return:
  • distance: number

tico.math.angle(x0, y0, x1, y1)

Return the angle between the two points

• args:
  • x0: number
  • y0: number
  • x1: number
  • y1: number
• return:
  • angle: number

filesystem module

tico.filesystem.read(filename)

Read content from file

• args:
  • filename: string
• return:
  • file_content: string

tico.filesystem.write(filename, text, mode)

Write content to file, if file don’t exists, create one.

• args:
  • filename: string
  • text: string
  • mode: string (“w”)

tico.filesystem.fileExists(filename)

Check if the file exists

• args:

• filename: string

• return:
  • fileExists: boolean

tico.filesystem.setPath(path)

tico.filesystem.getPath()

Get the current project path

• return:
  • project_path: string

tico.filesystem.exePath()

Get the exe path

• return:
  • exe_path: string

tico.filesystem.resolvePath(filename)

Resolve the filename using the current project_path

• args:
  • filename: string
• return:
  • resolved_path: string

tico.filesystem.mkdir(name)

Create a directory

• args:
  • name: string

tico.filesystem.rmdir(name)

Remove a directory

• args:
  • name: string

json module

tico.json.encode(table)

Encodes a Lua table in a JSON string

• args:
  • table: table
• return:
  • json_string: string

tico.json.decode(str)

Decodes a JSON string to a Lua table

• args:
  • str: string
• return:
  • table: table

tico.json.load(filename)

Load a JSON file to a Lua table

• args:
  • filename: string
• return:
  • table: table

tico.json.save(filename, table)

Save a Lua table to a JSON file

• args:
  • filename: string
  • table: table

window module

tico.window.getTitle()

Get window title

• return:
  • title: string

tico.window.setTitle(title)

Set window title

• args:
  • title: string

tico.window.getWidth()

Get window width

• return:
  • width: number

tico.window.setWidth(width)

Set window width

• return:
  • width: number

tico.window.getHeight()

Get window height

• return:
  • height: number

tico.window.setHeight(height)

Set window height

• args:
  • height: number

tico.window.getSize()

Get window size

• return:
  • width: number
  • height: number

timer module

tico.timer.delta()

Return the current delta time

• return:
  • delta: number

tico.timer.fps()

Return the current FPS

• return:
  • fps: number

graphics module

tico.graphics.getSize()

Returns the current window size

• return:
  • width: number
  • height: number

local w, h = tico.graphics.getSize()

tico.graphics.clear(r, g, b, a)

tico.graphics.clear(color)

Clear the current framebuffer

If none argument is passed, clear to black

• args:
  • r: number
  • g: number
  • b: number
  • a: number (255)
• args:
  • color: table ({0, 0, 0})

function tico.draw()
	tico.graphics.clear(255, 0, 0)
end

Color = require "tico.color"

function tico.draw()
	tico.graphics.clear(Color.Red)
end

function tico.draw()
	tico.graphics.clear({255, 0, 0})
end

tico.graphics.newCanvas(width, height)

Create a new canvas (OpenGL framebuffer)

• args:
  • width: number
  • height: number
• return:
  • Canvas: userdata

Canvas functions:

• Canvas:draw
• Canvas:auto
• Canvas:getWidth
• Canvas:getHeight
• Canvas:getSize
• Canvas:attach
• Canvas:detach

:draw(x, y, angle, scaleX, scaleY, centerX, centerY, color)

:draw(x, y, color)

Draw the canvas

All arguments are optional

• args:
  • x: number (0)
  • y: number (0)
  • angle: number (0)
  • scaleX: number (1)
  • scaleY: number (1)
  • centerX: number (0)
  • centerY: number (0)
  • color: table ({255, 255, 255})

:auto()

Draw canvas and auto scale to fit window size but maintain the ratio

:getWidth()

Get the canvas texture width

• return:
  • width: number

:getHeight()

Get the canvas texture height

• return:
  • height: number

:getSize()

Get the canvas texture size

• return:
  • width: number
  • height: number

:attach()

Attach the Canvas

:detach()

Detach the Canvas, backing to the default framebuffer

function tico.load()
	canvas = tico.graphics.newCanvas(320, 240)
end

function tico.draw()
	canvas:attach()
	tico.graphics.clear()
	tico.graphics.drawRectangle(0, 0, 32, 32)
	canvas:detach()

	canvas:auto()
end

tico.graphics.newImage(filename)

Creates a new image

• args:
  • filename: string
• return:
  • Image: userdata

Image functions

• Image:draw
• Image:getWidth
• Image:getHeight
• Image:getSize

:draw(x, y, angle, scaleX, scaleY, centerX, centerY, color)

Draw the image

All arguments are optional

• args:
  • x: number (0)
  • y: number (0)
  • angle: number (0)
  • scaleX: number (1)
  • scaleY: number (1)
  • centerX: number (0)
  • centerY: number (0)
  • color: table ({255, 255, 255})

:getWidth()

Get the image’s width

• return:
  • width: number

:getHeight()

Get the image’s height

• return:
  • height: number

:getSize()

Get the image’s size

• return:
  • width: number
  • height: number

function tico.load()
	image = tico.graphics.newImage("image.png")
end

function tico.draw()
	image:draw(32, 32)
end

tico.graphics.newRectangle(x, y, w, h)

Creates a new Rectangle

• args:
  • x: number
  • y: number
  • w: number
  • h: number
• return:
  • Rectangle: userdata

Rectangle functions

• Rectangle:x
• Rectangle:y
• Rectangle:width
• Rectangle:height

:width()

Get the rectangle width

• return
  • width: number

:height()

Get the rectangle height

• return
  • height: number

:x()

Get the rectangle x

• return
  • x: number

:y()

Get the rectangle y

• return
  • y: number

tico.graphics.drawRectangle(x, y, w, h, color)

Draw a lined rectangle

• args:
  • x: number
  • y: number
  • w: number
  • h: number
  • color: table ({255, 255, 255})

tico.graphics.fillRectangle(x, y, w, h, color)

Draw a filled rectangle

• args:
  • x: number
  • y: number
  • w: number
  • h: number
  • color: table ({255, 255, 255})

tico.graphics.drawCircle(x, y, radius, color)

Draw a lined circle

• args:
  • x: number
  • y: number
  • radius: number
  • color: table ({255, 255, 255})

tico.graphics.fillCircle(x, y, radius, color)

Draw a filled circle

• args:
  • x: number
  • y: number
  • radius: number
  • color: table ({255, 255, 255})

tico.graphics.drawTriangle(x0, y0, x1, y1, x2, y2, color)

Draw a lined triangle

• args:
  • x0, x1, x2: number
  • y0, y1, y2: number
  • color: table ({255, 255, 255})

tico.graphics.fillTriangle(x0, y0, x1, y1, x2, y2, color)

Draw a lined triangle

• args:
  • x0, x1, x2: number
  • y0, y1, y2: number
  • color: table ({255, 255, 255})

tico.graphics.line(x0, y0, x1, y1, color)

Draw a line

-args: - x0, x1: number - y0, y1: number - color: table ({255, 255, 255})

tico.graphics.scissor(x, y, w, h)

Set a scissor

• args:
  • x: number
  • y: number
  • w: number
  • h: number

tico.graphics.print(text, x, y, color)

tico.graphics.print(Font, text, x, y, color)

Draw text on the screen

• args:
  • font: Font (defaultFont)
  • text: string
  • x: number
  • y: number
  • color: number

tico.graphics.printf(text, x, y, sx, sy, color)

tico.graphics.printf(Font, text, x, y, sx, sy, color)

extended tico.graphics.print

sx and sy are the scale factor

• args:
  • font: Font (defaultFont)
  • text: string
  • x: number
  • y: number
  • sx: number
  • sy: number
  • color: number

This site is open source. Improve this page.