Exemple #1
0
        public CompSidearmMemory() : base()
        {
            if (Owner != null)
            {
                if (Owner.IsColonist)
                {
                    primaryWeaponMode = SimpleSidearms.ColonistDefaultWeaponMode.Value;
                }
                else
                {
                    primaryWeaponMode = SimpleSidearms.NPCDefaultWeaponMode.Value;
                }

                if (primaryWeaponMode == PrimaryWeaponMode.ByGenerated)
                {
                    if (Owner.equipment == null || Owner.equipment.Primary == null)
                    {
                        primaryWeaponMode = PrimaryWeaponMode.BySkill;
                    }
                    else if (Owner.equipment.Primary.def.IsRangedWeapon)
                    {
                        primaryWeaponMode = PrimaryWeaponMode.Ranged;
                    }
                    else if (Owner.equipment.Primary.def.IsMeleeWeapon)
                    {
                        primaryWeaponMode = PrimaryWeaponMode.Melee;
                    }
                    else
                    {
                        primaryWeaponMode = PrimaryWeaponMode.BySkill;
                    }
                }
            }
        }
Exemple #2
0
        public void backfillFromGoldfish(GoldfishModule obsoleteMemory)
        {
            this.rememberedWeapons = obsoleteMemory.rememberedWeapons;

            this.forcedWeaponEx              = obsoleteMemory.forcedWeaponEx;
            this.forcedUnarmedEx             = obsoleteMemory.forcedUnarmedEx;
            this.forcedWeaponWhileDraftedEx  = obsoleteMemory.forcedWeaponWhileDraftedEx;
            this.forcedUnarmedWhileDraftedEx = obsoleteMemory.forcedUnarmedWhileDraftedEx;

            this.preferredUnarmedEx     = obsoleteMemory.preferredUnarmedEx;
            this.defaultRangedWeaponEx  = obsoleteMemory.defaultRangedWeaponEx;
            this.preferredMeleeWeaponEx = obsoleteMemory.preferredMeleeWeaponEx;

            this.primaryWeaponMode = obsoleteMemory.primaryWeaponMode;
        }
        public GoldfishModule(Pawn owner, bool fillExisting)
        {
            this.rememberedWeapons = new List <ThingDefStuffDefPair>();
            this.Owner             = owner;
            if (fillExisting)
            {
                generateRememberedWeaponsFromEquipped();
            }
            if (owner != null) //null owner should only come up when loading from savegames
            {
                if (owner.IsColonist)
                {
                    primaryWeaponMode = SimpleSidearms.ColonistDefaultWeaponMode.Value;
                }
                else
                {
                    primaryWeaponMode = SimpleSidearms.NPCDefaultWeaponMode.Value;
                }

                if (primaryWeaponMode == PrimaryWeaponMode.ByGenerated)
                {
                    if (Owner == null || Owner.equipment == null || owner.equipment.Primary == null)
                    {
                        primaryWeaponMode = PrimaryWeaponMode.BySkill;
                    }
                    else if (owner.equipment.Primary.def.IsRangedWeapon)
                    {
                        primaryWeaponMode = PrimaryWeaponMode.Ranged;
                    }
                    else if (owner.equipment.Primary.def.IsMeleeWeapon)
                    {
                        primaryWeaponMode = PrimaryWeaponMode.Melee;
                    }
                    else
                    {
                        primaryWeaponMode = PrimaryWeaponMode.BySkill;
                    }
                }
            }
        }
Exemple #4
0
        public static void equipBestWeaponFromInventoryByPreference(Pawn pawn, DroppingModeEnum dropMode, PrimaryWeaponMode?modeOverride = null, Pawn target = null)
        {
            if (!pawn.IsValidSidearmsCarrier())
            {
                return;
            }
            CompSidearmMemory pawnMemory = CompSidearmMemory.GetMemoryCompForPawn(pawn);

            if (pawnMemory == null)
            {
                return;
            }

            PrimaryWeaponMode mode = modeOverride == null ? pawnMemory.primaryWeaponMode : modeOverride.Value;

            if ((pawn.CombinedDisabledWorkTags & WorkTags.Violent) != 0)
            {
                if (pawn.equipment.Primary != null)
                {
                    bool success = equipSpecificWeapon(pawn, null, MiscUtils.shouldDrop(pawn, dropMode, false), false);
                    if (success)
                    {
                        return;
                    }
                }
                else
                {
                    return;
                }
            }

            if (pawn.Drafted &&
                (pawnMemory.ForcedUnarmedWhileDrafted || pawnMemory.ForcedUnarmed && pawnMemory.ForcedWeaponWhileDrafted == null))
            {
                if (pawn.equipment.Primary != null)
                {
                    bool success = equipSpecificWeapon(pawn, null, MiscUtils.shouldDrop(pawn, dropMode, false), false);
                    if (success)
                    {
                        return;
                    }
                }
                else
                {
                    return;
                }
            }
            if (pawn.Drafted && pawnMemory.ForcedWeaponWhileDrafted != null)
            {
                if (pawn.equipment.Primary == null || pawn.equipment.Primary.toThingDefStuffDefPair() != pawnMemory.ForcedWeaponWhileDrafted.Value)
                {
                    var requiredWeapon = pawnMemory.ForcedWeaponWhileDrafted.Value;
                    if (!Settings.AllowBlockedWeaponUse && StatCalculator.canCarrySidearmType(requiredWeapon, pawn, out _))
                    {
                        //clear invalid
                        pawnMemory.ForcedWeaponWhileDrafted = null;
                        return;
                    }
                    bool success = equipSpecificWeaponTypeFromInventory(pawn, requiredWeapon, MiscUtils.shouldDrop(pawn, dropMode, false), false);
                    if (success)
                    {
                        return;
                    }
                }
                else
                {
                    return;
                }
            }
            if (pawnMemory.ForcedUnarmed)
            {
                if (pawn.equipment.Primary != null)
                {
                    bool success = equipSpecificWeapon(pawn, null, MiscUtils.shouldDrop(pawn, dropMode, false), false);
                    if (success)
                    {
                        return;
                    }
                }
                else
                {
                    return;
                }
            }
            if (pawnMemory.ForcedWeapon != null)
            {
                if (pawn.equipment.Primary == null || pawn.equipment.Primary.toThingDefStuffDefPair() != pawnMemory.ForcedWeapon.Value)
                {
                    var requiredWeapon = pawnMemory.ForcedWeapon.Value;
                    if (!Settings.AllowBlockedWeaponUse && StatCalculator.canCarrySidearmType(requiredWeapon, pawn, out _))
                    {
                        //clear invalid
                        pawnMemory.ForcedWeapon = null;
                        return;
                    }
                    bool success = equipSpecificWeaponTypeFromInventory(pawn, requiredWeapon, MiscUtils.shouldDrop(pawn, dropMode, false), false);
                    if (success)
                    {
                        return;
                    }
                }
                else
                {
                    return;
                }
            }

            if (mode == PrimaryWeaponMode.Ranged ||
                ((mode == PrimaryWeaponMode.BySkill) && (pawn.getSkillWeaponPreference() == PrimaryWeaponMode.Ranged)))
            {
                if (pawnMemory.DefaultRangedWeapon != null && pawn.hasWeaponType(pawnMemory.DefaultRangedWeapon.Value))
                {
                    if (pawn.equipment.Primary == null || pawn.equipment.Primary.toThingDefStuffDefPair() != pawnMemory.DefaultRangedWeapon.Value)
                    {
                        var requiredWeapon = pawnMemory.DefaultRangedWeapon.Value;
                        if (!Settings.AllowBlockedWeaponUse && StatCalculator.canCarrySidearmType(requiredWeapon, pawn, out _))
                        {
                            //clear invalid
                            pawnMemory.DefaultRangedWeapon = null;
                            return;
                        }
                        bool success = equipSpecificWeaponTypeFromInventory(pawn, requiredWeapon, MiscUtils.shouldDrop(pawn, dropMode, false), false);
                        if (success)
                        {
                            return;
                        }
                    }
                    else
                    {
                        return;
                    }
                }

                else
                {
                    bool skipManualUse = true;
                    bool skipDangerous = pawn.IsColonistPlayerControlled && Settings.SkipDangerousWeapons;
                    bool skipEMP       = true;
                    (ThingWithComps weapon, float dps, float averageSpeed)bestWeapon = GettersFilters.findBestRangedWeapon(pawn, null, skipManualUse, skipDangerous, skipEMP);
                    if (bestWeapon.weapon != null)
                    {
                        if (pawn.equipment.Primary != bestWeapon.weapon)
                        {
                            bool success = equipSpecificWeaponFromInventory(pawn, bestWeapon.weapon, MiscUtils.shouldDrop(pawn, dropMode, false), false);
                            if (success)
                            {
                                return;
                            }
                        }
                        else
                        {
                            return;
                        }
                    }
                }
            }

            //all that's left is either melee preference or no ranged weapon found - so in either case, we want to equip a melee weapon.

            /*if (mode == GoldfishModule.PrimaryWeaponMode.Melee ||
             *  ((mode == GoldfishModule.PrimaryWeaponMode.BySkill) && (pawn.getSkillWeaponPreference() == GoldfishModule.PrimaryWeaponMode.Melee)))*/
            {
                //Log.Message("melee mode");
                //prefers melee
                if (pawnMemory.PreferredUnarmed)
                {
                    if (pawn.equipment.Primary != null)
                    {
                        bool success = equipSpecificWeapon(pawn, null, MiscUtils.shouldDrop(pawn, dropMode, false), false);
                        if (success)
                        {
                            return;
                        }
                    }
                    else
                    {
                        return;
                    }
                }
                else
                {
                    if (pawnMemory.PreferredMeleeWeapon != null && pawn.hasWeaponType(pawnMemory.PreferredMeleeWeapon.Value))
                    {
                        if (pawn.equipment.Primary == null || pawn.equipment.Primary.toThingDefStuffDefPair() != pawnMemory.PreferredMeleeWeapon.Value)
                        {
                            var requiredWeapon = pawnMemory.PreferredMeleeWeapon.Value;
                            if (!Settings.AllowBlockedWeaponUse && StatCalculator.canCarrySidearmType(requiredWeapon, pawn, out _))
                            {
                                //clear invalid
                                pawnMemory.PreferredMeleeWeapon = null;
                                return;
                            }
                            bool success = equipSpecificWeaponTypeFromInventory(pawn, requiredWeapon, MiscUtils.shouldDrop(pawn, dropMode, false), false);
                            if (success)
                            {
                                return;
                            }
                        }
                        else
                        {
                            return;
                        }
                    }
                    else
                    {
                        ThingWithComps result;
                        bool           foundAlternative = GettersFilters.findBestMeleeWeapon(pawn, out result, includeRangedWithBash: false);
                        if (foundAlternative)
                        {
                            if (pawn.equipment.Primary != result)
                            {
                                bool success = equipSpecificWeaponFromInventory(pawn, result, MiscUtils.shouldDrop(pawn, dropMode, false), false);
                                if (success)
                                {
                                    return;
                                }
                            }
                            else
                            {
                                return;
                            }
                        }
                    }
                }
            }
            return;
        }
        public void ApplyBaseSettings()
        {
            ToolAutoSwitch         = true;
            OptimalMelee           = true;
            CQCAutoSwitch          = true;
            CQCTargetOnly          = false;
            RangedCombatAutoSwitch = true;

            RangedCombatAutoSwitchMaxWarmup = 0.75f;

            SpeedSelectionBiasMelee  = 1f;
            SpeedSelectionBiasRanged = 1.1f;

            SeparateModes   = false;
            LimitModeSingle = LimitModeSingleSidearm.None;
            LimitModeAmount = LimitModeAmountOfSidearms.None;

            LimitModeSingleMelee  = LimitModeSingleSidearm.None;
            LimitModeAmountMelee  = LimitModeAmountOfSidearms.None;
            LimitModeSingleRanged = LimitModeSingleSidearm.None;
            LimitModeAmountRanged = LimitModeAmountOfSidearms.None;
            LimitModeAmountTotal  = LimitModeAmountOfSidearms.None;

            #region LimitModeSingle
            LimitModeSingle_AbsoluteMass = 1.9f;
            LimitModeSingle_RelativeMass = 0.25f;
            LimitModeSingle_Selection    = GettersFilters.getValidWeaponsThingDefsOnly().Where(w => w.GetStatValueAbstract(StatDefOf.Mass) <= LimitModeSingle_AbsoluteMass).ToHashSet();
            #endregion
            #region LimitModeAmount
            LimitModeAmount_AbsoluteMass = 10f;
            LimitModeAmount_RelativeMass = 0.5f;
            LimitModeAmount_Slots        = 2;
            #endregion

            #region LimitModeSingleMelee
            LimitModeSingleMelee_AbsoluteMass = 1.9f;
            LimitModeSingleMelee_RelativeMass = 0.25f;
            LimitModeSingleMelee_Selection    = GettersFilters.filterForWeaponKind(GettersFilters.getValidWeaponsThingDefsOnly(), WeaponSearchType.Melee).Where(w => w.GetStatValueAbstract(StatDefOf.Mass) <= LimitModeSingleMelee_AbsoluteMass).ToHashSet();
            #endregion
            #region LimitModeAmountMelee
            LimitModeAmountMelee_AbsoluteMass = 10f;
            LimitModeAmountMelee_RelativeMass = 0.5f;
            LimitModeAmountMelee_Slots        = 2;
            #endregion

            #region LimitModeSingleRanged
            LimitModeSingleRanged_AbsoluteMass = 2.55f;
            LimitModeSingleRanged_RelativeMass = 0.25f;
            LimitModeSingleRanged_Selection    = GettersFilters.filterForWeaponKind(GettersFilters.getValidWeaponsThingDefsOnly(), WeaponSearchType.Ranged).Where(w => w.GetStatValueAbstract(StatDefOf.Mass) <= LimitModeSingleRanged_AbsoluteMass).ToHashSet();
            #endregion
            #region LimitModeAmountRanged
            LimitModeAmountRanged_AbsoluteMass = 10f;
            LimitModeAmountRanged_RelativeMass = 0.5f;
            LimitModeAmountRanged_Slots        = 2;
            #endregion

            #region LimitModeAmountTotal
            LimitModeAmountTotal_AbsoluteMass = 10f;
            LimitModeAmountTotal_RelativeMass = 0.5f;
            LimitModeAmountTotal_Slots        = 4;
            #endregion

            SidearmSpawnChance        = 0.5f;
            SidearmSpawnChanceDropoff = 0.25f;
            SidearmBudgetMultiplier   = 0.5f;
            SidearmBudgetDropoff      = 0.25f;

            ColonistDefaultWeaponMode = PrimaryWeaponMode.BySkill;
            NPCDefaultWeaponMode      = PrimaryWeaponMode.ByGenerated;

            FumbleMode           = FumbleModeOptionsEnum.InDistress;
            FumbleRecoveryChance = new SimpleCurve(defaultFumbleRecoveryChancePoints);
            ReEquipOutOfCombat   = true;
            ReEquipBest          = true;
            ReEquipInCombat      = true;

            PreserveInventoryInCaravans  = true;
            HideSidearmsInCaravanDialogs = true;
        }