private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.gameObject.CompareTag(Tags.player))
{
PlayerAttacks playerAttacks = collision.gameObject.GetComponent <PlayerAttacks>();
if (playerAttacks != null)
{
if (chipType == ConstantsDictionary.CHIP_TYPE.Normal)
{
float damageDealt = DamageFormulas.CalculateBasicAttackDamage(attackDamage, playerAttacks.m_defense, ConstantsDictionary.randomK, 1f);
playerAttacks.gameObject.GetComponent <PlayerHealth>().CmdTakeDamage(damageDealt);
}
else if (chipType == ConstantsDictionary.CHIP_TYPE.Ketchup)
{
playerAttacks.gameObject.GetComponent <PlayerHealth>().CmdTakeDamage(abilityDamage + ketchupDamage);
}
else if (chipType == ConstantsDictionary.CHIP_TYPE.Mayonnaise)
{
playerAttacks.gameObject.GetComponent <PlayerHealth>().CmdTakeDamage(abilityDamage);
playerAttacks.gameObject.GetComponent <PlayerController>().SpeedChange(-0.5f, mayonnaiseDuration);
}
}
NetworkServer.Destroy(gameObject);
}
if (collision.gameObject.CompareTag(Tags.building))
{
NetworkServer.Destroy(gameObject);
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.gameObject.CompareTag(Tags.player) && usingAbility1)
{
Debug.Log("Trumpled");
float damageDealt = DamageFormulas.CalculateBasicAttackDamage(basicAttackDamage, enemyController.target.GetComponent <PlayerAttacks>().m_defense, ConstantsDictionary.randomK, 1f);
collision.gameObject.GetComponent <PlayerHealth>().CmdTakeDamage(damageDealt);
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.gameObject.CompareTag(Tags.enemy))
{
if (enemiesStillToHit > 0 && !collision.gameObject.Equals(firstHitEnemy))
{
bool inComboField = false;
enemiesStillToHit--;
firstHitEnemy = collision.gameObject;
EnemyHealth enemyHealth = collision.gameObject.GetComponent <EnemyHealth>();
if (enemyHealth != null)
{
float damageDealt = DamageFormulas.CalculateBasicAttackDamage(damage, enemyHealth.defense, ConstantsDictionary.randomK, AttackTypeMultiplierFactory.SelectAttackTypeMultiplier(attackType, enemyHealth.type));
float threat;
if (inFishermanComboField)
{
threat = ConstantsDictionary.reducedComboFieldThreat;
inComboField = true;
}
else
{
threat = ConstantsDictionary.OctoChefBasicAttackThreat;
}
enemyHealth.CmdTakeDamage(damageDealt, ConstantsDictionary.PLAYERS.octo, threat);
if (inNekoMaidComboField && octoHealth.currentHealth > 0)
{
float healAmount = damageDealt * ConstantsDictionary.nekoComboRecoveredHpPercentage;
octoHealth.Heal(healAmount);
inComboField = true;
}
}
if (inComboField)
{
playerController.IncreaseUltimateCharge(ConstantsDictionary.ultiIncreaseForCombo);
}
else
{
playerController.IncreaseUltimateCharge(ConstantsDictionary.ultiIncreaseForBasicAttack);
}
}
if (enemiesStillToHit == 0)
{
NetworkServer.Destroy(gameObject);
}
}
if (collision.gameObject.CompareTag(Tags.building))
{
NetworkServer.Destroy(gameObject);
}
}
public void Explosion()
{
if (!onlyOnce)
{
return;
}
onlyOnce = false;
Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, explosionRadius, playerMask);
for (int i = 0; i < colliders.Length; i++)
{
PlayerHealth playerHealth = colliders[i].GetComponent <PlayerHealth>();
if (!playerHealth)
{
continue;
}
float damageDealt = DamageFormulas.CalculateBasicAttackDamage(basicAttackDamage, playerHealth.GetComponent <PlayerAttacks>().m_defense, ConstantsDictionary.randomK, 0.5f);
playerHealth.CmdTakeDamage(damageDealt);
}
StopAllCoroutines();
Destroy(gameObject);
//Spawn Of Childs
if (miniBoss)
{
for (int i = 0; i < popcornToSpawn; i++)
{
var popCorn = Instantiate(popcorn, transform.position, popcorn.transform.rotation);
if (NetworkServer.active)
{
NetworkServer.Spawn(popCorn);
}
}
}
else
{
for (int i = 0; i < miniPopcornToSpawn; i++)
{
var miniPopCorn = Instantiate(miniPopcorn, transform.position + new Vector3(Random.value * 0.5f, Random.value * 0.5f, 0f), miniPopcorn.transform.rotation);
if (NetworkServer.active)
{
NetworkServer.Spawn(miniPopCorn);
}
}
}
}
public override void CmdUseBasicAttack()
{
Vector3 damageArea = transform.position + ((enemyController.target.position - transform.position).normalized);
Collider2D[] colliders = Physics2D.OverlapCircleAll(damageArea, 1f, playerLayerMask);
foreach (Collider2D collider in colliders)
{
if (collider.CompareTag(Tags.player) && collider.GetComponent <PlayerHealth>() != null)
{
float damageDealt = DamageFormulas.CalculateBasicAttackDamage(basicAttackDamage, collider.GetComponent <PlayerAttacks>().m_defense, ConstantsDictionary.randomK, 0.7f);
collider.GetComponent <PlayerHealth>().CmdTakeDamage(damageDealt);
}
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.gameObject.CompareTag(Tags.player))
{
PlayerAttacks playerAttacks = collision.gameObject.GetComponent <PlayerAttacks>();
if (playerAttacks != null)
{
float damageDealt = DamageFormulas.CalculateBasicAttackDamage(attackDamage, playerAttacks.m_defense, ConstantsDictionary.randomK, 1f);
playerAttacks.gameObject.GetComponent <PlayerHealth>().CmdTakeDamage(damageDealt);
playerAttacks.gameObject.GetComponent <PlayerController>().SpeedChange(-0.5f, oilSlowDuration);
}
NetworkServer.Destroy(gameObject);
}
if (collision.gameObject.CompareTag(Tags.building))
{
NetworkServer.Destroy(gameObject);
}
}
private IEnumerator SushiDiscoDanceDamage()
{
while (started)
{
Collider2D[] hitColliders = Physics2D.OverlapCircleAll(transform.position, sushiDiscoDanceRadius);
foreach (Collider2D collider in hitColliders)
{
if (collider.gameObject.CompareTag(Tags.enemy))
{
EnemyHealth enemyHealth = collider.gameObject.GetComponent <EnemyHealth>();
enemyHealth.CmdTakeDamage(
DamageFormulas.CalculateBasicAttackDamage(
(m_basic_attack_damage + m_basic_attack_damage * sushiDiscoDancePercentageDamageIncrease),
enemyHealth.defense, ConstantsDictionary.randomK, AttackTypeMultiplierFactory.SelectAttackTypeMultiplier(m_attack_type, enemyHealth.type)), playerType, m_basic_attack_threat);
}
}
yield return(new WaitForSeconds(ConstantsDictionary.SushiDiscoDanceDamageTick));
}
}
public override void CmdUseBasicAttack()
{
if (!usingAbility1 && !usingAbility2)
{
if ((enemyController.target.transform.position - transform.position).magnitude < 2f)
{
Debug.Log("Attack 1");
currentAnimation = (int)AnimationToPlay.Attack1;
RpcSetAttackAnimation();
float damageDealt = DamageFormulas.CalculateBasicAttackDamage(basicAttackDamage, enemyController.target.GetComponent <PlayerAttacks>().m_defense, ConstantsDictionary.randomK, 1f);
enemyController.target.GetComponent <PlayerHealth>().CmdTakeDamage(damageDealt);
}
else
{
Debug.Log("Attack 2");
currentAnimation = (int)AnimationToPlay.Attack2;
RpcSetAttackAnimation();
}
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.gameObject.CompareTag(Tags.player))
{
PlayerAttacks playerAttacks = collision.gameObject.GetComponent <PlayerAttacks>();
if (playerAttacks != null)
{
float damageDealt = DamageFormulas.CalculateBasicAttackDamage(attackDamage, playerAttacks.m_defense, ConstantsDictionary.randomK, 1f);
playerAttacks.gameObject.GetComponent <PlayerHealth>().CmdTakeDamage(damageDealt);
if (miniBoss)
{
playerAttacks.gameObject.GetComponent <PlayerHealth>().TakeDotDamage(poisonPercentage, poisonDuration, poisonTick);
}
}
NetworkServer.Destroy(gameObject);
}
if (collision.gameObject.CompareTag(Tags.building))
{
NetworkServer.Destroy(gameObject);
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (current_number_of_hits > 0)
{
if (collision.gameObject.CompareTag(Tags.enemy))
{
bool inComboField = false;
current_number_of_hits--;
float basicAttackDamage = parent.m_basic_attack_damage;
if (parent.isInOctoComboField)
{
basicAttackDamage += basicAttackDamage * ConstantsDictionary.octoComboIncreasedDamagePercentage;
inComboField = true;
}
EnemyHealth enemyHealth = collision.gameObject.GetComponent <EnemyHealth>();
if (enemyHealth != null)
{
float damageDealt = DamageFormulas.CalculateBasicAttackDamage(basicAttackDamage, enemyHealth.defense, ConstantsDictionary.randomK, AttackTypeMultiplierFactory.SelectAttackTypeMultiplier(parent.m_attack_type, enemyHealth.type));
enemyHealth.CmdTakeDamage(damageDealt, parent.playerType, parent.m_basic_attack_threat);
if (parent.isInNekoComboField && parentHealth.currentHealth > 0)
{
float healAmount = damageDealt * ConstantsDictionary.nekoComboRecoveredHpPercentage;
CmdHeal(parent.gameObject, healAmount);
inComboField = true;
}
}
if (inComboField)
{
parentController.IncreaseUltimateCharge(ConstantsDictionary.ultiIncreaseForCombo);
}
else
{
parentController.IncreaseUltimateCharge(ConstantsDictionary.ultiIncreaseForBasicAttack);
}
}
}
}
public override void CmdUseBasicAttack()
{
float damageDealt = DamageFormulas.CalculateBasicAttackDamage(basicAttackDamage, enemyController.target.GetComponent <PlayerAttacks>().m_defense, ConstantsDictionary.randomK, 0.5f);
enemyController.target.GetComponent <PlayerHealth>().CmdTakeDamage(damageDealt);
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (current_number_of_hits > 0)
{
if (collision.gameObject.CompareTag(Tags.enemy))
{
bool inComboField = false;
current_number_of_hits--;
EnemyHealth enemyHealth = collision.gameObject.GetComponent <EnemyHealth>();
if (enemyHealth != null)
{
float basicAttackDamage = parent.m_basic_attack_damage;
if (parent.isInOctoComboField)
{
basicAttackDamage += basicAttackDamage * ConstantsDictionary.octoComboIncreasedDamagePercentage;
inComboField = true;
}
float damage = DamageFormulas.CalculateBasicAttackDamage(basicAttackDamage, enemyHealth.defense, ConstantsDictionary.randomK, AttackTypeMultiplierFactory.SelectAttackTypeMultiplier(parent.m_attack_type, enemyHealth.type));
float threat;
if (parent.isInFishermanComboField)
{
threat = ConstantsDictionary.reducedComboFieldThreat;
inComboField = true;
}
else
{
threat = parent.m_basic_attack_threat;
}
enemyHealth.CmdTakeDamage(damage, ConstantsDictionary.PLAYERS.neko, threat);
if (parent == null)
{
parent = GetComponentInParent <NekoMaidAttacks>();
}
if (nekoHealth == null)
{
nekoHealth = GetComponent <PlayerHealth>();
}
//se ho attivato la skill passiva kawaii dello skill tree della neko
if (parent.kawaiiPercentageOfDamageInHp > 0 && nekoHealth.currentHealth > 0)
{
nekoHealth.Heal(damage * parent.kawaiiPercentageOfDamageInHp);
}
//se ho attivato sharing is caring tutti gli altri player ricevono
//una percentuale di danni della neko in hp
if (parent.sharingIsCaringActivated)
{
foreach (GameObject player in otherPlayers)
{
PlayerHealth health = player.GetComponent <PlayerHealth>();
if (health.currentHealth > 0)
{
CmdHeal(nekoHealth.gameObject, damage * parent.sharingIsCaringPercentageOfDamageInHp);
//health.Heal(damage * parent.sharingIsCaringPercentageOfDamageInHp);
}
}
}
if (inComboField)
{
parentController.IncreaseUltimateCharge(ConstantsDictionary.ultiIncreaseForCombo);
}
else
{
parentController.IncreaseUltimateCharge(ConstantsDictionary.ultiIncreaseForBasicAttack);
}
}
}
}
}
