2022-06-12 15:57:39 +00:00
|
|
|
use crate::dynamic_data::script_handling::script::{Script, ScriptContainer};
|
2022-06-03 14:35:18 +00:00
|
|
|
use crate::dynamic_data::script_handling::script_set::ScriptSet;
|
2022-06-12 15:57:39 +00:00
|
|
|
use parking_lot::RwLock;
|
|
|
|
use std::sync::{Arc, Weak};
|
2022-06-03 14:35:18 +00:00
|
|
|
|
2022-06-11 15:22:46 +00:00
|
|
|
pub mod item_script;
|
2021-01-31 16:31:22 +00:00
|
|
|
pub mod script;
|
|
|
|
pub mod script_set;
|
2022-06-06 11:54:59 +00:00
|
|
|
pub mod volatile_scripts;
|
2022-06-03 14:35:18 +00:00
|
|
|
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! script_hook {
|
|
|
|
($hook_name: ident, $source: ident, $($parameters: expr),*) => {
|
|
|
|
let mut aggregator = $source.get_script_iterator();
|
|
|
|
while let Some(script) = aggregator.get_next() {
|
2022-06-12 15:57:39 +00:00
|
|
|
let lock = &mut script.get();
|
|
|
|
let script = lock.as_mut().unwrap();
|
2022-06-03 14:35:18 +00:00
|
|
|
if script.is_suppressed() {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
script.$hook_name($($parameters),*);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2022-06-16 15:59:33 +00:00
|
|
|
#[macro_export]
|
|
|
|
macro_rules! script_hook_on_lock {
|
|
|
|
($hook_name: ident, $source: ident, $($parameters: expr),*) => {
|
|
|
|
let mut aggregator = $source.read().get_script_iterator();
|
|
|
|
while let Some(script) = aggregator.get_next() {
|
|
|
|
let lock = &mut script.get();
|
|
|
|
let script = lock.as_mut().unwrap();
|
|
|
|
if script.is_suppressed() {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
script.$hook_name($($parameters),*);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! run_scripts {
|
|
|
|
($hook_name: ident, $source: ident, $($parameters: expr),*) => {
|
|
|
|
for script in $source {
|
|
|
|
match script {
|
|
|
|
ScriptWrapper::Script(s) => {
|
|
|
|
if let Some(s) = s.upgrade() {
|
|
|
|
if let Some(s) = s.write().deref_mut() {
|
|
|
|
if !s.is_suppressed() {
|
|
|
|
s.$hook_name($($parameters),*);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ScriptWrapper::Set(s) => {
|
|
|
|
if let Some(s) = s.upgrade() {
|
|
|
|
for s in s.read().get_underlying() {
|
|
|
|
let mut s = s.1.get();
|
|
|
|
if let Some(s) = s.deref_mut() {
|
|
|
|
if !s.is_suppressed() {
|
|
|
|
s.$hook_name($($parameters),*);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2022-06-12 16:41:49 +00:00
|
|
|
#[derive(Default, Debug)]
|
2022-06-12 15:57:39 +00:00
|
|
|
pub struct ScriptSourceData {
|
|
|
|
is_initialized: bool,
|
|
|
|
scripts: Vec<ScriptWrapper>,
|
|
|
|
}
|
|
|
|
|
|
|
|
pub trait ScriptSource<'a> {
|
2022-06-03 14:35:18 +00:00
|
|
|
fn get_script_iterator(&self) -> ScriptAggregator {
|
2022-06-12 15:57:39 +00:00
|
|
|
let lock = self.get_script_source_data();
|
|
|
|
if !lock.read().is_initialized {
|
|
|
|
let mut data = lock.write();
|
|
|
|
data.scripts = Vec::with_capacity(self.get_script_count());
|
|
|
|
self.collect_scripts(&mut data.scripts);
|
|
|
|
data.is_initialized = true;
|
|
|
|
}
|
|
|
|
ScriptAggregator::new(&lock.read().scripts as *const Vec<ScriptWrapper>)
|
2022-06-03 14:35:18 +00:00
|
|
|
}
|
2022-06-12 15:57:39 +00:00
|
|
|
fn get_script_count(&self) -> usize;
|
|
|
|
fn get_script_source_data(&self) -> &RwLock<ScriptSourceData>;
|
|
|
|
fn get_own_scripts(&self, scripts: &mut Vec<ScriptWrapper>);
|
|
|
|
fn collect_scripts(&self, scripts: &mut Vec<ScriptWrapper>);
|
2022-06-03 14:35:18 +00:00
|
|
|
}
|
|
|
|
|
2022-06-12 16:41:49 +00:00
|
|
|
#[derive(Debug)]
|
2022-06-06 11:54:59 +00:00
|
|
|
pub enum ScriptWrapper {
|
2022-06-12 15:57:39 +00:00
|
|
|
Script(Weak<RwLock<Option<Box<dyn Script>>>>),
|
|
|
|
Set(Weak<RwLock<ScriptSet>>),
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<&ScriptContainer> for ScriptWrapper {
|
|
|
|
fn from(c: &ScriptContainer) -> Self {
|
|
|
|
ScriptWrapper::Script(Arc::downgrade(c.arc()))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<&Arc<RwLock<ScriptSet>>> for ScriptWrapper {
|
|
|
|
fn from(c: &Arc<RwLock<ScriptSet>>) -> Self {
|
|
|
|
ScriptWrapper::Set(Arc::downgrade(c))
|
|
|
|
}
|
2022-06-03 14:35:18 +00:00
|
|
|
}
|
|
|
|
|
2022-06-06 11:54:59 +00:00
|
|
|
pub struct ScriptAggregator {
|
2022-06-12 15:57:39 +00:00
|
|
|
scripts: *const Vec<ScriptWrapper>,
|
2022-06-03 14:35:18 +00:00
|
|
|
size: i32,
|
|
|
|
index: i32,
|
|
|
|
set_index: i32,
|
|
|
|
}
|
|
|
|
|
2022-06-06 11:54:59 +00:00
|
|
|
impl ScriptAggregator {
|
2022-06-12 15:57:39 +00:00
|
|
|
pub fn new(scripts: *const Vec<ScriptWrapper>) -> Self {
|
|
|
|
unsafe {
|
|
|
|
let len = scripts.as_ref().unwrap().len();
|
|
|
|
Self {
|
|
|
|
scripts,
|
|
|
|
size: len as i32,
|
|
|
|
index: -1,
|
|
|
|
set_index: -1,
|
|
|
|
}
|
2022-06-03 14:35:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn increment_to_next_value(&mut self) -> bool {
|
|
|
|
if self.index != -1 {
|
2022-06-12 15:57:39 +00:00
|
|
|
let wrapper = unsafe { &self.scripts.as_ref().unwrap()[self.index as usize] };
|
|
|
|
if let ScriptWrapper::Set(set) = wrapper {
|
|
|
|
if let Some(set) = set.upgrade() {
|
|
|
|
self.set_index += 1;
|
|
|
|
if self.set_index as usize >= set.read().count() {
|
|
|
|
self.set_index = -1;
|
|
|
|
} else {
|
|
|
|
return true;
|
2022-06-03 14:35:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
self.index += 1;
|
|
|
|
for index in self.index..self.size {
|
|
|
|
self.index = index;
|
2022-06-12 15:57:39 +00:00
|
|
|
let wrapper = unsafe { &self.scripts.as_ref().unwrap()[self.index as usize] };
|
|
|
|
if let ScriptWrapper::Set(s) = wrapper {
|
|
|
|
if let Some(..) = s.upgrade() {
|
|
|
|
self.set_index = 0;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
} else if let ScriptWrapper::Script(script) = wrapper {
|
|
|
|
if let Some(v) = script.upgrade() {
|
|
|
|
if let Some(..) = v.read().as_ref() {
|
2022-06-06 11:54:59 +00:00
|
|
|
return true;
|
|
|
|
}
|
2022-06-03 14:35:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
false
|
|
|
|
}
|
|
|
|
|
2022-06-12 15:57:39 +00:00
|
|
|
pub fn get_next(&mut self) -> Option<ScriptContainer> {
|
2022-06-03 14:35:18 +00:00
|
|
|
if !self.increment_to_next_value() {
|
|
|
|
return None;
|
|
|
|
}
|
2022-06-12 15:57:39 +00:00
|
|
|
unsafe {
|
|
|
|
return match &self.scripts.as_ref().unwrap()[self.index as usize] {
|
|
|
|
// increment_to_next_value
|
|
|
|
ScriptWrapper::Script(script) => Some(script.upgrade().unwrap().into()),
|
|
|
|
ScriptWrapper::Set(set) => {
|
|
|
|
let lock = set.as_ptr().as_ref().unwrap();
|
|
|
|
let l = lock.read();
|
|
|
|
let sc = l.at(self.set_index as usize);
|
|
|
|
return Some(sc.clone());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn reset(&mut self) {
|
|
|
|
self.index = -1;
|
|
|
|
self.set_index = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
|
|
|
use crate::dynamic_data::script_handling::script::ScriptContainer;
|
|
|
|
use crate::static_data::EffectParameter;
|
|
|
|
use crate::StringKey;
|
|
|
|
use std::any::Any;
|
|
|
|
|
|
|
|
pub struct TestScript {
|
|
|
|
name: StringKey,
|
|
|
|
test_count: usize,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl TestScript {
|
|
|
|
fn new() -> Self {
|
|
|
|
Self {
|
|
|
|
name: StringKey::new("test"),
|
|
|
|
test_count: 0,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fn new_with_name(name: &str) -> Self {
|
|
|
|
Self {
|
|
|
|
name: StringKey::new(name),
|
|
|
|
test_count: 0,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Script for TestScript {
|
|
|
|
fn name(&self) -> &StringKey {
|
|
|
|
&self.name
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_suppressed_count(&self) -> usize {
|
|
|
|
0
|
|
|
|
}
|
|
|
|
|
2022-06-12 17:04:22 +00:00
|
|
|
fn add_suppression(&mut self) {}
|
2022-06-12 15:57:39 +00:00
|
|
|
|
2022-06-12 17:04:22 +00:00
|
|
|
fn remove_suppression(&mut self) {}
|
2022-06-12 15:57:39 +00:00
|
|
|
|
|
|
|
fn on_initialize(&mut self, _pars: &[EffectParameter]) {
|
|
|
|
self.test_count += 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
fn as_any(&self) -> &dyn Any {
|
|
|
|
self
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn script_aggregator_property_iterates_single_script() {
|
|
|
|
let script = ScriptContainer::new(Box::new(TestScript::new()));
|
|
|
|
let scripts = vec![ScriptWrapper::from(&script)];
|
|
|
|
let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
|
|
|
|
while let Some(v) = aggregator.get_next() {
|
|
|
|
v.get().as_mut().unwrap().on_initialize(&[]);
|
|
|
|
}
|
|
|
|
let a = script.get_as::<TestScript>();
|
|
|
|
assert_eq!(a.test_count, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn script_aggregator_property_iterates_single_script_with_resets() {
|
|
|
|
let script = ScriptContainer::new(Box::new(TestScript::new()));
|
|
|
|
let scripts = vec![ScriptWrapper::from(&script)];
|
|
|
|
let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
|
|
|
|
for i in 1..11 {
|
|
|
|
aggregator.reset();
|
|
|
|
while let Some(v) = aggregator.get_next() {
|
|
|
|
v.get().as_mut().unwrap().on_initialize(&[]);
|
|
|
|
}
|
|
|
|
let a = script.get_as::<TestScript>();
|
|
|
|
assert_eq!(a.test_count, i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn script_aggregator_property_iterates_three_script() {
|
|
|
|
let script1 = ScriptContainer::new(Box::new(TestScript::new()));
|
|
|
|
let script2 = ScriptContainer::new(Box::new(TestScript::new()));
|
|
|
|
let script3 = ScriptContainer::new(Box::new(TestScript::new()));
|
|
|
|
let scripts = vec![
|
|
|
|
ScriptWrapper::from(&script1),
|
|
|
|
ScriptWrapper::from(&script2),
|
|
|
|
ScriptWrapper::from(&script3),
|
|
|
|
];
|
|
|
|
let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
|
|
|
|
while let Some(v) = aggregator.get_next() {
|
|
|
|
v.get().as_mut().unwrap().on_initialize(&[]);
|
|
|
|
}
|
|
|
|
let a = script1.get_as::<TestScript>();
|
|
|
|
assert_eq!(a.test_count, 1);
|
|
|
|
let a = script2.get_as::<TestScript>();
|
|
|
|
assert_eq!(a.test_count, 1);
|
|
|
|
let a = script3.get_as::<TestScript>();
|
|
|
|
assert_eq!(a.test_count, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn script_aggregator_property_iterates_three_script_with_resets() {
|
|
|
|
let script1 = ScriptContainer::new(Box::new(TestScript::new()));
|
|
|
|
let script2 = ScriptContainer::new(Box::new(TestScript::new()));
|
|
|
|
let script3 = ScriptContainer::new(Box::new(TestScript::new()));
|
|
|
|
let scripts = vec![
|
|
|
|
ScriptWrapper::from(&script1),
|
|
|
|
ScriptWrapper::from(&script2),
|
|
|
|
ScriptWrapper::from(&script3),
|
|
|
|
];
|
|
|
|
let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
|
|
|
|
for i in 1..11 {
|
|
|
|
aggregator.reset();
|
|
|
|
while let Some(v) = aggregator.get_next() {
|
|
|
|
v.get().as_mut().unwrap().on_initialize(&[]);
|
|
|
|
}
|
|
|
|
let a = script1.get_as::<TestScript>();
|
|
|
|
assert_eq!(a.test_count, i);
|
|
|
|
let a = script2.get_as::<TestScript>();
|
|
|
|
assert_eq!(a.test_count, i);
|
|
|
|
let a = script3.get_as::<TestScript>();
|
|
|
|
assert_eq!(a.test_count, i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn script_aggregator_property_iterates_script_set() {
|
|
|
|
let set = Arc::new(RwLock::new(ScriptSet::default()));
|
|
|
|
let mut mut_set = set.write();
|
|
|
|
mut_set.add(Box::new(TestScript::new_with_name("test_a")));
|
|
|
|
mut_set.add(Box::new(TestScript::new_with_name("test_b")));
|
|
|
|
mut_set.add(Box::new(TestScript::new_with_name("test_c")));
|
|
|
|
// Drop so we don't have a lock on it anymore.
|
|
|
|
drop(mut_set);
|
|
|
|
|
|
|
|
let scripts = vec![ScriptWrapper::from(&set)];
|
|
|
|
let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
|
|
|
|
for i in 1..11 {
|
|
|
|
aggregator.reset();
|
|
|
|
while let Some(v) = aggregator.get_next() {
|
|
|
|
v.get().as_mut().unwrap().on_initialize(&[]);
|
|
|
|
}
|
|
|
|
let set = set.read();
|
|
|
|
let s = set.at(0).get_as::<TestScript>();
|
|
|
|
assert_eq!(s.test_count, i);
|
|
|
|
assert_eq!(s.name().str(), "test_a");
|
|
|
|
let s = set.at(1).get_as::<TestScript>();
|
|
|
|
assert_eq!(s.test_count, i);
|
|
|
|
assert_eq!(s.name().str(), "test_b");
|
|
|
|
let s = set.at(2).get_as::<TestScript>();
|
|
|
|
assert_eq!(s.test_count, i);
|
|
|
|
assert_eq!(s.name().str(), "test_c");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn script_aggregator_property_iterates_script_set_when_removing_last() {
|
|
|
|
let set = Arc::new(RwLock::new(ScriptSet::default()));
|
|
|
|
let mut mut_set = set.write();
|
|
|
|
mut_set.add(Box::new(TestScript::new_with_name("test_a")));
|
|
|
|
mut_set.add(Box::new(TestScript::new_with_name("test_b")));
|
|
|
|
mut_set.add(Box::new(TestScript::new_with_name("test_c")));
|
|
|
|
// Drop so we don't have a lock on it anymore.
|
|
|
|
drop(mut_set);
|
|
|
|
|
|
|
|
let scripts = vec![ScriptWrapper::from(&set)];
|
|
|
|
let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
|
|
|
|
assert_eq!(
|
2022-06-16 15:59:33 +00:00
|
|
|
aggregator.get_next().unwrap().get().as_mut().unwrap().name().str(),
|
2022-06-12 15:57:39 +00:00
|
|
|
"test_a"
|
|
|
|
);
|
|
|
|
assert_eq!(
|
2022-06-16 15:59:33 +00:00
|
|
|
aggregator.get_next().unwrap().get().as_mut().unwrap().name().str(),
|
2022-06-12 15:57:39 +00:00
|
|
|
"test_b"
|
|
|
|
);
|
|
|
|
|
|
|
|
let mut mut_set = set.write();
|
|
|
|
mut_set.remove(&StringKey::new("test_c"));
|
|
|
|
drop(mut_set);
|
|
|
|
|
|
|
|
assert!(aggregator.get_next().is_none());
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn script_aggregator_property_iterates_script_set_when_removing_middle() {
|
|
|
|
let set = Arc::new(RwLock::new(ScriptSet::default()));
|
|
|
|
let mut mut_set = set.write();
|
|
|
|
mut_set.add(Box::new(TestScript::new_with_name("test_a")));
|
|
|
|
mut_set.add(Box::new(TestScript::new_with_name("test_b")));
|
|
|
|
mut_set.add(Box::new(TestScript::new_with_name("test_c")));
|
|
|
|
// Drop so we don't have a lock on it anymore.
|
|
|
|
drop(mut_set);
|
|
|
|
|
|
|
|
let scripts = vec![ScriptWrapper::from(&set)];
|
|
|
|
let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
|
|
|
|
assert_eq!(
|
2022-06-16 15:59:33 +00:00
|
|
|
aggregator.get_next().unwrap().get().as_mut().unwrap().name().str(),
|
2022-06-12 15:57:39 +00:00
|
|
|
"test_a"
|
|
|
|
);
|
|
|
|
|
|
|
|
let mut mut_set = set.write();
|
|
|
|
mut_set.remove(&StringKey::new("test_b"));
|
|
|
|
drop(mut_set);
|
|
|
|
|
|
|
|
assert_eq!(
|
2022-06-16 15:59:33 +00:00
|
|
|
aggregator.get_next().unwrap().get().as_mut().unwrap().name().str(),
|
2022-06-12 15:57:39 +00:00
|
|
|
"test_c"
|
|
|
|
);
|
|
|
|
assert!(aggregator.get_next().is_none());
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct TestScriptSource {
|
|
|
|
pub data: RwLock<ScriptSourceData>,
|
|
|
|
pub script: ScriptContainer,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> ScriptSource<'a> for TestScriptSource {
|
|
|
|
fn get_script_count(&self) -> usize {
|
|
|
|
1
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_script_source_data(&self) -> &RwLock<ScriptSourceData> {
|
|
|
|
&self.data
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_own_scripts(&self, scripts: &mut Vec<ScriptWrapper>) {
|
|
|
|
scripts.push((&self.script).into());
|
|
|
|
}
|
|
|
|
|
|
|
|
fn collect_scripts(&self, scripts: &mut Vec<ScriptWrapper>) {
|
|
|
|
self.get_own_scripts(scripts);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn script_source_set_script_then_rerun() {
|
|
|
|
let source = TestScriptSource {
|
|
|
|
data: RwLock::new(ScriptSourceData::default()),
|
|
|
|
script: ScriptContainer::default(),
|
2022-06-03 14:35:18 +00:00
|
|
|
};
|
2022-06-12 15:57:39 +00:00
|
|
|
|
|
|
|
let mut aggregator = source.get_script_iterator();
|
|
|
|
aggregator.reset();
|
|
|
|
assert!(aggregator.get_next().is_none());
|
|
|
|
aggregator.reset();
|
|
|
|
source.script.set(Box::new(TestScript::new()));
|
|
|
|
assert!(aggregator.get_next().is_some());
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn script_source_clear_script_then_rerun() {
|
|
|
|
let source = TestScriptSource {
|
|
|
|
data: RwLock::new(ScriptSourceData::default()),
|
|
|
|
script: ScriptContainer::default(),
|
|
|
|
};
|
|
|
|
|
|
|
|
let mut aggregator = source.get_script_iterator();
|
|
|
|
source.script.set(Box::new(TestScript::new()));
|
|
|
|
assert!(aggregator.get_next().is_some());
|
|
|
|
aggregator.reset();
|
|
|
|
source.script.clear();
|
|
|
|
assert!(aggregator.get_next().is_none());
|
2022-06-03 14:35:18 +00:00
|
|
|
}
|
|
|
|
}
|