Struct Lili 

pub struct Lili { /* private fields */ }

This struct give access to the main api of the musi lili engine.

It can be used to check current states of buttons, keys and the mouse.

It can be used to draw on the screen.

Example

use musi_lili::{Game, Lili};

struct MyGame;

impl Game for MyGame {
    fn init(_lili: &Lili) -> Self {
        Self
    }

    fn update(&mut self, _lili: &Lili) {
        // the code to update your game
   }

    fn draw(&mut self, lili: &Lili) {
        // draw your game
        lili.clear(0);
        lili.txt("toki", 5, 5, 3);
    }

fn main() {
   musi_lili::run::<MyGame>(musi_lili::load!("my-game"));
}

Implementations

impl Lili

pub fn clear(&self, color: u8)

Sets all pixel of the screen to the given color.

• color: the color to fill the screen with (needs to be a value between 0 and 3).

Example

    fn draw(&mut self, lili: &Lili) {
        // clears the screen with color 0
        lili.clear(0);
    }

pub fn cam(&self, x: i32, y: i32)

Sets the position of the camera.

• x: the x offset of the camera.
• y: the y offset of the camera.

Example

    fn draw(&mut self, lili: &Lili) {
        lili.clear(0);
        lili.cam(5, 5);
        // the rect starts now at (6/6) instead of (5/5)
        lili.rect(1, 1, 5, 5, 3);
    }

pub fn tra(&self, color: Option<u8>)

Defines a color that is ignored during drawing operations.

• color: the color that should be ignored. Set it to None to reset the ignored color.

Example

    fn draw(&mut self, lili: &Lili) {
        // clears the screen with color 0
        lili.clear(0);
        lili.tra(Some(1));
        // now only the second rect with color 2 is visible
       lili.rect(0, 0, 5, 5, 1);
       lili.rect(1, 1, 4, 4, 2);
    }

pub fn clip(&self, x: i32, y: i32, width: u32, height: u32)

Defines a clipping region. It will be drawn only the stuff that is inside of the defined area.

• x: the x coordinate of the clipping area.
• y: the y coordinate of the clipping area.

Example

    fn draw(&mut self, lili: &Lili) {
        lili.clear(0);
        lili.clip(2, 2, 10, 10);
        // on the screen only the part of the rect is visible that is inside the clipping area.
        lili.fill_rect(0, 0, 14, 14, 3);
    }

pub fn res_clip(&self)

Resets the current clipping region. Check clip.

Example

    fn draw(&mut self, lili: &Lili) {
        lili.clear(0);
        lili.clip(2, 2, 10, 10);
        // on the screen only the part of the rect is visible that is inside the clipping area.
        lili.fill_rect(0, 0, 14, 14, 3);
        lili.res_clip();
        // this rect is now full visible
        lili.fill_rect(0, 0, 12, 12, 2);
    }

pub fn pix(&self, x: i32, y: i32, color: u8)

Draws a single pixel on the given coordinate.

• x: the x coordinate of the pixel.
• y: the y coordinate of the pixel.
• color: the color of the pixel (needs to be a value between 0 and 3).

Example

    fn draw(&mut self, lili: &Lili) {
        lili.clear(0);
        // draws a pixel on (2/3) with color 3.
        lili.pix(0, 0, 3);
    }

pub fn rect(&self, x0: i32, y0: i32, x1: i32, y1: i32, color: u8)

Draws a bordered rectangle.

• x0: the start x coordinate (top-left).
• y0: the start y coordinate (top-left).
• x1: the end x coordinate (bottom-right).
• y1: the end y coordinate (bottom-right).
• color: the color of the rectangles border (needs to be a value between 0 and 3).

Example

    fn draw(&mut self, lili: &Lili) {
        lili.clear(0);
        // draws a rect with width of 2 and height of 5
        lili.rect(1, 1, 3, 6, 3);
    }

pub fn fill_rect(&self, x0: i32, y0: i32, x1: i32, y1: i32, color: u8)

Draws a filled rectangle.

• x0: the start x coordinate (top-left).
• y0: the start y coordinate (top-left).
• x1: the end x coordinate (bottom-right).
• y1: the end y coordinate (bottom-right).
• color: the color of the rect (needs to be a value between 0 and 3).

Example

    fn draw(&mut self, lili: &Lili) {
        lili.clear(0);
        // draws a rect with width of 2 and height of 5
        lili.fill_rect(1, 1, 3, 6, 3);
    }

pub fn circ(&self, x: i32, y: i32, radius: u32, color: u8)

Draws a bordered circle.

• x: the x coordinate of the center of the circle.
• y: the y coordinate of the center of the circle.
• radius: the radius of the circle.
• color: the color of the circles border (needs to be a value between 0 and 3).

Example

    fn draw(&mut self, lili: &Lili) {
        lili.clear(0);
        // draws bordered circle with center (x: 5, y: 5)
        lili.circ(5, 5, 5, 3);
    }

pub fn fill_circ(&self, x: i32, y: i32, radius: u32, color: u8)

Draws a filled circle.

• x: the x coordinate of the center of the circle.
• y: the y coordinate of the center of the circle.
• radius: the radius of the circle.
• color: the fill color of the circle (needs to be a value between 0 and 3).

Example

    fn draw(&mut self, lili: &Lili) {
        lili.clear(0);
        // draws bordered circle with center (x: 5, y: 5)
        lili.fill_circ(5, 5, 5, 3);
    }

pub fn line(&self, x0: i32, y0: i32, x1: i32, y1: i32, color: u8)

Draws a line form x0/y0 to x1/y1

• x0: the start x coordinate (top-left).
• y0: the start y coordinate (top-left).
• x1: the end x coordinate (bottom-right).
• y1: the end y coordinate (bottom-right).
• color: the color of the line (needs to be a value between 0 and 3).

Example

    fn draw(&mut self, lili: &Lili) {
        lili.clear(0);
        // draws a line from (1/1) to (3/6)
        lili.line(1, 1, 3, 6, 3);
    }

pub fn txt(&self, text: &str, x: i32, y: i32, color: u8) -> i32

Prints a text.

• text: the text to display.
• x: the x coordinate of the text.
• y: the y coordinate of the text.
• color: the color of the text (needs to be a value between 0 and 3).

Example

    fn draw(&mut self, lili: &Lili) {
        lili.clear(0);
        // draws the word "toki" on the screen
        lili.txt("toki", 1, 1, 3);
    }

pub fn spr(&self, sprite: u8, x: i32, y: i32, flip_x: bool, flip_y: bool)

Draws a sprite from the sprite sheet to the screen

• sprite: the sprite to draw (need to be a value between 0 and 244).
• x: the x coordinate of the sprite on the screen.
• y: the y coordinate of the sprite on the screen.
• flip_x: if set to true the sprite is flipped horizontal.
• flip_y: if set to true the sprite is flipped vertical.

Example

    fn draw(&mut self, lili: &Lili) {
        lili.clear(0);
        // draws sprite 0
        lili.spr(0, 1, 1, false, false);
    }

pub fn spr_ext( &self, sprite: u8, x: i32, y: i32, width: f32, height: f32, flip_x: bool, flip_y: bool, )

Draws a sprite with fractional dimensions or a range of sprites.

Supports two modes:

1. Fractional mode: spr(sprite, x, y, width_ratio, height_ratio) - draws a portion of a single sprite
   • width_ratio: horizontal portion to draw (0.0 to 1.0)
   • height_ratio: vertical portion to draw (0.0 to 1.0)
2. Range mode: spr(sprite, x, y, width_count, height_count) - draws multiple sprites in a grid
   • width_count: number of sprites horizontally (must be > 1.0)
   • height_count: number of sprites vertically (must be > 1.0)

• sprite: The starting sprite index
• x: The x coordinate to draw at
• y: The y coordinate to draw at
• width: Width ratio (fractional) or count (range)
• height: Height ratio (fractional) or count (range)
• flip_x: Whether to flip the sprite horizontally
• flip_y: Whether to flip the sprite vertically

pub fn map( &self, cell_x: u32, cell_y: u32, screen_x: i32, screen_y: i32, cell_width: u32, cell_height: u32, )

Draws the map.

• cell_x: cell x coordinate on the map..
• cell_y: cell y coordinate on the map.
• screen_x: x coordinate on the screen in pixel.
• screen_y: y coordinate on the screen in pixel.
• cell_width: horizontal number of cells to draw.
• cell_height: vertical number of cells to draw.

Example

    fn draw(&mut self, lili: &Lili) {
        lili.clear(0);
        // draws the whole map
        lili.map(0, 0, 0, 0, MAP_WIDTH, MAP_HEIGHT);
    }

pub fn set_tile(&self, x: u32, y: u32, tile: u8)

Sets the sprite number on the given map position.

pub fn get_tile(&self, x: u32, y: u32) -> Option<u8>

Returns the

pub fn set_flag(&self, sprite: u8, flag: u8, value: bool)

Sets the flag for the given sprite

pub fn get_flag(&self, sprite: u8, flag: u8) -> bool

Returns if the given flag on the sprite is set.

pub fn btn(&self, button: impl Into<Button>) -> bool

Returns true if the given button is pressed.

pub fn get_mouse(&self) -> Point

Returns the current mouse position.

pub fn get_scroll(&self) -> Point

Returns the current scroll wheel delta.

pub fn key(&self, key: &Key) -> bool

Returns true if the given key is pressed.

pub fn get_keys(&self) -> Vec<Key>

Returns the list of all pressed keys.

pub fn set_pal(&self, palette: Palette)

Sets the current used color palette.

pub fn get_pal(&self) -> Palette

Return the current used color palette.

pub fn sound(&self, name: &str, samples: Vec<f32>, rate: u32)

Creates a new sound and stores it with the given name.

This function generates sound data based on the provided parameters.

Arguments

• name - A string slice that holds the name of the sound.
• samples - The raw audio samples.
• rate - The sample rate in Hz.

pub fn play(&self, sound: &str, volume: f32)

Plays the sound associated with the given name.

This function retrieves the sound data associated with the given name and plays it using the sound function.

Arguments

• sound - A string slice that holds the name of the sound to play
• volume - The volume of the sound. 1.0 is the normal volume.

pub fn stop(&self, sound: &str)

Stops the sound associated with the given name.

This function stops the sound with the given name that was started with play.

Arguments

• sound - A string slice that holds the name of the sound to stop.

pub fn stop_all(&self)

Stops all active sounds.

pub fn save(&self, name: &str, content: &[u8])

Saves a game state with the given name and content. Save games will be created per game in the settings directory of the user.

Paths

Linux: /home/alice/.config/{game_name}/{save_name}.save macOS: /Users/Alice/Library/Application Support/{game_name}/{save_name}.save Windows: C:\Users\Alice\AppData\Roaming\{game_name}\{save_name}.save Android: /data/data/{game_name}/{save_name}.save Web: Save games are stored and load using the Web Storage API

pub fn load(&self, name: &str) -> Option<Vec<u8>>

Loads a save game by a name as identifier. Save games will be created per game in the settings directory of the user.

If there is no save game with the given name this method returns None.

Paths

Linux: /home/alice/.config/{game_name}/{save_name}.save macOS: /Users/Alice/Library/Application Support/{game_name}/{save_name}.save Windows: C:\Users\Alice\AppData\Roaming\{game_name}\{save_name}.save Android: /data/data/{game_name}/{save_name}.save Web: Save games are stored and load using the Web Storage API

pub fn rm_save(&self, name: &str)

Removes the save game with the given name

pub fn save_games(&self) -> Option<Vec<String>>

Returns all names of the save games.

pub fn quit(&self)

Quit the game before the next frame is executed.

pub fn fullscreen(&self, fullscreen: bool)

Set or unset the window to display fullscreen.