working on charging and quick attacks

Assets/jelycho/Code/Feedbacks/FeedbacksManagerActor.cs

@@ -0,0 +1,140 @@
+using System.Collections.Generic;
+using RebootKit.Engine.Main;
+using RebootKit.Engine.Network;
+using RebootKit.Engine.Simulation;
+using Unity.Mathematics;
+using UnityEngine;
+using Logger = RebootKit.Engine.Foundation.Logger;
+
+namespace RebootReality.jelycho.Feedbacks {
+    struct CameraShakeFeedback {
+        public Vector3 center;
+        public float radius;
+        public float intensity;
+        public float timer;
+        
+        public static int GetMaxBytes() {
+            return sizeof(float) * 3 + sizeof(float) * 3;
+        }
+    }
+
+    public class FeedbacksManagerActor : Actor {
+        static readonly Logger s_Logger = new Logger(nameof(FeedbacksManagerActor));
+
+        List<CameraShakeFeedback> m_ActiveCameraShakes = new List<CameraShakeFeedback>();
+
+        //
+        // @MARK: Camera shake
+        //
+        public void ShakeCamera(Vector3 center, float radius, float intensity, float duration) {
+            if (!RR.IsServer()) {
+                s_Logger.Error("ShakeCamera can only be called on the server.");
+                return;
+            }
+            
+            FeedbacksCameraShakeEvent ev = new FeedbacksCameraShakeEvent {
+                Feedback = new CameraShakeFeedback {
+                    center = center,
+                    radius = radius,
+                    intensity = intensity,
+                    timer = duration
+                }
+            };
+            SendActorEvent((byte)FeedbacksManagerActorEvents.CameraShake, ref ev);
+        }
+
+        public float GetShakeIntensityForPosition(Vector3 position) {
+            if (m_ActiveCameraShakes.Count == 0) {
+                return 0.0f;
+            }
+
+            float intensity = 0.0f;
+
+            foreach (CameraShakeFeedback feedback in m_ActiveCameraShakes) {
+                if (feedback.radius <= 0.0f) {
+                    continue;
+                }
+
+                float distSquared = math.distancesq(feedback.center, position);
+                float radiusSquared = feedback.radius * feedback.radius;
+
+                if (distSquared > radiusSquared) {
+                    continue;
+                }
+
+                float feedbackIntensity = Mathf.Lerp(0.0f,
+                                                     feedback.intensity,
+                                                     1.0f - (distSquared / radiusSquared));
+                intensity = Mathf.Max(feedbackIntensity, intensity);
+            }
+
+            return intensity;
+        }
+        
+        //
+        // @MARK: Actor
+        //
+        protected override IActorData CreateActorData() {
+            return new NoActorData();
+        }
+        
+        public override void OnClientTick(float deltaTime) {
+            for (int i = m_ActiveCameraShakes.Count - 1; i >= 0; i--) {
+                CameraShakeFeedback feedback = m_ActiveCameraShakes[i];
+                feedback.timer -= deltaTime;
+
+                if (feedback.timer <= 0.0f) {
+                    m_ActiveCameraShakes.RemoveAt(i);
+                    continue;
+                }
+
+                m_ActiveCameraShakes[i] = feedback;
+            }
+        }
+
+        protected override void OnActorEventClient(ActorEvent actorEvent) {
+            FeedbacksManagerActorEvents feedbackEvent = (FeedbacksManagerActorEvents)actorEvent.EventID;
+
+            switch (feedbackEvent) {
+            
+            case FeedbacksManagerActorEvents.CameraShake: {
+                FeedbacksCameraShakeEvent ev = new FeedbacksCameraShakeEvent();
+                DataSerializationUtils.Deserialize(actorEvent.Data, ref ev);
+
+                if (ev.Feedback.timer > 0.0f) {
+                    m_ActiveCameraShakes.Add(ev.Feedback);
+                }
+                break;
+            }
+            
+            }
+        }
+    }
+    
+    enum FeedbacksManagerActorEvents : byte {
+        None = 0x00,
+        CameraShake = 0x01,
+    }
+
+    struct FeedbacksCameraShakeEvent : IActorData {
+        public CameraShakeFeedback Feedback;
+
+        public int GetMaxBytes() {
+            return CameraShakeFeedback.GetMaxBytes();
+        }
+
+        public void Serialize(NetworkBufferWriter writer) {
+            writer.Write(Feedback.center);
+            writer.Write(Feedback.radius);
+            writer.Write(Feedback.intensity);
+            writer.Write(Feedback.timer);
+        }
+
+        public void Deserialize(NetworkBufferReader reader) {
+            reader.Read(out Feedback.center);
+            reader.Read(out Feedback.radius);
+            reader.Read(out Feedback.intensity);
+            reader.Read(out Feedback.timer);
+        }
+    }
+}

Assets/jelycho/Code/Feedbacks/FeedbacksManagerActor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c66663d8df214ee9b21785208a782cc0
+timeCreated: 1753936932