void Awake()
{
plant_list.Add(this);
select = GetComponent <Selectable>();
destruct = GetComponent <Destructible>();
unique_id = GetComponent <UniqueID>();
}
// Collision behavior
public void OnCollisionEnter2D(Collision2D collision)
{
// Check if the collision was with a viable target
foreach (string targetTag in collidableTags)
{
if (collision.collider.tag == targetTag)
{
//TODO add hit effect
Destructible e = collision.collider.GetComponent <Destructible>();
// Hit behavior (allow first frame tolerance so bullet doesn't collide with shooter upon spawn)
if (e != null)
{
// For simplicity, collision damage is not scaled with angle of contact since the "shell" is big
// Hence, there's some part of it that can be considered normal to the armor
// Calculate effective damage [Damage = mass1 * mass2 * relative velocity ^ 2 / 256 - effectiveDefense]
// Scaling factor by 1/256 to base damage to account for mass and velocity.
Rigidbody2D erb = e.gameObject.GetComponent <Rigidbody2D>();
float edamage = mass * erb.mass * Mathf.Pow((rb.velocity - erb.velocity).magnitude, 2) / 256 - e.defense;
float damage = edamage + e.defense - defense;
Debug.Log("Collision Damage" + damage);
e.TakeDamage(edamage);
TakeDamage(damage);
}
}
}
}
//Spawn an existing one in the save file (such as after loading)
public static Plant Spawn(string uid)
{
SowedPlantData sdata = PlayerData.Get().GetSowedPlant(uid);
if (sdata != null)
{
PlantData pdata = PlantData.Get(sdata.plant_id);
if (pdata != null)
{
GameObject prefab = pdata.GetStagePrefab(sdata.growth_stage);
GameObject build = Instantiate(prefab, sdata.pos, prefab.transform.rotation);
Plant plant = build.GetComponent <Plant>();
plant.data = pdata;
plant.was_built = true;
plant.unique_id.unique_id = uid;
Destructible destruct = plant.GetComponent <Destructible>();
if (destruct != null)
{
destruct.was_built = true;
}
return(plant);
}
}
return(null);
}
public void explode()
{
Collider[] hits = Physics.OverlapSphere(transform.position, explosionRadius);
foreach (var hit in hits)
{
GameObject hitObj = hit.gameObject;
float DistanceDamageMultiplier = Vector3.Distance(transform.position, hitObj.transform.position) / 10;
Destructible dst = hitObj.GetComponent <Destructible>();
if (dst != null)
{
//Debug.Log("DAMAGE! " + kineticDamage * DistanceDamageMultiplier + " " + electricDamage * DistanceDamageMultiplier);
dst.TakeDamage(kineticDamage * DistanceDamageMultiplier, electricDamage * DistanceDamageMultiplier);
}
}
if (explosionEffectPrefab != null)
{
Instantiate(explosionEffectPrefab, transform.position, transform.rotation);
//explosionEffect.Play();
}
if (soundEffect != null)
{
var sfx = Instantiate(soundEffect, transform.position, transform.rotation);
var audioSource = sfx.GetComponent <AudioSource>();
audioSource.volume = GameManager.Instance.miscVolume;
audioSource.Play();
sfx.GetComponent <DelayedDestroyer>().StartCountdown();
}
killBullet();
}
public void OnTriggerEnter2D(Collider2D collision)
{
if (pookie == null)
{
pookie = GameObject.FindGameObjectWithTag("Player");
}
if (collision.gameObject.tag == "Enemy")
{
enemy = (Enemy)collision.gameObject.GetComponent(typeof(Enemy));
if (Time.time > nextDamage)
{
nextDamage = Time.time + damageCooldown;
enemy.getDamaged(damage, pookie);
}
}
if (collision.gameObject.tag == "Destructible")
{
Destructible destructible = (Destructible)collision.gameObject.GetComponent(typeof(Destructible));
if (Time.time > nextDamage)
{
nextDamage = Time.time + damageCooldown;
destructible.getDamaged(damage, pookie);
}
}
}
public void ExplodeLevePalette()
{
Instantiate(explosionEffect, transform.position, transform.rotation);
CameraShaker.Instance.ShakeOnce(5f, 5f, .2f, 2f);
FindObjectOfType <AudioManager>().Play("LevelPalette");
Debug.Log("Boom from little car !");
Collider[] collidersToDestroy = Physics.OverlapSphere(transform.position, radius);
foreach (Collider nearbyObject in collidersToDestroy)
{
Destructible dest = nearbyObject.GetComponent <Destructible>();
if (dest != null)
{
dest.Destroy();
Destroy(this);
}
}
Collider[] collidersToMove = Physics.OverlapSphere(transform.position, radius);
foreach (Collider nearbyObject in collidersToMove)
{
Rigidbody rb = nearbyObject.GetComponent <Rigidbody>();
if (rb != null)
{
rb.AddExplosionForce(force, transform.position, radius);
Destroy(this);
}
}
}
void OnDamage(Destructible sender, float damage)
{
if (sender.destroyed)
{
Impact();
}
}
public int ReactToHit(Color color) //color = color of gun
{
float r = rend.material.color.r, g = rend.material.color.g, b = rend.material.color.b;
int score = 0;
//we take off the colors from the gun on the candy.
if (color.r == 1 && r == 1)
{
r = 0;
score++;
}
if (color.g == 1 && g == 1)
{
g = 0;
score++;
}
if (color.b == 1 && b == 1)
{
b = 0;
score++;
}
rend.material.color = new Color(r, g, b, 1.0f);
if (r == g && r == b && r == 0) //if the candy has no more color, we destroy it.
{
Destructible des = GetComponent <Destructible>();
des.Die();
}
return(score);
}
void Shoot()
{
muzzleFlash.Play();
currentAmmo--;
RaycastHit hit;
if (Physics.Raycast(weaponCamera.transform.position, weaponCamera.transform.forward, out hit, range))
{
Destructible target = hit.transform.GetComponent <Destructible>();
if (target != null)
{
target.TakeDamage(damage);
}
if (hit.rigidbody != null)
{
hit.rigidbody.AddForce(-hit.normal * weaponStrength);
}
ParticleSystem bulletHole = Instantiate(impactEffect, hit.point, Quaternion.LookRotation(hit.normal));
bulletHole.transform.SetParent(hit.transform);
}
}
//Spawn an existing one in the save file (such as after loading)
public static Construction Spawn(string uid)
{
BuiltConstructionData bdata = PlayerData.Get().GetConstructed(uid);
if (bdata != null)
{
ConstructionData cdata = ConstructionData.Get(bdata.construction_id);
if (cdata != null)
{
GameObject build = Instantiate(cdata.construction_prefab, bdata.pos, cdata.construction_prefab.transform.rotation);
Construction construct = build.GetComponent <Construction>();
construct.data = cdata;
construct.was_built = true;
construct.unique_id.unique_id = uid;
Destructible destruct = construct.GetComponent <Destructible>();
if (destruct != null)
{
destruct.was_built = true;
}
return(construct);
}
}
return(null);
}
public Attack(Destructible target, string layer, Entity entity) : base(entity)
{
this.target = target;
lastPosition = target.transform.position;
ignoreLayer = LayerMask.GetMask(layer);
finalMask = interactalbeLayer | doorLayer | projectileLayer | defaultLayer | ignoreLayer;
}
public void FinishContruction()
{
building_mode = false;
is_overlap = false;
selectable.enabled = true;
foreach (Collider collide in colliders)
{
collide.isTrigger = false;
}
destruct = GetComponent <Destructible>();
if (destruct)
{
destruct.enabled = true;
destruct.was_built = true;
}
SetModelColor(Color.white);
BuiltConstructionData cdata = PlayerData.Get().AddConstruction(data.id, SceneNav.GetCurrentScene(), transform.position);
unique_id.unique_id = cdata.uid;
if (build_fx != null)
{
Instantiate(build_fx, transform.position, Quaternion.identity);
}
TheAudio.Get().PlaySFX("construction", build_audio);
if (onBuild != null)
{
onBuild.Invoke();
}
}
void FireRay()
{
RaycastHit hit;
Ray ray = new Ray(flameGameobject.transform.position, flameGameobject.transform.forward);
if (Physics.Raycast(ray, out hit, 1000f))
{
if (hit.collider.tag == "environment" || hit.collider.tag == "Soldier")
{
Debug.Log("Collision with environment");
Collider[] colliders = Physics.OverlapSphere(hit.point, explosionRadius);
GameObject cubehit = Instantiate(GameObject.CreatePrimitive(PrimitiveType.Cube), hit.point, Quaternion.identity);
Destroy(cubehit, 0.2f);
foreach (Collider collider in colliders)
{
Rigidbody rb = collider.GetComponent <Rigidbody>();
if (rb != null)
{
rb.AddExplosionForce(explosionForce, hit.point, explosionRadius);
}
Destructible dest = collider.GetComponent <Destructible>();
if (dest != null)
{
dest.Destroy();
}
}
}
}
}
void Explosion()
{
if (Input.GetMouseButton(0))
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, 1000))
{
Collider[] colliders = Physics.OverlapSphere(hit.point, explosionRadius);
foreach (Collider collider in colliders)
{
Rigidbody rb = collider.GetComponent <Rigidbody>();
if (rb != null)
{
rb.AddExplosionForce(explosionForce, hit.point, explosionRadius);
}
Destructible dest = collider.GetComponent <Destructible>();
if (dest != null)
{
dest.Destroy();
}
}
}
}
}
// Use this for initialization
void Start()
{
GameObject asteroidGroup = new GameObject();
asteroidGroup.name = "Asteroid Field";
for (float i = 0; i < totalNumberOfAsteroids; ++i)
{
Vector3 distance = (new Vector3(Random.value, Random.value, Random.value) - new Vector3(0.5f, 0.5f, 0.5f));
distance.x *= distanceFromFactory.x;
distance.y *= distanceFromFactory.y;
distance.z *= distanceFromFactory.z;
GameObject iAsteroid = Instantiate(asteroids[Random.Range(0, asteroids.Length)], transform.position + distance, Random.rotation) as GameObject;
float randomScale = maxSize - (maxSize - minSize) * Random.value;
iAsteroid.transform.localScale *= randomScale;
iAsteroid.rigidbody.mass *= randomScale;
Destructible destructibleScript = iAsteroid.GetComponent <Destructible>();
destructibleScript.maxHealth = (int)(destructibleScript.maxHealth * randomScale);
destructibleScript.curHealth = (int)(destructibleScript.curHealth * randomScale);
if (randomScale > 1)
{
i += (randomScale) - 1;
}
iAsteroid.transform.parent = asteroidGroup.transform;
}
}
void Explode()
{
Instantiate(explosionEffect, transform.position, Quaternion.identity);
Collider[] colliders = Physics.OverlapSphere(transform.position, explosionRadius);
foreach (var nearbyObject in colliders)
{
if (nearbyObject.gameObject == FPSPlayer)
{
FPSPlayer.GetComponent <Target>().Die();
}
Rigidbody rb = nearbyObject.GetComponent <Rigidbody>();
if (rb != null)
{
rb.AddExplosionForce(explosionForce, transform.position, explosionRadius);
}
Destructible dest = nearbyObject.GetComponent <Destructible>();
if (dest != null)
{
dest.Destroy();
}
}
Destroy(gameObject);
}
void Explode()
{
GameObject CurExplosion = Instantiate(Explosion, transform.position + Vector3.up, Quaternion.identity);
Transform player = GameObject.FindGameObjectWithTag("Player").transform;
float Distance = Vector3.Distance(transform.position, player.position);
if (Distance < 30)
{
CameraShake shaker = CameraShake.instance;
shaker.duration = ShakeDuration;
shaker.power = ShakeStrenght - Distance / 100;
shaker.ShouldShake = true;
}
//Destroy nearby enemies
Collider[] Enemies;
Enemies = Physics.OverlapSphere(transform.position, Radius);
for (int i = 0; i < Enemies.Length; i++)
{
Destructible destructible = Enemies[i].GetComponent <Destructible>();
if (destructible != null)
{
destructible.OnDamage(damage);
}
}
//Destroy trash
Destroy(CurExplosion, 5);
Destroy(gameObject);
}
void OnTriggerExit2D(Collider2D other)
{
so = null;
sensedObj = null;
//player.sensingDestructible = false;
senseDestructible = false;
}
public void OnModuleDamaged(Destructible subject)
{
if (OnHpAmountChanged != null)
{
OnHpAmountChanged();
if (this.GetComponent <ShipController>() != null)
{
string name = subject.referencedObject.type.ToString().ToLower();
name = char.ToUpper(name[0]) + name.Substring(1);
if (name.IndexOf("_") >= 0)
{
name = name.Substring(0, name.IndexOf('_')) + char.ToUpper(name[name.IndexOf('_') + 1]) + name.Substring(name.IndexOf('_') + 2);
}
float hp = 0;
float maxHp = 0;
for (int i = 0; i < modules.Count; i++)
{
if (modules[i].referencedObject.type == subject.referencedObject.type)
{
hp += modules[i].referencedObject.hp;
maxHp += modules[i].referencedObject.maxHp;
}
}
GameObject module = GameObject.Find("GUI").transform.FindChild("Game").FindChild("Modules").FindChild(name).gameObject;
if (!module.activeSelf)
{
module.SetActive(true);
}
GameObject.Find("GUI").transform.FindChild("Game").FindChild("Modules").FindChild(name).GetComponent <Text>().text = (int)(hp / (maxHp / 100)) + "%";
}
}
}
void Explode()
{
Instantiate(explosionEffect, transform.position, transform.rotation);
Collider[] collidersToDestroy = Physics.OverlapSphere(transform.position, radius);
foreach (Collider nearbyObject in collidersToDestroy)
{
Destructible dest = nearbyObject.GetComponent <Destructible>();
if (dest != null)
{
dest.Destroy();
}
}
Collider[] collidersToMove = Physics.OverlapSphere(transform.position, radius);
foreach (Collider nearbyObject in collidersToMove)
{
Rigidbody rb = nearbyObject.GetComponent <Rigidbody>();
if (rb != null)
{
rb.AddExplosionForce(force, transform.position, radius);
}
}
Debug.Log("Boom!");
Destroy(gameObject);
}
void OnTriggerEnter(Collider other)
{
//Vector3 closest = other.ClosestPoint(transform.position);
Vector3 dir = (other.transform.position - transform.position).normalized; //((closest - transform.position ).normalized + Vector3.up * 0.1f).normalized;
Debug.DrawLine(transform.position, transform.position + dir, Color.magenta, 4);
Rigidbody rigid = FindRigidbody(other.transform);
if (rigid != null)
{
rigid.AddForce(dir * 3, ForceMode.Impulse);
rigid.AddForce(Vector3.up * 1.5f, ForceMode.Impulse);
AlarmClock alarm = rigid.gameObject.GetComponent <AlarmClock>();
if (alarm != null)
{
alarm.Snooze();
}
}
Destructible dest = rigid != null?rigid.gameObject.GetComponent <Destructible>() : FindDestructible(other.transform);
if (dest != null)
{
dest.SufferDamage();
}
}
void Explode()
{
Instantiate(explosionEffect, transform.position, transform.rotation);
//function that allows us to create a shpere that we want the objects to interact with
//returns array
Collider[] collidersToDestroy = Physics.OverlapSphere(transform.position, radius);
//in the first loop we destroy and in the second we apply forces
foreach (Collider nearbyObject in collidersToDestroy)
{
//destroy in pieces
Destructible des = nearbyObject.GetComponent <Destructible>();
if (des != null)
{
des.Destroy();
}
}
Collider[] collidersToMove = Physics.OverlapSphere(transform.position, radius);
foreach (Collider nearbyObject in collidersToMove)
{
Rigidbody rb = nearbyObject.GetComponent <Rigidbody>();
if (rb != null)
{
//built in unity function
rb.AddExplosionForce(force, transform.position, radius);
}
}
Destroy(gameObject);
}
static void Prefix(Destructible __instance)
{
Dbgl($"destroyed destructible {__instance.name}");
foreach (string key in seedsDic.Keys)
{
Dbgl($"key: {key}");
}
string name = seedsDic.FirstOrDefault(s => __instance.name.StartsWith(s.Key)).Value;
if (name != null)
{
Dbgl($"destroyed trunk {__instance.name}, trying to spawn {name}");
GameObject prefab = ZNetScene.instance.GetPrefab(name);
if (prefab != null)
{
Dbgl($"trying to spawn new tree");
context.StartCoroutine(SpawnTree(prefab, __instance.transform.position));
}
else
{
Dbgl($"prefab is null");
}
}
}
void OnTriggerEnter2D(Collider2D col)
{
EnemyController enemy = col.GetComponent <EnemyController>();
EnemyController1 enemy1 = col.GetComponent <EnemyController1>();
EnemyController3 enemy3 = col.GetComponent <EnemyController3>();
EnemyController4 enemy4 = col.GetComponent <EnemyController4>();
EnemyController5 enemy5 = col.GetComponent <EnemyController5>();
Destructible des = col.GetComponent <Destructible>();
if (enemy != null)
{
enemy.TakeDamage(40);
}
else if (enemy1 != null)
{
enemy1.TakeDamage(40);
}
else if (enemy3 != null)
{
enemy3.TakeDamage(40);
}
else if (enemy4 != null)
{
enemy4.TakeDamage(40);
}
else if (enemy5 != null)
{
enemy5.TakeDamage(40);
}
else if (des != null)
{
des.TakeDamage(40);
}
Destroy(gameObject);
}
protected void ReloadCharacterNew()
{
//base.ReloadCharacter();
if (base.CharacterObject == null)
{
return;
}
//this.m_enableDifficultyIndicators = (GameState.Option.LevelScaling == LevelScalingOption.None && GameState.Option.ShowDifficultyIndicators);
m_enableDifficultyIndicators = true; // always force
Destructible component = ComponentUtils.GetComponent <Destructible>(base.CharacterObject as MonoBehaviour);
if (component != null || SingletonBehavior <PartyManager> .Instance.IsActivePartyMember(base.CharacterObject as CharacterStats))
{
this.m_sprite.alpha = 0f;
return;
}
if (this.m_onlyIfHostile)
{
Faction component2 = ComponentUtils.GetComponent <Faction>(base.CharacterObject as MonoBehaviour);
if (component2 && component2.GetRelationshipToPlayer() != Relationship.Hostile)
{
this.m_sprite.alpha = 0f;
return;
}
}
else
{
string levelDifficultySprite = GetLevelDifficultySprite(base.CharacterObject);
this.m_sprite.spriteName = levelDifficultySprite;
this.m_sprite.MakePixelPerfect();
this.m_sprite.alpha = (string.IsNullOrEmpty(levelDifficultySprite) ? 0f : 1f);
}
}
private void OnTriggerStay(Collider other)
{
float distance = Vector3.Distance(transform.position, other.transform.position);
float distanceCoefficient = 1.0f - distanceDependency * distance / range;
switch (other.gameObject.layer)
{
case GameLayer.Units:
{
if (other.gameObject == owner.gameObject)
{
break;
}
Unit targetUnit = other.GetComponent <Unit>();
targetUnit.ReceiveDamage(damage * distanceCoefficient * Time.deltaTime, damageType);
break;
}
case GameLayer.Items:
{
Item targetItem = other.GetComponent <Item>();
targetItem.ReceiveDamage(damage * distanceCoefficient * Time.deltaTime, damageType);
break;
}
case GameLayer.Destructibles:
{
Destructible targetDestructible = other.GetComponent <Destructible>();
targetDestructible.ReceiveDamage(damage * distanceCoefficient * Time.deltaTime, damageType);
break;
}
}
}
void Update()
{
Destructible d = GetComponent <Destructible>();
if (!d.Destroyed)
{
if (CurrentTarget != null)
{
Destructible targetDest = CurrentTarget.GetComponent <Destructible>();
if (!targetDest.Destroyed)
{
Actor a = GetComponent <Actor>();
Weapon w = a.MainWeapon();
Vector3 vecToTarget = CurrentTarget.transform.position - transform.position;
float distToTarget = vecToTarget.magnitude;
if (distToTarget < w.Projectile.Range)
{
Vector3 dirToTarget = vecToTarget.normalized;
transform.rotation = Quaternion.LookRotation(dirToTarget, Vector3.up);
w.Fire(gameObject, dirToTarget, a.Velocity);
}
}
}
}
}
void Explode()
{
GameObject spawnedParticle = Instantiate(exploParticle, transform.position, transform.rotation);
Destroy(spawnedParticle, 1);
Collider [] collidersToDeatroy = Physics.OverlapSphere(transform.position, radius);
foreach (Collider nearbyObject in collidersToDeatroy)
{
Destructible dest = nearbyObject.GetComponent <Destructible>();
if (dest != null)
{
dest.OnGrenadeExplosion();
if (dest.towerLifeLevel <= 0)
{
dest.DestroyDestructible();
}
}
}
Collider [] collidersToPunch = Physics.OverlapSphere(transform.position, radius);
foreach (Collider nearbyObject in collidersToPunch)
{
Rigidbody rb = nearbyObject.GetComponent <Rigidbody>();
if (rb != null)
{
rb.AddExplosionForce(force, transform.position, radius);
}
}
hasExploded = true;
Destroy(gameObject);
}
private void OnStartRepair()
{
Destructible repairTarget = null;
// Find close-by destructible and start repairing it
var colliders = Physics.OverlapSphere(transform.position, RepairRadius, RepairableLayerMask, QueryTriggerInteraction.Collide);
foreach (var collider in colliders)
{
if (!collider.CompareTag("DestructibleStaticTrigger"))
{
continue;
}
var destructible = collider.GetComponentInParent <Destructible>();
if (destructible == null || destructible.Intact)
{
continue;
}
if (destructible.Repairable == false)
{
continue;
}
repairTarget = destructible;
}
if (repairTarget == null)
{
return;
}
_currentRepairTarget = repairTarget;
repairTarget.StartRepair();
}
public override void ActionUpdate(float timekey)
{
timer += timekey;
if (timer > spawnDelay && !projectileSpawned)
{
// apply damage
Vector3 spawnPoint = character.transform.position + character.transform.TransformDirection(projectileSpawn);
projectileInstance = GameObject.Instantiate(projectile);
projectileInstance.transform.position = spawnPoint;
projectileInstance.character = character;
projectileInstance.velocity = velocity;
projectileSpawned = true;
}
if (timer > spawnDelay + timeOfFlight)
{
projectileInstance.Destroy();
Destructible destructible = target.GetComponent <Destructible>();
if (destructible != null)
{
destructible.Damage(CombatUtils.GetDamageToDestructible(destructible, baseDamage * damageModifer));
}
Done();
}
}
void renderShieldAndHealthBar()
{
if(!destructibleForPlayer){
destructibleForPlayer = transform.root.gameObject.GetComponent<Destructible>();
}
if(destructibleForPlayer){
renderShieldBar((float)destructibleForPlayer.curShield/destructibleForPlayer.maxShield);
renderHealthBar((float)destructibleForPlayer.curHealth/destructibleForPlayer.maxHealth);
}
}
public float this[Destructible.ATTRIBUTE name]
{
set
{
int ID = getAttributeIndex(name);
if (ID < 0) return;
Attributes[ID].value = value;
}
get
{
int ID = getAttributeIndex(name);
if (ID < 0)
{
Debug.Log("Uh Oh" + name.ToString()); return -1;
}
return Attributes[ID].value;
}
}
//
//Indexed Properties
//
//
//Most current indexed property
public float this[Destructible.STAT name, Stat.statPart stat]
{
get
{
int ID = getStatIndex(name);
if (ID < 0) return -1;
return Stats[ID][stat];
}
set
{
int ID = getStatIndex(name);
if (ID < 0)
{
Debug.Log("SOMETHING WENT WRONG!! " + name);
return;
}
Stats[ID][stat] = value;
}
}
public virtual bool IsInGroup(Destructible destructible)
{
foreach (var v in GetDestructibles())
if (v == destructible) return true;
return false;
}
private void Hit(Destructible target)
{
int damage = CalculateDamage(target);
if (IsCritting)
target.Hit(Performer, damage, CritAttackType, this);
else
target.Hit(Performer, damage, AttackType, this);
if (ApplyBuffToTargets != null && target is Unit)
{
var b = (Buff)ApplyBuffToTargets.Clone();
((Unit)target).AddBuff(b, (Unit)Performer, Mediator);
}
OnHit(target);
}
public override float AIPriority(Unit performer, Vector3 targetPosition, Destructible targetUnit)
{
float mod = 1;
if (Performer.HitPoints > 0.8f * Performer.MaxHitPoints) mod = 0.0001f;
return base.AIPriority(performer, targetPosition, targetUnit) * mod;
}
protected override int GetValue(Destructible d)
{
var u = d as Unit;
return u.CanPerformAbilitiesBlockers;
}
protected override void EndPerform(bool aborted)
{
base.EndPerform(aborted);
if (unit != null)
{
unit.TakesDamage -= new TakesDamageEventHandler(unit_TakesDamage);
unit = null;
}
}
protected virtual int GetMaxValue(Destructible d)
{
return GetValue(d);
}
public virtual bool IsInEffectiveRange(Destructible target, float tolerance)
{
return Common.Math.CircleArcIntersection(Common.Math.ToVector2(target.Position),
target.HitRadius,
Common.Math.ToVector2(MediatorOffsetedPosition), EffectiveRange * tolerance, Mediator.LookatDir,
EffectiveAngle);
}
protected abstract void SetValue(Destructible d, int value);
public override float AIPriority(Unit performer, Vector3 targetPosition, Destructible targetUnit)
{
if (IsPerforming) return 2;
if (!IsValidTarget(targetUnit)) return -100;
if (!IsEffectiveTowardsTarget(targetPosition, targetUnit)) return -50;
if (CurrentCooldown >= 0) return 0.1f;
if (!IsInEffectiveRange(targetUnit)) return 0.5f;
return 1;
}
public bool IsInEffectiveRange(Destructible target)
{
return IsInEffectiveRange(target, 1);
}
public virtual bool AIIsInEffectiveRange(Destructible target)
{
return IsInEffectiveRange(target, AIEffectiveRangeTolerance);
}
protected override int GetValue(Destructible d)
{
var u = d as Unit;
return u.CanControlRotationBlockers;
}
protected override void SetValue(Destructible d, int value)
{
var u = d as Unit;
u.CanControlRotationBlockers = value;
}
public override float AIPriority(Unit performer, Vector3 targetPosition, Destructible targetUnit)
{
float d = Math.Max(1, (targetUnit.Position - Game.Instance.Map.MainCharacter.Position).Length());
return base.AIPriority(performer, targetPosition, targetUnit) + 0.01f / d;
}
public override bool IsPerformableTowardsTarget(Vector3 targetPosition, Destructible targetEntity)
{
float d;
if (targetEntity != null) d = targetEntity.HitDistance(Mediator.Translation);
else d = (Mediator.Translation - targetPosition).Length();
return d < PerformableRange &&
Performer.State == UnitState.Alive &&
//Performer.MotionUnit.IsOnGround &&
base.IsPerformableTowardsTarget(targetPosition, targetEntity);
}
public override bool IsEffectiveTowardsTarget(Vector3 targetPosition, Destructible targetEntity)
{
return targetEntity != null && base.IsEffectiveTowardsTarget(targetPosition, targetEntity);
}
public override bool IsEffectiveTowardsTarget(Vector3 targetPosition, Destructible targetEntity)
{
if (!(targetEntity is Unit)) return false;
return ((Unit)targetEntity).CanAddBuff(Buff) && base.IsEffectiveTowardsTarget(targetPosition, targetEntity);
}
protected abstract int GetValue(Destructible d);
protected virtual int CalculateDamage(Destructible target)
{
if (IsCritting)
{
return (int)(Damage * CritDamageMultiplier *
Math.Pow(1 + CritRowMultiplier, nCritsInRow));
}
else
return Damage;
}
protected override void StartEffectivePerform()
{
base.StartEffectivePerform();
unit = Game.Instance.Scene.GetByName(Unit) as Destructible;
unit.TakesDamage += new TakesDamageEventHandler(unit_TakesDamage);
}
protected virtual bool CanHit(Destructible target)
{
return true;
}
protected override void SetValue(Destructible d, int value)
{
var u = d as Unit;
u.CanPerformAbilitiesBlockers = value;
}
protected virtual void OnHit(Destructible target)
{
}
public override bool IsInEffectiveRange(Destructible target, float tolerance)
{
if ((Performer.Position - target.Position).Length() < 4) return false;
return base.IsInEffectiveRange(target, tolerance);
}
protected void TryHit(Destructible target)
{
if (!IsInEffectiveRange(target)) return;
if (!CanHit(target)) return;
Hit(target);
}
// Use this for initialization
void Start()
{
_destructible = GetComponent<Destructible>();
StartCoroutine(UpdateHealthRoutine());
}
public override bool IsInGroup(Destructible destructible)
{
var region = Game.Instance.Map.GetRegion(Region);
return region.BoundingRegion.GetNodeAt(destructible.Translation) != null;
}
