☰

Dead Frontier - API

Dead Frontier API

当前为 2025-02-21 提交的版本，查看 最新版本。

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