17 changed files with 1767 additions and 898 deletions
-
4src/entity/character.rs
-
4src/entity/gateway/entitygateway.rs
-
8src/entity/gateway/inmemory.rs
-
6src/entity/item/mod.rs
-
15src/ship/character.rs
-
881src/ship/items.rs
-
198src/ship/items/bank.rs
-
261src/ship/items/floor.rs
-
396src/ship/items/inventory.rs
-
532src/ship/items/manager.rs
-
16src/ship/items/mod.rs
-
37src/ship/packet/builder/message.rs
-
62src/ship/packet/handler/direct_message.rs
-
2src/ship/packet/handler/lobby.rs
-
13src/ship/packet/handler/message.rs
-
10src/ship/ship.rs
-
220tests/test_bank.rs
@ -1,881 +0,0 @@ |
|||
use std::collections::{HashMap, BTreeMap};
|
|||
use std::cmp::Ordering;
|
|||
use thiserror::Error;
|
|||
use futures::future::join_all;
|
|||
use libpso::character::character;//::InventoryItem;
|
|||
use crate::entity::gateway::EntityGateway;
|
|||
use crate::entity::character::{CharacterEntity, CharacterEntityId};
|
|||
use crate::entity::item::{ItemEntityId, ItemEntity, ItemDetail, ItemLocation};
|
|||
use crate::entity::item::{Meseta, NewItemEntity};
|
|||
use crate::entity::item::tool::{Tool, ToolType};
|
|||
use crate::ship::map::MapArea;
|
|||
use crate::ship::ship::ItemDropLocation;
|
|||
use crate::ship::drops::{ItemDrop, ItemDropType};
|
|||
use crate::ship::location::{AreaClient, RoomId};
|
|||
|
|||
|
|||
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|||
pub struct ActiveItemId(pub u32);
|
|||
|
|||
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|||
struct RoomItemId(RoomId, u32);
|
|||
|
|||
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|||
pub struct ClientItemId(pub u32);
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub struct IndividualInventoryItem {
|
|||
pub entity_id: ItemEntityId,
|
|||
pub item_id: ClientItemId,
|
|||
pub item: ItemDetail,
|
|||
pub equipped: bool,
|
|||
}
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub struct StackedInventoryItem {
|
|||
pub entity_ids: Vec<ItemEntityId>,
|
|||
pub item_id: ClientItemId,
|
|||
pub tool: Tool,
|
|||
}
|
|||
|
|||
impl StackedInventoryItem {
|
|||
pub fn count(&self) -> usize {
|
|||
self.entity_ids.len()
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub enum InventoryItem {
|
|||
Individual(IndividualInventoryItem),
|
|||
Stacked(StackedInventoryItem),
|
|||
}
|
|||
|
|||
pub enum InventoryItemAddToError {
|
|||
BothAreNotStacked,
|
|||
DifferentTool,
|
|||
ExceedsCapacity,
|
|||
}
|
|||
|
|||
impl InventoryItem {
|
|||
pub fn item_id(&self) -> ClientItemId {
|
|||
match self {
|
|||
InventoryItem::Individual(individual_inventory_item) => {
|
|||
individual_inventory_item.item_id
|
|||
},
|
|||
InventoryItem::Stacked(stacked_inventory_item) => {
|
|||
stacked_inventory_item.item_id
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn set_item_id(&mut self, item_id: ClientItemId) {
|
|||
match self {
|
|||
InventoryItem::Individual(individual_inventory_item) => {
|
|||
individual_inventory_item.item_id = item_id
|
|||
},
|
|||
InventoryItem::Stacked(stacked_inventory_item) => {
|
|||
stacked_inventory_item.item_id = item_id
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn are_same_stackable_tool(&self, other_stacked_item: &StackedFloorItem) -> bool {
|
|||
match self {
|
|||
InventoryItem::Stacked(self_stacked_item) => {
|
|||
self_stacked_item.tool == other_stacked_item.tool
|
|||
&& self_stacked_item.tool.is_stackable() && other_stacked_item.tool.is_stackable()
|
|||
},
|
|||
_ => false
|
|||
}
|
|||
}
|
|||
|
|||
pub fn can_combine_stacks(&self, other_stacked_item: &StackedFloorItem) -> bool {
|
|||
match self {
|
|||
InventoryItem::Stacked(self_stacked_item) => {
|
|||
self_stacked_item.tool == other_stacked_item.tool
|
|||
&& self_stacked_item.tool.is_stackable() && other_stacked_item.tool.is_stackable()
|
|||
&& self_stacked_item.count() + other_stacked_item.count() <= self_stacked_item.tool.max_stack()
|
|||
},
|
|||
_ => false
|
|||
}
|
|||
}
|
|||
|
|||
// TODO: result
|
|||
pub fn combine_stacks(&mut self, other_stacked_item: &mut StackedFloorItem) {
|
|||
match self {
|
|||
InventoryItem::Stacked(self_stacked_item) => {
|
|||
self_stacked_item.entity_ids.append(&mut other_stacked_item.entity_ids);
|
|||
},
|
|||
_ => {
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn equipped(&self) -> bool {
|
|||
match self {
|
|||
InventoryItem::Individual(individual_inventory_item) => {
|
|||
individual_inventory_item.equipped
|
|||
},
|
|||
InventoryItem::Stacked(_) => {
|
|||
false
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn as_client_bytes(&self) -> [u8; 16] {
|
|||
match self {
|
|||
InventoryItem::Individual(item) => {
|
|||
match &item.item {
|
|||
ItemDetail::Weapon(w) => w.as_bytes(),
|
|||
ItemDetail::Armor(a) => a.as_bytes(),
|
|||
ItemDetail::Shield(s) => s.as_bytes(),
|
|||
ItemDetail::Unit(u) => u.as_bytes(),
|
|||
ItemDetail::Tool(t) => t.as_individual_bytes(),
|
|||
ItemDetail::TechniqueDisk(d) => d.as_bytes(),
|
|||
ItemDetail::Mag(m) => m.as_bytes(),
|
|||
}
|
|||
},
|
|||
InventoryItem::Stacked(item) => {
|
|||
item.tool.as_stacked_bytes(item.entity_ids.len())
|
|||
},
|
|||
}
|
|||
}
|
|||
|
|||
pub fn can_add_to(&mut self, stacked_floor_item: &StackedFloorItem) -> Result<(), InventoryItemAddToError> {
|
|||
if let InventoryItem::Stacked(stacked_inventory_item) = self {
|
|||
if stacked_floor_item.tool != stacked_inventory_item.tool {
|
|||
return Err(InventoryItemAddToError::DifferentTool)
|
|||
}
|
|||
|
|||
if stacked_floor_item.tool.tool.max_stack() < (stacked_floor_item.count() + stacked_inventory_item.count()) {
|
|||
return Err(InventoryItemAddToError::ExceedsCapacity)
|
|||
}
|
|||
Ok(())
|
|||
}
|
|||
else {
|
|||
Err(InventoryItemAddToError::BothAreNotStacked)
|
|||
}
|
|||
}
|
|||
|
|||
pub fn add_to(&mut self, mut stacked_floor_item: StackedFloorItem) -> Result<(), InventoryItemAddToError> {
|
|||
self.can_add_to(&stacked_floor_item)?;
|
|||
if let InventoryItem::Stacked(stacked_inventory_item) = self {
|
|||
stacked_inventory_item.entity_ids.append(&mut stacked_floor_item.entity_ids);
|
|||
}
|
|||
Ok(())
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub struct IndividualFloorItem {
|
|||
pub entity_id: ItemEntityId,
|
|||
pub item_id: ClientItemId,
|
|||
pub item: ItemDetail,
|
|||
pub map_area: MapArea,
|
|||
pub x: f32,
|
|||
pub y: f32,
|
|||
pub z: f32,
|
|||
}
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub struct StackedFloorItem {
|
|||
pub entity_ids: Vec<ItemEntityId>,
|
|||
pub item_id: ClientItemId,
|
|||
pub tool: Tool,
|
|||
pub map_area: MapArea,
|
|||
pub x: f32,
|
|||
pub y: f32,
|
|||
pub z: f32,
|
|||
}
|
|||
|
|||
impl StackedFloorItem {
|
|||
pub fn count(&self) -> usize {
|
|||
self.entity_ids.len()
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub struct MesetaFloorItem {
|
|||
pub item_id: ClientItemId,
|
|||
pub meseta: Meseta,
|
|||
pub map_area: MapArea,
|
|||
pub x: f32,
|
|||
pub y: f32,
|
|||
pub z: f32,
|
|||
}
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub enum FloorItem {
|
|||
Individual(IndividualFloorItem),
|
|||
Stacked(StackedFloorItem),
|
|||
Meseta(MesetaFloorItem),
|
|||
}
|
|||
|
|||
impl FloorItem {
|
|||
pub fn item_id(&self) -> ClientItemId {
|
|||
match self {
|
|||
FloorItem::Individual(individual_floor_item) => {
|
|||
individual_floor_item.item_id
|
|||
},
|
|||
FloorItem::Stacked(stacked_floor_item) => {
|
|||
stacked_floor_item.item_id
|
|||
},
|
|||
FloorItem::Meseta(meseta_floor_item) => {
|
|||
meseta_floor_item.item_id
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn x(&self) -> f32 {
|
|||
match self {
|
|||
FloorItem::Individual(individual_floor_item) => {
|
|||
individual_floor_item.x
|
|||
},
|
|||
FloorItem::Stacked(stacked_floor_item) => {
|
|||
stacked_floor_item.x
|
|||
},
|
|||
FloorItem::Meseta(meseta_floor_item) => {
|
|||
meseta_floor_item.x
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn y(&self) -> f32 {
|
|||
match self {
|
|||
FloorItem::Individual(individual_floor_item) => {
|
|||
individual_floor_item.y
|
|||
},
|
|||
FloorItem::Stacked(stacked_floor_item) => {
|
|||
stacked_floor_item.y
|
|||
},
|
|||
FloorItem::Meseta(meseta_floor_item) => {
|
|||
meseta_floor_item.y
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn z(&self) -> f32 {
|
|||
match self {
|
|||
FloorItem::Individual(individual_floor_item) => {
|
|||
individual_floor_item.z
|
|||
},
|
|||
FloorItem::Stacked(stacked_floor_item) => {
|
|||
stacked_floor_item.z
|
|||
},
|
|||
FloorItem::Meseta(meseta_floor_item) => {
|
|||
meseta_floor_item.z
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn map_area(&self) -> MapArea {
|
|||
match self {
|
|||
FloorItem::Individual(individual_floor_item) => {
|
|||
individual_floor_item.map_area
|
|||
},
|
|||
FloorItem::Stacked(stacked_floor_item) => {
|
|||
stacked_floor_item.map_area
|
|||
},
|
|||
FloorItem::Meseta(meseta_floor_item) => {
|
|||
meseta_floor_item.map_area
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn as_client_bytes(&self) -> [u8; 16] {
|
|||
match self {
|
|||
FloorItem::Individual(individual_floor_item) => {
|
|||
individual_floor_item.item.as_client_bytes()
|
|||
},
|
|||
FloorItem::Stacked(stacked_floor_item) => {
|
|||
stacked_floor_item.tool.as_stacked_bytes(stacked_floor_item.count())
|
|||
},
|
|||
FloorItem::Meseta(meseta_floor_item) => {
|
|||
meseta_floor_item.meseta.as_bytes()
|
|||
}
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug)]
|
|||
pub struct CharacterInventory<'a>(&'a Vec<InventoryItem>);
|
|||
|
|||
// TODO: this should actually do things
|
|||
impl<'a> CharacterInventory<'a> {
|
|||
pub fn as_client_inventory_items(&self) -> [character::InventoryItem; 30] {
|
|||
self.0.iter()
|
|||
.enumerate()
|
|||
.fold([character::InventoryItem::default(); 30], |mut inventory, (slot, item)| {
|
|||
let bytes = item.as_client_bytes();
|
|||
inventory[slot].data1.copy_from_slice(&bytes[0..12]);
|
|||
inventory[slot].data2.copy_from_slice(&bytes[12..16]);
|
|||
inventory[slot].item_id = item.item_id().0;
|
|||
// does this do anything?
|
|||
inventory[slot].equipped = if item.equipped() { 1 } else { 0 };
|
|||
// because this actually equips the item
|
|||
inventory[slot].flags |= if item.equipped() { 8 } else { 0 };
|
|||
inventory
|
|||
})
|
|||
}
|
|||
|
|||
pub fn slot(&self, slot: usize) -> Option<&'a InventoryItem> {
|
|||
self.0.get(slot)
|
|||
}
|
|||
|
|||
pub fn count(&self) -> usize {
|
|||
self.0.len()
|
|||
}
|
|||
|
|||
// TODO: function that gives out a handle to an item, allowing deletion of it from the inventory
|
|||
}
|
|||
|
|||
pub enum TriggerCreateItem {
|
|||
Yes,
|
|||
No
|
|||
}
|
|||
|
|||
|
|||
#[derive(Error, Debug)]
|
|||
#[error("")]
|
|||
pub enum ItemManagerError {
|
|||
EntityGatewayError,
|
|||
NoSuchItemId(ClientItemId),
|
|||
NoCharacter(CharacterEntityId),
|
|||
CouldNotAddToInventory(FloorItem),
|
|||
//ItemBelongsToOtherPlayer,
|
|||
Idunnoman,
|
|||
CouldNotSplitItem(InventoryItem),
|
|||
CouldNotDropMeseta,
|
|||
NotEnoughTools(Tool, usize, usize), // have, expected
|
|||
}
|
|||
|
|||
pub struct ItemManager {
|
|||
id_counter: u32,
|
|||
|
|||
character_inventory: HashMap<CharacterEntityId, Vec<InventoryItem>>,
|
|||
character_floor: HashMap<CharacterEntityId, Vec<FloorItem>>,
|
|||
|
|||
character_room: HashMap<CharacterEntityId, RoomId>,
|
|||
room_floor: HashMap<RoomId, Vec<FloorItem>>,
|
|||
room_item_id_counter: HashMap<RoomId, Box<dyn FnMut() -> ClientItemId + Send>>,
|
|||
}
|
|||
|
|||
impl ItemManager {
|
|||
pub fn new() -> ItemManager {
|
|||
ItemManager {
|
|||
id_counter: 0,
|
|||
character_inventory: HashMap::new(),
|
|||
character_floor: HashMap::new(),
|
|||
character_room: HashMap::new(),
|
|||
room_floor: HashMap::new(),
|
|||
room_item_id_counter: HashMap::new(),
|
|||
}
|
|||
}
|
|||
|
|||
pub fn next_global_item_id(&mut self) -> ClientItemId {
|
|||
self.id_counter += 1;
|
|||
ClientItemId(self.id_counter)
|
|||
}
|
|||
|
|||
// TODO: Result
|
|||
pub async fn load_character<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &CharacterEntity) {
|
|||
let items = entity_gateway.get_items_by_character(&character).await;
|
|||
let inventory_items = items.into_iter()
|
|||
.filter_map(|item| {
|
|||
match item.location {
|
|||
ItemLocation::Inventory{slot, equipped, ..} => Some((item.id, item.item, slot, equipped)),
|
|||
_ => None,
|
|||
}
|
|||
})
|
|||
.fold(BTreeMap::new(), |mut acc, (id, item, slot, equipped)| {
|
|||
if item.is_stackable() {
|
|||
if let ItemDetail::Tool(tool) = item {
|
|||
let inventory_item = acc.entry(slot).or_insert(InventoryItem::Stacked(StackedInventoryItem {
|
|||
entity_ids: Vec::new(),
|
|||
item_id: self.next_global_item_id(),
|
|||
tool: tool,
|
|||
}));
|
|||
if let InventoryItem::Stacked(ref mut stacked_inventory_item) = inventory_item {
|
|||
stacked_inventory_item.entity_ids.push(id);
|
|||
}
|
|||
}
|
|||
}
|
|||
else {
|
|||
acc.insert(slot, InventoryItem::Individual(IndividualInventoryItem {
|
|||
entity_id: id,
|
|||
item_id: self.next_global_item_id(),
|
|||
item: item,
|
|||
equipped: equipped,
|
|||
}));
|
|||
}
|
|||
|
|||
acc
|
|||
});
|
|||
let inventory = inventory_items.into_iter().map(|(k, v)| v).take(30).collect();
|
|||
self.character_inventory.insert(character.id, inventory);
|
|||
}
|
|||
|
|||
pub fn add_character_to_room(&mut self, room_id: RoomId, character: &CharacterEntity, area_client: AreaClient) {
|
|||
let base_id = ((area_client.local_client.id() as u32) << 21) | 0x10000;
|
|||
let inventory = self.character_inventory.get_mut(&character.id).unwrap();
|
|||
for (i, item) in inventory.iter_mut().enumerate() {
|
|||
item.set_item_id(ClientItemId(base_id + i as u32));
|
|||
}
|
|||
self.character_room.insert(character.id, room_id);
|
|||
self.character_floor.insert(character.id, Vec::new());
|
|||
self.room_floor.entry(room_id).or_insert(Vec::new());
|
|||
|
|||
let mut inc = 0xF0000000;
|
|||
self.room_item_id_counter.entry(room_id).or_insert(Box::new(move || {
|
|||
inc += 1;
|
|||
ClientItemId(inc)
|
|||
}));
|
|||
}
|
|||
|
|||
pub fn get_character_inventory(&self, character: &CharacterEntity) -> Result<CharacterInventory, ItemManagerError> {
|
|||
Ok(CharacterInventory(self.character_inventory.get(&character.id)
|
|||
.ok_or(ItemManagerError::NoCharacter(character.id))?))
|
|||
}
|
|||
|
|||
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() {
|
|||
self.room_floor.remove(room);
|
|||
}
|
|||
});
|
|||
}
|
|||
|
|||
pub fn get_inventory_item_by_id(&self, character: &CharacterEntity, item_id: ClientItemId) -> Result<InventoryItem, ItemManagerError> {
|
|||
let inventory = self.character_inventory.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
|
|||
inventory.iter()
|
|||
.filter(|item| {
|
|||
item.item_id() == item_id
|
|||
})
|
|||
.nth(0)
|
|||
.ok_or(ItemManagerError::NoSuchItemId(item_id))
|
|||
.map(Clone::clone)
|
|||
}
|
|||
|
|||
pub fn get_floor_item_by_id(&self, character: &CharacterEntity, item_id: ClientItemId) -> Result<FloorItem, ItemManagerError> {
|
|||
let floor = self.character_floor.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
|
|||
let room = self.character_room.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
|
|||
let shared_floor = self.room_floor.get(room).ok_or(ItemManagerError::NoCharacter(character.id))?;
|
|||
floor.iter()
|
|||
.chain(shared_floor.iter())
|
|||
.filter(|item| {
|
|||
item.item_id() == item_id
|
|||
})
|
|||
.nth(0)
|
|||
.ok_or(ItemManagerError::NoSuchItemId(item_id))
|
|||
.map(Clone::clone)
|
|||
}
|
|||
|
|||
pub async fn character_picks_up_item<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &mut CharacterEntity, floor_item: FloorItem) -> Result<TriggerCreateItem, ItemManagerError> {
|
|||
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 (floor_to_remove_from, position) = if let Some(position) = local_floor.iter().position(|item| item.item_id() == floor_item.item_id()) {
|
|||
(local_floor, position)
|
|||
}
|
|||
else if let Some(position) = shared_floor.iter().position(|item| item.item_id() == floor_item.item_id()) {
|
|||
(shared_floor, position)
|
|||
}
|
|||
else {
|
|||
return Err(ItemManagerError::NoSuchItemId(floor_item.item_id()))
|
|||
};
|
|||
|
|||
let trigger_create_item = match floor_item.clone() {
|
|||
FloorItem::Individual(individual_floor_item) => {
|
|||
if inventory.len() >= 30 {
|
|||
return Err(ItemManagerError::CouldNotAddToInventory(floor_item));
|
|||
}
|
|||
|
|||
entity_gateway.save_item(&ItemEntity {
|
|||
id: individual_floor_item.entity_id,
|
|||
item: individual_floor_item.item.clone(),
|
|||
location: ItemLocation::Inventory {
|
|||
character_id: character.id,
|
|||
slot: inventory.len(),
|
|||
equipped: false,
|
|||
}
|
|||
}).await;
|
|||
|
|||
let inventory_item = InventoryItem::Individual(IndividualInventoryItem {
|
|||
entity_id: individual_floor_item.entity_id,
|
|||
item_id: individual_floor_item.item_id,
|
|||
item: individual_floor_item.item,
|
|||
equipped: false,
|
|||
});
|
|||
inventory.push(inventory_item);
|
|||
|
|||
TriggerCreateItem::Yes
|
|||
},
|
|||
FloorItem::Stacked(mut stacked_floor_item) => {
|
|||
let mut tool_in_inventory = inventory.iter_mut()
|
|||
.enumerate()
|
|||
.find(|(_, item)| {
|
|||
item.are_same_stackable_tool(&stacked_floor_item)
|
|||
});
|
|||
|
|||
match tool_in_inventory {
|
|||
Some((slot, ref mut tool_in_inventory)) => {
|
|||
if tool_in_inventory.can_combine_stacks(&stacked_floor_item) {
|
|||
for entity_id in stacked_floor_item.entity_ids.iter() {
|
|||
entity_gateway.save_item(&ItemEntity {
|
|||
id: *entity_id,
|
|||
item: ItemDetail::Tool(stacked_floor_item.tool),
|
|||
location: ItemLocation::Inventory {
|
|||
character_id: character.id,
|
|||
slot: slot,
|
|||
equipped: false,
|
|||
}
|
|||
}).await;
|
|||
}
|
|||
|
|||
tool_in_inventory.combine_stacks(&mut stacked_floor_item)
|
|||
}
|
|||
else {
|
|||
return Err(ItemManagerError::CouldNotAddToInventory(floor_item))
|
|||
}
|
|||
TriggerCreateItem::No
|
|||
},
|
|||
None => {
|
|||
let slot = inventory.len();
|
|||
for entity_id in stacked_floor_item.entity_ids.iter() {
|
|||
entity_gateway.save_item(&ItemEntity {
|
|||
id: *entity_id,
|
|||
item: ItemDetail::Tool(stacked_floor_item.tool),
|
|||
location: ItemLocation::Inventory {
|
|||
character_id: character.id,
|
|||
slot: slot,
|
|||
equipped: false,
|
|||
}
|
|||
}).await;
|
|||
}
|
|||
|
|||
inventory.push(InventoryItem::Stacked(StackedInventoryItem {
|
|||
entity_ids: stacked_floor_item.entity_ids,
|
|||
item_id: stacked_floor_item.item_id,
|
|||
tool: stacked_floor_item.tool,
|
|||
}));
|
|||
TriggerCreateItem::Yes
|
|||
}
|
|||
}
|
|||
},
|
|||
FloorItem::Meseta(meseta_floor_item) => {
|
|||
if character.meseta == 999999 {
|
|||
return Err(ItemManagerError::CouldNotAddToInventory(floor_item));
|
|||
}
|
|||
character.meseta = std::cmp::min(character.meseta + meseta_floor_item.meseta.0, 999999);
|
|||
entity_gateway.save_character(&character).await;
|
|||
TriggerCreateItem::No
|
|||
}
|
|||
};
|
|||
|
|||
floor_to_remove_from.remove(position);
|
|||
|
|||
Ok(trigger_create_item)
|
|||
}
|
|||
|
|||
pub async fn enemy_drop_item_on_local_floor<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &CharacterEntity, item_drop: ItemDrop) -> Result<&FloorItem, ItemManagerError> {
|
|||
let room_id = self.character_room.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
|
|||
|
|||
enum ItemOrMeseta {
|
|||
Individual(ItemDetail),
|
|||
Stacked(Tool),
|
|||
Meseta(Meseta)
|
|||
}
|
|||
|
|||
let item = match item_drop.item {
|
|||
ItemDropType::Weapon(w) => ItemOrMeseta::Individual(ItemDetail::Weapon(w)),
|
|||
ItemDropType::Armor(w) => ItemOrMeseta::Individual(ItemDetail::Armor(w)),
|
|||
ItemDropType::Shield(w) => ItemOrMeseta::Individual(ItemDetail::Shield(w)),
|
|||
ItemDropType::Unit(w) => ItemOrMeseta::Individual(ItemDetail::Unit(w)),
|
|||
ItemDropType::TechniqueDisk(w) => ItemOrMeseta::Individual(ItemDetail::TechniqueDisk(w)),
|
|||
ItemDropType::Mag(w) => ItemOrMeseta::Individual(ItemDetail::Mag(w)),
|
|||
//ItemDropType::IndividualTool(t) => ItemOrMeseta::Individual(ItemDetail::Tool(t)),
|
|||
//ItemDropType::StackedTool(t, _) => ItemOrMeseta::Stacked(t),
|
|||
ItemDropType::Tool(t) if t.tool.is_stackable() => ItemOrMeseta::Stacked(t),
|
|||
ItemDropType::Tool(t) if !t.tool.is_stackable() => ItemOrMeseta::Individual(ItemDetail::Tool(t)),
|
|||
ItemDropType::Meseta(m) => ItemOrMeseta::Meseta(Meseta(m)),
|
|||
_ => unreachable!() // rust isnt smart enough to see that the conditional on tool catches everything
|
|||
};
|
|||
|
|||
let item_id = self.room_item_id_counter.get_mut(room_id).ok_or(ItemManagerError::NoCharacter(character.id))?();
|
|||
let floor_item = match item {
|
|||
ItemOrMeseta::Individual(item_detail) => {
|
|||
let entity = entity_gateway.create_item(NewItemEntity {
|
|||
item: item_detail.clone(),
|
|||
location: ItemLocation::LocalFloor {
|
|||
character_id: character.id,
|
|||
map_area: item_drop.map_area,
|
|||
x: item_drop.x,
|
|||
y: item_drop.y,
|
|||
z: item_drop.z,
|
|||
}
|
|||
}).await.ok_or(ItemManagerError::EntityGatewayError)?;
|
|||
FloorItem::Individual(IndividualFloorItem {
|
|||
entity_id: entity.id,
|
|||
item_id: item_id,
|
|||
item: item_detail,
|
|||
map_area: item_drop.map_area,
|
|||
x: item_drop.x,
|
|||
y: item_drop.y,
|
|||
z: item_drop.z,
|
|||
})
|
|||
},
|
|||
ItemOrMeseta::Stacked(tool) => {
|
|||
let entity = entity_gateway.create_item(NewItemEntity {
|
|||
item: ItemDetail::Tool(tool),
|
|||
location: ItemLocation::LocalFloor {
|
|||
character_id: character.id,
|
|||
map_area: item_drop.map_area,
|
|||
x: item_drop.x,
|
|||
y: item_drop.y,
|
|||
z: item_drop.z,
|
|||
}
|
|||
}).await.ok_or(ItemManagerError::EntityGatewayError)?;
|
|||
FloorItem::Stacked(StackedFloorItem {
|
|||
entity_ids: vec![entity.id],
|
|||
item_id: item_id,
|
|||
tool: tool,
|
|||
map_area: item_drop.map_area,
|
|||
x: item_drop.x,
|
|||
y: item_drop.y,
|
|||
z: item_drop.z,
|
|||
})
|
|||
},
|
|||
ItemOrMeseta::Meseta(meseta) => {
|
|||
FloorItem::Meseta(MesetaFloorItem {
|
|||
item_id: item_id,
|
|||
meseta: meseta,
|
|||
map_area: item_drop.map_area,
|
|||
x: item_drop.x,
|
|||
y: item_drop.y,
|
|||
z: item_drop.z,
|
|||
})
|
|||
},
|
|||
};
|
|||
|
|||
self.character_floor.entry(character.id).or_insert(Vec::new()).push(floor_item);
|
|||
self.character_floor.get(&character.id).ok_or(ItemManagerError::Idunnoman)?.last().ok_or(ItemManagerError::Idunnoman)
|
|||
}
|
|||
|
|||
pub async fn player_drop_item_on_shared_floor<EG: EntityGateway>(&mut self,
|
|||
entity_gateway: &mut EG,
|
|||
character: &CharacterEntity,
|
|||
inventory_item: InventoryItem,
|
|||
item_drop_location: (MapArea, f32, f32, f32))
|
|||
-> Result<(), ItemManagerError> {
|
|||
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 dropped_inventory_item = inventory
|
|||
.drain_filter(|i| i.item_id() == inventory_item.item_id())
|
|||
.nth(0)
|
|||
.ok_or(ItemManagerError::NoSuchItemId(inventory_item.item_id()))?;
|
|||
|
|||
let dropped_floor_item = match dropped_inventory_item {
|
|||
InventoryItem::Individual(individual_inventory_item) => {
|
|||
entity_gateway.save_item(&ItemEntity {
|
|||
id: individual_inventory_item.entity_id,
|
|||
item: individual_inventory_item.item.clone(),
|
|||
location: ItemLocation::SharedFloor {
|
|||
map_area: item_drop_location.0,
|
|||
x: item_drop_location.1,
|
|||
y: item_drop_location.2,
|
|||
z: item_drop_location.3,
|
|||
}
|
|||
}).await;
|
|||
|
|||
FloorItem::Individual(IndividualFloorItem {
|
|||
entity_id: individual_inventory_item.entity_id,
|
|||
item_id: individual_inventory_item.item_id,
|
|||
item: individual_inventory_item.item,
|
|||
map_area: item_drop_location.0,
|
|||
x: item_drop_location.1,
|
|||
y: item_drop_location.2,
|
|||
z: item_drop_location.3,
|
|||
})
|
|||
},
|
|||
InventoryItem::Stacked(stacked_inventory_item) => {
|
|||
for entity_id in stacked_inventory_item.entity_ids.iter() {
|
|||
entity_gateway.save_item(&ItemEntity {
|
|||
id: *entity_id,
|
|||
item: ItemDetail::Tool(stacked_inventory_item.tool),
|
|||
location: ItemLocation::SharedFloor {
|
|||
map_area: item_drop_location.0,
|
|||
x: item_drop_location.1,
|
|||
y: item_drop_location.2,
|
|||
z: item_drop_location.3,
|
|||
}
|
|||
}).await;
|
|||
}
|
|||
FloorItem::Stacked(StackedFloorItem {
|
|||
entity_ids: stacked_inventory_item.entity_ids,
|
|||
item_id: stacked_inventory_item.item_id,
|
|||
tool: stacked_inventory_item.tool,
|
|||
map_area: item_drop_location.0,
|
|||
x: item_drop_location.1,
|
|||
y: item_drop_location.2,
|
|||
z: item_drop_location.3,
|
|||
})
|
|||
},
|
|||
};
|
|||
|
|||
shared_floor.push(dropped_floor_item);
|
|||
Ok(())
|
|||
}
|
|||
|
|||
pub async fn player_drops_meseta_on_shared_floor<EG: EntityGateway>(&mut self,
|
|||
entity_gateway: &mut EG,
|
|||
character: &mut CharacterEntity,
|
|||
drop_location: ItemDropLocation,
|
|||
amount: u32)
|
|||
-> Result<FloorItem, ItemManagerError> {
|
|||
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))?;
|
|||
if character.meseta <= amount {
|
|||
return Err(ItemManagerError::CouldNotDropMeseta)
|
|||
}
|
|||
character.meseta -= amount;
|
|||
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,
|
|||
meseta: Meseta(amount),
|
|||
map_area: drop_location.map_area,
|
|||
x: drop_location.x,
|
|||
y: 0.0,
|
|||
z: drop_location.z,
|
|||
});
|
|||
|
|||
shared_floor.push(floor_item.clone());
|
|||
Ok(floor_item)
|
|||
}
|
|||
|
|||
pub async fn player_drops_partial_stack_on_shared_floor<EG: EntityGateway>(&mut self,
|
|||
entity_gateway: &mut EG,
|
|||
character: &CharacterEntity,
|
|||
inventory_item: InventoryItem,
|
|||
drop_location: ItemDropLocation,
|
|||
amount: usize)
|
|||
-> Result<FloorItem, ItemManagerError> {
|
|||
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 item_to_split = inventory.iter_mut()
|
|||
.find(|i| i.item_id() == inventory_item.item_id())
|
|||
.ok_or(ItemManagerError::NoSuchItemId(inventory_item.item_id()))?;
|
|||
|
|||
|
|||
if let InventoryItem::Stacked(ref mut stacked_inventory_item) = item_to_split {
|
|||
if stacked_inventory_item.entity_ids.len() <= amount {
|
|||
return Err(ItemManagerError::CouldNotSplitItem(inventory_item));
|
|||
}
|
|||
|
|||
let dropped_entity_ids = stacked_inventory_item.entity_ids.drain(..amount).collect::<Vec<_>>();
|
|||
for de in dropped_entity_ids.iter() {
|
|||
entity_gateway.save_item(&ItemEntity {
|
|||
id: *de,
|
|||
item: ItemDetail::Tool(stacked_inventory_item.tool),
|
|||
location: ItemLocation::SharedFloor {
|
|||
map_area: drop_location.map_area,
|
|||
x: drop_location.x,
|
|||
y: 0.0,
|
|||
z: drop_location.z,
|
|||
}
|
|||
}).await
|
|||
}
|
|||
|
|||
let item_id = self.room_item_id_counter.get_mut(room_id).ok_or(ItemManagerError::NoCharacter(character.id))?();
|
|||
let floor_item = FloorItem::Stacked(StackedFloorItem {
|
|||
entity_ids: dropped_entity_ids,
|
|||
item_id: item_id,
|
|||
tool: stacked_inventory_item.tool,
|
|||
map_area: drop_location.map_area,
|
|||
x: drop_location.x,
|
|||
y: 0.0,
|
|||
z: drop_location.z,
|
|||
});
|
|||
shared_floor.push(floor_item.clone());
|
|||
Ok(floor_item)
|
|||
}
|
|||
else {
|
|||
Err(ItemManagerError::CouldNotSplitItem(inventory_item))
|
|||
}
|
|||
}
|
|||
|
|||
pub async fn player_consumes_tool<EG: EntityGateway>(&mut self,
|
|||
entity_gateway: &mut EG,
|
|||
character: &CharacterEntity,
|
|||
inventory_item: InventoryItem,
|
|||
amount: usize)
|
|||
-> Result<ItemDetail, ItemManagerError> {
|
|||
let inventory = self.character_inventory.get_mut(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
|
|||
|
|||
match inventory_item.clone() {
|
|||
InventoryItem::Individual(individual_inventory_item) => {
|
|||
// TODO: use remove
|
|||
let _used_inventory_item = inventory
|
|||
.drain_filter(|i| i.item_id() == inventory_item.item_id())
|
|||
.nth(0)
|
|||
.ok_or(ItemManagerError::NoSuchItemId(inventory_item.item_id()))?;
|
|||
|
|||
entity_gateway.save_item(&ItemEntity {
|
|||
id: individual_inventory_item.entity_id,
|
|||
item: individual_inventory_item.item.clone(),
|
|||
location: ItemLocation::Consumed,
|
|||
}).await;
|
|||
Ok(individual_inventory_item.item)
|
|||
},
|
|||
InventoryItem::Stacked(stacked_inventory_item) => {
|
|||
let used_entity_ids = match stacked_inventory_item.count().cmp(&amount) {
|
|||
Ordering::Equal => {
|
|||
let _used_inventory_item = inventory
|
|||
.drain_filter(|i| i.item_id() == inventory_item.item_id())
|
|||
.nth(0)
|
|||
.ok_or(ItemManagerError::NoSuchItemId(inventory_item.item_id()))?;
|
|||
stacked_inventory_item.entity_ids
|
|||
},
|
|||
Ordering::Greater => {
|
|||
let tool_used = inventory
|
|||
.iter_mut()
|
|||
.find(|i| i.item_id() == stacked_inventory_item.item_id)
|
|||
.ok_or(ItemManagerError::NoSuchItemId(stacked_inventory_item.item_id))?;
|
|||
if let InventoryItem::Stacked(ref mut stacked_tool_used) = tool_used {
|
|||
stacked_tool_used.entity_ids.drain(..amount).collect::<Vec<_>>()
|
|||
}
|
|||
else {
|
|||
unreachable!()
|
|||
}
|
|||
//stacked_inventory_item.entity_ids.iter_mut().drain(..amount).collect::<Vec<_>>()
|
|||
}
|
|||
Ordering::Less => {
|
|||
//return Err(ItemManagerError::NotEnoughTools(tool, held_amount, amount))
|
|||
return Err(ItemManagerError::Idunnoman)
|
|||
},
|
|||
};
|
|||
|
|||
for used_entity_id in used_entity_ids {
|
|||
entity_gateway.save_item(&ItemEntity {
|
|||
id: used_entity_id,
|
|||
item: ItemDetail::Tool(stacked_inventory_item.tool),
|
|||
location: ItemLocation::Consumed,
|
|||
}).await;
|
|||
}
|
|||
Ok(ItemDetail::Tool(stacked_inventory_item.tool))
|
|||
},
|
|||
}
|
|||
|
|||
}
|
|||
}
|
|||
@ -0,0 +1,198 @@ |
|||
use crate::ship::items::ClientItemId;
|
|||
use std::collections::{HashMap, BTreeMap, BinaryHeap};
|
|||
use std::cmp::{Ordering, PartialOrd, PartialEq};
|
|||
use thiserror::Error;
|
|||
use futures::future::join_all;
|
|||
use libpso::character::character;//::InventoryItem;
|
|||
use crate::entity::gateway::EntityGateway;
|
|||
use crate::entity::character::{CharacterEntity, CharacterEntityId};
|
|||
use crate::entity::item::{ItemEntityId, ItemEntity, ItemDetail, ItemLocation, BankName};
|
|||
use crate::entity::item::{Meseta, NewItemEntity};
|
|||
use crate::entity::item::tool::{Tool, ToolType};
|
|||
use crate::ship::map::MapArea;
|
|||
use crate::ship::ship::ItemDropLocation;
|
|||
use crate::ship::drops::{ItemDrop, ItemDropType};
|
|||
use crate::ship::location::{AreaClient, RoomId};
|
|||
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub struct IndividualBankItem {
|
|||
pub entity_id: ItemEntityId,
|
|||
pub item_id: ClientItemId,
|
|||
pub item: ItemDetail,
|
|||
}
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub struct StackedBankItem {
|
|||
pub entity_ids: Vec<ItemEntityId>,
|
|||
pub item_id: ClientItemId,
|
|||
pub tool: Tool,
|
|||
}
|
|||
|
|||
impl StackedBankItem {
|
|||
pub fn count(&self) -> usize {
|
|||
self.entity_ids.len()
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub enum BankItem {
|
|||
Individual(IndividualBankItem),
|
|||
Stacked(StackedBankItem),
|
|||
}
|
|||
|
|||
|
|||
impl std::cmp::PartialEq for BankItem {
|
|||
fn eq(&self, other: &BankItem) -> bool {
|
|||
let mut self_bytes = [0u8; 4];
|
|||
let mut other_bytes = [0u8; 4];
|
|||
self_bytes.copy_from_slice(&self.as_client_bytes()[0..4]);
|
|||
other_bytes.copy_from_slice(&other.as_client_bytes()[0..4]);
|
|||
|
|||
let self_value = u32::from_be_bytes(self_bytes);
|
|||
let other_value = u32::from_be_bytes(other_bytes);
|
|||
|
|||
self_value.eq(&other_value)
|
|||
}
|
|||
}
|
|||
|
|||
impl std::cmp::Eq for BankItem {}
|
|||
|
|||
impl std::cmp::PartialOrd for BankItem {
|
|||
fn partial_cmp(&self, other: &BankItem) -> Option<std::cmp::Ordering> {
|
|||
//let self_bytes = self.as_client_bytes();
|
|||
//let other_bytes = other.as_client_bytes();
|
|||
let mut self_bytes = [0u8; 4];
|
|||
let mut other_bytes = [0u8; 4];
|
|||
self_bytes.copy_from_slice(&self.as_client_bytes()[0..4]);
|
|||
other_bytes.copy_from_slice(&other.as_client_bytes()[0..4]);
|
|||
|
|||
|
|||
let self_value = u32::from_be_bytes(self_bytes);
|
|||
let other_value = u32::from_be_bytes(other_bytes);
|
|||
|
|||
self_value.partial_cmp(&other_value)
|
|||
}
|
|||
}
|
|||
|
|||
impl std::cmp::Ord for BankItem {
|
|||
fn cmp(&self, other: &BankItem) -> std::cmp::Ordering {
|
|||
//let self_bytes = self.as_client_bytes();
|
|||
//let other_bytes = other.as_client_bytes();
|
|||
let mut self_bytes = [0u8; 4];
|
|||
let mut other_bytes = [0u8; 4];
|
|||
self_bytes.copy_from_slice(&self.as_client_bytes()[0..4]);
|
|||
other_bytes.copy_from_slice(&other.as_client_bytes()[0..4]);
|
|||
|
|||
|
|||
let self_value = u32::from_le_bytes(self_bytes);
|
|||
let other_value = u32::from_le_bytes(other_bytes);
|
|||
|
|||
self_value.cmp(&other_value)
|
|||
}
|
|||
}
|
|||
|
|||
impl BankItem {
|
|||
pub fn set_item_id(&mut self, item_id: ClientItemId) {
|
|||
match self {
|
|||
BankItem::Individual(individual_bank_item) => {
|
|||
individual_bank_item.item_id = item_id
|
|||
},
|
|||
BankItem::Stacked(stacked_bank_item) => {
|
|||
stacked_bank_item.item_id = item_id
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn item_id(&self) -> ClientItemId {
|
|||
match self {
|
|||
BankItem::Individual(individual_bank_item) => {
|
|||
individual_bank_item.item_id
|
|||
},
|
|||
BankItem::Stacked(stacked_bank_item) => {
|
|||
stacked_bank_item.item_id
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn as_client_bytes(&self) -> [u8; 16] {
|
|||
match self {
|
|||
BankItem::Individual(item) => {
|
|||
match &item.item {
|
|||
ItemDetail::Weapon(w) => w.as_bytes(),
|
|||
ItemDetail::Armor(a) => a.as_bytes(),
|
|||
ItemDetail::Shield(s) => s.as_bytes(),
|
|||
ItemDetail::Unit(u) => u.as_bytes(),
|
|||
ItemDetail::Tool(t) => t.as_individual_bytes(),
|
|||
ItemDetail::TechniqueDisk(d) => d.as_bytes(),
|
|||
ItemDetail::Mag(m) => m.as_bytes(),
|
|||
}
|
|||
},
|
|||
BankItem::Stacked(item) => {
|
|||
item.tool.as_stacked_bytes(item.entity_ids.len())
|
|||
},
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub struct CharacterBank(Vec<BankItem>);
|
|||
|
|||
impl CharacterBank {
|
|||
pub fn new(mut items: Vec<BankItem>) -> CharacterBank {
|
|||
items.sort();
|
|||
CharacterBank(items)
|
|||
}
|
|||
|
|||
pub fn initialize_item_ids(&mut self, base_item_id: u32) {
|
|||
for (i, item) in self.0.iter_mut().enumerate() {
|
|||
item.set_item_id(ClientItemId(base_item_id + i as u32));
|
|||
}
|
|||
}
|
|||
|
|||
pub fn as_client_bank_items(&self) -> character::Bank {
|
|||
self.0.iter()
|
|||
.enumerate()
|
|||
.fold(character::Bank::default(), |mut bank, (slot, item)| {
|
|||
bank.item_count = (slot + 1) as u32;
|
|||
let bytes = item.as_client_bytes();
|
|||
bank.items[slot].data1.copy_from_slice(&bytes[0..12]);
|
|||
bank.items[slot].data2.copy_from_slice(&bytes[12..16]);
|
|||
bank.items[slot].item_id = item.item_id().0;
|
|||
|
|||
bank
|
|||
})
|
|||
}
|
|||
|
|||
pub fn as_client_bank_request(&self) -> Vec<character::BankItem> {
|
|||
self.0.iter()
|
|||
.map(|item| {
|
|||
let bytes = item.as_client_bytes();
|
|||
let mut data1 = [0; 12];
|
|||
let mut data2 = [0; 4];
|
|||
data1.copy_from_slice(&bytes[0..12]);
|
|||
data2.copy_from_slice(&bytes[12..16]);
|
|||
let amount = match item {
|
|||
BankItem::Individual(_individual_bank_item) => {
|
|||
1
|
|||
},
|
|||
BankItem::Stacked(stacked_bank_item) => {
|
|||
stacked_bank_item.count()
|
|||
},
|
|||
};
|
|||
character::BankItem {
|
|||
data1: data1,
|
|||
data2: data2,
|
|||
item_id: item.item_id().0,
|
|||
amount: amount as u16,
|
|||
flags: 1,
|
|||
}
|
|||
})
|
|||
.collect()
|
|||
}
|
|||
|
|||
pub fn count(&self) -> usize {
|
|||
self.0.len()
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
@ -0,0 +1,261 @@ |
|||
use crate::ship::items::ClientItemId;
|
|||
use std::collections::{HashMap, BTreeMap, BinaryHeap};
|
|||
use std::cmp::{Ordering, PartialOrd, PartialEq};
|
|||
use thiserror::Error;
|
|||
use futures::future::join_all;
|
|||
use libpso::character::character;//::InventoryItem;
|
|||
use crate::entity::gateway::EntityGateway;
|
|||
use crate::entity::character::{CharacterEntity, CharacterEntityId};
|
|||
use crate::entity::item::{ItemEntityId, ItemEntity, ItemDetail, ItemLocation, BankName};
|
|||
use crate::entity::item::{Meseta, NewItemEntity};
|
|||
use crate::entity::item::tool::{Tool, ToolType};
|
|||
use crate::ship::map::MapArea;
|
|||
use crate::ship::ship::ItemDropLocation;
|
|||
use crate::ship::drops::{ItemDrop, ItemDropType};
|
|||
use crate::ship::location::{AreaClient, RoomId};
|
|||
use crate::ship::items::inventory::{IndividualInventoryItem, StackedInventoryItem, InventoryItemHandle};
|
|||
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub struct IndividualFloorItem {
|
|||
pub entity_id: ItemEntityId,
|
|||
pub item_id: ClientItemId,
|
|||
pub item: ItemDetail,
|
|||
pub map_area: MapArea,
|
|||
pub x: f32,
|
|||
pub y: f32,
|
|||
pub z: f32,
|
|||
}
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub struct StackedFloorItem {
|
|||
pub entity_ids: Vec<ItemEntityId>,
|
|||
pub item_id: ClientItemId,
|
|||
pub tool: Tool,
|
|||
pub map_area: MapArea,
|
|||
pub x: f32,
|
|||
pub y: f32,
|
|||
pub z: f32,
|
|||
}
|
|||
|
|||
impl StackedFloorItem {
|
|||
pub fn count(&self) -> usize {
|
|||
self.entity_ids.len()
|
|||
}
|
|||
|
|||
pub fn as_client_bytes(&self) -> [u8; 16] {
|
|||
self.tool.as_stacked_bytes(self.count())
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub struct MesetaFloorItem {
|
|||
pub item_id: ClientItemId,
|
|||
pub meseta: Meseta,
|
|||
pub map_area: MapArea,
|
|||
pub x: f32,
|
|||
pub y: f32,
|
|||
pub z: f32,
|
|||
}
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub enum FloorItem {
|
|||
Individual(IndividualFloorItem),
|
|||
Stacked(StackedFloorItem),
|
|||
Meseta(MesetaFloorItem),
|
|||
}
|
|||
|
|||
impl FloorItem {
|
|||
pub fn item_id(&self) -> ClientItemId {
|
|||
match self {
|
|||
FloorItem::Individual(individual_floor_item) => {
|
|||
individual_floor_item.item_id
|
|||
},
|
|||
FloorItem::Stacked(stacked_floor_item) => {
|
|||
stacked_floor_item.item_id
|
|||
},
|
|||
FloorItem::Meseta(meseta_floor_item) => {
|
|||
meseta_floor_item.item_id
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn x(&self) -> f32 {
|
|||
match self {
|
|||
FloorItem::Individual(individual_floor_item) => {
|
|||
individual_floor_item.x
|
|||
},
|
|||
FloorItem::Stacked(stacked_floor_item) => {
|
|||
stacked_floor_item.x
|
|||
},
|
|||
FloorItem::Meseta(meseta_floor_item) => {
|
|||
meseta_floor_item.x
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn y(&self) -> f32 {
|
|||
match self {
|
|||
FloorItem::Individual(individual_floor_item) => {
|
|||
individual_floor_item.y
|
|||
},
|
|||
FloorItem::Stacked(stacked_floor_item) => {
|
|||
stacked_floor_item.y
|
|||
},
|
|||
FloorItem::Meseta(meseta_floor_item) => {
|
|||
meseta_floor_item.y
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn z(&self) -> f32 {
|
|||
match self {
|
|||
FloorItem::Individual(individual_floor_item) => {
|
|||
individual_floor_item.z
|
|||
},
|
|||
FloorItem::Stacked(stacked_floor_item) => {
|
|||
stacked_floor_item.z
|
|||
},
|
|||
FloorItem::Meseta(meseta_floor_item) => {
|
|||
meseta_floor_item.z
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn map_area(&self) -> MapArea {
|
|||
match self {
|
|||
FloorItem::Individual(individual_floor_item) => {
|
|||
individual_floor_item.map_area
|
|||
},
|
|||
FloorItem::Stacked(stacked_floor_item) => {
|
|||
stacked_floor_item.map_area
|
|||
},
|
|||
FloorItem::Meseta(meseta_floor_item) => {
|
|||
meseta_floor_item.map_area
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn as_client_bytes(&self) -> [u8; 16] {
|
|||
match self {
|
|||
FloorItem::Individual(individual_floor_item) => {
|
|||
individual_floor_item.item.as_client_bytes()
|
|||
},
|
|||
FloorItem::Stacked(stacked_floor_item) => {
|
|||
stacked_floor_item.as_client_bytes()
|
|||
},
|
|||
FloorItem::Meseta(meseta_floor_item) => {
|
|||
meseta_floor_item.meseta.as_bytes()
|
|||
}
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
|
|||
pub struct FloorItemHandle<'a> {
|
|||
floor: &'a mut RoomFloorItems,
|
|||
index: usize,
|
|||
}
|
|||
|
|||
impl<'a> FloorItemHandle<'a> {
|
|||
pub fn item(&'a self) -> Option<&'a FloorItem> {
|
|||
self.floor.0.get(self.index)
|
|||
}
|
|||
|
|||
pub fn remove_from_floor(self) {
|
|||
self.floor.0.remove(self.index);
|
|||
}
|
|||
}
|
|||
|
|||
// TODO: floors should keep track of their own item_ids
|
|||
#[derive(Debug)]
|
|||
pub struct RoomFloorItems(Vec<FloorItem>);
|
|||
|
|||
impl RoomFloorItems {
|
|||
pub fn new() -> RoomFloorItems {
|
|||
RoomFloorItems(Vec::new())
|
|||
}
|
|||
|
|||
pub fn add_item(&mut self, item: FloorItem) {
|
|||
self.0.push(item);
|
|||
}
|
|||
|
|||
pub fn get_item_by_id(&self, item_id: ClientItemId) -> Option<&FloorItem> {
|
|||
self.0.iter().find(|item| item.item_id() == item_id)
|
|||
}
|
|||
|
|||
pub fn get_item_handle_by_id(&mut self, item_id: ClientItemId) -> Option<FloorItemHandle> {
|
|||
let index = self.0.iter().position(|item| item.item_id() == item_id)?;
|
|||
Some(FloorItemHandle {
|
|||
floor: self,
|
|||
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)
|
|||
}
|
|||
|
|||
pub fn drop_individual_inventory_item(&mut self, individual_inventory_item: IndividualInventoryItem, item_drop_location: (MapArea, f32, f32, f32)) -> &IndividualFloorItem {
|
|||
self.0.push(FloorItem::Individual(IndividualFloorItem {
|
|||
entity_id: individual_inventory_item.entity_id,
|
|||
item_id: individual_inventory_item.item_id,
|
|||
item: individual_inventory_item.item,
|
|||
map_area: item_drop_location.0,
|
|||
x: item_drop_location.1,
|
|||
y: item_drop_location.2,
|
|||
z: item_drop_location.3,
|
|||
}));
|
|||
|
|||
match self.0.last().unwrap() {
|
|||
FloorItem::Individual(item) => item,
|
|||
_ => unreachable!(),
|
|||
}
|
|||
}
|
|||
|
|||
pub fn drop_stacked_inventory_item(&mut self, stacked_inventory_item: StackedInventoryItem, item_drop_location: (MapArea, f32, f32, f32)) -> &StackedFloorItem {
|
|||
self.0.push(FloorItem::Stacked(StackedFloorItem {
|
|||
entity_ids: stacked_inventory_item.entity_ids,
|
|||
item_id: stacked_inventory_item.item_id,
|
|||
tool: stacked_inventory_item.tool,
|
|||
map_area: item_drop_location.0,
|
|||
x: item_drop_location.1,
|
|||
y: item_drop_location.2,
|
|||
z: item_drop_location.3,
|
|||
}));
|
|||
|
|||
match self.0.last().unwrap() {
|
|||
FloorItem::Stacked(item) => item,
|
|||
_ => unreachable!(),
|
|||
}
|
|||
}
|
|||
|
|||
// TODO: Result
|
|||
// TODO: if consumed_item is not a tool items do not get placed back into inventory (should I care?)
|
|||
pub fn drop_partial_stacked_inventory_item(&mut self, inventory_item: InventoryItemHandle, amount: usize, new_item_id: ClientItemId, item_drop_location: (MapArea, f32, f32, f32)) -> Option<&StackedFloorItem> {
|
|||
let consumed_item = inventory_item.consume(amount).ok()?;
|
|||
|
|||
if let ItemDetail::Tool(tool) = consumed_item.item {
|
|||
self.0.push(FloorItem::Stacked(StackedFloorItem {
|
|||
entity_ids: consumed_item.entity_ids,
|
|||
item_id: new_item_id,
|
|||
tool: tool,
|
|||
map_area: item_drop_location.0,
|
|||
x: item_drop_location.1,
|
|||
y: item_drop_location.2,
|
|||
z: item_drop_location.3,
|
|||
}))
|
|||
}
|
|||
else {
|
|||
return None
|
|||
}
|
|||
|
|||
match self.0.last().unwrap() {
|
|||
FloorItem::Stacked(item) => Some(item),
|
|||
_ => unreachable!(),
|
|||
}
|
|||
}
|
|||
}
|
|||
@ -0,0 +1,396 @@ |
|||
use std::collections::{HashMap, BTreeMap, BinaryHeap};
|
|||
use std::cmp::{Ordering, PartialOrd, PartialEq};
|
|||
use thiserror::Error;
|
|||
use futures::future::join_all;
|
|||
use libpso::character::character;//::InventoryItem;
|
|||
use crate::entity::gateway::EntityGateway;
|
|||
use crate::entity::character::{CharacterEntity, CharacterEntityId};
|
|||
use crate::entity::item::{ItemEntityId, ItemEntity, ItemDetail, ItemLocation, BankName};
|
|||
use crate::entity::item::{Meseta, NewItemEntity};
|
|||
use crate::entity::item::tool::{Tool, ToolType};
|
|||
use crate::ship::map::MapArea;
|
|||
use crate::ship::ship::ItemDropLocation;
|
|||
use crate::ship::drops::{ItemDrop, ItemDropType};
|
|||
use crate::ship::location::{AreaClient, RoomId};
|
|||
use crate::ship::items::ClientItemId;
|
|||
use crate::ship::items::floor::{IndividualFloorItem, StackedFloorItem};
|
|||
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub struct InventorySlot(pub usize);
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub struct IndividualInventoryItem {
|
|||
pub entity_id: ItemEntityId,
|
|||
pub item_id: ClientItemId,
|
|||
pub item: ItemDetail,
|
|||
pub equipped: bool,
|
|||
}
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub struct StackedInventoryItem {
|
|||
pub entity_ids: Vec<ItemEntityId>,
|
|||
pub item_id: ClientItemId,
|
|||
pub tool: Tool,
|
|||
}
|
|||
|
|||
impl StackedInventoryItem {
|
|||
pub fn count(&self) -> usize {
|
|||
self.entity_ids.len()
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Debug, Clone)]
|
|||
pub enum InventoryItem {
|
|||
Individual(IndividualInventoryItem),
|
|||
Stacked(StackedInventoryItem),
|
|||
}
|
|||
|
|||
#[derive(Error, Debug, Clone)]
|
|||
#[error("")]
|
|||
pub enum InventoryItemAddToError {
|
|||
BothAreNotStacked,
|
|||
DifferentTool,
|
|||
ExceedsCapacity,
|
|||
}
|
|||
|
|||
impl InventoryItem {
|
|||
pub fn item_id(&self) -> ClientItemId {
|
|||
match self {
|
|||
InventoryItem::Individual(individual_inventory_item) => {
|
|||
individual_inventory_item.item_id
|
|||
},
|
|||
InventoryItem::Stacked(stacked_inventory_item) => {
|
|||
stacked_inventory_item.item_id
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn set_item_id(&mut self, item_id: ClientItemId) {
|
|||
match self {
|
|||
InventoryItem::Individual(individual_inventory_item) => {
|
|||
individual_inventory_item.item_id = item_id
|
|||
},
|
|||
InventoryItem::Stacked(stacked_inventory_item) => {
|
|||
stacked_inventory_item.item_id = item_id
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn are_same_stackable_tool(&self, other_stacked_item: &StackedFloorItem) -> bool {
|
|||
match self {
|
|||
InventoryItem::Stacked(self_stacked_item) => {
|
|||
self_stacked_item.tool == other_stacked_item.tool
|
|||
&& self_stacked_item.tool.is_stackable() && other_stacked_item.tool.is_stackable()
|
|||
},
|
|||
_ => false
|
|||
}
|
|||
}
|
|||
|
|||
pub fn can_combine_stacks(&self, other_stacked_item: &StackedFloorItem) -> bool {
|
|||
match self {
|
|||
InventoryItem::Stacked(self_stacked_item) => {
|
|||
self_stacked_item.tool == other_stacked_item.tool
|
|||
&& self_stacked_item.tool.is_stackable() && other_stacked_item.tool.is_stackable()
|
|||
&& self_stacked_item.count() + other_stacked_item.count() <= self_stacked_item.tool.max_stack()
|
|||
},
|
|||
_ => false
|
|||
}
|
|||
}
|
|||
|
|||
// TODO: result
|
|||
pub fn combine_stacks(&mut self, other_stacked_item: &mut StackedFloorItem) {
|
|||
match self {
|
|||
InventoryItem::Stacked(self_stacked_item) => {
|
|||
self_stacked_item.entity_ids.append(&mut other_stacked_item.entity_ids);
|
|||
},
|
|||
_ => {
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn equipped(&self) -> bool {
|
|||
match self {
|
|||
InventoryItem::Individual(individual_inventory_item) => {
|
|||
individual_inventory_item.equipped
|
|||
},
|
|||
InventoryItem::Stacked(_) => {
|
|||
false
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
pub fn as_client_bytes(&self) -> [u8; 16] {
|
|||
match self {
|
|||
InventoryItem::Individual(item) => {
|
|||
match &item.item {
|
|||
ItemDetail::Weapon(w) => w.as_bytes(),
|
|||
ItemDetail::Armor(a) => a.as_bytes(),
|
|||
ItemDetail::Shield(s) => s.as_bytes(),
|
|||
ItemDetail::Unit(u) => u.as_bytes(),
|
|||
ItemDetail::Tool(t) => t.as_individual_bytes(),
|
|||
ItemDetail::TechniqueDisk(d) => d.as_bytes(),
|
|||
ItemDetail::Mag(m) => m.as_bytes(),
|
|||
}
|
|||
},
|
|||
InventoryItem::Stacked(item) => {
|
|||
item.tool.as_stacked_bytes(item.entity_ids.len())
|
|||
},
|
|||
}
|
|||
}
|
|||
|
|||
pub fn can_add_to(&mut self, stacked_floor_item: &StackedFloorItem) -> Result<(), InventoryItemAddToError> {
|
|||
if let InventoryItem::Stacked(stacked_inventory_item) = self {
|
|||
if stacked_floor_item.tool != stacked_inventory_item.tool {
|
|||
return Err(InventoryItemAddToError::DifferentTool)
|
|||
}
|
|||
|
|||
if stacked_floor_item.tool.tool.max_stack() < (stacked_floor_item.count() + stacked_inventory_item.count()) {
|
|||
return Err(InventoryItemAddToError::ExceedsCapacity)
|
|||
}
|
|||
Ok(())
|
|||
}
|
|||
else {
|
|||
Err(InventoryItemAddToError::BothAreNotStacked)
|
|||
}
|
|||
}
|
|||
|
|||
pub fn add_to(&mut self, mut stacked_floor_item: StackedFloorItem) -> Result<(), InventoryItemAddToError> {
|
|||
self.can_add_to(&stacked_floor_item)?;
|
|||
if let InventoryItem::Stacked(stacked_inventory_item) = self {
|
|||
stacked_inventory_item.entity_ids.append(&mut stacked_floor_item.entity_ids);
|
|||
}
|
|||
Ok(())
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
#[derive(Error, Debug, Clone)]
|
|||
#[error("")]
|
|||
pub enum InventoryItemConsumeError {
|
|||
InconsistentState,
|
|||
InvalidAmount,
|
|||
}
|
|||
|
|||
pub struct ConsumedItem {
|
|||
pub entity_ids: Vec<ItemEntityId>,
|
|||
pub item: ItemDetail
|
|||
}
|
|||
|
|||
pub struct InventoryItemHandle<'a> {
|
|||
inventory: &'a mut CharacterInventory,
|
|||
slot: usize,
|
|||
}
|
|||
|
|||
impl<'a> InventoryItemHandle<'a> {
|
|||
pub fn item(&'a self) -> Option<&'a InventoryItem> {
|
|||
self.inventory.0.get(self.slot)
|
|||
}
|
|||
|
|||
pub fn remove_from_inventory(self) {
|
|||
self.inventory.0.remove(self.slot);
|
|||
}
|
|||
|
|||
pub fn consume(self, amount: usize) -> Result<ConsumedItem, InventoryItemConsumeError> {
|
|||
enum RemoveMethod {
|
|||
EntireThing(ConsumedItem),
|
|||
Partial(ItemDetail),
|
|||
}
|
|||
|
|||
let inventory_item = self.inventory.0.get(self.slot).ok_or(InventoryItemConsumeError::InconsistentState)?;
|
|||
let remove_method = match inventory_item {
|
|||
InventoryItem::Individual(individual_inventory_item) => {
|
|||
RemoveMethod::EntireThing(ConsumedItem {
|
|||
entity_ids: vec![individual_inventory_item.entity_id],
|
|||
item: individual_inventory_item.item.clone()
|
|||
})
|
|||
},
|
|||
InventoryItem::Stacked(stacked_inventory_item) => {
|
|||
match stacked_inventory_item.count().cmp(&amount) {
|
|||
Ordering::Equal => {
|
|||
RemoveMethod::EntireThing(ConsumedItem {
|
|||
entity_ids: stacked_inventory_item.entity_ids.clone(),
|
|||
item: ItemDetail::Tool(stacked_inventory_item.tool),
|
|||
})
|
|||
},
|
|||
Ordering::Greater => {
|
|||
RemoveMethod::Partial(ItemDetail::Tool(stacked_inventory_item.tool))
|
|||
},
|
|||
Ordering::Less => {
|
|||
return Err(InventoryItemConsumeError::InvalidAmount)
|
|||
}
|
|||
}
|
|||
},
|
|||
};
|
|||
|
|||
match remove_method {
|
|||
RemoveMethod::EntireThing(consumed_item) => {
|
|||
self.inventory.0.remove(self.slot);
|
|||
Ok(consumed_item)
|
|||
},
|
|||
RemoveMethod::Partial(item_detail) => {
|
|||
let entity_ids = self.inventory.0.get_mut(self.slot)
|
|||
.and_then(|item| {
|
|||
if let InventoryItem::Stacked(stacked_inventory_item) = item {
|
|||
Some(stacked_inventory_item.entity_ids.drain(..amount).collect::<Vec<_>>())
|
|||
}
|
|||
else {
|
|||
None
|
|||
}
|
|||
})
|
|||
.ok_or(InventoryItemConsumeError::InvalidAmount)?;
|
|||
Ok(ConsumedItem {
|
|||
entity_ids: entity_ids,
|
|||
item: item_detail,
|
|||
})
|
|||
}
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
|
|||
|
|||
#[derive(Debug)]
|
|||
pub struct CharacterInventory(Vec<InventoryItem>);
|
|||
|
|||
impl CharacterInventory {
|
|||
pub fn new(items: Vec<InventoryItem>) -> CharacterInventory {
|
|||
CharacterInventory(items)
|
|||
}
|
|||
|
|||
pub fn initialize_item_ids(&mut self, base_item_id: u32) {
|
|||
for (i, item) in self.0.iter_mut().enumerate() {
|
|||
item.set_item_id(ClientItemId(base_item_id + i as u32));
|
|||
}
|
|||
}
|
|||
|
|||
pub fn as_client_inventory_items(&self) -> [character::InventoryItem; 30] {
|
|||
self.0.iter()
|
|||
.enumerate()
|
|||
.fold([character::InventoryItem::default(); 30], |mut inventory, (slot, item)| {
|
|||
let bytes = item.as_client_bytes();
|
|||
inventory[slot].data1.copy_from_slice(&bytes[0..12]);
|
|||
inventory[slot].data2.copy_from_slice(&bytes[12..16]);
|
|||
inventory[slot].item_id = item.item_id().0;
|
|||
// does this do anything?
|
|||
inventory[slot].equipped = if item.equipped() { 1 } else { 0 };
|
|||
// because this actually equips the item
|
|||
inventory[slot].flags |= if item.equipped() { 8 } else { 0 };
|
|||
inventory
|
|||
})
|
|||
}
|
|||
|
|||
pub fn slot(&self, slot: usize) -> Option<&InventoryItem> {
|
|||
self.0.get(slot)
|
|||
}
|
|||
|
|||
pub fn count(&self) -> usize {
|
|||
self.0.len()
|
|||
}
|
|||
|
|||
pub fn get_item_handle_by_id<'a>(&'a mut self, item_id: ClientItemId) -> Option<InventoryItemHandle<'a>> {
|
|||
let (slot, _) = self.0.iter()
|
|||
.enumerate()
|
|||
.filter(|(_, item)| {
|
|||
item.item_id() == item_id
|
|||
})
|
|||
.nth(0)?;
|
|||
Some(InventoryItemHandle {
|
|||
inventory: self,
|
|||
slot: slot,
|
|||
})
|
|||
}
|
|||
|
|||
pub fn get_item_by_id(&self, item_id: ClientItemId) -> Option<&InventoryItem> {
|
|||
self.0.iter()
|
|||
.filter(|item| {
|
|||
item.item_id() == item_id
|
|||
})
|
|||
.nth(0)
|
|||
}
|
|||
|
|||
pub fn take_item_by_id(&mut self, item_id: ClientItemId) -> Option<InventoryItem> {
|
|||
self.0
|
|||
.drain_filter(|i| i.item_id() == item_id)
|
|||
.nth(0)
|
|||
}
|
|||
|
|||
pub fn take_stacked_item_by_id(&mut self, item_id: ClientItemId, amount: usize) -> Option<InventoryItem> {
|
|||
// TODO: amount?
|
|||
self.0
|
|||
.drain_filter(|i| i.item_id() == item_id)
|
|||
.nth(0)
|
|||
}
|
|||
|
|||
pub fn add_item(&mut self, item: InventoryItem) -> Result<(), ()> { // TODO: errors
|
|||
// TODO: check slot conflict?
|
|||
self.0.push(item);
|
|||
Ok(())
|
|||
}
|
|||
|
|||
// TODO: should these pick up functions take floor_item as mut and remove the ids?
|
|||
pub fn pick_up_individual_floor_item(&mut self, floor_item: &IndividualFloorItem) -> Option<(&IndividualInventoryItem, InventorySlot)> {
|
|||
if self.count() >= 30 {
|
|||
return None;
|
|||
}
|
|||
|
|||
self.0.push(InventoryItem::Individual(IndividualInventoryItem {
|
|||
entity_id: floor_item.entity_id,
|
|||
item_id: floor_item.item_id,
|
|||
item: floor_item.item.clone(),
|
|||
equipped: false,
|
|||
}));
|
|||
|
|||
if let Some(InventoryItem::Individual(new_item)) = self.0.last() {
|
|||
Some((new_item, InventorySlot(self.count())))
|
|||
}
|
|||
else {
|
|||
None
|
|||
}
|
|||
}
|
|||
|
|||
// TODO: can be simplified using find instead of position
|
|||
pub fn pick_up_stacked_floor_item(&mut self, floor_item: &StackedFloorItem) -> Option<(&StackedInventoryItem, InventorySlot)> {
|
|||
let existing_stack_position = self.0.iter()
|
|||
.position(|inventory_item| {
|
|||
if let InventoryItem::Stacked(stacked_inventory_item) = inventory_item {
|
|||
if stacked_inventory_item.tool == floor_item.tool {
|
|||
return true
|
|||
}
|
|||
}
|
|||
false
|
|||
});
|
|||
|
|||
if let Some(existing_stack_position) = existing_stack_position {
|
|||
if let Some(InventoryItem::Stacked(stacked_item)) = self.0.get_mut(existing_stack_position) {
|
|||
if (stacked_item.count() + floor_item.count() <= stacked_item.tool.max_stack()) {
|
|||
stacked_item.entity_ids.append(&mut floor_item.entity_ids.clone());
|
|||
Some((stacked_item, InventorySlot(existing_stack_position)))
|
|||
}
|
|||
else {
|
|||
None
|
|||
}
|
|||
}
|
|||
else {
|
|||
None
|
|||
}
|
|||
}
|
|||
else {
|
|||
let new_stacked_item = InventoryItem::Stacked(StackedInventoryItem {
|
|||
entity_ids: floor_item.entity_ids.clone(),
|
|||
item_id: floor_item.item_id,
|
|||
tool: floor_item.tool,
|
|||
});
|
|||
|
|||
self.0.push(new_stacked_item);
|
|||
if let Some(InventoryItem::Stacked(new_item)) = self.0.last() {
|
|||
Some((new_item, InventorySlot(self.count())))
|
|||
}
|
|||
else {
|
|||
None
|
|||
}
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
@ -0,0 +1,532 @@ |
|||
use crate::ship::items::ClientItemId;
|
|||
use std::collections::{HashMap, BTreeMap, BinaryHeap};
|
|||
use std::cmp::{Ordering, PartialOrd, PartialEq};
|
|||
use thiserror::Error;
|
|||
use futures::future::join_all;
|
|||
use libpso::character::character;//::InventoryItem;
|
|||
use crate::entity::gateway::EntityGateway;
|
|||
use crate::entity::character::{CharacterEntity, CharacterEntityId};
|
|||
use crate::entity::item::{ItemEntityId, ItemEntity, ItemDetail, ItemLocation, BankName};
|
|||
use crate::entity::item::{Meseta, NewItemEntity};
|
|||
use crate::entity::item::tool::{Tool, ToolType};
|
|||
use crate::ship::map::MapArea;
|
|||
use crate::ship::ship::ItemDropLocation;
|
|||
use crate::ship::drops::{ItemDrop, ItemDropType};
|
|||
use crate::ship::location::{AreaClient, RoomId};
|
|||
|
|||
use crate::ship::items::bank::*;
|
|||
use crate::ship::items::floor::*;
|
|||
use crate::ship::items::inventory::*;
|
|||
|
|||
|
|||
pub enum TriggerCreateItem {
|
|||
Yes,
|
|||
No
|
|||
}
|
|||
|
|||
#[derive(Error, Debug)]
|
|||
#[error("")]
|
|||
pub enum ItemManagerError {
|
|||
EntityGatewayError,
|
|||
NoSuchItemId(ClientItemId),
|
|||
NoCharacter(CharacterEntityId),
|
|||
CouldNotAddToInventory(ClientItemId),
|
|||
//ItemBelongsToOtherPlayer,
|
|||
Idunnoman,
|
|||
CouldNotSplitItem(ClientItemId),
|
|||
CouldNotDropMeseta,
|
|||
NotEnoughTools(Tool, usize, usize), // have, expected
|
|||
InventoryItemConsumeError(#[from] InventoryItemConsumeError),
|
|||
}
|
|||
|
|||
pub struct ItemManager {
|
|||
id_counter: u32,
|
|||
|
|||
character_inventory: HashMap<CharacterEntityId, CharacterInventory>,
|
|||
character_bank: HashMap<CharacterEntityId, BTreeMap<BankName, CharacterBank>>,
|
|||
character_floor: HashMap<CharacterEntityId, RoomFloorItems>,
|
|||
|
|||
character_room: HashMap<CharacterEntityId, RoomId>,
|
|||
room_floor: HashMap<RoomId, RoomFloorItems>,
|
|||
room_item_id_counter: HashMap<RoomId, Box<dyn FnMut() -> ClientItemId + Send>>,
|
|||
}
|
|||
|
|||
impl ItemManager {
|
|||
pub fn new() -> ItemManager {
|
|||
ItemManager {
|
|||
id_counter: 0,
|
|||
character_inventory: HashMap::new(),
|
|||
character_bank: HashMap::new(),
|
|||
character_floor: HashMap::new(),
|
|||
character_room: HashMap::new(),
|
|||
room_floor: HashMap::new(),
|
|||
room_item_id_counter: HashMap::new(),
|
|||
}
|
|||
}
|
|||
|
|||
pub fn next_global_item_id(&mut self) -> ClientItemId {
|
|||
self.id_counter += 1;
|
|||
ClientItemId(self.id_counter)
|
|||
}
|
|||
|
|||
// TODO: Result
|
|||
pub async fn load_character<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &CharacterEntity) {
|
|||
let items = entity_gateway.get_items_by_character(&character).await;
|
|||
let inventory_items = items.clone().into_iter()
|
|||
.filter_map(|item| {
|
|||
match item.location {
|
|||
ItemLocation::Inventory{slot, equipped, ..} => Some((item.id, item.item, slot, equipped)),
|
|||
_ => None,
|
|||
}
|
|||
})
|
|||
.fold(BTreeMap::new(), |mut acc, (id, item, slot, equipped)| {
|
|||
if item.is_stackable() {
|
|||
if let ItemDetail::Tool(tool) = item {
|
|||
let inventory_item = acc.entry(slot).or_insert(InventoryItem::Stacked(StackedInventoryItem {
|
|||
entity_ids: Vec::new(),
|
|||
item_id: self.next_global_item_id(),
|
|||
tool: tool,
|
|||
}));
|
|||
if let InventoryItem::Stacked(ref mut stacked_inventory_item) = inventory_item {
|
|||
stacked_inventory_item.entity_ids.push(id);
|
|||
}
|
|||
}
|
|||
}
|
|||
else {
|
|||
acc.insert(slot, InventoryItem::Individual(IndividualInventoryItem {
|
|||
entity_id: id,
|
|||
item_id: self.next_global_item_id(),
|
|||
item: item,
|
|||
equipped: equipped,
|
|||
}));
|
|||
}
|
|||
|
|||
acc
|
|||
});
|
|||
|
|||
let bank_items = items.into_iter()
|
|||
.filter_map(|item| {
|
|||
match item.location {
|
|||
ItemLocation::Bank{name, ..} => Some((item.id, item.item, name)),
|
|||
_ => None,
|
|||
}
|
|||
})
|
|||
.fold(BTreeMap::new(), |mut acc, (id, item, name)| {
|
|||
acc.entry(name).or_insert(Vec::new()).push((id, item));
|
|||
acc
|
|||
})
|
|||
.into_iter()
|
|||
.map(|(bank_name, bank_items)| {
|
|||
let mut stacked_bank_items = bank_items.into_iter()
|
|||
.fold(Vec::new(), |mut acc, (id, bank_item)| {
|
|||
if bank_item.is_stackable() {
|
|||
let existing_item = acc.iter_mut()
|
|||
.find(|item| {
|
|||
if let (BankItem::Stacked(stacked_bank_item), &ItemDetail::Tool(ref tool)) = (item, &bank_item) {
|
|||
stacked_bank_item.tool == *tool
|
|||
}
|
|||
else {
|
|||
false
|
|||
}
|
|||
});
|
|||
match existing_item {
|
|||
Some(item) => {
|
|||
if let BankItem::Stacked(ref mut stacked_bank_item) = item {
|
|||
stacked_bank_item.entity_ids.push(id);
|
|||
}
|
|||
}
|
|||
None => {
|
|||
if let ItemDetail::Tool(tool) = bank_item {
|
|||
acc.push(BankItem::Stacked(StackedBankItem {
|
|||
entity_ids: vec![id],
|
|||
item_id: self.next_global_item_id(),
|
|||
tool: tool,
|
|||
}));
|
|||
}
|
|||
},
|
|||
}
|
|||
}
|
|||
else {
|
|||
acc.push(BankItem::Individual(IndividualBankItem {
|
|||
entity_id: id,
|
|||
item_id: self.next_global_item_id(),
|
|||
item: bank_item,
|
|||
}));
|
|||
}
|
|||
|
|||
acc
|
|||
});
|
|||
(bank_name, CharacterBank::new(stacked_bank_items))
|
|||
})
|
|||
.collect::<BTreeMap<_, _>>();
|
|||
let inventory = CharacterInventory::new(inventory_items.into_iter().map(|(_k, v)| v).take(30).collect());
|
|||
self.character_inventory.insert(character.id, inventory);
|
|||
self.character_bank.insert(character.id, bank_items);
|
|||
}
|
|||
|
|||
pub fn add_character_to_room(&mut self, room_id: RoomId, character: &CharacterEntity, area_client: AreaClient) {
|
|||
let base_inventory_id = ((area_client.local_client.id() as u32) << 21) | 0x10000;
|
|||
let inventory = self.character_inventory.get_mut(&character.id).unwrap();
|
|||
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).unwrap().get_mut(&BankName("".to_string()));
|
|||
match default_bank {
|
|||
Some(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());
|
|||
|
|||
let mut inc = 0xF0000000;
|
|||
self.room_item_id_counter.entry(room_id).or_insert(Box::new(move || {
|
|||
inc += 1;
|
|||
ClientItemId(inc)
|
|||
}));
|
|||
}
|
|||
|
|||
pub fn get_character_inventory(&self, character: &CharacterEntity) -> Result<&CharacterInventory, ItemManagerError> {
|
|||
Ok(self.character_inventory.get(&character.id)
|
|||
.ok_or(ItemManagerError::NoCharacter(character.id))?)
|
|||
}
|
|||
|
|||
pub fn get_character_bank(&self, character: &CharacterEntity) -> Result<&CharacterBank, ItemManagerError> {
|
|||
Ok(self.character_bank
|
|||
.get(&character.id)
|
|||
.ok_or(ItemManagerError::NoCharacter(character.id))?
|
|||
.get(&BankName("".to_string()))
|
|||
.unwrap()) // TODO: make an error
|
|||
}
|
|||
|
|||
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() {
|
|||
self.room_floor.remove(room);
|
|||
}
|
|||
});
|
|||
}
|
|||
|
|||
pub fn get_floor_item_by_id(&self, character: &CharacterEntity, item_id: ClientItemId) -> Result<&FloorItem, ItemManagerError> {
|
|||
let local_floor = self.character_floor.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
|
|||
let room = self.character_room.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
|
|||
let shared_floor = self.room_floor.get(room).ok_or(ItemManagerError::NoCharacter(character.id))?;
|
|||
|
|||
local_floor.get_item_by_id(item_id)
|
|||
.or_else(|| {
|
|||
shared_floor.get_item_by_id(item_id)
|
|||
})
|
|||
.ok_or(ItemManagerError::NoSuchItemId(item_id))
|
|||
}
|
|||
|
|||
pub async fn character_picks_up_item<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &mut CharacterEntity, item_id: ClientItemId)
|
|||
-> Result<TriggerCreateItem, ItemManagerError> {
|
|||
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 floor_item = local_floor.get_item_handle_by_id(item_id)
|
|||
.or_else(|| {
|
|||
shared_floor.get_item_handle_by_id(item_id)
|
|||
})
|
|||
.ok_or(ItemManagerError::NoSuchItemId(item_id))?;
|
|||
|
|||
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);
|
|||
match new_inventory_item {
|
|||
Some((new_inventory_item, slot)) => {
|
|||
entity_gateway.change_item_location(
|
|||
&new_inventory_item.entity_id,
|
|||
ItemLocation::Inventory {
|
|||
character_id: character.id,
|
|||
slot: slot.0,
|
|||
equipped: false,
|
|||
}
|
|||
).await;
|
|||
},
|
|||
None => {
|
|||
return Err(ItemManagerError::CouldNotAddToInventory(item_id));
|
|||
},
|
|||
}
|
|||
TriggerCreateItem::Yes
|
|||
},
|
|||
Some(FloorItem::Stacked(stacked_floor_item)) => {
|
|||
let new_inventory_item = inventory.pick_up_stacked_floor_item(&stacked_floor_item);
|
|||
println!("new inv item! {:?}", new_inventory_item);
|
|||
|
|||
match new_inventory_item {
|
|||
Some((new_inventory_item, slot)) => {
|
|||
for entity_id in &new_inventory_item.entity_ids {
|
|||
entity_gateway.change_item_location(
|
|||
&entity_id,
|
|||
ItemLocation::Inventory {
|
|||
character_id: character.id,
|
|||
slot: slot.0,
|
|||
equipped: false,
|
|||
}
|
|||
).await;
|
|||
}
|
|||
|
|||
if stacked_floor_item.count() != new_inventory_item.count() {
|
|||
TriggerCreateItem::No
|
|||
}
|
|||
else {
|
|||
TriggerCreateItem::Yes
|
|||
}
|
|||
},
|
|||
None => {
|
|||
return Err(ItemManagerError::CouldNotAddToInventory(item_id));
|
|||
}
|
|||
}
|
|||
},
|
|||
Some(FloorItem::Meseta(meseta_floor_item)) => {
|
|||
if character.meseta >= 999999 {
|
|||
return Err(ItemManagerError::CouldNotAddToInventory(item_id));
|
|||
}
|
|||
character.meseta = std::cmp::min(character.meseta + meseta_floor_item.meseta.0, 999999);
|
|||
entity_gateway.save_character(&character).await;
|
|||
TriggerCreateItem::No
|
|||
},
|
|||
None => {
|
|||
return Err(ItemManagerError::CouldNotAddToInventory(item_id));
|
|||
}
|
|||
};
|
|||
|
|||
floor_item.remove_from_floor();
|
|||
Ok(trigger_create_item)
|
|||
}
|
|||
|
|||
pub async fn enemy_drop_item_on_local_floor<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &CharacterEntity, item_drop: ItemDrop) -> Result<&FloorItem, ItemManagerError> {
|
|||
let room_id = self.character_room.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
|
|||
|
|||
enum ItemOrMeseta {
|
|||
Individual(ItemDetail),
|
|||
Stacked(Tool),
|
|||
Meseta(Meseta)
|
|||
}
|
|||
|
|||
let item = match item_drop.item {
|
|||
ItemDropType::Weapon(w) => ItemOrMeseta::Individual(ItemDetail::Weapon(w)),
|
|||
ItemDropType::Armor(w) => ItemOrMeseta::Individual(ItemDetail::Armor(w)),
|
|||
ItemDropType::Shield(w) => ItemOrMeseta::Individual(ItemDetail::Shield(w)),
|
|||
ItemDropType::Unit(w) => ItemOrMeseta::Individual(ItemDetail::Unit(w)),
|
|||
ItemDropType::TechniqueDisk(w) => ItemOrMeseta::Individual(ItemDetail::TechniqueDisk(w)),
|
|||
ItemDropType::Mag(w) => ItemOrMeseta::Individual(ItemDetail::Mag(w)),
|
|||
//ItemDropType::IndividualTool(t) => ItemOrMeseta::Individual(ItemDetail::Tool(t)),
|
|||
//ItemDropType::StackedTool(t, _) => ItemOrMeseta::Stacked(t),
|
|||
ItemDropType::Tool(t) if t.tool.is_stackable() => ItemOrMeseta::Stacked(t),
|
|||
ItemDropType::Tool(t) if !t.tool.is_stackable() => ItemOrMeseta::Individual(ItemDetail::Tool(t)),
|
|||
ItemDropType::Meseta(m) => ItemOrMeseta::Meseta(Meseta(m)),
|
|||
_ => unreachable!() // rust isnt smart enough to see that the conditional on tool catches everything
|
|||
};
|
|||
|
|||
let item_id = self.room_item_id_counter.get_mut(room_id).ok_or(ItemManagerError::NoCharacter(character.id))?();
|
|||
let floor_item = match item {
|
|||
ItemOrMeseta::Individual(item_detail) => {
|
|||
let entity = entity_gateway.create_item(NewItemEntity {
|
|||
item: item_detail.clone(),
|
|||
location: ItemLocation::LocalFloor {
|
|||
character_id: character.id,
|
|||
map_area: item_drop.map_area,
|
|||
x: item_drop.x,
|
|||
y: item_drop.y,
|
|||
z: item_drop.z,
|
|||
}
|
|||
}).await.ok_or(ItemManagerError::EntityGatewayError)?;
|
|||
FloorItem::Individual(IndividualFloorItem {
|
|||
entity_id: entity.id,
|
|||
item_id: item_id,
|
|||
item: item_detail,
|
|||
map_area: item_drop.map_area,
|
|||
x: item_drop.x,
|
|||
y: item_drop.y,
|
|||
z: item_drop.z,
|
|||
})
|
|||
},
|
|||
ItemOrMeseta::Stacked(tool) => {
|
|||
let entity = entity_gateway.create_item(NewItemEntity {
|
|||
item: ItemDetail::Tool(tool),
|
|||
location: ItemLocation::LocalFloor {
|
|||
character_id: character.id,
|
|||
map_area: item_drop.map_area,
|
|||
x: item_drop.x,
|
|||
y: item_drop.y,
|
|||
z: item_drop.z,
|
|||
}
|
|||
}).await.ok_or(ItemManagerError::EntityGatewayError)?;
|
|||
FloorItem::Stacked(StackedFloorItem {
|
|||
entity_ids: vec![entity.id],
|
|||
item_id: item_id,
|
|||
tool: tool,
|
|||
map_area: item_drop.map_area,
|
|||
x: item_drop.x,
|
|||
y: item_drop.y,
|
|||
z: item_drop.z,
|
|||
})
|
|||
},
|
|||
ItemOrMeseta::Meseta(meseta) => {
|
|||
FloorItem::Meseta(MesetaFloorItem {
|
|||
item_id: item_id,
|
|||
meseta: meseta,
|
|||
map_area: item_drop.map_area,
|
|||
x: item_drop.x,
|
|||
y: item_drop.y,
|
|||
z: item_drop.z,
|
|||
})
|
|||
},
|
|||
};
|
|||
|
|||
self.character_floor.entry(character.id).or_insert(RoomFloorItems::new()).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)
|
|||
}
|
|||
|
|||
pub async fn player_drop_item_on_shared_floor<EG: EntityGateway>(&mut self,
|
|||
entity_gateway: &mut EG,
|
|||
character: &CharacterEntity,
|
|||
//inventory_item: InventoryItem,
|
|||
item_id: ClientItemId,
|
|||
item_drop_location: (MapArea, f32, f32, f32))
|
|||
-> Result<(), ItemManagerError> {
|
|||
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 dropped_inventory_item = inventory.take_item_by_id(item_id).ok_or(ItemManagerError::NoSuchItemId(item_id))?;
|
|||
|
|||
match dropped_inventory_item {
|
|||
InventoryItem::Individual(individual_inventory_item) => {
|
|||
let individual_floor_item = shared_floor.drop_individual_inventory_item(individual_inventory_item, item_drop_location);
|
|||
entity_gateway.change_item_location(
|
|||
&individual_floor_item.entity_id,
|
|||
ItemLocation::SharedFloor {
|
|||
map_area: item_drop_location.0,
|
|||
x: item_drop_location.1,
|
|||
y: item_drop_location.2,
|
|||
z: item_drop_location.3,
|
|||
}
|
|||
).await;
|
|||
},
|
|||
InventoryItem::Stacked(stacked_inventory_item) => {
|
|||
let stacked_floor_item = shared_floor.drop_stacked_inventory_item(stacked_inventory_item, item_drop_location);
|
|||
for entity_id in &stacked_floor_item.entity_ids {
|
|||
entity_gateway.change_item_location(
|
|||
entity_id,
|
|||
ItemLocation::SharedFloor {
|
|||
map_area: item_drop_location.0,
|
|||
x: item_drop_location.1,
|
|||
y: item_drop_location.2,
|
|||
z: item_drop_location.3,
|
|||
}
|
|||
).await;
|
|||
}
|
|||
},
|
|||
}
|
|||
|
|||
Ok(())
|
|||
}
|
|||
|
|||
pub async fn player_drops_meseta_on_shared_floor<EG: EntityGateway>(&mut self,
|
|||
entity_gateway: &mut EG,
|
|||
character: &mut CharacterEntity,
|
|||
drop_location: ItemDropLocation,
|
|||
amount: u32)
|
|||
-> Result<FloorItem, ItemManagerError> {
|
|||
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))?;
|
|||
if character.meseta <= amount {
|
|||
return Err(ItemManagerError::CouldNotDropMeseta)
|
|||
}
|
|||
character.meseta -= amount;
|
|||
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,
|
|||
meseta: Meseta(amount),
|
|||
map_area: drop_location.map_area,
|
|||
x: drop_location.x,
|
|||
y: 0.0,
|
|||
z: drop_location.z,
|
|||
});
|
|||
|
|||
shared_floor.add_item(floor_item.clone());
|
|||
Ok(floor_item)
|
|||
}
|
|||
|
|||
pub async fn player_drops_partial_stack_on_shared_floor<EG: EntityGateway>(&mut self,
|
|||
entity_gateway: &mut EG,
|
|||
character: &CharacterEntity,
|
|||
//inventory_item: InventoryItem,
|
|||
item_id: ClientItemId,
|
|||
drop_location: ItemDropLocation,
|
|||
amount: usize)
|
|||
-> Result<&StackedFloorItem, ItemManagerError> {
|
|||
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 item_to_split = inventory.get_item_handle_by_id(item_id).ok_or(ItemManagerError::NoSuchItemId(item_id))?;
|
|||
|
|||
let new_item_id = self.room_item_id_counter.get_mut(room_id).ok_or(ItemManagerError::NoCharacter(character.id))?();
|
|||
let stacked_floor_item = shared_floor.drop_partial_stacked_inventory_item(item_to_split, amount, new_item_id, (drop_location.map_area, drop_location.x, 0.0, drop_location.z))
|
|||
.ok_or(ItemManagerError::CouldNotSplitItem(item_id))?;
|
|||
|
|||
for entity_id in &stacked_floor_item.entity_ids {
|
|||
entity_gateway.change_item_location(
|
|||
entity_id,
|
|||
ItemLocation::SharedFloor {
|
|||
map_area: drop_location.map_area,
|
|||
x: drop_location.x,
|
|||
y: 0.0,
|
|||
z: drop_location.z,
|
|||
}
|
|||
).await;
|
|||
}
|
|||
|
|||
Ok(stacked_floor_item)
|
|||
}
|
|||
|
|||
pub async fn player_consumes_tool<EG: EntityGateway>(&mut self,
|
|||
entity_gateway: &mut EG,
|
|||
character: &CharacterEntity,
|
|||
item_id: ClientItemId,
|
|||
amount: usize)
|
|||
-> Result<ItemDetail, ItemManagerError> {
|
|||
let inventory = self.character_inventory.get_mut(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
|
|||
let used_item = inventory.get_item_handle_by_id(item_id).ok_or(ItemManagerError::NoSuchItemId(item_id))?;
|
|||
let consumed_item = used_item.consume(amount)?;
|
|||
|
|||
for entity_id in consumed_item.entity_ids {
|
|||
entity_gateway.change_item_location(&entity_id,
|
|||
ItemLocation::Consumed).await;
|
|||
}
|
|||
|
|||
Ok(consumed_item.item)
|
|||
}
|
|||
|
|||
pub async fn player_deposits_item<EG: EntityGateway>(&mut self,
|
|||
entity_gateway: &mut EG,
|
|||
character: &CharacterEntity,
|
|||
item_id: ClientItemId,
|
|||
amount: usize)
|
|||
-> Result<(), ItemManagerError> {
|
|||
Ok(())
|
|||
}
|
|||
|
|||
pub async fn player_withdraws_item<EG: EntityGateway>(&mut self,
|
|||
entity_gateway: &mut EG,
|
|||
character: &CharacterEntity,
|
|||
item_id: ClientItemId,
|
|||
amount: usize)
|
|||
-> Result<(), ItemManagerError> {
|
|||
Ok(())
|
|||
}
|
|||
}
|
|||
@ -0,0 +1,16 @@ |
|||
mod bank;
|
|||
mod floor;
|
|||
mod inventory;
|
|||
mod manager;
|
|||
|
|||
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
|
|||
pub struct ClientItemId(pub u32);
|
|||
|
|||
//pub use inventory::InventoryItem;
|
|||
//pub use floor::FloorItem;
|
|||
pub use inventory::*;
|
|||
pub use floor::*;
|
|||
pub use bank::*;
|
|||
pub use manager::*;
|
|||
|
|||
|
|||
@ -0,0 +1,220 @@ |
|||
use elseware::common::serverstate::{ClientId, ServerState};
|
|||
use elseware::entity::gateway::{EntityGateway, InMemoryGateway};
|
|||
use elseware::entity::item;
|
|||
use elseware::ship::ship::{ShipServerState, RecvShipPacket, SendShipPacket};
|
|||
use elseware::ship::items::{ClientItemId};
|
|||
|
|||
use libpso::packet::ship::*;
|
|||
use libpso::packet::messages::*;
|
|||
|
|||
#[path = "common.rs"]
|
|||
mod common;
|
|||
use common::*;
|
|||
|
|||
#[async_std::test]
|
|||
async fn test_bank_items_sent_in_character_login() {
|
|||
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::Weapon(
|
|||
item::weapon::Weapon {
|
|||
weapon: item::weapon::WeaponType::Vulcan,
|
|||
grind: 0,
|
|||
special: None,
|
|||
attrs: [None, None, None],
|
|||
tekked: true,
|
|||
}
|
|||
),
|
|||
location: item::ItemLocation::Bank {
|
|||
character_id: char1.id,
|
|||
name: item::BankName("".to_string())
|
|||
}
|
|||
}).await;
|
|||
|
|||
let mut ship = ShipServerState::new(entity_gateway.clone());
|
|||
log_in_char(&mut ship, ClientId(1), "a1", "a").await;
|
|||
|
|||
let packets = ship.handle(ClientId(1), &RecvShipPacket::MenuSelect(MenuSelect {
|
|||
menu: BLOCK_MENU_ID,
|
|||
item: 1,
|
|||
})).await.unwrap().collect::<Vec<_>>();
|
|||
|
|||
assert!(matches!(&packets[0], (_, SendShipPacket::FullCharacter(fc)) if fc.character.bank.items[0].data1[0..3] == [0x00, 0x08, 0x04] ));
|
|||
}
|
|||
|
|||
#[async_std::test]
|
|||
async fn test_request_bank_items() {
|
|||
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..3 {
|
|||
entity_gateway.create_item(
|
|||
item::NewItemEntity {
|
|||
item: item::ItemDetail::Weapon(
|
|||
item::weapon::Weapon {
|
|||
weapon: item::weapon::WeaponType::Vulcan,
|
|||
grind: 0,
|
|||
special: None,
|
|||
attrs: [None, None, None],
|
|||
tekked: true,
|
|||
}
|
|||
),
|
|||
location: item::ItemLocation::Bank {
|
|||
character_id: char1.id,
|
|||
name: item::BankName("".to_string())
|
|||
}
|
|||
}).await;
|
|||
}
|
|||
|
|||
let mut ship = ShipServerState::new(entity_gateway.clone());
|
|||
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;
|
|||
|
|||
let packets = ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
|
|||
client: 0,
|
|||
target: 0,
|
|||
unknown: 0,
|
|||
})))).await.unwrap().collect::<Vec<_>>();
|
|||
|
|||
assert!(matches!(&packets[0], (_, SendShipPacket::BankItemList (bank_item_list))
|
|||
if bank_item_list.item_count == 3
|
|||
&& bank_item_list.size == 0x18 * 3 + 0x14
|
|||
&& bank_item_list.items[0].data1[0..3] == [0x00, 0x08, 0x04]
|
|||
&& bank_item_list.items[1].data1[0..3] == [0x00, 0x08, 0x04]
|
|||
&& bank_item_list.items[2].data1[0..3] == [0x00, 0x08, 0x04]
|
|||
));
|
|||
}
|
|||
|
|||
|
|||
#[async_std::test]
|
|||
async fn test_request_stacked_bank_items() {
|
|||
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..3 {
|
|||
entity_gateway.create_item(
|
|||
item::NewItemEntity {
|
|||
item: item::ItemDetail::Tool (
|
|||
item::tool::Tool {
|
|||
tool: item::tool::ToolType::Monomate,
|
|||
}
|
|||
),
|
|||
location: item::ItemLocation::Bank {
|
|||
character_id: char1.id,
|
|||
name: item::BankName("".to_string())
|
|||
}
|
|||
}).await;
|
|||
}
|
|||
|
|||
let mut ship = ShipServerState::new(entity_gateway.clone());
|
|||
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;
|
|||
|
|||
let packets = ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
|
|||
client: 0,
|
|||
target: 0,
|
|||
unknown: 0,
|
|||
})))).await.unwrap().collect::<Vec<_>>();
|
|||
|
|||
assert!(matches!(&packets[0], (_, SendShipPacket::BankItemList (bank_item_list))
|
|||
if bank_item_list.item_count == 1
|
|||
&& bank_item_list.size == 0x18 + 0x14
|
|||
&& bank_item_list.items[0].data1[0..3] == [0x03, 0x00, 0x00]
|
|||
&& bank_item_list.items[0].amount == 3
|
|||
));
|
|||
}
|
|||
|
|||
|
|||
#[async_std::test]
|
|||
async fn test_request_bank_items_sorted() {
|
|||
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::Weapon(
|
|||
item::weapon::Weapon {
|
|||
weapon: item::weapon::WeaponType::Vulcan,
|
|||
grind: 0,
|
|||
special: None,
|
|||
attrs: [None, None, None],
|
|||
tekked: true,
|
|||
}
|
|||
),
|
|||
location: item::ItemLocation::Bank {
|
|||
character_id: char1.id,
|
|||
name: item::BankName("".to_string())
|
|||
}
|
|||
}).await;
|
|||
entity_gateway.create_item(
|
|||
item::NewItemEntity {
|
|||
item: item::ItemDetail::Tool (
|
|||
item::tool::Tool {
|
|||
tool: item::tool::ToolType::Monomate,
|
|||
}
|
|||
),
|
|||
location: item::ItemLocation::Bank {
|
|||
character_id: char1.id,
|
|||
name: item::BankName("".to_string())
|
|||
}
|
|||
}).await;
|
|||
entity_gateway.create_item(
|
|||
item::NewItemEntity {
|
|||
item: item::ItemDetail::Weapon(
|
|||
item::weapon::Weapon {
|
|||
weapon: item::weapon::WeaponType::Calibur,
|
|||
grind: 0,
|
|||
special: None,
|
|||
attrs: [None, None, None],
|
|||
tekked: true,
|
|||
}
|
|||
),
|
|||
location: item::ItemLocation::Bank {
|
|||
character_id: char1.id,
|
|||
name: item::BankName("".to_string())
|
|||
}
|
|||
}).await;
|
|||
|
|||
let mut ship = ShipServerState::new(entity_gateway.clone());
|
|||
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;
|
|||
|
|||
let packets = ship.handle(ClientId(1), &RecvShipPacket::DirectMessage(DirectMessage::new(0, GameMessage::BankRequest(BankRequest {
|
|||
client: 0,
|
|||
target: 0,
|
|||
unknown: 0,
|
|||
})))).await.unwrap().collect::<Vec<_>>();
|
|||
|
|||
println!("{:?}", packets);
|
|||
assert!(matches!(&packets[0], (_, SendShipPacket::BankItemList (bank_item_list))
|
|||
if bank_item_list.item_count == 3
|
|||
&& bank_item_list.size == 0x18 * 3 + 0x14
|
|||
&& bank_item_list.items[0].data1[0..3] == [0x00, 0x02, 0x04]
|
|||
&& bank_item_list.items[1].data1[0..3] == [0x00, 0x08, 0x04]
|
|||
&& bank_item_list.items[2].data1[0..3] == [0x03, 0x00, 0x00]
|
|||
));
|
|||
}
|
|||
|
|||
|
|||
//test_deposit_individual_item
|
|||
//test_deposit_stacked_item
|
|||
//test_deposit_stacked_item_with_stack_already_in_bank
|
|||
//test_deposit_stacked_item_when_full_stack_in_bank
|
|||
//test_deposit_individual_item_in_full_bank
|
|||
//test_deposit_stacked_item_in_full_bank
|
|||
//test_deposit_meseta
|
|||
//test_deposit_too_much_meseta
|
|||
//test_deposit_when_bank_has_max_meseta
|
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue