nano9 0.1.0-alpha.3

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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use bevy::prelude::*;
use std::any::TypeId;

use super::PColor;
#[cfg(feature = "scripting")]
use bevy_mod_scripting::{
    core::docgen::typed_through::{ThroughTypeInfo, TypedThrough},
    core::{
        bindings::{function::from::FromScript, script_value::ScriptValue, WorldAccessGuard},
        error::InteropError,
    },
    GetTypeDependencies,
};

/// This is a fill color that specifies what color to use for the "off" bit (default) and "on" bit.
#[derive(Debug, Clone, Copy, Reflect)]
#[cfg_attr(feature = "scripting", derive(GetTypeDependencies))]
pub enum FillColor {
    One { off: PColor },
    Two { off: PColor, on: PColor },
}

impl FillColor {
    pub fn is_one_color(&self) -> bool {
        matches!(self, FillColor::One { .. })
    }

    pub fn on(&self) -> Option<PColor> {
        match self {
            FillColor::One { off: _ } => None,
            FillColor::Two { off: _, on } => Some(*on),
        }
    }

    pub fn off(&self) -> PColor {
        match self {
            FillColor::One { off } => *off,
            FillColor::Two { off, on: _ } => *off,
        }
    }
}

#[cfg(feature = "scripting")]
impl TypedThrough for FillColor {
    fn through_type_info() -> ThroughTypeInfo {
        ThroughTypeInfo::TypeInfo(<FillColor as bevy::reflect::Typed>::type_info())
    }
}

impl From<PColor> for FillColor {
    fn from(c: PColor) -> Self {
        FillColor::One { off: c }
    }
}

impl From<usize> for FillColor {
    fn from(c: usize) -> Self {
        FillColor::One {
            off: PColor::from(c),
        }
    }
}

impl From<Color> for FillColor {
    fn from(c: Color) -> Self {
        FillColor::One {
            off: PColor::Color(c.into()),
        }
    }
}

impl From<(Color, Color)> for FillColor {
    fn from((a, b): (Color, Color)) -> Self {
        FillColor::Two {
            off: b.into(),
            on: a.into(),
        }
    }
}

#[cfg(feature = "scripting")]
impl FromScript for FillColor {
    type This<'w> = Self;
    fn from_script(
        value: ScriptValue,
        _world: WorldAccessGuard<'_>,
    ) -> Result<Self::This<'_>, InteropError> {
        match value {
            ScriptValue::Integer(n) => {
                if n <= 0xf {
                    Ok(FillColor::One {
                        off: PColor::Palette(n as usize),
                    })
                } else {
                    Ok(FillColor::Two {
                        off: PColor::Palette((n & 0xf) as usize),
                        on: PColor::Palette((n >> 4) as usize),
                    })
                }
            }
            // ScriptValue::Unit => Ok(N9Color::Pen),
            _ => Err(InteropError::impossible_conversion(
                TypeId::of::<FillColor>(),
            )),
        }
    }
}