hut/outfly
hut/outfly
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

WIP implementing spawning Actors through defs.txt

Browse source
This commit is contained in:
yuni 2024-03-20 20:04:06 +01:00
parent e3e8278d03
commit d9c5398a17
2 changed files with 104 additions and 24 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/defs.txt
View file

@ -1,3 +1,11 @@
actor -30 0 0 "alien"
alive "yes"
suited "yes"
name "Icarus"
pronoun "it"
chatid "hialien"
scale 1
chat "hialien"
name "Icarus"
msg 2 "INIT" "hi" "Requesting permission to communicate..."

120
src/world.rs
View file

@ -310,10 +310,31 @@ pub fn setup(
});
}
#[derive(Debug)]
enum DefClass {
Actor,
Chat,
None,
}
#[derive(Debug)]
struct ParserState {
chat: String,
class: DefClass,
// Generic fields
name: String,
chat: String,
// Actor fields
pos: Vec3,
model: String,
model_scale: f32,
pronoun: String,
is_lifeform: bool,
is_alive: bool,
is_suited: bool,
// Chat fields
delay: f64,
text: String,
level: String,
@ -325,8 +346,18 @@ struct ParserState {
impl Default for ParserState {
fn default() -> Self {
Self {
chat: "".to_string(),
class: DefClass::None,
name: "".to_string(),
chat: "".to_string(),
pos: Vec3::new(0.0, 0.0, 0.0),
model: "".to_string(),
model_scale: 1.0,
pronoun: "they/them".to_string(),
is_lifeform: false,
is_alive: false,
is_suited: false,
delay: 0.0,
text: "".to_string(),
level: "chat".to_string(),
@ -337,21 +368,6 @@ impl Default for ParserState {
}
}
}
impl std::fmt::Display for ParserState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ParserState")
.field("chat", &self.chat)
.field("name", &self.name)
.field("delay", &self.delay)
.field("text", &self.text)
.field("level", &self.level)
.field("label", &self.label)
.field("goto", &self.goto)
.field("is_choice", &self.is_choice)
.field("stores_item", &self.stores_item)
.finish()
}
}
impl ParserState {
fn reset_message(&mut self) {
let default = ParserState::default();
@ -367,6 +383,9 @@ impl ParserState {
self.reset_message();
self.stores_item = default.stores_item;
}
fn reset(&mut self) {
*self = Self::default();
}
fn as_chatbranch(&self) -> actor::ChatBranch {
return actor::ChatBranch {
id: self.chat.clone(),
@ -380,13 +399,27 @@ impl ParserState {
goto: self.goto.clone(),
}
}
fn spawn_chatbranch(&mut self, commands: &mut Commands) {
fn spawn_chat(&mut self, commands: &mut Commands) {
if self.stores_item {
debug!("{:#?}", self.as_chatbranch());
commands.spawn(self.as_chatbranch());
}
self.reset_message();
}
fn spawn_actor(&mut self, commands: &mut Commands) {
let component_actor = actor::Actor::default();
let component_lifeform = actor::LifeForm::default();
let component_suit = actor::Suit::default();
commands.spawn((component_actor, component_lifeform, component_suit));
self.reset();
}
fn spawn_entities(&mut self, commands: &mut Commands) {
match self.class {
DefClass::Actor => { self.spawn_actor(commands); }
DefClass::Chat => { self.spawn_chat(commands); }
DefClass::None => {}
}
}
}
pub fn load_defs(
@ -422,9 +455,48 @@ pub fn load_defs(
}
match parts.as_slice() {
// Parsing actors
["actor", x, y, z, model] => {
state.class = DefClass::Actor;
state.model = model.to_string();
if let (Ok(x_float), Ok(y_float), Ok(z_float)) =
(x.parse::<f32>(), y.parse::<f32>(), z.parse::<f32>()) {
state.pos = Vec3::new(x_float, y_float, z_float);
}
else {
error!("Can't parse coordinates as floats in def: {line}");
state.reset();
continue;
}
}
["alive", "yes"] => {
state.is_alive = true;
state.is_lifeform = true;
}
["suited", "yes"] => {
state.is_suited = true;
}
["pronoun", pronoun] => {
state.pronoun = pronoun.to_string();
}
["chatid", chat] => {
state.chat = chat.to_string();
}
["scale", scale] => {
if let Ok(scale_float) = scale.parse::<f32>() {
state.model_scale = scale_float;
}
else {
error!("Can't parse float: {line}");
continue;
}
}
// Parsing chats
["chat", chat_name] => {
debug!("Registering chat: {}", chat_name);
state.spawn_chatbranch(&mut commands);
state.class = DefClass::Chat;
state.spawn_entities(&mut commands);
state.reset_chat();
state.chat = chat_name.to_string();
}
@ -434,7 +506,7 @@ pub fn load_defs(
}
["msg", sleep, text] => {
debug!("Registering message (sleep={}): {}", sleep, text);
state.spawn_chatbranch(&mut commands);
state.spawn_entities(&mut commands);
if let Ok(sleep_float) = sleep.parse::<f64>() {
state.delay = sleep_float;
state.text = text.to_string();
@ -447,7 +519,7 @@ pub fn load_defs(
}
["msg", sleep, label, goto, text] => {
debug!("Registering message (sleep={}): {}", sleep, text);
state.spawn_chatbranch(&mut commands);
state.spawn_entities(&mut commands);
if let Ok(sleep_float) = sleep.parse::<f64>() {
state.delay = sleep_float;
state.text = text.to_string();
@ -462,7 +534,7 @@ pub fn load_defs(
}
["choice", sleep, text] => {
debug!("Registering choice (sleep={}): {}", sleep, text);
state.spawn_chatbranch(&mut commands);
state.spawn_entities(&mut commands);
if let Ok(sleep_float) = sleep.parse::<f64>() {
state.delay = sleep_float;
state.text = text.to_string();
@ -475,7 +547,7 @@ pub fn load_defs(
}
["choice", sleep, label, goto, text] => {
debug!("Registering choice (sleep={}): {}", sleep, text);
state.spawn_chatbranch(&mut commands);
state.spawn_entities(&mut commands);
if let Ok(sleep_float) = sleep.parse::<f64>() {
state.delay = sleep_float;
state.text = text.to_string();
@ -505,7 +577,7 @@ pub fn load_defs(
}
}
}
state.spawn_chatbranch(&mut commands);
state.spawn_entities(&mut commands);
}
//pub fn swap_world_on_ar_toggle(