elseware/src/ship/items.rs

use std::collections::HashMap;

use libpso::character::character::InventoryItem;

use crate::entity::gateway::EntityGateway;
use crate::entity::character::CharacterEntity;
use crate::entity::item::{ItemEntity, ItemId, ItemDetail, ItemLocation};
use crate::entity::item::weapon::Weapon;
use crate::entity::item::armor::Armor;
use crate::entity::item::shield::Shield;
use crate::entity::item::unit::Unit;
use crate::entity::item::tool::Tool;
use crate::entity::item::mag::Mag;


#[derive(Debug, PartialEq)]
pub enum StackedItem {
    Individual(ItemEntity),
    Stacked(Vec<ItemEntity>),
}

#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ActiveItemId(u32);


#[derive(Debug)]
pub struct ActiveItem {
    id: ActiveItemId,
    item: StackedItem,
}

impl ActiveItem {
    pub fn as_client_bytes(&self) -> [u8; 16] {
        match &self.item {
            StackedItem::Individual(i) => {
                match &i.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(),
                }
            },
            StackedItem::Stacked(i) => {
                let len = i.len();
                match &i[0].item {
                    ItemDetail::Tool(t) => t.as_stacked_bytes(len),
                    _ => panic!(),
                }
            }
        }
    }
}

pub struct ActiveInventory(Vec<ActiveItem>);

impl ActiveInventory {
    pub fn as_client_inventory_items(&self) -> [InventoryItem; 30] {
        self.0.iter()
            .enumerate()
            .fold([InventoryItem::default(); 30], |mut inventory, (index, item)| {
                let bytes = item.as_client_bytes();
                inventory[index].data1.copy_from_slice(&bytes[0..12]);
                inventory[index].data2.copy_from_slice(&bytes[12..16]);
                inventory[index].item_id = item.id.0;

                // does this do anything?
                inventory[index].equipped = match item.item {
                    StackedItem::Individual(ItemEntity {location: ItemLocation::Inventory{ equipped: true, ..}, ..}) => 1,
                    _ => 0,
                };
                // because this actually equips the item
                inventory[index].flags |= match item.item {
                    StackedItem::Individual(ItemEntity {location: ItemLocation::Inventory{ equipped: true, ..}, ..}) => 8,
                    _ => 0,
                };
                inventory
            })
    }

    pub fn count(&self) -> usize {
        self.0.len()
    }
}

fn inventory_item_index(item: &StackedItem) -> usize {
    match item {
        StackedItem::Individual(i) => {
            match i.location {
                ItemLocation::Inventory{index: index, ..} => index,
                _ => panic!()
            }
        },
        StackedItem::Stacked(i) => {
            match i[0].location {
                ItemLocation::Inventory{index: index, ..} => index,
                _ => panic!()
            }
        }
    }
}

fn stack_items(items: Vec<ItemEntity>) -> Vec<StackedItem> {
    let mut stacks = HashMap::new();

    for item in items {
        stacks.entry(item.item.item_type()).or_insert(Vec::new()).push(item);
    }

    stacks.into_iter()
        .map(|(itype, items)| {
            match items[0].item.is_stackable() {
                true => {
                    vec![StackedItem::Stacked(items)]
                },
                false => {
                    items.into_iter().map(|i| {
                        StackedItem::Individual(i)
                    }).collect()
                }
            }
        })
        .flatten()
        .collect()
}

struct ActiveBank([Option<ActiveItemId>; 200]);

pub struct ActiveItemDatabase {
    id: u32,
}



impl ActiveItemDatabase {
    pub fn new() -> ActiveItemDatabase {
        ActiveItemDatabase {
            id: 0,
        }
    }

    fn activate_item(&mut self, item: StackedItem) -> ActiveItem {
        self.id += 1;
        ActiveItem {
            id: ActiveItemId(self.id),
            item: item,
        }
    }

    // deactivate item

    pub fn get_character_inventory<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &CharacterEntity) -> ActiveInventory {
        let items = entity_gateway.get_items_by_character(&character);
        let inventory_items = items.into_iter()
            .filter(|item| {
                match item.location {
                    ItemLocation::Inventory{..} => true,
                    _ => false,
                }
            }).collect();
        let mut stacked = stack_items(inventory_items);
        stacked.sort_by(|a, b| {
            inventory_item_index(a).partial_cmp(&inventory_item_index(b)).unwrap()
        });
        let activated = stacked.into_iter().map(|i| self.activate_item(i));
        ActiveInventory(activated.take(30).collect())
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::entity::character::CharacterEntityId;
    use crate::entity::item;
    use crate::entity::item::{ItemEntity, ItemDetail, ItemEntityId, ItemLocation};
    #[test]
    fn test_stack_items() {
        let item1 = ItemEntity {
            id: ItemEntityId(1),
            location: ItemLocation::Inventory {
                character_id: CharacterEntityId(0),
                index: 0,
                equipped: false,
            },
            item: ItemDetail::Weapon(item::weapon::Weapon {
                weapon: item::weapon::WeaponType::Saber,
                grind: 0,
                special: None,
                attrs: [None; 3],
                tekked: true,
            })
        };
        let item2 = ItemEntity {
            id: ItemEntityId(2),
            location: ItemLocation::Inventory {
                character_id: CharacterEntityId(0),
                index: 1,
                equipped: false,
            },
            item: ItemDetail::Tool(Tool {
                tool: item::tool::ToolType::Monofluid,
            })
        };
        let item3 = ItemEntity {
            id: ItemEntityId(3),
            location: ItemLocation::Inventory {
                character_id: CharacterEntityId(0),
                index: 2,
                equipped: false,
            },
            item: ItemDetail::Weapon(item::weapon::Weapon {
                weapon: item::weapon::WeaponType::Handgun,
                grind: 12,
                special: None,
                attrs: [None; 3],
                tekked: true,
            })
        };
        let item4 = ItemEntity {
            id: ItemEntityId(4),
            location: ItemLocation::Inventory {
                character_id: CharacterEntityId(0),
                index: 1,
                equipped: false,
            },
            item: ItemDetail::Tool(Tool {
                tool: item::tool::ToolType::Monofluid,
            })
        };
        let item5 = ItemEntity {
            id: ItemEntityId(5),
            location: ItemLocation::Inventory {
                character_id: CharacterEntityId(0),
                index: 1,
                equipped: false,
            },
            item: ItemDetail::Tool(Tool {
                tool: item::tool::ToolType::Monofluid,
            })
        };
        let item6 = ItemEntity {
            id: ItemEntityId(6),
            location: ItemLocation::Inventory {
                character_id: CharacterEntityId(0),
                index: 3,
                equipped: false,
            },
            item: ItemDetail::Weapon(item::weapon::Weapon {
                weapon: item::weapon::WeaponType::Handgun,
                grind: 12,
                special: None,
                attrs: [None; 3],
                tekked: true,
            })
        };
        let item7 = ItemEntity {
            id: ItemEntityId(7),
            location: ItemLocation::Inventory {
                character_id: CharacterEntityId(0),
                index: 4,
                equipped: false,
            },
            item: ItemDetail::Tool(Tool {
                tool: item::tool::ToolType::Monomate,
            })
        };
        let item8 = ItemEntity {
            id: ItemEntityId(8),
            location: ItemLocation::Inventory {
                character_id: CharacterEntityId(0),
                index: 4,
                equipped: false,
            },
            item: ItemDetail::Tool(Tool {
                tool: item::tool::ToolType::Monomate,
            })
        };
        let item9 = ItemEntity {
            id: ItemEntityId(9),
            location: ItemLocation::Inventory {
                character_id: CharacterEntityId(0),
                index: 4,
                equipped: false,
            },
            item: ItemDetail::Tool(Tool {
                tool: item::tool::ToolType::Monomate,
            })
        };
        let item_vec = vec![item1.clone(), item2.clone(), item3.clone(), item4.clone(), item5.clone(), item6.clone(), item7.clone(), item8.clone(), item9.clone()];

        let stacked = stack_items(item_vec);

        assert!(stacked.len() == 5);
        assert!(stacked.iter().filter(|k| {
            **k == StackedItem::Individual(item6.clone())
        }).count() == 1);

        assert!(stacked.iter().filter(|k| {
            **k == StackedItem::Individual(item3.clone())
        }).count() == 1);

        assert!(stacked.iter().filter(|k| {
            **k == StackedItem::Individual(item1.clone())
        }).count() == 1);

        assert!(stacked.iter().filter(|k| {
            **k == StackedItem::Stacked(vec![item2.clone(), item4.clone(), item5.clone()])
        }).count() == 1);

        assert!(stacked.iter().filter(|k| {
            **k == StackedItem::Stacked(vec![item7.clone(), item8.clone(), item9.clone()])
        }).count() == 1);
    }
}