111 lines
3.0 KiB
Rust
111 lines
3.0 KiB
Rust
use std::collections::HashMap;
|
|
use crate::character;
|
|
use crate::api;
|
|
use crate::mpsc::*;
|
|
use std::{thread};
|
|
use std::sync::{Arc,Mutex};
|
|
use std::time::Duration;
|
|
|
|
mod strings;
|
|
|
|
// Parse the tokens in a file
|
|
// Returns success or an error string
|
|
pub async fn token_parse(
|
|
tokens: &Vec<&str>,
|
|
mut characters: &mut HashMap::<String, character::Character>,
|
|
data_to_send: Arc<Mutex<api::Data_to_send>>,
|
|
rx: &Receiver<u8>,
|
|
) -> Result<(),String>
|
|
{
|
|
let mut index: usize = 0;
|
|
// Run an infinite loop
|
|
loop
|
|
{
|
|
match rx.try_recv()
|
|
{
|
|
Ok(_) =>
|
|
{
|
|
match tokens.get(index) {
|
|
Some(token) => {
|
|
// The instructions are related to characters
|
|
if token.chars().next().unwrap() == '@'
|
|
{
|
|
let character_name: String = token.chars().skip(1).collect();
|
|
// If the character doesn't exist, then create it
|
|
if ! characters.contains_key(&character_name)
|
|
{
|
|
let new_character = character::Character::new(character_name.clone());
|
|
characters.insert(character_name.clone(),new_character);
|
|
}
|
|
println!("Doing something with a character: {}", character_name);
|
|
// The index is incremented to after the character's instructions
|
|
index += match character_parse(index+1, &tokens, character_name, &mut characters, &data_to_send, &rx).await
|
|
{
|
|
Ok(increment) => {
|
|
increment
|
|
},
|
|
Err(error) => return Err(error),
|
|
}
|
|
}
|
|
// Miscelleneous instructions
|
|
if token.to_lowercase() == "end"
|
|
{
|
|
return Ok(()) // quit
|
|
}
|
|
},
|
|
None => return Err(String::from("File reached termination point")),
|
|
}
|
|
index += 1;
|
|
},
|
|
Err(_) => thread::sleep(Duration::from_millis(4000)),
|
|
}
|
|
}
|
|
}
|
|
// Parsing character related instructions
|
|
async fn character_parse
|
|
(
|
|
index: usize,
|
|
tokens: &Vec<&str>,
|
|
character_name: String,
|
|
characters: &mut HashMap::<String, character::Character>,
|
|
data_to_send: &Arc<Mutex<api::Data_to_send>>,
|
|
rx: &Receiver<u8>,
|
|
) -> Result<usize,String>
|
|
{
|
|
let mut sum_index: usize = index;
|
|
loop
|
|
{
|
|
// Ensure the index is valid (the index is not beyond the vector)
|
|
let _ = match tokens.get(sum_index)
|
|
{
|
|
Some(token) => {
|
|
match token.to_lowercase().as_str()
|
|
{
|
|
// The character is saying something, so grab the text and pass it
|
|
// to the client
|
|
"says" =>
|
|
{
|
|
match strings::extract_quoted(&tokens[sum_index+1..])
|
|
{
|
|
Some(output_string) =>
|
|
{
|
|
println!("{}", output_string);
|
|
let mut data = data_to_send.lock().unwrap();
|
|
data.action_type = String::from("output");
|
|
data.content = output_string;
|
|
data.character = character_name.clone();
|
|
},
|
|
None => return Err(String::from("Unable to read string")),
|
|
}
|
|
},
|
|
// Catch all condition, if the instruction is unrecognised as a
|
|
// character command
|
|
_ => return Err(String::from("Invalid command")),
|
|
}
|
|
},
|
|
None => return Err(String::from("File reached termination point"))
|
|
};
|
|
sum_index += 1;
|
|
}
|
|
}
|