private static List <Tuple <PartyCharacterVM, PartyScreenLogic.PartyCommand> > PrepareRecruitmentCommands(IEnumerable <PartyCharacterVM> recruitablePrisoners, int partySpace, ref RecruitmentResults results, PartyVM partyVm)
{
List <Tuple <PartyCharacterVM, PartyScreenLogic.PartyCommand> > commands = new List <Tuple <PartyCharacterVM, PartyScreenLogic.PartyCommand> >();
CharacterObject playerSelectedCharacter = partyVm.CurrentCharacter.Character;
foreach (PartyCharacterVM prisoners in recruitablePrisoners)
{
if (partySpace == 0 && !States.HotkeyControl)
{
break;
}
int prisonerCount = prisoners.NumOfRecruitablePrisoners;
int prisonersToRecruit = States.HotkeyControl ? prisonerCount : Math.Min(prisonerCount, partySpace);
int numOfRemainingRecruitablePrisoners = prisonerCount - prisonersToRecruit;
results.RecruitedTypes++;
results.RecruitedTotal += prisonersToRecruit;
partySpace -= prisonersToRecruit;
partyVm.CurrentCharacter.Character = prisoners.Character;
Campaign.Current.GetCampaignBehavior <IRecruitPrisonersCampaignBehavior>().SetRecruitableNumber(partyVm.CurrentCharacter.Character, numOfRemainingRecruitablePrisoners + 1);
PartyScreenLogic.PartyCommand recruitCommand = new PartyScreenLogic.PartyCommand();
recruitCommand.FillForRecruitTroop(prisoners.Side, prisoners.Type, prisoners.Character, prisonersToRecruit);
commands.Add(new Tuple <PartyCharacterVM, PartyScreenLogic.PartyCommand>(prisoners, recruitCommand));
partyVm.CurrentCharacter.UpdateRecruitable();
}
partyVm.CurrentCharacter.Character = playerSelectedCharacter;
return(commands);
}
public static void ProcessCommand(this PartyScreenLogic instance, PartyScreenLogic.PartyCommand command)
{
Traverse.Create(instance).Method("ProcessCommand", new Type[1]
{
typeof(PartyScreenLogic.PartyCommand)
}).GetValue(command);
}
public static void ExecuteRecruitAll(this PartyVM partyVM)
{
PartyScreenLogic partyScreenLogic = GetPartyScreenLogic(partyVM);
int num = partyScreenLogic.RightOwnerParty.PartySizeLimit - partyScreenLogic.MemberRosters[1].TotalManCount;
int num2 = 0;
int num3 = 0;
foreach (PartyCharacterVM item in partyVM.MainPartyPrisoners.OrderByDescending((PartyCharacterVM o) => o.Character.Tier).ToList())
{
if (num <= 0)
{
break;
}
if (!item.IsHero && item.NumOfRecruitablePrisoners > 0)
{
int num4 = Math.Min(item.NumOfRecruitablePrisoners, num);
num2++;
num -= num4;
num3 += num4;
PartyScreenLogic.PartyCommand partyCommand = new PartyScreenLogic.PartyCommand();
partyCommand.FillForRecruitTroop(item.Side, item.Type, item.Character, num4);
partyVM.CurrentCharacter = item;
ProcessCommand(partyScreenLogic, partyCommand);
}
}
RefreshPartyScreen(partyVM);
if (num2 > 0)
{
InformationManager.DisplayMessage(new InformationMessage($"招募 {num3} 兵 ({num2})"));
}
if (num <= 0)
{
InformationManager.DisplayMessage(new InformationMessage("队伍成员达到上限."));
}
}
public static void Postfix(PartyScreenLogic.PartyCommand command)
{
DropChance dc = new DropChance();
double dropChance = dc.CalculateChance();
Random random = new Random();
CharacterObject character = command.Character;
for (int index = 0; index < 12; ++index)
{
try
{
if (random.NextDouble() < dropChance)
{
EquipmentElement equipmentElement = character.Equipment.GetEquipmentFromSlot((EquipmentIndex)index);
if (equipmentElement.Item != null)
{
ItemRoster itemRoster = PartyBase.MainParty.ItemRoster;
equipmentElement = character.Equipment.GetEquipmentFromSlot((EquipmentIndex)index);
itemRoster.AddToCounts(equipmentElement.Item, 1, true);
SubModule.WriteDebugMessage(equipmentElement.Item.Name.ToString() + " was looted");
}
}
}
catch (Exception ex)
{
SubModule.WriteDebugMessage(ex.Message);
}
}
}
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 void UpdateLabel([CanBeNull] PartyScreenLogic.PartyCommand command)
{
try
{
if (!PartyScreenConfig.ExtraSettings.ShouldShowCompletePartyNumber)
{
return;
}
var _otherParty = _partyVM.OtherPartyTroops;
var _mainParty = _partyVM.MainPartyTroops;
if (_mainParty != null && !_mainParty.IsEmpty() &&
(_partyScreenLogic.RightOwnerParty?.PartySizeLimit > 0))
{
_partyVM.MainPartyTroopsLbl =
PopulatePartyList(_mainParty, _partyScreenLogic.RightOwnerParty.PartySizeLimit);
}
if (_otherParty != null && !_otherParty.IsEmpty() &&
(_partyScreenLogic.LeftOwnerParty?.PartySizeLimit > 0))
{
_partyVM.OtherPartyTroopsLbl =
PopulatePartyList(_otherParty, _partyScreenLogic.LeftOwnerParty.PartySizeLimit);
}
}
catch (Exception e)
{
Logging.Log(Logging.Levels.ERROR, $"Update Label: {e}");
Utilities.DisplayMessage($"PSE UpdateLabel Exception: {e}");
}
}
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);
}
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 void Postfix(PartyScreenLogic.PartyCommand command)
{
Random random = new Random();
CharacterObject character = command.Character;
for (int i = 0; i < 12; i++)
{
if (character.HeroObject.BattleEquipment[i].Item != null)
{
ItemRoster itemRoster = PartyBase.MainParty.ItemRoster;
EquipmentElement item = character.HeroObject.BattleEquipment[i];
itemRoster.AddToCounts(item.Item, 1, true);
item = character.HeroObject.BattleEquipment[i];
InformationManager.DisplayMessage(new InformationMessage(string.Concat(item.Item.Name.ToString(), " Added to inventory")));
}
}
}
public static void Postfix(PartyScreenLogic.PartyCommand command)
{
CharacterObject character = command.Character;
Equipment battleEquipment = character.HeroObject.BattleEquipment;
for (int i = 0; i < Equipment.EquipmentSlotLength - 1; i++)
{
ItemObject item = battleEquipment[i].Item;
if (item != null)
{
PartyBase.MainParty.ItemRoster.AddToCounts(item, 1);
InformationManager.DisplayMessage(
new InformationMessage($"Obtained {item.Name}")
);
}
}
}
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();
}
}
// Something wrong with upgrade
private static List <Tuple <PartyCharacterVM, PartyScreenLogic.PartyCommand> > PrepareUpgradeCommands(IEnumerable <PartyCharacterVM> upgradableTroops, PartyScreenLogic partyScreenLogic, ref UpgradeResults upgradeResults)
{
List <Tuple <PartyCharacterVM, PartyScreenLogic.PartyCommand> > commands = new List <Tuple <PartyCharacterVM, PartyScreenLogic.PartyCommand> >();
AvailableResources availableResources = new AvailableResources();
foreach (PartyCharacterVM troops in upgradableTroops)
{
List <(int, PartyScreenLogic.PartyCommand.UpgradeTargetType)> upgradesPerTypes =
new List <(int maxUpgradableTroops, PartyScreenLogic.PartyCommand.UpgradeTargetType upgradeTargetType)> {
(int.MaxValue, PartyScreenLogic.PartyCommand.UpgradeTargetType.UpgradeTarget1)
};
if (HasTwoUpgradePaths(troops) && !YapoSettings.Instance.PlayerDecision && !MultipathUpgradeLogic.TryGetUpgradePaths(troops, out upgradesPerTypes))
{
upgradeResults.MultiPathSkipped++;
continue;
}
foreach ((int maxUpgradableTroops, PartyScreenLogic.PartyCommand.UpgradeTargetType upgradeTargetType)upgradesPerType in upgradesPerTypes)
{
int troopsToUpgrade = CalculateCountOfTroopsThatCanBeUpgraded(availableResources, troops, partyScreenLogic, upgradesPerType);
if (troopsToUpgrade == 0)
{
continue;
}
upgradeResults.UpgradedTypes++;
upgradeResults.UpgradedTotal += troopsToUpgrade;
PartyScreenLogic.PartyCommand upgradeCommand = new PartyScreenLogic.PartyCommand();
upgradeCommand.FillForUpgradeTroop(troops.Side, troops.Type, troops.Character, troopsToUpgrade, upgradesPerType.upgradeTargetType);
commands.Add(new Tuple <PartyCharacterVM, PartyScreenLogic.PartyCommand>(troops, upgradeCommand));
availableResources.UpdateAvailableResources(troops, troopsToUpgrade, (int)upgradesPerType.upgradeTargetType);
}
}
return(commands);
}
public static void Postfix(PartyScreenLogic.PartyCommand command)
{
if (!LootOverhaulSettings.Instance.LootExecutedLords)
{
return;
}
CharacterObject character = command.Character;
EquipmentElement equipmentElement;
int maxItemsToLoot = LootOverhaulSettings.Instance.ApplyItemPerUnitToLords? LootOverhaulSettings.Instance.MaxItemsPerUnit : 12;
int itemsLooted = 0;
foreach (EquipmentIndex ei in LootOverhaul.allowedSlotsToLoot.Shuffle())
{
try
{
if (itemsLooted >= maxItemsToLoot)
{
break;
}
equipmentElement = character.Equipment.GetEquipmentFromSlot(ei);
if (equipmentElement.Item == null)
{
continue;
}
LootExecuted(equipmentElement.Item);
SubModule.WriteLootMessage(equipmentElement);
itemsLooted++;
}
catch (Exception ex)
{
SubModule.WriteException(ex.Message);
}
}
}
private static bool TransferAllCharacters(PartyVM __instance, ref PartyScreenLogic ____partyScreenLogic, ref PartyCharacterVM ____currentCharacter, PartyScreenLogic.PartyRosterSide rosterSide, PartyScreenLogic.TroopType type)
{
MBBindingList <PartyCharacterVM> list;
if (type == PartyScreenLogic.TroopType.Member)
{
if (rosterSide == PartyScreenLogic.PartyRosterSide.Left)
{
list = __instance.OtherPartyTroops;
}
else
{
list = __instance.MainPartyTroops;
}
}
else
{
if (rosterSide == PartyScreenLogic.PartyRosterSide.Left)
{
list = __instance.OtherPartyPrisoners;
}
else
{
list = __instance.MainPartyPrisoners;
}
}
var newList = list;
var lack = 10000;
var prisionerSetting = PrisonerSetting.Instance;
if (prisionerSetting.IsEnabled && rosterSide == PartyScreenLogic.PartyRosterSide.Left && PartyScreenLogic.TroopType.Prisoner == type)
{
var limit = MobileParty.MainParty.Party.PrisonerSizeLimit;
lack = limit - __instance.MainPartyPrisoners.Sum(a => a.Number);
var fixeds = new List <PartyCharacterVM>();
var order1 = new List <PartyCharacterVM>();
var order2 = new List <PartyCharacterVM>();
var order3 = new List <PartyCharacterVM>();
var order4 = new List <PartyCharacterVM>();
var other = new List <PartyCharacterVM>();
foreach (var item in newList)
{
if (prisionerSetting.IsFixTroop(item.Character) > 0)
{
fixeds.Add(item);
}
else if (prisionerSetting.OrderTroop(item.Character, prisionerSetting.Order1, prisionerSetting.Order1MinTier) > 0)
{
order1.Add(item);
}
else if (prisionerSetting.OrderTroop(item.Character, prisionerSetting.Order2, prisionerSetting.Order2MinTier) > 0)
{
order2.Add(item);
}
else if (prisionerSetting.OrderTroop(item.Character, prisionerSetting.Order3, prisionerSetting.Order3MinTier) > 0)
{
order3.Add(item);
}
else if (prisionerSetting.OrderTroop(item.Character, prisionerSetting.Order4, prisionerSetting.Order4MinTier) > 0)
{
order4.Add(item);
}
else if (!prisionerSetting.EnableFilter)
{
other.Add(item);
}
}
//var orderList = newList
// .OrderBy(a =>
// {
// return prisionerSetting.IsFixTroop(a.Character);
// })
// .ThenBy(a => { return prisionerSetting.OrderTroop(a.Character, prisionerSetting.Order1, prisionerSetting.Order1MinTier); })
// .ThenBy(a => { return prisionerSetting.OrderTroop(a.Character, prisionerSetting.Order2, prisionerSetting.Order2MinTier); })
// .ThenBy(a => { return prisionerSetting.OrderTroop(a.Character, prisionerSetting.Order3, prisionerSetting.Order3MinTier); })
// .ThenBy(a => { return prisionerSetting.OrderTroop(a.Character, prisionerSetting.Order4, prisionerSetting.Order4MinTier); })
// .ToList();
newList = new MBBindingList <PartyCharacterVM>();
foreach (var item in other.OrderBy(a => a.Character.Tier))
{
newList.Add(item);
}
foreach (var item in order4.OrderBy(a => { return(prisionerSetting.OrderTroop(a.Character, prisionerSetting.Order4, prisionerSetting.Order4MinTier)); }))
{
newList.Add(item);
}
foreach (var item in order3.OrderBy(a => { return(prisionerSetting.OrderTroop(a.Character, prisionerSetting.Order3, prisionerSetting.Order3MinTier)); }))
{
newList.Add(item);
}
foreach (var item in order2.OrderBy(a => { return(prisionerSetting.OrderTroop(a.Character, prisionerSetting.Order2, prisionerSetting.Order2MinTier)); }))
{
newList.Add(item);
}
foreach (var item in order1.OrderBy(a => { return(prisionerSetting.OrderTroop(a.Character, prisionerSetting.Order1, prisionerSetting.Order1MinTier)); }))
{
newList.Add(item);
}
foreach (var item in fixeds.OrderBy(a => { return(prisionerSetting.IsFixTroop(a.Character)); }))
{
newList.Add(item);
}
}
int tranfer = 0;
for (int i = newList.Count - 1; i >= 0; i--)
{
if (lack <= tranfer)
{
break;
}
if (____partyScreenLogic.IsTroopTransferrable(type, newList[i].Character, (int)newList[i].Side))
{
PartyScreenLogic.PartyCommand partyCommand = new PartyScreenLogic.PartyCommand();
PartyCharacterVM partyCharacterVM = newList[i];
____currentCharacter = partyCharacterVM;
if (partyCharacterVM.Type == PartyScreenLogic.TroopType.AttachedGroups)
{
partyCommand.FillForTransferPartyLeaderTroop(partyCharacterVM.Side, __instance.CurrentCharacter.Type, partyCharacterVM.Character, partyCharacterVM.Troop.Number);
}
else if (partyCharacterVM.Side == PartyScreenLogic.PartyRosterSide.Right)
{
if (PartyScreenLogic.TroopType.Prisoner == type && prisionerSetting.IsEnabled && prisionerSetting.IsFixTroop(partyCharacterVM.Character) > 0)
{
continue;
}
partyCommand.FillForTransferTroop(partyCharacterVM.Side, partyCharacterVM.Type, partyCharacterVM.Character, partyCharacterVM.Troop.Number, partyCharacterVM.Troop.WoundedNumber, -1);
}
else
{
var tranferNumber = partyCharacterVM.Troop.Number;
var tranferWoundedNumber = partyCharacterVM.Troop.WoundedNumber;
if (rosterSide == PartyScreenLogic.PartyRosterSide.Left && PartyScreenLogic.TroopType.Prisoner == type)
{
if (lack - tranfer <= partyCharacterVM.Troop.Number)
{
tranferNumber = lack - tranfer;
var heath = partyCharacterVM.Troop.Number - partyCharacterVM.Troop.WoundedNumber;
if (tranferNumber < heath)
{
tranferWoundedNumber = 0;
}
else
{
tranferWoundedNumber = tranferNumber - heath;
}
}
tranfer += tranferNumber;
}
partyCommand.FillForTransferTroop(partyCharacterVM.Side, partyCharacterVM.Type, partyCharacterVM.Character, tranferNumber, tranferWoundedNumber, -1);
}
____partyScreenLogic.AddCommand(partyCommand);
}
}
return(false);
}
public void RefreshDelegate(PartyScreenLogic.PartyCommand command)
{
RefreshValues();
}
public static void ExecuteUpgradeAll(this PartyVM partyVM)
{
var hasTwoUpgrade = new List <PartyCharacterVM>();
PartyScreenLogic partyScreenLogic = GetPartyScreenLogic(partyVM);
int troopNum = 0;
int troopNumTotal = 0;
var party = partyVM.MainPartyTroops.OrderByDescending((PartyCharacterVM o) => o.Character.Tier).ToList();
foreach (PartyCharacterVM partyCharacterVM in party)
{
if (!partyCharacterVM.IsHero && partyCharacterVM.IsUpgrade1Available && !partyCharacterVM.IsUpgrade2Exists && partyCharacterVM.NumOfTarget1UpgradesAvailable > 0 && !partyCharacterVM.IsUpgrade1Insufficient)
{
int numOfTarget1UpgradesAvailable = partyCharacterVM.NumOfTarget1UpgradesAvailable;
troopNum++;
troopNumTotal += numOfTarget1UpgradesAvailable;
PartyScreenLogic.PartyCommand partyCommand = new PartyScreenLogic.PartyCommand();
partyCommand.FillForUpgradeTroop(partyCharacterVM.Side, partyCharacterVM.Type, partyCharacterVM.Character, numOfTarget1UpgradesAvailable, PartyScreenLogic.PartyCommand.UpgradeTargetType.UpgradeTarget1);
partyVM.CurrentCharacter = partyCharacterVM;
ProcessCommand(partyScreenLogic, partyCommand);
}
if (!partyCharacterVM.IsHero && partyCharacterVM.IsUpgrade1Exists && partyCharacterVM.IsUpgrade1Available && partyCharacterVM.IsUpgrade2Exists && partyCharacterVM.IsUpgrade2Available)
{
hasTwoUpgrade.Add(partyCharacterVM);
}
}
foreach (var partyCharacterVM in hasTwoUpgrade)
{
if (UpgradeSetting.Instance.IsEnabled && partyCharacterVM.IsUpgrade1Exists && partyCharacterVM.IsUpgrade2Exists && partyCharacterVM.IsUpgrade1Available && partyCharacterVM.IsUpgrade2Available && !partyCharacterVM.IsUpgrade1Insufficient && !partyCharacterVM.IsUpgrade2Insufficient)
{
var upgradeSide = UpgradeSetting.Instance.FindUpgradeTopInSetting(partyCharacterVM.Character);
if (upgradeSide > -1 && upgradeSide < 2)
{
var upgradeNum = upgradeSide == 0 ? partyCharacterVM.NumOfTarget1UpgradesAvailable : partyCharacterVM.NumOfTarget2UpgradesAvailable;
troopNum++;
troopNumTotal += upgradeNum;
PartyScreenLogic.PartyCommand partyCommand = new PartyScreenLogic.PartyCommand();
partyCommand.FillForUpgradeTroop(partyCharacterVM.Side, partyCharacterVM.Type, partyCharacterVM.Character, upgradeNum, (PartyScreenLogic.PartyCommand.UpgradeTargetType)upgradeSide);
partyVM.CurrentCharacter = partyCharacterVM;
ProcessCommand(partyScreenLogic, partyCommand);
continue;
}
}
partyVM.MainPartyTroops.Remove(partyCharacterVM);
partyVM.MainPartyTroops.Insert(1, partyCharacterVM);
}
RefreshPartyScreen(partyVM);
if (troopNum > 0)
{
InformationManager.DisplayMessage(new InformationMessage($"升级 {troopNumTotal} 部队 ({troopNum})"));
}
}
protected override void OnClick()
{
MobileParty mainParty = MobileParty.MainParty;
TroopRoster memberRoster = mainParty.MemberRoster;
Hero playerHero = mainParty.Party.LeaderHero;
Random r = new Random();
int num = 0;
bool upgrade1LastTime = false;
for (int index = 0; index < _mainPartyList.Count; index++)
{
PartyCharacterVM partyCharacter = _mainPartyList[index];
int numOfUpgradableTroops = partyCharacter.NumOfUpgradeableTroops;
if (numOfUpgradableTroops > 0)
{
for (int i = 0; i < numOfUpgradableTroops; i++)
{
if (Settings.Instance.DontUpgradeMultipath && partyCharacter.IsUpgrade2Exists)
{
continue;
}
bool[] availableUpgrade = new bool[2];
availableUpgrade[0] = partyCharacter.IsUpgrade1Available && !partyCharacter.IsUpgrade1Insufficient;
availableUpgrade[1] = partyCharacter.IsUpgrade2Available && !partyCharacter.IsUpgrade2Insufficient;
if (!availableUpgrade[0] && !availableUpgrade[1])
{
continue;
}
int onlyPossibleIndex = -1;
if (availableUpgrade[0] && !availableUpgrade[1])
{
onlyPossibleIndex = 0;
}
if (!availableUpgrade[0] && availableUpgrade[1])
{
onlyPossibleIndex = 1;
}
int upgradePath;
if (onlyPossibleIndex == -1)
{
if (upgrade1LastTime)
{
upgradePath = 1;
}
else
{
upgradePath = 0;
}
upgrade1LastTime = !upgrade1LastTime;
}
else
{
upgradePath = onlyPossibleIndex;
}
PartyScreenLogic.PartyCommand partyCommand = new PartyScreenLogic.PartyCommand();
if (partyCharacter.Number == 1)
{
index--;
}
partyCommand.FillForUpgradeTroop(PartyScreenLogic.PartyRosterSide.Right, PartyScreenLogic.TroopType.Member, partyCharacter.Character, 1, (PartyScreenLogic.PartyCommand.UpgradeTargetType)upgradePath);
this._partyVM.CurrentCharacter = partyCharacter;
this._partyLogic.AddCommand(partyCommand);
num++;
}
}
}
InformationManager.DisplayMessage(new InformationMessage("Upgraded " + num.ToString() + " soldiers."));
}
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);
}
}
