Beispiel #1
0
        public static void TryAddAmmoToScenario(ScenarioDef ScenDef)
        {
            List <ScenPart> parts     = Traverse.Create(ScenDef.scenario).Field("parts").GetValue <List <ScenPart> >();
            List <ScenPart> ammoParts = new List <ScenPart>();

            foreach (ScenPart scenpart in parts.Where(x => x.def == ScenPartDefOf.StartingThing_Defined))
            {
                ThingDef td = Traverse.Create(scenpart).Field("thingDef").GetValue <ThingDef>();
                if (td.IsWeapon)
                {
                    if (td.IsWeaponUsingProjectiles || td.IsRangedWeapon)
                    {
                        ThingDef Weapon = td;
                        if (AdeptusIntergrationUtility.enabled_CombatExtended && Weapon.IsRangedWeapon)
                        {
                            if (Weapon.comps.Any(x => x.GetType().ToString().Contains("CompProperties_AmmoUser")))
                            {
                                int count = ScenDef.defName.StartsWith("OGAM_TestScenario_") ? -1 : 100;
                                AddAmmoCE(Weapon, ref ammoParts, count, 1, false); // Prefs.DevMode
                            }
                        }
                    }
                }
            }
            if (!ammoParts.NullOrEmpty())
            {
                parts.AddRange(ammoParts);
            }
        }
        public static ScenarioDef InventoryMoverBotOver3GConnection()
        {
            var test = new ScenarioDef();

            test.Connect("botnet", "public", NetworkProfile.Mobile3G);
            test.Connect("public", "internal", NetworkProfile.AzureIntranet);

            test.AddService("cl.internal", InstallCommitLog);
            test.AddService("api1.public", InstallBackend("cl.internal"));
            test.AddService("api2.public", InstallBackend("cl.internal"));


            var mover = new InventoryMoverBot {
                Servers          = new [] { "api1.public", "api2.public" },
                RingSize         = 7,
                Iterations       = 30,
                Delay            = 4.Sec(),
                HaltOnCompletion = true
            };

            test.AddBot(mover);

            var monkey = new GracefulChaosMonkey {
                ApplyToMachines     = s => s.StartsWith("api"),
                DelayBetweenStrikes = r => r.Next(5, 10).Sec()
            };

            test.Plan = monkey.Run;
            return(test);
        }
        public static ScenarioDef InventoryMoverOverStableConnection()
        {
            var test = new ScenarioDef();

            test.Connect("bot", "public");
            test.Connect("public", "internal");

            test.AddService("cl.internal", InstallCommitLog);
            test.AddService("api1.public", InstallBackend("cl.internal"));
            test.AddService("api2.public", InstallBackend("cl.internal"));

            var bot = new InventoryMoverBot("api1.public", "api2.public")
            {
                RingSize         = 5,
                Iterations       = 10,
                Delay            = 5.Sec(),
                HaltOnCompletion = true
            };

            test.AddBot(bot);
            test.Plan = async plan => {
                plan.StartServices();
                await plan.Delay(6.Sec());

                plan.Debug(LogType.Fault, "REIMAGE api1");
                await plan.StopServices(s => s.Machine == "api1.public", grace : 1.Sec());

                plan.WipeStorage("api1");
                await plan.Delay(2.Sec());

                plan.Debug(LogType.Fault, "START api1");
                plan.StartServices(s => s.Machine == "api1.public");
            };
            return(test);
        }
        public static void TryAddTestingWeaponsToScenario(ScenarioDef ScenDef, List <string> tags)
        {
            List <ThingDef> things = DefDatabase <ThingDef> .AllDefsListForReading.FindAll(x => x.IsRangedWeapon && x.defName.StartsWith("OG") && (tags.Any(y => x.weaponTags.ToCommaList().Contains(y)) || tags.Any(y => x.defName.Contains(y))));

            List <ScenPart> parts = ScenDef.scenario.parts;

            foreach (ThingDef Weapon in things)
            {
                bool hasweapon = false;
                foreach (ScenPart scenpart in parts.Where(x => x.def == ScenPartDefOf.StartingThing_Defined))
                {
                    ScenPart_StartingThing_Defined startingThing = scenpart as ScenPart_StartingThing_Defined;
                    if (startingThing != null)
                    {
                        ThingDef td = startingThing.thingDef;//
                        if (td == Weapon)
                        {
                            hasweapon = true;
                            break;
                        }
                    }
                }
                if (hasweapon)
                {
                    continue;
                }
                ScenPart_StartingThing_Define StartingThing = new ScenPart_StartingThing_Define()
                {
                    def = ScenPartDefOf.StartingThing_Defined
                };
                if (Weapon.MadeFromStuff)
                {
                    ThingDef stuffdef = DefDatabase <ThingDef> .AllDefsListForReading.Where(x => x.IsStuff && Weapon.stuffCategories.Any(y => x.stuffProps.categories.Contains(y))).RandomElement();

                    if (stuffdef != null)
                    {
                        StartingThing.ThingDefStuff = stuffdef;
                    }
                }
                StartingThing.ThingDef = Weapon;
                parts.Add(StartingThing);
            }
        }
        public static void TryAddLaserWeaponsToScenario(ScenarioDef ScenDef)
        {
            List <ThingDef> things = DefDatabase <ThingDef> .AllDefsListForReading.FindAll(x => x.IsRangedWeapon && x.Verbs.Any(z => z.defaultProjectile as LaserBeamDef != null));

            foreach (ThingDef Weapon in things)
            {
                bool            hasweapon = false;
                List <ScenPart> parts     = ScenDef.scenario.parts;
                foreach (ScenPart scenpart in parts.Where(x => x.def == ScenPartDefOf.StartingThing_Defined))
                {
                    ScenPart_StartingThing_Defined startingThing = scenpart as ScenPart_StartingThing_Defined;
                    if (startingThing != null)
                    {
                        ThingDef td = startingThing.thingDef;//
                        if (td == Weapon)
                        {
                            hasweapon = true;
                            break;
                        }
                    }
                }
                if (hasweapon)
                {
                    continue;
                }
                ScenPart_StartingThing_Define StartingThing = new ScenPart_StartingThing_Define()
                {
                    def = ScenPartDefOf.StartingThing_Defined
                };
                if (Weapon.MadeFromStuff)
                {
                    ThingDef stuffdef = DefDatabase <ThingDef> .AllDefsListForReading.Where(x => x.IsStuff && Weapon.stuffCategories.Any(y => x.stuffProps.categories.Contains(y))).RandomElement();

                    if (stuffdef != null)
                    {
                        StartingThing.ThingDefStuff = stuffdef;
                    }
                }
                StartingThing.ThingDef = Weapon;
                parts.Add(StartingThing);
            }
        }
        public static void TryAddWeaponsToScenario(ScenarioDef ScenDef, string Tag)
        {
            List <ThingDef> things = DefDatabase <ThingDef> .AllDefsListForReading.FindAll(x => ((x.PlayerAcquirable || Tag == "TY") && (x.IsWeapon || x.IsApparel) && x.defName.Contains("OG" + Tag) && !x.defName.Contains("TOGGLEDEF_S")));

            foreach (ThingDef Weapon in things)
            {
                bool            hasweapon = false;
                List <ScenPart> parts     = ScenDef.scenario.parts;
                foreach (ScenPart scenpart in parts.Where(x => x.def == ScenPartDefOf.StartingThing_Defined))
                {
                    ScenPart_StartingThing_Defined startingThing = scenpart as ScenPart_StartingThing_Defined;
                    if (startingThing != null)
                    {
                        ThingDef td = startingThing.thingDef;//
                        if (td == Weapon)
                        {
                            hasweapon = true;
                            break;
                        }
                    }
                }
                if (hasweapon)
                {
                    continue;
                }
                ScenPart_StartingThing_Define StartingThing = new ScenPart_StartingThing_Define()
                {
                    def = ScenPartDefOf.StartingThing_Defined
                };
                if (Weapon.MadeFromStuff)
                {
                    ThingDef stuffdef = DefDatabase <ThingDef> .AllDefsListForReading.Where(x => x.IsStuff && Weapon.stuffCategories.Any(y => x.stuffProps.categories.Contains(y))).RandomElement();

                    if (stuffdef != null)
                    {
                        StartingThing.ThingDefStuff = stuffdef;
                    }
                }
                StartingThing.ThingDef = Weapon;
                parts.Add(StartingThing);
            }
        }
        public static void TryAddRendingWeaponsToScenario(ScenarioDef ScenDef)
        {
            List <ThingDef> things = DefDatabase <ThingDef> .AllDefsListForReading.FindAll(x => x.IsWeapon && x.rendingWeapon());

            foreach (ThingDef Weapon in things)
            {
                bool            hasweapon = false;
                List <ScenPart> parts     = Traverse.Create(ScenDef.scenario).Field("parts").GetValue <List <ScenPart> >();
                foreach (ScenPart scenpart in parts.Where(x => x.def == ScenPartDefOf.StartingThing_Defined))
                {
                    ThingDef td = Traverse.Create(scenpart).Field("thingDef").GetValue <ThingDef>();
                    if (td == Weapon)
                    {
                        hasweapon = true;
                        break;
                    }
                }
                if (hasweapon)
                {
                    continue;
                }
                ScenPart_StartingThing_Define StartingThing = new ScenPart_StartingThing_Define()
                {
                    def = ScenPartDefOf.StartingThing_Defined
                };
                if (Weapon.MadeFromStuff)
                {
                    ThingDef stuffdef = DefDatabase <ThingDef> .AllDefsListForReading.Where(x => x.IsStuff && Weapon.stuffCategories.Any(y => x.stuffProps.categories.Contains(y))).RandomElement();

                    if (stuffdef != null)
                    {
                        StartingThing.ThingDefStuff = stuffdef;
                    }
                }
                StartingThing.ThingDef = Weapon;
                parts.Add(StartingThing);
            }
        }
Beispiel #8
0
        private static void TryAddWeaponsStartingThingToTestScenario(ScenarioDef ScenDef, string Tag)
        {
            List <ThingDef> things = DefDatabase <ThingDef> .AllDefsListForReading.FindAll(x => (x.defName.Contains("OG" + Tag + "_Gun_") || x.defName.Contains("OG" + Tag + "_Melee_") || x.defName.Contains("OG" + Tag + "_Apparel_") || x.defName.Contains("OG" + Tag + "_Wargear_") || x.defName.Contains("OG" + Tag + "_GrenadePack_")) && (!x.defName.Contains("TOGGLEDEF_") || x.defName.Contains("TOGGLEDEF_S")));

            foreach (ThingDef Weapon in things)
            {
                bool            hasweapon = false;
                List <ScenPart> parts     = Traverse.Create(ScenDef.scenario).Field("parts").GetValue <List <ScenPart> >();
                foreach (ScenPart scenpart in parts.Where(x => x.def == ScenPartDefOf.StartingThing_Defined))
                {
                    ThingDef td = Traverse.Create(scenpart).Field("thingDef").GetValue <ThingDef>();
                    if (td == Weapon)
                    {
                        hasweapon = true;
                    }
                }
                if (!hasweapon)
                {
                    ScenPart_StartingThing_Defined _Defined = new ScenPart_StartingThing_Defined()
                    {
                        def = ScenPartDefOf.StartingThing_Defined
                    };
                    Traverse.Create(_Defined).Field("thingDef").SetValue(Weapon);
                    if (Weapon.MadeFromStuff)
                    {
                        ThingDef stuffdef = DefDatabase <ThingDef> .AllDefsListForReading.Where(x => x.IsStuff && Weapon.stuffCategories.Any(y => x.stuffProps.categories.Contains(y))).RandomElement();

                        if (stuffdef != null)
                        {
                            Traverse.Create(_Defined).Field("stuff").SetValue(stuffdef);
                        }
                    }
                    parts.Add(_Defined);
                }
            }
        }
        public static IEnumerable <Scenario> ScenariosInCategoryPostfix(IEnumerable <Scenario> __result, ScenarioCategory cat)
        {
            foreach (Scenario scen in __result)
            {
                if (!DefDatabase <ScenarioDef> .AllDefsListForReading.Any(x => x.scenario.name == scen.name))
                {
                    yield return(scen);

                    continue;
                }
                if (cat == ScenarioCategory.FromDef)
                {
                    ScenarioDef scenDef = DefDatabase <ScenarioDef> .AllDefsListForReading.Find(x => x.scenario.name == scen.name);

                    //   Log.Message("checking name: " + scen.name+ " def: "+ scenDef.defName);
                    if (scenDef.defName.Contains("OGAM_TestScenario_") && SteamUtility.SteamPersonaName != "Ogliss")
                    {
                        //    Log.Message("skipping "+ scen.name);
                        continue;
                    }
                    if (scenDef.defName.Contains("OG_Ork_Tek_Scenario_Test") || scenDef.defName.Contains("OG_Ork_Feral_Tribe") || scenDef.defName.Contains("OG_Eldar_Craftworld_Scenario_Test"))
                    {
                        //    Log.Message("skipping "+ scen.name);
                        continue;
                    }
                    if (scenDef.defName.Contains("OG_Astartes_"))
                    {
                        if (!AMAMod.settings.AllowAdeptusAstartes)
                        {
                            continue;
                        }
                    }

                    if (scenDef.defName.Contains("OG_Mechanicus_"))
                    {
                        if (!AMAMod.settings.AllowAdeptusMechanicus)
                        {
                            continue;
                        }
                    }

                    if (scenDef.defName.Contains("OG_Militarum_"))
                    {
                        if (!AMAMod.settings.AllowAdeptusMilitarum)
                        {
                            continue;
                        }
                    }

                    if (scenDef.defName.Contains("OG_Sororitas_"))
                    {
                        if (!AMAMod.settings.AllowAdeptusSororitas)
                        {
                            continue;
                        }
                    }

                    if (scenDef.defName.Contains("OG_Choas_Deamons_"))
                    {
                        if (!AMAMod.settings.AllowChaosDeamons)
                        {
                            continue;
                        }
                    }

                    if (scenDef.defName.Contains("OG_Choas_Guard_"))
                    {
                        if (!AMAMod.settings.AllowChaosGuard)
                        {
                            continue;
                        }
                    }

                    if (scenDef.defName.Contains("OG_Choas_Marine_"))
                    {
                        if (!AMAMod.settings.AllowChaosMarine)
                        {
                            continue;
                        }
                    }

                    if (scenDef.defName.Contains("OG_Choas_Mechanicus_"))
                    {
                        if (!AMAMod.settings.AllowChaosMechanicus)
                        {
                            continue;
                        }
                    }

                    if (scenDef.defName.Contains("OG_DarkEldar_"))
                    {
                        if (!AMAMod.settings.AllowDarkEldar)
                        {
                            continue;
                        }
                    }

                    if (scenDef.defName.Contains("OG_Eldar_"))
                    {
                        if (scenDef.defName.Contains("Craftworld"))
                        {
                            if (!AMAMod.settings.AllowEldarCraftworld)
                            {
                                continue;
                            }
                        }
                        if (scenDef.defName.Contains("Exodite"))
                        {
                            if (!AMAMod.settings.AllowEldarExodite)
                            {
                                continue;
                            }
                        }
                        if (scenDef.defName.Contains("Harlequinn"))
                        {
                            if (!AMAMod.settings.AllowEldarHarlequinn)
                            {
                                continue;
                            }
                        }
                    }

                    if (scenDef.defName.Contains("OG_Tau_"))
                    {
                        if (!AMAMod.settings.AllowTau)
                        {
                            continue;
                        }
                    }

                    if (scenDef.defName.Contains("OG_Kroot_"))
                    {
                        if (!AMAMod.settings.AllowKroot)
                        {
                            continue;
                        }
                    }

                    if (scenDef.defName.Contains("OG_Vespid_"))
                    {
                        if (!AMAMod.settings.AllowVespidAuxiliaries)
                        {
                            continue;
                        }
                    }

                    if (scenDef.defName.Contains("OG_Ork_") || scenDef.defName.Contains("OG_Grot_"))
                    {
                        if (scenDef.defName.Contains("Tek"))
                        {
                            if (!AMAMod.settings.AllowOrkTek)
                            {
                                continue;
                            }
                        }
                        if (scenDef.defName.Contains("Feral"))
                        {
                            if (!AMAMod.settings.AllowOrkFeral)
                            {
                                continue;
                            }
                        }
                    }
                }
                yield return(scen);
            }
            yield break;
        }
Beispiel #10
0
        public static IEnumerable <Scenario> ScenariosInCategoryPrefix(IEnumerable <Scenario> __result, ScenarioCategory cat)
        {
            foreach (Scenario scen in __result)
            {
                if (!DefDatabase <ScenarioDef> .AllDefsListForReading.Any(x => x.scenario.name == scen.name))
                {
                    continue;
                }
                if (cat == ScenarioCategory.FromDef)
                {
                }
                ScenarioDef scenDef = DefDatabase <ScenarioDef> .AllDefsListForReading.Find(x => x.scenario.name == scen.name);

                if (scenDef.defName.Contains("OG_Astartes_"))
                {
                    if (!AMAMod.settings.AllowAdeptusAstartes)
                    {
                        continue;
                    }
                }

                if (scenDef.defName.Contains("OG_Mechanicus_"))
                {
                    if (!AMAMod.settings.AllowAdeptusMechanicus)
                    {
                        continue;
                    }
                }

                if (scenDef.defName.Contains("OG_Militarum_"))
                {
                    if (!AMAMod.settings.AllowAdeptusMilitarum)
                    {
                        continue;
                    }
                }

                if (scenDef.defName.Contains("OG_Sororitas_"))
                {
                    if (!AMAMod.settings.AllowAdeptusSororitas)
                    {
                        continue;
                    }
                }

                if (scenDef.defName.Contains("OG_Choas_Deamons_"))
                {
                    if (!AMAMod.settings.AllowChaosDeamons)
                    {
                        continue;
                    }
                }

                if (scenDef.defName.Contains("OG_Choas_Guard_"))
                {
                    if (!AMAMod.settings.AllowChaosGuard)
                    {
                        continue;
                    }
                }

                if (scenDef.defName.Contains("OG_Choas_Marine_"))
                {
                    if (!AMAMod.settings.AllowChaosMarine)
                    {
                        continue;
                    }
                }

                if (scenDef.defName.Contains("OG_Choas_Mechanicus_"))
                {
                    if (!AMAMod.settings.AllowChaosMechanicus)
                    {
                        continue;
                    }
                }

                if (scenDef.defName.Contains("OG_Dark_Eldar_"))
                {
                    if (!AMAMod.settings.AllowDarkEldar)
                    {
                        continue;
                    }
                }

                if (scenDef.defName.Contains("OG_Eldar_"))
                {
                    if (scenDef.defName.Contains("Craftworld"))
                    {
                        if (!AMAMod.settings.AllowEldarCraftworld)
                        {
                            continue;
                        }
                    }
                    if (scenDef.defName.Contains("Exodite"))
                    {
                        if (!AMAMod.settings.AllowEldarExodite)
                        {
                            continue;
                        }
                    }
                    if (scenDef.defName.Contains("Harlequinn"))
                    {
                        if (!AMAMod.settings.AllowEldarHarlequinn)
                        {
                            continue;
                        }
                    }
                }

                if (scenDef.defName.Contains("OG_Tau_"))
                {
                    if (!AMAMod.settings.AllowTau)
                    {
                        continue;
                    }
                }

                if (scenDef.defName.Contains("OG_Kroot_"))
                {
                    if (!AMAMod.settings.AllowKroot)
                    {
                        continue;
                    }
                }

                if (scenDef.defName.Contains("OG_Vespid_"))
                {
                    if (!AMAMod.settings.AllowVespidAuxiliaries)
                    {
                        continue;
                    }
                }

                if (scenDef.defName.Contains("OG_Ork_") || scenDef.defName.Contains("OG_Grot_"))
                {
                    if (scenDef.defName.Contains("Tek"))
                    {
                        if (!AMAMod.settings.AllowOrkTek)
                        {
                            continue;
                        }
                    }
                    if (scenDef.defName.Contains("Feral"))
                    {
                        if (!AMAMod.settings.AllowOrkFeral)
                        {
                            continue;
                        }
                    }
                }
                yield return(scen);
            }
            yield break;
        }