267 lines
8.1 KiB
Rust
267 lines
8.1 KiB
Rust
use core::{ops::Not, sync::atomic::Ordering};
|
|
use embassy_time::{Duration, Instant};
|
|
use heapless::Vec;
|
|
use pico_website::unwrap;
|
|
use portable_atomic::{AtomicBool, AtomicU32};
|
|
use core::fmt::Write;
|
|
|
|
use crate::socket::HttpResCode;
|
|
|
|
static TURN: AtomicBool = AtomicBool::new(false);
|
|
// bits [0; 8] : player zero board / bits [9; 17] : player one board
|
|
static BOARD: AtomicU32 = AtomicU32::new(0);
|
|
|
|
pub struct GameClient {
|
|
res_buf: Vec<u8, 4096>,
|
|
/// State of the board last time it has been sent
|
|
last_board: u32,
|
|
team: Team,
|
|
end: Option<(Instant, Option<Team>)>
|
|
}
|
|
impl GameClient {
|
|
pub fn new(team: Team) -> Self {
|
|
Self {
|
|
res_buf: Vec::new(),
|
|
last_board: 0,
|
|
team,
|
|
end: None
|
|
}
|
|
}
|
|
pub fn is_ended(&self, board: u32) -> (bool, Option<Team>) {
|
|
if let Some((_, t)) = self.end {
|
|
return (true, t);
|
|
}
|
|
for (t, m) in [(Team::Zero, 0), (Team::One, 9)] {
|
|
for w in [
|
|
0b111000000,
|
|
0b000111000,
|
|
0b000000111,
|
|
0b100100100,
|
|
0b010010010,
|
|
0b001001001,
|
|
0b100010001,
|
|
0b001010100
|
|
] {
|
|
if board & (w<<m) == (w<<m) {
|
|
return (true, Some(t))
|
|
}
|
|
}
|
|
}
|
|
if ((board | (board>>9)) & 0b111111111) == 0b111111111 {
|
|
return (true, None)
|
|
}
|
|
(false, None)
|
|
}
|
|
pub fn update_end_state(&mut self, board: &mut u32) {
|
|
if let Some((i, _)) = self.end {
|
|
if i+Duration::from_secs(7) < Instant::now() {
|
|
self.end = None;
|
|
BOARD.store(0, Ordering::Release);
|
|
*board = 0;
|
|
}
|
|
} else {
|
|
if let (true, t) = self.is_ended(*board) {
|
|
self.end = Some((Instant::now(), t));
|
|
}
|
|
}
|
|
}
|
|
/// Generate board html
|
|
pub async fn generate_board_res<'a>(&'a mut self, board: u32, turn: Team, outer_html: bool) -> &'a [u8] {
|
|
self.res_buf.clear();
|
|
if outer_html {
|
|
unwrap(self.res_buf.extend_from_slice(
|
|
b"<div \
|
|
id=\"game\" \
|
|
hx-get=\"/ttt/game\" \
|
|
hx-swap=\"innerHTML\" \
|
|
hx-trigger=\"every 100ms\" \
|
|
hx-target=\"this\"\
|
|
>"
|
|
)).await;
|
|
}
|
|
unwrap(write!(
|
|
self.res_buf,
|
|
"<h3>Team : <span style=\"color:{}\">{}</span></h3>",
|
|
self.team.color(),
|
|
self.team.name()
|
|
)).await;
|
|
match self.end {
|
|
Some((_, Some(t))) => unwrap(write!(
|
|
self.res_buf,
|
|
"<br><h3>Team <span style=\"color:{}\">{}</span> has won!</h3><br>",
|
|
t.color(),
|
|
t.name()
|
|
)).await,
|
|
Some((_, None)) => unwrap(write!(
|
|
self.res_buf,
|
|
"<br><h3>Draw!</h3><br>",
|
|
)).await,
|
|
None => {}
|
|
}
|
|
unwrap(self.res_buf.extend_from_slice(b"<div id=\"grid\">")).await;
|
|
for c in 0..=8 {
|
|
let picked_by = if board & (1<<c) != 0 {
|
|
Some(Team::Zero)
|
|
} else if board & (1<<(9 + c)) != 0 {
|
|
Some(Team::One)
|
|
} else {
|
|
None
|
|
};
|
|
match picked_by {
|
|
Some(t) => {
|
|
unwrap(write!(
|
|
self.res_buf,
|
|
"<div class=\"cell\" style=\"background-color:{}\"></div>",
|
|
t.color()
|
|
)).await;
|
|
}
|
|
None => if self.team == turn.into() && self.end.is_none() {
|
|
unwrap(write!(
|
|
self.res_buf,
|
|
"<button class=\"cell\" hx-post=\"/ttt/cell{}\" hx-trigger=\"click\" hx-target=\"#game\" hx-swap=\"innerHTML\"></button>",
|
|
c
|
|
)).await;
|
|
} else {
|
|
unwrap(self.res_buf.extend_from_slice(
|
|
b"<div class=\"cell\"></div>",
|
|
)).await;
|
|
}
|
|
};
|
|
}
|
|
unwrap(self.res_buf.extend_from_slice(b"</div>")).await;
|
|
if outer_html {
|
|
unwrap(self.res_buf.extend_from_slice(b"</div>")).await;
|
|
}
|
|
&self.res_buf
|
|
}
|
|
pub async fn handle_request<'a>(&'a mut self, path: &str) -> (HttpResCode, &'static str, &'a [u8]) {
|
|
if (path.starts_with("/ttt/cell") && path.len() == 10) || path == "/ttt/game" {
|
|
let mut board = BOARD.load(Ordering::Acquire);
|
|
let mut turn = TURN.load(Ordering::Acquire);
|
|
|
|
// just return correct board in case of unauthorized move
|
|
if path.starts_with("/ttt/cell") && self.team == turn.into() {
|
|
let clicked_c: Cell = match TryInto::<Cell>::try_into(
|
|
unwrap(path.chars().nth(9).ok_or("no 9th char")).await,
|
|
) {
|
|
Ok(c) => c,
|
|
Err(_) => return (HttpResCode::NotFound, "", &[]),
|
|
};
|
|
if board
|
|
& (
|
|
(1<<(clicked_c as u32)) + (1<<(9 + clicked_c as u32))
|
|
)
|
|
!= 0
|
|
{
|
|
return (HttpResCode::Forbidden, "", &[]);
|
|
}
|
|
board = board | (1<<((self.team as u32 * 9) + clicked_c as u32));
|
|
turn = (!self.team).into();
|
|
BOARD.store(board, Ordering::Release);
|
|
TURN.store(turn, Ordering::Release);
|
|
}
|
|
self.update_end_state(&mut board);
|
|
if self.last_board != board {
|
|
self.last_board = board;
|
|
(HttpResCode::Ok, "html", self.generate_board_res(board, turn.into(), false).await)
|
|
} else {
|
|
(HttpResCode::NoContent, "", &[])
|
|
}
|
|
} else if path == "/ttt/initial_game" {
|
|
let board = BOARD.load(Ordering::Acquire);
|
|
let turn = TURN.load(Ordering::Acquire);
|
|
(HttpResCode::Ok, "html", self.generate_board_res(board, turn.into(), true).await)
|
|
} else {
|
|
(HttpResCode::NotFound, "", &[])
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum Team {
|
|
Zero = 0,
|
|
One = 1,
|
|
}
|
|
impl From<bool> for Team {
|
|
fn from(value: bool) -> Self {
|
|
if value { Team::One } else { Team::Zero }
|
|
}
|
|
}
|
|
impl Into<bool> for Team {
|
|
fn into(self) -> bool {
|
|
match self {
|
|
Team::Zero => false,
|
|
Team::One => true
|
|
}
|
|
}
|
|
}
|
|
impl Not for Team {
|
|
type Output = Team;
|
|
fn not(self) -> Self::Output {
|
|
match self {
|
|
Team::Zero => Team::One,
|
|
Team::One => Team::Zero
|
|
}
|
|
}
|
|
}
|
|
impl Team {
|
|
fn color(self) -> &'static str {
|
|
match self {
|
|
Team::Zero => "dodgerblue",
|
|
Team::One => "firebrick"
|
|
}
|
|
}
|
|
fn name(self) -> &'static str {
|
|
match self {
|
|
Team::Zero => "blue",
|
|
Team::One => "red"
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
enum Cell {
|
|
C0 = 0,
|
|
C1 = 1,
|
|
C2 = 2,
|
|
C3 = 3,
|
|
C4 = 4,
|
|
C5 = 5,
|
|
C6 = 6,
|
|
C7 = 7,
|
|
C8 = 8,
|
|
}
|
|
impl TryFrom<char> for Cell {
|
|
type Error = ();
|
|
fn try_from(value: char) -> Result<Self, Self::Error> {
|
|
Ok(match value {
|
|
'0' => Cell::C0,
|
|
'1' => Cell::C1,
|
|
'2' => Cell::C2,
|
|
'3' => Cell::C3,
|
|
'4' => Cell::C4,
|
|
'5' => Cell::C5,
|
|
'6' => Cell::C6,
|
|
'7' => Cell::C7,
|
|
'8' => Cell::C8,
|
|
_ => return Err(()),
|
|
})
|
|
}
|
|
}
|
|
impl TryFrom<u8> for Cell {
|
|
type Error = ();
|
|
fn try_from(value: u8) -> Result<Self, Self::Error> {
|
|
Ok(match value {
|
|
0 => Cell::C0,
|
|
1 => Cell::C1,
|
|
2 => Cell::C2,
|
|
3 => Cell::C3,
|
|
4 => Cell::C4,
|
|
5 => Cell::C5,
|
|
6 => Cell::C6,
|
|
7 => Cell::C7,
|
|
8 => Cell::C8,
|
|
_ => return Err(()),
|
|
})
|
|
}
|
|
} |