public void RecruitAllPrisoners(bool ignorePartyLimit)
{
var currentlyRecruitingPrisoner = "";
try
{
var recruits = PartyVM?.MainPartyPrisoners?
.Where(x => !x.IsHero &&
x.IsRecruitablePrisoner && x.NumOfRecruitablePrisoners > 0).ToList();
if (PartyManagerSettings.Settings.RecruitPrisonersUseWhitelist)
{
recruits = recruits.Where(x =>
PartyManagerSettings.Settings.RecruitPrisonerBlackWhiteList.Contains(x.Name)).ToList();
}
else
{
recruits = recruits.Where(x =>
!PartyManagerSettings.Settings.RecruitPrisonerBlackWhiteList.Contains(x.Name)).ToList();
}
if (recruits?.Count > 0)
{
var freeUnitSlots = PartyScreenLogic.RightOwnerParty.PartySizeLimit - PartyScreenLogic.RightOwnerParty.NumberOfAllMembers;
var recruitCount = 0;
foreach (var troop in recruits)
{
currentlyRecruitingPrisoner = troop?.Name?.ToString();
if (freeUnitSlots > 0 || ignorePartyLimit)
{
var toBeRecruited = ignorePartyLimit ? troop.NumOfRecruitablePrisoners : Math.Min(freeUnitSlots, troop.NumOfRecruitablePrisoners);
for (int i = 0; i < toBeRecruited; i++)
{
PartyScreenLogic.PartyCommand command = new PartyScreenLogic.PartyCommand();
command.FillForRecruitTroop(PartyScreenLogic.PartyRosterSide.Right, troop.Type,
troop.Character, 1);
PartyScreenLogic.AddCommand(command);
}
GenericHelpers.LogDebug("RecruitAll", $"Recruited {toBeRecruited} {troop.Character.Name}");
recruitCount += toBeRecruited;
freeUnitSlots -= toBeRecruited;
}
}
ButtonClickRefresh(true, true);
}
else
{
GenericHelpers.LogMessage("No prisoners found to recruit");
}
}
catch (Exception ex)
{
GenericHelpers.LogException($"RecruitAllPrisoners UnitType({currentlyRecruitingPrisoner})", ex);
}
}
public static PartyManagerSettings LoadSettings()
{
if (!File.Exists(filePath))
{
return(CreateUpdateFile());
}
else
{
PartyManagerSettings settings;
using (FileStream fs = new FileStream(filePath, FileMode.Open))
{
try
{
settings = Serializer.Deserialize(fs) as PartyManagerSettings;
}
catch (Exception ex)
{
GenericHelpers.LogException("LoadSettings", ex);
settings = new PartyManagerSettings();
}
}
if (settings.Version != version)
{
settings = CreateUpdateFile(settings);
}
return(settings);
}
}
public void SortPartyScreen(SortType sortType = SortType.Default,
bool updateUI = true, bool rightTroops = true,
bool rightPrisoners = true, bool leftTroops = true, bool leftPrisoners = true)
{
try
{
if (!Validate(updateUI))
{
GenericHelpers.LogDebug("SortPartyScreen", "Sort validation failed");
return;
}
GenericHelpers.LogDebug("SortPartyScreen", "Sort Called");
SortPartyHelpers.SortPartyLogic(PartyScreenLogic, PartyVM, sortType, rightTroops, rightPrisoners, leftTroops, leftPrisoners);
if (updateUI)
{
InitializeTroopLists();
}
}
catch (Exception ex)
{
GenericHelpers.LogException("SortPartyScreen", ex);
}
}
public bool UpdateBlackWhiteList(PartyCharacterVM character, BlackWhiteListType listType)
{
try
{
List <string> targetList = null;
var unitName = character.Name;
var listName = "";
if (listType == BlackWhiteListType.Transfer && character.IsPrisoner && PartyScreenLogic.PrisonerTransferState == PartyScreenLogic.TransferState.TransferableWithTrade)
{
targetList = PartyManagerSettings.Settings.RansomPrisonerBlackWhiteList;
listName = "sell prisoners";
}
else if (listType == BlackWhiteListType.Transfer && character.IsPrisoner && PartyScreenLogic.PrisonerTransferState == PartyScreenLogic.TransferState.Transferable)
{
targetList = PartyManagerSettings.Settings.TransferPrisonerBlackWhiteList;
listName = "transfer prisoners";
}
else if (listType == BlackWhiteListType.Transfer && !character.IsPrisoner)
{
//targetList = PartyManagerSettings.Settings.TransferTroopsBlackWhiteList;
//listName = "transfer troops";
}
else if (listType == BlackWhiteListType.Recruit)
{
targetList = PartyManagerSettings.Settings.RecruitPrisonerBlackWhiteList;
listName = "recruit prisoners";
}
else if (listType == BlackWhiteListType.Upgrade)
{
targetList = PartyManagerSettings.Settings.UpgradeTroopsBlackWhiteList;
listName = "upgrade troops";
}
if (targetList == null)
{
return(true);
}
if (targetList.Contains(unitName))
{
GenericHelpers.LogMessage($"Removed {unitName} from {listName} filter list");
targetList.Remove(unitName);
}
else
{
GenericHelpers.LogMessage($"Added {unitName} to {listName} filter list");
targetList.Add(unitName);
}
PartyManagerSettings.Settings.SaveSettings();
return(false);
}
catch (Exception e)
{
GenericHelpers.LogException("UpdateBlackWhiteList", e);
}
return(true);
}
public static void AddPartyWidgets(GauntletPartyScreen partyScreen)
{
try
{
if (!PartyManagerSettings.Settings.HideUIWidgets)
{
var newLayer = new GauntletLayer(100, "GauntletLayer");
newLayer.InputRestrictions.SetInputRestrictions(true, InputUsageMask.All);
var partyManagerModVm = new PartyManagerVM(partyScreen.GetPartyVM(), partyScreen.GetPartyVM()?.GetPartyScreenLogic(), partyScreen);
newLayer?.LoadMovie("PartyManagerModScreen", (TaleWorlds.Library.ViewModel)partyManagerModVm);
CurrentInstance.WidgetsAdded = true;
partyScreen.AddLayer(newLayer);
GenericHelpers.LogDebug("AddPartyWidgets", "Party Widget Added");
}
else
{
GenericHelpers.LogDebug("AddPartyWidgets", "Skipped adding widgets");
}
}
catch (Exception ex)
{
GenericHelpers.LogException("AddPartyWidgets", ex);
}
}
protected override void OnApplicationTick(float dt)
{
base.OnApplicationTick(dt);
if (enableHotkey || enableRecruitUpgradeSort || enableSortTypeCycleHotkey)
{
string key = "";
try
{
//if (InputKey.LeftControl.IsDown()&& InputKey.P.IsDown())
//{
// PartyController.OpenSettings();
//}
if (Campaign.Current == null || !Campaign.Current.GameStarted || (!(ScreenManager.TopScreen is GauntletPartyScreen) || (!InputKey.LeftShift.IsDown()) && !InputKey.LeftControl.IsDown() && !InputKey.Minus.IsDown()))
{
return;
}
if ((enableHotkey && InputKey.S.IsDown()) || (enableRecruitUpgradeSort && InputKey.R.IsDown()) || (enableSortTypeCycleHotkey && InputKey.Minus.IsDown()))
{
var diff = (DateTime.Now.Ticks - lastHotkeyExecute) / TimeSpan.TicksPerMillisecond;
//Prevent the key from triggering more than once per tenth of a second
if (diff < 100)
{
return;
}
if (InputKey.Minus.IsDown() && enableSortTypeCycleHotkey)
{
key = "-";
PartyManagerSettings.Settings.CycleSortType();
}
//SortHotkey
if (InputKey.S.IsDown() && enableHotkey)
{
key = "S";
PartyController.CurrentInstance.SortPartyScreen();
}//RecruitSort
else if (InputKey.R.IsDown() && enableRecruitUpgradeSort)
{
key = "R";
PartyController.CurrentInstance.SortPartyScreen(SortType.RecruitUpgrade);
}
lastHotkeyExecute = DateTime.Now.Ticks;
}
}
catch (Exception ex)
{
lastHotkeyExecute = DateTime.Now.Ticks;
GenericHelpers.LogException($"Tick('{key}')", ex);
}
}
}
public static void ToggleUpgradePath(PartyCharacterVM vm, int upgradeIndex, bool split = false)
{
try
{
split = split && vm.IsUpgrade1Exists && vm.IsUpgrade2Exists;
string message = "";
var upgrade = PartyManagerSettings.Settings.SavedTroopUpgradePaths.FirstOrDefault(x => x.UnitName == vm.Character.Name.ToString());
if (upgrade != null)
{
if ((upgradeIndex == upgrade.TargetUpgrade && (split == upgrade.EvenSplit)) || (split && upgrade.EvenSplit))
{
PartyManagerSettings.Settings.SavedTroopUpgradePaths.Remove(upgrade);
message = $"Removed Upgrade Path for {vm.Character.Name.ToString()}";
}
else if (split)
{
upgrade.EvenSplit = true;
message = $"Changed Upgrade Path for {vm.Character.Name.ToString()} to be split evenly";
}
else
{
upgrade.EvenSplit = false;
upgrade.TargetUpgrade = upgradeIndex;
message = $"Changed Upgrade Path for {vm.Character.Name.ToString()}";
}
}
else
{
var newUpgrade = new SavedTroopUpgradePath()
{
UnitName = vm.Name,
TargetUpgrade = upgradeIndex,
EvenSplit = split
};
PartyManagerSettings.Settings.SavedTroopUpgradePaths.Add(newUpgrade);
if (split)
{
message = $"Added Split Upgrade Path for {vm.Character.Name.ToString()}";
}
else
{
message = $"Added Upgrade Path for {vm.Character.Name.ToString()}";
}
}
PartyManagerSettings.Settings.SaveSettings();
GenericHelpers.LogMessage(message);
}
catch (Exception e)
{
GenericHelpers.LogException("UpgradeAllTroops", e);
}
}
public static void UpdateBrushesPublic(this Widget widget, float dt)
{
try
{
GenericHelpers.GetPrivateMethod <Widget>("UpdateBrushes", widget)?.Invoke(widget, new object[] { dt });
}
catch (Exception ex)
{
GenericHelpers.LogException("UpdateBrushesPublic", ex);
}
}
protected override void OnSubModuleLoad()
{
base.OnSubModuleLoad();
try
{
enableHotkey = PartyManagerSettings.Settings.EnableHotkey;
enableAutoSort = PartyManagerSettings.Settings.EnableAutoSort;
enableRecruitUpgradeSort = PartyManagerSettings.Settings.EnableRecruitUpgradeSortHotkey;
enableSortTypeCycleHotkey = PartyManagerSettings.Settings.EnableSortTypeCycleHotkey;
new Harmony("mod.partymanager").PatchAll();
}
catch (Exception ex)
{
GenericHelpers.LogException("Patch Failed", ex);
}
}
public static MethodInfo GetMethod <T>(string methodName, T reflectionObject, BindingFlags bindingFlags)
{
if (reflectionObject == null)
{
return(null);
}
try
{
return(reflectionObject.GetType()?.GetMethod(methodName, bindingFlags));
}
catch (Exception ex)
{
GenericHelpers.LogException($"GetMethod({typeof(T)?.ToString()})", ex);
}
return(null);
}
protected override void OnBeforeInitialModuleScreenSetAsRoot()
{
base.OnBeforeInitialModuleScreenSetAsRoot();
try
{
GenericHelpers.LogMessage("Loaded PartyManager. Press CTRL+SHIFT+S in Party Screen to sort, CTRL+SHIFT+R to upgrade/recruit sort, CTRL+SHIFT+(Minus) to cycle sort types", "#ffa136FF");
if (!string.IsNullOrEmpty(PartyManagerSettings.Settings.NewFileMessage))
{
GenericHelpers.LogMessage(PartyManagerSettings.Settings.NewFileMessage);
}
}
catch (Exception ex)
{
GenericHelpers.LogException("OnBeforeInitialModuleScreenSetAsRoot", ex);
}
}
public bool TransferUnits(PartyCharacterVM troop, PMTransferType transferType)
{
try
{
if (troop == null || troop.Number == 0)
{
return(true);
}
int unitCount = 0;
switch (transferType)
{
case PMTransferType.All:
unitCount = troop.Number;
break;
case PMTransferType.Half:
unitCount = (int)Math.Round(troop.Number / 2f, MidpointRounding.AwayFromZero);
break;
case PMTransferType.Custom:
unitCount = Math.Min(troop.Number, PartyManagerSettings.Settings.CustomShiftTransferCount);
break;
}
if (unitCount == 0 || unitCount < 0)
{
return(true);
}
troop.OnTransfer(troop, -1, unitCount, troop.Side);
PartyVM.ExecuteRemoveZeroCounts();
return(false);
}
catch (Exception e)
{
GenericHelpers.LogException("TransferUnits", e);
}
return(true);
}
public static void OpenSettings()
{
try
{
if (settingsLayer == null || !settingsLayer.IsActive)
{
var screen = ScreenManager.TopScreen;
settingsLayer = new GauntletLayer(10000, "GauntletLayer");
settingsLayer.InputRestrictions.SetInputRestrictions(true, InputUsageMask.All);
var settingsVm = new PartyManagerSettingsVM(screen, settingsLayer);
settingsLayer?.LoadMovie("PartyManagerSettings", settingsVm);
screen.AddLayer(settingsLayer);
}
}
catch (Exception e)
{
GenericHelpers.LogException("OpenSettings", e);
}
}
public static MBBindingList <string> GetSelectableSortOrderStrings()
{
var sortTypes = new MBBindingList <string>();
try
{
foreach (var sort in Enum.GetValues(typeof(CustomSortOrder)))
{
if ((int)sort >= 0)
{
sortTypes.Add(sort.ToString());
}
}
}
catch (Exception ex)
{
GenericHelpers.LogException("PartyManagerSettings.GetSelectableSortOrders", ex);
}
return(sortTypes);
}
public PartyManagerSettings Clone()
{
try
{
//I feel dirty
PartyManagerSettings clone;
using (MemoryStream ms = new MemoryStream())
{
Serializer.Serialize(ms, this);
ms.Seek(0, SeekOrigin.Begin);
clone = Serializer.Deserialize(ms) as PartyManagerSettings;
}
return(clone);
}
catch (Exception ex)
{
GenericHelpers.LogException("PartyManagerSettings.Clone", ex);
}
return(null);
}
private static PartyManagerSettings CreateUpdateFile(PartyManagerSettings settings = null)
{
try
{
var newFileGenerated = false;
if (settings == null)
{
settings = new PartyManagerSettings();
newFileGenerated = true;
}
else
{
for (int i = settings.Version.Value; i < version; i++)
{
switch (i)
{
case 1:
settings.EnableHotkey = true;
settings.EnableAutoSort = true;
break;
case 2:
settings.EnableSortTypeCycleHotkey = true;
settings.EnableRecruitUpgradeSortHotkey = true;
break;
case 3:
settings.CavalryAboveFootmen = true;
settings.MeleeAboveArchers = true;
break;
}
}
settings.Version = version;
}
var saveDirectory = Path.GetDirectoryName(filePath);
if (!Directory.Exists(saveDirectory))
{
Directory.CreateDirectory(saveDirectory);
}
using (var fs = new FileStream(filePath, FileMode.Create))
{
Serializer.Serialize(fs, settings);
}
if (newFileGenerated)
{
var fullPath = Path.GetFullPath(filePath);
settings.NewFileMessage = $"PartyManager config generated at {fullPath}";
}
}
catch (Exception ex)
{
GenericHelpers.LogException("PartyManagerSettings.CreateUpdateFile", ex);
}
return(settings);
}
public void UpgradeAllTroops(bool customOnly = false)
{
var currentlyUpgradingUnit = "";
try
{
var upgrades = PartyVM?.MainPartyTroops?
.Where(x => !x.IsHero &&
((x.IsUpgrade1Available && !x.IsUpgrade1Insufficient) || (x.IsUpgrade2Available && !x.IsUpgrade2Insufficient))).ToList();
var upgradesCount = 0;
if (!PartyManagerSettings.Settings.DisableCustomUpgradePaths)
{
var splitTroops = PartyManagerSettings.Settings.SavedTroopUpgradePaths.Where(x => x.EvenSplit).Select(x => x.UnitName).ToList();
var customTroops = PartyManagerSettings.Settings.SavedTroopUpgradePaths.Where(x => !x.EvenSplit).Select(x => x.UnitName).ToList();
var splitUpgrades = upgrades.Where(x => splitTroops.Contains(x.Name.ToString())).ToList();
var customUpgrades = upgrades.Where(x => customTroops.Contains(x.Name.ToString())).ToList();
upgrades = upgrades.Where(x => !splitTroops.Contains(x.Name.ToString()) && !customTroops.Contains(x.Name.ToString())).ToList();
foreach (var troop in splitUpgrades)
{
currentlyUpgradingUnit = troop?.Character?.Name?.ToString();
var unitUpgrades = Math.Min(troop.NumOfTarget1UpgradesAvailable,
troop.NumOfTarget2UpgradesAvailable) / 2;
GenericHelpers.LogDebug("UpgradeAllTroops", $"Split {troop.Name.ToString()}: {unitUpgrades}");
var unitsUpgraded = false;
for (int i = 0; i < unitUpgrades; i++)
{
if (troop.IsUpgrade1Insufficient || troop.IsUpgrade2Insufficient || !troop.IsUpgrade1Available || !troop.IsUpgrade2Available)
{
break;
}
PartyScreenLogic.PartyCommand command1 = new PartyScreenLogic.PartyCommand();
PartyScreenLogic.PartyCommand command2 = new PartyScreenLogic.PartyCommand();
command1.FillForUpgradeTroop(PartyScreenLogic.PartyRosterSide.Right, troop.Type, troop.Character, 1,
PartyScreenLogic.PartyCommand.UpgradeTargetType.UpgradeTarget1);
var c1Valid = PartyScreenLogic.ValidateCommand(command1);
PartyScreenLogic.AddCommand(command1);
if (troop.IsUpgrade2Insufficient)
{
GenericHelpers.LogDebug("UpgradeAllTroops", $"Upgrade2 Insufficient");
break;
}
command2.FillForUpgradeTroop(PartyScreenLogic.PartyRosterSide.Right, troop.Type, troop.Character, 1,
PartyScreenLogic.PartyCommand.UpgradeTargetType.UpgradeTarget2);
var c2Valid = PartyScreenLogic.ValidateCommand(command1);
PartyScreenLogic.AddCommand(command2);
unitsUpgraded = true;
}
if (unitsUpgraded)
{
upgradesCount++;
}
}
foreach (var troop in customUpgrades)
{
currentlyUpgradingUnit = troop?.Character?.Name?.ToString();
var upgradePath = PartyManagerSettings.Settings.SavedTroopUpgradePaths
.Where(x => x.UnitName == troop.Name.ToString())?.Select(x => x.TargetUpgrade).FirstOrDefault();
if (upgradePath == 0 && !troop.IsUpgrade1Insufficient)
{
UpgradeUnit(troop, true);
upgradesCount++;
}
else if (upgradePath == 1 && !troop.IsUpgrade2Insufficient)
{
UpgradeUnit(troop, false);
upgradesCount++;
}
}
}
if (!customOnly)
{
//single upgrade units
var singleUpgrades = upgrades.Where(x => !(x.IsUpgrade1Exists && x.IsUpgrade2Exists)).ToList();
if (PartyManagerSettings.Settings.UpgradeTroopsUseWhitelist)
{
singleUpgrades = singleUpgrades.Where(x =>
PartyManagerSettings.Settings.UpgradeTroopsBlackWhiteList.Contains(x.Name)).ToList();
}
else
{
singleUpgrades = singleUpgrades.Where(x =>
!PartyManagerSettings.Settings.UpgradeTroopsBlackWhiteList.Contains(x.Name)).ToList();
}
foreach (var troop in singleUpgrades)
{
currentlyUpgradingUnit = troop?.Character?.Name?.ToString();
PartyScreenLogic.PartyCommand command = new PartyScreenLogic.PartyCommand();
if (troop.NumOfTarget1UpgradesAvailable > 0)
{
UpgradeUnit(troop, true);
}
else
{
UpgradeUnit(troop, false);
}
upgradesCount++;
}
}
if (upgradesCount > 0)
{
GenericHelpers.LogDebug("UpgradeAllTroops", $"{upgradesCount} troops upgraded");
ButtonClickRefresh(true, false);
}
else
{
GenericHelpers.LogMessage("No troops found to upgrade");
}
}
catch (Exception ex)
{
GenericHelpers.LogException($"UpgradeAllTroops unittype({currentlyUpgradingUnit})", ex);
}
}
