games
/
acts-of-gods
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

we got tests passing!

Browse Source 
Adding components to save files is a pain, but hopefully a one-time cost.
attempt/001
Elijah Voigt 1 year ago
parent e8b15c80c1
commit 7947be5cfb
3 changed files with 292 additions and 211 deletions
Show Stats Download Patch File Download Diff File

1
shell.nix
Unescape Escape View File

@ -21,6 +21,7 @@ mkShell rec {
udev # Audio?
vulkan-loader # Rendering
xorg.libX11 xorg.libXcursor xorg.libXi xorg.libXrandr # To use the x11 feature
tmux # Sharing environemnt between editor and terminal
];
LD_LIBRARY_PATH = lib.makeLibraryPath buildInputs;

471
src/parser.rs
Unescape Escape View File

@ -1,252 +1,254 @@
use nom::character::complete::hex_digit1;
use crate::prelude::*;
#[derive(Error, Debug)]
pub(crate) enum SaveEntityParseError {
#[error("Failed to parse Uuid: {0}")]
Uuid(#[from] uuid::Error),
#[error("Failed to parse name")]
Name,
#[error("Failed to parse Transform")]
Transform,
#[error("Failed to parse Entity")]
Nom(nom::Err<nom::error::Error<Box<str>>>),
#[error("Failed to parse camera")]
Camera,
#[error("Failed to parse Uuid: {0}")]
Uuid(#[from] uuid::Error),
#[error("Failed to parse name")]
Name,
#[error("Failed to parse Transform")]
Transform,
#[error("Failed to parse Entity")]
Nom(nom::Err<nom::error::Error<Box<str>>>),
#[error("Failed to parse camera")]
Camera,
#[error("Failed to parse marker component")]
Marker,
}
// Convert Nom error to parse error
// https://stackoverflow.com/a/77974858/3096574
impl From<nom::Err<nom::error::Error<&str>>> for SaveEntityParseError {
fn from(err: nom::Err<nom::error::Error<&str>>) -> Self {
SaveEntityParseError::Nom(err.map_input(|input| input.into()))
}
fn from(err: nom::Err<nom::error::Error<&str>>) -> Self {
SaveEntityParseError::Nom(err.map_input(|input| input.into()))
}
}
fn parse_word<'a>(w: &'a str) -> impl Fn(&'a str) -> IResult<&'a str, &'a str> {
move |i: &'a str| tag(w)(i)
fn parse_bool(i: &str) -> IResult<&str, bool> {
alt((tag("true"), tag("false")))(i).map(|(s, val)| match val {
"true" => (s, true),
"false" => (s, false),
_ => panic!("Bools must be `true` or `false`!"),
})
}
fn parse_xyz(i: &str) -> IResult<&str, (f32, f32, f32)> {
tuple((float, space1, float, space1, float))(i)
.map(|(s, (x, _, y, _, z))| (s, (x, y, z)))
tuple((float, space1, float, space1, float))(i).map(|(s, (x, _, y, _, z))| (s, (x, y, z)))
}
fn parse_wxyz(i: &str) -> IResult<&str, (f32, f32, f32, f32)> {
tuple((
float,
space1,
float,
space1,
float,
space1,
float,
))(i)
.map(|(s, (w, _, x, _, y, _, z))| (s, (w, x, y, z)))
tuple((float, space1, float, space1, float, space1, float))(i)
.map(|(s, (w, _, x, _, y, _, z))| (s, (w, x, y, z)))
}
fn parse_string(i: &str) -> IResult<&str, &str> {
let (rem, (_, out, _)) = tuple((tag("\""), take_until1("\""), tag("\"")))(i)?;
Ok((rem, out))
let (rem, (_, out, _)) = tuple((tag("\""), take_until1("\""), tag("\"")))(i)?;
Ok((rem, out))
}
///
///
pub(crate) fn parse_save_transform(line: &str) -> Result<Transform, SaveEntityParseError> {
let (rem, _) = tag("transform")(line)?;
let mut transform = Transform::default();
let mut curr = rem.trim_start();
for _ in 0..3 {
if let Ok((rem, (_, _, (x, y, z)))) = tuple((parse_word("translation"), space1, parse_xyz))(curr.trim_start()) {
transform.translation = Vec3::new(x, y, z);
curr = rem.trim_start();
} else if let Ok((rem, (_, _, (x, y, z, w)))) = tuple((parse_word("rotation"), space1, parse_wxyz))(curr.trim_start()) {
transform.rotation = Quat::from_xyzw(x, y, z, w);
curr = rem.trim_start();
} else if let Ok((rem, (_, _, (x, y, z)))) = tuple((parse_word("scale"), space1, parse_xyz))(curr.trim_start()) {
transform.scale = Vec3::new(x, y, z);
curr = rem.trim_start();
} else {
return Err(SaveEntityParseError::Transform);
}
}
// Assert there are no trailing characters on the line
debug_assert_eq!(curr, "");
Ok(transform)
let (rem, _) = tag("transform")(line)?;
let mut transform = Transform::default();
let mut curr = rem.trim_start();
for _ in 0..3 {
if let Ok((rem, (_, _, (x, y, z)))) =
tuple((tag("translation"), space1, parse_xyz))(curr.trim_start())
{
transform.translation = Vec3::new(x, y, z);
curr = rem.trim_start();
} else if let Ok((rem, (_, _, (x, y, z, w)))) =
tuple((tag("rotation"), space1, parse_wxyz))(curr.trim_start())
{
transform.rotation = Quat::from_xyzw(x, y, z, w);
curr = rem.trim_start();
} else if let Ok((rem, (_, _, (x, y, z)))) =
tuple((tag("scale"), space1, parse_xyz))(curr.trim_start())
{
transform.scale = Vec3::new(x, y, z);
curr = rem.trim_start();
} else {
return Err(SaveEntityParseError::Transform);
}
}
// Assert there are no trailing characters on the line
debug_assert_eq!(curr, "");
Ok(transform)
}
#[test]
fn test_parse_transform() {
let line = "transform translation 1.0 2.0 3.0 rotation 0.1 0.2 0.3 1.0 scale 1.1 1.2 1.3";
let parsed = parse_save_transform(line).unwrap();
let expected = Transform {
translation: Vec3::new(1.0, 2.0, 3.0),
rotation: Quat::from_xyzw(0.1, 0.2, 0.3, 1.0),
scale: Vec3::new(1.1, 1.2, 1.3),
};
assert_eq!(parsed, expected);
let line = "transform translation 1.0 2.0 3.0 rotation 0.1 0.2 0.3 1.0 scale 1.1 1.2 1.3";
let parsed = parse_save_transform(line).unwrap();
let expected = Transform {
translation: Vec3::new(1.0, 2.0, 3.0),
rotation: Quat::from_xyzw(0.1, 0.2, 0.3, 1.0),
scale: Vec3::new(1.1, 1.2, 1.3),
};
assert_eq!(parsed, expected);
}
///
///
pub(crate) fn parse_save_name(line: &str) -> Result<Name, SaveEntityParseError> {
let (remainder, _) = tag("name")(line)?;
let n = remainder.trim().to_string();
if n.is_empty() {
Err(SaveEntityParseError::Name)
} else {
let name = Name::new(n);
Ok(name)
}
let (remainder, _) = tag("name")(line)?;
let n = remainder.trim().to_string();
if n.is_empty() {
Err(SaveEntityParseError::Name)
} else {
let name = Name::new(n);
Ok(name)
}
}
#[test]
fn test_parse_name() {
{
let line = "name Van";
let parsed = parse_save_name(line).unwrap();
let expected = Name::new("Van");
assert_eq!(parsed, expected);
}
{
let line = "name Big Mike";
let parsed = parse_save_name(line).unwrap();
let expected = Name::new("Big Mike");
assert_eq!(parsed, expected);
}
{
let line = "name Van";
let parsed = parse_save_name(line).unwrap();
let expected = Name::new("Van");
assert_eq!(parsed, expected);
}
{
let line = "name Big Mike";
let parsed = parse_save_name(line).unwrap();
let expected = Name::new("Big Mike");
assert_eq!(parsed, expected);
}
}
#[derive(Component, Clone, Debug, Reflect, PartialEq)]
#[reflect(Component)]
pub(crate) struct EntityUuid {
id: String
id: String,
}
///
///
pub(crate) fn parse_save_uuid(line: &str) -> Result<EntityUuid, SaveEntityParseError> {
let (remainder, _) = tag("uuid")(line)?;
let id = remainder.trim().into();
Ok(EntityUuid { id })
let (remainder, _) = tag("uuid")(line)?;
let id = remainder.trim().into();
Ok(EntityUuid { id })
}
#[test]
fn test_parse_uuid() {
let line = "uuid 1c16ab9a-5f79-4340-8469-4086f69c64f2";
let parsed = parse_save_uuid(line).unwrap();
let expected = EntityUuid { id: "1c16ab9a-5f79-4340-8469-4086f69c64f2".into() };
let line = "uuid 1c16ab9a-5f79-4340-8469-4086f69c64f2";
let parsed = parse_save_uuid(line).unwrap();
let expected = EntityUuid {
id: "1c16ab9a-5f79-4340-8469-4086f69c64f2".into(),
};
assert_eq!(parsed, expected);
assert_eq!(parsed, expected);
}
///
///
///
pub(crate) fn parse_save_model(line: &str) -> Result<(String, String), SaveEntityParseError> {
let (rem, (_, _, gltf_path, _, scene_name)) = tuple((
tag("model"),
space1,
parse_string,
space1,
parse_string,
))(line)?;
let (rem, (_, _, gltf_path, _, scene_name)) =
tuple((tag("model"), space1, parse_string, space1, parse_string))(line)?;
debug_assert!(rem == "");
debug_assert!(rem == "");
Ok((gltf_path.into(), scene_name.into()))
Ok((gltf_path.into(), scene_name.into()))
}
#[test]
fn test_parse_model() {
let line = "model \"models/foo.glb\" \"My Scene\"";
let parsed = parse_save_model(line).unwrap();
let expected = (String::from("models/foo.glb"), String::from("My Scene"));
let line = "model \"models/foo.glb\" \"My Scene\"";
let parsed = parse_save_model(line).unwrap();
let expected = (String::from("models/foo.glb"), String::from("My Scene"));
assert_eq!(parsed, expected);
assert_eq!(parsed, expected);
}
#[derive(Component, Debug, Default, PartialEq, Reflect, Clone)]
#[reflect_value(Component, Default)]
pub(crate) enum SaveCameraRenderTarget {
#[default]
Default,
Window(Uuid),
#[default]
Default,
Window(Uuid),
}
pub(crate) fn parse_save_camera(line: &str) -> Result<SaveCameraRenderTarget, SaveEntityParseError> {
if let Ok((rem, _camera)) = tag::<&str, &str, ()>("camera")(line) {
if let Ok((rem, (_, _target))) = tuple((space1::<&str, ()>, tag("target")))(rem) {
if let Ok((rem, (_, _window))) = tuple((space1::<&str, ()>, tag("window")))(rem) {
// Camera + target + window + UUID
if let Ok((rem, (_, uuid))) = tuple((space1::<&str, ()>, take(36usize)))(rem) {
debug_assert!(rem == "");
let parsed_uuid = Uuid::parse_str(uuid)?;
Ok(SaveCameraRenderTarget::Window(parsed_uuid))
// Camera + target + widow
} else {
debug_assert!(rem == "");
Ok(SaveCameraRenderTarget::Default)
}
// camera + target
} else {
debug_assert!(rem == "");
Err(SaveEntityParseError::Camera)
}
// Just camera
} else {
debug_assert!(rem == "");
Ok(SaveCameraRenderTarget::Default)
}
// Nothing parsed well
} else {
Err(SaveEntityParseError::Camera)
}
pub(crate) fn parse_save_camera(
line: &str,
) -> Result<SaveCameraRenderTarget, SaveEntityParseError> {
if let Ok((rem, _camera)) = tag::<&str, &str, ()>("camera")(line) {
if let Ok((rem, (_, _target))) = tuple((space1::<&str, ()>, tag("target")))(rem) {
if let Ok((rem, (_, _window))) = tuple((space1::<&str, ()>, tag("window")))(rem) {
// Camera + target + window + UUID
if let Ok((rem, (_, uuid))) = tuple((space1::<&str, ()>, take(36usize)))(rem) {
debug_assert!(rem == "");
let parsed_uuid = Uuid::parse_str(uuid)?;
Ok(SaveCameraRenderTarget::Window(parsed_uuid))
// Camera + target + widow
} else {
debug_assert!(rem == "");
Ok(SaveCameraRenderTarget::Default)
}
// camera + target
} else {
debug_assert!(rem == "");
Err(SaveEntityParseError::Camera)
}
// Just camera
} else {
debug_assert!(rem == "");
Ok(SaveCameraRenderTarget::Default)
}
// Nothing parsed well
} else {
Err(SaveEntityParseError::Camera)
}
}
#[test]
fn test_parse_camera() {
{
let line = "camera";
let parsed = parse_save_camera(line).unwrap();
let expected = SaveCameraRenderTarget::Default;
assert_eq!(parsed, expected);
}
{
let line = "camera target window";
let parsed = parse_save_camera(line).unwrap();
let expected = SaveCameraRenderTarget::Default;
assert_eq!(parsed, expected);
}
{
let line = "camera target";
let parsed = parse_save_camera(line);
assert!(parsed.is_err());
}
{
let line = "camera target window 9a1367e0-71e5-4c79-b4ad-02aa44b68af0";
let target_uuid = Uuid::parse_str("9a1367e0-71e5-4c79-b4ad-02aa44b68af0").unwrap();
let parsed = parse_save_camera(line).unwrap();
let expected = SaveCameraRenderTarget::Window(target_uuid);
assert_eq!(parsed, expected);
}
{
let line = "notcamera";
let parsed = parse_save_camera(line);
assert!(parsed.is_err());
}
{
let line = "camera";
let parsed = parse_save_camera(line).unwrap();
let expected = SaveCameraRenderTarget::Default;
assert_eq!(parsed, expected);
}
{
let line = "camera target window";
let parsed = parse_save_camera(line).unwrap();
let expected = SaveCameraRenderTarget::Default;
assert_eq!(parsed, expected);
}
{
let line = "camera target";
let parsed = parse_save_camera(line);
assert!(parsed.is_err());
}
{
let line = "camera target window 9a1367e0-71e5-4c79-b4ad-02aa44b68af0";
let target_uuid = Uuid::parse_str("9a1367e0-71e5-4c79-b4ad-02aa44b68af0").unwrap();
let parsed = parse_save_camera(line).unwrap();
let expected = SaveCameraRenderTarget::Window(target_uuid);
assert_eq!(parsed, expected);
}
{
let line = "notcamera";
let parsed = parse_save_camera(line);
assert!(parsed.is_err());
}
}
/// SaveParent entity which is a reference to which entity this is a child of
/// A run-time system converts this to a bevy Parent component
#[derive(Component, PartialEq, Debug, Reflect, Clone)]
@ -258,58 +260,121 @@ pub(crate) struct SaveParent(String);
/// parent some_other_file.entity
/// ```
pub(crate) fn parse_save_parent(line: &str) -> Result<SaveParent, SaveEntityParseError> {
todo!()
let (rem, (_, _, parent_file)) = tuple((tag("parent"), space1, parse_string))(line)?;
debug_assert!(rem.is_empty());
Ok(SaveParent(parent_file.into()))
}
#[test]
fn test_parse_parent() {
let line = "parent some_other_file.entity";
let parsed = parse_save_parent(line).unwrap();
let expected = SaveParent("some_other_file.entity".into());
assert_eq!(parsed, expected);
let line = "parent \"some_other_file.entity\"";
let parsed = parse_save_parent(line).unwrap();
let expected = SaveParent("some_other_file.entity".into());
assert_eq!(parsed, expected);
}
///
/// Parse the Window component (which is very big!)
/// We only sparsely define the bits that we want to edit (for now)
///
///
pub(crate) fn parse_save_window(line: &str) -> Result<Window, SaveEntityParseError> {
todo!()
let (rem, (_, _, window_title)) = tuple((tag("window"), space1, parse_string))(line)?;
let (rem, (_, _, _, visibility)) = tuple((space1, tag("visible"), space1, parse_bool))(rem)?;
debug_assert!(rem.is_empty());
Ok(Window {
title: window_title.into(),
visible: visibility,
..default()
})
}
#[test]
fn test_parse_window() {
let line = "window \"Editor\" visible false";
let parsed = parse_save_window(line).unwrap();
let expected = Window { visible: false, title: "Editor".into(), ..default() };
assert_eq!(parsed.visible, expected.visible);
assert_eq!(parsed.title, expected.title);
let line = "window \"Editor\" visible false";
let parsed = parse_save_window(line).unwrap();
let expected = Window {
visible: false,
title: "Editor".into(),
..default()
};
assert_eq!(parsed.visible, expected.visible);
assert_eq!(parsed.title, expected.title);
}
///
/// The UI Text bundle specified as a sparse subset of a bundle
///
/// ```text
/// text "This is the text" color #abc123 size 12.34
/// ```
pub(crate) fn parse_save_ui_text(line: &str) -> Result<TextBundle, SaveEntityParseError> {
todo!()
let (rem, (_tag_text, _space1, text)) = tuple((tag("text"), space1, parse_string))(line)?;
let (rem, (_space, _tag_color, _space1, _hash, hex_color)) =
tuple((space1, tag("color"), space1, char('#'), hex_digit1))(rem)?;
let (rem, (_space, _tag_size, _space1, font_size)) =
tuple((space1, tag("size"), space1, float))(rem)?;
debug_assert!(rem.is_empty());
let style = TextStyle {
color: Color::Srgba(Srgba::hex(hex_color).unwrap()),
font_size,
..default()
};
Ok(TextBundle {
text: Text::from_section(text, style),
..default()
})
}
#[test]
fn test_save_ui_text() {
todo!()
let line = "text \"This is the text\" color #caffee size 14.6";
let parsed = parse_save_ui_text(line).unwrap();
let expected = Text::from_section(
"This is the text",
TextStyle {
color: Srgba::hex("#caffee").unwrap().into(),
font_size: 14.6,
..default()
},
);
assert_eq!(parsed.text.sections[0].value, expected.sections[0].value);
assert_eq!(
parsed.text.sections[0].style.color,
expected.sections[0].style.color,
);
assert_eq!(
parsed.text.sections[0].style.font_size,
expected.sections[0].style.font_size,
);
}
///
/// Returns a parser function for a basic stand-alone tag
/// e.g., "editor_tag" or "ui_node"
pub(crate) fn parse_save_tag<T: Component + Reflect>(tag: &str) -> impl FnOnce(&str) -> Result<T, SaveEntityParseError> {
move |line: &str| -> Result<T, SaveEntityParseError> {
todo!()
}
pub(crate) fn parse_save_tag<T: Component + Reflect + Default>(
t: &str,
) -> impl FnOnce(&str) -> Result<T, SaveEntityParseError> + '_ {
move |line: &str| -> Result<T, SaveEntityParseError> { Ok(tag(t)(line).map(|_| T::default())?) }
}
#[derive(Component, Reflect, PartialEq, Debug, Default)]
#[reflect(Component)]
struct TestingTag;
#[test]
fn test_save_tag() {
todo!()
let line = "testing";
let parsed = parse_save_tag::<TestingTag>("testing")(line).unwrap();
let expected = TestingTag;
assert_eq!(parsed, expected);
}
#[derive(Component, Clone, Debug, Reflect, PartialEq)]
@ -317,11 +382,25 @@ fn test_save_tag() {
pub(crate) struct SaveTargetCamera(String);
/// Parses the a SaveTargetCamera which at runtime is converted to a TargetCamera
pub(crate) fn parse_save_target_camera(line: &str) -> Result<SaveTargetCamera, SaveEntityParseError> {
todo!()
/// ```text
/// target-camera "./level-camera.entity"
/// ```
pub(crate) fn parse_save_target_camera(
line: &str,
) -> Result<SaveTargetCamera, SaveEntityParseError> {
Ok(
tuple((tag("target-camera"), space1, parse_string))(line).map(
|(_, (_, _, target_camera_entity_file))| {
SaveTargetCamera(target_camera_entity_file.into())
},
)?,
)
}
#[test]
fn test_target_camera() {
todo!()
}
let line = "target-camera \"./level-camera.entity\"";
let parsed = parse_save_target_camera(line).unwrap();
let expected = SaveTargetCamera("./level-camera.entity".into());
assert_eq!(parsed, expected);
}

31
src/prelude.rs
Unescape Escape View File

@ -1,23 +1,24 @@
pub(crate) use bevy::ecs::reflect::ReflectCommandExt;
pub(crate) use bevy::{
app::AppExit,
asset::{io::Reader, AssetLoader, LoadContext, AsyncReadExt},
color::palettes::css::{GRAY, RED, DARK_GREEN, BLUE},
gltf::Gltf,
input::common_conditions::input_just_pressed,
prelude::*,
render::camera::RenderTarget,
window::{WindowRef, WindowCloseRequested, PrimaryWindow},
app::AppExit,
asset::{io::Reader, AssetLoader, AsyncReadExt, LoadContext},
color::palettes::css::{BLUE, DARK_GREEN, GRAY, RED},
gltf::Gltf,
input::common_conditions::input_just_pressed,
prelude::*,
render::camera::RenderTarget,
window::{PrimaryWindow, WindowCloseRequested, WindowRef},
};
pub(crate) use bevy::ecs::reflect::ReflectCommandExt;
pub(crate) use nom::bytes::complete::take;
pub(crate) use nom::{
IResult,
bytes::complete::{tag, take_until1},
character::complete::space1,
number::complete::float,
sequence::tuple,
branch::{alt, permutation},
bytes::complete::{tag, take_until1},
character::complete::{char, hex_digit1, space1},
number::complete::float,
sequence::tuple,
IResult,
};
pub(crate) use uuid::Uuid;
pub(crate) use thiserror::Error;
pub(crate) use uuid::Uuid;
pub(crate) use crate::{conditions::*, parser::*};

Write Preview
Loading…
Cancel
Save