public void MoveDirectionHit(Vector3 _direction, float _damage, bool _condición = false)
{
print(_damage + " " + damage);
if (_damage <= damage)
{
currentDamage = TypeOfDamage.PLAYERREBOTA;
}
else
{
if (_condición)
{
currentDamage = TypeOfDamage.EMPUJADOCONCONDICIÓN;
}
else
{
currentDamage = TypeOfDamage.EMPUJAENEMIGO;
}
if (_damage - damage / 1.5f > 25)
{
_damage = 25 + damage / 1.5f;
}
directionKnockback = new Vector3(_direction.x, 0, _direction.z).normalized;
maxTime = _damage / damage;
speedEmpuje = _damage - damage / 1.5f;
maxTime = Mathf.Lerp(0, 0.25f, maxTime);
}
}
public Skill(int damage, string name, Effects effect, int probability, TypeOfDamage type)
{
this.Damage = damage;
this.Name = name;
this.Effect = effect;
this.ProbabilityForEffect = probability;
this.TypeOfDamage = type;
}
public override float TakeDamage(float dmg, Vector3 hitPosition, TypeOfDamage type)
{
if (isShielding)
{
return(base.TakeDamage(dmg * shieldSelfProtectionPercentage, hitPosition, type));
}
else
{
return(base.TakeDamage(dmg, hitPosition, type));
}
}
public virtual float TakeDamage(float damage, Vector3 hitPosition, TypeOfDamage type)
{
if (shieldDisabled)
{
type = TypeOfDamage.PIERCE;
}
switch (type)
{
case TypeOfDamage.NORMAL:
damage -= defencePower + additionalDefence;
break;
case TypeOfDamage.TRUE:
break;
case TypeOfDamage.PIERCE:
damage -= defencePower + additionalDefence;
break;
}
int dmg = Mathf.RoundToInt(damage);
if (damage < 0)
{
damage = 0;
}
else if (type != TypeOfDamage.PIERCE)
{
DamageShield(dmg);
}
else
{
DamageHP(dmg);
}
if (!recoverOnCD)
{
if (StatusRecoveringCoroutine != null)
{
StopCoroutine(StatusRecoveringCoroutine);
StatusRecoveringCoroutine = null;
}
StartCoroutine(StatusCoolDown());
}
else
{
recoveryCoolDown = 3f;
}
incomingHitDirection = hitPosition - transform.position;
return(damage);
}
public void TakeDamage(int damage, TypeOfDamage typeOfDamage = TypeOfDamage.Physical)
{
if (isDead)
{
return;
}
BroadcastMessage("OnDamageTaken");
hitPoints = Mathf.Max(0, hitPoints - damage);
print($"{name} took {damage} points of damage, resulting in remaining health of {hitPoints} hit points.");
if (hitPoints <= 0)
{
ProcessDeath();
}
}
private void DeathEvent(TypeOfDamage type)
{
switch (type)
{
case TypeOfDamage.Explosion:
GetComponent <WormCharacter>().AnimDie();
Invoke("DeathByExplosion", 1.0f);
break;
case TypeOfDamage.Water:
GetComponent <Rigidbody2D>().drag = 25f;
GetComponent <WormCharacter>().AnimJump(true);
Invoke("DeathByWater", 0.1f);
break;
}
}
public void ApplyDamage(int damage, TypeOfDamage type)
{
if (life >= damage)
{
Life -= damage;
}
else
{
Life = 0;
}
GameLoopManager.Instance.OnWormTakeDamage(myTeam);
if (Life == 0)
{
DeathEvent(type);
}
}
public override float TakeDamage(float dmg, Vector3 hitPosition, TypeOfDamage type)
{
float damageTaken = 0;
//if (!immune)
//{
damageTaken = base.TakeDamage(dmg, hitPosition, type);
cameraMovement.OnPlayerTakeDamage();
//}
//if (currentHealthPoints <= 0)
// Die();
return(damageTaken);
//Add dmg taken animation
}
// How an adventurer takes damage. Depending on the stance the damage will be increased or multiplied in a rock paper scissors way.
// Attack Beats Magic
// Magic Beats Counter
// Counter Beats Attack
// EX: If a Player attack were to do 4 damage and picked attack, and the Enemy would do 4 damage and picked Magic:
// Player would do 6 Damage
// Enemy would do 2 Damage
public void TakeDamage(int damage, TypeOfDamage tod)
{
isBattleReady = false;
if (tod == Stance)
{
Health -= damage;
}
switch (Stance)
{
case TypeOfDamage.Attack:
if (tod == TypeOfDamage.Counter)
{
Health -= damage + (damage / Multiplier);
}
if (tod == TypeOfDamage.Magic)
{
Health -= damage / Multiplier;
}
break;
case TypeOfDamage.Magic:
if (tod == TypeOfDamage.Attack)
{
Health -= damage + (damage / Multiplier);
}
if (tod == TypeOfDamage.Counter)
{
Health -= damage / Multiplier;
}
break;
case TypeOfDamage.Counter:
if (tod == TypeOfDamage.Magic)
{
Health -= damage + (damage / Multiplier);
}
if (tod == TypeOfDamage.Attack)
{
Health -= damage / Multiplier;
}
break;
}
}
public void RandomAttack()
{
int rand = Random.Range(0, 100);
if (rand >= 0 && rand <= AttackThreshold)
{
Stance = TypeOfDamage.Attack;
}
else if (rand > AttackThreshold && rand <= MagicThreshold)
{
Stance = TypeOfDamage.Magic;
}
else if (rand >= MagicThreshold && rand < CounterThreshold)
{
Stance = TypeOfDamage.Counter;
}
else
{
Debug.Log("Rerolled");
RandomAttack();
}
}
public override float TakeDamage(float dmg, Vector3 hitPosition, TypeOfDamage type)
{
float damageTaken = base.TakeDamage(dmg, hitPosition, type);
HandleStagger(2);
if (currentHealthPoints <= 0)
{
Die();
}
else
{
OnDamageTaken(this, currentHealthPoints, maxHealthPoints);
if (targetPlayer == null)
{
playerPosition = hitPosition;
currentState.ToAlertState();
alertState.AlertLevel = 1;
}
}
return(damageTaken);
}
public void RerstartTypeOfDamage()
{
currentDamage = TypeOfDamage.NADA;
}
public double influence; // <- Protected Set?
public DamageController(TypeOfDamage type, double damage, double influence)
{
this.type = type;
this.damage = damage;
this.influence = influence;
}
private void CreateSkill(int damage, string name, Effects effect, int probability, TypeOfDamage type)
{
ListOfAllSkills.Add(new Skill(damage, name, effect, probability, type));
XmlSerializer serializer = new XmlSerializer(typeof(List <Skill>));
string path = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + @"\DBItems\DatabaseSkill.xml";
XmlWriter writer = new XmlTextWriter(path, Encoding.UTF8);
serializer.Serialize(writer, ListOfAllSkills);
writer.Flush();
writer.Close();
}
public void ChooseAttack(int tod)
{
Stance = (TypeOfDamage)tod;
isBattleReady = true;
}
public override float TakeDamage(float dmg, Vector3 hitPosition, TypeOfDamage type)
{
float damageTaken = base.TakeDamage(dmg, hitPosition, type);
return(damageTaken);
}
//When you use damaging ability- comes here
public void CallBack(List <bool> CanAttack, float Damage, float DamageOverTime, float Mod, float StunL, float SlowL, float SlowS, TypeOfDamage DamageType, bool AoE, EnemyOrNo HeroOrEnemy)
{
check = 0;
CurDamage = Damage;
CurMod = Mod;
CurSlowL = SlowL;
CurSlowS = SlowS;
CurStunL = StunL;
TypeOfDamage = DamageType;
EnemyOrNo = HeroOrEnemy;
CurDoT = DamageOverTime;
if (AoE == true)
{
Turns[CurrentTurn].AnimateAbility();
if (HeroOrEnemy == EnemyOrNo.Hero)
{
for (int i = 0; i < EnemiesNumber; i++)
{
if (CanAttack[i] && Stat[i + 3].GetComponent <Stats>().curHealth > 0)
{
if (TypeOfDamage == TypeOfDamage.Phisical)
{
WhoIsAttacked = i + 3;
Stat[i + 3].DamagedPhis(CurDamage, CurDoT, CurMod, CurStunL, CurSlowL, CurSlowS);
}
else
{
WhoIsAttacked = i + 3;
Stat[i + 3].DamagedMagical(CurDamage, CurDoT, CurMod, CurStunL, CurSlowL, CurSlowS);
}
}
else
{
check++;
}
}
}
else
{
for (int i = 0; i < 3; i++)
{
if (CanAttack[i] && Stat[i].GetComponent <Stats>().curHealth > 0)
{
if (TypeOfDamage == TypeOfDamage.Phisical)
{
WhoIsAttacked = i;
Stat[i].DamagedPhis(CurDamage, CurDoT, CurMod, CurStunL, CurSlowL, CurSlowS);
}
else
{
WhoIsAttacked = i;
Stat[i].DamagedMagical(CurDamage, CurDoT, CurMod, CurStunL, CurSlowL, CurSlowS);
}
}
else
{
check++;
}
}
}
SwitchingTurns();
}
else
{
if (HeroOrEnemy == EnemyOrNo.Hero)
{
for (int i = 0; i < EnemiesNumber; i++)
{
if (CanAttack[i] && Stat[i + 3].GetComponent <Stats>().curHealth > 0)
{
Targets[i + 3].GetComponent <SpriteRenderer>().sprite = CircleRed;
Targets[i + 3].GetComponent <Presser>().IsDamaging = true;
Targets[i].GetComponent <Presser>().Ressurect = false;
Targets[i + 3].SetActive(true);
}
else
{
check++;
}
}
}
else
{
for (int i = 0; i < 3; i++)
{
if (CanAttack[i] && Stat[i].GetComponent <Stats>().curHealth > 0)
{
Targets[i].GetComponent <SpriteRenderer>().sprite = CircleRed;
Targets[i].GetComponent <Presser>().IsDamaging = true;
Targets[i].GetComponent <Presser>().Ressurect = false;
Targets[i].SetActive(true);
}
else
{
check++;
}
}
}
if (check >= 3)
{
SwitchingTurns();
}
}
}
private void CreateSkillBtn_Click(object sender, EventArgs e)
{
int damage = 0;
string name = String.Empty;
Effects effect = Effects.None;
int probabilitySkill = 0;
TypeOfDamage type = TypeOfDamage.Physical;
if (NameSkill.TextLength != 0)
{
damage = Convert.ToInt32(DamageSkill.Text);
name = NameSkill.Text;
probabilitySkill = Convert.ToInt32(ProbsSkill.Text);
switch (TypeOfDamageSkill.Text)
{
case "Physical":
type = TypeOfDamage.Physical;
break;
case "Magical":
type = TypeOfDamage.Magical;
break;
}
switch (EffectSkill.Text)
{
case "Stun":
effect = Effects.Stun;
break;
case "Blindness":
effect = Effects.Blindness;
break;
case "Sleep":
effect = Effects.Sleep;
break;
case "Knockout":
effect = Effects.Knockout;
break;
case "Burn":
effect = Effects.Burn;
break;
case "Poison":
effect = Effects.Poison;
break;
case "Freeze":
effect = Effects.Freeze;
break;
case "None":
effect = Effects.None;
break;
}
CreateSkill(damage, name, effect, probabilitySkill, type);
}
else
{
MessageBox.Show("Error, Name is not filled in!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
