Events

Forms that compile (125)

82 are written with override; 43 are recognized by name and argument type. Types are written with their fully qualified names. Add a using to write short names.

Forms written by overriding a base declaration

The base class holds the declaration, so you write these with public override.

Syntax	Name called	Variable that receives the argument
`void InputDrop(bool value, VRC.Udon.Common.UdonInputEventArgs args)`	`_inputDrop`	`inputDropBoolValue` `inputDropArgs`
`void InputGrab(bool value, VRC.Udon.Common.UdonInputEventArgs args)`	`_inputGrab`	`inputGrabBoolValue` `inputGrabArgs`
`void InputJump(bool value, VRC.Udon.Common.UdonInputEventArgs args)`	`_inputJump`	`inputJumpBoolValue` `inputJumpArgs`
`void InputLookHorizontal(float value, VRC.Udon.Common.UdonInputEventArgs args)`	`_inputLookHorizontal`	`inputLookHorizontalFloatValue` `inputLookHorizontalArgs`
`void InputLookVertical(float value, VRC.Udon.Common.UdonInputEventArgs args)`	`_inputLookVertical`	`inputLookVerticalFloatValue` `inputLookVerticalArgs`
`void InputMoveHorizontal(float value, VRC.Udon.Common.UdonInputEventArgs args)`	`_inputMoveHorizontal`	`inputMoveHorizontalFloatValue` `inputMoveHorizontalArgs`
`void InputMoveVertical(float value, VRC.Udon.Common.UdonInputEventArgs args)`	`_inputMoveVertical`	`inputMoveVerticalFloatValue` `inputMoveVerticalArgs`
`void InputUse(bool value, VRC.Udon.Common.UdonInputEventArgs args)`	`_inputUse`	`inputUseBoolValue` `inputUseArgs`
`void Interact()`	`_interact`	—
`void MidiControlChange(int channel, int number, int value)`	`_midiControlChange`	`midiControlChangeChannel` `midiControlChangeNumber` `midiControlChangeValue`
`void MidiNoteOff(int channel, int number, int velocity)`	`_midiNoteOff`	`midiNoteOffChannel` `midiNoteOffNumber` `midiNoteOffVelocity`
`void MidiNoteOn(int channel, int number, int velocity)`	`_midiNoteOn`	`midiNoteOnChannel` `midiNoteOnNumber` `midiNoteOnVelocity`
`void OnAsyncGpuReadbackComplete(VRC.SDK3.Rendering.VRCAsyncGPUReadbackRequest request)`	`_onAsyncGpuReadbackComplete`	`onAsyncGpuReadbackCompleteRequest`
`void OnAvatarChanged(VRC.SDKBase.VRCPlayerApi player)`	`_onAvatarChanged`	`onAvatarChangedPlayer`
`void OnAvatarEyeHeightChanged(VRC.SDKBase.VRCPlayerApi player, float prevEyeHeightAsMeters)`	`_onAvatarEyeHeightChanged`	`onAvatarEyeHeightChangedPlayer` `onAvatarEyeHeightChangedPrevEyeHeightAsMeters`
`void OnContactEnter(VRC.Dynamics.ContactEnterInfo contactInfo)`	`_onContactEnter`	`onContactEnterContactInfo`
`void OnContactExit(VRC.Dynamics.ContactExitInfo contactInfo)`	`_onContactExit`	`onContactExitContactInfo`
`void OnControllerColliderHitPlayer(VRC.SDK3.ControllerColliderPlayerHit hit)`	`_onControllerColliderHitPlayer`	`onControllerColliderHitPlayerHit`
`void OnDeserialization(VRC.Udon.Common.DeserializationResult result)`	`_onDeserialization`	`onDeserializationResult`
`void OnDroneTriggerEnter(VRC.SDKBase.VRCDroneApi drone)`	`_onDroneTriggerEnter`	`onDroneTriggerEnterDrone`
`void OnDroneTriggerExit(VRC.SDKBase.VRCDroneApi drone)`	`_onDroneTriggerExit`	`onDroneTriggerExitDrone`
`void OnDroneTriggerStay(VRC.SDKBase.VRCDroneApi drone)`	`_onDroneTriggerStay`	`onDroneTriggerStayDrone`
`void OnDrop()`	`_onDrop`	—
`void OnImageLoadError(VRC.SDK3.Image.IVRCImageDownload result)`	`_onImageLoadError`	`onImageLoadErrorIVRCImageDownload`
`void OnImageLoadSuccess(VRC.SDK3.Image.IVRCImageDownload result)`	`_onImageLoadSuccess`	`onImageLoadSuccessIVRCImageDownload`
`void OnInputMethodChanged(VRC.SDKBase.VRCInputMethod inputMethod)`	`_onInputMethodChanged`	`onInputMethodChangedInputMethod`
`void OnLanguageChanged(string language)`	`_onLanguageChanged`	`onLanguageChangedLanguage`
`void OnListAvailableProducts(VRC.Economy.IProduct[] products)`	`_onListAvailableProducts`	`onListAvailableProductsResult`
`void OnListProductOwners(VRC.Economy.IProduct product, string[] owners)`	`_onListProductOwners`	`onListProductOwnersResult` `onListProductOwnersOwners`
`void OnListPurchases(VRC.Economy.IProduct[] products, VRC.SDKBase.VRCPlayerApi player)`	`_onListPurchases`	`onListPurchasesResult` `onListPurchasesPlayer`
`void OnMasterTransferred(VRC.SDKBase.VRCPlayerApi newMaster)`	`_onMasterTransferred`	`onMasterTransferredNewMaster`
`bool OnOwnershipRequest(VRC.SDKBase.VRCPlayerApi requestingPlayer, VRC.SDKBase.VRCPlayerApi requestedOwner)`	`_onOwnershipRequest`	`onOwnershipRequestRequester` `onOwnershipRequestNewOwner`
`void OnOwnershipTransferred(VRC.SDKBase.VRCPlayerApi player)`	`_onOwnershipTransferred`	`onOwnershipTransferredPlayer`
`void OnPersistenceUsageUpdated()`	`_onPersistenceUsageUpdated`	—
`void OnPhysBoneGrabbed(VRC.Dynamics.PhysBoneGrabbedInfo physBoneInfo)`	`_onPhysBoneGrabbed`	`onPhysBoneGrabbedPhysBoneInfo`
`void OnPhysBonePosed(VRC.Dynamics.PhysBonePosedInfo physBoneInfo)`	`_onPhysBonePosed`	`onPhysBonePosedPhysBoneInfo`
`void OnPhysBoneReleased(VRC.Dynamics.PhysBoneReleasedInfo physBoneInfo)`	`_onPhysBoneReleased`	`onPhysBoneReleasedPhysBoneInfo`
`void OnPhysBoneUnPosed(VRC.Dynamics.PhysBoneUnPosedInfo physBoneInfo)`	`_onPhysBoneUnPosed`	`onPhysBoneUnPosedPhysBoneInfo`
`void OnPickup()`	`_onPickup`	—
`void OnPickupUseDown()`	`_onPickupUseDown`	—
`void OnPickupUseUp()`	`_onPickupUseUp`	—
`void OnPlayerCollisionEnter(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerCollisionEnter`	`onPlayerCollisionEnterPlayer`
`void OnPlayerCollisionExit(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerCollisionExit`	`onPlayerCollisionExitPlayer`
`void OnPlayerCollisionStay(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerCollisionStay`	`onPlayerCollisionStayPlayer`
`void OnPlayerDataStorageExceeded(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerDataStorageExceeded`	`onPlayerDataStorageExceededPlayer`
`void OnPlayerDataStorageWarning(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerDataStorageWarning`	`onPlayerDataStorageWarningPlayer`
`void OnPlayerDataUpdated(VRC.SDKBase.VRCPlayerApi player, VRC.SDK3.Persistence.PlayerData.Info[] infos)`	`_onPlayerDataUpdated`	`onPlayerDataUpdatedPlayer` `onPlayerDataUpdatedInfos`
`void OnPlayerJoined(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerJoined`	`onPlayerJoinedPlayer`
`void OnPlayerLeft(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerLeft`	`onPlayerLeftPlayer`
`void OnPlayerObjectStorageExceeded(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerObjectStorageExceeded`	`onPlayerObjectStorageExceededPlayer`
`void OnPlayerObjectStorageWarning(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerObjectStorageWarning`	`onPlayerObjectStorageWarningPlayer`
`void OnPlayerParticleCollision(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerParticleCollision`	`onPlayerParticleCollisionPlayer`
`void OnPlayerRespawn(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerRespawn`	`onPlayerRespawnPlayer`
`void OnPlayerRestored(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerRestored`	`onPlayerRestoredPlayer`
`void OnPlayerSuspendChanged(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerSuspendChanged`	`onPlayerSuspendChangedPlayer`
`void OnPlayerTriggerEnter(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerTriggerEnter`	`onPlayerTriggerEnterPlayer`
`void OnPlayerTriggerExit(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerTriggerExit`	`onPlayerTriggerExitPlayer`
`void OnPlayerTriggerStay(VRC.SDKBase.VRCPlayerApi player)`	`_onPlayerTriggerStay`	`onPlayerTriggerStayPlayer`
`void OnPostSerialization(VRC.Udon.Common.SerializationResult result)`	`_onPostSerialization`	`onPostSerializationResult`
`void OnPreSerialization()`	`_onPreSerialization`	—
`void OnProductEvent(VRC.Economy.IProduct product, VRC.SDKBase.VRCPlayerApi player)`	`_onProductEvent`	`onProductEventResult` `onProductEventPlayer`
`void OnPurchaseConfirmed(VRC.Economy.IProduct product, VRC.SDKBase.VRCPlayerApi player, bool purchasedNow)`	`_onPurchaseConfirmed`	`onPurchaseConfirmedResult` `onPurchaseConfirmedPlayer` `onPurchaseConfirmedPurchasedNow`
`void OnPurchaseConfirmedMultiple(VRC.Economy.IProduct product, VRC.SDKBase.VRCPlayerApi player, bool purchasedNow, int quantity)`	`_onPurchaseConfirmedMultiple`	`onPurchaseConfirmedMultipleResult` `onPurchaseConfirmedMultiplePlayer` `onPurchaseConfirmedMultiplePurchasedNow` `onPurchaseConfirmedMultipleQuantity`
`void OnPurchaseExpired(VRC.Economy.IProduct product, VRC.SDKBase.VRCPlayerApi player)`	`_onPurchaseExpired`	`onPurchaseExpiredResult` `onPurchaseExpiredPlayer`
`void OnPurchasesLoaded(VRC.Economy.IProduct[] products, VRC.SDKBase.VRCPlayerApi player)`	`_onPurchasesLoaded`	`onPurchasesLoadedResult` `onPurchasesLoadedPlayer`
`void OnScreenUpdate(VRC.SDK3.Platform.ScreenUpdateData data)`	`_onScreenUpdate`	`onScreenUpdateData`
`void OnSpawn()`	`_onSpawn`	—
`void OnStationEntered(VRC.SDKBase.VRCPlayerApi player)`	`_onStationEntered`	`onStationEnteredPlayer`
`void OnStationExited(VRC.SDKBase.VRCPlayerApi player)`	`_onStationExited`	`onStationExitedPlayer`
`void OnStringLoadError(VRC.SDK3.StringLoading.IVRCStringDownload result)`	`_onStringLoadError`	`onStringLoadErrorIVRCStringDownload`
`void OnStringLoadSuccess(VRC.SDK3.StringLoading.IVRCStringDownload result)`	`_onStringLoadSuccess`	`onStringLoadSuccessIVRCStringDownload`
`void OnVRCCameraSettingsChanged(VRC.SDK3.Rendering.VRCCameraSettings cameraSettings)`	`_onVRCCameraSettingsChanged`	`onVRCCameraSettingsChangedCamera`
`void OnVRCPlusMassGift(VRC.SDKBase.VRCPlayerApi gifter, int numGifts)`	`_onVRCPlusMassGift`	`onVRCPlusMassGiftGifter` `onVRCPlusMassGiftNumGifts`
`void OnVRCQualitySettingsChanged()`	`_onVRCQualitySettingsChanged`	—
`void OnVideoEnd()`	`_onVideoEnd`	—
`void OnVideoError(VRC.SDK3.Components.Video.VideoError videoError)`	`_onVideoError`	`onVideoErrorVideoError`
`void OnVideoLoop()`	`_onVideoLoop`	—
`void OnVideoPause()`	`_onVideoPause`	—
`void OnVideoPlay()`	`_onVideoPlay`	—
`void OnVideoReady()`	`_onVideoReady`	—
`void OnVideoStart()`	`_onVideoStart`	—
`void PostLateUpdate()`	`_postLateUpdate`	—

Forms recognized by name and argument type

There’s no declaration in a base class, so you write the declaration yourself. The return type is void.

Syntax	Name called	Variable that receives the argument
`void FixedUpdate()`	`_fixedUpdate`	—
`void LateUpdate()`	`_lateUpdate`	—
`void OnAnimatorIK(int layerIndex)`	`_onAnimatorIK`	`onAnimatorIKLayerIndex`
`void OnAnimatorMove()`	`_onAnimatorMove`	—
`void OnBecameInvisible()`	`_onBecameInvisible`	—
`void OnBecameVisible()`	`_onBecameVisible`	—
`void OnCollisionEnter(UnityEngine.Collision other)`	`_onCollisionEnter`	`onCollisionEnterOther`
`void OnCollisionEnter2D(UnityEngine.Collision2D other)`	`_onCollisionEnter2D`	`onCollisionEnter2DOther`
`void OnCollisionExit(UnityEngine.Collision other)`	`_onCollisionExit`	`onCollisionExitOther`
`void OnCollisionExit2D(UnityEngine.Collision2D other)`	`_onCollisionExit2D`	`onCollisionExit2DOther`
`void OnCollisionStay(UnityEngine.Collision other)`	`_onCollisionStay`	`onCollisionStayOther`
`void OnCollisionStay2D(UnityEngine.Collision2D other)`	`_onCollisionStay2D`	`onCollisionStay2DOther`
`void OnControllerColliderHit(UnityEngine.ControllerColliderHit hit)`	`_onControllerColliderHit`	`onControllerColliderHitHit`
`void OnDestroy()`	`_onDestroy`	—
`void OnDisable()`	`_onDisable`	—
`void OnEnable()`	`_onEnable`	—
`void OnJointBreak(float breakForce)`	`_onJointBreak`	`onJointBreakBreakForce`
`void OnJointBreak2D(UnityEngine.Joint2D brokenJoint)`	`_onJointBreak2D`	`onJointBreak2DBrokenJoint`
`void OnMouseDown()`	`_onMouseDown`	—
`void OnMouseDrag()`	`_onMouseDrag`	—
`void OnMouseEnter()`	`_onMouseEnter`	—
`void OnMouseExit()`	`_onMouseExit`	—
`void OnMouseOver()`	`_onMouseOver`	—
`void OnMouseUp()`	`_onMouseUp`	—
`void OnMouseUpAsButton()`	`_onMouseUpAsButton`	—
`void OnParticleCollision(UnityEngine.GameObject other)`	`_onParticleCollision`	`onParticleCollisionOther`
`void OnParticleTrigger()`	`_onParticleTrigger`	—
`void OnPostRender()`	`_onPostRender`	—
`void OnPreCull()`	`_onPreCull`	—
`void OnPreRender()`	`_onPreRender`	—
`void OnRenderImage(UnityEngine.RenderTexture src, UnityEngine.RenderTexture dest)`	`_onRenderImage`	`onRenderImageSrc` `onRenderImageDest`
`void OnRenderObject()`	`_onRenderObject`	—
`void OnTransformChildrenChanged()`	`_onTransformChildrenChanged`	—
`void OnTransformParentChanged()`	`_onTransformParentChanged`	—
`void OnTriggerEnter(UnityEngine.Collider other)`	`_onTriggerEnter`	`onTriggerEnterOther`
`void OnTriggerEnter2D(UnityEngine.Collider2D other)`	`_onTriggerEnter2D`	`onTriggerEnter2DOther`
`void OnTriggerExit(UnityEngine.Collider other)`	`_onTriggerExit`	`onTriggerExitOther`
`void OnTriggerExit2D(UnityEngine.Collider2D other)`	`_onTriggerExit2D`	`onTriggerExit2DOther`
`void OnTriggerStay(UnityEngine.Collider other)`	`_onTriggerStay`	`onTriggerStayOther`
`void OnTriggerStay2D(UnityEngine.Collider2D other)`	`_onTriggerStay2D`	`onTriggerStay2DOther`
`void OnWillRenderObject()`	`_onWillRenderObject`	—
`void Start()`	`_start`	—
`void Update()`	`_update`	—

Forms that don’t compile (1)

Syntax	Description	Error	Reason	Instead
`public void _start() と void Start()`	Give a method the name the runtime uses	TUKI0001	runtime	Change the method’s name

The typo net

A misspelled name stops compilation only for events written with override. For the ones recognized by name, this net doesn’t exist.

Syntax	If you misspell the name	If you get the argument types wrong
Written with `override` (82)	Stops with `CS0115`	Stops with `CS0115`
Written by name and argument type (43)	Compiles. Never called	Compiles. Never called

How they’re recognized

There are two forms because events come from two sources. The 82 written with override are VRChat events; the base class holds the declaration. The 43 recognized by name are Unity messages; there’s no declaration anywhere, even tracing back through MonoBehaviour. Unity itself has called them by name since long ago.

The calling mechanism is the same for both. The compiler matches methods against a fixed list of names and argument types, and emits an entry point name like _start for the ones that match. The runtime calls that name. C#‘s virtual call isn’t used here. The override declaration exists so the C# compiler can check the name — that’s what it’s there for.

∴ Who checks the form you wrote differs between the two. For override, the C# compiler checks it. For the ones recognized by name, no one checks it. The table in the previous section is exactly this difference.

For the ones recognized by name, you write the declaration yourself. The shortest form is Start.

using UnityEngine;
using Tsukimi;

public class EventsStart : TsukimiBehaviour
{
    void Start()
    {
        Debug.Log(1);   // => 1
    }
}

For the ones written with override, you match the declaration the base class holds.

using UnityEngine;
using Tsukimi;

public class EventsInteract : TsukimiBehaviour
{
    public override void Interact()
    {
        Debug.Log(2);
    }

    void Start()
    {
        Debug.Log(1);
    }
}

// Output
// 1

C# checks both the spelling and the argument types, so a mistake stops compilation right there.

using UnityEngine;
using Tsukimi;
using VRC.SDKBase;

public class R_events_override_typo : TsukimiBehaviour
{
    public override void OnPlayerJoind(VRCPlayerApi player)
    {
        Debug.Log(player.playerId);
    }
}

The ones recognized by name have no such safety. Only methods whose name and argument types match the table become events; anything else is treated as an ordinary method. The following Update takes one argument, so it isn’t an event. Nothing calls it, so no instruction is generated either.

using UnityEngine;
using Tsukimi;

public class EventsNameMatchMiss : TsukimiBehaviour
{
    private void Update(float delta)
    {
        Debug.Log(2);
    }

    void Start()
    {
        Debug.Log(1);
    }
}

// Output
// 1

Visibility doesn’t matter. A method marked private still becomes an event.

using UnityEngine;
using Tsukimi;

public class EventsPrivateEvent : TsukimiBehaviour
{
    private void LateUpdate()
    {
        Debug.Log(2);
    }

    void Start()
    {
        Debug.Log(1);
    }
}

// Output
// 1

Name the runtime calls

The runtime calls the program using the event name with its first letter lowercased and a _ prefix. For Start, that’s _start. The middle column of the table above holds this name.

This name is registered separately from the method’s own name. If you write a method with the same spelling, the registration collides, so that form is rejected with TUKI0001.

using UnityEngine;
using Tsukimi;

public class R_events_entry_collision : TsukimiBehaviour
{
    public void _start()
    {
        Debug.Log(2);
    }

    void Start()
    {
        Debug.Log(1);
    }
}

How arguments arrive

Udon has no mechanism for passing arguments. The runtime writes the value into a named variable first, then calls the event.

The variable’s name joins the event name with its first letter lowercased and the runtime’s argument name with its first letter uppercased — that’s how it’s built. The right column of the table above holds this name.

If the name differs by even one character, the write goes nowhere. The event is still called, and the argument runs at its initial value. No error and no runtime failure occurs. The compiler holds this mapping, checked against the event definitions the runtime holds.

using UnityEngine;
using Tsukimi;
using VRC.SDKBase;

public class EventsPlayerJoined : TsukimiBehaviour
{
    public override void OnPlayerJoined(VRCPlayerApi player)
    {
        Debug.Log(player.playerId);
    }

    void Start()
    {
        Debug.Log(1);
    }
}

// Output
// 1

The runtime’s own argument name decides the variable’s name, not the argument name you wrote. You can name your argument anything.

using UnityEngine;
using Tsukimi;
using VRC.SDKBase;

public class EventsParameterName : TsukimiBehaviour
{
    public override void OnPlayerLeft(VRCPlayerApi who)
    {
        Debug.Log(who.playerId);
    }

    void Start()
    {
        Debug.Log(1);
    }
}

// Output
// 1

Events recognized by name receive arguments under the same rule.

using UnityEngine;
using Tsukimi;

public class EventsTriggerEnter : TsukimiBehaviour
{
    void OnTriggerEnter(Collider other)
    {
        Debug.Log(other.gameObject.activeSelf);
    }

    void Start()
    {
        Debug.Log(1);
    }
}

// Output
// 1

Ones where the names differ

There are events where the argument name in the base declaration differs from the name of the variable the runtime writes the value into — 22 of them. The argument name you wrote is never used, so behaviour doesn’t change.

Events	Argument name in the base declaration	Variable that receives the argument
`InputDrop`	`value`	`inputDropBoolValue`
`InputGrab`	`value`	`inputGrabBoolValue`
`InputJump`	`value`	`inputJumpBoolValue`
`InputLookHorizontal`	`value`	`inputLookHorizontalFloatValue`
`InputLookVertical`	`value`	`inputLookVerticalFloatValue`
`InputMoveHorizontal`	`value`	`inputMoveHorizontalFloatValue`
`InputMoveVertical`	`value`	`inputMoveVerticalFloatValue`
`InputUse`	`value`	`inputUseBoolValue`
`OnImageLoadError`	`result`	`onImageLoadErrorIVRCImageDownload`
`OnImageLoadSuccess`	`result`	`onImageLoadSuccessIVRCImageDownload`
`OnListAvailableProducts`	`products`	`onListAvailableProductsResult`
`OnListProductOwners`	`product`	`onListProductOwnersResult`
`OnListPurchases`	`products`	`onListPurchasesResult`
`OnOwnershipRequest`	`requestingPlayer` `requestedOwner`	`onOwnershipRequestRequester` `onOwnershipRequestNewOwner`
`OnProductEvent`	`product`	`onProductEventResult`
`OnPurchaseConfirmed`	`product`	`onPurchaseConfirmedResult`
`OnPurchaseConfirmedMultiple`	`product`	`onPurchaseConfirmedMultipleResult`
`OnPurchaseExpired`	`product`	`onPurchaseExpiredResult`
`OnPurchasesLoaded`	`products`	`onPurchasesLoadedResult`
`OnStringLoadError`	`result`	`onStringLoadErrorIVRCStringDownload`
`OnStringLoadSuccess`	`result`	`onStringLoadSuccessIVRCStringDownload`
`OnVRCCameraSettingsChanged`	`cameraSettings`	`onVRCCameraSettingsChangedCamera`

using UnityEngine;
using Tsukimi;
using VRC.Udon.Common;

public class EventsInputJump : TsukimiBehaviour
{
    public override void InputJump(bool value, UdonInputEventArgs args)
    {
        Debug.Log(value);
    }

    void Start()
    {
        Debug.Log(1);
    }
}

// Output
// 1

Form that takes no arguments

4 events also have a declaration with no arguments. If you don’t need the argument, you can write it this way.

Events	Another way to write it
`OnDeserialization`	`void OnDeserialization()`
`OnOwnershipTransferred`	`void OnOwnershipTransferred()`
`OnStationEntered`	`void OnStationEntered()`
`OnStationExited`	`void OnStationExited()`

using UnityEngine;
using Tsukimi;

public class EventsNoArgumentOverload : TsukimiBehaviour
{
    public override void OnStationEntered()
    {
        Debug.Log(2);
    }

    void Start()
    {
        Debug.Log(1);
    }
}

// Output
// 1

Ones called without writing any calling code

Every event in the tables above is called without a call written anywhere. For Interact, that’s when a player uses that object (see the example in How they’re recognized).

Form you call from code

Separately from events, there’s a form that calls a method by name. A method marked public is registered by name and becomes a destination for SendCustomEvent. The way to write it and the forms that get rejected are covered in Collaboration between components.

Registration happens even if there isn’t a single call inside that program. The caller may be in a different program, or on the runtime’s side, invisible at compile time.

Ones called along with sync

OnDeserialization OnPreSerialization OnPostSerialization OnOwnershipRequest and OnOwnershipTransferred are called along with value sync and ownership. The conditions for being called are covered in Sync.

Ones you can write conditionally

In the base classes of the distributed package, the following 6 are wrapped in conditional compilation. If the project hasn’t enabled that feature, the declaration doesn’t exist, so you can’t write it with override.

Events	Condition
`OnPersistenceUsageUpdated`	`VRC_ENABLE_PLAYER_PERSISTENCE \
`OnPlayerDataStorageExceeded`	`VRC_ENABLE_PLAYER_PERSISTENCE`
`OnPlayerDataStorageWarning`	`VRC_ENABLE_PLAYER_PERSISTENCE`
`OnPlayerDataUpdated`	`VRC_ENABLE_PLAYER_PERSISTENCE`
`OnPlayerObjectStorageExceeded`	`VRC_ENABLE_PLAYER_PERSISTENCE`
`OnPlayerObjectStorageWarning`	`VRC_ENABLE_PLAYER_PERSISTENCE`

Ones not in the runtime’s definitions

The following 2 compile, but they aren’t in the event definitions the runtime holds. Existing code that overrides existing code that override this name keeps compiling.

Events
`OnVideoPause`
`OnVideoPlay`

Ones this language doesn’t have

There’s 1 event that exists on the runtime’s side but not in this language. OnVariableChange is called under a different name per variable, so it can’t be placed as a single event.

using UnityEngine;
using Tsukimi;

public class R_events_on_variable_change : TsukimiBehaviour
{
    public override void OnVariableChange()
    {
        Debug.Log(1);
    }
}