protected GameScene gs;//游戏场景总管理
#region 构造函数
/// <summary>
/// 卡片构造函数
/// </summary>
public Card()
{
Init();
this.cardName = "";
this.cardType = CardType.Character;//默认为角色卡
this.cardRarity = CardRarity.Normal;
}
protected int usedTimes;//装备可使用次数，0为无限使用
#region 构造函数
public Weapon(int cardId, string cardName, CardRarity cardRarity, int attackUpValue, int usedTimes, string cardDescription = "")
: base(cardId, cardName, cardRarity, cardDescription)
{
this.attackUpValue = attackUpValue;
this.usedTimes = usedTimes;
// this.equipmentState = new WeaponAttackUp(attackUpValue, usedTimes);
}
public AbstractCard(string _cardId, string _name, string _imgURL, int _cost, string _rawDescription, CardType _cardType, CardRarity _cardRarity, CardTarget _cardTarget, DamageType _damageType)
{
ChargeCost = -1;
IsCostModified = false;
IsCostModifiedForTurn = false;
IsRetain = false;
IsNotTriggerOnUse = false;
IsInnate = false;
IsLocked = false;
IsShowEvokeValue = false;
ShowEvokeOrbCount = 0;
KeyWords = new List <string>();
IsSelected = false;
IsExhaust = false;
IsEthereal = false;
IsUsed = false;
IsUpgraded = false;
TimesUpgraded = 0;
Misc = 0;
IsSeen = true;
IsUpgradeCost = false;
IsUpgradeDamage = false;
IsUpgradeBlock = false;
IsUpgradeMagicNumber = false;
IsMultiDamage = false;
BaseDamage = -1;
BaseBlock = -1;
BaseMagicNumber = -1;
BaseHeal = -1;
BaseDraw = -1;
BaseDiscard = -1;
Damage = -1;
Block = -1;
MagicNumber = -1;
Heal = -1;
Draw = -1;
Discard = -1;
IsDamageModified = false;
IsBlockModified = false;
IsMagicNumberModified = false;
Target = CardTarget.Enemy;
IsPurgeOnUse = false;
IsExhaustOnUseOnce = false;
IsExhaustOnFire = false;
IsFreeToPlayOnce = false;
IsInBottleFlame = false;
IsInBottleLightning = false;
IsInBottleTornado = false;
Name = _name;
CardID = _cardId;
Cost = _cost;
CostForTurn = _cost;
RawDescription = _rawDescription;
Type = _cardType;
Rarity = _cardRarity;
Target = _cardTarget;
CardDamageType = _damageType;
DamageTypeForTurn = _damageType;
CreateCardImage();
}
private Card RandomCard(CardRarity rarity)
{
int count = _cardsByRarity[rarity].Count;
int index = (int)System.Math.Floor(Random.value * count);
return(_cardsByRarity[rarity][index]);
}
public void SetFillColorByRarity(CardRarity rarity)
{
Color fillColor = Color.white;
switch (rarity)
{
case CardRarity.BASIC:
fillColor = Color.yellow;
break;
case CardRarity.COMMON:
fillColor = Color.green;
break;
case CardRarity.RARE:
fillColor = Color.blue;
break;
case CardRarity.EPIC:
fillColor = Color.red;
break;
case CardRarity.LEGENDARY:
fillColor = Color.magenta;
break;
default:
fillColor = Color.black;
break;
}
fillImage.color = fillColor;
}
public List <CardData> FiltterCardsData(List <CardData> cDat, bool showCardPlayerDontOwn = false, Dictionary <string, int> quantityOfCardsUserHaveFromBDOnline = null,
CardRarity rarity = CardRarity.NONE, bool isChainable = false, bool isDarkCard = false, int darkPoints = -1,
CARDTYPE cardType = CARDTYPE.NONE, ACTIVATIONTYPE activationType = ACTIVATIONTYPE.NONE, string keyword = "")
{
if (quantityOfCardsUserHaveFromBDOnline != null && showCardPlayerDontOwn == false)
{
cDat = FiltterCardDataWithCardsUserDontOwn(quantityOfCardsUserHaveFromBDOnline, cDat);
}
cDat = FiltterCardDataByRarity(rarity, cDat);
cDat = FiltterCardDataByType(cardType, cDat);
cDat = FiltterCardDataByActivationType(activationType, cDat);
if (isChainable)
{
cDat = FiltterCardDataOnlyChainable(cDat);
}
if (isDarkCard || darkPoints > -1)
{
cDat = FiltterCardDataOnlyDark(cDat);
}
if (darkPoints > -1)
{
cDat = FiltterCardDataByDarkPointAmount(cDat, darkPoints);
}
cDat = FiltterCardDataByKeyword(cDat, keyword);
var orderList = cDat.OrderBy(c => c.ID);
List <CardData> cda = orderList.ToList();
return(cda);
}
public async Task <IActionResult> Edit(int id, [Bind("CardRarityID,CardRarityName,LastUpdateDate")] CardRarity cardRarity)
{
if (id != cardRarity.CardRarityID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(cardRarity);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CardRarityExists(cardRarity.CardRarityID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(cardRarity));
}
private async Task <GameObject> CardFromPack(CardRarity rarity, Transform cardParent)
{
CardCollectionSearchFiltter cardCollectionSearchFiltter = new CardCollectionSearchFiltter();
List <CardData> cDat = gameMenuManager.GetAllCardDataArray().ToList();
List <CardData> CardsDataOfThisRarity = cardCollectionSearchFiltter.GetCardsDataWithCardRarity(cDat, rarity);
if (CardsDataOfThisRarity.Count == 0)
{
//Debug.Log("NOT FOUND OF RARITY " + rarity);
cDat = gameMenuManager.GetAllCardDataArray().ToList();
CardsDataOfThisRarity = cardCollectionSearchFiltter.GetCardsDataWithCardRarity(cDat, CardRarity.COMMON);
rarity = CardRarity.COMMON;
}
else
{
//Debug.Log("FOUND OF RARITY " + rarity);
}
CardData cardDataAux = CardsDataOfThisRarity[Random.Range(0, CardsDataOfThisRarity.Count)];
gameMenuManager.AddCardToGameCollectionDictionary(cardDataAux);
bool isLoaded = await gameMenuManager.AddNewCardToUserCollection(cardDataAux);
GameObject card = Instantiate(cardPrefab, cardParent);
card.transform.rotation = Quaternion.Euler(0f, 0f, 0f);
card.GetComponentInChildren <SimpleCardFromPackUINEW>().SetSimpleCardFromPackUI(GlowColorsByRarity[rarity], this);
MikzeerGame.CardDisplay cardDisplay = card.GetComponent <MikzeerGame.CardDisplay>();
cardDisplay.SetDisplay(cardDataAux);
return(card);
}
/// <summary>
/// Generates a random card from a specific rarity, or any non-starter card if left empty
/// </summary>
/// <param name="targetRarity">the rarity of cards you want to generate</param>
/// <param name="filterRarity">set to true to generate only from specified rarity</param>
/// <returns></returns>
public GameObject GenerateCard(CardRarity targetRarity = CardRarity.Debuff, bool filterRarity = false)
{
int rand;
//temp list to hold cards
List <GameObject> temp = new List <GameObject>();
for (int i = 0; i < cards.Length; i++)
{
if (filterRarity)
{
//you can't reference a member variable without an instance, so we're instantiating a copy
GameObject card = Instantiate(cards[i], new Vector3(200, 200, 200), Quaternion.identity);
if (card.GetComponent <CardDisplay>().card.cardRarity == targetRarity)
{
temp.Add(cards[i]);
}
Destroy(card);
}
else
{
if (cards[i].GetComponent <CardDisplay>().card.cardRarity != CardRarity.Starter)
{
temp.Add(cards[i]);
}
}
}
rand = Random.Range(0, temp.Count);
//Debug.Log(temp.Count);
return(temp[rand]);
}
public static void Parse(this CardRarity rarity, string rarityString, out CardRarity returnRarity)
{
const string mythicRarity = "mythic";
const string rareRarity = "rare";
const string uncommonRarity = "uncommon";
const string commonRarity = "common";
if (rarityString.Contains(mythicRarity))
{
returnRarity = CardRarity.Mythic;
}
else if (rarityString.Contains(rareRarity))
{
returnRarity = CardRarity.Rare;
}
else if (rarityString.Contains(uncommonRarity))
{
returnRarity = CardRarity.Uncommon;
}
else if (rarityString.Contains(commonRarity))
{
returnRarity = CardRarity.Common;
}
else
{
returnRarity = CardRarity.Undef;
}
}
public CardDrawedViewSample()
{
int baseId = 123;
Clan clan = Clan.GetClanById(ClanId.Raptors);
string cardName = "Tester";
Skill ability = new Skill(SkillPrefix.Courage, SkillSuffix.DecreasePillzXMinY, 2, 3);
int minLevel = 2;
int maxLevel = 4;
List <CardLevel> cardLevels = new List <CardLevel>
{
new CardLevel(2, 2, 3),
new CardLevel(3, 3, 4),
new CardLevel(4, 6, 5),
};
int abilityUnlockLevel = 3;
CardRarity rarity = CardRarity.Legendary;
int currentLevel = 4;
int instanceId = 222;
CardBase cardBase = new CardBase(baseId, cardName, clan, minLevel, maxLevel, cardLevels, ability, abilityUnlockLevel, rarity);
CardInstance cardInstance = new CardInstance(cardBase, instanceId, currentLevel);
card = new CardDrawed(cardInstance);
}
public void SetMaxAmountAndRarity(int maxAmount, CardRarity rarity)
{
SetFillColorByRarity(rarity);
txtMaxAmount.text = maxAmount.ToString();
this.maxAmount = maxAmount;
UpdateFillImage();
}
public int GerCardAmountByRarity(CardRarity pRarity)
{
if (amountPerRarity.ContainsKey(pRarity))
{
return(amountPerRarity[pRarity]);
}
return(0);
}
public Card(int cardId, string cardName, int cardRarity)
: this()
{
this.cardID = cardId;
this.cardName = cardName;
this.cardRarity = (CardRarity)cardRarity;
this.cardDescription = CardDescriptions.Instance.GetCardDescription(cardName);
}
public Card(string name, ClassType cardClass, CardRarity rarity, string text, int cost, CardType type)
{
CardClass = cardClass;
Rarity = rarity;
Text = text;
Cost = cost;
Name = name;
Type = type;
}
public void AddRarity(CardRarity rarity, DeckStatusRarityAmountSlot statusSlot, int maxAmount)
{
if (amountPerRarity.ContainsKey(rarity) == false)
{
amountPerRarity.Add(rarity, statusSlot);
amountPerRarity[rarity].SetMaxAmountAndRarity(maxAmount, rarity);
statusSlot.UpdateActualAmount(0);
}
}
public static void SetCardDataLimits(CardDataLimit pcDataLimit)
{
maxAmountOfCardsPerDeck = pcDataLimit.MaxAmountPerDeck;
for (int i = 0; i < pcDataLimit.MaxAmountPerRarity.cardDataLimitRarityAmount.Count; i++)
{
CardRarity rarity = GetCardRarityTypeFromInt(pcDataLimit.MaxAmountPerRarity.cardDataLimitRarityAmount[i].ID);
maxAmountPerRarityDictionary.Add(rarity, pcDataLimit.MaxAmountPerRarity.cardDataLimitRarityAmount[i].Amount);
}
}
private CollectionCardItem CreateCollectionCardItem(int id, int qty, CardRarity rarity)
{
return(new CollectionCardItem
{
Id = id,
Quantity = qty,
Rarity = rarity
});
}
public async Task <IActionResult> Create([Bind("CardRarityID,CardRarityName,LastUpdateDate")] CardRarity cardRarity)
{
if (ModelState.IsValid)
{
_context.Add(cardRarity);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(cardRarity));
}
private AbstractCard DraftCard(CardRarity rarity)
{
List <AbstractCard> filteredList = CardLibrary.Instance.Lookup(GameState.mainChar).Where(card => card.RARITY == rarity).ToList();
AbstractCard draft = filteredList[UnityEngine.Random.Range(0, filteredList.Count)];
int rng = UnityEngine.Random.Range(0, 100);
if (rng < 20) // 20% chance to upgrade a drafted card
{
draft.Upgrade();
}
return(draft);
}
public Card(CardRarity cardRarity, string cardName, int cardHP, int cardDMG, int cardCost, string cardDesc, string cardEffect, int?cardOverload)
{
this.CardRarity = cardRarity;
this.CardName = cardName;
this.CardHP = cardHP;
this.CardDMG = cardDMG;
this.CardCost = cardCost;
this.CardOverload = cardOverload;
this.CardDesc = cardDesc;
this.CardEffect = cardEffect;
this.CardTextz = new CardText(cardEffect, cardDesc);
Extent.Add(this);
}
public async void ShowPackOpening(Vector3 cardsInitialPosition)
{
// Allow To Drag Another Pack Only After DoneButton Is pressed
// 1) Determine rarity of all cards
CardRarity[] rarities = new CardRarity[SlotsForCards.Length];
bool AtLeastOneRareGiven = false;
for (int i = 0; i < rarities.Length; i++)
{
// determine rarity of this card
float prob = Random.Range(0f, 1f);
if (prob < LegendaryProbability)
{
rarities[i] = CardRarity.LEGENDARY;
AtLeastOneRareGiven = true;
}
else if (prob < EpicProbability)
{
rarities[i] = CardRarity.EPIC;
AtLeastOneRareGiven = true;
}
else if (prob < RareProbability)
{
rarities[i] = CardRarity.RARE;
AtLeastOneRareGiven = true;
}
else
{
rarities[i] = CardRarity.COMMON;
}
}
if (AtLeastOneRareGiven == false && giveAtLeastOneRare)
{
rarities[Random.Range(0, rarities.Length)] = CardRarity.RARE;
}
for (int i = 0; i < rarities.Length; i++)
{
GameObject card = await CardFromPack(rarities[i], SlotsForCards[i]);
//card.GetComponentInChildren<SimpleCardFromPackUINEW>().SetSimpleCardFromPackUI(GlowColorsByRarity[rarities[i]], this);
CardsFromPackCreated.Add(card);
card.transform.localPosition = cardsInitialPosition;
card.transform.DOLocalMove(SlotsForCards[i].position, 0.5f);
}
gameMenuManager.LoadUserCollectionFromFirebase();
}
public Card(
string name,
string cardType,
string expansion,
CardRarity rarity,
string artist,
string imageLocation)
{
Name = name;
CardType = cardType;
Expansion = expansion;
Rarity = rarity;
Artist = artist;
ImageLocation = imageLocation;
}
public AbstractCard(string inp_ID, CardRarity crarity, CardType ctype, CardTarget ctarget, int ccost, string cdescription)
{
ID = inp_ID;
card_rarity = crarity;
card_target = ctarget;
card_type = ctype;
card_cost = ccost;
card_description = cdescription;
card_tags = "";
if (cardutilities.CardIDUtilities.IsValidCardID(this))
{
card_name = ID.Split(':')[1];
}
}
public static CardRarity GetCardRarityTypeFromInt(int pIDRarity)
{
//var myEnumMemberCount = Enum.GetNames(typeof(MyEnum)).Length;
//YourEnum foo = (YourEnum)yourInt;
int rarTypeTotalCount = Enum.GetNames(typeof(CardRarity)).Length;
if (pIDRarity >= rarTypeTotalCount)
{
return(CardRarity.NONE);
}
CardRarity rarType = (CardRarity)pIDRarity;
return(rarType);
}
public MagicCard(int id, string cardName, string cardSet, bool premium, decimal buyPrice, decimal sellPrice, CardRarity rarity, int mtgoId, int ownedAmount, int cardSetNumber, int copiesOfCard, int botId, int botGroupId)
{
Id = id;
Name = cardName;
Set = cardSet;
Premium = premium;
BuyPrice = buyPrice;
SellPrice = sellPrice;
Rarity = rarity;
MtgoId = mtgoId;
OwnedAmount = ownedAmount;
CardSetNumber = cardSetNumber;
CopiesOfCard = copiesOfCard;
BotId = botId;
BotGroupId = botGroupId;
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
CardRarity rarity = (CardRarity)value;
string type = (string)parameter;
switch (type)
{
case "Brush":
return(Brushes[rarity]);
case "Background":
return(Backgrounds[rarity]);
default:
throw new ArgumentException(nameof(parameter) + " must be either Brush or Background");
}
}
public Card(int cardId, string cardName, CardType cardType, CardRarity cardRarity, string cardDescription = "")
{
Init();
this.cardID = cardId;
this.cardName = cardName;
this.cardType = cardType;
this.cardRarity = cardRarity;
if (cardDescription != "")
{
this.cardDescription = cardDescription;
}
else
{
this.cardDescription = CardDescriptions.Instance.GetCardDescription(cardName);
}
}
private Color GetColorForCard(CardRarity rarity)
{
switch (rarity)
{
case CardRarity.Common:
return(new Color(0xd1d1d1));
case CardRarity.Rare:
return(new Color(0x2b7dff));
case CardRarity.SR:
return(new Color(0xff7fff));
case CardRarity.SSR:
return(new Color(0xffe92b));
}
return(new Color(0x000000));
}
private uint GetPriceForCard(CardRarity rarity)
{
switch (rarity)
{
case CardRarity.Common:
return(Config.Configuration.CommonCardPrice);
case CardRarity.Rare:
return(Config.Configuration.RareCardPrice);
case CardRarity.SR:
return(Config.Configuration.SRCardPrice);
case CardRarity.SSR:
return(Config.Configuration.SSRCardPrice);
}
return(0);
}
public List <CardData> FiltterCardDataByRarity(CardRarity rarity, List <CardData> cards)
{
if (rarity == CardRarity.NONE)
{
return(cards);
}
List <CardData> returnC = new List <CardData>();
for (int i = 0; i < cards.Count; i++)
{
if (cards[i].CardRarity == rarity)
{
returnC.Add(cards[i]);
}
}
return(returnC);
}
//--------------------Берем рандомную карту по типу и редкости
public ICard GetRandomCardByType(SubTypeCard type, CardRarity rarity)
{
var flag = false;
ICard value = null;
var dictCards = GetDictionaryCards(type);
while (!flag)
{
var index = RandomExtensions.Random(dictCards.Count);
var card = dictCards.Values.ElementAt(index);
if (card.GetDataCard().Rarity != rarity)
{
continue;
}
value = card;
flag = true;
}
return(value);
}
public bool suppressEventCalls = false; // should only be true when a card invokes NegotiationManager.Instance.SelectCardsFromList
public AbstractCard(string id, Dictionary <string, string> cardStrings, int cost, CardAmbient ambience, CardRarity rarity, CardType type, List <CardTags> tags = null)
{
this.ID = id;
this.NAME = cardStrings["NAME"];
this.DESC = cardStrings["DESC"];
this.IMAGE = (this.ID == "DECKARD_DIPLOMACY") ? "Images/CardsDeckard/theace" : "Images/missing";
this.COST = cost;
this.AMBIENCE = ambience;
this.RARITY = rarity;
this.TYPE = type;
if (tags != null)
{
foreach (CardTags tag in tags)
{
this.TAGS.Add(tag);
}
}
this.DRAFT_CHARACTER = this.ID.Split('_')[0]; // Automatically derive the drafting char from the card ID since all card IDs follow the schemata CHARACTER_CARDNAME
}
public static string GetCardRarityNames(CardRarity rarity)
{
switch(rarity)
{
case CardRarity.Normal:
return "普通";
case CardRarity.Excellent:
return "精良";
case CardRarity.Scarce:
return "稀有";
case CardRarity.Rare:
return "罕见";
case CardRarity.Legend:
return "传说";
case CardRarity.Epic:
return "史诗";
default:
return "未知";
}
}
public static CardRarity ToPercent(this CardRarity cardRarity, double rarity)
{
if (rarity >= 0.6)
{
return(CardRarity.Common);
}
else if (rarity >= 0.15)
{
return(CardRarity.Rare);
}
else if (rarity >= 0.01)
{
return(CardRarity.SR);
}
else
{
return(CardRarity.SSR);
}
throw new Exception("No such rarity");
}
public AbstractCard(string id, string cardName, int cost, CardRarity rarity, List <CardType> type, string imageName, string cardText, string cardFlavor = "")
{
this.ID = id;
this.NAME = cardName;
this.COST = cost;
this.RARITY = rarity;
this.TYPE = type;
this.IMAGE = Resources.Load <Sprite>((string)"Images/Card Art/" + imageName);
this.TEXT = cardText;
this.FLAVOR = cardFlavor;
switch (this.TYPE[0])
{
case CardType.ATTACK:
this.TARGETING = CardTarget.ENEMIES_ONLY;
break;
default:
this.TARGETING = CardTarget.NON_TARGETED;
break;
}
}
public MagicCard(UInt32 mId,
String name,
ManaCost cost,
List<CardType> types,
List<String> subtypes,
List<String> text,
List<String> flavour,
String mark,
String pow,
String tough,
String expansion,
CardRarity rarity,
Dictionary<String, UInt32> sets,
Int16 num,
String artist,
Double rating,
List<Ruling> rulings,
String artUrl)
{
MultiverseId = mId;
Name = name;
Cost = cost;
Types = types;
SubTypes = subtypes;
Text = text;
FlavorText = flavour;
Watermark = mark;
Power = pow;
Toughness = tough;
Expansion = expansion;
Rarity = rarity;
Printings = sets;
Artist = artist;
CommunityRating = rating;
CardNumber = num;
Rulings = rulings;
CardArtUrl = artUrl;
}
protected StateSkill equipmentState;//装备拥有的状态
#region 构造函数
public EquipmentCard(int cardId, string cardName, CardRarity cardRarity, string cardDescription = "")
: base(cardId, cardName, cardRarity, cardDescription)
{ }
/// <summary>
/// Gets the rarity.
/// </summary>
/// <param name="Rarity">The rarity.</param>
/// <returns></returns>
public static string GetRarity(CardRarity Rarity)
{
switch (Rarity)
{
case CardRarity.COMMON:
return "common";
case CardRarity.UNCOMMON:
return "uncommon";
case CardRarity.RARE:
return "rare";
case CardRarity.MYTHIC:
return "mythic rare";
case CardRarity.SPECIAL:
return "special";
default:
return "unknown";
}
}
public Jewelry(int cardId, string cardName, CardRarity cardRarity, string cardDescription = "")
: base(cardId, cardName, cardRarity, cardDescription)
{
//创建BUFF
}
protected Dictionary<StateSkill, Card> cardState;//卡片状态列表 - <状态内容,状态来源>
#region 构造函数
public CharacterCard(int cardId, string cardName, CardRarity cardRarity, string cardDescription = "")
: base(cardId, cardName, CardType.Character, cardRarity, cardDescription)
{
this.cardState = new Dictionary<StateSkill, Card>();
}
/// <summary>
/// Gets the rarity.
/// </summary>
/// <param name="Rarity">The rarity.</param>
/// <returns></returns>
public static char GetShortRarity(CardRarity Rarity)
{
switch (Rarity)
{
case CardRarity.COMMON:
return 'C';
case CardRarity.UNCOMMON:
return 'U';
case CardRarity.RARE:
return 'R';
case CardRarity.MYTHIC:
return 'M';
case CardRarity.SPECIAL:
return 'S';
default:
return 'X';
}
}
private void SetBuyPriceForList(double quantityPerTicket, CardRarity rarity)
{
var cards = AllCardsInSystem.Where(p => p.Rarity == rarity);
var price = 1/quantityPerTicket;
foreach (var magicCard in cards)
{
magicCard.BuyPrice = (decimal)price;
}
}
public MagicCard GetCard(string name, string set, CardRarity [] rarities)
{
var sets = FilterSet(set.ToUpper()).ToList();
_logger.TraceFormat("Getting card {0}, from sets [{1}]", name, sets.JoinToString());
var card = AllCardsInSystem.FirstOrDefault(p => !p.Premium && sets.Contains(p.Set) && p.Name == name);
return NewCard(card ?? GetCardViaSuggestion(name, sets, rarities));
}
/// <summary>
/// 设置卡片信息
/// </summary>
public virtual void SetCardInfo(CardInfo info)
{
this.cardUUID = info.cardUUID;
this.cardID = info.cardId;
this.cardName = info.cardName;
this.cardRarity =(CardRarity)info.cardRarity;
}
public ItemCard(int cardId, string cardName, CardRarity cardRarity, string cardDescription = "")
: base(cardId, cardName, CardType.Item, cardRarity, cardDescription)
{ }
public MagicCard(string cardName, string cardSet, bool premium, CardRarity rarity)
: this(0, cardName, cardSet, premium, 0, 0, rarity, 0, 0, 0, 0, 0, 0)
{
}
