update description.txt

translator: cheungfatzong
https://steamcommunity.com/profiles/76561199126205919

.editorconfig

@@ -0,0 +1,33 @@
+root = true
+
+# Global
+[*]
+indent_style = unset
+indent_size = 4
+tab_width = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = unset
+
+# Unreal Engine 3 / Source
+[*.uc]
+indent_style = tab
+
+[*.{uci,upkg}]
+
+# Unreal Engine 3 / i18n
+[*.{chn,cht,cze,dan,deu,dut,esl,esn,fra,frc,hun,int,ita,jpn,kor,pol,por,ptb,rus,tur,ukr}]
+charset = utf-16le
+
+# Other
+[*.md]
+indent_style = space
+trim_trailing_whitespace = false
+
+[*.yml]
+indent_style = space
+indent_size = 2
+
+[*.{txt,cfg,conf}]
+indent_style = tab

.github/workflows/mega-linter.yml

@@ -0,0 +1,114 @@
+---
+name: MegaLinter
+
+permissions: read-all
+
+on:
+  push:
+  pull_request:
+    branches:
+      - master
+
+env:
+  APPLY_FIXES: none
+  APPLY_FIXES_EVENT: pull_request
+  APPLY_FIXES_MODE: commit
+  FILTER_REGEX_EXCLUDE: (mega-linter.yml)
+  DISABLE: SPELL
+
+concurrency:
+  group: ${{ github.ref }}-${{ github.workflow }}
+  cancel-in-progress: true
+
+jobs:
+  megalinter:
+    name: MegaLinter
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11
+        with:
+          token: ${{ secrets.PAT || secrets.GITHUB_TOKEN }}
+          fetch-depth: 0
+
+      - name: MegaLinter
+        uses: oxsecurity/megalinter@7e042c726c68415475b05a65a686c612120a1232
+        id: ml
+        env:
+          VALIDATE_ALL_CODEBASE: true
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Archive production artifacts
+        uses: actions/upload-artifact@c7d193f32edcb7bfad88892161225aeda64e9392
+        if: success() || failure()
+        with:
+          name: MegaLinter reports
+          path: |
+            megalinter-reports
+            mega-linter.log
+
+      - name: Set APPLY_FIXES_IF var
+        run: |
+          printf 'APPLY_FIXES_IF=%s\n' "${{
+            steps.ml.outputs.has_updated_sources == 1 &&
+            (
+              env.APPLY_FIXES_EVENT == 'all' ||
+              env.APPLY_FIXES_EVENT == github.event_name
+            ) &&
+            (
+              github.event_name == 'push' ||
+              github.event.pull_request.head.repo.full_name == github.repository
+            )
+          }}" >> "${GITHUB_ENV}"
+
+      - name: Set APPLY_FIXES_IF_* vars
+        run: |
+          printf 'APPLY_FIXES_IF_PR=%s\n' "${{
+            env.APPLY_FIXES_IF == 'true' &&
+            env.APPLY_FIXES_MODE == 'pull_request'
+          }}" >> "${GITHUB_ENV}"
+          printf 'APPLY_FIXES_IF_COMMIT=%s\n' "${{
+            env.APPLY_FIXES_IF == 'true' &&
+            env.APPLY_FIXES_MODE == 'commit' &&
+            (!contains(fromJSON('["refs/heads/main", "refs/heads/master"]'), github.ref))
+          }}" >> "${GITHUB_ENV}"
+
+      - name: Create Pull Request with applied fixes
+        uses: peter-evans/create-pull-request@153407881ec5c347639a548ade7d8ad1d6740e38
+        id: cpr
+        if: env.APPLY_FIXES_IF_PR == 'true'
+        with:
+          token: ${{ secrets.PAT || secrets.GITHUB_TOKEN }}
+          commit-message: "[MegaLinter] Apply linters automatic fixes"
+          title: "[MegaLinter] Apply linters automatic fixes"
+          labels: bot
+
+      - name: Create PR output
+        if: env.APPLY_FIXES_IF_PR == 'true'
+        run: |
+          echo "PR Number - ${{ steps.cpr.outputs.pull-request-number }}"
+          echo "PR URL - ${{ steps.cpr.outputs.pull-request-url }}"
+
+      - name: Prepare commit
+        if: env.APPLY_FIXES_IF_COMMIT == 'true'
+        run: sudo chown -Rc $UID .git/
+
+      - name: Commit and push applied linter fixes
+        uses: stefanzweifel/git-auto-commit-action@8756aa072ef5b4a080af5dc8fef36c5d586e521d
+        if: env.APPLY_FIXES_IF_COMMIT == 'true'
+        with:
+          branch: >-
+            ${{
+              github.event.pull_request.head.ref ||
+              github.head_ref ||
+              github.ref
+            }}
+          commit_message: "[MegaLinter] Apply linters fixes"
+          commit_user_name: "github-actions"
+          commit_user_email: "github-actions[bot]@users.noreply.github.com"

.gitignore

@@ -0,0 +1,2 @@
+*.psd
+/ignore

CTI/Classes/AddItems.uc

@@ -29,23 +29,36 @@ private static function ApplyDefault()
 public static function Array<class<KFWeaponDefinition> > Load(E_LogLevel LogLevel)
 {
 	local Array<class<KFWeaponDefinition> > ItemList;
-	local class<KFWeaponDefinition> ItemClass;
+	local class<KFWeaponDefinition> ItemWeapDef;
+	local class<KFWeapon> ItemWeapon;
 	local String ItemRaw;
 	local int    Line;
 
 	`Log_Info("Load Items to add:");
 	foreach default.Item(ItemRaw, Line)
 	{
-		ItemClass = class<KFWeaponDefinition>(DynamicLoadObject(ItemRaw, class'Class'));
-		if (ItemClass == None)
+		ItemWeapDef = class<KFWeaponDefinition>(DynamicLoadObject(ItemRaw, class'Class'));
+		if (ItemWeapDef == None)
 		{
-			`Log_Warn("[" $ Line + 1 $ "]" @ "Can't load Item class:" @ ItemRaw);
+			`Log_Warn("[" $ Line + 1 $ "]" @ "Can't load weapon definition:" @ ItemRaw);
+			continue;
 		}
-		else
+
+		ItemWeapon = class<KFWeapon>(DynamicLoadObject(ItemWeapDef.default.WeaponClassPath, class'Class'));
+		if (ItemWeapon == None)
 		{
-			ItemList.AddItem(ItemClass);
-			`Log_Debug("[" $ Line + 1 $ "]" @ "Loaded successfully:" @ ItemRaw);
+			`Log_Warn("[" $ Line + 1 $ "]" @ "Can't load weapon:" @ ItemWeapDef.default.WeaponClassPath);
+			continue;
 		}
+
+		if (ItemList.Find(ItemWeapDef) != INDEX_NONE)
+		{
+			`Log_Warn("[" $ Line + 1 $ "]" @ "Duplicate item:" @ ItemRaw @ "(skip)");
+			continue;
+		}
+
+		ItemList.AddItem(ItemWeapDef);
+		`Log_Debug("[" $ Line + 1 $ "]" @ "Loaded successfully:" @ ItemRaw);
 	}
 
 	if (ItemList.Length == default.Item.Length)

CTI/Classes/CTI.uc

@@ -1,20 +1,34 @@
 class CTI extends Info
 	config(CTI);
 
-const LatestVersion = 1;
+const LatestVersion = 5;
 
-const CfgRemoveItems = class'RemoveItems';
-const CfgAddItems    = class'AddItems';
-const Helper         = class'Helper';
+const CfgRemoveItems     = class'RemoveItems';
+const CfgAddItems        = class'AddItems';
+const CfgOfficialWeapons = class'OfficialWeapons';
+const Trader             = class'Trader';
+const Unlocker           = class'Unlocker';
+
+struct S_PreloadContent
+{
+	var class<KFWeaponDefinition> KFWD;
+	var class<KFWeapon>           KFWC;
+	var KFWeapon                  KFW;
+	var KFW_Access                KFWA;
+};
 
 var private config int        Version;
 var private config E_LogLevel LogLevel;
-var private config bool       UnlockDLC;
+var private config String     UnlockDLC;
 var private config bool       bPreloadContent;
+var private config bool       bOfficialWeaponsList;
+var private config bool       bDisableItemLimitCheck;
+var private config bool       bApplyPatch;
 
-var private KFGameInfo KFGI;
+var private KFGameInfo            KFGI;
 var private KFGameReplicationInfo KFGRI;
 
+var private Array<class<KFWeaponDefinition> > WeapDefs;
 var private Array<class<KFWeaponDefinition> > RemoveItems;
 var private Array<class<KFWeaponDefinition> > AddItems;
 
@@ -22,16 +36,29 @@ var private Array<CTI_RepInfo> RepInfos;
 
 var private bool ReadyToSync;
 
+// To bypass "Booleans may not be out parameters" error
+struct BoolWrapper
+{
+	var bool Value;
+
+	structdefaultproperties
+	{
+		Value = false
+	}
+};
+
+var private BoolWrapper DLCSkinUpdateRequired;
+
 public simulated function bool SafeDestroy()
 {
-	`Log_Trace(`Location);
+	`Log_Trace();
 
 	return (bPendingDelete || bDeleteMe || Destroy());
 }
 
 public event PreBeginPlay()
 {
-	`Log_Trace(`Location);
+	`Log_Trace();
 
 	`Log_Debug("PreBeginPlay readyToSync" @ ReadyToSync);
 
@@ -49,7 +76,7 @@ public event PreBeginPlay()
 
 public event PostBeginPlay()
 {
-	`Log_Trace(`Location);
+	`Log_Trace();
 
 	if (bPendingDelete || bDeleteMe) return;
 
@@ -60,13 +87,13 @@ public event PostBeginPlay()
 
 private function PreInit()
 {
-	`Log_Trace(`Location);
+	`Log_Trace();
 
 	if (Version == `NO_CONFIG)
 	{
 		LogLevel = LL_Info;
 		bPreloadContent = true;
-		UnlockDLC = false;
+		UnlockDLC = "False";
 		SaveConfig();
 	}
 
@@ -78,8 +105,18 @@ private function PreInit()
 		case `NO_CONFIG:
 			`Log_Info("Config created");
 
+		case 1:
+			bOfficialWeaponsList = false;
+
+		case 2:
+		case 3:
+			bDisableItemLimitCheck = false;
+
+		case 4:
+			bApplyPatch = false;
+
 		case MaxInt:
-			`Log_Info("Config updated to version"@LatestVersion);
+			`Log_Info("Config updated to version" @ LatestVersion);
 			break;
 
 		case LatestVersion:
@@ -93,6 +130,8 @@ private function PreInit()
 			break;
 	}
 
+	CfgOfficialWeapons.static.Update(bOfficialWeaponsList);
+
 	if (LatestVersion != Version)
 	{
 		Version = LatestVersion;
@@ -107,15 +146,22 @@ private function PreInit()
 	}
 	`Log_Base("LogLevel:" @ LogLevel);
 
+	if (!Unlocker.static.IsValidTypeUnlockDLC(UnlockDLC, LogLevel))
+	{
+		`Log_Warn("Wrong 'UnlockDLC' value (" $ UnlockDLC $ "), return to default value (False)");
+		UnlockDLC = "False";
+		SaveConfig();
+	}
+
 	RemoveItems = CfgRemoveItems.static.Load(LogLevel);
 	AddItems    = CfgAddItems.static.Load(LogLevel);
 }
 
 private function PostInit()
 {
-	local CTI_RepInfo RepLink;
+	local CTI_RepInfo RepInfo;
 
-	`Log_Trace(`Location);
+	`Log_Trace();
 
 	if (WorldInfo == None || WorldInfo.Game == None)
 	{
@@ -131,42 +177,6 @@ private function PostInit()
 		return;
 	}
 
-	// TODO:
-	// replace shopContainer (KFGFxTraderContainer_Store)
-	// without replacing KFGFxMoviePlayer_Manager
-	// but how? 🤔
-	if (UnlockDLC)
-	{
-		if (KFGameInfo_VersusSurvival(KFGI) != None)
-		{
-			if (KFGI.KFGFxManagerClass != class'CTI_GFxMoviePlayer_Manager_Versus')
-			{
-				if (KFGI.KFGFxManagerClass != class'KFGameInfo_VersusSurvival'.default.KFGFxManagerClass)
-				{
-					`Log_Warn("Found custom 'KFGFxManagerClass' (" $ KFGI.KFGFxManagerClass $ "), there may be compatibility issues");
-					`Log_Warn("If you notice problems, try disabling DLC unlock");
-				}
-				
-				KFGI.KFGFxManagerClass = class'CTI_GFxMoviePlayer_Manager_Versus';
-				`Log_Info("DLC unlocked");
-			}
-		}
-		else
-		{
-			if (KFGI.KFGFxManagerClass != class'CTI_GFxMoviePlayer_Manager')
-			{
-				if (KFGI.KFGFxManagerClass != class'KFGameInfo'.default.KFGFxManagerClass)
-				{
-					`Log_Warn("Found custom 'KFGFxManagerClass' (" $ KFGI.KFGFxManagerClass $ "), there may be compatibility issues");
-					`Log_Warn("If you notice problems, try disabling DLC unlock");
-				}
-				
-				KFGI.KFGFxManagerClass = class'CTI_GFxMoviePlayer_Manager';
-				`Log_Info("DLC unlocked");
-			}
-		}
-	}
-	
 	if (KFGI.GameReplicationInfo == None)
 	{
 		SetTimer(1.0f, false, nameof(PostInit));
@@ -181,86 +191,193 @@ private function PostInit()
 		return;
 	}
 
-	Helper.static.ModifyTrader(KFGRI, RemoveItems, AddItems, CfgRemoveItems.default.bAll);
+	WeapDefs = Trader.static.GenerateWeapDefList(
+		KFGRI,
+		RemoveItems,
+		AddItems,
+		CfgRemoveItems.default.bAll,
+		CfgRemoveItems.default.bHRG,
+		CfgRemoveItems.default.bDLC,
+		bDisableItemLimitCheck,
+		LogLevel);
+
+	RemoveItems.Length = 0;
+	AddItems.Length = 0;
+
+	if (Unlocker.static.UnlockDLC(KFGI, KFGRI, UnlockDLC, WeapDefs, DLCSkinUpdateRequired, LogLevel))
+	{
+		`Log_Info("DLC unlocked");
+	}
+	`Log_Debug("DLCSkinUpdateRequired:" @ String(DLCSkinUpdateRequired.Value));
+
+	if (bApplyPatch)
+	{
+		ServerPatch();
+	}
+
+	Trader.static.OverwriteTraderItems(KFGRI, WeapDefs, bApplyPatch, LogLevel);
+
+	`Log_Info("Trader items:" @ WeapDefs.Length);
 
 	if (bPreloadContent)
 	{
-		Helper.static.PreloadContent(AddItems);
+		Preload(WeapDefs);
 	}
 
 	ReadyToSync = true;
 
-	foreach RepInfos(RepLink)
+	foreach RepInfos(RepInfo)
 	{
-		if (RepLink.PendingSync)
+		if (RepInfo.PendingSync)
 		{
-			RepLink.ServerSync();
+			RepInfo.PrepareSync(Self, LogLevel, KFGI.KFGFxManagerClass, DLCSkinUpdateRequired.Value, bApplyPatch);
+			RepInfo.Replicate(WeapDefs);
 		}
 	}
 }
 
+private function ServerPatch()
+{
+	local class<KFAutoPurchaseHelper> AutoPurchaseHelper;
+	local class<KFInventoryManager> InventoryManager;
+
+	if (KFGI.KFGFxManagerClass.GetPackageName() != 'CTI')
+	{
+		if (Unlocker.static.CustomGFxManager(KFGI))
+		{
+			`Log_Warn("Custom KFGFxMoviePlayer_Manager detected:" @ String(KFGI.KFGFxManagerClass) $ ". There may be compatibility issues.");
+		}
+
+		if (KFGameInfo_VersusSurvival(KFGI) != None)
+		{
+			KFGI.KFGFxManagerClass = class'CTI_GFxMoviePlayer_Manager_Versus';
+		}
+		else
+		{
+			KFGI.KFGFxManagerClass = class'CTI_GFxMoviePlayer_Manager';
+		}
+	}
+
+	if (KFGRI.TraderItems.class != class'KFGFxObject_TraderItems')
+	{
+		`Log_Warn("Custom TraderItems detected:" @ String(KFGRI.TraderItems.class) $ ". There may be compatibility issues.");
+	}
+
+	AutoPurchaseHelper = class<KFPlayerController>(KFGI.PlayerControllerClass).default.PurchaseHelperClass;
+	if (AutoPurchaseHelper != class'KFPlayerController'.default.PurchaseHelperClass)
+	{
+		`Log_Warn("Custom PurchaseHelper detected:" @ String(AutoPurchaseHelper) $ ". There may be compatibility issues.");
+	}
+
+	InventoryManager = class<KFInventoryManager>(KFGI.DefaultPawnClass.default.InventoryManagerClass);
+	if (InventoryManager != class'KFPawn'.default.InventoryManagerClass)
+	{
+		`Log_Warn("Custom InventoryManager detected:" @ String(InventoryManager) $ ". There may be compatibility issues.");
+	}
+}
+
+private function Preload(const out Array<class<KFWeaponDefinition> > Content)
+{
+	local Array<S_PreloadContent> PreloadContent;
+	local S_PreloadContent SPC;
+
+	`Log_Trace();
+
+	foreach Content(SPC.KFWD)
+	{
+		SPC.KFWC = class<KFWeapon> (DynamicLoadObject(SPC.KFWD.default.WeaponClassPath, class'Class'));
+		if (SPC.KFWC != None)
+		{
+			if (SPC.KFWC.GetPackageName() == 'CTI' || SPC.KFWC.GetPackageName() == 'KFGameContent')
+			{
+				`Log_Debug("Skip preload:" @ SPC.KFWD.GetPackageName() $ "." $ SPC.KFWD);
+				continue;
+			}
+
+			SPC.KFW = KFGI.Spawn(SPC.KFWC);
+			if (SPC.KFW == None)
+			{
+				`Log_Warn("Spawn failed:" @ SPC.KFWD.default.WeaponClassPath);
+				continue;
+			}
+
+			SPC.KFWA = new (SPC.KFW) class'KFW_Access';
+			if (SPC.KFWA == None)
+			{
+				`Log_Warn("Spawn failed:" @ SPC.KFWD.default.WeaponClassPath @ "KFW_Access");
+				continue;
+			}
+
+			PreloadContent.AddItem(SPC);
+		}
+	}
+
+	foreach PreloadContent(SPC)
+	{
+		SPC.KFWA.KFW_StartLoadWeaponContent();
+	}
+
+	`Log_Info("Preloaded" @ PreloadContent.Length @ "weapon models");
+}
+
 public function NotifyLogin(Controller C)
 {
-	`Log_Trace(`Location);
+	`Log_Trace();
 
-	CreateRepLink(C);
+	if (!CreateRepInfo(C))
+	{
+		`Log_Error("Can't create RepInfo for:" @ C);
+	}
 }
 
 public function NotifyLogout(Controller C)
 {
-	`Log_Trace(`Location);
+	`Log_Trace();
 
-	DestroyRepLink(C);
+	DestroyRepInfo(C);
 }
 
-public function bool CreateRepLink(Controller C)
+public function bool CreateRepInfo(Controller C)
 {
-	local CTI_RepInfo RepLink;
+	local CTI_RepInfo RepInfo;
 
-	`Log_Trace(`Location);
+	`Log_Trace();
 
-	if (C == None) return false;
+	if (C == None || KFPlayerController(C) == None) return false;
 
-	RepLink = Spawn(class'CTI_RepInfo', C);
+	RepInfo = Spawn(class'CTI_RepInfo', C);
 
-	if (RepLink == None) return false;
+	if (RepInfo == None) return false;
 
-	RepLink.PrepareSync(
-		Self,
-		LogLevel,
-		RemoveItems,
-		AddItems,
-		CfgRemoveItems.default.bAll,
-		bPreloadContent);
-	
-	RepInfos.AddItem(RepLink);
+	RepInfos.AddItem(RepInfo);
 
 	if (ReadyToSync)
 	{
-		RepLink.ServerSync();
+		RepInfo.PrepareSync(Self, LogLevel, KFGI.KFGFxManagerClass, DLCSkinUpdateRequired.Value, bApplyPatch);
+		RepInfo.Replicate(WeapDefs);
 	}
 	else
 	{
-		RepLink.PendingSync = true;
+		RepInfo.PendingSync = true;
 	}
 
 	return true;
 }
 
-public function bool DestroyRepLink(Controller C)
+public function bool DestroyRepInfo(Controller C)
 {
-	local CTI_RepInfo RepLink;
+	local CTI_RepInfo RepInfo;
 
-	`Log_Trace(`Location);
+	`Log_Trace();
 
 	if (C == None) return false;
 
-	foreach RepInfos(RepLink)
+	foreach RepInfos(RepInfo)
 	{
-		if (RepLink.Owner == C)
+		if (RepInfo.Owner == C)
 		{
-			RepLink.SafeDestroy();
-			RepInfos.RemoveItem(RepLink);
+			RepInfos.RemoveItem(RepInfo);
+			RepInfo.SafeDestroy();
 			return true;
 		}
 	}

CTI/Classes/CTIMut.uc

@@ -1,62 +1 @@
-class CTIMut extends KFMutator;
-	
-var private CTI CTI;
-
-public simulated function bool SafeDestroy()
-{
-	return (bPendingDelete || bDeleteMe || Destroy());
-}
-
-public event PreBeginPlay()
-{
-	Super.PreBeginPlay();
-	
-	if (WorldInfo.NetMode == NM_Client) return;
-	
-	foreach WorldInfo.DynamicActors(class'CTI', CTI)
-	{
-		`Log_Base("Found 'CTI'");
-		break;
-	}
-	
-	if (CTI == None)
-	{
-		`Log_Base("Spawn 'CTI'");
-		CTI = WorldInfo.Spawn(class'CTI');
-	}
-	
-	if (CTI == None)
-	{
-		`Log_Base("Can't Spawn 'CTI', Destroy...");
-		SafeDestroy();
-	}
-}
-
-public function AddMutator(Mutator Mut)
-{
-	if (Mut == Self) return;
-	
-	if (Mut.Class == Class)
-		Mut.Destroy();
-	else
-		Super.AddMutator(Mut);
-}
-
-public function NotifyLogin(Controller C)
-{
-	Super.NotifyLogin(C);
-	
-	CTI.NotifyLogin(C);
-}
-
-public function NotifyLogout(Controller C)
-{
-	Super.NotifyLogout(C);
-	
-	CTI.NotifyLogout(C);
-}
-
-DefaultProperties
-{
-
-}
+class CTIMut extends Mut; // backward compatibility

CTI/Classes/CTI_AutoPurchaseHelper.uc

@@ -0,0 +1,289 @@
+class CTI_AutoPurchaseHelper extends KFAutoPurchaseHelper;
+
+var private CTI_GFxObject_TraderItems CTI_TraderItems;
+var private CTI_InventoryManager CTI_IM;
+
+private function CTI_GFxObject_TraderItems GetCTI_TraderItems()
+{
+	if (CTI_TraderItems == None)
+	{
+		if (TraderItems == None)
+		{
+			GetTraderItems();
+		}
+
+		if (TraderItems != None)
+		{
+			CTI_TraderItems = CTI_GFxObject_TraderItems(TraderItems);
+		}
+	}
+
+	return CTI_TraderItems;
+}
+
+private function CTI_InventoryManager GetCTI_IM()
+{
+	if (CTI_IM != Pawn.InvManager)
+	{
+		`Log_Base("Update InvManager:" @ String(CTI_IM) @ "<-" @ String(Pawn.InvManager));
+		CTI_IM = CTI_InventoryManager(Pawn.InvManager);
+	}
+
+	return CTI_IM;
+}
+
+public function Initialize(optional bool bInitializeOwned = true)
+{
+	Super.Initialize(bInitializeOwned);
+	GetCTI_IM();
+	GetCTI_TraderItems();
+}
+
+public function bool UpgradeWeapon(int OwnedItemIndex)
+{
+	local int ItemIndex;
+	local STraderItem DefaultItemInfo;
+	local SItemInformation ItemInfo;
+	local int Test1, Test2;
+
+	ItemInfo = OwnedItemList[OwnedItemIndex];
+	DefaultItemInfo = ItemInfo.DefaultItem;
+
+	if (ItemInfo.bIsSecondaryAmmo || !CanUpgrade(DefaultItemInfo, Test1, Test2, true))
+	{
+		return false;
+	}
+
+	if (GetCTI_IM() == None) return false;
+
+	CTI_GetItemIndicesFromArche(ItemIndex, DefaultItemInfo.ClassName);
+	CTI_IM.CTI_BuyUpgrade(ItemIndex, ItemInfo.ItemUpgradeLevel);
+	OwnedItemList[OwnedItemIndex].SellPrice = GetAdjustedSellPriceFor(DefaultItemInfo);
+
+	if (MyGfxManager != None && MyGfxManager.TraderMenu != None)
+	{
+		MyGfxManager.TraderMenu.OwnedItemList = OwnedItemList;
+	}
+
+	return true;
+}
+
+public function BoughtAmmo(float AmountPurchased, int Price, EItemType ItemType, optional name ClassName, optional bool bIsSecondaryAmmo)
+{
+	local int ItemIndex;
+	AddDosh(-Price);
+
+	if (ItemType == EIT_Weapon)
+	{
+		CTI_GetItemIndicesFromArche(ItemIndex, ClassName);
+	}
+
+	if (GetCTI_IM() == None) return;
+
+	CTI_IM.CTI_BuyAmmo(AmountPurchased, ItemType, ItemIndex, bIsSecondaryAmmo);
+}
+
+private function float AmmoCostScale()
+{
+	local KFGameReplicationInfo KFGRI;
+	KFGRI = KFGameReplicationInfo(WorldInfo.GRI);
+	return KFGRI == None? 1.0f : KFGRI.GameAmmoCostScale;
+}
+
+public function int AddWeaponToOwnedItemList(STraderItem DefaultItem, optional bool bDoNotBuy, optional int OverrideItemUpgradeLevel = INDEX_NONE)
+{
+	local SItemInformation WeaponInfo;
+	local int ItemIndex, AddedWeaponIndex, OwnedSingleIdx, SingleDualAmmoDiff;
+	local bool bAddingDual;
+
+	WeaponInfo.MagazineCapacity = DefaultItem.MagazineCapacity;
+	CurrentPerk.ModifyMagSizeAndNumber(None, WeaponInfo.MagazineCapacity, DefaultItem.AssociatedPerkClasses,, DefaultItem.ClassName);
+
+	WeaponInfo.MaxSpareAmmo = DefaultItem.MaxSpareAmmo;
+	CurrentPerk.ModifyMaxSpareAmmoAmount(none, WeaponInfo.MaxSpareAmmo, DefaultItem);
+	WeaponInfo.MaxSpareAmmo += WeaponInfo.MagazineCapacity;
+
+	WeaponInfo.SpareAmmoCount = DefaultItem.InitialSpareMags * DefaultItem.MagazineCapacity;
+	CurrentPerk.ModifySpareAmmoAmount(none, WeaponInfo.SpareAmmoCount, DefaultItem);
+	WeaponInfo.SpareAmmoCount += WeaponInfo.MagazineCapacity;
+
+	bAddingDual = DefaultItem.SingleClassName != '';
+	if (bAddingDual)
+	{
+		for (OwnedSingleIdx = 0; OwnedSingleIdx < OwnedItemList.Length; ++OwnedSingleIdx)
+		{
+			if (OwnedItemList[OwnedSingleIdx].DefaultItem.ClassName != DefaultItem.SingleClassName) continue;
+
+			SingleDualAmmoDiff = OwnedItemList[OwnedSingleIdx].SpareAmmoCount - WeaponInfo.SpareAmmoCount;
+			SingleDualAmmoDiff = Max(0, SingleDualAmmoDiff);
+
+			if (WeaponInfo.SpareAmmoCount > OwnedItemList[OwnedSingleIdx].SpareAmmoCount)
+			{
+				OwnedItemList[OwnedSingleIdx].SpareAmmoCount = WeaponInfo.SpareAmmoCount;
+			}
+			else
+			{
+				WeaponInfo.SpareAmmoCount = Min(OwnedItemList[OwnedSingleIdx].SpareAmmoCount, WeaponInfo.MaxSpareAmmo);
+			}
+
+			WeaponInfo.ItemUpgradeLevel = OwnedItemList[OwnedSingleIdx].ItemUpgradeLevel;
+			break;
+		}
+	}
+
+	CurrentPerk.MaximizeSpareAmmoAmount(DefaultItem.AssociatedPerkClasses, WeaponInfo.SpareAmmoCount, DefaultItem.MaxSpareAmmo + DefaultItem.MagazineCapacity);
+
+	WeaponInfo.SecondaryAmmoCount = DefaultItem.InitialSecondaryAmmo;
+	CurrentPerk.ModifyMagSizeAndNumber(None, WeaponInfo.MagazineCapacity, DefaultItem.AssociatedPerkClasses, true, DefaultItem.ClassName);
+	CurrentPerk.ModifySpareAmmoAmount(None, WeaponInfo.SecondaryAmmoCount, DefaultItem, true);
+
+	WeaponInfo.MaxSecondaryAmmo = DefaultItem.MaxSecondaryAmmo;
+	CurrentPerk.ModifyMaxSpareAmmoAmount(None, WeaponInfo.MaxSecondaryAmmo, DefaultItem, true);
+
+	WeaponInfo.AmmoPricePerMagazine = AmmoCostScale() * DefaultItem.WeaponDef.default.AmmoPricePerMag;
+	WeaponInfo.SellPrice = GetAdjustedSellPriceFor(DefaultItem);
+
+	WeaponInfo.DefaultItem = DefaultItem;
+
+	if (OverrideItemUpgradeLevel > INDEX_NONE)
+	{
+		WeaponInfo.ItemUpgradeLevel = OverrideItemUpgradeLevel;
+	}
+
+	AddedWeaponIndex = AddItemByPriority(WeaponInfo);
+
+	if (GetCTI_IM() == None) return AddedWeaponIndex;
+
+	CTI_GetItemIndicesFromArche(ItemIndex, DefaultItem.ClassName);
+
+	if (!bDoNotBuy)
+	{
+		CTI_IM.CTI_ServerBuyWeapon(ItemIndex, WeaponInfo.ItemUpgradeLevel);
+	}
+	else
+	{
+		CTI_IM.CTI_ServerAddTransactionItem(ItemIndex, WeaponInfo.ItemUpgradeLevel);
+		AddBlocks(CTI_IM.GetWeaponBlocks(DefaultItem, WeaponInfo.ItemUpgradeLevel));
+	}
+
+	if (bAddingDual)
+	{
+		CTI_AddTransactionAmmo(ItemIndex, SingleDualAmmoDiff, false);
+		RemoveWeaponFromOwnedItemList(, DefaultItem.SingleClassName, true);
+	}
+
+	return AddedWeaponIndex;
+}
+
+public function RemoveWeaponFromOwnedItemList(optional int OwnedListIdx = INDEX_NONE, optional name ClassName, optional bool bDoNotSell)
+{
+	local SItemInformation ItemInfo;
+	local int ItemIndex;
+	local int SingleOwnedIndex;
+
+	if (OwnedListIdx == INDEX_NONE && ClassName != '')
+	{
+		for (OwnedListIdx = 0; OwnedListIdx < OwnedItemList.length; ++OwnedListIdx)
+		{
+			if (OwnedItemList[OwnedListIdx].DefaultItem.ClassName == ClassName) break;
+		}
+	}
+
+	if (OwnedListIdx >= OwnedItemList.length) return;
+
+	ItemInfo = OwnedItemList[OwnedListIdx];
+
+	if (GetCTI_IM() == None) return;
+
+	if (!bDoNotSell)
+	{
+		CTI_GetItemIndicesFromArche(ItemIndex, ItemInfo.DefaultItem.ClassName);
+		CTI_IM.CTI_ServerSellWeapon(ItemIndex);
+	}
+	else
+	{
+		AddBlocks(-CTI_IM.GetDisplayedBlocksRequiredFor(ItemInfo.DefaultItem));
+		CTI_GetItemIndicesFromArche(ItemIndex, ItemInfo.DefaultItem.ClassName);
+		CTI_IM.CTI_ServerRemoveTransactionItem(ItemIndex);
+	}
+
+	if (OwnedItemList[OwnedListIdx].bIsSecondaryAmmo)
+	{
+		OwnedItemList.Remove(OwnedListIdx, 1);
+		if (OwnedListIdx - 1 >= 0)
+		{
+			OwnedItemList.Remove(OwnedListIdx - 1, 1);
+		}
+	}
+	else if (OwnedItemList[OwnedListIdx].DefaultItem.WeaponDef.static.UsesSecondaryAmmo())
+	{
+		if (OwnedListIdx + 1 < OwnedItemList.Length)
+		{
+			OwnedItemList.Remove(OwnedListIdx + 1, 1);
+			OwnedItemList.Remove(OwnedListIdx, 1);
+		}
+	}
+	else
+	{
+		OwnedItemList.Remove(OwnedListIdx, 1);
+	}
+
+	if (ItemInfo.DefaultItem.SingleClassName == 'KFWeap_Pistol_9mm' || ItemInfo.DefaultItem.SingleClassName == 'KFWeap_HRG_93R')
+	{
+		if (CTI_GetItemIndicesFromArche(ItemIndex, ItemInfo.DefaultItem.SingleClassName))
+		{
+			SingleOwnedIndex = AddWeaponToOwnedItemList(CTI_TraderItems.AllItems[ItemIndex], true, ItemInfo.ItemUpgradeLevel);
+
+			CTI_AddTransactionAmmo(ItemIndex, ItemInfo.SpareAmmoCount - (ItemInfo.MaxSpareAmmo / 2.0) + ((ItemInfo.MaxSpareAmmo / 2.0) - OwnedItemList[SingleOwnedIndex].SpareAmmoCount), false);
+			OwnedItemList[SingleOwnedIndex].SpareAmmoCount = ItemInfo.SpareAmmoCount;
+		}
+	}
+
+	if (MyGfxManager != None && MyGfxManager.TraderMenu != None)
+	{
+		MyGfxManager.TraderMenu.OwnedItemList = OwnedItemList;
+	}
+}
+
+public function SetWeaponInformation(KFWeapon KFW)
+{
+	local int i;
+
+	if (GetCTI_TraderItems() == None)
+	{
+		Super.SetWeaponInformation(KFW);
+		return;
+	}
+
+	for (i = 0; i < CTI_TraderItems.AllItems.Length; i++)
+	{
+		if (KFW.Class.name == CTI_TraderItems.AllItems[i].ClassName)
+		{
+			SetWeaponInfo(KFW, CTI_TraderItems.AllItems[i]);
+			return;
+		}
+	}
+}
+
+// native private final function AddTransactionAmmo( byte ItemIndex, int Amount, bool bSecondaryAmmo );
+private function CTI_AddTransactionAmmo(int ItemIndex, int Amount, bool bSecondaryAmmo); // TODO: impl
+
+private function bool CTI_GetItemIndicesFromArche(out int ItemIndex, name WeaponClassName)
+{
+	local int Index;
+
+	if (GetCTI_TraderItems() == None) return false;
+
+	Index = CTI_TraderItems.AllItems.Find('ClassName', WeaponClassName);
+
+	if (Index == INDEX_NONE) return false;
+
+	ItemIndex = Index;
+
+	return true;
+}
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_GFxMenu_Trader.uc

@@ -1,8 +1,217 @@
 class CTI_GFxMenu_Trader extends KFGFxMenu_Trader
 	dependsOn(CTI_GFxTraderContainer_Store);
 
+var private int SelectedItemIndexInt;
+
+private function UpdateByteSelectedIndex()
+{
+	SelectedItemIndex = Clamp(SelectedItemIndexInt, 0, 255);
+}
+
+public function SetTraderItemDetails(int ItemIndex)
+{
+	local STraderItem SelectedItem;
+	local bool bCanAfford, bCanBuyItem, bCanCarry;
+	SelectedList = TL_Shop;
+
+	if (ItemDetails == None || ShopContainer == None) return;
+
+	if (MyKFPC.GetPurchaseHelper().TraderItems.SaleItems.length >= 0 && ItemIndex < MyKFPC.GetPurchaseHelper().TraderItems.SaleItems.length)
+	{
+		SelectedItemIndexInt = ItemIndex;
+		SelectedItem = MyKFPC.GetPurchaseHelper().TraderItems.SaleItems[ItemIndex];
+
+		bCanAfford = MyKFPC.GetPurchaseHelper().GetCanAfford(MyKFPC.GetPurchaseHelper().GetAdjustedBuyPriceFor(SelectedItem));
+		bCanCarry = MyKFPC.GetPurchaseHelper().CanCarry(SelectedItem);
+
+		bCanBuyItem = bCanAfford && bCanCarry;
+
+		PurchaseError(!bCanAfford, !bCanCarry);
+
+		ItemDetails.SetShopItemDetails(SelectedItem, MyKFPC.GetPurchaseHelper().GetAdjustedBuyPriceFor(SelectedItem), bCanCarry, bCanBuyItem);
+		bCanBuyOrSellItem = bCanBuyItem;
+	}
+	else
+	{
+		ItemDetails.SetVisible(false);
+	}
+
+	UpdateByteSelectedIndex();
+}
+
+public function SetPlayerItemDetails(int ItemIndex)
+{
+	local STraderItem SelectedItem;
+
+	SelectedList = TL_Player;
+	if (ItemDetails == None || ItemIndex >= OwnedItemList.length) return;
+
+	bGenericItemSelected = false;
+	SelectedItemIndexInt = ItemIndex;
+	SelectedItem = OwnedItemList[ItemIndex].DefaultItem;
+	ItemDetails.SetPlayerItemDetails(SelectedItem, OwnedItemList[ItemIndex].SellPrice, OwnedItemList[ItemIndex].ItemUpgradeLevel);
+	bCanBuyOrSellItem = MyKFPC.GetPurchaseHelper().IsSellable(SelectedItem);
+	PurchaseError(false, false);
+
+	UpdateByteSelectedIndex();
+}
+
+public function SetNewSelectedIndex(int ListLength)
+{
+	if (SelectedItemIndexInt >= ListLength)
+	{
+		if (SelectedItemIndexInt != 0)
+		{
+			SelectedItemIndexInt--;
+		}
+	}
+
+	UpdateByteSelectedIndex();
+}
+
+public function RefreshItemComponents(optional bool bInitOwnedItems = false)
+{
+	if (PlayerInventoryContainer == None || PlayerInfoContainer == None) return;
+
+	if (bInitOwnedItems)
+	{
+		MyKFPC.GetPurchaseHelper().InitializeOwnedItemList();
+	}
+	OwnedItemList = MyKFPC.GetPurchaseHelper().OwnedItemList;
+	PlayerInventoryContainer.RefreshPlayerInventory();
+	RefreshShopItemList(CurrentTab, CurrentFilterIndex);
+	GameInfoContainer.UpdateGameInfo();
+	GameInfoContainer.SetDosh(MyKFPC.GetPurchaseHelper().TotalDosh);
+	GameInfoContainer.SetCurrentWeight(MyKFPC.GetPurchaseHelper().TotalBlocks, MyKFPC.GetPurchaseHelper().MaxBlocks);
+
+	if (SelectedList == TL_Shop)
+	{
+		SetTraderItemDetails(SelectedItemIndexInt);
+	}
+	else if (bGenericItemSelected)
+	{
+		SetGenericItemDetails(LastDefaultItemInfo, LastItemInfo);
+	}
+	else
+	{
+		SetPlayerItemDetails(SelectedItemIndexInt);
+	}
+}
+
+public function RefreshShopItemList(TabIndices TabIndex, byte FilterIndex)
+{
+	if (ShopContainer == None || FilterContainer == None) return;
+
+	switch (TabIndex)
+	{
+		case (TI_Perks):
+			ShopContainer.RefreshWeaponListByPerk(FilterIndex, MyKFPC.GetPurchaseHelper().TraderItems.SaleItems);
+			FilterContainer.SetPerkFilterData(FilterIndex);
+		break;
+		case (TI_Type):
+			ShopContainer.RefreshItemsByType(FilterIndex, MyKFPC.GetPurchaseHelper().TraderItems.SaleItems);
+			FilterContainer.SetTypeFilterData(FilterIndex);
+		break;
+		case (TI_Favorites):
+			ShopContainer.RefreshFavoriteItems(MyKFPC.GetPurchaseHelper().TraderItems.SaleItems);
+			FilterContainer.ClearFilters();
+		break;
+		case (TI_All):
+			ShopContainer.RefreshAllItems(MyKFPC.GetPurchaseHelper().TraderItems.SaleItems);
+			FilterContainer.ClearFilters();
+		break;
+	}
+
+	FilterContainer.SetInt("selectedTab", TabIndex);
+	FilterContainer.SetInt("selectedFilter", FilterIndex);
+
+	if (SelectedList == TL_Shop)
+	{
+		if (SelectedItemIndexInt >= MyKFPC.GetPurchaseHelper().TraderItems.SaleItems.length)
+		{
+			SelectedItemIndexInt = MyKFPC.GetPurchaseHelper().TraderItems.SaleItems.length - 1;
+		}
+
+		SetTraderItemDetails(SelectedItemIndexInt);
+		ShopContainer.SetSelectedIndex(SelectedItemIndexInt);
+	}
+}
+
+public function Callback_BuyOrSellItem()
+{
+	local STraderItem ShopItem;
+	local SItemInformation ItemInfo;
+
+	if (bCanBuyOrSellItem)
+	{
+		if (SelectedList == TL_Shop)
+		{
+			ShopItem = MyKFPC.GetPurchaseHelper().TraderItems.SaleItems[SelectedItemIndexInt];
+
+			MyKFPC.GetPurchaseHelper().PurchaseWeapon(ShopItem);
+			SetNewSelectedIndex(MyKFPC.GetPurchaseHelper().TraderItems.SaleItems.length);
+			SetTraderItemDetails(SelectedItemIndexInt);
+			ShopContainer.ActionScriptVoid("itemBought");
+		}
+		else
+		{
+			ItemInfo = OwnedItemList[SelectedItemIndexInt];
+			MyKFPC.GetPurchaseHelper().SellWeapon(ItemInfo, SelectedItemIndexInt);
+
+			SetNewSelectedIndex(OwnedItemList.length);
+			SetPlayerItemDetails(SelectedItemIndexInt);
+			PlayerInventoryContainer.ActionScriptVoid("itemSold");
+		}
+	}
+	else if (SelectedList == TL_Shop)
+	{
+		ShopItem = MyKFPC.GetPurchaseHelper().TraderItems.SaleItems[SelectedItemIndexInt];
+
+		MyKFPC.PlayTraderSelectItemDialog(!MyKFPC.GetPurchaseHelper().GetCanAfford(MyKFPC.GetPurchaseHelper().GetAdjustedBuyPriceFor(ShopItem)), !MyKFPC.GetPurchaseHelper().CanCarry(ShopItem));
+	}
+	RefreshItemComponents();
+}
+
+public function Callback_FavoriteItem()
+{
+	if (SelectedList == TL_Shop)
+	{
+		ToggleFavorite(MyKFPC.GetPurchaseHelper().TraderItems.SaleItems[SelectedItemIndexInt].ClassName);
+		if (CurrentTab == TI_Favorites)
+		{
+			SetNewSelectedIndex(MyKFPC.GetPurchaseHelper().TraderItems.SaleItems.length);
+		}
+		SetTraderItemDetails(SelectedItemIndexInt);
+	}
+	else
+	{
+		ToggleFavorite(OwnedItemList[SelectedItemIndexInt].DefaultItem.ClassName);
+		SetPlayerItemDetails(SelectedItemIndexInt);
+	}
+	RefreshItemComponents();
+}
+
+public function Callback_UpgradeItem()
+{
+	local SItemInformation ItemInfo;
+	local KFAutoPurchaseHelper PurchaseHelper;
+
+	if (SelectedList != TL_Player) return;
+
+	PurchaseHelper = MyKFPC.GetPurchaseHelper();
+	if (PurchaseHelper.UpgradeWeapon(SelectedItemIndexInt))
+	{
+		ItemInfo = PurchaseHelper.OwnedItemList[SelectedItemIndexInt];
+		PurchaseHelper.OwnedItemList[SelectedItemIndexInt].ItemUpgradeLevel++;
+		PurchaseHelper.OwnedItemList[SelectedItemIndexInt].SellPrice =
+			PurchaseHelper.GetAdjustedSellPriceFor(ItemInfo.DefaultItem);
+		RefreshItemComponents();
+		ShopContainer.ActionScriptVoid("itemBought");
+		class'KFMusicStingerHelper'.static.PlayWeaponUpgradeStinger(MyKFPC);
+	}
+}
+
 defaultproperties
 {
-	SubWidgetBindings.Remove((WidgetName="shopContainer",WidgetClass=class'KFGFxTraderContainer_Store'))
-	SubWidgetBindings.Add((WidgetName="shopContainer",WidgetClass=class'CTI_GFxTraderContainer_Store'))
+
 }

CTI/Classes/CTI_GFxMenu_Trader_DLC.uc

@@ -0,0 +1,8 @@
+class CTI_GFxMenu_Trader_DLC extends CTI_GFxMenu_Trader
+	dependsOn(CTI_GFxTraderContainer_Store);
+
+defaultproperties
+{
+	SubWidgetBindings.Remove((WidgetName="shopContainer",WidgetClass=class'KFGFxTraderContainer_Store'))
+	SubWidgetBindings.Add((WidgetName="shopContainer",WidgetClass=class'CTI_GFxTraderContainer_Store'))
+}

CTI/Classes/CTI_GFxMoviePlayer_Manager_DLC.uc

@@ -0,0 +1,8 @@
+class CTI_GFxMoviePlayer_Manager_DLC extends KFGFxMoviePlayer_Manager
+	dependsOn(CTI_GFxMenu_Trader);
+
+defaultproperties
+{
+	WidgetBindings.Remove((WidgetName="traderMenu",WidgetClass=class'KFGFxMenu_Trader'))
+	WidgetBindings.Add((WidgetName="traderMenu",WidgetClass=class'CTI_GFxMenu_Trader_DLC'))
+}

CTI/Classes/CTI_GFxMoviePlayer_Manager_Versus_DLC.uc

@@ -0,0 +1,8 @@
+class CTI_GFxMoviePlayer_Manager_Versus_DLC extends KFGFxMoviePlayer_Manager_Versus
+	dependsOn(CTI_GFxMenu_Trader);
+
+defaultproperties
+{
+	WidgetBindings.Remove((WidgetName="traderMenu",WidgetClass=class'KFGFxMenu_Trader'))
+	WidgetBindings.Add((WidgetName="traderMenu",WidgetClass=class'CTI_GFxMenu_Trader_DLC'))
+}

CTI/Classes/CTI_GFxObject_TraderItems.uc

@@ -0,0 +1,21 @@
+class CTI_GFxObject_TraderItems extends KFGFxObject_TraderItems;
+
+var() Array<STraderItem> AllItems;
+
+public function bool CTI_GetItemIndicesFromArche(out int ItemIndex, name WeaponClassName)
+{
+	local int Index;
+
+	Index = AllItems.Find('ClassName', WeaponClassName);
+
+	if (Index == INDEX_NONE) return false;
+
+	ItemIndex = Index;
+
+	return true;
+}
+
+DefaultProperties
+{
+
+}

CTI/Classes/CTI_GFxTraderContainer_Store.uc

@@ -11,7 +11,18 @@ function bool IsItemFiltered(STraderItem Item, optional bool bDebug)
 	if (Item.WeaponDef.default.PlatformRestriction != PR_All && class'KFUnlockManager'.static.IsPlatformRestricted(Item.WeaponDef.default.PlatformRestriction))
 		return true;
 
-   	return false;
+	if (Has9mmGun())
+	{
+		if ((Item.ClassName == 'KFWeap_HRG_93r' || Item.ClassName == 'KFWeap_HRG_93r_Dual'))
+			return true;
+	}
+	else
+	{
+		if ((Item.ClassName == 'KFWeap_Pistol_9mm' || Item.ClassName == 'KFWeap_Pistol_Dual9mm'))
+			return true;
+	}
+
+	return false;
 }
 
 defaultproperties

CTI/Classes/CTI_InventoryManager.uc

@@ -0,0 +1,505 @@
+class CTI_InventoryManager extends KFInventoryManager;
+
+var private CTI_RepInfo RepInfo;
+
+public function Initialize(CTI_RepInfo _RepInfo)
+{
+	RepInfo = _RepInfo;
+}
+
+public function OwnerDied()
+{
+	RepInfo.SetTimer(1.0f, false, nameof(RepInfo.InitInventoryManager));
+	Super.OwnerDied();
+}
+
+// simulated function final BuyAmmo( float AmountPurchased, EItemType ItemType, optional byte ItemIndex, optional bool bSecondaryAmmo )
+public simulated function CTI_BuyAmmo(float AmountPurchased, EItemType ItemType, optional int ItemIndex, optional bool bSecondaryAmmo)
+{
+	local STraderItem WeaponItem;
+	local KFWeapon KFW;
+	local int MagAmmoCount;
+
+	switch (ItemType)
+	{
+		case EIT_Weapon:
+			MagAmmoCount = INDEX_NONE;
+			if (CTI_GetTraderItemFromWeaponLists(WeaponItem, ItemIndex) && GetWeaponFromClass(KFW, WeaponItem.ClassName))
+			{
+				MagAmmoCount = bSecondaryAmmo ? KFW.AmmoCount[1] : KFW.AmmoCount[0];
+			}
+			CTI_ServerBuyAmmo(int(AmountPurchased), MagAmmoCount, ItemIndex, bSecondaryAmmo);
+		break;
+
+		case EIT_Armor:   CTI_ServerBuyArmor(AmountPurchased);        break;
+		case EIT_Grenade: CTI_ServerBuyGrenade(int(AmountPurchased)); break;
+	}
+}
+
+// reliable server final private function ServerBuyAmmo(int AmountPurchased, byte ClientAmmoCount, byte ItemIndex, bool bSecondaryAmmo)
+private reliable server function CTI_ServerBuyAmmo(int AmountPurchased, int ClientAmmoCount, int ItemIndex, bool bSecondaryAmmo)
+{
+	local STraderItem WeaponItem;
+	local KFWeapon KFW;
+	local int ClientMaxMagCapacity;
+
+	if (Role != ROLE_Authority || !bServerTraderMenuOpen)              return;
+	if (!CTI_GetTraderItemFromWeaponLists(WeaponItem, ItemIndex))      return;
+	if (!CTI_ProcessAmmoDosh(WeaponItem, AmountPurchased, bSecondaryAmmo)) return;
+
+	if (!GetWeaponFromClass(KFW, WeaponItem.ClassName))
+	{
+		CTI_ServerAddTransactionAmmo(AmountPurchased, ItemIndex, bSecondaryAmmo);
+		return;
+	}
+
+	if (bSecondaryAmmo)
+	{
+		KFW.AddSecondaryAmmo(AmountPurchased);
+	}
+	else
+	{
+		if (ClientAmmoCount != INDEX_NONE)
+		{
+			ClientMaxMagCapacity = KFW.default.MagazineCapacity[0];
+			if (KFW.GetPerk() != None)
+			{
+				KFW.GetPerk().ModifyMagSizeAndNumber(KFW, ClientMaxMagCapacity);
+			}
+			KFW.AmmoCount[0] = Clamp(ClientAmmoCount, 0, ClientMaxMagCapacity);
+		}
+
+		KFW.AddAmmo(AmountPurchased);
+	}
+}
+
+// reliable server final private event ServerAddTransactionAmmo( int AmountAdded, byte ItemIndex, bool bSecondaryAmmo )
+private reliable server event CTI_ServerAddTransactionAmmo(int AmountAdded, int ItemIndex, bool bSecondaryAmmo)
+{
+	local STraderItem WeaponItem;
+	local int TransactionIndex;
+
+	if (!bServerTraderMenuOpen) return;
+	if (!CTI_GetTraderItemFromWeaponLists(WeaponItem, ItemIndex)) return;
+
+	TransactionIndex = GetTransactionItemIndex(WeaponItem.ClassName);
+	if (TransactionIndex == INDEX_NONE) return;
+
+	TransactionItems[TransactionIndex].AddedAmmo[byte(bSecondaryAmmo)] += AmountAdded;
+}
+
+// simulated function final BuyUpgrade(byte ItemIndex, int CurrentUpgradeLevel)
+public simulated function CTI_BuyUpgrade(int ItemIndex, int CurrentUpgradeLevel)
+{
+	local STraderItem WeaponItem;
+	local KFPlayerController KFPC;
+
+	KFPC = KFPlayerController(Instigator.Owner);
+
+	if (!CTI_GetTraderItemFromWeaponLists(WeaponItem, ItemIndex)) return;
+
+	KFPC.GetPurchaseHelper().AddDosh(-WeaponItem.WeaponDef.static.GetUpgradePrice(CurrentUpgradeLevel)); //client tracking
+	KFPC.GetPurchaseHelper().AddBlocks(-GetDisplayedBlocksRequiredFor(WeaponItem));//remove the old weight
+	KFPC.GetPurchaseHelper().AddBlocks(GetDisplayedBlocksRequiredFor(WeaponItem, CurrentUpgradeLevel + 1)); //add the new
+	CTI_ServerBuyUpgrade(ItemIndex, CurrentUpgradeLevel);
+}
+
+// reliable server final private function ServerBuyUpgrade(byte ItemIndex, int CurrentUpgradeLevel)
+private reliable server function CTI_ServerBuyUpgrade(int ItemIndex, int CurrentUpgradeLevel)
+{
+	local STraderItem WeaponItem;
+	local KFWeapon KFW;
+	local int NewUpgradeLevel;
+
+	if (Role != ROLE_Authority || !bServerTraderMenuOpen)         return;
+	if (!CTI_GetTraderItemFromWeaponLists(WeaponItem, ItemIndex)) return;
+	if (!CTI_ProcessUpgradeDosh(WeaponItem, CurrentUpgradeLevel)) return;
+
+	NewUpgradeLevel = CurrentUpgradeLevel + 1;
+
+	if (GetWeaponFromClass(KFW, WeaponItem.ClassName))
+	{
+		if (KFW == None) return;
+
+		KFW.SetWeaponUpgradeLevel(NewUpgradeLevel);
+		if (CurrentUpgradeLevel > 0)
+		{
+			AddCurrentCarryBlocks(-KFW.GetUpgradeStatAdd(EWUS_Weight, CurrentUpgradeLevel));
+		}
+
+		AddCurrentCarryBlocks(KFW.GetUpgradeStatAdd(EWUS_Weight, NewUpgradeLevel));
+	}
+	else
+	{
+		CTI_ServerAddTransactionUpgrade(ItemIndex, NewUpgradeLevel);
+	}
+
+}
+
+// reliable server final function ServerBuyWeapon( byte ItemIndex, optional byte WeaponUpgrade )
+public reliable server function CTI_ServerBuyWeapon(int ItemIndex, optional int WeaponUpgrade )
+{
+	local STraderItem PurchasedItem;
+	local int BlocksRequired;
+
+	if (Role != ROLE_Authority || !bServerTraderMenuOpen)            return;
+	if (!CTI_GetTraderItemFromWeaponLists(PurchasedItem, ItemIndex)) return;
+
+	BlocksRequired = GetWeaponBlocks(PurchasedItem, WeaponUpgrade);
+
+	if (CurrentCarryBlocks > CurrentCarryBlocks + BlocksRequired) return;
+	if (!CTI_ProcessWeaponDosh(PurchasedItem))                        return;
+
+	CTI_AddTransactionItem(PurchasedItem, WeaponUpgrade);
+}
+
+// final function AddTransactionItem( const out STraderItem ItemToAdd, optional byte WeaponUpgrade )
+public function CTI_AddTransactionItem(const out STraderItem ItemToAdd, optional int WeaponUpgrade)
+{
+	local TransactionItem NewTransactionItem;
+
+	if (Role < ROLE_Authority || !bServerTraderMenuOpen) return;
+
+	NewTransactionItem.ClassName = ItemToAdd.ClassName;
+	NewTransactionItem.DLOString = ItemToAdd.WeaponDef.default.WeaponClassPath;
+	NewTransactionItem.AddedAmmo[0] = 0;
+	NewTransactionItem.AddedAmmo[1] = 0;
+	NewTransactionItem.WeaponUpgradeLevel = WeaponUpgrade;
+
+	TransactionItems.AddItem(NewTransactionItem);
+
+	AddCurrentCarryBlocks(GetWeaponBlocks(ItemToAdd, WeaponUpgrade));
+}
+
+// reliable server final function ServerAddTransactionItem( byte ItemIndex, optional byte WeaponUpgrade)
+public reliable server function CTI_ServerAddTransactionItem(int ItemIndex, optional int WeaponUpgrade)
+{
+	local STraderItem PurchasedItem;
+
+	if (Role != ROLE_Authority || !bServerTraderMenuOpen) return;
+
+	if (CTI_GetTraderItemFromWeaponLists(PurchasedItem, ItemIndex))
+	{
+		CTI_AddTransactionItem(PurchasedItem, WeaponUpgrade);
+	}
+}
+
+// final function RemoveTransactionItem( const out STraderItem ItemToRemove )
+final function CTI_RemoveTransactionItem(const out STraderItem ItemToRemove)
+{
+	local int Index;
+
+	if (Role < ROLE_Authority || !bServerTraderMenuOpen) return;
+
+	Index = GetTransactionItemIndex( ItemToRemove.ClassName );
+
+	if (Index == INDEX_NONE) return;
+
+	AddCurrentCarryBlocks(-GetDisplayedBlocksRequiredFor(ItemToRemove, TransactionItems[Index].WeaponUpgradeLevel));
+	TransactionItems.Remove(Index, 1);
+}
+
+// reliable server final function ServerRemoveTransactionItem( int ItemIndex )
+public reliable server final function CTI_ServerRemoveTransactionItem(int ItemIndex)
+{
+	local STraderItem ItemToRemove;
+	local KFWeapon InvWeap;
+
+	if (!bServerTraderMenuOpen) return;
+	if (!CTI_GetTraderItemFromWeaponLists(ItemToRemove, ItemIndex)) return;
+
+	CTI_RemoveTransactionItem(ItemToRemove);
+
+	if (!GetWeaponFromClass(InvWeap, ItemToRemove.ClassName)) return;
+
+	RemoveFromInventory(InvWeap);
+}
+
+// reliable server final function ServerSellWeapon( byte ItemIndex )
+public reliable server function CTI_ServerSellWeapon(int ItemIndex)
+{
+	local STraderItem SoldItem;
+	local int SellPrice, TransactionIndex;
+	local KFWeapon KFW;
+	local KFPlayerReplicationInfo KFPRI;
+
+	if (Role != ROLE_Authority || !bServerTraderMenuOpen) return;
+
+	KFPRI = KFPlayerReplicationInfo(Instigator.PlayerReplicationInfo);
+
+	if (KFPRI == None) return;
+
+	if (!CTI_GetTraderItemFromWeaponLists(SoldItem, ItemIndex)) return;
+
+	if (GetWeaponFromClass(KFW, SoldItem.ClassName))
+	{
+		SellPrice = GetAdjustedSellPriceFor(SoldItem);
+		KFPRI.AddDosh(SellPrice);
+		ServerRemoveFromInventory(KFW);
+		KFW.Destroy();
+	}
+	else
+	{
+		TransactionIndex = GetTransactionItemIndex(SoldItem.ClassName);
+
+		if (TransactionIndex == INDEX_NONE) return;
+
+		SellPrice = GetAdjustedSellPriceFor(SoldItem);
+		KFPRI.AddDosh(SellPrice);
+		CTI_RemoveTransactionItem(SoldItem);
+	}
+}
+
+// private final simulated function bool GetTraderItemFromWeaponLists(out STraderItem TraderItem, byte ItemIndex )
+private simulated function bool CTI_GetTraderItemFromWeaponLists(out STraderItem TraderItem, int ItemIndex)
+{
+	local CTI_GFxObject_TraderItems TraderItems;
+
+	if (WorldInfo.GRI == None) return false;
+
+	TraderItems = CTI_GFxObject_TraderItems(KFGameReplicationInfo(WorldInfo.GRI).TraderItems);
+
+	if (TraderItems == None) return false;
+
+	if (ItemIndex < TraderItems.AllItems.Length)
+	{
+		TraderItem = TraderItems.AllItems[ItemIndex];
+		return true;
+	}
+
+	return false;
+}
+
+// private final function bool ProcessWeaponDosh(out STraderItem PurchasedItem)
+private function bool CTI_ProcessWeaponDosh(out STraderItem PurchasedItem)
+{
+	local int BuyPrice;
+	local KFPlayerReplicationInfo KFPRI;
+
+	KFPRI = KFPlayerReplicationInfo(Instigator.PlayerReplicationInfo);
+	if (KFPRI == None) return false;
+
+	BuyPrice = GetAdjustedBuyPriceFor(PurchasedItem);
+
+	if (KFPRI.Score - BuyPrice >= 0)
+	{
+		KFPRI.AddDosh(-BuyPrice);
+		return true;
+	}
+
+	return false;
+}
+
+private function float AmmoCostScale()
+{
+	local KFGameReplicationInfo KFGRI;
+	KFGRI = KFGameReplicationInfo(WorldInfo.GRI);
+	return KFGRI == None ? 1.0f : KFGRI.GameAmmoCostScale;
+}
+
+// private final function bool ProcessAmmoDosh(out STraderItem PurchasedItem, int AdditionalAmmo, optional bool bSecondaryAmmo)
+private function bool CTI_ProcessAmmoDosh(out STraderItem PurchasedItem, int AdditionalAmmo, optional bool bSecondaryAmmo)
+{
+	local int BuyPrice;
+	local float PricePerMag, MagSize;
+	local KFPlayerReplicationInfo KFPRI;
+
+	KFPRI = KFPlayerReplicationInfo(Instigator.PlayerReplicationInfo);
+	if (KFPRI == None) return false;
+
+	if (bSecondaryAmmo)
+	{
+		PricePerMag = AmmoCostScale() * PurchasedItem.WeaponDef.default.SecondaryAmmoMagPrice;
+		MagSize = PurchasedItem.WeaponDef.default.SecondaryAmmoMagSize;
+		BuyPrice = FCeil((PricePerMag / MagSize) * float(AdditionalAmmo));
+	}
+	else
+	{
+		PricePerMag = AmmoCostScale() * PurchasedItem.WeaponDef.default.AmmoPricePerMag;
+		MagSize = PurchasedItem.MagazineCapacity;
+		BuyPrice = FCeil((PricePerMag / MagSize) * float(AdditionalAmmo));
+	}
+
+	if (KFPRI.Score - BuyPrice >= 0)
+	{
+		KFPRI.AddDosh(-BuyPrice);
+		return true;
+	}
+
+	return false;
+}
+
+// private final function bool ProcessUpgradeDosh(const out STraderItem PurchasedItem, int NewUpgradeLevel)
+private function bool CTI_ProcessUpgradeDosh(const out STraderItem PurchasedItem, int NewUpgradeLevel)
+{
+	local int BuyPrice;
+	local KFPlayerController KFPC;
+	local KFPlayerReplicationInfo KFPRI;
+
+	KFPC = KFPlayerController(Instigator.Owner);
+	KFPRI = KFPlayerReplicationInfo(Instigator.PlayerReplicationInfo);
+
+	if (KFPC == None || KFPRI == none) return false;
+
+	BuyPrice = PurchasedItem.WeaponDef.static.GetUpgradePrice(NewUpgradeLevel);
+	if (BuyPrice <= KFPRI.Score)
+	{
+		KFPRI.AddDosh(-BuyPrice);
+		return true;
+	}
+
+	return false;
+}
+
+// private final function bool ProcessGrenadeDosh(int AmountPurchased)
+private function bool CTI_ProcessGrenadeDosh(int AmountPurchased)
+{
+	local int BuyPrice;
+	local KFGFxObject_TraderItems TraderItems;
+	local KFPlayerController KFPC;
+	local KFPlayerReplicationInfo KFPRI;
+
+	KFPC = KFPlayerController(Instigator.Owner);
+	KFPRI = KFPlayerReplicationInfo(Instigator.PlayerReplicationInfo);
+	if (KFPC == None || KFPRI == None) return false;
+
+	TraderItems = KFGameReplicationInfo(WorldInfo.GRI).TraderItems;
+	BuyPrice = TraderItems.GrenadePrice * AmountPurchased;
+	if (BuyPrice <= KFPRI.Score)
+	{
+		KFPRI.AddDosh(-BuyPrice);
+		return true;
+	}
+
+	return false;
+}
+
+// reliable server final private function ServerBuyArmor( float PercentPurchased )
+private reliable server function CTI_ServerBuyArmor(float PercentPurchased)
+{
+	local KFPawn_Human KFP;
+	local int AmountPurchased;
+	local float MaxArmor;
+
+	KFP = KFPawn_Human(Instigator);
+	if (Role != ROLE_Authority || KFP == none || !bServerTraderMenuOpen) return;
+	if (!CTI_ProcessArmorDosh(PercentPurchased)) return;
+
+	MaxArmor = KFP.GetMaxArmor();
+	AmountPurchased = FCeil(MaxArmor * (PercentPurchased / 100.0));
+
+	KFP.AddArmor(AmountPurchased);
+}
+
+// private final function bool ProcessArmorDosh(float PercentPurchased)
+private function bool CTI_ProcessArmorDosh(float PercentPurchased)
+{
+	local int BuyPrice;
+	local KFGFxObject_TraderItems TraderItems;
+	local KFPlayerController KFPC;
+	local KFPerk CurrentPerk;
+	local int ArmorPricePerPercent;
+	local KFPlayerReplicationInfo KFPRI;
+
+	KFPRI = KFPlayerReplicationInfo(Instigator.PlayerReplicationInfo);
+	if (KFPRI == None) return false;
+
+	TraderItems = KFGameReplicationInfo(WorldInfo.GRI).TraderItems;
+	ArmorPricePerPercent = TraderItems.ArmorPrice;
+
+	KFPC = KFPlayerController(Instigator.Owner);
+	if (KFPC != None)
+	{
+		CurrentPerk = KFPC.GetPerk();
+		if (CurrentPerk != None)
+		{
+			ArmorPricePerPercent *= CurrentPerk.GetArmorDiscountMod();
+		}
+	}
+
+	BuyPrice = FCeil(ArmorPricePerPercent * PercentPurchased);
+	if (BuyPrice <= KFPRI.Score)
+	{
+		KFPRI.AddDosh(-BuyPrice);
+		return true;
+	}
+
+	return false;
+}
+
+// reliable server final private event ServerAddTransactionUpgrade(int ItemIndex, int NewUpgradeLevel)
+private reliable server event CTI_ServerAddTransactionUpgrade(int ItemIndex, int NewUpgradeLevel)
+{
+	if (bServerTraderMenuOpen)
+	{
+		CTI_AddTransactionUpgrade(ItemIndex, NewUpgradeLevel);
+	}
+}
+
+// final function AddTransactionUpgrade(int ItemIndex, int NewUpgradeLevel)
+private function CTI_AddTransactionUpgrade(int ItemIndex, int NewUpgradeLevel)
+{
+	local STraderItem WeaponItem;
+	local int TransactionIndex;
+
+	if (Role < ROLE_Authority || !bServerTraderMenuOpen) return;
+
+	if (CTI_GetTraderItemFromWeaponLists(WeaponItem, ItemIndex))
+	{
+		TransactionIndex = GetTransactionItemIndex(WeaponItem.ClassName);
+		if (TransactionIndex == INDEX_NONE) return;
+
+		TransactionItems[TransactionIndex].WeaponUpgradeLevel = NewUpgradeLevel;
+		TransactionItems[TransactionIndex].AddedWeight = WeaponItem.WeaponUpgradeWeight[NewUpgradeLevel];
+		if (NewUpgradeLevel > 0)
+		{
+			AddCurrentCarryBlocks(-WeaponItem.WeaponUpgradeWeight[NewUpgradeLevel-1]);
+		}
+		AddCurrentCarryBlocks(WeaponItem.WeaponUpgradeWeight[NewUpgradeLevel]);
+	}
+}
+
+// reliable server final private function ServerBuyGrenade( int AmountPurchased )
+private reliable server function CTI_ServerBuyGrenade(int AmountPurchased)
+{
+	if (Role != ROLE_Authority || !bServerTraderMenuOpen) return;
+
+	if (CTI_ProcessGrenadeDosh(AmountPurchased))
+	{
+		AddGrenades(AmountPurchased);
+	}
+}
+
+public simulated function int GetWeaponBlocks(const out STraderItem ShopItem, optional int OverrideLevelValue = INDEX_NONE)
+{
+	local int ItemUpgradeLevel;
+	local KFPlayerController KFPC;
+	local Inventory InventoryItem;
+
+	if (ShopItem.SingleClassName != '' && OverrideLevelValue == INDEX_NONE && ClassNameIsInInventory(ShopItem.SingleClassName, InventoryItem))
+	{
+		ItemUpgradeLevel = KFWeapon(InventoryItem).CurrentWeaponUpgradeIndex;
+	}
+	else
+	{
+		if (OverrideLevelValue != INDEX_NONE)
+		{
+			ItemUpgradeLevel = OverrideLevelValue;
+		}
+		else
+		{
+			KFPC = KFPlayerController(Instigator.Owner);
+			if (KFPC != None)
+			{
+				ItemUpgradeLevel = KFPC.GetPurchaseHelper().GetItemUpgradeLevelByClassName(ShopItem.ClassName);
+			}
+		}
+	}
+
+	return ShopItem.BlocksRequired + (ItemUpgradeLevel > INDEX_NONE ? ShopItem.WeaponUpgradeWeight[ItemUpgradeLevel] : 0);
+}
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_LocalMessage.uc

@@ -0,0 +1,89 @@
+class CTI_LocalMessage extends Object
+	abstract;
+
+var const             String SyncItemsDefault;
+var private localized String SyncItems;
+
+var const             String WaitingGRIDefault;
+var private localized String WaitingGRI;
+
+var const             String IncompatibleGRIDefault;
+var private localized String IncompatibleGRI;
+
+var const             String IncompatibleGRIWarningDefault;
+var private localized String IncompatibleGRIWarning;
+
+var const             String NoneGRIDefault;
+var private localized String NoneGRI;
+
+var const             String NoneGRIWarningDefault;
+var private localized String NoneGRIWarning;
+
+var const             String SecondsShortDefault;
+var private localized String SecondsShort;
+
+var const             String PleaseWaitDefault;
+var private localized String PleaseWait;
+
+enum E_CTI_LocalMessageType
+{
+	CTI_SyncItems,
+	CTI_WaitingGRI,
+	CTI_IncompatibleGRI,
+	CTI_IncompatibleGRIWarning,
+	CTI_NoneGRI,
+	CTI_NoneGRIWarning,
+	CTI_SecondsShort,
+	CTI_PleaseWait
+};
+
+public static function String GetLocalizedString(
+	E_LogLevel LogLevel,
+	E_CTI_LocalMessageType LMT,
+	optional String String1,
+	optional String String2,
+	optional String String3)
+{
+	`Log_TraceStatic();
+
+	switch (LMT)
+	{
+		case CTI_SyncItems:
+			return (default.SyncItems != "" ? default.SyncItems : default.SyncItemsDefault);
+
+		case CTI_WaitingGRI:
+			return (default.WaitingGRI != "" ? default.WaitingGRI : default.WaitingGRIDefault);
+
+		case CTI_IncompatibleGRI:
+			return (default.IncompatibleGRI != "" ? default.IncompatibleGRI : default.IncompatibleGRIDefault) @ String1;
+
+		case CTI_IncompatibleGRIWarning:
+			return (default.IncompatibleGRIWarning != "" ? default.IncompatibleGRIWarning : default.IncompatibleGRIWarningDefault);
+
+		case CTI_NoneGRI:
+			return (default.NoneGRI != "" ? default.NoneGRI : default.NoneGRIDefault);
+
+		case CTI_NoneGRIWarning:
+			return (default.NoneGRIWarning != "" ? default.NoneGRIWarning : default.NoneGRIWarningDefault);
+
+		case CTI_SecondsShort:
+			return (default.SecondsShort != "" ? default.SecondsShort : default.SecondsShortDefault);
+
+		case CTI_PleaseWait:
+			return (default.PleaseWait != "" ? default.PleaseWait : default.PleaseWaitDefault);
+	}
+
+	return "";
+}
+
+defaultproperties
+{
+	SyncItemsDefault              = "Sync items:"
+	WaitingGRIDefault             = "Waiting GRI..."
+	IncompatibleGRIDefault        = "Incompatible GRI:"
+	IncompatibleGRIWarningDefault = "You can enter the game, but the trader may not work correctly.";
+	NoneGRIDefault                = "GRI is not initialized!"
+	NoneGRIWarningDefault         = "It is recommended to reconnect. If you enter the game right now, the trader may not work correctly.";
+	SecondsShortDefault           = "s"
+	PleaseWaitDefault             = "Please wait"
+}

CTI/Classes/CTI_RepInfo.uc

@@ -1,64 +1,300 @@
-class CTI_RepInfo extends ReplicationInfo;
+class CTI_RepInfo extends ReplicationInfo
+	dependson(WeaponReplacements);
 
-const Helper = class'Helper';
+const CAPACITY = 64; // max: 128
+
+const Trader             = class'Trader';
+const LocalMessage       = class'CTI_LocalMessage';
+const Replacements       = class'WeaponReplacements';
+const PurchaseHelper     = class'CTI_AutoPurchaseHelper';
+const InventoryManager   = class'CTI_InventoryManager';
+
+struct ReplicationStruct
+{
+	var int Size;
+	var int Transfered;
+
+	var class<KFWeaponDefinition> Items[CAPACITY];
+	var int Length;
+};
 
 var public  bool PendingSync;
 
 var private CTI CTI;
 var private E_LogLevel LogLevel;
-var private Array<class<KFWeaponDefinition> > RemoveItems;
-var private Array<class<KFWeaponDefinition> > AddItems;
-var private bool ReplaceMode;
-var private bool PreloadContent;
 
-var private int  Recieved;
-var private int  SyncSize;
+var private class<KFGFxMoviePlayer_Manager> FrontEndClass;
 
+var private GameReplicationInfo     GRI;
 var private KFPlayerController      KFPC;
-var private KFPawn                  KFP;
-var private KFInventoryManager      KFIM;
-
+var private KFPlayerReplicationInfo KFPRI;
 var private KFGFxWidget_PartyInGame PartyInGameWidget;
 var private GFxObject               Notification;
 
-var private class<Weapon>           PreloadWeaponClass;
-var private float                   PreloadWeaponTime;
+var private String NotificationHeaderText;
+var private String NotificationLeftText;
+var private String NotificationRightText;
+var private int    NotificationPercent;
+
+var private int    WaitingGRI;
+var private int    WaitingGRIThreshold;
+var private int    WaitingGRILimit;
+
+var private ReplicationStruct                 RepData;
+var private Array<class<KFWeaponDefinition> > RepArray;
+
+var private bool SkinUpdateRequired;
+var private bool PatchRequired;
+
+var private bool ClientReady, ServerReady;
 
 replication
 {
 	if (bNetInitial && Role == ROLE_Authority)
-		LogLevel, ReplaceMode, PreloadContent, SyncSize;
+		LogLevel, SkinUpdateRequired, PatchRequired, FrontEndClass;
 }
 
 public simulated function bool SafeDestroy()
 {
-	`Log_Trace(`Location);
+	`Log_Trace();
 
 	return (bPendingDelete || bDeleteMe || Destroy());
 }
 
 public function PrepareSync(
-	CTI _CTI,
-	E_LogLevel _LogLevel,
-	Array<class<KFWeaponDefinition> > _RemoveItems,
-	Array<class<KFWeaponDefinition> > _AddItems,
-	bool _ReplaceMode,
-	bool _PreloadContent)
+	CTI _CTI, E_LogLevel _LogLevel,
+	class<KFGFxMoviePlayer_Manager> _FrontEndClass,
+	bool _SkinUpdateRequired, bool _PatchRequired)
 {
-	`Log_Trace(`Location);
+	`Log_Trace();
 
-	CTI                 = _CTI;
-	LogLevel            = _LogLevel;
-	RemoveItems         = _RemoveItems;
-	AddItems            = _AddItems;
-	ReplaceMode         = _ReplaceMode;
-	PreloadContent      = _PreloadContent;
-	SyncSize            = RemoveItems.Length + AddItems.Length;
+	CTI                      = _CTI;
+	LogLevel                 = _LogLevel;
+	FrontEndClass            = _FrontEndClass;
+	SkinUpdateRequired       = _SkinUpdateRequired;
+	PatchRequired            = _PatchRequired;
+}
+
+private reliable client function ClientSetFrontEnd()
+{
+	if (FrontEndClass == None || GetKFPRI() == None)
+	{
+		`Log_Debug("Wait for frontend");
+		SetTimer(1.0f, false, nameof(ClientSetFrontEnd));
+		return;
+	}
+
+	if (KFPC.MyGFxManager != None && KFPC.MyGFxManager.class == FrontEndClass)
+	{
+		`Log_Debug("MyGFxManager is ok:" @ String(KFPC.MyGFxManager.class));
+		return;
+	}
+
+	KFPC.MyGFxManager.CloseMenus(true);
+	KFPC.MyGFxManager = None;
+
+	KFPC.ClientSetFrontEnd(FrontEndClass, KFPRI.bOnlySpectator);
+
+	`Log_Debug(String(FrontEndClass) @ "initialized.");
+}
+
+public function Replicate(const out Array<class<KFWeaponDefinition> > WeapDefs)
+{
+	`Log_Trace();
+
+	ServerReady = !PatchRequired;
+
+	ClientSetFrontEnd();
+
+	if (PatchRequired)
+	{
+		if (GetKFPC() != None)
+		{
+			KFPC.PurchaseHelperClass = PurchaseHelper;
+			KFPC.PurchaseHelper = None;
+		}
+
+		InitInventoryManager();
+	}
+
+	RepArray = WeapDefs;
+	RepData.Size = RepArray.Length;
+
+	if (WorldInfo.NetMode != NM_StandAlone)
+	{
+		Sync();
+	}
+	else
+	{
+		Finished();
+	}
+}
+
+private reliable server function Sync()
+{
+	local int  LocalIndex;
+	local int  GlobalIndex;
+
+	`Log_Trace();
+
+	LocalIndex = 0;
+	GlobalIndex = RepData.Transfered;
+
+	while (LocalIndex < CAPACITY && GlobalIndex < RepData.Size)
+	{
+		RepData.Items[LocalIndex++] = RepArray[GlobalIndex++];
+	}
+
+	if (RepData.Transfered == GlobalIndex) return; // Finished
+
+	RepData.Transfered = GlobalIndex;
+	RepData.Length = LocalIndex;
+
+	Send(RepData);
+
+	Progress(RepData.Transfered, RepData.Size);
+}
+
+private reliable client function Send(ReplicationStruct RD)
+{
+	local int LocalIndex;
+
+	`Log_Trace();
+
+	for (LocalIndex = 0; LocalIndex < RD.Length; LocalIndex++)
+	{
+		RepArray.AddItem(RD.Items[LocalIndex]);
+	}
+
+	Progress(RD.Transfered, RD.Size);
+
+	Sync();
+}
+
+private simulated function Progress(int Value, int Size)
+{
+	`Log_Trace();
+
+	`Log_Debug("Replicated:" @ Value @ "/" @ Size);
+
+	if (ROLE < ROLE_Authority)
+	{
+		NotifyProgress(Value, Size);
+		if (Value >= Size) Finished();
+	}
+}
+
+private simulated function Finished()
+{
+	local KFGameReplicationInfo KFGRI;
+
+	`Log_Trace();
+
+	if ((GetGRI(WaitingGRI > WaitingGRIThreshold) == None) && WaitingGRI++ < WaitingGRILimit)
+	{
+		`Log_Debug("Finished: Waiting GRI" @ WaitingGRI);
+		NotifyWaitingGRI();
+		SetTimer(1.0f, false, nameof(Finished));
+		return;
+	}
+
+	if (PatchRequired && GetKFPC() != None)
+	{
+		KFPC.PurchaseHelperClass = PurchaseHelper;
+		KFPC.PurchaseHelper = None;
+	}
+
+	KFGRI = KFGameReplicationInfo(GRI);
+	if (KFGRI != None)
+	{
+		`Log_Debug("Finished: Trader.static.OverwriteTraderItems");
+		if (WorldInfo.NetMode != NM_StandAlone)
+		{
+			Trader.static.OverwriteTraderItems(KFGRI, RepArray, PatchRequired, LogLevel);
+		}
+		`Log_Info("Trader items successfully synchronized!");
+	}
+	else
+	{
+		`Log_Error("Incompatible Game Replication info:" @ String(GRI));
+		if (GRI == None)
+		{
+			NotifyNoneGRI();
+		}
+		else
+		{
+			NotifyIncompatibleGRI();
+		}
+	}
+
+	ShowReadyButton();
+
+	if (SkinUpdateRequired)
+	{
+		SkinUpdate();
+	}
+	else
+	{
+		ClientFinished();
+	}
+}
+
+private simulated function SkinUpdate()
+{
+	local SWeapReplace WeapReplace;
+
+	if (GetKFPRI() == None || !KFPRI.bHasSpawnedIn)
+	{
+		`Log_Debug("Wait for spawn (SkinUpdate)");
+		SetTimer(1.0f, false, nameof(SkinUpdate));
+		return;
+	}
+
+	foreach Replacements.default.DLC(WeapReplace)
+	{
+		// sometimes "WeapReplace.Weap.default.SkinItemId" can give values greater than zero while actually being zero
+		// this is the same bug that prevents creating the correct default config
+		// so for now let’s shorten the check a little so that the skinId of the WeapReplace is guaranteed to be correct
+		// but if this bug is ever fixed, then it’s worth replacing the check with this one:
+		// if (WeapReplace.WeapParent.default.SkinItemId > 0 && WeapReplace.Weap.default.SkinItemId != WeapReplace.WeapParent.default.SkinItemId)
+		// to reduce the number of meaningless disk writes
+		if (WeapReplace.WeapParent.default.SkinItemId > 0)
+		{
+			`Log_Debug("Update skin for:" @ String(WeapReplace.WeapDef) @ "SkinId:" @ WeapReplace.WeapParent.default.SkinItemId);
+			class'KFWeaponSkinList'.static.SaveWeaponSkin(WeapReplace.WeapDef, WeapReplace.WeapParent.default.SkinItemId);
+		}
+	}
+
+	ClearTimer(nameof(SkinUpdate));
+	ClientFinished();
+}
+
+private simulated function GameReplicationInfo GetGRI(optional bool ForcedSearch = false)
+{
+	`Log_Trace();
+
+	if (GRI == None)
+	{
+		GRI = WorldInfo.GRI;
+	}
+
+	if (GRI == None && ForcedSearch)
+	{
+		foreach WorldInfo.DynamicActors(class'GameReplicationInfo', GRI) break;
+	}
+
+	if (WorldInfo.GRI == None && GRI != None)
+	{
+		`Log_Warn("Force initialization of WorldInfo.GRI" @ String(GRI));
+		WorldInfo.GRI = GRI;
+	}
+
+	return GRI;
 }
 
 private simulated function KFPlayerController GetKFPC()
 {
-	`Log_Trace(`Location);
+	`Log_Trace();
 
 	if (KFPC != None) return KFPC;
 
@@ -72,9 +308,55 @@ private simulated function KFPlayerController GetKFPC()
 	return KFPC;
 }
 
+private simulated function KFPlayerReplicationInfo GetKFPRI()
+{
+	`Log_Trace();
+
+	if (KFPRI != None) return KFPRI;
+
+	if (GetKFPC() == None) return None;
+
+	KFPRI = KFPlayerReplicationInfo(KFPC.PlayerReplicationInfo);
+
+	return KFPRI;
+}
+
+public reliable client function WriteToChatLocalized(
+	E_CTI_LocalMessageType LMT,
+	optional String HexColor,
+	optional String String1,
+	optional String String2,
+	optional String String3)
+{
+	`Log_Trace();
+
+	WriteToChat(LocalMessage.static.GetLocalizedString(LogLevel, LMT, String1, String2, String3), HexColor);
+}
+
+public reliable client function WriteToChat(String Message, optional String HexColor)
+{
+	local KFGFxHudWrapper HUD;
+
+	`Log_Trace();
+
+	if (GetKFPC() == None) return;
+
+	if (KFPC.MyGFxManager.PartyWidget != None && KFPC.MyGFxManager.PartyWidget.PartyChatWidget != None)
+	{
+		KFPC.MyGFxManager.PartyWidget.PartyChatWidget.SetVisible(true);
+		KFPC.MyGFxManager.PartyWidget.PartyChatWidget.AddChatMessage(Message, HexColor);
+	}
+
+	HUD = KFGFxHudWrapper(KFPC.myHUD);
+	if (HUD != None && HUD.HUDMovie != None && HUD.HUDMovie.HudChatBox != None)
+	{
+		HUD.HUDMovie.HudChatBox.AddChatMessage(Message, HexColor);
+	}
+}
+
 private simulated function SetPartyInGameWidget()
 {
-	`Log_Trace(`Location);
+	`Log_Trace();
 
 	if (GetKFPC() == None) return;
 
@@ -87,7 +369,7 @@ private simulated function SetPartyInGameWidget()
 
 private simulated function bool CheckPartyInGameWidget()
 {
-	`Log_Trace(`Location);
+	`Log_Trace();
 
 	if (PartyInGameWidget == None)
 	{
@@ -97,9 +379,9 @@ private simulated function bool CheckPartyInGameWidget()
 	return (PartyInGameWidget != None);
 }
 
-private unreliable client function HideReadyButton()
+private simulated function HideReadyButton()
 {
-	`Log_Trace(`Location);
+	`Log_Trace();
 
 	if (CheckPartyInGameWidget())
 	{
@@ -109,7 +391,9 @@ private unreliable client function HideReadyButton()
 
 private simulated function ShowReadyButton()
 {
-	`Log_Trace(`Location);
+	`Log_Trace();
+
+	ClearTimer(nameof(KeepNotification));
 
 	if (CheckPartyInGameWidget())
 	{
@@ -120,113 +404,173 @@ private simulated function ShowReadyButton()
 	}
 }
 
-private unreliable client function UpdateNotification(String Title, String Downloading, String Remainig, int Percent)
+private simulated function UpdateNotification(String Title, String Left, String Right, int Percent)
 {
-	`Log_Trace(`Location);
+	`Log_Trace();
 
 	if (CheckPartyInGameWidget() && Notification != None)
 	{
 		Notification.SetString("itemName", Title);
 		Notification.SetFloat("percent", Percent);
 		Notification.SetInt("queue", 0);
-		Notification.SetString("downLoading", Downloading);
-		Notification.SetString("remaining", Remainig);
+		Notification.SetString("downLoading", Left);
+		Notification.SetString("remaining", Right);
 		Notification.SetObject("notificationInfo", Notification);
 		Notification.SetVisible(true);
 	}
 }
 
-private reliable client function ClientSync(class<KFWeaponDefinition> WeapDef, optional bool Remove = false)
+private simulated function KeepNotification()
 {
-	`Log_Trace(`Location);
-	
-	if (WeapDef == None)
-	{
-		`Log_Fatal("WeapDef is:" @ WeapDef);
-		SafeDestroy();
-		return;
-	}
-	
 	HideReadyButton();
-
-	if (Remove)
-	{
-		RemoveItems.AddItem(WeapDef);
-	}
-	else
-	{
-		AddItems.AddItem(WeapDef);
-		if (PreloadContent)
-		{
-			Helper.static.PreloadWeapon(WeapDef);
-		}
-	}
-	
-	Recieved = RemoveItems.Length + AddItems.Length;
-	
 	UpdateNotification(
-		"Sync trader items, please wait...",
-		Remove ? "-" : "+" @ Repl(String(WeapDef), "KFWeapDef_", ""),
-		Recieved @ "/" @ SyncSize,
-		(float(Recieved) / float(SyncSize)) * 100);
-	
-	ServerSync();
+		NotificationHeaderText,
+		NotificationLeftText,
+		NotificationRightText,
+		NotificationPercent);
 }
 
-private simulated reliable client function ClientSyncFinished()
+private reliable server function ClientFinished()
 {
-	local KFGameReplicationInfo KFGRI;
+	ClientReady = true;
+	if (ClientReady && ServerReady) Cleanup();
+}
 
-	`Log_Trace(`Location);
+private function ServerFinished()
+{
+	ServerReady = true;
+	if (ClientReady && ServerReady) Cleanup();
+}
 
-	if (WorldInfo.GRI == None)
+private reliable server function Cleanup()
+{
+	`Log_Trace();
+
+	if (PatchRequired)
 	{
-		SetTimer(1.0f, false, nameof(ClientSyncFinished));
-	}
-	
-	KFGRI = KFGameReplicationInfo(WorldInfo.GRI);
-	if (KFGRI == None)
-	{
-		`Log_Fatal("Incompatible Replication info:" @ WorldInfo.GRI);
-		SafeDestroy();
+		`Log_Debug("Skip cleanup to keep CTI_RepInfo alive");
 		return;
 	}
 
-	Helper.static.ModifyTrader(KFGRI, RemoveItems, AddItems, ReplaceMode);
-
-	ShowReadyButton();
-	
-	SafeDestroy();
+	`Log_Debug("Cleanup" @ GetKFPC() @ GetKFPRI() == None? "" : GetKFPRI().PlayerName);
+	if (!CTI.DestroyRepInfo(GetKFPC()))
+	{
+		`Log_Debug("Cleanup (forced)");
+		SafeDestroy();
+	}
 }
 
-public reliable server function ServerSync()
+public function InitInventoryManager()
 {
-	`Log_Trace(`Location);
+	local InventoryManager PrevInventoryManger;
+	local InventoryManager NextInventoryManger;
 
-	PendingSync = false;
+	local KFInventoryManager PrevKFInventoryManger;
+	local KFInventoryManager NextKFInventoryManger;
 
-	if (bPendingDelete || bDeleteMe) return;
+	local Inventory Item;
 
-	if (SyncSize <= Recieved || WorldInfo.NetMode == NM_StandAlone)
+	`Log_Trace();
+
+	if (GetKFPRI() == None || !KFPRI.bHasSpawnedIn || KFPC.Pawn == None)
 	{
-		ClientSyncFinished();
+		`Log_Debug("Wait for spawn (InventoryManager)");
+		SetTimer(1.0f, false, nameof(InitInventoryManager));
+		return;
+	}
 
-		if (!CTI.DestroyRepLink(Controller(Owner)))
-		{
-			SafeDestroy();
-		}
+	PrevInventoryManger = KFPC.Pawn.InvManager;
+
+	KFPC.Pawn.InventoryManagerClass = InventoryManager;
+	NextInventoryManger = Spawn(KFPC.Pawn.InventoryManagerClass, KFPC.Pawn);
+	CTI_InventoryManager(NextInventoryManger).Initialize(Self);
+
+	if (NextInventoryManger == None)
+	{
+		`Log_Error("Can't spawn" @ String(KFPC.Pawn.InventoryManagerClass));
+		ServerFinished();
+		return;
+	}
+
+	KFPC.Pawn.InvManager = NextInventoryManger;
+	KFPC.Pawn.InvManager.SetupFor(KFPC.Pawn);
+
+	if (PrevInventoryManger == None)
+	{
+		KFPC.Pawn.AddDefaultInventory();
 	}
 	else
 	{
-		if (Recieved < RemoveItems.Length)
+		for (Item = PrevInventoryManger.InventoryChain; Item != None; Item = PrevInventoryManger.InventoryChain)
 		{
-			ClientSync(RemoveItems[Recieved++], true);
-		}
-		else
-		{
-			ClientSync(AddItems[Recieved++ - RemoveItems.Length], false);
+			PrevInventoryManger.RemoveFromInventory(Item);
+			NextInventoryManger.AddInventory(Item);
 		}
 	}
+
+	PrevKFInventoryManger = KFInventoryManager(PrevInventoryManger);
+	NextKFInventoryManger = KFInventoryManager(NextInventoryManger);
+
+	if (PrevKFInventoryManger != None && NextKFInventoryManger != None)
+	{
+		NextKFInventoryManger.GrenadeCount = PrevKFInventoryManger.GrenadeCount;
+	}
+
+	PrevKFInventoryManger.InventoryChain = None;
+	PrevKFInventoryManger.Destroy();
+
+	`Log_Debug("InventoryManager initialized");
+
+	ServerFinished();
+}
+
+private simulated function NotifyWaitingGRI()
+{
+	if (!IsTimerActive(nameof(KeepNotification)))
+	{
+		SetTimer(0.1f, true, nameof(KeepNotification));
+	}
+
+	NotificationHeaderText = LocalMessage.static.GetLocalizedString(LogLevel, CTI_WaitingGRI);
+	NotificationLeftText   = String(WaitingGRI) $ LocalMessage.static.GetLocalizedString(LogLevel, CTI_SecondsShort);
+	NotificationRightText  = LocalMessage.static.GetLocalizedString(LogLevel, CTI_PleaseWait);
+	NotificationPercent    = 0;
+	KeepNotification();
+}
+
+private simulated function NotifyProgress(int Value, int Size)
+{
+	if (!IsTimerActive(nameof(KeepNotification)))
+	{
+		SetTimer(0.1f, true, nameof(KeepNotification));
+	}
+
+	NotificationHeaderText  = LocalMessage.static.GetLocalizedString(LogLevel, CTI_SyncItems);
+	NotificationLeftText    = Value @ "/" @ Size;
+	NotificationRightText   = LocalMessage.static.GetLocalizedString(LogLevel, CTI_PleaseWait);
+	NotificationPercent     = (float(Value) / float(Size)) * 100;
+	KeepNotification();
+}
+
+private simulated function NotifyIncompatibleGRI()
+{
+	WriteToChatLocalized(
+		CTI_IncompatibleGRI,
+		class'KFLocalMessage'.default.InteractionColor,
+		String(GRI.class));
+	WriteToChatLocalized(
+		CTI_IncompatibleGRIWarning,
+		class'KFLocalMessage'.default.InteractionColor);
+}
+
+private simulated function NotifyNoneGRI()
+{
+	WriteToChatLocalized(
+		CTI_NoneGRI,
+		class'KFLocalMessage'.default.InteractionColor);
+	WriteToChatLocalized(
+		CTI_NoneGRIWarning,
+		class'KFLocalMessage'.default.InteractionColor);
 }
 
 defaultproperties
@@ -236,5 +580,12 @@ defaultproperties
 	bSkipActorPropertyReplication = false
 
 	PendingSync = false
-	Recieved    = 0
+
+	NotificationPercent    = 0
+	WaitingGRI             = 0
+	WaitingGRIThreshold    = 15
+	WaitingGRILimit        = 30
+
+	ClientReady = false
+	ServerReady = false
 }

CTI/Classes/CTI_WeapDef_AutoTurret.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_AutoTurret extends KFWeapDef_AutoTurret
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_AutoTurret'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_AutoTurret"
+}

CTI/Classes/CTI_WeapDef_BladedPistol.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_BladedPistol extends KFWeapDef_BladedPistol
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_BladedPistol'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Pistol_Bladed"
+}

CTI/Classes/CTI_WeapDef_Blunderbuss.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_Blunderbuss extends KFWeapDef_Blunderbuss
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_Blunderbuss'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Pistol_Blunderbuss"
+}

CTI/Classes/CTI_WeapDef_ChainBat.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_ChainBat extends KFWeapDef_ChainBat
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_ChainBat'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Blunt_ChainBat"
+}

CTI/Classes/CTI_WeapDef_ChiappaRhino.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_ChiappaRhino extends KFWeapDef_ChiappaRhino
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_ChiappaRhino'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Pistol_ChiappaRhino"
+}

CTI/Classes/CTI_WeapDef_ChiappaRhinoDual.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_ChiappaRhinoDual extends KFWeapDef_ChiappaRhinoDual
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_ChiappaRhinoDual'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Pistol_ChiappaRhinoDual"
+}

CTI/Classes/CTI_WeapDef_CompoundBow.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_CompoundBow extends KFWeapDef_CompoundBow
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_CompoundBow'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Bow_CompoundBow"
+}

CTI/Classes/CTI_WeapDef_Doshinegun.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_Doshinegun extends KFWeapDef_Doshinegun
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_Doshinegun'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_AssaultRifle_Doshinegun"
+}

CTI/Classes/CTI_WeapDef_DualBladed.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_DualBladed extends KFWeapDef_DualBladed
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_DualBladed'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Pistol_DualBladed"
+}

CTI/Classes/CTI_WeapDef_FAMAS.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_FAMAS extends KFWeapDef_FAMAS
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_FAMAS'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_AssaultRifle_FAMAS"
+}

CTI/Classes/CTI_WeapDef_G18.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_G18 extends KFWeapDef_G18
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_G18'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_SMG_G18"
+}

CTI/Classes/CTI_WeapDef_G36C.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_G36C extends KFWeapDef_G36C
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_G36C'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_AssaultRifle_G36C"
+}

CTI/Classes/CTI_WeapDef_GravityImploder.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_GravityImploder extends KFWeapDef_GravityImploder
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_GravityImploder'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_GravityImploder"
+}

CTI/Classes/CTI_WeapDef_HVStormCannon.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_HVStormCannon extends KFWeapDef_HVStormCannon
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_HVStormCannon'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_HVStormCannon"
+}

CTI/Classes/CTI_WeapDef_IonThruster.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_IonThruster extends KFWeapDef_IonThruster
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_IonThruster'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Edged_IonThruster"
+}

CTI/Classes/CTI_WeapDef_MG3.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_MG3 extends KFWeapDef_MG3
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_MG3'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_LMG_MG3"
+}

CTI/Classes/CTI_WeapDef_Mine_Reconstructor.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_Mine_Reconstructor extends KFWeapDef_Mine_Reconstructor
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_Mine_Reconstructor'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Mine_Reconstructor"
+}

CTI/Classes/CTI_WeapDef_Minigun.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_Minigun extends KFWeapDef_Minigun
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_Minigun'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Minigun"
+}

CTI/Classes/CTI_WeapDef_MosinNagant.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_MosinNagant extends KFWeapDef_MosinNagant
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_MosinNagant'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Rifle_MosinNagant"
+}

CTI/Classes/CTI_WeapDef_ParasiteImplanter.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_ParasiteImplanter extends KFWeapDef_ParasiteImplanter
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_ParasiteImplanter'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Rifle_ParasiteImplanter"
+}

CTI/Classes/CTI_WeapDef_Pistol_DualG18.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_Pistol_DualG18 extends KFWeapDef_Pistol_DualG18
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_Pistol_DualG18'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Pistol_DualG18"
+}

CTI/Classes/CTI_WeapDef_Pistol_G18C.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_Pistol_G18C extends KFWeapDef_Pistol_G18C
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_Pistol_G18C'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Pistol_G18C"
+}

CTI/Classes/CTI_WeapDef_Rifle_FrostShotgunAxe.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_Rifle_FrostShotgunAxe extends KFWeapDef_Rifle_FrostShotgunAxe
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_Rifle_FrostShotgunAxe'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Rifle_FrostShotgunAxe"
+}

CTI/Classes/CTI_WeapDef_Scythe.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_Scythe extends KFWeapDef_Scythe
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_Scythe'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Edged_Scythe"
+}

CTI/Classes/CTI_WeapDef_Shotgun_S12.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_Shotgun_S12 extends KFWeapDef_Shotgun_S12
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_Shotgun_S12'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Shotgun_S12"
+}

CTI/Classes/CTI_WeapDef_ShrinkRayGun.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_ShrinkRayGun extends KFWeapDef_ShrinkRayGun
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_ShrinkRayGun'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_ShrinkRayGun"
+}

CTI/Classes/CTI_WeapDef_ThermiteBore.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_ThermiteBore extends KFWeapDef_ThermiteBore
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_ThermiteBore'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_RocketLauncher_ThermiteBore"
+}

CTI/Classes/CTI_WeapDef_ZedMKIII.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_ZedMKIII extends KFWeapDef_ZedMKIII
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_ZedMKIII'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_ZedMKIII"
+}

CTI/Classes/CTI_WeapDef_Zweihander.uc

@@ -0,0 +1,13 @@
+class CTI_WeapDef_Zweihander extends KFWeapDef_Zweihander
+	abstract;
+
+static function String GetItemLocalization(String KeyName)
+{
+	return class'KFGame.KFWeapDef_Zweihander'.static.GetItemLocalization(KeyName);
+}
+
+defaultproperties
+{
+	SharedUnlockId  = SCU_None
+	WeaponClassPath = "CTI.CTI_Weap_Edged_Zweihander"
+}

CTI/Classes/CTI_Weap_AssaultRifle_Doshinegun.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_AssaultRifle_Doshinegun extends KFWeap_AssaultRifle_Doshinegun;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_AssaultRifle_FAMAS.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_AssaultRifle_FAMAS extends KFWeap_AssaultRifle_FAMAS;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_AssaultRifle_G36C.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_AssaultRifle_G36C extends KFWeap_AssaultRifle_G36C;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_AutoTurret.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_AutoTurret extends KFWeap_AutoTurret;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Blunt_ChainBat.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Blunt_ChainBat extends KFWeap_Blunt_ChainBat;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Bow_CompoundBow.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Bow_CompoundBow extends KFWeap_Bow_CompoundBow;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Edged_IonThruster.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Edged_IonThruster extends KFWeap_Edged_IonThruster;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Edged_Scythe.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Edged_Scythe extends KFWeap_Edged_Scythe;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Edged_Zweihander.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Edged_Zweihander extends KFWeap_Edged_Zweihander;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_GravityImploder.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_GravityImploder extends KFWeap_GravityImploder;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_HVStormCannon.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_HVStormCannon extends KFWeap_HVStormCannon;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_LMG_MG3.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_LMG_MG3 extends KFWeap_LMG_MG3;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Mine_Reconstructor.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Mine_Reconstructor extends KFWeap_Mine_Reconstructor;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Minigun.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Minigun extends KFWeap_Minigun;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Pistol_Bladed.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Pistol_Bladed extends KFWeap_Pistol_Bladed;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Pistol_Blunderbuss.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Pistol_Blunderbuss extends KFWeap_Pistol_Blunderbuss;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Pistol_ChiappaRhino.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Pistol_ChiappaRhino extends KFWeap_Pistol_ChiappaRhino;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Pistol_ChiappaRhinoDual.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Pistol_ChiappaRhinoDual extends KFWeap_Pistol_ChiappaRhinoDual;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Pistol_DualBladed.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Pistol_DualBladed extends KFWeap_Pistol_DualBladed;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Pistol_DualG18.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Pistol_DualG18 extends KFWeap_Pistol_DualG18;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Pistol_G18C.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Pistol_G18C extends KFWeap_Pistol_G18C;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Rifle_FrostShotgunAxe.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Rifle_FrostShotgunAxe extends KFWeap_Rifle_FrostShotgunAxe;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Rifle_MosinNagant.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Rifle_MosinNagant extends KFWeap_Rifle_MosinNagant;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Rifle_ParasiteImplanter.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Rifle_ParasiteImplanter extends KFWeap_Rifle_ParasiteImplanter;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_RocketLauncher_ThermiteBore.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_RocketLauncher_ThermiteBore extends KFWeap_RocketLauncher_ThermiteBore;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_SMG_G18.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_SMG_G18 extends KFWeap_SMG_G18;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_Shotgun_S12.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_Shotgun_S12 extends KFWeap_Shotgun_S12;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_ShrinkRayGun.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_ShrinkRayGun extends KFWeap_ShrinkRayGun;
+
+defaultproperties
+{
+
+}

CTI/Classes/CTI_Weap_ZedMKIII.uc

@@ -0,0 +1,6 @@
+class CTI_Weap_ZedMKIII extends KFWeap_ZedMKIII;
+
+defaultproperties
+{
+
+}

CTI/Classes/Helper.uc

@@ -1,83 +0,0 @@
-class Helper extends Object;
-
-private delegate int ByPrice(class<KFWeaponDefinition> A, class<KFWeaponDefinition> B)
-{
-	return A.default.BuyPrice > B.default.BuyPrice ? -1 : 0;
-}
-
-public static simulated function ModifyTrader(
-	KFGameReplicationInfo KFGRI,
-	Array<class<KFWeaponDefinition> > RemoveItems,
-	Array<class<KFWeaponDefinition> > AddItems,
-	bool ReplaceMode)
-{
-	local KFGFxObject_TraderItems TraderItems;
-	local STraderItem Item;
-	local class<KFWeaponDefinition> WeapDef;
-	local Array<class<KFWeaponDefinition> > WeapDefs;
-	local int Index;
-	local int MaxItemID;
-	
-	if (KFGRI == None) return;
-	
-	TraderItems = KFGFxObject_TraderItems(DynamicLoadObject(KFGRI.TraderItemsPath, class'KFGFxObject_TraderItems'));
-	
-	if (!ReplaceMode)
-	{
-		foreach TraderItems.SaleItems(Item)
-		{
-			if (Item.WeaponDef != None && RemoveItems.Find(Item.WeaponDef) == INDEX_NONE)
-			{
-				WeapDefs.AddItem(Item.WeaponDef);
-			}
-		}
-	}
-	
-	for (Index = 0; Index < AddItems.Length; Index++)
-		WeapDefs.AddItem(AddItems[Index]);
-	
-	WeapDefs.Sort(ByPrice);
-	
-	TraderItems.SaleItems.Length = 0;
-	MaxItemID = 0;
-	foreach WeapDefs(WeapDef)
-	{
-		Item.WeaponDef = WeapDef;
-		Item.ItemID = ++MaxItemID;
-		TraderItems.SaleItems.AddItem(Item);
-	}
-
-	TraderItems.SetItemsInfo(TraderItems.SaleItems);
-	
-	KFGRI.TraderItems = TraderItems;
-}
-
-public static simulated function PreloadContent(Array<class<KFWeaponDefinition> > WeapDefs)
-{
-	local class<KFWeaponDefinition> WeapDef;
-	
-	foreach WeapDefs(WeapDef)
-	{
-		PreloadWeapon(WeapDef);
-	}
-}
-
-public static simulated function PreloadWeapon(class<KFWeaponDefinition> WeapDef)
-{
-	local class<KFWeapon> KFW;
-	
-	KFW = class<KFWeapon> (DynamicLoadObject(WeapDef.default.WeaponClassPath, class'Class'));
-	if (KFW != None)
-	{
-		// This doesn't seem to have any effect right now,
-		// so we're forced to use a workaround: CTI_RepInfo.ServerPreloadWeaponWorkaround()
-		// But I still leave it for the future
-		// in the hope that someday we can preload weapon models using this function
-		class'KFWeapon'.static.TriggerAsyncContentLoad(KFW);
-	}
-}
-
-defaultproperties
-{
-	
-}

CTI/Classes/KFW_Access.uc

@@ -0,0 +1,12 @@
+class KFW_Access extends Object
+	within KFWeapon;
+
+public function KFW_StartLoadWeaponContent()
+{
+	StartLoadWeaponContent();
+}
+
+defaultproperties
+{
+
+}

CTI/Classes/Mut.uc

@@ -0,0 +1,60 @@
+class Mut extends KFMutator;
+
+var private CTI CTI;
+
+public simulated function bool SafeDestroy()
+{
+	return (bPendingDelete || bDeleteMe || Destroy());
+}
+
+public event PreBeginPlay()
+{
+	Super.PreBeginPlay();
+
+	if (WorldInfo.NetMode == NM_Client) return;
+
+	foreach WorldInfo.DynamicActors(class'CTI', CTI)
+	{
+		break;
+	}
+
+	if (CTI == None)
+	{
+		CTI = WorldInfo.Spawn(class'CTI');
+	}
+
+	if (CTI == None)
+	{
+		`Log_Base("FATAL: Can't Spawn 'CTI'");
+		SafeDestroy();
+	}
+}
+
+public function AddMutator(Mutator M)
+{
+	if (M == Self) return;
+
+	if (M.Class == Class)
+		Mut(M).SafeDestroy();
+	else
+		Super.AddMutator(M);
+}
+
+public function NotifyLogin(Controller C)
+{
+	CTI.NotifyLogin(C);
+
+	Super.NotifyLogin(C);
+}
+
+public function NotifyLogout(Controller C)
+{
+	CTI.NotifyLogout(C);
+
+	Super.NotifyLogout(C);
+}
+
+DefaultProperties
+{
+	GroupNames.Add("TraderItems")
+}

CTI/Classes/OfficialWeapons.uc

@@ -0,0 +1,43 @@
+class OfficialWeapons extends Object
+	config(CTI);
+
+const Trader = class'Trader';
+const DefaultComment = "Auto-generated list of official weapons for your convenience, copy-paste ready";
+
+var private config String Comment;
+var private config Array<String> Item;
+
+private delegate int ByName(String A, String B)
+{
+	return A > B ? -1 : 0;
+}
+
+public static function Update(bool Enabled)
+{
+	local Array<class<KFWeaponDefinition> > KFWeapDefs;
+	local class<KFWeaponDefinition> KFWeapDef;
+
+	if (!Enabled) return;
+
+	KFWeapDefs = Trader.static.GetTraderWeapDefs();
+
+	if (default.Item.Length != KFWeapDefs.Length || default.Comment != DefaultComment)
+	{
+		default.Comment = DefaultComment;
+		default.Item.Length = 0;
+
+		foreach KFWeapDefs(KFWeapDef)
+		{
+			default.Item.AddItem(KFWeapDef.GetPackageName() $ "." $ KFWeapDef);
+		}
+
+		default.Item.Sort(ByName);
+
+		StaticSaveConfig();
+	}
+}
+
+defaultproperties
+{
+
+}

CTI/Classes/RemoveItems.uc

@@ -2,7 +2,9 @@ class RemoveItems extends Object
 	dependson(CTI)
 	config(CTI);
 
-var public  config bool bAll;
+var public  config bool bALL;
+var public  config bool bHRG;
+var public  config bool bDLC;
 var private config Array<String> Item;
 
 public static function InitConfig(int Version, int LatestVersion)
@@ -12,6 +14,10 @@ public static function InitConfig(int Version, int LatestVersion)
 		case `NO_CONFIG:
 			ApplyDefault();
 
+		case 2:
+			default.bHRG = false;
+			default.bDLC = false;
+
 		default: break;
 	}
 
@@ -23,42 +29,66 @@ public static function InitConfig(int Version, int LatestVersion)
 
 private static function ApplyDefault()
 {
-	default.bAll = false;
+	default.bALL = false;
+	default.bHRG = false;
+	default.bDLC = false;
 	default.Item.Length = 0;
-	default.Item.AddItem("KFGame.KFWeapDef_9mmDual");
+	default.Item.AddItem("KFGame.SomeWeapon");
 }
 
 public static function Array<class<KFWeaponDefinition> > Load(E_LogLevel LogLevel)
 {
 	local Array<class<KFWeaponDefinition> > ItemList;
-	local class<KFWeaponDefinition> ItemClass;
+	local class<KFWeaponDefinition> ItemWeapDef;
+	local class<KFWeapon> ItemWeapon;
 	local String ItemRaw;
 	local int    Line;
 
 	`Log_Info("Load items to remove:");
-	if (default.bAll)
+	if (default.bALL)
 	{
 		`Log_Info("Remove all default items");
 	}
 	else
 	{
+		if (default.bHRG)
+		{
+			`Log_Info("Remove all HRG items");
+		}
+		if (default.bDLC)
+		{
+			`Log_Info("Remove all DLC items");
+		}
+
 		foreach default.Item(ItemRaw, Line)
 		{
-			ItemClass = class<KFWeaponDefinition>(DynamicLoadObject(ItemRaw, class'Class'));
-			if (ItemClass == None)
+			ItemWeapDef = class<KFWeaponDefinition>(DynamicLoadObject(ItemRaw, class'Class'));
+			if (ItemWeapDef == None)
 			{
-				`Log_Warn("[" $ Line + 1 $ "]" @ "Can't load item class:" @ ItemRaw);
+				`Log_Warn("[" $ Line + 1 $ "]" @ "Can't load weapon definition:" @ ItemRaw);
+				continue;
 			}
-			else
+
+			ItemWeapon = class<KFWeapon>(DynamicLoadObject(ItemWeapDef.default.WeaponClassPath, class'Class'));
+			if (ItemWeapon == None)
 			{
-				ItemList.AddItem(ItemClass);
-				`Log_Debug("[" $ Line + 1 $ "]" @ "Loaded successfully:" @ ItemRaw);
+				`Log_Warn("[" $ Line + 1 $ "]" @ "Can't load weapon:" @ ItemWeapDef.default.WeaponClassPath);
+				continue;
 			}
+
+			if (ItemList.Find(ItemWeapDef) != INDEX_NONE)
+			{
+				`Log_Warn("[" $ Line + 1 $ "]" @ "Duplicate item:" @ ItemRaw @ "(skip)");
+				continue;
+			}
+
+			ItemList.AddItem(ItemWeapDef);
+			`Log_Debug("[" $ Line + 1 $ "]" @ "Loaded successfully:" @ ItemRaw);
 		}
 
 		if (ItemList.Length == default.Item.Length)
 		{
-			`Log_Info("Items to remove list loaded successfully (" $ default.Item.Length @ "entries)");
+			`Log_Info("Items to remove list loaded successfully (" $ ItemList.Length @ "entries)");
 		}
 		else
 		{

CTI/Classes/Trader.uc

@@ -0,0 +1,222 @@
+class Trader extends Object
+	abstract;
+
+// Bug:
+// The wrong weapon is purchased if the index is greater than 256 😡
+// Some greedy guy saved 3 bytes for no reason again
+const ITEMS_LIMIT = 256;
+
+private delegate int ByPrice(class<KFWeaponDefinition> A, class<KFWeaponDefinition> B)
+{
+	return A.default.BuyPrice > B.default.BuyPrice ? -1 : 0;
+}
+
+public static function KFGFxObject_TraderItems GetTraderItems(optional KFGameReplicationInfo KFGRI = None, optional E_LogLevel LogLevel = LL_Trace)
+{
+	local String TraderItemsPath;
+
+	if (KFGRI == None)
+	{
+		TraderItemsPath = class'KFGameReplicationInfo'.default.TraderItemsPath;
+	}
+	else
+	{
+		TraderItemsPath = KFGRI.TraderItemsPath;
+	}
+
+	return KFGFxObject_TraderItems(DynamicLoadObject(TraderItemsPath, class'KFGFxObject_TraderItems'));
+}
+
+public static function Array<class<KFWeaponDefinition> > GetTraderWeapDefs(optional KFGameReplicationInfo KFGRI = None, optional E_LogLevel LogLevel = LL_Trace)
+{
+	local Array<class<KFWeaponDefinition> > KFWeapDefs;
+	local KFGFxObject_TraderItems TraderItems;
+	local STraderItem Item;
+
+	TraderItems = GetTraderItems(KFGRI, LogLevel);
+
+	foreach TraderItems.SaleItems(Item)
+	{
+		if (Item.WeaponDef != None)
+		{
+			KFWeapDefs.AddItem(Item.WeaponDef);
+		}
+	}
+
+	return KFWeapDefs;
+}
+
+public static function Array<class<KFWeapon> > GetTraderWeapons(optional KFGameReplicationInfo KFGRI = None, optional E_LogLevel LogLevel = LL_Trace)
+{
+	local Array<class<KFWeapon> > KFWeapons;
+	local class<KFWeapon> KFWeapon;
+	local KFGFxObject_TraderItems TraderItems;
+	local STraderItem Item;
+
+	TraderItems = GetTraderItems(KFGRI, LogLevel);
+
+	foreach TraderItems.SaleItems(Item)
+	{
+		if (Item.WeaponDef != None)
+		{
+			KFWeapon = class<KFWeapon> (DynamicLoadObject(Item.WeaponDef.default.WeaponClassPath, class'Class'));
+			if (KFWeapon != None)
+			{
+				KFWeapons.AddItem(KFWeapon);
+			}
+		}
+	}
+
+	return KFWeapons;
+}
+
+public static function Array<class<KFWeaponDefinition> > GetTraderWeapDefsDLC(KFGameReplicationInfo KFGRI, E_LogLevel LogLevel)
+{
+	local KFGFxObject_TraderItems TraderItems;
+	local STraderItem Item;
+	local Array<class<KFWeaponDefinition> > WeapDefs;
+
+	`Log_TraceStatic();
+
+	TraderItems = GetTraderItems(KFGRI, LogLevel);
+
+	foreach TraderItems.SaleItems(Item)
+	{
+		if (Item.WeaponDef != None && Item.WeaponDef.default.SharedUnlockId != SCU_None)
+		{
+			WeapDefs.AddItem(Item.WeaponDef);
+		}
+	}
+
+	return WeapDefs;
+}
+
+public static simulated function Array< class<KFWeaponDefinition> > GenerateWeapDefList(
+	KFGameReplicationInfo KFGRI,
+	const out Array<class<KFWeaponDefinition> > RemoveItems,
+	const out Array<class<KFWeaponDefinition> > AddItems,
+	bool RemoveAll,
+	bool RemoveHRG,
+	bool RemoveDLC,
+	bool bDisableItemLimitCheck,
+	E_LogLevel LogLevel)
+{
+	local KFGFxObject_TraderItems TraderItems;
+	local STraderItem Item;
+	local Array< class<KFWeaponDefinition> > WeapDefs;
+	local int Index;
+
+	`Log_TraceStatic();
+
+	TraderItems = GetTraderItems(KFGRI, LogLevel);
+
+	if (!RemoveAll)
+	{
+		foreach TraderItems.SaleItems(Item)
+		{
+			if (Item.WeaponDef != None
+			&& RemoveItems.Find(Item.WeaponDef) == INDEX_NONE
+			&& (!RemoveHRG || (RemoveHRG && InStr(Item.WeaponDef, "_HRG", true) == INDEX_NONE))
+			&& (!RemoveDLC || (RemoveDLC && Item.WeaponDef.default.SharedUnlockId == SCU_None))
+			&& WeaponClassIsUnique(Item.WeaponDef.default.WeaponClassPath, AddItems, LogLevel))
+			{
+				WeapDefs.AddItem(Item.WeaponDef);
+			}
+		}
+	}
+
+	for (Index = 0; Index < AddItems.Length; ++Index)
+	{
+		if (WeaponClassIsUnique(AddItems[Index].default.WeaponClassPath, WeapDefs, LogLevel))
+		{
+			WeapDefs.AddItem(AddItems[Index]);
+		}
+	}
+
+	WeapDefs.Sort(ByPrice);
+
+	if (!bDisableItemLimitCheck && WeapDefs.Length > ITEMS_LIMIT)
+	{
+		`Log_Warn("The total number of items has reached the limit (" $ ITEMS_LIMIT $ ")," @ (WeapDefs.Length - ITEMS_LIMIT) @ "items will not be added.");
+		`Log_Warn("Excluded items:");
+		for (Index = ITEMS_LIMIT; Index < WeapDefs.Length; ++Index)
+		{
+			`Log_Warn("[" $ Index + 1 $ "]" @ String(WeapDefs[Index]));
+		}
+		WeapDefs.Length = ITEMS_LIMIT;
+	}
+
+	return WeapDefs;
+}
+
+public static simulated function OverwriteTraderItems(
+	KFGameReplicationInfo KFGRI,
+	const out Array<class<KFWeaponDefinition> > WeapDefs,
+	bool ApplyPatch,
+	E_LogLevel LogLevel)
+{
+	local CTI_GFxObject_TraderItems TraderItemsCTI;
+	local KFGFxObject_TraderItems TraderItemsDef;
+	local STraderItem Item;
+	local class<KFWeaponDefinition> WeapDef;
+	local int MaxItemID;
+
+	`Log_TraceStatic();
+
+	TraderItemsDef = GetTraderItems(KFGRI, LogLevel);
+	TraderItemsCTI = new class'CTI_GFxObject_TraderItems';
+	TraderItemsCTI.AllItems = TraderItemsDef.SaleItems;
+
+	TraderItemsCTI.SaleItems.Length = 0;
+	MaxItemID = 0;
+
+	`Log_Debug("Trader Items:");
+	foreach WeapDefs(WeapDef)
+	{
+		Item.WeaponDef = WeapDef;
+		Item.ItemID = MaxItemID++;
+		TraderItemsCTI.SaleItems.AddItem(Item);
+		TraderItemsCTI.AllItems.AddItem(Item);
+		`Log_Debug("[" $ MaxItemID $ "]" @ String(WeapDef));
+	}
+
+	foreach TraderItemsDef.SaleItems(Item)
+	{
+		Item.ItemID = MaxItemID++;
+		TraderItemsCTI.AllItems.AddItem(Item);
+	}
+
+	TraderItemsCTI.SetItemsInfo(TraderItemsCTI.SaleItems);
+	TraderItemsCTI.SetItemsInfo(TraderItemsCTI.AllItems);
+
+	if (ApplyPatch)
+	{
+		KFGRI.TraderItems = TraderItemsCTI;
+	}
+	else
+	{
+		KFGRI.TraderItems.SaleItems = TraderItemsCTI.SaleItems;
+	}
+}
+
+private static function bool WeaponClassIsUnique(String WeaponClassPath, const out Array<class<KFWeaponDefinition> > WeapDefs, E_LogLevel LogLevel)
+{
+	local class<KFWeaponDefinition> WeapDef;
+
+	`Log_TraceStatic();
+
+	foreach WeapDefs(WeapDef)
+	{
+		if (WeapDef.default.WeaponClassPath == WeaponClassPath)
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
+defaultproperties
+{
+
+}

CTI/Classes/Unlocker.uc

@@ -0,0 +1,194 @@
+class Unlocker extends Object
+	dependson(WeaponReplacements)
+	abstract;
+
+// TODO:
+// replace shopContainer (KFGFxTraderContainer_Store)
+// without replacing KFGFxMoviePlayer_Manager
+// but how? 🤔
+
+const Trader       = class'Trader';
+const Replacements = class'WeaponReplacements';
+
+public static function bool IsValidTypeUnlockDLC(String UnlockType, E_LogLevel LogLevel)
+{
+	`Log_TraceStatic();
+
+	switch (Locs(UnlockType))
+	{
+		case "true":
+		case "false":
+		case "auto":
+		case "replaceweapons":
+		case "replacefilter":
+			return true;
+	}
+
+	return false;
+}
+
+public static function bool UnlockDLC(
+	KFGameInfo KFGI,
+	KFGameReplicationInfo KFGRI,
+	String UnlockType,
+	out Array<class<KFWeaponDefinition> > WeapDefs,
+	out BoolWrapper DLCSkinUpdateRequired,
+	E_LogLevel LogLevel)
+{
+	`Log_TraceStatic();
+
+	switch (Locs(UnlockType))
+	{
+		case "true":
+		case "auto":
+			return Auto(KFGI, KFGRI, WeapDefs, DLCSkinUpdateRequired, LogLevel);
+
+		case "replaceweapons":
+			return ReplaceWeapons(KFGRI, WeapDefs, DLCSkinUpdateRequired, LogLevel);
+
+		case "replacefilter":
+			DLCSkinUpdateRequired.Value = false;
+			return ReplaceFilter(KFGI, LogLevel);
+
+		case "false":
+		default:
+			return false;
+	}
+}
+
+private static function bool Auto(
+	KFGameInfo KFGI,
+	KFGameReplicationInfo KFGRI,
+	out Array<class<KFWeaponDefinition> > WeapDefs,
+	out BoolWrapper DLCSkinUpdateRequired,
+	E_LogLevel LogLevel)
+{
+	`Log_TraceStatic();
+
+	if (KFGI == None) return false;
+
+	if (CustomGFxManager(KFGI))
+	{
+		return ReplaceWeapons(KFGRI, WeapDefs, DLCSkinUpdateRequired, LogLevel);
+	}
+	else
+	{
+		DLCSkinUpdateRequired.Value = false;
+		return ReplaceFilter(KFGI, LogLevel);
+	}
+}
+
+public static function bool CustomGFxManager(KFGameInfo KFGI)
+{
+	if (KFGameInfo_VersusSurvival(KFGI) != None)
+	{
+		return (KFGI.KFGFxManagerClass != class'KFGameInfo_VersusSurvival'.default.KFGFxManagerClass);
+	}
+	else
+	{
+		return (KFGI.KFGFxManagerClass != class'KFGameInfo'.default.KFGFxManagerClass);
+	}
+}
+
+private static function bool ReplaceWeapons(
+	KFGameReplicationInfo KFGRI,
+	out Array<class<KFWeaponDefinition> > WeapDefs,
+	out BoolWrapper DLCSkinUpdateRequired,
+	E_LogLevel LogLevel)
+{
+	local class<KFWeaponDefinition> WeapDef;
+	local class<KFWeaponDefinition> WeapDefReplacement;
+	local bool Unlock, PartialUnlock;
+	local int Index;
+
+	`Log_TraceStatic();
+
+	`Log_Debug("Unlock by replace weapons");
+
+	Unlock = false;
+	PartialUnlock = false;
+	DLCSkinUpdateRequired.Value = false;
+
+	for (Index = 0; Index < WeapDefs.Length; Index++)
+	{
+		WeapDef = WeapDefs[Index];
+
+		if (WeapDef.default.SharedUnlockId == SCU_None) continue;
+
+		WeapDefReplacement = PickReplacementWeapDefDLC(WeapDef, LogLevel);
+		if (WeapDefReplacement != None)
+		{
+			Unlock = true;
+			DLCSkinUpdateRequired.Value = true;
+			if (WeapDefs.Find(WeapDefReplacement) == INDEX_NONE)
+			{
+				WeapDefs[Index] = WeapDefReplacement;
+				`Log_Debug(WeapDef @ "replaced by" @ WeapDefReplacement);
+			}
+			else
+			{
+				WeapDefs.Remove(Index--, 1);
+				`Log_Debug("Skip already unlocked weapon:" @ WeapDef);
+			}
+		}
+		else
+		{
+			PartialUnlock = true;
+			`Log_Warn("Can't unlock item:" @ WeapDef @ "SharedUnlockId:" @ WeapDef.default.SharedUnlockId);
+		}
+	}
+
+	if (PartialUnlock)
+	{
+		`Log_Warn("Some DLCs are not unlocked. Try to set 'UnlockDLC=ReplaceFilter' or ask the author to update the mod");
+	}
+
+	return Unlock;
+}
+
+private static function class<KFWeaponDefinition> PickReplacementWeapDefDLC(class<KFWeaponDefinition> WeapDefDLC, E_LogLevel LogLevel)
+{
+	local SWeapReplace WeapReplace;
+
+	`Log_TraceStatic();
+
+	foreach Replacements.default.DLC(WeapReplace)
+	{
+		if (ClassIsChildOf(WeapReplace.WeapDef, WeapDefDLC))
+		{
+			return WeapReplace.WeapDef;
+		}
+	}
+
+	return None;
+}
+
+private static function bool ReplaceFilter(KFGameInfo KFGI, E_LogLevel LogLevel)
+{
+	`Log_TraceStatic();
+
+	`Log_Debug("Unlock by replace filter");
+
+	if (KFGI == None) return false;
+
+	if (CustomGFxManager(KFGI))
+	{
+		`Log_Warn("Custom KFGFxMoviePlayer_Manager detected:" @ String(KFGI.KFGFxManagerClass) $ ". There may be compatibility issues.");
+	}
+
+	if (KFGameInfo_VersusSurvival(KFGI) != None)
+	{
+		KFGI.KFGFxManagerClass = class'CTI_GFxMoviePlayer_Manager_Versus_DLC';
+	}
+	else
+	{
+		KFGI.KFGFxManagerClass = class'CTI_GFxMoviePlayer_Manager_DLC';
+	}
+
+	return true;
+}
+
+defaultproperties
+{
+
+}

CTI/Classes/WeaponReplacements.uc

@@ -0,0 +1,189 @@
+class WeaponReplacements extends Object;
+
+struct SWeapReplace
+{
+	var const class<KFWeaponDefinition> WeapDef;
+	var const class<KFWeaponDefinition> WeapDefParent;
+	var const class<KFWeapon>           Weap;
+	var const class<KFWeapon>           WeapParent;
+};
+
+var public const Array<SWeapReplace> DLC;
+
+defaultproperties
+{
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_AutoTurret',
+		WeapDefParent=class'KFWeapDef_AutoTurret',
+		Weap=class'CTI_Weap_AutoTurret',
+		WeapParent=class'KFWeap_AutoTurret'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_BladedPistol',
+		WeapDefParent=class'KFWeapDef_BladedPistol',
+		Weap=class'CTI_Weap_Pistol_Bladed',
+		WeapParent=class'KFWeap_Pistol_Bladed'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_Blunderbuss',
+		WeapDefParent=class'KFWeapDef_Blunderbuss',
+		Weap=class'CTI_Weap_Pistol_Blunderbuss',
+		WeapParent=class'KFWeap_Pistol_Blunderbuss'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_ChainBat',
+		WeapDefParent=class'KFWeapDef_ChainBat',
+		Weap=class'CTI_Weap_Blunt_ChainBat',
+		WeapParent=class'KFWeap_Blunt_ChainBat'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_ChiappaRhino',
+		WeapDefParent=class'KFWeapDef_ChiappaRhino',
+		Weap=class'CTI_Weap_Pistol_ChiappaRhino',
+		WeapParent=class'KFWeap_Pistol_ChiappaRhino'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_ChiappaRhinoDual',
+		WeapDefParent=class'KFWeapDef_ChiappaRhinoDual',
+		Weap=class'CTI_Weap_Pistol_ChiappaRhinoDual',
+		WeapParent=class'KFWeap_Pistol_ChiappaRhinoDual'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_CompoundBow',
+		WeapDefParent=class'KFWeapDef_CompoundBow',
+		Weap=class'CTI_Weap_Bow_CompoundBow',
+		WeapParent=class'KFWeap_Bow_CompoundBow'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_Doshinegun',
+		WeapDefParent=class'KFWeapDef_Doshinegun',
+		Weap=class'CTI_Weap_AssaultRifle_Doshinegun',
+		WeapParent=class'KFWeap_AssaultRifle_Doshinegun'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_DualBladed',
+		WeapDefParent=class'KFWeapDef_DualBladed',
+		Weap=class'CTI_Weap_Pistol_DualBladed',
+		WeapParent=class'KFWeap_Pistol_DualBladed'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_FAMAS',
+		WeapDefParent=class'KFWeapDef_FAMAS',
+		Weap=class'CTI_Weap_AssaultRifle_FAMAS',
+		WeapParent=class'KFWeap_AssaultRifle_FAMAS'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_G18',
+		WeapDefParent=class'KFWeapDef_G18',
+		Weap=class'CTI_Weap_SMG_G18',
+		WeapParent=class'KFWeap_SMG_G18'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_G36C',
+		WeapDefParent=class'KFWeapDef_G36C',
+		Weap=class'CTI_Weap_AssaultRifle_G36C',
+		WeapParent=class'KFWeap_AssaultRifle_G36C'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_GravityImploder',
+		WeapDefParent=class'KFWeapDef_GravityImploder',
+		Weap=class'CTI_Weap_GravityImploder',
+		WeapParent=class'KFWeap_GravityImploder'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_HVStormCannon',
+		WeapDefParent=class'KFWeapDef_HVStormCannon',
+		Weap=class'CTI_Weap_HVStormCannon',
+		WeapParent=class'KFWeap_HVStormCannon'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_IonThruster',
+		WeapDefParent=class'KFWeapDef_IonThruster',
+		Weap=class'CTI_Weap_Edged_IonThruster',
+		WeapParent=class'KFWeap_Edged_IonThruster'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_MG3',
+		WeapDefParent=class'KFWeapDef_MG3',
+		Weap=class'CTI_Weap_LMG_MG3',
+		WeapParent=class'KFWeap_LMG_MG3'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_Mine_Reconstructor',
+		WeapDefParent=class'KFWeapDef_Mine_Reconstructor',
+		Weap=class'CTI_Weap_Mine_Reconstructor',
+		WeapParent=class'KFWeap_Mine_Reconstructor'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_Minigun',
+		WeapDefParent=class'KFWeapDef_Minigun',
+		Weap=class'CTI_Weap_Minigun',
+		WeapParent=class'KFWeap_Minigun'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_MosinNagant',
+		WeapDefParent=class'KFWeapDef_MosinNagant',
+		Weap=class'CTI_Weap_Rifle_MosinNagant',
+		WeapParent=class'KFWeap_Rifle_MosinNagant'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_ParasiteImplanter',
+		WeapDefParent=class'KFWeapDef_ParasiteImplanter',
+		Weap=class'CTI_Weap_Rifle_ParasiteImplanter',
+		WeapParent=class'KFWeap_Rifle_ParasiteImplanter'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_Pistol_DualG18',
+		WeapDefParent=class'KFWeapDef_Pistol_DualG18',
+		Weap=class'CTI_Weap_Pistol_DualG18',
+		WeapParent=class'KFWeap_Pistol_DualG18'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_Pistol_G18C',
+		WeapDefParent=class'KFWeapDef_Pistol_G18C',
+		Weap=class'CTI_Weap_Pistol_G18C',
+		WeapParent=class'KFWeap_Pistol_G18C'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_Rifle_FrostShotgunAxe',
+		WeapDefParent=class'KFWeapDef_Rifle_FrostShotgunAxe',
+		Weap=class'CTI_Weap_Rifle_FrostShotgunAxe',
+		WeapParent=class'KFWeap_Rifle_FrostShotgunAxe'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_Scythe',
+		WeapDefParent=class'KFWeapDef_Scythe',
+		Weap=class'CTI_Weap_Edged_Scythe',
+		WeapParent=class'KFWeap_Edged_Scythe'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_Shotgun_S12',
+		WeapDefParent=class'KFWeapDef_Shotgun_S12',
+		Weap=class'CTI_Weap_Shotgun_S12',
+		WeapParent=class'KFWeap_Shotgun_S12'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_ShrinkRayGun',
+		WeapDefParent=class'KFWeapDef_ShrinkRayGun',
+		Weap=class'CTI_Weap_ShrinkRayGun',
+		WeapParent=class'KFWeap_ShrinkRayGun'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_ThermiteBore',
+		WeapDefParent=class'KFWeapDef_ThermiteBore',
+		Weap=class'CTI_Weap_RocketLauncher_ThermiteBore',
+		WeapParent=class'KFWeap_RocketLauncher_ThermiteBore'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_ZedMKIII',
+		WeapDefParent=class'KFWeapDef_ZedMKIII',
+		Weap=class'CTI_Weap_ZedMKIII',
+		WeapParent=class'KFWeap_ZedMKIII'
+	)})
+	DLC.Add({(
+		WeapDef=class'CTI_WeapDef_Zweihander',
+		WeapDefParent=class'KFWeapDef_Zweihander',
+		Weap=class'CTI_Weap_Edged_Zweihander',
+		WeapParent=class'KFWeap_Edged_Zweihander'
+	)})
+}

CTI/Classes/_Logger.uc

@@ -4,6 +4,7 @@ class _Logger extends Object
 enum E_LogLevel
 {
 	LL_WrongLevel,
+	LL_None,
 	LL_Fatal,
 	LL_Error,
 	LL_Warning,

CTI/Logger.uci

@@ -1,11 +1,15 @@
 // Logger
 `define Log_Tag 'CTI'
 
-`define Log_Base(msg, cond) `log(`msg `if(`cond), `cond`{endif},            `Log_Tag)
+`define LocationStatic        "`{ClassName}::" $ GetFuncName()
 
-`define Log_Fatal(msg)      `log("FATAL:" @ `msg, (LogLevel >= LL_Fatal),   `Log_Tag)
-`define Log_Error(msg)      `log("ERROR:" @ `msg, (LogLevel >= LL_Error),   `Log_Tag)
-`define Log_Warn(msg)       `log("WARN:"  @ `msg, (LogLevel >= LL_Warning), `Log_Tag)
-`define Log_Info(msg)       `log("INFO:"  @ `msg, (LogLevel >= LL_Info),    `Log_Tag)
-`define Log_Debug(msg)      `log("DEBUG:" @ `msg, (LogLevel >= LL_Debug),   `Log_Tag)
-`define Log_Trace(msg)      `log("TRACE:" @ `msg, (LogLevel >= LL_Trace),   `Log_Tag)
+`define Log_Base(msg, cond)  `log(`msg `if(`cond), `cond`{endif},            `Log_Tag)
+
+`define Log_Fatal(msg)       `log("FATAL:" @ `msg, (LogLevel >= LL_Fatal),   `Log_Tag)
+`define Log_Error(msg)       `log("ERROR:" @ `msg, (LogLevel >= LL_Error),   `Log_Tag)
+`define Log_Warn(msg)        `log("WARN:"  @ `msg, (LogLevel >= LL_Warning), `Log_Tag)
+`define Log_Info(msg)        `log("INFO:"  @ `msg, (LogLevel >= LL_Info),    `Log_Tag)
+`define Log_Debug(msg)       `log("DEBUG:" @ `msg, (LogLevel >= LL_Debug),   `Log_Tag)
+
+`define Log_Trace(msg)       `log("TRACE:" @ `Location       `if(`msg) @ `msg`{endif}, (LogLevel >= LL_Trace), `Log_Tag)
+`define Log_TraceStatic(msg) `log("TRACE:" @ `LocationStatic `if(`msg) @ `msg`{endif}, (LogLevel >= LL_Trace), `Log_Tag)

PublicationContent/description.txt

@@ -1,52 +1,116 @@
-[h1]Features[/h1]
-- remove and/or add items;
-- unlock DLC weapons;
-- correct items sorting (by price);
-- don't have to worry about adding new guns after each Tripware update.
+[img]https://img.shields.io/static/v1?logo=GitHub&labelColor=gray&color=blue&logoColor=white&label=&message=Open Source[/img] [img]https://img.shields.io/github/license/GenZmeY/KF2-CustomTraderInventory[/img] [img]https://img.shields.io/steam/downloads/2830826239[/img] [img]https://img.shields.io/steam/favorites/2830826239[/img] [img]https://img.shields.io/steam/update-date/2830826239[/img] [url=https://steamcommunity.com/sharedfiles/filedetails/changelog/2830826239][img]https://img.shields.io/github/v/tag/GenZmeY/KF2-CustomTraderInventory[/img][/url]
 
-[h1]Whitelisted?[/h1]
-No. This mod is not whitelisted and will unrank your server. Any XP gained will not be saved.
+[h1]📋 Description[/h1]
+Trader inventory management
 
-[h1]Usage (single player)[/h1]
-1. Subscribe to this mutator;
-2. Start KF2; 
-3. Open console (`) and input:
-[b]open KF-BioticsLab?Mutator=CTI.CTIMut[/b]
-(replace the map and add the parameters you need)
-4. <Enter>.
+[h1]✨ Features[/h1]
+[list]
+[*]Add items to trader
+[*]Remove items from trader
+[*]Preload weapon models (prevents lag when players buy weapons)
+[*]Unlock DLC weapons
+[*]Proper item sorting (by price)
+[*]Add an unlimited number of items to the trader
+[*]Players can sell weapons that were removed from the trader inventory
+[/list]
 
-[h1]Usage (server)[/h1]
-[b]Note:[/b] [i]If you don't understand what is written here, read the article [url=https://wiki.killingfloor2.com/index.php?title=Dedicated_Server_(Killing_Floor_2)][u]Dedicated Server (KF2 wiki)[/u][/url] before following these instructions.[/i]
+[h1]❌ Whitelisted?[/h1]
+No. This mod is not whitelisted and will de-rank your server. Any XP earned will not be saved.
 
-1. Open your [b]PCServer-KFEngine.ini[/b] / [b]LinuxServer-KFEngine.ini[/b];
-2. Add the following string to the [b][OnlineSubsystemSteamworks.KFWorkshopSteamworks][/b] section (create one if it doesn't exist):
-[b]ServerSubscribedWorkshopItems=2830826239[/b]
-3. Start the server and wait while the mutator is downloading;
-4. Add mutator to server start parameters: [b]?Mutator=CTI.CTIMut[/b] and restart the server.
+[h1]🎮 Usage (single player)[/h1]
+[olist]
+[*]Subscribe to this mutator.
+[*]Create a file [b](*)[/b]: [code]C:\Users\<username>\Documents\My Games\KillingFloor2\KFGame\Config\KFCTI.ini[/code]
+with content:
+[code][CTI.CTI]
+Version=0[/code]
+[*]Launch KF2.
+[*]Open console (~) and start any map with the mutator (this will generate the default KFCTI.ini content):
+[code]open KF-BioticsLab?Mutator=CTI.Mut[/code]
+[*]Close the game and configure the mutator (see [b]⚙️ Setup (KFCTI.ini)[/b] below).
+[*]Launch KF2 again, open the console, and start the game:
+[code]KF-BioticsLab?Game=KFGameContent.KFGameInfo_Survival?Difficulty=3?GameLength=2?Mutator=CTI.Mut[/code]
+(replace the map and set/add parameters you need).
+[/olist]
 
-[h1]Setup (KFCTI.ini)[/h1]
-Config will be created at the first start.
+[h1]🖥️ Usage (server)[/h1]
+[b]Note:[/b] [i]If this is unclear, first read: [url=https://wiki.killingfloor2.com/index.php?title=Dedicated_Server_(Killing_Floor_2)][u]Dedicated Server Guide (KF2 wiki)[/u][/url][/i]
+[olist]
+[*]Open [b]PCServer-KFEngine.ini[/b] / [b]LinuxServer-KFEngine.ini[/b].
+[*]Find [b][IpDrv.TcpNetDriver][/b] section and ensure line exists (add if missing):
+[code]DownloadManagers=OnlineSubsystemSteamworks.SteamWorkshopDownload[/code]
+(If there are several [b]DownloadManagers[/b] then the line above should be the first)
+[*]Add the following string to the [b][OnlineSubsystemSteamworks.KFWorkshopSteamworks][/b] section (create one if it doesn't exist):
+[code]ServerSubscribedWorkshopItems=2830826239[/code]
+[*]Start server and wait for mutator download.
+[*]When the download is complete, stop the server.
+[*]Create a file [b](*)[/b]: [code]<kf2-server>\KFGame\Config\KFCTI.ini[/code]
+with content:
+[code][CTI.CTI]
+Version=0[/code]
+[*]Add mutator to server start parameters: [code]?Mutator=CTI.Mut[/code] and start the server (this will generate the default KFCTI.ini content).
+[*]Stop the server and configure the mutator (see [b]⚙️ Setup (KFCTI.ini)[/b] below).
+[*]Start the server.
+[/olist]
 
-Set [b]UnlockDLC=True[/b] to allow all players to buy DLC weapons.
+[h1]🐞 (*) Buggy config initialization[/h1]
+This mutator (like many others) relies on UnrealScript's default values (0 for int type) to detect first-time use and generate a config.
+However, the game contains a bug that initializes unset values to random data, which can lead to incorrect settings or missing configs.
 
-Use [b][CTI.RemoveItems][/b] to remove items from the trader inventory.
-For example: [b]Item=KFGame.KFWeapDef_Mac10[/b] will remove MAC10 from sale.
-Set [b]bAll=True[/b] if you want to remove all items (can be useful if you want to set the entire sale list in the [b][CTI.AddItems][/b] section yourself).
+As a workaround, I recommend explicitly setting [b]Version=0[/b] in the config during the first initialization.
 
-Use [b][CTI.AddItems][/b] to add items to the trader inventory.
-For example: [b]Item=WeaponPack.KFWeapDef_XM25[/b] will add [url=https://steamcommunity.com/sharedfiles/filedetails/?id=1147408497]XM25[/url] to sale.
+Unfortunately, I can't fix this issue because it's a game engine problem (not the mutator's fault).
 
-[h1]Example config(s)[/h1]
-🔗 [url=https://steamcommunity.com/workshop/filedetails/discussion/2830826239/3409804177172972154/]Reinforcement Weapon Pack[/url]
-🔗 [url=https://steamcommunity.com/workshop/filedetails/discussion/2830826239/3409804177173363434/]Warface Arsenal[/url]
+[h1]⚙️ Setup (KFCTI.ini)[/h1]
+[list]
+[*][b]bDisableItemLimitCheck[/b]: The original game does not support more than 256 trader items: exceeding this limit causes issues. If this problem is solved (for example, if you are using a mutator that has already fixed this problem or by enabling [b]bApplyPatch[/b]) then it can be set [b]bDisableItemLimitCheck=True[/b] to remove the limit, otherwise it is better to leave it [b]False[/b].
 
-[h1]Notes[/h1]
-📌 Mutator does not contain custom weapons. You must have the required weapon packs in your subscriptions to be able to add them to the trader.
-📌 If you are using this mutator to add weapons, you should [b]not[/b] use mutators from weapon packs (just having them in subscriptions is enough).
-📌 Unlike [url=https://steamcommunity.com/sharedfiles/filedetails/?id=2193261170]DLC Weapon Unlocker[/url], a different method is used here.
-[url=https://steamcommunity.com/sharedfiles/filedetails/?id=2193261170]DLC Weapon Unlocker[/url] creates clones of DLC weapons and adds them to the trader. This allows you not to replace any classes in the game, so Hunter mutator has better compatibility with other mutators. However, those who have already purchased the DLC will not be able to use their skins on clones.
-CTI unlocks DLC weapons differently - it changes the trader filter allowing you to buy original DLC weapons without restrictions. Those who bought the DLC can use their skins and you don't need to update the mutator when new kf2 updates are released - unlocking will work with future weapons as well. However, when you set UnlockDLC=True CTI replaces the [b]KFGFxMoviePlayer_Manager[/b] class, so CTI may not be compatible with mods that replaces this class too. If you notice any compatibility issues, try turning off UnlockDLC.
-You can use this method or use a [url=https://steamcommunity.com/sharedfiles/filedetails/?id=2193261170]DLC Weapon Unlocker[/url] - choose what suits you best.
+[*]Set [b]bApplyPatch=True[/b] to fix some base classes of the game: this fixes problems when adding more than 256 items to a trader and will allow players to sell weapons that have been removed from trader inventory. Note that enabling this parameter replaces the following game classes: [b]KFAutoPurchaseHelper[/b], [b]KFInventoryManager[/b], [b]KFGFxMenu_Trader[/b], [b]KFGFxObject_TraderItems[/b]. There may be compatibility issues with mutators that also replace them.
 
-[h1]Sources[/h1]
-[url=https://github.com/GenZmeY/KF2-CustomTraderInventory]https://github.com/GenZmeY/KF2-CustomTraderInventory[/url] (GNU GPLv3)
+[*]Set [b]bPreloadContent=True[/b] to load weapon models in advance and have no lags when someone buys weapons. In some cases (usually if there is a lot of custom content), enabling preload may cause models to disappear. It is recommended to test how this setting affects the game for your server configuration and then decide whether to enable preloading or not.
+
+[*]Set [b]bOfficialWeaponsList=True[/b] to have an auto-updated list of all official weapons in the config (for a convenient copy-paste) or leave it [b]False[/b] if you want a clean config without unnecessary things.
+
+[*]Set [b]UnlockDLC[/b] to customize DLC weapon unlocks. Here are the possible values:
+[list]
+[*][b]False[/b] - disable DLC unlock.
+[*][b]ReplaceFilter[/b] - changes the trader filter allowing you to buy original DLC weapons without restrictions, unlocks future DLCs as well (no need to update this mutator). However, it replaces the [b]KFGFxMoviePlayer_Manager[/b] class so it may not be compatible with mods that also replace it.
+[*][b]ReplaceWeapons[/b] - replaces DLC weapons with their unlocked variants. Compatible with any mods, but may require a CTI update after the release of new DLC weapons.
+[*][b]True[/b] or [b]Auto[/b] - selects the most appropriate option automatically. Recommend putting CTI.Mut last in the mutator load queue if you use this.
+[/list]
+
+[*]Use [b][CTI.RemoveItems][/b] to remove items from the trader inventory.
+example: [b]Item=KFGame.KFWeapDef_Mac10[/b] will remove MAC10 from sale.
+
+[*]Set [b]bALL=True[/b] if you want to remove all items (can be useful if you want to set the entire sale list in the [b][CTI.AddItems][/b] section yourself).
+[*]Set [b]bHRG=True[/b] to remove HRG items.
+[*]Set [b]bDLC=True[/b] to remove DLC items.
+
+[*]Use [b][CTI.AddItems][/b] to add items to the trader inventory.
+example: [b]Item=WeaponPackExt.KFWeapDef_XM25[/b] will add XM25 to sale.
+[/list]
+
+[h1]📌 Notes[/h1]
+[list]
+[*]If you need an empty list anywhere (for example, you don't want to delete trader weapons), leave at least one line there:
+[b]Item=[/b]
+This is necessary to explicitly initialize the list (because of the bug mentioned above) to avoid initialization with incorrect values.
+[*]This mutator does not include custom weapons. You must have the required weapon packs in your subscriptions to be able to add them to the trader.
+[*]If you use this mutator to add weapons, avoid enabling mutators from weapon packs (having them in subscriptions is enough).
+[/list]
+
+[h1]🌍 Credits[/h1]
+[list]
+[*]The cat on the cover is Meawbin (original character by [url=https://x.com/horrormove]Cotton Valent[/url]).
+[/list]
+[b]Translators:[/b]
+[list]
+[*][url=https://steamcommunity.com/profiles/76561199126205919]cheungfatzong[/url] - Traditional [CHT] and Simplified [CHN] Chinese.
+[/list]
+
+[h1]☑️ Status: Completed[/h1]
+✔️ The mutator works with the current version of the game (v1150) and I have implemented everything I planned.
+⛔️ Development has stopped: I no longer have the time or motivation to maintain this mod. No further updates or bug fixes are planned.
+
+[h1]📜 Sources[/h1]
+https://github.com/GenZmeY/KF2-CustomTraderInventory [b](GNU GPLv3)[/b]

README.md

@@ -1,25 +1,28 @@
 # Custom Trader Inventory
 
 [![Steam Workshop](https://img.shields.io/static/v1?message=workshop&logo=steam&labelColor=gray&color=blue&logoColor=white&label=steam%20)](https://steamcommunity.com/sharedfiles/filedetails/?id=2830826239)
-[![Steam Subscriptions](https://img.shields.io/steam/subscriptions/2830826239)](https://steamcommunity.com/sharedfiles/filedetails/?id=2830826239)
+[![Steam Downloads](https://img.shields.io/steam/downloads/2830826239)](https://steamcommunity.com/sharedfiles/filedetails/?id=2830826239)
 [![Steam Favorites](https://img.shields.io/steam/favorites/2830826239)](https://steamcommunity.com/sharedfiles/filedetails/?id=2830826239)
-[![Steam Update Date](https://img.shields.io/steam/update-date/2830826239)](https://steamcommunity.com/sharedfiles/filedetails/?id=2830826239)
+[![MegaLinter](https://github.com/GenZmeY/KF2-CustomTraderInventory/actions/workflows/mega-linter.yml/badge.svg?branch=master)](https://github.com/GenZmeY/KF2-CustomTraderInventory/actions/workflows/mega-linter.yml)
 [![GitHub tag (latest by date)](https://img.shields.io/github/v/tag/GenZmeY/KF2-CustomTraderInventory)](https://github.com/GenZmeY/KF2-CustomTraderInventory/tags)
 [![GitHub](https://img.shields.io/github/license/GenZmeY/KF2-CustomTraderInventory)](LICENSE)
 
-# Description
-Add/Remove Items in the Trader's Inventory  
+## Description
+Trader inventory management  
 
-# Features
-- remove and/or add items;
+## Features
+- remove/add items to trader;
+- can preload weapon models (no lags when buying weapons);
 - unlock DLC weapons;
 - correct items sorting (by price);
-- don't have to worry about adding new guns after each Tripware update.
+- don't have to worry about adding new guns after each KF2 update;
+- add an unlimited number of items to the trader;
+- players can sell weapons excluded from trader inventory.
 
-# Usage & Setup
+## Usage & Setup
 [See steam workshop page](https://steamcommunity.com/sharedfiles/filedetails/?id=2830826239)
 
-# Build
+## Build
 **Note:** If you want to build/test/brew/publish a mutator without git-bash and/or scripts, follow [these instructions](https://tripwireinteractive.atlassian.net/wiki/spaces/KF2SW/pages/26247172/KF2+Code+Modding+How-to) instead of what is described here.
 1. Install [Killing Floor 2](https://store.steampowered.com/app/232090/Killing_Floor_2/), Killing Floor 2 - SDK and [git for windows](https://git-scm.com/download/win);
 2. open git-bash and go to any folder where you want to store sources:  
@@ -33,16 +36,9 @@ Add/Remove Items in the Trader's Inventory
 5. The compiled files will be here:  
 `C:\Users\<USERNAME>\Documents\My Games\KillingFloor2\KFGame\Unpublished\BrewedPC\Script\`
 
-# Testing
-Open git-bash in the source folder and run command:  
-`./tools/builder -t`  
-(or `./tools/builder -ct` if you haven't compiled the mutator yet)  
-
-A local single-user test will be launched with parameters from `builder.cfg` (edit this file if you want to test mutator with different parameters).
-
-# Bug reports
+## Bug reports
 If you find a bug, go to the [issue page](https://github.com/GenZmeY/KF2-CustomTraderInventory/issues) and check if there is a description of your bug. If not, create a new issue.  
 Describe what the bug looks like and how reproduce it.  
 
-# License
-[GNU GPLv3](LICENSE)  
+## License
+[![license](https://www.gnu.org/graphics/gplv3-with-text-136x68.png)](LICENSE)

builder.cfg

@@ -11,6 +11,15 @@ StripSource="True"
 PackageBuildOrder="CTI"
 
 
+### Brew parameters ###
+
+# Packages you want to brew using @peelz's patched KFEditor.
+# Useful for cases where regular brew doesn't put *.upk inside the package.
+# Specify them with a space as a separator,
+# The order doesn't matter
+PackagePeelzBrew=""
+
+
 ### Steam Workshop upload parameters ###
 
 # Mutators that will be uploaded to the workshop
@@ -30,7 +39,7 @@ Map="KF-Nuked"
 # Endless:        KFGameContent.KFGameInfo_Endless
 # Objective:      KFGameContent.KFGameInfo_Objective
 # Versus:         KFGameContent.KFGameInfo_VersusSurvival
-Game="KFGameContent.KFGameInfo_Endless"
+Game="KFGameContent.KFGameInfo_Survival"
 
 # Difficulty:
 # Normal:         0