void Shoot(float power)
{
Debug.Log(power);
if (power == 0)
{
return;
}
RaycastHit[] c = Physics.SphereCastAll(camera.ViewportPointToRay(new Vector3(.5f, .5f)), 2f, power / 200f);
for (int i = 0; i < c.Length; i++)
{
RaycastHit hit = c[i];
if (hit.collider != null)
{
Debug.Log(hit.collider.name);
if (hit.collider.attachedRigidbody != null)
{
hit.collider.attachedRigidbody.AddForceAtPosition(camera.transform.forward * power / (hit.distance), hit.point);
}
Killable k = (hit.collider.GetComponent <Killable>());
if (k != null)
{
k.Damage(power, hit.point);
}
}
}
}
public void Fire()
{
Vector3 shootPos = transform.position + transform.up * offset;
hit = Physics2D.Raycast(shootPos, transform.up, 200f, mask);
if (hit.collider != null)
{
GameObject go = hit.collider.gameObject;
Killable kill = go.GetComponent <Killable>();
if (kill)
{
kill.Damage(damage * Time.deltaTime);
}
/*
* Rigidbody2D rb = go.GetComponent<Rigidbody2D>();
*
* if (rb) {
* rb.AddForce(transform.up * damage * Time.deltaTime);
* }
*/
}
}
void OnParticleCollision(GameObject other)
{
int numCollisionEvents = system.GetCollisionEvents(other, events);
Rigidbody rb = other.GetComponent <Rigidbody>();
Killable killable = other.GetComponentInChildren <Killable>();
if (ignoreKillables != null)
{
foreach (var k in ignoreKillables)
{
if (k == killable)
{
return;
}
}
}
for (int i = 0; i < numCollisionEvents; i++)
{
Vector3 pos = events[i].intersection;
Vector3 force = events[i].velocity.normalized * bulletForce;
if (killable)
{
killable.Damage(bulletDamage);
PoolManager.GetPooledObject("Effects", "BloodSplatSmall", pos);
}
if (rb)
{
rb.velocity += force;
//rb.AddForceAtPosition(force, pos);
}
}
}
void OnCollisionEnter2D(Collision2D collision)
{
Killable killable = collision.gameObject.GetComponent <Killable>();
if (killable)
{
killable.Damage(1);
Destroy(this.gameObject);
}
}
void Shoot()
{
hit = Physics2D.Raycast(transform.position + (transform.up * offset), transform.up, 200f, mask);
GameObject go = hit.collider ? hit.collider.gameObject : null;
if (go && go.CompareTag("Player"))
{
Killable kill = go.GetComponent <Killable>();
kill.Damage(damage);
}
}
void OnCollisionEnter2D(Collision2D coll)
{
gameObject.SetActive(false);
Killable killable = coll.gameObject.GetComponent <Killable>();
SoundController.PlayArrowHit();
if (killable != null)
{
killable.Damage(5);
}
Destroy(gameObject);
}
private void AttackLightning(Killable unit)
{
if (unit == null)
{
return;
}
AttackAnimation();
LightningController.Attack(attackPosition, unit, -1 - 15f, 0.3f);
unit.Damage(randomedDamage, type);
}
void OnCollisionEnter2D(Collision2D coll)
{
gameObject.SetActive(false);
ObjectController.CreateArrowHit(transform.position, transform.rotation, coll.gameObject.transform);
Killable killable = coll.gameObject.GetComponent <Killable>();
SoundController.PlayArrowHit();
ObjectController.CreateSmallSmoke(transform.position + transform.right * 0.5f);
Camera.main.GetComponent <FollowCamera>().Shake();
if (killable != null)
{
killable.Damage(5);
}
Destroy(gameObject);
}
void OnCollisionEnter2D(Collision2D collision)
{
GameObject obj = collision.collider.gameObject;
Killable kill = obj.GetComponent <Killable>();
if (kill && kill.team != team)
{
kill.Damage(damage);
if (killOnContact)
{
self.Die();
}
}
}
public void Update(float deltaTime)
{
if (Vector2.Distance(target.mapPosition, mapPosition) > 0.1f)
{
Vector2 direction = (target.mapPosition - mapPosition);
direction.Normalize();
mapPosition += direction * deltaTime * speed;
layer = target.layer;
}
else
{
target.Damage(damage, towerType);
Destroy();
}
}
public void Update(float deltaTime)
{
if (Vector2.Distance(target.mapPosition, mapPosition) > 0.1f)
{
progress += deltaTime * speed;
float x2 = target.mapPosition.x - startPosition.x;
float y2 = target.mapPosition.y - startPosition.y;
/*
* Vector2 dx = new Vector2 (target.mapPosition.x, 0);
* parabolicHeight = 1;
*
* Vector2 resultPosition = startPosition + progress*dx;
*
*
* //resultPosition += (Vector2.up).normalized*parabolicHeight*( Mathf.Pow (progress*dx.x, 2) - (Mathf.Pow (target.mapPosition.x, 2)
* // - (Mathf.Pow (target.mapPosition.x, 2) - target.mapPosition.y)*progress*dx.x/target.mapPosition.x ) );
*
* float x2 = Mathf.Abs (target.mapPosition.x - startPosition.x);
* float y2 = target.mapPosition.y - startPosition.y ;
* resultPosition -= (Vector2.up)*parabolicHeight*( Mathf.Abs (progress*dx.x)*( Mathf.Abs (progress*dx.x) - (x2*x2-y2)/x2));
*
* mapPosition = resultPosition;
*/
/*
* Vector2 direction = (new Vector2 (startPosition.x + (x2*x2-y2)/x2, 0) - startPosition);
* Vector2 resultPosition = startPosition + progress*direction;
* resultPosition += (new Vector2 (direction.y, Mathf.Abs (direction.x))).normalized*parabolicHeight*(1 - Mathf.Pow (2*progress - 1, 2));
* mapPosition = resultPosition;
*/
Vector2 direction = (target.mapPosition - startPosition);
Vector2 resultPosition = startPosition + progress * direction;
//resultPosition += (new Vector2 (direction.y, Mathf.Abs (direction.x))).normalized*parabolicHeight*(1 - Mathf.Pow (2*progress - 1, 2));
mapPosition = resultPosition;
layer = target.layer;
}
else
{
target.Damage(damage, towerType);
Destroy();
}
}
private void AttackLazer(Killable unit)
{
if (unit == null)
{
return;
}
attackAnimatonTime = 0.3f;
AttackAnimation();
UpdateController.Timer(attackAnimatonTime / 2f, () => {
new Lazer(attackPosition, unit, new Color(0, 1f, 1f), () => {
unit.Damage(randomedDamage, type);
}, 0.6f, 0.4f);
});
}
private void OnCollisionEnter(Collision collision)
{
//Debug.Log(collision.gameObject);
Killable killable = collision.collider.GetComponent <Killable>();
if (killable != null)
{
killable.Damage(damage);
}
if (explosionPrefab != null)
{
Instantiate(explosionPrefab, transform.position, Quaternion.Euler(collision.GetContact(0).normal));
}
particles.Stop();
GetComponent <Light>().enabled = false;
GetComponent <Collider>().enabled = false;
}
public override void LiveUpdate()
{
var displacement = (_initSpeed + MissileSpeed) * Time.deltaTime;
var observationPosition = Universe.Current.ViewPort.transform.position;
var toOberverSquared = (transform.position - observationPosition).sqrMagnitude;
if (toOberverSquared < _rayCheckMaxDistSquared)
{
if (!_hasHit)
{
var missileRay = new Ray(transform.position, transform.forward);
RaycastHit missileHit;
if (Physics.Raycast(missileRay, out missileHit, displacement, _mask))
{
if (missileHit.collider.gameObject != Owner)
{
_killable = missileHit.collider.GetComponentInParent<Killable>();
if (_killable != null)
{
if (PlayerController.Current.VehicleInstance != null && Owner == PlayerController.Current.VehicleInstance.gameObject)
HeadsUpDisplay.Current.TriggerCrosshairPulse();
_killable.Damage(Damage, missileHit.point, missileHit.normal, Owner);
}
var rBody = missileHit.collider.GetComponentInParent<Rigidbody>();
if (rBody != null)
rBody.AddForceAtPosition(MissileForce * missileRay.direction, missileHit.point, ForceMode.Impulse);
_hasHit = true;
_hitPosition = missileHit.point;
PlaceHitEffects(missileHit.point, missileHit.normal, missileHit.collider.gameObject.transform);
}
}
}
}
else
{
if (toOberverSquared > _stopDistanceSquared)
{
Stop();
}
}
_shiftable.Translate(transform.forward * displacement);
}
void Explode(GameObject[] targets)
{
foreach (GameObject target in targets)
{
Killable kill = target.GetComponent <Killable>();
if (kill)
{
kill.Damage(damage);
}
}
Instantiate(explodeParticles, transform.position, Quaternion.identity);
Killable self = GetComponent <Killable>();
if (self)
{
self.Die();
}
}
// Update is called once per frame
void Update()
{
//Move shot towards target
transform.position += (Target - transform.position).normalized * (Speed * Time.deltaTime);
//Damage if shot lands and destroy shot object
if (Vector3.Distance(transform.position, Target) < CheckDistance)
{
Collider[] victims = Physics.OverlapSphere(transform.position, Radius, LayerMask.GetMask("Enemies"));
foreach (Collider victim in victims)
{
Killable victimKillable = victim.gameObject.GetComponent <Killable> ();
victimKillable.Damage(Damage);
}
Destroy(gameObject);
}
}
private void Explode()
{
var explodeInstance = ResourcePoolManager.GetAvailable(ExplodePrefab, transform.position, transform.rotation); //(GameObject)Instantiate(ExplodePrefab, transform.position, transform.rotation);
explodeInstance.transform.localScale = transform.localScale;
var explodeShiftable = explodeInstance.GetComponent<Shiftable>();
var ownerShiftable = GetComponent<Shiftable>();
if (explodeShiftable != null && ownerShiftable != null)
{
var univPos = Universe.Current.GetUniversePosition(transform.position);
explodeShiftable.SetShiftPosition(univPos);
}
var count = Physics.OverlapSphereNonAlloc(transform.position, MaxExplodeRadius, _damageColliders, _detectableMask);
for (var i = 0; i < count; i++)
{
_detectable = _damageColliders[i].GetComponent<Detectable>();
if (_detectable != null)
{
_killable = _detectable.TargetTransform.GetComponent<Killable>();
var damage = Mathf.Round(MaxExplodeDamage * GetDamageFraction(_detectable.transform.position, transform.position, MinExplodeRadius, MaxExplodeRadius));
_killable.Damage(damage, transform.position, Vector3.up, Owner);
}
var rBody = _damageColliders[i].GetComponentInParent<Rigidbody>();
if (rBody != null)
rBody.AddExplosionForce(MissileForce, transform.position, MaxExplodeRadius, 0f, ForceMode.Impulse);
}
Stop();
}
