146 lines
4.0 KiB
Rust
146 lines
4.0 KiB
Rust
use crate::{
|
|
app::session::{SessionToken, SessionFilter},
|
|
util::pack::{pack_u16, pack_u32, unpack_u8, unpack_u16, unpack_u32},
|
|
};
|
|
|
|
use super::Packet;
|
|
|
|
#[derive(Clone)]
|
|
pub struct PacketSessionList {
|
|
pub filter:SessionFilter,
|
|
|
|
//pub page:u16,
|
|
//pub game_state:u8,
|
|
//pub is_player:bool,
|
|
//pub is_live:bool,
|
|
}
|
|
impl PacketSessionList {
|
|
pub fn new() -> Self
|
|
{
|
|
Self {
|
|
filter:SessionFilter::new(),
|
|
|
|
//page:0,
|
|
//game_state:0,
|
|
//is_player:false,
|
|
//is_live:false,
|
|
}
|
|
}
|
|
}
|
|
impl Packet for PacketSessionList {
|
|
type Data = Self;
|
|
|
|
fn decode(data:&Vec<u8>, index:&mut usize) -> Result<Self::Data, ()>
|
|
{
|
|
let mut result = Self::new();
|
|
|
|
if data.len() - *index > 6 {
|
|
result.filter.start = unpack_u32(data, index) as usize;
|
|
result.filter.count = unpack_u32(data, index) as usize;
|
|
|
|
let filter_length = unpack_u16(data, index);
|
|
for _ in 0..filter_length {
|
|
let code = unpack_u8(data, index);
|
|
match code {
|
|
0x00 => { result.filter.is_complete = Some(unpack_u8(data, index) != 0); }
|
|
0x01 => { result.filter.is_live = Some(unpack_u8(data, index) != 0); }
|
|
0x02 => { result.filter.is_player = Some(unpack_u8(data, index) != 0); }
|
|
0x10 => {
|
|
let handle_length = unpack_u8(data, index) as usize;
|
|
if data.len() - *index >= handle_length {
|
|
if let Ok(handle) = String::from_utf8(data[*index..*index+handle_length].to_vec()) {
|
|
if result.filter.player[0].is_none() {
|
|
result.filter.player[0] = Some(handle);
|
|
} else if result.filter.player[1].is_none() {
|
|
result.filter.player[1] = Some(handle);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_ => { }
|
|
}
|
|
}
|
|
|
|
Ok(result)
|
|
} else {
|
|
Err(())
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#[derive(Clone)]
|
|
pub struct PacketSessionListResponseRecord {
|
|
pub token:SessionToken,
|
|
pub handles:[String; 2],
|
|
pub turn:u16,
|
|
pub last_move:u32,
|
|
pub viewers:u32,
|
|
pub player:u8,
|
|
pub is_turn:bool,
|
|
pub is_complete:u8,
|
|
}
|
|
impl PacketSessionListResponseRecord {
|
|
pub fn encode(&self) -> Vec<u8>
|
|
{
|
|
let mut output = self.token.to_vec();
|
|
|
|
let mut flags = 0u32;
|
|
flags |= self.player as u32;
|
|
flags |= (self.is_turn as u32) << 2;
|
|
flags |= (self.is_complete as u32) << 3;
|
|
|
|
// Flags
|
|
output.append(&mut pack_u32(flags));
|
|
|
|
// Dawn handle
|
|
let mut bytes = self.handles[0].as_bytes().to_vec();
|
|
output.append(&mut pack_u16(bytes.len() as u16));
|
|
if bytes.len() > 0 { output.append(&mut bytes); }
|
|
|
|
// Dusk handle
|
|
let mut bytes = self.handles[1].as_bytes().to_vec();
|
|
output.append(&mut pack_u16(bytes.len() as u16));
|
|
if bytes.len() > 0 { output.append(&mut bytes); }
|
|
|
|
// Turn number
|
|
output.append(&mut pack_u16(self.turn));
|
|
|
|
// Last move
|
|
output.append(&mut pack_u32(self.last_move));
|
|
|
|
// Spectator count
|
|
output.append(&mut pack_u32(self.viewers));
|
|
|
|
// User is player
|
|
//chunk.append(&mut vec![record.player as u8]);
|
|
|
|
output
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct PacketSessionListResponse {
|
|
pub records:Vec<PacketSessionListResponseRecord>,
|
|
}
|
|
impl PacketSessionListResponse {
|
|
pub fn new() -> Self
|
|
{
|
|
Self {
|
|
records:Vec::new(),
|
|
}
|
|
}
|
|
}
|
|
impl Packet for PacketSessionListResponse {
|
|
type Data = Self;
|
|
|
|
fn encode(&self) -> Vec<u8>
|
|
{
|
|
let mut result = pack_u16(self.records.len() as u16);
|
|
for record in &self.records {
|
|
result.append(&mut record.encode());
|
|
}
|
|
result
|
|
}
|
|
}
|