nano9 0.1.0-alpha.7

A Pico-8 compatibility layer for Bevy
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use bevy::prelude::*;

use crate::{
    PColor,
    pico8::{PalError, Palette},
};

pub(crate) fn plugin(_app: &mut App) {}

/// Default Pico-8 palette used when the palette image is not yet loaded (e.g. config-loaded asset).
fn default_pico8_color(index: usize) -> Option<Color> {
    let [r, g, b, a] = *super::cart::PALETTE.get(index)?;
    Some(Color::srgba_u8(r, g, b, a))
}

#[derive(Debug, Default, Deref, DerefMut, Reflect, Clone)]
pub struct Palettes(pub(crate) Vec<Palette>);

impl Palettes {
    pub fn get_pal(&self, palette_index: usize) -> Result<&Palette, PalError> {
        self.0.get(palette_index).ok_or(PalError::NoSuchPalette {
            index: palette_index,
            count: self.0.len(),
        })
    }

    /// Number of colors in the palette at the given index, when loaded from `images`. Returns `None` if the palette image is not loaded.
    pub fn len_in(
        &self,
        palette_index: usize,
        images: &Assets<Image>,
    ) -> Result<Option<usize>, PalError> {
        let pal = self.get_pal(palette_index)?;
        Ok(images.get(&pal.image).map(|img| pal.len_in(img)))
    }

    /// Resolve a PColor into a Color using the palette image from `images`.
    /// When the palette image is not yet loaded (e.g. still loading from config), falls back to the default Pico-8 palette for indices 0..16.
    pub fn get_color(
        &self,
        c: PColor,
        palette_index: usize,
        images: &Assets<Image>,
    ) -> Result<Color, PalError> {
        match c {
            PColor::Palette(n) => {
                let pal = self.get_pal(palette_index)?;
                if let Some(image) = images.get(&pal.image) {
                    pal.get_color_in(n, image)
                        .map(|c| c.into())
                        .map_err(|e| match e {
                            PalError::NoSuchColor(c) => PalError::NoSuchPaletteColor {
                                color: c,
                                palette: palette_index,
                            },
                            x => x,
                        })
                } else if let Some(color) = default_pico8_color(n) {
                    Ok(color)
                } else {
                    Err(PalError::NoSuchPaletteColor {
                        color: n,
                        palette: palette_index,
                    })
                }
            }
            PColor::Color(c) => Ok(c.into()),
        }
    }
}

impl From<Vec<Palette>> for Palettes {
    fn from(palettes: Vec<Palette>) -> Self {
        Self(palettes)
    }
}