Initial Commit

2026-04-05 18:57:16 +10:00
commit c3a5153a56
691 changed files with 85219 additions and 0 deletions
@@ -0,0 +1,70 @@
+using Easter2025.Components;
+using Kitchen;
+using KitchenLib.References;
+using KitchenMods;
+using MessagePack;
+using Unity.Collections;
+using Unity.Entities;
+using UnityEngine;
+
+namespace Easter2025.Views
+{
+    public class BinOrbView : UpdatableObjectView<BinOrbView.ViewData>
+    {
+        public class UpdateView : IncrementalViewSystemBase<ViewData>, IModSystem
+        {
+            private EntityQuery Views;
+
+            protected override void Initialise()
+            {
+                base.Initialise();
+
+                Views = GetEntityQuery(new QueryHelper().All(typeof(CAppliance), typeof(CApplianceBin), typeof(CLinkedView)));
+            }
+
+            protected override void OnUpdate()
+            {
+                using var entities = Views.ToEntityArray(Allocator.Temp);
+                using var views = Views.ToComponentDataArray<CLinkedView>(Allocator.Temp);
+
+                for (var i = 0; i < views.Length; i++)
+                {
+                    var view = views[i];
+                    var entity = entities[i];
+
+                    if (!Require(entity, out CAppliance cAppliance)) continue;
+                    if (cAppliance.ID != ApplianceReferences.Bin) continue;
+                    
+                    SendUpdate(view, new ViewData
+                    {
+                        ShouldShowGreenOrbs = Has<CHasOrbs>(entity) && !Has<CHasOrangeOrbs>(entity),
+                        ShouldShowOrangeOrbs = Has<CHasOrbs>(entity) && Has<CHasOrangeOrbs>(entity)
+                    });
+                }
+            }
+        }
+
+        [MessagePackObject(false)]
+        public struct ViewData : ISpecificViewData, IViewData.ICheckForChanges<ViewData>
+        {
+            [Key(0)] public bool ShouldShowGreenOrbs;
+            [Key(2)] public bool ShouldShowOrangeOrbs;
+
+            public IUpdatableObject GetRelevantSubview(IObjectView view) => view.GetSubView<BinOrbView>();
+
+            public bool IsChangedFrom(ViewData cached)
+            {
+                return ShouldShowGreenOrbs != cached.ShouldShowGreenOrbs || ShouldShowOrangeOrbs != cached.ShouldShowOrangeOrbs;
+            }
+        }
+
+        public GameObject GreenOrbs;
+        public GameObject OrangeOrbs;
+
+        protected override void UpdateData(ViewData view_data)
+        {
+            GreenOrbs.SetActive(view_data.ShouldShowGreenOrbs);
+            OrangeOrbs.SetActive(view_data.ShouldShowOrangeOrbs);
+        }
+    }
+}
@@ -0,0 +1,44 @@
+using Kitchen;
+using KitchenMods;
+using MessagePack;
+using UnityEngine;
+
+namespace Easter2025.Views
+{
+    public class BunnyEasterEggView : UpdatableObjectView<BunnyEasterEggView.ViewData>
+    {
+        public class UpdateView : IncrementalViewSystemBase<ViewData>, IModSystem
+        {
+            protected override void OnUpdate()
+            {
+            }
+        }
+        
+        [MessagePackObject(false)]
+        public class ViewData : ISpecificViewData, IViewData.ICheckForChanges<ViewData>
+        {
+            public IUpdatableObject GetRelevantSubview(IObjectView view)
+            {
+                return view.GetSubView<BunnyEasterEggView>();
+            }
+
+            public bool IsChangedFrom(ViewData check)
+            {
+                return true;
+            }
+        }
+        
+        protected override void UpdateData(ViewData viewData)
+        {
+
+        }
+        
+        public Animator GenericAnimator;
+
+        private void Update()
+        {
+            if (GenericAnimator == null) return;
+            GenericAnimator.SetBool("isLookingOut", true);
+        }
+    }
+}
@@ -0,0 +1,67 @@
+using Easter2025.Components;
+using Kitchen;
+using KitchenLib.References;
+using KitchenMods;
+using MessagePack;
+using Unity.Collections;
+using Unity.Entities;
+using UnityEngine;
+
+namespace Easter2025.Views
+{
+    public class BushView : UpdatableObjectView<BushView.ViewData>
+    {
+        public class UpdateView : IncrementalViewSystemBase<ViewData>, IModSystem
+        {
+            private EntityQuery Views;
+            private EntityQuery _ShouldShake;
+
+            protected override void Initialise()
+            {
+                base.Initialise();
+
+                Views = GetEntityQuery(new QueryHelper().All(typeof(CEggBush), typeof(CLinkedView)));
+                _ShouldShake = GetEntityQuery(typeof(CShouldShakeBushes));
+            }
+
+            protected override void OnUpdate()
+            {
+                using var entities = Views.ToEntityArray(Allocator.Temp);
+                using var views = Views.ToComponentDataArray<CLinkedView>(Allocator.Temp);
+
+                for (var i = 0; i < views.Length; i++)
+                {
+                    var entity = entities[i];
+                    var view = views[i];
+                    if (Require(entity, out CCanHideItem cCanHideItem))
+                    {
+                        SendUpdate(view, new ViewData
+                        {
+                            ShouldShake = !_ShouldShake.IsEmpty && cCanHideItem.HiddenItem != 0
+                        });
+                    }
+                }
+            }
+        }
+
+        [MessagePackObject(false)]
+        public struct ViewData : ISpecificViewData, IViewData.ICheckForChanges<ViewData>
+        {
+            [Key(0)] public bool ShouldShake;
+
+            public IUpdatableObject GetRelevantSubview(IObjectView view) => view.GetSubView<BushView>();
+
+            public bool IsChangedFrom(ViewData cached)
+            {
+                return ShouldShake != cached.ShouldShake;
+            }
+        }
+
+        public Animator Animator;
+        
+        protected override void UpdateData(ViewData view_data)
+        {
+            Animator.SetBool("IsShaking", view_data.ShouldShake);
+        }
+    }
+}
@@ -0,0 +1,26 @@
+using System.Collections.Generic;
+using KitchenLib.Utils;
+using UnityEngine;
+
+namespace Easter2025.Views.Local
+{
+    public class EggPileView : MonoBehaviour
+    {
+        public List<GameObject> EggContainers = new List<GameObject>();
+        private void Awake()
+        {
+            foreach (GameObject eggContainer in EggContainers)
+            {
+                foreach (Transform Egg in eggContainer.transform)
+                {
+                    Egg.gameObject.SetActive(false);
+                }
+            }
+
+            foreach (GameObject eggContainer in EggContainers)
+            {
+                eggContainer.transform.GetChild(Random.Range(0, eggContainer.transform.childCount)).gameObject.SetActive(true);
+            }
+        }
+    }
+}
@@ -0,0 +1,18 @@
+using UnityEngine;
+using UnityEngine.VFX;
+
+namespace Easter2025.Views.Local
+{
+    public class FlamingView : MonoBehaviour
+    {
+        public VisualEffect Fire;
+
+        private void Awake()
+        {
+            if (Fire == null) return;
+            Fire.initialEventName = "OnPlay";
+            Fire.SetFloat("Active", 1);
+            Fire.Play();
+        }
+    }
+}
@@ -0,0 +1,16 @@
+using UnityEngine;
+using Random = UnityEngine.Random;
+
+namespace Easter2025.Views.Local
+{
+    public class RandomPlacementView : MonoBehaviour
+    {
+        public Vector3 min = new(0, 0, 0);
+        public Vector3 max = new(0, 0, 0);
+        public GameObject Container;
+        private void Awake()
+        {
+            Container.transform.position = new Vector3(Random.Range(min.x, max.x), Random.Range(min.y, max.y), Random.Range(min.z, max.z)) + Container.transform.position;
+        }
+    }
+}
@@ -0,0 +1,17 @@
+using System;
+using UnityEngine;
+using Random = UnityEngine.Random;
+
+namespace Easter2025.Views.Local
+{
+    public class RandomRotationView : MonoBehaviour
+    {
+        public float min = -180f;
+        public float max = 180f;
+        public GameObject Container;
+        private void Awake()
+        {
+            Container.transform.rotation = Quaternion.Euler(0, Random.Range(min, max), 0);
+        }
+    }
+}
@@ -0,0 +1,129 @@
+using System;
+using Easter2025.Components;
+using Kitchen;
+using KitchenMods;
+using MessagePack;
+using Unity.Collections;
+using Unity.Entities;
+using UnityEngine;
+using UnityEngine.AI;
+
+namespace Easter2025.Views
+{
+    public class RoamingBunnyView : UpdatableObjectView<RoamingBunnyView.ViewData>
+    {
+        public NavMeshAgent agent;
+        public Animator animator;
+        
+        public override void SetPosition(UpdateViewPositionData pos)
+        {
+            if (!pos.Force && !((transform.localPosition - pos.Position).Chebyshev() > 0.5f)) return;
+            base.SetPosition(pos);
+            agent.Warp(pos.Position);
+        }
+        
+        protected override void UpdatePosition() { }
+        
+        public class UpdateView : IncrementalViewSystemBase<ViewData>, IModSystem
+        {
+            private EntityQuery _Bunnies;
+
+            protected override void Initialise()
+            {
+                base.Initialise();
+                _Bunnies = GetEntityQuery(typeof(CLinkedView), typeof(CBunny));
+            }
+
+            protected override void OnUpdate()
+            {
+                using (NativeArray<Entity> Bunnies = _Bunnies.ToEntityArray(Allocator.Temp))
+                {
+                    foreach (Entity Bunny in Bunnies)
+                    {
+                        if (!Require(Bunny, out CLinkedView cLinkedView) || !Has<CBunny>(Bunny)) continue;
+
+                        Vector3 TargetPosition = Vector3.zero;
+                        Vector3 PreferedFacingDirection = Vector3.zero;
+                        float StopDistance = 0;
+                        bool ShouldMove = false;
+                    
+                        if (Require(Bunny, out CMoveToLocation cMoveToLocation))
+                        {
+                            TargetPosition = cMoveToLocation.Location;
+                            PreferedFacingDirection = cMoveToLocation.DesiredFacing;
+                            StopDistance = cMoveToLocation.StoppingDistance;
+                            ShouldMove = true;
+                        }
+                    
+
+                        SendUpdate(cLinkedView, new ViewData
+                        {
+                            TargetPosition = TargetPosition,
+                            StopDistance = StopDistance,
+                            IsMoving = ShouldMove,
+                            PreferedFacingDirection = PreferedFacingDirection
+                        });
+                    }
+                }
+
+                
+            }
+        }
+        
+        [MessagePackObject(false)]
+        public class ViewData : ISpecificViewData, IViewData.ICheckForChanges<ViewData>
+        {
+            public IUpdatableObject GetRelevantSubview(IObjectView view)
+            {
+                return view.GetSubView<RoamingBunnyView>();
+            }
+
+            public bool IsChangedFrom(ViewData check)
+            {
+                return true;
+            }
+
+            [Key(0)] public bool IsMoving;
+            [Key(1)] public Vector3 TargetPosition;
+            [Key(2)] public float StopDistance;
+            [Key(3)] public Vector3 PreferedFacingDirection;
+        }
+
+        private ViewData Data;
+        
+        protected override void UpdateData(ViewData viewData)
+        {
+            Data = viewData;
+        }
+        
+        private void Update()
+        {
+            if (Data == null) return;
+
+            if (agent != null)
+            {
+                if (Data.TargetPosition != Vector3.zero && Data.IsMoving)
+                {
+                    agent.stoppingDistance = Data.StopDistance;
+                    agent.SetDestination(Data.TargetPosition);
+                }
+                
+                if (agent.remainingDistance <= agent.stoppingDistance && Data.PreferedFacingDirection != Vector3.zero)
+                {
+                    transform.rotation = Quaternion.LookRotation(Data.PreferedFacingDirection - transform.position, Vector3.up);
+                }
+
+                if (agent.velocity.magnitude > 0.1f)
+                {
+                    animator.SetBool("isJumping", true);
+                    animator.SetFloat("Speed", agent.velocity.magnitude);
+                }
+                else
+                {
+                    animator.SetBool("isJumping", false);
+                    animator.SetBool("isRunning", false);
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,67 @@
+using Easter2025.Components;
+using Easter2025.Customs.ItemGroups;
+using Kitchen;
+using KitchenLib.References;
+using KitchenLib.Utils;
+using KitchenMods;
+using MessagePack;
+using Unity.Collections;
+using Unity.Entities;
+using UnityEngine;
+
+namespace Easter2025.Views
+{
+    public class TootieEggs : UpdatableObjectView<TootieEggs.ViewData>
+    {
+        public class UpdateView : IncrementalViewSystemBase<ViewData>, IModSystem
+        {
+            private EntityQuery Views;
+
+            protected override void Initialise()
+            {
+                base.Initialise();
+
+                Views = GetEntityQuery(new QueryHelper().All(typeof(CItem), typeof(CLinkedView), typeof(CEgg)));
+            }
+
+            protected override void OnUpdate()
+            {
+                using var entities = Views.ToEntityArray(Allocator.Temp);
+                using var views = Views.ToComponentDataArray<CLinkedView>(Allocator.Temp);
+
+                for (var i = 0; i < views.Length; i++)
+                {
+                    var view = views[i];
+                    var entity = entities[i];
+                    
+                    SendUpdate(view, new ViewData
+                    {
+                        ShouldTootify = Utilies.Utility.IsTootieInLobby()
+                    });
+                }
+            }
+        }
+
+        [MessagePackObject(false)]
+        public struct ViewData : ISpecificViewData, IViewData.ICheckForChanges<ViewData>
+        {
+            [Key(0)] public bool ShouldTootify;
+
+            public IUpdatableObject GetRelevantSubview(IObjectView view) => view.GetSubView<TootieEggs>();
+
+            public bool IsChangedFrom(ViewData cached)
+            {
+                return ShouldTootify != cached.ShouldTootify;
+            }
+        }
+
+        public GameObject TootieEgg;
+        public GameObject NormalEgg;
+
+        protected override void UpdateData(ViewData view_data)
+        {
+            TootieEgg.SetActive(view_data.ShouldTootify);
+            NormalEgg.SetActive(!view_data.ShouldTootify);
+        }
+    }
+}