public IEnumerator TradeTest2()
{
Character character = GameManager.CurrentLevel.GetCharacter(2, 2);
character.Items.Clear();
character.Items.Add(Heal.Create());
character.Items.Add(Heal.Create());
character.Items.Add(Heal.Create());
Character targetCharacter = GameManager.CurrentLevel.GetCharacter(2, 1);
GameManager.TradeDetailPanel.Show(character, targetCharacter);
yield return(null);
Assert.True(GameManager.TradeDetailPanel.IsInFocus());
yield return(DownArrow());
Assert.AreEqual(1, GameManager.TradeDetailPanel.SourceItemsIndex);
yield return(Submit());
Assert.AreEqual(1, GameManager.TradeDetailPanel.SourceItemsIndex);
}
public void Heal(Heal heal)
{
if (isServer)
Send(heal);
if (heal.amount < 0)
throw new ArgumentException("Healing amount should be bigger than 0.");
var calculatedHeal = CalculateHeal(heal);
hp += calculatedHeal;
OnHealed(heal);
ParticleSystem _particle = Instantiate(_pfHealFX);
_particle.transform.SetParent(transform);
_particle.transform.localPosition = Vector3.zero;
Destroy(_particle.gameObject, _particle.duration);
var healText = Instantiate(_pfHealText);
healText.text = calculatedHeal.ToString();
healText.transform.position = transform.position + Vector3.up;
healText.transform.SetParent(_uiRoot);
var ro = UnityEngine.Random.Range(0f, 0.5f);
var phi = UnityEngine.Random.Range(0f, 2 * Mathf.PI);
var theta = UnityEngine.Random.Range(0f, 2 * Mathf.PI);
healText.transform.Translate(ro * Mathf.Sin(phi) * Mathf.Cos(theta), ro * Mathf.Sin(phi) * Mathf.Sin(theta), ro * Mathf.Cos(phi));
}
/// <summary>
/// A method to determine which spell should be cast
/// </summary>
/// <param name="spellchoice">The spellchoice</param>
/// <param name="attacker">the attacker</param>
/// <param name="defender">the defender</param>
public static Spell ProcessSpellChoice(string spellchoice, Character attacker)
{
Spell spell;
switch (spellchoice)
{
case "H":
case "h":
Heal heal = new Heal();
return(heal);
case "F":
case "f":
Fireball fireball = new Fireball();
return(fireball);
case "I":
case "i":
Icebolt icebolt = new Icebolt();
return(icebolt);
default:
Console.WriteLine();
Console.WriteLine("I'm sorry that wasn't a valid choice");
spellchoice = PrintSpells();
spell = ProcessSpellChoice(spellchoice, attacker);
break;
}
return(spell);
}
internal static void OnInComingDamage_OnIncomingDamage(OnInComingDamage.InComingDamageEventArgs args)
{
if (!Heal.IsReady() || !args.Target.IsKillable(800))
{
return;
}
if (!Summs.menu.CheckBoxValue("heal" + args.Target.Name()))
{
return;
}
if (Summs.menu.CheckBoxValue("execute"))
{
if (args.InComingDamage >= args.Target.Health && args.Target.IsInRange(Player.Instance, 800))
{
Heal.Cast();
}
return;
}
//if(Summs.menu.CheckBoxValue("execute")) return;
if (((Summs.menu.CheckBoxValue("Healally") && !args.Target.IsMe && args.Target.IsAlly) || Summs.menu.CheckBoxValue("Heal") && args.Target.IsMe) &&
(Summs.menu.SliderValue("hp" + args.Target.Name()) >= args.Target.HealthPercent || args.InComingDamage >= args.Target.TotalShieldHealth()))
{
Heal.Cast();
}
}
public IEnumerator TradeTest3()
{
Character character = GameManager.CurrentLevel.GetCharacter(2, 2);
character.Items.Clear();
character.Items.Add(Heal.Create());
character.Items.Add(Heal.Create());
character.Items.Add(Heal.Create());
Character targetCharacter = GameManager.CurrentLevel.GetCharacter(2, 1);
targetCharacter.Items.Clear();
targetCharacter.Items.Add(Heal.Create());
GameManager.TradeDetailPanel.Show(character, targetCharacter);
Assert.True(GameManager.TradeDetailPanel.IsInFocus());
yield return(RightArrow());
Assert.AreEqual(TradeDetailPanel.Side.DESTINATION, GameManager.TradeDetailPanel.CurrentSide);
yield return(Submit());
Assert.AreEqual(4, character.Items.Count);
Assert.AreEqual(TradeDetailPanel.Side.SOURCE, GameManager.TradeDetailPanel.CurrentSide);
}
public static void UseHeal()
{
if (Heal != null && Heal.IsReady())
{
Heal.Cast();
}
}
//----------------------------------------------SaveAlly-----------------------------------------------
public static void SaveAlly()
{
var Ally = EntityManager.Heroes.Allies.FirstOrDefault(ally => EntityManager.Heroes.Enemies.Any(enemy => ally.IsFacing(enemy)) && ally.HealthPercent <= 30 && Player.Distance(ally) <= 750);
if (Ally != null)
{
if (FOTMountain.IsReady())
{
FOTMountain.Cast(Ally);
}
if (Mikael.IsReady() && (Ally.HasBuffOfType(BuffType.Charm) || Ally.HasBuffOfType(BuffType.Fear) || Ally.HasBuffOfType(BuffType.Poison) || Ally.HasBuffOfType(BuffType.Polymorph) || Ally.HasBuffOfType(BuffType.Silence) || Ally.HasBuffOfType(BuffType.Sleep) || Ally.HasBuffOfType(BuffType.Slow) || Ally.HasBuffOfType(BuffType.Snare) || Ally.HasBuffOfType(BuffType.Stun) || Ally.HasBuffOfType(BuffType.Taunt)))
{
Mikael.Cast(Ally);
}
}
if (Heal != null && Menu["UseHeal?"].Cast <CheckBox>().CurrentValue)
{
var healtarget = EntityManager.Heroes.Allies.FirstOrDefault(it => it.IsValidTarget(Heal.Range) && it.HealthPercent <= Menu["HealHealth"].Cast <Slider>().CurrentValue);
if (healtarget != null)
{
if (EntityManager.Heroes.Enemies.Any(it => it.IsValidTarget() && it.Distance(healtarget) <= it.GetAutoAttackRange()))
{
Heal.Cast();
}
}
}
return;
}
public void Use()
{
if (item)
{
Debug.Log("You clicked:" + item.itemName);
if (item is Heal)
{
item.target = player;
Heal healing = item as Heal;
if (item.itemName == "Mana Potion")
{
healing.RestoreMana();
Debug.Log("New Mana is: " + healing.targetStats.magic);
}
else
{
healing.RestoreHealth();
Debug.Log("New HP is: " + healing.targetStats.HP);
}
}
inventory.Remove(item);
}
}
IItem CreatePotionHeal()
{
IItem potion = new Item("PotionHeal");
Heal potionHeal = new Heal(potion, 15);
return(potion);
}
public static void UseHeal()
{
if (HasHeal == true && Heal.IsReady())
{
Heal.Cast();
}
}
protected override void CreateLevel()
{
MusicPlay("sounds/level1Loop");
levelSize = new Vector2(80, 60); //set the level size
CreateObject("SpaceDustPF", gameBounds.center, 0);
for (int i = 0; i < 6; i++)
{
Asteroid current = (Asteroid)CreateObject("AsteroidPF", GetRandomPosition(), GetRandomAngle());
current.velocity = GetRandomVelocity(current.maxSpeed);
}
for (int i = 0; i < 2; i++)
{
RubberyDebris current = (RubberyDebris)CreateObject("RubberyDebrisPF", GetRandomPosition(), GetRandomAngle());
current.velocity = GetRandomVelocity(current.maxSpeed);
}
LazerSword sword = (LazerSword)CreateObject("LazerSwordPF");
MultiShots multiShot = (MultiShots)CreateObject("MultiShotPF");
Heal heal = (Heal)CreateObject("HealPF");
}
public IEnumerator HealingTest2()
{
Character hurtCharacter = GameManager.CurrentLevel.GetCharacter(2, 1);
hurtCharacter.CurrentHp -= 2;
Character healingCharacter = GameManager.CurrentLevel.GetCharacter(2, 2);
healingCharacter.Items.Clear();
healingCharacter.Items.Add(Heal.Create());
healingCharacter.AddProficiency(new Proficiency(typeof(HealingStaff), rank: Proficiency.Rank.E));
yield return(MoveCursor(2, 2));
// select character
yield return(Submit());
// select move
yield return(Submit());
// select Assist
GameManager.CharacterActionMenu.OnSubmit();
// select staff
GameManager.ItemSelectionMenu.OnSubmit();
//select other character
GameManager.Cursor.OnSubmit();
Assert.False(GameManager.ItemSelectionMenu.IsInFocus());
Assert.IsEmpty(healingCharacter.AssistableTransforms);
Assert.IsEmpty(healingCharacter.MovableTransforms);
Assert.IsEmpty(healingCharacter.AttackableTransforms);
Assert.AreEqual(hurtCharacter.CurrentHp, hurtCharacter.MaxHp);
}
public async Task <ActionResult> HealPlayerCharacter(long id, Heal heal)
{
var playerCharacter = await _context.PlayerCharacter.FindAsync(id);
playerCharacter.HPEvents.Add(new HPEvent {
HPEventType = HPEventType.Heal,
Amount = heal.Amount,
});
_context.Entry(playerCharacter).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PlayerCharacterExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
private void activateFloorTile(string playerName)
{
GameObject player = GameObject.Find(playerName);
PlayerController playerController = player.GetComponent <PlayerController>();
if (this.hasPowerUp)
{
switch (powerUp.grouping)
{
case "Danger":
Debug.Log("DANGER POWER UP " + playerName);
Danger danger = (Danger)powerUp;
scoreKeeper.updatePlayerHealth(playerName, -danger.damage);
resetFloorTilePowerup();
break;
case "Heal":
Debug.Log("HEAL POWER UP " + playerName);
Heal heal = (Heal)powerUp;
scoreKeeper.updatePlayerHealth(playerName, heal.health);
resetFloorTilePowerup();
break;
case "Weapon":
Debug.Log("WEAPON POWER UP " + playerName);
Weapon weapon = (Weapon)powerUp;
playerController.weapon = weapon;
resetFloorTilePowerup();
break;
default:
break;
}
}
}
public virtual async Task HealTask()
{
// This is never null......
if (InstanceManager.HealTarget == null)
{
return;
}
Tuple <SpellManager.SpellInformation, CastAction> currentBestAbility = Heal.GetHighestPriorityTuple(InstanceManager.HealTarget);
if (currentBestAbility != null && currentBestAbility.Item1.CanCast) // sanity check on CanCast
{
Omnibus.Logger.Debug(string.Format("[HEAL] FaceCast [Name {0}, SpellBarIndex {1}]",
currentBestAbility.Item1.Name,
currentBestAbility.Item1.SpellBarIndex));
// NOTE: this needs to change. Since abilities need different casting methods.
// ChargeAndRelease requires at least N charges before firing it off
// ChanneledArea or something needs to be cast -> cast again at the location [2+ frames]
// TODO: Add a "continuous face" into SpellCastBeahviors.CastSimple
if (Omnibus.WindowSettings.EnableMovement)
{
InstanceManager.HealTarget.Face();
}
//await SpellCastBehaviors.CastSimple(currentBestAbility, () => InstanceManager.HealTarget, true);
await currentBestAbility.Item2(InstanceManager.Target);
}
}
public static void UseHeal()
{
if (Heal != null && Heal.IsReady())
{
if (Config.Spell["eHeal"].Cast <CheckBox>().CurrentValue &&
Player.Instance.HealthPercent <= Config.Spell["myHPHeal"].Cast <Slider>().CurrentValue &&
Player.Instance.CountEnemiesInRange(1200) >= 1)
{
Heal.Cast();
}
foreach (var ally in EntityManager.Heroes.Allies.Where(a => !a.IsDead))
{
if (EntityManager.Heroes.Allies.Where(a => !a.IsDead) != null && ally.ChampionName != Player.Instance.ChampionName)
{
if (Config.Spell["eHealAlly"].Cast <CheckBox>().CurrentValue &&
ally.CountEnemiesInRange(1200) >= 1 &&
Player.Instance.Position.Distance(ally) <= 800 &&
Config.Spell["heal" + ally.ChampionName].Cast <CheckBox>().CurrentValue &&
ally.HealthPercent <= Config.Spell["allyHPHeal"].Cast <Slider>().CurrentValue)
{
Heal.Cast();
}
}
}
}
}
public IEnumerator OnCancelChoosingAssistTargetTest()
{
Character character = GameManager.CurrentLevel.GetCharacter(2, 2);
character.Items.Clear();
character.AddProficiency(new Proficiency(typeof(HealingStaff), Proficiency.Rank.A));
character.Items.Add(Heal.Create());
yield return(MoveCursor(2, 2));
yield return(Submit());
yield return(Submit());
yield return(Submit());
yield return(Submit());
Assert.AreEqual(Cursor.State.ChoosingAssistTarget, GameManager.Cursor.CurrentState);
Assert.True(GameManager.Cursor.IsInFocus());
yield return(Cancel());
Assert.True(GameManager.ItemSelectionMenu.gameObject.activeSelf);
Assert.True(GameManager.ItemSelectionMenu.IsInFocus());
}
public override void TuneComplete(bool crit)
{
base.TuneComplete(crit);
GameObject temp = (GameObject)GameObject.Instantiate(spawnObject, ownerTransform.position, ownerTransform.rotation);
Heal heal = temp.GetComponent <Heal>();
heal.tune = this;
heal.agressor = ownerTransform.GetComponent <BaseControl>().player;
temp.GetComponent <TrailRenderer>().material.color = Color.green;
temp.transform.GetChild(1).GetComponent <ParticleSystem>().startColor = Color.green;
temp.transform.GetChild(0).GetComponent <ParticleSystem>().startColor = Color.green;
if (crit)
{
temp.GetComponent <TrailRenderer>().material.color = Color.yellow;
temp.transform.GetChild(1).GetComponent <ParticleSystem>().startColor = Color.yellow;
temp.transform.GetChild(0).GetComponent <ParticleSystem>().startColor = Color.yellow;
heal.damage *= 2f;
}
Destroy(temp.transform.GetChild(0).gameObject, 2f);
Destroy(temp.transform.GetChild(1).gameObject, 2f);
temp.transform.GetChild(0).parent = null;
temp.transform.GetChild(0).parent = null;
}
public void HealIncreasesHp()
{
int maxHp = 12;
Character character = new Character()
{
MaxHp = maxHp,
CurrentHp = 5,
TempHp = 0
};
Heal heal = new Heal()
{
Hp = 3
};
int calculatedHp = 8;
var mockDal = new Mock <ICharacterData>();
CharacterManager characterManager = new CharacterManager(mockDal.Object);
mockDal.Setup(dal => dal.UpdateCharacter(character)).Returns(character);
Character updatedCharacter = characterManager.Heal(character, heal);
Assert.Equal(maxHp, updatedCharacter.MaxHp);
Assert.Equal(calculatedHp, updatedCharacter.CurrentHp);
Assert.Equal(0, updatedCharacter.TempHp);
}
internal static void OnInComingDamage_OnIncomingDamage(OnInComingDamage.InComingDamageEventArgs args)
{
if (!Heal.IsReady() || !args.Target.IsKillable(800) || !EntityManager.Heroes.Enemies.Any(e => e.IsValid && !e.IsDead && e.IsInRange(args.Target, 1250)) && args.Target.Health > args.InComingDamage)
{
return;
}
if (!Summs.menu.CheckBoxValue("heal" + args.Target.Name()))
{
return;
}
if (Summs.menu.CheckBoxValue("execute"))
{
if (args.Target.IsMe || !args.Target.IsMe && Summs.menu.CheckBoxValue("Healally"))
{
if (args.InComingDamage >= args.Target.Health && args.Target.IsInRange(Player.Instance, 800))
{
Heal.Cast();
}
}
return;
}
if (((Summs.menu.CheckBoxValue("Healally") && !args.Target.IsMe && args.Target.IsAlly) || Summs.menu.CheckBoxValue("Heal") && args.Target.IsMe) &&
(Summs.menu.SliderValue("hp" + args.Target.Name()) >= args.Target.HealthPercent || args.InComingDamage >= args.Target.TotalShieldHealth()))
{
Heal.Cast();
}
}
public static void Init()
{
if (HasSpell("summonersmite"))
{
Smite.Initialize();
}
if (HasSpell("summonerheal"))
{
Heal.Initialize();
}
if (HasSpell("summonerbarrier"))
{
Barrier.Initialize();
}
if (HasSpell("summonerexhaust"))
{
Exhaust.Initialize();
}
if (HasSpell("summonerghost"))
{
Ghost.Initialize();
}
}
public void TrackLine(Heal line)
{
TrackCharacter(line.Healer);
TrackCharacter(line.Patient);
// If "You" are healing/being healed then the other character is a PC or Merc
if (YouAre.IsThisYou(line.Healer))
{
CharResolver.SetMercenary(line.Patient);
}
if (YouAre.IsThisYou(line.Patient))
{
CharResolver.SetMercenary(line.Healer);
}
// If either char is a PC/merc/pet, then the other is a Merc. This won't override a Player type (if detect by /who line)
if (IsGoodPlayer(line.Healer))
{
CharResolver.SetMercenary(line.Patient, overwrite: false);
}
if (IsGoodPlayer(line.Patient))
{
CharResolver.SetMercenary(line.Healer, overwrite: false);
}
}
public void AddAction(EAction action, Character chara)
{
BattleAction newAction = null;
Character playerPeek = m_PlayerCharacters.Peek();
Character enemyPeek = m_EnnemyCharacters.Peek();
switch (action)
{
case EAction.Attack:
newAction = new Attack(chara.GetStrength(), chara, m_IsPlayerTurn ? enemyPeek : playerPeek);
break;
case EAction.Defense:
newAction = new Defense(chara.GetMagic(), chara, chara);
break;
case EAction.Heal:
newAction = new Heal(chara.GetMagic(), chara, m_IsPlayerTurn ? playerPeek : enemyPeek);
break;
case EAction.Protect:
newAction = new Protect(chara, m_IsPlayerTurn ? playerPeek : enemyPeek);
break;
case EAction.Bound:
newAction = new Bound(chara, m_IsPlayerTurn ? playerPeek : enemyPeek);
break;
}
m_Actions.Enqueue(newAction);
}
public static void Execute()
{
if (HasSpell("summonersmite"))
{
Smite.Execute();
}
if (HasSpell("summonerheal"))
{
Heal.Execute();
}
if (HasSpell("summonerbarrier"))
{
Barrier.Execute();
}
if (HasSpell("summonerexhaust"))
{
Exhaust.Execute();
}
if (HasSpell("summonerghost"))
{
Ghost.Execute();
}
}
public IEnumerator OnArrowChoosingTradeTargetTest2()
{
Character character = GameManager.CurrentLevel.GetCharacter(2, 2);
character.Items.Clear();
character.AddProficiency(new Proficiency(typeof(HealingStaff), Proficiency.Rank.A));
character.Items.Add(Heal.Create());
yield return(MoveCursor(2, 2));
yield return(Submit());
yield return(Submit());
yield return(DownArrow());
yield return(Submit());
Assert.AreEqual(Cursor.State.ChoosingTradeTarget, GameManager.Cursor.CurrentState);
Character originalAssistTarget = GameManager.CurrentLevel.GetCharacter(GameManager.Cursor.transform.position);
yield return(DownArrow());
Assert.AreSame(originalAssistTarget, GameManager.CurrentLevel.GetCharacter(GameManager.Cursor.transform.position));
}
private void OnTriggerEnter2D(Collider2D other)
{
if (other.tag == "EnemyLaser")
{
DamageDealer damageDealer = other.gameObject.GetComponent <DamageDealer>();
ProcessHit(damageDealer);
animationController.PlayEnemyLaserExplosion(other.transform.position);
}
if (other.tag == "Coin")
{
int value = other.gameObject.GetComponent <Coin>().GetValue();
FindObjectOfType <GameController>().AddCoins(value);
Destroy(other.gameObject);
}
if (other.tag == "Heal")
{
Heal heal = other.gameObject.GetComponent <Heal>();
int value = heal.GetHealAmount();
if (health + value >= maxHealth)
{
health = maxHealth;
}
else
{
health += value;
}
healthBar.SetHealth(health);
Destroy(other.gameObject);
}
}
public IEnumerator OnArrowChoosingAssistTargetTest1()
{
Character character = GameManager.CurrentLevel.GetCharacter(2, 2);
character.Items.Clear();
character.AddProficiency(new Proficiency(typeof(HealingStaff), Proficiency.Rank.A));
character.Items.Add(Heal.Create());
character.Move(new Vector2(3, 1));
// Adding second character
Character target = GameManager.CurrentLevel.Create <Character>(GameManager.WizardPrefab);
target.Player = GameManager.CurrentLevel.HumanPlayer;
GameManager.CurrentLevel.AddCharacter(target, 3, 0);
yield return(MoveCursor(3, 1));
yield return(Submit());
yield return(Submit());
yield return(Submit());
yield return(Submit());
Assert.AreEqual(Cursor.State.ChoosingAssistTarget, GameManager.Cursor.CurrentState);
Character originalAssistTarget = GameManager.CurrentLevel.GetCharacter(GameManager.Cursor.transform.position);
yield return(DownArrow());
Assert.AreNotSame(originalAssistTarget, GameManager.CurrentLevel.GetCharacter(GameManager.Cursor.transform.position));
}
public static void UseHeal()
{
if (ObjectManager.Player.CountEnemiesInRange(900) >= 1 && Heal != null && Heal.IsReady())
{
Heal.Cast();
}
}
// Start is called before the first frame update
void Start()
{
tileData = GameObject.FindGameObjectWithTag("TileManager").GetComponent <TileData>();
stats = GetComponent <Stats>();
heal = GetComponent <Heal>();
cursor = GameObject.FindGameObjectWithTag("Cursor");
}
public void before()
{
doer = new PlayerCharacter(new Stat(49f), null, null, null, null, 1, null, null, null, 1, null, null);
heal = new Heal();
targets = new List <Character>();
targets.Add(getter);
}
public override void Cast_Spell(Summon s)
{
base.Cast_Spell(s);
if (Random.Range(0, 101) > 90)
{
results += new Heal().Do_Ability(s);
}
}
public byte _0xD; // Classification (0-3 Battle, 4 Balls, 5 Mail)
#endregion Fields
#region Constructors
public Item(byte[] data)
{
using (BinaryReader br = new BinaryReader(new MemoryStream(data)))
{
Price = br.ReadUInt16();
BuyPrice = Price * 10;
SellPrice = Price * 5;
HeldEffect = br.ReadByte();
HeldArgument = br.ReadByte();
NaturalGiftEffect = br.ReadByte();
FlingEffect = br.ReadByte();
FlingPower = br.ReadByte();
NaturalGiftPower = br.ReadByte();
NaturalGiftType = br.ReadByte();
u8Flags = (byte)(NaturalGiftType >> 5);
NaturalGiftType &= 0x1F;
KeyFlags = br.ReadByte();
UseEffect = br.ReadByte();
_0xB = br.ReadByte();
_0xC = br.ReadByte();
_0xD = br.ReadByte();
Consumable = br.ReadByte();
SortIndex = br.ReadByte();
CureInflict = br.ReadByte();
FieldEffect = br.ReadByte();
BoostATK = FieldEffect >> 4;
FieldEffect &= 0xF;
BoostDEF = br.ReadByte();
BoostSPA = BoostDEF >> 4;
BoostDEF &= 0xF;
BoostSPD = br.ReadByte();
BoostSPE = BoostSPD >> 4;
BoostSPD &= 0xF;
BoostACC = br.ReadByte();
BoostCRIT = (BoostACC >> 4) & 0x3;
BoostPP = BoostACC >> 6;
BoostACC &= 0xF;
FunctionFlags = br.ReadUInt16();
EVHP = br.ReadByte();
EVATK = br.ReadByte();
EVDEF = br.ReadByte();
EVSPE = br.ReadByte();
EVSPA = br.ReadByte();
EVSPD = br.ReadByte();
Healing = new Heal(br.ReadByte());
PPGain = br.ReadByte();
Friendship1 = br.ReadByte();
Friendship2 = br.ReadByte();
Friendship3 = br.ReadByte();
_0x23 = br.ReadByte();
_0x24 = br.ReadByte();
}
}
void Awake()
{
Auras = new Dictionary<string, Aura>();
Auras["test"] = new AuraTemplate("test");
Auras["heal"] = new Heal("heal");
Auras["Corruption"] = new Corruption("Corruption");
Auras["BlessingOfMight"] = new BlessingOfMight("Blessing of Might");
Auras["shadowStun"] = new Shadowstun("shadowStun");
Auras["root"] = new Root("root");
Auras["slow"] = new Slow("slow");
Auras["dervishslow"] = new DervishSlow("dervishslow");
Auras["chaosbarrage"] = new chaosbarrage("chaosbarrage");
Auras["fireballbarrage"] = new fireballbarrage("fireballbarrage");
}
public Move(byte[] data)
{
Type = data[0];
Quality = data[1];
Category = data[2];
Power = data[3];
Accuracy = data[4];
PP = data[5];
Priority = data[6];
HitMin = (byte)(data[7] & 0xF);
HitMax = (byte)(data[7] >> 4);
Inflict = BitConverter.ToUInt16(data, 0x8);
InflictPercent = data[0xA];
_0xB = data[0xB];
TurnMin = data[0xC];
TurnMax = data[0xD];
CritStage = data[0xE];
Flinch = data[0xF];
Effect = BitConverter.ToUInt16(data, 0x10);
Recoil = data[0x12];
Healing = new Heal(data[0x13]);
Targeting = data[0x14];
Stat1 = data[0x15];
Stat2 = data[0x16];
Stat3 = data[0x17];
Stat1Stage = data[0x18];
Stat2Stage = data[0x19];
Stat3Stage = data[0x1A];
Stat1Percent = data[0x1B];
Stat2Percent = data[0x1C];
Stat3Percent = data[0x1D];
_0x1E = data[0x1E];
_0x1F = data[0x1F];
_0x20 = data[0x20];
_0x21 = data[0x21];
}
protected virtual float CalculateHeal(Heal heal)
{
return heal.amount;
}
private void castSpellHeal(Heal castSpell)
{
castSpell.applySpell(this);
}
private static void Init()
{
switch (ObjectManager.Player.ChampionName)
{
case "Alistar":
_heal = new Heal(SpellSlot.E, 575, false);
break;
case "Gangplank":
_heal = new Heal(SpellSlot.W, 0, false, true);
break;
case "Kayle":
_heal = new Heal(SpellSlot.W, 900);
break;
case "Nami":
_heal = new Heal(SpellSlot.W, 725);
break;
case "Nidalee":
_heal = new Heal(SpellSlot.E, 600);
break;
case "Sona":
_heal = new Heal(SpellSlot.W, 1000, false);
break;
case "Soraka":
_heal = new Heal(SpellSlot.W, 450, true, false, false);
break;
case "Taric":
_heal = new Heal(SpellSlot.Q, 750);
break;
default:
return;
}
}
public void AddHeal(Heal heal)
{
Heals.Add(heal);
}
private void combatParser_Heal(object sender, HealEventArgs e)
{
UpdateEncounter(e.Timestamp);
Heal heal = new Heal(e);
Character healer = FindCharacter(e.Healer);
healer.AddOffensiveHeal(heal);
Character healed = FindCharacter(e.Target);
healed.AddDefensiveHeal(heal);
}
public void Heal(Heal heal)
{
if (isServer)
Send(heal);
if (heal.amount < 0)
throw new ArgumentException("Healing amount should be bigger than 0.");
var calculatedHeal = CalculateHeal(heal);
hp += calculatedHeal;
OnHealed(heal);
ParticleSystem _particle = Instantiate(_pfHealFX);
_particle.transform.SetParent(transform);
_particle.transform.localPosition = Vector3.zero;
Destroy(_particle.gameObject, _particle.duration);
var healText = Instantiate(_pfHealText);
healText.text = calculatedHeal.ToString();
healText.transform.position = transform.position + Vector3.up;
healText.transform.SetParent(_uiRoot);
var ro = UnityEngine.Random.Range(0f, 0.5f);
var phi = UnityEngine.Random.Range(0f, 2 * Mathf.PI);
var theta = UnityEngine.Random.Range(0f, 2 * Mathf.PI);
healText.transform.Translate(ro * Mathf.Sin(phi) * Mathf.Cos(theta), ro * Mathf.Sin(phi) * Mathf.Sin(theta), ro * Mathf.Cos(phi));
}
protected virtual void OnHealed(Heal heal)
{
}
