public SpellElement ChooseElement()
{
List <SpellElement> elements = new List <SpellElement>();
if (modifiers.fieryModifier)
{
elements.Add(SpellElement.Fiery);
}
if (modifiers.frostModifier)
{
elements.Add(SpellElement.Frost);
}
if (modifiers.holyModifier)
{
elements.Add(SpellElement.Holy);
}
if (modifiers.crimsonModifier)
{
elements.Add(SpellElement.Crimson);
}
if (modifiers.corruptModifier)
{
elements.Add(SpellElement.Corrupt);
}
if (elements.Count > 0)
{
return(Element = elements[Main.rand.Next(elements.Count)]);
}
return(SpellElement.None);
}
//get rock paper scissor damage multiplier
public static float spellResistanceMultiplier(GameObject player, SpellElement spellElem)
{
Transform defensiveSpell;
SpellProperties properties;
DefensiveSpellBehaviour dSpellBehave;
if(defensiveSpell = player.transform.Find("defensiveSpell")){
properties = defensiveSpell.GetComponent<SpellProperties>();
dSpellBehave = defensiveSpell.GetComponent<DefensiveSpellBehaviour>();
switch(properties.spellElem){
case SpellElement.fire:
if(spellElem == SpellElement.earth)
return dSpellBehave.strongAgainstMultiplier;
else if(spellElem == SpellElement.water)
return dSpellBehave.weakAgainstMultiplier;
else
return 1.0f;
case SpellElement.water:
if(spellElem == SpellElement.fire)
return dSpellBehave.strongAgainstMultiplier;
else if(spellElem == SpellElement.earth)
return dSpellBehave.weakAgainstMultiplier;
else
return 1.0f;
case SpellElement.earth:
if(spellElem == SpellElement.water)
return dSpellBehave.strongAgainstMultiplier;
else if(spellElem == SpellElement.fire)
return dSpellBehave.weakAgainstMultiplier;
else
return 1.0f;
}
}
return 1.0f;
}
public void RunSpell(Player player, Vector2 position, Item item, Vector2 originalVelocity, float shootSpeed, int damage, float knockBack)
{
int totalImportantRuns = getTotalEffectImportantRuns();
if (totalImportantRuns >= 1)
{
for (int i = 0; i <= totalImportantRuns; i++)
{
DoEffect(player, position, item, originalVelocity, shootSpeed, damage, knockBack, i, totalImportantRuns);
}
}
else
{
DoEffect(player, position, item, originalVelocity, shootSpeed, damage, knockBack, 0, 0);
}
if (Style == SpellStyle.Default || Style == SpellStyle.HoldRelease)
{
player.statMana -= getTotalManaCost(player);
}
else
{
player.statMana -= getTotalManaCost(player, getChargePercentage());
}
cooldown = getTotalCooldown();
chargeProgress = 0;
Element = SpellElement.None;
}
public void TakeDamage(int baseAmount, SpellElement damageType)
{
damageable.TakeDamage(ComputeDamage(baseAmount, damageType));
if (damageType == SpellElement.Ice)
{
remainingSlowSeconds = 5f;
}
}
public Spell(SpellType type, SpellElement element, SpellEffect[] effects, String name, String description)
{
this.type = type;
this.element = element;
this.effects = effects;
this.name = name;
this.description = description;
}
public ISpell Get(SpellElement element)
{
if (spells.ContainsKey(element))
{
return(spells[element]);
}
return(noneSpell);
}
public Basic_spell(byte cost, string name, string _description, SpellTypes type, SpellElement elem)
{
spellCost = cost;
spellName = name;
description = _description;
spellType = type;
spellElem = elem;
}
public virtual void OnSetType(SpellVisuals spellVisuals)
{
SpellElement t = BattleManager.GetResourcesManager().typeElement;
SpellVisualsProperties type = spellVisuals.GetProperty(t);
type.textUI.text = typeName;
}
public void TakeDamage(int baseAmount, SpellElement damageType)
{
int damage = ComputeDamage(baseAmount, damageType);
if (damage > 0)
{
GameManager.S.Audio.AttackShield(audioSource);
damageable.TakeDamage(damage);
}
}
//Separation between takedamage and compute damage important because on taking/receiving damage,
//computing the damage is only one of many things that could happen.
private int ComputeDamage(int baseAmount, SpellElement damageType)
{
int amount = baseAmount;
if (affinity != SpellElement.None && damageType == affinity)
{
amount = Mathf.RoundToInt(amount * resistanceMultiplier);
}
return(amount);
}
//multiply damage if offensive spell type is defensive spell type
public static float spellDamageMultiplier(GameObject player, SpellElement spellElem)
{
Transform defensiveSpell;
SpellProperties properties;
DefensiveSpellBehaviour dSpellBehave;
if(defensiveSpell = player.transform.Find("defensiveSpell")){
properties = defensiveSpell.GetComponent<SpellProperties>();
if(properties.spellElem == spellElem){
dSpellBehave = defensiveSpell.GetComponent<DefensiveSpellBehaviour>();
return dSpellBehave.damageMultiplier;
}
}
return 1.0f;
}
private string GetElementalResist(SpellElement elementalResist)
{
if (elementalResist == SpellElement.None)
{
return("");
}
if (elementalResist == SpellElement.All)
{
return("All");
}
var list = new List <SpellElement>();
if (elementalResist.HasFlag(SpellElement.Earth))
{
list.Add(SpellElement.Earth);
}
if (elementalResist.HasFlag(SpellElement.Lightning))
{
list.Add(SpellElement.Lightning);
}
if (elementalResist.HasFlag(SpellElement.Ice))
{
list.Add(SpellElement.Ice);
}
if (elementalResist.HasFlag(SpellElement.Fire))
{
list.Add(SpellElement.Fire);
}
if (elementalResist.HasFlag(SpellElement.Death))
{
list.Add(SpellElement.Death);
}
if (elementalResist.HasFlag(SpellElement.Time))
{
list.Add(SpellElement.Time);
}
if (elementalResist.HasFlag(SpellElement.Poison))
{
list.Add(SpellElement.Poison);
}
if (elementalResist.HasFlag(SpellElement.Status))
{
list.Add(SpellElement.Status);
}
return(string.Join(", ", list));
}
public SpellVisualsProperties GetProperty(SpellElement e)
{
SpellVisualsProperties result = null;
for (int i = 0; i < properties.Count; i++)
{
if (properties[i].element == e)
{
result = properties[i];
break;
}
}
return(result);
}
private Spell HeavySpell(bool left)
{
Spell spell = null;
SpellElement element = left ? elementLeft : elementRight;
switch (element)
{
case SpellElement.FIRE:
if (timers[1] <= 0)
{
spell = Instantiate(heavyFire);
timers[1] = heavyFire.cooldown;
}
break;
case SpellElement.WATER:
if (timers[4] <= 0)
{
spell = Instantiate(heavyWater);
timers[4] = heavyWater.cooldown;
}
break;
case SpellElement.EARTH:
if (timers[7] <= 0)
{
spell = Instantiate(heavyEarth);
timers[7] = heavyEarth.cooldown;
}
break;
case SpellElement.AIR:
if (timers[10] <= 0)
{
spell = Instantiate(heavyAir);
timers[10] = heavyAir.cooldown;
}
break;
}
return(spell);
}
//Functions for dealing with the spell types
private Spell QuickSpell(bool left)
{
Spell spell = null;
SpellElement element = left ? elementLeft : elementRight;
switch (element)
{
case SpellElement.FIRE:
if (timers[0] <= 0)
{
spell = Instantiate(quickFire);
timers[0] = quickFire.cooldown;
}
break;
case SpellElement.WATER:
if (timers[3] <= 0)
{
spell = Instantiate(quickWater);
timers[3] = quickWater.cooldown;
}
break;
case SpellElement.EARTH:
if (timers[6] <= 0)
{
spell = Instantiate(quickEarth);
timers[6] = quickEarth.cooldown;
}
break;
case SpellElement.AIR:
if (timers[9] <= 0)
{
spell = Instantiate(quickAir);
timers[9] = quickAir.cooldown;
}
break;
}
return(spell);
}
private Spell SpecialSpell(bool left)
{
Spell spell = null;
SpellElement element = left ? elementLeft : elementRight;
switch (element)
{
case SpellElement.FIRE:
if (timers[2] <= 0)
{
spell = Instantiate(specialFire);
timers[2] = specialFire.cooldown;
}
break;
case SpellElement.WATER:
if (timers[5] <= 0)
{
spell = Instantiate(specialWater);
timers[5] = specialWater.cooldown;
}
break;
case SpellElement.EARTH:
if (timers[8] <= 0)
{
spell = Instantiate(specialEarth);
timers[8] = specialEarth.cooldown;
}
break;
case SpellElement.AIR:
if (timers[11] <= 0)
{
spell = Instantiate(specialAir);
timers[11] = specialAir.cooldown;
}
break;
}
return(spell);
}
public IEnumerable <(Spell Id, MagicSpell Info)> FindSpells(SpellRoutine routine, SpellTargeting targeting,
SpellElement element = SpellElement.Any,
SpellStatus status = SpellStatus.Any,
OOBSpellRoutine oobSpell = OOBSpellRoutine.None
)
{
IEnumerable <MagicSpell> foundSpells;
if (routine == SpellRoutine.Life)
{
foundSpells = SpellInfos.Where(s =>
(s.routine == SpellRoutine.CureAilment) &&
(s.targeting == targeting || targeting == SpellTargeting.Any) &&
(s.effect == (byte)SpellStatus.Death));
}
else if (routine == SpellRoutine.Smoke)
{
foundSpells = SpellInfos.Where(s =>
(s.routine == SpellRoutine.CureAilment) &&
(s.targeting == targeting || targeting == SpellTargeting.Any) &&
(s.effect == 0));
}
else if (routine == SpellRoutine.InflictStatus || routine == SpellRoutine.PowerWord || routine == SpellRoutine.CureAilment)
{
foundSpells = SpellInfos.Where(s =>
(s.routine == routine) &&
(s.targeting == targeting || targeting == SpellTargeting.Any) &&
(s.elem == element || element == SpellElement.Any) &&
(s.effect == (byte)status || status == SpellStatus.Any));
}
else
{
foundSpells = SpellInfos.Where(s =>
(s.routine == routine) &&
(s.targeting == targeting || targeting == SpellTargeting.Any) &&
(s.elem == element || element == SpellElement.Any) &&
(s.oobSpellRoutine == oobSpell || oobSpell == OOBSpellRoutine.None));
}
return(foundSpells.Select(s => ((Spell)Convert.ToByte((int)Spell.CURE + s.Index), s)).ToList());
}
private void Start()
{
//Randomly pick a spell type affinity and set forcefield color accordingly
if (affinity == SpellElement.None)
{
int i = Random.Range(0, 2);
if (i == 0)
{
affinity = SpellElement.Fire;
Color col = Color.red;
col.a = 0.7f;
GetComponent <Renderer>().material.SetColor("_MainColor", col);
}
else if (i == 1)
{
affinity = SpellElement.Ice;
Color col = Color.blue;
col.a = 0.7f;
GetComponent <Renderer>().material.SetColor("_MainColor", col);
}
}
}
public void TakeDamage(int baseAmount, SpellElement damageType)
{
int damage = ComputeDamage(baseAmount, damageType);
//Have Obelisk's light fade as it loses health
float H;
float S;
float V = colorIntensity;
float not_used;
Color col = transform.GetChild(0).GetChild(1).GetComponent <Renderer>().material.GetColor("_EmissionColor");
Color.RGBToHSV(col, out H, out S, out not_used);
Color newCol = Color.HSVToRGB(H, S, V);
transform.GetChild(0).transform.GetChild(1).GetComponent <Renderer>().material.SetColor("_EmissionColor", newCol);
if (damage > 0)
{
GameManager.S.Audio.AttackObelisk(audioSource);
damageable.TakeDamage(damage);
}
}
public static Color SetupColor(Color defaultColor, SpellElement Element)
{
switch (Element)
{
case (SpellElement.None):
{
return(defaultColor);
}
case (SpellElement.Fiery):
{
return(new Color(255, 142, 47));
}
case (SpellElement.Frost):
{
return(new Color(21, 144, 222));
}
case (SpellElement.Holy):
{
return(new Color(236, 83, 179));
}
case (SpellElement.Corrupt):
{
return(new Color(181, 255, 56));
}
case (SpellElement.Crimson):
{
return(new Color(255, 47, 47));
}
}
return(defaultColor);
}
public static int GetDust(int value, int defaultDust, SpellElement Element)
{
switch (Element)
{
case (SpellElement.None):
{
return(defaultDust);
}
case (SpellElement.Fiery):
{
return(fireDusts[value]);
}
case (SpellElement.Frost):
{
return(frostDusts[value]);
}
case (SpellElement.Holy):
{
return(holyDusts[value]);
}
case (SpellElement.Corrupt):
{
return(corruptDusts[value]);
}
case (SpellElement.Crimson):
{
return(crimsonDusts[value]);
}
}
return(0);
}
// set the element type of the spell
//and update the material used by the renderer
void setSpellProperties(Dictionary<int, object> spellParams)
{
parent = (Transform)spellParams[(int)SpellParameter.parent];
spellType = (SpellType)spellParams[(int)SpellParameter.type];
spellElem = (SpellElement)spellParams[(int)SpellParameter.element];
if(spellType == SpellType.offensive){
spellDamage *= (float)spellParams[(int)SpellParameter.damageMultiplier];
gameObject.name = "offensiveSpell";
oSpellBehave.enabled = true;
renderer.material = spellMat[(int)spellElem];
trail.renderer.material = trailMat[(int)spellElem];
Destroy(dSpellBehave);
//Defensice spell
}else{
gameObject.name = "defensiveSpell";
dSpellBehave.enabled = true;
renderer.enabled = false;
transform.parent = parent;
Destroy(oSpellBehave);
Destroy(trail);
}
}
private void SelectSpell(ISpellGesture gesture)
{
//Extract element and tier from the gesture
SpellElement?elem = gesture.Element;
SpellTier? tier = gesture.Tier;
//If elem/tier exist, store their value
SpellElement = elem.GetValueOrDefault(SpellElement);
SpellTier = tier.GetValueOrDefault(SpellTier);
//If an element and tier have been selected, transition to the Adjust state
if (SpellElement != SpellElement.None && SpellTier != SpellTier.None)
{
foreach (Spell spellPrefab in spellPrefabs)
{
if (spellPrefab.Element == SpellElement && spellPrefab.Tier == SpellTier)
{
CurrentSpell = Instantiate(spellPrefab, gesture.AttachmentPoint);
State = SpellCastingState.Adjust;
AdjustSpell(gesture);
break;
}
}
if (CurrentSpell == null)
{
Debug.LogWarningFormat(
"No spell prefab found for (Element, Tier) = ({0}, {1})",
SpellElement.ToString(), SpellTier.ToString()
);
SpellElement = SpellElement.None;
SpellTier = SpellTier.None;
}
}
}
private void AddElement(Armor a, SpellElement e, List <SpellElement> elements)
{
a.ElementalResist |= (byte)e;
elements.Remove(e);
allElements.Remove(e);
}
public List <SpellConfig> GetUnlockedSpellsByElement(SpellElement element)
{
return(SpellCategories.FirstOrDefault(c => c.Element == element)?.Spells.Where(d => d.IsUnlocked).ToList());
}
//set spell properties based off passed gesture
void handleGesture(GestureEnum gest)
{
if(gest == GestureEnum.V_DOWN){
elem = SpellElement.earth;
type = SpellType.invalid;
}else if(gest == GestureEnum.V_UP){
elem = SpellElement.fire;
type = SpellType.invalid;
}else if(gest == GestureEnum.SQUARE){
elem = SpellElement.water;
type = SpellType.invalid;
}else if(gest == GestureEnum.HORIZONTAL_LINE)
type = SpellType.offensive;
else if(gest == GestureEnum.VERTICAL_LINE)
type = SpellType.defensive;
if(elem != SpellElement.invalid){
ui.SetEquippedSpell(elem);
if(type != SpellType.invalid)
castSpell();
}
}
//spell data
void clearSpellData()
{
elem = SpellElement.invalid;
type = SpellType.invalid;
}
private int ComputeDamage(int baseAmount, SpellElement damageType)
{
int amount = baseAmount;
return(amount);
}
public void TakeDamage(int baseAmount, SpellElement damageType)
{
damageable.TakeDamage(ComputeDamage(baseAmount, damageType));
}
public SpellEffectInstance(SpellEffect spellEffect)
{
this.spellEffect = spellEffect;
Element = spellEffect.ChooseElement();
}
public static void SpellEffectHit(NPC target, Player player, int damage, float potency, SpellElement Element)
{
switch (Element)
{
case (SpellElement.None):
{
break;
}
case (SpellElement.Fiery):
{
target.AddBuff(BuffID.OnFire, (int)(10 * damage * potency));
break;
}
case (SpellElement.Frost):
{
target.AddBuff(BuffID.Frostburn, (int)(10 * damage * potency));
break;
}
case (SpellElement.Holy):
{
int mana = (int)(damage / 10 * potency);
player.ManaEffect(mana);
player.statMana += mana;
target.AddBuff(BuffID.Confused, (int)(10 * damage * potency));
break;
}
case (SpellElement.Corrupt):
{
target.AddBuff(BuffID.CursedInferno, (int)(20 * damage * potency));
break;
}
case (SpellElement.Crimson):
{
target.AddBuff(BuffID.Ichor, (int)(20 * damage * potency));
break;
}
}
}
public void TakeDamage(int baseDamage, SpellElement damageType)
{
onHit.Invoke();
}
public void Add(SpellElement element, ISpell spell)
{
spells.Add(element, spell);
}
public List <SpellConfig> GetByElement(SpellElement element)
{
return(SpellCategories.FirstOrDefault(c => c.Element == element)?.Spells);
}
