jake
/
elseware
1
0
Fork 0
Code Issues 63 Pull Requests 1 Projects Releases Wiki Activity
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.
407 Commits
20 Branches
0 Tags
12 MiB
 
Tree: 7ae60fafc5
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7ae60fafc5'
${ noResults }
elseware/src/login/character.rs

772 lines
30 KiB
Raw Blame History

#![allow(dead_code, unused_assignments)]
use std::io::Read;
use std::collections::HashMap;
use rand::Rng;
use crc::{crc32, Hasher32};
use libpso::packet::login::*;
use libpso::{PacketParseError, PSOPacket};
use libpso::crypto::bb::PSOBBCipher;
use crate::entity::item;
use libpso::character::character;
use crate::common::cipherkeys::{ELSEWHERE_PRIVATE_KEY, ELSEWHERE_PARRAY};
use crate::common::serverstate::{SendServerPacket, RecvServerPacket, ServerState, OnConnect, ClientId};
use crate::common::leveltable::CharacterLevelTable;
use libpso::{utf8_to_array, utf8_to_utf16_array};
use crate::entity::gateway::EntityGateway;
use crate::entity::account::{UserAccountEntity, NewUserSettingsEntity, USERFLAG_NEWCHAR, USERFLAG_DRESSINGROOM};
use crate::entity::item::{NewItemEntity, ItemDetail, ItemLocation};
use crate::entity::item::weapon::Weapon;
use crate::entity::item::armor::Armor;
use crate::entity::item::tech::Technique;
use crate::entity::item::tool::Tool;
use crate::entity::item::mag::{Mag, MagType};
use crate::entity::character::{CharacterEntity, NewCharacterEntity, CharacterClass, TechLevel};
use crate::login::login::get_login_status;
pub const CHARACTER_PORT: u16 = 12001;
const SHIP_MENU_ID: u32 = 1;
#[derive(Debug)]
pub enum CharacterError {
InvalidMenuSelection(u32, u32),
ClientNotFound(ClientId),
}
#[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),
}
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)?)),
_ => Err(PacketParseError::WrongPacketForServerType(u16::from_le_bytes([data[2], data[3]]), data.to_vec()))
}
}
}
#[derive(Debug)]
pub enum SendCharacterPacket {
LoginResponse(LoginResponse),
LoginWelcome(LoginWelcome),
SendKeyAndTeamSettings(SendKeyAndTeamSettings),
CharAck(CharAck),
ChecksumAck(ChecksumAck),
CharacterPreview(CharacterPreview),
GuildcardDataHeader(GuildcardDataHeader),
GuildcardDataChunk(GuildcardDataChunk),
ParamDataHeader(ParamDataHeader),
ParamDataChunk(ParamDataChunk),
Timestamp(Timestamp),
ShipList(ShipList),
RedirectClient(RedirectClient),
}
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(),
}
}
}
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(&param).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(), 0x40),
});
buffer.append(&mut filebuf);
}
(ParamDataHeader {
files: 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::new(),
}
}
}
struct Ship {
flags: u32,
name: String,
ip: [u8; 4],
port: u16,
}
impl Ship {
fn new(name: &str, ip: [u8; 4], port: u16) -> Ship {
Ship {
flags: 0,
name: name.to_owned(),
ip: ip,
port: port,
}
}
}
pub struct CharacterServerState<EG: EntityGateway> {
entity_gateway: EG,
param_header: ParamDataHeader,
param_data: Vec<u8>,
clients: HashMap<ClientId, ClientState>,
ships: Vec<Ship>,
level_table: CharacterLevelTable,
}
async fn new_character<EG: EntityGateway>(entity_gateway: &mut EG, user: &UserAccountEntity, preview: &CharacterPreview) {
//let mut character = entity_gateway.new_character_by_user(&user);
//new_character_from_preview(&mut char, preview);
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)),
_ => {}
}
character.meseta = 300;
let character = entity_gateway.create_character(character).await.unwrap();
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,
};
entity_gateway.create_item(
NewItemEntity {
item : ItemDetail::Weapon(
Weapon {
weapon: new_weapon,
grind: 0,
special: None,
attrs: [None; 3],
tekked: true,
}),
location: ItemLocation::Inventory {
character_id: character.id,
slot: 0,
equipped: true,
}}).await;
entity_gateway.create_item(
NewItemEntity {
item: ItemDetail::Armor (
Armor {
armor: item::armor::ArmorType::Frame,
dfp: 0,
evp: 0,
slots: 0,
}),
location: ItemLocation::Inventory {
character_id: character.id,
slot: 1,
equipped: true,
}}).await;
entity_gateway.create_item(
NewItemEntity {
item: ItemDetail::Mag(
Mag {
mag: MagType::Mag,
def: 500,
pow: 0,
dex: 0,
mnd: 0,
synchro: 20,
iq: 0,
photon_blast: [None; 3],
color: (character.appearance.skin % 18) as u8,
}),
location: ItemLocation::Inventory {
character_id: character.id,
slot: 2,
equipped: true,
}}).await;
for _ in 0..4 {
entity_gateway.create_item(
NewItemEntity {
item: ItemDetail::Tool (
Tool {
tool: item::tool::ToolType::Monomate,
}),
location: ItemLocation::Inventory {
character_id: character.id,
slot: 3,
equipped: false,
}}).await;
entity_gateway.create_item(
NewItemEntity {
item: ItemDetail::Tool (
Tool {
tool: item::tool::ToolType::Monofluid,
}),
location: ItemLocation::Inventory {
character_id: character.id,
slot: 4,
equipped: false,
}}).await;
}
}
impl<EG: EntityGateway> CharacterServerState<EG> {
pub fn new(entity_gateway: EG) -> CharacterServerState<EG> {
let (param_header, param_data) = generate_param_data("data/param/");
let ships = vec![Ship::new("Sona-Nyl", [127,0,0,1], 23423),
Ship::new("Dylath-Leen", [127,0,0,1], 23424),
Ship::new("Thalarion", [127,0,0,1], 23425),
];
CharacterServerState {
entity_gateway: entity_gateway,
param_header: param_header,
param_data: param_data,
clients: HashMap::new(),
ships: ships,
level_table: CharacterLevelTable::new(),
}
}
async fn validate_login(&mut self, id: ClientId, pkt: &Login) -> Result<Vec<SendCharacterPacket>, CharacterError> {
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
Ok(match get_login_status(&self.entity_gateway, pkt).await {
Ok(user) => {
let mut response = LoginResponse::by_status(AccountStatus::Ok, Session::new());
response.guildcard = user.guildcard;
response.team_id = user.team_id.map_or(0, |ti| ti) as u32;
client.user = Some(user);
client.session = pkt.session;
vec![SendCharacterPacket::LoginResponse(response)]
},
Err(err) => {
vec![SendCharacterPacket::LoginResponse(LoginResponse::by_status(err, Session::new()))]
}
})
}
fn send_ship_list(&mut self, _id: ClientId, _pkt: &Login) -> Result<Vec<SendCharacterPacket>, CharacterError> {
Ok(vec![SendCharacterPacket::Timestamp(Timestamp::new(chrono::Utc::now())),
SendCharacterPacket::ShipList(ShipList::new(self.ships.iter().enumerate().map(|(i, s)| {
ShipListEntry {
menu: SHIP_MENU_ID,
item: i as u32,
flags: 0,
name: utf8_to_utf16_array!(s.name, 0x11)
}
}).collect()))
])
}
async fn get_settings(&mut self, id: ClientId) -> Result<Vec<SendCharacterPacket>, CharacterError> {
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
let user = client.user.as_ref().unwrap();
// TODO: this should error (data should be added on account creation, why did I copy this silly sylv logic?)
let settings = match self.entity_gateway.get_user_settings_by_user(&user).await {
Some(settings) => settings,
None => {
let user_settings = NewUserSettingsEntity::new(user.id);
self.entity_gateway.create_user_settings(user_settings).await.unwrap()
}
};
let pkt = SendKeyAndTeamSettings::new(settings.settings.key_config,
settings.settings.joystick_config, 0, 0);
let pkt = SendCharacterPacket::SendKeyAndTeamSettings(pkt);
Ok(vec![pkt])
}
async fn char_select(&mut self, id: ClientId, select: &CharSelect) -> Result<Vec<SendCharacterPacket>, CharacterError> {
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
if client.characters.is_none() {
client.characters = Some(self.entity_gateway.get_characters_by_user(client.user.as_ref().unwrap()).await);
}
if select.reason == 0 {
let chars = client.characters.as_ref().unwrap();
Ok(if let Some(char) = &chars[select.slot as usize] {
let (level, _stats) = self.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>, CharacterError> {
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
let guildcard_data = self.entity_gateway.get_guild_card_data_by_user(client.user.as_ref().unwrap()).await;
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()))])
}
fn guildcard_data_chunk(&mut self, id: ClientId, chunk: u32, again: u32) -> Result<Vec<SendCharacterPacket>, CharacterError> {
let client = self.clients.get_mut(&id).ok_or(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() as usize - start);
let end = start + len;
let mut buf = [0u8; GUILD_CARD_CHUNK_SIZE as usize];
buf[..len as usize].copy_from_slice(&client.guildcard_data_buffer.as_ref().unwrap()[start..end]);
vec![SendCharacterPacket::GuildcardDataChunk(GuildcardDataChunk::new(chunk, buf, len))]
} else {
Vec::new()
})
}
async fn set_flag(&mut self, id: ClientId, setflag: &SetFlag) -> Result<std::option::IntoIter<SendCharacterPacket>, CharacterError> {
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
let mut user = client.user.as_mut().unwrap();
user.flags = setflag.flags;
self.entity_gateway.save_user(&user).await;
Ok(None.into_iter())
}
fn param_data_chunk_request(&mut self, id: ClientId, _request: &ParamDataChunkRequest) -> Result<Vec<SendCharacterPacket>, CharacterError> {
let client = self.clients.get_mut(&id).ok_or(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(
ParamDataChunk {
chunk: chunk as u32,
data: data,
}
)])
}
// TODO: move USERFLAGS over to SessionAction
async fn character_preview(&mut self, id: ClientId, preview: &CharacterPreview) -> Result<Vec<SendCharacterPacket>, CharacterError> {
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
let mut 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;
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
})
])
}
fn select_ship(&mut self, menuselect: &MenuSelect) -> Result<Vec<SendCharacterPacket>, CharacterError> {
if menuselect.menu != SHIP_MENU_ID {
return Err(CharacterError::InvalidMenuSelection(menuselect.menu, menuselect.item));
}
let ship = self.ships.get(menuselect.item as usize)
.ok_or(CharacterError::InvalidMenuSelection(menuselect.menu, menuselect.item))?;
Ok(vec![SendCharacterPacket::RedirectClient(RedirectClient::new(u32::from_le_bytes(ship.ip), ship.port))])
}
}
#[async_trait::async_trait]
impl<EG: EntityGateway> ServerState for CharacterServerState<EG> {
type SendPacket = SendCharacterPacket;
type RecvPacket = RecvCharacterPacket;
type PacketError = CharacterError;
fn on_connect(&mut self, id: ClientId) -> Vec<OnConnect<Self::SendPacket>> {
self.clients.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[..]);
vec![OnConnect::Packet(SendCharacterPacket::LoginWelcome(LoginWelcome::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))))
]
}
async fn handle(&mut self, id: ClientId, pkt: &RecvCharacterPacket)
-> Result<Box<dyn Iterator<Item = (ClientId, SendCharacterPacket)> + Send>, CharacterError> {
Ok(match pkt {
RecvCharacterPacket::Login(login) => {
if login.session.action == SessionAction::SelectCharacter {
Box::new(self.send_ship_list(id, login)?.into_iter().map(move |pkt| (id, pkt)))
}
else {
Box::new(self.validate_login(id, login).await?.into_iter().map(move |pkt| (id, pkt)))
}
},
RecvCharacterPacket::RequestSettings(_req) => {
Box::new(self.get_settings(id).await?.into_iter().map(move |pkt| (id, pkt)))
},
RecvCharacterPacket::CharSelect(sel) => {
Box::new(self.char_select(id, sel).await?.into_iter().map(move |pkt| (id, pkt)))
},
RecvCharacterPacket::Checksum(_checksum) => {
Box::new(self.validate_checksum().into_iter().map(move |pkt| (id, pkt)))
},
RecvCharacterPacket::GuildcardDataRequest(_request) => {
Box::new(self.guildcard_data_header(id).await?.into_iter().map(move |pkt| (id, pkt)))
},
RecvCharacterPacket::GuildcardDataChunkRequest(request) => {
Box::new(self.guildcard_data_chunk(id, request.chunk, request.again)?.into_iter().map(move |pkt| (id, pkt)))
},
RecvCharacterPacket::ParamDataRequest(_request) => {
Box::new(vec![SendCharacterPacket::ParamDataHeader(self.param_header.clone())].into_iter().map(move |pkt| (id, pkt)))
},
RecvCharacterPacket::SetFlag(flag) => {
Box::new(self.set_flag(id, flag).await?.map(move |pkt| (id, pkt)))
},
RecvCharacterPacket::ParamDataChunkRequest(request) => {
Box::new(self.param_data_chunk_request(id, request)?.into_iter().map(move |pkt| (id, pkt)))
},
RecvCharacterPacket::CharacterPreview(preview) => {
Box::new(self.character_preview(id, preview).await?.into_iter().map(move |pkt| (id, pkt)))
},
RecvCharacterPacket::MenuSelect(menuselect) => {
Box::new(self.select_ship(menuselect)?.into_iter().map(move |pkt| (id, pkt)))
}
})
}
fn on_disconnect(&mut self, _id: ClientId) -> Vec<(ClientId, SendCharacterPacket)> {
Vec::new()
}
}
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, 16),
//play_time: character.play_time,
..character::SelectScreenCharacter::default()
}
}
}
#[cfg(test)]
mod test {
use super::*;
use crate::entity::account::*;
use libpso::character::{settings, character};
use std::time::SystemTime;
use crate::entity::gateway::{InMemoryGateway};
#[async_std::test]
async fn test_option_send() {
#[derive(Clone)]
struct TestData {
}
#[async_trait::async_trait]
impl EntityGateway for TestData {
async fn get_user_settings_by_user(&self, user: &UserAccountEntity) -> Option<UserSettingsEntity> {
Some(UserSettingsEntity {
id: UserSettingsId(0),
user_id: user.id,
settings: settings::UserSettings::default()
})
}
}
let mut server = CharacterServerState::new(TestData {});
let mut clientstate = ClientState::new();
clientstate.user = Some(UserAccountEntity {
id: UserAccountId(1),
username: "testuser".to_owned(),
password: bcrypt::hash("mypassword", 5).unwrap(),
guildcard: 0,
team_id: None,
banned: false,
muted_until: SystemTime::now(),
created_at: SystemTime::now(),
flags: 0,
});
server.clients.insert(ClientId(5), clientstate);
let send = server.handle(ClientId(5), &RecvCharacterPacket::RequestSettings(RequestSettings{})).await
.unwrap()
.collect::<Vec<_>>();
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 {}
let mut server = CharacterServerState::new(TestData {});
let send = server.handle(ClientId(1), &RecvCharacterPacket::Checksum(Checksum {checksum: 1234,
padding: 0,
})).await.unwrap().collect::<Vec<_>>();
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 test_data = InMemoryGateway::new();
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: false,
muted_until: SystemTime::now(),
created_at: SystemTime::now(),
flags: 0,
});
let mut server = CharacterServerState::new(test_data.clone());
server.clients.insert(ClientId(1), fake_user.clone());
let mut send = server.handle(ClientId(1), &RecvCharacterPacket::SetFlag(SetFlag {flags: 1})).await.unwrap().collect::<Vec<_>>();
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().collect::<Vec<_>>();
assert!(send.len() == 2);
let chars = test_data.get_characters_by_user(&fake_user.user.unwrap()).await;
assert!(chars[1].as_ref().unwrap().name == "\tEtest name");
assert!(chars[0].is_none());
}
}