public static void Prefix(PartyCharacterVM __instance, ref int transferAmount)
{
if (States.HotkeyControl)
{
transferAmount = __instance.Troop.Number;
}
}
protected override int localCompare(ref PartyCharacterVM x, ref PartyCharacterVM y)
{
var xName = x.Troop.Character.Culture.Name?.ToString();
var yName = y.Troop.Character.Culture.Name?.ToString();
if (xName == null || yName == null)
{
return(1);
}
xName = CustomSettingsList.Contains(xName) ? xName : CultureCode.AnyOtherCulture.ToString();
yName = CustomSettingsList.Contains(yName) ? yName : CultureCode.AnyOtherCulture.ToString();
if (xName.Equals(yName))
{
return(EqualSorter?.Compare(x, y) ?? 0);
}
foreach (var setting in CustomSettingsList)
{
bool xMatch = xName.Equals(setting);
bool yMatch = yName.Equals(setting);
if (xMatch && !yMatch)
{
return(Descending ? -1 : 1);
}
if (yMatch && !xMatch)
{
return(Descending ? 1 : -1);
}
}
return(1);
}
public static bool Prefix(ref PartyVM __instance)
{
Main.Log($"PartyVM_SetGroup_Patch");
//for (int index = 6;index < SlotsInParty; ++index) {
// Main.Log($"PartyVM_SetGroup_Patch - adding slot: {index}");
// __instance.CharactersVM.Add(new PartyCharacterVM(new Action<bool>(__instance.NextPrev), index));
//}
__instance.m_ActualGroup = Game.Instance.SelectionCharacter.ActualGroup;
__instance.StartIndex = 0;
for (int index = 0; index < __instance.m_ActualGroup.Count; ++index)
{
if (__instance.FullCharactersVM.Count == index)
{
__instance.FullCharactersVM.Add(new PartyCharacterVM(new Action <bool>(__instance.NextPrev), index));
__instance.CharactersVM.Add(new PartyCharacterVM(new Action <bool>(__instance.NextPrev), index));
Main.Log($"PartyVM_SetGroup_Patch - adding slot: {index}");
}
__instance.FullCharactersVM[index].SetUnitData(__instance.m_ActualGroup[index]);
}
while (__instance.FullCharactersVM.Count > __instance.m_ActualGroup.Count)
{
Main.Log($"PartyVM_SetGroup_Patch - removing slot: {__instance.FullCharactersVM.Count - 1}");
PartyCharacterVM partyCharacterVm = __instance.FullCharactersVM[__instance.FullCharactersVM.Count - 1];
partyCharacterVm.Dispose();
__instance.FullCharactersVM.Remove(partyCharacterVm);
}
return(false);
}
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);
}
private void ExecuteTransferWounded()
{
try
{
var enumerator = new PartyCharacterVM[_mainPartyList.Count];
_mainPartyList?.CopyTo(enumerator, 0);
foreach (PartyCharacterVM character in enumerator)
{
if (character?.WoundedCount > 0)
{
if (character.IsTroopTransferrable)
{
int wounded = Math.Min(character.WoundedCount, character.Number);
character.OnTransfer(character, -1, wounded, character.Side);
character.InitializeUpgrades();
}
}
}
_partyVm?.ExecuteRemoveZeroCounts();
_parent.RefreshValues();
}
catch (Exception e)
{
Logging.Log(Logging.Levels.ERROR, $"Transfer Wounded Troops: {e}");
Utilities.DisplayMessage($"PSE Transfer Wounded Exception: {e}");
}
}
private int Upgrade(PartyCharacterVM character, UpgradeTarget upgradeTarget)
{
//Somehow, for some people, character seems to be null at random times. Haven't been able to reproduce it so far
//So this simple null check will have to stay.
if (character == null)
{
return(0);
}
bool allInsufficient;
if (upgradeTarget is SpecificUpgradeTarget target)
{
// The upgrade target changed possible upgrade paths and therefore errors out, reset the upgrade preference
if (target.targetIndex >= character.Upgrades.Count)
{
Utilities.DisplayMessage($"Detected outdated upgrade preference, resetting upgrade preference for {character.Name}", Colors.Red);
PartyScreenConfig.PathsToUpgrade.Remove(character.Character.StringId);
return(0);
}
allInsufficient = character.Upgrades[target.targetIndex].IsInsufficient;
}
else
{
allInsufficient = character.Upgrades.All(uTarget => uTarget.IsInsufficient);
}
if (!allInsufficient)
{
return(ExecuteUpgrade(upgradeTarget, character));
}
return(0);
}
private void UpgradeUnit(PartyCharacterVM troop, bool path1)
{
PartyScreenLogic.PartyCommand command = new PartyScreenLogic.PartyCommand();
command.FillForUpgradeTroop(PartyScreenLogic.PartyRosterSide.Right, troop.Type, troop.Character,
path1 ? troop.NumOfTarget1UpgradesAvailable : troop.NumOfTarget2UpgradesAvailable,
path1 ? PartyScreenLogic.PartyCommand.UpgradeTargetType.UpgradeTarget1 : PartyScreenLogic.PartyCommand.UpgradeTargetType.UpgradeTarget2);
PartyScreenLogic.AddCommand(command);
}
public void UpdateAvailableResources(PartyCharacterVM troops, int troopsToUpgrade, int upgradesPerTargetType)
{
AvailableGold -= troops.Character.UpgradeCost(PartyBase.MainParty, 0) * troopsToUpgrade;
if (troops.Character.UpgradeTargets[upgradesPerTargetType]?.UpgradeRequiresItemFromCategory != null)
{
ItemsOfCategoryWithCount[troops.Character.UpgradeTargets[upgradesPerTargetType]?.UpgradeRequiresItemFromCategory] -= troopsToUpgrade;
}
}
private void SendCommand(PartyCharacterVM character, int amount,
int target)
{
var partyCommand = new PartyScreenLogic.PartyCommand();
partyCommand.FillForUpgradeTroop(character.Side, character.Type, character.Character, amount, target);
_partyVM.CurrentCharacter = character;
_partyLogic.AddCommand(partyCommand);
}
public static bool Prefix(int upgradeIndex, ref PartyCharacterVM __instance)
{
if (ScreenManager.TopScreen is GauntletPartyScreen && Utilities.IsControlDown() && Utilities.IsShiftDown())
{
if (PartyScreenConfig.PathsToUpgrade.TryGetValue(__instance.Character.StringId, out var upgradeValue))
{
if (upgradeValue == upgradeIndex)
{
PartyScreenConfig.PathsToUpgrade.Remove(__instance.Character.StringId);
InformationManager.DisplayMessage(new InformationMessage(
$"Removed the set upgrade path for {__instance.Name}",
Color.ConvertStringToColor("#a83123FF")));
}
else
{
if (upgradeValue == -1)
{
PartyScreenConfig.PathsToUpgrade.Remove(__instance.Character.StringId);
InformationManager.DisplayMessage(new InformationMessage(
$"Allowed single-path upgrading of {__instance.Name} to {__instance.Character.UpgradeTargets[upgradeIndex].Name}",
Color.ConvertStringToColor("#0bbd0bFF")));
}
else
{
PartyScreenConfig.PathsToUpgrade[__instance.Character.StringId] = upgradeIndex;
InformationManager.DisplayMessage(new InformationMessage(
$"Changed the upgrade target of {__instance.Name} to {__instance.Character.UpgradeTargets[upgradeIndex].Name}",
Color.ConvertStringToColor("#0bbd0bFF")));
}
}
}
else
{
if (__instance.Character.UpgradeTargets.Length == 1)
{
PartyScreenConfig.PathsToUpgrade.Add(__instance.Character.StringId, -1);
InformationManager.DisplayMessage(new InformationMessage(
$"Disallowed single-path upgrading of {__instance.Name}",
Color.ConvertStringToColor("#a83123FF")));
}
else
{
PartyScreenConfig.PathsToUpgrade.Add(__instance.Character.StringId, upgradeIndex);
InformationManager.DisplayMessage(new InformationMessage(
$"Set the upgrade target of {__instance.Name} to {__instance.Character.UpgradeTargets[upgradeIndex].Name}",
Color.ConvertStringToColor("#0bbd0bFF")));
}
}
PartyScreenConfig.Save();
return(false);
}
return(true);
}
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);
}
}
protected override int localCompare(ref PartyCharacterVM x, ref PartyCharacterVM y)
{
if (Descending ? x.Troop.WoundedNumber > y.Troop.WoundedNumber : y.Troop.WoundedNumber > x.Troop.WoundedNumber)
{
return(-1);
}
if (x.Troop.WoundedNumber == y.Troop.WoundedNumber)
{
return(EqualSorter?.Compare(x, y) ?? 0);
}
return(1);
}
protected override int localCompare(ref PartyCharacterVM x, ref PartyCharacterVM y)
{
if (Descending ? x.Character.Tier <y.Character.Tier : x.Character.Tier> y.Character.Tier)
{
return(1);
}
if (x.Character.Tier == y.Character.Tier)
{
return(EqualSorter?.Compare(x, y) ?? 0);
}
return(-1);
}
protected override int localCompare(ref PartyCharacterVM x, ref PartyCharacterVM y)
{
if (Descending ? x.Character.Level > y.Character.Level : y.Character.Level > x.Character.Level)
{
return(-1);
}
if (x.Character.Level == y.Character.Level)
{
return(EqualSorter?.Compare(x, y) ?? 0);
}
return(1);
}
protected override int localCompare(ref PartyCharacterVM x, ref PartyCharacterVM y)
{
if (Descending
? x.Character.GetFormationClass() < y.Character.GetFormationClass()
: x.Character.GetFormationClass() > y.Character.GetFormationClass())
{
return(1);
}
if (y.Character.GetFormationClass() == x.Character.GetFormationClass())
{
return(EqualSorter?.Compare(x, y) ?? 0);
}
return(-1);
}
protected override int localCompare(ref PartyCharacterVM x, ref PartyCharacterVM y)
{
if (Descending
? x.NumOfReadyToUpgradeTroops > y.NumOfReadyToUpgradeTroops
: y.NumOfReadyToUpgradeTroops > x.NumOfReadyToUpgradeTroops)
{
return(-1);
}
if (y.NumOfReadyToUpgradeTroops == x.NumOfReadyToUpgradeTroops)
{
return(EqualSorter?.Compare(x, y) ?? 0);
}
return(1);
}
protected override int localCompare(ref PartyCharacterVM x, ref PartyCharacterVM y)
{
if (_compDictionary == null)
{
FillDictionary();
}
var xChar = x.Character;
var yChar = y.Character;
if (xChar == null || yChar == null)
{
return(1);
}
bool isXHorseArcher = xChar.IsRanged && xChar.IsMounted;
bool isYHorseArcher = yChar.IsRanged && yChar.IsMounted;
if (isXHorseArcher || isYHorseArcher)
{
if (isXHorseArcher && isYHorseArcher)
{
return(EqualSorter?.Compare(x, y) ?? 0);
}
}
else
{
if ((x.Character.IsInfantry && y.Character.IsInfantry) || (x.Character.IsMounted && y.Character.IsMounted) || (x.Character.IsRanged && y.Character.IsRanged))
{
return(EqualSorter?.Compare(x, y) ?? 0);
}
}
foreach (var order in CustomSettingsList)
{
var function = _compDictionary[order];
int value = function(xChar, yChar);
if (value != int.MaxValue)
{
return(value);
}
}
return(1);
}
public static bool Prefix(int upgradeIndex, ref PartyCharacterVM __instance)
{
if (!PartyManagerSettings.Settings.DisableCustomUpgradePaths && (ScreenManager.TopScreen is GauntletPartyScreen topScreen))
{
if (topScreen.DebugInput.IsControlDown() && topScreen.DebugInput.IsShiftDown())
{
PartyController.ToggleUpgradePath(__instance, upgradeIndex, true);
return(false);
}
else if (topScreen.DebugInput.IsControlDown())
{
PartyController.ToggleUpgradePath(__instance, upgradeIndex, false);
return(false);
}
return(true);
}
return(true);
}
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);
}
protected override int localCompare(ref PartyCharacterVM x, ref PartyCharacterVM y)
{
int result;
if (Descending)
{
result = StringComparer.CurrentCulture.Compare(y.Name.ToString(), x.Name.ToString());
}
else
{
result = StringComparer.CurrentCulture.Compare(x.Name.ToString(), y.Name.ToString());
}
if (result == 0)
{
return(EqualSorter?.Compare(x, y) ?? 0);
}
return(result);
}
private void RecruitPrisoner(PartyCharacterVM character, int remainingSize, ref int amount)
{
if (!_partyLogic.IsPrisonerRecruitable(character.Type, character.Character, character.Side))
{
return;
}
var number = Math.Min(character.NumOfRecruitablePrisoners, remainingSize);
if (number > 0)
{
PartyScreenLogic.PartyCommand partyCommand = new PartyScreenLogic.PartyCommand();
partyCommand.FillForRecruitTroop(character.Side, character.Type,
character.Character, number);
_partyLogic.AddCommand(partyCommand);
amount += number;
character.UpdateRecruitable();
}
}
private static void SortAnyParty(MBBindingList <PartyCharacterVM> toSort, PartyBase party,
TroopRoster rosterToSort, PartySort sorter)
{
if (rosterToSort == null || rosterToSort.Count == 0 || toSort == null || toSort.IsEmpty())
{
return;
}
CharacterObject leaderOfParty = party?.LeaderHero?.CharacterObject;
// Sort the list, this is done for the visual unit cards to be properly positioned after the sort
// This is not yet persisted to the actual roster, that is done after this.
toSort.StableSort(sorter);
// Sanity check to ensure the leader is *always* at the top of the party.
if (leaderOfParty != null)
{
var index = toSort.FindIndex((character) => character.Character.Equals(leaderOfParty));
PartyCharacterVM leaderVm = toSort[index];
toSort.RemoveAt(index);
toSort.Insert(0, leaderVm);
}
// Here we manually clear the roster while ignoring the party leader.
// Don't use `rosterToSort.Clear()` as that seems to cause the party leader to get unset permanently afterward, which stops upgrades from working.
rosterToSort.RemoveIf((item) => item.Character != leaderOfParty);
// Re-add the correctly sorted troops to the roster. We need to do it in this janky way due to the fact that we can't easily sort
// the underlying roster array.
foreach (PartyCharacterVM character in toSort)
{
if (character.Character != leaderOfParty)
{
rosterToSort.AddToCounts(
character.Troop.Character, character.Troop.Number, false, character.Troop.WoundedNumber,
character.Troop.Xp);
}
}
}
public static bool Prefix(ref PartyCharacterVM __instance)
{
if (ScreenManager.TopScreen is GauntletPartyScreen && Utilities.IsControlDown() && Utilities.IsShiftDown())
{
if (!PartyScreenConfig.PrisonersToRecruit.ContainsKey(__instance.Character.StringId))
{
PartyScreenConfig.PrisonersToRecruit.Add(__instance.Character.StringId, -1);
if (PartyScreenConfig.ExtraSettings.RecruitByDefault)
{
DisplayRemoved(__instance);
}
else
{
DisplayAllowed(__instance);
}
}
else
{
PartyScreenConfig.PrisonersToRecruit.Remove(__instance.Character.StringId);
if (PartyScreenConfig.ExtraSettings.RecruitByDefault)
{
DisplayAllowed(__instance);
}
else
{
DisplayRemoved(__instance);
}
}
PartyScreenConfig.Save();
return(false);
}
return(true);
}
public static void Postfix(PartyCharacterVM __instance)
{
__instance.TransferHint.HintText += Strings.TRANSFER_HINT_TEXT_APPENDIX;
}
private static void DisplayAllowed(PartyCharacterVM __instance)
{
InformationManager.DisplayMessage(new InformationMessage(
$"Allowed recruiting of {__instance.Name}",
Color.ConvertStringToColor("#0bbd0bFF")));
}
private static int CalculateCountOfTroopsThatCanBeUpgraded(AvailableResources availableResources,
PartyCharacterVM troops,
PartyScreenLogic partyScreenLogic,
(int maxUpgradableTroops, PartyScreenLogic.PartyCommand.UpgradeTargetType upgradeTargetType) upgradesPerTargetType)
private static bool HasTwoUpgradePaths(PartyCharacterVM troops) => troops.IsUpgrade1Exists && troops.IsUpgrade2Exists;
private static void DisplayRemoved(PartyCharacterVM __instance)
{
InformationManager.DisplayMessage(new InformationMessage(
$"Disallowed recruiting of {__instance.Character.Name}",
Color.ConvertStringToColor("#a83123FF")));
}
//TODO: Switch to cleaner RecruitByDefault=false logic.
public void RecruitAll()
{
bool shouldIgnoreLimit = Utilities.IsControlDown();
int amountUpgraded = 0;
try
{
var enumerator = new PartyCharacterVM[_mainPartyPrisoners.Count];
_mainPartyPrisoners.CopyTo(enumerator, 0);
foreach (PartyCharacterVM prisoner in enumerator)
{
if (prisoner == null)
{
continue;
}
int remainingPartySize = _partyLogic.RightOwnerParty.PartySizeLimit - _partyLogic
.MemberRosters[(int)PartyScreenLogic.PartyRosterSide.Right]
.TotalManCount;
if (remainingPartySize > 0 || shouldIgnoreLimit)
{
if (prisoner.IsTroopRecruitable)
{
_partyVM.CurrentCharacter = prisoner;
if (PartyScreenConfig.PrisonersToRecruit.TryGetValue(prisoner.Character.StringId,
out int val))
{
if (val == -1 && PartyScreenConfig.ExtraSettings.RecruitByDefault)
{
continue;
}
}
else if (!PartyScreenConfig.ExtraSettings.RecruitByDefault)
{
continue;
}
RecruitPrisoner(prisoner,
shouldIgnoreLimit ? prisoner.NumOfRecruitablePrisoners : remainingPartySize,
ref amountUpgraded);
}
}
else
{
if (PartyScreenConfig.ExtraSettings.ShowGeneralLogMessage)
{
InformationManager.DisplayMessage(
new InformationMessage($"Party size limit reached, {amountUpgraded} recruited!"));
}
return;
}
}
if (PartyScreenConfig.ExtraSettings.ShowGeneralLogMessage)
{
InformationManager.DisplayMessage(new InformationMessage($"Recruited {amountUpgraded} prisoners"));
}
_parent.RefreshValues();
}
catch (Exception e)
{
Logging.Log(Logging.Levels.ERROR, $"Recruit Prisoners: {e}");
Utilities.DisplayMessage($"PSE Recruit Prisoner Exception {e}");
}
}
public void TransferUnit(PartyCharacterVM troop, bool fromLeft)
{
troop.OnTransfer(troop, -1, troop.Number,
fromLeft ? PartyScreenLogic.PartyRosterSide.Left : PartyScreenLogic.PartyRosterSide.Right);
}
