Feat: implement energy particle consumption

src/GameServer/Enums/ElementType.cs

@@ -7,15 +7,15 @@ namespace Weedwacker.GameServer.Enums
     public enum ElementType
     {
         None,
+        Fire = 1,
+        Water = 2,
+        Grass = 3,
+        Electric = 4,
+        Ice = 5,  
+        Frozen = 6,
+        Wind = 7,
+        Rock = 8,
         AntiFire,
-        Fire = 2,
-        Water = 3,
-        Wind = 4,
-        Ice = 5,
-        Rock = 6,
-        Electric = 7,
-        Grass = 8,
-        Frozen,
         Default = 255,
         VehicleMuteIce, //wtf
     }

src/GameServer/Packet/Recv/HandleGadgetInteractReq.cs

@@ -0,0 +1,21 @@
+using Weedwacker.GameServer.Enums;
+using Weedwacker.GameServer.Packet.Send;
+using Weedwacker.GameServer.Systems.World;
+using Weedwacker.Shared.Network.Proto;
+
+namespace Weedwacker.GameServer.Packet.Recv
+{
+    [OpCode((ushort)OpCode.GadgetInteractReq)]
+    internal class HandleGadgetInteractReq : BaseHandler
+    {
+        public override async Task HandleAsync(Connection session, byte[] header, byte[] payload)
+        {
+            GadgetInteractReq req = GadgetInteractReq.Parser.ParseFrom(payload);
+            var gadget = session.Player.Scene.GetEntityById(req.GadgetEntityId) as BaseGadgetEntity;
+            if (gadget is null)
+                return;
+            await gadget.OnInteractAsync(session.Player, req);
+            await session.Player.Scene?.BroadcastPacketAsync(new PacketGadgetInteractRsp(req.GadgetId, req.GadgetEntityId, gadget.InteractType, null));
+        }
+    }
+}

src/GameServer/Packet/Send/PacketGadgetInteractRsp.cs

@@ -0,0 +1,24 @@
+using Google.Protobuf;
+using Weedwacker.Shared.Network.Proto;
+
+namespace Weedwacker.GameServer.Packet.Send
+{
+    internal class PacketGadgetInteractRsp : BasePacket
+    {
+        public PacketGadgetInteractRsp(uint gadgetId, uint gadgetEntityId, InteractType interactType, InterOpType? opType) : base(Enums.OpCode.GadgetInteractRsp)
+        {
+            GadgetInteractRsp proto = new GadgetInteractRsp()
+            {
+                GadgetId = gadgetId,
+                GadgetEntityId = gadgetEntityId,
+                InteractType = interactType
+            };
+            if(opType != null)
+            {
+                proto.OpType = opType.Value;
+            }
+
+            Data = proto.ToByteArray();
+        }
+    }
+}

src/GameServer/Systems/Inventory/ItemUseOp/BaseItemUse.cs

@@ -13,6 +13,6 @@ namespace Weedwacker.GameServer.Systems.Inventory.ItemUseOp
             User = user;
             ItemData = (MaterialData)GameData.ItemDataMap[itemId];
         }
-        internal abstract Task<bool> Use();
+        internal abstract Task<bool> Use(uint count = 1);
     }
 }

src/GameServer/Systems/Inventory/ItemUseOp/ItemUseAcceptQuest.cs

@@ -7,7 +7,7 @@
         {
         }
 
-        internal override Task<bool> Use()
+        internal override async Task<bool> Use(uint count = 1)
         {
             throw new NotImplementedException();
         }

src/GameServer/Systems/Inventory/ItemUseOp/ItemUseAddAllEnergy.cs

@@ -0,0 +1,43 @@
+using Weedwacker.GameServer.Enums;
+
+namespace Weedwacker.GameServer.Systems.Inventory.ItemUseOp
+{
+    [ItemUse(Enums.ItemUseOp.ITEM_USE_ADD_ALL_ENERGY)]
+    internal class ItemUseAddAllEnergy : BaseItemUse
+    {
+        private readonly float energy;
+
+        public ItemUseAddAllEnergy(Player.Player user, uint itemId) : base(user, itemId)
+        {
+            if(!float.TryParse(ItemData.itemUse.Where(w => w.useOp == Enums.ItemUseOp.ITEM_USE_ADD_ALL_ENERGY).First().useParam[0], out energy))
+            {
+                energy = 0;
+            }
+        }
+        internal override async Task<bool> Use(uint count = 1)
+        {
+            switch (ItemData.useTarget)
+            {
+                case ItemUseTarget.ITEM_USE_TARGET_CUR_AVATAR:
+                    await User.TeamManager.CurrentAvatarEntity.AddEnergyAsync(energy * count, Shared.Network.Proto.PropChangeReason.EnergyBall);
+                    break;
+                case ItemUseTarget.ITEM_USE_TARGET_CUR_TEAM:
+                    float offFieldRatio = 1f - User.TeamManager.ActiveTeam.Count / 10f;
+                    foreach(var x in User.TeamManager.ActiveTeam)
+                    {
+                        if (x.Key == User.TeamManager.CurrentCharacterIndex || ItemData.materialType == MaterialType.MATERIAL_FOOD)
+                        {
+                            await x.Value.AddEnergyAsync(energy * count, Shared.Network.Proto.PropChangeReason.EnergyBall);
+                        }
+                        else await x.Value.AddEnergyAsync(energy * offFieldRatio * count, Shared.Network.Proto.PropChangeReason.EnergyBall);
+                    }
+                    break;
+                default:
+                    //TODO: handle other cases
+                    return false;
+
+            }
+            return true;
+        }
+    }
+}

src/GameServer/Systems/Inventory/ItemUseOp/ItemUseAddElemEnergy.cs

@@ -0,0 +1,52 @@
+using KcpSharp;
+using Weedwacker.GameServer.Enums;
+using Weedwacker.Shared.Utils;
+
+namespace Weedwacker.GameServer.Systems.Inventory.ItemUseOp
+{
+    [ItemUse(Enums.ItemUseOp.ITEM_USE_ADD_ELEM_ENERGY)]
+    internal class ItemUseAddElemEnergy : BaseItemUse
+    {
+        private readonly float energy = 0;
+        private readonly Enums.ElementType element = Enums.ElementType.None;
+        private readonly float altEnergy = 0;
+        public ItemUseAddElemEnergy(Player.Player user, uint itemId) : base(user, itemId)
+        {
+            if(int.TryParse(ItemData.itemUse.Where(w => w.useOp == Enums.ItemUseOp.ITEM_USE_ADD_ELEM_ENERGY).First().useParam[0], out int elementID))
+            {
+                element = (Enums.ElementType)elementID;
+            }
+            float.TryParse(ItemData.itemUse.Where(w => w.useOp == Enums.ItemUseOp.ITEM_USE_ADD_ELEM_ENERGY).First().useParam[1], out energy);
+            float.TryParse(ItemData.itemUse.Where(w => w.useOp == Enums.ItemUseOp.ITEM_USE_ADD_ELEM_ENERGY).First().useParam[2], out altEnergy);
+        }
+        internal override async Task<bool> Use(uint count = 1)
+        {
+            switch (ItemData.useTarget)
+            {
+                case ItemUseTarget.ITEM_USE_TARGET_CUR_AVATAR:
+                    float energyAmount = User.TeamManager.CurrentAvatarEntity.Avatar.CurSkillDepot.Element?.Type == element ? energy : altEnergy;
+                    await User.TeamManager.CurrentAvatarEntity.AddEnergyAsync(energyAmount * count, Shared.Network.Proto.PropChangeReason.EnergyBall);
+                    break;
+                case ItemUseTarget.ITEM_USE_TARGET_CUR_TEAM:
+                    float offFieldRatio = 1f - User.TeamManager.ActiveTeam.Count / 10f;
+                    foreach(var avatar in User.TeamManager.ActiveTeam)
+                    {
+                        if (avatar.Value.Avatar.CurSkillDepot.Element is null)
+                            continue;
+                        float amount = avatar.Value.Avatar.CurSkillDepot.Element.Type == element ? energy : altEnergy;
+                        if (avatar.Key == User.TeamManager.CurrentCharacterIndex || ItemData.materialType == MaterialType.MATERIAL_FOOD) //The food items do not care for off field chars
+                        {
+                            await avatar.Value.AddEnergyAsync(amount * count, Shared.Network.Proto.PropChangeReason.EnergyBall);
+                        }
+                        else await avatar.Value.AddEnergyAsync(amount * offFieldRatio * count, Shared.Network.Proto.PropChangeReason.EnergyBall);
+                    }
+                    break;
+                default:
+                    //TODO: handle other cases if any?
+                    return false;
+
+            }
+            return true;
+        }
+    }
+}

src/GameServer/Systems/World/AvatarEntity.cs

@@ -128,6 +128,8 @@ namespace Weedwacker.GameServer.Systems.World
 
         public async Task AddEnergyAsync(float amount, PropChangeReason reason, bool isFlat = false)
         {
+            if (Avatar.CurSkillDepot.Element is null || Avatar.LifeState == LifeState.LIFE_DEAD)
+                return;
             float curEnergy = Avatar.GetCurrentEnergy();
             float maxEnergy = Avatar.CurSkillDepot.Element.MaxEnergy;
 

src/GameServer/Systems/World/Gadget/GatherGadgetEntity.cs

@@ -1,4 +1,7 @@
-using System;
+using System;
+using Weedwacker.GameServer.Data;
+using Weedwacker.GameServer.Data.Excel;
+using Weedwacker.GameServer.Packet.Send;
 using Weedwacker.Shared.Network.Proto;
 using static Weedwacker.GameServer.Systems.Script.Scene.SceneGroup;
 
@@ -12,6 +15,7 @@ namespace Weedwacker.GameServer.Systems.World
         {
         }
 
+
         public override SceneEntityInfo ToProto()
         {
             SceneEntityInfo info = base.ToProto();

src/GameServer/Systems/World/SceneEntity.cs

@@ -12,7 +12,7 @@ namespace Weedwacker.GameServer.Systems.World
         public virtual Vector3 Position { get; protected set; }
         public virtual Vector3 Rotation { get; protected set; }
         public Vector3 Speed { get; protected set; }
-
+        public virtual InteractType InteractType => InteractType.None;
         public LifeState LiveState { get; protected set; }
         public MotionState MotionState { get; protected set; }
         public Dictionary<FightProperty, float> FightProps { get; protected set; }