add coreplayer, core effect and some module minor change

Author: SlejmUr

EIV_Core/CorePlayer.cs

@@ -0,0 +1,24 @@
+using EIV_Modules.Extensions;
+using EIV_Modules.Modules;
+
+namespace EIV_Core;
+
+public abstract class CorePlayer
+{
+    public string PlayerName { get; set; }
+    public string UserId { get; set; }
+    public string UserToken { get; set; }
+
+    public HealthModule Health { get; private set; }
+    public EnergyModule Energy { get; private set; }
+    public HydrationModule Hydration { get; private set; }
+
+    public void InitModules()
+    {
+        Health = this.AddAndGetModuleNode<HealthModule>();
+        Energy = this.AddAndGetModuleNode<EnergyModule>();
+        Hydration = this.AddAndGetModuleNode<HydrationModule>();
+        this.AddAndGetModuleNode<EffectModule>();
+        this.AddAndGetModuleNode<InventoryModule>();
+    }
+}

EIV_Core/Effects/CoreEffect.cs

@@ -0,0 +1,58 @@
+using EIV_Common.Coroutines;
+using EIV_JsonLib;
+using EIV_Modules.Modules;
+using System.Collections.Generic;
+
+namespace EIV_Core.Effects;
+
+public abstract class CoreEffect(Effect effect, object parent)
+{
+    CoroutineHandle? TimeCoroutine;
+    public Effect JsonEffect => effect;
+    private object Parent => parent;
+
+    public virtual void StartEffect()
+    {
+        StartEffect(JsonEffect.Time.Initial, JsonEffect.Strength.Min);
+    }
+
+    public virtual void StartEffect(double Seconds, int Strength)
+    {
+        TimeCoroutine = CoroutineStaticExt.StartCoroutine(TimeStuff(Seconds, Strength), "Effect");
+    }
+
+    public virtual void StopEffect()
+    {
+        if (TimeCoroutine == null)
+            return;
+        CoroutineStaticExt.KillCoroutineInstance(TimeCoroutine.Value);
+    }
+
+    public virtual void EffectTick(int Strength)
+    {
+        if (JsonEffect.Strength.ApplyTo.Contains("Health") && Parent.TryGetModule(out HealthModule healthModule))
+        {
+            healthModule.Damage(JsonEffect.Health.Negative * Strength, JsonEffect.Health.Cause);
+            healthModule.Heal(JsonEffect.Health.Positive * Strength, true);
+        }
+        if (JsonEffect.Strength.ApplyTo.Contains("Energy") && Parent.TryGetModule(out EnergyModule energyModule))
+        {
+            energyModule.RemoveValue(JsonEffect.Energy.Negative * Strength);
+            energyModule.AddValue(JsonEffect.Energy.Positive * Strength, false);
+        }
+    }
+
+    private IEnumerator<double> TimeStuff(double InitialTime, int Strength)
+    {
+        yield return JsonEffect.Time.WaitUntilApply;
+        double time = InitialTime;
+        yield return CoroutineStaticExt.WaitUntilZero(
+        () => 
+        {
+            EffectTick(Strength);
+            time--;
+            return time;
+        });
+        TimeCoroutine = null;
+    }
+}

EIV_Core/Modules/EffectModule.cs

@@ -0,0 +1,86 @@
+using EIV_Common.JsonStuff;
+using EIV_JsonLib;
+using EIV_JsonLib.Base;
+using EIV_JsonLib.Extension;
+using EIV_Core.Effects;
+using System.Collections.Generic;
+using System.Linq;
+using EIV_Modules;
+
+namespace EIV_Core.Modules;
+
+public partial class EffectModule : IModule
+{
+    internal List<EffectBase> Effects = [];
+
+    public void ApplyEffectFromItem(CoreItem item)
+    {
+        var sideEffects = item.GetProperty<List<SideEffect>>("SideEffects");
+        if (sideEffects.Count == 0)
+            return;
+        foreach (var sideEffect in sideEffects)
+        {
+            EffectApply(sideEffect, item);
+        }
+    }
+
+    public void EffectApply(SideEffect sideEffect, CoreItem item)
+    {
+        var effect = EffectMaker.MakeNewEffect(sideEffect.EffectName);
+        if (effect == null)
+            return;
+        // Cannot Apply from it.
+        if (!effect.AppliedFrom.Contains(item.Id) || effect.AppliedFrom.Contains(item.ItemType))
+            return;
+
+        if (effect.Strength.Max < sideEffect.EffectStrength)
+            return;
+        if (effect.Strength.Min > sideEffect.EffectStrength)
+            return;
+        /*
+        TODO: API
+        MakeEffectBase makeEffectBase = new(this, effect);
+        V2Manager.TriggerEvent(makeEffectBase);
+        // This means we couldnt made EffectBase
+        if (makeEffectBase.EffectBase == null)
+            return;
+        makeEffectBase.EffectBase.StartEffect(sideEffect.EffectTime, sideEffect.EffectStrength);
+        Effects.Add(makeEffectBase.EffectBase);
+        */
+    }
+
+
+    public void EffectApply(string EffectName)
+    {
+        var effect = EffectMaker.MakeNewEffect(EffectName);
+        if (effect == null)
+            return;
+        EffectApply(effect, effect.Time.Initial, effect.Strength.Min);
+    }
+
+    public void EffectApply(Effect effect, double time, int strength)
+    {
+        if (effect == null)
+            return;
+        /* TODO: API
+        MakeEffectBase makeEffectBase = new(this, effect);
+        V2Manager.TriggerEvent(makeEffectBase);
+        // This means we couldnt made EffectBase
+        if (makeEffectBase.EffectBase == null)
+            return;
+        makeEffectBase.EffectBase.StartEffect(time, strength);
+        Effects.Add(makeEffectBase.EffectBase);
+        */
+    }
+
+    public void DisableEffect(string EffectName)
+    {
+        var effect = Effects.SingleOrDefault(x => x.CoreEffect.EffectName == EffectName);
+        if (effect == null)
+            return;
+        effect.StopEffect();
+    }
+
+    public List<string> GetEffectNames() => Effects.Select(x => x.CoreEffect.EffectName).ToList();
+
+}

EIV_Core/Using.cs

@@ -0,0 +1 @@
+using CoroutineStaticExt = EIV_Coroutines.CoroutineWorkers.CoroutineStaticExt<double>;

EIV_Modules/Extensions/ModuleExtensions.cs

@@ -21,6 +21,18 @@ public static bool TryGetModule<T>(this object obj, out T out_t) where T : IModu
         return out_t != null;
     }
 
+    public static void AddModule<T>(this object obj) where T : IModule, new()
+    {
+        ModuleSub.AddModule?.Invoke(obj, new T());
+    }
+
+    public static T AddAndGetModule<T>(this object obj) where T : IModule, new()
+    {
+        T module = new();
+        ModuleSub.AddModule?.Invoke(obj, module);
+        return module;
+    }
+
     public static void AddModule<T>(this object obj, T module) where T : IModule
     {
         ModuleSub.AddModule?.Invoke(obj, module);

EIV_Modules/Modules/SimpleModules.cs

@@ -0,0 +1,5 @@
+namespace EIV_Modules.Modules;
+
+public partial class EnergyModule() : BaseChangingModule<int>(0, 100);
+
+public partial class HydrationModule() : BaseChangingModule<int>(0, 100);