protected override bool TryGetArmyData()
    {
        if (this.createFirstArmyTicket != null)
        {
            return(false);
        }
        if (base.AIDataArmyGUID.IsValid)
        {
            return(true);
        }
        if (this.currentTicket != null)
        {
            return(false);
        }
        IGameEntity gameEntity;

        if (!this.gameEntityRepositoryService.TryGetValue(this.SourceGuid, out gameEntity))
        {
            base.Completion = AICommanderMission.AICommanderMissionCompletion.Fail;
            return(false);
        }
        for (int i = this.UnitGuids.Length - 1; i >= 0; i--)
        {
            AIData_Unit aidata_Unit;
            this.aiDataRepository.TryGetAIData <AIData_Unit>(this.UnitGuids[i], out aidata_Unit);
            if (aidata_Unit == null)
            {
                Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] no AIData for Unit {0}", new object[]
                {
                    this.UnitGuids[i].ToString()
                });
            }
            else
            {
                if (aidata_Unit.IsUnitLocked() && !aidata_Unit.IsUnitLockedByMe(base.InternalGUID))
                {
                    WorldPosition worldPosition = WorldPosition.Invalid;
                    if (aidata_Unit.Unit.Garrison is IWorldPositionable)
                    {
                        worldPosition = (aidata_Unit.Unit.Garrison as IWorldPositionable).WorldPosition;
                    }
                    Diagnostics.LogWarning(string.Format("{1} {2} LOCKING: Unit shouldn't be in use, current unit state: {0}", aidata_Unit.GetLockingStateString(), base.Commander.Empire, worldPosition));
                    base.Completion = AICommanderMission.AICommanderMissionCompletion.Fail;
                    return(false);
                }
                if (aidata_Unit.Unit.UnitDesign.Tags.Contains(DownloadableContent9.TagSolitary))
                {
                    Diagnostics.LogWarning("You cannot regroup Colossus or Solitary unit with something else.");
                    base.Completion = AICommanderMission.AICommanderMissionCompletion.Fail;
                    return(false);
                }
            }
        }
        IGarrison garrison = gameEntity as IGarrison;

        if (garrison == null)
        {
            base.Completion = AICommanderMission.AICommanderMissionCompletion.Fail;
            return(false);
        }
        if (this.AICommanderRegroupArmies != null && this.AICommanderRegroupArmies.RequestUnitListMessageID != 0UL)
        {
            RequestUnitListMessage requestUnitListMessage = base.Commander.AIPlayer.Blackboard.GetMessage(this.AICommanderRegroupArmies.RequestUnitListMessageID) as RequestUnitListMessage;
            if (requestUnitListMessage == null)
            {
                base.Completion = AICommanderMission.AICommanderMissionCompletion.Fail;
                return(false);
            }
            requestUnitListMessage.ExecutionState = RequestUnitListMessage.RequestUnitListState.Regrouping;
        }
        bool flag = false;

        for (int j = 0; j < this.UnitGuids.Length; j++)
        {
            if (!garrison.ContainsUnit(this.UnitGuids[j]))
            {
                flag = true;
                break;
            }
        }
        if (flag)
        {
            List <GameEntityGUID> list = new List <GameEntityGUID>();
            for (int k = 0; k < this.UnitGuids.Length; k++)
            {
                if (garrison.ContainsUnit(this.UnitGuids[k]))
                {
                    list.Add(this.UnitGuids[k]);
                }
            }
            this.UnitGuids = list.ToArray();
        }
        if (this.UnitGuids.Length == 0)
        {
            base.Completion = AICommanderMission.AICommanderMissionCompletion.Fail;
            return(false);
        }
        WorldPosition armyPosition = WorldPosition.Invalid;
        Army          army         = gameEntity as Army;

        if (army != null)
        {
            AIData_Army aidata = this.aiDataRepository.GetAIData <AIData_Army>(gameEntity.GUID);
            Diagnostics.Assert(aidata != null);
            if (army.GetPropertyValue(SimulationProperties.Movement) <= 0f)
            {
                return(false);
            }
            if (aidata.CommanderMission != null)
            {
                aidata.CommanderMission.Interrupt();
            }
            if (aidata.Army.IsInEncounter || aidata.Army.IsLocked)
            {
                return(false);
            }
            if (aidata.Army.StandardUnits.Count != this.UnitGuids.Length)
            {
                armyPosition = AILayer_ArmyRecruitment.GetValidArmySpawningPosition(aidata.Army, this.worldPositionningService, this.pathfindingService);
                int num = (int)base.Commander.Empire.GetPropertyValue(SimulationProperties.ArmyUnitSlot);
                if (aidata.Army.StandardUnits.Count > num)
                {
                    Array.Resize <GameEntityGUID>(ref this.UnitGuids, num);
                }
            }
            else
            {
                if (!aidata.AssignCommanderMission(this))
                {
                    base.Completion = AICommanderMission.AICommanderMissionCompletion.Fail;
                    return(false);
                }
                base.AIDataArmyGUID = gameEntity.GUID;
                return(true);
            }
        }
        else if (gameEntity is Village)
        {
            Village village = gameEntity as Village;
            if (village.IsInEncounter)
            {
                return(false);
            }
            WorldPosition    worldPosition2   = village.WorldPosition;
            WorldOrientation worldOrientation = WorldOrientation.East;
            if (this.AICommanderRegroupArmies.FinalPosition.IsValid)
            {
                worldOrientation = this.worldPositionningService.GetOrientation(worldPosition2, this.AICommanderRegroupArmies.FinalPosition);
            }
            for (int l = 0; l < 6; l++)
            {
                WorldPosition neighbourTile = this.worldPositionningService.GetNeighbourTile(worldPosition2, worldOrientation, 1);
                if (DepartmentOfDefense.CheckWhetherTargetPositionIsValidForUseAsArmySpawnLocation(neighbourTile, PathfindingMovementCapacity.Ground | PathfindingMovementCapacity.Water) && this.pathfindingService.IsTransitionPassable(village.WorldPosition, neighbourTile, this.pathfindingContext, PathfindingFlags.IgnoreFogOfWar, null) && this.pathfindingService.IsTilePassable(neighbourTile, this.pathfindingContext, (PathfindingFlags)0, null) && this.pathfindingService.IsTileStopable(neighbourTile, this.pathfindingContext, (PathfindingFlags)0, null))
                {
                    if (this.worldPositionningService.GetArmyAtPosition(neighbourTile) == null)
                    {
                        armyPosition = neighbourTile;
                        break;
                    }
                }
                else
                {
                    worldOrientation = worldOrientation.Rotate(1);
                }
            }
        }
        else if (gameEntity is City)
        {
            City city = gameEntity as City;
            if (city.IsInEncounter)
            {
                return(false);
            }
            if (!DepartmentOfTheInterior.TryGetWorldPositionForNewArmyFromCity(city, this.pathfindingService, this.pathfindingContext, out armyPosition))
            {
                return(false);
            }
        }
        else
        {
            Diagnostics.LogError(string.Format("[AICommanderMission_RegroupArmyAt] The garrison {0} is not valid.", garrison.GUID));
        }
        if (armyPosition.IsValid)
        {
            if (army != null && army.WorldPath != null && army.WorldPath.Destination != army.WorldPosition)
            {
                OrderGoTo orderGoTo = new OrderGoTo(army.Empire.Index, army.GUID, army.WorldPosition);
                orderGoTo.Flags = (PathfindingFlags)0;
                base.Commander.Empire.PlayerControllers.AI.PostOrder(orderGoTo, out this.currentTicket, new EventHandler <TicketRaisedEventArgs>(this.MoveOrder_TicketRaised));
                if (this.currentTicket != null)
                {
                    return(false);
                }
                if (!this.orderExecuted)
                {
                    Diagnostics.LogError("[AICommanderMission_RegroupArmyAt] new cancelation move order was not executed, from {0} to {1}", new object[]
                    {
                        army.WorldPosition,
                        army.WorldPosition
                    });
                    return(false);
                }
            }
            for (int m = 0; m < this.UnitGuids.Length; m++)
            {
                AIData_Unit aidata_Unit2;
                this.aiDataRepository.TryGetAIData <AIData_Unit>(this.UnitGuids[m], out aidata_Unit2);
                if (aidata_Unit2 == null)
                {
                    Diagnostics.LogWarning("[AICommanderMission_RegroupArmyAt] no AIData for Unit {0}", new object[]
                    {
                        this.UnitGuids[m].ToString()
                    });
                }
                else if (!aidata_Unit2.IsUnitLockedByMe(base.InternalGUID))
                {
                    aidata_Unit2.TryLockUnit(base.InternalGUID, base.GetType().ToString(), AIData_Unit.AIDataReservationExtraTag.Regrouping, base.Commander.GetPriority(this));
                }
            }
            OrderTransferGarrisonToNewArmy order = new OrderTransferGarrisonToNewArmy(base.Commander.Empire.Index, this.SourceGuid, this.UnitGuids, armyPosition, "Regroup", false, true, true);
            base.Commander.Empire.PlayerControllers.Server.PostOrder(order, out this.createFirstArmyTicket, new EventHandler <TicketRaisedEventArgs>(this.OrderTransferUnitToNewArmyTicketRaised));
        }
        return(false);
    }