public override string GetCurrentEffectText(CardStatistics cardStats, SaveManager saveManager, RelicManager relicManager)
{
int extraDamage = GetExtraDamage(GetCard());
if (cardStats == null)
{
if (extraDamage > 0)
{
return(string.Format("CardTraitScalingAddDamage_ExtraDamage_XCostOutsideBattle_CardText".Localize(), extraDamage, "tempUpgradeHighlight"));
}
return(string.Empty);
}
int baseDamage = GetBaseDamage(GetCard());
if (extraDamage > 0)
{
if (!CardStatistics.GetTrackedValueIsValidOutsideBattle(base.StatValueData.trackedValue) && !cardStats.GetIsInActiveBattle())
{
return(string.Format("CardTraitScalingAddDamage_ExtraDamage_XCostOutsideBattle_CardText".Localize(), extraDamage, "tempUpgradeHighlight"));
}
return(string.Format("CardTraitScalingAddDamage_ExtraDamage_CardText".Localize(new LocalizedInteger(baseDamage, baseDamage + extraDamage)), extraDamage, "tempUpgradeHighlight"));
}
if (!cardStats.GetStatValueShouldDisplayOnCardNow(base.StatValueData))
{
return(string.Empty);
}
return("CardTraitScalingAddDamage_CurrentScaling_CardText".Localize(new LocalizedIntegers(baseDamage)));
}
public static IEnumerator RestartBattleCoroutine(BattleHud battleHud)
{
// Get managers from battleHud private fields
CombatManager combatManager = Traverse.Create(battleHud).Field("combatManager").GetValue <CombatManager>();
GameStateManager gameStateManager = Traverse.Create(combatManager).Field("gameStateManager").GetValue <GameStateManager>();
SaveManager saveManager = Traverse.Create(combatManager).Field("saveManager").GetValue <SaveManager>();
ScreenManager screenManager = Traverse.Create(battleHud).Field("screenManager").GetValue <ScreenManager>();
CardManager cardManager = Traverse.Create(battleHud).Field("cardManager").GetValue <CardManager>();
CardStatistics cardStatistics = Traverse.Create(cardManager).Field("cardStatistics").GetValue <CardStatistics>();
// Get the current type of run that you're playing
RunType runType = Traverse.Create(saveManager).Field("activeRunType").GetValue <RunType>();
string sharecode = Traverse.Create(saveManager).Field("activeSharecode").GetValue <string>();
// Return to the main menu
// Note: Copied from PauseDialog.ReturnToMainMenu()
gameStateManager.LeaveGame();
screenManager.ReturnToMainMenu();
cardStatistics.ResetAllStats();
// Wait until the main menu is loaded
yield return(new WaitUntil(() => SceneManager.GetActiveScene().name == "main_menu" && SceneManager.GetActiveScene().isLoaded));
yield return(null);
yield return(null);
yield return(null);
// Resume your battle from the main menu
gameStateManager.ContinueRun(runType, sharecode);
}
public override string GetCurrentEffectText(CardStatistics cardStatistics, SaveManager saveManager, RelicManager relicManager)
{
int baseDamage = GetTotalPyreDamage();
int extraDamage = GetExtraDamage(GetCard());
// The card text must be different if we're in combat or out of it
if (cardStatistics != null && cardStatistics.GetIsInActiveBattle())
{
// In combat
if (extraDamage > 0)
{
return(string.Format("Pyreboost_CardText_InsideCombat_WithUpgrades".Localize(), extraDamage, "tempUpgradeHighlight", baseDamage));
}
else
{
return(string.Format("Pyreboost_CardText_InsideCombat_NoUpgrades".Localize(), baseDamage));
}
}
// Out of combat
if (extraDamage > 0)
{
return(string.Format(("Pyreboost_CardText_OutsideCombat").Localize(), extraDamage, "tempUpgradeHighlight"));
}
return(string.Empty);
}
public override string GetCurrentEffectText(CardStatistics cardStatistics, SaveManager saveManager, RelicManager relicManager)
{
//if (cardStatistics.GetStatValueShouldDisplayOnCardNow(base.StatValueData))
//{
// return string.Format("CardTraitScalingUpgradeUnitAttack_CurrentScaling_CardText".Localize(), GetMultiplier(cardStatistics));
//}
return(string.Empty);
}
public int GetCardStatistic(CardStatistics statistic)
{
if (_avatarCardStatistics == null)
{
InitCardStatistics();
}
return(_avatarCardStatistics[statistic]);
}
public override string GetCurrentEffectText(CardStatistics cardStatistics, SaveManager saveManager, RelicManager relicManager)
{
if (cardStatistics != null && cardStatistics.GetStatValueShouldDisplayOnCardNow(base.StatValueData))
{
return("CardTraitScalingReturnConsumedCards_CurrentScaling_CardText".Localize(new LocalizedIntegers(GetAdditionalCardCount(cardStatistics))));
}
return(string.Empty);
}
public void SetCardStatistic(CardStatistics statistic, int value)
{
if (_avatarCardStatistics.ContainsKey(statistic))
{
_avatarCardStatistics[statistic] = value;
ReinitProjectileStatistics();
}
else
{
_avatarCardStatistics.Add(statistic, value);
}
}
public override int OnApplyingDamage(ApplyingDamageParameters damageParams)
{
CardStatistics cardStatistics = damageParams.combatManager.GetCardManager().GetCardStatistics();
int baseDamage = GetBaseDamage(damageParams.damageSourceCard);
int extraDamage = GetExtraDamage(damageParams.damageSourceCard);
CharacterState attacker = damageParams.attacker;
if (attacker != null)
{
attacker.SetAttackDamage(attacker.GetAttackDamage() + baseDamage + extraDamage);
}
return(baseDamage + extraDamage);
}
private int GetMultiplier(CardStatistics cardStatistics)
{
CardStatistics.StatValueData statValueData = default(CardStatistics.StatValueData);
statValueData.cardState = GetCard();
statValueData.trackedValue = GetParamTrackedValue();
statValueData.entryDuration = GetParamEntryDuration();
statValueData.cardTypeTarget = GetParamCardType();
statValueData.paramSubtype = GetParamSubtype();
CardStatistics.StatValueData statValueData2 = statValueData;
int statValue = cardStatistics.GetStatValue(statValueData2);
return(statValue);
}
public override int GetModifiedCost(int cost, CardState thisCard, CardStatistics cardStats, MonsterManager monsterManager)
{
return(GetParamInt());
}
static void Postfix(ref string __result, CardTraitScalingReturnConsumedCards __instance, CardStatistics cardStatistics)
{
if (cardStatistics != null)
{
if (!ProviderManager.TryGetProvider <CardManager>(out CardManager cardManager))
{
return;
}
if (!ProviderManager.TryGetProvider <PlayerManager>(out PlayerManager playerManager))
{
return;
}
;
if (cardManager.GetExhaustedPile() == null)
{
return;
}
__result = "CardTraitScalingReturnConsumedCards_CurrentScaling_CardText".Localize(new LocalizedIntegers(UnityEngine.Mathf.Min(playerManager.GetEnergy(), cardManager.GetExhaustedPile().FindAll(x => !x.GetDebugName().Contains("Rewind")).Count)));
}
}
private int GetAdditionalCardCount(CardStatistics cardStatistics)
{
int statValue = cardStatistics.GetStatValue(base.StatValueData);
return(GetParamInt() * statValue);
}
public Decision Decide_Hard()
{
Decision decision = new Decision();
decision.found = false;
for (int i = 0; i < Properties.Settings.Default.nbrPlayers; i++)
{
if ((i != player.indexPlayer) && (Game.Instance.players[i].isActive))
{
for (int c = 0; c < 16; c++)
{
statistics0[i, c] = new CardStatistics();
}
for (int c = 0; c < 5; c++)
{
statistics0[i, c].card = Card.Garde;
}
for (int c = 5; c < 7; c++)
{
statistics0[i, c].card = Card.Pretre;
}
for (int c = 7; c < 9; c++)
{
statistics0[i, c].card = Card.Baron;
}
for (int c = 9; c < 11; c++)
{
statistics0[i, c].card = Card.Servante;
}
for (int c = 11; c < 13; c++)
{
statistics0[i, c].card = Card.Prince;
}
statistics0[i, 13].card = Card.Roi;
statistics0[i, 14].card = Card.Comtesse;
statistics0[i, 15].card = Card.Princesse;
if (seen[i] != Card.Unknown)
{
//we know the card
for (int c = 0; c < 16; c++)
{
statistics0[i, c].canBe = false;
}
CanBe(i, seen[i]);
}
else
{
//exclude cards of other players & removed cards
for (int j = 0; j < Properties.Settings.Default.nbrPlayers; j++)
{
if ((i != j) && Game.Instance.players[j].isActive)
{
if (seen[j] != Card.Unknown)
{
CannotBe(i, seen[j]);
}
}
foreach (LoveLetter.Card card in Game.Instance.players[j].deadCard)
{
CannotBe(i, (Card)card.value);
}
foreach (LoveLetter.Card card in Game.Instance.removedCards)
{
CannotBe(i, (Card)card.value);
}
}
}
for (int j = 1; j < 9; j++)
{
statistics1[i, j] = 0;
}
for (int j = 0; j < 16; j++)
{
if (statistics0[i, j].canBe)
{
statistics1[i, (int)statistics0[i, j].card]++;
}
}
}
}
if (Have(Card.Prince) && (PlayerLikelyWith(Card.Princesse) != -1)) //Si l'IA a un prince et qu'un autre joueur a une princesse, on peut éliminer ce joueur
{
decision.chosenCard = Hand(Card.Prince);
decision.guessPlayer = PlayerLikelyWith(Card.Princesse);
decision.guessCard = (int)Card.Princesse;
decision.found = true;
}
else if (Have(Card.Baron) && (PlayerLikelyWithBelow(Other(Card.Baron)) != -1)) //Si l'IA a un baron et qu'un joueur a une carte inférieure à notre autre carte
{
decision.chosenCard = Hand(Card.Baron);
decision.guessPlayer = PlayerLikelyWithBelow(Other(Card.Baron));
decision.found = true;
}
if (!decision.found)
{
if (Have(Card.Garde))
{
Tuple <int, Card> target = PlayerWithMostLikelyCardThatIsntGuard();
if (target.Item1 != -1)
{
decision.chosenCard = Hand(Card.Garde);
decision.guessPlayer = target.Item1;
decision.guessCard = (int)target.Item2;
decision.found = true;
}
}
}
return(decision);
}
static bool Prefix(RelicEffectBase __instance, ref StringBuilder stringBuilder, CardStatistics cardStatistics)
{
RelicEffectRewind relicEffect;
if ((relicEffect = __instance as RelicEffectRewind) != null)
{
// When we find our relic type, we overwrite this entire method to bypass CardStatistics which can't track our custom relic triggers correctly
string countDisplayString = relicEffect._counter.ToString() + "/1";
if (!string.IsNullOrWhiteSpace(countDisplayString))
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(", ");
}
stringBuilder.Append(countDisplayString);
}
return(false);
}
return(true);
}
public override void OnTrigger(CardStatistics cardStatistics)
{
// We override this for this relic to handle the manual counting we do for when the effect has triggered (for the UI)
// Don't run the base class's implementation with this RelicEffect
}
