Dead Frontier - API

Dead Frontier API

当前为 2025-02-08 提交的版本,查看 最新版本

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