You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

547 lines
23 KiB

4 years ago
5 years ago
2 years ago
3 years ago
2 years ago
3 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
2 years ago
4 years ago
5 years ago
5 years ago
4 years ago
4 years ago
5 years ago
5 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
3 years ago
2 years ago
  1. use std::collections::BTreeMap;
  2. use std::convert::TryInto;
  3. use futures::Future;
  4. use crate::entity::account::*;
  5. use crate::entity::character::*;
  6. use crate::entity::gateway::{EntityGateway, EntityGatewayTransaction, GatewayError};
  7. use crate::entity::item::*;
  8. use std::sync::{Arc, Mutex};
  9. // TODO: implement multiple banks
  10. pub struct InMemoryGatewayTransaction<'a> {
  11. working_gateway: InMemoryGateway,
  12. original_gateway: &'a mut InMemoryGateway,
  13. }
  14. #[async_trait::async_trait]
  15. impl<'a> EntityGatewayTransaction for InMemoryGatewayTransaction<'a> {
  16. fn gateway(&mut self) -> &mut dyn EntityGateway {
  17. &mut self.working_gateway
  18. }
  19. async fn commit(mut self: Box<Self>) -> Result<(), GatewayError> {
  20. self.original_gateway.users.lock().unwrap().clear();
  21. self.original_gateway.users.lock().unwrap().extend(self.working_gateway.users.lock().unwrap().clone());
  22. self.original_gateway.user_settings.lock().unwrap().clear();
  23. self.original_gateway.user_settings.lock().unwrap().extend(self.working_gateway.user_settings.lock().unwrap().clone());
  24. self.original_gateway.characters.lock().unwrap().clear();
  25. self.original_gateway.characters.lock().unwrap().extend(self.working_gateway.characters.lock().unwrap().clone());
  26. self.original_gateway.character_meseta.lock().unwrap().clear();
  27. self.original_gateway.character_meseta.lock().unwrap().extend(self.working_gateway.character_meseta.lock().unwrap().clone());
  28. self.original_gateway.bank_meseta.lock().unwrap().clear();
  29. self.original_gateway.bank_meseta.lock().unwrap().extend(self.working_gateway.bank_meseta.lock().unwrap().clone());
  30. self.original_gateway.items.lock().unwrap().clear();
  31. self.original_gateway.items.lock().unwrap().extend(self.working_gateway.items.lock().unwrap().clone());
  32. self.original_gateway.inventories.lock().unwrap().clear();
  33. self.original_gateway.inventories.lock().unwrap().extend(self.working_gateway.inventories.lock().unwrap().clone());
  34. self.original_gateway.banks.lock().unwrap().clear();
  35. self.original_gateway.banks.lock().unwrap().extend(self.working_gateway.banks.lock().unwrap().clone());
  36. self.original_gateway.equips.lock().unwrap().clear();
  37. self.original_gateway.equips.lock().unwrap().extend(self.working_gateway.equips.lock().unwrap().clone());
  38. self.original_gateway.mag_modifiers.lock().unwrap().clear();
  39. self.original_gateway.mag_modifiers.lock().unwrap().extend(self.working_gateway.mag_modifiers.lock().unwrap().clone());
  40. self.original_gateway.weapon_modifiers.lock().unwrap().clear();
  41. self.original_gateway.weapon_modifiers.lock().unwrap().extend(self.working_gateway.weapon_modifiers.lock().unwrap().clone());
  42. self.original_gateway.trades.lock().unwrap().clear();
  43. self.original_gateway.trades.lock().unwrap().extend(self.working_gateway.trades.lock().unwrap().clone());
  44. Ok(())
  45. }
  46. }
  47. #[derive(Clone)]
  48. pub struct InMemoryGateway {
  49. users: Arc<Mutex<BTreeMap<UserAccountId, UserAccountEntity>>>,
  50. user_settings: Arc<Mutex<BTreeMap<UserSettingsId, UserSettingsEntity>>>,
  51. characters: Arc<Mutex<BTreeMap<CharacterEntityId, CharacterEntity>>>,
  52. character_meseta: Arc<Mutex<BTreeMap<CharacterEntityId, Meseta>>>,
  53. bank_meseta: Arc<Mutex<BTreeMap<(CharacterEntityId, BankName), Meseta>>>,
  54. items: Arc<Mutex<BTreeMap<ItemEntityId, ItemEntity>>>,
  55. inventories: Arc<Mutex<BTreeMap<CharacterEntityId, InventoryEntity>>>,
  56. banks: Arc<Mutex<BTreeMap<CharacterEntityId, BankEntity>>>,
  57. equips: Arc<Mutex<BTreeMap<CharacterEntityId, EquippedEntity>>>,
  58. mag_modifiers: Arc<Mutex<BTreeMap<ItemEntityId, Vec<mag::MagModifier>>>>,
  59. weapon_modifiers: Arc<Mutex<BTreeMap<ItemEntityId, Vec<weapon::WeaponModifier>>>>,
  60. unit_modifiers: Arc<Mutex<BTreeMap<ItemEntityId, Vec<unit::UnitModifier>>>>,
  61. trades: Arc<Mutex<Vec<TradeEntity>>>,
  62. unit_modifiers: Arc<Mutex<BTreeMap<ItemEntityId, Vec<unit::UnitModifier>>>>,
  63. }
  64. impl Default for InMemoryGateway {
  65. fn default() -> InMemoryGateway {
  66. InMemoryGateway {
  67. users: Arc::new(Mutex::new(BTreeMap::new())),
  68. user_settings: Arc::new(Mutex::new(BTreeMap::new())),
  69. characters: Arc::new(Mutex::new(BTreeMap::new())),
  70. character_meseta: Arc::new(Mutex::new(BTreeMap::new())),
  71. bank_meseta: Arc::new(Mutex::new(BTreeMap::new())),
  72. items: Arc::new(Mutex::new(BTreeMap::new())),
  73. inventories: Arc::new(Mutex::new(BTreeMap::new())),
  74. banks: Arc::new(Mutex::new(BTreeMap::new())),
  75. equips: Arc::new(Mutex::new(BTreeMap::new())),
  76. mag_modifiers: Arc::new(Mutex::new(BTreeMap::new())),
  77. weapon_modifiers: Arc::new(Mutex::new(BTreeMap::new())),
  78. unit_modifiers: Arc::new(Mutex::new(BTreeMap::new())),
  79. trades: Arc::new(Mutex::new(Vec::new())),
  80. unit_modifiers: Arc::new(Mutex::new(BTreeMap::new())),
  81. }
  82. }
  83. }
  84. impl InMemoryGateway {
  85. fn apply_modifiers(&self, inventory: InventoryEntity ) -> InventoryEntity {
  86. let items = self.items.lock().unwrap();
  87. let inventory_items = inventory.items.into_iter()
  88. .map(|item| {
  89. item.map_individual(|mut item| {
  90. item.item = match item.item {
  91. ItemDetail::Weapon(mut weapon) => {
  92. if let Some(weapon_modifiers) = self.weapon_modifiers.lock().unwrap().get(&item.id) {
  93. if weapon.weapon.has_counter() {
  94. weapon.kills = Some(0);
  95. }
  96. for weapon_modifier in weapon_modifiers.iter() {
  97. weapon.apply_modifier(weapon_modifier);
  98. }
  99. }
  100. ItemDetail::Weapon(weapon)
  101. },
  102. ItemDetail::Mag(mag) => {
  103. let mut mag = mag::Mag::baby_mag(mag.color as u16);
  104. if let Some(mag_modifiers) = self.mag_modifiers.lock().unwrap().get(&item.id) {
  105. for mag_modifier in mag_modifiers.iter() {
  106. match mag_modifier {
  107. mag::MagModifier::FeedMag {food} => {
  108. if let Some(mag_feed) = items.get(food) {
  109. if let ItemDetail::Tool(mag_feed) = mag_feed.item {
  110. mag.feed(mag_feed.tool)
  111. }
  112. }
  113. },
  114. mag::MagModifier::OwnerChange(class, section_id) => {
  115. mag.change_owner(*class, *section_id)
  116. },
  117. mag::MagModifier::MagCell(mag_cell_id) => {
  118. if let Some(mag_cell) = items.get(mag_cell_id) {
  119. if let ItemDetail::Tool(mag_cell) = mag_cell.item {
  120. mag.apply_mag_cell(mag_cell.tool.try_into().unwrap()).unwrap()
  121. }
  122. }
  123. },
  124. _ => {}
  125. }
  126. }
  127. }
  128. ItemDetail::Mag(mag)
  129. },
  130. ItemDetail::Unit(mut unit) => {
  131. if let Some(unit_modifiers) = self.unit_modifiers.lock().unwrap().get(&item.id) {
  132. if unit.unit.has_counter() {
  133. unit.kills = Some(0);
  134. }
  135. for unit_modifier in unit_modifiers.iter() {
  136. unit.apply_modifier(unit_modifier);
  137. }
  138. }
  139. ItemDetail::Unit(unit)
  140. },
  141. _ => {
  142. item.item
  143. }
  144. };
  145. item
  146. })
  147. })
  148. .collect();
  149. InventoryEntity::new(inventory_items)
  150. }
  151. }
  152. #[async_trait::async_trait]
  153. impl EntityGateway for InMemoryGateway {
  154. async fn transaction<'a>(&'a mut self) -> Result<Box<dyn EntityGatewayTransaction + 'a>, GatewayError>
  155. {
  156. let working_gateway = {
  157. let users = self.users.lock().unwrap().clone();
  158. let user_settings = self.user_settings.lock().unwrap().clone();
  159. let characters = self.characters.lock().unwrap().clone();
  160. let character_meseta = self.character_meseta.lock().unwrap().clone();
  161. let bank_meseta = self.bank_meseta.lock().unwrap().clone();
  162. let items = self.items.lock().unwrap().clone();
  163. let inventories = self.inventories.lock().unwrap().clone();
  164. let banks = self.banks.lock().unwrap().clone();
  165. let equips = self.equips.lock().unwrap().clone();
  166. let mag_modifiers = self.mag_modifiers.lock().unwrap().clone();
  167. let weapon_modifiers = self.weapon_modifiers.lock().unwrap().clone();
  168. let trades = self.trades.lock().unwrap().clone();
  169. InMemoryGateway {
  170. users: Arc::new(Mutex::new(users)),
  171. user_settings: Arc::new(Mutex::new(user_settings)),
  172. characters: Arc::new(Mutex::new(characters)),
  173. character_meseta: Arc::new(Mutex::new(character_meseta)),
  174. bank_meseta: Arc::new(Mutex::new(bank_meseta)),
  175. items: Arc::new(Mutex::new(items)),
  176. inventories: Arc::new(Mutex::new(inventories)),
  177. banks: Arc::new(Mutex::new(banks)),
  178. equips: Arc::new(Mutex::new(equips)),
  179. mag_modifiers: Arc::new(Mutex::new(mag_modifiers)),
  180. weapon_modifiers: Arc::new(Mutex::new(weapon_modifiers)),
  181. trades: Arc::new(Mutex::new(trades)),
  182. }
  183. };
  184. Ok(Box::new(InMemoryGatewayTransaction {
  185. working_gateway,
  186. original_gateway: self,
  187. }))
  188. }
  189. async fn with_transaction<'a, F, Fut, R, E>(&'a mut self, func: F) -> Result<R, E>
  190. where
  191. Fut: Future<Output = Result<(Box<dyn EntityGatewayTransaction + 'a>, R), E>> + Send + 'a,
  192. F: FnOnce(Box<dyn EntityGatewayTransaction + 'a>) -> Fut + Send,
  193. R: Send,
  194. E: From<GatewayError>,
  195. {
  196. let users = self.users.lock().unwrap().clone();
  197. let user_settings = self.user_settings.lock().unwrap().clone();
  198. let characters = self.characters.lock().unwrap().clone();
  199. let character_meseta = self.character_meseta.lock().unwrap().clone();
  200. let bank_meseta = self.bank_meseta.lock().unwrap().clone();
  201. let items = self.items.lock().unwrap().clone();
  202. let inventories = self.inventories.lock().unwrap().clone();
  203. let banks = self.banks.lock().unwrap().clone();
  204. let equips = self.equips.lock().unwrap().clone();
  205. let mag_modifiers = self.mag_modifiers.lock().unwrap().clone();
  206. let weapon_modifiers = self.weapon_modifiers.lock().unwrap().clone();
  207. let trades = self.trades.lock().unwrap().clone();
  208. let working_gateway = InMemoryGateway {
  209. users: Arc::new(Mutex::new(users)),
  210. user_settings: Arc::new(Mutex::new(user_settings)),
  211. characters: Arc::new(Mutex::new(characters)),
  212. character_meseta: Arc::new(Mutex::new(character_meseta)),
  213. bank_meseta: Arc::new(Mutex::new(bank_meseta)),
  214. items: Arc::new(Mutex::new(items)),
  215. inventories: Arc::new(Mutex::new(inventories)),
  216. banks: Arc::new(Mutex::new(banks)),
  217. equips: Arc::new(Mutex::new(equips)),
  218. mag_modifiers: Arc::new(Mutex::new(mag_modifiers)),
  219. weapon_modifiers: Arc::new(Mutex::new(weapon_modifiers)),
  220. trades: Arc::new(Mutex::new(trades)),
  221. };
  222. let transaction = Box::new(InMemoryGatewayTransaction {
  223. working_gateway,
  224. original_gateway: self,
  225. });
  226. let (transaction, result) = func(transaction).await?;
  227. transaction.commit().await?;
  228. Ok(result)
  229. }
  230. async fn create_user(&mut self, user: NewUserAccountEntity) -> Result<UserAccountEntity, GatewayError> {
  231. let mut users = self.users.lock().unwrap();
  232. let id = users
  233. .iter()
  234. .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
  235. + 1;
  236. let user = UserAccountEntity {
  237. id: UserAccountId(id),
  238. username: user.username,
  239. password: user.password,
  240. guildcard: user.guildcard,
  241. team_id: user.team_id,
  242. banned_until: user.banned_until,
  243. muted_until: user.muted_until,
  244. created_at: chrono::Utc::now(),
  245. flags: user.flags,
  246. activated: user.activated,
  247. at_login: false,
  248. at_character: false,
  249. at_ship: false,
  250. };
  251. users.insert(user.id, user.clone());
  252. Ok(user)
  253. }
  254. async fn get_user_by_id(&mut self, id: UserAccountId) -> Result<UserAccountEntity, GatewayError> {
  255. let users = self.users.lock().unwrap();
  256. users.get(&id).cloned().ok_or(GatewayError::Error)
  257. }
  258. async fn get_user_by_name(&mut self, username: String) -> Result<UserAccountEntity, GatewayError> {
  259. let users = self.users.lock().unwrap();
  260. users
  261. .iter()
  262. .find(|(_, k)| k.username == username)
  263. .map(|(_, k)| k.clone())
  264. .ok_or(GatewayError::Error)
  265. }
  266. async fn save_user(&mut self, user: &UserAccountEntity) -> Result<(), GatewayError> {
  267. let mut users = self.users.lock().unwrap();
  268. users.insert(user.id, user.clone());
  269. Ok(())
  270. }
  271. async fn create_user_settings(&mut self, settings: NewUserSettingsEntity) -> Result<UserSettingsEntity, GatewayError> {
  272. let mut user_settings = self.user_settings.lock().unwrap();
  273. let id = user_settings
  274. .iter()
  275. .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
  276. + 1;
  277. let new_settings = UserSettingsEntity {
  278. id: UserSettingsId(id),
  279. user_id: settings.user_id,
  280. settings: settings.settings,
  281. };
  282. user_settings.insert(new_settings.id, new_settings.clone());
  283. Ok(new_settings)
  284. }
  285. async fn get_user_settings_by_user(&mut self, user: &UserAccountEntity) -> Result<UserSettingsEntity, GatewayError> {
  286. let user_settings = self.user_settings.lock().unwrap();
  287. user_settings
  288. .iter()
  289. .find(|(_, k)| k.user_id == user.id)
  290. .map(|(_, k)| k.clone())
  291. .ok_or(GatewayError::Error)
  292. }
  293. async fn get_characters_by_user(&mut self, user: &UserAccountEntity) -> Result<[Option<CharacterEntity>; 4], GatewayError> {
  294. let characters = self.characters.lock().unwrap();
  295. const NONE: Option<CharacterEntity> = None;
  296. let mut chars = [NONE; 4];
  297. characters
  298. .iter()
  299. .filter(|(_, c)| c.user_id == user.id)
  300. .for_each(|(_, c)| chars[c.slot as usize] = Some(c.clone()));
  301. Ok(chars)
  302. }
  303. async fn create_character(&mut self, character: NewCharacterEntity) -> Result<CharacterEntity, GatewayError> {
  304. let mut characters = self.characters.lock().unwrap();
  305. let id = characters
  306. .iter()
  307. .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
  308. + 1;
  309. let new_character = CharacterEntity {
  310. id: CharacterEntityId(id),
  311. user_id: character.user_id,
  312. slot: character.slot,
  313. name: character.name,
  314. exp: character.exp,
  315. char_class: character.char_class,
  316. section_id: character.section_id,
  317. appearance: character.appearance,
  318. techs: character.techs,
  319. config: character.config,
  320. info_board: character.info_board,
  321. guildcard: character.guildcard,
  322. materials: character.materials,
  323. tech_menu: character.tech_menu,
  324. option_flags: character.option_flags,
  325. keyboard_config: character.keyboard_config,
  326. gamepad_config: character.gamepad_config,
  327. };
  328. characters.insert(new_character.id, new_character.clone());
  329. Ok(new_character)
  330. }
  331. async fn save_character(&mut self, char: &CharacterEntity) -> Result<(), GatewayError> {
  332. let mut characters = self.characters.lock().unwrap();
  333. characters.insert(char.id, char.clone());
  334. Ok(())
  335. }
  336. async fn get_guild_card_data_by_user(&mut self, user: &UserAccountEntity) -> Result<GuildCardDataEntity, GatewayError> {
  337. Ok(GuildCardDataEntity::new(user.id))
  338. }
  339. async fn create_item(&mut self, item: NewItemEntity) -> Result<ItemEntity, GatewayError> {
  340. let mut items = self.items.lock().unwrap();
  341. let id = items
  342. .iter()
  343. .fold(0, |sum, (i, _)| std::cmp::max(sum, i.0))
  344. + 1;
  345. let new_item = ItemEntity {
  346. id: ItemEntityId(id),
  347. item: item.item,
  348. };
  349. items.insert(ItemEntityId(id), new_item.clone());
  350. Ok(new_item)
  351. }
  352. async fn add_item_note(&mut self, _item_id: &ItemEntityId, _item_note: ItemNote) -> Result<(), GatewayError> {
  353. Ok(())
  354. }
  355. async fn feed_mag(&mut self, mag_item_id: &ItemEntityId, tool_item_id: &ItemEntityId) -> Result<(), GatewayError> {
  356. self.mag_modifiers.lock().unwrap()
  357. .entry(*mag_item_id)
  358. .or_insert_with(Vec::new)
  359. .push(mag::MagModifier::FeedMag {
  360. food: *tool_item_id
  361. });
  362. Ok(())
  363. }
  364. async fn change_mag_owner(&mut self, mag_item_id: &ItemEntityId, character: &CharacterEntity) -> Result<(), GatewayError> {
  365. self.mag_modifiers.lock().unwrap()
  366. .entry(*mag_item_id)
  367. .or_insert_with(Vec::new)
  368. .push(mag::MagModifier::OwnerChange(character.char_class, character.section_id));
  369. Ok(())
  370. }
  371. async fn use_mag_cell(&mut self, mag_item_id: &ItemEntityId, mag_cell_id: &ItemEntityId) -> Result<(), GatewayError> {
  372. self.mag_modifiers.lock().unwrap()
  373. .entry(*mag_item_id)
  374. .or_insert_with(Vec::new)
  375. .push(mag::MagModifier::MagCell(*mag_cell_id));
  376. Ok(())
  377. }
  378. async fn add_weapon_modifier(&mut self, item_id: &ItemEntityId, modifier: weapon::WeaponModifier) -> Result<(), GatewayError> {
  379. self.weapon_modifiers.lock().unwrap()
  380. .entry(*item_id)
  381. .or_insert_with(Vec::new)
  382. .push(modifier);
  383. Ok(())
  384. }
  385. async fn add_unit_modifier(&mut self, item_id: &ItemEntityId, modifier: unit::UnitModifier) -> Result<(), GatewayError> {
  386. self.unit_modifiers.lock().unwrap()
  387. .entry(*item_id)
  388. .or_insert_with(Vec::new)
  389. .push(modifier);
  390. Ok(())
  391. }
  392. async fn get_character_inventory(&mut self, char_id: &CharacterEntityId) -> Result<InventoryEntity, GatewayError> {
  393. let inventories = self.inventories.lock().unwrap();
  394. Ok(inventories
  395. .iter()
  396. .find(|(id, _)| **id == *char_id)
  397. .map(|(_, inv)| inv.clone())
  398. .map(|inv| self.apply_modifiers(inv))
  399. .unwrap_or_default())
  400. }
  401. async fn get_character_bank(&mut self, char_id: &CharacterEntityId, _bank_name: &BankName) -> Result<BankEntity, GatewayError> {
  402. let banks = self.banks.lock().unwrap();
  403. Ok(banks
  404. .iter()
  405. .find(|(id, _)| **id == *char_id)
  406. .map(|(_, b)| b.clone())
  407. .unwrap_or_default())
  408. }
  409. async fn set_character_inventory(&mut self, char_id: &CharacterEntityId, inventory: &InventoryEntity) -> Result<(), GatewayError> {
  410. let mut inventories = self.inventories.lock().unwrap();
  411. inventories.insert(*char_id, inventory.clone());
  412. Ok(())
  413. }
  414. // TOOD: impl bank name
  415. async fn set_character_bank(&mut self, char_id: &CharacterEntityId, bank: &BankEntity, _bank_name: &BankName) -> Result<(), GatewayError> {
  416. let mut banks = self.banks.lock().unwrap();
  417. banks.insert(*char_id, bank.clone());
  418. Ok(())
  419. }
  420. async fn get_character_equips(&mut self, char_id: &CharacterEntityId) -> Result<EquippedEntity, GatewayError> {
  421. let equips = self.equips.lock().unwrap();
  422. Ok(equips
  423. .iter()
  424. .find(|(id, _)| **id == *char_id)
  425. .map(|(_, inv)| inv.clone())
  426. .unwrap_or_default())
  427. }
  428. async fn set_character_equips(&mut self, char_id: &CharacterEntityId, equipped: &EquippedEntity) -> Result<(), GatewayError> {
  429. let mut equips = self.equips.lock().unwrap();
  430. equips.insert(*char_id, equipped.clone());
  431. Ok(())
  432. }
  433. async fn set_character_meseta(&mut self, char_id: &CharacterEntityId, meseta: Meseta) -> Result<(), GatewayError> {
  434. let mut character_meseta = self.character_meseta.lock().unwrap();
  435. character_meseta.insert(*char_id, meseta);
  436. Ok(())
  437. }
  438. async fn get_character_meseta(&mut self, char_id: &CharacterEntityId) -> Result<Meseta, GatewayError> {
  439. let mut character_meseta = self.character_meseta.lock().unwrap();
  440. if let Some(meseta) = character_meseta.get_mut(char_id) {
  441. Ok(*meseta)
  442. }
  443. else {
  444. Err(GatewayError::Error)
  445. }
  446. }
  447. async fn set_bank_meseta(&mut self, char_id: &CharacterEntityId, bank: &BankName, meseta: Meseta) -> Result<(), GatewayError> {
  448. let mut bank_meseta = self.bank_meseta.lock().unwrap();
  449. bank_meseta.insert((*char_id, bank.clone()), meseta);
  450. Ok(())
  451. }
  452. async fn get_bank_meseta(&mut self, char_id: &CharacterEntityId, bank: &BankName) -> Result<Meseta, GatewayError> {
  453. let mut bank_meseta = self.bank_meseta.lock().unwrap();
  454. if let Some(meseta) = bank_meseta.get_mut(&(*char_id, bank.clone())) {
  455. Ok(*meseta)
  456. }
  457. else {
  458. Err(GatewayError::Error)
  459. }
  460. }
  461. async fn create_trade(&mut self, char_id1: &CharacterEntityId, char_id2: &CharacterEntityId) -> Result<TradeEntity, GatewayError> {
  462. let mut trades = self.trades.lock().unwrap();
  463. let id = trades.len() as u32;
  464. let new_trade = TradeEntity {
  465. id: TradeId(id),
  466. character1: *char_id1,
  467. character2: *char_id2,
  468. };
  469. trades.push(new_trade.clone());
  470. Ok(new_trade)
  471. }
  472. async fn increment_kill_counter(&mut self, item_id: &ItemEntityId) -> Result<(), GatewayError> {
  473. if let Some(item_entity) = self.items.lock().unwrap().get_mut(item_id) {
  474. item_entity.increase_kill_counter();
  475. }
  476. Ok(())
  477. }
  478. async fn get_kill_counter() {
  479. println!("src/entity/gateway/inmemory.rs::get_kill_counter() - unimplemented!");
  480. }
  481. async fn set_kill_counter() {
  482. println!("src/entity/gateway/inmemory.rs::set_kill_counter() - unimplemented!");
  483. }
  484. }