Added some basic parsing ability, need to add the network calls

src/character.rs

@@ -0,0 +1,14 @@
+pub struct Character
+{
+	name: String,
+}
+impl Character
+{
+	pub fn new(new_name: String) -> Character
+	{
+		Character
+		{
+			name: new_name,
+		}
+	}
+}

src/etiquette.txt

@@ -0,0 +1,4 @@
+Indentation style: Allman
+Indentation characters: Tabs
+Maximum indents: 8
+Maximum lines per file: 200

src/main.rs

@@ -1,3 +1,19 @@
+use std::fs;
+use std::collections::HashMap;
+
+mod parsing;
+mod character;
+
 fn main() {
-    println!("Hello, world!");
+	let mut characters = HashMap::<String, character::Character>::new();
+	let file_contents: String = fs::read_to_string("stories/story.ha").unwrap();
+	// Split the file contents into tokens
+	let tokens: Vec<&str> = file_contents
+		.split_whitespace()
+		.collect();
+	// Run the parsing process
+	match parsing::token_parse(&tokens, &mut characters) {
+		Ok(()) => println!("Program exited successfully"),
+		Err(error) => println!("{}", error),
+	}
 }

src/parsing.rs

@@ -0,0 +1,85 @@
+use std::collections::HashMap;
+use crate::character;
+
+mod strings;
+
+// Parse the tokens in a file
+// Returns success or an error string
+pub fn token_parse(
+	tokens: &Vec<&str>,
+	mut characters: &mut HashMap::<String, character::Character>
+) -> ( Result<(),&'static str> )
+{
+	let mut index: usize = 0;
+	// Run an infinite loop
+	loop
+	{
+		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)
+					{
+						Ok(increment) => increment,
+						Err(error) => return Err(error),
+					}
+				}
+				// Miscelleneous instructions
+				if token.to_lowercase() == "end"
+				{
+					return Ok(());
+				}
+				index += 1;
+			},
+			None => return Err("File reached termination point")
+		}
+	}
+}
+
+// Parsing character related instructions
+fn character_parse(index: usize, tokens: &Vec<&str>, character_name: String, characters: &mut HashMap::<String, character::Character>) ->
+( Result<usize,&'static str> )
+{
+	let mut sum_index: usize = index;
+	loop
+	{
+		
+		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);
+								return Ok(sum_index - index);
+							},
+							None => return Err("Unable to read string"),
+						}
+					},
+					// Catch all condition, if the instruction is unrecognised as a
+					// character command
+					&_ => return Err("Invalid command"),
+				}
+			},
+			None => return Err("File reached termination point")
+		}
+		sum_index += 1;
+	}
+}

src/parsing/strings.rs

@@ -0,0 +1,25 @@
+pub fn extract_quoted(parts: &[&str]) -> Option<String> {
+	let mut vec_string = Vec::new();
+	for part in parts
+	{
+		println!("{}",part);
+		if part.chars().next_back().unwrap() == '"'
+		{
+			vec_string.push(*part);
+			let final_string: String = vec_string.join(" ");
+			let final_string: String = final_string
+				.chars()
+				.skip(1)
+				.take(
+					final_string.chars()
+					.count() - 2)
+				.collect();
+			return Some(final_string);
+		}
+		else
+		{
+			vec_string.push(*part);
+		}
+	}
+	None
+}