public virtual IEnumerable <IncidentTargetTypeDef> AcceptedTypes()
        {
            if (this.def.incidentTargetTypes != null)
            {
                using (List <IncidentTargetTypeDef> .Enumerator enumerator = this.def.incidentTargetTypes.GetEnumerator())
                {
                    if (enumerator.MoveNext())
                    {
                        IncidentTargetTypeDef type2 = enumerator.Current;
                        yield return(type2);

                        /*Error: Unable to find new state assignment for yield return*/;
                    }
                }
            }
            for (int i = 0; i < this.comps.Count; i++)
            {
                using (IEnumerator <IncidentTargetTypeDef> enumerator2 = this.comps[i].AcceptedTypes().GetEnumerator())
                {
                    if (enumerator2.MoveNext())
                    {
                        IncidentTargetTypeDef type = enumerator2.Current;
                        yield return(type);

                        /*Error: Unable to find new state assignment for yield return*/;
                    }
                }
            }
            yield break;
IL_01a4:
            /*Error near IL_01a5: Unexpected return in MoveNext()*/;
        }
Esempio n. 2
0
            public bool MoveNext()
            {
                uint num = (uint)this.$PC;

                this.$PC = -1;
                switch (num)
                {
                case 0u:
                    this.$current = IncidentTargetTypeDefOf.World;
                    if (!this.$disposing)
                    {
                        this.$PC = 1;
                    }
                    return(true);

                case 1u:
                    this.$PC = -1;
                    break;
                }
                return(false);
            }
Esempio n. 3
0
        public override IEnumerable <IncidentTargetTypeDef> AcceptedTypes()
        {
            using (IEnumerator <IncidentTargetTypeDef> enumerator = base.AcceptedTypes().GetEnumerator())
            {
                if (enumerator.MoveNext())
                {
                    IncidentTargetTypeDef type = enumerator.Current;
                    yield return(type);

                    /*Error: Unable to find new state assignment for yield return*/;
                }
            }
            if (!this.raidBeaconEnabled)
            {
                yield break;
            }
            yield return(IncidentTargetTypeDefOf.MapRaidBeacon);

            /*Error: Unable to find new state assignment for yield return*/;
IL_00ec:
            /*Error near IL_00ed: Unexpected return in MoveNext()*/;
        }
Esempio n. 4
0
        public override IEnumerable <IncidentTargetTypeDef> AcceptedTypes()
        {
            using (IEnumerator <IncidentTargetTypeDef> enumerator = base.AcceptedTypes().GetEnumerator())
            {
                if (enumerator.MoveNext())
                {
                    IncidentTargetTypeDef type = enumerator.Current;
                    yield return(type);

                    /*Error: Unable to find new state assignment for yield return*/;
                }
            }
            if (base.Faction == Faction.OfPlayer)
            {
                yield return(IncidentTargetTypeDefOf.MapPlayerHome);

                /*Error: Unable to find new state assignment for yield return*/;
            }
            yield return(IncidentTargetTypeDefOf.MapMisc);

            /*Error: Unable to find new state assignment for yield return*/;
IL_0119:
            /*Error near IL_011a: Unexpected return in MoveNext()*/;
        }
Esempio n. 5
0
            public bool MoveNext()
            {
                uint num = (uint)this.$PC;

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

                switch (num)
                {
                case 0u:
                    enumerator = base.< AcceptedTypes > __BaseCallProxy0().GetEnumerator();
                    num        = 4294967293u;
                    break;

                case 1u:
                    break;

                case 2u:
                    goto IL_118;

                case 3u:
                    goto IL_118;

                default:
                    return(false);
                }
                try
                {
                    switch (num)
                    {
                    }
                    if (enumerator.MoveNext())
                    {
                        type          = enumerator.Current;
                        this.$current = type;
                        if (!this.$disposing)
                        {
                            this.$PC = 1;
                        }
                        flag = true;
                        return(true);
                    }
                }
                finally
                {
                    if (!flag)
                    {
                        if (enumerator != null)
                        {
                            enumerator.Dispose();
                        }
                    }
                }
                if (base.Faction == Faction.OfPlayer)
                {
                    this.$current = IncidentTargetTypeDefOf.Map_PlayerHome;
                    if (!this.$disposing)
                    {
                        this.$PC = 2;
                    }
                }
                else
                {
                    this.$current = IncidentTargetTypeDefOf.Map_Misc;
                    if (!this.$disposing)
                    {
                        this.$PC = 3;
                    }
                }
                return(true);

IL_118:
                this.$PC = -1;
                return(false);
            }