namespace Sims3.Gameplay.Objects.Twinsimming
{
    public class Camera : GameObject
    {
        public class Camera_TakePracticeShots : Interaction<Sim, ICamera>
        {
            public class Definition : InteractionDefinition<Sim, ICamera, Camera_TakePracticeShots>
            {
                public override string GetInteractionName(Sim actor, ICamera target, InteractionObjectPair interaction)
                {
                    return "Take Practice Shots";
                }
                public override bool Test(Sim a, ICamera target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
                {
                    if (!target.InInventory)
                    {
                        return false;
                    }
                    a = (target.ItemComp.InventoryParent.Owner as Sim);
                    if (a == null)
                    {
                        return false;
                    }
                    if (!a.SimDescription.ChildOrAbove || !a.IsHuman)
                    {
                        return false;
                    }
                    return true;
                }
            }
            public static InteractionDefinition Singleton = new Definition();

            public override bool RunFromInventory()
            {
                Actor = (Target.ItemComp.InventoryParent.Owner as Sim);
                InteractionInstance entry = Target.TakePhotoSingleton.CreateInstance(Target, Actor, GetPriority(), isAutonomous: false, cancellableByPlayer: true);
                return Actor.InteractionQueue.AddNext(entry);
            }

            public override bool Run()
            {
                // We ask the game to give/initiate the skill on the actor that's currently using the object. Even if they're level 10 or don't know the skill yet, this will be added. 
                Photography photographySkill = base.Actor.SkillManager.AddElement(SkillNames.Photography) as Photography;
                if (photographySkill == null)
                {
                    // For good practise on a first run, make sure to add an in-game notification here to debug whether the skill has been loaded or not
                    return false;
                }
                // Starts skill gaining. The Skilling bar will appear above the sim's head now.
                photographySkill.StartSkillGain(30);
                base.StandardEntry();
                base.EnterStateMachine("TakePhoto", "Enter", "x");
                base.SetActor("camera_object", base.Target);
                base.EnterState("x", "Enter");
                base.BeginCommodityUpdates();
                base.AnimateSim("Taking Photo");
                // EA uses the 'Flag' variable for this. But when looping, it's important on each loop to return either 'true' or 'false'. An exit reason can return a false or true 
                bool GainSkillOnLoop = DoLoop(ExitReason.Default, LoopInfinite, null);
                base.AnimateSim("Exit");
                base.EndCommodityUpdates(true);
                // Because we're exiting, we're also stopping skillgaining here.
                photographySkill.StopSkillGain();
                base.StandardExit();
                // This is the only instance in a run() function to return a variable like this. Merely because of the 'DoLoop' function.
                return GainSkillOnLoop;

            }
            // Our loop function. See how in: bool GainSkillOnLoop = DoLoop(ExitReason.Default, LoopInfinite, null); We call a function in the second parameter? 
            public void LoopInfinite(StateMachineClient smc, LoopData loopData)
            {
                //2 things here, if either we as the player cancel the animation OR the game notices that the sim is super hungry/has no fun/has to go to the toilet, we'll add the exit reasons. 
                if (Actor.HasExitReason(ExitReason.UserCanceled) || (Actor.HasExitReason(ExitReason.MoodFailure)))
                {
                    // AddExitReason so that we 'base.AnimateSim()' will be initiated
                    base.Actor.AddExitReason(ExitReason.UserCanceled);
                    base.Actor.AddExitReason(ExitReason.MoodFailure);
                }
            }
        }
        public override void OnStartup()
        {
            AddInventoryInteraction(Camera_TakePracticeShots.Singleton);
        }
    }
}

using Sims3.SimIFace;
using System;
using System.Text;
using Sims3.Gameplay.Objects.Miscellaneous;
using Sims3.Gameplay.Actors;
using Sims3.Gameplay.EventSystem;
using Sims3.UI;
using Sims3.Gameplay.Abstracts;
using Sims3.Gameplay.DreamsAndPromises;
using Sims3.Gameplay.ActorSystems;
using Sims3.Gameplay.Utilities;
using Sims3.Gameplay.TuningValues;
using Sims3.Gameplay.Autonomy;
using Sims3.Gameplay.Interactions;
using Sims3.Gameplay.Skills;
using Sims3.SimIFace.SACS;
using Sims3.Gameplay.Roles;
using System.Collections.Generic;
using Sims3.Gameplay.Interfaces;
using Sims3.Gameplay.Objects.Decorations.Mimics;
using Sims3.Gameplay.Objects.Electronics;
using Sims3.Gameplay.Objects.HobbieSkills.Camera.Twinsimming;
using Sims3.Gameplay.Objects.HobbieSkills.Camera;
using Sims3.Gameplay.Objects.HobbiesSkills;

public class Instantiator
{
    [Tunable]
    protected static bool kInstantiator = false;

    static Instantiator()
    {
        World.sOnWorldLoadFinishedEventHandler += new EventHandler(OnWorldLoadFinished);
    }

    private static void OnWorldLoadFinished(object sender, EventArgs e)
    {
        Camera[] objects = Queries.GetObjects<Camera>();
        foreach (Camera camera in objects)
        {
            AddInteractions(camera);
        }
        EventTracker.AddListener(EventTypeId.kBoughtObject, OnObjectChanged);
        EventTracker.AddListener(EventTypeId.kInventoryObjectAdded, OnObjectChanged);
        EventTracker.AddListener(EventTypeId.kObjectStateChanged, OnObjectChanged);
    }
    private static void AddInteractions(Camera camera)
    {
        foreach (InteractionObjectPair interaction in camera.Interactions)
        {
            if (interaction.InteractionDefinition.GetType() == TakePracticeShots.Singleton.GetType())
            {
                return;
            }
        }
        camera.AddInteraction(TakePracticeShots.Singleton);
    }
    private static ListenerAction OnObjectChanged(Event e)
    {
        try
        {
            Camera camera = e.TargetObject as Camera;
            if (camera != null)
            {
                AddInteractions(camera);
            }
        }
        catch (Exception)
        {
        }
        return ListenerAction.Keep;
    }
}

Camera[] objects = Sims3.Gameplay.Queries.GetObjects<Camera>();

using Queries = Sims3.Gameplay.Queries;

// Additional code cut for clarity

Camera[] objects = Queries.GetObjects<Camera>();

namespace Twinsimming.TakePracticeShots.Common
{
    public class Instantiator
    {
        // Instantiator code
    }
}

using static Sims3.Gameplay.Objects.HobbieSkills.Camera.Twinsimming.TakePracticeShots;

camera.AddInteraction(Singleton);

camera.AddInventoryInteraction(Singleton);