129 lines
3.6 KiB
Rust
129 lines
3.6 KiB
Rust
use std::io;
|
|
|
|
use bevy::{
|
|
asset::{
|
|
AssetLoader, AssetPath, AsyncReadExt, AsyncWriteExt, LoadContext,
|
|
io::{Reader, Writer},
|
|
processor::LoadTransformAndSave,
|
|
saver::{AssetSaver, SavedAsset},
|
|
transformer::{AssetTransformer, TransformedAsset},
|
|
},
|
|
prelude::*,
|
|
};
|
|
|
|
use crate::scripting::{FighterAttackScript, move_compiler};
|
|
|
|
#[derive(Default, TypePath)]
|
|
struct FighterAttackScriptSourceLoader;
|
|
|
|
#[derive(Asset, TypePath)]
|
|
struct FighterAttackScriptContents(String);
|
|
|
|
impl AssetLoader for FighterAttackScriptSourceLoader {
|
|
type Asset = FighterAttackScriptContents;
|
|
type Settings = ();
|
|
type Error = io::Error;
|
|
|
|
async fn load(
|
|
&self,
|
|
reader: &mut dyn Reader,
|
|
_: &Self::Settings,
|
|
_: &mut LoadContext<'_>,
|
|
) -> Result<Self::Asset, Self::Error> {
|
|
let mut contents = String::default();
|
|
reader.read_to_string(&mut contents).await?;
|
|
Ok(FighterAttackScriptContents(contents))
|
|
}
|
|
|
|
fn extensions(&self) -> &[&str] {
|
|
&["attack.rhai"]
|
|
}
|
|
}
|
|
|
|
#[derive(Default, TypePath)]
|
|
struct FighterAttackScriptTransformer;
|
|
|
|
impl AssetTransformer for FighterAttackScriptTransformer {
|
|
type AssetInput = FighterAttackScriptContents;
|
|
type AssetOutput = FighterAttackScript;
|
|
type Settings = ();
|
|
type Error = String;
|
|
|
|
async fn transform<'a>(
|
|
&'a self,
|
|
source: TransformedAsset<Self::AssetInput>,
|
|
_: &'a Self::Settings,
|
|
) -> Result<TransformedAsset<Self::AssetOutput>, Self::Error> {
|
|
let output = move_compiler::compile_script(&source.0)?;
|
|
Ok(source.replace_asset(output))
|
|
}
|
|
}
|
|
|
|
#[derive(Default, TypePath)]
|
|
struct FighterAttackScriptLoader;
|
|
|
|
impl AssetLoader for FighterAttackScriptLoader {
|
|
type Asset = FighterAttackScript;
|
|
type Settings = ();
|
|
type Error = io::Error;
|
|
|
|
async fn load(
|
|
&self,
|
|
reader: &mut dyn Reader,
|
|
_: &Self::Settings,
|
|
_: &mut LoadContext<'_>,
|
|
) -> Result<Self::Asset, Self::Error> {
|
|
let mut bytes = Vec::new();
|
|
reader.read_to_end(&mut bytes).await?;
|
|
bincode::deserialize(&bytes)
|
|
.map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))
|
|
}
|
|
|
|
fn extensions(&self) -> &[&str] {
|
|
&["attack.rhai"]
|
|
}
|
|
}
|
|
|
|
#[derive(Default, TypePath)]
|
|
struct FighterAttackScriptSaver;
|
|
|
|
impl AssetSaver for FighterAttackScriptSaver {
|
|
type Asset = FighterAttackScript;
|
|
type Settings = ();
|
|
type OutputLoader = FighterAttackScriptLoader;
|
|
type Error = io::Error;
|
|
|
|
async fn save(
|
|
&self,
|
|
writer: &mut Writer,
|
|
asset: SavedAsset<'_, '_, Self::Asset>,
|
|
_: &Self::Settings,
|
|
_: AssetPath<'_>,
|
|
) -> Result<(), Self::Error> {
|
|
let bytes = bincode::serialize(&*asset)
|
|
.map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
|
|
writer.write_all(&bytes).await
|
|
}
|
|
}
|
|
|
|
type FighterAttackScriptProcessor = LoadTransformAndSave<
|
|
FighterAttackScriptSourceLoader,
|
|
FighterAttackScriptTransformer,
|
|
FighterAttackScriptSaver,
|
|
>;
|
|
|
|
pub struct FighterScriptImportPlugin;
|
|
|
|
impl Plugin for FighterScriptImportPlugin {
|
|
fn build(&self, app: &mut App) {
|
|
app.init_asset::<FighterAttackScript>()
|
|
.register_asset_loader(FighterAttackScriptSourceLoader)
|
|
.register_asset_loader(FighterAttackScriptLoader)
|
|
.register_asset_processor(FighterAttackScriptProcessor::new(
|
|
FighterAttackScriptTransformer,
|
|
FighterAttackScriptSaver,
|
|
))
|
|
.set_default_asset_processor::<FighterAttackScriptProcessor>("attack.rhai");
|
|
}
|
|
}
|