pi_world 0.1.25

ecs world
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
134
135
136
137
138
139
140
141
142
143
144
145
146

//! App包含一个world，一个调度器，及一个运行时
//!
//!
use pi_async_rt::prelude::{AsyncRuntime, AsyncRuntimeExt};

use crate::{schedule::{MainSchedule, Schedule}, schedule_config::{IntoSystemConfigs, IntoSystemSetConfigs, ScheduleLabel, StageLabel}, world::World};


pub type App = AppInner<runtime::Runtime>;

pub struct AppInner<A: AsyncRuntime + AsyncRuntimeExt> {
    pub world: World,
    pub schedule: Schedule,
    pub startup_schedule: Schedule,
    pub rt: A,
    pub is_first_run: bool,
}
impl AppInner<runtime::Runtime> {
    pub fn new() -> Self {
        App {
            world: World::new(),
            schedule: Schedule::new(true),
            startup_schedule: Schedule::new(false),
            rt: runtime::create_runtime(),
            is_first_run: true,
        }
    }
}

impl<A: AsyncRuntime + AsyncRuntimeExt> AppInner<A> {

    /// 配置系统集
    pub fn configure_set(&mut self, _stage_label: impl StageLabel, config: impl IntoSystemSetConfigs) -> &mut Self {
        self.schedule.configure_set(config.into_configs());
        self
    }

    // 添加system
    pub fn add_system<M>(&mut self, stage_label: impl StageLabel, system: impl IntoSystemConfigs<M>) -> &mut Self {
        let stage_label = stage_label.intern();
        let system_config = system.into_configs();
                
        self.schedule.add_system(stage_label, system_config);
        self
    }

    // 添加system
    pub fn add_startup_system<M>(&mut self, stage_label: impl StageLabel, system: impl IntoSystemConfigs<M>) -> &mut Self {
        let stage_label = stage_label.intern();
        let system_config = system.into_configs();
                
        self.startup_schedule.add_system(stage_label, system_config);
        self
    }

    /// 同步运行日程
    /// schedule_label为None时， 表示运行所有的system
    /// 否则运行指定日程中的system
    pub fn run(&mut self) {
        // for item in self.world.archetype_arr.iter(){
        //     println!("item: {:?}", item);
        // }
        if self.is_first_run {
            self.startup_schedule.run(&mut self.world, &self.rt, &MainSchedule.intern());
            self.is_first_run = false;
        }
        
        self.schedule.run(&mut self.world, &self.rt, &MainSchedule.intern());
    }

    /// 同步运行日程
    /// schedule_label为None时， 表示运行所有的system
    /// 否则运行指定日程中的system
    pub fn run_schedule(&mut self, schedule_label: impl ScheduleLabel) {
        if self.is_first_run {
            self.startup_schedule.run(&mut self.world, &self.rt, &MainSchedule.intern());
            self.is_first_run = false;
        }

        self.schedule.run(&mut self.world, &self.rt, &schedule_label.intern());
    }

    /// 异步运行日程
    /// schedule_label为None时， 表示运行所有的system
    /// 否则运行指定日程中的system
    pub async fn async_run(&mut self, schedule_label: impl ScheduleLabel) {
        if self.is_first_run {
            self.startup_schedule.async_run(&mut self.world, &self.rt, &MainSchedule.intern()).await;
            self.is_first_run = false;
        }

        self.schedule.async_run(&mut self.world, &self.rt, &schedule_label.intern()).await;
    }

    /// 异步运行日程
    /// schedule_label为None时， 表示运行所有的system
    /// 否则运行指定日程中的system
    pub async fn async_run_schedule(&mut self) {
        if self.is_first_run {
            self.startup_schedule.async_run(&mut self.world, &self.rt, &MainSchedule.intern()).await;
            self.is_first_run = false;
        }

        self.schedule.async_run(&mut self.world, &self.rt, &MainSchedule.intern()).await;
    }
}

#[cfg(not(any(feature="single_thread", target_arch = "wasm32")))]
mod runtime {
    pub use pi_async_rt::rt::multi_thread::MultiTaskRuntime as Runtime;
    use pi_async_rt::rt::multi_thread::{MultiTaskRuntimeBuilder, StealableTaskPool};


    use crate::{schedule::Schedule, world::World};

    pub fn create_runtime() -> Runtime {
        let pool = StealableTaskPool::with(4, 100000, [1, 254], 3000);
        let builer = MultiTaskRuntimeBuilder::new(pool)
            .set_timer_interval(1)
            .init_worker_size(4)
            .set_worker_limit(4, 4);
        builer.build()
    }
}

#[cfg(all(feature="single_thread", not(target_arch = "wasm32")))]
mod runtime {
    pub use pi_async_rt::prelude::SingleTaskRuntime as Runtime;
    use pi_async_rt::prelude::{SingleTaskPool, SingleTaskRunner};

    pub fn create_runtime() -> Runtime {
        let pool = SingleTaskPool::default();
        SingleTaskRunner::<(), SingleTaskPool<()>>::new(pool).into_local()
    }
}

#[cfg(target_arch = "wasm32")]
mod runtime {
    pub use pi_async_rt::rt::serial_local_compatible_wasm_runtime::LocalTaskRuntime as Runtime;
    use pi_async_rt::rt::serial_local_compatible_wasm_runtime::LocalTaskRunner;

    pub fn create_runtime() -> Runtime {
        let runner = LocalTaskRunner::new();
        runner.get_runtime()
    }
}