make function for adding boards to send queue

Cargo.lock

@@ -1222,6 +1222,7 @@ dependencies = [
  "rocket_codegen",
  "rocket_http",
  "serde",
+ "serde_json",
  "state",
  "tempfile",
  "time",

Cargo.toml

@@ -6,7 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-rocket = "0.5.0-rc.1"
+rocket = {version = "0.5.0-rc.1", features= ["json"]}
 lazy_static = "1.4.0"
 clap = { version = "3.0.6", features = ["derive"] }
 rocket_dyn_templates = {version="0.1.0-rc.1", features= ["handlebars"] }

src/main.rs

@@ -4,21 +4,22 @@ extern crate rocket;
 extern crate lazy_static;
 
 use clap::Parser;
+
 use rocket::fs::{relative, FileServer};
 use rocket_dyn_templates::Template;
 use rocket::response::stream::{EventStream, Event};
+
 use std::{collections::HashMap, mem::drop, sync::Mutex};
 
 mod names;
 mod rooms;
 mod templates;
-mod plays;
 
 lazy_static! {
     static ref ARGS: Args = Args::parse();
     static ref ROOMS: Mutex<HashMap<String, rooms::Room>> = Mutex::new(HashMap::new());
     /// String is the room list
-    static ref PLAYS: Mutex<HashMap<String, Vec<plays::Play>>> = Mutex::new(HashMap::new());
+    static ref PLAYS: Mutex<HashMap<String, Vec<rooms::Board>>> = Mutex::new(HashMap::new());
 }
 
 
@@ -44,7 +45,7 @@ fn rocket() -> _ {
     rocket::custom(config)
         .attach(Template::fairing())
         .mount("/", FileServer::from(relative!("static")))
-        .mount("/", routes![index, room])
+        .mount("/", routes![index, room, stream])
 }
 
 /*
@@ -98,7 +99,6 @@ async fn room(roomname: &str, token: usize, player1: bool) -> Template {
         // the room is real and the token is correct
         if room.token == token {
             drop(rooms);
-            //TODO: placeholder
             templates::get_room(roomname, token, player1)
         }
         // the room is real but the token is incorrect
@@ -114,12 +114,51 @@ async fn room(roomname: &str, token: usize, player1: bool) -> Template {
     }
 }
 
+//*
+//sends new board if there have been updates
+//*
 #[get("/stream/<roomname>/<token>")]
 fn stream(roomname: String, token: usize) -> EventStream![]{
     EventStream!{
         loop {
-            let event = plays::Board::new(roomname);
-            yield Event::json(&event);
+            // TODO
+            // check if there are any new events, and then if the room token is correct
+            // if that's the case send the current playing board
+            // otherwise don't do anything
+            let mut i = 0;
+            if i == 0 {
+                let event = "something";
+                yield Event::json(&event);
+            }
+            i += 1
         }
     }
 }
+
+
+//*
+// adds new boards to the send queue after calculating move
+//*
+#[post("/play?<roomname>&<token>&<player1>&<x>&<y>")]
+fn play (roomname: &str, token: usize, player1: bool, x: u8, y: u8){
+    // get room mutex
+    let mut roomlist = ROOMS.lock().unwrap();
+    // check if room is legal
+    if rooms::room_and_token_correct(&roomlist, &roomname, &token) {
+        let board = &roomlist.get_mut(roomname).unwrap().board;
+        if board.play_is_legal(&x, &y, &player1) {
+            // change the board by making a new play
+            board.make_play(&x, &y);
+            let mut playlist = PLAYS.lock().unwrap();
+            // if the board doesn't exist yet, make a new one
+            if !(playlist.contains_key(roomname)){
+                let rn = roomname.to_string();
+                playlist.insert(rn, vec![]);
+            }
+            // add new board to the play queue
+            playlist.get_mut(roomname).unwrap().push(board.clone());
+            drop(playlist);
+        }
+    }
+    drop(roomlist);
+}

src/plays.rs

@@ -1,33 +0,0 @@
-use rand::{thread_rng, Rng};
-use rocket::serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, FromForm, Serialize, Deserialize)]
-#[cfg_attr(test, derive(PartialEq, UriDisplayQuery))]
-#[serde(crate = "rocket::serde")]
-pub struct Play {
-    pub roomname: String,
-    #[field(validate = len(2...2))]
-    pub position: String,
-    pub player1: bool,
-}
-
-#[derive(Debug, Clone, FromForm, Serialize, Deserialize)]
-#[cfg_attr(test, derive(PartialEq, UriDisplayQuery))]
-#[serde(crate = "rocket::serde")]
-pub struct Board {
-    pub roomname: String,
-    pub position: String,
-    pub player1: bool,
-}
-
-impl Board {
-    pub fn new(rname: String) -> Board {
-        let rng = thread_rng();
-        Board {
-            roomname: rname,
-            player1: rng.gen_bool(1.0 / 2.0),
-            // TODO change this!!! this doesn't make sense! i just put this here for testing
-            position: "".to_string(),
-        }
-    }
-}

src/rooms.rs

@@ -1,21 +1,100 @@
 use rand::{thread_rng, Rng};
+use rocket::serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 
 #[derive(Debug)]
 pub struct Room {
     pub token: usize,
     pub full: bool,
     pub play_queue: Vec<String>,
+    pub board: Board,
 }
 
 impl Room {
     pub fn new() -> Room {
         // generate room token
-        let tok: usize = thread_rng().gen();
-        // flip coin to see who starts
+        let token: usize = thread_rng().gen();
         Room {
             full: false,
-            token: tok,
+            token,
             play_queue: vec![],
+            board: Board::new(),
         }
     }
 }
+
+pub fn room_and_token_correct(
+    rooms: &HashMap<String, Room>,
+    roomname: &str,
+    token: &usize,
+) -> bool {
+    if rooms.contains_key(roomname) {
+        if &rooms.get(roomname).unwrap().token == token {
+            return true;
+        }
+    }
+    false
+}
+
+#[derive(Debug, Clone, FromForm, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq, UriDisplayQuery))]
+#[serde(crate = "rocket::serde")]
+pub struct Play {
+    pub roomname: String,
+    #[field(validate = len(2...2))]
+    pub position: String,
+    pub player1: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq))]
+#[serde(crate = "rocket::serde")]
+pub struct Board {
+    pub position: String,
+    pub player1: bool,
+    pub fields: Vec<Vec<Field>>,
+}
+
+impl Board {
+    pub fn new() -> Board {
+        let mut rng = thread_rng();
+        let mut fields: Vec<Vec<Field>> = vec![];
+        let mut i: u8 = 0;
+        while i <= 8 {
+            let mut inner: Vec<Field> = vec![];
+            let mut i_inner: u8 = 0;
+            while i_inner <= 8 {
+                inner.push(Field::new());
+                i_inner += 1;
+            }
+            fields.push(inner);
+            i += 1;
+        }
+        Board {
+            player1: rng.gen_bool(1.0 / 2.0),
+            // TODO change this!!! this doesn't make sense! i just put this here for testing
+            position: "".to_string(),
+            fields,
+        }
+    }
+    pub fn make_play(&self, x: &u8, y: &u8) {
+        //TODO
+    }
+    pub fn play_is_legal(&self, x: &u8, y: &u8, player1: &bool) -> bool {
+        true
+    }
+}
+
+#[derive(Debug, Clone, FromForm, Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq, UriDisplayQuery))]
+#[serde(crate = "rocket::serde")]
+pub struct Field {
+    owner: u8,
+}
+
+
+impl Field {
+    fn new() -> Field {
+        Field { owner: 0 }
+    }
+}