public override void Damage(AttackDetails attackDetails)
{
base.Damage(attackDetails);
GameObject.Instantiate(deadStateData.bloodEffectGO, aliveGameObject.transform.position, deadStateData.bloodEffectGO.transform.rotation);
if (isDead)
{
finiteStateMachine.ChangeState(deadState);
}
else if (isStunned && finiteStateMachine.currentState != stunState)
{
finiteStateMachine.ChangeState(stunState);
}
else if (CheckIfPlayerInCloseRangeAction())
{
finiteStateMachine.ChangeState(meleeAttackState);
}
else if (CheckIfPlayerInLongRangeAction())
{
finiteStateMachine.ChangeState(rangedAttackState);
}
else
{
lookForPlayerState.SetShouldTurnImmediately(true);
finiteStateMachine.ChangeState(lookForPlayerState);
}
}
public void Damage(AttackDetails ad)
{
if (!isHurt)
{
GetComponentInParent <Entity>().Damage(ad);
}
}
public virtual void Damage(AttackDetails attackDetails)
{
currentHealth -= attackDetails.damageAmmount;
currentStunResistance -= attackDetails.stunDamageAmount;
lastDamageTime = Time.time;
DamageHop(entityData.damageHopSpeed);
lastDamageDirection = attackDetails.position.x > aliveGameObject.transform.position.x ? -1 : 1;
foreach (GameObject hitPartcile in entityData.hitPartciles)
{
Instantiate(hitPartcile, aliveGameObject.transform.position, Quaternion.Euler(0.0f, 0.0f, Random.Range(0, 360)));
}
if (currentStunResistance <= 0)
{
isStunned = true;
}
if (currentHealth <= 0)
{
isDead = true;
}
}
public void Damage(AttackDetails attackDetails)
{
// Debug.Log("in player script");
Instantiate(hitParticle, transform.position, Quaternion.Euler(0f, 0f, Random.Range(0f, 360f)));
currentHealth -= attackDetails.damageAmount;
// currentStunResistance -= attackDetails.stunDamageAmount;
if (attackDetails.position.x > transform.position.x)
{
lastDamageDirection = -1;
}
else
{
lastDamageDirection = 1;
}
DamageHop(attackDetails.damageKnockbackSpeed);
/*_________if (currentStunResistance <= 0)
* {
* isStunned = true;
* } _______________*/
if (currentHealth <= 0)
{
Anim.SetBool("Destroyed", true);
//wait some time then destroy object
}
}
IEnumerator BuffDuration(AttackDetails attack)
{
isBuffed = true;
yield return(new WaitForSeconds(attack.BuffDuration));
isBuffed = false;
}
public override void Damage(AttackDetails attackDetails)
{
base.Damage(attackDetails);
if (isDead)
{
stateMachine.ChangeState(deathState);
}
else if (isStunned && stateMachine.currentState != stunState)
{
stateMachine.ChangeState(stunState);
}
else if (CheckPlayerInMinAgroRange())
{
stateMachine.ChangeState(rangedAttackState);
}
else if (!CheckPlayerInMinAgroRange())
{
lookForPlayerState.SetTurnImmidiately(true);
stateMachine.ChangeState(lookForPlayerState);
}
}
private void Damage(AttackDetails attackDetails)
{
//if (!PC.GetDashStatus())
// {
if (!isInvulnerable)
{
StartCoroutine("GetInvulnerable");
int direction;
playerStats.DecreaseHealth(Convert.ToInt32(attackDetails.damageAmount));
if (attackDetails.position.x < transform.position.x)
{
direction = 1;
}
else
{
direction = -1;
}
PC.Knockback(direction);
}
// }
}
public override void Damage(AttackDetails attackDetails)
{
if (DeadState.IsDead)
{
return;
}
bool canDamage = Time.time >= StatsManager.LastDamageTime + _damageStateData.timeBeforeNextDamage;
base.Damage(attackDetails);
foreach (GameObject hitPartcile in _damageStateData.hitPartciles)
{
GameObject.Instantiate(hitPartcile, AliveGameObject.transform.position, Quaternion.Euler(0.0f, 0.0f, Random.Range(0, 360)));
}
if (StatsManager.IsDead)
{
FiniteStateMachine.ChangeState(DeadState);
}
else if (canDamage)
{
FiniteStateMachine.ChangeState(DamageState);
}
}
public virtual void Damage(AttackDetails attackDetails)
{
GameObject.Instantiate(damageParticle, transform.position, damageParticle.transform.rotation);
lastDamageTime = Time.time;
Debug.Log("Player takes " + attackDetails.damageAmount + " damage");
currentHealth -= attackDetails.damageAmount;
currentStunResistance -= attackDetails.stunDamageAmount;
int direction;
if (attackDetails.position.x < transform.position.x)
{
direction = 1;
}
else
{
direction = -1;
}
Knockback(direction);
if (currentStunResistance <= 0)
{
isStunned = true;
}
if (currentHealth <= 0)
{
isDead = true;
Anim.SetBool("dead", isDead);
deadTime = Time.time;
}
}
private void Damage(AttackDetails attackDetails)
{
currentHealth -= attackDetails.damageAmount;
Instantiate(hitParticle, aliveGO.transform.position, Quaternion.Euler(0.0f, 0.0f, Random.Range(0.0f, 360.0f)));
if (attackDetails.position.x < aliveGO.transform.position.x)
{
playerFacingDirection = 1;
}
else
{
playerFacingDirection = -1;
}
aliveAnim.SetBool("PlayerOnLeft", playerOnLeft);
aliveAnim.SetTrigger("damage");
if (applyKnockback && currentHealth > 0.0f)
{
//Knockback
Knockback();
}
if (currentHealth <= 0.0f)
{
Die();
}
}
public void FireProjectile(float speed, float travelDistance, AttackDetails attackDetails, float gravityScale)
{
_speed = transform.right * speed;
_travelDistance = travelDistance;
_gravityScale = gravityScale;
_attackDetails = attackDetails;
}
private void Damage(AttackDetails attackDetails)
{
currentHP -= attackDetails.damageAmount;
Instantiate(hitParticle, aliveAnim.transform.position, Quaternion.Euler(0.0f, 0.0f, Random.Range(0.0f, 360.0f)));
if (player.transform.position.x < aliveAnim.transform.position.x)
{
playerOnLeft = true;
playerFacingDirection = 1;
}
else
{
playerOnLeft = false;
playerFacingDirection = -1;
}
if (applyKnockback && currentHP > 0.0f)
{
Knockback();
Debug.Log("Knockback");
}
if (currentHP <= 0.0f)
{
aliveGO.GetComponent <Animation>().Play("redflash");
Die();
Debug.Log("Die");
}
Debug.Log(playerFacingDirection);
}
public void FireProjectile(float speed, float travelDistance, AttackDetails attackDetails, float gravityScale, Vector2 direction)
{
_speed = direction * speed;
_travelDistance = travelDistance;
_gravityScale = gravityScale;
_attackDetails = attackDetails;
}
public virtual void Damage(AttackDetails attackDetails)
{
lastDamageTime = Time.time;
currentHealth -= attackDetails.damageAmount;
currentStunResistance -= attackDetails.stunDamageAmount;
DamageHop(entityData.damageHopSpeed);
Instantiate(entityData.hitParticle, aliveGo.transform.position, Quaternion.Euler(0f, 0f, Random.Range(0f, 360f)));
if (attackDetails.position.x > aliveGo.transform.position.x)
{
lastDamageDirection = -1;
}
else
{
lastDamageDirection = 1;
}
if (currentStunResistance <= 0)
{
isStunned = true;
}
if (currentHealth <= 0)
{
isDead = true;
}
}
public override void ReceiveDamage(float directionHitX, float maxHitContactY, AttackDetails attack)
{
// nur attack Damage relevant
if (attack != null && attack.damage > 0)
{
currentHealth -= attack.damage;
InstantiateEffect(damageEffect);
InstantiateEffect(explosionEffect);
SoundManager.PlaySFX(damageSound);
if (currentHealth <= 0)
{
// destroyed
Debug.Log("Destroyed!");
spriteRenderer.sprite = destroyedSprite;
boxCollider.enabled = false;
}
else if (currentHealth < 2)
{
// damageSprite
Debug.Log("Damage!");
spriteRenderer.sprite = damageSprite;
}
}
}
//--OTHER FUNCTIONS-----------------------------------------------------------------------------------------------------------------
private void Damage(AttackDetails attackDetails)
{
currentHealth -= attackDetails.damageAmount;
Instantiate(hitParticle, alive.transform.position, Quaternion.Euler(0.0f, 0.0f, Random.Range(0.0f, 360.0f)));
if (attackDetails.position.x > alive.transform.position.x)
{
damageDirection = -1;
}
else
{
damageDirection = 1;
}
//Hit particle
if (currentHealth > 0.0f)
{
SwitchState(State.Knockback);
}
else if (currentHealth <= 0.0f)
{
SwitchState(State.Dead);
}
}
IEnumerator SetBuffActive(AttackDetails attack, int index)
{
isBuffActive[index] = true;
yield return(new WaitForSeconds(attack.BuffDuration));
isBuffActive[index] = false;
}
public void damage(AttackDetails attackDetails)
{
if (!invincible)
{
damageSource.GenerateImpulse();
StartCoroutine("hitFlash");
currentHealth -= attackDetails.damageAmount;
healthBar.SetHealth(currentHealth);
StartCoroutine("InvincibleTimer");
if (currentHealth <= 0)
{
FindObjectOfType <AudioManager>().Play("PlayerDeath");
FindObjectOfType <AudioManager>().stopPlaying("LevelTheme");
source.GenerateImpulse();
Instantiate(playerDeathParticle, transform.position, transform.rotation);
crosshair.isGameOver = true;
levelManager.StartCoroutine("gameOver");
gameObject.SetActive(false);
}
else
{
FindObjectOfType <AudioManager>().Play("PlayerHurt");
}
}
}
public virtual void Damage(AttackDetails p_attackDetails)
{
_lastDamageTime = Time.time;
_currentHealth -= p_attackDetails.damage;
_currentStunResistance -= p_attackDetails.stunDamage;
Hop(entityData.hopSpeedX, entityData.hopSpeedY);
if (p_attackDetails.position.x > aliveGO.transform.parent.position.x)
{
lastDamageDirection = -1;
}
else
{
lastDamageDirection = 1;
}
if (_currentStunResistance <= 0)
{
isStunned = true;
}
if (_currentHealth <= 0)
{
isDead = true;
}
}
public void Damage(AttackDetails attackDetails)
{
RB.AddForce(new Vector2(attackDetails.attackerFacingDirection, 0.375f) * 4, ForceMode2D.Impulse);
if (!indestructible)
{
currentHealth -= attackDetails.damageAmount;
}
}
public void Knockback(AttackDetails attackDetails)
{
knockbackDirection = attackDetails.position.x > transform.position.x ? -1 : 1;
isKnockbacked = true;
knockbackStartTime = Time.time;
myRigidbody2D.velocity = new Vector2(knockbackSpeed.x * knockbackDirection, knockbackSpeed.y);
}
public void CheckIfDamage(AttackDetails attackDetails)
{
if (CanBeHurt)
{
CurrentHealth -= attackDetails.damageAmount;
Debug.Log("Current Health is " + CurrentHealth);
}
}
public void Damage(AttackDetails damageDetail)
{
bossHealth -= damageDetail.damageAmount;
hurt = true;
var renderer = head.GetComponent <Renderer> ();
prevColor = renderer.material.GetColor("_Color");
HitColor();
}
void SetAttackProperties(AttackDetails attackDetails)
{
currentBtn = attackDetails.attackBtn;
tooltipManager = attackDetails.gameObject.GetComponent <Tooltip>();
tooltipManager.SetTooltipData(attackDetails.attackName,
"Put the ability description here.");
pointerDown = true;
}
public override void Damage(AttackDetails attackDetails)
{
base.Damage(attackDetails);
if (isDead)
{
stateMachine.ChangeState(deadState);
}
}
private void _____ATTACK___(AttackDetails _Atk_details, ref Label L_statue, ref Label L_code, ref LinkLabel L_source, ref Label hint, string attacker = "")
{
Notify(_Atk_details.Target + " Attacking ");
L_statue.Text = L_code.Text = "...";
__HTTTPAttack_ at = new __HTTTPAttack_();
at.Payload = _Atk_details.Payload;
at._Url = _Atk_details.URL;
at.SetTargetHeader(_Atk_details.Target);
at.Attack_Current_Header();
at.owner = _Atk_details.Owner;
if (at.Succeeded)
{
if (at.IsCurrentHeaderVulnerable())
{
L_statue.Text = "Vulnerable " + Payloads.Percent(at.Payload);
}
else
{
L_statue.Text = "Not Vulnerable";
}
}
else
{
L_statue.Text = "Error ";
}
L_code.Text = at.statueCode;
AddAttackToList(at);
L_code.Visible = true;
switch (attacker.ToLower().Trim())
{
case "cus": __CustomAttack = __HTTTPAttack_.Copy(at); break;
case "xf":
case "x-forwarded-for": __XfrwrdAttack = __HTTTPAttack_.Copy(at); break;
case "c*k":
case "cookie": __CookieAttack = __HTTTPAttack_.Copy(at); break;
case "ua":
case "useragent":
case "user-agent": __UserAgentAttack = __HTTTPAttack_.Copy(at); break;
case "ref":
case "referer": __RefererAttack = __HTTTPAttack_.Copy(at); break;
case "mul":
case "multi": __MultidAttack = __HTTTPAttack_.Copy(at); break;
}
hint.Text = at.Message;
hint.Visible = true;
this.Notify(at.Summary(), 3000);
}
public void OnTriggerEnter2D(Collider2D collision)
{
if (collision.gameObject.layer == LayerMask.NameToLayer("Player"))
{
AttackDetails ad = new AttackDetails();
ad.damageAmount = 1;
ad.position = transform.position;
collision.gameObject.GetComponent <IDamagable>().Damage(ad);
}
}
private void Damage(AttackDetails attackerDetails)
{
if (!pc.GetDashStatus())
{
int direction = attackerDetails.position.x < transform.position.x ? 1 : -1;
ps.DecreaseHealth(attackerDetails.damageAmount);
pc.Knockback(direction);
}
}
public AttackingHeavyState()
{
//Init Effect Prefab
dustEffect = Resources.Load(DUST_EFFECT_PREFAB_NAME);
// Define Attack Details
attack = new AttackDetails(); // default attack
attack.type = AttackDetails.AttackType.Sharp;
attack.pushOnDamage = false; // light attack no push
attack.criticalHitPercent = 0.5f; // 50% crit
}
public AttackingCombo1State()
{
//Init Effect Prefab
dustEffect = Resources.Load(DUST_EFFECT_PREFAB_NAME);
// Define Attack Details
attack = new AttackDetails(); // default attack
attack.type = AttackDetails.AttackType.Sharp;
attack.pushSpeed = 1.5f;
attack.criticalHitPercent = 0.5f; // 50% crit
}
