Rage/Fika-Tarkov
Archived
1
0
Fork 0
Code Issues Releases 1 Activity

Adding Mods w/Symlink

Browse Source
This commit is contained in:
Rage
2025-01-02 20:23:50 -05:00
parent 88fc2c3c93
commit 404890ecbb
10218 changed files with 3191380 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
mods/SVD/user/mods/WTTArmorySVD/bundles.json
+146
View File
@@ -0,0 +1,146 @@
{
"manifest": [
{
"key": "WeaponDragunov/dragunov2portmuzzlebrake.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle"
]
},
{
"key": "WeaponDragunov/dragunov3portmuzzlebrake.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle"
]
},
{
"key": "WeaponDragunov/dragunovbuffertubeadapt.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle"
]
},
{
"key": "WeaponDragunov/dragunovflashhider.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle"
]
},
{
"key": "WeaponDragunov/svdgreencamodustcover.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle"
]
},
{
"key": "WeaponDragunov/svdpolymerstock.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle"
]
},
{
"key": "WeaponDragunov/svdpolymerstockgreen.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle"
]
},
{
"key": "WeaponDragunov/svdshortenedbarrel.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle"
]
},
{
"key": "WeaponDragunov/svdwoodenhandguard.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle"
]
},
{
"key": "WeaponDragunov/svdwoodenhandguardgreen.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle"
]
},
{
"key": "WeaponDragunov/svdwoodenhandguardgreenghillie.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle"
]
},
{
"key": "WeaponDragunov/svdwoodenstock.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle"
]
},
{
"key": "WeaponDragunov/svd_cammomag.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle"
]
},
{
"key": "WeaponDragunov/svd_magazinepoly25.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle"
]
},
{
"key": "WeaponDragunov/svd_polymermag10.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle"
]
},
{
"key": "WeaponDragunov/weapon_dragunov.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle",
"assets/content/audio/blendoptions/assets.bundle",
"assets/content/weapons/additional_hands/client_assets.bundle",
"assets/content/weapons/weapon_root_anim_fix.bundle"
]
},
{
"key": "WeaponDragunov/weapon_dragunovgreen.bundle",
"dependencyKeys": [
"shaders",
"cubemaps",
"assets/commonassets/physics/physicsmaterials.bundle",
"assets/content/audio/blendoptions/assets.bundle",
"assets/content/weapons/additional_hands/client_assets.bundle",
"assets/content/weapons/weapon_root_anim_fix.bundle"
]
}
]
}
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/dragunov2portmuzzlebrake.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/dragunov3portmuzzlebrake.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/dragunovbuffertubeadapt.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/dragunovflashhider.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/svd_cammomag.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/svd_magazinepoly25.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/svd_polymermag10.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/svdgreencamodustcover.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/svdpolymerstock.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/svdpolymerstockgreen.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/svdshortenedbarrel.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/svdwoodenhandguard.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/svdwoodenhandguardgreen.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/svdwoodenhandguardgreenghillie.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/svdwoodenstock.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/weapon_dragunov.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/bundles/WeaponDragunov/weapon_dragunovgreen.bundle
LFS
BIN
View File
Binary file not shown.
mods/SVD/user/mods/WTTArmorySVD/db/CustomAssortSchemes/CustomAssortSchemes.json
+500
View File
@@ -0,0 +1,500 @@
{
"PRAPOR": {
"items": [
{
"_id": "6657bc22eb423bf4b7f6e36b",
"_tpl": "6657bd663a5a69b08786fecc",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 1000
}
},
{
"_id": "6657bc2bc2735f472160a694",
"_tpl": "6657bd80a635c01603bd9ef7",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 1000
}
},
{
"_id": "6657bc3439728852ed799c4a",
"_tpl": "6657bd891b74ff27b6a64fae",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 1000
}
},
{
"_id": "6657bc37e9ca535ba9bfb4c8",
"_tpl": "6657bd29491b4baa8790dd91",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 1000
}
},
{
"_id": "6657bc3c1215023e2ca2c41a",
"_tpl": "6657bd990e17e7fb2bab32e6",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 1000
}
},
{
"_id": "6657bc3f643bffdeb5ae9107",
"_tpl": "6657bda8ebfed767215c15d4",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 1000
}
},
{
"_id": "6657bc42d9425e71b37eb18e",
"_tpl": "6657bdb47618210e20db4064",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 1000
}
},
{
"_id": "6657bfac5ea61e0a6e7022b3",
"_tpl": "6657bdc55b6dea8c9e65dc93",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 1000
}
},
{
"_id": "6657bfbaaae6fd21cbc5c7e3",
"_tpl": "6657bdd3ceb56099bc50c188",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 1000
}
},
{
"_id": "6657bfc5db1eda95d3df56e2",
"_tpl": "6657bdde5fb53ba8b0657bd6",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 1000
}
},
{
"_id": "6657bfd5fc004f35cef5a426",
"_tpl": "6657bde9e47c756d6b149a5b",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 1000
}
},
{
"_id": "6657c04e26eb4587c12238ae",
"_tpl": "6657be1f9014a9663b39bc4b",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 1000
}
},
{
"_id": "6657c04bdd537d04b58bc450",
"_tpl": "6657be2ae0a6ff466db575de",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 1000
}
},
{
"_id": "6657c0488fa5d07ee9954ff8",
"_tpl": "6657be33ed0d0e6d65f1ba00",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 1000
}
},
{
"_id": "6657c044cfdb8c0084ea152b",
"_tpl": "6657be3d8876d16a5866f413",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 1000
}
},
{
"_id": "6657c33860546ceedbf82985",
"_tpl": "6657bc8faeddd6b0a9b40224",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 99,
"Repairable": {
"MaxDurability": 100,
"Durability": 100
},
"FireMode": {
"FireMode": "single"
}
}
},
{
"_id": "6657c37eae9e64ffa9177064",
"_tpl": "6657bd29491b4baa8790dd91",
"parentId": "6657c33860546ceedbf82985",
"slotId": "mod_pistol_grip"
},
{
"_id": "6657c3a65b744dce9f0d3803",
"_tpl": "5c471c442e221602b542a6f8",
"parentId": "6657c33860546ceedbf82985",
"slotId": "mod_magazine"
},
{
"_id": "6657c3cddfb86908bcd04569",
"_tpl": "5c471cb32e221602b177afaa",
"parentId": "6657c33860546ceedbf82985",
"slotId": "mod_barrel"
},
{
"_id": "6657c3d0ad8571a744de7d4a",
"_tpl": "5c471c2d2e22164bef5d077f",
"parentId": "6657c33860546ceedbf82985",
"slotId": "mod_mount_001"
},
{
"_id": "6657c3d3431ec4a4623bcd52",
"_tpl": "5c471bd12e221602b4129c3a",
"parentId": "6657c33860546ceedbf82985",
"slotId": "mod_reciever"
},
{
"_id": "6657c3f5b9a3316e1690111d",
"_tpl": "6657bde9e47c756d6b149a5b",
"parentId": "6657c3cddfb86908bcd04569",
"slotId": "mod_muzzle"
},
{
"_id": "6657c4024c034c08f9a7eaf0",
"_tpl": "5c471c842e221615214259b5",
"parentId": "6657c3cddfb86908bcd04569",
"slotId": "mod_gas_block"
},
{
"_id": "6657c40c14430f3aedf3e359",
"_tpl": "6657bd663a5a69b08786fecc",
"parentId": "6657c3d0ad8571a744de7d4a",
"slotId": "mod_handguard"
},
{
"_id": "6657c41812769ebc473a20f3",
"_tpl": "5c471b7e2e2216152006e46c",
"parentId": "6657c3d0ad8571a744de7d4a",
"slotId": "mod_sight_rear",
"upd": {
"Sight": {
"ScopesCurrentCalibPointIndexes": [
0
],
"ScopesSelectedModes": [
0
],
"SelectedScope": 0
}
}
},
{
"_id": "6657c41bcaca165103c69f96",
"_tpl": "5c471ba12e221602b3137d76",
"parentId": "6657c3f5b9a3316e1690111d",
"slotId": "mod_sight_front",
"upd": {
"Sight": {
"ScopesCurrentCalibPointIndexes": [
0
],
"ScopesSelectedModes": [
0
],
"SelectedScope": 0
}
}
},
{
"_id": "6657c4a470d9c2350c47aa80",
"_tpl": "6657bd4d3a4d6e7c33fd2fdc",
"parentId": "hideout",
"slotId": "hideout",
"upd": {
"StackObjectsCount": 99,
"Repairable": {
"MaxDurability": 100,
"Durability": 100
},
"FireMode": {
"FireMode": "single"
}
}
},
{
"_id": "6657c4c697576e03d908ed92",
"_tpl": "6657bda8ebfed767215c15d4",
"parentId": "6657c4a470d9c2350c47aa80",
"slotId": "mod_pistol_grip"
},
{
"_id": "6657c501afa3fa9754c4b93f",
"_tpl": "6657be2ae0a6ff466db575de",
"parentId": "6657c4a470d9c2350c47aa80",
"slotId": "mod_magazine"
},
{
"_id": "6657c51fb939dab2b1f9db81",
"_tpl": "6657bdc55b6dea8c9e65dc93",
"parentId": "6657c4a470d9c2350c47aa80",
"slotId": "mod_barrel"
},
{
"_id": "6657c524ab2c6764cdf25f55",
"_tpl": "5c471c2d2e22164bef5d077f",
"parentId": "6657c4a470d9c2350c47aa80",
"slotId": "mod_mount_001"
},
{
"_id": "6657c5275735bc934e2ab08e",
"_tpl": "6657be1f9014a9663b39bc4b",
"parentId": "6657c4a470d9c2350c47aa80",
"slotId": "mod_reciever"
},
{
"_id": "6657c53642f6401b0857903b",
"_tpl": "5c471bfc2e221602b21d4e17",
"parentId": "6657c51fb939dab2b1f9db81",
"slotId": "mod_muzzle"
},
{
"_id": "6657c53eb0403186b5e8bd25",
"_tpl": "5c471c842e221615214259b5",
"parentId": "6657c51fb939dab2b1f9db81",
"slotId": "mod_gas_block"
},
{
"_id": "6657c5413be37d2414525452",
"_tpl": "6657bd891b74ff27b6a64fae",
"parentId": "6657c524ab2c6764cdf25f55",
"slotId": "mod_handguard"
},
{
"_id": "6657c5450fead9ea189e68f5",
"_tpl": "5c471b7e2e2216152006e46c",
"parentId": "6657c524ab2c6764cdf25f55",
"slotId": "mod_sight_rear",
"upd": {
"Sight": {
"ScopesCurrentCalibPointIndexes": [
0
],
"ScopesSelectedModes": [
0
],
"SelectedScope": 0
}
}
},
{
"_id": "6657c549e60861c8d848474f",
"_tpl": "5c471ba12e221602b3137d76",
"parentId": "6657c53642f6401b0857903b",
"slotId": "mod_sight_front",
"upd": {
"Sight": {
"ScopesCurrentCalibPointIndexes": [
0
],
"ScopesSelectedModes": [
0
],
"SelectedScope": 0
}
}
}
],
"barter_scheme": {
"6657bc22eb423bf4b7f6e36b": [
[
{
"count": 3700,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657bc2bc2735f472160a694": [
[
{
"count": 4000,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657bc3439728852ed799c4a": [
[
{
"count": 6500,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657bc37e9ca535ba9bfb4c8": [
[
{
"count": 4500,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657bc3c1215023e2ca2c41a": [
[
{
"count": 6800,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657bc3f643bffdeb5ae9107": [
[
{
"count": 7000,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657bc42d9425e71b37eb18e": [
[
{
"count": 6900,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657bfac5ea61e0a6e7022b3": [
[
{
"count": 11500,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657bfbaaae6fd21cbc5c7e3": [
[
{
"count": 6500,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657bfc5db1eda95d3df56e2": [
[
{
"count": 6000,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657bfd5fc004f35cef5a426": [
[
{
"count": 2200,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657c04e26eb4587c12238ae": [
[
{
"count": 3780,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657c04bdd537d04b58bc450": [
[
{
"count": 4250,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657c0488fa5d07ee9954ff8": [
[
{
"count": 5800,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657c044cfdb8c0084ea152b": [
[
{
"count": 13500,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657c33860546ceedbf82985": [
[
{
"count": 89500,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
],
"6657c4a470d9c2350c47aa80": [
[
{
"count": 93000,
"_tpl": "5449016a4bdc2d6f028b456f"
}
]
]
},
"loyal_level_items": {
"6657bc22eb423bf4b7f6e36b": 3,
"6657bc2bc2735f472160a694": 3,
"6657bc3439728852ed799c4a": 3,
"6657bc37e9ca535ba9bfb4c8": 3,
"6657bc3c1215023e2ca2c41a": 3,
"6657bc3f643bffdeb5ae9107": 3,
"6657bc42d9425e71b37eb18e": 3,
"6657bfac5ea61e0a6e7022b3": 3,
"6657bfc5db1eda95d3df56e2": 3,
"6657bfd5fc004f35cef5a426": 3,
"6657c04e26eb4587c12238ae": 3,
"6657c04bdd537d04b58bc450": 3,
"6657c0488fa5d07ee9954ff8": 3,
"6657c044cfdb8c0084ea152b": 3,
"6657c33860546ceedbf82985": 3,
"6657c4a470d9c2350c47aa80": 3,
"6657bfbaaae6fd21cbc5c7e3": 3
}
}
}
mods/SVD/user/mods/WTTArmorySVD/db/Items/WeaponDragunov.json
+1590
View File
File diff suppressed because it is too large Load Diff
mods/SVD/user/mods/WTTArmorySVD/package.json
+34
View File
@@ -0,0 +1,34 @@
{
"name": "WTTArmorySVD",
"author": "Tron",
"version": "1.0.7",
"license": "NCSA",
"main": "src/mod.js",
"sptVersion": "~3.10",
"loadBefore": [],
"loadAfter": [],
"isBundleMod": true,
"incompatibilities": [],
"contributors": [],
"scripts": {
"setup": "npm i",
"build": "node ./build.mjs",
"buildinfo": "node ./build.mjs --verbose"
},
"devDependencies": {
"@types/node": "20.11",
"@typescript-eslint/eslint-plugin": "7.2",
"@typescript-eslint/parser": "7.2",
"archiver": "^6.0",
"eslint": "8.57",
"fs-extra": "11.2",
"ignore": "^5.2",
"os": "^0.1",
"tsyringe": "4.8.0",
"typescript": "5.4",
"winston": "3.12"
},
"dependencies": {
"jsonc": "^2.0.0"
}
}
mods/SVD/user/mods/WTTArmorySVD/src/CustomAssortSchemeService.ts
+49
View File
@@ -0,0 +1,49 @@
/* eslint-disable @typescript-eslint/naming-convention */
import type { WTTInstanceManager } from "./WTTInstanceManager";
import customAssortSchemes from "../db/CustomAssortSchemes/CustomAssortSchemes.json";
import { traderIDs } from "./references/configConsts";
import type { ITraderAssort } from "@spt/models/eft/common/tables/ITrader";
export class CustomAssortSchemeService
{
private instanceManager: WTTInstanceManager;
public preSptLoad(instanceManager: WTTInstanceManager): void
{
this.instanceManager = instanceManager;
}
public postDBLoad(): void
{
const tables = this.instanceManager.database;
for (const traderId in customAssortSchemes)
{
const traderIdFromMap = traderIDs[traderId];
const finalTraderId = traderIdFromMap || traderId;
const trader = tables.traders[finalTraderId];
if (!trader)
{
return;
}
const newAssort : ITraderAssort = customAssortSchemes[traderId];
for (const item of newAssort.items)
{
trader.assort.items.push(item);
}
for (const [itemName, scheme] of Object.entries(newAssort.barter_scheme))
{
trader.assort.barter_scheme[itemName] = scheme;
}
for (const [itemName, count] of Object.entries(newAssort.loyal_level_items))
{
trader.assort.loyal_level_items[itemName] = count;
}
}
}
}
mods/SVD/user/mods/WTTArmorySVD/src/CustomItemService.ts
+856
View File
@@ -0,0 +1,856 @@
/* eslint-disable @typescript-eslint/naming-convention */
import type { NewItemFromCloneDetails } from "@spt/models/spt/mod/NewItemDetails";
import type { ConfigItem } from "./references/configConsts";
import { traderIDs } from "./references/configConsts";
import { currencyIDs } from "./references/configConsts";
import { inventorySlots } from "./references/configConsts";
import { ItemMap } from "./references/items";
import { ItemBaseClassMap } from "./references/itemBaseClasses";
import { ItemHandbookCategoryMap } from "./references/itemHandbookCategories";
import { LogTextColor } from "@spt/models/spt/logging/LogTextColor";
import fs from "node:fs";
import path from "node:path";
import type { WTTInstanceManager } from "./WTTInstanceManager";
import type { IDatabaseTables } from "@spt/models/spt/server/IDatabaseTables";
import type { ILocation } from "@spt/models/eft/common/ILocation";
import type { IPreset } from "@spt/models/eft/common/IGlobals";
import type { IItem } from "@spt/models/eft/common/tables/IItem";
import type { IInventory } from "@spt/models/eft/common/tables/IBotType";
import type { IProps } from "@spt/models/eft/common/tables/ITemplateItem";
export class CustomItemService {
private instanceManager: WTTInstanceManager;
public preSptLoad(instanceManager: WTTInstanceManager): void {
this.instanceManager = instanceManager;
}
public postDBLoad(): void {
const configPath = path.join(__dirname, "../db/Items");
const configFiles = fs
.readdirSync(configPath)
.filter((file) => !file.includes("BaseItemReplacement"));
let numItemsAdded = 0;
for (const file of configFiles) {
const filePath = path.join(configPath, file);
try {
const fileContents = fs.readFileSync(filePath, "utf-8");
const config = JSON.parse(fileContents) as ConfigItem;
for (const itemId in config) {
const itemConfig = config[itemId];
try {
const { exampleCloneItem, finalItemTplToClone } =
this.createExampleCloneItem(itemConfig, itemId);
if (this.instanceManager.debug) {
console.log(`Processing file: ${file}, Item ID: ${itemId}`);
console.log(
`Prefab Path: ${exampleCloneItem.overrideProperties?.Prefab.path}`
);
}
this.instanceManager.customItem.createItemFromClone(exampleCloneItem);
this.processStaticLootContainers(itemConfig, itemId);
this.processModSlots(itemConfig, [finalItemTplToClone], itemId);
this.processInventorySlots(itemConfig, itemId);
this.processMasterySections(itemConfig, itemId);
this.processWeaponPresets(itemConfig, itemId);
this.processTraders(itemConfig, itemId);
this.addtoHallofFame(itemConfig, itemId);
this.addtoSpecialSlots(itemConfig, itemId);
numItemsAdded++;
} catch (itemError) {
console.error(`Error processing item ID: ${itemId} in file: ${file}`);
console.error(itemError);
}
}
} catch (fileError) {
console.error(`Error processing config file: ${file}`);
console.error(fileError);
}
}
if (numItemsAdded > 0) {
this.instanceManager.logger.log(
`[${this.instanceManager.modName}] Database: Loaded ${numItemsAdded} custom items.`,
LogTextColor.GREEN
);
} else {
this.instanceManager.logger.log(
`[${this.instanceManager.modName}] Database: No custom items loaded.`,
LogTextColor.GREEN
);
}
// Post-item processing (e.g., bot inventories, quest modifications)
for (const file of configFiles) {
const filePath = path.join(configPath, file);
try {
const fileContents = fs.readFileSync(filePath, "utf-8");
const config = JSON.parse(fileContents) as ConfigItem;
for (const itemId in config) {
const itemConfig = config[itemId];
this.processBotInventories(itemConfig, itemConfig.itemTplToClone, itemId);
}
} catch (fileError) {
console.error(`Error processing bot inventories for file: ${file}`);
console.error(fileError);
}
}
}
/**
* Creates an example clone item with the provided item configuration and item ID.
*
* @param {any} itemConfig - The configuration of the item to clone.
* @param {string} itemId - The ID of the item.
* @return {{ exampleCloneItem: NewItemFromCloneDetails, finalItemTplToClone: string }} The created example clone item and the final item template to clone.
*/
private createExampleCloneItem(
itemConfig: ConfigItem[string],
itemId: string
): {
exampleCloneItem: NewItemFromCloneDetails;
finalItemTplToClone: string;
} {
const itemTplToCloneFromMap =
ItemMap[itemConfig.itemTplToClone] || itemConfig.itemTplToClone;
const finalItemTplToClone = itemTplToCloneFromMap;
const parentIdFromMap =
ItemBaseClassMap[itemConfig.parentId] || itemConfig.parentId;
const finalParentId = parentIdFromMap;
const handbookParentIdFromMap =
ItemHandbookCategoryMap[itemConfig.handbookParentId] ||
itemConfig.handbookParentId;
const finalHandbookParentId = handbookParentIdFromMap;
const itemPrefabPath = `customItems/${itemId}.bundle`;
const exampleCloneItem: NewItemFromCloneDetails = {
itemTplToClone: finalItemTplToClone,
overrideProperties: itemConfig.overrideProperties
? {
...itemConfig.overrideProperties,
Prefab: {
path:
itemConfig.overrideProperties.Prefab?.path || itemPrefabPath,
rcid: ""
}
}
: undefined,
parentId: finalParentId,
newId: itemId,
fleaPriceRoubles: itemConfig.fleaPriceRoubles,
handbookPriceRoubles: itemConfig.handbookPriceRoubles,
handbookParentId: finalHandbookParentId,
locales: itemConfig.locales
};
if (this.instanceManager.debug) {
console.log(`Cloning item ${finalItemTplToClone} for itemID: ${itemId}`);
}
return { exampleCloneItem, finalItemTplToClone };
}
/**
* Adds an item to a static loot container with a given probability.
*
* @param {string} containerID - The ID of the loot container.
* @param {string} itemToAdd - The item to add to the loot container.
* @param {number} probability - The probability of the item being added.
* @return {void} This function does not return anything.
*/
private addToStaticLoot(
containerID: string,
itemToAdd: string,
probability: number
): void {
const locations = this.instanceManager.database.locations;
for (const locationID in locations) {
if (!Object.prototype.hasOwnProperty.call(locations, locationID)) {
continue; // Skip invalid locations
}
const location: ILocation = locations[locationID];
if (!location.staticLoot) {
if (this.instanceManager.debug) {
console.warn(`Warning: No static loot found in location: ${locationID}`);
}
continue;
}
const staticLoot = location.staticLoot;
if (!Object.prototype.hasOwnProperty.call(staticLoot, containerID)) {
if (this.instanceManager.debug) {
console.log(`Error: Loot container ID ${containerID} not found in location: ${locationID}`);
}
continue;
}
const lootContainer = staticLoot[containerID];
if (!lootContainer) {
if (this.instanceManager.debug) {
console.log(`Error: Loot container ID ${containerID} is null in location: ${locationID}`);
}
continue;
}
const templateFromMap = ItemMap[itemToAdd];
const finalTemplate = templateFromMap || itemToAdd;
const newLoot = [
{
tpl: finalTemplate,
relativeProbability: probability,
},
];
lootContainer.itemDistribution.push(...newLoot);
if (this.instanceManager.debug) {
console.log(`Added ${itemToAdd} to loot container: ${containerID} in location: ${locationID}`);
}
}
}
/**
* Processes the static loot containers for a given item.
*
* @param {any} itemConfig - The configuration object for the item.
* @param {string} itemId - The ID of the item.
* @return {void} This function does not return a value.
*/
private processStaticLootContainers(itemConfig: ConfigItem[string], itemId: string): void {
if (itemConfig.addtoStaticLootContainers) {
if (this.instanceManager.debug) {
console.log("Processing static loot containers for item:", itemId);
}
if (Array.isArray(itemConfig.StaticLootContainers)) {
if (this.instanceManager.debug) {
console.log("Adding item to multiple static loot containers:");
}
for (const container of itemConfig.StaticLootContainers) {
const staticLootContainer =
ItemMap[container.ContainerName] || container.ContainerName;
this.addToStaticLoot(
staticLootContainer,
itemId,
container.Probability
);
if (this.instanceManager.debug) {
console.log(
` - Added to container '${staticLootContainer}' with probability ${container.Probability}`
);
}
}
}
else {
const staticLootContainer =
ItemMap[itemConfig.StaticLootContainers] ||
itemConfig.StaticLootContainers;
this.addToStaticLoot(
staticLootContainer,
itemId,
itemConfig.Probability
);
if (this.instanceManager.debug) {
console.log(`Added to container '${staticLootContainer}' with probability ${itemConfig.Probability}`);
}
}
}
}
/**
* Processes the mod slots of an item.
*
* @param {any} itemConfig - The configuration of the item.
* @param {string[]} finalItemTplToClone - The final item template to clone.
* @param {string} itemId - The ID of the item.
* @returns {void}
*/
private processModSlots(
itemConfig: ConfigItem[string],
finalItemTplToClone: string[],
itemId: string
): void {
const tables = this.instanceManager.database;
const moddableItemWhitelistIds = Array.isArray(
itemConfig.ModdableItemWhitelist
)
? itemConfig.ModdableItemWhitelist.map((shortname) => ItemMap[shortname])
: itemConfig.ModdableItemWhitelist
? [ItemMap[itemConfig.ModdableItemWhitelist]]
: [];
const moddableItemBlacklistIds = Array.isArray(
itemConfig.ModdableItemBlacklist
)
? itemConfig.ModdableItemBlacklist.map((shortname) => ItemMap[shortname])
: itemConfig.ModdableItemBlacklist
? [ItemMap[itemConfig.ModdableItemBlacklist]]
: [];
const modSlots = Array.isArray(itemConfig.modSlot)
? itemConfig.modSlot
: itemConfig.modSlot
? [itemConfig.modSlot]
: [];
const lowercaseModSlots = modSlots.map((modSlotName) =>
modSlotName.toLowerCase()
);
if (itemConfig.addtoModSlots) {
if (this.instanceManager.debug) {
console.log("Processing mod slots for item:", itemId);
}
for (const parentItemId in tables.templates.items) {
const parentItem = tables.templates.items[parentItemId];
if (!parentItem._props.Slots) {
continue;
}
const isBlacklisted = moddableItemBlacklistIds.includes(parentItemId);
const isWhitelisted = moddableItemWhitelistIds.includes(parentItemId);
if (isBlacklisted) {
continue;
}
let addToModSlots = false;
if (isWhitelisted && itemConfig.modSlot) {
addToModSlots = true;
}
else if (!isBlacklisted && itemConfig.modSlot) {
for (const modSlot of parentItem._props.Slots) {
if (
modSlot._props.filters?.[0].Filter.some((filterItem) =>
finalItemTplToClone.includes(filterItem)
)
) {
if (lowercaseModSlots.includes(modSlot._name.toLowerCase())) {
addToModSlots = true;
break;
}
}
}
}
if (addToModSlots) {
for (const modSlot of parentItem._props.Slots) {
if (lowercaseModSlots.includes(modSlot._name.toLowerCase())) {
if (!modSlot._props.filters) {
modSlot._props.filters = [
{
AnimationIndex: 0,
Filter: []
}
];
}
if (!modSlot._props.filters[0].Filter.includes(itemId)) {
modSlot._props.filters[0].Filter.push(itemId);
if (this.instanceManager.debug) {
console.log(`Successfully added item ${itemId} to the filter of mod slot ${modSlot._name} for parent item ${parentItemId}`);
}
}
}
}
}
}
}
}
/**
* Processes the inventory slots for a given item.
*
* @param {any} itemConfig - The configuration object for the item.
* @param {string} itemId - The ID of the item.
* @param {any} defaultInventorySlots - The default inventory slots.
* @return {void} This function does not return a value.
*/
private processInventorySlots(
itemConfig: ConfigItem[string],
itemId: string
): void {
const tables = this.instanceManager.database;
if (itemConfig.addtoInventorySlots) {
if (this.instanceManager.debug) {
console.log("Processing inventory slots for item:", itemId);
}
const defaultInventorySlots =
tables.templates.items["55d7217a4bdc2d86028b456d"]._props.Slots;
const allowedSlots = Array.isArray(itemConfig.addtoInventorySlots)
? itemConfig.addtoInventorySlots
: [itemConfig.addtoInventorySlots];
// Iterate over the slots and push the item into the filters per the config
for (const slot of defaultInventorySlots) {
const slotName = inventorySlots[slot._name];
const slotId = Object.keys(inventorySlots).find(
(key) => inventorySlots[key] === slot._name
);
if (
allowedSlots.includes(slot._name) ||
allowedSlots.includes(slotName) ||
allowedSlots.includes(slotId)
) {
if (!slot._props.filters[0].Filter.includes(itemId)) {
slot._props.filters[0].Filter.push(itemId);
if (this.instanceManager.debug) {
console.log(`Successfully added item ${itemId} to the filter of slot ${slot._name}`);
}
}
}
}
}
}
/**
* Processes the mastery sections for an item.
*
* @param {any} itemConfig - The configuration object for the item.
* @param {string} itemId - The ID of the item.
* @param {any} tables - The tables object containing global configuration.
* @return {void} This function does not return a value.
*/
private processMasterySections(
itemConfig: ConfigItem[string],
itemId: string
): void {
const tables = this.instanceManager.database;
if (itemConfig.masteries) {
if (this.instanceManager.debug) {
console.log("Processing mastery sections for item:", itemId);
}
const masterySections = Array.isArray(itemConfig.masterySections)
? itemConfig.masterySections
: [itemConfig.masterySections];
for (const mastery of masterySections) {
const existingMastery = tables.globals.config.Mastering.find(
(existing) => existing.Name === mastery.Name
);
if (existingMastery) {
existingMastery.Templates.push(...mastery.Templates);
if (this.instanceManager.debug) {
console.log(` - Adding to existing mastery section for item: ${itemId}`);
}
}
else {
tables.globals.config.Mastering.push(mastery);
if (this.instanceManager.debug) {
console.log(` - Adding new mastery section for item: ${itemId}`);
}
}
}
}
}
/**
* Processes weapon presets based on the provided item configuration and tables.
*
* @param {any} itemConfig - The item configuration.
* @return {void} This function does not return anything.
*/
private processWeaponPresets(
itemConfig: ConfigItem[string],
itemId: string
): void {
const tables = this.instanceManager.database;
const { addweaponpreset, weaponpresets } = itemConfig;
const itemPresets = tables.globals.ItemPresets;
if (addweaponpreset) {
if (this.instanceManager.debug) {
console.log("Processing weapon presets for item:", itemId);
}
for (const presetData of weaponpresets) {
const preset: IPreset = {
_changeWeaponName: presetData._changeWeaponName,
_encyclopedia: presetData._encyclopedia || undefined,
_id: presetData._id,
_items: presetData._items.map((itemData: IItem) => {
const item: IItem = {
_id: itemData._id,
_tpl: itemData._tpl
};
// Add parentId and slotId only if they are present in itemData
if (itemData.parentId) {
item.parentId = itemData.parentId;
}
if (itemData.slotId) {
item.slotId = itemData.slotId;
}
return item;
}),
_name: presetData._name,
_parent: presetData._parent,
_type: "Preset"
};
itemPresets[preset._id] = preset;
if (this.instanceManager.debug) {
console.log(` - Added weapon preset: ${preset._name}`);
console.log(` - Preset: ${JSON.stringify(preset)}`);
}
}
}
}
/**
* Processes traders based on the item configuration.
*
* @param {any} itemConfig - The configuration of the item.
* @param {string} itemId - The ID of the item.
* @return {void} This function does not return a value.
*/
private processTraders(
itemConfig: ConfigItem[string],
itemId: string
): void {
const tables = this.instanceManager.database;
if (!itemConfig.addtoTraders) {
return;
}
const { traderId, traderItems, barterScheme } = itemConfig;
const traderIdFromMap = traderIDs[traderId];
const finalTraderId = traderIdFromMap || traderId;
const trader = tables.traders[finalTraderId];
if (!trader) {
return;
}
for (const item of traderItems) {
if (this.instanceManager.debug) {
console.log("Processing traders for item:", itemId);
}
const newItem = {
_id: itemId,
_tpl: itemId,
parentId: "hideout",
slotId: "hideout",
upd: {
UnlimitedCount: item.unlimitedCount,
StackObjectsCount: item.stackObjectsCount
}
};
trader.assort.items.push(newItem);
if (this.instanceManager.debug) {
console.log(`Successfully added item ${itemId} to the trader ${traderId}`);
}
}
trader.assort.barter_scheme[itemId] = [];
for (const scheme of barterScheme) {
if (this.instanceManager.debug) {
console.log("Processing trader barter scheme for item:", itemId);
}
const count = scheme.count;
const tpl = currencyIDs[scheme._tpl] || ItemMap[scheme._tpl];
if (!tpl) {
throw new Error(
`Invalid _tpl value in barterScheme for item: ${itemId}`
);
}
trader.assort.barter_scheme[itemId].push([
{
count: count,
_tpl: tpl
}
]);
if (this.instanceManager.debug) {
console.log(`Successfully added item ${itemId} to the barter scheme of trader ${traderId}`);
}
}
trader.assort.loyal_level_items[itemId] = itemConfig.loyallevelitems;
}
private addtoHallofFame(itemConfig: ConfigItem[string], itemId: string) {
const hallofFame1 = this.instanceManager.database.templates.items["63dbd45917fff4dee40fe16e"];
const hallofFame2 = this.instanceManager.database.templates.items["65424185a57eea37ed6562e9"];
const hallofFame3 = this.instanceManager.database.templates.items["6542435ea57eea37ed6562f0"];
// Add to Hall of Fame filters
if (itemConfig.addtoHallOfFame) {
const hallOfFames = [hallofFame1, hallofFame2, hallofFame3];
for (const hall of hallOfFames) {
for (const slot of hall._props.Slots) {
for (const filter of slot._props.filters) {
if (!filter.Filter.includes(itemId)) {
filter.Filter.push(itemId);
if (this.instanceManager.debug) {
console.log(`Added item ${itemId} to filter Hall of Fame ${hall._name}`);
}
}
}
}
}
}
}
private addtoSpecialSlots(itemConfig: ConfigItem[string], itemId: string) {
const tables = this.instanceManager.database;
if (itemConfig.addtoSpecialSlots) {
const pockets = tables.templates.items["627a4e6b255f7527fb05a0f6"];
for (const slot of pockets._props.Slots) {
if (!slot._props.filters[0].Filter.includes(itemId)) {
slot._props.filters[0].Filter.push(itemId);
}
}
}
}
/**
* Processes the bot inventories based on the given item configuration.
*
* @param {ConfigItem[string]} itemConfig - The item configuration.
* @param {string} finalItemTplToClone - The final item template to clone.
* @param {string} itemId - The item ID.
* @return {void} This function does not return anything.
*/
private processBotInventories(
itemConfig: ConfigItem[string],
finalItemTplToClone: string,
itemId: string
): void {
const tables = this.instanceManager.database;
if (!itemConfig.addtoBots) return;
if (this.instanceManager.debug) {
console.log("Processing bot inventories for item:", itemId);
}
// Iterate through bot types
for (const botId in tables.bots.types) {
const botType = botId;
const botInventory = tables.bots.types[botId].inventory;
botInventory.Ammo = botInventory.Ammo || {};
// Process items and equipment
this.processInventoryType(botInventory.items, finalItemTplToClone, itemId, botType, "items");
this.processInventoryType(botInventory.equipment, finalItemTplToClone, itemId, botType, "equipment");
// Process mods if applicable
if (itemConfig.addtoModSlots && itemConfig.modSlot) {
this.processBotModSlots(finalItemTplToClone, itemId, botType, itemConfig.modSlot);
}
}
}
/**
* Processes inventory type (items or equipment) and gathers mods based on Slots.
*
* @param {any} inventoryType - The inventory type to process.
* @param {string} finalTplToClone - The final item template to clone.
* @param {string} itemId - The item ID.
* @param {string} botType - The bot type identifier.
* @param {string} typeLabel - Label indicating items or equipment.
* @return {void} This function does not return anything.
*/
private processInventoryType(
// biome-ignore lint/suspicious/noExplicitAny: <explanation>
inventoryType: any,
finalTplToClone: string,
itemId: string,
botType: string,
typeLabel: string
): void {
const tables = this.instanceManager.database;
if (typeLabel === "equipment" && (
(inventoryType.FirstPrimaryWeapon?.[finalTplToClone]) ||
(inventoryType.SecondPrimaryWeapon?.[finalTplToClone]) ||
(inventoryType.Holster?.[finalTplToClone])
)) {
if (!this.ensureValidWeaponPreset(itemId)) {
return;
}
this.processAmmoAndChambers(tables.bots.types[botType].inventory, tables.templates.items[itemId]._props, itemId, botType);
}
for (const lootSlot in inventoryType) {
const items = inventoryType[lootSlot];
if (items && items[finalTplToClone] !== undefined) {
const weight = items[finalTplToClone];
if (this.instanceManager.debug) {
console.log(` - Adding item to bot ${typeLabel} for bot type: ${botType} in loot slot: ${lootSlot} with weight: ${weight}`);
}
items[itemId] = weight;
this.addModsToItem(tables, itemId, botType);
}
}
}
/**
* Adds mods to an item based on its Slots configuration.
*
* @param {any} tables - The database tables.
* @param {string} itemId - The item ID.
* @param {string} botType - The bot type identifier.
* @return {void} This function does not return anything.
*/
private addModsToItem(tables: IDatabaseTables, itemId: string, botType: string): void {
const itemProps = tables.templates.items[itemId]._props;
if (itemProps?.Slots) {
for (const slot of itemProps.Slots) {
const slotName = slot._name;
const filters = slot._props.filters;
if (filters && filters.length > 0) {
for (const filter of filters) {
for (const modId of filter.Filter) {
if (modId && tables.templates.items[modId]) {
tables.bots.types[botType].inventory.mods[itemId] = tables.bots.types[botType].inventory.mods[itemId] || {};
tables.bots.types[botType].inventory.mods[itemId][slotName] = tables.bots.types[botType].inventory.mods[itemId][slotName] || [];
if (!tables.bots.types[botType].inventory.mods[itemId][slotName].includes(modId)) {
tables.bots.types[botType].inventory.mods[itemId][slotName].push(modId);
if (tables.templates.items[modId]._props) {
if (tables.templates.items[modId]._props.Slots.length > 0) {
this.addModsToItem(tables, modId, botType);
}
}
}
if (this.instanceManager.debug) {
console.log(` - Added mod ${modId} to ${itemId}'s ${slotName} of bot type ${botType}`);
}
}
}
}
}
}
}
}
/**
* Processes mod slots and adds itemId to specified slots if finalItemTplToClone is present.
*
* @param {any} mods - The mods inventory.
* @param {string} finalItemTplToClone - The final item template to clone.
* @param {string} itemId - The item ID.
* @param {string} botType - The bot type identifier.
* @param {string[]} modSlots - The list of mod slots to process.
* @return {void} This function does not return anything.
*/
private processBotModSlots(
finalItemTplToClone: string,
itemId: string,
botType: string,
modSlots: string[]
): void {
const mods = this.instanceManager.database.bots.types[botType].inventory.mods;
for (const item in mods) {
const itemMods = mods[item];
for (const modSlot of modSlots) {
if (itemMods[modSlot]?.includes(finalItemTplToClone)) {
itemMods[modSlot].push(itemId);
if (this.instanceManager.debug) {
console.log(` - Added item ${itemId} to mod slot ${modSlot} for bot type ${botType} in item ${item}`);
}
// Adding nested mods for the new item
this.addModsToItem(this.instanceManager.database, itemId, botType);
}
}
}
}
/**
* Processes ammo and chambers, adding calibers and chamber filters if needed.
*
* @param {any} botInventory - The bot's inventory.
* @param {any} itemProps - The properties of the item.
* @param {string} itemId - The item ID.
* @param {string} botType - The bot type identifier.
* @return {void} This function does not return anything.
*/
private processAmmoAndChambers(
botInventory: IInventory,
itemProps: IProps,
itemId: string,
botType: string
): void {
const ammoCaliber = itemProps.ammoCaliber;
if (!ammoCaliber) return;
botInventory.Ammo[ammoCaliber] = botInventory.Ammo[ammoCaliber] || {};
if (this.instanceManager.debug) {
console.log(` - Added new caliber ${ammoCaliber} to bot inventory for bot type ${botType}`);
}
if (itemProps.Chambers) {
for (const chamber of itemProps.Chambers) {
const filters = chamber._props.filters;
if (filters && filters.length > 0) {
for (const filter of filters) {
for (const filterItem of filter.Filter) {
botInventory.Ammo[ammoCaliber][filterItem] = botInventory.Ammo[ammoCaliber][filterItem] || 0;
if (this.instanceManager.debug) {
console.log(` - Added filter item ${filterItem} to caliber ${ammoCaliber} in bot inventory for bot type ${botType}`);
}
}
}
}
}
}
}
/**
* Ensures the weapon has a valid preset in the global ItemPresets.
*
* @param {string} itemId - The item ID.
* @return {boolean} True if the weapon has a valid preset, false otherwise.
*/
private ensureValidWeaponPreset(itemId: string): boolean {
const db = this.instanceManager.database;
const presets: Record<string, IPreset> = db.globals.ItemPresets;
for (const presetObj of Object.values(presets)) {
if (presetObj._items[0]._tpl === itemId) {
if (this.instanceManager.debug) {
console.log(` - Valid preset found for item ${itemId}`);
}
return true;
}
}
if (this.instanceManager.debug) {
console.warn(`No valid preset found for item ${itemId} in globals.ItemPresets`);
}
return false;
}
}
mods/SVD/user/mods/WTTArmorySVD/src/WTTInstanceManager.ts
+119
View File
@@ -0,0 +1,119 @@
import path from "node:path";
import type { ILogger } from "@spt/models/spt/utils/ILogger";
import type { ProfileController } from "@spt/controllers/ProfileController";
import type { ProfileCallbacks } from "@spt/callbacks/ProfileCallbacks";
import type { EventOutputHolder } from "@spt/routers/EventOutputHolder";
import type { DatabaseServer } from "@spt/servers/DatabaseServer";
import type { IDatabaseTables } from "@spt/models/spt/server/IDatabaseTables";
import type { StaticRouterModService } from "@spt/services/mod/staticRouter/StaticRouterModService";
import type { DynamicRouterModService } from "@spt/services/mod/dynamicRouter/DynamicRouterModService";
import type { TraderAssortService } from "@spt/services/TraderAssortService";
import type { DependencyContainer } from "tsyringe";
import type { CustomItemService } from "@spt/services/mod/CustomItemService";
import type { ImageRouter } from "@spt/routers/ImageRouter";
import type { PreSptModLoader } from "@spt/loaders/PreSptModLoader";
import type { ConfigServer } from "@spt/servers/ConfigServer";
import type { JsonUtil } from "@spt/utils/JsonUtil";
import type { ProfileHelper } from "@spt/helpers/ProfileHelper";
import type { RagfairPriceService } from "@spt/services/RagfairPriceService";
import type { ImporterUtil } from "@spt/utils/ImporterUtil";
import type { SaveServer } from "@spt/servers/SaveServer";
import type { ItemHelper } from "@spt/helpers/ItemHelper";
import type { ApplicationContext } from "@spt/context/ApplicationContext";
import type { VFS } from "@spt/utils/VFS";
export class WTTInstanceManager
{
//#region Accessible in or after preSptLoad
public modName: string;
public debug: boolean;
// Useful Paths
public profilePath: string = path.join(process.cwd(), "\\user\\profiles");
// Instances
public container: DependencyContainer;
public PreSptModLoader: PreSptModLoader;
public configServer: ConfigServer;
public saveServer: SaveServer;
public itemHelper: ItemHelper;
public logger: ILogger;
public staticRouter: StaticRouterModService;
public dynamicRouter: DynamicRouterModService;
public profileController: ProfileController;
public profileCallbacks: ProfileCallbacks;
//#endregion
//#region Acceessible in or after postDBLoad
public database: IDatabaseTables;
public customItem: CustomItemService;
public imageRouter: ImageRouter;
public jsonUtil: JsonUtil;
public profileHelper: ProfileHelper;
public eventOutputHolder: EventOutputHolder;
public ragfairPriceService: RagfairPriceService;
public importerUtil: ImporterUtil;
public traderAssortService: TraderAssortService;
public applicationContext: ApplicationContext;
public vfs: VFS;
//#endregion
// Call at the start of the mods postDBLoad method
public preSptLoad(container: DependencyContainer, mod: string): void
{
this.modName = mod;
this.container = container;
this.PreSptModLoader = container.resolve<PreSptModLoader>("PreSptModLoader");
this.imageRouter = container.resolve<ImageRouter>("ImageRouter");
this.configServer = container.resolve<ConfigServer>("ConfigServer");
this.saveServer = container.resolve<SaveServer>("SaveServer");
this.itemHelper = container.resolve<ItemHelper>("ItemHelper");
this.eventOutputHolder = container.resolve<EventOutputHolder>("EventOutputHolder");
this.profileController = container.resolve<ProfileController>("ProfileController");
this.profileCallbacks = container.resolve<ProfileCallbacks>("ProfileCallbacks");
this.logger = container.resolve<ILogger>("WinstonLogger");
this.staticRouter = container.resolve<StaticRouterModService>("StaticRouterModService");
this.dynamicRouter = container.resolve<DynamicRouterModService>("DynamicRouterModService");
this.traderAssortService = container.resolve<TraderAssortService>("TraderAssortService");
this.vfs = container.resolve<VFS>("VFS");
}
public postDBLoad(container: DependencyContainer): void
{
this.database = container.resolve<DatabaseServer>("DatabaseServer").getTables();
this.customItem = container.resolve<CustomItemService>("CustomItemService");
this.jsonUtil = container.resolve<JsonUtil>("JsonUtil");
this.profileHelper = container.resolve<ProfileHelper>("ProfileHelper");
this.ragfairPriceService = container.resolve<RagfairPriceService>("RagfairPriceService");
this.importerUtil = container.resolve<ImporterUtil>("ImporterUtil");
this.applicationContext = container.resolve<ApplicationContext>("ApplicationContext");
}
public colorLog(message: string, color: string) {
const colorCodes = {
red: "\x1b[31m",
green: "\x1b[32m",
yellow: "\x1b[33m",
blue: "\x1b[34m",
magenta: "\x1b[35m",
cyan: "\x1b[36m",
white: "\x1b[37m",
gray: "\x1b[90m",
brightRed: "\x1b[91m",
brightGreen: "\x1b[92m",
brightYellow: "\x1b[93m",
brightBlue: "\x1b[94m",
brightMagenta: "\x1b[95m",
brightCyan: "\x1b[96m",
brightWhite: "\x1b[97m"
};
const resetCode = "\x1b[0m";
const colorCode = colorCodes[color as keyof typeof colorCodes] || "\x1b[37m"; // Default to white if color is invalid.
console.log(`${colorCode}${message}${resetCode}`); // Log the colored message here
}
}
mods/SVD/user/mods/WTTArmorySVD/src/mod.ts
+117
View File
@@ -0,0 +1,117 @@
/* eslint-disable @typescript-eslint/naming-convention */
import * as fs from "node:fs";
import * as path from "node:path";
import type { DependencyContainer } from "tsyringe";
import type { IPostDBLoadMod } from "@spt/models/external/IPostDBLoadMod";
import type { IPreSptLoadMod } from "@spt/models/external/IPreSptLoadMod";
import { LogTextColor } from "@spt/models/spt/logging/LogTextColor";
// WTT imports
import { WTTInstanceManager } from "./WTTInstanceManager";
// Boss imports
import { CustomItemService } from "./CustomItemService";
// Custom Trader Assort Items
import { CustomAssortSchemeService } from "./CustomAssortSchemeService";
class WTTArmorySVD
implements IPreSptLoadMod, IPostDBLoadMod
{
private Instance: WTTInstanceManager = new WTTInstanceManager();
private version: string;
private modName = "WTTArmorySVD";
private config;
//#region CustomBosses
private customItemService: CustomItemService = new CustomItemService();
//#endregion
private customAssortSchemeService: CustomAssortSchemeService = new CustomAssortSchemeService();
debug = false;
// Anything that needs done on preSptLoad, place here.
public preSptLoad(container: DependencyContainer): void
{
// Initialize the instance manager DO NOTHING ELSE BEFORE THIS
this.Instance.preSptLoad(container, this.modName);
this.Instance.debug = this.debug;
// EVERYTHING AFTER HERE MUST USE THE INSTANCE
this.getVersionFromJson();
this.displayCreditBanner();
// Custom Bosses
this.customItemService.preSptLoad(this.Instance);
this.customAssortSchemeService.preSptLoad(this.Instance);
}
// Anything that needs done on postDBLoad, place here.
postDBLoad(container: DependencyContainer): void
{
// Initialize the instance manager DO NOTHING ELSE BEFORE THIS
this.Instance.postDBLoad(container);
// EVERYTHING AFTER HERE MUST USE THE INSTANCE
// Bosses
this.customItemService.postDBLoad();
this.customAssortSchemeService.postDBLoad();
this.Instance.logger.log(
`[${this.modName}] Database: Loading complete.`,
LogTextColor.GREEN
);
}
private getVersionFromJson(): void
{
const packageJsonPath = path.join(__dirname, "../package.json");
fs.readFile(packageJsonPath, "utf-8", (err, data) =>
{
if (err)
{
console.error("Error reading file:", err);
return;
}
const jsonData = JSON.parse(data);
this.version = jsonData.version;
});
}
private displayCreditBanner(): void
{
this.Instance.logger.log(
`[${this.modName}] ------------------------------------------------------------------------`,
LogTextColor.GREEN
);
this.Instance.logger.log(
`[${this.modName}] Pre-Alpha development build`,
LogTextColor.GREEN
);
this.Instance.logger.log(
`[${this.modName}] Developers: Tron and the WTT Team`,
LogTextColor.GREEN
);
this.Instance.logger.log(
`[${this.modName}] Yevgeny Dragunov would be proud.`,
LogTextColor.GREEN
);
this.Instance.logger.log(
`[${this.modName}] ------------------------------------------------------------------------`,
LogTextColor.GREEN
);
}
}
module.exports = { mod: new WTTArmorySVD() };
mods/SVD/user/mods/WTTArmorySVD/src/references/configConsts.ts
+296
View File
@@ -0,0 +1,296 @@
/* eslint-disable @typescript-eslint/naming-convention */
import type { IPreset } from "@spt/models/eft/common/IGlobals";
import type { Ixyz } from "@spt/models/eft/common/Ixyz";
import type { IPrefab } from "@spt/models/eft/common/tables/ICustomizationItem";
export interface ConfigItem
{
[itemId: string]: {
itemTplToClone: string;
overrideProperties: {
Prefab: {
path: string;
rcid: string;
};
ReverbVolume: number;
};
parentId: string;
fleaPriceRoubles: number;
handbookPriceRoubles: number;
handbookParentId: string;
locales: {
[locale: string]: {
name: string;
shortName: string;
description: string;
};
};
clearClonedProps: boolean;
addtoInventorySlots: string[];
addtoModSlots: boolean;
modSlot: string[];
ModdableItemWhitelist: string;
ModdableItemBlacklist: string;
addtoTraders: boolean;
traderId: traderIDs;
traderItems: {
unlimitedCount: boolean;
stackObjectsCount: number;
}[];
barterScheme: {
count: number;
_tpl: string;
}[];
loyallevelitems: number;
addtoBots: boolean;
addtoStaticLootContainers: boolean;
StaticLootContainers: string;
Probability: number;
masteries: boolean;
masterySections: {
Name: string;
Templates: string[];
Level2: number;
Level3: number;
};
addweaponpreset: boolean;
weaponpresets: IPreset[];
addtoHallOfFame: boolean;
addtoSpecialSlots: boolean;
};
};
export interface HeadConfig {
path: string;
addHeadToPlayer: boolean;
side: string[];
locales: {
[key: string]: string; // This allows dynamic locale keys, such as "en", "ru", etc.
};
}
export interface VoiceConfig
{
[voiceId: string]: {
locales: {
[key: string]: string; // This allows dynamic locale keys, such as "en", "ru", etc.
};
name: string;
addVoiceToPlayer: boolean;
sideSpecificVoice: string;
addToBotTypes: Record<string, number>;
};
}
export interface ClothingConfig {
type: string; // The type of clothing item, e.g., "bottom"
suiteId: string; // ID of the clothing item's suite
outfitId: string; // Unique identifier for the outfit
bottomId?: string; // ID of the clothing item's bottom
locales: {
[key: string]: string; // This allows dynamic locale keys, such as "en", "ru", etc.
};
topId?: string; // ID of the clothing item's top
handsId?: string; // ID of the clothing item's hands
side: string[]; // Side of the clothing item, e.g., ["usec", "bear"]
bottomBundlePath?: string; // Path to the clothing item's asset bundle
topBundlePath?: string; // Path to the clothing item's top asset bundle
handsBundlePath?: string; // Path to the clothing item's hands asset bundle
watchPrefab?: IPrefab; // Path to the watch prefab asset bundle
watchPosition?: Ixyz; // Position of the watch on the clothing item
watchRotation?: Ixyz; // Rotation of the watch on the clothing item
handsBaseID?: string; // ID of the clothing item's hands base
traderId: string; // Trader who sells this item, e.g., "RAGMAN"
loyaltyLevel: number; // Loyalty level required to purchase the item
profileLevel: number; // Player profile level required to purchase the item
standing: number; // Minimum standing required with the trader
currencyId: string; // Currency type for the item's price, e.g., "ROUBLES"
price: number; // Cost of the clothing item in the specified currency
}
export enum traderIDs
{
MECHANIC = "5a7c2eca46aef81a7ca2145d",
SKIER = "58330581ace78e27b8b10cee",
PEACEKEEPER = "5935c25fb3acc3127c3d8cd9",
THERAPIST = "54cb57776803fa99248b456e",
PRAPOR = "54cb50c76803fa8b248b4571",
JAEGAR = "5c0647fdd443bc2504c2d371",
RAGMAN = "5ac3b934156ae10c4430e83c",
FENCE = "579dc571d53a0658a154fbec",
BADGER = "bd3a8b28356d9c6509966546"
}
export enum currencyIDs
{
ROUBLES = "5449016a4bdc2d6f028b456f",
EUROS = "569668774bdc2da2298b4568",
DOLLARS = "5696686a4bdc2da3298b456a"
}
export enum allBotTypes
{
// Arena Fighters
ARENAFIGHTER = "arenafighter",
ARENAFIGHTEREVENT = "arenafighterevent",
// Scavs
ASSAULT = "assault",
ASSAULTGROUP = "assaultgroup",
MARKSMAN = "marksman",
CRAZYASSAULTEVENT = "crazyassaultevent",
CURSEDASSAULT = "cursedassault",
// PMC's
BEAR = "bear",
USEC = "usec",
PMCBEAR = "pmcbear",
PMCUSEC = "pmcusec",
PMC = "pmcbot",
// ExUsec
EXUSEC = "exusec",
// Cultists
CULTISTPRIEST = "sectantpriest",
CULTISTWARRIOR = "sectantwarrior",
CULTISTONI = "sectantoni",
CULTISTPRIESTEVENT = "sectantpriestevent",
CULTISTPREDVESTNIK = "sectantpredvestnik",
CULTISTPRIZRAK = "sectantprizrak",
// BTR
BTR = "btrshooter",
// Spirits
SPIRITSPRING = "spiritspring",
SPIRITWINTER = "spiritwinter",
// Zombies
INFECTEDASSAULT = "infectedassault",
INFECTEDCIVIL = "infectedcivil",
INFECTEDLABORANT = "infectedlaborant",
INFECTEDPMC = "infectedpmc",
INFECTEDTAGILLA = "infectedtagilla",
// Santa
GIFTER = "gifter",
// Bosses & Followers
// Kaban
KABAN = "bossboar",
KABANSNIPER = "bossboarsniper",
FOLLOWERBOAR = "followerboar",
FOLLOWERBOARCLOSE1 = "followerboarclose1",
FOLLOWERBOARCLOSE2 = "followerboarclose2",
// Killa
KILLA = "bosskilla",
// Kolontay
KOLONTAY = "bosskolontay",
FOLLOWERKOLONTAYASSAULT = "followerkolontayassault",
FOLLOWERKOLONTAYSECURITY = "followerkolontaysecurity",
// Partisan
PARTISAN = "bosspartisan",
// Reshala
RESHALA = "bossbully",
FOLLOWERRESHALA = "followerbully",
// Gluhar
GLUHAR = "bossgluhar",
FOLLOWERGLUHARASSAULT = "followergluharassault",
FOLLOWERGLUHARSCOUT = "followergluharscout",
FOLLOWERGLUHARSECURITY = "followergluharsecurity",
FOLLOWERGLUHARSNIPER = "followergluharsnipe",
// Goons
KNIGHT = "bossknight",
FOLLOWERBIGPIPE = "followerbigpipe",
FOLLOWERBIRDEYE = "followerbirdeye",
// Shturman
SHTURMAN = "bosskojaniy",
FOLLOWERSHTURMAN = "followerkojaniy",
// Sanitar
SANITAR = "bosssanitar",
FOLLOWERSANITAR = "followersanitar",
// Tagilla
TAGILLA = "bosstagilla",
FOLLOWERTAGILLA = "followertagilla",
// Zryachiy
ZRYACHIY = "bosszryachiy",
FOLLOWERZRYACHIY = "followerzryachiy",
PEACEFULZRYACHIYEVENT = "peacefulzryachiyevent",
RAVANGEZRYACHIYEVENT = "ravengezryachiyevent",
// Traders
// Peacemaker
PEACEMAKER = "peacemaker",
// Skier
SKIER = "skier",
}
export enum inventorySlots
{
FirstPrimaryWeapon = "55d729c64bdc2d89028b4570",
SecondPrimaryWeapon = "55d729d14bdc2d86028b456e",
Holster = "55d729d84bdc2de3098b456b",
Scabbard = "55d729e34bdc2d1b198b456d",
FaceCover = "55d729e84bdc2d8a028b4569",
Headwear = "55d729ef4bdc2d3a168b456c",
TacticalVest = "55d729f74bdc2d87028b456e",
SecuredContainer = "55d72a054bdc2d88028b456e",
Backpack = "55d72a104bdc2d89028b4571",
ArmorVest = "55d72a194bdc2d86028b456f",
Pockets = "55d72a274bdc2de3098b456c",
Earpiece = "5665b7164bdc2d144c8b4570",
Dogtag = "59f0be1e86f77453be490939",
Eyewear = "5a0ad9313f1241000e072755",
ArmBand = "5b3f583786f77411d552fb2b"
}
export enum Stashes
{
LEVEL1 = "566abbc34bdc2d92178b4576",
LEVEL2 = "5811ce572459770cba1a34ea",
LEVEL3 = "5811ce662459770f6f490f32",
LEVEL4 = "5811ce772459770e9e5f9532"
}
export interface QuestZone
{
zoneId: string;
zoneName: string;
zoneType: string;
flareType?: string;
zoneLocation: string;
position: {
x: string;
y: string;
z: string;
};
rotation: {
x: string;
y: string;
z: string;
};
scale: {
x: string;
y: string;
z: string;
};
}
mods/SVD/user/mods/WTTArmorySVD/src/references/itemBaseClasses.ts
+79
View File
@@ -0,0 +1,79 @@
export const ItemBaseClassMap: { [itemName: string]: string } = {
"AMMO": "5485a8684bdc2da71d8b4567",
"AMMO_CONTAINER": "543be5cb4bdc2deb348b4568",
"ARMORED_EQUIPMENT": "57bef4c42459772e8d35a53b",
"ARMBAND": "5b3f15d486f77432d0509248",
"ARMOR": "5448e54d4bdc2dcc718b4568",
"ARMORPLATE": "644120aa86ffbe10ee032b6f",
"ASSAULT_CARBINE": "5447b5fc4bdc2d87278b4567",
"ASSAULT_RIFLE": "5447b5f14bdc2d61278b4567",
"ASSAULT_SCOPE": "55818add4bdc2d5b648b456f",
"BACKPACK": "5448e53e4bdc2d60728b4567",
"BARREL": "555ef6e44bdc2de9068b457e",
"BATTERY": "57864ee62459775490116fc1",
"BIPOD": "55818afb4bdc2dde698b456d",
"BUILDING_MATERIAL": "57864ada245977548638de91",
"CHARGING_HANDLE": "55818a6f4bdc2db9688b456b",
"CHEST_RIG": "5448e5284bdc2dcb718b4567",
"COMMON_CONTAINER": "5795f317245977243854e041",
"COMPACT_REFLEX_SIGHT": "55818acf4bdc2dde698b456b",
"COMPASS": "5f4fbaaca5573a5ac31db429",
"DRINK": "5448e8d64bdc2dce718b4568",
"DRUG": "5448f3a14bdc2d27728b4569",
"ELECTRONICS": "57864a66245977548f04a81f",
"FACECOVER": "5a341c4686f77469e155819e",
"FLASHLIGHT": "55818b084bdc2d5b648b4571",
"FLASHHIDER": "550aa4bf4bdc2dd6348b456b",
"FOOD": "5448e8d04bdc2ddf718b4569",
"FOREGRIP": "55818af64bdc2d5b648b4570",
"FUEL": "5d650c3e815116009f6201d2",
"GAS_BLOCK": "56ea9461d2720b67698b456f",
"GRENADE_LAUNCHER": "5447bedf4bdc2d87278b4568",
"HANDGUN": "5447b5cf4bdc2d65278b4567",
"HANDGUARD": "55818a104bdc2db9688b4569",
"HEADPHONES": "5645bcb74bdc2ded0b8b4578",
"HEADWEAR": "5a341c4086f77401f2541505",
"INFO": "5448ecbe4bdc2d60728b4568",
"INVENTORY": "55d720f24bdc2d88028b456d",
"IRON_SIGHT": "55818ac54bdc2d5b648b456e",
"KEYCARD": "5c164d2286f774194c5e69fa",
"KEYMECHANICAL": "5c99f98d86f7745c314214b3",
"KEY_CARD": "5c164d2286f774194c5e69fa",
"KNIFE": "5447e1d04bdc2dff2f8b4567",
"LOCKING_CONTAINER": "5671435f4bdc2d96058b4569",
"LOOT_CONTAINER": "566965d44bdc2d814c8b4571",
"LUBRICANT": "57864e4c24597754843f8723",
"MACHINEGUN": "5447bed64bdc2d97278b4568",
"MAGAZINE": "5448bc234bdc2d3c308b4569",
"MAP": "567849dd4bdc2d150f8b456e",
"MARKSMAN_RIFLE": "5447b6194bdc2d67278b4567",
"MEDICAL_ITEM": "5448f3ac4bdc2dce718b4569",
"MEDICAL_SUPPLIES": "57864c8c245977548867e7f1",
"MEDITKIT": "5448f39d4bdc2d0a728b4568",
"MONEY": "543be5dd4bdc2deb348b4569",
"MUZZLECOMBO": "550aa4dd4bdc2dc9348b4569",
"MOUNT": "55818b224bdc2dde698b456f",
"NIGHTVISION": "5a2c3a9486f774688b05e574",
"OTHER": "590c745b86f7743cc433c5f2",
"PISTOLGRIP": "55818a684bdc2ddd698b456d",
"POCKETS": "557596e64bdc2dc2118b4571",
"PORTABLE_RANGEFINDER": "61605ddea09d851a0a0c1bbc",
"RANDOMLOOTCONTAINER": "62f109593b54472778797866",
"RECEIVER": "55818a304bdc2db5418b457d",
"REFLEX_SIGHT": "55818ad54bdc2ddc698b4569",
"REPAIRKITS": "616eb7aea207f41933308f46",
"SCOPE": "55818ae44bdc2dde698b456c",
"SHOTGUN": "5447b6094bdc2dc3278b4567",
"SILENCER": "550aa4cd4bdc2dd8348b456c",
"SNIPER_RIFLE": "5447b6254bdc2dc3278b4568",
"SPECIAL_ITEM": "5447e0e74bdc2d3c308b4567",
"STASH": "566abbb64bdc2d144c8b457d",
"STATIONARY_CONT.": "567583764bdc2d98058b456e",
"STIMULANT": "5448f3a64bdc2d60728b456a",
"STOCK": "55818a594bdc2db9688b456a",
"THROWABLE_WEAPON": "543be6564bdc2df4348b4568",
"THERMALVISION": "5d21f59b6dbe99052b54ef83",
"TOOL": "57864bb7245977548b3b66c2",
"UBGL": "55818b014bdc2ddc698b456b",
"VIS_OBSERV_DEVICE": "5448e5724bdc2ddf718b4568",
};
mods/SVD/user/mods/WTTArmorySVD/src/references/itemHandbookCategories.ts
+81
View File
@@ -0,0 +1,81 @@
export const ItemHandbookCategoryMap: { [itemName: string]: string } = {
"AMMO": "5b47574386f77428ca22b346",
"AMMO_BOXES": "5b47574386f77428ca22b33c",
"AMMO_ROUNDS": "5b47574386f77428ca22b33b",
"BARTER": "5b47574386f77428ca22b33e",
"BARTER_BUILDING": "5b47574386f77428ca22b2ee",
"BARTER_ELECTRONICS": "5b47574386f77428ca22b2ef",
"BARTER_ENERGY": "5b47574386f77428ca22b2ed",
"BARTER_FLAMMABLE": "5b47574386f77428ca22b2f2",
"BARTER_HOUSEHOLD": "5b47574386f77428ca22b2f0",
"BARTER_MEDICAL": "5b47574386f77428ca22b2f3",
"BARTER_OTHERS": "5b47574386f77428ca22b2f4",
"BARTER_TOOLS": "5b47574386f77428ca22b2f6",
"BARTER_VALUABLES": "5b47574386f77428ca22b2f1",
"GEAR": "5b47574386f77428ca22b33f",
"GEAR_ARMOR": "5b5f701386f774093f2ecf0f",
"GEAR_BACKPACKS": "5b5f6f6c86f774093f2ecf0b",
"GEAR_CASES": "5b5f6fa186f77409407a7eb7",
"GEAR_COMPONENTS": "5b5f704686f77447ec5d76d7",
"GEAR_FACECOVERS": "5b47574386f77428ca22b32f",
"GEAR_HEADSETS": "5b5f6f3c86f774094242ef87",
"GEAR_HEADWEAR": "5b47574386f77428ca22b330",
"GEAR_RIGS": "5b5f6f8786f77447ed563642",
"GEAR_SECURED": "5b5f6fd286f774093f2ecf0d",
"GEAR_VISORS": "5b47574386f77428ca22b331",
"INFO": "5b47574386f77428ca22b341",
"KEYS": "5b47574386f77428ca22b342",
"KEYS_ELECTRONIC": "5c518ed586f774119a772aee",
"KEYS_MECHANIC": "5c518ec986f7743b68682ce2",
"MAPS": "5b47574386f77428ca22b343",
"MEDICAL": "5b47574386f77428ca22b344",
"MEDICAL_INJECTORS": "5b47574386f77428ca22b33a",
"MEDICAL_INJURY": "5b47574386f77428ca22b339",
"MEDICAL_MEDKITS": "5b47574386f77428ca22b338",
"MEDICAL_PILLS": "5b47574386f77428ca22b337",
"MODS": "5b5f71a686f77447ed5636ab",
"MODS_FUNCTIONAL": "5b5f71b386f774093f2ecf11",
"MODS_GEAR": "5b5f750686f774093e6cb503",
"MODS_VITAL": "5b5f75b986f77447ec5d7710",
"MOD_ASSAULT_SCOPE": "5b5f740a86f77447ec5d7706",
"MOD_AUX": "5b5f74cc86f77447ec5d770a",
"MOD_BARREL": "5b5f75c686f774094242f19f",
"MOD_BIPOD": "5b5f71c186f77409407a7ec0",
"MOD_CHARGE": "5b5f751486f77447ec5d770c",
"MOD_FLASHHIDER": "5b5f724c86f774093f2ecf15",
"MOD_FOREGRIP": "5b5f71de86f774093f2ecf13",
"MOD_GASBLOCK": "5b5f760586f774093e6cb509",
"MOD_HANDGUARD": "5b5f75e486f77447ec5d7712",
"MOD_IRON_SIGHT": "5b5f746686f77447ec5d7708",
"MOD_LAUNCHER": "5b5f752e86f774093e6cb505",
"MOD_LIGHTLASER": "5b5f736886f774094242f193",
"MOD_MAGAZINE": "5b5f754a86f774094242f19b",
"MOD_MOUNT": "5b5f755f86f77447ec5d770e",
"MOD_MICRO_DOT": "5b5f744786f774094242f197",
"MOD_MUZZLE": "5b5f724186f77447ed5636ad",
"MOD_OPTIC": "5b5f748386f774093e6cb501",
"MOD_PISTOLGRIP": "5b5f761f86f774094242f1a1",
"MOD_RECEIVER": "5b5f764186f77447ec5d7714",
"MOD_SIGHT": "5b5f73ec86f774093e6cb4fd",
"MOD_STOCK": "5b5f757486f774093e6cb507",
"MOD_SUPPRESSOR": "5b5f731a86f774093e6cb4f9",
"MONEY": "5b5f78b786f77447ed5636af",
"PROVISIONS": "5b47574386f77428ca22b340",
"PROVISIONS_DRINKS": "5b47574386f77428ca22b335",
"PROVISIONS_FOOD": "5b47574386f77428ca22b336",
"QUEST": "5b619f1a86f77450a702a6f3",
"SPEC": "5b47574386f77428ca22b345",
"WEAPONS": "5b5f78dc86f77409407a7f8e",
"WEAPONS_ASSAULTRIFLES": "5b5f78fc86f77409407a7f90",
"WEAPONS_BOLTACTION": "5b5f798886f77447ed5636b5",
"WEAPONS_CARBINES": "5b5f78e986f77447ed5636b1",
"WEAPONS_DMR": "5b5f791486f774093f2ed3be",
"WEAPONS_GL": "5b5f79d186f774093f2ed3c2",
"WEAPONS_MG": "5b5f79a486f77409407a7f94",
"WEAPONS_MELEE": "5b5f7a0886f77409407a7f96",
"WEAPONS_PISTOLS": "5b5f792486f77447ed5636b3",
"WEAPONS_SHOTGUNS": "5b5f794b86f77409407a7f92",
"WEAPONS_SMG": "5b5f796a86f774093f2ed3c0",
"WEAPONS_SPECIAL": "5b5f79eb86f77447ed5636b7",
"WEAPONS_THROW": "5b5f7a2386f774093f2ed3c4",
};
mods/SVD/user/mods/WTTArmorySVD/src/references/items.ts
+3695
View File
File diff suppressed because it is too large Load Diff