static void LoadData()
{
spellEffects = new List <ItemEffect>();
List <ItemEffectDto> spellEffectDtos = CsvData.Get <ItemEffectDto>(Folders.InCoreData("DnD - SpellEffects.csv"), false);
foreach (ItemEffectDto itemEffect in spellEffectDtos)
{
SpellEffects.Add(ItemEffect.From(itemEffect));
}
}
// Unity
private void Awake()
{
if (Instance != null)
{
Debug.LogError("More than one spell effects instance");
Destroy(this);
return;
}
Instance = this;
}
public static SpellCheckCastResult InvokeHandler(SpellEffects command, SpellCast Spell, List <WorldObject> Targets, int Index, Item Item)
{
if (EffectHandlers.ContainsKey(command))
{
return(EffectHandlers[command] != null ? EffectHandlers[command].Invoke(Spell, Targets, Index, Item) : SpellCheckCastResult.SPELL_CAST_OK);
}
else
{
return(SpellCheckCastResult.SPELL_FAILED_ERROR);
}
}
private Card[] makeHand(Player p)
{
spaceType = GameController.Game.board.GetSpaceAt(p.avatar.transform.position).Type;
return(new Card[] {
//come up with better names
new AxisCard("Ink & Loyalty", 0, p, this, SpellEffects.Resources, "Gain 1 ink per turn.\nGain 1 loyalty."),
new AxisCard("Fresh Ink", 0, p, this, (Player _p, Space s) => SpellEffects.AltResources(_p), "Gain 1 ink.\nGain 1 ink per turn"),
new AxisCard("Pillar", 5, p, this, SpellEffects.Pillar, "This Inkwell becomes a Pillar."),
getFactionCard(spaceType, p)
});
}
public static SpellFailedReason InvokeHandler(SpellEffects command, SpellCast Spell, List <WorldObject> Targets, int Index, Item Item)
{
if (EffectHandlers.ContainsKey(command))
{
return(EffectHandlers[command] != null ? EffectHandlers[command].Invoke(Spell, Targets, Index, Item) : SpellFailedReason.SPELL_FAILED_NO_REASON);
}
else
{
return(SpellFailedReason.SPELL_FAILED_ERROR);
}
}
protected TargetCard(XmlNode xml, Player p) :
base(xml, p)
{
if (xml.Attributes["effect"] != null)
{
effect = SpellEffects.GetMethod(typeof(Target), xml.Attributes["effect"].Value) as Target;
}
if (xml.Attributes["pred"] != null)
{
pred = SpellEffects.GetMethod(typeof(TargetPred), xml.Attributes["pred"].Value) as TargetPred;
}
}
public override bool Wound(Character c = null)
{
//"dealling n+'th wound => pillar" game rule
if (c != null && Wounds >= woundsToDead - 1 && GameController.Game.StructureAtPos(c.transform.position) == null)
{
// weird code
SpellEffects.Pillar(c.Card.Owner, GameController.Game.board.GetSpaceAt(c.transform.position));
Wounds = 0;
// /weird code
}
return(base.Wound(c));
}
public bool HasEffect(SpellEffects effect)
{
for (var i = 0; i < SharedConst.MaxSpellEffects; ++i)
{
if (Effects[i] == null)
{
continue;
}
if (Effects[i].IsEffect(effect))
{
return(true);
}
}
return(false);
}
private Card getFactionCard(Space.Types t, Player p)
{
//returns the special axis card ascociated with the given space
switch (t)
{
case Space.Types.DEAD:
return(new AxisCard("Devotion", 0, p, this, (Player q, Space s) => q.GainLoyalty(Card.Factions.EIR, 2), "Gain 2 loyalty.", 2, Card.Factions.EIR));
case Space.Types.WATER:
return(new AxisCard("Ink Stream", 0, p, this, (Player q, Space s) => q.GainMana(3), "Gain 3 ink.", 2, Card.Factions.SALT));
case Space.Types.NATURE:
return(new AxisCard("Shroud", 0, p, this, (Player q, Space s) => SpellEffects.ConjureFog(s.transform.position), "Give this space fog.", 2, Card.Factions.WHITE));
case Space.Types.COLD:
return(new AxisCard("Survey", 2, p, this, (Player q, Space s) => q.Draw(2), "Draw 2 cards.", 3, Card.Factions.DRA));
}
return(null);
}
private Card SpellSetup(SpellCardData data)
{
SpellCard card = Instantiate(spellCardPrefab, MainCanvas.Instance.transform).GetComponent <SpellCard>();
card.BaseGoldCost = -1;
card.effects = data.effects;
SpellEffects effs = card.gameObject.AddComponent(data.effects.GetType()) as SpellEffects;
effs.card = card;
if (effs == null)
{
return(card);
}
card.onInitilization = effs.OnInitilization;
// regist effects
if (effs.OnMoveToCardPile != null)
{
card.E_AddedToCardPile += effs.OnMoveToCardPile;
}
return(card);
}
public Dictionary <WorldObject, SpellMissInfo> CalculateMisses(WorldObject Caster, List <WorldObject> Targets, SpellEffects SpellEffect)
{
Dictionary <WorldObject, SpellMissInfo> newTargets = new Dictionary <WorldObject, SpellMissInfo>();
foreach (WorldObject Target in Targets)
{
if (Target == Caster && Caster.IsTypeOf(ObjectTypes.TYPE_UNIT) && Target.IsTypeOf(ObjectTypes.TYPE_UNIT))
{
var _with1 = Target;
switch (SchoolMask)
{
case SpellSchoolMask.SPELL_SCHOOL_MASK_NONE:
newTargets.Add(Target, SpellMissInfo.MISS_NONE);
break;
case SpellSchoolMask.SPELL_SCHOOL_MASK_MAGIC:
newTargets.Add(Target, SpellMissInfo.MISS_NONE); // _with1.GetMagicSpellHitResult(Caster, this));
break;
case SpellSchoolMask.SPELL_SCHOOL_MASK_NORMAL:
newTargets.Add(Target, SpellMissInfo.MISS_NONE); //_with1.GetMeleeSpellHitResult(Caster, this));
break;
}
}
else
{
newTargets.Add(Target, SpellMissInfo.MISS_NONE);
}
}
return(newTargets);
}
private void AuraModTypeName(int index)
{
AuraType aura = (AuraType)spell.EffectApplyAuraName[index];
int misc = spell.EffectMiscValue[index];
if (spell.EffectApplyAuraName[index] == 0)
{
SpellEffects effect = (SpellEffects)spell.Effect[index];
switch (effect)
{
case SpellEffects.SPELL_EFFECT_ACTIVATE_RUNE:
rtb.AppendFormatLine("EffectMiscValueA ={0} ({1})", misc, (RuneType)misc);
break;
case SpellEffects.SPELL_EFFECT_DISPEL_MECHANIC:
rtb.AppendFormatLine("EffectMiscValueA ={0} ({1})", misc, (Mechanics)misc);
break;
case SpellEffects.SPELL_EFFECT_ENERGIZE:
case SpellEffects.SPELL_EFFECT_ENERGIZE_PCT:
case SpellEffects.SPELL_EFFECT_POWER_DRAIN:
rtb.AppendFormatLine("EffectMiscValueA ={0} ({1})", misc, (Powers)misc);
break;
case SpellEffects.SPELL_EFFECT_DISPEL:
rtb.AppendFormatLine("EffectMiscValueA ={0} ({1})", misc, (DispelType)misc);
break;
case SpellEffects.SPELL_EFFECT_OPEN_LOCK:
rtb.AppendFormatLine("EffectMiscValueA ={0} ({1})", misc, (LockType)misc);
break;
default:
rtb.AppendFormatLineIfNotNull("EffectMiscValueA = {0}", spell.EffectMiscValue[index]);
break;
}
rtb.AppendFormatLineIfNotNull("EffectMiscValueB = {0}", spell.EffectMiscValueB[index]);
rtb.AppendFormatLineIfNotNull("EffectAmplitude = {0}", spell.EffectAmplitude[index]);
return;
}
rtb.AppendFormat("Aura Id {0:D} ({0})", aura);
rtb.AppendFormat(", value = {0}", spell.EffectBasePoints[index] + 1);
rtb.AppendFormat(", misc = {0} (", misc);
switch (aura)
{
case AuraType.SPELL_AURA_MOD_STAT:
case AuraType.SPELL_AURA_MOD_PERCENT_STAT:
case AuraType.SPELL_AURA_MOD_TOTAL_STAT_PERCENTAGE:
case AuraType.SPELL_AURA_MOD_SPELL_HEALING_OF_STAT_PERCENT:
case AuraType.SPELL_AURA_MOD_RANGED_ATTACK_POWER_OF_STAT_PERCENT:
case AuraType.SPELL_AURA_MOD_MANA_REGEN_FROM_STAT:
case AuraType.SPELL_AURA_MOD_ATTACK_POWER_OF_STAT_PERCENT:
rtb.Append((UnitMods)misc);
break;
case AuraType.SPELL_AURA_MOD_RATING:
case AuraType.SPELL_AURA_MOD_RATING_FROM_STAT:
rtb.Append((CombatRating)misc);
break;
case AuraType.SPELL_AURA_MOD_DAMAGE_DONE:
case AuraType.SPELL_AURA_MOD_DAMAGE_TAKEN:
case AuraType.SPELL_AURA_MOD_DAMAGE_PERCENT_DONE:
case AuraType.SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN:
case AuraType.SPELL_AURA_MOD_SPELL_DAMAGE_OF_STAT_PERCENT:
case AuraType.SPELL_AURA_SHARE_DAMAGE_PCT:
case AuraType.SPELL_AURA_MOD_SPELL_DAMAGE_OF_ATTACK_POWER:
case AuraType.SPELL_AURA_MOD_AOE_DAMAGE_AVOIDANCE:
case AuraType.SPELL_AURA_SPLIT_DAMAGE_PCT:
case AuraType.SPELL_AURA_DAMAGE_IMMUNITY:
case AuraType.SPELL_AURA_MOD_CRIT_DAMAGE_BONUS:
case AuraType.SPELL_AURA_MOD_ATTACKER_MELEE_CRIT_DAMAGE:
case AuraType.SPELL_AURA_MOD_ATTACKER_RANGED_CRIT_DAMAGE:
case AuraType.SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_DAMAGE:
case AuraType.SPELL_AURA_MOD_HEALING:
case AuraType.SPELL_AURA_MOD_HEALING_PCT:
case AuraType.SPELL_AURA_MOD_HEALING_DONE:
case AuraType.SPELL_AURA_MOD_HEALING_DONE_PERCENT:
case AuraType.SPELL_AURA_MOD_DAMAGE_FROM_CASTER:
case AuraType.SPELL_AURA_MOD_HEALING_RECEIVED:
case AuraType.SPELL_AURA_MOD_PERIODIC_HEAL:
case AuraType.SPELL_AURA_MOD_SPELL_HEALING_OF_ATTACK_POWER:
case AuraType.SPELL_AURA_MOD_RESISTANCE:
case AuraType.SPELL_AURA_MOD_BASE_RESISTANCE:
case AuraType.SPELL_AURA_MOD_RESISTANCE_PCT:
case AuraType.SPELL_AURA_MOD_TARGET_RESISTANCE:
case AuraType.SPELL_AURA_MOD_BASE_RESISTANCE_PCT:
case AuraType.SPELL_AURA_MOD_RESISTANCE_EXCLUSIVE:
case AuraType.SPELL_AURA_MOD_RESISTANCE_OF_STAT_PERCENT:
case AuraType.SPELL_AURA_MOD_ATTACKER_SPELL_CRIT_CHANCE:
case AuraType.SPELL_AURA_MOD_ATTACKER_SPELL_HIT_CHANCE:
case AuraType.SPELL_AURA_MOD_INCREASES_SPELL_PCT_TO_HIT:
case AuraType.SPELL_AURA_SCHOOL_IMMUNITY:
case AuraType.SPELL_AURA_SCHOOL_ABSORB:
case AuraType.SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL:
case AuraType.SPELL_AURA_MOD_POWER_COST_SCHOOL_PCT:
case AuraType.SPELL_AURA_MOD_POWER_COST_SCHOOL:
case AuraType.SPELL_AURA_REFLECT_SPELLS_SCHOOL:
case AuraType.SPELL_AURA_MOD_IGNORE_ABSORB_SCHOOL:
case AuraType.SPELL_AURA_MOD_IMMUNE_AURA_APPLY_SCHOOL:
case AuraType.SPELL_AURA_MOD_IGNORE_DAMAGE_REDUCTION_SCHOOL:
case AuraType.SPELL_AURA_MOD_IGNORE_ABSORB_FOR_SPELL:
case AuraType.SPELL_AURA_MOD_THREAT:
case AuraType.SPELL_AURA_MOD_CRITICAL_THREAT:
case AuraType.SPELL_AURA_REDUCE_PUSHBACK:
case AuraType.SPELL_AURA_MOD_PET_AOE_DAMAGE_AVOIDANCE:
case AuraType.SPELL_AURA_HASTE_SPELLS:
case AuraType.SPELL_AURA_MANA_SHIELD:
case AuraType.SPELL_AURA_MOD_CRITICAL_HEALING_AMOUNT:
rtb.Append((SpellSchoolMask)misc);
break;
case AuraType.SPELL_AURA_ADD_FLAT_MODIFIER:
case AuraType.SPELL_AURA_ADD_PCT_MODIFIER:
rtb.Append((SpellModOp)misc);
break;
case AuraType.SPELL_AURA_MOD_POWER_REGEN:
case AuraType.SPELL_AURA_MOD_POWER_REGEN_PERCENT:
case AuraType.SPELL_AURA_MOD_INCREASE_ENERGY_PERCENT:
case AuraType.SPELL_AURA_MOD_INCREASE_ENERGY:
case AuraType.SPELL_AURA_PERIODIC_ENERGIZE:
rtb.Append((Powers)misc);
break;
case AuraType.SPELL_AURA_MECHANIC_IMMUNITY:
case AuraType.SPELL_AURA_MOD_MECHANIC_RESISTANCE:
case AuraType.SPELL_AURA_MECHANIC_DURATION_MOD:
case AuraType.SPELL_AURA_MECHANIC_DURATION_MOD_NOT_STACK:
case AuraType.SPELL_AURA_MOD_MECHANIC_DAMAGE_TAKEN_PERCENT:
rtb.Append((Mechanics)misc);
break;
case AuraType.SPELL_AURA_MECHANIC_IMMUNITY_MASK:
rtb.Append(misc.FlagToString <Mechanics>().Replace("MECHANIC_", ""));
break;
case AuraType.SPELL_AURA_MOD_MELEE_ATTACK_POWER_VERSUS:
case AuraType.SPELL_AURA_MOD_RANGED_ATTACK_POWER_VERSUS:
case AuraType.SPELL_AURA_MOD_DAMAGE_DONE_VERSUS:
case AuraType.SPELL_AURA_MOD_CRIT_PERCENT_VERSUS:
case AuraType.SPELL_AURA_MOD_FLAT_SPELL_DAMAGE_VERSUS:
case AuraType.SPELL_AURA_MOD_DAMAGE_DONE_CREATURE:
rtb.Append((CreatureTypeMask)misc);
break;
case AuraType.SPELL_AURA_TRACK_CREATURES:
rtb.Append((CreatureTypeMask)((int)(1 << (misc - 1))));
break;
case AuraType.SPELL_AURA_DISPEL_IMMUNITY:
case AuraType.SPELL_AURA_MOD_DEBUFF_RESISTANCE:
case AuraType.SPELL_AURA_MOD_DURATION_OF_MAGIC_EFFECTS:
case AuraType.SPELL_AURA_MOD_DURATION_OF_EFFECTS_BY_DISPEL:
rtb.Append((DispelType)misc);
break;
case AuraType.SPELL_AURA_TRACK_RESOURCES:
rtb.Append((LockType)misc);
break;
case AuraType.SPELL_AURA_MOD_SHAPESHIFT:
rtb.Append((ShapeshiftFormMask)(1 << (misc - 1)));
break;
case AuraType.SPELL_AURA_EFFECT_IMMUNITY:
rtb.Append((SpellEffects)misc);
break;
case AuraType.SPELL_AURA_CONVERT_RUNE:
rtb.Append((RuneType)misc);
break;
case AuraType.SPELL_AURA_IGNORE_COMBAT_RESULT:
case AuraType.SPELL_AURA_MOD_COMBAT_RESULT_CHANCE:
rtb.Append((MeleeHitOutcome)misc);
break;
// todo: more case
default:
rtb.Append(misc);
break;
}
int miscB = spell.EffectMiscValueB[index];
rtb.AppendFormat("), miscB = {0}", miscB);
switch (aura)
{
case AuraType.SPELL_AURA_MOD_SPELL_DAMAGE_OF_STAT_PERCENT:
case AuraType.SPELL_AURA_MOD_RESISTANCE_OF_STAT_PERCENT:
case AuraType.SPELL_AURA_MOD_RATING_FROM_STAT:
rtb.AppendFormat("({0})", (UnitMods)miscB);
break;
case AuraType.SPELL_AURA_CONVERT_RUNE:
rtb.AppendFormat("({0})", (RuneType)miscB);
break;
}
rtb.AppendFormatLine(", periodic = {0}", spell.EffectAmplitude[index]);
switch (aura)
{
case AuraType.SPELL_AURA_OVERRIDE_SPELLS:
if (!DBC.OverrideSpellData.ContainsKey((uint)misc))
{
rtb.SetStyle(Color.Red, FontStyle.Bold);
rtb.AppendFormatLine("Cannot find key {0} in OverrideSpellData.dbc", (uint)misc);
}
else
{
rtb.AppendLine();
rtb.SetStyle(Color.DarkRed, FontStyle.Bold);
rtb.AppendLine("Overriding Spells:");
OverrideSpellDataEntry Override = DBC.OverrideSpellData[(uint)misc];
for (int i = 0; i < 10; ++i)
{
if (Override.Spells[i] == 0)
{
continue;
}
rtb.SetStyle(Color.DarkBlue, FontStyle.Regular);
rtb.AppendFormatLine("\t - #{0} ({1}) {2}", i + 1, Override.Spells[i],
DBC.Spell.ContainsKey(Override.Spells[i]) ? DBC.Spell[Override.Spells[i]].SpellName : "?????");
}
rtb.AppendLine();
}
break;
case AuraType.SPELL_AURA_SCREEN_EFFECT:
rtb.SetStyle(Color.DarkBlue, FontStyle.Bold);
rtb.AppendFormatLine("ScreenEffect: {0}",
DBC.ScreenEffect.ContainsKey((uint)misc) ? DBC.ScreenEffect[(uint)misc].Name : "?????");
break;
default:
break;
}
}
public bool IsEffect(SpellEffects effectName)
{
return(Effect == (uint)effectName);
}
public void Start()
{
AMa = GameObject.Find("AudioManager").GetComponent <AudioManager>();
SpEf = GameObject.Find("Player").GetComponent <SpellEffects>();
}
public static void DefineEffect(SpellEffects command, SpellEffectHandler handler)
{
EffectHandlers[command] = handler;
}
public bool HasEffect(SpellEffects effect)
{
return(Effects.Where(eff => eff != null && eff.Type == (uint)effect).Count() > 0);
}
public bool HasEffect(SpellEffects effect)
{
return(Effects.Any(eff => eff != null && eff.Effect == (uint)effect));
}
void ReadSpellLogExecute()
{
Output.AppendLine("Caster: " + Reader.ReadPackedGuid());
Output.AppendLine("Spell ID: " + Reader.ReadInt32());
int count = Reader.ReadInt32();
Output.AppendLine("Effect count: " + count);
for (int i = 0; i < count; ++i)
{
SpellEffects effect = (SpellEffects)Reader.ReadInt32();
Output.AppendLine("Spell Effect: " + effect);
int hitCount = Reader.ReadInt32();
for (int c = 0; c < hitCount; ++c)
{
switch (effect)
{
case SpellEffects.PowerDrain:
case SpellEffects.PowerBurn:
Output.AppendLine("Target: " + Reader.ReadPackedGuid());
Output.AppendLine("SpellID: " + Reader.ReadInt32());
Output.AppendLine("Unk2: " + Reader.ReadInt32());
Output.AppendLine("Unk3: " + Reader.ReadInt32());
break;
case SpellEffects.AddExtraAttacks:
case SpellEffects.InterruptCast:
Output.AppendLine("Target: " + Reader.ReadPackedGuid());
Output.AppendLine("SpellID: {0}" + Reader.ReadInt32());
break;
case SpellEffects.DurabilityDamage:
Output.AppendLine("Target: " + Reader.ReadPackedGuid());
Output.AppendLine("SpellID: " + Reader.ReadInt32());
Output.AppendLine("Unk3: " + Reader.ReadInt32());
break;
case SpellEffects.OpenLock:
Output.AppendLine("Target: " + Reader.ReadPackedGuid());
break;
case SpellEffects.CreateItem:
case SpellEffects.CreateRandomItem:
case SpellEffects.CreateItem2:
Output.AppendLine("ItemID: " + Reader.ReadInt32());
break;
case SpellEffects.Summon:
case SpellEffects.TransDoor:
case SpellEffects.SummonPet:
case SpellEffects.SummonObjectWild:
case SpellEffects.CreateHouse:
case SpellEffects.Duel:
case SpellEffects.SummonObjectSlot1:
case SpellEffects.Effect171:
Output.AppendLine("Summoned: " + Reader.ReadPackedGuid());
break;
case SpellEffects.FeedPet:
Output.AppendLine("EatID: " + Reader.ReadInt32());
break;
case SpellEffects.DismissPet:
Output.AppendLine("Pet: " + Reader.ReadPackedGuid());
break;
case SpellEffects.Resurrect:
case SpellEffects.ResurrectNew:
case SpellEffects.Effect172:
Output.AppendLine("Target: " + Reader.ReadPackedGuid());
break;
}
}
}
}
