You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
974 lines
39 KiB
974 lines
39 KiB
#![allow(dead_code, unused_assignments)]
|
|
use std::io::Read;
|
|
use std::collections::{BTreeMap, BTreeSet, HashMap};
|
|
|
|
use async_std::sync::{Arc, RwLock};
|
|
use async_std::channel;
|
|
|
|
use rand::Rng;
|
|
use crc::{crc32, Hasher32};
|
|
|
|
use libpso::packet::login::*;
|
|
use libpso::packet::ship::{MenuDetail, SmallLeftDialog};
|
|
use libpso::{PacketParseError, PSOPacket};
|
|
use libpso::crypto::bb::PSOBBCipher;
|
|
use libpso::character::character;
|
|
use entity::item;
|
|
|
|
use networking::cipherkeys::{ELSEWHERE_PRIVATE_KEY, ELSEWHERE_PARRAY};
|
|
use networking::serverstate::{SendServerPacket, RecvServerPacket, ServerState, OnConnect, ClientId};
|
|
use networking::interserver::{ServerId, InterserverActor, LoginMessage, ShipMessage, Ship};
|
|
use stats::leveltable::LEVEL_TABLE;
|
|
use libpso::util::{utf8_to_array, utf8_to_utf16_array};
|
|
|
|
use entity::gateway::{EntityGateway, GatewayError};
|
|
use entity::account::{UserAccountId, UserAccountEntity, NewUserSettingsEntity, USERFLAG_NEWCHAR, USERFLAG_DRESSINGROOM};
|
|
use entity::item::{NewItemEntity, ItemDetail, ItemNote, InventoryItemEntity, InventoryEntity, BankEntity, BankIdentifier, EquippedEntity, Meseta};
|
|
use entity::item::weapon::Weapon;
|
|
use entity::item::armor::Armor;
|
|
use entity::item::tech::Technique;
|
|
use entity::item::tool::Tool;
|
|
use entity::item::mag::Mag;
|
|
use entity::character::{CharacterEntity, NewCharacterEntity, CharacterClass, TechLevel};
|
|
|
|
use crate::login::get_login_status;
|
|
use networking::interserver::AuthToken;
|
|
|
|
use pktbuilder::ship::SHIP_MENU_ID;
|
|
|
|
pub const CHARACTER_PORT: u16 = 12001;
|
|
|
|
#[derive(thiserror::Error, Debug)]
|
|
pub enum CharacterError {
|
|
#[error("invalid menu selection {0} {1}")]
|
|
InvalidMenuSelection(u32, u32),
|
|
#[error("client not found {0}")]
|
|
ClientNotFound(ClientId),
|
|
#[error("could not load settings {0}")]
|
|
CouldNotLoadSettings(GatewayError),
|
|
#[error("could not load characters")]
|
|
CouldNotLoadCharacters,
|
|
#[error("could not load guildcard")]
|
|
CouldNotLoadGuildcard,
|
|
#[error("gateway error {0}")]
|
|
GatewayError(#[from] GatewayError),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum RecvCharacterPacket {
|
|
Login(Login),
|
|
RequestSettings(RequestSettings),
|
|
CharSelect(CharSelect),
|
|
Checksum(Checksum),
|
|
GuildcardDataRequest(GuildcardDataRequest),
|
|
GuildcardDataChunkRequest(GuildcardDataChunkRequest),
|
|
ParamDataRequest(ParamDataRequest),
|
|
ParamDataChunkRequest(ParamDataChunkRequest),
|
|
CharacterPreview(CharacterPreview),
|
|
SetFlag(SetFlag),
|
|
MenuSelect(MenuSelect),
|
|
MenuDetail(MenuDetail),
|
|
}
|
|
|
|
impl RecvServerPacket for RecvCharacterPacket {
|
|
fn from_bytes(data: &[u8]) -> Result<RecvCharacterPacket, PacketParseError> {
|
|
match u16::from_le_bytes([data[2], data[3]]) {
|
|
0x93 => Ok(RecvCharacterPacket::Login(Login::from_bytes(data)?)),
|
|
0xE0 => Ok(RecvCharacterPacket::RequestSettings(RequestSettings::from_bytes(data)?)),
|
|
0xE3 => Ok(RecvCharacterPacket::CharSelect(CharSelect::from_bytes(data)?)),
|
|
0x1E8 => Ok(RecvCharacterPacket::Checksum(Checksum::from_bytes(data)?)),
|
|
0x3E8 => Ok(RecvCharacterPacket::GuildcardDataRequest(GuildcardDataRequest::from_bytes(data)?)),
|
|
0x3DC => Ok(RecvCharacterPacket::GuildcardDataChunkRequest(GuildcardDataChunkRequest::from_bytes(data)?)),
|
|
0x4EB => Ok(RecvCharacterPacket::ParamDataRequest(ParamDataRequest::from_bytes(data)?)),
|
|
0x3EB => Ok(RecvCharacterPacket::ParamDataChunkRequest(ParamDataChunkRequest::from_bytes(data)?)),
|
|
0xE5 => Ok(RecvCharacterPacket::CharacterPreview(CharacterPreview::from_bytes(data)?)),
|
|
0xEC => Ok(RecvCharacterPacket::SetFlag(SetFlag::from_bytes(data)?)),
|
|
0x10 => Ok(RecvCharacterPacket::MenuSelect(MenuSelect::from_bytes(data)?)),
|
|
0x09 => Ok(RecvCharacterPacket::MenuDetail(MenuDetail::from_bytes(data)?)),
|
|
_ => Err(PacketParseError::WrongPacketForServerType(u16::from_le_bytes([data[2], data[3]]), data.to_vec()))
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#[derive(Debug)]
|
|
pub enum SendCharacterPacket {
|
|
LoginResponse(LoginResponse),
|
|
LoginWelcome(LoginWelcome),
|
|
SendKeyAndTeamSettings(Box<SendKeyAndTeamSettings>),
|
|
CharAck(CharAck),
|
|
ChecksumAck(ChecksumAck),
|
|
CharacterPreview(CharacterPreview),
|
|
GuildcardDataHeader(GuildcardDataHeader),
|
|
GuildcardDataChunk(Box<GuildcardDataChunk>),
|
|
ParamDataHeader(ParamDataHeader),
|
|
ParamDataChunk(Box<ParamDataChunk>),
|
|
Timestamp(Timestamp),
|
|
ShipList(ShipList),
|
|
RedirectClient(RedirectClient),
|
|
SmallLeftDialog(SmallLeftDialog),
|
|
}
|
|
|
|
impl SendServerPacket for SendCharacterPacket {
|
|
fn as_bytes(&self) -> Vec<u8> {
|
|
match self {
|
|
SendCharacterPacket::LoginResponse(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::LoginWelcome(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::SendKeyAndTeamSettings(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::CharAck(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::ChecksumAck(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::CharacterPreview(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::GuildcardDataHeader(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::GuildcardDataChunk(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::ParamDataHeader(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::ParamDataChunk(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::Timestamp(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::ShipList(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::RedirectClient(pkt) => pkt.as_bytes(),
|
|
SendCharacterPacket::SmallLeftDialog(pkt) => pkt.as_bytes(),
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
fn generate_param_data(path: &str) -> (ParamDataHeader, Vec<u8>) {
|
|
let paths = std::fs::read_dir(path).expect("could not find param/ directory");
|
|
|
|
let mut files = Vec::new();
|
|
let mut buffer = Vec::new();
|
|
for p in paths {
|
|
let param = p.unwrap().path();
|
|
let mut file = std::fs::File::open(¶m).unwrap();
|
|
|
|
let mut filebuf = Vec::new();
|
|
let len = file.read_to_end(&mut filebuf).unwrap();
|
|
|
|
let mut crc = crc32::Digest::new(crc32::IEEE);
|
|
crc.write(&filebuf[..]);
|
|
|
|
files.push(ParamFile {
|
|
size: len as u32,
|
|
checksum: crc.sum32(),
|
|
offset: buffer.len() as u32,
|
|
filename: utf8_to_array(param.file_name().unwrap().to_str().unwrap()),
|
|
});
|
|
|
|
buffer.append(&mut filebuf);
|
|
}
|
|
|
|
(ParamDataHeader {
|
|
files
|
|
}, buffer)
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
struct ClientState {
|
|
param_index: usize,
|
|
user: Option<UserAccountEntity>,
|
|
characters: Option<[Option<CharacterEntity>; 4]>,
|
|
guildcard_data_buffer: Option<Vec<u8>>,
|
|
session: Session,
|
|
}
|
|
|
|
impl ClientState {
|
|
fn new() -> ClientState {
|
|
ClientState {
|
|
param_index: 0,
|
|
user: None,
|
|
characters: None,
|
|
guildcard_data_buffer: None,
|
|
session: Session::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct ConnectedClient {
|
|
ship_id: Option<ServerId>,
|
|
expires: Option<chrono::DateTime<chrono::Utc>>,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct CharacterServerState<EG: EntityGateway + Clone> {
|
|
entity_gateway: EG,
|
|
param_header: ParamDataHeader,
|
|
param_data: Arc<Vec<u8>>,
|
|
clients: Arc<RwLock<HashMap<ClientId, ClientState>>>,
|
|
ships: Arc<RwLock<BTreeMap<ServerId, Ship>>>,
|
|
auth_token: AuthToken,
|
|
|
|
connected_clients: Arc<RwLock<BTreeMap<UserAccountId, ConnectedClient>>>,
|
|
authenticated_ships: Arc<RwLock<BTreeSet<ServerId>>>,
|
|
ship_sender: Arc<RwLock<BTreeMap<ServerId, channel::Sender<LoginMessage>>>>,
|
|
}
|
|
|
|
|
|
async fn new_character<EG: EntityGateway + Clone>(entity_gateway: &mut EG, user: &UserAccountEntity, preview: &CharacterPreview) -> Result<(), anyhow::Error> {
|
|
let mut character = new_character_from_preview(user, preview);
|
|
match character.char_class {
|
|
CharacterClass::FOmar | CharacterClass::FOmarl| CharacterClass::FOnewm | CharacterClass::FOnewearl => character.techs.set_tech(Technique::Foie, TechLevel(1)),
|
|
_ => {}
|
|
}
|
|
|
|
let character = entity_gateway.create_character(character).await?;
|
|
entity_gateway.set_character_meseta(&character.id, Meseta(300)).await?;
|
|
entity_gateway.set_bank_meseta(&character.id, &BankIdentifier::Character, Meseta(0)).await?;
|
|
|
|
let new_weapon = match character.char_class {
|
|
CharacterClass::HUmar | CharacterClass::HUnewearl | CharacterClass::HUcast | CharacterClass::HUcaseal => item::weapon::WeaponType::Saber,
|
|
CharacterClass::RAmar | CharacterClass::RAmarl | CharacterClass::RAcast | CharacterClass::RAcaseal => item::weapon::WeaponType::Handgun,
|
|
CharacterClass::FOmar | CharacterClass::FOmarl | CharacterClass::FOnewm | CharacterClass::FOnewearl => item::weapon::WeaponType::Cane,
|
|
};
|
|
|
|
|
|
let weapon = entity_gateway.create_item(
|
|
NewItemEntity {
|
|
item : ItemDetail::Weapon(
|
|
Weapon {
|
|
weapon: new_weapon,
|
|
grind: 0,
|
|
special: None,
|
|
attrs: [None; 3],
|
|
tekked: true,
|
|
})}).await?;
|
|
|
|
entity_gateway.add_item_note(&weapon.id, ItemNote::CharacterCreation {
|
|
character_id: character.id,
|
|
}).await?;
|
|
|
|
let armor = entity_gateway.create_item(
|
|
NewItemEntity {
|
|
item: ItemDetail::Armor (
|
|
Armor {
|
|
armor: item::armor::ArmorType::Frame,
|
|
dfp: 0,
|
|
evp: 0,
|
|
slots: 0,
|
|
})}).await?;
|
|
|
|
entity_gateway.add_item_note(&armor.id, ItemNote::CharacterCreation {
|
|
character_id: character.id,
|
|
}).await?;
|
|
|
|
let mut mag = {
|
|
if character.char_class.is_android() {
|
|
Mag::baby_mag(character.appearance.skin)
|
|
} else {
|
|
Mag::baby_mag(character.appearance.costume)
|
|
}
|
|
};
|
|
mag.change_owner(character.char_class, character.section_id);
|
|
let mag = entity_gateway.create_item(
|
|
NewItemEntity {
|
|
item: ItemDetail::Mag(mag),
|
|
}).await?;
|
|
|
|
entity_gateway.add_item_note(&mag.id, ItemNote::CharacterCreation {
|
|
character_id: character.id,
|
|
}).await?;
|
|
|
|
entity_gateway.change_mag_owner(&mag.id, &character).await?;
|
|
|
|
let mut monomates = Vec::new();
|
|
for _ in 0..4usize {
|
|
let monomate = entity_gateway.create_item(
|
|
NewItemEntity {
|
|
item: ItemDetail::Tool (
|
|
Tool {
|
|
tool: item::tool::ToolType::Monomate,
|
|
})}).await?;
|
|
|
|
entity_gateway.add_item_note(&monomate.id, ItemNote::CharacterCreation {
|
|
character_id: character.id
|
|
}).await?;
|
|
|
|
monomates.push(monomate);
|
|
}
|
|
|
|
let mut monofluids = Vec::new();
|
|
for _ in 0..4usize {
|
|
let monofluid = entity_gateway.create_item(
|
|
NewItemEntity {
|
|
item: ItemDetail::Tool (
|
|
Tool {
|
|
tool: item::tool::ToolType::Monofluid,
|
|
})}).await?;
|
|
|
|
entity_gateway.add_item_note(&monofluid.id, ItemNote::CharacterCreation {
|
|
character_id: character.id
|
|
}).await?;
|
|
|
|
monofluids.push(monofluid);
|
|
}
|
|
|
|
let inventory = InventoryEntity {
|
|
items: vec![InventoryItemEntity::Individual(weapon.clone()), InventoryItemEntity::Individual(armor.clone()), InventoryItemEntity::Individual(mag.clone()),
|
|
InventoryItemEntity::Stacked(monomates), InventoryItemEntity::Stacked(monofluids)],
|
|
};
|
|
entity_gateway.set_character_inventory(&character.id, &inventory).await?;
|
|
entity_gateway.set_character_bank(&character.id, &BankEntity::default(), &BankIdentifier::Character).await?;
|
|
let equipped = EquippedEntity {
|
|
weapon: Some(weapon.id),
|
|
armor: Some(armor.id),
|
|
mag: Some(mag.id),
|
|
..Default::default()
|
|
};
|
|
entity_gateway.set_character_equips(&character.id, &equipped).await?;
|
|
Ok(())
|
|
}
|
|
|
|
|
|
impl<EG: EntityGateway + Clone> CharacterServerState<EG> {
|
|
pub fn new(entity_gateway: EG, auth_token: AuthToken) -> CharacterServerState<EG> {
|
|
let (param_header, param_data) = generate_param_data("data/param/");
|
|
|
|
CharacterServerState {
|
|
entity_gateway,
|
|
param_header,
|
|
param_data: Arc::new(param_data),
|
|
clients: Default::default(),
|
|
ships: Default::default(),
|
|
//level_table: CharacterLevelTable::default(),
|
|
auth_token,
|
|
authenticated_ships: Default::default(),
|
|
ship_sender: Default::default(),
|
|
connected_clients: Default::default(),
|
|
}
|
|
}
|
|
|
|
async fn validate_login(&mut self, id: ClientId, pkt: &Login) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
|
|
match get_login_status(&mut self.entity_gateway, pkt).await {
|
|
Ok(user) => {
|
|
if let Some(connected_client) = self.connected_clients.read().await.get(&user.id) {
|
|
if let Some(expires) = connected_client.expires {
|
|
if expires > chrono::Utc::now() {
|
|
return Ok(vec![SendCharacterPacket::LoginResponse(LoginResponse::by_status(AccountStatus::AlreadyOnline, Session::default()))]);
|
|
}
|
|
}
|
|
else {
|
|
return Ok(vec![SendCharacterPacket::LoginResponse(LoginResponse::by_status(AccountStatus::AlreadyOnline, Session::default()))]);
|
|
}
|
|
}
|
|
|
|
let mut response = LoginResponse::by_status(AccountStatus::Ok, Session::default());
|
|
response.guildcard = user.guildcard;
|
|
response.team_id = user.team_id.map_or(0, |ti| ti);
|
|
|
|
let mut client = self.clients.write().await;
|
|
let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
|
|
|
|
self.connected_clients.write().await.insert(user.id, ConnectedClient {
|
|
ship_id: None,
|
|
expires: None, //Some(chrono::Utc::now() + chrono::Duration::minutes(1)),
|
|
});
|
|
|
|
client.user = Some(user);
|
|
client.session = pkt.session;
|
|
Ok(vec![SendCharacterPacket::LoginResponse(response)])
|
|
},
|
|
Err(err) => {
|
|
Ok(vec![SendCharacterPacket::LoginResponse(LoginResponse::by_status(err, Session::default()))])
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn send_ship_list(&mut self, _id: ClientId, _pkt: &Login) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
|
|
Ok(vec![SendCharacterPacket::Timestamp(Timestamp::new(chrono::Utc::now())),
|
|
SendCharacterPacket::ShipList(ShipList::new(self.ships.read().await.iter().map(|(i, s)| {
|
|
ShipListEntry {
|
|
menu: SHIP_MENU_ID,
|
|
item: i.0 as u32,
|
|
flags: 0,
|
|
name: utf8_to_utf16_array(&s.name)
|
|
}
|
|
}).collect()))
|
|
])
|
|
}
|
|
|
|
async fn get_settings(&mut self, id: ClientId) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
|
|
let mut client = self.clients.write().await;
|
|
let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
|
|
let user = client.user.as_ref().unwrap();
|
|
|
|
let settings = match self.entity_gateway.get_user_settings_by_user(user).await {
|
|
Ok(settings) => settings,
|
|
Err(_) => {
|
|
let user_settings = NewUserSettingsEntity::new(user.id);
|
|
self.entity_gateway.create_user_settings(user_settings).await.map_err(CharacterError::CouldNotLoadSettings)?
|
|
}
|
|
};
|
|
|
|
let pkt = SendKeyAndTeamSettings::new(settings.settings.keyboard_config,
|
|
settings.settings.gamepad_config, 0, 0);
|
|
let pkt = SendCharacterPacket::SendKeyAndTeamSettings(Box::new(pkt));
|
|
|
|
Ok(vec![pkt])
|
|
}
|
|
|
|
async fn char_select(&mut self, id: ClientId, select: &CharSelect) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
|
|
let mut client = self.clients.write().await;
|
|
let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
|
|
if client.characters.is_none() {
|
|
client.characters = Some(self.entity_gateway.get_characters_by_user(client.user.as_ref().unwrap()).await.map_err(|_| CharacterError::CouldNotLoadCharacters)?);
|
|
}
|
|
|
|
if select.reason == 0 {
|
|
let chars = client.characters.as_ref().unwrap();
|
|
Ok(if let Some(char) = &chars[select.slot as usize] {
|
|
let (level, _stats) = LEVEL_TABLE.get_stats_from_exp(char.char_class, char.exp);
|
|
vec![SendCharacterPacket::CharacterPreview(CharacterPreview {
|
|
slot: select.slot,
|
|
character: SelectScreenCharacterBuilder::new()
|
|
.character(char)
|
|
.level(level)
|
|
.build()
|
|
})]
|
|
}
|
|
else {
|
|
vec![SendCharacterPacket::CharAck(CharAck {
|
|
slot: select.slot,
|
|
code: 2,
|
|
})]
|
|
})
|
|
}
|
|
else {
|
|
let user = client.user.as_ref().unwrap();
|
|
client.session.action = SessionAction::SelectCharacter;
|
|
client.session.character_slot = select.slot as u8;
|
|
Ok(vec![SendCharacterPacket::LoginResponse(LoginResponse::by_char_select(user.guildcard,
|
|
user.team_id.unwrap_or(1),
|
|
client.session)),
|
|
SendCharacterPacket::CharAck(CharAck {
|
|
slot: select.slot,
|
|
code: 1,
|
|
})
|
|
])
|
|
}
|
|
}
|
|
|
|
fn validate_checksum(&mut self) -> Vec<SendCharacterPacket> {
|
|
vec![SendCharacterPacket::ChecksumAck(ChecksumAck {
|
|
ack: 1,
|
|
})]
|
|
}
|
|
|
|
async fn guildcard_data_header(&mut self, id: ClientId) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
|
|
let mut client = self.clients.write().await;
|
|
let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
|
|
let guildcard_data = self.entity_gateway.get_guild_card_data_by_user(client.user.as_ref().unwrap()).await.map_err(|_| CharacterError::CouldNotLoadGuildcard)?;
|
|
|
|
let bytes = guildcard_data.guildcard.as_bytes();
|
|
let mut crc = crc32::Digest::new(crc32::IEEE);
|
|
crc.write(&bytes[..]);
|
|
client.guildcard_data_buffer = Some(bytes.to_vec());
|
|
|
|
Ok(vec![SendCharacterPacket::GuildcardDataHeader(GuildcardDataHeader::new(bytes.len(), crc.sum32()))])
|
|
}
|
|
|
|
async fn guildcard_data_chunk(&mut self, id: ClientId, chunk: u32, again: u32) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
|
|
let mut client = self.clients.write().await;
|
|
let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
|
|
Ok(if again != 0 {
|
|
let start = chunk as usize * GUILD_CARD_CHUNK_SIZE;
|
|
let len = std::cmp::min(GUILD_CARD_CHUNK_SIZE, client.guildcard_data_buffer.as_ref().unwrap().len() - start);
|
|
let end = start + len;
|
|
|
|
let mut buf = [0u8; GUILD_CARD_CHUNK_SIZE];
|
|
buf[..len].copy_from_slice(&client.guildcard_data_buffer.as_ref().unwrap()[start..end]);
|
|
|
|
vec![SendCharacterPacket::GuildcardDataChunk(Box::new(GuildcardDataChunk::new(chunk, buf, len)))]
|
|
} else {
|
|
Vec::new()
|
|
})
|
|
}
|
|
|
|
async fn set_flag(&mut self, id: ClientId, setflag: &SetFlag) -> Result<std::option::IntoIter<SendCharacterPacket>, anyhow::Error> {
|
|
let mut client = self.clients.write().await;
|
|
let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
|
|
let user = client.user.as_mut().unwrap();
|
|
user.flags = setflag.flags;
|
|
self.entity_gateway.save_user(user).await.unwrap();
|
|
Ok(None.into_iter())
|
|
}
|
|
|
|
async fn param_data_chunk_request(&mut self, id: ClientId, _request: &ParamDataChunkRequest) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
|
|
let mut client = self.clients.write().await;
|
|
let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
|
|
let chunk = client.param_index;
|
|
client.param_index += 1;
|
|
|
|
let start = chunk * 0x6800;
|
|
let end = std::cmp::min((chunk+1)*0x6800, self.param_data.len());
|
|
|
|
let mut data = [0u8; 0x6800];
|
|
data[..end-start].copy_from_slice(&self.param_data[start..end]);
|
|
|
|
Ok(vec![SendCharacterPacket::ParamDataChunk(
|
|
Box::new(ParamDataChunk {
|
|
chunk: chunk as u32,
|
|
data,
|
|
})
|
|
)])
|
|
}
|
|
|
|
|
|
// TODO: move USERFLAGS over to SessionAction
|
|
async fn character_preview(&mut self, id: ClientId, preview: &CharacterPreview) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
|
|
let mut client = self.clients.write().await;
|
|
let client = client.get_mut(&id).ok_or_else(|| CharacterError::ClientNotFound(id))?;
|
|
let user = client.user.as_mut().unwrap();
|
|
if user.flags == USERFLAG_NEWCHAR {
|
|
new_character(&mut self.entity_gateway, user, preview).await?
|
|
}
|
|
if user.flags == USERFLAG_DRESSINGROOM {
|
|
// TODO: dressing room stuff
|
|
}
|
|
|
|
client.session.action = SessionAction::SelectCharacter;
|
|
client.session.character_slot = preview.slot as u8;
|
|
user.flags = 0;
|
|
self.entity_gateway.save_user(user).await.unwrap();
|
|
Ok(vec![SendCharacterPacket::LoginResponse(LoginResponse::by_char_select(user.guildcard,
|
|
user.team_id.unwrap_or(1),
|
|
client.session)),
|
|
SendCharacterPacket::CharAck(CharAck {
|
|
slot: preview.slot,
|
|
code: 0
|
|
})
|
|
])
|
|
}
|
|
|
|
async fn select_ship(&mut self, id: ClientId, menuselect: &MenuSelect) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
|
|
if menuselect.menu != SHIP_MENU_ID {
|
|
return Err(CharacterError::InvalidMenuSelection(menuselect.menu, menuselect.item).into());
|
|
}
|
|
|
|
if let Some(client) = self.clients.read().await.get(&id) {
|
|
if let Some(user) = &client.user {
|
|
if let Some(cc) = self.connected_clients.write().await.get_mut(&user.id) {
|
|
cc.ship_id = Some(ServerId(menuselect.item as usize));
|
|
}
|
|
}
|
|
}
|
|
|
|
let ship = self.ships.read().await;
|
|
let ship = ship.get(&ServerId(menuselect.item as usize))
|
|
.ok_or_else(|| CharacterError::InvalidMenuSelection(menuselect.menu, menuselect.item))?;
|
|
Ok(vec![SendCharacterPacket::RedirectClient(RedirectClient::new(u32::from_le_bytes(ship.ip.octets()), ship.port))])
|
|
}
|
|
|
|
async fn ship_detail(&mut self, menudetail: &MenuDetail) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
|
|
let players = self.connected_clients
|
|
.read()
|
|
.await
|
|
.iter()
|
|
.filter(|(_, client)| {
|
|
client.ship_id == Some(ServerId(menudetail.item as usize))
|
|
})
|
|
.count();
|
|
let ship_details = format!("players: {}\nrooms: {}", players, 0);
|
|
Ok(vec![SendCharacterPacket::SmallLeftDialog(SmallLeftDialog::new(ship_details))])
|
|
}
|
|
}
|
|
|
|
#[async_trait::async_trait]
|
|
impl<EG: EntityGateway + Clone> ServerState for CharacterServerState<EG> {
|
|
type SendPacket = SendCharacterPacket;
|
|
type RecvPacket = RecvCharacterPacket;
|
|
type Cipher = PSOBBCipher;
|
|
type PacketError = anyhow::Error;
|
|
|
|
async fn on_connect(&mut self, id: ClientId) -> Result<Vec<OnConnect<Self::SendPacket, Self::Cipher>>, anyhow::Error> {
|
|
self.clients.write().await.insert(id, ClientState::new());
|
|
|
|
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[..]);
|
|
|
|
Ok(vec![OnConnect::Packet(SendCharacterPacket::LoginWelcome(LoginWelcome::new(server_key, client_key))),
|
|
OnConnect::Cipher(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, client_key),
|
|
PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, server_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))))
|
|
])
|
|
}
|
|
|
|
async fn handle(&mut self, id: ClientId, pkt: RecvCharacterPacket) -> Result<Vec<(ClientId, SendCharacterPacket)>, anyhow::Error> {
|
|
Ok(match pkt {
|
|
RecvCharacterPacket::Login(login) => {
|
|
if login.session.action == SessionAction::SelectCharacter {
|
|
self.send_ship_list(id, &login).await?.into_iter().map(move |pkt| (id, pkt)).collect()
|
|
}
|
|
else {
|
|
self.validate_login(id, &login).await?.into_iter().map(move |pkt| (id, pkt)).collect()
|
|
}
|
|
},
|
|
RecvCharacterPacket::RequestSettings(_req) => {
|
|
self.get_settings(id).await?.into_iter().map(move |pkt| (id, pkt)).collect()
|
|
},
|
|
RecvCharacterPacket::CharSelect(sel) => {
|
|
self.char_select(id, &sel).await?.into_iter().map(move |pkt| (id, pkt)).collect()
|
|
},
|
|
RecvCharacterPacket::Checksum(_checksum) => {
|
|
self.validate_checksum().into_iter().map(move |pkt| (id, pkt)).collect()
|
|
},
|
|
RecvCharacterPacket::GuildcardDataRequest(_request) => {
|
|
self.guildcard_data_header(id).await?.into_iter().map(move |pkt| (id, pkt)).collect()
|
|
},
|
|
RecvCharacterPacket::GuildcardDataChunkRequest(request) => {
|
|
self.guildcard_data_chunk(id, request.chunk, request.again).await?.into_iter().map(move |pkt| (id, pkt)).collect()
|
|
},
|
|
RecvCharacterPacket::ParamDataRequest(_request) => {
|
|
vec![SendCharacterPacket::ParamDataHeader(self.param_header.clone())].into_iter().map(move |pkt| (id, pkt)).collect()
|
|
},
|
|
RecvCharacterPacket::SetFlag(flag) => {
|
|
self.set_flag(id, &flag).await?.map(move |pkt| (id, pkt)).collect()
|
|
},
|
|
RecvCharacterPacket::ParamDataChunkRequest(request) => {
|
|
self.param_data_chunk_request(id, &request).await?.into_iter().map(move |pkt| (id, pkt)).collect()
|
|
},
|
|
RecvCharacterPacket::CharacterPreview(preview) => {
|
|
self.character_preview(id, &preview).await?.into_iter().map(move |pkt| (id, pkt)).collect()
|
|
},
|
|
RecvCharacterPacket::MenuSelect(menuselect) => {
|
|
self.select_ship(id, &menuselect).await?.into_iter().map(move |pkt| (id, pkt)).collect()
|
|
},
|
|
RecvCharacterPacket::MenuDetail(menudetail) => {
|
|
match menudetail.menu {
|
|
SHIP_MENU_ID => self.ship_detail(&menudetail).await?.into_iter().map(move |pkt| (id, pkt)).collect(),
|
|
_ => Vec::new()
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
async fn on_disconnect(&mut self, id: ClientId) -> Result<Vec<(ClientId, SendCharacterPacket)>, anyhow::Error> {
|
|
if let Some(client) = self.clients.write().await.remove(&id) {
|
|
if let Some(user) = client.user {
|
|
self.connected_clients.write().await.remove(&user.id);
|
|
}
|
|
}
|
|
Ok(Vec::new())
|
|
}
|
|
}
|
|
|
|
#[async_trait::async_trait]
|
|
impl<EG: EntityGateway + Clone> InterserverActor for CharacterServerState<EG> {
|
|
type SendMessage = LoginMessage;
|
|
type RecvMessage = ShipMessage;
|
|
type Error = ();
|
|
|
|
async fn on_connect(&mut self, _id: ServerId) -> Vec<(ServerId, Self::SendMessage)> {
|
|
Vec::new()
|
|
}
|
|
|
|
async fn on_action(&mut self, id: ServerId, msg: Self::RecvMessage) -> Result<Vec<(ServerId, Self::SendMessage)>, Self::Error> {
|
|
dbg!(&id, &msg);
|
|
match msg {
|
|
ShipMessage::Authenticate(auth_token) => {
|
|
if self.auth_token == auth_token {
|
|
self.authenticated_ships.write().await.insert(id);
|
|
}
|
|
Ok(Vec::new())
|
|
},
|
|
ShipMessage::NewShip(new_ship) => {
|
|
dbg!("adding ship", &id, &new_ship);
|
|
if self.authenticated_ships.read().await.contains(&id) {
|
|
self.ships.write().await.insert(id, new_ship);
|
|
}
|
|
dbg!("ship list", &self.authenticated_ships);
|
|
|
|
let ships = self.ships.read().await.iter().map(|(_, s)| s).cloned().collect::<Vec<_>>();
|
|
Ok(self.ships
|
|
.read()
|
|
.await
|
|
.iter()
|
|
.map(|(id, _)| {
|
|
(*id, LoginMessage::ShipList{ ships: ships.clone() })
|
|
})
|
|
.collect())
|
|
},
|
|
ShipMessage::AddUser(new_user) => {
|
|
if self.authenticated_ships.read().await.contains(&id) {
|
|
self.connected_clients.write().await.insert(new_user, ConnectedClient {
|
|
ship_id: Some(id),
|
|
expires: None,
|
|
});
|
|
}
|
|
Ok(Vec::new())
|
|
},
|
|
ShipMessage::RemoveUser(new_user) => {
|
|
if self.authenticated_ships.read().await.contains(&id) {
|
|
self.connected_clients.write().await.remove(&new_user);
|
|
}
|
|
Ok(Vec::new())
|
|
},
|
|
ShipMessage::RequestShipList => {
|
|
dbg!("request ship list", &self.authenticated_ships);
|
|
if self.authenticated_ships.read().await.contains(&id) {
|
|
Ok(vec![(id, LoginMessage::ShipList {
|
|
ships: self.ships
|
|
.read()
|
|
.await
|
|
.iter()
|
|
.map(|(_, ship)| {
|
|
ship
|
|
})
|
|
.cloned()
|
|
.collect()
|
|
})])
|
|
}
|
|
else {
|
|
Ok(Vec::new())
|
|
}
|
|
},
|
|
ShipMessage::SendMail{..} => {
|
|
Ok(Vec::new())
|
|
},
|
|
}
|
|
}
|
|
|
|
async fn on_disconnect(&mut self, id: ServerId) -> Vec<(ServerId, Self::SendMessage)> {
|
|
self.ships.write().await.remove(&id);
|
|
self.ship_sender.write().await.remove(&id);
|
|
self.connected_clients
|
|
.write()
|
|
.await
|
|
.retain(|_, client| {
|
|
client.ship_id != Some(id)
|
|
});
|
|
Vec::new()
|
|
}
|
|
|
|
async fn set_sender(&mut self, server_id: ServerId, sender: channel::Sender<LoginMessage>) {
|
|
self.ship_sender.write().await.insert(server_id, sender);
|
|
}
|
|
}
|
|
|
|
|
|
fn new_character_from_preview(user: &UserAccountEntity, preview: &CharacterPreview) -> NewCharacterEntity {
|
|
let mut character = NewCharacterEntity::new(user.id);
|
|
character.slot = preview.slot;
|
|
character.name = String::from_utf16_lossy(&preview.character.name).trim_matches(char::from(0)).into();
|
|
character.section_id = preview.character.section_id.into();
|
|
character.char_class = preview.character.ch_class.into();
|
|
character.appearance.costume = preview.character.costume;
|
|
character.appearance.skin = preview.character.skin;
|
|
character.appearance.face = preview.character.face;
|
|
character.appearance.head = preview.character.head;
|
|
character.appearance.hair = preview.character.hair;
|
|
character.appearance.hair_r = preview.character.hair_r;
|
|
character.appearance.hair_g = preview.character.hair_g;
|
|
character.appearance.hair_b = preview.character.hair_b;
|
|
character.appearance.prop_x = preview.character.prop_x;
|
|
character.appearance.prop_y = preview.character.prop_y;
|
|
character
|
|
}
|
|
|
|
|
|
struct SelectScreenCharacterBuilder<'a> {
|
|
character: Option<&'a CharacterEntity>,
|
|
level: Option<u32>,
|
|
}
|
|
|
|
impl<'a> SelectScreenCharacterBuilder<'a> {
|
|
fn new() -> SelectScreenCharacterBuilder<'a> {
|
|
SelectScreenCharacterBuilder {
|
|
character: None,
|
|
level: None,
|
|
}
|
|
}
|
|
|
|
fn character(self, character: &'a CharacterEntity) -> SelectScreenCharacterBuilder<'a> {
|
|
SelectScreenCharacterBuilder {
|
|
character: Some(character),
|
|
..self
|
|
}
|
|
}
|
|
|
|
fn level(self, level: u32) -> SelectScreenCharacterBuilder<'a> {
|
|
SelectScreenCharacterBuilder {
|
|
level: Some(level),
|
|
..self
|
|
}
|
|
}
|
|
|
|
fn build(self) -> character::SelectScreenCharacter {
|
|
let character = self.character.unwrap();
|
|
let level = self.level.unwrap();
|
|
|
|
character::SelectScreenCharacter {
|
|
//exp: character.exp,
|
|
level: level - 1,
|
|
//guildcard: character.guildcard,
|
|
//_unknown: character._unknown3,
|
|
//name_color: character.name_color,
|
|
//model: character.model,
|
|
//_unused: [0; 15],
|
|
//name_color_checksum: character.name_color_checksum,
|
|
section_id: character.section_id.into(),
|
|
ch_class: character.char_class.into(),
|
|
//v2flags: character.v2flags,
|
|
//version: character.version,
|
|
//v1flags: character.v1flags,
|
|
costume: character.appearance.costume,
|
|
skin: character.appearance.skin,
|
|
face: character.appearance.face,
|
|
head: character.appearance.head,
|
|
hair: character.appearance.hair,
|
|
hair_r: character.appearance.hair_r,
|
|
hair_g: character.appearance.hair_g,
|
|
hair_b: character.appearance.hair_b,
|
|
prop_x: character.appearance.prop_x,
|
|
prop_y: character.appearance.prop_y,
|
|
name: utf8_to_utf16_array(&character.name),
|
|
play_time: character.playtime,
|
|
..character::SelectScreenCharacter::default()
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
use entity::account::*;
|
|
use libpso::character::{settings, character};
|
|
use entity::gateway::{InMemoryGateway, EntityGatewayTransaction, GatewayError};
|
|
|
|
#[derive(Clone)]
|
|
struct CharTestDb;
|
|
|
|
impl EntityGateway for CharTestDb {
|
|
type Transaction<'t> = CharTestDb where Self: 't;
|
|
}
|
|
|
|
impl EntityGatewayTransaction for CharTestDb {
|
|
type ParentGateway = CharTestDb;
|
|
}
|
|
|
|
|
|
#[async_std::test]
|
|
async fn test_option_send() {
|
|
#[derive(Clone)]
|
|
struct TestData {
|
|
}
|
|
|
|
#[async_trait::async_trait]
|
|
impl EntityGateway for TestData {
|
|
type Transaction<'a> = CharTestDb where Self: 'a;
|
|
async fn get_user_settings_by_user(&mut self, user: &UserAccountEntity) -> Result<UserSettingsEntity, GatewayError> {
|
|
Ok(UserSettingsEntity {
|
|
id: UserSettingsId(0),
|
|
user_id: user.id,
|
|
settings: settings::UserSettings::default()
|
|
})
|
|
}
|
|
}
|
|
|
|
let mut server = CharacterServerState::new(TestData {}, AuthToken("".into()));
|
|
let mut clientstate = ClientState::new();
|
|
clientstate.user = Some(UserAccountEntity {
|
|
id: UserAccountId(1),
|
|
username: "testuser".to_owned(),
|
|
password: bcrypt::hash("mypassword", 5).unwrap(),
|
|
guildcard: 0,
|
|
banned_until: None,
|
|
muted_until: None,
|
|
created_at: chrono::Utc::now(),
|
|
team_id: None,
|
|
flags: 0,
|
|
activated: true,
|
|
at_login: false,
|
|
at_character: false,
|
|
at_ship: false,
|
|
});
|
|
server.clients.write().await.insert(ClientId(5), clientstate);
|
|
|
|
let send = server.handle(ClientId(5), RecvCharacterPacket::RequestSettings(RequestSettings{})).await.unwrap();
|
|
assert!(send.len() == 1);
|
|
|
|
assert!(send[0].0 == ClientId(5));
|
|
let bytes = send[0].1.as_bytes();
|
|
assert!(bytes[2] == 0xE2);
|
|
assert!(bytes.len() == 0xAFC);
|
|
}
|
|
|
|
#[async_std::test]
|
|
async fn test_user_checksum() {
|
|
#[derive(Clone)]
|
|
struct TestData;
|
|
impl EntityGateway for TestData {
|
|
type Transaction<'a> = CharTestDb where Self: 'a;
|
|
}
|
|
let mut server = CharacterServerState::new(TestData {}, AuthToken("".into()));
|
|
let send = server.handle(ClientId(1), RecvCharacterPacket::Checksum(Checksum {checksum: 1234,
|
|
padding: 0,
|
|
})).await.unwrap();
|
|
assert!(send.len() == 1);
|
|
|
|
let bytes = send[0].1.as_bytes();
|
|
assert!(bytes == [0xC, 0, 0xE8, 0x02, 0,0,0,0, 1,0,0,0]);
|
|
}
|
|
|
|
#[async_std::test]
|
|
async fn test_character_create() {
|
|
let mut test_data = InMemoryGateway::default();
|
|
let mut fake_user = ClientState::new();
|
|
fake_user.user = Some(UserAccountEntity {
|
|
id: UserAccountId(3),
|
|
username: "hi3".to_string(),
|
|
password: bcrypt::hash("qwer", 5).unwrap(),
|
|
guildcard: 3,
|
|
team_id: None,
|
|
banned_until: None,
|
|
muted_until: None,
|
|
created_at: chrono::Utc::now(),
|
|
flags: 0,
|
|
activated: true,
|
|
at_login: false,
|
|
at_character: false,
|
|
at_ship: false,
|
|
});
|
|
|
|
let mut server = CharacterServerState::new(test_data.clone(), AuthToken("".into()));
|
|
server.clients.write().await.insert(ClientId(1), fake_user.clone());
|
|
let mut send = server.handle(ClientId(1), RecvCharacterPacket::SetFlag(SetFlag {flags: 1})).await.unwrap();
|
|
assert!(test_data.get_user_by_id(UserAccountId(3)).await.unwrap().flags == 1);
|
|
send = server.handle(ClientId(1), RecvCharacterPacket::CharacterPreview(CharacterPreview {slot: 1, character: character::SelectScreenCharacter {
|
|
exp: 0,
|
|
level: 0,
|
|
guildcard: [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
|
|
_unknown: [0, 0],
|
|
name_color: 4294967295,
|
|
model: 0,
|
|
_unused: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
|
|
name_color_checksum: 0,
|
|
section_id: 4,
|
|
ch_class: 2,
|
|
v2flags: 0,
|
|
version: 3,
|
|
v1flags: 49,
|
|
costume: 0,
|
|
skin: 4,
|
|
face: 0,
|
|
head: 0,
|
|
hair: 0,
|
|
hair_r: 0,
|
|
hair_g: 0,
|
|
hair_b: 0,
|
|
prop_x: 0.33333334,
|
|
prop_y: 0.0,
|
|
name: [9, 69, 116, 101, 115, 116, 32, 110, 97, 109, 101, 0, 0, 0, 0, 0], // "\tEtest name"
|
|
play_time: 0,
|
|
} })).await.unwrap();
|
|
assert!(send.len() == 2);
|
|
|
|
let chars = test_data.get_characters_by_user(&fake_user.user.unwrap()).await.unwrap();
|
|
assert!(chars[1].as_ref().unwrap().name == "\tEtest name");
|
|
assert!(chars[0].is_none());
|
|
}
|
|
}
|