feat: added reasources states based on resource health

Framework/Intersect.Framework.Core/GameObjects/Resources/ResourceStateDescriptor.cs

@@ -6,7 +6,7 @@ public partial class ResourceStateDescriptor
 
     public string Name { get; set; }
 
-    public string TextureName { get; set; } = default;
+    public string? TextureName { get; set; } = default;
 
     public ResourceTextureSource TextureType { get; set; } = ResourceTextureSource.Resource;
 

Intersect.Client.Core/Entities/Resource.cs

@@ -49,7 +49,6 @@ public ResourceDescriptor? Descriptor
         get => _descriptor;
         set
         {
-            _descriptor = value;
             if (value is { } descriptor)
             {
                 _maximumHealthForStates = (int)(descriptor.UseExplicitMaxHealthForResourceStates
@@ -60,6 +59,14 @@ public ResourceDescriptor? Descriptor
             {
                 _maximumHealthForStates = 0;
             }
+
+            if (value == _descriptor)
+            {
+                return;
+            }
+
+            _descriptor = value;
+            UpdateCurrentState();
         }
     }
 
@@ -109,7 +116,7 @@ private void ReloadSpriteTexture()
             case ResourceTextureSource.Tileset:
                 if (GameContentManager.Current.TilesetsLoaded)
                 {
-                    Texture = GameContentManager.Current.GetTexture(TextureType.Tileset, _sprite);
+                    Texture = GameContentManager.Current.GetTexture(TextureType.Tileset, _currentState?.TextureName);
                 }
                 else
                 {
@@ -118,7 +125,7 @@ private void ReloadSpriteTexture()
                 break;
 
             case ResourceTextureSource.Resource:
-                Texture = GameContentManager.Current.GetTexture(TextureType.Resource, _sprite);
+                Texture = GameContentManager.Current.GetTexture(TextureType.Resource, _currentState?.TextureName);
                 break;
 
             case ResourceTextureSource.Animation:
@@ -189,7 +196,6 @@ public override void Load(EntityPacket? packet)
         }
 
         Descriptor = descriptor;
-        UpdateCurrentState();
 
         if (!justDied)
         {
@@ -240,8 +246,8 @@ public void UpdateCurrentState()
         var currentHealthPercentage = Math.Floor((float)Vital[(int)Enums.Vital.Health] / _maximumHealthForStates * 100);
 
         if (_currentState is { } currentState &&
-            currentHealthPercentage >= _currentState?.MinimumHealth &&
-            currentHealthPercentage <= _currentState?.MaximumHealth
+            currentHealthPercentage >= currentState?.MinimumHealth &&
+            currentHealthPercentage <= currentState?.MaximumHealth
         )
         {
             return;
@@ -255,16 +261,14 @@ public void UpdateCurrentState()
         // but the previous state was an animation
         if (
             _currentState?.TextureType == ResourceTextureSource.Animation &&
-            _stateAnimation != default &&
             currentState?.TextureType != ResourceTextureSource.Animation
-            )
+        )
         {
-            _stateAnimation.Dispose();
+            _stateAnimation?.Dispose();
             _stateAnimation = default;
         }
 
         _currentState = currentState;
-        _sprite = _currentState?.TextureName ?? string.Empty;
 
         if (currentState is { TextureType: ResourceTextureSource.Animation } && currentState.AnimationId != Guid.Empty)
         {
@@ -299,7 +303,6 @@ public override bool Update()
         {
             _ = ResourceDescriptor.TryGet(deletedDescriptor.Id, out var descriptor);
             Descriptor = descriptor;
-            UpdateCurrentState();
         }
 
         if (!Maps.MapInstance.TryGet(MapId, out var map) || !map.InView())
@@ -338,7 +341,7 @@ public override bool Update()
 
     public override HashSet<Entity>? DetermineRenderOrder(HashSet<Entity>? renderList, IMapInstance? map)
     {
-        if (Descriptor == default || CurrentState is not { } graphicState || !graphicState.RenderBelowEntities)
+        if (CurrentState is not { } graphicState || !graphicState.RenderBelowEntities)
         {
             return base.DetermineRenderOrder(renderList, map);
         }
@@ -463,35 +466,29 @@ private void CalculateRenderBounds()
                 break;
 
             case ResourceTextureSource.Tileset:
-                if (IsDead)
+                ResourceStateDescriptor? selectedGraphic = null;
+
+                if (IsDead && graphicState is { MaximumHealth: 0 } deadGraphic)
                 {
-                    if (graphicState is { MaximumHealth: 0 } deadGraphic)
-                    {
-                        _renderBoundsSrc = new(
-                            deadGraphic.X * _tileWidth,
-                            deadGraphic.Y * _tileHeight,
-                            (deadGraphic.Width + 1) * _tileWidth,
-                            (deadGraphic.Height + 1) * _tileHeight
-                        );
-                    }
-                    else
-                    {
-                        _renderBoundsSrc = new();
-                    }
+                    selectedGraphic = deadGraphic;
                 }
-                else if (graphicState is { MinimumHealth: > 0 } aliveGraphic)
+                else if (!IsDead && graphicState is { MinimumHealth: > 0 } aliveGraphic)
                 {
-                    _renderBoundsSrc = new(
-                        aliveGraphic.X * _tileWidth,
-                        aliveGraphic.Y * _tileHeight,
-                        (aliveGraphic.Width + 1) * _tileWidth,
-                        (aliveGraphic.Height + 1) * _tileHeight
-                    );
+                    selectedGraphic = aliveGraphic;
                 }
+
+                _renderBoundsSrc = selectedGraphic is null
+                    ? default
+                    : new (
+                        selectedGraphic.X * _tileWidth,
+                        selectedGraphic.Y * _tileHeight,
+                        (selectedGraphic.Width + 1) * _tileWidth,
+                        (selectedGraphic.Height + 1) * _tileHeight
+                    );
                 break;
 
             case ResourceTextureSource.Animation:
-                _renderBoundsSrc = new();
+                _renderBoundsSrc = default;
                 break;
 
             default:

Intersect.Editor/Core/Graphics.cs

@@ -1348,7 +1348,9 @@ bool alternate
         var x2 = Options.Instance.Map.MapWidth;
         var y1 = 0;
         var y2 = Options.Instance.Map.MapHeight;
-        var xoffset = CurrentView.Left + gridX * Options.Instance.Map.TileWidth * Options.Instance.Map.MapWidth;
+        var tileWidth = Options.Instance.Map.TileWidth;
+        var tileHeight = Options.Instance.Map.TileHeight;
+        var xoffset = CurrentView.Left + gridX * tileWidth * Options.Instance.Map.MapWidth;
         var yoffset = CurrentView.Top + gridY * Options.Instance.Map.TileHeight * Options.Instance.Map.MapHeight;
 
         if (screenShotting)
@@ -1402,8 +1404,11 @@ bool alternate
                         continue;
                     }
 
+                    float xpos = x * tileWidth + xoffset;
+                    float ypos = y * Options.Instance.Map.TileHeight + yoffset;
+
                     // we have the graphic, now lets build based on type
-                    switch(resourceGraphic.TextureType)
+                    switch (resourceGraphic.TextureType)
                     {
                         case ResourceTextureSource.Resource:
                             {
@@ -1416,21 +1421,25 @@ bool alternate
                                     continue;
                                 }
 
-                                float xpos = x * Options.Instance.Map.TileWidth + xoffset;
-                                float ypos = y * Options.Instance.Map.TileHeight + yoffset;
-
                                 if (texture.Height > Options.Instance.Map.TileHeight)
                                 {
                                     ypos -= texture.Height - Options.Instance.Map.TileHeight;
                                 }
 
-                                if (texture.Width > Options.Instance.Map.TileWidth)
+                                if (texture.Width > tileWidth)
                                 {
-                                    xpos -= (texture.Width - Options.Instance.Map.TileWidth) / 2;
+                                    xpos -= (texture.Width - tileWidth) / 2;
                                 }
 
                                 DrawTexture(
-                                    texture, xpos, ypos, 0, 0, texture.Width, texture.Height, renderTarget
+                                    texture,
+                                    xpos,
+                                    ypos,
+                                    0,
+                                    0,
+                                    texture.Width,
+                                    texture.Height,
+                                    renderTarget
                                 );
                             }
                             break;
@@ -1446,24 +1455,25 @@ bool alternate
                                     continue;
                                 }
 
-                                float xpos = x * Options.Instance.Map.TileWidth + xoffset;
-                                float ypos = y * Options.Instance.Map.TileHeight + yoffset;
-
                                 if ((resourceGraphic.Height + 1) * Options.Instance.Map.TileHeight > Options.Instance.Map.TileHeight)
                                 {
                                     ypos -= (resourceGraphic.Height + 1) * Options.Instance.Map.TileHeight - Options.Instance.Map.TileHeight;
                                 }
 
-                                if ((resourceGraphic.Width + 1) * Options.Instance.Map.TileWidth > Options.Instance.Map.TileWidth)
+                                if ((resourceGraphic.Width + 1) * tileWidth > tileWidth)
                                 {
-                                    xpos -= ((resourceGraphic.Width + 1) * Options.Instance.Map.TileWidth - Options.Instance.Map.TileWidth) / 2;
+                                    xpos -= ((resourceGraphic.Width + 1) * tileWidth - tileWidth) / 2;
                                 }
 
                                 DrawTexture(
-                                    texture, xpos, ypos, resourceGraphic.X * Options.Instance.Map.TileWidth,
+                                    texture,
+                                    xpos,
+                                    ypos,
+                                    resourceGraphic.X * tileWidth,
                                     resourceGraphic.Y * Options.Instance.Map.TileHeight,
-                                    (resourceGraphic.Width + 1) * Options.Instance.Map.TileWidth,
-                                    (resourceGraphic.Height + 1) * Options.Instance.Map.TileHeight, renderTarget
+                                    (resourceGraphic.Width + 1) * tileWidth,
+                                    (resourceGraphic.Height + 1) * Options.Instance.Map.TileHeight,
+                                    renderTarget
                                 );
                             }
                             break;
@@ -1475,8 +1485,8 @@ bool alternate
                                     continue;
                                 }
 
-                                float xpos = x * Options.Instance.Map.TileWidth + xoffset + Options.Instance.Map.TileWidth / 2f;
-                                float ypos = y * Options.Instance.Map.TileHeight + yoffset + Options.Instance.Map.TileHeight / 2f;
+                                xpos += tileWidth / 2f;
+                                ypos += Options.Instance.Map.TileHeight / 2f;
 
                                 var animationInstance = tmpMap.GetAttributeAnimation(tmpMap.Attributes[x, y], animation.Id);
 
@@ -1514,7 +1524,7 @@ bool alternate
 
                     if (animation != null)
                     {
-                        float xpos = x * Options.Instance.Map.TileWidth + xoffset + Options.Instance.Map.TileWidth / 2;
+                        float xpos = x * tileWidth + xoffset + tileWidth / 2;
                         float ypos = y * Options.Instance.Map.TileHeight + yoffset + Options.Instance.Map.TileHeight / 2;
                         if (tmpMap.Attributes[x, y] != null)
                         {

Intersect.Editor/Forms/Editors/frmResource.cs

@@ -18,15 +18,16 @@ namespace Intersect.Editor.Forms.Editors;
 
 public partial class FrmResource : EditorForm
 {
+    private readonly List<string> _knownFolders = [];
+    private readonly BindingList<NotifiableDrop> _dropList = [];
+    private readonly BindingList<ResourceStateDescriptor> _stateList = [];
     private readonly Dictionary<Guid, ResourceDescriptor> _changed = [];
+
     private string? _copiedItem;
     private ResourceDescriptor? _editorItem;
     private Bitmap? _graphicBitmap;
     private Bitmap? _resourceGraphic;
     private bool _mouseDown;
-    private readonly List<string> _knownFolders = [];
-    private readonly BindingList<NotifiableDrop> _dropList = [];
-    private readonly BindingList<ResourceStateDescriptor> _stateList = [];
 
     public FrmResource()
     {
@@ -246,7 +247,7 @@ private void InitLocalization()
         btnDropAdd.Text = Strings.ResourceEditor.dropadd;
         btnDropRemove.Text = Strings.ResourceEditor.dropremove;
 
-        lblHpRegen.Text = Strings.ResourceEditor.hpregen;
+        lblHpRegen.Text = Strings.ResourceEditor.HealthRegenPercent;
         new ToolTip().SetToolTip(lblHpRegen, Strings.ResourceEditor.regenhint);
 
         grpGraphics.Text = Strings.ResourceEditor.Appearance;

Intersect.Editor/Localization/Strings.cs

@@ -5048,7 +5048,7 @@ public partial struct ResourceEditor
 
         public static LocalizedString StateNameError = @"State Name must be greater than 0 characters.";
 
-        public static LocalizedString hpregen = @"HP Regen (%):";
+        public static LocalizedString HealthRegenPercent = @"HP Regen (%):";
 
         public static LocalizedString maxhp = @"Max HP:";