bevy_mod_scripting_core 0.21.0

Core traits and structures required for other parts of bevy_mod_scripting
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

use std::fmt;

use bevy_asset::AssetId;
use bevy_ecs::entity::Entity;

use super::*;
use crate::ScriptAsset;

impl From<ScriptAttachment> for ContextKey {
    fn from(val: ScriptAttachment) -> Self {
        match val {
            ScriptAttachment::EntityScript(entity, script) => ContextKey {
                entity: Some(entity),
                script: Some(script.id()),
            },
            ScriptAttachment::StaticScript(script) => ContextKey {
                entity: None,
                script: Some(script.id()),
            },
        }
    }
}

/// The key for a context. The context key is used for:
/// - Identifying the script itself, uniquely.
/// - later on it's mapped to a context, which will determine how the scripts are grouped in execution environments.
#[derive(Debug, Hash, Clone, Default, PartialEq, Eq, Reflect)]
pub struct ContextKey {
    /// Entity if there is one.
    pub entity: Option<Entity>,
    /// Script ID if there is one.
    /// Can be empty if the script is not driven by an asset.
    pub script: Option<AssetId<ScriptAsset>>,
}

impl fmt::Display for ContextKey {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // write!(f, "context ")?;
        let mut empty = true;
        if let Some(script_id) = &self.script {
            write!(f, "script {script_id}")?;
            empty = false;
        }
        if let Some(id) = self.entity {
            write!(f, "entity {id}")?;
            empty = false;
        }
        if empty {
            write!(f, "empty")?;
        }
        Ok(())
    }
}

impl ContextKey {
    /// Creates an invalid context key, which should never exist.
    pub const INVALID: Self = Self {
        entity: Some(Entity::PLACEHOLDER),
        script: Some(AssetId::invalid()),
    };

    /// Creates a shared context key, which is used for shared contexts
    pub const SHARED: Self = {
        Self {
            entity: None,
            script: None,
        }
    };

    /// Is the key empty?
    pub fn is_empty(&self) -> bool {
        self == &Self::default()
    }

    /// or with other context
    pub fn or(self, other: ContextKey) -> Self {
        Self {
            entity: self.entity.or(other.entity),
            script: self.script.or(other.script),
        }
    }
}