jake/elseware
1
0
Fork 0
Code Issues 63 Pull Requests 1 Projects Releases Wiki Activity

Merge pull request 'the clip has spoken' (#42) from clippylint into master
All checks were successful
continuous-integration/drone/push Build is passing
Details

Browse Source 
Reviewed-on: #42
This commit is contained in:
jake 2021-06-19 02:48:24 -04:00
commit 4c7fa97c5b
72 changed files with 903 additions and 939 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
.drone.yml
View File

@ -7,7 +7,7 @@ concurrency:
limit: 1
steps:
- name: cargo build
- name: build
image: rustlang/rust:nightly
volumes:
- name: cache
@ -16,7 +16,16 @@ steps:
path: /drone/src/target
commands:
- cargo build
- name: cargo test
- name: clippy!
image: rustlang/rust:nightly
volumes:
- name: cache
path: /usr/local/cargo
- name: target-cache
path: /drone/src/target
commands:
- cargo clippy -- --deny warnings
- name: test
image: rustlang/rust:nightly
volumes:
- name: cache

2
src/bin/login.rs
View File

@ -41,7 +41,7 @@ fn main() {
let login_state = LoginServerState::new(thread_entity_gateway, charserv_ip);
let login_loop = login_mainloop(login_state, elseware::login::login::LOGIN_PORT);
let char_state = CharacterServerState::new(entity_gateway, AuthToken(shipgate_token.into()));
let char_state = CharacterServerState::new(entity_gateway, AuthToken(shipgate_token));
let character_loop = character_mainloop(char_state, elseware::login::character::CHARACTER_PORT, elseware::login::login::COMMUNICATION_PORT);
info!("[auth/character] starting server");

9
src/bin/main.rs
View File

@ -6,6 +6,7 @@ use elseware::login::login::LoginServerState;
use elseware::login::character::CharacterServerState;
use elseware::ship::ship::ShipServerStateBuilder;
use elseware::entity::account::{NewUserAccountEntity, NewUserSettingsEntity};
#[allow(unused_imports)]
use elseware::entity::gateway::{EntityGateway, InMemoryGateway, PostgresGateway};
use elseware::entity::character::NewCharacterEntity;
use elseware::entity::item::{NewItemEntity, ItemDetail, ItemLocation};
@ -48,7 +49,7 @@ fn main() {
setup_logger();
async_std::task::block_on(async move {
//let mut entity_gateway = PostgresGateway::new("localhost", "elsewhere", "elsewhere", "");
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
for i in 0..5 {
let fake_user = NewUserAccountEntity {
@ -383,7 +384,7 @@ fn main() {
let thread_entity_gateway = entity_gateway.clone();
info!("[ship] starting server");
let ship_state = Box::new(ShipServerStateBuilder::new()
let ship_state = Box::new(ShipServerStateBuilder::default()
.name("US/Sona-Nyl".into())
.ip(Ipv4Addr::new(127,0,0,1))
.port(elseware::ship::ship::SHIP_PORT)
@ -392,7 +393,7 @@ fn main() {
let ship_loop = ship_mainloop(*ship_state, elseware::ship::ship::SHIP_PORT, std::net::Ipv4Addr::new(127, 0, 0, 1), elseware::login::login::COMMUNICATION_PORT);
let thread_entity_gateway = entity_gateway.clone();
let ship_state = Box::new(ShipServerStateBuilder::new()
let ship_state = Box::new(ShipServerStateBuilder::default()
.name("EU/Dylath-Leen".into())
.ip(Ipv4Addr::new(127,0,0,1))
.port(elseware::ship::ship::SHIP_PORT+2000)
@ -401,7 +402,7 @@ fn main() {
let ship_loop2 = ship_mainloop(*ship_state, elseware::ship::ship::SHIP_PORT+2000, std::net::Ipv4Addr::new(127, 0, 0, 1), elseware::login::login::COMMUNICATION_PORT);
let thread_entity_gateway = entity_gateway.clone();
let ship_state = Box::new(ShipServerStateBuilder::new()
let ship_state = Box::new(ShipServerStateBuilder::default()
.name("JP/Thalarion".into())
.ip(Ipv4Addr::new(127,0,0,1))
.port(elseware::ship::ship::SHIP_PORT+3000)

4
src/bin/ship.rs
View File

@ -37,12 +37,12 @@ fn main() {
let shipgate_token = std::env::var("SHIPGATE_TOKEN").unwrap();
let ship_name = std::env::var("SHIP_NAME").unwrap().parse().unwrap();
let ip = std::env::var("SELF_IP").unwrap().parse().unwrap();
let ship_state = ShipServerStateBuilder::new()
let ship_state = ShipServerStateBuilder::default()
.name(ship_name)
.ip(ip)
.port(elseware::ship::ship::SHIP_PORT)
.gateway(entity_gateway)
.auth_token(AuthToken(shipgate_token.into()))
.auth_token(AuthToken(shipgate_token))
.build();
let shipgate_ip = std::env::var("SHIPGATE_IP").unwrap().parse().unwrap();

15
src/common/leveltable.rs
View File

@ -30,9 +30,8 @@ pub struct CharacterLevelTable {
table: HashMap<CharacterClass, [CharacterLevelEntry; 200]>,
}
impl CharacterLevelTable {
pub fn new() -> CharacterLevelTable {
impl Default for CharacterLevelTable {
fn default() -> CharacterLevelTable {
let file = File::open("data/char_stats.json").unwrap();
let json: Value = serde_json::from_reader(file).unwrap();
let mut table = HashMap::new();
@ -55,7 +54,7 @@ impl CharacterLevelTable {
};
let mut statlist = [CharacterLevelEntry::default(); 200];
for (i, stat) in it.1.as_array().unwrap().into_iter().enumerate() {
for (i, stat) in it.1.as_array().unwrap().iter().enumerate() {
statlist[i] = CharacterLevelEntry {
hp: stat["hp"].as_i64().unwrap() as u32,
atp: stat["atp"].as_i64().unwrap() as u32,
@ -72,10 +71,12 @@ impl CharacterLevelTable {
}
CharacterLevelTable {
table: table,
table,
}
}
}
impl CharacterLevelTable {
pub fn get_level_from_exp(&self, ch_class: CharacterClass, exp: u32) -> u32 {
if let Some(statlist) = self.table.get(&ch_class) {
statlist
@ -120,14 +121,14 @@ mod test {
use super::*;
#[test]
fn test_stat_levels() {
let table = CharacterLevelTable::new();
let table = CharacterLevelTable::default();
assert!(table.get_stats_from_exp(CharacterClass::FOmarl, 0) == (1, CharacterStats { hp: 20, atp: 13, mst: 53, evp: 35, dfp: 10, ata: 15, lck: 10 }));
assert!(table.get_stats_from_exp(CharacterClass::FOmarl, 1 << 17) == (36, CharacterStats { hp: 125, atp: 114, mst: 219, evp: 182, dfp: 42, ata: 213, lck: 10 }));
}
#[test]
fn test_levels() {
let table = CharacterLevelTable::new();
let table = CharacterLevelTable::default();
assert!(table.get_level_from_exp(CharacterClass::FOmarl, 0) == 1);
assert!(table.get_level_from_exp(CharacterClass::FOmarl, 3000) == 8);
assert!(table.get_level_from_exp(CharacterClass::FOmarl, 3200) == 9);

22
src/common/mainloop/client.rs
View File

@ -49,8 +49,8 @@ struct PacketReceiver {
impl PacketReceiver {
fn new(socket: Arc<async_std::net::TcpStream>, cipher: Arc<Mutex<Box<dyn PSOCipher + Send>>>) -> PacketReceiver {
PacketReceiver {
socket: socket,
cipher: cipher,
socket,
cipher,
recv_buffer: Vec::new(),
incoming_data: Vec::new(),
}
@ -65,7 +65,7 @@ impl PacketReceiver {
return Err(NetworkError::ClientDisconnected);
}
self.recv_buffer.extend_from_slice(&mut data[..len]);
self.recv_buffer.extend_from_slice(&data[..len]);
let mut dec_buf = {
let mut cipher = self.cipher.lock().await;
@ -149,7 +149,7 @@ where
R: RecvServerPacket + std::fmt::Debug + Send + 'static,
{
async_std::task::spawn(async move {
server_sender.send(ClientAction::NewClient(client_id, client_sender)).await;
server_sender.send(ClientAction::NewClient(client_id, client_sender)).await.unwrap();
let mut pkt_receiver = PacketReceiver::new(socket, cipher);
loop {
@ -157,14 +157,14 @@ where
Ok(pkts) => {
for pkt in pkts {
trace!("[recv from {:?}] {:?}", client_id, pkt);
server_sender.send(ClientAction::Packet(client_id, pkt)).await;
server_sender.send(ClientAction::Packet(client_id, pkt)).await.unwrap();
}
},
Err(err) => {
match err {
NetworkError::ClientDisconnected => {
trace!("[client disconnected] {:?}", client_id);
server_sender.send(ClientAction::Disconnect(client_id)).await;
server_sender.send(ClientAction::Disconnect(client_id)).await.unwrap();
break;
}
_ => {
@ -229,10 +229,10 @@ fn state_client_loop<STATE, S, R, E>(state: Arc<Mutex<STATE>>,
for action in actions {
match action {
OnConnect::Cipher((inc, outc)) => {
sender.send(ServerStateAction::Cipher(inc, outc)).await;
sender.send(ServerStateAction::Cipher(inc, outc)).await.unwrap();
},
OnConnect::Packet(pkt) => {
sender.send(ServerStateAction::Packet(pkt)).await;
sender.send(ServerStateAction::Packet(pkt)).await.unwrap();
}
}
}
@ -249,7 +249,7 @@ fn state_client_loop<STATE, S, R, E>(state: Arc<Mutex<STATE>>,
Ok(pkts) => {
for (client_id, pkt) in pkts {
if let Some(client) = clients.get_mut(&client_id) {
client.send(ServerStateAction::Packet(pkt)).await;
client.send(ServerStateAction::Packet(pkt)).await.unwrap();
}
}
},
@ -264,12 +264,12 @@ fn state_client_loop<STATE, S, R, E>(state: Arc<Mutex<STATE>>,
Ok(pkts) => {
for (client_id, pkt) in pkts {
if let Some(client) = clients.get_mut(&client_id) {
client.send(ServerStateAction::Packet(pkt)).await;
client.send(ServerStateAction::Packet(pkt)).await.unwrap();
}
}
if let Some(client) = clients.get_mut(&client_id) {
client.send(ServerStateAction::Disconnect).await;
client.send(ServerStateAction::Disconnect).await.unwrap();
}
}
Err(err) => {

20
src/common/mainloop/interserver.rs
View File

@ -29,7 +29,7 @@ struct MessageReceiver {
impl MessageReceiver {
fn new(socket: async_std::net::TcpStream) -> MessageReceiver {
MessageReceiver {
socket: socket,
socket,
}
}
@ -79,7 +79,7 @@ where
ships.insert(server_id, ship_action_sender);
for (server, action) in state.on_connect(server_id).await {
if let Some(sender) = ships.get_mut(&server) {
sender.send(action).await;
sender.send(action).await.unwrap();
}
}
},
@ -89,7 +89,7 @@ where
Ok(actions) => {
for (server, action) in actions{
if let Some(sender) = ships.get_mut(&server) {
sender.send(action).await;
sender.send(action).await.unwrap();
}
}
},
@ -103,7 +103,7 @@ where
ships.remove(&server_id);
for (server, action) in actions {
if let Some(sender) = ships.get_mut(&server) {
sender.send(action).await;
sender.send(action).await.unwrap();
}
}
}
@ -121,7 +121,7 @@ where
R: DeserializeOwned + std::fmt::Debug + Send + 'static,
{
async_std::task::spawn(async move {
state_loop_sender.send(InterserverInputAction::NewConnection(server_id, output_loop_sender)).await;
state_loop_sender.send(InterserverInputAction::NewConnection(server_id, output_loop_sender)).await.unwrap();
let mut msg_receiver = MessageReceiver::new(socket);
loop {
@ -129,12 +129,12 @@ where
match msg_receiver.recv().await {
Ok(msg) => {
info!("[login recv loop msg] {:?}", msg);
state_loop_sender.send(InterserverInputAction::Message(server_id, msg)).await;
state_loop_sender.send(InterserverInputAction::Message(server_id, msg)).await.unwrap();
},
Err(err) => {
if let MessageReceiverError::Disconnected = err {
info!("[login recv loop disconnect] {:?}", server_id);
state_loop_sender.send(InterserverInputAction::Disconnect(server_id)).await;
state_loop_sender.send(InterserverInputAction::Disconnect(server_id)).await.unwrap();
break;
}
info!("[login recv loop err] {:?}", err);
@ -163,7 +163,7 @@ where
warn!("interserver send failed: {:?}", err);
break;
}
if let Err(err) = socket.write_all(&payload.as_bytes()).await {
if let Err(err) = socket.write_all(payload.as_bytes()).await {
warn!("intserserver send failed: {:?}", err);
break;
}
@ -200,7 +200,7 @@ pub fn login_listen_mainloop<EG: EntityGateway + 'static>(state: Arc<Mutex<Chara
let mut state = state.lock().await;
let local_sender = client_sender.clone();
state.set_sender(server_id, Box::new(move |message| {
async_std::task::block_on(local_sender.send(message));
async_std::task::block_on(local_sender.send(message)).unwrap();
}))
}
@ -236,7 +236,7 @@ pub fn ship_connect_mainloop<EG: EntityGateway + 'static>(state: Arc<Mutex<ShipS
let mut state = state.lock().await;
let local_sender = client_sender.clone();
state.set_sender(Box::new(move |message| {
async_std::task::block_on(local_sender.send(message));
async_std::task::block_on(local_sender.send(message)).unwrap();
}))
}

2
src/common/mainloop/mod.rs
View File

@ -25,7 +25,7 @@ pub fn patch_mainloop(patch_state: PatchServerState, patch_port: u16) -> Pin<Box
pub fn login_mainloop<EG: EntityGateway + 'static>(login_state: LoginServerState<EG>, login_port: u16) -> Pin<Box<dyn Future<Output = ()>>> {
let login_state = Arc::new(Mutex::new(login_state));
let client_mainloop = client_accept_mainloop(login_state.clone(), login_port);
let client_mainloop = client_accept_mainloop(login_state, login_port);
Box::pin(client_mainloop)
}

6
src/entity/account.rs
View File

@ -75,7 +75,7 @@ pub struct NewUserSettingsEntity {
impl NewUserSettingsEntity {
pub fn new(user_id: UserAccountId) -> NewUserSettingsEntity {
NewUserSettingsEntity {
user_id: user_id,
user_id,
settings: settings::UserSettings::default(),
}
}
@ -98,7 +98,7 @@ pub struct NewGuildCardDataEntity {
impl NewGuildCardDataEntity {
pub fn new(user_id: UserAccountId) -> NewGuildCardDataEntity {
NewGuildCardDataEntity {
user_id: user_id,
user_id,
guildcard: guildcard::GuildCardData::default(),
}
}
@ -116,7 +116,7 @@ impl GuildCardDataEntity {
pub fn new(user_id: UserAccountId) -> GuildCardDataEntity {
GuildCardDataEntity {
id: GuildCardDataId(0),
user_id: user_id,
user_id,
guildcard: guildcard::GuildCardData::default(),
}
}

40
src/entity/character.rs
View File

@ -44,9 +44,9 @@ impl From<u8> for CharacterClass {
}
}
impl Into<u8> for CharacterClass {
fn into(self) -> u8 {
match self {
impl From<CharacterClass> for u8 {
fn from(other: CharacterClass) -> u8 {
match other {
CharacterClass::HUmar => 0,
CharacterClass::HUnewearl => 1,
CharacterClass::HUcast => 2,
@ -65,29 +65,27 @@ impl Into<u8> for CharacterClass {
impl CharacterClass {
pub fn is_human(&self) -> bool {
match self {
matches!(self,
CharacterClass::HUmar |
CharacterClass::RAmar | CharacterClass::RAmarl |
CharacterClass::FOmar | CharacterClass::FOmarl => true,
_ => false,
}
CharacterClass::RAmar |
CharacterClass::RAmarl |
CharacterClass::FOmar |
CharacterClass::FOmarl)
}
pub fn is_newman(&self) -> bool {
match self {
matches!(self,
CharacterClass::HUnewearl |
CharacterClass::FOnewm | CharacterClass::FOnewearl => true,
_ => false,
}
CharacterClass::FOnewm |
CharacterClass::FOnewearl)
}
pub fn is_android(&self) -> bool {
match self {
CharacterClass::HUcast | CharacterClass::HUcaseal |
CharacterClass::RAcast | CharacterClass::RAcaseal => true,
_ => false,
}
matches!(self,
CharacterClass::HUcast |
CharacterClass::HUcaseal |
CharacterClass::RAcast |
CharacterClass::RAcaseal)
}
}
@ -124,9 +122,9 @@ impl From<u8> for SectionID {
}
}
impl Into<u8> for SectionID {
fn into(self) -> u8 {
match self {
impl From<SectionID> for u8 {
fn from(other: SectionID) -> u8 {
match other {
SectionID::Viridia => 0,
SectionID::Greenill => 1,
SectionID::Skyly => 2,

47
src/entity/gateway/inmemory.rs
View File

@ -21,8 +21,8 @@ pub struct InMemoryGateway {
weapon_modifiers: Arc<Mutex<BTreeMap<ItemEntityId, Vec<weapon::WeaponModifier>>>>,
}
impl InMemoryGateway {
pub fn new() -> InMemoryGateway {
impl Default for InMemoryGateway {
fn default() -> InMemoryGateway {
InMemoryGateway {
users: Arc::new(Mutex::new(BTreeMap::new())),
user_settings: Arc::new(Mutex::new(BTreeMap::new())),
@ -47,7 +47,7 @@ impl InMemoryGateway {
ItemDetail::Weapon(mut weapon) => {
if let Some(weapon_modifiers) = self.weapon_modifiers.lock().unwrap().get(&item.id) {
for weapon_modifier in weapon_modifiers.iter() {
weapon.apply_modifier(&weapon_modifier);
weapon.apply_modifier(weapon_modifier);
}
}
ItemDetail::Weapon(weapon)
@ -58,23 +58,21 @@ impl InMemoryGateway {
for mag_modifier in mag_modifiers.iter() {
match mag_modifier {
mag::MagModifier::FeedMag {food} => {
items.get(&food).map(|mag_feed| {
match mag_feed.item {
ItemDetail::Tool(mag_feed) => mag.feed(mag_feed.tool),
_ => {}
if let Some(mag_feed) = items.get(food) {
if let ItemDetail::Tool(mag_feed) = mag_feed.item {
mag.feed(mag_feed.tool)
}
}
});
},
mag::MagModifier::OwnerChange(class, section_id) => {
mag.change_owner(*class, *section_id)
},
mag::MagModifier::MagCell(mag_cell_id) => {
items.get(&mag_cell_id).map(|mag_cell| {
match mag_cell.item {
ItemDetail::Tool(mag_cell) => mag.apply_mag_cell(mag_cell.tool.try_into().unwrap()),
_ => {}
if let Some(mag_cell) = items.get(mag_cell_id) {
if let ItemDetail::Tool(mag_cell) = mag_cell.item {
mag.apply_mag_cell(mag_cell.tool.try_into().unwrap())
}
}
});
},
_ => {}
}
@ -124,7 +122,7 @@ impl EntityGateway for InMemoryGateway {
async fn get_user_by_id(&self, id: UserAccountId) -> Result<UserAccountEntity, GatewayError> {
let users = self.users.lock().unwrap();
users.get(&id).map(|k| k.clone()).ok_or(GatewayError::Error)
users.get(&id).cloned().ok_or(GatewayError::Error)
}
async fn get_user_by_name(&self, username: String) -> Result<UserAccountEntity, GatewayError> {
@ -233,17 +231,16 @@ impl EntityGateway for InMemoryGateway {
}
async fn change_item_location(&mut self, item_id: &ItemEntityId, item_location: ItemLocation) -> Result<(), GatewayError> {
self.items.lock().unwrap().get_mut(&item_id)
.map(|item_entity| {
if let Some(item_entity) = self.items.lock().unwrap().get_mut(item_id) {
item_entity.location = item_location
});
}
Ok(())
}
async fn feed_mag(&mut self, mag_item_id: &ItemEntityId, tool_item_id: &ItemEntityId) -> Result<(), GatewayError> {
self.mag_modifiers.lock().unwrap()
.entry(*mag_item_id)
.or_insert(Vec::new())
.or_insert_with(Vec::new)
.push(mag::MagModifier::FeedMag {
food: *tool_item_id
});
@ -253,7 +250,7 @@ impl EntityGateway for InMemoryGateway {
async fn change_mag_owner(&mut self, mag_item_id: &ItemEntityId, character: &CharacterEntity) -> Result<(), GatewayError> {
self.mag_modifiers.lock().unwrap()
.entry(*mag_item_id)
.or_insert(Vec::new())
.or_insert_with(Vec::new)
.push(mag::MagModifier::OwnerChange(character.char_class, character.section_id));
Ok(())
}
@ -261,15 +258,15 @@ impl EntityGateway for InMemoryGateway {
async fn use_mag_cell(&mut self, mag_item_id: &ItemEntityId, mag_cell_id: &ItemEntityId) -> Result<(), GatewayError> {
self.mag_modifiers.lock().unwrap()
.entry(*mag_item_id)
.or_insert(Vec::new())
.push(mag::MagModifier::MagCell(mag_cell_id.clone()));
.or_insert_with(Vec::new)
.push(mag::MagModifier::MagCell(*mag_cell_id));
Ok(())
}
async fn add_weapon_modifier(&mut self, item_id: &ItemEntityId, modifier: weapon::WeaponModifier) -> Result<(), GatewayError> {
self.weapon_modifiers.lock().unwrap()
.entry(*item_id)
.or_insert(Vec::new())
.or_insert_with(Vec::new)
.push(modifier);
Ok(())
}
@ -282,7 +279,7 @@ impl EntityGateway for InMemoryGateway {
.find(|(id, _)| **id == *char_id)
.map(|(_, inv)| inv.clone())
.map(|inv| self.apply_modifiers(inv))
.unwrap_or(InventoryEntity::default()))
.unwrap_or_default())
}
async fn get_character_bank(&mut self, char_id: &CharacterEntityId, _bank_name: BankName) -> Result<BankEntity, GatewayError> {
@ -291,7 +288,7 @@ impl EntityGateway for InMemoryGateway {
.iter()
.find(|(id, _)| **id == *char_id)
.map(|(_, b)| b.clone())
.unwrap_or(BankEntity::default()))
.unwrap_or_default())
}
async fn set_character_inventory(&mut self, char_id: &CharacterEntityId, inventory: &InventoryEntity) -> Result<(), GatewayError> {
@ -313,7 +310,7 @@ impl EntityGateway for InMemoryGateway {
.iter()
.find(|(id, _)| **id == *char_id)
.map(|(_, inv)| inv.clone())
.unwrap_or(EquippedEntity::default()))
.unwrap_or_default())
}
async fn set_character_equips(&mut self, char_id: &CharacterEntityId, equipped: &EquippedEntity) -> Result<(), GatewayError> {

1
src/entity/gateway/postgres/mod.rs
View File

@ -1,3 +1,4 @@
#[allow(clippy::module_inception)]
pub mod postgres;
pub mod migrations;
pub mod models;

260
src/entity/gateway/postgres/models.rs
View File

@ -23,22 +23,22 @@ pub struct PgUserAccount {
at_ship: bool,
}
impl Into<UserAccountEntity> for PgUserAccount {
fn into(self) -> UserAccountEntity {
impl From<PgUserAccount> for UserAccountEntity {
fn from(other: PgUserAccount) -> UserAccountEntity {
UserAccountEntity {
id: UserAccountId(self.id as u32),
username: self.username,
password: self.password,
banned_until: self.banned,
muted_until: self.muted,
created_at: self.created_at,
flags: self.flags as u32,
guildcard: self.id as u32 + 1,
id: UserAccountId(other.id as u32),
username: other.username,
password: other.password,
banned_until: other.banned,
muted_until: other.muted,
created_at: other.created_at,
flags: other.flags as u32,
guildcard: other.id as u32 + 1,
team_id: None,
activated: self.activated,
at_login: self.at_login,
at_character: self.at_character,
at_ship: self.at_ship,
activated: other.activated,
at_login: other.at_login,
at_character: other.at_character,
at_ship: other.at_ship,
}
}
}
@ -56,19 +56,19 @@ pub struct PgUserSettings {
team_name: Vec<u8>, //[u16; 0x10],
}
impl Into<UserSettingsEntity> for PgUserSettings {
fn into(self) -> UserSettingsEntity {
impl From<PgUserSettings> for UserSettingsEntity {
fn from(other: PgUserSettings) -> UserSettingsEntity {
UserSettingsEntity {
id: UserSettingsId(self.id as u32),
user_id: UserAccountId(self.user_account as u32),
id: UserSettingsId(other.id as u32),
user_id: UserAccountId(other.user_account as u32),
settings: settings::UserSettings {
blocked_users: vec_to_array(self.blocked_users.chunks(4).map(|b| u32::from_le_bytes([b[0], b[1], b[2], b[3]])).collect()),
key_config: vec_to_array(self.key_config),
joystick_config: vec_to_array(self.joystick_config),
option_flags: self.option_flags as u32,
shortcuts: vec_to_array(self.shortcuts),
symbol_chats: vec_to_array(self.symbol_chats),
team_name: vec_to_array(self.team_name.chunks(2).map(|b| u16::from_le_bytes([b[0], b[1]])).collect()),
blocked_users: vec_to_array(other.blocked_users.chunks(4).map(|b| u32::from_le_bytes([b[0], b[1], b[2], b[3]])).collect()),
key_config: vec_to_array(other.key_config),
joystick_config: vec_to_array(other.joystick_config),
option_flags: other.option_flags as u32,
shortcuts: vec_to_array(other.shortcuts),
symbol_chats: vec_to_array(other.symbol_chats),
team_name: vec_to_array(other.team_name.chunks(2).map(|b| u16::from_le_bytes([b[0], b[1]])).collect()),
}
}
}
@ -91,9 +91,9 @@ pub enum PgCharacterClass {
FOnewearl,
}
impl Into<CharacterClass> for PgCharacterClass {
fn into(self) -> CharacterClass {
match self {
impl From<PgCharacterClass> for CharacterClass {
fn from(other: PgCharacterClass) -> CharacterClass {
match other{
PgCharacterClass::HUmar => CharacterClass::HUmar,
PgCharacterClass::HUnewearl => CharacterClass::HUnewearl,
PgCharacterClass::HUcast => CharacterClass::HUcast,
@ -144,9 +144,9 @@ pub enum PgSectionId {
Whitill,
}
impl Into<SectionID> for PgSectionId {
fn into(self) -> SectionID {
match self {
impl From<PgSectionId> for SectionID {
fn from(other: PgSectionId) -> SectionID {
match other {
PgSectionId::Viridia => SectionID::Viridia,
PgSectionId::Greenill => SectionID::Greenill,
PgSectionId::Skyly => SectionID::Skyly,
@ -220,55 +220,55 @@ pub struct PgCharacter {
bank_meseta: i32,
}
impl Into<CharacterEntity> for PgCharacter {
fn into(self) -> CharacterEntity {
impl From<PgCharacter> for CharacterEntity {
fn from(other: PgCharacter) -> CharacterEntity {
CharacterEntity {
id: CharacterEntityId(self.id as u32),
user_id: UserAccountId(self.user_account as u32),
slot: self.slot as u32,
name: self.name,
exp: self.exp as u32,
char_class: self.class.parse().unwrap(),
section_id: self.section_id.parse().unwrap(),
id: CharacterEntityId(other.id as u32),
user_id: UserAccountId(other.user_account as u32),
slot: other.slot as u32,
name: other.name,
exp: other.exp as u32,
char_class: other.class.parse().unwrap(),
section_id: other.section_id.parse().unwrap(),
appearance: CharacterAppearance {
costume: self.costume as u16,
skin: self.skin as u16,
face: self.face as u16,
head: self.head as u16,
hair: self.hair as u16,
hair_r: self.hair_r as u16,
hair_g: self.hair_g as u16,
hair_b: self.hair_b as u16,
prop_x: self.prop_x,
prop_y: self.prop_y,
costume: other.costume as u16,
skin: other.skin as u16,
face: other.face as u16,
head: other.head as u16,
hair: other.hair as u16,
hair_r: other.hair_r as u16,
hair_g: other.hair_g as u16,
hair_b: other.hair_b as u16,
prop_x: other.prop_x,
prop_y: other.prop_y,
},
techs: CharacterTechniques {
techs: self.techs.iter().enumerate().take(19).filter(|(_, t)| **t != 0xFF).map(|(i, t)| (tech::Technique::from_value(i as u8), TechLevel(*t)) ).collect()
techs: other.techs.iter().enumerate().take(19).filter(|(_, t)| **t != 0xFF).map(|(i, t)| (tech::Technique::from_value(i as u8), TechLevel(*t)) ).collect()
},
config: CharacterConfig {
raw_data: vec_to_array(self.config)
raw_data: vec_to_array(other.config)
},
info_board: CharacterInfoboard {
board: libpso::utf8_to_utf16_array!(self.infoboard, 172),
board: libpso::utf8_to_utf16_array!(other.infoboard, 172),
},
guildcard: CharacterGuildCard {
description: self.guildcard,
description: other.guildcard,
},
option_flags: self.option_flags as u32,
option_flags: other.option_flags as u32,
materials: CharacterMaterials {
power: self.power as u32,
mind: self.mind as u32,
def: self.def as u32,
evade: self.evade as u32,
luck: self.luck as u32,
hp: self.hp as u32,
tp: self.tp as u32,
power: other.power as u32,
mind: other.mind as u32,
def: other.def as u32,
evade: other.evade as u32,
luck: other.luck as u32,
hp: other.hp as u32,
tp: other.tp as u32,
},
tech_menu: CharacterTechMenu {
tech_menu: vec_to_array(self.tech_menu)
tech_menu: vec_to_array(other.tech_menu)
},
meseta: self.meseta as u32,
bank_meseta: self.bank_meseta as u32,
meseta: other.meseta as u32,
bank_meseta: other.bank_meseta as u32,
}
}
}
@ -300,10 +300,10 @@ impl From<weapon::Weapon> for PgWeapon {
}
}
impl Into<weapon::Weapon> for PgWeapon {
fn into(self) -> weapon::Weapon {
impl From<PgWeapon> for weapon::Weapon {
fn from(other: PgWeapon) -> weapon::Weapon {
let mut attrs: [Option<weapon::WeaponAttribute>; 3] = [None; 3];
for (attr, (atype, value)) in attrs.iter_mut().zip(self.attrs.iter()) {
for (attr, (atype, value)) in attrs.iter_mut().zip(other.attrs.iter()) {
*attr = Some(weapon::WeaponAttribute {
attr: *atype,
value: *value
@ -311,11 +311,11 @@ impl Into<weapon::Weapon> for PgWeapon {
}
weapon::Weapon {
weapon: self.weapon,
special: self.special,
grind: self.grind,
attrs: attrs,
tekked: self.tekked,
weapon: other.weapon,
special: other.special,
grind: other.grind,
attrs,
tekked: other.tekked,
}
}
}
@ -345,13 +345,13 @@ impl From<armor::Armor> for PgArmor {
}
}
impl Into<armor::Armor> for PgArmor {
fn into(self) -> armor::Armor {
impl From<PgArmor> for armor::Armor {
fn from(other: PgArmor) -> armor::Armor {
armor::Armor {
armor: self.armor,
dfp: self.dfp,
evp: self.evp,
slots: self.slots,
armor: other.armor,
dfp: other.dfp,
evp: other.evp,
slots: other.slots,
}
}
}
@ -373,12 +373,12 @@ impl From<shield::Shield> for PgShield {
}
}
impl Into<shield::Shield> for PgShield {
fn into(self) -> shield::Shield {
impl From<PgShield> for shield::Shield {
fn from(other: PgShield) -> shield::Shield {
shield::Shield {
shield: self.shield,
dfp: self.dfp,
evp: self.evp,
shield: other.shield,
dfp: other.dfp,
evp: other.evp,
}
}
}
@ -398,11 +398,11 @@ impl From<unit::Unit> for PgUnit {
}
}
impl Into<unit::Unit> for PgUnit {
fn into(self) -> unit::Unit {
impl From<PgUnit> for unit::Unit {
fn from(other: PgUnit) -> unit::Unit {
unit::Unit {
unit: self.unit,
modifier: self.modifier,
unit: other.unit,
modifier: other.modifier,
}
}
}
@ -420,10 +420,10 @@ impl From<tool::Tool> for PgTool {
}
}
impl Into<tool::Tool> for PgTool {
fn into(self) -> tool::Tool {
impl From<PgTool> for tool::Tool {
fn from(other: PgTool) -> tool::Tool {
tool::Tool {
tool: self.tool,
tool: other.tool,
}
}
}
@ -443,11 +443,11 @@ impl From<tech::TechniqueDisk> for PgTechDisk {
}
}
impl Into<tech::TechniqueDisk> for PgTechDisk {
fn into(self) -> tech::TechniqueDisk {
impl From<PgTechDisk> for tech::TechniqueDisk {
fn from(other: PgTechDisk) -> tech::TechniqueDisk {
tech::TechniqueDisk {
tech: self.tech,
level: self.level
tech: other.tech,
level: other.level
}
}
}
@ -469,8 +469,8 @@ impl From<mag::Mag> for PgMag {
}
}
impl Into<mag::Mag> for PgMag {
fn into(self) -> mag::Mag {
impl From<PgMag> for mag::Mag {
fn from(other: PgMag) -> mag::Mag {
/*mag::Mag {
mag: self.mag,
synchro: self.synchro,
@ -484,9 +484,9 @@ impl Into<mag::Mag> for PgMag {
class: CharacterClass::HUmar,
id: SectionID::Viridia,
}*/
let mut mag = mag::Mag::baby_mag(self.color as u16);
mag.mag = self.mag;
mag.synchro = self.synchro;
let mut mag = mag::Mag::baby_mag(other.color as u16);
mag.mag = other.mag;
mag.synchro = other.synchro;
mag
}
}
@ -510,13 +510,13 @@ impl From<esweapon::ESWeapon> for PgESWeapon {
}
}
impl Into<esweapon::ESWeapon> for PgESWeapon {
fn into(self) -> esweapon::ESWeapon {
impl From<PgESWeapon> for esweapon::ESWeapon {
fn from(other: PgESWeapon) -> esweapon::ESWeapon {
esweapon::ESWeapon {
esweapon: self.esweapon,
special: self.special,
name: self.name,
grind: self.grind,
esweapon: other.esweapon,
special: other.special,
name: other.name,
grind: other.grind,
}
}
}
@ -548,9 +548,9 @@ impl From<ItemDetail> for PgItemDetail {
}
}
impl Into<ItemDetail> for PgItemDetail {
fn into(self) -> ItemDetail {
match self {
impl From<PgItemDetail> for ItemDetail {
fn from(other: PgItemDetail) -> ItemDetail {
match other {
PgItemDetail::Weapon(weapon) => ItemDetail::Weapon(weapon.into()),
PgItemDetail::Armor(armor) => ItemDetail::Armor(armor.into()),
PgItemDetail::Shield(shield) => ItemDetail::Shield(shield.into()),
@ -613,9 +613,9 @@ impl From<ItemLocation> for PgItemLocationDetail {
}
}
impl Into<ItemLocation> for PgItemLocationDetail {
fn into(self) -> ItemLocation {
match self {
impl From<PgItemLocationDetail> for ItemLocation {
fn from(other: PgItemLocationDetail) -> ItemLocation {
match other{
PgItemLocationDetail::Inventory{character_id} => ItemLocation::Inventory{character_id: CharacterEntityId(character_id)},
PgItemLocationDetail::Bank{character_id, name} => ItemLocation::Bank{character_id: CharacterEntityId(character_id), name: BankName(name)},
PgItemLocationDetail::LocalFloor{character_id, map_area, x,y,z} => ItemLocation::LocalFloor{character_id: CharacterEntityId(character_id), map_area, x,y,z},
@ -655,9 +655,9 @@ impl From<mag::MagModifier> for PgMagModifierDetail {
}
}
impl Into<mag::MagModifier> for PgMagModifierDetail {
fn into(self) -> mag::MagModifier {
match self {
impl From<PgMagModifierDetail> for mag::MagModifier {
fn from(other: PgMagModifierDetail) -> mag::MagModifier {
match other {
PgMagModifierDetail::FeedMag(food) => mag::MagModifier::FeedMag{food: ItemEntityId(food as u32)},
PgMagModifierDetail::BankMag => mag::MagModifier::BankMag,
PgMagModifierDetail::MagCell(cell) => mag::MagModifier::MagCell(ItemEntityId(cell as u32)),
@ -687,12 +687,12 @@ pub struct PgItemWithLocation {
pub location: sqlx::types::Json<PgItemLocationDetail>,
}
impl Into<ItemEntity> for PgItemWithLocation {
fn into(self) -> ItemEntity {
impl From<PgItemWithLocation> for ItemEntity {
fn from(other: PgItemWithLocation) -> ItemEntity {
ItemEntity {
id: ItemEntityId(self.id as u32),
item: self.item.0.into(),
location: self.location.0.into(),
id: ItemEntityId(other.id as u32),
item: other.item.0.into(),
location: other.location.0.into(),
}
}
}
@ -740,18 +740,18 @@ pub struct PgEquipped {
mag: Option<i32>,
}
impl Into<EquippedEntity> for PgEquipped {
fn into(self) -> EquippedEntity {
impl From<PgEquipped> for EquippedEntity{
fn from(other: PgEquipped) -> EquippedEntity {
EquippedEntity {
weapon: self.weapon.map(|i| ItemEntityId(i as u32)),
armor: self.armor.map(|i| ItemEntityId(i as u32)),
shield: self.shield.map(|i| ItemEntityId(i as u32)),
unit: [self.unit0.map(|i| ItemEntityId(i as u32)),
self.unit1.map(|i| ItemEntityId(i as u32)),
self.unit2.map(|i| ItemEntityId(i as u32)),
self.unit3.map(|i| ItemEntityId(i as u32)),
weapon: other.weapon.map(|i| ItemEntityId(i as u32)),
armor: other.armor.map(|i| ItemEntityId(i as u32)),
shield: other.shield.map(|i| ItemEntityId(i as u32)),
unit: [other.unit0.map(|i| ItemEntityId(i as u32)),
other.unit1.map(|i| ItemEntityId(i as u32)),
other.unit2.map(|i| ItemEntityId(i as u32)),
other.unit3.map(|i| ItemEntityId(i as u32)),
],
mag: self.mag.map(|i| ItemEntityId(i as u32)),
mag: other.mag.map(|i| ItemEntityId(i as u32)),
}
}
}

19
src/entity/gateway/postgres/postgres.rs
View File

@ -1,5 +1,4 @@
use std::convert::{From, TryFrom, Into};
use futures::future::join_all;
use futures::TryStreamExt;
use async_std::stream::StreamExt;
use libpso::character::guildcard;
@ -25,10 +24,10 @@ pub struct PostgresGateway {
impl PostgresGateway {
pub fn new(host: &str, dbname: &str, username: &str, password: &str) -> PostgresGateway {
let mut conn = refinery::config::Config::new(refinery::config::ConfigDbType::Postgres)
.set_db_host(&host)
.set_db_user(&username)
.set_db_pass(&password)
.set_db_name(&dbname);
.set_db_host(host)
.set_db_user(username)
.set_db_pass(password)
.set_db_name(dbname);
embedded::migrations::runner().run(&mut conn).unwrap();
let pool = async_std::task::block_on(async move {
@ -40,7 +39,7 @@ impl PostgresGateway {
});
PostgresGateway {
pool: pool,
pool,
}
}
@ -96,13 +95,13 @@ impl PostgresGateway {
ItemDetail::Mag(mag)
},
item @ _ => item
item => item
};
ItemEntity {
id: id,
item: item,
location: location
id,
item,
location
}
}
}

4
src/entity/item/armor.rs
View File

@ -317,9 +317,9 @@ impl Armor {
pub fn from_bytes(data: [u8; 16]) -> Result<Armor, ItemParseError> {
let a = ArmorType::parse_type([data[0], data[1], data[2]]);
if a.is_ok() {
if let Ok(a) = a {
Ok(Armor {
armor: a.unwrap(),
armor: a,
dfp: data[6],
evp: data[8],
slots: data[5],

37
src/entity/item/esweapon.rs
View File

@ -190,10 +190,10 @@ impl ESWeapon {
pub fn bytes_from_name(&self) -> [u8; 6] {
let mut result = [0u16; 3];
let mut letters = [0u8; 8];
letters[0..self.name.len()].clone_from_slice(&self.name.to_uppercase().clone().into_bytes());
letters[0..self.name.len()].clone_from_slice(&self.name.to_uppercase().into_bytes());
for letter in letters.iter_mut() {
*letter = *letter & 0x3F;
*letter &= 0x3F;
}
result[0] = 0x8000 + (0x20 * letters[0] as u16) + (letters[1] as u16);
@ -207,29 +207,22 @@ impl ESWeapon {
// TODO: error handling, ensure name is never more than 8
pub fn name_from_bytes(namebytes: &[u8]) -> String {
let mut name: Vec<u8> = Vec::with_capacity(8);
name.extend_from_slice(namebytes);
for _ in name.len()..name.capacity() {
name.push(0);
}
let buf: [u16; 3] = [
u16::from_be_bytes([namebytes[0], namebytes[1]]),
u16::from_be_bytes([namebytes[2], namebytes[3]]),
u16::from_be_bytes([namebytes[4], namebytes[5]]),
];
name[0] = ((buf[0] - 0x8000) / 0x20 + 0x40) as u8;
name[1] = ((buf[0] - 0x8000) % 0x20 + 0x40) as u8;
name[2] = ((buf[1] - 0x8000) / 0x400 + 0x40) as u8;
name[3] = (((buf[1] - 0x8000) % 0x400) / 0x20 + 0x40) as u8;
name[4] = (((buf[1] - 0x8000) % 0x400) % 0x20 + 0x40) as u8;
name[5] = ((buf[2] - 0x8000) / 0x400 + 0x40) as u8;
name[6] = (((buf[2] - 0x8000) % 0x400) / 0x20 + 0x40) as u8;
name[7] = (((buf[2] - 0x8000) % 0x400) % 0x20 + 0x40) as u8;
let mut name: Vec<u8> = vec![
((buf[0] - 0x8000) / 0x20 + 0x40) as u8,
((buf[0] - 0x8000) % 0x20 + 0x40) as u8,
((buf[1] - 0x8000) / 0x400 + 0x40) as u8,
(((buf[1] - 0x8000) % 0x400) / 0x20 + 0x40) as u8,
(((buf[1] - 0x8000) % 0x400) % 0x20 + 0x40) as u8,
((buf[2] - 0x8000) / 0x400 + 0x40) as u8,
(((buf[2] - 0x8000) % 0x400) / 0x20 + 0x40) as u8,
(((buf[2] - 0x8000) % 0x400) % 0x20 + 0x40) as u8,
];
name.retain(|&x| x > 0x40 && x < 0x5B);
@ -254,10 +247,10 @@ impl ESWeapon {
let name = ESWeapon::name_from_bytes(&bytes[6..12]);
ESWeapon {
esweapon: esweapon,
esweapon,
special: special.ok(),
grind: grind,
name: name,
grind,
name,
}
}
}

29
src/entity/item/mag.rs
View File

@ -43,7 +43,7 @@ lazy_static::lazy_static! {
f.read_to_string(&mut s).unwrap();
let mut feed: HashMap<String, Vec<HashMap<String, MagFeedTable>>> = toml::from_str(&s).unwrap();
let feed = feed.remove("feedtable".into()).unwrap();
let feed = feed.remove("feedtable").unwrap();
feed.into_iter()
.map(|table| {
table.into_iter()
@ -624,7 +624,7 @@ impl Mag {
fn photon_blast_count(&self) -> u8 {
let mut count = 0;
for i in 0..3 {
if let Some(_) = self.photon_blast[i] {
if self.photon_blast[i].is_some() {
count |= 1 << i
};
}
@ -633,7 +633,7 @@ impl Mag {
pub fn from_bytes(data: [u8; 16]) -> Result<Mag, ItemParseError> {
let m = MagType::parse_type([data[0], data[1], data[2]]);
if m.is_ok() {
if let Ok(m) = m {
let mut def = u16::from_le_bytes([data[4], data[5]]);
let mut pow = u16::from_le_bytes([data[6], data[7]]);
let mut dex = u16::from_le_bytes([data[8], data[9]]);
@ -650,13 +650,13 @@ impl Mag {
let iq = data[13] % 201; // TODO: handle invalid values.
Ok(Mag{
mag: m.unwrap(),
def: def,
pow: pow,
dex: dex,
mag: m,
def,
pow,
dex,
mnd: mind,
synchro: sync,
iq: iq,
iq,
photon_blast: [None, None, None], // TODO: actually get PBs from bytes
color: data[15] % 18,
//modifiers: Vec::new(),
@ -739,6 +739,7 @@ impl Mag {
}
},
MagType::Vritra => {
#[allow(clippy::if_same_then_else)]
if self.pow > self.dex && self.pow > self.mnd {
self.mag = MagType::Sumba
}
@ -1004,9 +1005,9 @@ impl Mag {
MAG_STATS.get(&self.mag).map(|stats| {
stats.photon_blast.map(|photon_blast| {
if !self.photon_blast.contains(&Some(photon_blast)) {
self.photon_blast.iter_mut().find(|k| k.is_none()).map(|pb_slot| {
if let Some(pb_slot) = self.photon_blast.iter_mut().find(|k| k.is_none()) {
*pb_slot = Some(photon_blast)
});
}
}
})
});
@ -1038,10 +1039,10 @@ impl Mag {
}
pub fn bank(&mut self) {
self.def = self.def & 0xFFFE;
self.pow = self.pow & 0xFFFE;
self.dex = self.dex & 0xFFFE;
self.mnd = self.mnd & 0xFFFE;
self.def &= 0xFFFE;
self.pow &= 0xFFFE;
self.dex &= 0xFFFE;
self.mnd &= 0xFFFE;
}
// TODO: this needs more checks on validity

14
src/entity/item/mod.rs
View File

@ -121,13 +121,13 @@ impl ItemDetail {
}
pub fn parse_item_from_bytes(data: [u8; 16]) -> Option<ItemDropType> {
let item_type = weapon::WeaponType::parse_type([data[0],data[1],data[2]]).map(|w| ItemType::Weapon(w))
.or(armor::ArmorType::parse_type([data[0],data[1],data[2]]).map(|a| ItemType::Armor(a)))
.or(shield::ShieldType::parse_type([data[0],data[1],data[2]]).map(|s| ItemType::Shield(s)))
.or(unit::UnitType::parse_type([data[0],data[1],data[2]]).map(|u| ItemType::Unit(u)))
.or(mag::MagType::parse_type([data[0],data[1],data[2]]).map(|m| ItemType::Mag(m)))
.or(tool::ToolType::parse_type([data[0],data[1],data[2]]).map(|t| ItemType::Tool(t)))
.or(esweapon::ESWeaponType::parse_type([data[0],data[1],data[2]]).map(|e| ItemType::ESWeapon(e))).ok()?;
let item_type = weapon::WeaponType::parse_type([data[0],data[1],data[2]]).map(ItemType::Weapon)
.or_else(|_| armor::ArmorType::parse_type([data[0],data[1],data[2]]).map(ItemType::Armor))
.or_else(|_| shield::ShieldType::parse_type([data[0],data[1],data[2]]).map(ItemType::Shield))
.or_else(|_| unit::UnitType::parse_type([data[0],data[1],data[2]]).map(ItemType::Unit))
.or_else(|_| mag::MagType::parse_type([data[0],data[1],data[2]]).map(ItemType::Mag))
.or_else(|_| tool::ToolType::parse_type([data[0],data[1],data[2]]).map(ItemType::Tool))
.or_else(|_| esweapon::ESWeaponType::parse_type([data[0],data[1],data[2]]).map(ItemType::ESWeapon)).ok()?;
match item_type {
ItemType::Weapon(_w) => Some(ItemDropType::Weapon(weapon::Weapon::from_bytes(data).ok()?)),

4
src/entity/item/shield.rs
View File

@ -537,9 +537,9 @@ impl Shield {
pub fn from_bytes(data: [u8; 16]) -> Result<Shield, ItemParseError> {
let s = ShieldType::parse_type([data[0], data[1], data[2]]);
if s.is_ok() {
if let Ok(s) = s {
Ok(Shield{
shield: s.unwrap(),
shield: s,
dfp: data[6],
evp: data[8],
})

124
src/entity/item/tool.rs
View File

@ -186,36 +186,33 @@ pub enum ToolType {
impl ToolType {
pub fn is_stackable(&self) -> bool {
match self {
ToolType::Monomate => true,
ToolType::Dimate => true,
ToolType::Trimate => true,
ToolType::Monofluid => true,
ToolType::Difluid => true,
ToolType::Trifluid => true,
ToolType::SolAtomizer => true,
ToolType::MoonAtomizer => true,
ToolType::StarAtomizer => true,
ToolType::Antidote => true,
ToolType::Antiparalysis => true,
ToolType::Telepipe => true,
ToolType::TrapVision => true,
ToolType::Monogrinder => true,
ToolType::Digrinder => true,
ToolType::Trigrinder => true,
ToolType::PowerMaterial => true,
ToolType::MindMaterial => true,
ToolType::EvadeMaterial => true,
ToolType::HpMaterial => true,
ToolType::TpMaterial => true,
ToolType::DefMaterial => true,
ToolType::LuckMaterial => true,
ToolType::Addslot => true,
ToolType::PhotonDrop => true,
ToolType::PhotonSphere => true,
ToolType::PhotonCrystal => true,
_ => false,
}
matches!(self, ToolType::Monomate |
ToolType::Dimate |
ToolType::Trimate |
ToolType::Monofluid |
ToolType::Difluid |
ToolType::Trifluid |
ToolType::SolAtomizer |
ToolType::MoonAtomizer |
ToolType::StarAtomizer |
ToolType::Antidote |
ToolType::Antiparalysis |
ToolType::Telepipe |
ToolType::TrapVision |
ToolType::Monogrinder |
ToolType::Digrinder |
ToolType::Trigrinder |
ToolType::PowerMaterial |
ToolType::MindMaterial |
ToolType::EvadeMaterial |
ToolType::HpMaterial |
ToolType::TpMaterial |
ToolType::DefMaterial |
ToolType::LuckMaterial |
ToolType::Addslot |
ToolType::PhotonDrop |
ToolType::PhotonSphere |
ToolType::PhotonCrystal)
}
pub fn max_stack(&self) -> usize {
@ -252,39 +249,36 @@ impl ToolType {
}
pub fn is_mag_cell(&self) -> bool {
match self {
ToolType::CellOfMag502 => true,
ToolType::CellOfMag213 => true,
ToolType::PartsOfRobochao => true,
ToolType::HeartOfOpaOpa => true,
ToolType::HeartOfPian => true,
ToolType::HeartOfChao => true,
ToolType::HeartOfAngel => true,
ToolType::HeartOfDevil => true,
ToolType::KitOfHamburger => true,
ToolType::PanthersSpirit => true,
ToolType::KitOfMark3 => true,
ToolType::KitOfMasterSystem => true,
ToolType::KitOfGenesis => true,
ToolType::KitOfSegaSaturn => true,
ToolType::KitOfDreamcast => true,
ToolType::Tablet => true,
ToolType::DragonScale => true,
ToolType::HeavenStrikerCoat => true,
ToolType::PioneerParts => true,
ToolType::AmitiesMemo => true,
ToolType::HeartOfMorolian => true,
ToolType::RappysBeak => true,
ToolType::YahoosEngine => true,
ToolType::DPhotonCore => true,
ToolType::LibertaKit => true,
ToolType::CellOfMag0503 => true,
ToolType::CellOfMag0504 => true,
ToolType::CellOfMag0505 => true,
ToolType::CellOfMag0506 => true,
ToolType::CellOfMag0507 => true,
_ => false,
}
matches!(self, ToolType::CellOfMag502 |
ToolType::CellOfMag213 |
ToolType::PartsOfRobochao |
ToolType::HeartOfOpaOpa |
ToolType::HeartOfPian |
ToolType::HeartOfChao |
ToolType::HeartOfAngel |
ToolType::HeartOfDevil |
ToolType::KitOfHamburger |
ToolType::PanthersSpirit |
ToolType::KitOfMark3 |
ToolType::KitOfMasterSystem |
ToolType::KitOfGenesis |
ToolType::KitOfSegaSaturn |
ToolType::KitOfDreamcast |
ToolType::Tablet |
ToolType::DragonScale |
ToolType::HeavenStrikerCoat |
ToolType::PioneerParts |
ToolType::AmitiesMemo |
ToolType::HeartOfMorolian |
ToolType::RappysBeak |
ToolType::YahoosEngine |
ToolType::DPhotonCore |
ToolType::LibertaKit |
ToolType::CellOfMag0503 |
ToolType::CellOfMag0504 |
ToolType::CellOfMag0505 |
ToolType::CellOfMag0506 |
ToolType::CellOfMag0507)
}
pub fn value(&self) -> [u8; 3] {
@ -669,9 +663,9 @@ impl Tool {
pub fn from_bytes(data: [u8; 16]) -> Result<Tool, ItemParseError> {
let t = ToolType::parse_type([data[0], data[1], data[2]]);
if t.is_ok() {
if let Ok(t) = t {
Ok(Tool {
tool: t.unwrap(),
tool: t,
})
}
else {

4
src/entity/item/unit.rs
View File

@ -366,7 +366,7 @@ impl Unit {
pub fn from_bytes(data: [u8; 16]) -> Result<Unit, ItemParseError> {
let u = UnitType::parse_type([data[0], data[1], data[2]]);
if u.is_ok() {
if let Ok(u) = u {
let m = match u16::from_le_bytes([data[6], data[7]]) {
0x02 => Some(UnitModifier::PlusPlus),
0x01 => Some(UnitModifier::Plus),
@ -376,7 +376,7 @@ impl Unit {
};
Ok(Unit{
unit: u.unwrap(),
unit: u,
modifier: m,
})
}

45
src/entity/item/weapon.rs
View File

@ -1476,8 +1476,7 @@ impl Weapon {
}
pub fn apply_modifier(&mut self, modifier: &WeaponModifier) {
match modifier {
WeaponModifier::Tekked{special, percent, grind} => {
if let WeaponModifier::Tekked{special, percent, grind} = modifier {
match special {
TekSpecialModifier::Plus => {
self.special = self.special.map(|special| {
@ -1515,8 +1514,6 @@ impl Weapon {
}
self.grind = std::cmp::max(self.grind as i32 + grind, 0) as u8;
self.tekked = true;
},
_ => {}
}
}
@ -1526,7 +1523,7 @@ impl Weapon {
result[3] = self.grind;
result[4] = self.special.map(|s| s.value()).unwrap_or(0);
if self.tekked == false {
if !self.tekked {
result[4] += 0x80
};
@ -1539,25 +1536,25 @@ impl Weapon {
// TODO: error handling
pub fn from_bytes(data: [u8; 16]) -> Result<Weapon, ItemParseError> {
let w = WeaponType::parse_type([data[0], data[1], data[2]]);
if w.is_ok() {
let mut s = None;
let mut t = true;
let g = data[3];
let wep = WeaponType::parse_type([data[0], data[1], data[2]]);
if let Ok(weapon) = wep {
let mut special = None;
let mut tekked = true;
let grind = data[3];
if data[4] >= 0x81 && data[4] <= 0xA8 {
s = WeaponSpecial::from(data[4] - 0x80);
t = false;
special = WeaponSpecial::from(data[4] - 0x80);
tekked = false;
}
else if data[4] >= 0x01 && data[4] <= 0x28 {
s = WeaponSpecial::from(data[4]);
t = true;
special = WeaponSpecial::from(data[4]);
tekked = true;
}
// else {
// return Err(ItemParseError::InvalidSpecial)
// }
let mut a = [
let mut attrs = [
None,
None,
None
@ -1565,26 +1562,22 @@ impl Weapon {
for i in 0..3 {
if data[2 * (3 + i)] >= 1 && data[2 * (3 + i)] <= 5 {
a[i] = Some(WeaponAttribute{
attrs[i] = Some(WeaponAttribute{
attr: Attribute::from(data[2 * (3 + i)]).unwrap(),
value: data[2 * (3 + i) + 1] as i8,
});
} else {
a[i] = None;
attrs[i] = None;
// return Err(ItemParseError::InvalidAttribute)
}
}
Ok(Weapon {
weapon: w.unwrap(),
special: s,
grind: g,
attrs:[
a[0],
a[1],
a[2],
],
tekked: t,
weapon,
special,
grind,
attrs,
tekked,
})
}
else {

52
src/login/character.rs
View File

@ -28,7 +28,7 @@ use crate::entity::item::tool::Tool;
use crate::entity::item::mag::Mag;
use crate::entity::character::{CharacterEntity, NewCharacterEntity, CharacterClass, TechLevel};
use crate::login::login::{get_login_status, check_if_already_online};
use crate::login::login::{get_login_status};
use crate::common::interserver::AuthToken;
pub const CHARACTER_PORT: u16 = 12001;
@ -86,14 +86,14 @@ impl RecvServerPacket for RecvCharacterPacket {
pub enum SendCharacterPacket {
LoginResponse(LoginResponse),
LoginWelcome(LoginWelcome),
SendKeyAndTeamSettings(SendKeyAndTeamSettings),
SendKeyAndTeamSettings(Box<SendKeyAndTeamSettings>),
CharAck(CharAck),
ChecksumAck(ChecksumAck),
CharacterPreview(CharacterPreview),
GuildcardDataHeader(GuildcardDataHeader),
GuildcardDataChunk(Box<GuildcardDataChunk>),
ParamDataHeader(ParamDataHeader),
ParamDataChunk(ParamDataChunk),
ParamDataChunk(Box<ParamDataChunk>),
Timestamp(Timestamp),
ShipList(ShipList),
RedirectClient(RedirectClient),
@ -148,7 +148,7 @@ fn generate_param_data(path: &str) -> (ParamDataHeader, Vec<u8>) {
}
(ParamDataHeader {
files: files
files
}, buffer)
}
@ -285,10 +285,12 @@ async fn new_character<EG: EntityGateway>(entity_gateway: &mut EG, user: &UserAc
};
entity_gateway.set_character_inventory(&character.id, &inventory).await?;
entity_gateway.set_character_bank(&character.id, &BankEntity::default(), BankName("".into())).await?;
let mut equipped = EquippedEntity::default();
equipped.weapon = Some(weapon.id);
equipped.armor = Some(armor.id);
equipped.mag = Some(mag.id);
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(())
}
@ -299,13 +301,13 @@ impl<EG: EntityGateway> CharacterServerState<EG> {
let (param_header, param_data) = generate_param_data("data/param/");
CharacterServerState {
entity_gateway: entity_gateway,
param_header: param_header,
param_data: param_data,
entity_gateway,
param_header,
param_data,
clients: HashMap::new(),
ships: BTreeMap::new(),
level_table: CharacterLevelTable::new(),
auth_token: auth_token,
level_table: CharacterLevelTable::default(),
auth_token,
authenticated_ships: BTreeSet::new(),
ship_sender: BTreeMap::new(),
connected_clients: BTreeMap::new(),
@ -336,7 +338,7 @@ impl<EG: EntityGateway> CharacterServerState<EG> {
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
self.connected_clients.insert(user.id.clone(), ConnectedClient {
self.connected_clients.insert(user.id, ConnectedClient {
ship_id: None,
expires: None, //Some(chrono::Utc::now() + chrono::Duration::minutes(1)),
});
@ -368,7 +370,7 @@ impl<EG: EntityGateway> CharacterServerState<EG> {
let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
let user = client.user.as_ref().unwrap();
let settings = match self.entity_gateway.get_user_settings_by_user(&user).await {
let settings = match self.entity_gateway.get_user_settings_by_user(user).await {
Ok(settings) => settings,
Err(_) => {
let user_settings = NewUserSettingsEntity::new(user.id);
@ -378,7 +380,7 @@ impl<EG: EntityGateway> CharacterServerState<EG> {
let pkt = SendKeyAndTeamSettings::new(settings.settings.key_config,
settings.settings.joystick_config, 0, 0);
let pkt = SendCharacterPacket::SendKeyAndTeamSettings(pkt);
let pkt = SendCharacterPacket::SendKeyAndTeamSettings(Box::new(pkt));
Ok(vec![pkt])
}
@ -396,7 +398,7 @@ impl<EG: EntityGateway> CharacterServerState<EG> {
vec![SendCharacterPacket::CharacterPreview(CharacterPreview {
slot: select.slot,
character: SelectScreenCharacterBuilder::new()
.character(&char)
.character(char)
.level(level)
.build()
})]
@ -461,7 +463,7 @@ impl<EG: EntityGateway> CharacterServerState<EG> {
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.unwrap();
self.entity_gateway.save_user(user).await.unwrap();
Ok(None.into_iter())
}
@ -477,10 +479,10 @@ impl<EG: EntityGateway> CharacterServerState<EG> {
data[..end-start].copy_from_slice(&self.param_data[start..end]);
Ok(vec![SendCharacterPacket::ParamDataChunk(
ParamDataChunk {
Box::new(ParamDataChunk {
chunk: chunk as u32,
data: data,
}
data,
})
)])
}
@ -490,7 +492,7 @@ impl<EG: EntityGateway> CharacterServerState<EG> {
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?
new_character(&mut self.entity_gateway, user, preview).await?
}
if user.flags == USERFLAG_DRESSINGROOM {
// TODO: dressing room stuff
@ -499,7 +501,7 @@ impl<EG: EntityGateway> CharacterServerState<EG> {
client.session.action = SessionAction::SelectCharacter;
client.session.character_slot = preview.slot as u8;
user.flags = 0;
self.entity_gateway.save_user(&user).await.unwrap();
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)),
@ -512,7 +514,7 @@ impl<EG: EntityGateway> CharacterServerState<EG> {
fn select_ship(&mut self, id: ClientId, menuselect: &MenuSelect) -> Result<Vec<SendCharacterPacket>, anyhow::Error> {
if menuselect.menu != SHIP_MENU_ID {
Err(CharacterError::InvalidMenuSelection(menuselect.menu, menuselect.item))?;
return Err(CharacterError::InvalidMenuSelection(menuselect.menu, menuselect.item).into());
}
if let Some(client) = self.clients.get(&id) {
@ -856,7 +858,7 @@ mod test {
#[async_std::test]
async fn test_character_create() {
let test_data = InMemoryGateway::new();
let test_data = InMemoryGateway::default();
let mut fake_user = ClientState::new();
fake_user.user = Some(UserAccountEntity {
id: UserAccountId(3),

6
src/login/login.rs
View File

@ -101,8 +101,8 @@ pub struct LoginServerState<EG: EntityGateway> {
impl<EG: EntityGateway> LoginServerState<EG> {
pub fn new(entity_gateway: EG, character_server_ip: net::Ipv4Addr) -> LoginServerState<EG> {
LoginServerState {
entity_gateway: entity_gateway,
character_server_ip: character_server_ip.into(),
entity_gateway,
character_server_ip,
clients: HashMap::new(),
}
}
@ -164,7 +164,7 @@ impl<EG: EntityGateway> ServerState for LoginServerState<EG> {
if let Some(username) = self.clients.remove(&id) {
if let Ok(mut user) = self.entity_gateway.get_user_by_name(username).await {
user.at_login = false;
self.entity_gateway.save_user(&user).await;
self.entity_gateway.save_user(&user).await?;
}
}
Ok(Vec::new())

1
src/login/mod.rs
View File

@ -1,2 +1,3 @@
#[allow(clippy::module_inception)]
pub mod login;
pub mod character;

1
src/patch/mod.rs
View File

@ -1 +1,2 @@
#[allow(clippy::module_inception)]
pub mod patch;

25
src/patch/patch.rs
View File

@ -2,7 +2,7 @@ use std::collections::{HashMap, HashSet};
use std::fs;
use std::io;
use std::io::{Read};
use std::path::PathBuf;
use std::path::{Path, PathBuf};
use rand::Rng;
use crc::{crc32, Hasher32};
use libpso::{PacketParseError, PSOPacket};
@ -60,7 +60,7 @@ impl PatchFileTree {
PatchFileTree::Directory(dir, files) => {
v.push(PatchTreeIterItem::Directory(dir.clone()));
for file in files {
v.append(&mut PatchFileTree::iter_dir(&file));
v.append(&mut PatchFileTree::iter_dir(file));
}
v.push(PatchTreeIterItem::UpDirectory);
},
@ -146,10 +146,10 @@ pub struct PatchServerState {
impl PatchServerState {
pub fn new(patch_file_tree: PatchFileTree, patch_file_lookup: HashMap<u32, PatchFile>, patch_motd: String) -> PatchServerState {
PatchServerState {
patch_file_tree: patch_file_tree,
patch_file_lookup: patch_file_lookup,
patch_file_tree,
patch_file_lookup,
patch_file_info: Vec::new(),
patch_motd: patch_motd,
patch_motd,
}
}
}
@ -197,7 +197,7 @@ impl ServerState for PatchServerState {
let p = vec![SendPatchPacket::FilesToPatchMetadata(FilesToPatchMetadata::new(total_size, total_files)),
SendPatchPacket::PatchStartList(PatchStartList {})
];
Box::new(p.into_iter().chain(SendFileIterator::new(&self)).map(move |pkt| (id, pkt)))
Box::new(p.into_iter().chain(SendFileIterator::new(self)).map(move |pkt| (id, pkt)))
}
})
}
@ -214,18 +214,17 @@ fn load_patch_dir(basedir: &str, patchbase: &str, file_ids: &mut HashMap<u32, Pa
let mut dirs = Vec::new();
for p in paths {
let path = p.expect("not a real path").path();
if path.is_dir() {
let patch_path = path.strip_prefix(basedir).unwrap();
if path.is_dir() {
dirs.push(load_patch_dir(path.to_str().unwrap(), patch_path.to_str().unwrap(), file_ids));
}
else {
let patch_path = path.strip_prefix(basedir).unwrap();
files.push(PatchFileTree::File(patch_path.to_path_buf(), file_ids.len() as u32));
let (checksum, size) = get_checksum_and_size(&path).unwrap();
file_ids.insert(file_ids.len() as u32, PatchFile {
path: path,
checksum: checksum,
size: size,
path,
checksum,
size,
});
}
}
@ -264,7 +263,7 @@ fn get_file_list_packets(patch_file_tree: &PatchFileTree) -> Vec<SendPatchPacket
pkts
}
fn get_checksum_and_size(path: &PathBuf) -> Result<(u32, u32), PatchError> {
fn get_checksum_and_size(path: &Path) -> Result<(u32, u32), PatchError> {
let file = fs::File::open(path)?;
let size = file.metadata().unwrap().len();
let mut crc = crc32::Digest::new(crc32::IEEE);
@ -307,7 +306,7 @@ impl SendFileIterator {
file_iter: Box::new(state.patch_file_tree.flatten().into_iter().filter(move |file| {
match file {
PatchTreeIterItem::File(_path, id) => {
file_ids_to_update.contains(&id)
file_ids_to_update.contains(id)
},
_ => true,
}

26
src/ship/character.rs
View File

@ -9,16 +9,18 @@ pub struct CharacterBytesBuilder<'a> {
level: Option<u32>,
}
impl<'a> CharacterBytesBuilder<'a> {
pub fn new() -> CharacterBytesBuilder<'a> {
impl<'a> Default for CharacterBytesBuilder<'a> {
fn default() -> CharacterBytesBuilder<'a> {
CharacterBytesBuilder {
character: None,
stats: None,
level: None,
}
}
}
impl<'a> CharacterBytesBuilder<'a> {
pub fn character(self, character: &'a CharacterEntity) -> CharacterBytesBuilder<'a> {
CharacterBytesBuilder {
character: Some(character),
@ -53,7 +55,7 @@ impl<'a> CharacterBytesBuilder<'a> {
dfp: stats.dfp + character.materials.def as u16 * 2,
ata: stats.ata,
lck: stats.lck + character.materials.luck as u16 * 2,
level: level,
level,
section_id: character.section_id.into(),
ch_class: character.char_class.into(),
costume: character.appearance.costume,
@ -89,9 +91,8 @@ pub struct FullCharacterBytesBuilder<'a> {
option_flags: Option<u32>,
}
impl<'a> FullCharacterBytesBuilder<'a> {
pub fn new() -> FullCharacterBytesBuilder<'a> {
impl<'a> Default for FullCharacterBytesBuilder<'a> {
fn default() -> FullCharacterBytesBuilder<'a> {
FullCharacterBytesBuilder {
character: None,
stats: None,
@ -105,7 +106,10 @@ impl<'a> FullCharacterBytesBuilder<'a> {
option_flags: None,
}
}
}
impl<'a> FullCharacterBytesBuilder<'a> {
pub fn character(self, character: &'a CharacterEntity) -> FullCharacterBytesBuilder<'a> {
FullCharacterBytesBuilder {
character: Some(character),
@ -196,9 +200,9 @@ impl<'a> FullCharacterBytesBuilder<'a> {
inventory_items[11].material_count = character.materials.luck as u8;
character::FullCharacter {
character: CharacterBytesBuilder::new()
.character(&character)
.stats(&stats)
character: CharacterBytesBuilder::default()
.character(character)
.stats(stats)
.level(level - 1)
.build(),
inventory: character::Inventory {
@ -217,7 +221,7 @@ impl<'a> FullCharacterBytesBuilder<'a> {
symbol_chats: *symbol_chat,
tech_menu: *tech_menu,
bank: bank.as_client_bank_items(),
option_flags: option_flags,
option_flags,
..character::FullCharacter::default()
}
}

2
src/ship/drops/box_drop_table.rs
View File

@ -170,7 +170,7 @@ impl BoxDropTable {
else {
None
}
}).nth(0)
}).next()
}
fn random_box_drop<R: Rng>(&self, map_area: &MapArea, rng: &mut R) -> Option<ItemDropType> {

28
src/ship/drops/generic_weapon.rs
View File

@ -232,9 +232,9 @@ impl AttributeTable {
let area_percent_patterns: AreaPercentPatterns = load_data_file(episode, difficulty, section_id, "area_percent_pattern.toml");
AttributeTable {
attribute_rates: attribute_rates,
percent_rates: percent_rates,
area_percent_patterns: area_percent_patterns,
attribute_rates,
percent_rates,
area_percent_patterns,
}
}
@ -258,7 +258,7 @@ impl AttributeTable {
let percent = ((value + 1) * 5) as i8;
Some(WeaponAttribute {
attr: attr,
attr,
value: percent
})
}
@ -266,30 +266,24 @@ impl AttributeTable {
fn attributes<R: Rng>(&self, percent_pattern: &AttributePercentPattern, attribute_rate: &AttributeRate, rng: &mut R) -> [Option<WeaponAttribute>; 3] {
let mut percents = vec![
percent_pattern.attribute1.and_then(|pattern_type| {
self.generate_attribute(&pattern_type, &attribute_rate, rng)
self.generate_attribute(&pattern_type, attribute_rate, rng)
}),
percent_pattern.attribute2.and_then(|pattern_type| {
self.generate_attribute(&pattern_type, &attribute_rate, rng)
self.generate_attribute(&pattern_type, attribute_rate, rng)
}),
percent_pattern.attribute3.and_then(|pattern_type| {
self.generate_attribute(&pattern_type, &attribute_rate, rng)
self.generate_attribute(&pattern_type, attribute_rate, rng)
}),
];
percents.sort_by_key(|p| {
match p {
Some(a) => Some(a.attr),
None => None,
}
p.as_ref().map(|a| a.attr)
});
percents.dedup_by_key(|p| {
match p {
Some(a) => Some(a.attr),
None => None,
}
p.as_ref().map(|a| a.attr)
});
percents.iter()
.fold(([None; 3], 0), |(mut acc, index), p| { // one day I'll be able to collece into an array
if let Some(_) = p {
if p.is_some() {
acc[index] = *p;
(acc, index + 1)
}
@ -412,7 +406,7 @@ impl GenericWeaponTable {
rank_table.insert(WeaponDropType::Wand, vec![WeaponType::Wand, WeaponType::Staff, WeaponType::Baton, WeaponType::Scepter]);
GenericWeaponTable {
rank_table: rank_table,
rank_table,
weapon_ratio: WeaponRatios::new(episode, difficulty, section_id),
grind_rates: GrindRates::new(episode, difficulty, section_id),
attribute_table: AttributeTable::new(episode, difficulty, section_id),

2
src/ship/drops/mod.rs
View File

@ -152,7 +152,7 @@ impl<R: Rng + SeedableRng> DropTable<R> {
return None;
}
if let Some(item) = self.rare_table.get_drop(map_area, &monster, &mut self.rng) {
if let Some(item) = self.rare_table.get_drop(map_area, monster, &mut self.rng) {
return Some(item);
}

31
src/ship/drops/rare_drop_table.rs
View File

@ -30,18 +30,17 @@ pub enum RareDropItem {
impl RareDropItem {
pub fn from_string(name: String) -> RareDropItem {
let parse_funcs: [Box<dyn Fn(&String) -> Option<RareDropItem>>; 6] = [
Box::new(|i| Some(RareDropItem::Weapon(str::parse::<WeaponType>(&i).ok()?))),
Box::new(|i| Some(RareDropItem::Armor(str::parse::<ArmorType>(&i).ok()?))),
Box::new(|i| Some(RareDropItem::Shield(str::parse::<ShieldType>(&i).ok()?))),
Box::new(|i| Some(RareDropItem::Unit(str::parse::<UnitType>(&i).ok()?))),
Box::new(|i| Some(RareDropItem::Tool(str::parse::<ToolType>(&i).ok()?))),
Box::new(|i| Some(RareDropItem::Mag(str::parse::<MagType>(&i).ok()?))),
Box::new(|i| Some(RareDropItem::Weapon(str::parse::<WeaponType>(i).ok()?))),
Box::new(|i| Some(RareDropItem::Armor(str::parse::<ArmorType>(i).ok()?))),
Box::new(|i| Some(RareDropItem::Shield(str::parse::<ShieldType>(i).ok()?))),
Box::new(|i| Some(RareDropItem::Unit(str::parse::<UnitType>(i).ok()?))),
Box::new(|i| Some(RareDropItem::Tool(str::parse::<ToolType>(i).ok()?))),
Box::new(|i| Some(RareDropItem::Mag(str::parse::<MagType>(i).ok()?))),
];
for parse in parse_funcs.iter() {
match parse(&name) {
Some(k) => return k,
None => {},
if let Some (k) = parse(&name) {
return k
}
}
@ -88,7 +87,7 @@ impl RareDropTable {
}).collect();
RareDropTable {
rates: rates,
rates,
attribute_table: AttributeTable::new(episode, difficulty, section_id),
armor_stats: GenericArmorTable::new(episode, difficulty, section_id),
shield_stats: GenericShieldTable::new(episode, difficulty, section_id),
@ -99,7 +98,7 @@ impl RareDropTable {
match item {
RareDropItem::Weapon(weapon) => {
ItemDropType::Weapon(Weapon {
weapon: weapon,
weapon,
special: None,
grind: 0,
attrs: self.attribute_table.generate_rare_attributes(map_area, rng),
@ -109,7 +108,7 @@ impl RareDropTable {
},
RareDropItem::Armor(armor) => {
ItemDropType::Armor(Armor {
armor: armor,
armor,
dfp: self.armor_stats.dfp_modifier(&armor, rng) as u8,
evp: self.armor_stats.evp_modifier(&armor, rng) as u8,
slots: self.armor_stats.slots(map_area, rng) as u8,
@ -117,20 +116,20 @@ impl RareDropTable {
},
RareDropItem::Shield(shield) => {
ItemDropType::Shield(Shield {
shield: shield,
shield,
dfp: self.shield_stats.dfp_modifier(&shield, rng) as u8,
evp: self.shield_stats.evp_modifier(&shield, rng) as u8,
})
},
RareDropItem::Unit(unit) => {
ItemDropType::Unit(Unit {
unit: unit,
unit,
modifier: None,
})
},
RareDropItem::Tool(tool) => {
ItemDropType::Tool(Tool {
tool: tool,
tool,
})
},
RareDropItem::Mag(_mag) => {
@ -151,7 +150,7 @@ impl RareDropTable {
else {
None
}
}).nth(0)
}).next()
})
}
}

4
src/ship/item_stats.rs
View File

@ -172,9 +172,9 @@ pub fn mag_stats() -> HashMap<MagType, MagStats> {
pub fn mag_feed_tables() -> MagFeedTables {
let mag_feed_tables: BTreeMap<String, Vec<BTreeMap<String, MagFeedStats>>> = load_data_file("data/item_stats/mag_feed_table.toml");
MagFeedTables(mag_feed_tables.get("feedtable").unwrap().into_iter()
MagFeedTables(mag_feed_tables.get("feedtable").unwrap().iter()
.map(|feed_table| {
MagFeedTable(feed_table.into_iter()
MagFeedTable(feed_table.iter()
.map(|(tool, feed_stats)| {
(tool.parse().unwrap(), *feed_stats)
}).collect())

15
src/ship/items/bank.rs
View File

@ -167,7 +167,7 @@ impl CharacterBank {
items.sort();
CharacterBank {
item_id_counter: 0,
items: items,
items,
}
}
@ -178,16 +178,15 @@ impl CharacterBank {
self.item_id_counter = base_item_id + self.items.len() as u32 + 1;
}
pub fn get_item_handle_by_id<'a>(&'a mut self, item_id: ClientItemId) -> Option<BankItemHandle<'a>> {
pub fn get_item_handle_by_id(&mut self, item_id: ClientItemId) -> Option<BankItemHandle> {
let (index, _) = self.items.iter()
.enumerate()
.filter(|(_, item)| {
.find(|(_, item)| {
item.item_id() == item_id
})
.nth(0)?;
})?;
Some(BankItemHandle {
bank: self,
index: index,
index,
})
}
@ -222,8 +221,8 @@ impl CharacterBank {
},
};
character::BankItem {
data1: data1,
data2: data2,
data1,
data2,
item_id: item.item_id().0,
amount: amount as u16,
flags: 1,

12
src/ship/items/floor.rs
View File

@ -162,11 +162,13 @@ impl<'a> FloorItemHandle<'a> {
#[derive(Debug)]
pub struct RoomFloorItems(Vec<FloorItem>);
impl RoomFloorItems {
pub fn new() -> RoomFloorItems {
impl Default for RoomFloorItems {
fn default() -> RoomFloorItems {
RoomFloorItems(Vec::new())
}
}
impl RoomFloorItems {
pub fn add_item(&mut self, item: FloorItem) {
self.0.push(item);
}
@ -179,14 +181,14 @@ impl RoomFloorItems {
let index = self.0.iter().position(|item| item.item_id() == item_id)?;
Some(FloorItemHandle {
floor: self,
index: index,
index,
})
}
pub fn take_item_by_id(&mut self, item_id: ClientItemId) -> Option<FloorItem> {
self.0
.drain_filter(|i| i.item_id() == item_id)
.nth(0)
.next()
}
pub fn drop_individual_inventory_item(&mut self, individual_inventory_item: IndividualInventoryItem, item_drop_location: (MapArea, f32, f32, f32)) -> &IndividualFloorItem {
@ -232,7 +234,7 @@ impl RoomFloorItems {
self.0.push(FloorItem::Stacked(StackedFloorItem {
entity_ids: consumed_item.entity_ids(),
item_id: new_item_id,
tool: tool,
tool,
map_area: item_drop_location.0,
x: item_drop_location.1,
y: item_drop_location.2,

71
src/ship/items/inventory.rs
View File

@ -82,6 +82,11 @@ pub enum InventoryItemAddToError {
ExceedsCapacity,
}
#[derive(Error, Debug, Clone)]
#[error("")]
pub enum InventoryAddError {
}
impl InventoryItem {
pub fn entity_ids(&self) -> Vec<ItemEntityId> {
match self {
@ -153,12 +158,8 @@ impl InventoryItem {
// TODO: result
// TOOD: delete?
pub fn combine_stacks(&mut self, other_stacked_item: &mut StackedFloorItem) {
match self {
InventoryItem::Stacked(self_stacked_item) => {
if let InventoryItem::Stacked(self_stacked_item) = self {
self_stacked_item.entity_ids.append(&mut other_stacked_item.entity_ids);
},
_ => {
}
}
}
@ -338,8 +339,8 @@ impl<'a> InventoryItemHandle<'a> {
})
.ok_or(InventoryItemConsumeError::InvalidAmount)?;
Ok(ConsumedItem::Stacked(StackedConsumedItem {
entity_ids: entity_ids,
tool: tool,
entity_ids,
tool,
}))
}
}
@ -364,7 +365,7 @@ impl CharacterInventory {
pub fn new(items: Vec<InventoryItem>, equipped: &EquippedEntity) -> CharacterInventory {
CharacterInventory{
item_id_counter: 0,
items: items,
items,
equipped: equipped.clone(),
}
}
@ -393,7 +394,7 @@ impl CharacterInventory {
inventory[slot].data1[4] = self.equipped.unit.iter()
.enumerate()
.find(|(_, u_id)| **u_id == Some(individual_item.entity_id))
.map(|(a, b)| a)
.map(|(a, _)| a)
.unwrap_or(0) as u8
}
inventory[slot].equipped = 1;
@ -412,106 +413,100 @@ impl CharacterInventory {
self.items.len()
}
pub fn get_item_handle_by_id<'a>(&'a mut self, item_id: ClientItemId) -> Option<InventoryItemHandle<'a>> {
pub fn get_item_handle_by_id(&mut self, item_id: ClientItemId) -> Option<InventoryItemHandle> {
let (slot, _) = self.items.iter()
.enumerate()
.filter(|(_, item)| {
.find(|(_, item)| {
item.item_id() == item_id
})
.nth(0)?;
})?;
Some(InventoryItemHandle {
inventory: self,
slot: slot,
slot,
})
}
pub fn get_equipped_mag_handle<'a>(&'a mut self) -> Option<InventoryItemHandle<'a>> {
pub fn get_equipped_mag_handle(&mut self) -> Option<InventoryItemHandle> {
let (slot, _) = self.items.iter()
.enumerate()
.filter(|(_, item)| {
.find(|(_, item)| {
if let InventoryItem::Individual(individual_inventory_item) = item {
if let ItemDetail::Mag(_) = &individual_inventory_item.item {
return self.equipped.is_equipped(&individual_inventory_item.entity_id)
}
}
false
})
.nth(0)?;
})?;
Some(InventoryItemHandle {
inventory: self,
slot: slot,
slot,
})
}
pub fn get_equipped_armor_handle<'a>(&'a mut self) -> Option<InventoryItemHandle<'a>> {
pub fn get_equipped_armor_handle(&mut self) -> Option<InventoryItemHandle> {
let (slot, _) = self.items.iter()
.enumerate()
.filter(|(_, item)| {
.find(|(_, item)| {
if let InventoryItem::Individual(individual_inventory_item) = item {
if let ItemDetail::Armor(_) = &individual_inventory_item.item {
return self.equipped.is_equipped(&individual_inventory_item.entity_id)
}
}
false
})
.nth(0)?;
})?;
Some(InventoryItemHandle {
inventory: self,
slot: slot,
slot,
})
}
pub fn get_equipped_shield_handle<'a>(&'a mut self) -> Option<InventoryItemHandle<'a>> {
pub fn get_equipped_shield_handle(&mut self) -> Option<InventoryItemHandle> {
let (slot, _) = self.items.iter()
.enumerate()
.filter(|(_, item)| {
.find(|(_, item)| {
if let InventoryItem::Individual(individual_inventory_item) = item {
if let ItemDetail::Shield(_) = &individual_inventory_item.item {
return self.equipped.is_equipped(&individual_inventory_item.entity_id)
}
}
false
})
.nth(0)?;
})?;
Some(InventoryItemHandle {
inventory: self,
slot: slot,
slot,
})
}
pub fn get_equipped_weapon_handle<'a>(&'a mut self) -> Option<InventoryItemHandle<'a>> {
pub fn get_equipped_weapon_handle(&mut self) -> Option<InventoryItemHandle> {
let (slot, _) = self.items.iter()
.enumerate()
.filter(|(_, item)| {
.find(|(_, item)| {
if let InventoryItem::Individual(individual_inventory_item) = item {
if let ItemDetail::Weapon(_) = &individual_inventory_item.item {
return self.equipped.is_equipped(&individual_inventory_item.entity_id)
}
}
false
})
.nth(0)?;
})?;
Some(InventoryItemHandle {
inventory: self,
slot: slot,
slot,
})
}
pub fn get_item_by_id(&self, item_id: ClientItemId) -> Option<&InventoryItem> {
self.items.iter()
.filter(|item| {
.find(|item| {
item.item_id() == item_id
})
.nth(0)
}
pub fn take_item_by_id(&mut self, item_id: ClientItemId) -> Option<InventoryItem> {
self.items
.drain_filter(|i| i.item_id() == item_id)
.nth(0)
.next()
}
pub fn add_item(&mut self, item: InventoryItem) -> Result<(), ()> { // TODO: errors
pub fn add_item(&mut self, item: InventoryItem) -> Result<(), InventoryAddError> { // TODO: errors
// TODO: check slot conflict?
self.items.push(item);
Ok(())

110
src/ship/items/manager.rs
View File

@ -1,12 +1,11 @@
use crate::ship::items::ClientItemId;
use std::collections::{HashMap, BTreeMap};
use std::collections::HashMap;
use thiserror::Error;
use crate::entity::gateway::EntityGateway;
use crate::entity::character::{CharacterEntity, CharacterEntityId, TechLevel};
use crate::entity::item::{ItemDetail, ItemLocation, BankName};
use crate::entity::item::{Meseta, NewItemEntity, ItemEntity, InventoryItemEntity, EquippedEntity, InventoryEntity, BankItemEntity, BankEntity};
use crate::entity::item::{Meseta, NewItemEntity, ItemEntity, InventoryItemEntity, BankItemEntity};
use crate::entity::item::tool::{Tool, ToolType};
use crate::entity::item::unit;
use crate::entity::item::weapon;
use crate::ship::map::MapArea;
use crate::ship::ship::ItemDropLocation;
@ -71,8 +70,8 @@ pub struct ItemManager {
room_item_id_counter: HashMap<RoomId, Box<dyn FnMut() -> ClientItemId + Send>>,
}
impl ItemManager {
pub fn new() -> ItemManager {
impl Default for ItemManager {
fn default() -> ItemManager {
ItemManager {
id_counter: 0,
character_inventory: HashMap::new(),
@ -83,7 +82,9 @@ impl ItemManager {
room_item_id_counter: HashMap::new(),
}
}
}
impl ItemManager {
pub fn next_global_item_id(&mut self) -> ClientItemId {
self.id_counter += 1;
ClientItemId(self.id_counter)
@ -110,11 +111,11 @@ impl ItemManager {
entity_ids: items.iter().map(|i| i.id).collect(),
item_id: self.next_global_item_id(),
tool: items.get(0)
.ok_or(ItemManagerError::StackedItemError(items.clone()))?
.ok_or_else(|| ItemManagerError::StackedItemError(items.clone()))?
.item
.clone()
.as_tool()
.ok_or(ItemManagerError::StackedItemError(items.clone()))?
.ok_or_else(|| ItemManagerError::StackedItemError(items.clone()))?
})
},
})
@ -137,11 +138,11 @@ impl ItemManager {
entity_ids: items.iter().map(|i| i.id).collect(),
item_id: self.next_global_item_id(),
tool: items.get(0)
.ok_or(ItemManagerError::StackedItemError(items.clone()))?
.ok_or_else(|| ItemManagerError::StackedItemError(items.clone()))?
.item
.clone()
.as_tool()
.ok_or(ItemManagerError::StackedItemError(items.clone()))?
.ok_or_else(|| ItemManagerError::StackedItemError(items.clone()))?
})
},
})
@ -160,18 +161,15 @@ impl ItemManager {
inventory.initialize_item_ids(base_inventory_id);
let base_bank_id = ((area_client.local_client.id() as u32) << 21) | 0x20000;
let default_bank = self.character_bank.get_mut(&character.id);
match default_bank {
Some(default_bank) => {
if let Some(default_bank ) = default_bank {
default_bank.initialize_item_ids(base_bank_id);
},
None => {},
}
self.character_room.insert(character.id, room_id);
self.character_floor.insert(character.id, RoomFloorItems::new());
self.room_floor.entry(room_id).or_insert(RoomFloorItems::new());
self.character_floor.insert(character.id, RoomFloorItems::default());
self.room_floor.entry(room_id).or_insert_with(RoomFloorItems::default);
let mut inc = 0x00810000;
self.room_item_id_counter.entry(room_id).or_insert(Box::new(move || {
self.room_item_id_counter.entry(room_id).or_insert_with(|| Box::new(move || {
inc += 1;
ClientItemId(inc)
}));
@ -202,13 +200,11 @@ impl ItemManager {
pub fn remove_character_from_room(&mut self, character: &CharacterEntity) {
self.character_inventory.remove(&character.id);
self.character_floor.remove(&character.id);
self.character_room.remove(&character.id)
.as_ref()
.map(|room| {
if self.character_room.iter().find(|(_, r)| *r == room).is_none() {
if let Some(room) = self.character_room.remove(&character.id).as_ref() {
if self.character_room.iter().any(|(_, r)| r == room) {
self.room_floor.remove(room);
}
});
}
}
pub fn get_floor_item_by_id(&self, character: &CharacterEntity, item_id: ClientItemId) -> Result<(&FloorItem, FloorType), anyhow::Error> {
@ -220,7 +216,7 @@ impl ItemManager {
.or_else(|| {
shared_floor.get_item_by_id(item_id).map(|item| (item, FloorType::Shared))
})
.ok_or(ItemManagerError::NoSuchItemId(item_id).into())
.ok_or_else(|| ItemManagerError::NoSuchItemId(item_id).into())
}
pub async fn character_picks_up_item<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &mut CharacterEntity, item_id: ClientItemId)
@ -228,7 +224,7 @@ impl ItemManager {
let local_floor = self.character_floor.get_mut(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let inventory = self.character_inventory.get_mut(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let room_id = self.character_room.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let shared_floor = self.room_floor.get_mut(&room_id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let shared_floor = self.room_floor.get_mut(room_id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let floor_item = local_floor.get_item_handle_by_id(item_id)
.or_else(|| {
@ -238,16 +234,16 @@ impl ItemManager {
let trigger_create_item = match floor_item.item() {
Some(FloorItem::Individual(individual_floor_item)) => {
let new_inventory_item = inventory.pick_up_individual_floor_item(&individual_floor_item);
let new_inventory_item = inventory.pick_up_individual_floor_item(individual_floor_item);
match new_inventory_item {
Some((new_inventory_item, slot)) => {
Some((new_inventory_item, _slot)) => {
entity_gateway.change_item_location(
&new_inventory_item.entity_id,
ItemLocation::Inventory {
character_id: character.id,
}
).await?;
if let Some(_) = new_inventory_item.mag() {
if new_inventory_item.mag().is_some() {
entity_gateway.change_mag_owner(&new_inventory_item.entity_id, character).await?;
}
},
@ -258,13 +254,13 @@ impl ItemManager {
TriggerCreateItem::Yes
},
Some(FloorItem::Stacked(stacked_floor_item)) => {
let new_inventory_item = inventory.pick_up_stacked_floor_item(&stacked_floor_item);
let new_inventory_item = inventory.pick_up_stacked_floor_item(stacked_floor_item);
match new_inventory_item {
Some((new_inventory_item, slot)) => {
Some((new_inventory_item, _slot)) => {
for entity_id in &new_inventory_item.entity_ids {
entity_gateway.change_item_location(
&entity_id,
entity_id,
ItemLocation::Inventory {
character_id: character.id,
}
@ -288,7 +284,7 @@ impl ItemManager {
return Err(ItemManagerError::CouldNotAddToInventory(item_id).into());
}
character.meseta = std::cmp::min(character.meseta + meseta_floor_item.meseta.0, 999999);
entity_gateway.save_character(&character).await?;
entity_gateway.save_character(character).await?;
TriggerCreateItem::No
},
None => {
@ -340,7 +336,7 @@ impl ItemManager {
}).await?;
FloorItem::Individual(IndividualFloorItem {
entity_id: entity.id,
item_id: item_id,
item_id,
item: item_detail,
map_area: item_drop.map_area,
x: item_drop.x,
@ -361,8 +357,8 @@ impl ItemManager {
}).await?;
FloorItem::Stacked(StackedFloorItem {
entity_ids: vec![entity.id],
item_id: item_id,
tool: tool,
item_id,
tool,
map_area: item_drop.map_area,
x: item_drop.x,
y: item_drop.y,
@ -371,8 +367,8 @@ impl ItemManager {
},
ItemOrMeseta::Meseta(meseta) => {
FloorItem::Meseta(MesetaFloorItem {
item_id: item_id,
meseta: meseta,
item_id,
meseta,
map_area: item_drop.map_area,
x: item_drop.x,
y: item_drop.y,
@ -381,9 +377,9 @@ impl ItemManager {
},
};
self.character_floor.entry(character.id).or_insert(RoomFloorItems::new()).add_item(floor_item);
self.character_floor.entry(character.id).or_insert_with(RoomFloorItems::default).add_item(floor_item);
// TODO: make these real errors
self.character_floor.get(&character.id).ok_or(ItemManagerError::Idunnoman)?.get_item_by_id(item_id).ok_or(ItemManagerError::Idunnoman.into())
self.character_floor.get(&character.id).ok_or(ItemManagerError::Idunnoman)?.get_item_by_id(item_id).ok_or_else(|| ItemManagerError::Idunnoman.into())
}
pub async fn player_drop_item_on_shared_floor<EG: EntityGateway>(&mut self,
@ -395,7 +391,7 @@ impl ItemManager {
-> Result<(), anyhow::Error> {
let inventory = self.character_inventory.get_mut(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let room_id = self.character_room.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let shared_floor = self.room_floor.get_mut(&room_id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let shared_floor = self.room_floor.get_mut(room_id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let dropped_inventory_item = inventory.take_item_by_id(item_id).ok_or(ItemManagerError::NoSuchItemId(item_id))?;
@ -439,16 +435,16 @@ impl ItemManager {
amount: u32)
-> Result<FloorItem, anyhow::Error> {
let room_id = self.character_room.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let shared_floor = self.room_floor.get_mut(&room_id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let shared_floor = self.room_floor.get_mut(room_id).ok_or(ItemManagerError::NoCharacter(character.id))?;
if character.meseta < amount {
return Err(ItemManagerError::CouldNotDropMeseta.into())
}
character.meseta -= amount;
entity_gateway.save_character(&character).await?;
entity_gateway.save_character(character).await?;
let item_id = self.room_item_id_counter.get_mut(room_id).ok_or(ItemManagerError::NoCharacter(character.id))?();
let floor_item = FloorItem::Meseta(MesetaFloorItem {
item_id: item_id,
item_id,
meseta: Meseta(amount),
map_area: drop_location.map_area,
x: drop_location.x,
@ -470,7 +466,7 @@ impl ItemManager {
-> Result<&StackedFloorItem, anyhow::Error> {
let inventory = self.character_inventory.get_mut(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let room_id = self.character_room.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let shared_floor = self.room_floor.get_mut(&room_id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let shared_floor = self.room_floor.get_mut(room_id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let item_to_split = inventory.get_item_handle_by_id(item_id).ok_or(ItemManagerError::NoSuchItemId(item_id))?;
@ -574,13 +570,13 @@ impl ItemManager {
let inventory_item = inventory.withdraw_item(item_to_withdraw, amount).ok_or(ItemManagerError::Idunnoman)?;
match inventory_item {
(InventoryItem::Individual(individual_inventory_item), slot) => {
(InventoryItem::Individual(individual_inventory_item), _slot) => {
entity_gateway.change_item_location(&individual_inventory_item.entity_id,
ItemLocation::Inventory {
character_id: character.id,
}).await?;
},
(InventoryItem::Stacked(stacked_inventory_item), slot) => {
(InventoryItem::Stacked(stacked_inventory_item), _slot) => {
for entity_id in &stacked_inventory_item.entity_ids {
entity_gateway.change_item_location(entity_id,
ItemLocation::Inventory {
@ -594,7 +590,7 @@ impl ItemManager {
entity_gateway.set_character_inventory(&character.id, &inventory.as_inventory_entity(&character.id)).await?;
entity_gateway.set_character_bank(&character.id, &bank.as_bank_entity(&character.id, &BankName("".into())), BankName("".into())).await?;
inventory.slot(inventory_item_slot).ok_or(ItemManagerError::Idunnoman.into())
inventory.slot(inventory_item_slot).ok_or_else(|| ItemManagerError::Idunnoman.into())
}
pub async fn player_feeds_mag_item<EG: EntityGateway>(&mut self,
@ -771,8 +767,8 @@ impl ItemManager {
}
let floor_item = StackedFloorItem {
entity_ids: item_entities.into_iter().map(|i| i.id).collect(),
item_id: item_id,
tool: tool,
item_id,
tool,
// TODO: this is gonna choke if I ever require the item being near the player for pickup
map_area: MapArea::Pioneer2Ep1,
x: 0.0,
@ -780,7 +776,7 @@ impl ItemManager {
z: 0.0,
};
let item_id = {
let (picked_up_item, slot) = inventory.pick_up_stacked_floor_item(&floor_item).ok_or(ItemManagerError::CouldNotAddBoughtItemToInventory)?;
let (picked_up_item, _slot) = inventory.pick_up_stacked_floor_item(&floor_item).ok_or(ItemManagerError::CouldNotAddBoughtItemToInventory)?;
for entity_id in &picked_up_item.entity_ids {
entity_gateway.change_item_location(entity_id,
ItemLocation::Inventory {
@ -798,7 +794,7 @@ impl ItemManager {
}).await?;
let floor_item = IndividualFloorItem {
entity_id: item_entity.id,
item_id: item_id,
item_id,
item: ItemDetail::Tool(tool),
// TODO: this is gonna choke if I ever require the item being near the player for pickup
map_area: MapArea::Pioneer2Ep1,
@ -807,7 +803,7 @@ impl ItemManager {
z: 0.0,
};
let item_id = {
let (picked_up_item, slot) = inventory.pick_up_individual_floor_item(&floor_item).ok_or(ItemManagerError::CouldNotAddBoughtItemToInventory)?;
let (picked_up_item, _slot) = inventory.pick_up_individual_floor_item(&floor_item).ok_or(ItemManagerError::CouldNotAddBoughtItemToInventory)?;
entity_gateway.change_item_location(&picked_up_item.entity_id,
ItemLocation::Inventory {
character_id: character.id,
@ -817,14 +813,14 @@ impl ItemManager {
inventory.get_item_by_id(item_id).ok_or(ItemManagerError::ItemIdNotInInventory(item_id))?
}
},
item_detail @ _ => {
item_detail => {
let item_entity = entity_gateway.create_item(NewItemEntity {
location: ItemLocation::Shop,
item: item_detail.clone(),
}).await?;
let floor_item = IndividualFloorItem {
entity_id: item_entity.id,
item_id: item_id,
item_id,
item: item_detail,
// TODO: this is gonna choke if I ever require the item being near the player for pickup
map_area: MapArea::Pioneer2Ep1,
@ -833,7 +829,7 @@ impl ItemManager {
z: 0.0,
};
let item_id = {
let (picked_up_item, slot) = inventory.pick_up_individual_floor_item(&floor_item).ok_or(ItemManagerError::CouldNotAddBoughtItemToInventory)?;
let (picked_up_item, _slot) = inventory.pick_up_individual_floor_item(&floor_item).ok_or(ItemManagerError::CouldNotAddBoughtItemToInventory)?;
entity_gateway.change_item_location(&picked_up_item.entity_id,
ItemLocation::Inventory {
character_id: character.id,
@ -881,7 +877,7 @@ impl ItemManager {
let sorted_inventory_items: Vec<InventoryItem> = item_ids.iter()
.filter(|&client_item_id| *client_item_id < 0xFFFFFFFF)
.map(|&client_item_id| inventory.get_item_by_id(ClientItemId(client_item_id)))
.filter(|&x| x.is_some() == true)
.filter(|&x| x.is_some())
.map(|x| x.cloned().unwrap())
.collect();
@ -914,10 +910,10 @@ impl ItemManager {
entity_gateway.add_weapon_modifier(&entity_id, tek).await?;
inventory.add_item(InventoryItem::Individual(IndividualInventoryItem {
entity_id: entity_id,
item_id: item_id,
entity_id,
item_id,
item: ItemDetail::Weapon(weapon.clone()),
}));
}))?;
entity_gateway.set_character_inventory(&character.id, &inventory.as_inventory_entity(&character.id)).await?;

28
src/ship/location.rs
View File

@ -155,8 +155,7 @@ impl ClientLocation {
let l = self.lobbies.get_mut(lobby.0).ok_or(JoinLobbyError::LobbyDoesNotExist)?;
let (index, empty_slot) = l.0.iter_mut()
.enumerate()
.filter(|(_, k)| k.is_none())
.nth(0)
.find(|(_, k)| k.is_none())
.ok_or(JoinLobbyError::LobbyFull)?;
*empty_slot = Some(AreaClient {
client: id,
@ -173,10 +172,9 @@ impl ClientLocation {
let new_lobby = LobbyId((lobby.0 + lobby_index) % 15);
(new_lobby, self.add_client_to_lobby(id, new_lobby))
})
.filter(|(_, lobby_option)| {
.find(|(_, lobby_option)| {
lobby_option.is_ok()
})
.nth(0)
.ok_or(JoinLobbyError::LobbyFull)?;
Ok(l.0)
@ -185,8 +183,7 @@ impl ClientLocation {
pub fn create_new_room(&mut self, id: ClientId) -> Result<RoomId, CreateRoomError> {
let (index, empty_slot) = self.rooms.iter_mut()
.enumerate()
.filter(|(_, r)| r.is_none())
.nth(0)
.find(|(_, r)| r.is_none())
.ok_or(CreateRoomError::NoOpenSlots)?;
*empty_slot = Some(Room([None; 4]));
self.add_client_to_room(id, RoomId(index)).map_err(|_err| CreateRoomError::JoinError)?;
@ -201,8 +198,7 @@ impl ClientLocation {
.ok_or(JoinRoomError::RoomDoesNotExist)?;
let (index, empty_slot) = r.0.iter_mut()
.enumerate()
.filter(|(_, k)| k.is_none())
.nth(0)
.find(|(_, k)| k.is_none())
.ok_or(JoinRoomError::RoomFull)?;
*empty_slot = Some(AreaClient {
client: id,
@ -252,7 +248,7 @@ impl ClientLocation {
let mut r = self.rooms[room.0]
.as_ref()
.ok_or(GetLeaderError::InvalidArea)?
.0.iter().flat_map(|k| k)
.0.iter().flatten()
.collect::<Vec<_>>();
r.sort_by_key(|k| k.time_join);
let c = r.get(0).ok_or(GetLeaderError::NoClientInArea)?;
@ -261,7 +257,7 @@ impl ClientLocation {
pub fn get_lobby_leader(&self, lobby: LobbyId) -> Result<AreaClient, GetLeaderError> {
let mut l = self.lobbies[lobby.0]
.0.iter().flat_map(|k| k)
.0.iter().flatten()
.collect::<Vec<_>>();
l.sort_by_key(|k| k.time_join);
let c = l.get(0).ok_or(GetLeaderError::NoClientInArea)?;
@ -319,15 +315,13 @@ impl ClientLocation {
RoomLobby::Room(room) => {
self.get_clients_in_room(*room).map_err(|_| GetClientsError::InvalidArea)?
.into_iter()
.filter(|c| c.client == id)
.nth(0)
.find(|c| c.client == id)
.ok_or(GetClientsError::InvalidClient)
},
RoomLobby::Lobby(lobby) => {
self.get_clients_in_lobby(*lobby).map_err(|_| GetClientsError::InvalidArea)?
.into_iter()
.filter(|c| c.client == id)
.nth(0)
.find(|c| c.client == id)
.ok_or(GetClientsError::InvalidClient)
}
}
@ -361,8 +355,10 @@ impl ClientLocation {
let area = self.client_location.get_mut(&id).ok_or(ClientRemovalError::ClientNotInArea)?;
let client_list = match area {
RoomLobby::Room(room) => {
self.rooms[room.0].as_mut().map_or(None, |r| {
Some(r.0.iter_mut())
self.rooms[room.0]
.as_mut()
.map(|r| {
r.0.iter_mut()
})
},
RoomLobby::Lobby(lobby) => {

6
src/ship/map/area.rs
View File

@ -291,13 +291,15 @@ pub struct MapAreaLookupBuilder {
map_areas: HashMap<u16, MapArea>,
}
impl MapAreaLookupBuilder {
pub fn new() -> MapAreaLookupBuilder {
impl Default for MapAreaLookupBuilder {
fn default() -> MapAreaLookupBuilder {
MapAreaLookupBuilder {
map_areas: HashMap::new()
}
}
}
impl MapAreaLookupBuilder {
pub fn add(mut self, value: u16, map_area: MapArea) -> MapAreaLookupBuilder {
self.map_areas.insert(value, map_area);
self

8
src/ship/map/enemy.rs
View File

@ -252,8 +252,8 @@ impl MapEnemy {
};
Ok(MapEnemy {
monster: monster,
map_area: map_area.clone(),
monster,
map_area: *map_area,
hp: 0,
dropped_item: false,
gave_exp: false,
@ -263,8 +263,8 @@ impl MapEnemy {
pub fn new(monster: MonsterType, map_area: MapArea) -> MapEnemy {
MapEnemy {
monster: monster,
map_area: map_area,
monster,
map_area,
hp: 0,
dropped_item: false,
gave_exp: false,

11
src/ship/map/maps.rs
View File

@ -17,14 +17,14 @@ pub fn objects_from_stream(cursor: &mut impl Read, episode: &Episode, map_area:
let mut object_data = Vec::new();
while let Ok(raw_object) = RawMapObject::from_byte_stream(cursor) {
let object = MapObject::from_raw(raw_object.clone(), *episode, map_area);
let object = MapObject::from_raw(raw_object, *episode, map_area);
object_data.push(object.ok());
}
object_data
}
fn objects_from_map_data(path: PathBuf, episode: &Episode, map_area: &MapArea) -> Vec<Option<MapObject>> {
let mut cursor = File::open(path.clone()).unwrap();
let mut cursor = File::open(path).unwrap();
objects_from_stream(&mut cursor, episode, map_area)
}
@ -32,8 +32,7 @@ fn parse_enemy(episode: &Episode, map_area: &MapArea, raw_enemy: RawMapEnemy) ->
let enemy = MapEnemy::from_raw(raw_enemy, episode, map_area);
enemy
.map_or(vec![None], |monster| {
let mut monsters = Vec::new();
monsters.push(Some(monster));
let mut monsters = vec![Some(monster)];
match monster.monster {
MonsterType::Monest => {
@ -275,13 +274,13 @@ impl Maps {
let maps = Maps {
enemy_data: map_variants.iter().fold(Vec::new(), |mut enemy_data, map_variant| {
enemy_data.append(&mut enemy_data_from_map_data(&map_variant, &room_mode.episode()));
enemy_data.append(&mut enemy_data_from_map_data(map_variant, &room_mode.episode()));
enemy_data
}),
object_data: map_variants.iter().map(|map_variant| {
objects_from_map_data(map_variant.obj_file().into(), &room_mode.episode(), &map_variant.map)
}).flatten().collect(),
map_variants: map_variants,
map_variants,
};
maps
}

4
src/ship/map/object.rs
View File

@ -159,8 +159,8 @@ impl MapObject {
};
Ok(MapObject {
object: object,
map: map_area.clone(),
object,
map: *map_area,
dropped_item: false,
})
}

28
src/ship/map/variant.rs
View File

@ -75,10 +75,10 @@ impl MapVariant {
};
MapVariant {
map: map,
mode: mode,
major: major,
minor: minor,
map,
mode,
major,
minor,
}
}
else {
@ -136,10 +136,10 @@ impl MapVariant {
};
MapVariant {
map: map,
mode: mode,
major: major,
minor: minor,
map,
mode,
major,
minor,
}
}
}
@ -198,9 +198,9 @@ impl MapVariant {
MapArea::Forest1 => format!("data/maps/map_forest01_0{}_offe.dat", self.minor*2),
MapArea::Forest2 => {
match self.minor {
0 => format!("data/maps/map_forest02_00_offe.dat"),
1 => format!("data/maps/map_forest02_03_offe.dat"),
2 => format!("data/maps/map_forest02_04_offe.dat"),
0 => "data/maps/map_forest02_00_offe.dat".into(),
1 => "data/maps/map_forest02_03_offe.dat".into(),
2 => "data/maps/map_forest02_04_offe.dat".into(),
_ => unreachable!()
}},
MapArea::Caves1 => format!("data/maps/map_cave01_0{}_0{}_offe.dat", self.major, self.minor),
@ -302,9 +302,9 @@ impl MapVariant {
MapArea::Forest1 => format!("data/maps/map_forest01_0{}o.dat", self.minor*2),
MapArea::Forest2 => {
match self.minor {
0 => format!("data/maps/map_forest02_00o.dat"),
1 => format!("data/maps/map_forest02_03o.dat"),
2 => format!("data/maps/map_forest02_04o.dat"),
0 => "data/maps/map_forest02_00o.dat".into(),
1 => "data/maps/map_forest02_03o.dat".into(),
2 => "data/maps/map_forest02_04o.dat".into(),
_ => unreachable!()
}},
MapArea::Caves1 => format!("data/maps/map_cave01_0{}_0{}o.dat", self.major, self.minor),

1
src/ship/mod.rs
View File

@ -1,3 +1,4 @@
#[allow(clippy::module_inception)]
pub mod ship;
pub mod location;
pub mod character;

4
src/ship/packet/builder/lobby.rs
View File

@ -18,7 +18,7 @@ pub fn join_lobby(id: ClientId,
let playerinfo = lobby_clients.iter()
.map(|area_client| {
let client = clients.get(&area_client.client).ok_or(ShipError::ClientNotFound(area_client.client)).unwrap();
player_info(0x100, &client, area_client, item_manager, level_table)
player_info(0x100, client, area_client, item_manager, level_table)
});
let client = clients.get(&id).ok_or(ShipError::ClientNotFound(id)).unwrap();
@ -55,7 +55,7 @@ pub fn add_to_lobby(id: ClientId,
block: client.block as u16,
event: 0,
padding: 0,
playerinfo: player_info(0x100, &client, &area_client, item_manager, level_table),
playerinfo: player_info(0x100, client, &area_client, item_manager, level_table),
})
}

16
src/ship/packet/builder/message.rs
View File

@ -12,8 +12,8 @@ use crate::ship::shops::ShopItem;
pub fn item_drop(client: u8, target: u8, item_drop: &FloorItem) -> Result<ItemDrop, ShipError> {
let item_bytes = item_drop.as_client_bytes();
Ok(ItemDrop {
client: client,
target: target,
client,
target,
map_area: item_drop.map_area().area_value(),
variety: 0,
unknown: 0,
@ -101,7 +101,7 @@ pub fn character_gained_exp(area_client: AreaClient, exp: u32) -> GiveCharacterE
GiveCharacterExp {
client: area_client.local_client.id(),
target: 0,
exp: exp,
exp,
}
}
@ -138,12 +138,12 @@ pub fn player_no_longer_has_item(area_client: AreaClient, item_id: ClientItemId,
client: area_client.local_client.id(),
target: 0,
item_id: item_id.0,
amount: amount,
amount,
}
}
pub fn shop_list<I: ShopItem>(shop_type: u8, items: &Vec<I>) -> ShopList {
let items = items.into_iter()
pub fn shop_list<I: ShopItem>(shop_type: u8, items: &[I]) -> ShopList {
let items = items.iter()
.enumerate()
.map(|(i, item)| {
ShopListItem {
@ -157,10 +157,10 @@ pub fn shop_list<I: ShopItem>(shop_type: u8, items: &Vec<I>) -> ShopList {
ShopList {
client: 0,
target: 0,
shop_type: shop_type,
shop_type,
num_items: 0,
unused: 0,
items: items,
items,
}
}

6
src/ship/packet/builder/mod.rs
View File

@ -14,7 +14,7 @@ use crate::ship::items::ItemManager;
pub fn player_header(tag: u32, client: &ClientState, area_client: &AreaClient) -> PlayerHeader {
PlayerHeader {
tag: tag,
tag,
guildcard: client.user.id.0,
_unknown1: [0; 5],
client_id: area_client.local_client.id() as u32,
@ -26,7 +26,7 @@ pub fn player_header(tag: u32, client: &ClientState, area_client: &AreaClient) -
pub fn player_info(tag: u32, client: &ClientState, area_client: &AreaClient, item_manager: &ItemManager, level_table: &CharacterLevelTable) -> PlayerInfo {
let (level, stats) = level_table.get_stats_from_exp(client.character.char_class, client.character.exp);
let inventory = item_manager.get_character_inventory(&client.character).unwrap();
let character = CharacterBytesBuilder::new()
let character = CharacterBytesBuilder::default()
.character(&client.character)
.stats(&stats)
.level(level - 1)
@ -40,6 +40,6 @@ pub fn player_info(tag: u32, client: &ClientState, area_client: &AreaClient, ite
language: 0, // TODO: account language
items: inventory.as_client_inventory_items(),
},
character: character,
character,
}
}

8
src/ship/packet/builder/quest.rs
View File

@ -22,7 +22,7 @@ pub fn quest_category_list(quests: &QuestList) -> QuestCategoryList {
}
}
pub fn quest_list(category_id: u32, quests: &Vec<Quest>) -> QuestOptionList {
pub fn quest_list(category_id: u32, quests: &[Quest]) -> QuestOptionList {
let quest_entries = quests.iter()
.map(|quest| {
QuestEntry {
@ -59,9 +59,9 @@ pub fn quest_header(quest_menu_select: &QuestMenuSelect, data_blob: &[u8], suffi
pub fn quest_chunk(chunk_num: u32, filename: [u8; 16], blob: [u8; 0x400], blob_length: usize) -> QuestChunk {
QuestChunk {
chunk_num: chunk_num,
filename: filename,
blob: blob,
chunk_num,
filename,
blob,
blob_length: blob_length as u32,
unknown: 0,
}

6
src/ship/packet/builder/room.rs
View File

@ -20,7 +20,7 @@ pub fn join_room(id: ClientId,
let header_client = clients.get(&c.client).ok_or(ShipError::ClientNotFound(id))?;
let header_area_client = client_location.get_local_client(id).map_err(|err| -> ClientLocationError { err.into() })?;
acc.map(|mut a| {
a[i] = player_header(0x10000, &header_client, &header_area_client);
a[i] = player_header(0x10000, header_client, &header_area_client);
a
})
})?;
@ -30,7 +30,7 @@ pub fn join_room(id: ClientId,
Ok(JoinRoom {
flag: all_clients.len() as u32,
maps: room.maps.map_headers(),
players: players,
players,
client: area_client.local_client.id(),
leader: leader.local_client.id(),
one: 1,
@ -67,7 +67,7 @@ pub fn add_to_room(_id: ClientId,
block: 0,
event: 0,
padding: 0,
playerinfo: player_info(0x10000, client, &area_client, item_manager, level_table),
playerinfo: player_info(0x10000, client, area_client, item_manager, level_table),
})
}

11
src/ship/packet/builder/ship.rs
View File

@ -1,19 +1,10 @@
use libpso::packet::login::{ShipList, ShipListEntry};
use libpso::packet::ship::*;
use crate::common::serverstate::ClientId;
use crate::common::leveltable::CharacterLevelTable;
use crate::ship::ship::{ShipError, ClientState, Clients};
use crate::ship::location::{ClientLocation, RoomId, AreaClient, ClientLocationError};
use crate::ship::room::RoomState;
use crate::ship::items::ItemManager;
use crate::ship::packet::builder::{player_header, player_info};
use libpso::utf8_to_utf16_array;
use crate::common::interserver::Ship;
use libpso::packet::ship::BLOCK_MENU_ID;
use crate::login::character::SHIP_MENU_ID;
pub fn ship_list(ships: &Vec<Ship>) -> ShipList {
pub fn ship_list(ships: &[Ship]) -> ShipList {
let ships = ships.iter()
.enumerate()
.map(|(i, ship)| {

9
src/ship/packet/handler/auth.rs
View File

@ -2,18 +2,19 @@ use libpso::packet::login::{Login, LoginResponse, AccountStatus, Session};
use libpso::packet::ship::*;
use crate::common::serverstate::ClientId;
use crate::ship::ship::{SendShipPacket, ShipError, ClientState, Clients};
use crate::login::login::{get_login_status, check_if_already_online};
use crate::login::login::get_login_status;
use crate::entity::gateway::EntityGateway;
use crate::ship::items::ItemManager;
use crate::common::interserver::ShipMessage;
#[allow(clippy::too_many_arguments)]
pub async fn validate_login<EG: EntityGateway>(id: ClientId,
pkt: &Login,
entity_gateway: &mut EG,
clients: &mut Clients,
item_manager: &mut ItemManager,
shipgate_sender: &Option<Box<dyn Fn(ShipMessage) + Send + Sync>>,
ship_name: &String,
ship_name: &str,
num_blocks: usize)
-> Result<Vec<SendShipPacket>, anyhow::Error> {
Ok(match get_login_status(entity_gateway, pkt).await {
@ -32,10 +33,10 @@ pub async fn validate_login<EG: EntityGateway>(id: ClientId,
item_manager.load_character(entity_gateway, &character).await?;
if let Some(shipgate_sender) = shipgate_sender.as_ref() {
shipgate_sender(ShipMessage::AddUser(user.id.clone()));
shipgate_sender(ShipMessage::AddUser(user.id));
}
clients.insert(id, ClientState::new(user, settings, character, pkt.session));
vec![SendShipPacket::LoginResponse(response), SendShipPacket::ShipBlockList(ShipBlockList::new(&&ship_name, num_blocks))]
vec![SendShipPacket::LoginResponse(response), SendShipPacket::ShipBlockList(ShipBlockList::new(ship_name, num_blocks))]
},
Err(err) => {
vec![SendShipPacket::LoginResponse(LoginResponse::by_status(err, Session::new()))]

22
src/ship/packet/handler/direct_message.rs
View File

@ -65,7 +65,7 @@ pub fn guildcard_send(id: ClientId,
class: client.character.char_class.into(),
}),
};
send_to_client(id, target as u8, msg, &client_location)
send_to_client(id, target as u8, msg, client_location)
}
pub async fn request_item<EG>(id: ClientId,
@ -110,7 +110,7 @@ where
};
let client = clients.get_mut(&area_client.client).ok_or(ShipError::ClientNotFound(area_client.client))?;
let floor_item = item_manager.enemy_drop_item_on_local_floor(entity_gateway, &client.character, item_drop).await?;
let item_drop_msg = builder::message::item_drop(request_item.client, request_item.target, &floor_item)?;
let item_drop_msg = builder::message::item_drop(request_item.client, request_item.target, floor_item)?;
item_drop_packets.push((area_client.client, SendShipPacket::Message(Message::new(GameMessage::ItemDrop(item_drop_msg)))));
}
@ -135,7 +135,7 @@ where
// TODO: should not need to fetch the item here to construct this packet
let (item, floor_type) = item_manager.get_floor_item_by_id(&client.character, ClientItemId(pickup_item.item_id))?;
let remove_item = builder::message::remove_item_from_floor(area_client, &item)?;
let remove_item = builder::message::remove_item_from_floor(area_client, item)?;
let create_item = match item {
FloorItem::Individual(individual_floor_item) => Some(builder::message::create_item(area_client, item.item_id(), &individual_floor_item.item)?),
FloorItem::Stacked(stacked_floor_item) => Some(builder::message::create_item(area_client, item.item_id(), &item::ItemDetail::Tool(stacked_floor_item.tool))?),
@ -216,7 +216,7 @@ EG: EntityGateway
};
let client = clients.get_mut(&area_client.client).ok_or(ShipError::ClientNotFound(area_client.client))?;
let floor_item = item_manager.enemy_drop_item_on_local_floor(entity_gateway, &client.character, item_drop).await?; // TODO: unwrap
let item_drop_msg = builder::message::item_drop(box_drop_request.client, box_drop_request.target, &floor_item)?;
let item_drop_msg = builder::message::item_drop(box_drop_request.client, box_drop_request.target, floor_item)?;
item_drop_packets.push((area_client.client, SendShipPacket::Message(Message::new(GameMessage::ItemDrop(item_drop_msg)))))
}
@ -233,7 +233,7 @@ pub async fn send_bank_list(id: ClientId,
let client = clients.get(&id).ok_or(ShipError::ClientNotFound(id))?;
let bank_items = item_manager.get_character_bank(&client.character)?;
let bank_items_pkt = builder::message::bank_item_list(&bank_items, client.character.bank_meseta);
let bank_items_pkt = builder::message::bank_item_list(bank_items, client.character.bank_meseta);
Ok(Box::new(vec![(id, SendShipPacket::BankItemList(bank_items_pkt))].into_iter()))
}
@ -277,7 +277,7 @@ where
}
else {
let item_added_to_inventory = item_manager.player_withdraws_item(entity_gateway, &client.character, ClientItemId(bank_interaction.item_id), bank_interaction.item_amount as usize).await?;
let item_created = builder::message::create_withdrawn_inventory_item(area_client, &item_added_to_inventory)?;
let item_created = builder::message::create_withdrawn_inventory_item(area_client, item_added_to_inventory)?;
vec![SendShipPacket::Message(Message::new(GameMessage::CreateItem(item_created)))]
}
},
@ -357,18 +357,12 @@ where
},
SHOP_OPTION_TOOL => {
let item = client.tool_shop.get(buy_item.shop_index as usize).ok_or(ShipError::ShopError)?;
let remove = match item {
ToolShopItem::Tech(_) => true,
_ => false,
};
let remove = matches!(item, ToolShopItem::Tech(_));
(item, remove)
},
SHOP_OPTION_ARMOR => {
let item = client.armor_shop.get(buy_item.shop_index as usize).ok_or(ShipError::ShopError)?;
let remove = match item {
ArmorShopItem::Unit(_) => true,
_ => false,
};
let remove = matches!(item, ArmorShopItem::Unit(_));
(item, remove)
},
_ => {

11
src/ship/packet/handler/lobby.rs
View File

@ -24,12 +24,12 @@ pub fn block_selected(id: ClientId,
let inventory = item_manager.get_character_inventory(&client.character).unwrap();
let bank = item_manager.get_character_bank(&client.character).unwrap();
let fc = FullCharacterBytesBuilder::new()
let fc = FullCharacterBytesBuilder::default()
.character(&client.character)
.stats(&stats)
.level(level)
.inventory(&inventory)
.bank(&bank)
.inventory(inventory)
.bank(bank)
.key_config(&client.settings.settings.key_config)
.joystick_config(&client.settings.settings.joystick_config)
.symbol_chat(&client.settings.settings.symbol_chats)
@ -63,6 +63,7 @@ pub fn send_player_to_lobby(id: ClientId,
.map(|c| (c.client, SendShipPacket::AddToLobby(addto.clone())))).collect())
}
#[allow(clippy::too_many_arguments)]
pub async fn change_lobby<EG: EntityGateway>(id: ClientId,
requested_lobby: u32,
client_location: &mut ClientLocation,
@ -81,7 +82,7 @@ pub async fn change_lobby<EG: EntityGateway>(id: ClientId,
}
},
RoomLobby::Room(old_room) => {
if client_location.get_client_neighbors(id).map_err(|err| -> ClientLocationError {err.into()})?.len() == 0 {
if client_location.get_client_neighbors(id)?.is_empty() {
ship_rooms[old_room.0] = None;
}
item_manager.remove_character_from_room(&client.character);
@ -90,7 +91,7 @@ pub async fn change_lobby<EG: EntityGateway>(id: ClientId,
let leave_lobby = packet::builder::lobby::remove_from_lobby(id, client_location)?;
let old_neighbors = client_location.get_client_neighbors(id).unwrap();
let mut lobby = LobbyId(requested_lobby as usize);
if let Err(_) = client_location.add_client_to_lobby(id, lobby) {
if client_location.add_client_to_lobby(id, lobby).is_err() {
match prev_area {
RoomLobby::Lobby(_lobby) => {
let dialog = SmallDialog::new(String::from("Lobby is full."));

5
src/ship/packet/handler/message.rs
View File

@ -1,12 +1,11 @@
use libpso::packet::ship::*;
use libpso::packet::messages::*;
use crate::entity::gateway::EntityGateway;
use crate::entity::item::{ItemType};
use crate::common::serverstate::ClientId;
use crate::common::leveltable::CharacterLevelTable;
use crate::ship::ship::{SendShipPacket, ShipError, Rooms, Clients, ItemDropLocation};
use crate::ship::location::{ClientLocation, ClientLocationError};
use crate::ship::items::{ItemManager, ClientItemId, InventoryItem};
use crate::ship::items::{ItemManager, ClientItemId};
use crate::ship::packet::builder;
pub async fn request_exp<EG: EntityGateway>(id: ClientId,
@ -26,7 +25,7 @@ pub async fn request_exp<EG: EntityGateway>(id: ClientId,
.ok_or_else(|| ShipError::InvalidRoom(room_id.0 as u32))?;
let monster = room.maps.enemy_by_id(request_exp.enemy_id as usize)?;
let monster_stats = room.monster_stats.get(&monster.monster).ok_or(ShipError::UnknownMonster(monster.monster.clone()))?;
let monster_stats = room.monster_stats.get(&monster.monster).ok_or(ShipError::UnknownMonster(monster.monster))?;
let exp_gain = if request_exp.last_hitter == 1 {
monster_stats.exp

14
src/ship/packet/handler/quest.rs
View File

@ -17,8 +17,8 @@ fn parse_filename(filename_bytes: &[u8; 16]) -> Result<(u16, u16, QuestFileType)
let filename = array_to_utf8(*filename_bytes).map_err(|_| ShipError::InvalidQuestFilename("NOT UTF8".to_string()))?;
let (filename, suffix) = {
let mut s = filename.splitn(2, '.');
(s.next().ok_or(ShipError::InvalidQuestFilename(filename.to_owned()))?,
s.next().ok_or(ShipError::InvalidQuestFilename(filename.to_owned()))?)
(s.next().ok_or_else(|| ShipError::InvalidQuestFilename(filename.to_owned()))?,
s.next().ok_or_else(|| ShipError::InvalidQuestFilename(filename.to_owned()))?)
};
let datatype = match suffix {
@ -29,8 +29,8 @@ fn parse_filename(filename_bytes: &[u8; 16]) -> Result<(u16, u16, QuestFileType)
let (category, quest) = {
let mut s = filename.splitn(2, '-');
(s.next().and_then(|k| k.parse().ok()).ok_or(ShipError::InvalidQuestFilename(filename.to_owned()))?,
s.next().and_then(|k| k.parse().ok()).ok_or(ShipError::InvalidQuestFilename(filename.to_owned()))?)
(s.next().and_then(|k| k.parse().ok()).ok_or_else(|| ShipError::InvalidQuestFilename(filename.to_owned()))?,
s.next().and_then(|k| k.parse().ok()).ok_or_else(|| ShipError::InvalidQuestFilename(filename.to_owned()))?)
};
Ok((category, quest, datatype))
@ -63,7 +63,7 @@ pub fn quest_detail(id: ClientId, questdetailrequest: &QuestDetailRequest, quest
q.id == questdetailrequest.quest as u16
}).ok_or(ShipError::InvalidQuest(questdetailrequest.quest as u32))?;
let qd = quest::quest_detail(&quest);
let qd = quest::quest_detail(quest);
Ok(Box::new(vec![(id, SendShipPacket::QuestDetail(qd))].into_iter()))
}
@ -91,9 +91,9 @@ pub fn load_quest(id: ClientId, questmenuselect: &QuestMenuSelect, quests: &Ques
let area_clients = client_location.get_all_clients_by_client(id).map_err(|err| -> ClientLocationError { err.into() })?;
area_clients.iter().for_each(|c| {
clients.get_mut(&c.client).map(|client| {
if let Some(client) = clients.get_mut(&c.client) {
client.done_loading_quest = false;
});
}
});
Ok(Box::new(area_clients.into_iter().map(move |c| {
vec![(c.client, SendShipPacket::QuestHeader(bin.clone())), (c.client, SendShipPacket::QuestHeader(dat.clone()))]

14
src/ship/packet/handler/room.rs
View File

@ -66,8 +66,8 @@ pub fn join_room(id: ClientId,
let original_area = client_location.get_area(id).unwrap();
let original_neighbors = client_location.get_client_neighbors(id).unwrap();
let room = rooms.get(pkt.item as usize)
.ok_or_else(|| ShipError::InvalidRoom(pkt.item))?.as_ref()
.ok_or_else(|| ShipError::InvalidRoom(pkt.item))?;
.ok_or(ShipError::InvalidRoom(pkt.item))?.as_ref()
.ok_or(ShipError::InvalidRoom(pkt.item))?;
if room.bursting {
return Ok(Box::new(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("player is bursting\nplease wait".into())))].into_iter()))
}
@ -81,8 +81,8 @@ pub fn join_room(id: ClientId,
item_manager.add_character_to_room(room_id, &client.character, area_client);
let leader = client_location.get_room_leader(room_id).map_err(|err| -> ClientLocationError { err.into() })?;
let join_room = builder::room::join_room(id, clients, client_location, room_id, &room)?;
let add_to = builder::room::add_to_room(id, &client, &area_client, &leader, item_manager, level_table, room_id)?;
let join_room = builder::room::join_room(id, clients, client_location, room_id, room)?;
let add_to = builder::room::add_to_room(id, client, &area_client, &leader, item_manager, level_table, room_id)?;
let room = rooms.get_mut(room_id.0).unwrap().as_mut().unwrap();
room.bursting = true;
@ -90,7 +90,7 @@ pub fn join_room(id: ClientId,
let mut result: Box<dyn Iterator<Item=(ClientId, SendShipPacket)> + Send> = Box::new(
vec![(id, SendShipPacket::JoinRoom(join_room))]
.into_iter()
.chain(original_room_clients.clone().into_iter()
.chain(original_room_clients.into_iter()
.map(move |c| (c.client, SendShipPacket::AddToRoom(add_to.clone())))
));
@ -109,9 +109,9 @@ pub fn done_bursting(id: ClientId,
-> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
let area = client_location.get_area(id).unwrap();
if let RoomLobby::Room(room_id) = area {
rooms.get_mut(room_id.0).unwrap().as_mut().map(|room| {
if let Some(room) = rooms.get_mut(room_id.0).unwrap().as_mut() {
room.bursting = false;
});
}
}
let area_client = client_location.get_local_client(id).unwrap(); // TODO: unwrap
Box::new(client_location.get_client_neighbors(id).unwrap().into_iter() // TODO: unwrap

6
src/ship/packet/handler/ship.rs
View File

@ -2,10 +2,10 @@ use libpso::packet::ship::*;
use libpso::packet::login::RedirectClient;
use crate::common::serverstate::ClientId;
use crate::common::interserver::Ship;
use crate::ship::ship::{SendShipPacket, ShipError, Clients};
use crate::ship::ship::{SendShipPacket, ShipError};
use crate::ship::packet::builder;
pub fn ship_list(id: ClientId, ship_list: &Vec<Ship>)
pub fn ship_list(id: ClientId, ship_list: &[Ship])
-> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
Box::new(vec![(id, SendShipPacket::ShipList(builder::ship::ship_list(ship_list)))].into_iter())
}
@ -15,7 +15,7 @@ pub fn block_list(id: ClientId, shipname: &str, num_blocks: usize)
Box::new(vec![(id, SendShipPacket::ShipBlockList(ShipBlockList::new(shipname, num_blocks)))].into_iter())
}
pub fn selected_ship(id: ClientId, menuselect: &MenuSelect, ship_list: &Vec<Ship>)
pub fn selected_ship(id: ClientId, menuselect: &MenuSelect, ship_list: &[Ship])
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> {
let ship = ship_list.get(menuselect.item as usize).ok_or(ShipError::InvalidShip(menuselect.item as usize))?;
let ip = u32::from_ne_bytes(ship.ip.octets());

33
src/ship/quests.rs
View File

@ -73,18 +73,18 @@ fn read_dat_section_header<T: Read + Seek>(cursor: &mut T, episode: &Episode, ma
match header {
DAT_OBJECT_HEADER_ID => {
let mut obj_data = vec![0u8; length as usize];
cursor.read(&mut obj_data)?;
cursor.read_exact(&mut obj_data)?;
let mut obj_cursor = Cursor::new(obj_data);
let objects = objects_from_stream(&mut obj_cursor, episode, &map_area);
let objects = objects_from_stream(&mut obj_cursor, episode, map_area);
Ok(DatBlock::Object(objects))
},
DAT_ENEMY_HEADER_ID => {
let mut enemy_data = vec![0u8; length as usize];
cursor.read(&mut enemy_data)?;
cursor.read_exact(&mut enemy_data)?;
let mut enemy_cursor = Cursor::new(enemy_data);
let enemies = enemy_data_from_stream(&mut enemy_cursor, &map_area, episode);
let enemies = enemy_data_from_stream(&mut enemy_cursor, map_area, episode);
Ok(DatBlock::Enemy(enemies))
},
@ -100,14 +100,14 @@ fn quest_episode(bin: &[u8]) -> Option<Episode> {
for bytes in bin.windows(3) {
// set_episode
if bytes[0] == 0xF8 && bytes[1] == 0xBC {
return Some(Episode::from_quest(bytes[2]).ok()?)
return Episode::from_quest(bytes[2]).ok()
}
}
None
}
fn map_area_mappings(bin: &[u8]) -> MapAreaLookup {
let mut map_areas = MapAreaLookupBuilder::new();
let mut map_areas = MapAreaLookupBuilder::default();
for bytes in bin.windows(4) {
// BB_Map_Designate
if bytes[0] == 0xF9 && bytes[1] == 0x51 {
@ -121,6 +121,7 @@ fn map_area_mappings(bin: &[u8]) -> MapAreaLookup {
map_areas.build()
}
#[allow(clippy::type_complexity)]
fn parse_dat(dat: &[u8], episode: &Episode, map_areas: &MapAreaLookup) -> Result<(Vec<Option<MapEnemy>>, Vec<Option<MapObject>>), ParseDatError> {
let mut cursor = Cursor::new(dat);
@ -185,21 +186,21 @@ impl Quest {
let (enemies, objects) = parse_dat(&dat, &episode, &map_areas)?;
let mut prs_bin = LegacyPrsEncoder::new(Vec::new());
prs_bin.write(&bin)?;
prs_bin.write_all(&bin)?;
let mut prs_dat = LegacyPrsEncoder::new(Vec::new());
prs_dat.write(&dat)?;
prs_dat.write_all(&dat)?;
Ok(Quest {
name: name,
description: description,
full_description: full_description,
id: id,
language: language,
name,
description,
full_description,
id,
language,
bin_blob: prs_bin.into_inner().map_err(|_| QuestLoadError::CouldNotReadMetadata)?,
dat_blob: prs_dat.into_inner().map_err(|_| QuestLoadError::CouldNotReadMetadata)?,
enemies: enemies,
objects: objects,
map_areas: map_areas,
enemies,
objects,
map_areas,
})
}
}

16
src/ship/room.rs
View File

@ -40,9 +40,9 @@ impl TryFrom<u8> for Episode {
}
}
impl Into<u8> for Episode {
fn into(self) -> u8 {
match self {
impl From<Episode> for u8 {
fn from(other: Episode) -> u8 {
match other {
Episode::One => 1,
Episode::Two => 2,
Episode::Four => 3,
@ -83,9 +83,9 @@ impl TryFrom<u8> for Difficulty {
}
}
impl Into<u8> for Difficulty {
fn into(self) -> u8 {
match self {
impl From<Difficulty> for u8 {
fn from(other: Difficulty) -> u8 {
match other {
Difficulty::Normal => 0,
Difficulty::Hard => 1,
Difficulty::VeryHard => 2,
@ -232,13 +232,13 @@ impl RoomState {
};
Ok(RoomState {
monster_stats: Box::new(load_monster_stats_table(&room_mode).map_err(|_| RoomCreationError::CouldNotLoadMonsterStats(room_mode.clone()))?),
monster_stats: Box::new(load_monster_stats_table(&room_mode).map_err(|_| RoomCreationError::CouldNotLoadMonsterStats(room_mode))?),
mode: room_mode,
random_seed: rand::thread_rng().gen(),
name: String::from_utf16_lossy(&create_room.name).trim_matches(char::from(0)).into(),
password: create_room.password,
maps: Maps::new(room_mode),
section_id: section_id,
section_id,
drop_table: Box::new(DropTable::new(room_mode.episode(), room_mode.difficulty(), section_id)),
bursting: false,
map_areas: MapAreaLookup::new(&room_mode.episode()),

72
src/ship/ship.rs
View File

@ -262,10 +262,10 @@ pub struct ClientState {
impl ClientState {
pub fn new(user: UserAccountEntity, settings: UserSettingsEntity, character: CharacterEntity, session: Session) -> ClientState {
ClientState {
user: user,
settings: settings,
character: character,
session: session,
user,
settings,
character,
session,
block: 0,
item_drop_location: None,
done_loading_quest: false,
@ -287,8 +287,8 @@ pub struct ItemShops {
pub armor_shop: ArmorShop<rand_chacha::ChaCha20Rng>,
}
impl ItemShops {
pub fn new() -> ItemShops {
impl Default for ItemShops {
fn default() -> ItemShops {
let difficulty = [room::Difficulty::Normal, room::Difficulty::Hard, room::Difficulty::VeryHard, room::Difficulty::Ultimate];
let section_id = [SectionID::Viridia, SectionID::Greenill, SectionID::Skyly, SectionID::Bluefull, SectionID::Purplenum,
SectionID::Pinkal, SectionID::Redria, SectionID::Oran, SectionID::Yellowboze, SectionID::Whitill];
@ -301,9 +301,9 @@ impl ItemShops {
}
ItemShops {
weapon_shop: weapon_shop,
tool_shop: ToolShop::new(),
armor_shop: ArmorShop::new(),
weapon_shop,
tool_shop: ToolShop::default(),
armor_shop: ArmorShop::default(),
}
}
}
@ -318,8 +318,8 @@ pub struct ShipServerStateBuilder<EG: EntityGateway> {
num_blocks: usize,
}
impl<EG: EntityGateway> ShipServerStateBuilder<EG> {
pub fn new() -> ShipServerStateBuilder<EG> {
impl<EG: EntityGateway> Default for ShipServerStateBuilder<EG> {
fn default() -> ShipServerStateBuilder<EG> {
ShipServerStateBuilder {
entity_gateway: None,
name: None,
@ -329,7 +329,9 @@ impl<EG: EntityGateway> ShipServerStateBuilder<EG> {
num_blocks: 2,
}
}
}
impl<EG: EntityGateway> ShipServerStateBuilder<EG> {
pub fn gateway(mut self, entity_gateway: EG) -> ShipServerStateBuilder<EG> {
self.entity_gateway = Some(entity_gateway);
self
@ -365,17 +367,17 @@ impl<EG: EntityGateway> ShipServerStateBuilder<EG> {
ShipServerState {
entity_gateway: self.entity_gateway.unwrap(),
clients: HashMap::new(),
level_table: CharacterLevelTable::new(),
name: self.name.unwrap_or("NAMENOTSET".into()),
item_manager: items::ItemManager::new(),
level_table: CharacterLevelTable::default(),
name: self.name.unwrap_or_else(|| "NAMENOTSET".into()),
item_manager: items::ItemManager::default(),
quests: quests::load_quests("data/quests.toml".into()).unwrap(),
ip: self.ip.unwrap_or(Ipv4Addr::new(127,0,0,1)),
ip: self.ip.unwrap_or_else(|| Ipv4Addr::new(127,0,0,1)),
port: self.port.unwrap_or(SHIP_PORT),
shops: Box::new(ItemShops::new()),
shops: Box::new(ItemShops::default()),
blocks: Blocks(blocks),
auth_token: self.auth_token.unwrap_or(AuthToken("".into())),
auth_token: self.auth_token.unwrap_or_else(|| AuthToken("".into())),
ship_list: Vec::new(),
shipgate_sender: None,
}
@ -428,7 +430,7 @@ pub struct ShipServerState<EG: EntityGateway> {
impl<EG: EntityGateway> ShipServerState<EG> {
pub fn builder() -> ShipServerStateBuilder<EG> {
ShipServerStateBuilder::new()
ShipServerStateBuilder::default()
}
pub fn set_sender(&mut self, sender: Box<dyn Fn(ShipMessage) + Send + Sync>) {
@ -443,7 +445,7 @@ impl<EG: EntityGateway> ShipServerState<EG> {
},
GameMessage::PlayerDropItem(player_drop_item) => {
let block = self.blocks.with_client(id, &self.clients)?;
handler::message::player_drop_item(id, player_drop_item, &mut self.entity_gateway, &mut block.client_location, &mut self.clients, &mut block.rooms, &mut self.item_manager).await?
handler::message::player_drop_item(id, player_drop_item, &mut self.entity_gateway, &block.client_location, &mut self.clients, &mut block.rooms, &mut self.item_manager).await?
},
GameMessage::DropCoordinates(drop_coordinates) => {
let block = self.blocks.with_client(id, &self.clients)?;
@ -451,37 +453,37 @@ impl<EG: EntityGateway> ShipServerState<EG> {
},
GameMessage::PlayerNoLongerHasItem(no_longer_has_item) => {
let block = self.blocks.with_client(id, &self.clients)?;
handler::message::no_longer_has_item(id, no_longer_has_item, &mut self.entity_gateway, &mut block.client_location, &mut self.clients, &mut self.item_manager).await?
handler::message::no_longer_has_item(id, no_longer_has_item, &mut self.entity_gateway, &block.client_location, &mut self.clients, &mut self.item_manager).await?
},
GameMessage::PlayerChangedMap(_) | GameMessage::PlayerChangedMap2(_) | GameMessage::TellOtherPlayerMyLocation(_) |
GameMessage::PlayerWarpingToFloor(_) | GameMessage::PlayerTeleported(_) | GameMessage::PlayerStopped(_) |
GameMessage::PlayerLoadedIn(_) | GameMessage::PlayerWalking(_) | GameMessage::PlayerRunning(_) |
GameMessage::PlayerWarped(_) | GameMessage::PlayerChangedFloor(_) | GameMessage::InitializeSpeechNpc(_) => {
let block = self.blocks.with_client(id, &self.clients)?;
handler::message::update_player_position(id, &msg, &mut self.clients, &mut block.client_location, &block.rooms)?
handler::message::update_player_position(id, msg, &mut self.clients, &block.client_location, &block.rooms)?
},
GameMessage::ChargeAttack(charge_attack) => {
handler::message::charge_attack(id, charge_attack, &mut self.clients, &mut self.entity_gateway).await?
},
GameMessage::PlayerUseItem(player_use_item) => {
let block = self.blocks.with_client(id, &self.clients)?;
handler::message::use_item(id, player_use_item, &mut self.entity_gateway, &mut block.client_location, &mut self.clients, &mut self.item_manager).await?
handler::message::use_item(id, player_use_item, &mut self.entity_gateway, &block.client_location, &mut self.clients, &mut self.item_manager).await?
},
GameMessage::PlayerUsedMedicalCenter(player_used_medical_center) => {
handler::message::player_used_medical_center(id, &player_used_medical_center, &mut self.entity_gateway, &mut self.clients).await?
handler::message::player_used_medical_center(id, player_used_medical_center, &mut self.entity_gateway, &mut self.clients).await?
},
GameMessage::PlayerFeedMag(player_feed_mag) => {
let block = self.blocks.with_client(id, &self.clients)?;
handler::message::player_feed_mag(id, &player_feed_mag, &mut self.entity_gateway, &mut block.client_location, &mut self.clients, &mut self.item_manager).await?
handler::message::player_feed_mag(id, player_feed_mag, &mut self.entity_gateway, &block.client_location, &self.clients, &mut self.item_manager).await?
},
GameMessage::PlayerEquipItem(player_equip_item) => {
handler::message::player_equips_item(id, &player_equip_item, &mut self.entity_gateway, &mut self.clients, &mut self.item_manager).await?
handler::message::player_equips_item(id, player_equip_item, &mut self.entity_gateway, &self.clients, &mut self.item_manager).await?
},
GameMessage::PlayerUnequipItem(player_unequip_item) => {
handler::message::player_unequips_item(id, &player_unequip_item, &mut self.entity_gateway, &mut self.clients, &mut self.item_manager).await?
handler::message::player_unequips_item(id, player_unequip_item, &mut self.entity_gateway, &self.clients, &mut self.item_manager).await?
},
GameMessage::SortItems(sort_items) => {
handler::message::player_sorts_items(id, sort_items, &mut self.entity_gateway, &mut self.clients, &mut self.item_manager).await?
handler::message::player_sorts_items(id, sort_items, &mut self.entity_gateway, &self.clients, &mut self.item_manager).await?
},
_ => {
let cmsg = msg.clone();
@ -502,13 +504,13 @@ impl<EG: EntityGateway> ShipServerState<EG> {
handler::direct_message::guildcard_send(id, guildcard_send, target, &block.client_location, &self.clients)
},
GameMessage::RequestItem(request_item) => {
handler::direct_message::request_item(id, request_item, &mut self.entity_gateway, &mut block.client_location, &mut self.clients, &mut block.rooms, &mut self.item_manager).await?
handler::direct_message::request_item(id, request_item, &mut self.entity_gateway, &block.client_location, &mut self.clients, &mut block.rooms, &mut self.item_manager).await?
},
GameMessage::PickupItem(pickup_item) => {
handler::direct_message::pickup_item(id, pickup_item, &mut self.entity_gateway, &mut block.client_location, &mut self.clients, &mut self.item_manager).await?
handler::direct_message::pickup_item(id, pickup_item, &mut self.entity_gateway, &block.client_location, &mut self.clients, &mut self.item_manager).await?
},
GameMessage::BoxDropRequest(box_drop_request) => {
handler::direct_message::request_box_item(id, box_drop_request, &mut self.entity_gateway, &mut block.client_location, &mut self.clients, &mut block.rooms, &mut self.item_manager).await?
handler::direct_message::request_box_item(id, box_drop_request, &mut self.entity_gateway, &block.client_location, &mut self.clients, &mut block.rooms, &mut self.item_manager).await?
},
GameMessage::BankRequest(_bank_request) => {
handler::direct_message::send_bank_list(id, &self.clients, &mut self.item_manager).await?
@ -626,7 +628,7 @@ impl<EG: EntityGateway> ServerState for ShipServerState<EG> {
},
RecvShipPacket::PlayerChat(msg) => {
let block = self.blocks.with_client(id, &self.clients)?;
Box::new(handler::communication::player_chat(id, msg, &block.client_location, &self.clients)?.into_iter())
Box::new(handler::communication::player_chat(id, msg, &block.client_location, &self.clients)?)
},
RecvShipPacket::CreateRoom(create_room) => {
let block = self.blocks.with_client(id, &self.clients)?;
@ -706,7 +708,7 @@ impl<EG: EntityGateway> ServerState for ShipServerState<EG> {
let pkt = match block.client_location.get_area(id)? {
RoomLobby::Room(room) => {
if neighbors.len() == 0 {
if neighbors.is_empty() {
block.rooms[room.0] = None;
}
let leader = block.client_location.get_room_leader(room)?;
@ -719,7 +721,7 @@ impl<EG: EntityGateway> ServerState for ShipServerState<EG> {
};
if let Some(shipgate_sender) = self.shipgate_sender.as_ref() {
shipgate_sender(ShipMessage::RemoveUser(client.user.id.clone()));
shipgate_sender(ShipMessage::RemoveUser(client.user.id));
}
block.client_location.remove_client_from_area(id);
@ -748,7 +750,7 @@ impl<EG: EntityGateway> InterserverActor for ShipServerState<EG> {
(id, ShipMessage::Authenticate(self.auth_token.clone())),
(id, ShipMessage::NewShip(Ship {
name: self.name.clone(),
ip: self.ip.clone(),
ip: self.ip,
port: self.port,
block_count: 2,
})),
@ -768,7 +770,7 @@ impl<EG: EntityGateway> InterserverActor for ShipServerState<EG> {
LoginMessage::RequestUsers => {
Ok(self.clients.iter()
.map(|(_, client)| {
(id, ShipMessage::AddUser(client.user.id.clone()))
(id, ShipMessage::AddUser(client.user.id))
})
.collect())
}

20
src/ship/shops/armor.rs
View File

@ -19,7 +19,7 @@ pub enum ArmorShopItem {
Unit(UnitType),
}
const ARMOR_MULTIPLIER: f32 = 0.799999952;
const ARMOR_MULTIPLIER: f32 = 0.799_999_95;
const SHIELD_MULTIPLIER: f32 = 1.5;
const UNIT_MULTIPLIER: f32 = 1000.0;
@ -27,7 +27,7 @@ impl ShopItem for ArmorShopItem {
fn price(&self) -> usize {
match self {
ArmorShopItem::Frame(frame, slot) => {
ARMOR_STATS.get(&frame)
ARMOR_STATS.get(frame)
.map(|frame_stats| {
let mut price = (frame_stats.dfp + frame_stats.evp) as f32;
price *= price;
@ -39,7 +39,7 @@ impl ShopItem for ArmorShopItem {
.unwrap_or(0xFFFF)
},
ArmorShopItem::Barrier(barrier) => {
SHIELD_STATS.get(&barrier)
SHIELD_STATS.get(barrier)
.map(|barrier_stats| {
let mut price = (barrier_stats.dfp + barrier_stats.evp) as f32;
price *= price;
@ -50,7 +50,7 @@ impl ShopItem for ArmorShopItem {
.unwrap_or(0xFFFF)
},
ArmorShopItem::Unit(unit) => {
UNIT_STATS.get(&unit)
UNIT_STATS.get(unit)
.map(|unit_stats| {
(unit_stats.stars as f32 * UNIT_MULTIPLIER) as usize
})
@ -236,8 +236,8 @@ pub struct ArmorShop<R: Rng + SeedableRng> {
rng: R,
}
impl<R: Rng + SeedableRng> ArmorShop<R> {
pub fn new() -> ArmorShop<R> {
impl<R: Rng + SeedableRng> Default for ArmorShop<R> {
fn default() -> ArmorShop<R> {
ArmorShop {
frame: load_frame_table(),
barrier: load_barrier_table(),
@ -245,7 +245,9 @@ impl<R: Rng + SeedableRng> ArmorShop<R> {
rng: R::from_entropy(),
}
}
}
impl<R: Rng + SeedableRng> ArmorShop<R> {
fn generate_frame_list(&mut self, character_level: usize) -> Vec<ArmorShopItem> {
let tier = self.frame.frame.iter()
.filter(|t| t.level <= character_level)
@ -297,7 +299,7 @@ impl<R: Rng + SeedableRng> ArmorShop<R> {
})
.collect()
})
.unwrap_or(Vec::new())
.unwrap_or_else(Vec::new)
}
pub fn generate_armor_list(&mut self, character_level: usize) -> Vec<ArmorShopItem> {
@ -316,12 +318,12 @@ mod test {
#[test]
fn test_loading_tool_shop() {
ArmorShop::<rand_chacha::ChaCha20Rng>::new();
ArmorShop::<rand_chacha::ChaCha20Rng>::default();
}
#[test]
fn test_generating_some_armor() {
let mut fs = ArmorShop::<rand_chacha::ChaCha20Rng>::new();
let mut fs = ArmorShop::<rand_chacha::ChaCha20Rng>::default();
for i in 0..200 {
fs.generate_armor_list(i);
}

23
src/ship/shops/tool.rs
View File

@ -53,7 +53,7 @@ impl ShopItem for ToolShopItem {
fn price(&self) -> usize {
match self {
ToolShopItem::Tool(tool) => {
TOOL_STATS.get(&tool)
TOOL_STATS.get(tool)
.map(|tool_stats| {
tool_stats.price
})
@ -146,7 +146,7 @@ fn load_tool_table() -> ToolTable {
let mut table: HashMap<String, Vec<ToolType>> = toml::from_str(s.as_str()).unwrap();
ToolTable(table.remove("tools".into()).unwrap())
ToolTable(table.remove("tools").unwrap())
}
fn load_tech_table() -> TechTable {
@ -156,7 +156,7 @@ fn load_tech_table() -> TechTable {
f.read_to_string(&mut s).unwrap();
let mut table: HashMap<String, Vec<TechTierDeserialize>> = toml::from_str(s.as_str()).unwrap();
let techniques = table.remove("techniques".into()).unwrap();
let techniques = table.remove("techniques").unwrap();
let techniques = techniques.into_iter()
.map(|tech_tier| {
TechTier {
@ -194,15 +194,18 @@ pub struct ToolShop<R: Rng + SeedableRng> {
rng: R,
}
impl<R: Rng + SeedableRng> ToolShop<R> {
pub fn new() -> ToolShop<R> {
impl<R: Rng + SeedableRng> Default for ToolShop<R> {
fn default() -> ToolShop<R> {
ToolShop {
tools: load_tool_table(),
techs: load_tech_table(),
rng: R::from_entropy(),
}
}
}
impl<R: Rng + SeedableRng> ToolShop<R> {
fn generate_tech_types(&mut self, character_level: usize) -> Vec<Technique> {
let tier = self.techs.0.iter()
.filter(|t| t.level <= character_level)
@ -233,7 +236,7 @@ impl<R: Rng + SeedableRng> ToolShop<R> {
let tech_choice = WeightedIndex::new(tier.iter().map(|(_, e)| e.probability)).unwrap();
while techs.len() < number_of_techs {
let tech_detail = tier.get(tech_choice.sample(&mut self.rng)).unwrap();
if techs.iter().find(|t| *t == tech_detail.0).is_none() {
if !techs.iter().any(|t| t == tech_detail.0) {
techs.push(*tech_detail.0);
}
}
@ -260,7 +263,7 @@ impl<R: Rng + SeedableRng> ToolShop<R> {
};
ToolShopItem::Tech(TechniqueDisk {
tech: tech,
tech,
level: level as u32,
})
})
@ -269,7 +272,7 @@ impl<R: Rng + SeedableRng> ToolShop<R> {
pub fn generate_tool_list(&mut self, character_level: usize) -> Vec<ToolShopItem> {
let mut tools = Vec::new().into_iter()
.chain(self.tools.0.clone().into_iter().map(|t| ToolShopItem::Tool(t)))
.chain(self.tools.0.clone().into_iter().map(ToolShopItem::Tool))
.chain(self.generate_techs(character_level).into_iter())
.collect::<Vec<_>>();
tools.sort();
@ -284,12 +287,12 @@ mod test {
#[test]
fn test_loading_tool_shop() {
ToolShop::<rand_chacha::ChaCha20Rng>::new();
ToolShop::<rand_chacha::ChaCha20Rng>::default();
}
#[test]
fn test_generating_some_tools() {
let mut ts = ToolShop::<rand_chacha::ChaCha20Rng>::new();
let mut ts = ToolShop::<rand_chacha::ChaCha20Rng>::default();
for i in 0..200 {
ts.generate_tool_list(i);
}

119
src/ship/shops/weapon.rs
View File

@ -32,14 +32,10 @@ pub struct WeaponShopItem {
impl PartialEq for WeaponShopItem {
fn eq(&self, other: &Self) -> bool {
if self.weapon == other.weapon &&
self.weapon == other.weapon &&
self.special == other.special &&
self.grind == other.grind &&
self.attributes == other.attributes {
true
} else {
false
}
self.attributes == other.attributes
}
}
@ -247,7 +243,7 @@ fn load_weapon_table(difficulty: Difficulty, section_id: SectionID) -> WeaponTab
let mut table: HashMap<String, Vec<WeaponTableTier>> = toml::from_str(s.as_str()).unwrap();
WeaponTable(table.remove("weapon_tier".into()).unwrap())
WeaponTable(table.remove("weapon_tier").unwrap())
}
fn load_special_table() -> SpecialTable {
@ -258,7 +254,7 @@ fn load_special_table() -> SpecialTable {
let mut table: HashMap<String, Vec<SpecialTier>> = toml::from_str(s.as_str()).unwrap();
SpecialTable(table.remove("specials".into()).unwrap())
SpecialTable(table.remove("specials").unwrap())
}
fn load_grind_table() -> GrindTable {
@ -269,7 +265,7 @@ fn load_grind_table() -> GrindTable {
let mut table: HashMap<String, Vec<GrindTier>> = toml::from_str(s.as_str()).unwrap();
GrindTable(table.remove("grind".into()).unwrap())
GrindTable(table.remove("grind").unwrap())
}
fn load_alt_grind_table() -> GrindTable {
@ -280,7 +276,7 @@ fn load_alt_grind_table() -> GrindTable {
let mut table: HashMap<String, Vec<GrindTier>> = toml::from_str(s.as_str()).unwrap();
GrindTable(table.remove("grind".into()).unwrap())
GrindTable(table.remove("grind").unwrap())
}
fn load_attribute1_table() -> AttributeTable {
@ -291,7 +287,7 @@ fn load_attribute1_table() -> AttributeTable {
let mut table: HashMap<String, Vec<AttributeTier>> = toml::from_str(s.as_str()).unwrap();
AttributeTable(table.remove("attributes".into()).unwrap())
AttributeTable(table.remove("attributes").unwrap())
}
fn load_attribute2_table() -> AttributeTable {
@ -302,7 +298,7 @@ fn load_attribute2_table() -> AttributeTable {
let mut table: HashMap<String, Vec<AttributeTier>> = toml::from_str(s.as_str()).unwrap();
AttributeTable(table.remove("attributes".into()).unwrap())
AttributeTable(table.remove("attributes").unwrap())
}
fn number_of_weapons_to_generate(character_level: usize) -> usize {
@ -333,8 +329,8 @@ pub struct WeaponShop<R: Rng + SeedableRng> {
impl<R: Rng + SeedableRng> WeaponShop<R> {
pub fn new(difficulty: Difficulty, section_id: SectionID) -> WeaponShop<R> {
WeaponShop {
difficulty: difficulty,
section_id: section_id,
difficulty,
section_id,
weapon: load_weapon_table(difficulty, section_id),
special: load_special_table(),
grind: load_grind_table(),
@ -381,8 +377,7 @@ impl<R: Rng + SeedableRng> WeaponShop<R> {
fn generate_alt_grind(&mut self, level: usize) -> usize {
let tier = self.alt_grind.0.iter()
.filter(|t| t.level <= level)
.nth(0)
.find(|t| t.level <= level)
.unwrap();
self.rng.gen_range(tier.min, tier.max+1)
@ -410,7 +405,7 @@ impl<R: Rng + SeedableRng> WeaponShop<R> {
.choose(&mut self.rng)?;
Some(WeaponAttribute {
attr: attr,
attr,
value: percent as i8,
})
}
@ -437,54 +432,52 @@ impl<R: Rng + SeedableRng> WeaponShop<R> {
.choose(&mut self.rng)?;
Some(WeaponAttribute {
attr: attr,
attr,
value: percent as i8,
})
}
fn is_alt_grind(&self, weapon: &WeaponType) -> bool {
match (self.section_id, weapon) {
(SectionID::Viridia, WeaponType::Shot) => true,
(SectionID::Viridia, WeaponType::Spread) => true,
(SectionID::Viridia, WeaponType::Cannon) => true,
(SectionID::Viridia, WeaponType::Launcher) => true,
(SectionID::Viridia, WeaponType::Arms) => true,
(SectionID::Greenill, WeaponType::Rifle) => true,
(SectionID::Greenill, WeaponType::Sniper) => true,
(SectionID::Greenill, WeaponType::Blaster) => true,
(SectionID::Greenill, WeaponType::Beam) => true,
(SectionID::Greenill, WeaponType::Laser) => true,
(SectionID::Skyly, WeaponType::Sword) => true,
(SectionID::Skyly, WeaponType::Gigush) => true,
(SectionID::Skyly, WeaponType::Breaker) => true,
(SectionID::Skyly, WeaponType::Claymore) => true,
(SectionID::Skyly, WeaponType::Calibur) => true,
(SectionID::Bluefull, WeaponType::Partisan) => true,
(SectionID::Bluefull, WeaponType::Halbert) => true,
(SectionID::Bluefull, WeaponType::Glaive) => true,
(SectionID::Bluefull, WeaponType::Berdys) => true,
(SectionID::Bluefull, WeaponType::Gungnir) => true,
(SectionID::Purplenum, WeaponType::Mechgun) => true,
(SectionID::Purplenum, WeaponType::Assault) => true,
(SectionID::Purplenum, WeaponType::Repeater) => true,
(SectionID::Purplenum, WeaponType::Gatling) => true,
(SectionID::Purplenum, WeaponType::Vulcan) => true,
(SectionID::Pinkal, WeaponType::Cane) => true,
(SectionID::Pinkal, WeaponType::Stick) => true,
(SectionID::Pinkal, WeaponType::Mace) => true,
(SectionID::Pinkal, WeaponType::Club) => true,
(SectionID::Oran, WeaponType::Dagger) => true,
(SectionID::Oran, WeaponType::Knife) => true,
(SectionID::Oran, WeaponType::Blade) => true,
(SectionID::Oran, WeaponType::Edge) => true,
(SectionID::Oran, WeaponType::Ripper) => true,
(SectionID::Whitill, WeaponType::Slicer) => true,
(SectionID::Whitill, WeaponType::Spinner) => true,
(SectionID::Whitill, WeaponType::Cutter) => true,
(SectionID::Whitill, WeaponType::Sawcer) => true,
(SectionID::Whitill, WeaponType::Diska) => true,
_ => false,
}
matches!((self.section_id, weapon),
(SectionID::Viridia, WeaponType::Shot) |
(SectionID::Viridia, WeaponType::Spread) |
(SectionID::Viridia, WeaponType::Cannon) |
(SectionID::Viridia, WeaponType::Launcher) |
(SectionID::Viridia, WeaponType::Arms) |
(SectionID::Greenill, WeaponType::Rifle) |
(SectionID::Greenill, WeaponType::Sniper) |
(SectionID::Greenill, WeaponType::Blaster) |
(SectionID::Greenill, WeaponType::Beam) |
(SectionID::Greenill, WeaponType::Laser) |
(SectionID::Skyly, WeaponType::Sword) |
(SectionID::Skyly, WeaponType::Gigush) |
(SectionID::Skyly, WeaponType::Breaker) |
(SectionID::Skyly, WeaponType::Claymore) |
(SectionID::Skyly, WeaponType::Calibur) |
(SectionID::Bluefull, WeaponType::Partisan) |
(SectionID::Bluefull, WeaponType::Halbert) |
(SectionID::Bluefull, WeaponType::Glaive) |
(SectionID::Bluefull, WeaponType::Berdys) |
(SectionID::Bluefull, WeaponType::Gungnir) |
(SectionID::Purplenum, WeaponType::Mechgun) |
(SectionID::Purplenum, WeaponType::Assault) |
(SectionID::Purplenum, WeaponType::Repeater) |
(SectionID::Purplenum, WeaponType::Gatling) |
(SectionID::Purplenum, WeaponType::Vulcan) |
(SectionID::Pinkal, WeaponType::Cane) |
(SectionID::Pinkal, WeaponType::Stick) |
(SectionID::Pinkal, WeaponType::Mace) |
(SectionID::Pinkal, WeaponType::Club) |
(SectionID::Oran, WeaponType::Dagger) |
(SectionID::Oran, WeaponType::Knife) |
(SectionID::Oran, WeaponType::Blade) |
(SectionID::Oran, WeaponType::Edge) |
(SectionID::Oran, WeaponType::Ripper) |
(SectionID::Whitill, WeaponType::Slicer) |
(SectionID::Whitill, WeaponType::Spinner) |
(SectionID::Whitill, WeaponType::Cutter) |
(SectionID::Whitill, WeaponType::Sawcer) |
(SectionID::Whitill, WeaponType::Diska))
}
fn generate_weapon(&mut self, level: usize) -> WeaponShopItem {
@ -519,9 +512,9 @@ impl<R: Rng + SeedableRng> WeaponShop<R> {
};
WeaponShopItem {
weapon: weapon,
grind: grind,
special: special,
weapon,
grind,
special,
attributes: [attr1, attr2],
}
}

52
tests/test_bank.rs
View File

@ -13,7 +13,7 @@ use common::*;
#[async_std::test]
async fn test_bank_items_sent_in_character_login() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -52,7 +52,7 @@ async fn test_bank_items_sent_in_character_login() {
#[async_std::test]
async fn test_request_bank_items() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -104,7 +104,7 @@ async fn test_request_bank_items() {
#[async_std::test]
async fn test_request_stacked_bank_items() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -151,7 +151,7 @@ async fn test_request_stacked_bank_items() {
#[async_std::test]
async fn test_request_bank_items_sorted() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -229,7 +229,7 @@ async fn test_request_bank_items_sorted() {
#[async_std::test]
async fn test_deposit_individual_item() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -308,7 +308,7 @@ async fn test_deposit_individual_item() {
#[async_std::test]
async fn test_deposit_stacked_item() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -372,7 +372,7 @@ async fn test_deposit_stacked_item() {
#[async_std::test]
async fn test_deposit_partial_stacked_item() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -445,7 +445,7 @@ async fn test_deposit_partial_stacked_item() {
#[async_std::test]
async fn test_deposit_stacked_item_with_stack_already_in_bank() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -524,7 +524,7 @@ async fn test_deposit_stacked_item_with_stack_already_in_bank() {
#[async_std::test]
async fn test_deposit_stacked_item_with_full_stack_in_bank() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -603,7 +603,7 @@ async fn test_deposit_stacked_item_with_full_stack_in_bank() {
#[async_std::test]
async fn test_deposit_individual_item_in_full_bank() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -684,7 +684,7 @@ async fn test_deposit_individual_item_in_full_bank() {
#[async_std::test]
async fn test_deposit_stacked_item_in_full_bank() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -764,7 +764,7 @@ async fn test_deposit_stacked_item_in_full_bank() {
#[async_std::test]
async fn test_deposit_stacked_item_in_full_bank_with_partial_stack() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -858,7 +858,7 @@ async fn test_deposit_stacked_item_in_full_bank_with_partial_stack() {
#[async_std::test]
async fn test_deposit_meseta() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.meseta = 300;
@ -895,7 +895,7 @@ async fn test_deposit_meseta() {
#[async_std::test]
async fn test_deposit_too_much_meseta() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.meseta = 300;
@ -934,7 +934,7 @@ async fn test_deposit_too_much_meseta() {
#[async_std::test]
async fn test_deposit_meseta_when_bank_is_maxed() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.meseta = 300;
@ -973,7 +973,7 @@ async fn test_deposit_meseta_when_bank_is_maxed() {
#[async_std::test]
async fn test_withdraw_individual_item() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -1039,7 +1039,7 @@ async fn test_withdraw_individual_item() {
#[async_std::test]
async fn test_withdraw_stacked_item() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -1103,7 +1103,7 @@ async fn test_withdraw_stacked_item() {
#[async_std::test]
async fn test_withdraw_partial_stacked_item() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -1173,7 +1173,7 @@ async fn test_withdraw_partial_stacked_item() {
#[async_std::test]
async fn test_withdraw_stacked_item_with_stack_already_in_inventory() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -1254,7 +1254,7 @@ async fn test_withdraw_stacked_item_with_stack_already_in_inventory() {
#[async_std::test]
async fn test_withdraw_stacked_item_with_full_stack_in_inventory() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -1333,7 +1333,7 @@ async fn test_withdraw_stacked_item_with_full_stack_in_inventory() {
#[async_std::test]
async fn test_withdraw_individual_item_in_full_inventory() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -1410,7 +1410,7 @@ async fn test_withdraw_individual_item_in_full_inventory() {
#[async_std::test]
async fn test_withdraw_stacked_item_in_full_inventory() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -1491,7 +1491,7 @@ async fn test_withdraw_stacked_item_in_full_inventory() {
#[async_std::test]
async fn test_withdraw_stacked_item_in_full_inventory_with_partial_stack() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -1587,7 +1587,7 @@ async fn test_withdraw_stacked_item_in_full_inventory_with_partial_stack() {
#[async_std::test]
async fn test_withdraw_meseta() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.bank_meseta = 300;
@ -1624,7 +1624,7 @@ async fn test_withdraw_meseta() {
#[async_std::test]
async fn test_withdraw_too_much_meseta() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.meseta = 999980;
@ -1662,7 +1662,7 @@ async fn test_withdraw_too_much_meseta() {
#[async_std::test]
async fn test_withdraw_meseta_inventory_is_maxed() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.meseta = 999999;

2
tests/test_character.rs
View File

@ -10,7 +10,7 @@ use common::*;
#[async_std::test]
async fn test_save_options() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a").await;

10
tests/test_exp_gain.rs
View File

@ -13,7 +13,7 @@ use common::*;
#[async_std::test]
async fn test_character_gains_exp() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -50,7 +50,7 @@ async fn test_character_gains_exp() {
#[async_std::test]
async fn test_character_levels_up() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.exp = 49;
@ -83,14 +83,14 @@ async fn test_character_levels_up() {
assert!(matches!(levelup_pkt[1].1, SendShipPacket::Message(Message {msg: GameMessage::PlayerLevelUp(PlayerLevelUp {lvl: 2, ..})})));
let leveltable = CharacterLevelTable::new();
let leveltable = CharacterLevelTable::default();
let c1 = ship.clients.get(&ClientId(1)).unwrap();
assert!(leveltable.get_level_from_exp(c1.character.char_class, c1.character.exp) == 2);
}
#[async_std::test]
async fn test_character_levels_up_multiple_times() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -134,7 +134,7 @@ async fn test_character_levels_up_multiple_times() {
#[async_std::test]
async fn test_one_character_gets_full_exp_and_other_attacker_gets_partial() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, _char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a").await;

6
tests/test_item_actions.rs
View File

@ -12,7 +12,7 @@ use common::*;
#[async_std::test]
async fn test_equip_unit_from_equip_menu() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -98,7 +98,7 @@ async fn test_equip_unit_from_equip_menu() {
#[async_std::test]
async fn test_unequip_armor_with_units() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -175,7 +175,7 @@ async fn test_unequip_armor_with_units() {
#[async_std::test]
async fn test_sort_items() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;

20
tests/test_item_pickup.rs
View File

@ -12,7 +12,7 @@ use common::*;
#[async_std::test]
async fn test_pick_up_item_stack_of_items_already_in_inventory() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -94,7 +94,7 @@ async fn test_pick_up_item_stack_of_items_already_in_inventory() {
#[async_std::test]
async fn test_pick_up_item_stack_of_items_not_already_held() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -156,7 +156,7 @@ async fn test_pick_up_item_stack_of_items_not_already_held() {
#[async_std::test]
async fn test_pick_up_meseta_when_inventory_full() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (user2, mut char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -235,7 +235,7 @@ async fn test_pick_up_meseta_when_inventory_full() {
#[async_std::test]
async fn test_pick_up_partial_stacked_item_when_inventory_is_otherwise_full() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -327,7 +327,7 @@ async fn test_pick_up_partial_stacked_item_when_inventory_is_otherwise_full() {
#[async_std::test]
async fn test_can_not_pick_up_item_when_inventory_full() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -423,7 +423,7 @@ async fn test_can_not_pick_up_item_when_inventory_full() {
#[async_std::test]
async fn test_can_not_drop_more_meseta_than_is_held() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -464,7 +464,7 @@ async fn test_can_not_drop_more_meseta_than_is_held() {
#[async_std::test]
async fn test_pick_up_stack_that_would_exceed_stack_limit() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -544,7 +544,7 @@ async fn test_pick_up_stack_that_would_exceed_stack_limit() {
#[async_std::test]
async fn test_can_not_pick_up_meseta_when_full() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (user2, mut char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -602,7 +602,7 @@ async fn test_can_not_pick_up_meseta_when_full() {
#[async_std::test]
async fn test_meseta_caps_at_999999_when_trying_to_pick_up_more() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (user2, mut char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -659,7 +659,7 @@ async fn test_meseta_caps_at_999999_when_trying_to_pick_up_more() {
#[async_std::test]
async fn test_player_drops_partial_stack_and_other_player_picks_it_up() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, char2) = new_user_character(&mut entity_gateway, "a2", "a").await;

10
tests/test_item_use.rs
View File

@ -14,7 +14,7 @@ use common::*;
#[async_std::test]
async fn test_use_monomate() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -64,7 +64,7 @@ async fn test_use_monomate() {
#[async_std::test]
async fn test_use_monomate_twice() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -119,7 +119,7 @@ async fn test_use_monomate_twice() {
#[async_std::test]
async fn test_use_last_monomate() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -164,7 +164,7 @@ async fn test_use_last_monomate() {
#[async_std::test]
async fn test_use_nonstackable_tool() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -202,7 +202,7 @@ async fn test_use_nonstackable_tool() {
#[async_std::test]
async fn test_use_materials() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;

6
tests/test_mags.rs
View File

@ -13,7 +13,7 @@ use common::*;
#[async_std::test]
async fn test_mag_feed() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -92,7 +92,7 @@ async fn test_mag_feed() {
#[async_std::test]
async fn test_mag_change_owner() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, mut char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -160,7 +160,7 @@ async fn test_mag_change_owner() {
#[async_std::test]
async fn test_mag_cell() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;

2
tests/test_rooms.rs
View File

@ -13,7 +13,7 @@ use common::*;
#[async_std::test]
async fn test_item_ids_reset_when_rejoining_rooms() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, char2) = new_user_character(&mut entity_gateway, "a2", "a").await;

26
tests/test_shops.rs
View File

@ -13,7 +13,7 @@ use common::*;
#[async_std::test]
async fn test_player_opens_weapon_shop() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.exp = 80000000;
@ -43,7 +43,7 @@ async fn test_player_opens_weapon_shop() {
#[async_std::test]
async fn test_player_opens_tool_shop() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.exp = 80000000;
@ -73,7 +73,7 @@ async fn test_player_opens_tool_shop() {
#[async_std::test]
async fn test_player_opens_armor_shop() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.exp = 80000000;
@ -103,7 +103,7 @@ async fn test_player_opens_armor_shop() {
#[async_std::test]
async fn test_player_buys_from_weapon_shop() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.exp = 80000000;
@ -142,7 +142,7 @@ async fn test_player_buys_from_weapon_shop() {
#[async_std::test]
async fn test_player_buys_from_tool_shop() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.exp = 80000000;
@ -180,7 +180,7 @@ async fn test_player_buys_from_tool_shop() {
#[async_std::test]
async fn test_player_buys_multiple_from_tool_shop() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.exp = 80000000;
@ -222,7 +222,7 @@ async fn test_player_buys_multiple_from_tool_shop() {
#[async_std::test]
async fn test_player_buys_from_armor_shop() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.exp = 80000000;
@ -264,7 +264,7 @@ async fn test_player_sells_to_shop() {
#[async_std::test]
async fn test_other_clients_see_purchase() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -307,7 +307,7 @@ async fn test_other_clients_see_purchase() {
#[async_std::test]
async fn test_other_clients_see_stacked_purchase() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
let (_user2, _char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
@ -361,7 +361,7 @@ async fn test_other_clients_see_stacked_purchase() {
#[async_std::test]
async fn test_buying_item_without_enough_mseseta() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
@ -397,7 +397,7 @@ async fn test_buying_item_without_enough_mseseta() {
#[async_std::test]
async fn test_player_double_buys_from_tool_shop() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.exp = 80000000;
@ -463,7 +463,7 @@ async fn test_player_double_buys_from_tool_shop() {
#[async_std::test]
async fn test_techs_disappear_from_shop_when_bought() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.exp = 80000000;
@ -525,7 +525,7 @@ async fn test_techs_disappear_from_shop_when_bought() {
// TOOD: this is not deterministic and can randomly fail
#[async_std::test]
async fn test_units_disappear_from_shop_when_bought() {
let mut entity_gateway = InMemoryGateway::new();
let mut entity_gateway = InMemoryGateway::default();
let (_user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
char1.exp = 80000000;