You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
756 lines
25 KiB
756 lines
25 KiB
use elseware::common::serverstate::{ClientId, ServerState};
|
|
use elseware::entity::gateway::{EntityGateway, InMemoryGateway};
|
|
use elseware::entity::item;
|
|
use elseware::ship::ship::{ShipServerState, RecvShipPacket};
|
|
|
|
use libpso::packet::ship::*;
|
|
use libpso::packet::messages::*;
|
|
|
|
#[path = "common.rs"]
|
|
mod common;
|
|
use common::*;
|
|
|
|
#[async_std::test]
|
|
async fn test_pick_up_item_stack_of_items_already_in_inventory() {
|
|
let mut entity_gateway = InMemoryGateway::new();
|
|
|
|
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
|
|
let (_user2, char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
|
|
|
|
entity_gateway.create_item(
|
|
item::NewItemEntity {
|
|
item: item::ItemDetail::Tool(
|
|
item::tool::Tool {
|
|
tool: item::tool::ToolType::Monomate
|
|
}
|
|
),
|
|
location: item::ItemLocation::Inventory {
|
|
character_id: char1.id,
|
|
slot: 0,
|
|
equipped: false,
|
|
}
|
|
}).await;
|
|
|
|
for (slot, tool) in vec![item::tool::ToolType::Monomate, item::tool::ToolType::Monofluid].into_iter().enumerate() {
|
|
for _ in 0..5 {
|
|
entity_gateway.create_item(
|
|
item::NewItemEntity {
|
|
item: item::ItemDetail::Tool(
|
|
item::tool::Tool {
|
|
tool: tool
|
|
}
|
|
),
|
|
location: item::ItemLocation::Inventory {
|
|
character_id: char2.id,
|
|
slot: slot,
|
|
equipped: false,
|
|
}
|
|
}).await;
|
|
}
|
|
}
|
|
|
|
let mut ship = ShipServerState::builder()
|
|
.gateway(entity_gateway.clone())
|
|
.build();
|
|
log_in_char(&mut ship, ClientId(1), "a1", "a").await;
|
|
log_in_char(&mut ship, ClientId(2), "a2", "a").await;
|
|
|
|
join_lobby(&mut ship, ClientId(1)).await;
|
|
join_lobby(&mut ship, ClientId(2)).await;
|
|
|
|
create_room(&mut ship, ClientId(1), "room", "").await;
|
|
join_room(&mut ship, ClientId(2), 0).await;
|
|
|
|
ship.handle(ClientId(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerDropItem(PlayerDropItem {
|
|
client: 0,
|
|
target: 0,
|
|
unknown1: 0,
|
|
map_area: 0,
|
|
item_id: 0x210000,
|
|
x: 0.0,
|
|
y: 0.0,
|
|
z: 0.0,
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0x210000,
|
|
map_area: 0,
|
|
unknown: [0; 3]
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
let p1_items = entity_gateway.get_items_by_character(&char1).await;
|
|
assert!(p1_items.len() == 6);
|
|
|
|
let p1_item_ids = p1_items.iter().map(|item| {
|
|
item.id
|
|
}).collect::<Vec<_>>();
|
|
assert!(p1_item_ids == vec![item::ItemEntityId(1), item::ItemEntityId(2), item::ItemEntityId(3), item::ItemEntityId(4), item::ItemEntityId(5), item::ItemEntityId(6)]);
|
|
|
|
let all_items_are_monomates = p1_items.iter().all(|item| {
|
|
match item.item {
|
|
item::ItemDetail::Tool(tool) => tool.tool == item::tool::ToolType::Monomate,
|
|
_ => false
|
|
}
|
|
});
|
|
assert!(all_items_are_monomates);
|
|
}
|
|
|
|
#[async_std::test]
|
|
async fn test_pick_up_item_stack_of_items_not_already_held() {
|
|
let mut entity_gateway = InMemoryGateway::new();
|
|
|
|
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
|
|
let (_user2, char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
|
|
|
|
entity_gateway.create_item(
|
|
item::NewItemEntity {
|
|
item: item::ItemDetail::Tool(
|
|
item::tool::Tool {
|
|
tool: item::tool::ToolType::Monomate
|
|
}
|
|
),
|
|
location: item::ItemLocation::Inventory {
|
|
character_id: char2.id,
|
|
slot: 0,
|
|
equipped: false,
|
|
}
|
|
}).await;
|
|
|
|
let mut ship = ShipServerState::builder()
|
|
.gateway(entity_gateway.clone())
|
|
.build();
|
|
log_in_char(&mut ship, ClientId(1), "a1", "a").await;
|
|
log_in_char(&mut ship, ClientId(2), "a2", "a").await;
|
|
|
|
join_lobby(&mut ship, ClientId(1)).await;
|
|
join_lobby(&mut ship, ClientId(2)).await;
|
|
|
|
create_room(&mut ship, ClientId(1), "room", "").await;
|
|
join_room(&mut ship, ClientId(2), 0).await;
|
|
|
|
ship.handle(ClientId(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerDropItem(PlayerDropItem {
|
|
client: 0,
|
|
target: 0,
|
|
unknown1: 0,
|
|
map_area: 0,
|
|
item_id: 0x210000,
|
|
x: 0.0,
|
|
y: 0.0,
|
|
z: 0.0,
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0x210000,
|
|
map_area: 0,
|
|
unknown: [0; 3]
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
let p1_items = entity_gateway.get_items_by_character(&char1).await;
|
|
assert!(p1_items.len() == 1);
|
|
|
|
let first_item = p1_items.get(0).unwrap();
|
|
assert!(first_item.id == item::ItemEntityId(1));
|
|
assert!(first_item.item == item::ItemDetail::Tool(item::tool::Tool {
|
|
tool: item::tool::ToolType::Monomate,
|
|
}));
|
|
}
|
|
|
|
#[async_std::test]
|
|
async fn test_pick_up_meseta_when_inventory_full() {
|
|
let mut entity_gateway = InMemoryGateway::new();
|
|
|
|
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;
|
|
|
|
for slot in 0..30 {
|
|
entity_gateway.create_item(
|
|
item::NewItemEntity {
|
|
item: item::ItemDetail::Weapon(
|
|
item::weapon::Weapon {
|
|
weapon: item::weapon::WeaponType::Saber,
|
|
grind: 0,
|
|
special: None,
|
|
attrs: [None, None, None],
|
|
tekked: true,
|
|
}
|
|
),
|
|
location: item::ItemLocation::Inventory {
|
|
character_id: char1.id,
|
|
slot: slot,
|
|
equipped: false,
|
|
}
|
|
}).await;
|
|
}
|
|
|
|
char2.meseta = 300;
|
|
entity_gateway.save_character(&char2).await;
|
|
|
|
let mut ship = ShipServerState::builder()
|
|
.gateway(entity_gateway.clone())
|
|
.build();
|
|
log_in_char(&mut ship, ClientId(1), "a1", "a").await;
|
|
log_in_char(&mut ship, ClientId(2), "a2", "a").await;
|
|
|
|
join_lobby(&mut ship, ClientId(1)).await;
|
|
join_lobby(&mut ship, ClientId(2)).await;
|
|
|
|
create_room(&mut ship, ClientId(1), "room", "").await;
|
|
join_room(&mut ship, ClientId(2), 0).await;
|
|
|
|
ship.handle(ClientId(2), &RecvShipPacket::Message(Message::new(GameMessage::DropCoordinates(DropCoordinates {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0xFFFFFFFF,
|
|
map_area: 0,
|
|
room: 0,
|
|
x: 0.0,
|
|
z: 0.0,
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
ship.handle(ClientId(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerNoLongerHasItem(PlayerNoLongerHasItem {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0xFFFFFFFF,
|
|
amount: 23,
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0xF0000001,
|
|
map_area: 0,
|
|
unknown: [0; 3]
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
let p1_items = entity_gateway.get_items_by_character(&char1).await;
|
|
assert!(p1_items.len() == 30);
|
|
|
|
let characters1 = entity_gateway.get_characters_by_user(&user1).await;
|
|
let c1 = characters1.get(0).as_ref().unwrap().as_ref().unwrap();
|
|
let characters2 = entity_gateway.get_characters_by_user(&user2).await;
|
|
let c2 = characters2.get(0).as_ref().unwrap().as_ref().unwrap();
|
|
assert!(c1.meseta == 23);
|
|
assert!(c2.meseta == 277);
|
|
}
|
|
|
|
#[async_std::test]
|
|
async fn test_pick_up_partial_stacked_item_when_inventory_is_otherwise_full() {
|
|
let mut entity_gateway = InMemoryGateway::new();
|
|
|
|
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
|
|
let (_user2, char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
|
|
|
|
for slot in 0..29 {
|
|
entity_gateway.create_item(
|
|
item::NewItemEntity {
|
|
item: item::ItemDetail::Weapon(
|
|
item::weapon::Weapon {
|
|
weapon: item::weapon::WeaponType::Saber,
|
|
grind: 0,
|
|
special: None,
|
|
attrs: [None, None, None],
|
|
tekked: true,
|
|
}
|
|
),
|
|
location: item::ItemLocation::Inventory {
|
|
character_id: char1.id,
|
|
slot: slot,
|
|
equipped: false,
|
|
}
|
|
}).await;
|
|
}
|
|
|
|
entity_gateway.create_item(
|
|
item::NewItemEntity {
|
|
item: item::ItemDetail::Tool(
|
|
item::tool::Tool {
|
|
tool: item::tool::ToolType::Monomate,
|
|
}
|
|
),
|
|
location: item::ItemLocation::Inventory {
|
|
character_id: char1.id,
|
|
slot: 29,
|
|
equipped: false,
|
|
}
|
|
}).await;
|
|
entity_gateway.create_item(
|
|
item::NewItemEntity {
|
|
item: item::ItemDetail::Tool(
|
|
item::tool::Tool {
|
|
tool: item::tool::ToolType::Monomate,
|
|
}
|
|
),
|
|
location: item::ItemLocation::Inventory {
|
|
character_id: char2.id,
|
|
slot: 0,
|
|
equipped: false,
|
|
}
|
|
}).await;
|
|
|
|
let mut ship = ShipServerState::builder()
|
|
.gateway(entity_gateway.clone())
|
|
.build();
|
|
log_in_char(&mut ship, ClientId(1), "a1", "a").await;
|
|
log_in_char(&mut ship, ClientId(2), "a2", "a").await;
|
|
|
|
join_lobby(&mut ship, ClientId(1)).await;
|
|
join_lobby(&mut ship, ClientId(2)).await;
|
|
|
|
create_room(&mut ship, ClientId(1), "room", "").await;
|
|
join_room(&mut ship, ClientId(2), 0).await;
|
|
|
|
ship.handle(ClientId(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerDropItem(PlayerDropItem {
|
|
client: 0,
|
|
target: 0,
|
|
unknown1: 0,
|
|
map_area: 0,
|
|
item_id: 0x210000,
|
|
x: 0.0,
|
|
y: 0.0,
|
|
z: 0.0,
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0x210000,
|
|
map_area: 0,
|
|
unknown: [0; 3]
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
let p1_items = entity_gateway.get_items_by_character(&char1).await;
|
|
assert!(p1_items.len() == 31);
|
|
|
|
let monomate1 = p1_items.get(29).unwrap();
|
|
assert!(monomate1.item == item::ItemDetail::Tool(item::tool::Tool {
|
|
tool: item::tool::ToolType::Monomate,
|
|
}));
|
|
let monomate2 = p1_items.get(30).unwrap();
|
|
assert!(monomate2.item == item::ItemDetail::Tool(item::tool::Tool {
|
|
tool: item::tool::ToolType::Monomate,
|
|
}));
|
|
}
|
|
|
|
#[async_std::test]
|
|
async fn test_can_not_pick_up_item_when_inventory_full() {
|
|
let mut entity_gateway = InMemoryGateway::new();
|
|
|
|
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
|
|
let (_user2, char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
|
|
|
|
for slot in 0..30 {
|
|
entity_gateway.create_item(
|
|
item::NewItemEntity {
|
|
item: item::ItemDetail::Weapon(
|
|
item::weapon::Weapon {
|
|
weapon: item::weapon::WeaponType::Saber,
|
|
grind: 0,
|
|
special: None,
|
|
attrs: [None, None, None],
|
|
tekked: true,
|
|
}
|
|
),
|
|
location: item::ItemLocation::Inventory {
|
|
character_id: char1.id,
|
|
slot: slot,
|
|
equipped: false,
|
|
}
|
|
}).await;
|
|
}
|
|
|
|
entity_gateway.create_item(
|
|
item::NewItemEntity {
|
|
item: item::ItemDetail::Weapon(
|
|
item::weapon::Weapon {
|
|
weapon: item::weapon::WeaponType::Handgun,
|
|
grind: 0,
|
|
special: None,
|
|
attrs: [None, None, None],
|
|
tekked: true,
|
|
}
|
|
),
|
|
location: item::ItemLocation::Inventory {
|
|
character_id: char2.id,
|
|
slot: 0,
|
|
equipped: false,
|
|
}
|
|
}).await;
|
|
|
|
let mut ship = ShipServerState::builder()
|
|
.gateway(entity_gateway.clone())
|
|
.build();
|
|
log_in_char(&mut ship, ClientId(1), "a1", "a").await;
|
|
log_in_char(&mut ship, ClientId(2), "a2", "a").await;
|
|
|
|
join_lobby(&mut ship, ClientId(1)).await;
|
|
join_lobby(&mut ship, ClientId(2)).await;
|
|
|
|
create_room(&mut ship, ClientId(1), "room", "").await;
|
|
join_room(&mut ship, ClientId(2), 0).await;
|
|
|
|
ship.handle(ClientId(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerDropItem(PlayerDropItem {
|
|
client: 0,
|
|
target: 0,
|
|
unknown1: 0,
|
|
map_area: 0,
|
|
item_id: 0x210000,
|
|
x: 0.0,
|
|
y: 0.0,
|
|
z: 0.0,
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0x210000,
|
|
map_area: 0,
|
|
unknown: [0; 3]
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
let p1_items = entity_gateway.get_items_by_character(&char1).await;
|
|
assert!(p1_items.len() == 30);
|
|
|
|
let p2_items = entity_gateway.get_items_by_character(&char2).await;
|
|
assert!(p2_items.len() == 0);
|
|
|
|
ship.handle(ClientId(2), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0x210000,
|
|
map_area: 0,
|
|
unknown: [0; 3]
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
let p2_items = entity_gateway.get_items_by_character(&char2).await;
|
|
assert!(p2_items.len() == 1);
|
|
}
|
|
|
|
#[async_std::test]
|
|
async fn test_can_not_drop_more_meseta_than_is_held() {
|
|
let mut entity_gateway = InMemoryGateway::new();
|
|
|
|
let (user1, mut char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
|
|
|
|
char1.meseta = 300;
|
|
entity_gateway.save_character(&char1).await;
|
|
|
|
let mut ship = ShipServerState::builder()
|
|
.gateway(entity_gateway.clone())
|
|
.build();
|
|
log_in_char(&mut ship, ClientId(1), "a1", "a").await;
|
|
|
|
join_lobby(&mut ship, ClientId(1)).await;
|
|
|
|
create_room(&mut ship, ClientId(1), "room", "").await;
|
|
|
|
ship.handle(ClientId(1), &RecvShipPacket::Message(Message::new(GameMessage::DropCoordinates(DropCoordinates {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0xFFFFFFFF,
|
|
map_area: 0,
|
|
room: 0,
|
|
x: 0.0,
|
|
z: 0.0,
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
let split_attempt = ship.handle(ClientId(1), &RecvShipPacket::Message(Message::new(GameMessage::PlayerNoLongerHasItem(PlayerNoLongerHasItem {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0xFFFFFFFF,
|
|
amount: 301,
|
|
})))).await;
|
|
assert!(split_attempt.is_err());
|
|
|
|
let characters1 = entity_gateway.get_characters_by_user(&user1).await;
|
|
let c1 = characters1.get(0).as_ref().unwrap().as_ref().unwrap();
|
|
assert!(c1.meseta == 300);
|
|
}
|
|
|
|
#[async_std::test]
|
|
async fn test_pick_up_stack_that_would_exceed_stack_limit() {
|
|
let mut entity_gateway = InMemoryGateway::new();
|
|
|
|
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
|
|
let (_user2, char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
|
|
|
|
for _ in 0..6 {
|
|
entity_gateway.create_item(
|
|
item::NewItemEntity {
|
|
item: item::ItemDetail::Tool(
|
|
item::tool::Tool {
|
|
tool: item::tool::ToolType::Monomate,
|
|
}
|
|
),
|
|
location: item::ItemLocation::Inventory {
|
|
character_id: char1.id,
|
|
slot: 0,
|
|
equipped: false,
|
|
}
|
|
}).await;
|
|
}
|
|
for _ in 0..6 {
|
|
entity_gateway.create_item(
|
|
item::NewItemEntity {
|
|
item: item::ItemDetail::Tool(
|
|
item::tool::Tool {
|
|
tool: item::tool::ToolType::Monomate,
|
|
}
|
|
),
|
|
location: item::ItemLocation::Inventory {
|
|
character_id: char2.id,
|
|
slot: 0,
|
|
equipped: false,
|
|
}
|
|
}).await;
|
|
}
|
|
|
|
let mut ship = ShipServerState::builder()
|
|
.gateway(entity_gateway.clone())
|
|
.build();
|
|
log_in_char(&mut ship, ClientId(1), "a1", "a").await;
|
|
log_in_char(&mut ship, ClientId(2), "a2", "a").await;
|
|
|
|
join_lobby(&mut ship, ClientId(1)).await;
|
|
join_lobby(&mut ship, ClientId(2)).await;
|
|
|
|
create_room(&mut ship, ClientId(1), "room", "").await;
|
|
join_room(&mut ship, ClientId(2), 0).await;
|
|
|
|
ship.handle(ClientId(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerDropItem(PlayerDropItem {
|
|
client: 0,
|
|
target: 0,
|
|
unknown1: 0,
|
|
map_area: 0,
|
|
item_id: 0x210000,
|
|
x: 0.0,
|
|
y: 0.0,
|
|
z: 0.0,
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
let packets = ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0x210000,
|
|
map_area: 0,
|
|
unknown: [0; 3]
|
|
})))).await.unwrap().collect::<Vec<_>>();
|
|
assert!(packets.len() == 0);
|
|
|
|
let p1_items = entity_gateway.get_items_by_character(&char1).await;
|
|
assert!(p1_items.len() == 6);
|
|
|
|
let p2_items = entity_gateway.get_items_by_character(&char2).await;
|
|
assert!(p2_items.len() == 0);
|
|
}
|
|
|
|
#[async_std::test]
|
|
async fn test_can_not_pick_up_meseta_when_full() {
|
|
let mut entity_gateway = InMemoryGateway::new();
|
|
|
|
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;
|
|
|
|
char1.meseta = 999999;
|
|
entity_gateway.save_character(&char1).await;
|
|
char2.meseta = 300;
|
|
entity_gateway.save_character(&char2).await;
|
|
|
|
let mut ship = ShipServerState::builder()
|
|
.gateway(entity_gateway.clone())
|
|
.build();
|
|
log_in_char(&mut ship, ClientId(1), "a1", "a").await;
|
|
log_in_char(&mut ship, ClientId(2), "a2", "a").await;
|
|
|
|
join_lobby(&mut ship, ClientId(1)).await;
|
|
join_lobby(&mut ship, ClientId(2)).await;
|
|
|
|
create_room(&mut ship, ClientId(1), "room", "").await;
|
|
join_room(&mut ship, ClientId(2), 0).await;
|
|
|
|
ship.handle(ClientId(2), &RecvShipPacket::Message(Message::new(GameMessage::DropCoordinates(DropCoordinates {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0xFFFFFFFF,
|
|
map_area: 0,
|
|
room: 0,
|
|
x: 0.0,
|
|
z: 0.0,
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
ship.handle(ClientId(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerNoLongerHasItem(PlayerNoLongerHasItem {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0xFFFFFFFF,
|
|
amount: 23,
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
let packets = ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0xF0000001,
|
|
map_area: 0,
|
|
unknown: [0; 3]
|
|
})))).await.unwrap().collect::<Vec<_>>();
|
|
assert!(packets.len() == 0);
|
|
|
|
let characters1 = entity_gateway.get_characters_by_user(&user1).await;
|
|
let c1 = characters1.get(0).as_ref().unwrap().as_ref().unwrap();
|
|
let characters2 = entity_gateway.get_characters_by_user(&user2).await;
|
|
let c2 = characters2.get(0).as_ref().unwrap().as_ref().unwrap();
|
|
assert!(c1.meseta == 999999);
|
|
assert!(c2.meseta == 277);
|
|
}
|
|
|
|
#[async_std::test]
|
|
async fn test_meseta_caps_at_999999_when_trying_to_pick_up_more() {
|
|
let mut entity_gateway = InMemoryGateway::new();
|
|
|
|
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;
|
|
|
|
char1.meseta = 999998;
|
|
entity_gateway.save_character(&char1).await;
|
|
char2.meseta = 300;
|
|
entity_gateway.save_character(&char2).await;
|
|
|
|
let mut ship = ShipServerState::builder()
|
|
.gateway(entity_gateway.clone())
|
|
.build();
|
|
log_in_char(&mut ship, ClientId(1), "a1", "a").await;
|
|
log_in_char(&mut ship, ClientId(2), "a2", "a").await;
|
|
|
|
join_lobby(&mut ship, ClientId(1)).await;
|
|
join_lobby(&mut ship, ClientId(2)).await;
|
|
|
|
create_room(&mut ship, ClientId(1), "room", "").await;
|
|
join_room(&mut ship, ClientId(2), 0).await;
|
|
|
|
ship.handle(ClientId(2), &RecvShipPacket::Message(Message::new(GameMessage::DropCoordinates(DropCoordinates {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0xFFFFFFFF,
|
|
map_area: 0,
|
|
room: 0,
|
|
x: 0.0,
|
|
z: 0.0,
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
ship.handle(ClientId(2), &RecvShipPacket::Message(Message::new(GameMessage::PlayerNoLongerHasItem(PlayerNoLongerHasItem {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0xFFFFFFFF,
|
|
amount: 23,
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0xF0000001,
|
|
map_area: 0,
|
|
unknown: [0; 3]
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
let characters1 = entity_gateway.get_characters_by_user(&user1).await;
|
|
let c1 = characters1.get(0).as_ref().unwrap().as_ref().unwrap();
|
|
let characters2 = entity_gateway.get_characters_by_user(&user2).await;
|
|
let c2 = characters2.get(0).as_ref().unwrap().as_ref().unwrap();
|
|
assert!(c1.meseta == 999999);
|
|
assert!(c2.meseta == 277);
|
|
}
|
|
|
|
#[async_std::test]
|
|
async fn test_player_drops_partial_stack_and_other_player_picks_it_up() {
|
|
let mut entity_gateway = InMemoryGateway::new();
|
|
|
|
let (_user1, char1) = new_user_character(&mut entity_gateway, "a1", "a").await;
|
|
let (_user2, char2) = new_user_character(&mut entity_gateway, "a2", "a").await;
|
|
|
|
for _ in 0..5 {
|
|
entity_gateway.create_item(
|
|
item::NewItemEntity {
|
|
item: item::ItemDetail::Tool(
|
|
item::tool::Tool {
|
|
tool: item::tool::ToolType::Monomate,
|
|
}
|
|
),
|
|
location: item::ItemLocation::Inventory {
|
|
character_id: char1.id,
|
|
slot: 0,
|
|
equipped: false,
|
|
}
|
|
}).await;
|
|
}
|
|
|
|
let mut ship = ShipServerState::builder()
|
|
.gateway(entity_gateway.clone())
|
|
.build();
|
|
log_in_char(&mut ship, ClientId(1), "a1", "a").await;
|
|
log_in_char(&mut ship, ClientId(2), "a2", "a").await;
|
|
|
|
join_lobby(&mut ship, ClientId(1)).await;
|
|
join_lobby(&mut ship, ClientId(2)).await;
|
|
|
|
create_room(&mut ship, ClientId(1), "room", "").await;
|
|
join_room(&mut ship, ClientId(2), 0).await;
|
|
|
|
ship.handle(ClientId(1), &RecvShipPacket::Message(Message::new(GameMessage::DropCoordinates(DropCoordinates {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0x10000,
|
|
map_area: 0,
|
|
room: 0,
|
|
x: 0.0,
|
|
z: 0.0,
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
ship.handle(ClientId(1), &RecvShipPacket::Message(Message::new(GameMessage::PlayerNoLongerHasItem(PlayerNoLongerHasItem {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0x10000,
|
|
amount: 2,
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
ship.handle(ClientId(2), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::PickupItem(PickupItem {
|
|
client: 0,
|
|
target: 0,
|
|
item_id: 0xF0000001,
|
|
map_area: 0,
|
|
unknown: [0; 3]
|
|
})))).await.unwrap().for_each(drop);
|
|
|
|
let p1_items = entity_gateway.get_items_by_character(&char1).await;
|
|
assert!(p1_items.len() == 3);
|
|
|
|
let p1_item_ids = p1_items.iter().map(|item| {
|
|
item.id
|
|
}).collect::<Vec<_>>();
|
|
assert!(p1_item_ids == vec![item::ItemEntityId(3), item::ItemEntityId(4), item::ItemEntityId(5)]);
|
|
|
|
let all_items_are_monomates = p1_items.iter().all(|item| {
|
|
match item.item {
|
|
item::ItemDetail::Tool(tool) => tool.tool == item::tool::ToolType::Monomate,
|
|
_ => false
|
|
}
|
|
});
|
|
assert!(all_items_are_monomates);
|
|
|
|
let p2_items = entity_gateway.get_items_by_character(&char2).await;
|
|
assert!(p2_items.len() == 2);
|
|
|
|
let p2_item_ids = p2_items.iter().map(|item| {
|
|
item.id
|
|
}).collect::<Vec<_>>();
|
|
assert!(p2_item_ids == vec![item::ItemEntityId(1), item::ItemEntityId(2)]);
|
|
|
|
let all_items_are_monomates = p1_items.iter().all(|item| {
|
|
match item.item {
|
|
item::ItemDetail::Tool(tool) => tool.tool == item::tool::ToolType::Monomate,
|
|
_ => false
|
|
}
|
|
});
|
|
assert!(all_items_are_monomates);
|
|
}
|