public override void AddDelegate(CardEffectState cardEffectState,
CardEffectParams cardEffectParams,
DeckScreen deckScreen)
{
deckScreen.AddDeckScreenCardStateChosenDelegate((DeckScreen.CardStateChosenDelegate)(chosenCardState =>
{
CardUpgradeState cardUpgradeState = new CardUpgradeState();
cardUpgradeState.Setup(cardEffectState.GetParamCardUpgradeData());
foreach (CardUpgradeMaskData filter in cardUpgradeState.GetFilters())
{
if (!filter.FilterCard(chosenCardState, cardEffectParams.relicManager))
{
// If any of the filters matches, it doesn't get upgraded
return;
}
}
if (chosenCardState.GetCardType() == CardType.Monster)
{
chosenCardState.GetTemporaryCardStateModifiers().AddUpgrade(cardUpgradeState);
}
if (chosenCardState.GetCardType() == CardType.Spell)
{
chosenCardState.AddTemporaryTrait(new CardTraitDataBuilder {
TraitStateType = typeof(CardTraitPyreboost)
}.Build(), cardEffectParams.cardManager);
}
chosenCardState.UpdateCardBodyText();
cardEffectParams.screenManager.SetScreenActive(ScreenName.Deck, false, (ScreenManager.ScreenActiveCallback)null);
}));
}
//I probably could convert these functions to be generic and the selected objects to a type dictionary... but I am lazy, so too bad.
public void OnClickCardState(StokerPlugin plugin, SelectionButton <CardState> obj, CardState item)
{
//Sets the Selected Card State to this
plugin.selectedCardState = item;
//Update old Card State's GameObj's color
if (plugin.selectedCardStateGameobject != null)
{
plugin.selectedCardStateGameobject.button.colors = getGreyColorBlock();
}
//Set Selected Card State to this
plugin.selectedCardStateGameobject = obj;
//Update Colors
obj.button.colors = getRedColorBlock();
selectedUpgradeData = null;
selectedUpgradeState = null;
if (plugin.selectedUpgradeStateGameobject != null)
{
plugin.selectedUpgradeStateGameobject.button.colors = getGreyColorBlock();
plugin.selectedUpgradeStateGameobject = null;
}
if (plugin.selectedUpgradeDataGameobject != null)
{
plugin.selectedUpgradeDataGameobject.button.colors = getGreyColorBlock();
plugin.selectedUpgradeDataGameobject = null;
}
selectedCardState.UpdateCardBodyText(currentSave);
UpdateUpgrades();
UpdateUpgradeDatabaseByCardState(selectedCardState);
//Prevents a desync due to deck issues.
if (!IsInit)
{
DeckChangedNotification(currentSave.GetDeckState(), currentSave.GetVisibleDeckCount());
IsInit = true;
}
}
public static void LoadSaveState(StokerSaveState saveState, SaveManager save)
{
if (save != null && saveState != null)
{
//remove all cards except for champion
var deckState = save.GetDeckState();
if (deckState != null)
{
deckState.RemoveAll(x => !x.IsChampionCard());
List <IDeckNotifications> deckNotifications = (List <IDeckNotifications>)AccessTools.Field(typeof(SaveManager), "deckNotifications").GetValue(save);
deckNotifications.ForEach(rn => rn.DeckChangedNotification(deckState, save.GetVisibleDeckCount()));
}
save.RemoveAllRelics();
if (saveState.relics != null)
{
foreach (var relic in saveState.relics)
{
if (relic != null)
{
var relicData = save.GetAllGameData().FindCollectableRelicData(relic);
if (relicData != null)
{
save.AddRelic(relicData);
}
}
}
}
if (saveState.cards != null)
{
foreach (var card in saveState.cards)
{
if (card.cardName != null || card.cardName != "")
{
var cardData = save.GetAllGameData().FindCardData(card.cardName);
var spawn = cardData.GetSpawnCharacterData();
if (cardData != null && (spawn == null || (spawn != null && !spawn.IsChampion())))
{
var state = save.AddCardToDeck(cardData);
if (card.upgradeNames != null)
{
foreach (string upgrade in card.upgradeNames)
{
if (upgrade != "")
{
CardUpgradeState cardUpgradeState = Activator.CreateInstance <CardUpgradeState>();
CardUpgradeData data = save.GetAllGameData().FindCardUpgradeData(upgrade);
cardUpgradeState.Setup(data);
state.Upgrade(cardUpgradeState, null);
}
}
}
}
}
}
}
}
}
public override IEnumerator ApplyEffect(CardEffectState cardEffectState, CardEffectParams cardEffectParams)
{
foreach (CharacterState target in cardEffectParams.targets)
{
if (!OnGainEmber.energyData.TryGetValue(target, out int addEnergy))
{
addEnergy = 1;
}
CardUpgradeState upgradeState = new CardUpgradeState();
upgradeState.Setup(cardEffectState.GetParamCardUpgradeData());
// Tweak the CardUpgradeState's stats
Traverse.Create(upgradeState).Field("attackDamage").SetValue(upgradeState.GetAttackDamage() * addEnergy);
Traverse.Create(upgradeState).Field("additionalHP").SetValue(upgradeState.GetAdditionalHP() * addEnergy);
if (cardEffectParams.playedCard != null)
{
foreach (CardTraitState traitState in cardEffectParams.playedCard.GetTraitStates())
{
traitState.OnApplyingCardUpgradeToUnit(cardEffectParams.playedCard, target, upgradeState, cardEffectParams.cardManager);
}
}
int attackDamage = upgradeState.GetAttackDamage();
int additionalHP = upgradeState.GetAdditionalHP();
string text = ((attackDamage != 0) ? GetAttackNotificationText(upgradeState) : null);
string text2 = ((additionalHP != 0) ? GetHPNotificationText(upgradeState) : null);
string text3 = string.Empty;
if (text != null && text2 != null)
{
text3 = string.Format("TextFormat_SpacedItems".Localize(), text, text2);
}
else if (text != null)
{
text3 = text;
}
else if (text2 != null)
{
text3 = text2;
}
if (text3 != null)
{
NotifyHealthEffectTriggered(cardEffectParams.saveManager, cardEffectParams.popupNotificationManager, text3, target.GetCharacterUI());
}
yield return(target.ApplyCardUpgrade(upgradeState));
CardState spawnerCard = target.GetSpawnerCard();
bool flag = target.HasStatusEffect("cardless");
if (spawnerCard != null && !cardEffectParams.saveManager.PreviewMode && !flag)
{
CardAnimator.CardUpgradeAnimationInfo type = new CardAnimator.CardUpgradeAnimationInfo(spawnerCard, upgradeState);
CardAnimator.DoAddRecentCardUpgrade.Dispatch(type);
spawnerCard.GetTemporaryCardStateModifiers().AddUpgrade(upgradeState);
spawnerCard.UpdateCardBodyText();
cardEffectParams.cardManager?.RefreshCardInHand(spawnerCard);
}
}
}
private string GetHPNotificationText(CardUpgradeState upgradeState)
{
int additionalHP = upgradeState.GetAdditionalHP();
if (additionalHP >= 0)
{
return(CardEffectBuffMaxHealth.GetNotificationText(additionalHP));
}
return(CardEffectDebuffMaxHealth.GetNotificationText(Mathf.Abs(additionalHP)));
}
public void AttemptToUpgradeCardState()
{
if (selectedCardState != null && selectedUpgradeData != null)
{
CardUpgradeState cardUpgradeState = Activator.CreateInstance <CardUpgradeState>();
cardUpgradeState.Setup(selectedUpgradeData);
selectedCardState.Upgrade(cardUpgradeState, currentSave);
selectedCardState.UpdateCardBodyText(currentSave);
UpdateUpgrades();
RefreshSelectionCardStateSelectionButtons();
}
}
static IEnumerator Postfix(IEnumerator __result, CharacterState __instance, CardUpgradeState cardUpgradeState)
{
Traverse.Create(__instance).Property("PrimaryStateInformation").Property("Size").SetValue(__instance.GetSize() + cardUpgradeState.GetAdditionalSize());
ProviderManager.TryGetProvider <RoomManager>(out RoomManager roomManager);
if (ProviderManager.CombatManager.IsPlayerActionPhase())
{
var room = roomManager.GetRoom(__instance.GetCurrentRoomIndex());
Traverse.Create(room).Field("roomUI").Field <RoomCapacityUI>("roomCapacityUI").Value.Show((room), false);
}
//yield return roomManager.GetRoom(__instance.GetCurrentRoomIndex()).AdjustCapacity(Team.Type.Monsters, 0, false);
yield return(__result);
}
public override IEnumerator ApplyEffect(
CardEffectState cardEffectState,
CardEffectParams cardEffectParams)
{
CardUpgradeState cardUpgradeState = new CardUpgradeState();
cardUpgradeState.Setup(cardEffectState.GetParamCardUpgradeData());
var card = cardEffectParams.playedCard;
CardAnimator.CardUpgradeAnimationInfo type = new CardAnimator.CardUpgradeAnimationInfo(card, cardUpgradeState);
CardAnimator.DoAddRecentCardUpgrade.Dispatch(type);
card.GetTemporaryCardStateModifiers().AddUpgrade(cardUpgradeState);
card.UpdateCardBodyText();
cardEffectParams.cardManager.RefreshCardInHand(card);
yield break;
}
public WardStatePower()
{
ID = "Power";
tooltipTitleKey = "PowerWardBeta_Name";
tooltipBodyKey = "PowerWardBeta_Desc";
var localPath = Path.GetDirectoryName(new Uri(Assembly.GetCallingAssembly().CodeBase).LocalPath);
wardIcon = CustomAssetManager.LoadSpriteFromPath(Path.Combine(localPath, "Unit Assets/PowerWard.png"));
CardUpgradeData upgrade = new CardUpgradeDataBuilder
{
BonusDamage = power
}.Build();
upgradeState = new CardUpgradeState();
upgradeState.Setup(upgrade);
}
public override void OnCardDrawn(CardState thisCard, CardManager cardManager, PlayerManager playerManager, MonsterManager monsterManager)
{
if (upgrade == null)
{
var upgradeBuilder = new CardUpgradeDataBuilder
{
HideUpgradeIconOnCard = true,
};
upgradeBuilder.StatusEffectUpgrades.AddRange(GetParamStatusEffects().ToList());
upgrade = new CardUpgradeState();
upgrade.Setup(upgradeBuilder.Build());
}
foreach (CardState item in cardManager.GetAllCards())
{
if (item.IsMonsterCard() && !item.GetTemporaryCardStateModifiers().HasUpgrade(upgrade))
{
item.GetTemporaryCardStateModifiers().AddUpgrade(upgrade);
}
}
}
public override void AddDelegate(CardEffectState cardEffectState,
CardEffectParams cardEffectParams,
DeckScreen deckScreen)
{
deckScreen.AddDeckScreenCardStateChosenDelegate((DeckScreen.CardStateChosenDelegate)(chosenCardState =>
{
CardUpgradeState cardUpgradeState = new CardUpgradeState();
cardUpgradeState.Setup(cardEffectState.GetParamCardUpgradeData());
foreach (CardUpgradeMaskData filter in cardUpgradeState.GetFilters())
{
if (!filter.FilterCard(chosenCardState, cardEffectParams.relicManager))
{
// If any of the filters matches, it doesn't get upgraded
return;
}
}
chosenCardState.GetTemporaryCardStateModifiers().AddUpgrade(cardUpgradeState);
chosenCardState.UpdateCardBodyText();
cardEffectParams.screenManager.SetScreenActive(ScreenName.Deck, false, (ScreenManager.ScreenActiveCallback)null);
}));
}
private string GetAttackNotificationText(CardUpgradeState upgradeState)
{
return(CardEffectBuffDamage.GetNotificationText(upgradeState.GetAttackDamage()));
}
public override void OnApplyingCardUpgradeToUnit(CardState thisCard, CharacterState targetUnit, CardUpgradeState upgradeState, CardManager cardManager)
{
int multiplier = GetMultiplier(cardManager.GetCardStatistics());
upgradeState.SetAttackDamage(upgradeState.GetAttackDamage() * multiplier);
upgradeState.SetAdditionalHP(upgradeState.GetAdditionalHP() * multiplier);
upgradeState.SetAdditionalSize(upgradeState.GetAdditionalSize() * multiplier);
}
public override bool OnCardBeingUpgraded(CardState cardState, CardState upgradingCardSource, CardManager cardManager, CardUpgradeState cardUpgradeState)
{
int scaleAmount = GetScaleAmount(upgradingCardSource, cardManager);
cardUpgradeState.SetAttackDamage(cardUpgradeState.GetAttackDamage() * scaleAmount);
cardUpgradeState.SetAdditionalHP(cardUpgradeState.GetAdditionalHP() * scaleAmount);
cardUpgradeState.SetCostReduction(cardUpgradeState.GetCostReduction() * scaleAmount);
cardUpgradeState.SetAdditionalHeal(cardUpgradeState.GetAdditionalHeal() * scaleAmount);
cardUpgradeState.SetAdditionalSize(cardUpgradeState.GetAdditionalSize() * scaleAmount);
foreach (StatusEffectStackData statusEffectStackData in cardUpgradeState.GetStatusEffectUpgrades())
{
cardUpgradeState.AddStatusEffectUpgradeStacks(statusEffectStackData.statusId, statusEffectStackData.count * (scaleAmount - statusEffectStackData.count));
}
return(true);
}
public string GetUpgradeStateName(CardUpgradeState arg)
{
return(GetUpgradeText(data.FindCardUpgradeData(arg.GetCardUpgradeDataId())));
}
public void OnClickUpgradeState(StokerPlugin plugin, SelectionButton <CardUpgradeState> obj, CardUpgradeState item)
{
plugin.selectedUpgradeState = item;
if (plugin.selectedUpgradeStateGameobject != null)
{
plugin.selectedUpgradeStateGameobject.button.colors = getGreyColorBlock();
}
plugin.selectedUpgradeStateGameobject = obj;
obj.button.colors = getRedColorBlock();
}
