Esempio n. 1
0
        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("队伍成员达到上限."));
            }
        }
Esempio n. 2
0
        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);
            }
        }
        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);
        }
        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();
            }
        }