360 lines
14 KiB
Rust
360 lines
14 KiB
Rust
use std::collections::HashMap;
|
|
|
|
use rand::Rng;
|
|
|
|
use libpso::packet::ship::*;
|
|
use libpso::packet::login::{Login, LoginResponse, AccountStatus, Session};
|
|
use libpso::packet::messages::*;
|
|
use libpso::{PacketParseError, PSOPacket};
|
|
use libpso::crypto::bb::PSOBBCipher;
|
|
use libpso::character::character;
|
|
use libpso::utf8_to_utf16_array;
|
|
|
|
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::{UserAccount, UserSettings, USERFLAG_NEWCHAR, USERFLAG_DRESSINGROOM};
|
|
use crate::entity::character::Character;
|
|
use crate::entity::item::ItemLocation;
|
|
use crate::login::login::get_login_status;
|
|
use crate::ship::location::ClientLocation;
|
|
use crate::ship::character::{CharacterBuilder, FullCharacterBuilder};
|
|
|
|
pub const SHIP_PORT: u16 = 23423;
|
|
|
|
#[derive(Debug)]
|
|
pub enum ShipError {
|
|
ClientNotFound(ClientId),
|
|
NoCharacterInSlot(ClientId, u32),
|
|
InvalidSlot(ClientId, u32),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum RecvShipPacket {
|
|
Login(Login),
|
|
MenuSelect(MenuSelect),
|
|
CharData(CharData),
|
|
Message(Message),
|
|
DirectMessage(DirectMessage),
|
|
}
|
|
|
|
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 => Ok(RecvShipPacket::MenuSelect(MenuSelect::from_bytes(data)?)),
|
|
0x61 => Ok(RecvShipPacket::CharData(CharData::from_bytes(data)?)),
|
|
0x60 => Ok(RecvShipPacket::Message(Message::from_bytes(data)?)),
|
|
0x62 => Ok(RecvShipPacket::DirectMessage(DirectMessage::from_bytes(data)?)),
|
|
_ => Err(PacketParseError::WrongPacketForServerType(u16::from_le_bytes([data[2], data[3]]), data.to_vec()))
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum SendShipPacket {
|
|
ShipWelcome(ShipWelcome),
|
|
LoginResponse(LoginResponse),
|
|
ShipBlockList(ShipBlockList),
|
|
FullCharacter(FullCharacter),
|
|
CharDataRequest(CharDataRequest),
|
|
JoinLobby(JoinLobby),
|
|
AddToLobby(AddToLobby),
|
|
Message(Message),
|
|
DirectMessage(DirectMessage),
|
|
}
|
|
|
|
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(),
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
struct ClientState {
|
|
user: UserAccount,
|
|
settings: UserSettings,
|
|
character: Character,
|
|
session: Session,
|
|
block: u32,
|
|
room_client_id: u32,
|
|
}
|
|
|
|
impl ClientState {
|
|
fn new(user: UserAccount, settings: UserSettings, character: Character, session: Session) -> ClientState {
|
|
ClientState {
|
|
user: user,
|
|
settings: settings,
|
|
character: character,
|
|
session: session,
|
|
block: 1,
|
|
room_client_id: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
pub struct ShipServerState<EG: EntityGateway> {
|
|
entity_gateway: EG,
|
|
clients: HashMap<ClientId, ClientState>,
|
|
client_location: ClientLocation,
|
|
level_table: CharacterLevelTable,
|
|
name: String,
|
|
}
|
|
|
|
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(),
|
|
}
|
|
}
|
|
|
|
fn validate_login(&mut self, id: ClientId, pkt: &Login) -> Result<Vec<SendShipPacket>, ShipError> {
|
|
Ok(match get_login_status(&self.entity_gateway, pkt) {
|
|
Ok(user) => {
|
|
let mut response = LoginResponse::by_status(AccountStatus::Ok, Session::new());
|
|
response.guildcard = user.guildcard.map_or(24, |gc| gc) as u32;
|
|
response.team_id = user.team_id.map_or(31, |ti| ti) as u32;
|
|
let characters = self.entity_gateway.get_characters_by_user(&user);
|
|
let character = characters
|
|
.get(pkt.session.character_slot as usize)
|
|
.ok_or(ShipError::InvalidSlot(id, pkt.session.character_slot as u32))?
|
|
.ok_or(ShipError::NoCharacterInSlot(id, pkt.session.character_slot as u32))?;
|
|
let settings = self.entity_gateway.get_user_settings_by_user(&user)
|
|
.ok_or(ShipError::ClientNotFound(id))?;
|
|
|
|
self.clients.insert(id, ClientState::new(user, settings, character, pkt.session));
|
|
vec![SendShipPacket::LoginResponse(response), SendShipPacket::ShipBlockList(ShipBlockList::new(&self.name, 3))]
|
|
},
|
|
Err(err) => {
|
|
vec![SendShipPacket::LoginResponse(LoginResponse::by_status(err, Session::new()))]
|
|
}
|
|
})
|
|
}
|
|
|
|
fn block_selected(&mut self, id: ClientId, pkt: &MenuSelect) -> Result<Vec<SendShipPacket>, ShipError> {
|
|
let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
|
|
client.block = pkt.item as u32;
|
|
|
|
let (level, stats) = self.level_table.get_stats_from_exp(character::Class::from(client.character.character.ch_class), client.character.character.exp);
|
|
|
|
let items = self.entity_gateway.get_items_by_character(&client.character);
|
|
let (inventory, inv_len) = items
|
|
.iter()
|
|
.take(30)
|
|
.fold(([character::InventoryItem::default(); 30], 0), |(mut inv, len), item| {
|
|
let index = {
|
|
if let ItemLocation::Inventory{index, .. } = item.location {
|
|
index
|
|
}
|
|
else {
|
|
panic!("inventory item that isnt in inventory???");
|
|
}
|
|
};
|
|
let bytes = item.item.as_bytes();
|
|
inv[index].data1.copy_from_slice(&bytes[0..12]);
|
|
inv[index].item_id = item.id;
|
|
(inv, len+1)
|
|
});
|
|
let fc = FullCharacterBuilder::new()
|
|
.character(&CharacterBuilder::new()
|
|
.character(&client.character.character)
|
|
.stats(&stats)
|
|
.level(level - 1)
|
|
.build())
|
|
.inventory(&inventory, inv_len)
|
|
.key_config(&client.settings.settings.key_config)
|
|
.joystick_config(&client.settings.settings.joystick_config)
|
|
//.team_config(&joystick_config)
|
|
.build();
|
|
|
|
Ok(vec![
|
|
SendShipPacket::FullCharacter(FullCharacter {
|
|
character: fc,
|
|
}),
|
|
SendShipPacket::CharDataRequest(CharDataRequest {}),
|
|
])
|
|
}
|
|
|
|
fn send_player_to_lobby(&mut self, id: ClientId, _pkt: &CharData) -> Result<Vec<(ClientId, SendShipPacket)>, ShipError> {
|
|
self.client_location.add_to_lobby(id, 0).unwrap();
|
|
|
|
let lobby = self.client_location.get_area_by_user(id);
|
|
let clients = lobby.clients();
|
|
println!("clients in lobby: {:?}", clients);
|
|
let playerinfo = clients.iter()
|
|
.map(|room_client| {
|
|
let client = self.clients.get(&room_client.client_id).ok_or(ShipError::ClientNotFound(id)).unwrap();
|
|
let (level, stats) = self.level_table.get_stats_from_exp(character::Class::from(client.character.character.ch_class), client.character.character.exp);
|
|
let c = CharacterBuilder::new()
|
|
.character(&client.character.character)
|
|
.stats(&stats)
|
|
.level(level - 1)
|
|
.build();
|
|
PlayerInfo {
|
|
header: PlayerHeader {
|
|
tag: 0x100,
|
|
guildcard: client.user.id,
|
|
_unknown1: [0; 5],
|
|
client_id: room_client.index as u32,
|
|
name: c.name,
|
|
_unknown2: 2,
|
|
},
|
|
inventory: character::Inventory {
|
|
item_count: 0,
|
|
hp_mats_used: 0,
|
|
tp_mats_used: 0,
|
|
language: 0,
|
|
items: [character::InventoryItem::default(); 30],
|
|
},
|
|
character: c,
|
|
}
|
|
});
|
|
let client_id = clients.iter()
|
|
.fold(0, |acc, k| {
|
|
if k.client_id == id {
|
|
k.index
|
|
}
|
|
else {
|
|
acc
|
|
}
|
|
});
|
|
|
|
let join_lobby = JoinLobby {
|
|
client: client_id as u8,
|
|
leader: lobby.leader().index as u8,
|
|
one: 1,
|
|
lobby: lobby.id() as u8,
|
|
block: 1,
|
|
event: 0,
|
|
padding: 0,
|
|
playerinfo: playerinfo.collect(),
|
|
};
|
|
|
|
let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id)).unwrap();
|
|
let (level, stats) = self.level_table.get_stats_from_exp(character::Class::from(client.character.character.ch_class), client.character.character.exp);
|
|
let c = CharacterBuilder::new()
|
|
.character(&client.character.character)
|
|
.stats(&stats)
|
|
.level(level - 1)
|
|
.build();
|
|
let addto = AddToLobby {
|
|
flag: 1,
|
|
client: client_id as u8,
|
|
leader: lobby.leader().index as u8,
|
|
one: 1,
|
|
lobby: lobby.id() as u8,
|
|
block: 1,
|
|
event: 0,
|
|
padding: 0,
|
|
playerinfo: PlayerInfo {
|
|
header: PlayerHeader {
|
|
tag: 0x100,
|
|
guildcard: client.user.id,
|
|
_unknown1: [0; 5],
|
|
client_id: client_id as u32,
|
|
name: c.name,
|
|
_unknown2: 2,
|
|
},
|
|
inventory: character::Inventory {
|
|
item_count: 0,
|
|
hp_mats_used: 0,
|
|
tp_mats_used: 0,
|
|
language: 0,
|
|
items: [character::InventoryItem::default(); 30],
|
|
},
|
|
character: c,
|
|
},
|
|
};
|
|
|
|
let mut v = Vec::new();
|
|
v.push((id, SendShipPacket::JoinLobby(join_lobby)));
|
|
for client in clients {
|
|
if client.client_id != id {
|
|
v.push((client.client_id, SendShipPacket::AddToLobby(addto.clone()))
|
|
)}
|
|
}
|
|
|
|
Ok(v)
|
|
}
|
|
|
|
fn message(&mut self, id: ClientId, msg: &Message) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)>> {
|
|
let cmsg = msg.clone();
|
|
Box::new(self.client_location.get_area_by_user(id).clients().iter()
|
|
.filter(|client| client.client_id != id)
|
|
.map(move |client| {
|
|
(client.client_id, SendShipPacket::Message(cmsg.clone()))
|
|
}).collect::<Vec<_>>().into_iter())
|
|
}
|
|
|
|
fn direct_message(&mut self, id: ClientId, msg: &DirectMessage) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)>> {
|
|
let cmsg = msg.clone();
|
|
Box::new(self.client_location.get_area_by_user(id).clients().iter()
|
|
.filter(|client| client.index == cmsg.flag as usize)
|
|
.map(|client| {
|
|
(client.client_id, SendShipPacket::DirectMessage(cmsg.clone()))
|
|
}).collect::<Vec<_>>().into_iter())
|
|
}
|
|
}
|
|
|
|
|
|
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)>>, ShipError> {
|
|
Ok(match pkt {
|
|
RecvShipPacket::Login(login) => {
|
|
Box::new(self.validate_login(id, login)?.into_iter().map(move |pkt| (id, pkt)))
|
|
},
|
|
RecvShipPacket::MenuSelect(menuselect) => {
|
|
match menuselect.menu {
|
|
BLOCK_MENU_ID => Box::new(self.block_selected(id, menuselect)?.into_iter().map(move |pkt| (id, pkt))),
|
|
_ => unreachable!(),
|
|
}
|
|
},
|
|
RecvShipPacket::CharData(chardata) => {
|
|
Box::new(self.send_player_to_lobby(id, chardata)?.into_iter())
|
|
},
|
|
RecvShipPacket::Message(msg) => {
|
|
self.message(id, msg)
|
|
},
|
|
RecvShipPacket::DirectMessage(msg) => {
|
|
self.direct_message(id, msg)
|
|
},
|
|
})
|
|
}
|
|
}
|