☰

Greasy Fork is available in English.

Dead Frontier - API

Dead Frontier API

Този скрипт не може да бъде инсталиран директно. Това е библиотека за други скриптове и може да бъде използвана с мета-директива // @require https://update.greatest.deepsurf.us/scripts/441829/1586829/Dead%20Frontier%20-%20API.js 

  1. // ==UserScript==
  2. // @name        Dead Frontier - API
  3. // @namespace   Dead Frontier - Shrike00
  4. // @match       *://fairview.deadfrontier.com/onlinezombiemmo/index.php?page=24
  5. // @match       *://fairview.deadfrontier.com/onlinezombiemmo/index.php?page=25
  6. // @match       *://fairview.deadfrontier.com/onlinezombiemmo/index.php?page=35
  7. // @grant       none
  8. // @version     0.1.32
  9. // @author      Shrike00
  10. // @description Dead Frontier API
  11. // ==/UserScript==
  12.  
  13. // Changelog
  14. // 0.1.32 - May 10, 2025
  15. // - Change: Added empty backpack function.
  16. // 0.1.31 - April 25, 2025
  17. // - Bugfix: Fixed backpack functions.
  18. // 0.1.30 - April 25, 2025
  19. // - Change: Added useBackpackItem.
  20. // 0.1.29 - April 18, 2025
  21. // - Change: Updated itemcat to itemtype.
  22. // 0.1.28 - February 22, 2025
  23. // - Feature: Added discardBackpackItem.
  24. // 0.1.27 - February 21, 2025
  25. // - Change: Added length limit to search string.
  26. // 0.1.26 - February 21, 2025
  27. // - Change: Rollback 0.1.25
  28. // 0.1.25 - February 21, 2025
  29. // - Change: Encoded search strings with encodeURI.
  30. // 0.1.24 - February 19, 2025
  31. // - Change: Added data and raw_data getters to PlayerValues.
  32. // 0.1.23 - February 7, 2025
  33. // - Change: Fixed(?) implantsToImplants and added locking and unlocking inventory and backpack slots.
  34. // 0.1.22 - February 7, 2025
  35. // - Change: Added implantsToImplants.
  36. // 0.1.21 - February 7, 2025
  37. // - Change: Added backpackToImplants.
  38. // 0.1.20 - February 7, 2025
  39. // - Change: Removed window references and called in implicit scope to account for sandboxing (for non-@grant none scripts)
  40. // - Feature: Added implant mutation.
  41. // 0.1.19 - December 16, 2024
  42. // - Change: Replaced references to webCall with webCall to account for const change.
  43. // 0.1.18 - November 8, 2024
  44. // - Bugfix: Fixed backpack slot count/iterating through backpack when not wearing one.
  45. // - Bugfix: Fixed requesting rename data.
  46. // 0.1.17 - November 4, 2024
  47. // - Feature: Added search by category to MarketCache.
  48. // 0.1.16 - October 27, 2024
  49. // - Feature: Added CollectionBook.
  50. // 0.1.15 - October 25, 2024
  51. // - Bugfix: Added support for private/public selling entries.
  52. // 0.1.14 - October 24, 2024
  53. // - Bugfix: Added credits to stackable items.
  54. // - Feature: Added support for searching renamed items that is completely separate from searching regular items.
  55. // 0.1.13 - May 2, 2024
  56. // - Change: Updated tradezone ids.
  57. // 0.1.12 - April 11, 2024
  58. // - Bugfix: Fixed querying backpack from uservars.
  59. // 0.1.11 - February 25, 2024
  60. // - Bugfix: Storage moves for larger than max stacked ammo should now work properly.
  61. // 0.1.10 - February 22, 2024
  62. // - Change: Added support for backpacks.
  63. // - Change: Added mastercrafting.
  64. // 0.1.9 - February 22, 2024
  65. // - Change: Added generic market search strings that should work for most items.
  66. // 0.1.8 - February 21, 2024
  67. // - Change: Added property to Item for renames, added backpack functions for querying and moving items.
  68. // 0.1.7 - December 15, 2023
  69. // - Change: Added search string for all stockings.
  70. // 0.1.6 - October 24, 2023
  71. // - Bugfix: Item should now correctly handle cooked item names.
  72. // 0.1.5 - August 19, 2023
  73. // - Bugfix: Bank now checks for presence of bank elements.
  74. // 0.1.4 - March 21, 2023
  75. // - Change: Storage moves no longer query the storage before sending the move.
  76. // 0.1.3 - March 19, 2023
  77. // - Change: Added ammo, inventory, and selling entry counts to MarketItems.
  78. // 0.1.2 - March 15, 2023
  79. // - Change: Added additional helper functions.
  80. // - Change: Added parameter to some functions that talk to the backend. Can now choose to not update UI on return.
  81. // 0.1.1 - December 24, 2022
  82. // - Change: Added Christmas Stocking 2022.
  83.  
  84. // base.js
  85. // flshToArr(flashStr, padding, callback) takes a response and puts it to a object or sends it to a callback.
  86. // updateIntoArr(flshArr, baseArr) copies the elements of the first array into the second.
  87. // updateAllFields() updates weapon sidebar, vital stats/boosts sidebar.
  88. // renderAvatarUpdate(elem, customVars) updates character avatar.
  89. // inventory.js
  90. // populateStorage(), populateInventory(), populateImplants(), populateCharacterInventory() all update their elements
  91. // from userVars.
  92. // reloadStorageData() and reloadInventoryData() load from the backend before calling the populate functions.
  93. // TODO: Fix storage no ui updating (need to move response from storage move into local variables)
  94. const DeadFrontier = (function() {
  95. 	'use strict';
  96. 	// TODO: Remove request methods, always re-query. Also remove uservars, global data?
  97. 	// TODO: Figure out how to request/force update global data.
  98. 	// Helpers
  99.  
  100. 	function typeSplit(type) {
  101. 		// Splits item id into components.
  102. 		return type.split("_");
  103. 	}
  104.  
  105. 	function stringGroups(s, size) {
  106. 		// Splits string into array of substrings of length size or smaller.
  107. 		const output = [];
  108. 		for (let i = 0; i < s.length; i += size) {
  109. 			output.push(s.substring(i, i + size));
  110. 		}
  111. 		return output;
  112. 	}
  113.  
  114. 	function responseToMap(response) {
  115. 		// Converts raw string response to Map.
  116. 		const map = new Map();
  117. 		const pairs = response.split("&");
  118. 		for (let i = 0; i < pairs.length; i++) {
  119. 			const [key, value] = pairs[i].split("=");
  120. 			map.set(key, value);
  121. 		}
  122. 		map.delete(""); // Removes undefined key, since response leads with an ampersand (&).
  123. 		return map;
  124. 	}
  125.  
  126. 	function updateCashBank(cash_on_hand, cash_in_bank) {
  127. 		// Updates cash and bank amount elements with provided values.
  128. 		const cash = "Cash: $"+nf.format(cash_on_hand);
  129. 		const bank = "Bank: $"+nf.format(cash_in_bank);
  130. 		$(".heldCash").each(function(cashKey, cashVal) {
  131. 			$(cashVal).text(cash).attr("data-cash", cash);
  132. 		});
  133. 		const bank_element_exists = $("#bankCash").length > 0;
  134. 		if (bank_element_exists){
  135. 			$("#bankCash").text(bank).attr("data-cash", bank);
  136. 		}
  137. 	}
  138.  
  139. 	function promiseWait(dt) {
  140. 		// Returns promise that waits the given number of ms.
  141. 		const promise = new Promise(function(resolve, reject) {
  142. 			setTimeout(resolve, dt);
  143. 		});
  144. 		return promise;
  145. 	}
  146.  
  147. 	function queryObjectByKey(obj, key, dt = 100) {
  148. 		// Returns promise that resolves with the object once it contains the given key.
  149. 		if (obj[key] !== undefined) {
  150. 			return Promise.resolve(obj);
  151. 		}
  152. 		const promise = new Promise(function(resolve, reject) {
  153. 			const check = setInterval(function() {
  154. 				const key_exists = obj[key] !== undefined;
  155. 				if (key_exists) {
  156. 					clearInterval(check);
  157. 					resolve(obj);
  158. 				}
  159. 			}, dt);
  160. 		});
  161. 		return promise;
  162. 	}
  163.  
  164. 	function queryObjectByKeys(obj, keys, dt) {
  165. 		// Returns promise that resolves with the object once it contains all the given keys.
  166. 		const unique_keys = new Set(keys);
  167. 		const promises = Array.from(unique_keys).map((key) => queryObjectForKey(obj, key, dt));
  168. 		return Promise.all(promises).then(() => obj);
  169. 	}
  170.  
  171. 	function isMastercrafted(item) {
  172. 		// Returns if item is mastercrafted.
  173. 		const properties = item.properties;
  174. 		const category = item.category
  175. 		const is_mastercrafted = properties.has("mastercrafted") && properties.get("mastercrafted") === true;
  176. 		const is_enhanceable = isEnhanceable(item);
  177. 		return is_enhanceable && is_mastercrafted;
  178. 	}
  179.  
  180. 	function isNearGodcrafted(item) {
  181. 		// Returns if item is near-godcrafted.
  182. 		const properties = item.properties;
  183. 		const category = item.category;
  184. 		const is_mastercrafted = properties.has("mastercrafted") && properties.get("mastercrafted") === true;
  185. 		if (category === ItemCategory.WEAPON) {
  186. 			const total_stats = properties.get("accuracy") + properties.get("reloading") + properties.get("critical_hit");
  187. 			return total_stats === 23;
  188. 		} else if (category === ItemCategory.ARMOUR) {
  189. 			const total_stats = properties.get("agility") + properties.get("endurance");
  190. 			return total_stats === 47;
  191. 		} else if (category === ItemCategory.BACKPACK) {
  192. 			return properties.get("bonus_slots") === 2;
  193. 		} else {
  194. 			return false;
  195. 		}
  196. 	}
  197.  
  198. 	function isGodcrafted(item) {
  199. 		// Returns if item is godcrafted.
  200. 		const properties = item.properties;
  201. 		const category = item.category;
  202. 		const is_mastercrafted = properties.has("mastercrafted") && properties.get("mastercrafted") === true;
  203. 		const godcrafted_weapon = is_mastercrafted && category === ItemCategory.WEAPON
  204. 			&& properties.get("accuracy") === 8 && properties.get("reloading") === 8 && properties.get("critical_hit") === 8;
  205. 		const godcrafted_armour = is_mastercrafted && category === ItemCategory.ARMOUR
  206. 			&& properties.get("agility") === 24 && properties.get("endurance") === 24;
  207. 		const godcrafted_backpack = is_mastercrafted && category === ItemCategory.BACKPACK
  208. 			&& properties.get("bonus_slots") === 3;
  209. 		return godcrafted_weapon || godcrafted_armour || godcrafted_backpack;
  210. 	}
  211.  
  212. 	function isCooked(item) {
  213. 		// Returns if item is cooked.
  214. 		return item.properties.has("cooked") && item.properties.get("cooked") === true;
  215. 	}
  216.  
  217. 	function isStackable(item) {
  218. 		// Returns if item is stackable.
  219. 		return item.category === ItemCategory.AMMO || item.base_type === "credits";
  220. 	}
  221.  
  222. 	function isEnhanceable(item) {
  223. 		// Returns if an item can be mastercrafted/godcrafted.
  224. 		const enhanceable = new Set([ItemCategory.WEAPON, ItemCategory.ARMOUR, ItemCategory.BACKPACK]);
  225. 		return enhanceable.has(item.category);
  226. 	}
  227.  
  228. 	// Enums
  229.  
  230. 	const Tradezone = {
  231. 		// The integers used are the same as the internal Dead Frontier representation, so they cannot be changed.
  232. 		OUTPOST: 21,
  233. 		CAMP_VALCREST: 22,
  234. // 		NASTYAS_HOLDOUT: 4,
  235. // 		DOGGS_STOCKAGE: 10,
  236. // 		PRECINCT_13: 11,
  237. // 		FORT_PASTOR: 12,
  238. // 		SECRONOM_BUNKER: 13,
  239. 		WASTELANDS: 10,
  240. 		NW: 1,
  241. 		N: 2,
  242. 		NE: 3,
  243. 		W: 4,
  244. 		CENTRAL: 5,
  245. 		E: 6,
  246. 		SW: 7,
  247. 		S: 8,
  248. 		SE: 9
  249. 	};
  250.  
  251. 	const ItemCategory = {
  252. 		AMMO: "ammo",
  253. 		WEAPON: "weapon",
  254. 		ARMOUR: "armour",
  255. 		BACKPACK: "backpack",
  256. 		ITEM: "item",
  257. 		OTHER: "other"
  258. 	};
  259.  
  260. 	const ItemSubcategory = {
  261. 		FOOD: "food",
  262. 		MEDICINE: "medicine",
  263. 		IMPLANT: "implant",
  264. 		CLOTHING: "clothing",
  265. 		BARRICADE: "barricade",
  266. 		OTHER: "other"
  267. 	};
  268.  
  269. 	const ServiceType = {
  270. 		CHEF: "Chef",
  271. 		DOCTOR: "Doctor",
  272. 		ENGINEER: "Engineer"
  273. 	};
  274.  
  275. 	const ProficiencyType = {
  276. 		MELEE: "melee",
  277. 		PISTOL: "pistol",
  278. 		RIFLE: "rifle",
  279. 		SHOTGUN: "shotgun",
  280. 		MACHINEGUN: "machinegun",
  281. 		EXPLOSIVE: "explosive"
  282. 	};
  283.  
  284. 	const UiUpdate = {
  285. 		YES: true,
  286. 		NO: false
  287. 	};
  288.  
  289. 	// Predicates
  290.  
  291. 	const ItemFilters = {
  292. 		Mastercrafted: (item) => isMastercrafted(item),
  293. 		NearGodcrafted: (item) => isNearGodcrafted(item),
  294. 		Godcrafted: (item) => isGodcrafted(item),
  295. 		Cooked: (item) => isCooked(item),
  296. 		Enhanceable: (item) => isEnhanceable(item)
  297. 	};
  298.  
  299. 	const ServiceFilters = {
  300. 		ServiceLevel: function(level) {
  301. 			return (service) => service.level === level;
  302. 		},
  303. 		ServiceLevels: function(levels) {
  304. 			return (service) => levels.includes(service.level);
  305. 		},
  306. 		ServiceLevelAtLeast: function(level) {
  307. 			return (service) => service.level >= level;
  308. 		}
  309. 	};
  310.  
  311. 	const MarketFilters = {
  312. 		ServiceLevel: function(level) {
  313. 			return (market_entry) => market_entry.service.level === level;
  314. 		},
  315. 		ServiceLevels: function(levels) {
  316. 			return (market_entry) => levels.includes(market_entry.service.level);
  317. 		},
  318. 		ServiceLevelAtLeast: function(level) {
  319. 			return (market_entry) => market_entry.service.level >= level;
  320. 		},
  321. 		Mastercrafted: (market_entry) => isMastercrafted(market_entry.item),
  322. 		NearGodcrafted: (market_entry) => isNearGodcrafted(market_entry.item),
  323. 		Godcrafted: (market_entry) => isGodcrafted(market_entry.item),
  324. 		Cooked: (market_entry) => isCooked(market_entry.item),
  325. 		Enhanceable: (market_entry) => isEnhanceable(market_entry.item)
  326. 	};
  327.  
  328. 	// Classes
  329.  
  330. 	// Item, ItemMarketEntry, Service, ServiceMarketEntry
  331. 	// These classes are all simple data classes meant to hold information.
  332.  
  333. 	class Item {
  334. 		static #global_data = globalData;
  335.  
  336. 		#makeProperties(full_type) {
  337. 			const base_type = typeSplit(full_type)[0];
  338. 			const data = Item.#global_data[base_type];
  339. 			const is_weapon = data.itemtype === "weapon";
  340. 			const is_armour = data.itemtype === "armour";
  341. 			const is_backpack = data.itemtype === "backpack";
  342. 			// Creates properties Map from full type string.
  343. 			const components = typeSplit(full_type);
  344. 			const properties = new Map();
  345. 			// Iterate through each component.
  346. 			for (let i = 1; i < components.length; i++) {
  347. 				const component = components[i];
  348. 				const is_mastercrafted = component.indexOf("stats") !== -1;
  349. 				const has_colour = component.indexOf("colour") !== -1;
  350. 				const is_rename = component.indexOf("name") !== -1;
  351. 				if (is_mastercrafted) {
  352. 					properties.set("mastercrafted", true);
  353. 					const numbers = component.substring("stats".length);
  354. 					if (is_weapon) {
  355. 						const stats = stringGroups(numbers, 1);
  356. 						properties.set("accuracy", parseInt(stats[0]));
  357. 						properties.set("reloading", parseInt(stats[1]));
  358. 						properties.set("critical_hit", parseInt(stats[2]));
  359. 					} else if (is_armour) {
  360. 						const stats = stringGroups(numbers, 2);
  361. 						properties.set("agility", parseInt(stats[0]));
  362. 						properties.set("endurance", parseInt(stats[1]));
  363. 					} else if (is_backpack) {
  364. 						const stats = stringGroups(numbers, 1);
  365. 						properties.set("bonus_slots", parseInt(stats[0]));
  366. 					}
  367. 				} else if (has_colour) {
  368. 					const colour = component.substring("colour".length);
  369. 					properties.set("colour", colour);
  370. 				} else if (is_rename) {
  371. 					const rename = component.substring("name".length);
  372. 					properties.set("rename", rename);
  373. 				} else {
  374. 					properties.set(component, true);
  375. 				}
  376. 			}
  377. 			// Properties from globalData.
  378. 			properties.set("lootable", !("noloot" in data) || data.noloot !== "1");
  379. 			properties.set("transferable", !("no_transfer" in data) || data.no_transfer !== "1");
  380. 			if (is_weapon) {
  381. 				properties.set("weapon_type", data.type);
  382. 				properties.set("proficiency_type", data.wepPro);
  383. 				properties.set("proficiency_level", data.pro_req);
  384. 				properties.set("required_strength", data.str_req);
  385. 			} else if (is_armour) {
  386. 				properties.set("engineer_level", parseInt(data.shop_level) - 5);
  387. 				properties.set("required_strength", parseInt(data.str_req));
  388. 			} else if (is_backpack) {
  389. 				properties.set("base_slots", parseInt(data.slots));
  390. 				const total_slots = properties.has("bonus_slots") ? properties.get("base_slots") + properties.get("bonus_slots") : properties.get("base_slots");
  391. 				properties.set("total_slots", total_slots);
  392. 			}
  393.  
  394. 			return properties;
  395. 		}
  396.  
  397. 		#itemCategory(type) {
  398. 			// Returns item category given type.
  399. 			const data = Item.#global_data[type];
  400. 			const is_ammo = data.itemtype == "ammo";
  401. 			const is_weapon = data.itemtype == "weapon";
  402. 			const is_armour = data.itemtype == "armour";
  403. 			const is_backpack = data.itemtype === "backpack";
  404. 			const is_item = data.itemtype == "item";
  405. 			if (is_ammo) {
  406. 				return ItemCategory.AMMO;
  407. 			} else if (is_weapon) {
  408. 				return ItemCategory.WEAPON;
  409. 			} else if (is_armour) {
  410. 				return ItemCategory.ARMOUR;
  411. 			} else if (is_backpack) {
  412. 				return ItemCategory.BACKPACK;
  413. 			} else if (is_item) {
  414. 				return ItemCategory.ITEM;
  415. 			} else {
  416. 				return ItemCategory.OTHER;
  417. 			}
  418. 		}
  419.  
  420. 		#itemSubcategory(type) {
  421. 			// Returns item subcategory given type. Type should have itemcat == "item".
  422. 			const data = Item.#global_data[type];
  423. 			const is_food = parseInt(data.foodrestore) > 0;
  424. 			const is_medicine = parseInt(data.healthrestore) > 0;
  425. 			const is_implant = "implant" in data && data.implant == "1";
  426. 			const is_clothing = "clothingtype" in data;
  427. 			const is_barricade = "barricade" in data && data.barricade == "1";
  428. 			if (is_food) {
  429. 				return ItemSubcategory.FOOD;
  430. 			} else if (is_medicine) {
  431. 				return ItemSubcategory.MEDICINE;
  432. 			} else if (is_implant) {
  433. 				return ItemSubcategory.IMPLANT;
  434. 			} else if (is_clothing) {
  435. 				return ItemSubcategory.CLOTHING;
  436. 			} else if (is_barricade) {
  437. 				return ItemSubcategory.BARRICADE;
  438. 			} else {
  439. 				return ItemSubcategory.OTHER;
  440. 			}
  441. 		}
  442.  
  443. 		constructor(full_type, name, quantity) {
  444. 			this.full_type = full_type;
  445. 			this.base_name = name;
  446. 			this.base_type = typeSplit(full_type)[0];
  447. 			this.category = this.#itemCategory(this.base_type);
  448. 			this.quantity = parseInt(quantity);
  449. 			this.properties = this.#makeProperties(full_type);
  450. 			if (this.category === ItemCategory.ITEM) {
  451. 				this.subcategory = this.#itemSubcategory(this.base_type);
  452. 				if (this.subcategory === ItemSubcategory.CLOTHING) {
  453. 					this.properties.set("clothing_type", Item.#global_data[this.base_type].clothingtype);
  454. 				}
  455. 			}
  456. 			if (this.properties.has("cooked") && this.properties.get("cooked")) {
  457. 				this.base_name = name.substring(0, 6) === "Cooked" ? name.substring(7) : name;
  458. 				this.full_name = "Cooked " + this.base_name;
  459. 			} else if (this.properties.has("colour")) {
  460. 				this.full_name = this.properties.get("colour") + " " + this.base_name;
  461. 			}
  462. 		}
  463. 	}
  464.  
  465. 	class ItemMarketEntry {
  466. 		constructor(item, price, trade_id, member_id, member_name, tradezone) {
  467. 			this.item = item;
  468. 			this.price = parseInt(price);
  469. 			this.trade_id = parseInt(trade_id)
  470. 			this.member_id = parseInt(member_id);
  471. 			this.member_name = member_name;
  472. 			this.tradezone = parseInt(tradezone);
  473. 		}
  474. 	}
  475.  
  476. 	class ItemSellingEntry {
  477. 		constructor(market_entry, member_to_id, member_to_name) {
  478. 			this.market_entry = market_entry;
  479. 			this.member_to_id = parseInt(member_to_id);
  480. 			this.member_to_name = member_to_name;
  481. 		}
  482. 	}
  483.  
  484. 	class Service {
  485. 		constructor(service_type, level) {
  486. 			this.service_type = service_type;
  487. 			this.level = parseInt(level);
  488. 		}
  489. 	}
  490.  
  491. 	class ServiceMarketEntry {
  492. 		constructor(service, price, member_id, member_name, tradezone) {
  493. 			this.service = service;
  494. 			this.price = parseInt(price);
  495. 			this.member_id = parseInt(member_id);
  496. 			this.member_name = member_name;
  497. 			this.tradezone = tradezone;
  498. 		}
  499. 	}
  500.  
  501. 	// GlobalData
  502.  
  503. 	// class GlobalData {
  504. 	// 	#setupPlayerValuesWebcallParameters() {
  505. 	// 		const parameters = {};
  506. 	// 		const uservars = userVars;
  507. 	// 		parameters["userID"] = uservars["userID"];
  508. 	// 		parameters["password"] = uservars["password"];
  509. 	// 		parameters["sc"] = uservars["sc"];
  510. 	// 		parameters["template_ID"] = "";
  511. 	// 		console.debug(parameters);
  512. 	// 		return parameters;
  513. 	// 	}
  514.  //
  515. 	// 	#_data;
  516. 	// 	#_requests_out;
  517. 	// 	constructor() {
  518. 	// 		this.#_requests_out = 0;
  519. 	// 	}
  520.  //
  521. 	// 	request() {
  522. 	// 		const instance = this;
  523. 	// 		const promise = new Promise(function(resolve, reject) {
  524. 	// 			instance.#_requests_out += 1;
  525. 	// 			const parameters = instance.#setupPlayerValuesWebcallParameters();
  526. 	// 			const data = {};
  527. 	// 			webCall("itemspawn", data);
  528. 	// 			setTimeout(function() {
  529. 	// 				console.debug(data);
  530. 	// 			}, 5000);
  531. 	// 			// webCall("itemspawn", parameters, function(data) {
  532. 	// 			// 	instance.#_data = responseToMap(data);
  533. 	// 			// 	instance.#_requests_out -= 1;
  534. 	// 			// 	resolve(instance);
  535. 	// 			// });
  536. 	// 		});
  537. 	// 		return promise;
  538. 	// 	}
  539. 	// }
  540.  
  541.  
  542. 	// PlayerValues
  543.  
  544. 	class PlayerValues {
  545.  
  546. 		#setupPlayerValuesWebcallParameters() {
  547. 			const parameters = {};
  548. 			const uservars = userVars;
  549. 			parameters["userID"] = uservars["userID"];
  550. 			parameters["password"] = uservars["password"];
  551. 			parameters["sc"] = uservars["sc"];
  552. 			return parameters;
  553. 		}
  554.  
  555. 		#query(str) {
  556. 			return this.#_data.get(str);
  557. 		}
  558.  
  559. 		#_raw_data;
  560. 		#_data;
  561. 		#_requests_out;
  562. 		constructor() {
  563. 			this.#_requests_out = 0;
  564. 		}
  565.  
  566. 		get data() {
  567. 			return this.#_data;
  568. 		}
  569.  
  570. 		get member_id() {
  571. 			return this.#query("id_member");
  572. 		}
  573.  
  574. 		get name() {
  575. 			return this.#query("df_name");
  576. 		}
  577.  
  578. 		get gender() {
  579. 			return this.#query("df_gender");
  580. 		}
  581.  
  582. 		get rank() {
  583. 			return this.#query("df_rank");
  584. 		}
  585.  
  586. 		get profession() {
  587. 			return this.#query("df_profession");
  588. 		}
  589.  
  590. 		get level() {
  591. 			return this.#query("df_level");
  592. 		}
  593.  
  594. 		get dead() {
  595. 			return this.#query("df_dead") === "1";
  596. 		}
  597.  
  598. 		get cash() {
  599. 			return parseInt(this.#query("df_cash"));
  600. 		}
  601.  
  602. 		get bank() {
  603. 			return parseInt(this.#query("df_bankcash"));
  604. 		}
  605.  
  606. 		get credits() {
  607. 			return parseInt(this.#query("df_credits"));
  608. 		}
  609.  
  610. 		get gold_member() {
  611. 			return this.#query("df_goldmember") === "1"
  612. 		}
  613.  
  614. 		get max_hp() {
  615. 			return parseInt(this.#query("df_hpmax"));
  616. 		}
  617.  
  618. 		get current_hp() {
  619. 			return parseInt(this.#query("df_hpcurrent"));
  620. 		}
  621.  
  622. 		get current_hunger() {
  623. 			return parseInt(this.#query("df_hungerhp"));
  624. 		}
  625.  
  626. 		get x() {
  627. 			return parseInt(this.#query("df_positionx"));
  628. 		}
  629.  
  630. 		get y() {
  631. 			return parseInt(this.#query("df_positiony"));
  632. 		}
  633.  
  634. 		get stats() {
  635. 			return {
  636. 				strength: parseInt(this.#query("df_strength")),
  637. 				accuracy: parseInt(this.#query("df_accuracy")),
  638. 				agility: parseInt(this.#query("df_agility")),
  639. 				endurance: parseInt(this.#query("df_endurance")),
  640. 				critical_hit: parseInt(this.#query("df_criticalhit")),
  641. 				reloading: parseInt(this.#query("df_reloading"))
  642. 			};
  643. 		}
  644.  
  645. 		get proficiencies() {
  646. 			return {
  647. 				melee: parseInt(this.#query("df_promelee")),
  648. 				pistols: parseInt(this.#query("df_propistol")),
  649. 				rifles: parseInt(this.#query("df_prorifle")),
  650. 				shotguns: parseInt(this.#query("df_proshotgun")),
  651. 				machine_guns: parseInt(this.#query("df_promachinegun")),
  652. 				explosives: parseInt(this.#query("df_proexplosive"))
  653. 			};
  654. 		}
  655.  
  656. 		get ammo() {
  657. 			return {
  658. 				// Shotgun ammo
  659. 				"10gaugeammo": parseInt(this.#query("df_10gaugeammo")),
  660. 				"12gaugeammo": parseInt(this.#query("df_12gaugeammo")),
  661. 				"16gaugeammo": parseInt(this.#query("df_16gaugeammo")),
  662. 				"20gaugeammo": parseInt(this.#query("df_20gaugeammo")),
  663. 				// Handgun ammo
  664. 				"32ammo": parseInt(this.#query("df_32ammo")),
  665. 				"357ammo": parseInt(this.#query("df_357ammo")),
  666. 				"35ammo": parseInt(this.#query("df_35ammo")),
  667. 				"38ammo": parseInt(this.#query("df_38ammo")),
  668. 				"40ammo": parseInt(this.#query("df_40ammo")),
  669. 				"45ammo": parseInt(this.#query("df_45ammo")),
  670. 				"50ammo": parseInt(this.#query("df_50ammo")),
  671. 				"55ammo": parseInt(this.#query("df_55ammo")),
  672. 				// Rifle ammo
  673. 				"55rifleammo": parseInt(this.#query("df_55rifleammo")),
  674. 				"75rifleammo": parseInt(this.#query("df_75rifleammo")),
  675. 				"9rifleammo": parseInt(this.#query("df_9rifleammo")),
  676. 				"127rifleammo": parseInt(this.#query("df_127rifleammo")),
  677. 				"14rifleammo": parseInt(this.#query("df_14rifleammo")),
  678. 				// Grenade ammo
  679. 				"grenadeammo": parseInt(this.#query("df_grenadeammo")),
  680. 				"heavygrenadeammo": parseInt(this.#query("df_heavygrenadeammo"))
  681. 			};
  682. 		}
  683.  
  684. 		get tradezone() {
  685. 			return parseInt(this.#query("df_tradezone"));
  686. 		}
  687.  
  688. 		get account_name() {
  689. 			return this.#query("account_name");
  690. 		}
  691.  
  692. 		get data() {
  693. 			return this.#_data;
  694. 		}
  695.  
  696. 		get raw_data() {
  697. 			return this.#_raw_data;
  698. 		}
  699.  
  700. 		request() {
  701. 			const instance = this;
  702. 			const promise = new Promise(function(resolve, reject) {
  703. 				instance.#_requests_out += 1;
  704. 				const parameters = instance.#setupPlayerValuesWebcallParameters();
  705. 				webCall("get_values", parameters, function(data) {
  706. 					instance.#_raw_data = data;
  707. 					instance.#_data = responseToMap(data);
  708. 					instance.#_requests_out -= 1;
  709. 					resolve(instance);
  710. 				});
  711. 			});
  712. 			return promise;
  713. 		}
  714. 	}
  715.  
  716.  
  717. 	// PlayerItems
  718. 	// The PlayerItems class is responsible for storing item data and item movement (equipment, storage).
  719. 	// TODO: Add check for global data availability for all items (inventory, equipment).
  720. 	class PlayerItems {
  721. 		static #global_data = globalData;
  722.  
  723. 		#fulltypeQuantityFromInventorySlot(slot) {
  724. 			// Returns item type and item quantity from slot.
  725. 			const uservars = this.#_uservars;
  726. 			const nslots = parseInt(uservars["DFSTATS_df_invslots"]);
  727. 			if (slot > nslots || slot < 1) {
  728. 				throw new RangeError("Slot: " + slot.toString() + " out of range of inventory slots.");
  729. 			}
  730. 			const type_key = "DFSTATS_df_inv" + slot.toString() + "_type";
  731. 			const quantity_key = "DFSTATS_df_inv" + slot.toString() + "_quantity";
  732. 			return [uservars[type_key], parseInt(uservars[quantity_key])];
  733. 		}
  734.  
  735. 		#fulltypeQuantityFromStorageSlot(slot) {
  736. 			const uservars = this.#_uservars;
  737. 			const storage = this.#_storage_data;
  738. 			const nslots = parseInt(uservars["DFSTATS_df_storage_slots"]);
  739. 			if (slot > nslots || slot < 1) {
  740. 				throw new RangeError("Slot: " + slot.toString() + " out of range of storage slots.");
  741. 			}
  742. 			const type_key = "df_store" + slot.toString() + "_type";
  743. 			const quantity_key = "df_store" + slot.toString() + "_quantity";
  744. 			return [storage.get(type_key), parseInt(storage.get(quantity_key))];
  745. 		}
  746.  
  747. 		#nBackpackSlots() {
  748. 			// Returns number of backpack slots available.
  749. 			const uservars = this.#_uservars;
  750. 			const globaldata = PlayerItems.#global_data;
  751. 			const full_type = uservars["DFSTATS_df_backpack"];
  752. 			if (full_type === "") {
  753. 				return 0;
  754. 			}
  755. 			const base_type = typeSplit(uservars["DFSTATS_df_backpack"])[0];
  756. 			const backpack = new Item(full_type, globaldata[base_type].name, 1);
  757. 			return backpack.properties.get("total_slots");
  758. 		}
  759.  
  760. 		#fulltypeQuantityFromBackpackSlot(slot) {
  761. 			// Returns item type and item quantity from slot.
  762. 			const uservars = this.#_uservars;
  763. 			const nslots = this.#nBackpackSlots();
  764. 			if (slot > nslots || slot < 1) {
  765. 				throw new RangeError("Slot: " + slot.toString() + " out of range of backpack slots.");
  766. 			}
  767. 			const type_key = "DFSTATS_df_backpack" + slot.toString() + "_type";
  768. 			const quantity_key = "DFSTATS_df_backpack" + slot.toString() + "_quantity";
  769. 			return type_key in uservars ? [uservars[type_key], parseInt(uservars[quantity_key])] : ["", ""];
  770. 		}
  771.  
  772. 		#setupStorageWebcallParameters() {
  773. 			const parameters = {};
  774. 			const uservars = this.#_uservars;
  775. 			parameters["userID"] = uservars["userID"];
  776. 			parameters["password"] = uservars["password"];
  777. 			parameters["sc"] = uservars["sc"];
  778. 			parameters["pagetime"] = uservars["pagetime"];
  779. 			return parameters;
  780. 		}
  781.  
  782. 		#typeFromImplantSlot(slot) {
  783. 			const uservars = this.#_uservars;
  784. 			const nslots = parseInt(uservars["DFSTATS_df_implantslots"]);
  785. 			if (slot > nslots || slot < 1) {
  786. 				throw new RangeError("Slot: " + slot.toString() + " out of range of implant slots.");
  787. 			}
  788. 			const type_key = "DFSTATS_df_implant" + slot.toString() + "_type";
  789. 			return uservars[type_key];
  790. 		}
  791.  
  792. 		#typeInGlobalData(type) {
  793. 			return type === "" || type in PlayerItems.#global_data;
  794. 		}
  795.  
  796. 		#_uservars;
  797. 		#_storage_data;
  798. 		constructor() {
  799. 			this.#_uservars = userVars;
  800. 		}
  801.  
  802. 		// Availability Checks
  803.  
  804. 		inventoryAvailable() {
  805. 			// Check for userstats keys.
  806. 			const inventory_available = this.#_uservars["DFSTATS_df_invslots"] !== undefined;
  807. 			if (!inventory_available) {
  808. 				return false;
  809. 			}
  810. 			// Check for global data keys.
  811. 			const nslots = parseInt(this.#_uservars["DFSTATS_df_invslots"]);
  812. 			for (let i = 1; i <= nslots; i++) {
  813. 				const [full_type, quantity] = this.#fulltypeQuantityFromInventorySlot(i);
  814. 				const base_type = typeSplit(full_type)[0];
  815. 				if (!this.#typeInGlobalData(base_type)) {
  816. 					return false;
  817. 				}
  818. 			}
  819. 			return true;
  820. 		}
  821.  
  822. 		equipmentAvailable() {
  823. 			// TODO: Check for clothing in global data.
  824. 			const uservars = this.#_uservars;
  825. 			const global_data = PlayerItems.#global_data;
  826. 			const implants_available = uservars["DFSTATS_df_implantslots"] !== undefined;
  827. 			const weapons_available = uservars["DFSTATS_df_weapon1type"] !== undefined;
  828. 			const armour_available = uservars["DFSTATS_df_armourtype"] !== undefined;
  829. 			const implants_nslots = parseInt(this.#_uservars["DFSTATS_df_implantslots"]);
  830. 			for (let i = 1; i <= implants_nslots; i++) {
  831. 				const implant_type = typeFromImplantSlot(i);
  832. 				if (!this.#typeInGlobalData(implant_type)) {
  833. 					return false;
  834. 				}
  835. 			}
  836. 			const weapons_in_globaldata = this.#typeInGlobalData(uservars["DFSTATS_df_weapon1type"]) && this.#typeInGlobalData(uservars["DFSTATS_df_weapon2type"]) && this.#typeInGlobalData(uservars["DFSTATS_df_weapon3type"]);
  837. 			if (!weapons_in_globaldata) {
  838. 				return false;
  839. 			}
  840. 			const armour_in_global_data = this.#typeInGlobalData(uservars["DFSTATS_df_armourtype"]);
  841. 			if (!armour_in_global_data) {
  842. 				return false;
  843. 			}
  844. 			return true;
  845. 		}
  846.  
  847. 		storageAvailable() {
  848. 			const uservars_available = this.#_uservars !== undefined;
  849. 			return uservars_available;
  850. 		}
  851.  
  852. 		// Inventory Queries
  853.  
  854. 		itemFromInventorySlot(slot) {
  855. 			const [full_type, quantity] = this.#fulltypeQuantityFromInventorySlot(slot);
  856. 			if (full_type === "") {
  857. 				return undefined;
  858. 			}
  859. 			const base_type = typeSplit(full_type)[0];
  860. 			const data = PlayerItems.#global_data[base_type]
  861. 			const name = data.name;
  862. 			const item = new Item(full_type, name, quantity);
  863. 			// Adding in durability properties for armour.
  864. 			if (item.category === ItemCategory.ARMOUR) {
  865. 				item.properties.set("durability", quantity);
  866. 				item.properties.set("max_durability", parseInt(data.hp));
  867. 			}
  868. 			// Adding in cooked property for food.
  869. 			if (item.category === ItemCategory.ITEM && item.subcategory === ItemSubcategory.FOOD) {
  870. 				const is_cooked = item.properties.has("cooked") && item.properties.get("cooked") === true;
  871. 				if (!is_cooked) {
  872. 					item.properties.set("cooked", false);
  873. 				}
  874. 			}
  875. 			// Adding in max quantity property for ammunition.
  876. 			if (item.category === ItemCategory.AMMO) {
  877. 				item.properties.set("max_quantity", parseInt(data.max_quantity));
  878. 			}
  879. 			return item;
  880. 		}
  881.  
  882. 		inventory(slot) {
  883. 			return this.itemFromInventorySlot(slot);
  884. 		}
  885.  
  886. 		*inventorySlots() {
  887. 			// Generator that iterates through slots and yields [slot, Item].
  888. 			const uservars = this.#_uservars;
  889. 			const nslots = parseInt(uservars["DFSTATS_df_invslots"]);
  890. 			for (let slot = 1; slot <= nslots; slot++) {
  891. 				const item = this.itemFromInventorySlot(slot);
  892. 				yield [slot, item];
  893. 			}
  894. 		}
  895.  
  896. 		*inventoryItems() {
  897. 			// Generator that iterates through filled slots and yields [slot, Item].
  898. 			for (const [slot, item] of this.inventorySlots()) {
  899. 				const slot_filled = item !== undefined;
  900. 				if (slot_filled) {
  901. 					yield [slot, item];
  902. 				}
  903. 			}
  904. 		}
  905.  
  906. 		isLockedSlot(slot) {
  907. 			return lockedSlots.includes(slot.toString());
  908. 		}
  909.  
  910. 		totalInventorySlots() {
  911. 			const uservars = this.#_uservars;
  912. 			const nslots = parseInt(uservars["DFSTATS_df_invslots"]);
  913. 			return nslots;
  914. 		}
  915.  
  916. 		fullInventorySlots() {
  917. 			return Array.from(this.inventorySlots()).filter((e) => e[1] !== undefined).length;
  918. 		}
  919.  
  920. 		emptyInventorySlots() {
  921. 			return Array.from(this.inventorySlots()).filter((e) => e[1] === undefined).length;
  922. 		}
  923.  
  924. 		// Backpack Queries
  925.  
  926. 		itemFromBackpackSlot(slot) {
  927. 			const [full_type, quantity] = this.#fulltypeQuantityFromBackpackSlot(slot);
  928. 			if (full_type === "") {
  929. 				return undefined;
  930. 			}
  931. 			const base_type = typeSplit(full_type)[0];
  932. 			const data = PlayerItems.#global_data[base_type]
  933. 			const name = data.name;
  934. 			const item = new Item(full_type, name, quantity);
  935. 			// Adding in durability properties for armour.
  936. 			if (item.category === ItemCategory.ARMOUR) {
  937. 				item.properties.set("durability", quantity);
  938. 				item.properties.set("max_durability", parseInt(data.hp));
  939. 			}
  940. 			// Adding in cooked property for food.
  941. 			if (item.category === ItemCategory.ITEM && item.subcategory === ItemSubcategory.FOOD) {
  942. 				const is_cooked = item.properties.has("cooked") && item.properties.get("cooked") === true;
  943. 				if (!is_cooked) {
  944. 					item.properties.set("cooked", false);
  945. 				}
  946. 			}
  947. 			// Adding in max quantity property for ammunition.
  948. 			if (item.category === ItemCategory.AMMO) {
  949. 				item.properties.set("max_quantity", parseInt(data.max_quantity));
  950. 			}
  951. 			return item;
  952. 		}
  953.  
  954. 		backpack(slot) {
  955. 			return this.itemFromBackpackSlot(slot);
  956. 		}
  957.  
  958. 		*backpackSlots() {
  959. 			// Generator that iterates through slots and yields [slot, Item].
  960. 			const uservars = this.#_uservars;
  961. 			const nslots = this.#nBackpackSlots();
  962. 			for (let slot = 1; slot <= nslots; slot++) {
  963. 				const item = this.itemFromBackpackSlot(slot);
  964. 				yield [slot, item];
  965. 			}
  966. 		}
  967.  
  968. 		*backpackItems() {
  969. 			// Generator that iterates through filled slots and yields [slot, Item].
  970. 			for (const [slot, item] of this.backpackSlots()) {
  971. 				const slot_filled = item !== undefined;
  972. 				if (slot_filled) {
  973. 					yield [slot, item];
  974. 				}
  975. 			}
  976. 		}
  977.  
  978. 		isLockedBackpackSlot(slot) {
  979. 			return lockedSlots.includes((slot + 1050).toString());
  980. 		}
  981.  
  982. 		totalBackpackSlots() {
  983. 			return this.#nBackpackSlots();
  984. 		}
  985.  
  986. 		fullBackpackSlots() {
  987. 			return Array.from(this.backpackSlots()).filter((e) => e[1] !== undefined).length;
  988. 		}
  989.  
  990. 		emptyBackpackSlots() {
  991. 			return Array.from(this.backpackSlots()).filter((e) => e[1] === undefined).length;
  992. 		}
  993.  
  994. 		// Implant Queries
  995.  
  996. 		itemFromImplantSlot(slot) {
  997. 			const type = this.#typeFromImplantSlot(slot);
  998. 			if (type === "") {
  999. 				return undefined;
  1000. 			}
  1001. 			const base_type = typeSplit(type)[0];
  1002. 			const name = PlayerItems.#global_data[base_type].name;
  1003. 			const quantity = 1;
  1004. 			const item = new Item(type, name, quantity);
  1005. 			return item;
  1006. 		}
  1007.  
  1008. 		implant(slot) {
  1009. 			return this.itemFromImplantSlot(slot);
  1010. 		}
  1011.  
  1012. 		*implantSlots() {
  1013. 			const uservars = this.#_uservars;
  1014. 			const nslots = parseInt(uservars["DFSTATS_df_implantslots"]);
  1015. 			for (let slot = 1; slot <= nslots; slot++) {
  1016. 				const item = this.itemFromImplantSlot(slot);
  1017. 				yield [slot, item];
  1018. 			}
  1019. 		}
  1020.  
  1021. 		*implantItems() {
  1022. 			for (const [slot, item] of this.implantSlots()) {
  1023. 				const slot_filled = item !== undefined;
  1024. 				if (slot_filled) {
  1025. 					yield [slot, item];
  1026. 				}
  1027. 			}
  1028. 		}
  1029.  
  1030. 		// Equipment Queries
  1031.  
  1032. 		armour() {
  1033. 			const uservars = this.#_uservars;
  1034. 			const full_type = uservars["DFSTATS_df_armourtype"];
  1035. 			if (full_type === "") {
  1036. 				return undefined;
  1037. 			}
  1038. 			const name = uservars["DFSTATS_df_armourname"];
  1039. 			const durability = parseInt(uservars["DFSTATS_df_armourhp"]);
  1040. 			const max_durability = parseInt(uservars["DFSTATS_df_armourhpmax"]);
  1041. 			const item = new Item(full_type, name, durability);
  1042. 			item.properties.set("durability", durability);
  1043. 			item.properties.set("max_durability", max_durability);
  1044. 			return item;
  1045. 		}
  1046.  
  1047. 		weapon(index) {
  1048. 			const uservars = this.#_uservars;
  1049. 			const i = index.toString();
  1050. 			const full_type = uservars["DFSTATS_df_weapon" + i + "type"];
  1051. 			if (full_type === "") {
  1052. 				return undefined;
  1053. 			}
  1054. 			const name = uservars["DFSTATS_df_weapon" + i + "name"];
  1055. 			const quantity = 1;
  1056. 			const item = new Item(full_type, name, quantity);
  1057. 			return item;
  1058. 		}
  1059.  
  1060. 		backpack() {
  1061. 			const uservars = this.#_uservars;
  1062. 			const full_type = uservars["DFSTATS_df_backpack"];
  1063. 			if (full_type === "") {
  1064. 				return undefined;
  1065. 			}
  1066. 			const base_type = typeSplit(full_type)[0];
  1067. 			const name = PlayerItems.#global_data[base_type].name;
  1068. 			const quantity = 1;
  1069. 			const item = new Item(full_type, name, quantity);
  1070. 			return item;
  1071. 		}
  1072.  
  1073. 		#cosmetic(key) {
  1074. 			const uservars = this.#_uservars;
  1075. 			const full_type = uservars[key];
  1076. 			if (full_type === "") {
  1077. 				return undefined;
  1078. 			}
  1079. 			const base_type = typeSplit(full_type)[0];
  1080. 			const name = PlayerItems.#global_data[base_type].name;
  1081. 			const quantity = 1;
  1082. 			const item = new Item(full_type, name, quantity);
  1083. 			return item;
  1084. 		}
  1085.  
  1086. 		hat() {
  1087. 			return this.#cosmetic("DFSTATS_df_avatar_hat");
  1088. 		}
  1089.  
  1090. 		mask() {
  1091. 			return this.#cosmetic("DFSTATS_df_avatar_mask");
  1092. 		}
  1093.  
  1094. 		coat() {
  1095. 			return this.#cosmetic("DFSTATS_df_avatar_coat");
  1096. 		}
  1097.  
  1098. 		shirt() {
  1099. 			return this.#cosmetic("DFSTATS_df_avatar_shirt");
  1100. 		}
  1101.  
  1102. 		trousers() {
  1103. 			return this.#cosmetic("DFSTATS_df_avatar_trousers");
  1104. 		}
  1105.  
  1106. 		// Storage Queries
  1107.  
  1108. 		requestStorage() {
  1109. 			// Before any storage queries, this function must be called, as well as after any changes are made to storage.
  1110. 			const instance = this;
  1111. 			const promise = new Promise(function(resolve, reject) {
  1112. 				const parameters = instance.#setupStorageWebcallParameters();
  1113. 				webCall("get_storage", parameters, function(data) {
  1114. 					storageBox = flshToArr(data); // Update website vars.
  1115. 					instance.#_storage_data = responseToMap(data);
  1116. 					resolve(instance);
  1117. 				}, true);
  1118. 			});
  1119. 			return promise;
  1120. 		}
  1121.  
  1122. 		itemFromStorageSlot(slot) {
  1123. 			const [full_type, quantity] = this.#fulltypeQuantityFromStorageSlot(slot);
  1124. 			if (full_type === undefined) {
  1125. 				return undefined;
  1126. 			}
  1127. 			const base_type = typeSplit(full_type)[0];
  1128. 			const data = PlayerItems.#global_data[base_type]
  1129. 			const name = data.name;
  1130. 			const item = new Item(full_type, name, quantity);
  1131. 			if (item.category === ItemCategory.ITEM && item.subcategory === ItemSubcategory.FOOD) {
  1132. 				const is_cooked = item.properties.has("cooked") && item.properties.get("cooked") === true;
  1133. 				if (!is_cooked) {
  1134. 					item.properties.set("cooked", false);
  1135. 				}
  1136. 			}
  1137. 			if (item.category === ItemCategory.AMMO) {
  1138. 				item.properties.set("max_quantity", parseInt(data.max_quantity));
  1139. 			}
  1140. 			return item;
  1141. 		}
  1142.  
  1143. 		storage(slot) {
  1144. 			return this.itemFromStorageSlot(slot);
  1145. 		}
  1146.  
  1147. 		*storageSlots() {
  1148. 			const uservars = this.#_uservars;
  1149. 			const nslots = parseInt(uservars["DFSTATS_df_storage_slots"]);
  1150. 			for (let slot = 1; slot <= nslots; slot++) {
  1151. 				const item = this.itemFromStorageSlot(slot);
  1152. 				yield [slot, item];
  1153. 			}
  1154. 		}
  1155.  
  1156. 		*storageItems() {
  1157. 			for (const [slot, item] of this.storageSlots()) {
  1158. 				const slot_filled = item !== undefined;
  1159. 				if (slot_filled) {
  1160. 					yield [slot, item];
  1161. 				}
  1162. 			}
  1163. 		}
  1164.  
  1165. 		// Move Operations
  1166.  
  1167. 		#setupMoveParameters() {
  1168. 			const parameters = {};
  1169. 			const uservars = this.#_uservars;
  1170. 			parameters["userID"] = uservars["userID"];
  1171. 			parameters["password"] = uservars["password"];
  1172. 			parameters["sc"] = uservars["sc"];
  1173. 			parameters["pagetime"] = uservars["pagetime"];
  1174. 			parameters["templateID"] = uservars["template_ID"];
  1175. 			parameters["creditsnum"] = this.#_uservars["DFSTATS_df_credits"];
  1176. 			return parameters;
  1177. 		}
  1178.  
  1179. 		#quantityIsMax(item) {
  1180. 			return item.quantity === item.properties.get("max_quantity");
  1181. 		}
  1182.  
  1183. 		#moveResult(item1, item2_init) {
  1184. 			// Returns result of moving item1 into item2. item2 can be undefined.
  1185. 			const item2 = item2_init === undefined ? new Item(item1.full_type, item1.base_name, 0) : item2_init; // Dummy item if item2 is undefined.
  1186. 			const both_stackable = isStackable(item1) && isStackable(item2);
  1187. 			const same_type = item1.full_type === item2.full_type;
  1188. 			if (both_stackable && same_type) {
  1189. 				const max = item1.properties.get("max_quantity");
  1190. 				const sum = item1.quantity + item2.quantity;
  1191. 				const item_stacking = item1.quantity < max && item2.quantity < max;
  1192. 				if (item_stacking) {
  1193. 					if (sum > max) {
  1194. 						// item2 slot becomes fully stacked, item1 slot gets remainder.
  1195. 						const diff = sum - max;
  1196. 						const item1_new = new Item(item1.full_type, item1.base_name, diff);
  1197. 						const item2_new = new Item(item2.full_type, item2.base_name, max);
  1198. 						return [item1_new, item2_new];
  1199. 					} else {
  1200. 						// item2 slot gets full quantity, item1 slot is empty.
  1201. 						const item1_new = undefined;
  1202. 						const item2_new = new Item(item2.full_type, item2.base_name, sum);
  1203. 						return [item1_new, item2_new];
  1204. 					}
  1205. 				}
  1206. 			}
  1207. 			// Swap items.
  1208. 			return [item2, item1];
  1209. 		}
  1210.  
  1211. 		#storageArrayFromSlotItem(slot, item) {
  1212. 			const delta = {};
  1213. 			delta["df_store" + slot.toString() + "_type"] = item.full_type;
  1214. 			delta["df_store" + slot.toString() + "_quantity"] = item.quantity.toString();
  1215. 			return delta;
  1216. 		}
  1217.  
  1218. 		inventoryToInventory(primary_slot, secondary_slot, update_ui = UiUpdate.YES) {
  1219. 			const instance = this;
  1220. 			const promise = new Promise(function(resolve, reject) {
  1221. 				const parameters = instance.#setupMoveParameters();
  1222. 				parameters["action"] = "newswap";
  1223. 				const primary_item = instance.itemFromInventorySlot(primary_slot);
  1224. 				const secondary_item = instance.itemFromInventorySlot(secondary_slot);
  1225. 				parameters["itemnum"] = primary_slot.toString();
  1226. 				parameters["itemnum2"] = secondary_slot.toString();
  1227. 				parameters["expected_itemtype"] = primary_item !== undefined  ? primary_item.full_type : "";
  1228. 				parameters["expected_itemtype2"] = secondary_item !== undefined ? secondary_item.full_type : "";
  1229. 				webCall("inventory_new", parameters, function(data)
  1230. 				{
  1231. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  1232. 					if (update_ui === UiUpdate.YES) {
  1233. 						populateInventory();
  1234. 						updateAllFields();
  1235. 					}
  1236. 					resolve(instance);
  1237. 				}, true);
  1238. 			});
  1239. 			return promise;
  1240. 		}
  1241.  
  1242. 		inventoryToImplants(inventory_slot, implant_slot, update_ui = UiUpdate.YES) {
  1243. 			const instance = this;
  1244. 			const promise = new Promise(function(resolve, reject) {
  1245. 				const parameters = instance.#setupMoveParameters();
  1246. 				parameters["action"] = "newswap";
  1247. 				const inventory_item = instance.itemFromInventorySlot(inventory_slot);
  1248. 				if (inventory_item !== undefined && (inventory_item.category !== ItemCategory.ITEM || inventory_item.subcategory !== ItemSubcategory.IMPLANT)) {
  1249. 					throw new TypeError("Inventory item: " + inventory_item.full_type + " is not an implant.");
  1250. 				}
  1251. 				const implant_item = instance.itemFromImplantSlot(implant_slot);
  1252. 				parameters["itemnum"] = inventory_slot.toString();
  1253. 				parameters["itemnum2"] = (implant_slot + 1000).toString();
  1254. 				parameters["expected_itemtype"] = inventory_item !== undefined ? inventory_item.full_type : "";
  1255. 				parameters["expected_itemtype2"] = implant_item !== undefined ? implant_item.full_type : "";
  1256. 				webCall("inventory_new", parameters, function(data) {
  1257. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  1258. 					if (update_ui === UiUpdate.YES) {
  1259. 						populateInventory();
  1260. 						populateImplants();
  1261. 						updateAllFields();
  1262. 					}
  1263. 					resolve(instance);
  1264. 				}, true);
  1265. 			});
  1266. 			return promise;
  1267. 		}
  1268.  
  1269. 		#inventoryToEquipment(inventory_slot, equipment_slot, get_equipment, error_if_false, equipment_slot_name = "given", update_ui = UiUpdate.YES) {
  1270. 			const instance = this;
  1271. 			const promise = new Promise(function(resolve, reject) {
  1272. 				const parameters = instance.#setupMoveParameters();
  1273. 				parameters["action"] = "newequip";
  1274. 				const inventory_item = instance.itemFromInventorySlot(inventory_slot);
  1275. 				if (!error_if_false(inventory_item)) {
  1276. 					throw new TypeError("Inventory item: " + inventory_item.full_type + " cannot be placed in the " + equipment_slot_name + " slot.");
  1277. 				}
  1278. 				const equipment_item = get_equipment();
  1279. 				parameters["itemnum"] = inventory_slot.toString();
  1280. 				parameters["itemnum2"] = equipment_slot.toString();
  1281. 				parameters["expected_itemtype"] = inventory_item !== undefined ? inventory_item.full_type : "";
  1282. 				parameters["expected_itemtype2"] = equipment_item !== undefined ? equipment_item.full_type : "";
  1283. 				webCall("inventory_new", parameters, function(data) {
  1284. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  1285. 					if (update_ui === UiUpdate.YES) {
  1286. 						$.each($(".characterRender"), function(key, val)
  1287. 						{
  1288. 							renderAvatarUpdate(val, userVars);
  1289. 						});
  1290. 						populateInventory();
  1291. 						populateCharacterInventory();
  1292. 						updateAllFields();
  1293. 						renderAvatarUpdate();
  1294. 					}
  1295. 					resolve(instance)
  1296. 				}, true);
  1297. 			});
  1298. 			return promise;
  1299. 		}
  1300.  
  1301. 		inventoryToArmour(inventory_slot, update_ui = UiUpdate.YES) {
  1302. 			const armour_slot = 34
  1303. 			const error_if_false = (inventory_item) => inventory_item === undefined || inventory_item.category === ItemCategory.ARMOUR;
  1304. 			const armour = () => this.armour();
  1305. 			return this.#inventoryToEquipment(inventory_slot, armour_slot, armour, error_if_false, "armour", update_ui);
  1306. 		}
  1307.  
  1308. 		inventoryToWeapon(inventory_slot, weapon_slot, update_ui = UiUpdate.YES) {
  1309. 			const adjusted_weapon_slot = weapon_slot + 30;
  1310. 			const error_if_false = (inventory_item) => inventory_item === undefined || inventory_item.category === ItemCategory.WEAPON;
  1311. 			const weapon = () => this.weapon(weapon_slot);
  1312. 			return this.#inventoryToEquipment(inventory_slot, adjusted_weapon_slot, weapon, error_if_false, "weapon", update_ui);
  1313. 		}
  1314.  
  1315. 		inventoryToHat(inventory_slot, update_ui = UiUpdate.YES) {
  1316. 			const hat_slot = 40;
  1317. 			const error_if_false = (inventory_item) => inventory_item === undefined || (inventory_item.category === ItemCategory.ITEM && inventory_item.subcategory === ItemSubcategory.CLOTHING && inventory_item.properties.get("clothing_type") === "hat");
  1318. 			const hat = () => this.hat();
  1319. 			return this.#inventoryToEquipment(inventory_slot, hat_slot, hat, error_if_false, "hat", update_ui);
  1320. 		}
  1321.  
  1322. 		inventoryToMask(inventory_slot, update_ui = UiUpdate.YES) {
  1323. 			const mask_slot = 39;
  1324. 			const error_if_false = (inventory_item) => inventory_item === undefined || (inventory_item.category === ItemCategory.ITEM && inventory_item.subcategory === ItemSubcategory.CLOTHING && inventory_item.properties.get("clothing_type") === "mask");
  1325. 			const mask = () => this.mask();
  1326. 			return this.#inventoryToEquipment(inventory_slot, mask_slot, mask, error_if_false, "mask", update_ui);
  1327. 		}
  1328.  
  1329. 		inventoryToCoat(inventory_slot, update_ui = UiUpdate.YES) {
  1330. 			const coat_slot = 38;
  1331. 			const error_if_false = (inventory_item) => inventory_item === undefined || (inventory_item.category === ItemCategory.ITEM && inventory_item.subcategory === ItemSubcategory.CLOTHING && inventory_item.properties.get("clothing_type") === "coat");
  1332. 			const coat = () => this.coat();
  1333. 			return this.#inventoryToEquipment(inventory_slot, coat_slot, coat, error_if_false, "coat", update_ui);
  1334. 		}
  1335.  
  1336. 		inventoryToShirt(inventory_slot, update_ui = UiUpdate.YES) {
  1337. 			const shirt_slot = 36;
  1338. 			const error_if_false = (inventory_item) => inventory_item === undefined || (inventory_item.category === ItemCategory.ITEM && inventory_item.subcategory === ItemSubcategory.CLOTHING && inventory_item.properties.get("clothing_type") === "shirt");
  1339. 			const shirt = () => this.shirt();
  1340. 			return this.#inventoryToEquipment(inventory_slot, shirt_slot, shirt, error_if_false, "shirt", update_ui);
  1341. 		}
  1342.  
  1343. 		inventoryToTrousers(inventory_slot, update_ui = UiUpdate.YES) {
  1344. 			const trousers_slot = 37;
  1345. 			const error_if_false = (inventory_item) => inventory_item === undefined || (inventory_item.category === ItemCategory.ITEM && inventory_item.subcategory === ItemSubcategory.CLOTHING && inventory_item.properties.get("clothing_type") === "trousers");
  1346. 			const trousers = () => this.trousers();
  1347. 			return this.#inventoryToEquipment(inventory_slot, trousers_slot, trousers, error_if_false, "trousers", update_ui);
  1348. 		}
  1349.  
  1350. 		inventoryToStorage(inventory_slot, storage_slot, update_ui = UiUpdate.YES) {
  1351. 			const instance = this;
  1352. 			const promise = new Promise(function(resolve, reject) {
  1353. 				const parameters = instance.#setupMoveParameters();
  1354. 				parameters["action"] = "store";
  1355. 				const inventory_item = instance.itemFromInventorySlot(inventory_slot);
  1356. 				const storage_item = instance.itemFromStorageSlot(storage_slot);
  1357. 				parameters["itemnum"] = inventory_slot.toString();
  1358. 				parameters["itemnum2"] = (storage_slot + 40).toString();
  1359. 				parameters["expected_itemtype"] = inventory_item !== undefined  ? inventory_item.full_type : "";
  1360. 				parameters["expected_itemtype2"] = storage_item !== undefined ? storage_item.full_type : "";
  1361. 				webCall("inventory_new", parameters, function(data)
  1362. 				{
  1363. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  1364. 					const [inventory_new, storage_new] = instance.#moveResult(inventory_item, storage_item);
  1365. 					if (storage_new !== undefined) {
  1366. 						updateIntoArr(instance.#storageArrayFromSlotItem(storage_slot, storage_new), storageBox);
  1367. 					} else {
  1368. 						delete storageBox["df_store" + storage_slot.toString() + "_type"];
  1369. 						delete storageBox["df_store" + storage_slot.toString() + "_quantity"];
  1370. 					}
  1371. 					if (update_ui) {
  1372. 						populateStorage();
  1373. 						populateInventory();
  1374. 						updateAllFields();
  1375. 					}
  1376. 					resolve(instance);
  1377. 				}, true);
  1378. 			});
  1379. 			return promise;
  1380. 		}
  1381.  
  1382. 		storageToInventory(storage_slot, inventory_slot, update_ui = UiUpdate.YES) {
  1383. 			// Slightly different because the first item in the inventory_new webCall must be defined, and the final
  1384. 			// item/stack will end up in inventory. i.e. If there is no item in the inventory slot for inventoryToStorage,
  1385. 			// it will not do anything. (Also has a different action type.)
  1386. 			const instance = this;
  1387. 			const promise = new Promise(function(resolve, reject) {
  1388. 				const parameters = instance.#setupMoveParameters();
  1389. 				parameters["action"] = "take";
  1390. 				const inventory_item = instance.itemFromInventorySlot(inventory_slot);
  1391. 				const storage_item = instance.itemFromStorageSlot(storage_slot);
  1392. 				parameters["itemnum"] = (storage_slot + 40).toString();
  1393. 				parameters["itemnum2"] = inventory_slot.toString();
  1394. 				parameters["expected_itemtype"] = storage_item !== undefined ? storage_item.full_type : "";
  1395. 				parameters["expected_itemtype2"] = inventory_item !== undefined  ? inventory_item.full_type : "";
  1396. 				webCall("inventory_new", parameters, function(data)
  1397. 				{
  1398. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  1399. 					const [storage_new, inventory_new] = instance.#moveResult(storage_item, inventory_item);
  1400. 					if (storage_new !== undefined) {
  1401. 						updateIntoArr(instance.#storageArrayFromSlotItem(storage_slot, storage_new), storageBox);
  1402. 					} else {
  1403. 						delete storageBox["df_store" + storage_slot.toString() + "_type"];
  1404. 						delete storageBox["df_store" + storage_slot.toString() + "_quantity"];
  1405. 					}
  1406. 					if (update_ui) {
  1407. 						populateStorage();
  1408. 						populateInventory();
  1409. 						updateAllFields();
  1410. 					}
  1411. 					resolve(instance);
  1412. 				}, true);
  1413. 			});
  1414. 			return promise;
  1415. 		}
  1416.  
  1417. 		inventoryToBackpack(inventory_slot, backpack_slot, update_ui = UiUpdate.YES) {
  1418. 			const instance = this;
  1419. 			const promise = new Promise(function(resolve, reject) {
  1420. 				const parameters = instance.#setupMoveParameters();
  1421. 				parameters["action"] = "backpack";
  1422. 				const inventory_item = instance.itemFromInventorySlot(inventory_slot);
  1423. 				const backpack_item = instance.itemFromBackpackSlot(backpack_slot);
  1424. 				parameters["itemnum"] = inventory_slot.toString();
  1425. 				parameters["itemnum2"] = (backpack_slot + 1050).toString();
  1426. 				parameters["expected_itemtype"] = inventory_item !== undefined  ? inventory_item.full_type : "";
  1427. 				parameters["expected_itemtype2"] = backpack_item !== undefined ? backpack_item.full_type : "";
  1428. 				webCall("hotrods/backpack", parameters, function(data)
  1429. 				{
  1430. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  1431. 					if (update_ui) {
  1432. 						populateBackpack();
  1433. 						populateInventory();
  1434. 						updateAllFields();
  1435. 					}
  1436. 					resolve(instance);
  1437. 				}, true);
  1438. 			});
  1439. 			return promise;
  1440. 		}
  1441.  
  1442. 		backpackToInventory(backpack_slot, inventory_slot, update_ui = UiUpdate.YES) {
  1443. 			const instance = this;
  1444. 			const promise = new Promise(function(resolve, reject) {
  1445. 				const parameters = instance.#setupMoveParameters();
  1446. 				parameters["action"] = "backpack";
  1447. 				const inventory_item = instance.itemFromInventorySlot(inventory_slot);
  1448. 				const backpack_item = instance.itemFromBackpackSlot(backpack_slot);
  1449. 				parameters["itemnum"] = (backpack_slot + 1050).toString();
  1450. 				parameters["itemnum2"] = inventory_slot.toString();
  1451. 				parameters["expected_itemtype"] = backpack_item !== undefined  ? backpack_item.full_type : "";
  1452. 				parameters["expected_itemtype2"] = inventory_item !== undefined ? inventory_item.full_type : "";
  1453. 				webCall("hotrods/backpack", parameters, function(data)
  1454. 				{
  1455. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  1456. 					if (update_ui) {
  1457. 						populateBackpack();
  1458. 						populateInventory();
  1459. 						updateAllFields();
  1460. 					}
  1461. 					resolve(instance);
  1462. 				}, true);
  1463. 			});
  1464. 			return promise;
  1465. 		}
  1466.  
  1467. 		emptyBackpackToInventory(update_ui = UiUpdate.YES) {
  1468. 			const instance = this;
  1469. 			const promise = new Promise(function(resolve, reject) {
  1470. 				const parameters = instance.#setupMoveParameters();
  1471. 				parameters["action"] = "empty";
  1472. 				parameters["itemnum"] = "";
  1473. 				parameters["itemnum2"] = "";
  1474. 				parameters["expected_itemtype"] = "";
  1475. 				parameters["expected_itemtype2"] = "";
  1476. 				webCall("hotrods/backpack", parameters, function(data)
  1477. 				{
  1478. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  1479. 					if (update_ui) {
  1480. 						populateBackpack();
  1481. 						populateInventory();
  1482. 						updateAllFields();
  1483. 					}
  1484. 					resolve(instance);
  1485. 				}, true);
  1486. 			});
  1487. 			return promise;
  1488. 		}
  1489.  
  1490. 		backpackToImplants(backpack_slot, implant_slot, update_ui = UiUpdate.YES) {
  1491. 			const instance = this;
  1492. 			const promise = new Promise(function(resolve, reject) {
  1493. 				const parameters = instance.#setupMoveParameters();
  1494. 				parameters["action"] = "backpack";
  1495. 				const implant_item = instance.itemFromImplantSlot(implant_slot);
  1496. 				const backpack_item = instance.itemFromBackpackSlot(backpack_slot);
  1497. 				const primary_slot = backpack_item !== undefined ? backpack_slot + 1050 : implant_slot + 1000;
  1498. 				const secondary_slot = backpack_item !== undefined ? implant_slot + 1000: backpack_slot + 1050;
  1499. 				const primary_item = backpack_item !== undefined ? backpack_item.full_type : implant_item.full_type;
  1500. 				const secondary_item = (backpack_item !== undefined && implant_item !== undefined) ? implant_item.full_type : "";
  1501. 				parameters["itemnum"] = primary_slot.toString();
  1502. 				parameters["itemnum2"] = secondary_slot.toString();
  1503. 				parameters["expected_itemtype"] = primary_item;
  1504. 				parameters["expected_itemtype2"] = secondary_item;
  1505. 				webCall("hotrods/backpack", parameters, function(data)
  1506. 				{
  1507. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  1508. 					if (update_ui) {
  1509. 						populateBackpack();
  1510. 						populateImplants();
  1511. 						updateAllFields();
  1512. 					}
  1513. 					resolve(instance);
  1514. 				}, true);
  1515. 			});
  1516. 			return promise;
  1517. 		}
  1518.  
  1519. 		implantsToImplants(primary_slot, secondary_slot, update_ui = UiUpdate.YES) {
  1520. 			const instance = this;
  1521. 			const promise = new Promise(function(resolve, reject) {
  1522. 				// Using just the itemnum and expected_itemtype work but cause a connection error almost everytime. I'm
  1523. 				// not sure which of these are necessary, so I just included everything.
  1524. 				const primary_item = instance.itemFromImplantSlot(primary_slot);
  1525. 				const secondary_item = instance.itemFromImplantSlot(secondary_slot);
  1526. 				const parameters = {};
  1527. 				const uservars = instance.#_uservars;
  1528. 				parameters["pagetime"] = uservars["pagetime"];
  1529. 				parameters["templateID"] = uservars["template_ID"];
  1530. 				parameters["sc"] = uservars["sc"];
  1531. 				parameters["creditsnum"] = instance.#_uservars["DFSTATS_df_credits"];
  1532. 				parameters["buynum"] = "0";
  1533. 				parameters["renameto"] = "undefined`undefined";
  1534. 				parameters["expected_itemprice"] = "-1";
  1535. 				parameters["expected_itemtype2"] = secondary_item !== undefined ? secondary_item.full_type : "";
  1536. 				parameters["expected_itemtype"] = primary_item !== undefined ? primary_item.full_type : "";
  1537. 				parameters["itemnum2"] = (secondary_slot + 1000).toString();
  1538. 				parameters["itemnum"] = (primary_slot + 1000).toString();
  1539. 				parameters["price"] = "2400000";
  1540. 				parameters["gv"] = "21";
  1541. 				parameters["userID"] = uservars["userID"];
  1542. 				parameters["password"] = uservars["password"];
  1543. 				parameters["action"] = "newswap";
  1544. 				webCall("inventory_new", parameters, function(data)
  1545. 				{
  1546. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  1547. 					if (update_ui) {
  1548. 						populateImplants();
  1549. 						updateAllFields();
  1550. 					}
  1551. 					resolve(instance);
  1552. 				}, true);
  1553. 			});
  1554. 			return promise;
  1555. 		}
  1556.  
  1557. 		// Usage, Discard, Scrap, Mastercraft
  1558.  
  1559. 		#setupItemScrapRequest() {
  1560. 			const parameters = {};
  1561. 			parameters["pagetime"] = this.#_uservars["pagetime"];
  1562. 			parameters["templateID"] = this.#_uservars["template_ID"];
  1563. 			parameters["sc"] = this.#_uservars["sc"];
  1564. 			parameters["creditsnum"] = 0;
  1565. 			parameters["buynum"] = 0;
  1566. 			parameters["renameto"] = "";
  1567. 			parameters["expected_itemprice"] = "-1";
  1568. 			parameters["expected_itemtype2"] = "";
  1569. 			parameters["itemnum2"] = "0";
  1570. 			parameters["userID"] = this.#_uservars["userID"];
  1571. 			parameters["password"] = this.#_uservars["password"];
  1572. 			return parameters;
  1573. 		}
  1574.  
  1575. 		scrapInventoryItem(slot, inventory_item, update_ui = UiUpdate.YES) {
  1576. 			const instance = this;
  1577. 			const promise = new Promise(function(resolve, reject) {
  1578. 				const scrap_value = scrapValue(inventory_item.full_type, inventory_item.quantity);
  1579. 				const parameters = instance.#setupItemRemovalRequest();
  1580. 				parameters["action"] = "scrap";
  1581. 				parameters["price"] = scrap_value;
  1582. 				parameters["itemnum"] = slot.toString();
  1583. 				parameters["expected_itemtype"] = inventory_item.full_type;
  1584. 				webCall("inventory_new", parameters, function(data) {
  1585. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  1586. 					if (update_ui === UiUpdate.YES) {
  1587. 						populateInventory();
  1588. 						populateCharacterInventory();
  1589. 						updateAllFields();
  1590. 						renderAvatarUpdate();
  1591. 						const cash = instance.#_uservars["DFSTATS_df_cash"];
  1592. 						const bank = instance.#_uservars["DFSTATS_df_bankcash"];
  1593. 						updateCashBank(cash, bank);
  1594. 					}
  1595. 					resolve(instance);
  1596. 				}, true);
  1597. 			});
  1598. 			return promise;
  1599. 		}
  1600.  
  1601. 		#setupItemMastercraftRequest() {
  1602. 			const parameters = {};
  1603. 			parameters["pagetime"] = this.#_uservars["pagetime"];
  1604. 			parameters["templateID"] = this.#_uservars["template_ID"];
  1605. 			parameters["sc"] = this.#_uservars["sc"];
  1606. 			parameters["creditsnum"] = 0;
  1607. 			parameters["buynum"] = 0;
  1608. 			parameters["renameto"] = "";
  1609. 			parameters["expected_itemprice"] = "-1";
  1610. 			parameters["expected_itemtype2"] = "";
  1611. 			parameters["itemnum2"] = "0";
  1612. 			parameters["userID"] = this.#_uservars["userID"];
  1613. 			parameters["password"] = this.#_uservars["password"];
  1614. 			return parameters;
  1615. 		}
  1616.  
  1617. 		mastercraftInventoryItem(slot, inventory_item, update_ui = UiUpdate.YES) {
  1618. 			const instance = this;
  1619. 			const promise = new Promise(function(resolve, reject) {
  1620. 				const enhance_value = enhanceValue(inventory_item.full_type);
  1621. 				const parameters = instance.#setupItemMastercraftRequest();
  1622. 				parameters["action"] = "enhance";
  1623. 				parameters["price"] = enhance_value;
  1624. 				parameters["itemnum"] = slot.toString();
  1625. 				parameters["expected_itemtype"] = inventory_item.full_type;
  1626. 				webCall("inventory_new", parameters, function(data) {
  1627. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  1628. 					if (update_ui === UiUpdate.YES) {
  1629. 						populateInventory();
  1630. 						populateCharacterInventory();
  1631. 						updateAllFields();
  1632. 						renderAvatarUpdate();
  1633. 						const cash = instance.#_uservars["DFSTATS_df_cash"];
  1634. 						const bank = instance.#_uservars["DFSTATS_df_bankcash"];
  1635. 						updateCashBank(cash, bank);
  1636. 					}
  1637. 					resolve(instance);
  1638. 				}, true);
  1639. 			});
  1640. 			return promise;
  1641. 		}
  1642.  
  1643. 		#setupItemRemovalRequest() {
  1644. 			const parameters = {};
  1645. 			parameters["pagetime"] = this.#_uservars["pagetime"];
  1646. 			parameters["templateID"] = this.#_uservars["template_ID"];
  1647. 			parameters["sc"] = this.#_uservars["sc"];
  1648. 			parameters["creditsnum"] = this.#_uservars["DFSTATS_df_credits"];
  1649. 			parameters["buynum"] = "0";
  1650. 			parameters["renameto"] = "undefined`undefined";
  1651. 			parameters["expected_itemprice"] = "-1";
  1652. 			parameters["price"] = getUpgradePrice();
  1653. 			parameters["userID"] = this.#_uservars["userID"];
  1654. 			parameters["password"] = this.#_uservars["password"];
  1655. 			return parameters;
  1656. 		}
  1657.  
  1658. 		#useActionType(item) {
  1659. 			const global_data = PlayerItems.#global_data;
  1660. 			const medicine = parseInt(global_data[item.base_type]["healthrestore"]) > 0;
  1661. 			const usable_gm_ticket = global_data[item.base_type]["gm_days"] && global_data[item.base_type]["gm_days"] !== "0";
  1662. 			const food = parseInt(global_data[item.base_type]["foodrestore"]) > 0;
  1663. 			const boost = parseInt(global_data[item.base_type]["boostdamagehours"]) > 0 || parseInt(global_data[item.base_type]["boostexphours"]) > 0 || parseInt(global_data[item.base_type]["boostspeedhours"]) > 0;
  1664. 			const story_item = global_data[item.base_type]["opencontents"] && global_data[item.base_type]["opencontents"].length > 0;
  1665. 			if (medicine || usable_gm_ticket) {
  1666. 				return "newuse";
  1667. 			} else if (food) {
  1668. 				return "newconsume";
  1669. 			} else if (boost) {
  1670. 				return "newboost";
  1671. 			} else if (story_item) {
  1672. 				return "newopen";
  1673. 			} else {
  1674. 				return false;
  1675. 			}
  1676. 		}
  1677.  
  1678. 		#actionNecessary(item) {
  1679. 			const global_data = PlayerItems.#global_data;
  1680. 			const medicine = parseInt(global_data[item.base_type]["healthrestore"]) > 0;
  1681. 			const usable_gm_ticket = global_data[item.base_type]["gm_days"] && global_data[item.base_type]["gm_days"] !== "0";
  1682. 			const food = parseInt(global_data[item.base_type]["foodrestore"]) > 0;
  1683. 			const boost = parseInt(global_data[item.base_type]["boostdamagehours"]) > 0 || parseInt(global_data[item.base_type]["boostexphours"]) > 0 || parseInt(global_data[item.base_type]["boostspeedhours"]) > 0;
  1684. 			const story_item = global_data[item.base_type]["opencontents"] && global_data[item.base_type]["opencontents"].length > 0;
  1685. 			const need_health = parseInt(this.#_uservars["DFSTATS_df_hpcurrent"]) < parseInt(this.#_uservars["DFSTATS_df_hpmax"]);
  1686. 			const need_hunger = parseInt(this.#_uservars["DFSTATS_df_hungerhp"]) < 100;
  1687. 			if (medicine) {
  1688. 				return need_health;
  1689. 			} else if (food) {
  1690. 				return need_hunger;
  1691. 			} else {
  1692. 				return true;
  1693. 			}
  1694. 		}
  1695.  
  1696. 		useInventoryItem(slot, inventory_item, update_ui = UiUpdate.YES) {
  1697. 			const instance = this;
  1698. 			const promise = new Promise(function(resolve, reject) {
  1699. 				const action_type = instance.#useActionType(inventory_item);
  1700. 				if (!action_type) {
  1701. 					throw new TypeError("Cannot use Item: " + inventory_item.full_type + ".");
  1702. 				}
  1703. 				const action_necessary = instance.#actionNecessary(inventory_item);
  1704. 				if (!action_necessary) {
  1705. 					throw new RangeError("Item: " + inventory_item.full_type + " will provide no benefit when used.");
  1706. 				}
  1707. 				const parameters = instance.#setupItemRemovalRequest();
  1708. 				parameters["action"] = action_type;
  1709. 				parameters["itemnum"] = slot.toString();
  1710. 				parameters["itemnum2"] = "0";
  1711. 				parameters["expected_itemtype"] = inventory_item.full_type;
  1712. 				parameters["expected_itemtype2"] = "";
  1713. 				webCall("inventory_new", parameters, function(data) {
  1714. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  1715. 					if (update_ui === UiUpdate.YES) {
  1716. 						populateInventory();
  1717. 						populateCharacterInventory();
  1718. 						updateAllFields();
  1719. 					}
  1720. 					resolve(instance);
  1721. 				}, true);
  1722. 			});
  1723. 			return promise;
  1724. 		}
  1725.  
  1726. 		useBackpackItem(slot, item, update_ui = UiUpdate.YES) {
  1727. 			return this.useInventoryItem(slot + 1050, item, update_ui);
  1728. 		}
  1729.  
  1730. 		discardInventoryItem(slot, inventory_item, update_ui = UiUpdate.YES) {
  1731. 			const instance = this;
  1732. 			const promise = new Promise(function(resolve, reject) {
  1733. 				const parameters = instance.#setupItemRemovalRequest();
  1734. 				parameters["action"] = "newdiscard";
  1735. 				parameters["itemnum"] = slot.toString();
  1736. 				parameters["itemnum2"] = "0";
  1737. 				parameters["expected_itemtype"] = inventory_item.full_type;
  1738. 				parameters["expected_itemtype2"] = "";
  1739. 				webCall("inventory_new", parameters, function(data) {
  1740. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  1741. 					if (update_ui === UiUpdate.YES) {
  1742. 						populateInventory();
  1743. 						populateCharacterInventory();
  1744. 						updateAllFields();
  1745. 						renderAvatarUpdate();
  1746. 					}
  1747. 					resolve(instance);
  1748. 				}, true);
  1749. 			});
  1750. 			return promise;
  1751. 		}
  1752.  
  1753. 		discardBackpackItem(slot, item, update_ui = UiUpdate.YES) {
  1754. 			return this.discardInventoryItem(slot + 1050, item, update_ui);
  1755. 		}
  1756.  
  1757. 		#setupItemMutateRequest() {
  1758. 			const parameters = {};
  1759. 			parameters["pagetime"] = this.#_uservars["pagetime"];
  1760. 			parameters["templateID"] = this.#_uservars["template_ID"];
  1761. 			parameters["sc"] = this.#_uservars["sc"];
  1762. 			parameters["creditsnum"] = this.#_uservars["DFSTATS_df_credits"];
  1763. 			parameters["buynum"] = "0";
  1764. 			parameters["renameto"] = "undefined`undefined";
  1765. 			parameters["expected_itemprice"] = "-1";
  1766. 			parameters["price"] = "0";
  1767. 			parameters["userID"] = this.#_uservars["userID"];
  1768. 			parameters["password"] = this.#_uservars["password"];
  1769. 			return parameters;
  1770. 		}
  1771.  
  1772. 		mutateItem(slot, item, new_item_type, update_ui = UiUpdate.YES) {
  1773. 			const instance = this;
  1774. 			const promise = new Promise(function(resolve, reject) {
  1775. 				const parameters = instance.#setupItemRemovalRequest();
  1776. 				parameters["action"] = "mutate";
  1777. 				parameters["itemnum"] = slot.toString();
  1778. 				parameters["itemnum2"] = "0";
  1779. 				parameters["expected_itemtype"] = item.full_type;
  1780. 				parameters["expected_itemtype2"] = new_item_type;
  1781. 				webCall("inventory_new", parameters, function(data) {
  1782. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  1783. 					if (update_ui === UiUpdate.YES) {
  1784. 						populateInventory();
  1785. 						populateCharacterInventory();
  1786. 						populateImplants();
  1787. 						updateAllFields();
  1788. 						renderAvatarUpdate();
  1789. 					}
  1790. 					resolve(instance);
  1791. 				}, true);
  1792. 			});
  1793. 			return promise;
  1794. 		}
  1795.  
  1796. 		updateLockedSlots() {
  1797. 			// TODO: Add support for implants and equipment later.
  1798. 			const inventory = document.getElementById("inventory");
  1799. 			const backpack = document.getElementById("backpackdisplay");
  1800. 			if (inventory !== null) {
  1801. 				const inventory_slots = inventory.querySelectorAll("td.validSlot");
  1802. 				for (const slot of inventory_slots) {
  1803. 					const index = slot.dataset.slot;
  1804. 					if (lockedSlots.includes(index.toString()) && !slot.classList.contains("locked")) {
  1805. 						slot.classList.add("locked");
  1806. 					} else if (slot.classList.contains("locked")) {
  1807. 						slot.classList.remove("locked");
  1808. 					}
  1809. 				}
  1810. 			}
  1811. 			if (backpack !== null) {
  1812. 				const backpack_slots = backpack.querySelectorAll("td.validSlot");
  1813. 				for (const slot of backpack_slots) {
  1814. 					const index = slot.dataset.slot + 1050;
  1815. 					if (lockedSlots.includes(index.toString()) && !slot.classList.contains("locked")) {
  1816. 						slot.classList.add("locked");
  1817. 					} else if (slot.classList.contains("locked")) {
  1818. 						slot.classList.remove("locked");
  1819. 					}
  1820. 				}
  1821. 			}
  1822. 		}
  1823.  
  1824. 		lockInventorySlot(slot, update_ui = UiUpdate.YES) {
  1825. 			const instance = this;
  1826. 			const promise = new Promise(function(resolve, reject) {
  1827. 				const parameters = instance.#setupItemRemovalRequest();
  1828. 				const uservars = instance.#_uservars;
  1829. 				parameters["itemnum"] = slot.toString();
  1830. 				parameters["userID"] = uservars["userID"];
  1831. 				parameters["password"] = uservars["password"];
  1832. 				parameters["sc"] = uservars["sc"];
  1833. 				parameters["gv"] = "21";
  1834. 				parameters["action"] = "addSlot";
  1835. 				webCall("hotrods/item_lock", parameters, function(data) {
  1836. 					lockedSlots = data.split(',');
  1837. 					if (update_ui === UiUpdate.YES) {
  1838. 						populateInventory();
  1839. 						doLockedElems();
  1840. 						instance.updateLockedSlots();
  1841. 						updateAllFields();
  1842. 					}
  1843. 					resolve(instance);
  1844. 				}, true);
  1845. 			});
  1846. 			return promise;
  1847. 		}
  1848.  
  1849. 		unlockInventorySlot(slot, update_ui = UiUpdate.YES) {
  1850. 			const instance = this;
  1851. 			const promise = new Promise(function(resolve, reject) {
  1852. 				const parameters = instance.#setupItemRemovalRequest();
  1853. 				const uservars = instance.#_uservars;
  1854. 				parameters["itemnum"] = slot.toString();
  1855. 				parameters["userID"] = uservars["userID"];
  1856. 				parameters["password"] = uservars["password"];
  1857. 				parameters["sc"] = uservars["sc"];
  1858. 				parameters["gv"] = "21";
  1859. 				parameters["action"] = "removeSlot";
  1860. 				webCall("hotrods/item_lock", parameters, function(data) {
  1861. 					lockedSlots = data.split(',');
  1862. 					if (update_ui === UiUpdate.YES) {
  1863. 						populateInventory();
  1864. 						doLockedElems();
  1865. 						instance.updateLockedSlots();
  1866. 						updateAllFields();
  1867. 					}
  1868. 					resolve(instance);
  1869. 				}, true);
  1870. 			});
  1871. 			return promise;
  1872. 		}
  1873.  
  1874. 		lockBackpackSlot(slot, update_ui = UiUpdate.YES) {
  1875. 			const instance = this;
  1876. 			const promise = new Promise(function(resolve, reject) {
  1877. 				const parameters = instance.#setupItemRemovalRequest();
  1878. 				const uservars = instance.#_uservars;
  1879. 				parameters["itemnum"] = (slot + 1050).toString();
  1880. 				parameters["userID"] = uservars["userID"];
  1881. 				parameters["password"] = uservars["password"];
  1882. 				parameters["sc"] = uservars["sc"];
  1883. 				parameters["gv"] = "21";
  1884. 				parameters["action"] = "addSlot";
  1885. 				webCall("hotrods/item_lock", parameters, function(data) {
  1886. 					lockedSlots = data.split(',');
  1887. 					if (update_ui === UiUpdate.YES) {
  1888. 						populateBackpack();
  1889. 						doLockedElems();
  1890. 						instance.updateLockedSlots();
  1891. 						updateAllFields();
  1892. 					}
  1893. 					resolve(instance);
  1894. 				}, true);
  1895. 			});
  1896. 			return promise;
  1897. 		}
  1898.  
  1899. 		unlockBackpackSlot(slot, update_ui = UiUpdate.YES) {
  1900. 			const instance = this;
  1901. 			const promise = new Promise(function(resolve, reject) {
  1902. 				const parameters = instance.#setupItemRemovalRequest();
  1903. 				const uservars = instance.#_uservars;
  1904. 				parameters["itemnum"] = (slot + 1050).toString();
  1905. 				parameters["userID"] = uservars["userID"];
  1906. 				parameters["password"] = uservars["password"];
  1907. 				parameters["sc"] = uservars["sc"];
  1908. 				parameters["gv"] = "21";
  1909. 				parameters["action"] = "removeSlot";
  1910. 				webCall("hotrods/item_lock", parameters, function(data) {
  1911. 					lockedSlots = data.split(',');
  1912. 					if (update_ui === UiUpdate.YES) {
  1913. 						populateBackpack();
  1914. 						doLockedElems();
  1915. 						instance.updateLockedSlots();
  1916. 						updateAllFields();
  1917. 					}
  1918. 					resolve(instance);
  1919. 				}, true);
  1920. 			});
  1921. 			return promise;
  1922. 		}
  1923. 	}
  1924.  
  1925. 	// MarketItems
  1926.  
  1927. 	class MarketItems {
  1928.  
  1929. 		static #global_data = globalData;
  1930.  
  1931. 		#typeInGlobalData(base_type) {
  1932. 			return base_type in MarketItems.#global_data;
  1933. 		}
  1934.  
  1935. 		#_uservars;
  1936. 		#_data;
  1937. 		#_nselling;
  1938. 		#_publicselling;
  1939. 		constructor() {
  1940. 			this.#_uservars = userVars;
  1941. 		}
  1942.  
  1943. 		// Availability Checks
  1944.  
  1945. 		sellingEntriesAvailable() {
  1946. 			// Run after requesting data.
  1947. 			const data = this.#_data;
  1948. 			const nselling = this.#_nselling;
  1949. 			const publicselling = this.#_publicselling;
  1950. 			for (let i = 0; i < publicselling; i++) {
  1951. 				const full_type = data.get("tradelist_" + i.toString() + "_item");
  1952. 				const base_type = typeSplit(full_type)[0];
  1953. 				if (!this.#typeInGlobalData(base_type)) {
  1954. 					return false;
  1955. 				}
  1956. 			}
  1957. 			return true;
  1958. 		}
  1959.  
  1960. 		// Selling Queries
  1961.  
  1962. 		#setupSellingWebcallParameters() {
  1963. 			const parameters = {};
  1964. 			parameters["pagetime"] = this.#_uservars["pagetime"];
  1965. 			parameters["tradezone"] = "";
  1966. 			parameters["searchname"] = "";
  1967. 			parameters["searchtype"] = "sellinglist";
  1968. 			parameters["search"] = "trades";
  1969. 			parameters["memID"] = this.#_uservars["userID"];
  1970. 			parameters["category"] = "";
  1971. 			parameters["profession"] = "";
  1972. 			return parameters;
  1973. 		}
  1974.  
  1975. 		requestSelling() {
  1976. 			const instance = this;
  1977. 			const promise = new Promise(function(resolve, reject) {
  1978. 				const parameters = instance.#setupSellingWebcallParameters();
  1979. 				webCall("trade_search", parameters, function(data) {
  1980. 					instance.#_data = responseToMap(data);
  1981. 					// maxresults is the number of results for this type of trade, while totalsales is across all trades (public and private)
  1982. 					// totalsales is shared between public and private sales (30 is the total sales between public and private)
  1983. 					instance.#_nselling = parseInt(instance.#_data.get("tradelist_totalsales")); // maxresults vs. totalsales?
  1984. 					instance.#_publicselling = parseInt(instance.#_data.get("tradelist_maxresults"));
  1985. 					resolve(instance);
  1986. 				});
  1987. 			});
  1988. 			return promise;
  1989. 		}
  1990.  
  1991. 		maxSellingEntries() {
  1992. 			const uservars = this.#_uservars;
  1993. 			const nslots = parseInt(uservars["DFSTATS_df_invslots"]);
  1994. 			return nslots; // Maximum selling entries equal to number of inventory slots.
  1995. 		}
  1996.  
  1997. 		nSellingEntries() {
  1998. 			return this.#_nselling;
  1999. 		}
  2000.  
  2001. 		availableSellingEntries() {
  2002. 			return this.maxSellingEntries() - this.nSellingEntries();
  2003. 		}
  2004.  
  2005. 		itemFromSellingIndex(index) {
  2006. 			const data = this.#_data;
  2007. 			const full_type = data.get("tradelist_" + index.toString() + "_item");
  2008. 			const name = data.get("tradelist_" + index.toString() + "_itemname");
  2009. 			const quantity = data.get("tradelist_" + index.toString() + "_quantity");
  2010. 			const item = new Item(full_type, name, quantity);
  2011. 			return item;
  2012. 		}
  2013.  
  2014. 		marketEntryFromSellingIndex(index) {
  2015. 			const item = this.itemFromSellingIndex(index);
  2016. 			const data = this.#_data;
  2017. 			const price =  data.get("tradelist_" + index.toString() + "_price");
  2018. 			const trade_id = data.get("tradelist_" + index.toString() + "_trade_id");
  2019. 			const member_id = data.get("tradelist_" + index.toString() + "_id_member");
  2020. 			const member_name = data.get("tradelist_" + index.toString() + "_member_name");
  2021. 			const tradezone = data.get("tradelist_" + index.toString() + "_trade_zone");
  2022. 			const market_entry = new ItemMarketEntry(item, price, trade_id, member_id, member_name, tradezone);
  2023. 			return market_entry;
  2024. 		}
  2025.  
  2026. 		sellingEntryFromSellingIndex(index) {
  2027. 			const market_entry = this.marketEntryFromSellingIndex(index);
  2028. 			const data = this.#_data;
  2029. 			const member_to_id = data.get("tradelist_" + index.toString() + "_id_member_to");
  2030. 			const member_to_name = data.get("tradelist_" + index.toString() + "_member_to_name");
  2031. 			const selling_entry = new ItemSellingEntry(market_entry, member_to_id, member_to_name);
  2032. 			return selling_entry;
  2033. 		}
  2034.  
  2035. 		*sellingEntries() {
  2036. 			for (let i = 0; i < this.#_publicselling; i++) {
  2037. 				yield [i, this.sellingEntryFromSellingIndex(i)];
  2038. 			}
  2039. 		}
  2040.  
  2041. 		// Selling Changes
  2042.  
  2043. 		#setupCancelSellingParameters() {
  2044. 			const parameters = {};
  2045. 			parameters["pagetime"] = this.#_uservars["pagetime"];
  2046. 			parameters["templateID"] = this.#_uservars["template_ID"];
  2047. 			parameters["sc"] = this.#_uservars["sc"];
  2048. 			parameters["creditsnum"] = "0";
  2049. 			parameters["renameto"] = "";
  2050. 			parameters["expected_itemprice"] = "-1";
  2051. 			parameters["expected_itemtype2"] = "";
  2052. 			parameters["expected_itemtype"] = "";
  2053. 			parameters["itemnum2"] = 0;
  2054. 			parameters["itemnum"] = 0;
  2055. 			parameters["price"] = 0;
  2056. 			parameters["action"] = "newcancelsale";
  2057. 			parameters["userID"] = this.#_uservars["userID"];
  2058. 			parameters["password"] = this.#_uservars["password"];
  2059. 			return parameters
  2060. 		}
  2061.  
  2062. 		cancelSellingEntry(selling_entry, update_ui = UiUpdate.YES) {
  2063. 			const instance = this;
  2064. 			const promise = new Promise(function(resolve, reject) {
  2065. 				const inventory_space_available = findFirstEmptyGenericSlot("inv") !== false;
  2066. 				const is_credits = selling_entry.market_entry.item.full_type === "credits";
  2067. 				if (!is_credits && !inventory_space_available) {
  2068. 					throw new RangeError("Cannot cancel selling entry if no inventory space is available.");
  2069. 				}
  2070. 				const parameters = instance.#setupCancelSellingParameters();
  2071. 				parameters["buynum"] = selling_entry.market_entry.trade_id;
  2072. 				webCall("inventory_new", parameters, function(data) {
  2073. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  2074. 					if (update_ui === UiUpdate.YES) {
  2075. 						if (getSellingList !== undefined) {
  2076. 							getSellingList();
  2077. 						} else { // These functions are also called by getSellingList, but it is undefined out of the marketplace.
  2078. 							populateInventory();
  2079. 							updateAllFields();
  2080. 						}
  2081. 					}
  2082. 					resolve(instance);
  2083. 				}, true);
  2084. 			});
  2085. 			return promise;
  2086. 		}
  2087.  
  2088. 		#setupSellInventoryParameters() {
  2089. 			var parameters = {};
  2090. 			parameters["pagetime"] = this.#_uservars["pagetime"];
  2091. 			parameters["templateID"] = this.#_uservars["template_ID"];
  2092. 			parameters["sc"] = this.#_uservars["sc"];
  2093. 			parameters["buynum"] = 0;
  2094. 			parameters["renameto"] = "";
  2095. 			parameters["expected_itemprice"] = "-1"; // same on all sales
  2096. 			parameters["expected_itemtype2"] = "";
  2097. 			parameters["expected_itemtype"] = "";
  2098. 			parameters["itemnum2"] = "0";
  2099. 			parameters["userID"] = this.#_uservars["userID"];
  2100. 			parameters["password"] = this.#_uservars["password"];
  2101. 			return parameters;
  2102. 		}
  2103.  
  2104. 		sellInventoryItem(inventory_slot, inventory_item, price, update_ui = UiUpdate.YES) {
  2105. 			const instance = this;
  2106. 			// return instance.requestSelling().then(
  2107. 			const promise = new Promise(function(resolve, reject) {
  2108. 				// const selling_list_has_space = instance.#_nselling < parseInt(instance.#_uservars["DFSTATS_df_invslots"]);
  2109. 				// if (!selling_list_has_space) {
  2110. 				// 	throw new RangeError("Cannot sell item when selling list is full.");
  2111. 				// }
  2112. 				const parameters = instance.#setupSellInventoryParameters();
  2113. 				parameters["price"] = price;
  2114. 				parameters["action"] = "newsell";
  2115. 				parameters["expected_itemtype"] = inventory_item.full_type;
  2116. 				parameters["itemnum"] = inventory_slot.toString();
  2117. 				webCall("inventory_new", parameters, function(data) {
  2118. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  2119. 					if (update_ui === UiUpdate.YES) {
  2120. 						if (getSellingList !== undefined) {
  2121. 							getSellingList();
  2122. 						} else {
  2123. 							populateInventory();
  2124. 							updateAllFields();
  2125. 						}
  2126. 					}
  2127. 					resolve(instance);
  2128. 				}, true);
  2129. 			});
  2130. 			return promise;
  2131. 		}
  2132.  
  2133. 		// Buying Items
  2134.  
  2135. 		#setupBuyItemParameters() {
  2136. 			const parameters = {};
  2137. 			parameters["pagetime"] = this.#_uservars["pagetime"];
  2138. 			parameters["templateID"] = this.#_uservars["template_ID"];
  2139. 			parameters["sc"] = this.#_uservars["sc"];
  2140. 			parameters["creditsnum"] = "undefined";
  2141. 			parameters["renameto"] = "undefined`undefined";
  2142. 			parameters["expected_itemtype2"] = "";
  2143. 			parameters["expected_itemtype"] = "";
  2144. 			parameters["itemnum2"] = 0;
  2145. 			parameters["itemnum"] = 0;
  2146. 			parameters["price"] = 0;
  2147. 			parameters["action"] = "newbuy";
  2148. 			parameters["userID"] = userVars["userID"];
  2149. 			parameters["password"] = userVars["password"];
  2150. 			return parameters;
  2151. 		}
  2152.  
  2153. 		buyItemFromMarketEntry(market_entry, update_ui = UiUpdate.YES) {
  2154. 			const instance = this;
  2155. 			const promise = new Promise(function(resolve, reject) {
  2156. 				// Throw if inventory is full or not enough cash on-hand.
  2157. 				const inventory_space_available = findFirstEmptyGenericSlot("inv") !== false;
  2158. 				const enough_cash = parseInt(instance.#_uservars["DFSTATS_df_cash"]) >= market_entry.price;
  2159. 				if (!inventory_space_available) {
  2160. 					throw new RangeError("Cannot buy item when inventory is full.");
  2161. 				}
  2162. 				if (!enough_cash) {
  2163. 					throw new RangeError("Cannot buy item: " + market_entry.item.full_type + " with price $" + market_entry.price.toLocaleString() + " with $" + instance.#_uservars["DFSTATS_df_cash"].toLocaleString() + " on-hand.");
  2164. 				}
  2165. 				// Setup parameters and request purchase.
  2166. 				const parameters = instance.#setupBuyItemParameters();
  2167. 				parameters["buynum"] = market_entry.trade_id;
  2168. 				parameters["expected_itemprice"] = market_entry.price;
  2169. 				webCall("inventory_new", parameters, function(data) {
  2170. 					const item_purchase_successful = data !== "";
  2171. 					if (item_purchase_successful) {
  2172. 						updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  2173. 						if (update_ui === UiUpdate.YES) {
  2174. 							populateInventory();
  2175. 							const cash = instance.#_uservars["DFSTATS_df_cash"];
  2176. 							const bank = instance.#_uservars["DFSTATS_df_bankcash"];
  2177. 							updateCashBank(cash, bank);
  2178. 							updateAllFields();
  2179. 						}
  2180. 						resolve(instance);
  2181. 					} else {
  2182. 						reject(instance);
  2183. 					}
  2184. 				}, true);
  2185. 			});
  2186. 			return promise;
  2187. 		}
  2188.  
  2189. 		// Buying Services
  2190.  
  2191. 		#setupBuyServiceParameters() {
  2192. 			const parameters = {};
  2193. 			parameters["pagetime"] = this.#_uservars["pagetime"];
  2194. 			parameters["templateID"] = this.#_uservars["template_ID"];
  2195. 			parameters["sc"] = this.#_uservars["sc"];
  2196. 			parameters["creditsnum"] = 0;
  2197. 			parameters["renameto"] = "undefined`undefined";
  2198. 			parameters["expected_itemtype2"] = "";
  2199. 			parameters["expected_itemtype"] = "";
  2200. 			parameters["itemnum2"] = "0";
  2201. 			parameters["userID"] = this.#_uservars["userID"];
  2202. 			parameters["password"] = this.#_uservars["password"];
  2203. 			return parameters;
  2204. 		}
  2205.  
  2206. 		#buyServiceFromMarketEntry(item_valid, service_needed, action_type, market_entry, slot, inventory_item, update_ui = UiUpdate.YES) {
  2207. 			const instance = this;
  2208. 			const promise = new Promise(function(resolve, reject) {
  2209. 				const is_valid_item = item_valid(inventory_item);
  2210. 				const enough_cash = parseInt(instance.#_uservars["DFSTATS_df_cash"]) >= market_entry.price;
  2211. 				if (!service_needed()) {
  2212. 					throw new RangeError("Service not needed.");
  2213. 				}
  2214. 				if (!is_valid_item) {
  2215. 					throw new TypeError("Item: " + inventory_item.full_type + " is invalid for this service.");
  2216. 				}
  2217. 				if (!enough_cash) {
  2218. 					throw new RangeError("Cannot buy service for $" + market_entry.price.toLocaleString() + " with $" + parseInt(instance.#_uservars["DFSTATS_df_cash"]).toLocaleString() + " on-hand.");
  2219. 				}
  2220. 				const parameters = instance.#setupBuyServiceParameters();
  2221. 				parameters["itemnum"] = slot.toString();
  2222. 				parameters["price"] = scrapAmount(inventory_item.full_type, inventory_item.quantity); // I don't know why this is here.
  2223. 				parameters["action"] = action_type;
  2224. 				parameters["buynum"] = market_entry.member_id.toString();
  2225. 				parameters["expected_itemprice"] = market_entry.price.toString();
  2226. 				webCall("inventory_new", parameters, function(data) {
  2227. 					updateIntoArr(flshToArr(data, "DFSTATS_"), userVars);
  2228. 					if (update_ui === UiUpdate.YES) {
  2229. 						loadStatusData();
  2230. 						populateInventory();
  2231. 						populateCharacterInventory();
  2232. 						updateAllFields();
  2233. 						const cash = instance.#_uservars["DFSTATS_df_cash"];
  2234. 						const bank = instance.#_uservars["DFSTATS_df_bankcash"];
  2235. 						updateCashBank(cash, bank);
  2236. 					}
  2237. 					resolve(instance);
  2238. 				}, true);
  2239. 			});
  2240. 			return promise;
  2241. 		}
  2242.  
  2243. 		buyRepairFromMarketEntry(market_entry, slot, inventory_item, update_ui = UiUpdate.YES) {
  2244. 			const item_valid = (item) => item.category === ItemCategory.ARMOUR && item.properties.get("durability") !== item.properties.get("max_durability");
  2245. 			const service_needed = () => true;
  2246. 			const action_type = "buyrepair";
  2247. 			return this.#buyServiceFromMarketEntry(item_valid, service_needed, action_type, market_entry, slot, inventory_item, update_ui);
  2248. 		}
  2249.  
  2250. 		buyAdministerFromMarketEntry(market_entry, slot, inventory_item, update_ui = UiUpdate.YES) {
  2251. 			const item_valid = (item) => item.category === ItemCategory.ITEM && item.subcategory === ItemSubcategory.MEDICINE && MarketItems.#global_data[item.full_type].needdoctor === "1";
  2252. 			const service_needed = () => this.#_uservars["DFSTATS_df_hpcurrent"] !== this.#_uservars["DFSTATS_df_hpmax"];
  2253. 			const action_type = "buyadminister";
  2254. 			return this.#buyServiceFromMarketEntry(item_valid, service_needed, action_type, market_entry, slot, inventory_item, update_ui);
  2255. 		}
  2256.  
  2257. 		buyCookFromMarketEntry(market_entry, slot, inventory_item, update_ui = UiUpdate.YES) {
  2258. 			const item_valid = (item) => item.category === ItemCategory.ITEM && item.subcategory === ItemSubcategory.FOOD && MarketItems.#global_data[item.full_type].needcook === "1" && (!inventory_item.properties.has("cooked") || inventory_item.properties.get("cooked") === false);
  2259. 			const service_needed = () => true;
  2260. 			const action_type = "buycook";
  2261. 			return this.#buyServiceFromMarketEntry(item_valid, service_needed, action_type, market_entry, slot, inventory_item, update_ui);
  2262. 		}
  2263. 	}
  2264.  
  2265. 	// Bank
  2266.  
  2267. 	class Bank {
  2268. 		#_player_values;
  2269. 		#_uservars;
  2270. 		constructor() {
  2271. 			this.#_uservars = userVars;
  2272. 			this.#_player_values = new PlayerValues();
  2273. 		}
  2274.  
  2275. 		#setupBankWebcallParameters() {
  2276. 			const parameters = {};
  2277. 			parameters["sc"] = this.#_uservars["sc"];
  2278. 			parameters["userID"] = this.#_uservars["userID"];
  2279. 			parameters["password"] = this.#_uservars["password"];
  2280. 			return parameters;
  2281. 		}
  2282.  
  2283. 		deposit(amount, update_ui = UiUpdate.YES) {
  2284. 			const instance = this;
  2285. 			const promise = new Promise(function(resolve, reject) {
  2286. 				instance.#_player_values.request()
  2287. 				.then(function(values) {
  2288. 					const parameters = instance.#setupBankWebcallParameters();
  2289. 					parameters["deposit"] = amount;
  2290. 					if (amount > values.cash) {
  2291. 						throw new RangeError("Cannot deposit: $" + amount.toLocaleString() + " is more than is carried on-hand.");
  2292. 					}
  2293. 					webCall("bank", parameters, function(data) {
  2294. 						const map = responseToMap(data);
  2295. 						if (update_ui === UiUpdate.YES) {
  2296. 							const cash = parseInt(map.get("df_cash"));
  2297. 							const bank = parseInt(map.get("df_bankcash"));
  2298. 							updateCashBank(cash, bank);
  2299. 						}
  2300. 						resolve(instance);
  2301. 					});
  2302. 				});
  2303. 			});
  2304. 			return promise;
  2305. 		}
  2306.  
  2307. 		depositAll(update_ui = UiUpdate.YES) {
  2308. 			const instance = this;
  2309. 			const promise = new Promise(function(resolve, reject) {
  2310. 				instance.#_player_values.request()
  2311. 				.then(function(values) {
  2312. 					return instance.deposit(values.cash, update_ui);
  2313. 				});
  2314. 			});
  2315. 			return promise;
  2316. 		}
  2317.  
  2318. 		withdraw(amount, update_ui = UiUpdate.YES) {
  2319. 			const instance = this;
  2320. 			const promise = new Promise(function(resolve, reject) {
  2321. 				instance.#_player_values.request()
  2322. 				.then(function(values) {
  2323. 					const parameters = instance.#setupBankWebcallParameters();
  2324. 					parameters["withdraw"] = amount;
  2325. 					if (amount > values.bank) {
  2326. 						throw new RangeError("Cannot withdraw: $" + amount.toLocaleString() + " is more than is in bank.");
  2327. 					}
  2328. 					webCall("bank", parameters, function(data) {
  2329. 						const map = responseToMap(data);
  2330. 						if (update_ui === UiUpdate.YES) {
  2331. 							const cash = parseInt(map.get("df_cash"));
  2332. 							const bank = parseInt(map.get("df_bankcash"));
  2333. 							updateCashBank(cash, bank);
  2334. 						}
  2335. 						resolve(instance);
  2336. 					});
  2337. 				});
  2338. 			});
  2339. 			return promise;
  2340. 		}
  2341. 	}
  2342.  
  2343. 	// MarketCache
  2344. 	// The MarketCache class is responsible for requesting, processing, and storing market data for items and services.
  2345.  
  2346. 	class MarketCache {
  2347. 		static #global_data = globalData;
  2348.  
  2349. 		// Data Processing
  2350.  
  2351. 		#specialSearchString(type) {
  2352. 			// NOTE: All custom search strings go here.
  2353. 			const name = MarketCache.#global_data[type].name;
  2354. 			if (type == "exterminatorreactivext") {
  2355. 				//     "12345678901234567890" 20 char limit
  2356. 				return "reactive xt";
  2357. 			} else if (type == "exterminatorreactive") {
  2358. 				return "exterminator react";
  2359. 			} else if (type == "xterminatorreactive") {
  2360. 				return "x-terminator react";
  2361. 			} else if (type == "barnellrf31crossbow") {
  2362. 				return "barnell rf31";
  2363. 			} else if (type == "goldenrabbitimplant") {
  2364. 				return "golden rabbit imp";
  2365. 			} else if (type == "xmannbergblueprints") {
  2366. 				return "x-mannberg blue";
  2367. 			} else if (type == "dawnsabreblueprints") {
  2368. 				return "dawn blade blue";
  2369. 			} else if (type == "dawnenforcerblueprints") {
  2370. 				return "dawn enforcer blue";
  2371. 			} else if (type == "dawncarbineblueprints") {
  2372. 				return "dawn carbine blue";
  2373. 			} else if (type == "dawnstrikerblueprints") {
  2374. 				return "dawn striker blue";
  2375. 			} else if (type == "dawnlauncherblueprints") {
  2376. 				return "dawn launcher blue";
  2377. 			} else if (type == "xreactiveblueprints") {
  2378. 				return "x-reactive blue";
  2379. 			} else if (type == "inquisitorblueprints") {
  2380. 				return "inquisitor blue";
  2381. 			} else if (type == "sharktoothripperblueprints") {
  2382. 				return "ripper blue";
  2383. 			} else if (type == "qr22obsidianblueprints") {
  2384. 				return "obsidian blue";
  2385. 			} else if (type == "rusthound37eblueprints") {
  2386. 				return "37-e blue";
  2387. 			} else if (type == "heatpit75blueprints") {
  2388. 				return "pit 75 blue";
  2389. 			} else if (type == "a10bullsharkblueprints") {
  2390. 				return "bullshark blue";
  2391. 			} else if (type == "scorchernk19blueprints") {
  2392. 				return "nk19 blue";
  2393. 			} else if (type == "christmasstocking2022"){
  2394. 				return "stocking 2022";
  2395. 			} else if (type.indexOf("christmasstocking") !== -1 && !Number.isNaN(type.slice(-4))) {
  2396. 				return "stocking " + type.slice(-4);
  2397. 			} else if (type.indexOf("blueprints") !== -1) {
  2398. 				return name.slice(-20);
  2399. 			} else if (name.length > 20) {
  2400. 				return name.slice(0, 20);
  2401. 			} else {
  2402. 				return false;
  2403. 			}
  2404. 		}
  2405.  
  2406. 		// Item Requests
  2407.  
  2408. 		#setupItemRequest(tradezone, search_string) {
  2409. 			// Sets up POST request for searching up market data for given search string and tradezone.
  2410. 			const request = new XMLHttpRequest();
  2411. 			request.open("POST", "https://fairview.deadfrontier.com/onlinezombiemmo/trade_search.php");
  2412. 			request.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
  2413. 			// Setting up request payload.
  2414. 			const request_parameters = new URLSearchParams();
  2415. 			request_parameters.set("hash", "");
  2416. 			request_parameters.set("pagetime", "");
  2417. 			request_parameters.set("tradezone", tradezone.toString());
  2418. 			request_parameters.set("searchname", encodeURI(search_string.slice(0, 20)));
  2419. 			request_parameters.set("category", "");
  2420. 			request_parameters.set("profession", "");
  2421. 			request_parameters.set("memID", "");
  2422. 			request_parameters.set("searchtype", "buyinglistitemname");
  2423. 			request_parameters.set("search", "trades");
  2424. 			return [request, request_parameters];
  2425. 		}
  2426.  
  2427. 		#setupCategoryRequest(tradezone, category) {
  2428. 			// Sets up POST request for searching up market data for given category and tradezone.
  2429. 			const request = new XMLHttpRequest();
  2430. 			request.open("POST", "https://fairview.deadfrontier.com/onlinezombiemmo/trade_search.php");
  2431. 			request.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
  2432. 			// Setting up request payload.
  2433. 			const request_parameters = new URLSearchParams();
  2434. 			request_parameters.set("hash", "");
  2435. 			request_parameters.set("pagetime", "");
  2436. 			request_parameters.set("tradezone", tradezone.toString());
  2437. 			request_parameters.set("searchname", "");
  2438. 			request_parameters.set("category", category);
  2439. 			request_parameters.set("profession", "");
  2440. 			request_parameters.set("memID", "");
  2441. 			request_parameters.set("searchtype", "buyinglistcategory");
  2442. 			request_parameters.set("search", "trades");
  2443. 			return [request, request_parameters];
  2444. 		}
  2445.  
  2446. 		#deleteItemData(item_type) {
  2447. 			this.item_types.delete(item_type);
  2448. 			this.item_data.delete(item_type);
  2449. 		}
  2450.  
  2451. 		#deleteRenameData(rename) {
  2452. 			this.renames.delete(rename);
  2453. 			this.rename_data.delete(rename);
  2454. 		}
  2455.  
  2456. 		#parseItemData(response) {
  2457. 			// Parses item data and puts array(s) of MarketEntry into the instance.
  2458. 			const map = responseToMap(response);
  2459. 			const results = parseInt(map.get("tradelist_maxresults"));
  2460. 			const types = new Set(); // Contains types that this worker is operating on. These will all be new types.
  2461. 			// Delete all types that exist in this request.
  2462. 			const types_to_delete = new Set();
  2463. 			for (let i = 0; i < results; i++) {
  2464. 				const full_type = map.get("tradelist_" + i.toString() + "_item");
  2465. 				const base_type = typeSplit(full_type)[0];
  2466. 				types_to_delete.add(base_type);
  2467. 			}
  2468. 			for (const type of types_to_delete.values()) {
  2469. 				if (this.hasItemType(type)) {
  2470. 					this.#deleteItemData(type);
  2471. 				}
  2472. 			}
  2473. 			// Add in new data.
  2474. 			for (let i = 0; i < results; i++) {
  2475. 				// Extracts MarketEntry properties from keys.
  2476. 				const full_type = map.get("tradelist_" + i.toString() + "_item");
  2477. 				const base_type = typeSplit(full_type)[0];
  2478. 				const name = map.get("tradelist_" + i.toString() + "_itemname");
  2479. 				const quantity = parseInt(map.get("tradelist_" + i.toString() + "_quantity"))
  2480. 				const price = parseInt(map.get("tradelist_" + i.toString() + "_price"));
  2481. 				const trade_id = parseInt(map.get("tradelist_" + i.toString() + "_trade_id"));
  2482. 				const member_id = parseInt(map.get("tradelist_" + i.toString() + "_id_member"));
  2483. 				const member_name = map.get("tradelist_" + i.toString() + "_member_name");
  2484. 				const item = new Item(full_type, name, quantity);
  2485. 				const market_entry = new ItemMarketEntry(item, price, trade_id, member_id, member_name, this.tradezone);
  2486. 				const is_renamed = item.properties.has("rename");
  2487. 				if (is_renamed) {
  2488. 					const rename = item.properties.get("rename");
  2489. 				}
  2490. 				// Putting data into item data.
  2491. 				if (!this.hasItemType(base_type)) { // New type that has not yet been added.
  2492. 					types.add(base_type);
  2493. 					this.item_types.add(base_type);
  2494. 					this.item_data.set(base_type, []);
  2495. 					this.item_data.get(base_type).push(market_entry);
  2496. 				} else if (types.has(base_type)) { // Type that this worker has started and has exclusive access to.
  2497. 					this.item_data.get(base_type).push(market_entry);
  2498. 				} else { // Some other worker is handling the type.
  2499. 					continue;
  2500. 				}
  2501. 			}
  2502. 			// Sorts MarketEntry[] of newly added types by price per unit, ascending.
  2503. 			for (const type of types.values()) {
  2504. 				const market_entries = this.item_data.get(type);
  2505. 				const item = market_entries[0].item;
  2506. 				if (isStackable(item)) {
  2507. 					market_entries.sort(function(a, b) {return (a.price/a.quantity) - (b.price/b.quantity);});
  2508. 				} else { // Armour has its durability in its quantity, and I don't want to sort by that.
  2509. 					market_entries.sort(function(a, b) {return a.price - b.price;})
  2510. 				}
  2511. 			}
  2512. 		}
  2513.  
  2514. 		#parseRenameData(response) {
  2515. 			// Parses item data and puts array(s) of MarketEntry into the instance.
  2516. 			const map = responseToMap(response);
  2517. 			const results = parseInt(map.get("tradelist_maxresults"));
  2518. 			const renames = new Set(); // Contains renames that this worker is operating on. These will all be new names.
  2519. 			// Delete all names that exist in this request.
  2520. 			const names_to_delete = new Set();
  2521. 			for (let i = 0; i < results; i++) {
  2522. 				const name = map.get("tradelist_" + i.toString() + "_itemname");
  2523. 				names_to_delete.add(name);
  2524. 			}
  2525. 			for (const name of names_to_delete.values()) {
  2526. 				if (this.hasRename(name)) {
  2527. 					this.#deleteRenameData(name);
  2528. 				}
  2529. 			}
  2530. 			// Add in new data.
  2531. 			for (let i = 0; i < results; i++) {
  2532. 				// Extracts MarketEntry properties from keys.
  2533. 				const full_type = map.get("tradelist_" + i.toString() + "_item");
  2534. 				const base_type = typeSplit(full_type)[0];
  2535. 				const name = map.get("tradelist_" + i.toString() + "_itemname");
  2536. 				const quantity = parseInt(map.get("tradelist_" + i.toString() + "_quantity"))
  2537. 				const price = parseInt(map.get("tradelist_" + i.toString() + "_price"));
  2538. 				const trade_id = parseInt(map.get("tradelist_" + i.toString() + "_trade_id"));
  2539. 				const member_id = parseInt(map.get("tradelist_" + i.toString() + "_id_member"));
  2540. 				const member_name = map.get("tradelist_" + i.toString() + "_member_name");
  2541. 				const item = new Item(full_type, name, quantity);
  2542. 				const market_entry = new ItemMarketEntry(item, price, trade_id, member_id, member_name, this.tradezone);
  2543. 				const rename = item.properties.get("rename");
  2544. 				// Putting data into rename data.
  2545. 				if (!this.hasRename(rename)) { // New name that has not yet been added.
  2546. 					renames.add(rename);
  2547. 					this.renames.add(rename);
  2548. 					this.rename_data.set(rename, []);
  2549. 					this.rename_data.get(rename).push(market_entry);
  2550. 				} else if (renames.has(rename)) { // Name that this worker has started and has exclusive access to.
  2551. 					this.rename_data.get(rename).push(market_entry);
  2552. 				} else { // Some other worker is handling this name.
  2553. 					continue;
  2554. 				}
  2555. 			}
  2556. 			// Sorts MarketEntry[] of newly added names by price per unit, ascending.
  2557. 			for (const rename of renames.values()) {
  2558. 				const market_entries = this.rename_data.get(rename);
  2559. 				const item = market_entries[0].item;
  2560. 				if (isStackable(item)) {
  2561. 					market_entries.sort(function(a, b) {return (a.price/a.quantity) - (b.price/b.quantity);});
  2562. 				} else { // Armour has its durability in its quantity, and I don't want to sort by that.
  2563. 					market_entries.sort(function(a, b) {return a.price - b.price;})
  2564. 				}
  2565. 			}
  2566. 		}
  2567.  
  2568. 		#parseMixedData(response) {
  2569. 			// Parses item data and puts array(s) of MarketEntry into the instance.
  2570. 			const map = responseToMap(response);
  2571. 			const results = parseInt(map.get("tradelist_maxresults"));
  2572. 			const types = new Set(); // Contains types that this worker is operating on. These will all be new types.
  2573. 			const renames = new Set();
  2574. 			// Add in new data.
  2575. 			for (let i = 0; i < results; i++) {
  2576. 				// Extracts MarketEntry properties from keys.
  2577. 				const full_type = map.get("tradelist_" + i.toString() + "_item");
  2578. 				const base_type = typeSplit(full_type)[0];
  2579. 				const name = map.get("tradelist_" + i.toString() + "_itemname");
  2580. 				const quantity = parseInt(map.get("tradelist_" + i.toString() + "_quantity"))
  2581. 				const price = parseInt(map.get("tradelist_" + i.toString() + "_price"));
  2582. 				const trade_id = parseInt(map.get("tradelist_" + i.toString() + "_trade_id"));
  2583. 				const member_id = parseInt(map.get("tradelist_" + i.toString() + "_id_member"));
  2584. 				const member_name = map.get("tradelist_" + i.toString() + "_member_name");
  2585. 				const item = new Item(full_type, name, quantity);
  2586. 				const market_entry = new ItemMarketEntry(item, price, trade_id, member_id, member_name, this.tradezone);
  2587. 				const is_renamed = item.properties.has("rename");
  2588. 				// Putting data into item data.
  2589. 				if (!is_renamed) {
  2590. 					if (!this.hasItemType(base_type)) { // New type that has not yet been added.
  2591. 						types.add(base_type);
  2592. 						this.item_types.add(base_type);
  2593. 						this.item_data.set(base_type, []);
  2594. 						this.item_data.get(base_type).push(market_entry);
  2595. 					} else if (types.has(base_type)) { // Type that this worker has started and has exclusive access to.
  2596. 						this.item_data.get(base_type).push(market_entry);
  2597. 					} else { // Some other worker is handling the type.
  2598. 						continue;
  2599. 					}
  2600. 				} else {
  2601. 					// Putting data into rename data.
  2602. 					const rename = item.properties.get("rename");
  2603. 					if (!this.hasRename(rename)) { // New name that has not yet been added.
  2604. 						renames.add(rename);
  2605. 						this.renames.add(rename);
  2606. 						this.rename_data.set(rename, []);
  2607. 						this.rename_data.get(rename).push(market_entry);
  2608. 					} else if (renames.has(rename)) { // Name that this worker has started and has exclusive access to.
  2609. 						this.rename_data.get(rename).push(market_entry);
  2610. 					} else { // Some other worker is handling this name.
  2611. 						continue;
  2612. 					}
  2613. 				}
  2614. 			}
  2615. 			// Sorts MarketEntry[] of newly added types by price per unit, ascending.
  2616. 			for (const type of types.values()) {
  2617. 				const market_entries = this.item_data.get(type);
  2618. 				const item = market_entries[0].item;
  2619. 				if (isStackable(item)) {
  2620. 					market_entries.sort(function(a, b) {return (a.price/a.quantity) - (b.price/b.quantity);});
  2621. 				} else { // Armour has its durability in its quantity, and I don't want to sort by that.
  2622. 					market_entries.sort(function(a, b) {return a.price - b.price;})
  2623. 				}
  2624. 			}
  2625. 			// Sorts MarketEntry[] of newly added names by price per unit, ascending.
  2626. 			for (const rename of renames.values()) {
  2627. 				const market_entries = this.rename_data.get(rename);
  2628. 				const item = market_entries[0].item;
  2629. 				if (isStackable(item)) {
  2630. 					market_entries.sort(function(a, b) {return (a.price/a.quantity) - (b.price/b.quantity);});
  2631. 				} else { // Armour has its durability in its quantity, and I don't want to sort by that.
  2632. 					market_entries.sort(function(a, b) {return a.price - b.price;})
  2633. 				}
  2634. 			}
  2635. 		}
  2636.  
  2637. 		#requestItemData(tradezone, search_string, callback) {
  2638. 			const instance = this; // Variable to hold class instance to avoid clashing with the request (inner 'this').
  2639. 			const promise = new Promise(function(resolve, reject) {
  2640. 				const [request, parameters] = instance.#setupItemRequest(tradezone, search_string);
  2641. 				request.onreadystatechange = function() {
  2642. 					const is_complete = this.readyState == 4;
  2643. 					const response_ok = this.status == 200;
  2644. 					const client_error = this.status >= 400 && this.status < 500;
  2645. 					const server_error = this.status >= 500 && this.status < 600;
  2646. 					if (is_complete && response_ok) {
  2647. 						instance.#parseItemData(this.response);
  2648. 						instance.#_requests_out -= 1;
  2649. 						resolve(instance);
  2650. 					} else if (is_complete && (client_error || server_error)) {
  2651. 						instance.#_requests_out -= 1;
  2652. 						reject(instance);
  2653. 					}
  2654. 				}
  2655. 				instance.#_requests_out += 1;
  2656. 				request.send(parameters);
  2657. 			});
  2658. 			return promise;
  2659. 		}
  2660.  
  2661. 		#requestRenameData(tradezone, search_string) {
  2662. 			const instance = this; // Variable to hold class instance to avoid clashing with the request (inner 'this').
  2663. 			const promise = new Promise(function(resolve, reject) {
  2664. 				const [request, parameters] = instance.#setupItemRequest(tradezone, search_string);
  2665. 				request.onreadystatechange = function() {
  2666. 					const is_complete = this.readyState == 4;
  2667. 					const response_ok = this.status == 200;
  2668. 					const client_error = this.status >= 400 && this.status < 500;
  2669. 					const server_error = this.status >= 500 && this.status < 600;
  2670. 					if (is_complete && response_ok) {
  2671. 						instance.#parseRenameData(this.response);
  2672. 						instance.#_requests_out -= 1;
  2673. 						resolve(instance);
  2674. 					} else if (is_complete && (client_error || server_error)) {
  2675. 						instance.#_requests_out -= 1;
  2676. 						reject(instance);
  2677. 					}
  2678. 				}
  2679. 				instance.#_requests_out += 1;
  2680. 				request.send(parameters);
  2681. 			});
  2682. 			return promise;
  2683. 		}
  2684.  
  2685. 		#requestCategoricalData(tradezone, category) {
  2686. 			const instance = this; // Variable to hold class instance to avoid clashing with the request (inner 'this').
  2687. 			const promise = new Promise(function(resolve, reject) {
  2688. 				const [request, parameters] = instance.#setupCategoryRequest(tradezone, category);
  2689. 				request.onreadystatechange = function() {
  2690. 					const is_complete = this.readyState == 4;
  2691. 					const response_ok = this.status == 200;
  2692. 					const client_error = this.status >= 400 && this.status < 500;
  2693. 					const server_error = this.status >= 500 && this.status < 600;
  2694. 					if (is_complete && response_ok) {
  2695. 						instance.#parseMixedData(this.response);
  2696. 						instance.#_requests_out -= 1;
  2697. 						resolve(instance);
  2698. 					} else if (is_complete && (client_error || server_error)) {
  2699. 						instance.#_requests_out -= 1;
  2700. 						reject(instance);
  2701. 					}
  2702. 				}
  2703. 				instance.#_requests_out += 1;
  2704. 				request.send(parameters);
  2705. 			});
  2706. 			return promise;
  2707. 		}
  2708.  
  2709. 		// Service Requests
  2710.  
  2711. 		#setupServiceRequest(tradezone, service) {
  2712. 			// Sets up POST request for searching up market data for given service and tradezone.
  2713. 			const request = new XMLHttpRequest();
  2714. 			request.open("POST", "https://fairview.deadfrontier.com/onlinezombiemmo/trade_search.php");
  2715. 			request.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
  2716. 			// Setting up request payload.
  2717. 			const request_parameters = new URLSearchParams();
  2718. 			request_parameters.set("hash", "");
  2719. 			request_parameters.set("pagetime", "");
  2720. 			request_parameters.set("tradezone", tradezone.toString());
  2721. 			request_parameters.set("searchname", "");
  2722. 			request_parameters.set("category", "");
  2723. 			request_parameters.set("profession", service.toString());
  2724. 			request_parameters.set("memID", "");
  2725. 			request_parameters.set("searchtype", "buyinglist");
  2726. 			request_parameters.set("search", "services");
  2727. 			return [request, request_parameters];
  2728. 		}
  2729.  
  2730. 		#deleteServiceData(service) {
  2731. 			this.service_types.delete(service);
  2732. 			this.service_data.delete(service);
  2733. 		}
  2734.  
  2735. 		#parseServiceData(response, service) {
  2736. 			const map = responseToMap(response);
  2737. 			map.set("services", true);
  2738. 			const results = parseInt(map.get("tradelist_maxresults"));
  2739. 			const types = new Set();
  2740. 			// Deletes all types that exist in this request.
  2741. 			const types_to_delete = new Set();
  2742. 			for (let i = 0; i < results; i++) {
  2743. 				const service_type = map.get("tradelist_" + i.toString() + "_profession");
  2744. 				types_to_delete.add(service_type);
  2745. 			}
  2746. 			for (const type of types_to_delete.values()) {
  2747. 				if (this.hasServiceType(type)) {
  2748. 					this.#deleteServiceData(type);
  2749. 				}
  2750. 			}
  2751. 			// Adding in new data.
  2752. 			for (let i = 0; i < results; i++) {
  2753. 				const service_type = map.get("tradelist_" + i.toString() + "_profession");
  2754. 				const level = parseInt(map.get("tradelist_" + i.toString() + "_level"));
  2755. 				const price = parseInt(map.get("tradelist_" + i.toString() + "_price"));
  2756. 				const member_id = parseInt(map.get("tradelist_" + i.toString() + "_id_member"));
  2757. 				const member_name = map.get("tradelist_" + i.toString() + "_member_name");
  2758. 				const service = new Service(service_type, level);
  2759. 				const market_entry = new ServiceMarketEntry(service, price, member_id, member_name, this.tradezone);
  2760. 				// Putting data into service data.
  2761. 				if (!this.hasServiceType(service_type)) { // New type that has not yet been added.
  2762. 					types.add(service_type);
  2763. 					this.service_types.add(service_type);
  2764. 					this.service_data.set(service_type, []);
  2765. 					this.service_data.get(service_type).push(market_entry);
  2766. 				} else if (types.has(service_type)) { // Type that this worker has started and has exclusive access to.
  2767. 					this.service_data.get(service_type).push(market_entry);
  2768. 				} else { // Some other worker is handling the type.
  2769. 					continue;
  2770. 				}
  2771. 			}
  2772. 			for (const type of types.values()) {
  2773. 				const market_entries = this.service_data.get(type);
  2774. 				market_entries.sort(function(a, b) {return a.price - b.price;});
  2775. 			}
  2776. 		}
  2777.  
  2778. 		#requestServiceData(tradezone, service) {
  2779. 			// Requests market data for given service and tradezone. Calls parseServiceData to parse and store
  2780. 			// information.
  2781. 			const instance = this; // Variable to hold class instance to avoid clashing with the request (inner 'this').
  2782. 			const promise = new Promise(function(resolve, reject) {
  2783. 				const [request, parameters] = instance.#setupServiceRequest(tradezone, service);
  2784. 				request.onreadystatechange = function() {
  2785. 					const is_complete = this.readyState == 4;
  2786. 					const response_ok = this.status == 200;
  2787. 					const client_error = this.status >= 400 && this.status < 500;
  2788. 					const server_error = this.status >= 500 && this.status < 600;
  2789. 					if (is_complete && response_ok) {
  2790. 						instance.#_requests_out -= 1;
  2791. 						instance.#parseServiceData(this.response, service);
  2792. 						resolve(instance);
  2793. 					} else if (is_complete && (client_error || server_error)) {
  2794. 						instance.#_requests_out -= 1;
  2795. 						reject(instance);
  2796. 					}
  2797. 				}
  2798. 				instance.#_requests_out += 1;
  2799. 				request.send(parameters);
  2800. 			});
  2801. 			return promise;
  2802. 		}
  2803.  
  2804. 		// Public Functions
  2805.  
  2806. 		static itemToCategorical(item) {
  2807. 			if (item.category === ItemCategory.WEAPON) {
  2808. 				const weapon_type = item.properties.get("weapon_type");
  2809. 				if (["submachinegun", "machinegun"].includes(weapon_type)) {
  2810. 					return "weapon_lightmachinegun";
  2811. 				} else if (["bigmachinegun", "minigun"].includes(weapon_type)) {
  2812. 					return "weapon_heavymachinegun";
  2813. 				} else if (weapon_type === "grenadelauncher") {
  2814. 					return "weapon_grenadelauncher";
  2815. 				}
  2816. 				else {
  2817. 					return "weapon_" + item.properties.get("proficiency_type");
  2818. 				}
  2819. 			} else if (item.category === ItemCategory.ARMOUR) {
  2820. 				return "armour";
  2821. 			} else if (item.category === ItemCategory.AMMO) {
  2822. 				if (item.base_type.indexOf("rifle") !== -1) {
  2823. 					return "ammo_rifle";
  2824. 				} else if (item.base_type.indexOf("gauge") !== -1) {
  2825. 					return "ammo_shotgun";
  2826. 				} else if (item.base_type.indexOf("grenade") !== -1) {
  2827. 					return "ammo_grenade";
  2828. 				} else if (item.base_type.indexOf("fuel") !== -1) {
  2829. 					return "ammo_fuel";
  2830. 				} else {
  2831. 					return "ammo_handgun";
  2832. 				}
  2833. 			} else if (item.category === ItemCategory.ITEM && item.subcategory === ItemSubcategory.FOOD) {
  2834. 				return "food";
  2835. 			} else if (item.category === ItemCategory.ITEM && item.subcategory === ItemSubcategory.MEDICINE) {
  2836. 				return "medical";
  2837. 			} else if (item.category === ItemCategory.ITEM && item.subcategory === ItemSubcategory.CLOTHING) {
  2838. 				const clothing_type = item.properties.get("clothing_type");
  2839. 				if (["mask", "hat"].includes(clothing_type)) {
  2840. 					return "clothing_headwear";
  2841. 				} else if (clothing_type === "coat") {
  2842. 					return "clothing_coat";
  2843. 				} else {
  2844. 					return "clothing_basic";
  2845. 				}
  2846. 			} else if (item.category === ItemCategory.ITEM && item.subcategory === ItemSubcategory.BARRICADE) {
  2847. 				return "barricading";
  2848. 			} else if (item.category === ItemCategory.ITEM && item.subcategory === ItemSubcategory.IMPLANT) {
  2849. 				return "implants";
  2850. 			} else if (item.category === ItemCategory.BACKPACK) {
  2851. 				return "backpack";
  2852. 			} else {
  2853. 				return "misc";
  2854. 			}
  2855. 		}
  2856.  
  2857. 		#_tradezone;
  2858. 		#_requests_out;
  2859. 		constructor(tradezone) {
  2860. 			this.#_tradezone = tradezone;
  2861. 			this.item_types = new Set();
  2862. 			this.item_data = new Map();
  2863. 			this.renames = new Set();
  2864. 			this.rename_data = new Map();
  2865. 			this.service_types = new Set();
  2866. 			this.service_data = new Map();
  2867. 			this.#_requests_out = 0;
  2868. 		}
  2869.  
  2870. 		get tradezone() {
  2871. 			return this.#_tradezone;
  2872. 		}
  2873.  
  2874. 		get requests_out() {
  2875. 			return this.#_requests_out;
  2876. 		}
  2877.  
  2878. 		hasItemType(type) {
  2879. 			const base_type = typeSplit(type)[0];
  2880. 			return this.item_types.has(base_type);
  2881. 		}
  2882.  
  2883. 		hasRename(rename) {
  2884. 			return this.renames.has(rename);
  2885. 		}
  2886.  
  2887. 		getItemMarketEntriesByType(type) {
  2888. 			const base_type = typeSplit(type)[0];
  2889. 			const data = this.item_data.get(base_type);
  2890. 			if (data === undefined) {
  2891. 				throw new ReferenceError("Item: " + base_type + " unavailable.");
  2892. 			} else {
  2893. 				return data;
  2894. 			}
  2895. 		}
  2896.  
  2897. 		getItemMarketEntriesByRename(rename) {
  2898. 			const data = this.rename_data.get(rename);
  2899. 			if (data === undefined) {
  2900. 				throw new ReferenceError("Renamed item: " + rename + " unavailable.");
  2901. 			} else {
  2902. 				return data;
  2903. 			}
  2904. 		}
  2905.  
  2906. 		requestItemMarketEntriesByType(type) {
  2907. 			const base_type = typeSplit(type)[0];
  2908. 			const special_string = this.#specialSearchString(base_type);
  2909. 			const name = special_string !== false ? special_string : MarketCache.#global_data[base_type].name;
  2910. 			const promise = this.#requestItemData(this.tradezone, name);
  2911. 			return promise;
  2912. 		}
  2913.  
  2914. 		requestMultipleItemMarketEntriesByType(types) {
  2915. 			const unique_types = new Set(types); // To avoid repeats.
  2916. 			// Need to bind to avoid losing track of 'this', becoming undefined.
  2917. 			const promises = Array.from(unique_types).map(this.requestItemMarketEntriesByType.bind(this));
  2918. 			// Once all promises (requests) complete, unify them into a single promise that resolves to the instance.
  2919. 			return Promise.allSettled(promises).then(() => this);
  2920. 		}
  2921.  
  2922. 		requestItemMarketEntriesByRename(rename) {
  2923. 			const promise = this.#requestRenameData(this.tradezone, rename);
  2924. 			return promise;
  2925. 		}
  2926.  
  2927. 		requestMultipleItemMarketEntriesByRename(renames) {
  2928. 			const unique_renames = new Set(renames); // To avoid repeats.
  2929. 			// Need to bind to avoid losing track of 'this', becoming undefined.
  2930. 			const promises = Array.from(unique_renames).map(this.requestItemMarketEntriesByRename.bind(this));
  2931. 			// Once all promises (requests) complete, unify them into a single promise that resolves to the instance.
  2932. 			return Promise.allSettled(promises).then(() => this);
  2933. 		}
  2934.  
  2935. 		requestItemMarketEntriesByCategory(category) {
  2936. 			const promise = this.#requestCategoricalData(this.tradezone, category);
  2937. 			return promise;
  2938. 		}
  2939.  
  2940. 		requestMultipleItemMarketEntriesByCategory(categories) {
  2941. 			const unique_categories = new Set(categories); // To avoid repeats.
  2942. 			// Need to bind to avoid losing track of 'this', becoming undefined.
  2943. 			const promises = Array.from(unique_categories).map(this.requestItemMarketEntriesByCategory.bind(this));
  2944. 			// Once all promises (requests) complete, unify them into a single promise that resolves to the instance.
  2945. 			return Promise.allSettled(promises).then(() => this);
  2946. 		}
  2947.  
  2948. 		hasServiceType(type) {
  2949. 			return this.service_types.has(type);
  2950. 		}
  2951.  
  2952. 		getServiceMarketEntriesByType(type) {
  2953. 			const data = this.service_data.get(type);
  2954. 			if (data === undefined) {
  2955. 				throw new ReferenceError("Service: " + type + " unavailable.");
  2956. 			} else {
  2957. 				return data;
  2958. 			}
  2959. 		}
  2960.  
  2961. 		requestServiceMarketEntriesByType(type) {
  2962. 			const promise = this.#requestServiceData(this.tradezone, type);
  2963. 			return promise;
  2964. 		}
  2965.  
  2966. 		requestMultipleServiceMarketEntriesByType(types) {
  2967. 			const unique_types = new Set(types); // To avoid repeats.
  2968. 			// Need to bind to avoid losing track of 'this', becoming undefined.
  2969. 			const promises = Array.from(unique_types).map(this.requestServiceMarketEntriesByType.bind(this));
  2970. 			// Once all promises (requests) complete, unify them into a single promise that resolves to the instance.
  2971. 			return Promise.allSettled(promises).then(() => this);
  2972. 		}
  2973. 	}
  2974.  
  2975. 	// CollectionBook
  2976.  
  2977. 	class CollectionBook {
  2978. 		#setupCollectionBookRequest() {
  2979. 			// Sets up POST request for requesting collection book data.
  2980. 			const request = new XMLHttpRequest();
  2981. 			request.open("POST", "https://fairview.deadfrontier.com/onlinezombiemmo/hotrods/collectionbook.php");
  2982. 			request.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
  2983. 			// Setting up request payload.
  2984. 			const request_parameters = new URLSearchParams();
  2985. 			request_parameters.set("userID", this.#_uservars["userID"]);
  2986. 			request_parameters.set("password", this.#_uservars["password"]);
  2987. 			request_parameters.set("sc", this.#_uservars["sc"]);
  2988. 			request_parameters.set("pagetime", this.#_uservars["pagetime"]);
  2989. 			request_parameters.set("memberto", this.#_uservars["userID"]);
  2990. 			request_parameters.set("action", "getother");
  2991. 			return [request, request_parameters];
  2992. 		}
  2993.  
  2994. 		#parseCollectionBookData(response) {
  2995. 			const map = responseToMap(response);
  2996. 			const count = parseInt(map.get("total_items"));
  2997. 			for (let i = 0; i < count; i++) {
  2998. 				const base_key = "cb" + i.toString() + "_";
  2999. 				const base_type = map.get(base_key + "type");
  3000. 				const quantity = parseInt(map.get(base_key + "quantity"));
  3001. 				const full_type = map.get(base_key + "inv");
  3002. 				const pinned = map.get(base_key + "pinned") === "1";
  3003. 				const priority = parseInt(map.get(base_key + "priority"));
  3004. 				this.#_ordered_types.push(base_type);
  3005. 				this.#_base_types.add(base_type);
  3006. 				this.#_quantities.set(base_type, quantity);
  3007. 				this.#_full_types.set(base_type, full_type);
  3008. 				this.#_pinned.set(base_type, pinned);
  3009. 				this.#_priorities.set(base_type, priority);
  3010. 			}
  3011. 		}
  3012.  
  3013. 		#_uservars;
  3014. 		#_requests_out;
  3015. 		#_ordered_types;
  3016. 		#_base_types;
  3017. 		#_quantities;
  3018. 		#_full_types;
  3019. 		#_pinned;
  3020. 		#_priorities;
  3021. 		constructor() {
  3022. 			this.#_uservars = userVars;
  3023. 			this.#_requests_out = 0;
  3024. 			this.#_ordered_types = [];
  3025. 			this.#_base_types = new Set();
  3026. 			this.#_quantities = new Map();
  3027. 			this.#_full_types = new Map();
  3028. 			this.#_pinned = new Map();
  3029. 			this.#_priorities = new Map();
  3030. 		}
  3031.  
  3032. 		get requests_out() {
  3033. 			return this.#_requests_out;
  3034. 		}
  3035.  
  3036. 		requestCollectionBookData() {
  3037. 			const instance = this; // Variable to hold class instance to avoid clashing with the request (inner 'this').
  3038. 			const promise = new Promise(function(resolve, reject) {
  3039. 				const [request, parameters] = instance.#setupCollectionBookRequest();
  3040. 				request.onreadystatechange = function() {
  3041. 					const is_complete = this.readyState == 4;
  3042. 					const response_ok = this.status == 200;
  3043. 					const client_error = this.status >= 400 && this.status < 500;
  3044. 					const server_error = this.status >= 500 && this.status < 600;
  3045. 					if (is_complete && response_ok) {
  3046. 						instance.#_requests_out -= 1;
  3047. 						instance.#parseCollectionBookData(this.response);
  3048. 						resolve(instance);
  3049. 					} else if (is_complete && (client_error || server_error)) {
  3050. 						instance.#_requests_out -= 1;
  3051. 						reject(instance);
  3052. 					}
  3053. 				}
  3054. 				instance.#_requests_out += 1;
  3055. 				request.send(parameters);
  3056. 			});
  3057. 			return promise;
  3058. 		}
  3059.  
  3060. 		hasType(type) {
  3061. 			return this.#_base_types.has(type);
  3062. 		}
  3063.  
  3064. 		quantity(type) {
  3065. 			return this.#_quantities.get(type);
  3066. 		}
  3067.  
  3068. 		fullTypeInCollection(type) {
  3069. 			return this.#_full_types.get(type);
  3070. 		}
  3071.  
  3072. 		pinned(type) {
  3073. 			return this.#_pinned.get(type);
  3074. 		}
  3075.  
  3076. 		priority(type) {
  3077. 			return this.#_priorities.get(type);
  3078. 		}
  3079.  
  3080. 		total() {
  3081. 			return this.#_base_types.size;
  3082. 		}
  3083.  
  3084. 		*types() {
  3085. 			const n = this.total();
  3086. 			for (let i = 0; i < n; i++) {
  3087. 				yield this.#_ordered_types[i];
  3088. 			}
  3089. 		}
  3090. 	}
  3091.  
  3092. 	// InventoryUI
  3093.  
  3094. 	class InventoryUI {
  3095. 		#_player_items;
  3096. 		constructor() {
  3097. 			this.#_player_items = new PlayerItems();
  3098. 		}
  3099.  
  3100. 		#isValidSlotElementFromMouseOverElement(element) {
  3101. 			const is_slot_element = element.classList.contains("validSlot");
  3102. 			const is_item_element = element.classList.contains("item");
  3103. 			return is_slot_element || is_item_element;
  3104. 		}
  3105.  
  3106. 		#slotSlotTypeFromMouseOverElement(element) {
  3107. 			const is_slot_element = element.classList.contains("validSlot");
  3108. 			const is_item_element = element.classList.contains("item");
  3109. 			if (!is_slot_element && !is_item_element) {
  3110. 				throw new Error("Element: " + element + " is not a slot or item element.");
  3111. 			}
  3112. 			const slot_element = is_slot_element ? element : element.parentNode;
  3113. 			const slot = parseInt(element.dataset.slot);
  3114. 			const slot_type = "slottype" in element.dataset ? element.dataset.slottype : undefined;
  3115. 			return [slot, slot_type];
  3116. 		}
  3117.  
  3118. 		#elementSlotTypeCheck(element, key) {
  3119. 			const [slot, slot_type] = instance.#slotSlotTypeFromMouseOverElement(element);
  3120. 			return slot_type === key;
  3121. 		}
  3122.  
  3123. 		#elementIsInventory(element) {
  3124. 			return this.#elementSlotTypeCheck(element, undefined);
  3125. 		}
  3126.  
  3127. 		#elementIsImplant(element) {
  3128. 			return this.#elementSlotTypeCheck(element, "implant");
  3129. 		}
  3130.  
  3131. 		#elementIsWeapon(element) {
  3132. 			return this.#elementSlotTypeCheck(element, "weapon");
  3133. 		}
  3134.  
  3135. 		#elementIsArmour(element) {
  3136. 			return this.#elementSlotTypeCheck(element, "armour");
  3137. 		}
  3138.  
  3139. 		#elementIsHat(element) {
  3140. 			return this.#elementSlotTypeCheck(element, "hat");
  3141. 		}
  3142.  
  3143. 		#elementIsMask(element) {
  3144. 			return this.#elementSlotTypeCheck(element, "mask");
  3145. 		}
  3146.  
  3147. 		#elementIsCoat(element) {
  3148. 			return this.#elementSlotTypeCheck(element, "coat");
  3149. 		}
  3150.  
  3151. 		#elementIsShirt(element) {
  3152. 			return this.#elementSlotTypeCheck(element, "shirt");
  3153. 		}
  3154.  
  3155. 		#elementIsTrousers(element) {
  3156. 			return this.#elementSlotTypeCheck("trousers");
  3157. 		}
  3158. 	}
  3159.  
  3160. 	function main() {
  3161. 		// setTimeout(function() {
  3162. 		// 	const player_items = new PlayerItems();
  3163. 		// }, 1000);
  3164. 		// const market_cache = new MarketCache(21);
  3165. 		// market_cache.requestItemMarketEntriesByCategory("weapon_melee")
  3166. 		// .then(function() {
  3167. 		// 	console.debug(market_cache);
  3168. 		// });
  3169. 		// setTimeout(function() {
  3170. 		// 	const global_data = globalData;
  3171. 		// 	const map = new Map();
  3172. 		// 	for (const [key, value] of Object.entries(global_data)) {
  3173. 		// 		const item = new Item(key, value.name, 1);
  3174. 		// 		const transferable = item.properties.get("transferable");
  3175. 		// 		if (transferable) {
  3176. 		// 			map.set(key, MarketCache.itemToCategorical(item));
  3177. 		// 		}
  3178. 		// 	}
  3179. 		// 	console.debug(map);
  3180. 		// }, 1000);
  3181. 		// const target = player_items.implant(16);
  3182. 		// console.debug(target);
  3183. 		// player_items.mutateItem("1016", target, "fortuneimplant_statsb3jrb4")
  3184. 		// player_items.unlockInventorySlot(1);
  3185. 		// player_items.unlockBackpackSlot(6);
  3186. 		// console.debug("API");
  3187. 		// const player_items = new PlayerItems();
  3188. 		// for (const [slot, item] of player_items.backpackSlots()) {
  3189. 		// 	console.debug(slot, item);
  3190. 		// }
  3191.  
  3192. 	}
  3193. 	main();
  3194.  
  3195. 	return {
  3196. 		// Enums
  3197. 		Tradezone: Tradezone,
  3198. 		ItemCategory: ItemCategory,
  3199. 		ItemSubcategory: ItemSubcategory,
  3200. 		ServiceType: ServiceType,
  3201. 		ProficiencyType: ProficiencyType,
  3202. 		UiUpdate: UiUpdate,
  3203. 		// Predicates
  3204. 		ItemFilters: ItemFilters,
  3205. 		ServiceFilters: ServiceFilters,
  3206. 		MarketFilters: MarketFilters,
  3207. 		// Classes
  3208. 		PlayerValues: PlayerValues,
  3209. 		PlayerItems: PlayerItems,
  3210. 		MarketItems: MarketItems,
  3211. 		Bank: Bank,
  3212. 		MarketCache: MarketCache,
  3213. 		CollectionBook: CollectionBook
  3214. 	};
  3215.  
  3216. })();