public BloodFlow(IPlayer player, string args = null)
{
WeaponType = WeaponType.Blood;
SpellTypes.Add(typeof(Rupture));
// If Corruption(Gimmick) is > 60 we do a dot, dealing 0.36*CP/sec for 6 seconds.
// Causes next 4 blood attacks to deal additional 1.93 * CP extra.
}
public Flay()
{
WeaponType = WeaponType.Blood;
SpellTypes.Add(typeof(Maleficium));
BaseDamage = 0.11; // TODO: Make sure it's 0.11 BaseDamage and not 0.11 BaseDamageModifier...
ModelledInWeapon = true;
}
public PlayerSpell(int attackCount, int[] damage, float[] timeBtwAttack, DamageTypes[] damageType, SpellTypes type, SpellUseTypes useType, float timeToUse /*, int energyCost*/, float castTime, float cooldown, Vector2[] damageRange, Element element, Vector2[] forceDirection, float[] castDistance, float[] shellLifeTime)
{
this.attackCount = attackCount;
this.damage = damage;
this.timeBtwAttack = timeBtwAttack;
this.damageType = damageType;
this.type = type;
//this.energyCost = energyCost;
this.castTime = castTime;
this.cooldown = cooldown;
this.damageRange = damageRange;
this.element = element;
this.forceDirection = forceDirection;
this.castDistance = castDistance;
this.timeToUse = timeToUse;
this.useType = useType;
this.shellLifeTime = shellLifeTime;
icon = null;
waitingIcon = null;
castAnimation = null;
attackAnimations = null;
audioCast = null;
audioImpact = null;
audioAttacks = null;
particle = null;
spellPrefab = null;
shellClip = null;
}
public Superconductor(IPlayer player, string args = null)
{
WeaponType = WeaponType.Elemental;
SpellTypes.Add(typeof(Mjolnir));
//Mjolnir can't miss.
BaseDamageCritModifier = 0.32;
}
public HardenedBlade()
{
WeaponType = WeaponType.Blade;
SpellTypes.Add(typeof(SwallowCut));
ModelledInWeapon = true;
// Has 30% chance to not consume a spirit blade attackcharge when used.
}
public Passive3()
{
WeaponType = WeaponType.Hammer;
SpellTypes.Add(typeof(Spell1));
BaseDamageModifier = 1;
BaseDamageCritModifier = 2;
}
public EyeOfTheRuinStorm(IPlayer player, string args = null)
{
WeaponType = WeaponType.Chaos;
SpellTypes.Add(typeof(Weapons.Chaos.Singularity));
BaseDamage = 1.68;
// Singularity Base Damage increased to 4.35
}
public static int SpellNumber(SpellTypes s)
{
int num = Info(s).SpellNumber;
Debug.Assert(num >= MIN_SPELL_NUM && num <= MAX_SPELL_NUM);
return(num);
}
public Duality(IPlayer player, string args = null)
{
WeaponType = WeaponType.Chaos;
SpellTypes.Add(typeof(TumultousWhisper));
// If TumultousWHisper causes us to exceed 8 paradoxes... We get a Doppleganger();
// See chaos weapon modeling. (Weapons.Chaos.Doppleganger)
}
public void SetSpellCooldown(SpellTypes spell, TimeSpan cooldown)
{
var castInfo = SpellCastInfo(spell);
castInfo.Cooldown = cooldown;
castInfo.TimeLeft = cooldown;
}
public bool IsOnCooldown(SpellTypes spell)
{
TimeSpan lastUse = TimeOfLastSpellUse(spell);
return lastUse == TimeSpan.Zero ? false :
lastUse.TotalSeconds + SpellsHelper.Info(spell).Cooldown.TotalSeconds >
Server.Instance.GetTime().TotalSeconds;
}
public bool IsCastingSpell(ChampionTypes champ, PlayerActionType action)
{
SpellTypes spell = ChampionTypesHelper.GetSpellFromAction(champ, action);
return(TimeOfLastSpellUse(spell).TotalSeconds +
SpellsHelper.Info(spell).CastingTime.TotalSeconds >= Server.Instance.GetTime().TotalSeconds);
}
public Glaciate(IPlayer player, string args = null)
{
WeaponType = WeaponType.Elemental;
SpellTypes.Add(typeof(IceBeam));
//Attacks against the target with Ice Beam debuff ( 5seconds)
//Deal 0.5 * CP extra.
}
public KeenEdge()
{
WeaponType = WeaponType.Blade;
SpellTypes.Add(typeof(Hone));
BaseDamageCritModifier = 0.4;
// Adds 40% critpower buff during hone
}
public Outrage()
{
WeaponType = WeaponType.Hammer;
SpellTypes.Add(typeof(Seethe));
PrimaryGimmickGain = 38;
// Using Seethe generating 38 Rage
}
/// <summary>
/// Get animations for current spellcast.
/// This happens the first time a spell is cast and stored for re-casting.
/// It's likely player will use a wide variety of spell types in normal play.
/// </summary>
void SetCurrentAnims(SpellTypes spellType, int border = 0, bool dilate = false)
{
// Attempt to get current anims
if (castAnims.ContainsKey(spellType))
{
currentAnimType = spellType;
currentAnims = castAnims[spellType];
return;
}
// Load spellcast file
string filename = WeaponBasics.GetSpellAnimFilename(spellType);
string path = Path.Combine(DaggerfallUnity.Instance.Arena2Path, filename);
CifRciFile cifFile = new CifRciFile();
if (!cifFile.Load(path, FileUsage.UseMemory, true))
{
throw new Exception(string.Format("Could not load spell anims file {0}", path));
}
// Load CIF palette
cifFile.Palette.Load(Path.Combine(DaggerfallUnity.Instance.Arena2Path, cifFile.PaletteName));
// Load textures - spells have a single frame per record unlike weapons
Texture2D[] frames = new Texture2D[cifFile.RecordCount];
for (int record = 0; record < cifFile.RecordCount; record++)
{
Texture2D texture = null;
// Get Color32 array
DFSize sz;
Color32[] colors = cifFile.GetColor32(record, 0, 0, border, out sz);
// Dilate edges
if (border > 0 && dilate)
{
ImageProcessing.DilateColors(ref colors, sz);
}
// Create Texture2D
texture = new Texture2D(sz.Width, sz.Height, TextureFormat.RGBA32, false);
texture.SetPixels32(colors);
texture.Apply(true);
// Set filter mode and store in frames array
if (texture)
{
texture.filterMode = (FilterMode)DaggerfallUnity.Settings.MainFilterMode;
frames[record] = texture;
}
}
// Add frames array to dictionary
castAnims.Add(spellType, frames);
// Use as current anims
currentAnimType = spellType;
currentAnims = frames;
}
public Character(double level, double magic, SpellTypes spell, bool serenity)
{
_level = level;
_magic = magic;
_spell = spell;
_spellPower = (double)_spell;
_serenityMult = serenity ? SerenityBoost : NoSerenityBoost;
}
public FocusedFire()
{
WeaponType = WeaponType.Pistol;
SpellType = SpellType.Passive;
BaseDamageModifier = 3.47;
// If no matching chambers gain Double White, BaseDamage of Kill Blind increased to 3,47CP
SpellTypes.Add(typeof(KillBlind));
}
// TODO: Test
public BulletEcho()
{
WeaponType = WeaponType.Pistol;
SpellTypes.Add(typeof(Ricochet));
BaseDamage = 0.32;
PassiveBonusSpell = this;
// When Ricochet expires Pistol attacks chain to nearby enemies 0,32CP damage 4s duration
}
public PassiveBonusSpell()
{
WeaponType = WeaponType.Hammer;
SpellTypes.Add(typeof(Spell1));
BaseDamage = 0.81;
PassiveBonusSpell = this;
// Critical Hits with Dual Shot deal an additional 0,81CP BaseDamage
}
public ElementalForce(IPlayer player, string args = null)
{
WeaponType = WeaponType.Elemental;
SpellTypes.Add(typeof(Overload));
//Heat reduction increased by 10 (so total -40)
//Creates 0.42 * CP attack
//Creates 0.14 * CP dot for 6 seconds
}
public Annihilate()
{
WeaponType = WeaponType.Hammer;
SpellTypes.Add(typeof(EruptionRage));
BaseDamage = 7.12; // Damage increased to 12.72 * CombatPower Instead of 5.6 Base..
PrimaryGimmickCost = 50; // Total of 50
PrimaryGimmickGain = -7;
}
public Obliterate()
{
WeaponType = WeaponType.Hammer;
SpellTypes.Add(typeof(Demolish));
SpellTypes.Add(typeof(DemolishRage));
BaseDamageCritModifier = 0.35;
// +35% Demolish BaseDamage on crit
}
public Defilement()
{
WeaponType = WeaponType.Blood;
SpellTypes.Add(typeof(Desecrate));
ModelledInWeapon = true;
// Corrution gain during Desecrate is increased by 20%
// If at max corruption we gain 16.5% blood ability damage.
}
public UnerringAccuracy()
{
WeaponType = WeaponType.Rifle;
SpellTypes.Add(typeof(RedMist));
BaseDamageCritModifier = 0.68;
// Critical hits deal 68 % more damage
// TODO: Test and add: Can no longer glance or evade
}
public SlowBurn(IPlayer player, string args = null)
{
WeaponType = WeaponType.Rifle;
SpellTypes.Add(typeof(IncendiaryGrenade));
DotDuration = 3;
// TODO: Test
// Increasing duration to 11s from 8s
}
public Basic_spell(byte cost, string name, string _description, SpellTypes type, SpellElement elem)
{
spellCost = cost;
spellName = name;
description = _description;
spellType = type;
spellElem = elem;
}
public PointBlankShot()
{
WeaponType = WeaponType.Shotgun;
SpellTypes.Add(typeof(RagingShot));
BaseDamage = 0.58;
// TODO: Test and implement range???
// Increase damage to 4.00 to targets within 3m
}
public SalvageExpert()
{
WeaponType = WeaponType.Shotgun;
SpellTypes.Add(typeof(ShellSalvage));
SecondaryGain = 5;
// TODO: offer to reload the same type of shell
// Always offer to reload the same type of shell.
}
public bool IsOnCooldown(SpellTypes spell)
{
TimeSpan lastUse = TimeOfLastSpellUse(spell);
return(lastUse == TimeSpan.Zero ? false :
lastUse.TotalSeconds + SpellsHelper.Info(spell).Cooldown.TotalSeconds >
Server.Instance.GetTime().TotalSeconds);
}
public ExtendedMagazine()
{
WeaponType = WeaponType.Rifle;
SpellTypes.Add(typeof(FullAuto));
ChannelTicks = 1;
// TODO: Test
// Increase number of hits to 5 from 4
}
public void UsedSpell(SpellTypes spell)
{
float time = (float)Server.Instance.GetTime().TotalSeconds;
if (LastSpellUses.ContainsKey(spell))
LastSpellUses[spell] = time;
else
LastSpellUses.Add(spell, time);
}
public SpellTypes Combination(SpellTypes spell1, SpellTypes spell2){
int result = FSM.getCombination ((int)spell1, (int)spell2);
if (result == -1) // No existe esa combinación.
return SpellTypes.NULL;
SpellTypes parsedResult = (SpellTypes) result;
return parsedResult;
}
public ClientLinearSpell(ulong id, SpellTypes type, Vec2 pos, float time, Vec2 velocity, float range, float width)
{
ID = id;
Type = type;
StartingPosition = pos;
Position = StartingPosition;
Velocity = velocity;
Time = Math.Max(0f, (float)Client.Instance.GetTime().TotalSeconds - time);
Active = true;
Range = range;
Width = width;
}
public LinearSpell(ulong id, Teams team, Vec2 position, Vec2 target, SpellTypes type, ICharacter owner)
: base(id, position,
SpellsHelper.Info(type).Speed,
SpellsHelper.Info(type).Width, SpellsHelper.Info(type).Width)
{
Info = SpellsHelper.Info(type);
IsSolid = Info.Solid;
Type = type;
Velocity = Vec2.Normalize(target - position) * MoveSpeed;
StartPosition = (Vec2)position.Clone();
Team = team;
Owner = owner;
}
public static int SpellNumber(SpellTypes s)
{
int num = Info(s).SpellNumber;
Debug.Assert(num >= MIN_SPELL_NUM && num <= MAX_SPELL_NUM);
return num;
}
public static SpellInfo Info(SpellTypes s)
{
if (Spells.ContainsKey(s))
return Spells[s];
else {
ILogger.Log("Spell not implemented: " + s + ".");
return Spells[SpellTypes.ManMega_RocketRampage]; // just a default value that is not relevant
}
}
public Spell(SpellTypes spellType, string infoText, string pathToImage)
: base(infoText, pathToImage)
{
this.SpellType = spellType;
}
public SpellData(float engy, SpellResponseDelegate dDelegate)
{
ResetRally = false;
SpellType = SpellTypes.Normal;
EnergyCost = engy;
Function = dDelegate;
WoodCost = 0;
AppleCost = 0;
GlueCost = 0;
CastTime = 0;
SupplyCost = 0;
}
public void SetSpellCooldown(SpellTypes spell, TimeSpan cooldown)
{
var castInfo = SpellCastInfo(spell);
castInfo.Cooldown = cooldown;
castInfo.TimeLeft = cooldown;
}
private SpellCastInfo SpellCastInfo(SpellTypes spell)
{
int spellNum = SpellsHelper.SpellNumber(spell);
switch (spellNum) {
case SpellsHelper.SPELL_1: return Spell1;
case SpellsHelper.SPELL_2: return Spell2;
case SpellsHelper.SPELL_3: return Spell3;
case SpellsHelper.SPELL_4: return Spell4;
default:
throw new NotImplementedException("Spell number not supported.");
}
}
public SpellCastEventData(ulong id, ulong owner, SpellTypes type, float time, Vec2 pos,
Vec2 vel, TimeSpan cooldown, float range, float width)
: base(ServerCommand.SpellCast)
{
ID = id;
OwnerID = owner;
Type = type;
Time = time;
Position = pos;
Velocity = vel;
Cooldown = cooldown;
Range = range;
Width = width;
}
TimeSpan TimeOfLastSpellUse(SpellTypes spell)
{
return TimeSpan.FromSeconds(LastSpellUses.ContainsKey(spell) ? LastSpellUses[spell] : 0f);
}
private void addSpell(SpellTypes spell){
if (currentSpells.Count >= maxSpells) {
return;
}
currentSpells.Add (spell);
if (currentSpells.Count == 1) {
SkillGUIManager.Singleton.UpdateGraphics (currentSpells);
return;
}
int index = 0;
while (index < currentSpells.Count - 1) {
SpellTypes result = SpellManager.instance.Combination (currentSpells[index], currentSpells[index+1] );
if( result != SpellTypes.NULL){
currentSpells.RemoveAt(index);
currentSpells.RemoveAt(index);
currentSpells.Insert(index, result);
index = 0;
} else {
index++;
}
}
SkillGUIManager.Singleton.UpdateGraphics (currentSpells);
}
public GameObject getGraphic(SpellTypes Spell, SpellTypes Type){
switch (Spell) {
case SpellTypes.FIRE : {
if(Type == SpellTypes.SHIELD)
return Prefabs[3];
if(Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[0];
if (Type == SpellTypes.RAY)
return Prefabs[14];
break;
}
case SpellTypes.FIRE1 : {
if(Type == SpellTypes.SHIELD)
return Prefabs[3];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[1];
if (Type == SpellTypes.RAY)
return Prefabs[14];
break;
}
case SpellTypes.FIRE2 : {
if(Type == SpellTypes.SHIELD)
return Prefabs[3];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[2];
if (Type == SpellTypes.RAY)
return Prefabs[14];
break;
}
case SpellTypes.WATER : {
if(Type == SpellTypes.SHIELD)
return Prefabs[13];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[5];
if (Type == SpellTypes.RAY)
return Prefabs[20];
break;
}
case SpellTypes.WATER2:
case SpellTypes.WATER1 : {
if(Type == SpellTypes.SHIELD)
return Prefabs[13];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[10];
if (Type == SpellTypes.RAY)
return Prefabs[20];
break;
}
case SpellTypes.ROCK : {
if(Type == SpellTypes.SHIELD)
return Prefabs[12];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[6];
if (Type == SpellTypes.RAY)
return Prefabs[21];
break;
}
case SpellTypes.ROCK2:
case SpellTypes.ROCK1 : {
if(Type == SpellTypes.SHIELD)
return Prefabs[12];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[9];
if (Type == SpellTypes.RAY)
return Prefabs[21];
break;
}
case SpellTypes.AIR : {
if(Type == SpellTypes.SHIELD)
return Prefabs[11];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[8];
if (Type == SpellTypes.RAY)
return Prefabs[18];
break;
}
case SpellTypes.AIR2:
case SpellTypes.AIR1 : {
if(Type == SpellTypes.SHIELD)
return Prefabs[11];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[7];
if (Type == SpellTypes.RAY)
return Prefabs[18];
break;
}
case SpellTypes.ARCANE: {
if (Type == SpellTypes.SHIELD)
return Prefabs[27];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[24];
if (Type == SpellTypes.RAY)
return Prefabs[28];
break;
}
case SpellTypes.ARCANE1: {
if (Type == SpellTypes.SHIELD)
return Prefabs[27];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[25];
if (Type == SpellTypes.RAY)
return Prefabs[28];
break;
}
case SpellTypes.ARCANE2: {
if (Type == SpellTypes.SHIELD)
return Prefabs[27];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[26];
if (Type == SpellTypes.RAY)
return Prefabs[28];
break;
}
case SpellTypes.LIGHT:
case SpellTypes.LIGHT1:
{
if (Type == SpellTypes.SHIELD)
return Prefabs[30];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[31];
if (Type == SpellTypes.RAY)
return Prefabs[29];
break;
}
case SpellTypes.LIGHT2:
{
if (Type == SpellTypes.SHIELD)
return Prefabs[30];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[33];
if (Type == SpellTypes.RAY)
return Prefabs[29];
break;
}
case SpellTypes.LIGHTNING:
{
if (Type == SpellTypes.SHIELD)
return Prefabs[36];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[33];
if (Type == SpellTypes.RAY)
return Prefabs[37];
break;
}
case SpellTypes.LIGHTNING1:
{
if (Type == SpellTypes.SHIELD)
return Prefabs[36];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[34];
if (Type == SpellTypes.RAY)
return Prefabs[37];
break;
}
case SpellTypes.LIGHTNING2:
{
if (Type == SpellTypes.SHIELD)
return Prefabs[36];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[35];
if (Type == SpellTypes.RAY)
return Prefabs[37];
break;
}
case SpellTypes.LIFE:
case SpellTypes.LIFE1:{
if (Type == SpellTypes.SHIELD)
return Prefabs[39];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[40];
if (Type == SpellTypes.RAY)
return Prefabs[38];
break;
}
case SpellTypes.LIFE2: {
if (Type == SpellTypes.SHIELD)
return Prefabs[39];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[41];
if (Type == SpellTypes.RAY)
return Prefabs[38];
break;
}
case SpellTypes.SHADOW:
case SpellTypes.SHADOW1: {
if (Type == SpellTypes.SHIELD)
return Prefabs[45];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[42];
if (Type == SpellTypes.RAY)
return Prefabs[44];
break;
}
case SpellTypes.SHADOW2: {
if (Type == SpellTypes.SHIELD)
return Prefabs[45];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[43];
if (Type == SpellTypes.RAY)
return Prefabs[44];
break;
}
case SpellTypes.FROST:
case SpellTypes.FROST1: {
if (Type == SpellTypes.SHIELD)
return Prefabs[46];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[48];
if (Type == SpellTypes.RAY)
return Prefabs[47];
break;
}
case SpellTypes.FROST2: {
if (Type == SpellTypes.SHIELD)
return Prefabs[46];
if (Type == SpellTypes.THROW || Type == SpellTypes.DROP)
return Prefabs[49];
if (Type == SpellTypes.RAY)
return Prefabs[47];
break;
}
}
return null;
}
void setTypeSpell(SpellTypes type){
if (type == CurrentTypeSpell || isShooting)
return;
Debug.Log ("SWITCHING TO " + type);
cleanSpells ();
CurrentTypeSpell = type;
}