Sims3.UI.StyledNotification.Show(new Sims3.UI.StyledNotification.Format("ADD TEXT/OR FUNCTION HERE", StyledNotification.NotificationStyle.kGameMessageNegative));

actor.ShowTNSIfSelectable("In use!", StyledNotification.NotificationStyle.kSimTalking)

Gameflow.SetGameSpeed(SimIFace.Gameflow.GameSpeed.Pause, Gameflow.SetGameSpeedContext.GameStates);

AlarmHandle handle = object.AddAlarmRepeating(1f, TimeUnit.Hours, new AlarmTimerCallback(WhenAlarmEnds()), "AlarmName", AlarmType.AlwaysPersisted);

object.RemoveAlarm(handle);

if (sim.IsInActiveHousehold)
{
}

sim.ModifyFunds( amount to add to funds, negative value for taking away money));

sim.Household.UnpaidBills += value

object.Destroy()

    InteractionInstance interactionInstance = GameInteraction.Singleton.CreateInstance(Target, Actor, new InteractionPriority(InteractionPriorityLevel.Autonomous), true, false);
    StyledNotification.Show(
     new StyledNotification.Format(InteractionDefinitionUtilities.GetInteractionLocalizationKey(typeof(TargetClass),interactionInstance.InteractionObjectPair),StyledNotification.NotificationStyle.kGameMessagePositive));

	public class Task_GenericAction : Task
	{
		Action mAction = null;
		Action[] mActions = null;


		public static void Start(Action PerformAction)
		{
			Simulator.AddObject (new Task_GenericAction (PerformAction));
		}

		public static void StartArray(Action[] PerformActions)
		{
			Simulator.AddObject (new Task_GenericAction (PerformActions));
		}

		public Task_GenericAction (Action PerformAction)
		{
			mAction = PerformAction;
		}	

		public Task_GenericAction (Action[] PerformActions)
		{
			mActions = PerformActions;
		}

		public override void Simulate()
		{
			try
			{
				if (mAction != null)
				{
					mAction();
				}
				if (mActions != null && mActions.Length > 0)
				{
					foreach(Action current in this.mActions)
					{
						current();
					}
				}
			}
			catch(Exception e) 
			{
				
			}
			finally 
			{
				Sims3.SimIFace.Simulator.DestroyObject(base.ObjectId);
			}
		}
	}

Task_GenericAction.Start(YourActionHere)

namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	public class ExtensionAttribute : Attribute
	{
	}
}

base.StandardEntry();
base.EnterStateMachine("JAZZ_MACHINE_NAME_HERE", "Enter", "x"); // Enter could be anything, but it's common practise to start with enter
base.SetActor("OBJECT OR ACTOR NAME HERE", base.Target); // This can be another actor, "y" or "Oven" or "glass_prop". 
base.EnterState("x", "Enter");Â* Â*
base.AnimateSim("Exit");
base.StandardExit(); 

Â* Â* Â* Â* Â*public override bool StacksWith(IGameObject other)
Â*Â*Â*Â*Â*Â*Â*Â*{
Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*GameObject gameObject = other as GameObject ;
Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*if(gameObject != null)
Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*{
Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*return true;
Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*}
Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*return false;
Â*Â*Â*Â*Â*Â*Â*Â*}

      public override void OnStartup()      {
         base.AddComponent(new object[1]         {
            new List(new Type[3]            {
               typeof(Sim),
               typeof(SharedFamilyInventory),
               typeof(SewingTable)
            })
         });
         base.AddInteraction(PutInInventory.Singleton);
         base.OnCreation();
      }


Â* Â* Â* Â* Â*public bool IsDraggable = true;
Â* Â* Â* Â* Â*public override bool HandToolAllowUserPickup()
Â*Â*Â*Â*Â*Â*Â*Â*{
Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*if (!IsDraggable)
Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*{
Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*return false;
Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*}
Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*return base.HandToolAllowUserPickup();
Â*Â*Â*Â*Â*Â*Â*Â*}

// To apply it to your object:
GameObject.IsDraggable = true;

Â* Â* Â* Â* Â* Â* DateTime startÂ*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*= DateTime.Now;
Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*// ADD YOUR CODE BETWEEN THESE LINES, THIS CAN BE A TYPE OF LOOP, METHOD, SOMETHING BEING CALLED, ETC.
Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*DateTime endÂ*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*= DateTime.Now;
Â*Â*Â*Â*Â*Â*Â*Â*   
        // Here we just print it for debugging purposes. This can be done in a dialogue or notification
Â*Â*Â*Â*Â*Â*Â*Â*Â*Â*Â* SimpleMessageDialogue.show("Title of the dialogue " + (end - start).ToString());

public override bool Test(Sim a, SomeGameObject target, bool isAutonomous, ref GreyedOutTooltipCallback greyedOutTooltipCallback)
               {                   
                   if(canDoThisNow == true)
                   {
                        return true;
                   }
                  else 
                  {
                     string message= "i am too tired";
                     greyedOutTooltipCallback = CreateTooltipCallback(message);
                  }
                 return false;
              }

using Sims3.SimIFace;
using System;
using System.Collections.Generic;
using System.Reflection;

/// <summary>Transfers (or "Ferries") values of PersistableStatic type members ("Cargo") across worlds when traveling.</summary>
/// <remarks><para>Using the Ferry, one copy of a type's PersistableStatic data can be shared across multiple worlds in a save,
/// as opposed to each world creating and maintaining its own separate copy.</para>
/// <para>Client code is responsible for setting any default values for Cargo after it has been loaded,
/// should such values be necessary for new games or newly-exposed saves.</para>
/// <para>Types derived from <typeparamref name="T">T</typeparamref> and types from which <typeparamref name="T">T</typeparamref> is derived 
/// will not have their declared Cargo saved unless a separate Ferry is called for them as well.</para></remarks>
/// <typeparam name="T">The type containing PersistableStatic data to be ferried</typeparam>
/// <exception cref="NotSupportedException"><typeparamref name="T">T</typeparamref> does not contain PersistableStatic members</exception>
public static class Ferry<T>
{
    private static readonly Dictionary<FieldInfo, object> mCargo;

    static Ferry()
    {
        FieldInfo[] fields = FindPersistableStatics();
        if (fields.Length == 0)
        {
            throw new NotSupportedException($"There are no PersistableStatic fields declared in {typeof(T)}.");
        }
        mCargo = new Dictionary<FieldInfo, object>(fields.Length);
        foreach (FieldInfo current in fields)
        {
            mCargo[current] = null;
        }
    }

    private static FieldInfo[] FindPersistableStatics()
    {
        MemberInfo[] fieldMembers = typeof(T).FindMembers(MemberTypes.Field,
            BindingFlags.Static | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic,
            (info, criteria) => info.GetCustomAttributes(typeof(PersistableStaticAttribute), false).Length > 0, null);

        return Array.ConvertAll(fieldMembers, (x) => (FieldInfo)x);
    }

    // Transfer loaded Cargo to respective members of T
    public static void UnloadCargo()
    {
        if (GameStates.IsTravelling)
        {
            foreach (FieldInfo current in new List<FieldInfo>(mCargo.Keys))
            {
                current.SetValue(null, mCargo[current]);
                mCargo[current] = null;
            }
        }
    }

    // Load all Cargo onto T's Ferry for transfer
    public static void LoadCargo()
    {
        if (GameStates.IsTravelling)
        {
            foreach (FieldInfo current in new List<FieldInfo>(mCargo.Keys))
            {
                mCargo[current] = current.GetValue(null);
            }
        }
    }
}

using Sims3.SimIFace;
using System;

// In this example, UselessSettings's Cargo is loaded/unloaded to maintain current settings across an entire save
// However, no default values for the Cargo are ever set after app startup
// So any new games or newly-exposed saves after quitting to main menu will copy the settings from the previously-loaded world
public static class Main 
{
    [Tunable]
    private static bool kInstantiator;

    static Main()
    {
        World.OnWorldLoadFinishedEventHandler += OnWorldLoadFinished;
        World.OnWorldQuitEventHandler += OnWorldQuit;
    }

    private static void OnWorldLoadFinished(object sender, EventArgs e) => Ferry<UselessSettings>.UnloadCargo();

    private static void OnWorldQuit(object sender, EventArgs e) => Ferry<UselessSettings>.LoadCargo();
}

public struct UselessSettings
{
    [PersistableStatic]
    public static int sInt = 5;
	
    [PersistableStatic]
    public static float sFloat = 7.2f;
}

using Sims3.Gameplay.Utilities;
using Sims3.SimIFace;
using Sims3.UI;
using System;

public static class Main 
{
    [Tunable]
    private static bool kInstantiator;

    static Main()
    {
        World.OnWorldLoadFinishedEventHandler += OnWorldLoadFinished;
        World.OnWorldQuitEventHandler += OnWorldQuit;
    }

    private static void OnWorldLoadFinished(object sender, EventArgs e)
    {
        UselessData.Unload();
        UselessData.sTimesTraveledInSave++;
        UselessData.seekretString += 'A';
        // Display the current value of sTimesTraveledInSave and seekretString upon entering live mode after loading/traveling
        AlarmManager.Global.AddAlarm(1f, TimeUnit.Minutes, 
            delegate () { 
                StyledNotification.Show(new StyledNotification.Format($"{UselessData.sTimesTraveledInSave}\n{UselessData.seekretString}", StyledNotification.NotificationStyle.kSystemMessage));
            }, "TEST", AlarmType.NeverPersisted, null);
    }

    private static void OnWorldQuit(object sender, EventArgs e)
    {
        UselessData.Load();
        // UselessData is cleared every time a world is unloaded,
        // So any new games or newly-exposed saves after quitting to main menu will have default values (rather than copying the values from the previously-loaded world)
        // But if we're traveling, our data is safe and sound in the Ferry!
        UselessData.sTimesTraveledInSave = 0;
        UselessData.seekretString = "";
    }
}

// Static classes cannot be generic type parameters
// So this is just a sealed class instead
public sealed class UselessData
{
    [PersistableStatic]
    public static int sTimesTraveledInSave = 0;
	
    [PersistableStatic]
    public static string seekretString = "";

    public static void Unload() => Ferry<UselessData>.UnloadCargo();

    public static void Load() => Ferry<UselessData>.LoadCargo();
}

using Sims3.SimIFace
using System

public static class Main
{
    [Tunable]
    private static bool kInstantiator;

    static Main()
    {
        World.OnWorldLoadFinishedEventHandler += OnWorldLoadFinished;
        World.OnWorldQuitEventHandler += OnWorldQuit;
    }

    private static void OnWorldLoadFinished(object sender, EventArgs e)
    {
        Ferry<Animal>.UnloadCargo();
        Ferry<Dog>.UnloadCargo();
    }

    private static void OnWorldQuit(object sender, EventArgs e)
    {
        Ferry<Animal>.LoadCargo();
        Ferry<Dog>.LoadCargo();
    }
}

public class Animal
{
    // This field is ONLY captured by Ferry<Animal>
    // It is NOT considered part of Dog's declared Cargo
    [PersistableStatic]
    private static int sAnimalCount;
}

public class Dog : Animal
{
    // This field is ONLY captured by Ferry<Dog>
    // It is NOT considered part of Animal's declared Cargo
    [PersistableStatic]
    private static int sNumMailmenChased;
}

private static void OnPreload()
      Â* {
            WashHands.Singleton = new CustomWashHands.Definition();
        }

uint numberOfObject = someLot.CountObjects<Sink>();

Â*List<IGameObject> objects = sim.Inventory.FindAllOfType(typeof(SomeObject));

Route route = Actor.CreateRoute();
                route.SetOption(Route.RouteOption.DoLineOfSightCheckUserOverride, value: true);
                float num = 1f;
                float num2 = 2f;
                IHasRouteRadius hasRouteRadius = Target as IHasRouteRadius;
                if (hasRouteRadius != null)
                {
                  Â* float num3 = 3f;
                  Â* num = hasRouteRadius.CarryRouteToObjectRadius;
                  Â* num2 = num * num3;
                  Â* if (num2 - num > 2f)
                  Â* {
                        num2 = num + 2f;
                  Â* }
                }
                route.PlanToPointRadialRange(Target.Position, num, num2, RouteDistancePreference.PreferNearestToRouteDestination, RouteOrientationPreference.TowardsObject, Target.LotCurrent.LotId, new int[1]
                {
                Target.RoomId
                });
                Vector3 position = Target.Position;
                if (!Actor.DoRoute(route))
                {
                  Â* return false;
                }
                if (position != Target.Position)
                {
                  Â* return false;
                }

Cup cup = GlobalFunctions.CreateObject("CoffeeCup", Target.Parent.Position, Target.Level, Vector3.UnitZ) as Cup;

string resourceString= "Type:Group:Instance";
object= (CustomObject)GlobalFunctions.CreateObject(ResourceKey.FromString(resourceString), Target.Position, Target.Level, Target.Position);