public static IEnumerable <PawnKindDef> GeneratePawnKindsExample(PawnGroupMakerParms parms)
        {
            if (parms.groupKind == null)
            {
                Log.Error("Tried to generate pawn kinds with null pawn group kind def. parms=" + parms, false);
                yield break;
            }
            if (parms.faction == null)
            {
                Log.Error("Tried to generate pawn kinds with null faction. parms=" + parms, false);
                yield break;
            }
            if (parms.faction.def.pawnGroupMakers.NullOrEmpty <PawnGroupMaker>())
            {
                Log.Error(string.Concat(new object[]
                {
                    "Faction ",
                    parms.faction,
                    " of def ",
                    parms.faction.def,
                    " has no any PawnGroupMakers."
                }), false);
                yield break;
            }
            PawnGroupMaker chosenGroupMaker;

            if (!PawnGroupMakerUtility.TryGetRandomPawnGroupMaker(parms, out chosenGroupMaker))
            {
                Log.Error(string.Concat(new object[]
                {
                    "Faction ",
                    parms.faction,
                    " of def ",
                    parms.faction.def,
                    " has no usable PawnGroupMakers for parms ",
                    parms
                }), false);
                yield break;
            }
            foreach (PawnKindDef p in chosenGroupMaker.GeneratePawnKindsExample(parms))
            {
                yield return(p);
            }
            yield break;
        }
Example #2
0
        public static IEnumerable <Pawn> GeneratePawns(PawnGroupMakerParms parms, bool warnOnZeroResults = true)
        {
            PawnGroupMaker chosenGroupMaker;

            if (parms.groupKind == null)
            {
                Log.Error("Tried to generate pawns with null pawn group kind def. parms=" + parms, false);
            }
            else if (parms.faction == null)
            {
                Log.Error("Tried to generate pawn kinds with null faction. parms=" + parms, false);
            }
            else if (parms.faction.def.pawnGroupMakers.NullOrEmpty <PawnGroupMaker>())
            {
                Log.Error(string.Concat(new object[]
                {
                    "Faction ",
                    parms.faction,
                    " of def ",
                    parms.faction.def,
                    " has no any PawnGroupMakers."
                }), false);
            }
            else if (!PawnGroupMakerUtility.TryGetRandomPawnGroupMaker(parms, out chosenGroupMaker))
            {
                Log.Error(string.Concat(new object[]
                {
                    "Faction ",
                    parms.faction,
                    " of def ",
                    parms.faction.def,
                    " has no usable PawnGroupMakers for parms ",
                    parms
                }), false);
            }
            else
            {
                foreach (Pawn p in chosenGroupMaker.GeneratePawns(parms, warnOnZeroResults))
                {
                    yield return(p);
                }
            }
        }
            public bool MoveNext()
            {
                uint num = (uint)this.$PC;

                this.$PC = -1;
                bool flag = false;

                switch (num)
                {
                case 0u:
                    if (parms.groupKind == null)
                    {
                        Log.Error("Tried to generate pawns with null pawn group kind def. parms=" + parms, false);
                        return(false);
                    }
                    if (parms.faction == null)
                    {
                        Log.Error("Tried to generate pawn kinds with null faction. parms=" + parms, false);
                        return(false);
                    }
                    if (parms.faction.def.pawnGroupMakers.NullOrEmpty <PawnGroupMaker>())
                    {
                        Log.Error(string.Concat(new object[]
                        {
                            "Faction ",
                            parms.faction,
                            " of def ",
                            parms.faction.def,
                            " has no any PawnGroupMakers."
                        }), false);
                        return(false);
                    }
                    if (!PawnGroupMakerUtility.TryGetRandomPawnGroupMaker(parms, out chosenGroupMaker))
                    {
                        Log.Error(string.Concat(new object[]
                        {
                            "Faction ",
                            parms.faction,
                            " of def ",
                            parms.faction.def,
                            " has no usable PawnGroupMakers for parms ",
                            parms
                        }), false);
                        return(false);
                    }
                    enumerator = chosenGroupMaker.GeneratePawns(parms, warnOnZeroResults).GetEnumerator();
                    num        = 4294967293u;
                    break;

                case 1u:
                    break;

                default:
                    return(false);
                }
                try
                {
                    switch (num)
                    {
                    }
                    if (enumerator.MoveNext())
                    {
                        p             = enumerator.Current;
                        this.$current = p;
                        if (!this.$disposing)
                        {
                            this.$PC = 1;
                        }
                        flag = true;
                        return(true);
                    }
                }
                finally
                {
                    if (!flag)
                    {
                        if (enumerator != null)
                        {
                            enumerator.Dispose();
                        }
                    }
                }
                this.$PC = -1;
                return(false);
            }