public static bool AreMechsCrossVariantCompartible(MechDef a, MechDef b)
        {
            // a excluded had been checked before
            if (b.IsCrossAssemblyExcluded())
            {
                return(false); // b excluded
            }
            string va = a.Chassis.GetVariant();
            string vb = b.Chassis.GetVariant();

            if (IsCrossAssemblyOverrideEnabled(a, b, va, vb))
            {
                return(true); // override enabled
            }
            if (string.IsNullOrEmpty(va) || !va.Equals(vb))
            {
                return(false); // wrong or invalid variant
            }
            if (a.Chassis.MovementCapDef == null)
            {
                a.Chassis.RefreshMovementCaps();
                if (a.Chassis.MovementCapDef == null)
                {
                    Log.LogError(string.Format("{0} {1} (a) has no MovementCapDef, aborting speed comparison", a.Chassis.Description.UIName, a.Chassis.VariantName));
                    return(false);
                }
            }
            if (b.Chassis.MovementCapDef == null)
            {
                b.Chassis.RefreshMovementCaps();
                if (b.Chassis.MovementCapDef == null)
                {
                    Log.LogError(string.Format("{0} {1} (b) has no MovementCapDef, aborting speed comparison", b.Chassis.Description.UIName, b.Chassis.VariantName));
                    return(false);
                }
            }
            if (Settings.CrossAssemblySpeedMatch && (a.Chassis.MovementCapDef.MaxWalkDistance != b.Chassis.MovementCapDef.MaxWalkDistance))
            {
                return(false); // speed missmatch
            }
            if (Settings.CrossAssemblyTonnsMatch && (a.Chassis.Tonnage != b.Chassis.Tonnage))
            {
                return(false); // tonnage missmatch
            }
            foreach (string tag in Settings.CrossAssemblyTagsMatch)
            {
                if (a.Chassis.ChassisTags.Contains(tag) != b.Chassis.ChassisTags.Contains(tag))
                {
                    return(false); // tag missmatch
                }
            }
            foreach (string it in Settings.CrossAssemblyInventoryMatch)
            {
                if (a.CountMechInventory(it) != b.CountMechInventory(it))
                {
                    return(false); // inventory mismatch
                }
            }
            return(true);
        }
        public static bool AreVehicleMechsCompatible(MechDef a, MechDef b)
        {
            // aexcluded already checked, as well as a+b vehicle
            if (b.IsCrossAssemblyExcluded())
            {
                return(false); // b excluded
            }
            string va = a.Chassis.GetVariant();
            string vb = b.Chassis.GetVariant();

            return(va != null && vb != null && va.Equals(vb));
        }
        public static IEnumerable <MechDef> GetAllNonOmniVariants(SimGameState s, MechDef m)
        {
            yield return(m);

            if (IsCrossAssemblyAllowed(s) && !m.IsCrossAssemblyExcluded())
            {
                foreach (KeyValuePair <string, MechDef> kv in s.DataManager.MechDefs)
                {
                    if (!m.Chassis.Description.Id.Equals(kv.Value.Chassis.Description.Id) && !kv.Value.IsVehicle() && !kv.Value.IsMechDefCustom() &&
                        (Settings.AllowNonMainVariants || kv.Value.IsMechDefMain()) && AreMechsCrossVariantCompartible(m, kv.Value))
                    {
                        yield return(kv.Value);
                    }
                }
            }
        }
        public static IEnumerable <MechDef> GetAllVehicleMechVariants(SimGameState s, MechDef m)
        {
            //FileLog.Log($"getting vehicle variants for {m.Description.Id}");
            yield return(m);

            if (IsCrossAssemblyAllowed(s) && !m.IsCrossAssemblyExcluded())
            {
                foreach (KeyValuePair <string, MechDef> kv in s.DataManager.MechDefs)
                {
                    if (!m.Chassis.Description.Id.Equals(kv.Value.Chassis.Description.Id) && kv.Value.IsVehicle() && !kv.Value.IsMechDefCustom() &&
                        (Settings.AllowNonMainVariants || kv.Value.IsMechDefMain()) && AreVehicleMechsCompatible(m, kv.Value))
                    {
                        //FileLog.Log($"variant found {kv.Value.Description.Id}");
                        yield return(kv.Value);
                    }
                }
            }
        }
        public static bool AreOmniMechsCompartible(MechDef a, MechDef b)
        {
            // a omni & a excluded had been checked before
            if (!b.Chassis.IsOmni()) // no omni
            {
                return(false);
            }
            if (b.IsCrossAssemblyExcluded())
            {
                return(false); // b excluded
            }
            string va = a.Chassis.GetVariant();
            string vb = b.Chassis.GetVariant();

            if (IsCrossAssemblyOverrideEnabled(a, b, va, vb))
            {
                return(true); // override enabled
            }
            if (string.IsNullOrEmpty(va) || !va.Equals(vb))
            {
                return(false); // wrong or invalid variant
            }
            return(true);
        }