Struct PlaydateSystem 

pub struct PlaydateSystem { /* private fields */ }

Implementations

impl PlaydateSystem

pub fn log_to_console(&self, msg: impl AsRef<str>)

Calls the log function.

pub fn error(&self, msg: impl AsRef<str>)

Calls the log function, outputting an error in red to the console, then pauses execution.

pub fn get_language(&self) -> Language

Returns the current language of the system.

pub fn get_current_time_milliseconds(&self) -> usize

Returns the number of milliseconds since…​some arbitrary point in time. This should present a consistent timebase while a game is running, but the counter will be disabled when the device is sleeping.

pub fn get_seconds_since_epoch(&self) -> (usize, usize)

Returns the number of seconds (and sets milliseconds if not NULL) elapsed since midnight (hour 0), January 1, 2000.

pub fn draw_fps(&self, pos: Vec2<i32>)

Calculates the current frames per second and draws that value at x, y.

Examples found in repository

examples/hello_world.rs (line 42)

    fn update(&mut self, delta: f32) {
        // Clear screen
        PLAYDATE.graphics.clear(Color::White);
        // Draw image
        PLAYDATE.graphics.draw_rotated_bitmap(
            &self.image,
            vec2![130, 120],
            self.rotation,
            vec2![0.5, 0.5],
            vec2![1.0, 1.0],
        );
        // Rotate image
        self.rotation += delta * 90.0;
        // Draw text
        PLAYDATE
            .graphics
            .draw_text("Hello, World!", vec2![230, 112]);
        // Draw FPS
        PLAYDATE.system.draw_fps(vec2![0, 0]);
    }

examples/mandelbrot.rs (line 209)

    fn update(&mut self, _delta: f32) {
        let button_state = PLAYDATE.system.get_button_state();
        let prev_scale = self.scale;
        let prev_center = self.center;
        // Scale
        if button_state.current.contains(Buttons::A) {
            self.scale /= 1.1;
        } else if button_state.current.contains(Buttons::B) {
            self.scale *= 1.1
        }
        if !PLAYDATE.system.is_crank_docked() {
            let crank = PLAYDATE.system.get_crank_change();
            if crank > 0.0 {
                self.scale /= 1.05;
            } else if crank < 0.0 {
                self.scale *= 1.05;
            }
        }
        // Move
        if button_state.current.contains(Buttons::Up) {
            self.center.im += 10.0 * self.scale
        } else if button_state.current.contains(Buttons::Down) {
            self.center.im -= 10.0 * self.scale
        }
        if button_state.current.contains(Buttons::Left) {
            self.center.re -= 10.0 * self.scale
        } else if button_state.current.contains(Buttons::Right) {
            self.center.re += 10.0 * self.scale
        }
        if prev_center != self.center || prev_scale != self.scale {
            self.draw_frame();
        }
        // Draw metadata
        self.draw_meta();
        // Draw FPS
        PLAYDATE.system.draw_fps(vec2![0, 0]);
    }

pub fn get_button_state(&self) -> ButtonState

Returns bitmasks indicating which buttons are currently down. pushed and released reflect which buttons were pushed or released over the previous update cycle—at the nominal frame rate of 50 ms, fast button presses can be missed if you just poll the instantaneous state.

Examples found in repository

examples/mandelbrot.rs (line 175)

    fn update(&mut self, _delta: f32) {
        let button_state = PLAYDATE.system.get_button_state();
        let prev_scale = self.scale;
        let prev_center = self.center;
        // Scale
        if button_state.current.contains(Buttons::A) {
            self.scale /= 1.1;
        } else if button_state.current.contains(Buttons::B) {
            self.scale *= 1.1
        }
        if !PLAYDATE.system.is_crank_docked() {
            let crank = PLAYDATE.system.get_crank_change();
            if crank > 0.0 {
                self.scale /= 1.05;
            } else if crank < 0.0 {
                self.scale *= 1.05;
            }
        }
        // Move
        if button_state.current.contains(Buttons::Up) {
            self.center.im += 10.0 * self.scale
        } else if button_state.current.contains(Buttons::Down) {
            self.center.im -= 10.0 * self.scale
        }
        if button_state.current.contains(Buttons::Left) {
            self.center.re -= 10.0 * self.scale
        } else if button_state.current.contains(Buttons::Right) {
            self.center.re += 10.0 * self.scale
        }
        if prev_center != self.center || prev_scale != self.scale {
            self.draw_frame();
        }
        // Draw metadata
        self.draw_meta();
        // Draw FPS
        PLAYDATE.system.draw_fps(vec2![0, 0]);
    }

pub fn set_peripherals_enabled(&self, mask: Peripherals)

By default, the accelerometer is disabled to save (a small amount of) power. To use a peripheral, it must first be enabled via this function. Accelerometer data is not available until the next update cycle after it’s enabled.

pub fn get_accelerometer(&self) -> (f32, f32, f32)

Returns the last-read accelerometer data.

pub fn get_crank_angle(&self) -> f32

Returns the current position of the crank, in the range 0-360. Zero is pointing up, and the value increases as the crank moves clockwise, as viewed from the right side of the device.

pub fn get_crank_change(&self) -> f32

Returns the angle change of the crank since the last time this function was called. Negative values are anti-clockwise.

Examples found in repository

examples/mandelbrot.rs (line 185)

    fn update(&mut self, _delta: f32) {
        let button_state = PLAYDATE.system.get_button_state();
        let prev_scale = self.scale;
        let prev_center = self.center;
        // Scale
        if button_state.current.contains(Buttons::A) {
            self.scale /= 1.1;
        } else if button_state.current.contains(Buttons::B) {
            self.scale *= 1.1
        }
        if !PLAYDATE.system.is_crank_docked() {
            let crank = PLAYDATE.system.get_crank_change();
            if crank > 0.0 {
                self.scale /= 1.05;
            } else if crank < 0.0 {
                self.scale *= 1.05;
            }
        }
        // Move
        if button_state.current.contains(Buttons::Up) {
            self.center.im += 10.0 * self.scale
        } else if button_state.current.contains(Buttons::Down) {
            self.center.im -= 10.0 * self.scale
        }
        if button_state.current.contains(Buttons::Left) {
            self.center.re -= 10.0 * self.scale
        } else if button_state.current.contains(Buttons::Right) {
            self.center.re += 10.0 * self.scale
        }
        if prev_center != self.center || prev_scale != self.scale {
            self.draw_frame();
        }
        // Draw metadata
        self.draw_meta();
        // Draw FPS
        PLAYDATE.system.draw_fps(vec2![0, 0]);
    }

pub fn is_crank_docked(&self) -> bool

Returns 1 or 0 indicating whether or not the crank is folded into the unit.

Examples found in repository

examples/mandelbrot.rs (line 184)

    fn update(&mut self, _delta: f32) {
        let button_state = PLAYDATE.system.get_button_state();
        let prev_scale = self.scale;
        let prev_center = self.center;
        // Scale
        if button_state.current.contains(Buttons::A) {
            self.scale /= 1.1;
        } else if button_state.current.contains(Buttons::B) {
            self.scale *= 1.1
        }
        if !PLAYDATE.system.is_crank_docked() {
            let crank = PLAYDATE.system.get_crank_change();
            if crank > 0.0 {
                self.scale /= 1.05;
            } else if crank < 0.0 {
                self.scale *= 1.05;
            }
        }
        // Move
        if button_state.current.contains(Buttons::Up) {
            self.center.im += 10.0 * self.scale
        } else if button_state.current.contains(Buttons::Down) {
            self.center.im -= 10.0 * self.scale
        }
        if button_state.current.contains(Buttons::Left) {
            self.center.re -= 10.0 * self.scale
        } else if button_state.current.contains(Buttons::Right) {
            self.center.re += 10.0 * self.scale
        }
        if prev_center != self.center || prev_scale != self.scale {
            self.draw_frame();
        }
        // Draw metadata
        self.draw_meta();
        // Draw FPS
        PLAYDATE.system.draw_fps(vec2![0, 0]);
    }

pub fn set_crank_sounds_disabled(&self, flag: bool) -> bool

The function returns the previous value for this setting.

pub fn get_flipped(&self) -> bool

Returns 1 if the global “flipped” system setting is set, otherwise 0.

pub fn set_auto_lock_disabled(&self, disable: bool)

Disables or enables the 60 second auto lock feature. When called, the timer is reset to 60 seconds.

pub fn set_menu_image(&self, bitmap: impl AsRef<Bitmap>, x_offset: i32)

A game can optionally provide an image to be displayed alongside the system menu. bitmap must be a 400x240 LCDBitmap. All important content should be in the left half of the image in an area 200 pixels wide, as the menu will obscure the rest. The right side of the image will be visible briefly as the menu animates in and out.

Optionally, a non-zero xoffset, can be provided. This must be a number between 0 and 200 and will cause the menu image to animate to a position offset left by xoffset pixels as the menu is animated in.

This function could be called in response to the kEventPause event in your implementation of eventHandler().

pub fn add_menu_item(&self, title: impl AsRef<str>, callback: fn()) -> MenuItem

title will be the title displayed by the menu item.

Adds a new menu item to the System Menu. When invoked by the user, this menu item will:

1. Invoke your callback function.
2. Hide the System Menu.
3. Unpause your game and call eventHandler() with the kEventResume event.

Your game can then present an options interface to the player, or take other action, in whatever manner you choose.

pub fn add_checkmark_menu_item( &self, title: impl AsRef<str>, value: bool, callback: fn(), ) -> MenuItem

Adds a new menu item that can be checked or unchecked by the player.

title will be the title displayed by the menu item.

value should be false for unchecked, true for checked.

If this menu item is interacted with while the system menu is open, callback will be called when the menu is closed.

pub fn add_options_menu_item( &self, title: impl AsRef<str>, option_titles: &[&str], callback: fn(), ) -> MenuItem

Adds a new menu item that allows the player to cycle through a set of options.

title will be the title displayed by the menu item.

options should be an array of strings representing the states this menu item can cycle through. Due to limited horizontal space, the option strings and title should be kept short for this type of menu item.

optionsCount should be the number of items contained in options.

If this menu item is interacted with while the system menu is open, callback will be called when the menu is closed.

pub fn get_reduce_flashing(&self) -> bool

Returns 1 if the global “reduce flashing” system setting is set, otherwise 0.

pub fn get_elapsed_time(&self) -> f32

Returns the number of seconds since playdate.resetElapsedTime() was called. The value is a floating-point number with microsecond accuracy.

pub fn reset_elapsed_time(&self)

Resets the high-resolution timer.

pub fn get_battery_percentage(&self) -> f32

Returns a value from 0-100 denoting the current level of battery charge. 0 = empty; 100 = full.

pub fn get_battery_voltage(&self) -> f32

Returns the battery’s current voltage level.

pub fn get_timezone_offset(&self) -> i32

Returns the system timezone offset from GMT, in seconds.

pub fn should_display_24_hour_time(&self) -> bool

Returns 1 if the user has set the 24-Hour Time preference in the Settings program.

pub fn convert_epoch_to_date_time(&self, epoch: u32) -> DateTime

Converts the given epoch time to a PDDateTime.

pub fn convert_date_time_to_epoch(&self, datetime: DateTime) -> u32

Converts the given PDDateTime to an epoch time.

pub fn clear_icache(&self)

Flush the CPU instruction cache, on the very unlikely chance you’re modifying instruction code on the fly. (If you don’t know what I’m talking about, you don’t need this. :smile:)