fix(1447): kill resource instances on save

pandinocoder · pandinocoder · commit 2c4edc94e489 · 2025-01-16T00:22:14.000+01:00
client fixes:
- update resource instance descriptor (detect deletion)
- reload resource sprite on descriptor deletion
diff --git a/Framework/Intersect.Framework.Core/Models/DatabaseObject.cs b/Framework/Intersect.Framework.Core/Models/DatabaseObject.cs
@@ -58,6 +58,8 @@ public GameObjectType Type
     [Column(Order = 0)]
     public string Name { get; set; }
 
+    [NotMapped, JsonIgnore] public bool IsDeleted => !Lookup.TryGetValue(Id, out var descriptor) || descriptor != this;
+
     public virtual void Load(string json, bool keepCreationTime = false)
     {
         var oldTime = TimeCreated;
diff --git a/Intersect.Client.Core/Entities/Entity.cs b/Intersect.Client.Core/Entities/Entity.cs
@@ -126,7 +126,7 @@ public Guid[] Equipment
 
     private long mLastUpdate;
 
-    protected string mMySprite = string.Empty;
+    protected string _sprite = string.Empty;
 
     public Color Color { get; set; } = new Color(255, 255, 255, 255);
 
@@ -286,23 +286,23 @@ public virtual string TransformedSprite
 
             mTransformedSprite = value;
 
-            var textureName = string.IsNullOrEmpty(mTransformedSprite) ? mMySprite : mTransformedSprite;
+            var textureName = string.IsNullOrEmpty(mTransformedSprite) ? _sprite : mTransformedSprite;
             LoadTextures(textureName);
         }
     }
 
     public virtual string Sprite
     {
-        get => mMySprite;
+        get => _sprite;
         set
         {
-            if (mMySprite == value)
+            if (_sprite == value)
             {
                 return;
             }
 
-            mMySprite = value;
-            LoadTextures(mMySprite);
+            _sprite = value;
+            LoadTextures(_sprite);
         }
     }
 
@@ -2294,7 +2294,7 @@ public int IsTileBlocked(
                             switch (en.Value)
                             {
                                 case Resource resource:
-                                    var resourceBase = resource.BaseResource;
+                                    var resourceBase = resource.Descriptor;
                                     if (resourceBase != null)
                                     {
                                         if (projectileTrigger)
diff --git a/Intersect.Client.Core/Entities/Resource.cs b/Intersect.Client.Core/Entities/Resource.cs
@@ -12,58 +12,76 @@ namespace Intersect.Client.Entities;
 
 public partial class Resource : Entity, IResource
 {
-    private bool _waitingForTilesets;
-
-    public ResourceBase? BaseResource { get; set; }
+    private FloatRect _renderBoundsDest = FloatRect.Empty;
+    private FloatRect _renderBoundsSrc = FloatRect.Empty;
 
-    bool IResource.IsDepleted => IsDead;
+    private bool _recalculateRenderBounds;
+    private bool _waitingForTilesets;
 
-    public bool IsDead { get; set; }
+    private bool _isDead;
+    private ResourceBase? _descriptor;
 
-    FloatRect mDestRectangle = FloatRect.Empty;
+    public Resource(Guid id, ResourceEntityPacket packet) : base(id, packet, EntityType.Resource)
+    {
+        mRenderPriority = 0;
+    }
 
-    private bool mHasRenderBounds;
+    public ResourceBase? Descriptor
+    {
+        get => _descriptor;
+        set => _descriptor = value;
+    }
 
-    FloatRect mSrcRectangle = FloatRect.Empty;
+    public bool IsDepleted => IsDead;
 
-    public Resource(Guid id, ResourceEntityPacket packet) : base(id, packet, EntityType.Resource)
+    public bool IsDead
     {
-        mRenderPriority = 0;
+        get => _isDead;
+        set
+        {
+            if (value == _isDead)
+            {
+                return;
+            }
+
+            _isDead = value;
+            _recalculateRenderBounds = true;
+        }
     }
 
     public override string Sprite
     {
-        get => mMySprite;
+        get => _sprite;
         set
         {
-            if (value == mMySprite)
+            if (value == _sprite)
             {
                 return;
             }
 
-            if (BaseResource == null)
+            if (Descriptor == null)
             {
                 return;
             }
 
-            mMySprite = value;
+            _sprite = value;
             ReloadSpriteTexture();
         }
     }
 
     private void ReloadSpriteTexture()
     {
-        if (BaseResource == null)
+        if (Descriptor == null)
         {
             return;
         }
 
-        if (IsDead && BaseResource.Exhausted.GraphicFromTileset ||
-            !IsDead && BaseResource.Initial.GraphicFromTileset)
+        if (IsDead && Descriptor.Exhausted.GraphicFromTileset ||
+            !IsDead && Descriptor.Initial.GraphicFromTileset)
         {
             if (GameContentManager.Current.TilesetsLoaded)
             {
-                Texture = Globals.ContentManager.GetTexture(Framework.Content.TextureType.Tileset, mMySprite);
+                Texture = Globals.ContentManager.GetTexture(Framework.Content.TextureType.Tileset, _sprite);
             }
             else
             {
@@ -72,40 +90,43 @@ private void ReloadSpriteTexture()
         }
         else
         {
-            Texture = Globals.ContentManager.GetTexture(Framework.Content.TextureType.Resource, mMySprite);
+            Texture = Globals.ContentManager.GetTexture(Framework.Content.TextureType.Resource, _sprite);
         }
 
-        mHasRenderBounds = false;
+        _recalculateRenderBounds = true;
     }
 
     public override void Load(EntityPacket? packet)
     {
         base.Load(packet);
-        var pkt = packet as ResourceEntityPacket;
 
-        if (pkt == default)
+        _recalculateRenderBounds = true;
+
+        if (packet is not ResourceEntityPacket resourceEntityPacket)
         {
             return;
         }
 
-        IsDead = pkt.IsDead;
-        var baseId = pkt.ResourceId;
-        BaseResource = ResourceBase.Get(baseId);
+        IsDead = resourceEntityPacket.IsDead;
 
-        if (BaseResource == default)
+        if (!ResourceBase.TryGet(resourceEntityPacket.ResourceId, out _descriptor))
         {
             return;
         }
 
-        HideName = true;
-        if (IsDead)
-        {
-            Sprite = BaseResource.Exhausted.Graphic;
-        }
-        else
+        UpdateFromDescriptor(_descriptor);
+    }
+
+    private void UpdateFromDescriptor(ResourceBase? descriptor)
+    {
+        if (descriptor == null)
         {
-            Sprite = BaseResource.Initial.Graphic;
+            return;
         }
+
+        var updatedSprite = IsDead ? descriptor.Exhausted.Graphic : descriptor.Initial.Graphic;
+        _sprite = updatedSprite;
+        ReloadSpriteTexture();
     }
 
     public override void Dispose()
@@ -130,6 +151,12 @@ public override bool Update()
             return false;
         }
 
+        if (Descriptor is { IsDeleted: true } deletedDescriptor)
+        {
+            _ = ResourceBase.TryGet(deletedDescriptor.Id, out _descriptor);
+            UpdateFromDescriptor(_descriptor);
+        }
+
         if (!Maps.MapInstance.TryGet(MapId, out var map) || !map.InView())
         {
             LatestMap = map;
@@ -138,12 +165,12 @@ public override bool Update()
             return false;
         }
 
-        if (!mHasRenderBounds)
+        if (_recalculateRenderBounds)
         {
             CalculateRenderBounds();
         }
 
-        if (!Graphics.WorldViewport.IntersectsWith(mDestRectangle))
+        if (!Graphics.WorldViewport.IntersectsWith(_renderBoundsDest))
         {
             if (RenderList != null)
             {
@@ -170,9 +197,9 @@ public override bool Update()
 
     public override HashSet<Entity>? DetermineRenderOrder(HashSet<Entity>? renderList, IMapInstance? map)
     {
-        if (BaseResource == default ||
-            (IsDead && !BaseResource.Exhausted.RenderBelowEntities) ||
-            (!IsDead && !BaseResource.Initial.RenderBelowEntities)
+        if (Descriptor == default ||
+            (IsDead && !Descriptor.Exhausted.RenderBelowEntities) ||
+            (!IsDead && !Descriptor.Initial.RenderBelowEntities)
         )
         {
             return base.DetermineRenderOrder(renderList, map);
@@ -249,7 +276,7 @@ public override bool Update()
 
     private void CalculateRenderBounds()
     {
-        if (BaseResource == default)
+        if (Descriptor == default)
         {
             return;
         }
@@ -278,43 +305,43 @@ private void CalculateRenderBounds()
             return;
         }
 
-        mSrcRectangle.X = 0;
-        mSrcRectangle.Y = 0;
-        if (IsDead && BaseResource.Exhausted.GraphicFromTileset)
+        _renderBoundsSrc.X = 0;
+        _renderBoundsSrc.Y = 0;
+        if (IsDead && Descriptor.Exhausted.GraphicFromTileset)
         {
-            mSrcRectangle.X = BaseResource.Exhausted.X * Options.TileWidth;
-            mSrcRectangle.Y = BaseResource.Exhausted.Y * Options.TileHeight;
-            mSrcRectangle.Width = (BaseResource.Exhausted.Width + 1) * Options.TileWidth;
-            mSrcRectangle.Height = (BaseResource.Exhausted.Height + 1) * Options.TileHeight;
+            _renderBoundsSrc.X = Descriptor.Exhausted.X * Options.TileWidth;
+            _renderBoundsSrc.Y = Descriptor.Exhausted.Y * Options.TileHeight;
+            _renderBoundsSrc.Width = (Descriptor.Exhausted.Width + 1) * Options.TileWidth;
+            _renderBoundsSrc.Height = (Descriptor.Exhausted.Height + 1) * Options.TileHeight;
         }
-        else if (!IsDead && BaseResource.Initial.GraphicFromTileset)
+        else if (!IsDead && Descriptor.Initial.GraphicFromTileset)
         {
-            mSrcRectangle.X = BaseResource.Initial.X * Options.TileWidth;
-            mSrcRectangle.Y = BaseResource.Initial.Y * Options.TileHeight;
-            mSrcRectangle.Width = (BaseResource.Initial.Width + 1) * Options.TileWidth;
-            mSrcRectangle.Height = (BaseResource.Initial.Height + 1) * Options.TileHeight;
+            _renderBoundsSrc.X = Descriptor.Initial.X * Options.TileWidth;
+            _renderBoundsSrc.Y = Descriptor.Initial.Y * Options.TileHeight;
+            _renderBoundsSrc.Width = (Descriptor.Initial.Width + 1) * Options.TileWidth;
+            _renderBoundsSrc.Height = (Descriptor.Initial.Height + 1) * Options.TileHeight;
         }
         else
         {
-            mSrcRectangle.Width = Texture.Width;
-            mSrcRectangle.Height = Texture.Height;
+            _renderBoundsSrc.Width = Texture.Width;
+            _renderBoundsSrc.Height = Texture.Height;
         }
 
-        mDestRectangle.Width = mSrcRectangle.Width;
-        mDestRectangle.Height = mSrcRectangle.Height;
-        mDestRectangle.Y = (int) (map.Y + Y * Options.TileHeight + OffsetY);
-        mDestRectangle.X = (int) (map.X + X * Options.TileWidth + OffsetX);
-        if (mSrcRectangle.Height > Options.TileHeight)
+        _renderBoundsDest.Width = _renderBoundsSrc.Width;
+        _renderBoundsDest.Height = _renderBoundsSrc.Height;
+        _renderBoundsDest.Y = (int) (map.Y + Y * Options.TileHeight + OffsetY);
+        _renderBoundsDest.X = (int) (map.X + X * Options.TileWidth + OffsetX);
+        if (_renderBoundsSrc.Height > Options.TileHeight)
         {
-            mDestRectangle.Y -= mSrcRectangle.Height - Options.TileHeight;
+            _renderBoundsDest.Y -= _renderBoundsSrc.Height - Options.TileHeight;
         }
 
-        if (mSrcRectangle.Width > Options.TileWidth)
+        if (_renderBoundsSrc.Width > Options.TileWidth)
         {
-            mDestRectangle.X -= (mSrcRectangle.Width - Options.TileWidth) / 2;
+            _renderBoundsDest.X -= (_renderBoundsSrc.Width - Options.TileWidth) / 2;
         }
 
-        mHasRenderBounds = true;
+        _recalculateRenderBounds = false;
     }
 
     //Rendering Resources
@@ -327,7 +354,7 @@ public override void Draw()
 
         if (Texture != null)
         {
-            Graphics.DrawGameTexture(Texture, mSrcRectangle, mDestRectangle, Intersect.Color.White);
+            Graphics.DrawGameTexture(Texture, _renderBoundsSrc, _renderBoundsDest, Intersect.Color.White);
         }
     }
 }
diff --git a/Intersect.Client.Core/Networking/PacketHandler.cs b/Intersect.Client.Core/Networking/PacketHandler.cs
@@ -1681,7 +1681,7 @@ public void HandlePacket(IPacketSender packetSender, BankUpdatePacket packet)
     public void HandlePacket(IPacketSender packetSender, GameObjectPacket packet)
     {
         var type = packet.Type;
-        var id = packet.Id;
+        var objectId = packet.Id;
         var another = packet.AnotherFollowing;
         var deleted = packet.Deleted;
         var json = string.Empty;
@@ -1696,9 +1696,9 @@ public void HandlePacket(IPacketSender packetSender, GameObjectPacket packet)
                 //Handled in a different packet
                 break;
             case GameObjectType.Tileset:
-                var obj = new TilesetBase(id);
+                var obj = new TilesetBase(objectId);
                 obj.Load(json);
-                TilesetBase.Lookup.Set(id, obj);
+                TilesetBase.Lookup.Set(objectId, obj);
                 if (Globals.HasGameData && !another)
                 {
                     Globals.ContentManager.LoadTilesets(TilesetBase.GetNameList());
@@ -1710,15 +1710,18 @@ public void HandlePacket(IPacketSender packetSender, GameObjectPacket packet)
                 break;
             default:
                 var lookup = type.GetLookup();
-                if (deleted)
+
+                _ = lookup.DeleteAt(objectId);
+                if (!deleted)
                 {
-                    lookup.Get(id)?.Delete();
+                    var objectType = type.GetObjectType();
+                    var databaseObject = lookup.AddNew(objectType, objectId);
+                    databaseObject.Load(json);
                 }
-                else
+
+                if (type == GameObjectType.Resource)
                 {
-                    lookup.DeleteAt(id);
-                    var item = lookup.AddNew(type.GetObjectType(), id);
-                    item.Load(json);
+
                 }
 
                 break;
diff --git a/Intersect.Client.Framework/Entities/IResource.cs b/Intersect.Client.Framework/Entities/IResource.cs
@@ -4,7 +4,7 @@ namespace Intersect.Client.Framework.Entities;
 
 public interface IResource : IEntity
 {
-    ResourceBase? BaseResource { get; }
+    ResourceBase? Descriptor { get; }
     
     bool IsDepleted { get; }
 }
diff --git a/Intersect.Server/Networking/NetworkedPacketHandler.cs b/Intersect.Server/Networking/NetworkedPacketHandler.cs

Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,8 @@ public GameObjectType Type`
`58`	`58`	`[Column(Order = 0)]`
`59`	`59`	`public string Name { get; set; }`
`60`	`60`
	`61`	`+ [NotMapped, JsonIgnore] public bool IsDeleted => !Lookup.TryGetValue(Id, out var descriptor) \|\| descriptor != this;`
	`62`	`+`
`61`	`63`	`public virtual void Load(string json, bool keepCreationTime = false)`
`62`	`64`	`{`
`63`	`65`	`var oldTime = TimeCreated;`
Original file line number	Diff line number	Diff line change
`@@ -126,7 +126,7 @@ public Guid[] Equipment`
`126`	`126`
`127`	`127`	`private long mLastUpdate;`
`128`	`128`
`129`		`- protected string mMySprite = string.Empty;`
	`129`	`+ protected string _sprite = string.Empty;`
`130`	`130`
`131`	`131`	`public Color Color { get; set; } = new Color(255, 255, 255, 255);`
`132`	`132`
`@@ -286,23 +286,23 @@ public virtual string TransformedSprite`
`286`	`286`
`287`	`287`	`mTransformedSprite = value;`
`288`	`288`
`289`		`- var textureName = string.IsNullOrEmpty(mTransformedSprite) ? mMySprite : mTransformedSprite;`
	`289`	`+ var textureName = string.IsNullOrEmpty(mTransformedSprite) ? _sprite : mTransformedSprite;`
`290`	`290`	`LoadTextures(textureName);`
`291`	`291`	`}`
`292`	`292`	`}`
`293`	`293`
`294`	`294`	`public virtual string Sprite`
`295`	`295`	`{`
`296`		`- get => mMySprite;`
	`296`	`+ get => _sprite;`
`297`	`297`	`set`
`298`	`298`	`{`
`299`		`- if (mMySprite == value)`
	`299`	`+ if (_sprite == value)`
`300`	`300`	`{`
`301`	`301`	`return;`
`302`	`302`	`}`
`303`	`303`
`304`		`- mMySprite = value;`
`305`		`- LoadTextures(mMySprite);`
	`304`	`+ _sprite = value;`
	`305`	`+ LoadTextures(_sprite);`
`306`	`306`	`}`
`307`	`307`	`}`
`308`	`308`
`@@ -2294,7 +2294,7 @@ public int IsTileBlocked(`
`2294`	`2294`	`switch (en.Value)`
`2295`	`2295`	`{`
`2296`	`2296`	`case Resource resource:`
`2297`		`- var resourceBase = resource.BaseResource;`
	`2297`	`+ var resourceBase = resource.Descriptor;`
`2298`	`2298`	`if (resourceBase != null)`
`2299`	`2299`	`{`
`2300`	`2300`	`if (projectileTrigger)`
Original file line number	Diff line number	Diff line change
`@@ -12,58 +12,76 @@ namespace Intersect.Client.Entities;`
`12`	`12`
`13`	`13`	`public partial class Resource : Entity, IResource`
`14`	`14`	`{`
`15`		`- private bool _waitingForTilesets;`
`16`		`-`
`17`		`- public ResourceBase? BaseResource { get; set; }`
	`15`	`+ private FloatRect _renderBoundsDest = FloatRect.Empty;`
	`16`	`+ private FloatRect _renderBoundsSrc = FloatRect.Empty;`
`18`	`17`
`19`		`- bool IResource.IsDepleted => IsDead;`
	`18`	`+ private bool _recalculateRenderBounds;`
	`19`	`+ private bool _waitingForTilesets;`
`20`	`20`
`21`		`- public bool IsDead { get; set; }`
	`21`	`+ private bool _isDead;`
	`22`	`+ private ResourceBase? _descriptor;`
`22`	`23`
`23`		`- FloatRect mDestRectangle = FloatRect.Empty;`
	`24`	`+ public Resource(Guid id, ResourceEntityPacket packet) : base(id, packet, EntityType.Resource)`
	`25`	`+ {`
	`26`	`+ mRenderPriority = 0;`
	`27`	`+ }`
`24`	`28`
`25`		`- private bool mHasRenderBounds;`
	`29`	`+ public ResourceBase? Descriptor`
	`30`	`+ {`
	`31`	`+ get => _descriptor;`
	`32`	`+ set => _descriptor = value;`
	`33`	`+ }`
`26`	`34`
`27`		`- FloatRect mSrcRectangle = FloatRect.Empty;`
	`35`	`+ public bool IsDepleted => IsDead;`
`28`	`36`
`29`		`- public Resource(Guid id, ResourceEntityPacket packet) : base(id, packet, EntityType.Resource)`
	`37`	`+ public bool IsDead`
`30`	`38`	`{`
`31`		`- mRenderPriority = 0;`
	`39`	`+ get => _isDead;`
	`40`	`+ set`
	`41`	`+ {`
	`42`	`+ if (value == _isDead)`
	`43`	`+ {`
	`44`	`+ return;`
	`45`	`+ }`
	`46`	`+`
	`47`	`+ _isDead = value;`
	`48`	`+ _recalculateRenderBounds = true;`
	`49`	`+ }`
`32`	`50`	`}`
`33`	`51`
`34`	`52`	`public override string Sprite`
`35`	`53`	`{`
`36`		`- get => mMySprite;`
	`54`	`+ get => _sprite;`
`37`	`55`	`set`
`38`	`56`	`{`
`39`		`- if (value == mMySprite)`
	`57`	`+ if (value == _sprite)`
`40`	`58`	`{`
`41`	`59`	`return;`
`42`	`60`	`}`
`43`	`61`
`44`		`- if (BaseResource == null)`
	`62`	`+ if (Descriptor == null)`
`45`	`63`	`{`
`46`	`64`	`return;`
`47`	`65`	`}`
`48`	`66`
`49`		`- mMySprite = value;`
	`67`	`+ _sprite = value;`
`50`	`68`	`ReloadSpriteTexture();`
`51`	`69`	`}`
`52`	`70`	`}`
`53`	`71`
`54`	`72`	`private void ReloadSpriteTexture()`
`55`	`73`	`{`
`56`		`- if (BaseResource == null)`
	`74`	`+ if (Descriptor == null)`
`57`	`75`	`{`
`58`	`76`	`return;`
`59`	`77`	`}`
`60`	`78`
`61`		`- if (IsDead && BaseResource.Exhausted.GraphicFromTileset \|\|`
`62`		`- !IsDead && BaseResource.Initial.GraphicFromTileset)`
	`79`	`+ if (IsDead && Descriptor.Exhausted.GraphicFromTileset \|\|`
	`80`	`+ !IsDead && Descriptor.Initial.GraphicFromTileset)`
`63`	`81`	`{`
`64`	`82`	`if (GameContentManager.Current.TilesetsLoaded)`
`65`	`83`	`{`
`66`		`- Texture = Globals.ContentManager.GetTexture(Framework.Content.TextureType.Tileset, mMySprite);`
	`84`	`+ Texture = Globals.ContentManager.GetTexture(Framework.Content.TextureType.Tileset, _sprite);`
`67`	`85`	`}`
`68`	`86`	`else`
`69`	`87`	`{`
`@@ -72,40 +90,43 @@ private void ReloadSpriteTexture()`
`72`	`90`	`}`
`73`	`91`	`else`
`74`	`92`	`{`
`75`		`- Texture = Globals.ContentManager.GetTexture(Framework.Content.TextureType.Resource, mMySprite);`
	`93`	`+ Texture = Globals.ContentManager.GetTexture(Framework.Content.TextureType.Resource, _sprite);`
`76`	`94`	`}`
`77`	`95`
`78`		`- mHasRenderBounds = false;`
	`96`	`+ _recalculateRenderBounds = true;`
`79`	`97`	`}`
`80`	`98`
`81`	`99`	`public override void Load(EntityPacket? packet)`
`82`	`100`	`{`
`83`	`101`	`base.Load(packet);`
`84`		`- var pkt = packet as ResourceEntityPacket;`
`85`	`102`
`86`		`- if (pkt == default)`
	`103`	`+ _recalculateRenderBounds = true;`
	`104`	`+`
	`105`	`+ if (packet is not ResourceEntityPacket resourceEntityPacket)`
`87`	`106`	`{`
`88`	`107`	`return;`
`89`	`108`	`}`
`90`	`109`
`91`		`- IsDead = pkt.IsDead;`
`92`		`- var baseId = pkt.ResourceId;`
`93`		`- BaseResource = ResourceBase.Get(baseId);`
	`110`	`+ IsDead = resourceEntityPacket.IsDead;`
`94`	`111`
`95`		`- if (BaseResource == default)`
	`112`	`+ if (!ResourceBase.TryGet(resourceEntityPacket.ResourceId, out _descriptor))`
`96`	`113`	`{`
`97`	`114`	`return;`
`98`	`115`	`}`
`99`	`116`
`100`		`- HideName = true;`
`101`		`- if (IsDead)`
`102`		`- {`
`103`		`- Sprite = BaseResource.Exhausted.Graphic;`
`104`		`- }`
`105`		`- else`
	`117`	`+ UpdateFromDescriptor(_descriptor);`
	`118`	`+ }`
	`119`	`+`
	`120`	`+ private void UpdateFromDescriptor(ResourceBase? descriptor)`
	`121`	`+ {`
	`122`	`+ if (descriptor == null)`
`106`	`123`	`{`
`107`		`- Sprite = BaseResource.Initial.Graphic;`
	`124`	`+ return;`
`108`	`125`	`}`
	`126`	`+`
	`127`	`+ var updatedSprite = IsDead ? descriptor.Exhausted.Graphic : descriptor.Initial.Graphic;`
	`128`	`+ _sprite = updatedSprite;`
	`129`	`+ ReloadSpriteTexture();`
`109`	`130`	`}`
`110`	`131`
`111`	`132`	`public override void Dispose()`
`@@ -130,6 +151,12 @@ public override bool Update()`
`130`	`151`	`return false;`
`131`	`152`	`}`
`132`	`153`
	`154`	`+ if (Descriptor is { IsDeleted: true } deletedDescriptor)`
	`155`	`+ {`
	`156`	`+ _ = ResourceBase.TryGet(deletedDescriptor.Id, out _descriptor);`
	`157`	`+ UpdateFromDescriptor(_descriptor);`
	`158`	`+ }`
	`159`	`+`
`133`	`160`	`if (!Maps.MapInstance.TryGet(MapId, out var map) \|\| !map.InView())`
`134`	`161`	`{`
`135`	`162`	`LatestMap = map;`
`@@ -138,12 +165,12 @@ public override bool Update()`
`138`	`165`	`return false;`
`139`	`166`	`}`
`140`	`167`
`141`		`- if (!mHasRenderBounds)`
	`168`	`+ if (_recalculateRenderBounds)`
`142`	`169`	`{`
`143`	`170`	`CalculateRenderBounds();`
`144`	`171`	`}`
`145`	`172`
`146`		`- if (!Graphics.WorldViewport.IntersectsWith(mDestRectangle))`
	`173`	`+ if (!Graphics.WorldViewport.IntersectsWith(_renderBoundsDest))`
`147`	`174`	`{`
`148`	`175`	`if (RenderList != null)`
`149`	`176`	`{`
`@@ -170,9 +197,9 @@ public override bool Update()`
`170`	`197`
`171`	`198`	`public override HashSet<Entity>? DetermineRenderOrder(HashSet<Entity>? renderList, IMapInstance? map)`
`172`	`199`	`{`
`173`		`- if (BaseResource == default \|\|`
`174`		`- (IsDead && !BaseResource.Exhausted.RenderBelowEntities) \|\|`
`175`		`- (!IsDead && !BaseResource.Initial.RenderBelowEntities)`
	`200`	`+ if (Descriptor == default \|\|`
	`201`	`+ (IsDead && !Descriptor.Exhausted.RenderBelowEntities) \|\|`
	`202`	`+ (!IsDead && !Descriptor.Initial.RenderBelowEntities)`
`176`	`203`	`)`
`177`	`204`	`{`
`178`	`205`	`return base.DetermineRenderOrder(renderList, map);`
`@@ -249,7 +276,7 @@ public override bool Update()`
`249`	`276`
`250`	`277`	`private void CalculateRenderBounds()`
`251`	`278`	`{`
`252`		`- if (BaseResource == default)`
	`279`	`+ if (Descriptor == default)`
`253`	`280`	`{`
`254`	`281`	`return;`
`255`	`282`	`}`
`@@ -278,43 +305,43 @@ private void CalculateRenderBounds()`
`278`	`305`	`return;`
`279`	`306`	`}`
`280`	`307`
`281`		`- mSrcRectangle.X = 0;`
`282`		`- mSrcRectangle.Y = 0;`
`283`		`- if (IsDead && BaseResource.Exhausted.GraphicFromTileset)`
	`308`	`+ _renderBoundsSrc.X = 0;`
	`309`	`+ _renderBoundsSrc.Y = 0;`
	`310`	`+ if (IsDead && Descriptor.Exhausted.GraphicFromTileset)`
`284`	`311`	`{`
`285`		`- mSrcRectangle.X = BaseResource.Exhausted.X * Options.TileWidth;`
`286`		`- mSrcRectangle.Y = BaseResource.Exhausted.Y * Options.TileHeight;`
`287`		`- mSrcRectangle.Width = (BaseResource.Exhausted.Width + 1) * Options.TileWidth;`
`288`		`- mSrcRectangle.Height = (BaseResource.Exhausted.Height + 1) * Options.TileHeight;`
	`312`	`+ _renderBoundsSrc.X = Descriptor.Exhausted.X * Options.TileWidth;`
	`313`	`+ _renderBoundsSrc.Y = Descriptor.Exhausted.Y * Options.TileHeight;`
	`314`	`+ _renderBoundsSrc.Width = (Descriptor.Exhausted.Width + 1) * Options.TileWidth;`
	`315`	`+ _renderBoundsSrc.Height = (Descriptor.Exhausted.Height + 1) * Options.TileHeight;`
`289`	`316`	`}`
`290`		`- else if (!IsDead && BaseResource.Initial.GraphicFromTileset)`
	`317`	`+ else if (!IsDead && Descriptor.Initial.GraphicFromTileset)`
`291`	`318`	`{`
`292`		`- mSrcRectangle.X = BaseResource.Initial.X * Options.TileWidth;`
`293`		`- mSrcRectangle.Y = BaseResource.Initial.Y * Options.TileHeight;`
`294`		`- mSrcRectangle.Width = (BaseResource.Initial.Width + 1) * Options.TileWidth;`
`295`		`- mSrcRectangle.Height = (BaseResource.Initial.Height + 1) * Options.TileHeight;`
	`319`	`+ _renderBoundsSrc.X = Descriptor.Initial.X * Options.TileWidth;`
	`320`	`+ _renderBoundsSrc.Y = Descriptor.Initial.Y * Options.TileHeight;`
	`321`	`+ _renderBoundsSrc.Width = (Descriptor.Initial.Width + 1) * Options.TileWidth;`
	`322`	`+ _renderBoundsSrc.Height = (Descriptor.Initial.Height + 1) * Options.TileHeight;`
`296`	`323`	`}`
`297`	`324`	`else`
`298`	`325`	`{`
`299`		`- mSrcRectangle.Width = Texture.Width;`
`300`		`- mSrcRectangle.Height = Texture.Height;`
	`326`	`+ _renderBoundsSrc.Width = Texture.Width;`
	`327`	`+ _renderBoundsSrc.Height = Texture.Height;`
`301`	`328`	`}`
`302`	`329`
`303`		`- mDestRectangle.Width = mSrcRectangle.Width;`
`304`		`- mDestRectangle.Height = mSrcRectangle.Height;`
`305`		`- mDestRectangle.Y = (int) (map.Y + Y * Options.TileHeight + OffsetY);`
`306`		`- mDestRectangle.X = (int) (map.X + X * Options.TileWidth + OffsetX);`
`307`		`- if (mSrcRectangle.Height > Options.TileHeight)`
	`330`	`+ _renderBoundsDest.Width = _renderBoundsSrc.Width;`
	`331`	`+ _renderBoundsDest.Height = _renderBoundsSrc.Height;`
	`332`	`+ _renderBoundsDest.Y = (int) (map.Y + Y * Options.TileHeight + OffsetY);`
	`333`	`+ _renderBoundsDest.X = (int) (map.X + X * Options.TileWidth + OffsetX);`
	`334`	`+ if (_renderBoundsSrc.Height > Options.TileHeight)`
`308`	`335`	`{`
`309`		`- mDestRectangle.Y -= mSrcRectangle.Height - Options.TileHeight;`
	`336`	`+ _renderBoundsDest.Y -= _renderBoundsSrc.Height - Options.TileHeight;`
`310`	`337`	`}`
`311`	`338`
`312`		`- if (mSrcRectangle.Width > Options.TileWidth)`
	`339`	`+ if (_renderBoundsSrc.Width > Options.TileWidth)`
`313`	`340`	`{`
`314`		`- mDestRectangle.X -= (mSrcRectangle.Width - Options.TileWidth) / 2;`
	`341`	`+ _renderBoundsDest.X -= (_renderBoundsSrc.Width - Options.TileWidth) / 2;`
`315`	`342`	`}`
`316`	`343`
`317`		`- mHasRenderBounds = true;`
	`344`	`+ _recalculateRenderBounds = false;`
`318`	`345`	`}`
`319`	`346`
`320`	`347`	`//Rendering Resources`
`@@ -327,7 +354,7 @@ public override void Draw()`
`327`	`354`
`328`	`355`	`if (Texture != null)`
`329`	`356`	`{`
`330`		`- Graphics.DrawGameTexture(Texture, mSrcRectangle, mDestRectangle, Intersect.Color.White);`
	`357`	`+ Graphics.DrawGameTexture(Texture, _renderBoundsSrc, _renderBoundsDest, Intersect.Color.White);`
`331`	`358`	`}`
`332`	`359`	`}`
`333`	`360`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ namespace Intersect.Client.Framework.Entities;`
`4`	`4`
`5`	`5`	`public interface IResource : IEntity`
`6`	`6`	`{`
`7`		`- ResourceBase? BaseResource { get; }`
	`7`	`+ ResourceBase? Descriptor { get; }`
`8`	`8`
`9`	`9`	`bool IsDepleted { get; }`
`10`	`10`	`}`