public override void InitCard(CardData _cardData, Player owner)
{
base.InitCard(_cardData, owner);
ResetStats(true);
AbilityInit();
Status = UnitStatuses.None;
CurrentHealth = GetStat(StatTypes.MaxHealth);
RemainingSpeed = 0;
TemporaryMindControlled = false;
LoseNextAction = false;
ConfiscatedCards = new List <Card>();
ImprisonedUnits = new List <Unit>();
SpymasterLurenCards = new List <Card>();
if (GameManager.instance.CurrentGamePhase != GameManager.GamePhases.Menu)
{
Enchantments = new List <AppliedEnchantment>();
CurrentStatusEffects = new List <StatusEffects>();
CurrentKeywords = new List <Keywords>();
if (BaseKeywords.Count > 0 || UnitData.Empowered > 0)
{
var keywordEnchantment = new UnitEnchantment()
{
Source = "Base Keywords",
Status = UnitEnchantment.EnchantmentStatus.Base,
};
keywordEnchantment.Keywords = BaseKeywords.ToList();
if (UnitData.Empowered > 0)
{
keywordEnchantment.AddStatModifier(StatTypes.Empowered, StatModifierTypes.Modify, UnitData.Empowered);
}
AddEnchantment(keywordEnchantment);
}
if (Owner != null)
{
foreach (var passive in Owner.Passives)
{
if (passive.Enchantment != null)
{
if (passive.PassiveApplies(this))
{
AddEnchantment(passive.Enchantment);
}
}
}
}
}
}
public void ImmuneUnit()
{
var enchantment = new UnitEnchantment()
{
Status = UnitEnchantment.EnchantmentStatus.Permanent,
Source = "Immune",
StatusEffects = new List <StatusEffects>()
{
StatusEffects.Immune
}
};
AddEnchantment(enchantment);
}
public void IndestructibleUnit()
{
var enchantment = new UnitEnchantment()
{
Status = UnitEnchantment.EnchantmentStatus.Permanent,
Source = "Indestructible",
StatusEffects = new List <StatusEffects>()
{
StatusEffects.Indestructible
}
};
AddEnchantment(enchantment);
}
public void RootUnit()
{
var enchantment = new UnitEnchantment()
{
Status = UnitEnchantment.EnchantmentStatus.EndOfOwnersTurn,
Source = "Root",
StatusEffects = new List <StatusEffects>()
{
StatusEffects.Rooted
}
};
AddEnchantment(enchantment);
}
public void StunUnit()
{
var enchantment = new UnitEnchantment()
{
Status = UnitEnchantment.EnchantmentStatus.EndOfOwnersTurn,
Source = "Stun",
StatusEffects = new List <StatusEffects>()
{
StatusEffects.Stunned
}
};
AddEnchantment(enchantment);
}
/// <summary>
///
/// Adds the stat modifier to the enchantment for a particular stat type dropdown and an input
///
/// </summary>
private void GetStatModifier(UnitEnchantment enchantment, Unit.StatTypes statType, TMP_Dropdown statModTypeDropdown, TMP_InputField statValueInput)
{
var statModType = (StatModifierTypes)Enum.Parse(typeof(StatModifierTypes), statModTypeDropdown.captionText.text);
if (statModType != StatModifierTypes.None)
{
if (string.IsNullOrWhiteSpace(statValueInput.text))
{
statValueInput.text = "0";
}
var statValue = int.Parse(statValueInput.text);
enchantment.AddStatModifier(statType, statModType, statValue);
}
}
public void CheckUnleash(int targetAttack, int targetHealth)
{
if (HasKeyword(Keywords.Unleash))
{
var unleashEnchantment = new UnitEnchantment()
{
Source = "Unleash",
Status = UnitEnchantment.EnchantmentStatus.Permanent,
};
var modifier = Owner.HasSpecialPassive(SpecialPassiveEffects.FeralNature) ? 2 : 1;
unleashEnchantment.AddStatModifier(StatTypes.Attack, StatModifierTypes.Modify, targetAttack * modifier);
unleashEnchantment.AddStatModifier(StatTypes.MaxHealth, StatModifierTypes.Modify, targetHealth * modifier);
AddEnchantment(unleashEnchantment);
}
}
public void ModifyOverloadEnchantment(PlayerMana manaResource = null)
{
string overloadSourceString = "Overload Reduction";
if (Owner.UsedResources.Contains(CardResources.Mana))
{
if (manaResource == null)
{
manaResource = (PlayerMana)Owner.Resources.Single(x => x.ResourceType == CardResources.Mana);
}
var overloadEnchantment = Enchantments.Select(x => x.Enchantment).SingleOrDefault(x => x.Source == overloadSourceString);
var isNew = false;
if (overloadEnchantment == null)
{
overloadEnchantment = new UnitEnchantment()
{
Status = UnitEnchantment.EnchantmentStatus.OverloadPassive, Source = overloadSourceString
};
isNew = true;
}
overloadEnchantment.AddStatModifier(StatTypes.Attack, StatModifierTypes.Modify, manaResource.TotalOverload);
if (isNew)
{
AddEnchantment(overloadEnchantment);
}
else
{
UpdateEnchantments();
}
}
else
{
throw new Exception("Cannot modify overload enchantment for a non-mana class");
}
}
public void ConfirmButton()
{
if (string.IsNullOrWhiteSpace(sourceInput.text))
{
sourceInput.text = "Test Enchantment";
}
var enchantment = new UnitEnchantment();
GetStatModifier(enchantment, Unit.StatTypes.Attack, attackModTypeDropdown, attackValueInput);
GetStatModifier(enchantment, Unit.StatTypes.MaxHealth, healthModTypeDropdown, healthValueInput);
GetStatModifier(enchantment, Unit.StatTypes.Range, rangeModTypeDropdown, rangeValueInput);
GetStatModifier(enchantment, Unit.StatTypes.Speed, speedModTypeDropdown, speedValueInput);
GetStatModifier(enchantment, Unit.StatTypes.Empowered, empoweredModTypeDropdown, empoweredValueInput);
foreach (var keywordObject in keywordList)
{
var keyword = (Keywords)Enum.Parse(typeof(Keywords), keywordObject.Value);
enchantment.Keywords.Add(keyword);
}
foreach (var statusEffectObject in statusEffectList)
{
var statusEffect = (Unit.StatusEffects)Enum.Parse(typeof(Unit.StatusEffects), statusEffectObject.Value);
enchantment.StatusEffects.Add(statusEffect);
}
enchantment.Status = (UnitEnchantment.EnchantmentStatus)Enum.Parse(typeof(UnitEnchantment.EnchantmentStatus), statusDropdown.captionText.text);
enchantment.Source = sourceInput.text;
if (enchantment.ValidEnchantment)
{
StartEffect();
GameManager.instance.effectManager.SetEnchantUnitMode(enchantment);
}
}
public void CreateDeployUnits(CardData cardData, UnitEnchantment enchantment, int numToCreate, string createdBy)
{
if (cardData.CardType == CardTypes.Unit)
{
var unitList = new List <Unit>();
for (int cardIndex = 0; cardIndex < numToCreate; cardIndex++)
{
var unit = (Unit)GameManager.instance.libraryManager.CreateCard(cardData, this);
unit.CreatedByName = createdBy;
if (enchantment != null)
{
unit.AddEnchantment(enchantment);
}
unitList.Add(unit);
}
GameManager.instance.effectManager.SetDeployUnits(unitList);
}
else
{
throw new Exception("Cannot deploy a non unit card");
}
}
public void SetEnchantUnitMode(UnitEnchantment unitEnchantment)
{
SelectedEnchantment = unitEnchantment;
ActiveEffect = ActiveEffectTypes.EnchantUnit;
}
public void AddEnchantment(UnitEnchantment enchantment)
{
if (enchantment.ValidEnchantment)
{
var newEnchantment = new AppliedEnchantment()
{
Enchantment = enchantment
};
if (newEnchantment.Enchantment.Keywords.Contains(Keywords.Flying))
{
if (!HasStatusEffect(StatusEffects.Airborne))
{
newEnchantment.Enchantment.StatusEffects.Add(StatusEffects.Airborne);
if (Status != UnitStatuses.Preparing)
{
CanFlyOrLand = true;
}
}
}
if (newEnchantment.Enchantment.Keywords.Contains(Keywords.Stealth))
{
newEnchantment.Enchantment.StatusEffects.Add(StatusEffects.Stealthed);
}
if (Status != UnitStatuses.Preparing && Status != UnitStatuses.None)
{
if (newEnchantment.Enchantment.Keywords.Contains(Keywords.SpecialSwiftstrike))
{
if (!HasKeyword(Keywords.Swiftstrike) && !HasKeyword(Keywords.SpecialSwiftstrike))
{
ModifyActions(2);
}
else if (HasKeyword(Keywords.Swiftstrike))
{
ModifyActions(1);
}
}
else if (newEnchantment.Enchantment.Keywords.Contains(Keywords.Swiftstrike))
{
if (!HasKeyword(Keywords.Swiftstrike) && !HasKeyword(Keywords.SpecialSwiftstrike))
{
ModifyActions(1);
}
}
}
Enchantments.Add(newEnchantment);
UpdateEnchantments();
if (HasKeyword(Keywords.Prepared) && (Status == UnitStatuses.Preparing || Status == UnitStatuses.None))
{
RefreshActions();
}
RefreshCounter();
}
else
{
throw new Exception("Enchantment is not valid to add to unit");
}
}
public void ConfirmButton()
{
if (!string.IsNullOrWhiteSpace(createdByInput.text))
{
var player = GameManager.instance.GetPlayer(activeOwnerToggle.isOn);
var enchantment = new UnitEnchantment()
{
Status = UnitEnchantment.EnchantmentStatus.Permanent, Source = createdByInput.text
};
GetStatModifier(enchantment, Unit.StatTypes.Attack, attackModTypeDropdown, attackValueInput);
GetStatModifier(enchantment, Unit.StatTypes.MaxHealth, healthModTypeDropdown, healthValueInput);
GetStatModifier(enchantment, Unit.StatTypes.Range, rangeModTypeDropdown, rangeValueInput);
GetStatModifier(enchantment, Unit.StatTypes.Speed, speedModTypeDropdown, speedValueInput);
var generationFilter = new GenerateCardFilter(player.PlayerClass)
{
Name = nameInput.text,
CardType = CardTypes.Unit,
IncludeUncollectables = includeUncollectablesToggle.isOn,
IsUnique = isChoiceToggle.isOn,
};
if (tagDropdown.captionText.text != DEFAULT_DROPDOWN_STRING)
{
generationFilter.Tag = (Tags)Enum.Parse(typeof(Tags), tagDropdown.captionText.text.Replace(" ", ""));
}
if (enchantment.ValidEnchantment)
{
generationFilter.Enchantment = enchantment;
}
if (int.TryParse(numToCreateInput.text, out int result) && numToCreateInput.text != "0")
{
generationFilter.UnitsToCreate = Mathf.Max(1, result);
}
else
{
generationFilter.UnitsToCreate = 1;
}
if (isChoiceToggle.isOn)
{
generationFilter.NumToGenerate = generationFilter.UnitsToCreate;
}
if (player.GenerateCards(generationFilter, CardGenerationTypes.Deploy, isChoiceToggle.isOn, createdByInput.text))
{
StartEffect();
}
else
{
titleText.text = $"{defaultTitleText} (Failed)";
}
}
else
{
createdByInput.placeholder.color = new Color(0.8f, 0.0f, 0.0f, 0.5f);
titleText.text = $"{defaultTitleText} (Input Created By)";
}
}
public void ConfirmButton()
{
UpgradeData sourceUpgrade = null;
CardData sourceCard = null;
int? playerId = null;
switch (GameManager.instance.CurrentGamePhase)
{
case GameManager.GamePhases.Setup:
sourceUpgrade = GameManager.instance.upgradeManager.GetUpgrade(nameInput.text);
playerId = int.Parse(playerNumberDropdown.captionText.text) - 1;
break;
case GameManager.GamePhases.Gameplay:
sourceCard = GameManager.instance.libraryManager.GetCard(nameInput.text);
break;
}
if (sourceUpgrade != null || sourceCard != null)
{
var passive = new Passive
{
Name = nameInput.text,
IsTemporary = isTemporaryToggle.isOn,
SourceUpgrade = sourceUpgrade,
SourceCard = sourceCard
};
if (affectedCardTypeDropdown.captionText.text != DEFAULT_INPUT_STRING_ANY)
{
passive.AffectedCardTypes = (CardTypes)Enum.Parse(typeof(CardTypes), affectedCardTypeDropdown.captionText.text);
}
if (affectedTagDropdown.captionText.text != DEFAULT_INPUT_STRING_ANY)
{
passive.AffectedCardTag = (Tags)Enum.Parse(typeof(Tags), affectedTagDropdown.captionText.text);
}
if (affectedUnitTagDropdown.captionText.text != DEFAULT_INPUT_STRING_ANY)
{
passive.AffectedUnitTags = (UnitTags)Enum.Parse(typeof(UnitTags), affectedUnitTagDropdown.captionText.text);
}
if (costResourceDropdown.captionText.text != DEFAULT_INPUT_STRING_NONE)
{
passive.TargetResource = (CardResources)Enum.Parse(typeof(CardResources), costResourceDropdown.captionText.text);
}
if (int.TryParse(costValueInput.text, out int result))
{
var costAdjustment = new AdjustCostObject()
{
AdjustmentType = StatModifierTypes.Modify, FromPassive = true
};
costAdjustment.Value = result;
if (int.TryParse(minCostInput.text, out int minCostResult))
{
costAdjustment.MinCost = minCostResult;
}
if (int.TryParse(greaterThanInput.text, out int greaterThanResult))
{
costAdjustment.MustBeGreaterThan = greaterThanResult;
}
passive.CostAdjustment = costAdjustment;
}
else
{
passive.CostAdjustment = null;
}
var enchantment = new UnitEnchantment()
{
Status = UnitEnchantment.EnchantmentStatus.Passive,
Source = nameInput.text,
};
GetStatModifier(enchantment, Unit.StatTypes.Attack, attackModTypeDropdown, attackValueInput);
GetStatModifier(enchantment, Unit.StatTypes.MaxHealth, healthModTypeDropdown, healthValueInput);
GetStatModifier(enchantment, Unit.StatTypes.Range, rangeModTypeDropdown, rangeValueInput);
GetStatModifier(enchantment, Unit.StatTypes.Speed, speedModTypeDropdown, speedValueInput);
if (enchantment.ValidEnchantment)
{
passive.Enchantment = enchantment;
}
if (specialPassiveValueDropdown.captionText.text != DEFAULT_INPUT_STRING_NONE)
{
passive.SpecialPassive = (SpecialPassiveEffects)Enum.Parse(typeof(SpecialPassiveEffects), specialPassiveValueDropdown.captionText.text);
if (int.TryParse(specialPassiveValueInput.text, out int specialPassive))
{
passive.SpecialPassiveProperty = specialPassive;
}
else
{
passive.SpecialPassiveProperty = 0;
}
}
if (GameManager.instance.effectManager.AddPassive(passive, playerId))
{
gameObject.SetActive(false);
}
else
{
titleText.text = $"{defaultTitleText} (Failed)";
}
}
else
{
titleText.text = $"{defaultTitleText} (Failed)";
}
}
/// <summary>
///
/// Button click event for confirming the given filter and attempting to generate a card
///
/// </summary>
public void ConfirmGeneration()
{
//In order to submit, needs to have a created by string. Doesn't confirm if there is no text, and displays error to player
if (!string.IsNullOrWhiteSpace(createdByInput.text))
{
//Sets the name filter to the name input
GenerationFilter.Name = nameInput.text;
GenerationFilter.IncludeUncollectables = includeUncollectablesToggle.isOn;
GenerationFilter.IsUnique = isUnique.isOn;
if (!string.IsNullOrWhiteSpace(numToGenerateInput.text) && numToGenerateInput.text != "0")
{
GenerationFilter.NumToGenerate = Mathf.Max(1, int.Parse(numToGenerateInput.text));
}
else
{
GenerationFilter.NumToGenerate = 1;
}
//Applies the dropdown filter to each of the relevant dropdowns
ApplyDropdownFilter <Classes.ClassList>(classDropdown, GenerationFilter);
ApplyDropdownFilter <Tags>(tagDropdown, GenerationFilter);
ApplyDropdownFilter <CardResources>(resourceDropdown, GenerationFilter);
ApplyDropdownFilter <CardTypes>(typeDropdown, GenerationFilter);
if (int.TryParse(modifyCostInput.text, out int result) && modifyCostInput.text != "0")
{
GenerationFilter.CostModification = result;
if (modifyCostDropdown.captionText.text == MODIFY_COST_DEFAULT_DROPDOWN_STRING)
{
GenerationFilter.ResourceModification = null;
}
else
{
GenerationFilter.ResourceModification = (CardResources)Enum.Parse(typeof(CardResources), modifyCostDropdown.captionText.text);
}
}
else
{
GenerationFilter.CostModification = null;
GenerationFilter.ResourceModification = null;
}
//If the card type is a unit, constructs the enchantment and adds it to the filter for generation
if (GenerationFilter.CardType == CardTypes.Unit)
{
var enchantment = new UnitEnchantment()
{
Status = UnitEnchantment.EnchantmentStatus.Permanent, Source = createdByInput.text
};
GetStatModifier(enchantment, Unit.StatTypes.Attack, attackModTypeDropdown, attackValueInput);
GetStatModifier(enchantment, Unit.StatTypes.MaxHealth, healthModTypeDropdown, healthValueInput);
GetStatModifier(enchantment, Unit.StatTypes.Range, rangeModTypeDropdown, rangeValueInput);
GetStatModifier(enchantment, Unit.StatTypes.Speed, speedModTypeDropdown, speedValueInput);
GetStatModifier(enchantment, Unit.StatTypes.Empowered, empoweredModTypeDropdown, empoweredValueInput);
if (enchantment.ValidEnchantment)
{
GenerationFilter.Enchantment = enchantment;
}
}
ClearEnchantmentFields();
//Attempts the generation of cards. For deck generation, includes the position to place the generated card
bool successfulGeneration;
if (CardGenerationType == CardGenerationTypes.Deck)
{
var position = (DeckPositions)Enum.Parse(typeof(DeckPositions), positionDropdown.captionText.text);
successfulGeneration = CardFunctionUI.ConfirmCardGeneration(GenerationFilter, isChoice.isOn, createdByInput.text, position);
}
else
{
successfulGeneration = CardFunctionUI.ConfirmCardGeneration(GenerationFilter, isChoice.isOn, createdByInput.text);
}
//If failed the generation, displays this in the title
if (!successfulGeneration)
{
titleText.text = $"{defaultTitleText} (Failed)";
}
}
else
{
createdByInput.placeholder.color = new Color(0.8f, 0.0f, 0.0f, 0.5f);
titleText.text = $"{defaultTitleText} (Input Created By)";
}
}
