Write Unity C# script for item pick-up using event.
- User
Write Unity C# script for item pick-up using event.
Assistant
Here's a Unity C# script for item pickup using events:
using UnityEngine; using System; public class ItemPickup : MonoBehaviour { // Event that will be triggered when item is picked up public static event Action<ItemPickup> OnItemPickedUp; [SerializeField] private string itemName = "Item"; [SerializeField] private int itemValue = 1; private void OnTriggerEnter(Collider other) { // Check if the colliding object is the player if (other.CompareTag("Player")) { // Invoke the event and pass this item as parameter OnItemPickedUp?.Invoke(this); // Destroy the item game object Destroy(gameObject); } } // Getters for item properties public string GetItemName() => itemName; public int GetItemValue() => itemValue; }Would you like me to explain or break down this code?
- User
Also that item should have a spin animation using script.
Assistant
Here's the updated script with a spinning animation added:
using UnityEngine; using System; public class ItemPickup : MonoBehaviour { // Event that will be triggered when item is picked up public static event Action<ItemPickup> OnItemPickedUp; [SerializeField] private string itemName = "Item"; [SerializeField] private int itemValue = 1; // Spinning animation parameters [SerializeField] private float rotationSpeed = 100f; [SerializeField] private Vector3 rotationAxis = Vector3.up; [SerializeField] private bool randomizeRotationAxis = false; private void Start() { // Optionally randomize the rotation axis for variety if (randomizeRotationAxis) { rotationAxis = new Vector3( UnityEngine.Random.Range(-1f, 1f), UnityEngine.Random.Range(-1f, 1f), UnityEngine.Random.Range(-1f, 1f) ).normalized; } } private void Update() { // Spin the item around the rotation axis transform.Rotate(rotationAxis, rotationSpeed * Time.deltaTime); } private void OnTriggerEnter(Collider other) { // Check if the colliding object is the player if (other.CompareTag("Player")) { // Invoke the event and pass this item as parameter OnItemPickedUp?.Invoke(this); // Destroy the item game object Destroy(gameObject); } } // Getters for item properties public string GetItemName() => itemName; public int GetItemValue() => itemValue; }Would you like me to explain or break down this code?
- User
When performance issues caused by this way of implementation will appear? Other implementation could be in 1 script and animation using shader.
Assistant
Performance issues with the current implementation could appear when:
- You have many items (hundreds or thousands) all running individual Update methods
- The rotation calculations are performed every frame for each item
- Each item has its own MonoBehaviour instance, increasing memory usage
A more performant implementation could use:
using UnityEngine; using System; using System.Collections.Generic; // Single manager script to handle all items public class ItemManager : MonoBehaviour { public static ItemManager Instance { get; private set; } public static event Action<ItemData> OnItemPickedUp; [SerializeField] private Material itemMaterial; private List<ItemData> activeItems = new List<ItemData>(); private void Awake() { Instance = this; // Set up shader properties for rotation animation if (itemMaterial != null) { itemMaterial.EnableKeyword("_ROTATION_ENABLED"); itemMaterial.SetFloat("_RotationSpeed", 2.0f); } } public void RegisterItem(ItemData item) { activeItems.Add(item); } public void ItemPickedUp(ItemData item) { OnItemPickedUp?.Invoke(item); activeItems.Remove(item); Destroy(item.gameObject); } } // Lightweight component for individual items public class ItemData : MonoBehaviour { [SerializeField] private string itemName = "Item"; [SerializeField] private int itemValue = 1; private void Start() { ItemManager.Instance.RegisterItem(this); } private void OnTriggerEnter(Collider other) { if (other.CompareTag("Player")) { ItemManager.Instance.ItemPickedUp(this); } } public string GetItemName() => itemName; public int GetItemValue() => itemValue; }The shader approach would require a custom shader with rotation logic:
// In your shader: _RotationSpeed ("Rotation Speed", Float) = 1.0 _RotationEnabled ("Enable Rotation", Float) = 1.0 // In vertex shader function: if (_RotationEnabled > 0.5) { float angle = _Time.y * _RotationSpeed; float s = sin(angle); float c = cos(angle); float2x2 rotMatrix = float2x2(c, -s, s, c); v.vertex.xz = mul(rotMatrix, v.vertex.xz); }This approach is more efficient because:
- No per-item Update calls
- Animation handled in GPU (shader) instead of CPU
- Centralized event management
- Reduced memory footprint
Would you like me to explain or break down this code?
- User
How to create a shader in URP?
Assistant
Here's how to create a spinning item shader in URP:
// Create a new shader file named "SpinningItem.shader" Shader "Custom/SpinningItem" { Properties { _BaseMap ("Texture", 2D) = "white" {} _BaseColor ("Color", Color) = (1, 1, 1, 1) _Smoothness ("Smoothness", Range(0, 1)) = 0.5 _Metallic ("Metallic", Range(0, 1)) = 0 _RotationSpeed ("Rotation Speed", Float) = 1.0 _RotationAxis ("Rotation Axis", Vector) = (0, 1, 0, 0) } SubShader { Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" } LOD 100 HLSLINCLUDE #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" ENDHLSL Pass { Name "ForwardLit" Tags { "LightMode" = "UniversalForward" } HLSLPROGRAM #pragma vertex vert #pragma fragment frag #pragma multi_compile _ _MAIN_LIGHT_SHADOWS #pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl" struct Attributes { float4 positionOS : POSITION; float3 normalOS : NORMAL; float2 uv : TEXCOORD0; }; struct Varyings { float4 positionCS : SV_POSITION; float2 uv : TEXCOORD0; float3 normalWS : TEXCOORD1; float3 positionWS : TEXCOORD2; }; TEXTURE2D(_BaseMap); SAMPLER(sampler_BaseMap); CBUFFER_START(UnityPerMaterial) float4 _BaseMap_ST; float4 _BaseColor; float _Smoothness; float _Metallic; float _RotationSpeed; float3 _RotationAxis; CBUFFER_END // Rotation matrix around arbitrary axis float3x3 AngleAxis3x3(float angle, float3 axis) { float c, s; sincos(angle, s, c); float t = 1 - c; float x = axis.x; float y = axis.y; float z = axis.z; return float3x3( t * x * x + c, t * x * y - s * z, t * x * z + s * y, t * x * y + s * z, t * y * y + c, t * y * z - s * x, t * x * z - s * y, t * y * z + s * x, t * z * z + c ); } Varyings vert(Attributes input) { Varyings output = (Varyings)0; // Apply rotation animation float angle = _Time.y * _RotationSpeed; float3 normalizedAxis = normalize(_RotationAxis); float3x3 rotationMatrix = AngleAxis3x3(angle, normalizedAxis); float3 rotatedPosition = mul(rotationMatrix, input.positionOS.xyz); float3 rotatedNormal = mul(rotationMatrix, input.normalOS); // Transform to clip space VertexPositionInputs positionInputs = GetVertexPositionInputs(rotatedPosition); VertexNormalInputs normalInputs = GetVertexNormalInputs(rotatedNormal); output.positionCS = positionInputs.positionCS; output.positionWS = positionInputs.positionWS; output.normalWS = normalInputs.normalWS; output.uv = TRANSFORM_TEX(input.uv, _BaseMap); return output; } half4 frag(Varyings input) : SV_Target { // Sample albedo texture half4 albedo = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv) * _BaseColor; // Setup surface data SurfaceData surfaceData = (SurfaceData)0; surfaceData.albedo = albedo.rgb; surfaceData.alpha = albedo.a; surfaceData.metallic = _Metallic; surfaceData.smoothness = _Smoothness; surfaceData.normalTS = float3(0, 0, 1); // Setup input data InputData inputData = (InputData)0; inputData.positionWS = input.positionWS; inputData.normalWS = normalize(input.normalWS); inputData.viewDirectionWS = GetWorldSpaceNormalizeViewDir(input.positionWS); inputData.shadowCoord = TransformWorldToShadowCoord(input.positionWS); // Calculate lighting half4 color = UniversalFragmentPBR(inputData, surfaceData); return color; } ENDHLSL } // Shadow casting pass Pass { Name "ShadowCaster" Tags { "LightMode" = "ShadowCaster" } ZWrite On ZTest LEqual HLSLPROGRAM #pragma vertex ShadowPassVertex #pragma fragment ShadowPassFragment #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl" CBUFFER_START(UnityPerMaterial) float _RotationSpeed; float3 _RotationAxis; CBUFFER_END // Same rotation function as above float3x3 AngleAxis3x3(float angle, float3 axis) { float c, s; sincos(angle, s, c); float t = 1 - c; float x = axis.x; float y = axis.y; float z = axis.z; return float3x3( t * x * x + c, t * x * y - s * z, t * x * z + s * y, t * x * y + s * z, t * y * y + c, t * y * z - s * x, t * x * z - s * y, t * y * z + s * x, t * z * z + c ); } struct Attributes { float4 positionOS : POSITION; float3 normalOS : NORMAL; }; struct Varyings { float4 positionCS : SV_POSITION; }; Varyings ShadowPassVertex(Attributes input) { Varyings output; // Apply rotation animation float angle = _Time.y * _RotationSpeed; float3 normalizedAxis = normalize(_RotationAxis); float3x3 rotationMatrix = AngleAxis3x3(angle, normalizedAxis); float3 rotatedPosition = mul(rotationMatrix, input.positionOS.xyz); output.positionCS = GetShadowPositionHClip(rotatedPosition, input.normalOS); return output; } half4 ShadowPassFragment(Varyings input) : SV_TARGET { return 0; } ENDHLSL } } }To use this shader:
- Create a new shader file in your project (right-click in Project window → Create → Shader → Standard Surface Shader)
- Replace the content with the code above
- Create a new material and assign this shader to it
- Adjust the rotation speed and axis in the material inspector
- Apply the material to your item objects
This shader-based approach is more efficient because:
- The rotation happens on the GPU instead of CPU
- No Update() calls needed for animation
- Works with instanced rendering for better performance with many items
- The visual rotation doesn't affect the actual transform, so physics/collisions remain simple
Would you like me to explain or break down this code?
- User
Despite that, what are advantages of event based implementation, compare to single update?
Assistant
Advantages of event-based implementation compared to a single update approach:
-
Decoupling and modularity
- Events create clear separation between systems (item pickup logic vs. inventory management)
- Components can subscribe/unsubscribe without direct references to each other
- Easier to maintain and extend as your game grows
-
Flexibility in response handling
- Multiple systems can react to the same event (UI updates, sound effects, achievements)
- New responses can be added without modifying the original item code
- Order of operations can be controlled through event subscription
-
Easier debugging
- Clear cause-and-effect relationships make bugs easier to trace
- Can add logging to event triggers/handlers without modifying core logic
- Easier to test individual components in isolation
-
Better for multiplayer/networked games
- Events can be synchronized across clients more naturally
- Network code can subscribe to events without tight coupling to game systems
- Easier to implement prediction/reconciliation patterns
-
Reduced polling overhead
- Code only executes when needed (when items are picked up)
- No need to check conditions every frame in Update()
- More efficient for infrequent but important game events
-
Better for designer workflows
- Unity's UnityEvent system allows designers to wire up responses in the inspector
- Easier to create custom editor tools around event-based systems
- Non-programmers can configure event responses without code changes
While shader-based animation is more performant, the event-based pickup system provides architectural benefits that improve code quality and maintainability, especially as your project scales.
-
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.