public override InteractionTestResult Test(ref InteractionInstanceParameters parameters, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
 {
     using(WoohooTuningControl control = new WoohooTuningControl(parameters.InteractionObjectPair.Tuning, Woohooer.Settings.mAllowTeenSkinnyDip))
     {
         return base.Test(ref parameters, ref greyedOutTooltipCallback);
     }
 }

 public override bool Test(Sim a, RabbitHole target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
 {
     try
     {
         if (a.FamilyFunds < CollegeOfBusiness.kCostOfBudgetClass)
         {
             return false;
         }
         if (!SimClock.IsTimeBetweenTimes(CollegeOfBusiness.AttendBudgetClass.kStartAvailibilityTime, CollegeOfBusiness.AttendBudgetClass.kEndAvailibilityTime))
         {
             return false;
         }
         /*
         if (!GameUtils.IsUniversityWorld())
         {
             return false;
         }
         */
         float num = 0f;
         if (CollegeOfBusiness.AttendBudgetClass.sCooldownDict.TryGetValue(a.SimDescription.SimDescriptionId, out num))
         {
             return ((SimClock.ElapsedTime(TimeUnit.Hours) - num) > CollegeOfBusiness.AttendBudgetClass.kInteractionCooldown);
         }
         return true;
     }
     catch (Exception e)
     {
         Common.Exception(a, target, e);
         return false;
     }
 }

            public override bool Test(Sim a, EquestrianCenter target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
            {
                PetPool pool;
                if (!PetPoolManager.TryGetPetPool(PetPoolType.BuySellHorse, out pool, false))
                {
                    greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(EquestrianCenter.BuyHorse.LocalizeString(a.IsFemale, "PoolEmpty", new object[0x0]));
                    return false;
                }

                /*
                if (!a.Household.CanAddSpeciesToHousehold(CASAgeGenderFlags.Horse, 0x1, true))
                {
                    greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(EquestrianCenter.BuyHorse.LocalizeString(a.IsFemale, "TooManyPetsInHousehold", new object[0x0]));
                    return false;
                }
                */

                Lot lotHome = a.LotHome;
                if ((lotHome != null) && lotHome.HasVirtualResidentialSlots)
                {
                    greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(PetAdoption.LocalizeString(a.IsFemale, "CannotAdoptHorse", new object[0]));
                    return false;
                }

                return true;
            }

            public override bool Test(Sim a, Book target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
            {
                if (target is BookToddler)
                {
                    if (!a.Inventory.Contains(target))
                    {
                        if (isAutonomous) return false;
                    }

                    if (a.LotHome != a.LotCurrent) return false;
                }
                else
                {
                    if (a.Inventory.Contains(target) && (a.LotCurrent != a.LotHome))
                    {
                        return false;
                    }
                }

                if (target.InUse || (Bookshelf.FindClosestBookshelf(a, target, a.Inventory.Contains(target)) == null))
                {
                    return false;
                }

                if (!target.IsServiceableBySim(a))
                {
                    return false;
                }

                return true;
            }

            public override bool Test(Sim actor, Sim target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
            {
                try
                {
                    HotairBalloon.InBalloonPosture posture = actor.Posture as HotairBalloon.InBalloonPosture;
                    if (posture == null)
                    {
                        return false;
                    }

                    if (posture.Balloon.GetOtherSim(actor) == null)
                    {
                        return false;
                    }

                    // Custom
                    return HotAirBalloonProposal.ProposalTest(posture.Balloon, actor, target, isAutonomous, ref greyedOutTooltipCallback);
                }
                catch (ResetException)
                {
                    throw;
                }
                catch (Exception e)
                {
                    Common.Exception(actor, target, e);
                    return false;
                }
            }

            public override bool Test(Sim a, VoucherCloneMe target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
            {
                target.TargetScienceLab = Voucher.FindNearestScienceLab(a);
                if (target.TargetScienceLab == null)
                {
                    return false;
                }

                /*
                if (!Household.ActiveHousehold.CanAddSpeciesToHousehold(a.SimDescription.Species))
                {
                    greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(Localization.LocalizeString(a.IsFemale, "Gameplay/Objects/RabbitHoles/ScienceLab:HouseholdTooLarge", new object[0x0]));
                    return false;
                }

                if (a.OccultManager.HasAnyOccultType())
                {
                    return false;
                }

                if (a.SimDescription.IsGhost)
                {
                    return false;
                }
                */

                if (GameUtils.IsOnVacation())
                {
                    greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(Localization.LocalizeString(a.IsFemale, "Ui/Tooltip/Vacation/GreyedoutTooltip:InteractionNotValidOnVacation", new object[0x0]));
                    return false;
                }

                return true;
            }

            public override bool Test(Sim a, WeddingArch target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
            {
                try
                {
                    SimDescription partner = a.Partner;
                    if (partner == null)
                    {
                        return false;
                    }
                    Sim createdSim = partner.CreatedSim;
                    if ((createdSim == null) || !a.IsEngaged)
                    {
                        return false;
                    }
                    if (createdSim.LotCurrent != target.LotCurrent)
                    {
                        greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(WeddingArch.LocalizeString(a.IsFemale, "FianceNotOnLot", new object[] { createdSim }));
                        return false;
                    }

                    string reason;
                    if (!CommonSocials.CanGetRomantic(a, createdSim, false, false, true, ref greyedOutTooltipCallback, out reason))
                    {
                        return false;
                    }

                    return CommonSocials.CanGetMarriedNow(a, createdSim, isAutonomous, false, ref greyedOutTooltipCallback);
                }
                catch (Exception e)
                {
                    Common.Exception(a, target, e);
                    return false;
                }
            }

 public override bool Test(Sim a, ScienceResearchStation target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
 {
     if (target.Repairable.Broken)
     {
         greyedOutTooltipCallback = new GreyedOutTooltipCallback(target.StationIsBroken);
         return false;
     }
     ScienceSkill element = (ScienceSkill)a.SkillManager.GetElement(SkillNames.Science);
     if ((element == null) || (element.SkillLevel < ScientificSample.CloneFromSample.MinScienceSkillLevel))
     {
         greyedOutTooltipCallback = new GreyedOutTooltipCallback(ScienceResearchStation.DisplayLevelTooLowTooltip);
         return false;
     }
     new List<InventoryStack>();
     bool flag = false;
     foreach (InventoryStack stack in a.Inventory.InventoryItems.Values)
     {
         ScientificSample sample = null;
         if (stack != null)
         {
             sample = stack.List[0].Object as ScientificSample;
         }
         if ((sample != null) && ((sample.ScientificSampleType != ScientificSample.SampleType.Dna) /*|| (!GameUtils.IsUniversityWorld() && a.Household.CanAddSpeciesToHousehold(CASAgeGenderFlags.None | CASAgeGenderFlags.Human))*/ ))
         {
             flag = true;
             break;
         }
     }
     if (!flag)
     {
         greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(ScienceResearchStation.LocalizeString("SampleNotPresent", new object[0]));
         return false;
     }
     return flag;
 }

 public override bool Test(Sim a, RabbitHole target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
 {
     try
     {
         if (a.FamilyFunds < CollegeOfBusiness.kCostOfResumeInterviewClass)
         {
             return false;
         }
         if (!SimClock.IsTimeBetweenTimes(CollegeOfBusiness.AttendResumeWritingAndInterviewTechniquesClass.kStartAvailibilityTime, CollegeOfBusiness.AttendResumeWritingAndInterviewTechniquesClass.kEndAvailibilityTime))
         {
             return false;
         }
         /*
         if (!GameUtils.IsUniversityWorld())
         {
             return false;
         }
         */
         return true;
     }
     catch (Exception e)
     {
         Common.Exception(a, target, e);
         return false;
     }
 }

            public override bool Test(Sim actor, Jetpack target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
            {
                if (!Jetpack.IsAllowedToUseJetpack(actor))
                {
                    return false;
                }
                if (actor.GetActiveJetpack() == null)
                {
                    return false;
                }
                if (actor.GetActiveJetpack() != target)
                {
                    return false;
                }

                /*
                if (actor.SimDescription.IsPregnant)
                {
                    greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(Localization.LocalizeString(actor.IsFemale, "Gameplay/Actors/Sim:PregnantFailure", new object[0x0]));
                    return false;
                }
                */
                return true;

            }

            public override bool Test(Sim a, Sim target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
            {
                OccultImaginaryFriend friend;
                if (!OccultImaginaryFriend.TryGetOccultFromSim(target, out friend) || friend.IsReal)
                {
                    return false;
                }
                
                if (friend.OwnerSimDescriptionId != a.SimDescription.SimDescriptionId)
                {
                    return false;
                }
                
                Relationship relationship = Relationship.Get(a, target, false);
                bool flag = (relationship != null) && (relationship.CurrentLTRLiking >= OccultImaginaryFriend.kRelationshipThresholdBeforeCanTurnFriendReal);
                
                if (a.Inventory.Find<IImaginaryFriendPotion>(true) == null)
                {
                    if (flag)
                    {
                        greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(OccultImaginaryFriend.LocalizeString(a.IsFemale, "NeedImaginaryFriendPotion", new object[] { a }));
                    }
                    return false;
                }
                
                if (!flag)
                {
                    greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(OccultImaginaryFriend.LocalizeString(new bool[] { a.IsFemale, target.IsFemale }, "NeedRelToUseImaginaryFriendPotion", new object[] { a, target }));
                    return false;
                }

                return true;
            }

        public static bool CallbackTest(Sim actor, Sim target, ActiveTopic topic, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
        {
            try
            {
                if (target.Household == null)
                {
                    greyedOutTooltipCallback = Common.DebugTooltip("No Household");
                    return false;
                }

                if (target.Household == actor.Household)
                {
                    greyedOutTooltipCallback = Common.DebugTooltip("Same Household");
                    return false;
                }

                if (target.Household.IsSpecialHousehold)
                {
                    greyedOutTooltipCallback = Common.DebugTooltip("Special Household");
                    return false;
                }

                return true;
            }
            catch (Exception e)
            {
                Common.Exception(actor, target, e);
                return false;
            }
        }

            public override bool Test(Sim actor, Terrain target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
            {
                if ((actor != null) && (actor.LotCurrent == actor.LotHome) && (Sims3.Gameplay.Queries.CountObjects<ITeleporter>(actor.LotHome) > 0x0))
                {
                    return false;
                }

                if (GoHere.Settings.mTeleportForAll) return true;

                if (GoHere.Settings.mVampireTeleport)
                {
                    if (actor.SimDescription.IsVampire) return true;

                    if (actor.SimDescription.IsPlayableGhost) return true;

                    if (actor.SimDescription.IsUnicorn) return true;

                    if (actor.SimDescription.IsGenie) return true;

                    if (actor.SimDescription.IsFairy) return true;

                    if (actor.SimDescription.IsWitch) return true;
                }

                return false;
            }

            public override bool Test(Sim a, JuiceKeg target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
            {
                try
                {
                    if (target.IsHaunted)
                    {
                        return false;
                    }

                    if (!Woohooer.Settings.mUnlockTeenActions)
                    {
                        if (a.SimDescription.TeenOrBelow)
                        {
                            return false;
                        }
                    }

                    if (target.IsEmpty())
                    {
                        greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(JuiceKeg.LocalizeString("OutOfJuice", new object[0x0]));
                        return false;
                    }
                    return true;
                }
                catch (ResetException)
                {
                    throw;
                }
                catch (Exception e)
                {
                    Common.Exception(a, target, e);
                    return false;
                }
            }

            public override bool Test(Sim actor, Lot target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
            {
                // Stops the dead from leaving the cemetery
                if ((actor.SimDescription.IsDead) && (!actor.SimDescription.IsPlayableGhost)) return false;

                return base.Test(actor, target, isAutonomous, ref greyedOutTooltipCallback);
            }

            public override bool Test(Sim a, Sim target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
            {
                try
                {
                    if (a == target)
                    {
                        return false;
                    }

                    if (!Woohooer.Settings.mAllowTeenSkinnyDip)
                    {
                        if (target.SimDescription.TeenOrBelow)
                        {
                            return false;
                        }
                    }
                    else
                    {
                        if (target.SimDescription.ChildOrBelow)
                        {
                            return false;
                        }
                    }

                    if (!CelebrityManager.CanSocialize(a, target))
                    {
                        return false;
                    }

                    if (target.SimDescription.IsVisuallyPregnant)
                    {
                        greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(Localization.LocalizeString(target.IsFemale, "Gameplay/Actors/Sim:PregnantFailure", new object[0]));
                        return false;
                    }

                    SwimmingInPool posture = a.Posture as SwimmingInPool;
                    SwimmingInPool pool2 = target.Posture as SwimmingInPool;
                    if (posture == null)
                    {
                        return false;
                    }

                    if ((pool2 != null) && (pool2.ContainerPool == posture.ContainerPool))
                    {
                        return false;
                    }

                    if (!Pool.SimOutfitSupportsSkinnyDipping(target, ref greyedOutTooltipCallback))
                    {
                        return false;
                    }
                    return true;
                }
                catch (Exception e)
                {
                    Common.Exception(a, target, e);
                    return false;
                }
            }

            public override bool Test(Sim a, GameObject target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
            {
                if (target.InUse)
                {
                    greyedOutTooltipCallback = Common.DebugTooltip("InUse");
                    return false;
                }

                PlantableComponent plantable = target.Plantable;
                if ((plantable == null) || plantable.InSeedSpawner)
                {
                    greyedOutTooltipCallback = Common.DebugTooltip("InSeedSpawner");
                    return false;
                }

                /*
                TerrainType type = (TerrainType)World.GetTerrainType(target.Position.x, target.Position.z, 0x0);
                if ((type != TerrainType.LotTerrain) && (type != TerrainType.WorldTerrain))
                {
                    return false;
                }
                */
                if (target.Parent != null)
                {
                    greyedOutTooltipCallback = Common.DebugTooltip("Parent");
                    return false;
                }
                /*
                else if (!target.IsOutside)
                {
                    return false;
                }
                */
                else if (!BaseCommonPlantingTest(a, target, target.LotCurrent, ref greyedOutTooltipCallback))
                {
                    return false;
                }

                bool flag = true;
                /*
                Soil soilToPlace = GlobalFunctions.CreateObjectOutOfWorld("GardenSoil") as Soil;
                if (soilToPlace == null)
                {
                    greyedOutTooltipCallback = Common.DebugTooltip("GardenSoil");
                    return false;
                }

                soilToPlace.AddToWorld();
                soilToPlace.Ghost();
                flag = PlantObjectHere.CanPlaceSoil(a, target, soilToPlace);
                soilToPlace.Destroy();

                if (!flag)
                {
                    greyedOutTooltipCallback = Common.DebugTooltip("CanPlaceSoil");
                }
                */
                return flag;
            }

 public override bool SkatableObjectTest(Sim a, ISkatableObject target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
 {
     if (!target.IsActorUsingMe(a))
     {
         return false;
     }
     SkateEx currentInteraction = a.CurrentInteraction as SkateEx;
     return ((currentInteraction != null) && currentInteraction.CanSingleSpin(ref greyedOutTooltipCallback));
 }

            public override bool Test(Sim a, EquestrianCenter target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
            {
                if (target.IsActorUsingMe(a))
                {
                    return false;
                }

                Posture posture = a.Posture as RidingPosture;
                if (posture == null)
                {
                    posture = a.Posture as LeadingHorsePosture;
                    if (posture == null)
                    {
                        greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(EquestrianCenter.OfferStallionAsStud.LocalizeString(a.IsFemale, "NeedHorse", new object[] { a }));
                        return false;
                    }
                }

                Sim container = posture.Container as Sim;
                if (!container.IsSelectable)
                {
                    return false;
                }

                if (container.SimDescription.IsFemale)
                {
                    greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(EquestrianCenter.OfferStallionAsStud.LocalizeString(a.IsFemale, "NeedMaleHorse", new object[] { a }));
                    return false;
                }
                else if (container.SimDescription.Child)
                {
                    greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(EquestrianCenter.OfferStallionAsStud.LocalizeString(a.IsFemale, "NeedAdultHorse", new object[] { a }));
                    return false;
                }
                else if (container.SimDescription.Elder)
                {
                    greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(EquestrianCenter.OfferStallionAsStud.LocalizeString(container.IsFemale, "ElderPetsTooOldForBreed", new object[] { container }));
                    return false;
                }

                /*
                if (container.SimDescription.IsUnicorn)
                {
                    greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(EquestrianCenter.OfferStallionAsStud.LocalizeString(a.IsFemale, "UnicornCannotBeOffered", new object[] { a }));
                    return false;
                }
                */

                Motives motives = container.Motives;
                if (motives.HasMotive(CommodityKind.StallionOffered) && (motives.GetValue(CommodityKind.StallionOffered) >= EquestrianCenter.kOfferStallionMotiveThreshold))
                {
                    greyedOutTooltipCallback = InteractionInstance.CreateTooltipCallback(EquestrianCenter.OfferStallionAsStud.LocalizeString(a.IsFemale, "Cooldown", new object[] { a, container }));
                    return false;
                }
                return true;
            }

            public override bool Test(Sim a, Phone target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
            {
                if (!target.IsUsableBy(a))
                {
                    greyedOutTooltipCallback = Common.DebugTooltip("Not Usable");
                    return false;
                }

                return Helpers.TravelUtilEx.CanSimTriggerTravelToHomeWorld(a, ref greyedOutTooltipCallback);
            }