pybevy 0.2.1

PyBevy: A Python Real-Time Engine Built on Bevy
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use pyo3::{prelude::*, types::PyDict};

/// Wrapper for a system with a run condition
/// Similar to Bevy's IntoSystemConfigs::run_if()
#[pyclass(name = "ConditionalSystem")]
pub struct PyConditionalSystem {
    /// The system function to run
    pub system: Py<PyAny>,
    /// The condition function that must return bool
    pub condition: Py<PyAny>,
}

impl Clone for PyConditionalSystem {
    fn clone(&self) -> Self {
        Python::attach(|py| Self {
            system: self.system.clone_ref(py),
            condition: self.condition.clone_ref(py),
        })
    }
}

#[pymethods]
impl PyConditionalSystem {
    #[new]
    pub fn new(system: Py<PyAny>, condition: Py<PyAny>) -> Self {
        Self { system, condition }
    }

    /// Combine this condition with another using AND logic
    /// Both conditions must return true for the system to run
    /// Usage: run_if(system, condition1).and_(condition2)
    pub fn and_(&self, condition: Py<PyAny>) -> PyResult<Self> {
        Python::attach(|py| {
            // Create a Python function that combines both conditions with AND
            // Use functools.wraps to preserve the first condition's annotations
            let self_condition = self.condition.clone_ref(py);
            let functools = py.import("functools")?;

            let locals = PyDict::new(py);
            locals.set_item("c1", self_condition)?;
            locals.set_item("c2", condition)?;
            locals.set_item("functools", functools)?;

            let code = c"\
def make_and(c1, c2, functools):
    @functools.wraps(c1)
    def combined(*args, **kwargs):
        return c1(*args, **kwargs) and c2(*args, **kwargs)
    return combined
result = make_and(c1, c2, functools)";
            py.run(code, None, Some(&locals))?;

            let combined = locals.get_item("result")?.unwrap().unbind();

            Ok(Self {
                system: self.system.clone_ref(py),
                condition: combined,
            })
        })
    }

    /// Combine this condition with another using OR logic
    /// Either condition must return true for the system to run
    /// Usage: run_if(system, condition1).or_(condition2)
    pub fn or_(&self, condition: Py<PyAny>) -> PyResult<Self> {
        Python::attach(|py| {
            // Create a Python function that combines both conditions with OR
            // Use functools.wraps to preserve the first condition's annotations
            let self_condition = self.condition.clone_ref(py);
            let functools = py.import("functools")?;

            let locals = PyDict::new(py);
            locals.set_item("c1", self_condition)?;
            locals.set_item("c2", condition)?;
            locals.set_item("functools", functools)?;

            let code = c"\
def make_or(c1, c2, functools):
    @functools.wraps(c1)
    def combined(*args, **kwargs):
        return c1(*args, **kwargs) or c2(*args, **kwargs)
    return combined
result = make_or(c1, c2, functools)";
            py.run(code, None, Some(&locals))?;

            let combined = locals.get_item("result")?.unwrap().unbind();

            Ok(Self {
                system: self.system.clone_ref(py),
                condition: combined,
            })
        })
    }

    /// Negate this condition using NOT logic
    /// The condition must return false for the system to run
    /// Usage: run_if(system, condition).not_()
    pub fn not_(&self) -> PyResult<Self> {
        Python::attach(|py| {
            // Create a Python function that negates the condition
            // Use functools.wraps to preserve the condition's annotations
            let self_condition = self.condition.clone_ref(py);
            let functools = py.import("functools")?;

            let locals = PyDict::new(py);
            locals.set_item("c", self_condition)?;
            locals.set_item("functools", functools)?;

            let code = c"\
def make_not(c, functools):
    @functools.wraps(c)
    def negated(*args, **kwargs):
        return not c(*args, **kwargs)
    return negated
result = make_not(c, functools)";
            py.run(code, None, Some(&locals))?;

            let negated = locals.get_item("result")?.unwrap().unbind();

            Ok(Self {
                system: self.system.clone_ref(py),
                condition: negated,
            })
        })
    }
}

/// Helper function to create a conditional system
/// Usage: run_if(system_func, condition_func)
#[pyfunction]
pub fn run_if(system: Py<PyAny>, condition: Py<PyAny>) -> PyResult<PyConditionalSystem> {
    Ok(PyConditionalSystem::new(system, condition))
}