public abstract class Sandbox.Component

protected T __sync_GetValue(Sandbox.WrappedPropertyGet`1<T> p)

protected void __sync_SetValue(Sandbox.WrappedPropertySet`1<T> p)

public T AddComponent(bool startEnabled = True)

Add a component to this GameObject

public void Deserialize(System.Text.Json.Nodes.JsonObject node)

public void DeserializeImmediately(System.Text.Json.Nodes.JsonObject node)

Deserialize this component as per `Sandbox.Component.Deserialize(System.Text.Json.Nodes.JsonObject)` but update `Sandbox.Component.GameObject` and `Sandbox.Component` property references immediately instead of having them deferred.

public void Destroy()

Destroy this component, if it isn't already destroyed. The component will be removed from its GameObject and will stop existing. You should avoid interating with the component after calling this.

public void DestroyGameObject()

Destroy the parent GameObject. This really only exists so when you're typing Destroy you realise that calling Destroy only destroys the Component - not the whole GameObject.

protected virtual void DrawGizmos()

Called in the editor to draw things like bounding boxes etc

public void EditLog(string name, object source)Obsolete

Called when something on the component has been edited

Obsolete: EditLog is obsolete use Scene.Editor.UndoScope or Scene.Editor.AddUndo instead.

public T GetComponent(bool includeDisabled = False)

Get a component on this GameObject

public T GetComponentInChildren(bool includeDisabled = False, bool includeSelf = True)

Get component on this GameObject or on descendant GameObjects

public T GetComponentInParent(bool includeDisabled = False, bool includeSelf = True)

Get component on this GameObject and on ancestor GameObjects

public System.Collections.Generic.IEnumerable`1<T> GetComponents(bool includeDisabled = False)

Get components on this GameObject

public System.Collections.Generic.IEnumerable`1<T> GetComponentsInChildren(bool includeDisabled = False, bool includeSelf = True)

Get components on this GameObject and on descendant GameObjects

public System.Collections.Generic.IEnumerable`1<T> GetComponentsInParent(bool includeDisabled = False, bool includeSelf = True)

Get components on this GameObject and on ancestor GameObjects

public T GetOrAddComponent(bool startEnabled = True)

Add a component to this GameObject

public void Invoke(float secondsDelay, System.Action action, System.Threading.CancellationToken ct = null)

Invoke a method in x seconds. Won't be invoked if the component is no longer active.

public bool IsRunning(Sandbox.Doo doo)

Returns true if the given Doo is currently running on this component.

public static override object JsonRead(System.Text.Json.Utf8JsonReader reader, System.Type targetType)

public static override void JsonWrite(object value, System.Text.Json.Utf8JsonWriter writer)

protected virtual void OnAwake()

Called once per component

protected virtual void OnDestroy()

Called once, when the component or gameobject is destroyed

protected virtual void OnDirty()Obsolete

Called when the component has become dirty

Obsolete: This API member is obsolete.

protected virtual void OnDisabled()

protected virtual void OnEnabled()

Called after Awake or whenever the component switches to being enabled (because a gameobject hierarchy active change, or the component changed)

protected virtual void OnFixedUpdate()

When enabled, called on a fixed interval that is determined by the Scene. This is also the fixed interval in which the physics are ticked. Time.Delta is that fixed interval.

protected virtual void OnParentChanged(Sandbox.GameObject oldParent, Sandbox.GameObject newParent)

The parent has changed from one parent to another

public virtual void OnParentDestroy()

The parent object is being destroyed. This is a nice place to switch to a healthier parent.

protected virtual void OnPreRender()

When enabled, called every frame, does not get called on a dedicated server

protected virtual void OnRefresh()

Called immediately after being refreshed from a network snapshot.

protected virtual void OnStart()

Called once before the first Update - when enabled.

protected virtual void OnTagsChanged()

When tags have been updated

protected virtual void OnUpdate()

When enabled, called every frame

protected virtual void OnValidate()

Called immediately after deserializing, and when a property is changed in the editor.

public virtual void Reset()

public void Run(Sandbox.Doo doo, System.Action`1<Sandbox.Doo.Configure> c = null)

public System.Text.Json.Nodes.JsonNode Serialize(Sandbox.GameObject.SerializeOptions options = null)

public void Stop(Sandbox.Doo doo)

Stop a specific Doo, if it's running

public void StopAll()

Stop all running Doos

public bool Sandbox.Component.Active { get; set; }

True if this Component is enabled, and all of its ancestor GameObjects are enabled

public virtual sealed Sandbox.ComponentList Sandbox.Component.Components { get; set; }

Access components on this component's GameObject

public virtual int Sandbox.Component.ComponentVersion { get; set; }

The version of the component. Used by `Sandbox.JsonUpgrader`.

public Sandbox.DebugOverlaySystem Sandbox.Component.DebugOverlay { get; set; }

Allows drawing of temporary debug shapes and text in the scene

public bool Sandbox.Component.Enabled { get; set; }

The enable state of this `Sandbox.Component`. This doesn't tell you whether the component is actually active because its parent `Sandbox.GameObject` might be disabled. This merely tells you what the component wants to be. You should use `Sandbox.Component.Active` to determine whether the object is truly active in the scene.

public Sandbox.ComponentFlags Sandbox.Component.Flags { get; set; }

public Sandbox.GameObject Sandbox.Component.GameObject { get; set; }

The GameObject this component belongs to.

public System.Guid Sandbox.Component.Id { get; set; }

public bool Sandbox.Component.IsProxy { get; set; }

True if this is a networked object and is owned by another client. This means that we're not controlling this object, so shouldn't try to move it or anything.

public virtual sealed bool Sandbox.Component.IsValid { get; set; }

public Vector3 Sandbox.Component.LocalPosition { get; set; }

The local position of the game object.

public Rotation Sandbox.Component.LocalRotation { get; set; }

The local rotation of the game object.

public Vector3 Sandbox.Component.LocalScale { get; set; }

The local scale of the game object.

public Transform Sandbox.Component.LocalTransform { get; set; }

The local transform of the game object.

public Sandbox.GameObject.NetworkAccessor Sandbox.Component.Network { get; set; }

public System.Action Sandbox.Component.OnComponentDestroy { get; set; }

public System.Action Sandbox.Component.OnComponentDisabled { get; set; }

public System.Action Sandbox.Component.OnComponentEnabled { get; set; }

public System.Action Sandbox.Component.OnComponentFixedUpdate { get; set; }

public System.Action Sandbox.Component.OnComponentStart { get; set; }

public System.Action Sandbox.Component.OnComponentUpdate { get; set; }

public Sandbox.Scene Sandbox.Component.Scene { get; set; }

The scene this Component is in. This is a shortcut for `GameObject.Scene`.

public Sandbox.ITagSet Sandbox.Component.Tags { get; set; }

protected Sandbox.TaskSource Sandbox.Component.Task { get; set; }

Allow creating tasks that are automatically cancelled when the GameObject is destroyed.

public Sandbox.GameTransform Sandbox.Component.Transform { get; set; }

The transform of the GameObject this component belongs to. Components don't have their own transforms but they can access the transform of the GameObject they belong to. This is a shortcut for `GameObject.Transform`.

public Vector3 Sandbox.Component.WorldPosition { get; set; }

The world position of the game object.

public virtual sealed Rotation Sandbox.Component.WorldRotation { get; set; }

The world rotation of the game object.

public virtual sealed Vector3 Sandbox.Component.WorldScale { get; set; }

The world scale of the game object.

public Transform Sandbox.Component.WorldTransform { get; set; }

The world transform of the game object.