/// <summary>
/// Builds the CardEffectData represented by this builder's parameters recursively;
/// all Builders represented in this class's various fields will also be built.
/// </summary>
/// <returns>The newly created CardEffectData</returns>
public CardEffectData Build()
{
if (this.ParamCharacterDataBuilder != null)
{
this.ParamCharacterData = this.ParamCharacterDataBuilder.BuildAndRegister();
}
CardEffectData cardEffectData = new CardEffectData();
AccessTools.Field(typeof(CardEffectData), "additionalParamInt").SetValue(cardEffectData, this.AdditionalParamInt);
AccessTools.Field(typeof(CardEffectData), "additionalTooltips").SetValue(cardEffectData, this.AdditionalTooltips);
AccessTools.Field(typeof(CardEffectData), "animToPlay").SetValue(cardEffectData, this.AnimToPlay);
AccessTools.Field(typeof(CardEffectData), "appliedToSelfVFX").SetValue(cardEffectData, this.AppliedToSelfVFX);
AccessTools.Field(typeof(CardEffectData), "appliedVFX").SetValue(cardEffectData, this.AppliedVFX);
AccessTools.Field(typeof(CardEffectData), "copyModifiersFromSource").SetValue(cardEffectData, this.CopyModifiersFromSource);
AccessTools.Field(typeof(CardEffectData), "effectStateName").SetValue(cardEffectData, this.EffectStateName);
AccessTools.Field(typeof(CardEffectData), "filterBasedOnMainSubClass").SetValue(cardEffectData, this.FilterBasedOnMainSubClass);
AccessTools.Field(typeof(CardEffectData), "hideTooltip").SetValue(cardEffectData, this.HideTooltip);
AccessTools.Field(typeof(CardEffectData), "ignoreTemporaryModifiersFromSource").SetValue(cardEffectData, this.IgnoreTemporaryModifiersFromSource);
AccessTools.Field(typeof(CardEffectData), "paramAdditionalCharacterData").SetValue(cardEffectData, this.ParamAdditionalCharacterData);
AccessTools.Field(typeof(CardEffectData), "paramBool").SetValue(cardEffectData, this.ParamBool);
AccessTools.Field(typeof(CardEffectData), "paramCardFilter").SetValue(cardEffectData, this.ParamCardFilter);
AccessTools.Field(typeof(CardEffectData), "paramCardPool").SetValue(cardEffectData, this.ParamCardPool);
AccessTools.Field(typeof(CardEffectData), "paramCardUpgradeData").SetValue(cardEffectData, this.ParamCardUpgradeData);
AccessTools.Field(typeof(CardEffectData), "paramCharacterData").SetValue(cardEffectData, this.ParamCharacterData);
AccessTools.Field(typeof(CardEffectData), "paramInt").SetValue(cardEffectData, this.ParamInt);
AccessTools.Field(typeof(CardEffectData), "paramMaxInt").SetValue(cardEffectData, this.ParamMaxInt);
AccessTools.Field(typeof(CardEffectData), "paramMinInt").SetValue(cardEffectData, this.ParamMinInt);
AccessTools.Field(typeof(CardEffectData), "paramMultiplier").SetValue(cardEffectData, this.ParamMultiplier);
AccessTools.Field(typeof(CardEffectData), "paramRoomData").SetValue(cardEffectData, this.ParamRoomData);
AccessTools.Field(typeof(CardEffectData), "paramStatusEffects").SetValue(cardEffectData, this.ParamStatusEffects);
AccessTools.Field(typeof(CardEffectData), "paramStr").SetValue(cardEffectData, this.ParamStr);
AccessTools.Field(typeof(CardEffectData), "paramSubtype").SetValue(cardEffectData, this.ParamSubtype);
AccessTools.Field(typeof(CardEffectData), "paramTimingDelays").SetValue(cardEffectData, this.ParamTimingDelays);
AccessTools.Field(typeof(CardEffectData), "paramTrigger").SetValue(cardEffectData, this.ParamTrigger);
AccessTools.Field(typeof(CardEffectData), "shouldTest").SetValue(cardEffectData, this.ShouldTest);
AccessTools.Field(typeof(CardEffectData), "statusEffectStackMultiplier").SetValue(cardEffectData, this.StatusEffectStackMultiplier);
//AccessTools.Field(typeof(CardData), "stringBuilder").SetValue(cardData, this.);
AccessTools.Field(typeof(CardEffectData), "targetCardSelectionMode").SetValue(cardEffectData, this.TargetCardSelectionMode);
AccessTools.Field(typeof(CardEffectData), "targetCardType").SetValue(cardEffectData, this.TargetCardType);
AccessTools.Field(typeof(CardEffectData), "targetCharacterSubtype").SetValue(cardEffectData, this.TargetCharacterSubtype);
AccessTools.Field(typeof(CardEffectData), "targetIgnoreBosses").SetValue(cardEffectData, this.TargetIgnoreBosses);
AccessTools.Field(typeof(CardEffectData), "targetMode").SetValue(cardEffectData, this.TargetMode);
AccessTools.Field(typeof(CardEffectData), "targetModeHealthFilter").SetValue(cardEffectData, this.TargetModeHealthFilter);
AccessTools.Field(typeof(CardEffectData), "targetModeStatusEffectsFilter").SetValue(cardEffectData, this.TargetModeStatusEffectsFilter);
AccessTools.Field(typeof(CardEffectData), "targetTeamType").SetValue(cardEffectData, this.TargetTeamType);
AccessTools.Field(typeof(CardEffectData), "useIntRange").SetValue(cardEffectData, this.UseIntRange);
AccessTools.Field(typeof(CardEffectData), "useStatusEffectStackMultiplier").SetValue(cardEffectData, this.UseStatusEffectStackMultiplier);
return(cardEffectData);
}
public static void Modify()
{
string frozenLanceID = VanillaCardIDs.FrozenLance;
var frozenLanceData = CustomCardManager.GetCardDataByID(frozenLanceID);
// Add piercing to Frozen Lance's trait list
var piercingTrait = new CardTraitData();
string piercingTraitName = VanillaCardTraitTypes.CardTraitIgnoreArmor.AssemblyQualifiedName;
piercingTrait.Setup(piercingTraitName);
frozenLanceData.GetTraits().Add(piercingTrait);
// Set Frozen Lance's damage to 12
var frozenLanceDamageEffect = frozenLanceData.GetEffects()[0];
Traverse.Create(frozenLanceDamageEffect).Field("paramInt").SetValue(12);
// Instantiate the Frostbite CardEffect
var frostbiteEffect = new CardEffectData();
// Set its effect type
string addStatusEffectName = VanillaCardEffectTypes.CardEffectAddStatusEffect.AssemblyQualifiedName;
Traverse.Create(frostbiteEffect).Field("effectStateName").SetValue(addStatusEffectName);
// Set targeting mode to be the same one used by Flash Freeze: Last Targeted Characters
Traverse.Create(frostbiteEffect).Field("targetMode").SetValue(TargetMode.LastTargetedCharacters);
// This field can't be null, or the game crashes with a NullPointerException
// All the other null fields are fine, though
Traverse.Create(frostbiteEffect).Field("targetModeStatusEffectsFilter").SetValue(new string[0]);
// Create the Frostbite status and add it to the effect's status array
StatusEffectStackData frostbiteStatus = new StatusEffectStackData();
frostbiteStatus.statusId = VanillaStatusEffectIDs.Frostbite;
frostbiteStatus.count = 327;
var paramStatusEffects = new StatusEffectStackData[] { frostbiteStatus };
Traverse.Create(frostbiteEffect).Field("paramStatusEffects").SetValue(paramStatusEffects);
// Add the Frostbite effect to Frozen Lance's card effect list
frozenLanceData.GetEffects().Add(frostbiteEffect);
}
protected static StatusEffectStackData GetStatusEffectStack(CardEffectData cardEffectData)
{
StatusEffectStackData[] paramStatusEffects = cardEffectData.GetParamStatusEffects();
if (paramStatusEffects == null || paramStatusEffects.Length == 0)
{
Log.Error(LogGroups.Gameplay, "cardEffectData.GetParamStatusEffects() yielded no results.");
return(null);
}
var stat = paramStatusEffects[0];
// Empower it
PlayerManager playerManager;
ProviderManager.TryGetProvider <PlayerManager>(out playerManager);
stat.count = playerManager.GetEnergy();
return(stat);
}
/**
* Apply the move effect by creating the sequence in the gameSequencer
*/
public override void ApplyEffect(CardEffectData effectData, GameContext context)
{
//Trust
if (effectData.trust)
{
if (BuffManager.Instance.IsTrustValidate(effectData.trustNb))
{
PlayerManager.Instance.UpdateMultiplier(2);
}
}
else
{
PlayerManager.Instance.UpdateMultiplier(1);
}
//add the move sequence
GSA_PlayerMove playerMoveAction = new GSA_PlayerMove();
GameSequencer.Instance.AddAction(playerMoveAction);
}
/**
* apply the spell on player and create the action in the sequencer
*/
public override void ApplyEffect(CardEffectData effectData, GameContext context)
{
//Trust
if (effectData.trust)
{
if (effectData.trustNb == TimelineManager.Instance.nbActualAction)
{
Debug.Log("Trust activate");
isTrustActivate = true;
}
}
Debug.Log("Spell : ");
//effect to draw X card
if (effectData.DrawCard)
{
int nbCardToDraw = effectData.nbCardToDraw;
if (isTrustActivate)
{
nbCardToDraw = nbCardToDraw * 2;
}
GameManager.Instance.DrawCard(nbCardToDraw);
Debug.Log(" - Draw " + nbCardToDraw + " cards");
//add the Spell sequence
GSA_Spell playerSpellAction = new GSA_Spell();
GameSequencer.Instance.AddAction(playerSpellAction);
}
//add the sight sequence
if (effectData.Sight)
{
FogMgr.Instance.SetRevealRange(effectData.sightRange);
GSA_Sight sightAction = new GSA_Sight();
GameSequencer.Instance.AddAction(sightAction);
}
}
public override void ApplyEffect(CardEffectData effectData, GameContext context)
{
int damagePoint = effectData.damagePoint;
//Shiver
if (effectData.shiver)
{
if (BuffManager.Instance.IsShiverValidate())
{
damagePoint = damagePoint * 2;
Debug.Log("Shiver activate");
}
}
//Trust
if (effectData.trust)
{
if (BuffManager.Instance.IsTrustValidate(effectData.trustNb))
{
damagePoint = damagePoint * 2;
Debug.Log("Trust activate");
}
}
//if player attack an enemy
if (context.targets == null)
{
Debug.Log("il manque une target dans le contexte !");
}
//toujours passer par le playerData pour infliger les dégats correspondant au stats actuel du player
context.targets.TakeDamage(PlayerData.Instance.DoDamage(damagePoint), true);
//add the attack sequence
GSA_PlayerAttack playerAttackAction = new GSA_PlayerAttack();
GameSequencer.Instance.AddAction(playerAttackAction);
}
/**
* Apply defense effect to player and create the defense action in sequencer
*/
public override void ApplyEffect(CardEffectData effectData, GameContext context)
{
int nbBlock = effectData.nbBlock;
//Explorer (on multiplie la défense par le nombre de nodes explorés)
if (effectData.Explorer)
{
nbBlock = nbBlock * MapManager.Instance.nbNodesCleared;
}
//inflige des dégâts au player tout court
if (effectData.PlayerDamage > 0)
{
PlayerMgr.Instance.TakeDamage(effectData.PlayerDamage);
}
//Shiver
if (effectData.shiver)
{
if (BuffManager.Instance.IsShiverValidate())
{
nbBlock = nbBlock * 2;
Debug.Log("Shiver activate");
}
}
//Trust
if (effectData.trust)
{
if (BuffManager.Instance.IsTrustValidate(effectData.trustNb))
{
nbBlock = nbBlock * 2;
Debug.Log("Trust activate");
}
}
//si l'effet discard les cartes en mains (pour "abnegation")
if (effectData.isDiscardHand)
{
nbBlock = (GameEngine.Instance.GetHandCards().Count + 1) * nbBlock;
nbBlock = nbBlock - 3;
GSA_DiscardHand discardHandAction = new GSA_DiscardHand();
GameSequencer.Instance.AddAction(discardHandAction);
}
//si l'effet active le counter
if (effectData.isCounter)
{
BuffManager.Instance.isCounterActive = true;
BuffManager.Instance.counterDamage = effectData.counterDamagePoint;
GSA_PlayerCounter counterAction = new GSA_PlayerCounter();
GameSequencer.Instance.AddAction(counterAction);
PlayerMgr.Instance.OnPlayerCounter();
}
//apply effect
PlayerMgr.Instance.AddBlock(nbBlock);
Debug.Log("add " + nbBlock + " to player defense");
//add the defense sequence
GSA_PlayerDefense playerDefenseAction = new GSA_PlayerDefense();
GameSequencer.Instance.AddAction(playerDefenseAction);
}
public abstract void ApplyEffect(CardEffectData effectData, GameContext context);
/**
* Apply the sight effect by creating the sequence in the gameSequencer
*/
public override void ApplyEffect(CardEffectData effectData, GameContext context)
{
}
static void Postfix(ref AssetLoadingData ____assetLoadingData)
{
if (!triggered)
{
// Reach into the game data and pull out the full card set
List <CardData> cardData = ____assetLoadingData.AllGameData.GetAllCardData();
// Set aside some values to fill in later
CardTraitData piercingTraitData = null;
CardTraitData offeringTraitData = null;
CardEffectData frostbiteData = null;
CardData lanceData = null;
// Iterate through all cards
for (int i = 0; i < cardData.Count; i++)
{
if (cardData[i].GetName() == "Horn Break")
{ // Set aside Horn Break's piercing trait, so we can copy it onto Frozen Lance later
piercingTraitData = cardData[i].GetTraits()[0].Copy();
}
if (cardData[i].GetName() == "Titanstooth")
{ // Set aside Titanstooth's offering trait and frostbite effect for the same reason
offeringTraitData = cardData[i].GetTraits()[0].Copy();
frostbiteData = cardData[i].GetEffects()[1];
}
if (cardData[i].GetName() == "Frozen Lance")
{ // Set aside Frozen Lance's card data, so we have a place to copy the aforementioned onto
lanceData = cardData[i];
}
}
// Use reflection to set the paramCardData field of the traits to Frozen Lance's card data
// We only need to do this for traits, not effects
var prop = typeof(CardTraitData).GetField("paramCardData", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
prop.SetValue(piercingTraitData, lanceData);
prop.SetValue(offeringTraitData, lanceData);
// Add the traits to Frozen Lance's trait list
lanceData.GetTraits().Add(piercingTraitData);
lanceData.GetTraits().Add(offeringTraitData);
// Find Frozen Lance's damage effect and set its value to 3
foreach (CardEffectData cardEffectData in lanceData.GetEffects())
{
prop = typeof(CardEffectData).GetField("paramInt", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
prop.SetValue(cardEffectData, 3);
}
// Modify the frostbite effect's targeting mode to only the last targeted characters
// This prevents it from targeting the entire room (what it would otherwise do, since we copied it from Titanstooth)
// This probably modifies Titanstooth's behaviour, too (that's bad), but I haven't checked
prop = typeof(CardEffectData).GetField("targetMode", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
prop.SetValue(frostbiteData, TargetMode.LastTargetedCharacters);
// Add the effect to Frozen Lance's effects list
lanceData.GetEffects().Add(frostbiteData);
// Prevent patch from running again
triggered = true;
}
else
{
Debug.Log("KittenPatch has already run once!");
}
}
public override void ApplyEffect(CardEffectData effectData, GameContext context)
{
int damagePoint = effectData.damagePoint;
//Explorer (on multiplie les dégats par le nombre de nodes explorés)
if (effectData.Explorer)
{
damagePoint = damagePoint * MapManager.Instance.nbNodesCleared;
}
//Shiver
if (effectData.shiver)
{
if (BuffManager.Instance.IsShiverValidate())
{
damagePoint = damagePoint * 2;
Debug.Log("Shiver activate");
}
}
//Trust
if (effectData.trust)
{
if (BuffManager.Instance.IsTrustValidate(effectData.trustNb))
{
damagePoint = damagePoint * 2;
Debug.Log("Trust activate");
}
}
//Si pas de target
if (context.targets == null)
{
Debug.Log("il manque une target dans le contexte !");
}
//inflige des dégâts au player tout court
if (effectData.PlayerDamage > 0)
{
PlayerMgr.Instance.TakeDamage(effectData.PlayerDamage);
}
//attaque tout les enemy dans la node du player
if (effectData.isCircular)
{
foreach (EnemyScript enemyScript in EnemyMgr.Instance.GetEnemiesOnPlayersNode())
{
enemyScript.enemyData.TakeDamage(PlayerMgr.Instance.playerData.DoDamage(damagePoint), true);
}
Debug.Log("circular attack");
}
//on renvoie nbDamage en fonction des dégat reçu à ce tour
else if (effectData.BackAtYou)
{
for (int i = 0; i <= PlayerMgr.Instance.GetTurnDamage(); i++)
{
context.targets.TakeDamage(PlayerMgr.Instance.playerData.DoDamage(damagePoint), true);
}
}
//inflige des dégats à l'enemy visé et au player
else if (effectData.Rush)
{
context.targets.TakeDamage(PlayerMgr.Instance.playerData.DoDamage(damagePoint), true);
}
else
{
//toujours passer par le playerData pour infliger les dégats correspondant au stats actuel du player
context.targets.TakeDamage(PlayerMgr.Instance.playerData.DoDamage(damagePoint), true);
}
//add the attack sequence
GSA_PlayerAttack playerAttackAction = new GSA_PlayerAttack();
GameSequencer.Instance.AddAction(playerAttackAction);
}
/**
* apply the spell on player and create the action in the sequencer
*/
public override void ApplyEffect(CardEffectData effectData, GameContext context)
{
//Trust
if (effectData.trust)
{
if (effectData.trustNb == TimelineManager.Instance.nbActualAction)
{
Debug.Log("Trust activate");
isTrustActivate = true;
}
}
//inflige des dégâts au player tout court
if (effectData.PlayerDamage > 0)
{
PlayerMgr.Instance.TakeDamage(effectData.PlayerDamage);
}
//effect to draw X card
if (effectData.DrawCard)
{
int nbCardToDraw = effectData.nbCardToDraw;
if (isTrustActivate)
{
nbCardToDraw *= 2;
}
GameManager.Instance.DrawCard(nbCardToDraw);
Debug.Log(" - Draw " + nbCardToDraw + " cards");
//add the Spell sequence
GSA_Spell playerSpellAction = new GSA_Spell();
GameSequencer.Instance.AddAction(playerSpellAction);
}
//effect to draw X card from discard pile
if (effectData.recycling)
{
int nbCardToDraw = effectData.nbCardToDraw;
if (isTrustActivate)
{
nbCardToDraw *= 2;
}
GameManager.Instance.DrawCardFromDiscardPile(nbCardToDraw);
//add the Spell sequence
GSA_Spell playerSpellAction = new GSA_Spell();
GameSequencer.Instance.AddAction(playerSpellAction);
}
//effect to discard X card
if (effectData.DiscardCard)
{
//informe le gameManager du nombre de carte à discard
GameManager.Instance.SetNbCardToDiscard(effectData.nbDiscardCard);
GSA_DiscardCard discardCardAction = new GSA_DiscardCard();
GameSequencer.Instance.AddAction(discardCardAction);
}
//add the sight sequence
if (effectData.Sight)
{
FogMgr.Instance.SetRevealRange(effectData.sightRange);
GSA_Sight sightAction = new GSA_Sight();
GameSequencer.Instance.AddAction(sightAction);
}
//heal the player
if (effectData.isHeal)
{
PlayerMgr.Instance.TakeHeal(effectData.nbHeal);
GSA_Spell playerSpellAction = new GSA_Spell();
GameSequencer.Instance.AddAction(playerSpellAction);
}
//Teleport ennemy
if (effectData.Teleport)
{
//on cast target en EnemyData
EnemyData enData = context.targets as EnemyData;
if (enData != null)
{
EnemyMgr.Instance.TeleportEnemy(enData.enemyScript);
GSA_Spell playerSpellAction = new GSA_Spell();
GSA_TrapDoor trapDoorAction = new GSA_TrapDoor();
GameSequencer.Instance.AddAction(playerSpellAction);
GameSequencer.Instance.AddAction(trapDoorAction);
}
else
{
Debug.Log("target to teleport is not an ennemy");
}
}
//Overtake (switch pos player <-> enemy)
if (effectData.Overtake)
{
EnemyData enData = context.targets as EnemyData;
if (enData != null)
{
Debug.Log("Overtake");
Vector3Int newPlayerNodePos = enData.enemyScript.GetTilePosOfEnemy();
enData.enemyScript.SetNodeOfEnemy(PlayerMgr.Instance.GetTilePosOfPlayer());
PlayerMgr.Instance.SetNodeOfPlayer(newPlayerNodePos);
GSA_Spell playerSpellAction = new GSA_Spell();
GameSequencer.Instance.AddAction(playerSpellAction);
GSA_Overtake overtakeAction = new GSA_Overtake();
GameSequencer.Instance.AddAction(overtakeAction);
}
}
//discard all the card in hand and draw 4 cards
if (effectData.SecondChance)
{
GameManager.Instance.DiscardHand();
GameManager.Instance.DrawCard(4);
GSA_Spell playerSpellAction = new GSA_Spell();
GameSequencer.Instance.AddAction(playerSpellAction);
}
}
