382 lines
17 KiB
Rust
382 lines
17 KiB
Rust
#![allow(dead_code, unused_must_use)]
|
|
use std::collections::HashMap;
|
|
|
|
use rand::Rng;
|
|
use thiserror::Error;
|
|
|
|
use libpso::packet::ship::*;
|
|
use libpso::packet::login::{Login, LoginResponse, Session};
|
|
use libpso::packet::messages::*;
|
|
use libpso::{PacketParseError, PSOPacket};
|
|
use libpso::crypto::bb::PSOBBCipher;
|
|
|
|
use libpso::packet::ship::{BLOCK_MENU_ID, ROOM_MENU_ID};
|
|
|
|
|
|
use crate::common::cipherkeys::{ELSEWHERE_PRIVATE_KEY, ELSEWHERE_PARRAY};
|
|
use crate::common::serverstate::{SendServerPacket, RecvServerPacket, ServerState, OnConnect, ClientId};
|
|
use crate::common::leveltable::CharacterLevelTable;
|
|
|
|
use crate::entity::gateway::EntityGateway;
|
|
use crate::entity::account::{UserAccountEntity, UserSettingsEntity};
|
|
use crate::entity::character::CharacterEntity;
|
|
|
|
use crate::ship::location::{ClientLocation, RoomLobby, MAX_ROOMS, ClientLocationError};
|
|
|
|
use crate::ship::items;
|
|
use crate::ship::room;
|
|
use crate::ship::map::{MapsError, MapAreaError, MapArea};
|
|
use crate::ship::packet::handler;
|
|
|
|
pub const SHIP_PORT: u16 = 23423;
|
|
pub type Rooms = [Option<room::RoomState>; MAX_ROOMS];
|
|
pub type Clients = HashMap<ClientId, ClientState>;
|
|
|
|
#[derive(Error, Debug)]
|
|
#[error("")]
|
|
pub enum ShipError {
|
|
ClientNotFound(ClientId),
|
|
NoCharacterInSlot(ClientId, u32),
|
|
InvalidSlot(ClientId, u32),
|
|
TooManyClients,
|
|
ClientLocationError(#[from] ClientLocationError),
|
|
MapsError(#[from] MapsError),
|
|
MapAreaError(#[from] MapAreaError),
|
|
InvalidRoom(u32),
|
|
MonsterAlreadyDroppedItem(ClientId, u16),
|
|
SliceError(#[from] std::array::TryFromSliceError),
|
|
ItemError, // TODO: refine this
|
|
PickUpInvalidItemId(u32),
|
|
DropInvalidItemId(u32),
|
|
ItemManagerError(#[from] items::ItemManagerError),
|
|
ItemDropLocationNotSet,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum RecvShipPacket {
|
|
Login(Login),
|
|
MenuSelect(MenuSelect),
|
|
RoomPasswordReq(RoomPasswordReq),
|
|
CharData(CharData),
|
|
Message(Message),
|
|
DirectMessage(DirectMessage),
|
|
PlayerChat(PlayerChat),
|
|
CreateRoom(CreateRoom),
|
|
RoomNameRequest(RoomNameRequest),
|
|
UpdateConfig(UpdateConfig),
|
|
ViewInfoboardRequest(ViewInfoboardRequest),
|
|
WriteInfoboard(WriteInfoboard),
|
|
RoomListRequest(RoomListRequest),
|
|
Like62ButCooler(Like62ButCooler),
|
|
ClientCharacterData(ClientCharacterData),
|
|
DoneBursting(DoneBursting),
|
|
LobbySelect(LobbySelect),
|
|
}
|
|
|
|
impl RecvServerPacket for RecvShipPacket {
|
|
fn from_bytes(data: &[u8]) -> Result<RecvShipPacket, PacketParseError> {
|
|
match u16::from_le_bytes([data[2], data[3]]) {
|
|
0x93 => Ok(RecvShipPacket::Login(Login::from_bytes(data)?)),
|
|
0x10 => match data[0] {
|
|
16 => Ok(RecvShipPacket::MenuSelect(MenuSelect::from_bytes(data)?)),
|
|
48 => Ok(RecvShipPacket::RoomPasswordReq(RoomPasswordReq::from_bytes(data)?)),
|
|
_ => Err(PacketParseError::WrongPacketForServerType(u16::from_le_bytes([data[2], data[3]]), data.to_vec())),
|
|
},
|
|
0x61 => Ok(RecvShipPacket::CharData(CharData::from_bytes(data)?)),
|
|
0x60 => Ok(RecvShipPacket::Message(Message::from_bytes(data)?)),
|
|
0x62 => Ok(RecvShipPacket::DirectMessage(DirectMessage::from_bytes(data)?)),
|
|
0x06 => Ok(RecvShipPacket::PlayerChat(PlayerChat::from_bytes(data)?)),
|
|
0xC1 => Ok(RecvShipPacket::CreateRoom(CreateRoom::from_bytes(data)?)),
|
|
0x8A => Ok(RecvShipPacket::RoomNameRequest(RoomNameRequest::from_bytes(data)?)),
|
|
0x7ED => Ok(RecvShipPacket::UpdateConfig(UpdateConfig::from_bytes(data)?)),
|
|
0xD8 => Ok(RecvShipPacket::ViewInfoboardRequest(ViewInfoboardRequest::from_bytes(data)?)),
|
|
0xD9 => Ok(RecvShipPacket::WriteInfoboard(WriteInfoboard::from_bytes(data)?)),
|
|
0x08 => Ok(RecvShipPacket::RoomListRequest(RoomListRequest::from_bytes(data)?)),
|
|
0x6D => Ok(RecvShipPacket::Like62ButCooler(Like62ButCooler::from_bytes(data)?)),
|
|
0x98 => Ok(RecvShipPacket::ClientCharacterData(ClientCharacterData::from_bytes(data)?)),
|
|
0x6F => Ok(RecvShipPacket::DoneBursting(DoneBursting::from_bytes(data)?)),
|
|
0x84 => Ok(RecvShipPacket::LobbySelect(LobbySelect::from_bytes(data)?)),
|
|
_ => Err(PacketParseError::WrongPacketForServerType(u16::from_le_bytes([data[2], data[3]]), data.to_vec()))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum SendShipPacket {
|
|
ShipWelcome(ShipWelcome),
|
|
LoginResponse(LoginResponse),
|
|
ShipBlockList(ShipBlockList),
|
|
FullCharacter(FullCharacter),
|
|
CharDataRequest(CharDataRequest),
|
|
JoinLobby(JoinLobby),
|
|
AddToLobby(AddToLobby),
|
|
Message(Message),
|
|
DirectMessage(DirectMessage),
|
|
PlayerChat(PlayerChat),
|
|
SmallDialog(SmallDialog),
|
|
JoinRoom(JoinRoom),
|
|
AddToRoom(AddToRoom),
|
|
LeaveLobby(LeaveLobby),
|
|
LeaveRoom(LeaveRoom),
|
|
RoomNameResponse(RoomNameResponse),
|
|
ViewInfoboardResponse(ViewInfoboardResponse),
|
|
RoomListResponse(RoomListResponse),
|
|
Like62ButCooler(Like62ButCooler),
|
|
BurstDone72(BurstDone72),
|
|
DoneBursting(DoneBursting),
|
|
LobbyList(LobbyList),
|
|
}
|
|
|
|
impl SendServerPacket for SendShipPacket {
|
|
fn as_bytes(&self) -> Vec<u8> {
|
|
match self {
|
|
SendShipPacket::ShipWelcome(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::LoginResponse(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::ShipBlockList(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::FullCharacter(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::CharDataRequest(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::JoinLobby(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::AddToLobby(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::Message(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::DirectMessage(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::PlayerChat(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::SmallDialog(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::JoinRoom(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::AddToRoom(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::LeaveLobby(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::LeaveRoom(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::RoomNameResponse(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::ViewInfoboardResponse(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::RoomListResponse(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::Like62ButCooler(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::BurstDone72(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::DoneBursting(pkt) => pkt.as_bytes(),
|
|
SendShipPacket::LobbyList(pkt) => pkt.as_bytes(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
pub struct ItemDropLocation {
|
|
pub map_area: MapArea,
|
|
pub x: f32,
|
|
pub z: f32,
|
|
pub item_id: items::ClientItemId,
|
|
}
|
|
|
|
pub struct ClientState {
|
|
pub user: UserAccountEntity,
|
|
pub settings: UserSettingsEntity,
|
|
pub character: CharacterEntity,
|
|
session: Session,
|
|
//guildcard: GuildCard,
|
|
pub block: u32,
|
|
pub item_drop_location: Option<ItemDropLocation>,
|
|
}
|
|
|
|
impl ClientState {
|
|
pub fn new(user: UserAccountEntity, settings: UserSettingsEntity, character: CharacterEntity, session: Session) -> ClientState {
|
|
ClientState {
|
|
user: user,
|
|
settings: settings,
|
|
character: character,
|
|
session: session,
|
|
block: 1,
|
|
item_drop_location: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
pub struct ShipServerState<EG: EntityGateway> {
|
|
entity_gateway: EG,
|
|
clients: Clients,
|
|
client_location: ClientLocation,
|
|
level_table: CharacterLevelTable,
|
|
name: String,
|
|
rooms: Rooms,
|
|
item_manager: items::ItemManager,
|
|
}
|
|
|
|
impl<EG: EntityGateway> ShipServerState<EG> {
|
|
pub fn new(entity_gateway: EG) -> ShipServerState<EG> {
|
|
ShipServerState {
|
|
entity_gateway: entity_gateway,
|
|
clients: HashMap::new(),
|
|
client_location: ClientLocation::new(),
|
|
level_table: CharacterLevelTable::new(),
|
|
name: "Sona-Nyl".into(),
|
|
rooms: [None; MAX_ROOMS],
|
|
item_manager: items::ItemManager::new(),
|
|
}
|
|
}
|
|
|
|
fn message(&mut self, id: ClientId, msg: &Message) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
|
|
match &msg.msg {
|
|
GameMessage::RequestExp(request_exp) => {
|
|
handler::message::request_exp(id, request_exp, &self.client_location, &self.rooms)
|
|
},
|
|
GameMessage::PlayerDropItem(player_drop_item) => {
|
|
handler::message::player_drop_item(id, player_drop_item, &mut self.entity_gateway, &mut self.client_location, &mut self.clients, &mut self.rooms, &mut self.item_manager).unwrap()
|
|
},
|
|
GameMessage::DropCoordinates(drop_coordinates) => {
|
|
handler::message::drop_coordinates(id, drop_coordinates, &self.client_location, &mut self.clients, &self.rooms).unwrap()
|
|
},
|
|
GameMessage::PlayerSplitItemStack(split_item_stack) => {
|
|
handler::message::split_item_stack(id, split_item_stack, &mut self.entity_gateway, &mut self.client_location, &mut self.clients, &mut self.item_manager).unwrap()
|
|
},
|
|
_ => {
|
|
let cmsg = msg.clone();
|
|
Box::new(self.client_location.get_client_neighbors(id).unwrap().into_iter()
|
|
.map(move |client| {
|
|
(client.client, SendShipPacket::Message(cmsg.clone()))
|
|
}))
|
|
},
|
|
}
|
|
}
|
|
|
|
fn direct_message(&mut self, id: ClientId, msg: &DirectMessage) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
|
|
let target = msg.flag;
|
|
match &msg.msg {
|
|
GameMessage::GuildcardSend(guildcard_send) => {
|
|
handler::direct_message::guildcard_send(id, guildcard_send, target, &self.client_location, &self.clients)
|
|
},
|
|
GameMessage::RequestItem(request_item) => {
|
|
handler::direct_message::request_item(id, request_item, &mut self.entity_gateway, &mut self.client_location, &mut self.clients, &mut self.rooms, &mut self.item_manager).unwrap()
|
|
},
|
|
GameMessage::PickupItem(pickup_item) => {
|
|
handler::direct_message::pickup_item(id, pickup_item, &mut self.entity_gateway, &mut self.client_location, &mut self.clients, &mut self.item_manager).unwrap()
|
|
},
|
|
_ => {
|
|
let cmsg = msg.clone();
|
|
Box::new(self.client_location.get_all_clients_by_client(id).unwrap().into_iter()
|
|
.filter(move |client| client.local_client.id() == target as u8)
|
|
.map(move |client| {
|
|
(client.client, SendShipPacket::DirectMessage(cmsg.clone()))
|
|
}))
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<EG: EntityGateway> ServerState for ShipServerState<EG> {
|
|
type SendPacket = SendShipPacket;
|
|
type RecvPacket = RecvShipPacket;
|
|
type PacketError = ShipError;
|
|
|
|
fn on_connect(&mut self, _id: ClientId) -> Vec<OnConnect<Self::SendPacket>> {
|
|
let mut rng = rand::thread_rng();
|
|
|
|
let mut server_key = [0u8; 48];
|
|
let mut client_key = [0u8; 48];
|
|
rng.fill(&mut server_key[..]);
|
|
rng.fill(&mut client_key[..]);
|
|
|
|
vec![OnConnect::Packet(SendShipPacket::ShipWelcome(ShipWelcome::new(server_key, client_key))),
|
|
OnConnect::Cipher((Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, client_key)),
|
|
Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, server_key))))
|
|
]
|
|
}
|
|
|
|
fn handle(&mut self, id: ClientId, pkt: &RecvShipPacket)
|
|
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> {
|
|
Ok(match pkt {
|
|
RecvShipPacket::Login(login) => {
|
|
Box::new(handler::auth::validate_login(id, login, &mut self.entity_gateway, &mut self.clients, &mut self.item_manager, &self.name)?.into_iter().map(move |pkt| (id, pkt)))
|
|
},
|
|
RecvShipPacket::MenuSelect(menuselect) => {
|
|
match menuselect.menu {
|
|
BLOCK_MENU_ID => Box::new(handler::lobby::block_selected(id, menuselect, &mut self.clients, &self.item_manager, &self.level_table)?.into_iter().map(move |pkt| (id, pkt))),
|
|
ROOM_MENU_ID => handler::room::join_room(id, menuselect, &mut self.client_location, &mut self.clients, &mut self.item_manager, &self.level_table, &mut self.rooms)?,
|
|
_ => unreachable!(),
|
|
}
|
|
},
|
|
RecvShipPacket::RoomPasswordReq(room_password_req) => {
|
|
if room_password_req.password == self.rooms[room_password_req.item as usize].as_ref()
|
|
.ok_or(ShipError::InvalidRoom(room_password_req.item))?
|
|
.password {
|
|
let menuselect = MenuSelect {
|
|
menu: room_password_req.menu,
|
|
item: room_password_req.item,
|
|
};
|
|
handler::room::join_room(id, &menuselect, &mut self.client_location, &mut self.clients, &mut self.item_manager, &self.level_table, &mut self.rooms)?
|
|
}
|
|
else {
|
|
Box::new(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("Incorrect password".into())))].into_iter())
|
|
}
|
|
},
|
|
RecvShipPacket::CharData(chardata) => {
|
|
Box::new(handler::lobby::send_player_to_lobby(id, chardata, &mut self.client_location, &self.clients, &self.item_manager, &self.level_table)?.into_iter())
|
|
},
|
|
RecvShipPacket::Message(msg) => {
|
|
self.message(id, msg)
|
|
},
|
|
RecvShipPacket::DirectMessage(msg) => {
|
|
self.direct_message(id, msg)
|
|
},
|
|
RecvShipPacket::PlayerChat(msg) => {
|
|
Box::new(handler::communication::player_chat(id, msg, &self.client_location, &self.clients)?.into_iter())
|
|
},
|
|
RecvShipPacket::CreateRoom(create_room) => {
|
|
handler::room::create_room(id, create_room, &mut self.client_location, &mut self.clients, &mut self.item_manager, &mut self.rooms)?
|
|
},
|
|
RecvShipPacket::RoomNameRequest(_req) => {
|
|
handler::room::room_name_request(id, &self.client_location, &self.rooms)
|
|
},
|
|
RecvShipPacket::UpdateConfig(pkt) => {
|
|
handler::settings::update_config(id, pkt, &mut self.clients, &mut self.entity_gateway)
|
|
},
|
|
RecvShipPacket::ViewInfoboardRequest(_pkt) => {
|
|
handler::communication::request_infoboard(id, &self.client_location, &self.clients)
|
|
},
|
|
RecvShipPacket::WriteInfoboard(pkt) => {
|
|
handler::communication::write_infoboard(id, pkt, &mut self.clients, &mut self.entity_gateway)
|
|
},
|
|
RecvShipPacket::RoomListRequest(_req) => {
|
|
handler::room::request_room_list(id, &self.client_location, &self.rooms)
|
|
},
|
|
RecvShipPacket::Like62ButCooler(cool62) => {
|
|
handler::room::cool_62(id, cool62, &self.client_location)
|
|
},
|
|
RecvShipPacket::ClientCharacterData(_) => {
|
|
// TOOD: validate this in some way?
|
|
Box::new(None.into_iter())
|
|
},
|
|
RecvShipPacket::DoneBursting(_) => {
|
|
handler::room::done_bursting(id, &self.client_location, &mut self.rooms)
|
|
},
|
|
RecvShipPacket::LobbySelect(pkt) => {
|
|
Box::new(handler::lobby::change_lobby(id, pkt.lobby, &mut self.client_location, &self.clients, &mut self.item_manager, &self.level_table, &mut self.rooms)?.into_iter())
|
|
}
|
|
})
|
|
}
|
|
|
|
fn on_disconnect(&mut self, id: ClientId) -> Vec<(ClientId, SendShipPacket)> {
|
|
// TODO: don't unwrap!
|
|
let client = self.clients.get(&id).unwrap();
|
|
let area_client = self.client_location.get_local_client(id).unwrap();
|
|
let neighbors = self.client_location.get_client_neighbors(id).unwrap();
|
|
|
|
let pkt = match self.client_location.get_area(id).unwrap() {
|
|
RoomLobby::Room(room) => {
|
|
if neighbors.len() == 0 {
|
|
self.rooms[room.0] = None;
|
|
}
|
|
let leader = self.client_location.get_room_leader(room).unwrap();
|
|
SendShipPacket::LeaveRoom(LeaveRoom::new(area_client.local_client.id(), leader.local_client.id()))
|
|
},
|
|
RoomLobby::Lobby(lobby) => {
|
|
let leader = self.client_location.get_lobby_leader(lobby).unwrap();
|
|
SendShipPacket::LeaveLobby(LeaveLobby::new(area_client.local_client.id(), leader.local_client.id()))
|
|
}
|
|
};
|
|
|
|
self.client_location.remove_client_from_area(id);
|
|
self.item_manager.remove_character_from_room(&client.character);
|
|
|
|
neighbors.into_iter().map(|n| {
|
|
(n.client, pkt.clone())
|
|
}).collect()
|
|
}
|
|
}
|