private static void AddInteractions(GameObjectOfChoice obj)
{
    foreach (InteractionObjectPair pair in obj.Interactions)
    {
        if (pair.InteractionDefinition.GetType() == YourInteraction.Singleton.GetType())
        {
            return;
        }
    }
    obj.AddInteraction(YourInteraction.Singleton);
}

foreach (GameObjectOfChoice obj in Sims3.Gameplay.Queries.GetObjects<GameObjectOfChoice>())
            {
                AddInteractions(obj);
            }

private static EventListener sObjectBoughtListener;

private static ListenerAction OnObjectBought(Event e)
{
    GameObjectOfChoice obj = e.TargetObject as GameObjectOfChoice;
    if (obj != null)
    {
        AddInteractions(obj);
    }
    return ListenerAction.Keep;
}

sObjectBoughtListener = EventTracker.AddListener(EventTypeId.kBoughtObject, new ProcessEventDelegate(OnObjectBought));

        public static void AddHotTubInteractions(HotTubBase obj)
        {
            // check if the interaction isn't already on the object
            foreach (InteractionObjectPair pair in obj.Interactions)
            {
                if (pair.InteractionDefinition.GetType() == TurnOffHottub.Singleton.GetType())
                {
                    return;
                }
            }

            obj.AddInteraction(TurnOffHottub.Singleton);
        }

        // This is sent for every member of the household
        protected static ListenerAction OnObjectBought(Event e)
        {
            HotTubBase targetObject = e.TargetObject as HotTubBase;
            if (targetObject != null)
            {
                AddHotTubInteractions(targetObject);
            }
            return ListenerAction.Keep;
        }



        public static void OnWorldLoadFinishedHandler(object sender, EventArgs e)
        {
            Notify("OnWorldLoadFinishedHandler");

            List<HotTubBase> tubs = new List<HotTubBase>(Sims3.Gameplay.Queries.GetObjects<HotTubBase>());
            foreach (HotTubBase tub in tubs)
            {
                if (tub != null)
                {
                    AddHotTubInteractions(tub);
                }
            }

            EventTracker.AddListener(EventTypeId.kBoughtObject, new ProcessEventDelegate(VelocitygrassSims3Mod.OnObjectBought));
        }

        // Turn off lights and jets on hot tubs
        public sealed class TurnOffHottub : ImmediateInteraction<Sim, HotTubBase>
        {
            // Fields
            public static readonly InteractionDefinition Singleton = new Definition();

            // Methods
            public override bool Run()
            {
                if (base.Target.IsLightOn())
                    base.Target.TurnOffLights();
                if (base.Target.AreJetsOn())
                    base.Target.StopJetFX(false);
                return true;
            }

            // Nested Types
            [DoesntRequireTuning]
            public sealed class Definition : ActorlessInteractionDefinition<Sim, HotTubBase, VelocitygrassSims3Mod.TurnOffHottub>
            {
                // Methods
                public override string GetInteractionName(Sim a, HotTubBase target, InteractionObjectPair interaction)
                {
                    return "Turn off";
                }

                public override bool Test(Sim a, HotTubBase target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
                {
                    return target.IsLightOn() || target.AreJetsOn();
                }
            }
        }

using System;
using System.Collections.Generic;
using System.Text;
using Sims3.SimIFace;
using Sims3.Gameplay.Objects.Miscellaneous;
using Sims3.Gameplay.Actors;
using Sims3.Gameplay.Interactions;
using Sims3.Gameplay.Utilities;
using Sims3.Gameplay.EventSystem;
using Sims3.Gameplay.Autonomy;

namespace KJFireworks
{
    public class KJFinale
    {
        [Tunable]
        protected static bool kInstantiator = false;
        [Tunable, TunableComment("The number of Big Booms required for a finale.")]
        private static int kNumBoomsForFinale;

        //static KJFinale();
        //public KJFinale();
        

        public static void AddFireworkInteractions(FireworksBigBooms obj)
        {
            // check if the interaction isn't already on the object
            foreach (InteractionObjectPair pair in obj.Interactions)
            {
                if (pair.InteractionDefinition.GetType() == LaunchFinale.Singleton.GetType())
                {
                    return;
                }
            }
            obj.AddInteraction(LaunchFinale.Singleton);
        }

        // This is sent for every member of the household
        protected static ListenerAction OnObjectBought(Event e)
        {
            FireworksBigBooms targetObject = e.TargetObject as FireworksBigBooms;
            if (targetObject != null)
            {
                AddFireworkInteractions(targetObject);
            }
            return ListenerAction.Keep;
        }

        public static void OnWorldLoadFinishedHandler(object sender, EventArgs e)
        {
            Notify("OnWorldLoadFinishedHandler");

            List<FireworksBigBooms> bangs = new List<FireworksBigBooms>(Sims3.Gameplay.Queries.GetObjects<FireworksBigBooms>());
            foreach (FireworksBigBooms bang in bangs)
            {
                if (bang != null)
                {
                    AddFireworkInteractions(bangs);
                }
            }

            EventTracker.AddListener(EventTypeId.kBoughtObject, new ProcessEventDelegate(KJFireworks.KJFinale.OnObjectBought));
        }

        private sealed class LaunchFinale : Interaction<Sim, FireworksBigBooms>
        {
            // Fields
            private List<FireworksBigBooms> mReservedFireworks = new List<FireworksBigBooms>();
            public static readonly InteractionDefinition Singleton = new Definition();

            // Methods
            private void ReserveFireworks()
            {
                foreach (FireworksBigBooms booms in base.Actor.Inventory.FindAll<FireworksBigBooms>(true))
                {
                    if (booms != base.Target)
                    {
                        this.mReservedFireworks.Add(booms);
                        if (this.mReservedFireworks.Count >= (KJFinale.kNumBoomsForFinale - 1))
                        {
                            break;
                        }
                    }
                }
                foreach (FireworksBigBooms booms2 in this.mReservedFireworks)
                {
                    base.Actor.Inventory.TryToRemove(booms2);
                }
            }

            protected override bool Run()
            {
                if (this.mReservedFireworks.Count == 0)
                {
                    this.ReserveFireworks();
                }
                if (!base.Target.RouteToLauncher(base.Actor))
                {
                    foreach (FireworksBigBooms booms in this.mReservedFireworks)
                    {
                        base.Actor.Inventory.TryToAdd(booms);
                    }
                    return false;
                }
                base.StandardEntry();
                base.BeginCommodityUpdates();
                base.Target.LaunchAndPushWatching(KJFinale.kNumBoomsForFinale, base.Actor);
                foreach (FireworksBigBooms booms2 in this.mReservedFireworks)
                {
                    booms2.Destroy();
                }
                base.EndCommodityUpdates(true);
                base.StandardExit();
                return true;
            }

            protected override bool RunFromInventory()
            {
                this.ReserveFireworks();
                CarrySystem.PickUpFromSimInventory(base.Actor, base.Target);
                CarrySystem.PutDownOnFloor(base.Actor);
                return this.Run();
            }

            // Nested Types
            public sealed class Definition : InteractionDefinition<Sim, FireworksBigBooms, KJFireworks.KJFinale.LaunchFinale>
            {
                protected override string GetInteractionName(Sim a, FireworksBigBooms target, InteractionObjectPair interaction)
                {
                    return "Launch Finale";
                }

                // Methods
                protected override bool Test(Sim a, FireworksBigBooms target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
                {
                    int num = a.Inventory.AmountIn<FireworksBigBooms>();
                    if ((num == 0) || (target.mCurrentState != FireworksBigBooms.FireworkState.Idle))
                    {
                        return false;
                    }
                    if (a.Inventory.Contains(target))
                    {
                        return (num >= KJFinale.kNumBoomsForFinale);
                    }
                    return (num >= (KJFinale.kNumBoomsForFinale - 1));
                }
            }
        }
    }
}

        private void PlayFireworkFX(bool isFailure)
        {
            if (this.mFireworkFX == null)
            {
                this.mFireworkFX = new List<VisualEffect>();
            }
            if (isFailure)
            {
                    base.StartOneShotFunction(new Function(this.AnimateFailure), GameObject.OneShotFunctionDisposeFlag.OnDispose);
            }
            else
            {
                this.StartFX("ep1FireWorksFx");
            }
        }

        static KJFinale()
        {
            Sims3.SimIFace.World.OnWorldLoadFinishedEventHandler += new EventHandler(KJFinale.OnWorldLoadFinishedHandler);
        }

obj.AddInteraction(LaunchFinale.Singleton);
obj.AddInventoryInteraction(LaunchFinale.Singleton);

obj.AddInteraction(LaunchFinale.Singleton);
obj.AddInventoryInteraction(LaunchFinale.Singleton);