765 lines
33 KiB
Rust
765 lines
33 KiB
Rust
use std::collections::HashMap;
|
|
use log::warn;
|
|
|
|
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::packet::ship::{BLOCK_MENU_ID, ROOM_MENU_ID};
|
|
use libpso::{utf8_to_array, 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::{UserAccountEntity, UserSettingsEntity, USERFLAG_NEWCHAR, USERFLAG_DRESSINGROOM};
|
|
use crate::entity::character::CharacterEntity;
|
|
use crate::entity::item::{ItemLocation, ItemEntity};
|
|
use crate::login::login::get_login_status;
|
|
use crate::ship::location::{ClientLocation, LobbyId, RoomId, RoomLobby, MAX_ROOMS};
|
|
use crate::ship::character::{CharacterBytesBuilder, FullCharacterBytesBuilder};
|
|
use crate::ship::items;
|
|
use crate::ship::room;
|
|
|
|
pub const SHIP_PORT: u16 = 23423;
|
|
|
|
#[derive(Debug)]
|
|
pub enum ShipError {
|
|
ClientNotFound(ClientId),
|
|
NoCharacterInSlot(ClientId, u32),
|
|
InvalidSlot(ClientId, u32),
|
|
TooManyClients,
|
|
ClientError(String),
|
|
InvalidRoom(u32),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum RecvShipPacket {
|
|
Login(Login),
|
|
MenuSelect(MenuSelect),
|
|
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),
|
|
}
|
|
|
|
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)?)),
|
|
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)?)),
|
|
_ => 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),
|
|
}
|
|
|
|
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(),
|
|
}
|
|
}
|
|
}
|
|
|
|
struct ClientState {
|
|
user: UserAccountEntity,
|
|
settings: UserSettingsEntity,
|
|
character: CharacterEntity,
|
|
session: Session,
|
|
//guildcard: GuildCard,
|
|
inventory: items::ActiveInventory,
|
|
//bank: Bank,
|
|
block: u32,
|
|
}
|
|
|
|
impl ClientState {
|
|
fn new(user: UserAccountEntity, settings: UserSettingsEntity, character: CharacterEntity, inventory: items::ActiveInventory, /*bank: Bank,*/ session: Session) -> ClientState {
|
|
ClientState {
|
|
user: user,
|
|
settings: settings,
|
|
character: character,
|
|
session: session,
|
|
inventory: inventory,
|
|
//bank: bank,
|
|
block: 1,
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
pub struct ShipServerState<EG: EntityGateway> {
|
|
entity_gateway: EG,
|
|
clients: HashMap<ClientId, ClientState>,
|
|
client_location: ClientLocation,
|
|
level_table: CharacterLevelTable,
|
|
name: String,
|
|
rooms: [Option<room::RoomState>; MAX_ROOMS],
|
|
item_database: items::ActiveItemDatabase,
|
|
}
|
|
|
|
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_database: items::ActiveItemDatabase::new(),
|
|
}
|
|
}
|
|
|
|
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.id.0 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))?.as_ref()
|
|
.ok_or(ShipError::NoCharacterInSlot(id, pkt.session.character_slot as u32))?
|
|
.clone();
|
|
let settings = self.entity_gateway.get_user_settings_by_user(&user)
|
|
.ok_or(ShipError::ClientNotFound(id))?;
|
|
let inventory = self.item_database.get_character_inventory(&mut self.entity_gateway, &character);
|
|
|
|
self.clients.insert(id, ClientState::new(user, settings, character, inventory, 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(client.character.char_class, client.character.exp);
|
|
|
|
let fc = FullCharacterBytesBuilder::new()
|
|
.character(&client.character)
|
|
.stats(&stats)
|
|
.level(level)
|
|
.inventory(&client.inventory)
|
|
.key_config(&client.settings.settings.key_config)
|
|
.joystick_config(&client.settings.settings.joystick_config)
|
|
.symbol_chat(&client.settings.settings.symbol_chats)
|
|
.tech_menu(&client.character.tech_menu.as_bytes())
|
|
.build();
|
|
|
|
Ok(vec![
|
|
SendShipPacket::FullCharacter(FullCharacter {
|
|
character: fc,
|
|
}),
|
|
SendShipPacket::CharDataRequest(CharDataRequest {}),
|
|
])
|
|
}
|
|
|
|
fn join_room(&mut self, id: ClientId, pkt: &MenuSelect) -> Result<Vec<(ClientId, SendShipPacket)>, ShipError> {
|
|
let original_area = self.client_location.get_area(id).unwrap();
|
|
let original_neighbors = self.client_location.get_client_neighbors(id).unwrap();
|
|
let room = self.rooms.get(pkt.item as usize)
|
|
.ok_or_else(|| ShipError::InvalidRoom(pkt.item))?.as_ref()
|
|
.ok_or_else(|| ShipError::InvalidRoom(pkt.item))?;
|
|
if room.bursting {
|
|
return Ok(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("player is bursting\nplease wait".into())))])
|
|
}
|
|
let room_id = RoomId(pkt.item as usize);
|
|
let original_room_clients = self.client_location.get_clients_in_room(room_id).map_err(|err| ShipError::ClientError(format!("{:?}", err)))?;
|
|
self.client_location.add_client_to_room(id, room_id).unwrap(); // TODO: show room full error or whatever
|
|
|
|
let all_clients = self.client_location.get_clients_in_room(room_id).map_err(|err| ShipError::ClientError(format!("{:?}", err)))?;
|
|
let player_headers = all_clients.iter()
|
|
.enumerate()
|
|
.fold([PlayerHeader::default(); 4], |mut acc, (i, c)| {
|
|
let header_client = self.clients.get(&c.client).ok_or(ShipError::ClientNotFound(id)).unwrap();
|
|
acc[i] = PlayerHeader {
|
|
tag: 0x100,
|
|
guildcard: header_client.user.id.0,
|
|
_unknown1: [0,0,0, c.local_client.id() as u32, 0],
|
|
client_id: 0,
|
|
name: libpso::utf8_to_utf16_array!(header_client.character.name, 16),
|
|
_unknown2: 2,
|
|
};
|
|
acc
|
|
});
|
|
|
|
let area_client = self.client_location.get_local_client(id).map_err(|err| ShipError::ClientError(format!("{:?}", err)))?;
|
|
let leader = self.client_location.get_room_leader(room_id).map_err(|err| ShipError::ClientError(format!("{:?}", err)))?;
|
|
|
|
let join_room = JoinRoom {
|
|
flag: all_clients.len() as u32,
|
|
maps: room.map_headers(),
|
|
players: player_headers,
|
|
client: area_client.local_client.id(),
|
|
leader: leader.local_client.id(),
|
|
one: 1,
|
|
difficulty: room.mode.difficulty().into(),
|
|
battle: matches!(room.mode, room::RoomMode::Battle {..}) as u8,
|
|
event: 0,
|
|
section: room.section_id.into(),
|
|
challenge: matches!(room.mode, room::RoomMode::Challenge {..}) as u8,
|
|
random_seed: room.random_seed,
|
|
episode: room.mode.episode().into(),
|
|
one2: 1,
|
|
single_player: 0, // TODO
|
|
unknown: 0,
|
|
};
|
|
|
|
let client = self.clients.get(&id).ok_or(ShipError::ClientNotFound(id))?;
|
|
let (level, stats) = self.level_table.get_stats_from_exp(client.character.char_class, client.character.exp);
|
|
let c = CharacterBytesBuilder::new()
|
|
.character(&client.character)
|
|
.stats(&stats)
|
|
.level(level - 1)
|
|
.build();
|
|
let add_to = AddToRoom {
|
|
flag: 0x10000,
|
|
client: area_client.local_client.id(),
|
|
leader: leader.local_client.id(),
|
|
one: 0, // TODO: ??????????
|
|
lobby: 0xff,
|
|
block: 0,
|
|
event: 0,
|
|
padding: 1,
|
|
playerinfo: PlayerInfo {
|
|
header: PlayerHeader {
|
|
tag: 0x10000,
|
|
guildcard: client.user.id.0,
|
|
_unknown1: [0; 5],
|
|
client_id: area_client.local_client.id() as u32,
|
|
name: libpso::utf8_to_utf16_array!(client.character.name, 16),
|
|
_unknown2: 2,
|
|
},
|
|
inventory: character::Inventory {
|
|
item_count: 0,
|
|
hp_mats_used: 0,
|
|
tp_mats_used: 0,
|
|
language: 0,
|
|
items: [character::InventoryItem::default(); 30], // TOOD: this should be something
|
|
},
|
|
character: c,
|
|
},
|
|
};
|
|
|
|
let result = vec![(id, SendShipPacket::JoinRoom(join_room))]
|
|
.into_iter()
|
|
.chain(original_room_clients.clone().into_iter()
|
|
.map(|c| (c.client, SendShipPacket::AddToRoom(add_to.clone())))
|
|
);
|
|
|
|
let room = self.rooms.get_mut(room_id.0).unwrap().as_mut().unwrap();
|
|
room.bursting = true;
|
|
if let Ok(leader) = self.client_location.get_area_leader(original_area) {
|
|
let leave_lobby = SendShipPacket::LeaveLobby(LeaveLobby::new(area_client.local_client.id(), leader.local_client.id()));
|
|
Ok(result.chain(original_neighbors.into_iter()
|
|
.map(|c| (c.client, leave_lobby.clone()))).collect())
|
|
}
|
|
else {
|
|
Ok(result.collect())
|
|
}
|
|
}
|
|
|
|
fn send_player_to_lobby(&mut self, id: ClientId, _pkt: &CharData) -> Result<Vec<(ClientId, SendShipPacket)>, ShipError> {
|
|
let lobby = self.client_location.add_client_to_next_available_lobby(id, LobbyId(0)).map_err(|_| ShipError::TooManyClients)?;
|
|
let clients = self.client_location.get_clients_in_lobby(lobby).map_err(|err| ShipError::ClientError(format!("{:?}", err)))?;
|
|
let playerinfo = clients.iter()
|
|
.map(|room_client| {
|
|
let client = self.clients.get(&room_client.client).ok_or(ShipError::ClientNotFound(id)).unwrap();
|
|
let (level, stats) = self.level_table.get_stats_from_exp(client.character.char_class, client.character.exp);
|
|
let c = CharacterBytesBuilder::new()
|
|
.character(&client.character)
|
|
.stats(&stats)
|
|
.level(level - 1)
|
|
.build();
|
|
PlayerInfo {
|
|
header: PlayerHeader {
|
|
tag: 0x100,
|
|
guildcard: client.user.id.0,
|
|
_unknown1: [0; 5],
|
|
client_id: room_client.local_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 area_client = self.client_location.get_local_client(id).map_err(|err| ShipError::ClientError(format!("{:?}", err)))?;
|
|
let leader = self.client_location.get_lobby_leader(lobby).map_err(|err| ShipError::ClientError(format!("{:?}", err)))?;
|
|
|
|
let join_lobby = JoinLobby {
|
|
client: area_client.local_client.id(),
|
|
leader: leader.local_client.id(),
|
|
one: 1,
|
|
lobby: lobby.id(),
|
|
block: 1,
|
|
event: 0,
|
|
padding: 0,
|
|
playerinfo: playerinfo.collect(),
|
|
};
|
|
|
|
let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
|
|
let (level, stats) = self.level_table.get_stats_from_exp(client.character.char_class, client.character.exp);
|
|
let c = CharacterBytesBuilder::new()
|
|
.character(&client.character)
|
|
.stats(&stats)
|
|
.level(level - 1)
|
|
.build();
|
|
let addto = AddToLobby {
|
|
flag: 1,
|
|
client: area_client.local_client.id(),
|
|
leader: leader.local_client.id(),
|
|
one: 1,
|
|
lobby: lobby.id(),
|
|
block: 1,
|
|
event: 0,
|
|
padding: 0,
|
|
playerinfo: PlayerInfo {
|
|
header: PlayerHeader {
|
|
tag: 0x100,
|
|
guildcard: client.user.id.0,
|
|
_unknown1: [0; 5],
|
|
client_id: area_client.local_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 neighbors = self.client_location.get_client_neighbors(id).unwrap();
|
|
Ok(vec![(id, SendShipPacket::JoinLobby(join_lobby))]
|
|
.into_iter()
|
|
.chain(neighbors.into_iter()
|
|
.map(|c| (c.client, SendShipPacket::AddToLobby(addto.clone())))).collect())
|
|
}
|
|
|
|
fn done_bursting(&mut self, id: ClientId) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
|
|
let area = self.client_location.get_area(id).unwrap();
|
|
if let RoomLobby::Room(room_id) = area {
|
|
let room = self.rooms.get_mut(room_id.0).unwrap().as_mut().unwrap();
|
|
room.bursting = false;
|
|
}
|
|
Box::new(self.client_location.get_client_neighbors(id).unwrap().into_iter()
|
|
.map(move |client| {
|
|
vec![
|
|
(client.client, SendShipPacket::BurstDone72(BurstDone72::new())),
|
|
]
|
|
}).flatten())
|
|
}
|
|
|
|
fn message(&mut self, id: ClientId, msg: &Message) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
|
|
match &msg.msg {
|
|
GameMessage::RequestExp(killmonster) => {
|
|
match self.client_location.get_area(id).unwrap() {
|
|
RoomLobby::Room(room) => {
|
|
let r = self.rooms[room.0].as_ref().unwrap();
|
|
warn!("killed a {:?}", r.maps.enemy_by_id(killmonster.enemy_id as usize).monster);
|
|
},
|
|
_ => {}
|
|
}
|
|
},
|
|
_ => {},
|
|
}
|
|
|
|
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 generate_item_drop(&mut self, id: ClientId, monster: MonsterType) -> Option<ActiveItem> {
|
|
let room = self.rooms[self.client_location.get_area_by_user(id).index];
|
|
let item_drop = room.drop_table.get_drop()
|
|
}*/
|
|
|
|
fn direct_message(&mut self, id: ClientId, msg: &DirectMessage) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
|
|
let cmsg = msg.clone();
|
|
let client = self.clients.get_mut(&id).unwrap();
|
|
match &cmsg.msg {
|
|
GameMessage::GuildcardSend(guildcard_send) => {
|
|
let out_msg = DirectMessage{
|
|
flag: cmsg.flag,
|
|
msg: GameMessage::GuildcardRecv(GuildcardRecv {
|
|
client: guildcard_send.client,
|
|
target: guildcard_send.target,
|
|
guildcard: client.user.id.0,
|
|
name: utf8_to_utf16_array!(client.character.name, 0x18),
|
|
team: [0; 0x10], // TODO: teams not yet implemented
|
|
desc: utf8_to_utf16_array!(client.character.guildcard.description, 0x58),
|
|
one: 1,
|
|
language: 0, // TODO: add language flag to character
|
|
section_id: client.character.section_id.into(),
|
|
class: client.character.char_class.into(),
|
|
}),
|
|
};
|
|
let msg_flag = cmsg.flag as u8;
|
|
Box::new(self.client_location.get_all_clients_by_client(id).unwrap().into_iter()
|
|
.filter(move |client| client.local_client.id() == msg_flag)
|
|
.map(move |client| {
|
|
(client.client, SendShipPacket::DirectMessage(out_msg.clone()))
|
|
}))
|
|
},
|
|
/*GameMessage::RequestItem(req_item) => {
|
|
let item = self.generate_item_drop(id);
|
|
Box::new(vec![(id, SendShipPacket::Message(Message::new(GameMessage::ItemDrop(ItemDrop {
|
|
client: req_item.client,
|
|
target: req_item.target,
|
|
area: req_item.area,
|
|
variety: 0,
|
|
unknown: 0,
|
|
x: req_item.x,
|
|
z: req_item.z,
|
|
unknown2: 0,
|
|
item_bytes: item[0..12].try_into().unwrap(),
|
|
item_id: 0,
|
|
item_bytes2: item[12..16].try_into().unwrap(),
|
|
unknown3: 0,
|
|
}))))].into_iter())
|
|
},*/
|
|
_ => {
|
|
let msg_flag = cmsg.flag as u8;
|
|
Box::new(self.client_location.get_all_clients_by_client(id).unwrap().into_iter()
|
|
.filter(move |client| client.local_client.id() == msg_flag)
|
|
.map(move |client| {
|
|
(client.client, SendShipPacket::DirectMessage(cmsg.clone()))
|
|
}))
|
|
},
|
|
}
|
|
}
|
|
|
|
fn player_chat(&mut self, id: ClientId, msg: &PlayerChat) -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> {
|
|
let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
|
|
let cmsg = PlayerChat::new(client.user.id.0, msg.message.clone());
|
|
|
|
Ok(Box::new(self.client_location.get_all_clients_by_client(id).unwrap().into_iter()
|
|
.map(move |client| {
|
|
(client.client, SendShipPacket::PlayerChat(cmsg.clone()))
|
|
})))
|
|
}
|
|
|
|
fn create_room(&mut self, id: ClientId, create_room: &CreateRoom) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
|
|
let area = self.client_location.get_area(id).unwrap();
|
|
let area_client = self.client_location.get_local_client(id).unwrap();
|
|
let lobby_neighbors = self.client_location.get_client_neighbors(id).unwrap();
|
|
let room_id = self.client_location.create_new_room(id).unwrap();
|
|
|
|
let client = self.clients.get_mut(&id).unwrap();//.ok_or(ShipError::ClientNotFound(id)).unwrap();
|
|
let mut room = room::RoomState::from_create_room(create_room, client.character.section_id).unwrap();
|
|
room.bursting = true;
|
|
|
|
let players = [PlayerHeader {
|
|
tag: 0x10000,
|
|
guildcard: client.user.id.0,
|
|
_unknown1: [0; 5],
|
|
client_id: 0,
|
|
name: libpso::utf8_to_utf16_array!(client.character.name, 16),
|
|
_unknown2: 2,
|
|
}, PlayerHeader::default(), PlayerHeader::default(), PlayerHeader::default()];
|
|
|
|
let join_room = JoinRoom {
|
|
flag: 1,
|
|
maps: room.maps.map_headers(),
|
|
players: players,
|
|
client: 0,
|
|
leader: 0,
|
|
one: 1,
|
|
difficulty: create_room.difficulty,
|
|
battle: create_room.battle,
|
|
event: 0,
|
|
section: 0, // TODO
|
|
challenge: create_room.challenge,
|
|
random_seed: 23, // TODO
|
|
episode: create_room.episode,
|
|
one2: 1,
|
|
single_player: create_room.single_player,
|
|
unknown: 0,
|
|
};
|
|
self.rooms[room_id.0] = Some(room);
|
|
|
|
let leader = self.client_location.get_area_leader(area);
|
|
let result = vec![(id, SendShipPacket::JoinRoom(join_room))].into_iter();
|
|
match leader {
|
|
Ok(leader) => Box::new(result.chain(lobby_neighbors
|
|
.into_iter()
|
|
.map(move |c| {
|
|
(c.client, SendShipPacket::LeaveLobby(LeaveLobby::new(area_client.local_client.id(), leader.local_client.id())))
|
|
}))),
|
|
Err(_) => Box::new(result)
|
|
}
|
|
}
|
|
|
|
fn room_name_request(&mut self, id: ClientId) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
|
|
let area = self.client_location.get_area(id).unwrap();
|
|
match area {
|
|
RoomLobby::Room(room) => Box::new(vec![(id, SendShipPacket::RoomNameResponse(RoomNameResponse {name: self.rooms[room.0].as_ref().unwrap().name.clone()}))].into_iter()),
|
|
RoomLobby::Lobby(_) => panic!()
|
|
}
|
|
}
|
|
|
|
fn update_config(&mut self, id: ClientId, update_config: &UpdateConfig) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
|
|
let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id)).unwrap();
|
|
client.character.config.update(update_config);
|
|
self.entity_gateway.save_character(&client.character);
|
|
Box::new(None.into_iter())
|
|
}
|
|
|
|
fn request_infoboard(&mut self, id: ClientId, request_infoboard: &ViewInfoboardRequest) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
|
|
let clients = self.client_location.get_client_neighbors(id).unwrap();
|
|
let r = clients.iter()
|
|
.filter_map(|c| {
|
|
self.clients.get(&c.client)
|
|
})
|
|
.map(|client| {
|
|
InfoboardResponse {
|
|
name: libpso::utf8_to_utf16_array!(client.character.name, 16),
|
|
message: client.character.info_board.as_bytes(),
|
|
}
|
|
}).collect();
|
|
Box::new(vec![(id, SendShipPacket::ViewInfoboardResponse(ViewInfoboardResponse {response: r}))].into_iter())
|
|
}
|
|
|
|
fn write_infoboard(&mut self, id: ClientId, new_infoboard: &WriteInfoboard) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
|
|
let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id)).unwrap();
|
|
client.character.info_board.update_infoboard(new_infoboard);
|
|
self.entity_gateway.save_character(&client.character);
|
|
Box::new(None.into_iter())
|
|
}
|
|
|
|
fn request_room_list(&mut self, id: ClientId) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
|
|
let active_room_list = self.rooms.iter()
|
|
.enumerate()
|
|
.filter_map(|(i, r)| {
|
|
r.as_ref().map(|room| {
|
|
RoomList {
|
|
menu_id: ROOM_MENU_ID,
|
|
item_id: i as u32,
|
|
difficulty: room.get_difficulty_for_room_list(),
|
|
players: self.client_location.get_clients_in_room(RoomId(i)).unwrap().len() as u8,
|
|
name: libpso::utf8_to_utf16_array!(room.name, 16),
|
|
episode: room.get_episode_for_room_list(),
|
|
flags: room.get_flags_for_room_list(),
|
|
}
|
|
})
|
|
});
|
|
let baseroom: RoomList = RoomList {
|
|
menu_id: ROOM_MENU_ID,
|
|
item_id: ROOM_MENU_ID,
|
|
difficulty: 0x00,
|
|
players: 0x00,
|
|
name: libpso::utf8_to_utf16_array!("Room list menu", 16),
|
|
episode: 0,
|
|
flags: 0,
|
|
};
|
|
|
|
Box::new(vec![(id, SendShipPacket::RoomListResponse(RoomListResponse {
|
|
baseroom,
|
|
rooms: active_room_list.collect()
|
|
}))].into_iter())
|
|
}
|
|
|
|
fn cool_62(&mut self, id: ClientId, cool_62: &Like62ButCooler) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
|
|
let target = cool_62.flag as u8;
|
|
let cool_62 = cool_62.clone();
|
|
Box::new(self.client_location.get_client_neighbors(id).unwrap().into_iter()
|
|
.filter(move |client| client.local_client.id() == target)
|
|
.map(move |client| {
|
|
(client.client, SendShipPacket::Like62ButCooler(cool_62.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(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))),
|
|
ROOM_MENU_ID => Box::new(self.join_room(id, menuselect)?.into_iter()),
|
|
_ => 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)
|
|
},
|
|
|
|
RecvShipPacket::PlayerChat(msg) => {
|
|
Box::new(self.player_chat(id, msg)?.into_iter())
|
|
},
|
|
RecvShipPacket::CreateRoom(create_room) => {
|
|
self.create_room(id, create_room)
|
|
},
|
|
RecvShipPacket::RoomNameRequest(_req) => {
|
|
self.room_name_request(id)
|
|
},
|
|
RecvShipPacket::UpdateConfig(pkt) => {
|
|
self.update_config(id, pkt)
|
|
},
|
|
|
|
RecvShipPacket::ViewInfoboardRequest(pkt) => {
|
|
self.request_infoboard(id, pkt)
|
|
},
|
|
|
|
RecvShipPacket::WriteInfoboard(pkt) => {
|
|
self.write_infoboard(id, pkt)
|
|
},
|
|
|
|
RecvShipPacket::RoomListRequest(_req) => {
|
|
self.request_room_list(id)
|
|
},
|
|
RecvShipPacket::Like62ButCooler(cool62) => {
|
|
self.cool_62(id, cool62)
|
|
},
|
|
RecvShipPacket::ClientCharacterData(_) => {
|
|
// TOOD: validate this in some way?
|
|
Box::new(None.into_iter())
|
|
},
|
|
RecvShipPacket::DoneBursting(_) => {
|
|
self.done_bursting(id)
|
|
}
|
|
})
|
|
}
|
|
|
|
fn on_disconnect(&mut self, id: ClientId) -> Vec<(ClientId, SendShipPacket)> {
|
|
let 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) => {
|
|
let leader = self.client_location.get_room_leader(room).unwrap();
|
|
SendShipPacket::LeaveRoom(LeaveRoom::new(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(client.local_client.id(), leader.local_client.id()))
|
|
}
|
|
};
|
|
|
|
self.client_location.remove_client_from_area(id);
|
|
|
|
neighbors.into_iter().map(|n| {
|
|
(n.client, pkt.clone())
|
|
}).collect()
|
|
}
|
|
}
|