/// <summary> /// Is called when walls next to the main dmaged walls are damaged by proxy. Doesn't call damageConnectedWalls, hence the "non recursive". Will NOT update corners. /// </summary> /// <param name="damage"></param> /// <param name="damageType"></param> public void nonRecursiveDealDamage(float damage, Elements.DamageType damageType) { //No damage is dealt if the block's damage type is equal to the source's damage type, as long as they aren't the normal types (blunt/sharp) float finalDamage = damage - armor; if (finalDamage < 1) { return; } if (damageType != Elements.DamageType.Blunt && damageType != Elements.DamageType.Sharp && damageType == getDamageType()) { return; } finalDamage *= elementEffectiveness(damageType); life -= finalDamage; if (life <= 0) { destroy(); } else { updateChildCracks(); } }
public override void initStats() { damageType = Elements.DamageType.Blunt; cooldown = 0.55f - Mathf.Min(0.02f * user.FITNESS, 0.15f); cost = 1.5f; range = 0.6f; damage = 3 + user.STRENGTH * 0.7f; // it's fine pushback = 3 + user.STRENGTH * 1.5f; }
/// <summary> /// Deals damage to this block (will only be called for walls). the controller should be a Person's object, not a projectile/ability. Will update corners (and might damage connected walls). /// </summary> public void dealDamage(float damage, float pushback, GameObject damageSourceController, Elements.DamageType damageType) { //No damage is dealt if the block's damage type is equal to the source's damage type, as long as they aren't the normal types (blunt/sharp) float finalDamage = damage + pushback - armor; if (finalDamage < 1) { return; } if (damageType != Elements.DamageType.Blunt && damageType != Elements.DamageType.Sharp && damageType == getDamageType()) { return; } finalDamage *= elementEffectiveness(damageType); life -= finalDamage; if (life <= 0) { destroy(); } else { updateChildCracks(); } if (finalDamage >= 30 - armor) { damageConnectedWalls(finalDamage + armor, damageSourceController, damageType); } updateCorners(); }
/// <summary> /// Returns the effectiveness multiplier. Default is 1. Is 2 if the attack is super-effective (e.g. Fire VS Plant) and 0.5 if it's not efective (e.g. Acid VS Cement). Hard-coded! /// </summary> /// <param name="damageType"></param> /// <returns></returns> public float elementEffectiveness(Elements.DamageType damageType) { switch (damageType) { case Elements.DamageType.Blunt: return(1); case Elements.DamageType.Sharp: return(1); case Elements.DamageType.Burn: if (type == Type.wPlant) { return(2); } if (type == Type.wIce) { return(2); } if (type == Type.wFlesh) { return(2f); } if (type == Type.wMetal) { return(0.5f); } if (type == Type.wCement) { return(0.5f); } if (type == Type.wEarth) { return(0.5f); } return(1); case Elements.DamageType.Acid: if (type == Type.wFlesh) { return(2); } if (type == Type.wMetal) { return(2f); } if (type == Type.wIce) { return(0.5f); } if (type == Type.wCement) { return(0.5f); } return(1); case Elements.DamageType.Shock: if (type == Type.wFlesh) { return(2); } if (type == Type.wMetal) { return(0f); } return(0.5f); default: Debug.LogError("Weird damage type for the damage of the damag source that dealt damage to this damaged block pls halp"); return(10); } }
/// <summary> /// Is called when the wall is heavily damaged (30+ damage). Will damage nearby walls. Will update corners. /// </summary> public void damageConnectedWalls(float damage, GameObject damageSourceController, Elements.DamageType damageType) { float radius = damage / 11; //why 11? I dunno Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, radius, LayerMask.NameToLayer("Walls")); float minX = transform.position.x, minY = transform.position.y, maxX = transform.position.x, maxY = transform.position.y; foreach (Collider2D c in colliders) { Block wall = c.gameObject.GetComponent <Block>(); if (wall == null) { Debug.LogError("Pastramamia! " + c.gameObject.name); } if (wall.transform.position == this.transform.position) { continue; } //damage = damage divided by the distance float itsDamage = damage / (c.gameObject.transform.position - transform.position).magnitude; wall.nonRecursiveDealDamage(itsDamage, damageType); minX = Mathf.Min(minX, c.transform.position.x); minY = Mathf.Min(minY, c.transform.position.y); maxX = Mathf.Max(maxX, c.transform.position.x); maxY = Mathf.Max(maxY, c.transform.position.y); } Environment env = GetComponentInParent <Environment>(); //neat function! env.updateCornersStandard((int)minX, (int)minY, (int)maxX, (int)maxY); //TODO make sure I don't need to add 0.5 or something, because of chunk offset }