Misc: smaller enhancements

Arcidev · Arcidev · commit d2e444c3b443 · 2019-02-01T22:34:13.000+01:00
diff --git a/Client/Client.csproj b/Client/Client.csproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+﻿<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
@@ -28,7 +28,7 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
-    <LangVersion>7.3</LangVersion>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>
diff --git a/Client/Game/ClientGame.cs b/Client/Game/ClientGame.cs
@@ -229,11 +229,11 @@ public bool SetPossibleSpellTargets()
 
         public PlayableCard GetCardByImageControlName(string imageControlName)
         {
-            var cardPair = Player.GetCardByImageControlName(imageControlName);
-            if (cardPair.Item1 != null)
-                return cardPair.Item1;
+            var (card, image) = Player.GetCardByImageControlName(imageControlName);
+            if (card != null)
+                return card;
 
-            return Opponent.GetCardByImageControlName(imageControlName).Item1;
+            return Opponent.GetCardByImageControlName(imageControlName).card;
         }
 
         private async Task UpdateAsync()
diff --git a/Client/Game/Player.cs b/Client/Game/Player.cs
@@ -11,7 +11,7 @@ namespace Client.Game
     public class Player
     {
         private readonly ClientGame game;
-        private readonly ValueTuple<PlayableCard, Image>[] cardDeck;
+        private readonly (PlayableCard card, Image image)[] cardDeck;
         private Dictionary<UInt64, PlayableCard> cards;
 
         public UInt32 Id { get; set; }
@@ -22,9 +22,9 @@ public class Player
 
         public int ActiveCardPosition { get; private set; }
 
-        public PlayableCard ActiveCard => cardDeck[ActiveCardPosition].Item1;
+        public PlayableCard ActiveCard => cardDeck[ActiveCardPosition].card;
 
-        public IEnumerable<PlayableCard> CardDeck => cardDeck.Select(x => x.Item1);
+        public IEnumerable<PlayableCard> CardDeck => cardDeck.Select(x => x.card);
 
         public Player(ClientGame clientGame, params Image[] imageLocations)
         {
@@ -55,8 +55,8 @@ public void PutCardsOnDeck(UInt64[] cardGuids)
                 {
                     Invoke(() =>
                     {
-                        cardDeck[i].Item1 = card;
-                        cardDeck[i].Item2.Source = card.Image;
+                        cardDeck[i].card = card;
+                        cardDeck[i].image.Source = card.Image;
                     });
                 }
             }
@@ -66,8 +66,8 @@ public void PutCardsOnDeck(UInt64[] cardGuids)
             {
                 Invoke(() =>
                 {
-                    cardDeck[i].Item1 = null;
-                    cardDeck[i].Item2.Source = new BitmapImage(new Uri(i < availableCardsCount ? "Assets/CardBack.png" : "Assets/CardBackGrayscale.png", UriKind.Relative));
+                    cardDeck[i].card = null;
+                    cardDeck[i].image.Source = new BitmapImage(new Uri(i < availableCardsCount ? "Assets/CardBack.png" : "Assets/CardBackGrayscale.png", UriKind.Relative));
                 });
             }
         }
@@ -85,22 +85,22 @@ public void SetPossibleTargets(IEnumerable<UInt64> targetableCards)
         public void DeselectSpellFriendlyTargets()
         {
             var activeCardDeck = cardDeck[ActiveCardPosition];
-            if (activeCardDeck.Item1.SelectionType != SelectionType.Selected)
+            if (activeCardDeck.card.SelectionType != SelectionType.Selected)
             {
                 Invoke(() =>
                 {
-                    activeCardDeck.Item1.SelectionType = SelectionType.Selected;
-                    activeCardDeck.Item2.Source = activeCardDeck.Item1.Image;
+                    activeCardDeck.card.SelectionType = SelectionType.Selected;
+                    activeCardDeck.image.Source = activeCardDeck.card.Image;
                 });
 
-                foreach(var card in cardDeck.Where(x => x.Item1 != null))
+                foreach(var card in cardDeck.Where(x => x.card != null))
                 {
-                    if (card.Item1.SelectionType == SelectionType.SpellUsable)
+                    if (card.card.SelectionType == SelectionType.SpellUsable)
                     {
                         Invoke(() =>
                         {
-                            card.Item1.SelectionType = SelectionType.None;
-                            card.Item2.Source = card.Item1.Image;
+                            card.card.SelectionType = SelectionType.None;
+                            card.image.Source = card.card.Image;
                         });
                     }
                 }
@@ -110,25 +110,25 @@ public void DeselectSpellFriendlyTargets()
         // Remove selection
         public void RemoveSelectionFromCards()
         {
-            foreach (var card in cardDeck.Where(x => x.Item1 != null && x.Item1.SelectionType != SelectionType.None))
+            foreach (var card in cardDeck.Where(x => x.card != null && x.card.SelectionType != SelectionType.None))
             {
                 Invoke(() =>
                 {
-                    card.Item1.SelectionType = SelectionType.None;
-                    card.Item2.Source = card.Item1.Image;
+                    card.card.SelectionType = SelectionType.None;
+                    card.image.Source = card.card.Image;
                 });
             }
         }
 
         // Selects possible targets
         public void SelectPossibleTargets(IEnumerable<UInt64> targetableCards, SelectionType selection)
         {
-            foreach (var card in cardDeck.Where(x => x.Item1 != null && targetableCards.Contains(x.Item1.Guid)))
+            foreach (var card in cardDeck.Where(x => x.card != null && targetableCards.Contains(x.card.Guid)))
             {
                 Invoke(() =>
                 {
-                    card.Item1.SelectionType = selection;
-                    card.Item2.Source = card.Item1.Image;
+                    card.card.SelectionType = selection;
+                    card.image.Source = card.card.Image;
                 });
             }
         }
@@ -139,23 +139,23 @@ public void SetActiveState(UInt64 cardGuid)
             IsActive = true;
             for(var i = 0; i < cardDeck.Length; i++)
             {
-                var c = cardDeck[i];
-                if (c.Item1 == null)
+                var (card, image) = cardDeck[i];
+                if (card == null)
                     continue;
 
                 var select = SelectionType.None;
-                if (c.Item1.Guid == cardGuid)
+                if (card.Guid == cardGuid)
                 {
                     ActiveCardPosition = i;
                     select = SelectionType.Selected;
                 }
 
-                if (c.Item1.SelectionType != select)
+                if (card.SelectionType != select)
                 {
                     Invoke(() =>
                     {
-                        c.Item1.SelectionType = select;
-                        c.Item2.Source = c.Item1.Image;
+                        card.SelectionType = select;
+                        image.Source = card.Image;
                     });
                 }
             }
@@ -169,27 +169,27 @@ public void SetWaitingState()
         }
 
         // Gets card by control name
-        public (PlayableCard, Image) GetCardByImageControlName(string name)
+        public (PlayableCard card, Image image) GetCardByImageControlName(string name)
         {
-            return cardDeck.FirstOrDefault(x => x.Item2.Name == name);
+            return cardDeck.FirstOrDefault(x => x.image.Name == name);
         }
 
         // Attacks card
         public void AttackCard(UInt64 guid, byte damage, CombatLogTypes combatLogType, bool isPeriodicDamage)
         {
-            var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == guid);
-            if (cardPair.Item1 == null)
+            var (card, image) = cardDeck.FirstOrDefault(x => x.card?.Guid == guid);
+            if (card == null)
                 return;
 
             if (isPeriodicDamage)
-                game.Chat.LogPeriodicDamage(cardPair.Item1, damage, true);
+                game.Chat.LogPeriodicDamage(card, damage, true);
             else
-                game.Chat.LogDamage(combatLogType, game.GetOpponent(Id).ActiveCard, cardPair.Item1, damage, true);
+                game.Chat.LogDamage(combatLogType, game.GetOpponent(Id).ActiveCard, card, damage, true);
             
             Invoke(() =>
             {
-                cardPair.Item1.Hp -= damage;
-                cardPair.Item2.Source = cardPair.Item1.Image;
+                card.Hp -= damage;
+                image.Source = card.Image;
             });
         }
 
@@ -210,15 +210,15 @@ public void DestroyCard(UInt64 guid, byte damage, CombatLogTypes combatLogType,
         // Modifies card stat
         public void ModifyCardStat(UInt64 cardGuid, CardStats cardStat, sbyte value)
         {
-            var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == cardGuid);
-            if (cardPair.Item1 == null)
+            var (card, image) = cardDeck.FirstOrDefault(x => x.card?.Guid == cardGuid);
+            if (card == null)
                 return;
 
-            game.Chat.LogStatChange(cardStat, cardPair.Item1, value);
+            game.Chat.LogStatChange(cardStat, card, value);
             Invoke(() =>
             {
-                cardPair.Item1.ApplyModifier(cardStat, value);
-                cardPair.Item2.Source = cardPair.Item1.Image;
+                card.ApplyModifier(cardStat, value);
+                image.Source = card.Image;
             });
         }
 
@@ -231,27 +231,27 @@ public bool CanCastSpell()
         // Adds aura to creature
         public void ApplyAura(UInt64 cardGuid, UInt32 spellId)
         {
-            var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == cardGuid);
-            if (cardPair.Item1 == null)
+            var (card, image) = cardDeck.FirstOrDefault(x => x.card?.Guid == cardGuid);
+            if (card == null)
                 return;
 
             var spellData = DataHolder.GetSpellData(spellId);
-            game.Chat.LogApplyAura(cardPair.Item1, spellData);
+            game.Chat.LogApplyAura(card, spellData);
 
             /// TODO: add some graphics effect
         }
 
         // Removes aura from creature
         public void ExpireAuras(UInt64 cardGuid, UInt32[] spellIds)
         {
-            var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == cardGuid);
-            if (cardPair.Item1 == null)
+            var (card, image) = cardDeck.FirstOrDefault(x => x.card?.Guid == cardGuid);
+            if (card == null)
                 return;
 
             foreach(var spellId in spellIds)
             {
                 var spellData = DataHolder.GetSpellData(spellId);
-                game.Chat.LogExpireAura(cardPair.Item1, spellData);
+                game.Chat.LogExpireAura(card, spellData);
 
                 /// TODO: add some graphics effect
             }
@@ -260,36 +260,36 @@ public void ExpireAuras(UInt64 cardGuid, UInt32[] spellIds)
         // Heals card
         public void HealCard(UInt64 cardGuid, byte health, byte amount)
         {
-            var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == cardGuid);
-            if (cardPair.Item1 == null)
+            var (card, image) = cardDeck.FirstOrDefault(x => x.card?.Guid == cardGuid);
+            if (card == null)
                 return;
 
-            game.Chat.LogHeal(cardPair.Item1, amount);
+            game.Chat.LogHeal(card, amount);
             Invoke(() =>
             {
-                cardPair.Item1.Hp = health;
-                cardPair.Item2.Source = cardPair.Item1.Image;
+                card.Hp = health;
+                image.Source = card.Image;
             });
         }
 
         // Consumes mana from card and logs it into comba log
         public void HandleSuccessfulSpellCast(UInt64 cardGuid, UInt32 spellId, byte mana, byte manaCost)
         {
-            var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == cardGuid);
-            if (cardPair.Item1 == null)
+            var cardPair = cardDeck.FirstOrDefault(x => x.card?.Guid == cardGuid);
+            if (cardPair.card == null)
                 return;
 
             var spellData = DataHolder.GetSpellData(spellId);
-            game.Chat.LogManaConsume(cardPair.Item1, spellData, manaCost);
+            game.Chat.LogManaConsume(cardPair.card, spellData, manaCost);
 
             SetCardMana(cardPair, mana);
         }
 
         // Sets cards mana
         public void SetCardMana(UInt64 cardGuid, byte mana)
         {
-            var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == cardGuid);
-            if (cardPair.Item1 == null)
+            var cardPair = cardDeck.FirstOrDefault(x => x.card?.Guid == cardGuid);
+            if (cardPair.card == null)
                 return;
 
             SetCardMana(cardPair, mana);
@@ -298,33 +298,33 @@ public void SetCardMana(UInt64 cardGuid, byte mana)
         // Morphs card
         public void MorphCard(UInt64 cardGuid, Card cardTemplate, byte mana, bool isMorph)
         {
-            var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == cardGuid);
-            if (cardPair.Item1 == null)
+            var (card, image) = cardDeck.FirstOrDefault(x => x.card?.Guid == cardGuid);
+            if (card == null)
                 return;
 
-            game.Chat.LogMorph(cardPair.Item1, cardTemplate, isMorph);
+            game.Chat.LogMorph(card, cardTemplate, isMorph);
             Invoke(() =>
             {
-                cardPair.Item1.UnloadImages();
-                cardPair.Item1.Id = cardTemplate.Id;
-                cardPair.Item1.ImageUri = cardTemplate.ImageUri;
-                cardPair.Item1.Type = cardTemplate.Type;
-                cardPair.Item1.Spell = cardTemplate.Spell;
-                cardPair.Item1.Name = cardTemplate.Name;
-                cardPair.Item1.Damage = cardTemplate.Damage;
-                cardPair.Item1.Defense = cardTemplate.Defense;
-                cardPair.Item1.Mana = mana;
-                cardPair.Item2.Source = cardPair.Item1.Image;
+                card.UnloadImages();
+                card.Id = cardTemplate.Id;
+                card.ImageUri = cardTemplate.ImageUri;
+                card.Type = cardTemplate.Type;
+                card.Spell = cardTemplate.Spell;
+                card.Name = cardTemplate.Name;
+                card.Damage = cardTemplate.Damage;
+                card.Defense = cardTemplate.Defense;
+                card.Mana = mana;
+                image.Source = card.Image;
             });
         }
 
         // Sets card mana
-        private void SetCardMana((PlayableCard, Image) cardPair, byte mana)
+        private void SetCardMana((PlayableCard card, Image image) cardPair, byte mana)
         {
             Invoke(() =>
             {
-                cardPair.Item1.Mana = mana;
-                cardPair.Item2.Source = cardPair.Item1.Image;
+                cardPair.card.Mana = mana;
+                cardPair.image.Source = cardPair.card.Image;
             });
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -229,11 +229,11 @@ public bool SetPossibleSpellTargets()`
`229`	`229`
`230`	`230`	`public PlayableCard GetCardByImageControlName(string imageControlName)`
`231`	`231`	`{`
`232`		`- var cardPair = Player.GetCardByImageControlName(imageControlName);`
`233`		`- if (cardPair.Item1 != null)`
`234`		`- return cardPair.Item1;`
	`232`	`+ var (card, image) = Player.GetCardByImageControlName(imageControlName);`
	`233`	`+ if (card != null)`
	`234`	`+ return card;`
`235`	`235`
`236`		`- return Opponent.GetCardByImageControlName(imageControlName).Item1;`
	`236`	`+ return Opponent.GetCardByImageControlName(imageControlName).card;`
`237`	`237`	`}`
`238`	`238`
`239`	`239`	`private async Task UpdateAsync()`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ namespace Client.Game`
`11`	`11`	`public class Player`
`12`	`12`	`{`
`13`	`13`	`private readonly ClientGame game;`
`14`		`- private readonly ValueTuple<PlayableCard, Image>[] cardDeck;`
	`14`	`+ private readonly (PlayableCard card, Image image)[] cardDeck;`
`15`	`15`	`private Dictionary<UInt64, PlayableCard> cards;`
`16`	`16`
`17`	`17`	`public UInt32 Id { get; set; }`
`@@ -22,9 +22,9 @@ public class Player`
`22`	`22`
`23`	`23`	`public int ActiveCardPosition { get; private set; }`
`24`	`24`
`25`		`- public PlayableCard ActiveCard => cardDeck[ActiveCardPosition].Item1;`
	`25`	`+ public PlayableCard ActiveCard => cardDeck[ActiveCardPosition].card;`
`26`	`26`
`27`		`- public IEnumerable<PlayableCard> CardDeck => cardDeck.Select(x => x.Item1);`
	`27`	`+ public IEnumerable<PlayableCard> CardDeck => cardDeck.Select(x => x.card);`
`28`	`28`
`29`	`29`	`public Player(ClientGame clientGame, params Image[] imageLocations)`
`30`	`30`	`{`
`@@ -55,8 +55,8 @@ public void PutCardsOnDeck(UInt64[] cardGuids)`
`55`	`55`	`{`
`56`	`56`	`Invoke(() =>`
`57`	`57`	`{`
`58`		`- cardDeck[i].Item1 = card;`
`59`		`- cardDeck[i].Item2.Source = card.Image;`
	`58`	`+ cardDeck[i].card = card;`
	`59`	`+ cardDeck[i].image.Source = card.Image;`
`60`	`60`	`});`
`61`	`61`	`}`
`62`	`62`	`}`
`@@ -66,8 +66,8 @@ public void PutCardsOnDeck(UInt64[] cardGuids)`
`66`	`66`	`{`
`67`	`67`	`Invoke(() =>`
`68`	`68`	`{`
`69`		`- cardDeck[i].Item1 = null;`
`70`		`- cardDeck[i].Item2.Source = new BitmapImage(new Uri(i < availableCardsCount ? "Assets/CardBack.png" : "Assets/CardBackGrayscale.png", UriKind.Relative));`
	`69`	`+ cardDeck[i].card = null;`
	`70`	`+ cardDeck[i].image.Source = new BitmapImage(new Uri(i < availableCardsCount ? "Assets/CardBack.png" : "Assets/CardBackGrayscale.png", UriKind.Relative));`
`71`	`71`	`});`
`72`	`72`	`}`
`73`	`73`	`}`
`@@ -85,22 +85,22 @@ public void SetPossibleTargets(IEnumerable<UInt64> targetableCards)`
`85`	`85`	`public void DeselectSpellFriendlyTargets()`
`86`	`86`	`{`
`87`	`87`	`var activeCardDeck = cardDeck[ActiveCardPosition];`
`88`		`- if (activeCardDeck.Item1.SelectionType != SelectionType.Selected)`
	`88`	`+ if (activeCardDeck.card.SelectionType != SelectionType.Selected)`
`89`	`89`	`{`
`90`	`90`	`Invoke(() =>`
`91`	`91`	`{`
`92`		`- activeCardDeck.Item1.SelectionType = SelectionType.Selected;`
`93`		`- activeCardDeck.Item2.Source = activeCardDeck.Item1.Image;`
	`92`	`+ activeCardDeck.card.SelectionType = SelectionType.Selected;`
	`93`	`+ activeCardDeck.image.Source = activeCardDeck.card.Image;`
`94`	`94`	`});`
`95`	`95`
`96`		`- foreach(var card in cardDeck.Where(x => x.Item1 != null))`
	`96`	`+ foreach(var card in cardDeck.Where(x => x.card != null))`
`97`	`97`	`{`
`98`		`- if (card.Item1.SelectionType == SelectionType.SpellUsable)`
	`98`	`+ if (card.card.SelectionType == SelectionType.SpellUsable)`
`99`	`99`	`{`
`100`	`100`	`Invoke(() =>`
`101`	`101`	`{`
`102`		`- card.Item1.SelectionType = SelectionType.None;`
`103`		`- card.Item2.Source = card.Item1.Image;`
	`102`	`+ card.card.SelectionType = SelectionType.None;`
	`103`	`+ card.image.Source = card.card.Image;`
`104`	`104`	`});`
`105`	`105`	`}`
`106`	`106`	`}`
`@@ -110,25 +110,25 @@ public void DeselectSpellFriendlyTargets()`
`110`	`110`	`// Remove selection`
`111`	`111`	`public void RemoveSelectionFromCards()`
`112`	`112`	`{`
`113`		`- foreach (var card in cardDeck.Where(x => x.Item1 != null && x.Item1.SelectionType != SelectionType.None))`
	`113`	`+ foreach (var card in cardDeck.Where(x => x.card != null && x.card.SelectionType != SelectionType.None))`
`114`	`114`	`{`
`115`	`115`	`Invoke(() =>`
`116`	`116`	`{`
`117`		`- card.Item1.SelectionType = SelectionType.None;`
`118`		`- card.Item2.Source = card.Item1.Image;`
	`117`	`+ card.card.SelectionType = SelectionType.None;`
	`118`	`+ card.image.Source = card.card.Image;`
`119`	`119`	`});`
`120`	`120`	`}`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`// Selects possible targets`
`124`	`124`	`public void SelectPossibleTargets(IEnumerable<UInt64> targetableCards, SelectionType selection)`
`125`	`125`	`{`
`126`		`- foreach (var card in cardDeck.Where(x => x.Item1 != null && targetableCards.Contains(x.Item1.Guid)))`
	`126`	`+ foreach (var card in cardDeck.Where(x => x.card != null && targetableCards.Contains(x.card.Guid)))`
`127`	`127`	`{`
`128`	`128`	`Invoke(() =>`
`129`	`129`	`{`
`130`		`- card.Item1.SelectionType = selection;`
`131`		`- card.Item2.Source = card.Item1.Image;`
	`130`	`+ card.card.SelectionType = selection;`
	`131`	`+ card.image.Source = card.card.Image;`
`132`	`132`	`});`
`133`	`133`	`}`
`134`	`134`	`}`
`@@ -139,23 +139,23 @@ public void SetActiveState(UInt64 cardGuid)`
`139`	`139`	`IsActive = true;`
`140`	`140`	`for(var i = 0; i < cardDeck.Length; i++)`
`141`	`141`	`{`
`142`		`- var c = cardDeck[i];`
`143`		`- if (c.Item1 == null)`
	`142`	`+ var (card, image) = cardDeck[i];`
	`143`	`+ if (card == null)`
`144`	`144`	`continue;`
`145`	`145`
`146`	`146`	`var select = SelectionType.None;`
`147`		`- if (c.Item1.Guid == cardGuid)`
	`147`	`+ if (card.Guid == cardGuid)`
`148`	`148`	`{`
`149`	`149`	`ActiveCardPosition = i;`
`150`	`150`	`select = SelectionType.Selected;`
`151`	`151`	`}`
`152`	`152`
`153`		`- if (c.Item1.SelectionType != select)`
	`153`	`+ if (card.SelectionType != select)`
`154`	`154`	`{`
`155`	`155`	`Invoke(() =>`
`156`	`156`	`{`
`157`		`- c.Item1.SelectionType = select;`
`158`		`- c.Item2.Source = c.Item1.Image;`
	`157`	`+ card.SelectionType = select;`
	`158`	`+ image.Source = card.Image;`
`159`	`159`	`});`
`160`	`160`	`}`
`161`	`161`	`}`
`@@ -169,27 +169,27 @@ public void SetWaitingState()`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`// Gets card by control name`
`172`		`- public (PlayableCard, Image) GetCardByImageControlName(string name)`
	`172`	`+ public (PlayableCard card, Image image) GetCardByImageControlName(string name)`
`173`	`173`	`{`
`174`		`- return cardDeck.FirstOrDefault(x => x.Item2.Name == name);`
	`174`	`+ return cardDeck.FirstOrDefault(x => x.image.Name == name);`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`// Attacks card`
`178`	`178`	`public void AttackCard(UInt64 guid, byte damage, CombatLogTypes combatLogType, bool isPeriodicDamage)`
`179`	`179`	`{`
`180`		`- var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == guid);`
`181`		`- if (cardPair.Item1 == null)`
	`180`	`+ var (card, image) = cardDeck.FirstOrDefault(x => x.card?.Guid == guid);`
	`181`	`+ if (card == null)`
`182`	`182`	`return;`
`183`	`183`
`184`	`184`	`if (isPeriodicDamage)`
`185`		`- game.Chat.LogPeriodicDamage(cardPair.Item1, damage, true);`
	`185`	`+ game.Chat.LogPeriodicDamage(card, damage, true);`
`186`	`186`	`else`
`187`		`- game.Chat.LogDamage(combatLogType, game.GetOpponent(Id).ActiveCard, cardPair.Item1, damage, true);`
	`187`	`+ game.Chat.LogDamage(combatLogType, game.GetOpponent(Id).ActiveCard, card, damage, true);`
`188`	`188`
`189`	`189`	`Invoke(() =>`
`190`	`190`	`{`
`191`		`- cardPair.Item1.Hp -= damage;`
`192`		`- cardPair.Item2.Source = cardPair.Item1.Image;`
	`191`	`+ card.Hp -= damage;`
	`192`	`+ image.Source = card.Image;`
`193`	`193`	`});`
`194`	`194`	`}`
`195`	`195`
`@@ -210,15 +210,15 @@ public void DestroyCard(UInt64 guid, byte damage, CombatLogTypes combatLogType,`
`210`	`210`	`// Modifies card stat`
`211`	`211`	`public void ModifyCardStat(UInt64 cardGuid, CardStats cardStat, sbyte value)`
`212`	`212`	`{`
`213`		`- var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == cardGuid);`
`214`		`- if (cardPair.Item1 == null)`
	`213`	`+ var (card, image) = cardDeck.FirstOrDefault(x => x.card?.Guid == cardGuid);`
	`214`	`+ if (card == null)`
`215`	`215`	`return;`
`216`	`216`
`217`		`- game.Chat.LogStatChange(cardStat, cardPair.Item1, value);`
	`217`	`+ game.Chat.LogStatChange(cardStat, card, value);`
`218`	`218`	`Invoke(() =>`
`219`	`219`	`{`
`220`		`- cardPair.Item1.ApplyModifier(cardStat, value);`
`221`		`- cardPair.Item2.Source = cardPair.Item1.Image;`
	`220`	`+ card.ApplyModifier(cardStat, value);`
	`221`	`+ image.Source = card.Image;`
`222`	`222`	`});`
`223`	`223`	`}`
`224`	`224`
`@@ -231,27 +231,27 @@ public bool CanCastSpell()`
`231`	`231`	`// Adds aura to creature`
`232`	`232`	`public void ApplyAura(UInt64 cardGuid, UInt32 spellId)`
`233`	`233`	`{`
`234`		`- var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == cardGuid);`
`235`		`- if (cardPair.Item1 == null)`
	`234`	`+ var (card, image) = cardDeck.FirstOrDefault(x => x.card?.Guid == cardGuid);`
	`235`	`+ if (card == null)`
`236`	`236`	`return;`
`237`	`237`
`238`	`238`	`var spellData = DataHolder.GetSpellData(spellId);`
`239`		`- game.Chat.LogApplyAura(cardPair.Item1, spellData);`
	`239`	`+ game.Chat.LogApplyAura(card, spellData);`
`240`	`240`
`241`	`241`	`/// TODO: add some graphics effect`
`242`	`242`	`}`
`243`	`243`
`244`	`244`	`// Removes aura from creature`
`245`	`245`	`public void ExpireAuras(UInt64 cardGuid, UInt32[] spellIds)`
`246`	`246`	`{`
`247`		`- var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == cardGuid);`
`248`		`- if (cardPair.Item1 == null)`
	`247`	`+ var (card, image) = cardDeck.FirstOrDefault(x => x.card?.Guid == cardGuid);`
	`248`	`+ if (card == null)`
`249`	`249`	`return;`
`250`	`250`
`251`	`251`	`foreach(var spellId in spellIds)`
`252`	`252`	`{`
`253`	`253`	`var spellData = DataHolder.GetSpellData(spellId);`
`254`		`- game.Chat.LogExpireAura(cardPair.Item1, spellData);`
	`254`	`+ game.Chat.LogExpireAura(card, spellData);`
`255`	`255`
`256`	`256`	`/// TODO: add some graphics effect`
`257`	`257`	`}`
`@@ -260,36 +260,36 @@ public void ExpireAuras(UInt64 cardGuid, UInt32[] spellIds)`
`260`	`260`	`// Heals card`
`261`	`261`	`public void HealCard(UInt64 cardGuid, byte health, byte amount)`
`262`	`262`	`{`
`263`		`- var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == cardGuid);`
`264`		`- if (cardPair.Item1 == null)`
	`263`	`+ var (card, image) = cardDeck.FirstOrDefault(x => x.card?.Guid == cardGuid);`
	`264`	`+ if (card == null)`
`265`	`265`	`return;`
`266`	`266`
`267`		`- game.Chat.LogHeal(cardPair.Item1, amount);`
	`267`	`+ game.Chat.LogHeal(card, amount);`
`268`	`268`	`Invoke(() =>`
`269`	`269`	`{`
`270`		`- cardPair.Item1.Hp = health;`
`271`		`- cardPair.Item2.Source = cardPair.Item1.Image;`
	`270`	`+ card.Hp = health;`
	`271`	`+ image.Source = card.Image;`
`272`	`272`	`});`
`273`	`273`	`}`
`274`	`274`
`275`	`275`	`// Consumes mana from card and logs it into comba log`
`276`	`276`	`public void HandleSuccessfulSpellCast(UInt64 cardGuid, UInt32 spellId, byte mana, byte manaCost)`
`277`	`277`	`{`
`278`		`- var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == cardGuid);`
`279`		`- if (cardPair.Item1 == null)`
	`278`	`+ var cardPair = cardDeck.FirstOrDefault(x => x.card?.Guid == cardGuid);`
	`279`	`+ if (cardPair.card == null)`
`280`	`280`	`return;`
`281`	`281`
`282`	`282`	`var spellData = DataHolder.GetSpellData(spellId);`
`283`		`- game.Chat.LogManaConsume(cardPair.Item1, spellData, manaCost);`
	`283`	`+ game.Chat.LogManaConsume(cardPair.card, spellData, manaCost);`
`284`	`284`
`285`	`285`	`SetCardMana(cardPair, mana);`
`286`	`286`	`}`
`287`	`287`
`288`	`288`	`// Sets cards mana`
`289`	`289`	`public void SetCardMana(UInt64 cardGuid, byte mana)`
`290`	`290`	`{`
`291`		`- var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == cardGuid);`
`292`		`- if (cardPair.Item1 == null)`
	`291`	`+ var cardPair = cardDeck.FirstOrDefault(x => x.card?.Guid == cardGuid);`
	`292`	`+ if (cardPair.card == null)`
`293`	`293`	`return;`
`294`	`294`
`295`	`295`	`SetCardMana(cardPair, mana);`
`@@ -298,33 +298,33 @@ public void SetCardMana(UInt64 cardGuid, byte mana)`
`298`	`298`	`// Morphs card`
`299`	`299`	`public void MorphCard(UInt64 cardGuid, Card cardTemplate, byte mana, bool isMorph)`
`300`	`300`	`{`
`301`		`- var cardPair = cardDeck.FirstOrDefault(x => x.Item1?.Guid == cardGuid);`
`302`		`- if (cardPair.Item1 == null)`
	`301`	`+ var (card, image) = cardDeck.FirstOrDefault(x => x.card?.Guid == cardGuid);`
	`302`	`+ if (card == null)`
`303`	`303`	`return;`
`304`	`304`
`305`		`- game.Chat.LogMorph(cardPair.Item1, cardTemplate, isMorph);`
	`305`	`+ game.Chat.LogMorph(card, cardTemplate, isMorph);`
`306`	`306`	`Invoke(() =>`
`307`	`307`	`{`
`308`		`- cardPair.Item1.UnloadImages();`
`309`		`- cardPair.Item1.Id = cardTemplate.Id;`
`310`		`- cardPair.Item1.ImageUri = cardTemplate.ImageUri;`
`311`		`- cardPair.Item1.Type = cardTemplate.Type;`
`312`		`- cardPair.Item1.Spell = cardTemplate.Spell;`
`313`		`- cardPair.Item1.Name = cardTemplate.Name;`
`314`		`- cardPair.Item1.Damage = cardTemplate.Damage;`
`315`		`- cardPair.Item1.Defense = cardTemplate.Defense;`
`316`		`- cardPair.Item1.Mana = mana;`
`317`		`- cardPair.Item2.Source = cardPair.Item1.Image;`
	`308`	`+ card.UnloadImages();`
	`309`	`+ card.Id = cardTemplate.Id;`
	`310`	`+ card.ImageUri = cardTemplate.ImageUri;`
	`311`	`+ card.Type = cardTemplate.Type;`
	`312`	`+ card.Spell = cardTemplate.Spell;`
	`313`	`+ card.Name = cardTemplate.Name;`
	`314`	`+ card.Damage = cardTemplate.Damage;`
	`315`	`+ card.Defense = cardTemplate.Defense;`
	`316`	`+ card.Mana = mana;`
	`317`	`+ image.Source = card.Image;`
`318`	`318`	`});`
`319`	`319`	`}`
`320`	`320`
`321`	`321`	`// Sets card mana`
`322`		`- private void SetCardMana((PlayableCard, Image) cardPair, byte mana)`
	`322`	`+ private void SetCardMana((PlayableCard card, Image image) cardPair, byte mana)`
`323`	`323`	`{`
`324`	`324`	`Invoke(() =>`
`325`	`325`	`{`
`326`		`- cardPair.Item1.Mana = mana;`
`327`		`- cardPair.Item2.Source = cardPair.Item1.Image;`
	`326`	`+ cardPair.card.Mana = mana;`
	`327`	`+ cardPair.image.Source = cardPair.card.Image;`
`328`	`328`	`});`
`329`	`329`	`}`
`330`	`330`	`}`