public bool IsInitializing()
{
foreach (TAG_CARDTYPE tag_cardtype in this.ACTOR_CARD_TYPES)
{
IEnumerator enumerator = Enum.GetValues(typeof(TAG_PREMIUM)).GetEnumerator();
try
{
while (enumerator.MoveNext())
{
TAG_PREMIUM current = (TAG_PREMIUM)((int)enumerator.Current);
ActorKey key = this.MakeActorKey(tag_cardtype, current);
if (!this.m_actorMap.ContainsKey(key))
{
return(true);
}
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable == null)
{
}
disposable.Dispose();
}
}
return(false);
}
public static string GetHistoryActor(Entity entity)
{
if (entity.IsSecret() && entity.IsHidden())
{
return(GetHistorySecretActor(entity));
}
if (ShouldObfuscate(entity))
{
return("History_Obfuscated");
}
TAG_CARDTYPE cardType = entity.GetCardType();
TAG_PREMIUM premiumType = entity.GetPremiumType();
TAG_CARDTYPE tag_cardtype2 = cardType;
if (tag_cardtype2 == TAG_CARDTYPE.HERO)
{
return("History_Hero");
}
if (tag_cardtype2 != TAG_CARDTYPE.HERO_POWER)
{
return(GetHandActor(entity));
}
if (entity.GetController().IsFriendlySide())
{
return(GetNameWithPremiumType("History_HeroPower", premiumType));
}
return(GetNameWithPremiumType("History_HeroPower_Opponent", premiumType));
}
public void Initialize()
{
foreach (TAG_CARDTYPE tag_cardtype in this.ACTOR_CARD_TYPES)
{
IEnumerator enumerator = Enum.GetValues(typeof(TAG_PREMIUM)).GetEnumerator();
try
{
while (enumerator.MoveNext())
{
TAG_PREMIUM current = (TAG_PREMIUM)((int)enumerator.Current);
string heroSkinOrHandActor = ActorNames.GetHeroSkinOrHandActor(tag_cardtype, current);
ActorKey callbackData = this.MakeActorKey(tag_cardtype, current);
AssetLoader.Get().LoadActor(heroSkinOrHandActor, new AssetLoader.GameObjectCallback(this.OnActorLoaded), callbackData, false);
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable == null)
{
}
disposable.Dispose();
}
}
}
public void Initialize()
{
foreach (TAG_CARDTYPE tag_cardtype in this.ACTOR_CARD_TYPES)
{
IEnumerator enumerator = Enum.GetValues(typeof(TAG_PREMIUM)).GetEnumerator();
try
{
while (enumerator.MoveNext())
{
TAG_PREMIUM current = (TAG_PREMIUM)((int)enumerator.Current);
ActorKey key = this.MakeActorKey(tag_cardtype, current, true);
this.m_actorMap.Add(key, new List <Actor>());
ActorKey key2 = this.MakeActorKey(tag_cardtype, current, false);
this.m_actorMap.Add(key2, new List <Actor>());
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable == null)
{
}
disposable.Dispose();
}
}
if (this.PRELOAD_ACTORS != null)
{
this.Preload(TAG_CARDTYPE.MINION, TAG_PREMIUM.NORMAL, true, 1);
this.Preload(TAG_CARDTYPE.SPELL, TAG_PREMIUM.NORMAL, true, 1);
this.Preload(TAG_CARDTYPE.WEAPON, TAG_PREMIUM.NORMAL, true, 1);
}
}
public CollectionFilterSet(bool mustPassAllFilters)
{
IEnumerator enumerator = Enum.GetValues(typeof(TAG_PREMIUM)).GetEnumerator();
try
{
while (enumerator.MoveNext())
{
TAG_PREMIUM current = (TAG_PREMIUM)((int)enumerator.Current);
if (!ApplicationMgr.IsInternal() || !this.ShouldSkipPremiumType(current))
{
CollectionArtFilterSet item = new CollectionArtFilterSet(new CardFlair(current), mustPassAllFilters);
this.m_artFilterSets.Add(item);
}
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable == null)
{
}
disposable.Dispose();
}
}
public CardRewardData(string cardID, TAG_PREMIUM premium, int count) : base(Reward.Type.CARD)
{
this.CardID = cardID;
this.Count = count;
this.Premium = premium;
this.InnKeeperLine = InnKeeperTrigger.NONE;
}
public static string GetHeroSkinOrHandActor(TAG_CARDTYPE type, TAG_PREMIUM premium)
{
if (type == TAG_CARDTYPE.HERO)
{
return("Card_Hero_Skin");
}
return(GetHandActor(type, premium));
}
public static string GetNameWithPremiumType(string actorName, TAG_PREMIUM premiumType)
{
if (premiumType == TAG_PREMIUM.GOLDEN)
{
return(string.Format("{0}_Premium", actorName));
}
return(actorName);
}
public virtual SpellType DetermineSummonOutSpell_HandToPlay(Card card)
{
Entity entity = card.GetEntity();
if (!entity.GetController().IsFriendlySide())
{
return(SpellType.SUMMON_OUT);
}
int cost = entity.GetEntityDef().GetCost();
TAG_PREMIUM premiumType = entity.GetPremiumType();
if (cost < 7)
{
if (cost < 4)
{
switch (premiumType)
{
case TAG_PREMIUM.NORMAL:
goto Label_00C4;
case TAG_PREMIUM.GOLDEN:
return(SpellType.SUMMON_OUT_PREMIUM);
}
Debug.LogWarning(string.Format("CardDef.DetermineSummonOutSpell_HandToPlay(): unexpected premium type {0}", premiumType));
goto Label_00C4;
}
switch (premiumType)
{
case TAG_PREMIUM.NORMAL:
goto Label_008D;
case TAG_PREMIUM.GOLDEN:
return(SpellType.SUMMON_OUT_PREMIUM);
}
Debug.LogWarning(string.Format("CardDef.DetermineSummonOutSpell_HandToPlay(): unexpected premium type {0}", premiumType));
}
else
{
switch (premiumType)
{
case TAG_PREMIUM.NORMAL:
break;
case TAG_PREMIUM.GOLDEN:
return(SpellType.SUMMON_OUT_PREMIUM);
default:
Debug.LogWarning(string.Format("CardDef.DetermineSummonOutSpell_HandToPlay(): unexpected premium type {0}", premiumType));
break;
}
return(SpellType.SUMMON_OUT_LARGE);
}
Label_008D:
return(SpellType.SUMMON_OUT_MEDIUM);
Label_00C4:
return(SpellType.SUMMON_OUT);
}
public void AddCards(int count, int sellAmount, TAG_PREMIUM premiumType)
{
this.m_numCards += count;
if (this.m_premiumType != premiumType)
{
this.m_numGoldCards += count;
}
this.m_amount += sellAmount;
}
public int GetNumOwnedCopies(string cardID, TAG_PREMIUM premium, bool includePending)
{
int numCopiesInCollection = CollectionManager.Get().GetNumCopiesInCollection(cardID, premium);
if (includePending)
{
return(numCopiesInCollection + this.m_transactions);
}
return(numCopiesInCollection);
}
public bool CanAddOwnedCard(string cardID, TAG_PREMIUM premium)
{
int standard = 0;
int golden = 0;
CollectionManager.Get().GetOwnedCardCount(cardID, out standard, out golden);
int num3 = (premium != TAG_PREMIUM.NORMAL) ? golden : standard;
int num4 = this.GetOwnedCardCount(cardID, premium, true);
return(num3 > num4);
}
public bool CanCraftCard(string cardID, TAG_PREMIUM premium)
{
NetCache.CardDefinition item = new NetCache.CardDefinition {
Name = cardID,
Premium = premium
};
if (!this.m_craftableCardRewards.Contains(item) && GameUtils.FixedRewardExistsForCraftingCard(cardID, premium))
{
return(false);
}
return(true);
}
public NetCache.CardValue GetCardValue(string cardID, TAG_PREMIUM premium)
{
NetCache.CardValue value2;
NetCache.NetCacheCardValues netObject = NetCache.Get().GetNetObject <NetCache.NetCacheCardValues>();
NetCache.CardDefinition key = new NetCache.CardDefinition {
Name = cardID,
Premium = premium
};
if (!netObject.Values.TryGetValue(key, out value2))
{
return(null);
}
return(value2);
}
public string GetHowToEarnText(TAG_PREMIUM premium)
{
string stringTag;
if (premium == TAG_PREMIUM.GOLDEN)
{
stringTag = base.GetStringTag(GAME_TAG.HOW_TO_EARN_GOLDEN);
if (stringTag == null)
{
return(string.Empty);
}
return(stringTag);
}
stringTag = base.GetStringTag(GAME_TAG.HOW_TO_EARN);
if (stringTag == null)
{
return(string.Empty);
}
return(stringTag);
}
public static string GetHandActor(TAG_CARDTYPE cardType, TAG_PREMIUM premiumType)
{
switch (cardType)
{
case TAG_CARDTYPE.HERO:
return("History_Hero");
case TAG_CARDTYPE.MINION:
return(GetNameWithPremiumType("Card_Hand_Ally", premiumType));
case TAG_CARDTYPE.SPELL:
return(GetNameWithPremiumType("Card_Hand_Ability", premiumType));
case TAG_CARDTYPE.WEAPON:
return(GetNameWithPremiumType("Card_Hand_Weapon", premiumType));
case TAG_CARDTYPE.HERO_POWER:
return("History_HeroPower");
}
return("Card_Hidden");
}
public void DoCreate()
{
this.UpdateTips();
if (!Options.Get().GetBool(Option.HAS_CRAFTED))
{
Options.Get().SetBool(Option.HAS_CRAFTED, true);
}
string cardId = CraftingManager.Get().GetShownActor().GetEntityDef().GetCardId();
TAG_PREMIUM premium = CraftingManager.Get().GetShownActor().GetCardFlair().Premium;
CraftingManager.Get().AdjustLocalArcaneDustBalance(-this.GetCardBuyValue(cardId, premium));
CraftingManager.Get().NotifyOfTransaction(1);
if (CraftingManager.Get().GetNumOwnedCopies(cardId, premium) > 1)
{
CraftingManager.Get().ForceNonGhostFlagOn();
}
this.UpdateText();
this.StopCurrentAnim();
base.StartCoroutine(this.DoCreateAnims());
CraftingManager.Get().StartCoroutine(this.StartDisenchantCooldown());
}
private void MissingCardDisplay(Actor actor, string cardID, TAG_PREMIUM premium)
{
NetCache.CardValue value2;
int buy = -1;
NetCache.NetCacheCardValues netObject = NetCache.Get().GetNetObject <NetCache.NetCacheCardValues>();
NetCache.CardDefinition key = new NetCache.CardDefinition {
Name = cardID,
Premium = premium
};
if (netObject.Values.TryGetValue(key, out value2))
{
buy = value2.Buy;
}
long balance = NetCache.Get().GetNetObject <NetCache.NetCacheArcaneDustBalance>().Balance;
if (((buy > 0) && (buy <= balance)) && FixedRewardsMgr.Get().CanCraftCard(cardID, premium))
{
if (!actor.isGhostCard())
{
actor.GhostCardEffect(true);
}
}
else
{
CollectionManagerDisplay display = CollectionManagerDisplay.Get();
if (!actor.MissingCardEffect())
{
if (premium == TAG_PREMIUM.GOLDEN)
{
actor.OverrideAllMeshMaterials(display.GetGoldenCardNotOwnedMeshMaterial());
}
else
{
actor.OverrideAllMeshMaterials(display.GetCardNotOwnedMeshMaterial());
}
}
}
}
public static bool FixedRewardExistsForCraftingCard(string cardID, TAG_PREMIUM premium)
{
int num = TranslateCardIdToDbId(cardID);
string str = EnumUtils.GetString <FixedRewardType>(FixedRewardType.CRAFTABLE_CARD);
foreach (DbfRecord record in GameDbf.FixedReward.GetRecords())
{
if (record.GetString("TYPE").Equals(str))
{
int @int = record.GetInt("CARD_ID");
if (num == @int)
{
int num3 = record.GetInt("CARD_PREMIUM");
if (premium == num3)
{
return(true);
}
}
}
}
return(false);
}
public bool AddCard(string cardID, TAG_PREMIUM premium)
{
if (!this.CanInsertCard(cardID, premium))
{
return(false);
}
bool owned = this.CanAddOwnedCard(cardID, premium);
CollectionDeckSlot slot = this.FindSlotByCardIdPremiumAndOwned(cardID, premium, owned);
if (slot != null)
{
slot.Count++;
return(true);
}
slot = new CollectionDeckSlot {
CardID = cardID,
Count = 1,
Premium = premium,
Owned = owned
};
this.InsertSlotByDefaultSort(slot);
return(true);
}
private bool CanInsertCard(string cardID, TAG_PREMIUM premium)
{
if (this.Type != DeckType.DRAFT_DECK)
{
EntityDef entityDef = DefLoader.Get().GetEntityDef(cardID);
EntityDef def2 = DefLoader.Get().GetEntityDef(this.HeroCardID);
TAG_CLASS tag_class = entityDef.GetClass();
TAG_CLASS tag_class2 = def2.GetClass();
if ((tag_class != TAG_CLASS.INVALID) && (tag_class != tag_class2))
{
Debug.LogWarning(string.Format("CollectionDeck.CanInsertCard(): {0} (class {1}) has invalid class for deck with hero class {2}", entityDef.GetName(), tag_class, tag_class2));
return(false);
}
int cardIdCount = this.GetCardIdCount(cardID);
int num2 = !entityDef.IsElite() ? 2 : 1;
if ((cardIdCount + 1) > num2)
{
Debug.LogWarning(string.Format("CollectionDeck.CanInsertCard(): already have {0} copies of {1} (max allowed copies = {2})", cardIdCount, entityDef.GetName(), num2));
return(false);
}
}
return(true);
}
public void SetPremium(TAG_PREMIUM premium)
{
object[] objArray1 = new object[] { premium };
base.method_8("SetPremium", objArray1);
}
public void Preload(TAG_CARDTYPE type, TAG_PREMIUM premium, bool owned, int num)
{
}
private ActorKey MakeActorKey(TAG_CARDTYPE cardType, TAG_PREMIUM premiumType, bool owned)
{
return(new ActorKey {
m_cardType = cardType, m_owned = owned, m_premiumType = premiumType
});
}
public static string GetZoneActor(EntityDef entityDef, TAG_ZONE zoneTag, TAG_PREMIUM premium)
{
object[] objArray1 = new object[] { entityDef, zoneTag, premium };
return(MonoClass.smethod_13(TritonHs.MainAssemblyPath, "", "ActorNames", "GetZoneActor", new Class272.Enum20[] { Class272.Enum20.Class }, objArray1));
}
public static string GetNameWithPremiumType(string actorName, TAG_PREMIUM premiumType)
{
object[] objArray1 = new object[] { actorName, premiumType };
return(MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "ActorNames", "GetNameWithPremiumType", objArray1));
}
public static string GetHeroSkinOrHandActor(TAG_CARDTYPE type, TAG_PREMIUM premium)
{
object[] objArray1 = new object[] { type, premium };
return(MonoClass.smethod_12(TritonHs.MainAssemblyPath, "", "ActorNames", "GetHeroSkinOrHandActor", objArray1));
}
public static string GetHandActor(TAG_CARDTYPE cardType, TAG_PREMIUM premiumType)
{
Class272.Enum20[] enumArray1 = new Class272.Enum20[] { Class272.Enum20.ValueType, Class272.Enum20.ValueType };
object[] objArray1 = new object[] { cardType, premiumType };
return(MonoClass.smethod_13(TritonHs.MainAssemblyPath, "", "ActorNames", "GetHandActor", enumArray1, objArray1));
}
public static string GetZoneActor(TAG_CARDTYPE cardType, TAG_CLASS classTag, TAG_ZONE zoneTag, Player controller, TAG_PREMIUM premium)
{
object[] objArray1 = new object[] { cardType, classTag, zoneTag, controller, premium };
return(MonoClass.smethod_13(TritonHs.MainAssemblyPath, "", "ActorNames", "GetZoneActor", new Class272.Enum20[] { Class272.Enum20.ValueType }, objArray1));
}
public static int ClientCardUID(int cardDbId, TAG_PREMIUM premium, bool owned)
{
return(CardUID(cardDbId, premium) | (!owned ? 0 : 0x10000));
}
