public override void Swing(Damageable target)
{
if (fireCooldown < 0)
{
hitting = true;
if (target is Unit)
{
AggroEvent e = new AggroEvent(this, target, true);
((Unit)target).OnAggroRecieved(e);
this.OnAggro(e);
}
SoundManager.GetInstance().PlaySFX(SoundManager.GetInstance().lanceSounds);
DamageEvent dmgEvent = new DamageEvent(new MeleeSwing(PathfindingTest.Combat.DamageEvent.DamageType.Melee, baseDamage), target, this);
target.OnDamage(dmgEvent);
this.fireCooldown = this.rateOfFire;
// We already know that this unit is local
if (Game1.GetInstance().IsMultiplayerGame())
{
Synchronizer.GetInstance().QueueDamageEvent(dmgEvent);
}
}
}
private void Awake()
{
player = GameObject.FindGameObjectWithTag("Player").GetComponent<Transform>();
playerController = player.GetComponent<PlayerController>();
damageableEnemy = GetComponent<DamageableEnemy>();
gameController = GameObject.FindGameObjectWithTag("GameController").GetComponent<GameController>();
}
public void StartBoss(string name, Damageable health)
{
bossUI.SetActive(true);
bossHealthBar.fillAmount = 1;
bossHealth = health;
bossUI.transform.Find("Name").GetComponent<Text>().text = name;
}
public void DealDamage(float amount, Damageable d)
{
d.Health = d.Health - amount;
// if(isWrath)
// {
// BroadcastMessage("EnableEnemyHitAnimatorFlag", "Wrath_Hit", SendMessageOptions.DontRequireReceiver);
// }
}
void OnDeath(Damageable victim)
{
var enemy = victim.GetComponent<EnemyMob>();
if(enemy != null && ais.Contains(enemy))
{
ais.Remove(enemy);
}
}
public DamageEvent(DamageSource by, Damageable target, Unit source)
{
this.source = source;
this.by = by;
this.target = target;
this.usedModifier = this.GetModifier();
this.damageDone = by.baseDamage * this.usedModifier;
}
public virtual void Damage(Damageable damageable)
{
if (damageable == null)
return;
if (damageable.Damage(GetDamageData()))
Entity.SendMessage(EntityMessages.OnDamage, damageable);
}
public override int GetDamage(Damageable target)
{
if (body.velocity.sqrMagnitude > (velocityThreshold * velocityThreshold)) {
return damage;
}
else {
return 0;
}
}
void Awake()
{
layer = gameObject.layer;
hitbox = GetComponent<Damageable>();
body = GetComponent<Rigidbody2D>();
direction = UnityEngine.Random.value > .5f ? 1 : -1;
home = transform.position;
maxDecent = home + Vector3.down * descendDistance;
state = State.Crawling;
}
void Awake()
{
anim = GetComponent<Animator>();
movement = GetComponent<CharacterMovement>();
collider = GetComponent<BoxCollider2D>();
damageable = GetComponent<Damageable>();
audioSource = GetComponent<AudioSource>();
damageable.OnDamage += TakeDamage;
}
// Use this for initialization
void Start()
{
m_Rigidbody = GetComponent<Rigidbody>();
m_Animator = GetComponent<Animator>();
m_Damageable = GetComponent<Damageable>();
m_NavAgent = GetComponent<NavMeshAgent>();
//m_Damageable.RegisterDamageEvent(onStayHit);
//m_Damageable.SetDeathHandler(onDead);
}
void Awake()
{
character = GetComponent<CharacterController>();
dude = gameObject.GetComponent<Dude>();
swordzDude = gameObject.GetComponent<SwordzDude>();
damageable = gameObject.GetComponent<Damageable>();
detector = gameObject.GetComponentInChildren<Detector>();
//controller = gameObject.GetComponent(typeof(DudeController)) as DudeController;
attackers = new List<GameObject>();
}
/// <summary>
/// Attempt to fire the weapon!
/// </summary>
public override void Swing(Damageable target)
{
if (this.fireCooldown < 0)
{
if (target is Unit)
{
AggroEvent e = new AggroEvent(this, target, true);
((Unit)target).OnAggroRecieved(e);
this.OnAggro(e);
}
this.projectiles.AddLast(new Arrow(this, target));
this.fireCooldown = this.rateOfFire;
}
}
void FixedUpdate()
{
if (!m_CanDamage)
{
return;
}
ClearDamageable();
Vector2 scale = m_DamagerTransform.lossyScale;
Vector2 facingOffset = Vector2.Scale(offset, scale);
if (offsetBasedOnSpriteFacing && spriteRenderer != null && spriteRenderer.flipX != m_SpriteOriginallyFlipped)
{
facingOffset = new Vector2(-offset.x * scale.x, offset.y * scale.y);
}
Vector2 scaledSize = Vector2.Scale(size, scale);
Vector2 pointA = (Vector2)m_DamagerTransform.position + facingOffset - scaledSize * 0.5f;
Vector2 pointB = pointA + scaledSize;
int hitCount = Physics2D.OverlapArea(pointA, pointB, m_AttackContactFilter, m_AttackOverlapResults);
if (hitCount > 0)
{
m_LastHit = m_AttackOverlapResults[0];
Damageable damageable = m_LastHit.GetComponent <Damageable>();
m_damageable = damageable;
if (damageable)
{
OnFinalKill.Invoke(this, damageable);
damageable.TakeFinalKill(this);
if (disableDamageAfterHit)
{
DisableDamage();
}
}
//else
//{
// //OnNonDamageableHit.Invoke(this);
//}
}
}
private void OnCollisionEnter(Collision collision)
{
// Debug.Log("BULLET HIT :: " + collision.collider.name + " / " + collision.collider.tag);
if (collision.collider.tag == "HitBox" || collision.collider.name == "HitBox")
{
GameObject.Find(AudioBulletHit).GetComponent <AudioSource>().Play();
//Debug.Log("BULLET HIT :: " + collision.collider.name + " / " + collision.collider.tag);
// Damage
Damageable damageable = collision.collider.GetComponent <Damageable>();
if (damageable)
{
damageable.InflictDamage(damage, false);
}
}
}
void Start()
{
enemyTransform = this.transform;
enemyRigidBody = this.GetComponent <Rigidbody2D>();
SpriteRenderer enemySprite = this.GetComponent <SpriteRenderer>();
enemyWidth = enemySprite.bounds.extents.x;
enemyHeight = enemySprite.bounds.extents.y;
animator = this.GetComponent <Animator>();
isAttacking = false;
enemyVelocity = enemyRigidBody.velocity;
canMove = true;
isDead = false;
playerDamageableScript = (Damageable)player.GetComponent(typeof(Damageable));
playerDamagerScript = (Damager)player.GetComponent(typeof(Damager));
playerMovementScript = (PlayerMovement)player.GetComponent(typeof(PlayerMovement));
facingRight = true;
}
protected virtual void DealDamage(Collider2D hitBox)
{
AITarget target = hitBox.GetComponentInParent <AITarget>();
if (target != null && !AITarget.FactionsHostile(instigatorAlignment, target.alignment))
{
return;
}
Damageable damageable = hitBox.GetComponent <Damageable>();
if (damageable == null)
{
return;
}
damageable.TakeDamage(damage, transform.position, force);
}
private void OnCollisionEnter2D(Collision2D collision)
{
Damageable otherGuy = collision.gameObject.GetComponent <Damageable>();
float damageToDeal = Mathf.Min(otherGuy.health, health);
damageToDeal *= otherGuy.armor;
if (!isShielded)
{
if (collision.gameObject.layer != gameObject.layer && otherGuy)
{
StartCoroutine(DealDamageWithDelay(damageToDeal, otherGuy));
}
}
else
{
otherGuy.Die();
}
}
private void OnCollisionEnter2D(Collision2D collision)
{
if (collision.gameObject.tag == m_owner)
{
return;
}
Debug.Log("OnCollisionEnter with " + collision.gameObject);
if (collision.gameObject.tag == "Enemy" || collision.gameObject.tag == "Bullet")
{
if (collision.gameObject.GetComponent <Damageable>())
{
Damageable dmg = collision.gameObject.GetComponent <Damageable>();
dmg.TakeDamage(m_damage, true);
}
}
}
public void onHitSwitch(Damager damager, Damageable damageable)
{
constraint.transform.localScale = new Vector3(constraint.transform.localScale.x * 0.9f, constraint.transform.localScale.y, constraint.transform.localScale.z);
switchTime = switchDelay;
for (int loop = 0; loop < switches.Length; ++loop)
{
if (switches[loop].activeSelf)
{
offScreenIndicator.Remove(switches[loop]);
switches[loop].SetActive(false);
}
}
for (int bladeLoop = 0; bladeLoop < blades.Length; ++bladeLoop)
{
blades[bladeLoop].transform.localPosition = new Vector3(blades[bladeLoop].transform.localPosition.x * 0.8f, blades[bladeLoop].transform.localPosition.y, blades[bladeLoop].transform.localPosition.z);
}
boss.transform.localPosition = new Vector3(boss.transform.localPosition.x * 0.8f, boss.transform.localPosition.y, boss.transform.localPosition.z);
}
void Shoot()
{
Debug.DrawRay(cam.transform.position, cam.transform.forward);
if (Physics.Raycast(cam.transform.position, cam.transform.forward, out hit, range))
{
Debug.Log(hit.transform.name);
Damageable target = hit.transform.GetComponent <Damageable>();
if (target != null)
{
//target.TakeDamage(damage);
targetPos = hit.point;
Rigidbody clone;
clone = Instantiate(bullet, barrel.position, cam.transform.rotation);
clone.velocity = cam.transform.forward * bulletSpeed;
}
}
}
private List <Damageable> HandleMultipleTargetsRaycast(RaycastHit[] hitArray)
{
List <Damageable> damageableList = new List <Damageable>();
for (int n = 0; n < hitArray.Length; n++)
{
Damageable damageable = null;
damageable = hitArray[n].collider.GetComponent <Damageable>();
if (damageable != null && !ThisDamageableIsMine(damageable))
{
damageableList.Add(damageable);
}
}
return(damageableList);
}
public void setCurrentTarget(List <Damageable> targets, SpellCaster owner)
{
myOwner = owner;
List <Damageable> goodTargets = new List <Damageable>();
for (int i = 0; i < targets.Count; i++)
{
if (targets[i] != GetComponent <Damageable>())
{
goodTargets.Add(targets[i]);
}
}
if (goodTargets.Count > 0)
{
Damageable target = goodTargets[UnityEngine.Random.Range(0, goodTargets.Count)];
attackTarget = target.transform;
}
}
// Use this for initialization
void Start()
{
if (damageable == null)
{
damageable = GetComponent <Damageable> ();
}
damageable.OnDamaged += (Damageable self, int amount) => {
if (amount > 0)
{
damagedSound.RandomizePlaySound();
}
};
damageable.OnDied += (self) => {
diedSound.RandomizePlaySound();
};
}
private void OnCollisionEnter2D(Collision2D collision)
{
Damageable damageable = collision.gameObject.GetComponent <Damageable>();
// if a sticky grenade collides with something, have it stick
if (isSticky && !hasStuck)
{
rb.simulated = false;
transform.parent = collision.transform;
hasStuck = true;
}
// if an on-contact grenade collides with a player, have it explode
else if (onContact && damageable)
{
Boom();
}
}
protected override void ProcessInputs(out bool processAllOutputs)
{
GameObject target = (GameObject) inputs[0].GetData();
float power = (float)inputs[1].GetData();
Damageable damageable = target.GetComponent<Damageable>();
if(damageable != null)
{
damageable.DealDamage((int)power);
}
else
{
Debug.Log("this target is not damageable (" + target + ")");
}
//TODO take in account player's level
processAllOutputs = false;
}
public new static GameObject ReadXml(XmlReader reader, Component workingObj)
{
Damageable damageable = (Damageable)workingObj;
reader.Read();
damageable.faction = SpaceGameGlobal.StringToFaction(reader.ReadString());
reader.Read();
damageable.maxhp = int.Parse(reader.ReadString());
reader.Read();
damageable.curhp = int.Parse(reader.ReadString());
reader.Read();
damageable.RepairTime = float.Parse(reader.ReadString());
return(workingObj.gameObject);
}
private void OnTriggerStay2D(Collider2D collision)
{
if (timer > 0f)
{
return;
}
Damageable d = collision.GetComponent <Damageable>();
if (d == null)
{
return;
}
timer = Cooldown;
d.Dot(new DotFrame(BurnTotalDamage, DamagePerBurn, DamageType.Fire, null));
}
public override void OnCollection()
{
GameObject rogers = GameObject.FindGameObjectWithTag("Player");
if (rogers == null)
{
Debug.LogError("Rogers cannot be found in the scene!");
return;
}
Damageable rogersDamageComponent = rogers.GetComponent <Damageable>();
if (rogersDamageComponent == null)
{
Debug.LogError("Rogers damage component cannot be found in the scene!");
return;
}
rogersDamageComponent.Heal(healedAmount);
}
/** Spawn the damage part. */
public void Spawn(Damageable damageable)
{
var center = damageable.DestroyEffectEmitter.position;
var go = Instantiate(Prefab, transform.position, transform.rotation) as GameObject;
var r = go.GetComponent <Rigidbody2D>();
if (r == null)
{
return;
}
var speed = Random.Range(SpeedRange.x, SpeedRange.y);
var direction = (transform.position - center).normalized;
r.velocity = (direction * speed);
r.angularVelocity = Random.Range(AngularSpeedRange.x, AngularSpeedRange.y);
}
private void Awake()
{
List <Damageable> damageables = unitList.Items;
for (int i = damageables.Count - 1; i >= 0; --i)
{
Damageable d = damageables[i];
float distance = Vector3.Distance(transform.position, d.transform.position);
if (distance < radius)
{
float value = 1f - Mathf.InverseLerp(0f, radius, distance);
float finalDamage = value * damage;
d.TakeDamage(finalDamage, damageType);
}
}
Destroy(this.gameObject, 3f);
}
public virtual void Explode()
{
Collider[] colliders;
colliders = Physics.OverlapSphere(transform.position, explosionRadius);
foreach (Collider col in colliders)
{
Rigidbody colrb = col.GetComponent <Rigidbody>();
if (colrb != null)
{
colrb.AddExplosionForce(explosionForce, transform.position, explosionRadius, 5f);
Damageable colDamageable = colrb.GetComponent <Damageable>();
if (colDamageable != null)
{
colDamageable.DecrementHealth(damage);
}
}
}
}
public override void OnInitialized()
{
character = worlditem.Get <Character> ();
character.OnCollectiveThoughtStart += OnCollectiveThoughtStart;
character.State.GlobalReputation = 1;
damageable = worlditem.Get <Damageable> ();
damageable.OnTakeDamage += OnTakeDamage;
damageable.OnDie += OnDie;
//this script won't get added by default
looker = worlditem.GetOrAdd <Looker> ();
looker.State.ItemsOfInterest.SafeAdd("Creature");
looker.State.ItemsOfInterest.SafeAdd("Character");
looker.State.VisibleTypesOfInterest |= ItemOfInterestType.WorldItem;
looker.State.VisibleTypesOfInterest |= ItemOfInterestType.Player;
Listener listener = worlditem.GetOrAdd <Listener> ();
}
public override void Update()
{
elapsedTime += Time.deltaTime;
if (elapsedTime >= owner.attackTime / 2 && !checkedHit)
{
RaycastHit hit;
bool bearHit = Physics.Linecast(owner.transform.position, owner.swordTransform.position, out hit, owner.attackingLayer);
if (bearHit)
{
Damageable damageable = hit.transform.GetComponent <Damageable>();
if (damageable != null)
{
damageable.OnHit(owner.transform.right);
}
}
checkedHit = true;
}
}
/// <summary>
/// Get the max health of the player base
/// </summary>
protected virtual void Start()
{
LevelManager levelManager = LevelManager.instance;
if (levelManager == null)
{
return;
}
if (levelManager.numberOfHomeBases > 0)
{
Damageable baseConfig = levelManager.playerHomeBases[0].configuration;
baseConfig.damaged += OnBaseDamaged;
float currentHealth = baseConfig.currentHealth;
float noramlisedHealth = baseConfig.normalisedHealth;
m_MaxHealth = currentHealth / noramlisedHealth;
}
UpdateDisplay();
}
public void DestroySpawendEnemies()
{
Damageable.DamageMessage data = new Damageable.DamageMessage();
foreach (var spawendEnemy in _spawendEnemies)
{
if (spawendEnemy != null)
{
Damageable damageable = spawendEnemy.GetComponent <Damageable>();
damageable.isInvulnerable = false;
data.amount = damageable.currentHitPoints;
data.damageSource = Vector3.zero;
damageable.ApplyDamage(data);
}
}
_spawendEnemies.Clear();
_canSpawn = true;
}
public void PlayerShotSomethingDown(Damageable thing)
{
score++;
if (exclusionsByTag.ToList().Contains(thing.tag))
{
return;
}
nextIn--;
if (nextIn <= 0)
{
DoPickupSpawn(thing.transform.position);
}
scoreText.text = "Score: " + score;
}
/// <summary>
/// Continues to attack the closest target, if there is one
/// </summary>
private void Update()
{
if (_attacking && CanAttack && _currentTargets.Count > 0)
{
Damageable closest = _currentTargets[0];
for (int i = 1; i < _currentTargets.Count; i++)
{
Damageable damageable = _currentTargets[i];
if (Vector3.Distance(damageable.transform.position, transform.position) <
Vector3.Distance(closest.transform.position, transform.position))
{
closest = damageable;
}
}
Attack(closest);
}
}
private void Detonate()
{
if (PendingForDeletion)
{
return;
}
PendingForDeletion = true;
Sounds.CreateSound(ExplosionSound, transform.position);
if (OnHitObjects.Length > 0)
{
GameObject onHitObject = Instantiate(OnHitObjects[Random.Range(0, OnHitObjects.Length)], LevelLoader.TemporaryObjects);
onHitObject.transform.position = transform.position;
onHitObject.transform.rotation = transform.rotation;
}
Collider2D[] targets = Physics2D.OverlapCircleAll(transform.position, ExplosionRadius.y);
foreach (Collider2D target in targets)
{
Damageable d = target.GetComponent <Damageable>();
if (d == null)
{
continue;
}
Vector2 dif = target.transform.position - transform.position;
Vector2 dir = dif == Vector2.zero ? Vector2.zero : dif.normalized;
Vector2 hitPoint = (Vector2)target.transform.position - dir;
float lerp = Mathf.InverseLerp(ExplosionRadius.x, ExplosionRadius.y, dif.magnitude - d.Radius);
int dmg = Mathf.CeilToInt(Mathf.Lerp(Damage, 1, lerp));
d.Damage(new DamageFrame(dmg, AttackType.Explosion, damageType, owner, hitPoint));
d.Impulse(dir, Mathf.Lerp(Force, 1, lerp));
}
//camera shake
float distanceToCamera = ((Vector2)transform.position - (Vector2)Camera.main.transform.position).magnitude;
Messaging.CameraControl.Shake.Invoke((1f - Mathf.InverseLerp(1, 30, distanceToCamera)) * .5f);
}
void OnTriggerEnter(Collider other)
{
//Retreive damageable
Damageable dmg = other.GetComponent <Damageable>();
//Exit if nothing hit
if (dmg == null)
{
return;
}
//Prevent self harm
if (dmg.gameObject == m_owner)
{
return;
}
//Bounce of an object that is not on target layer
if ((targetLayers.value & (1 << other.gameObject.layer)) == 0)
{
return;
}
//Do the damage!
dmg.TakeDamage(damage);
//Play a sound
if (impactSounds != null)
{
impactSounds.PlayOnce();
}
//Particles!
if (hitParticle != null)
{
hitParticle.Play();
}
//Clean up (gun is responsible for destroying object)
if (destroyOnContact)
{
Destroy(gameObject);
}
}
protected override void OnUpdate()
{
if (attacking)
{
if (fireTime < attackHappenTime)
{
attacking = false;
Vector3 d = Camera.main.transform.forward;
Vector2 r = Random.insideUnitCircle * dispersion;
d += Camera.main.transform.right * r.x + Camera.main.transform.up * r.y;
d.Normalize();
Ray ray = new Ray(Camera.main.transform.position, d);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, maxRange, ~((1 << 9) | (1 << 10) | (1 << 14)), QueryTriggerInteraction.Ignore))
{
Damageable target = hit.collider.gameObject.GetComponent <Damageable>();
if (target != null)
{
target.Damage(Random.Range(DamageMin, DamageMax + 1), DamageType.Generic, PlayerControls.Instance.gameObject);
if (target.Bleed)
{
GameObject blood = Instantiate(GameManager.Instance.BloodDrop);
blood.transform.position = hit.point - ray.direction * .2f;
}
else
{
GameObject puff = Instantiate(GameManager.Instance.BulletPuff);
puff.transform.position = hit.point - ray.direction * .2f;
}
}
else
{
GameObject puff = Instantiate(GameManager.Instance.BulletPuff);
puff.transform.position = hit.point - ray.direction * .2f;
}
audioSource.clip = Sounds[0];
audioSource.Play();
}
}
}
}
void OnHit(Vector3 point, Vector3 normal, Collider collider)
{
if (collider.gameObject.tag == "Player")
{
Health life = collider.GetComponent <Health>();
life.TakeDamage(damage, m_ProjectileBase.owner);
}
// damage
if (areaOfDamage)
{
// area damage
areaOfDamage.InflictDamageInArea(damage, point, hittableLayers, k_TriggerInteraction, m_ProjectileBase.owner);
}
else
{
// point damage
Damageable damageable = collider.GetComponent <Damageable>();
if (damageable)
{
damageable.InflictDamage(damage, false, m_ProjectileBase.owner);
}
}
// impact vfx
if (impactVFX)
{
GameObject impactVFXInstance = Instantiate(impactVFX, point + (normal * impactVFXSpawnOffset), Quaternion.LookRotation(normal));
if (impactVFXLifetime > 0)
{
Destroy(impactVFXInstance.gameObject, impactVFXLifetime);
}
}
// impact sfx
if (impactSFXClip)
{
AudioUtility.CreateSFX(impactSFXClip, point, AudioUtility.AudioGroups.Impact, 1f, 3f);
}
// Self Destruct
Destroy(this.gameObject);
}
private void OnCollisionEnter(Collision collision)
{
Damageable damageable = collision.collider.GetComponentInChildren <Damageable>();
if (damageable != null && !damageable.isInvulnerable)
{
Damageable.DamageMessage message = new Damageable.DamageMessage
{
damageSource = transform.position,
damager = this,
amount = damageAmount,
direction = (collision.collider.transform.position - transform.position).normalized,
effect = Magic.MagicEffect.Paralyze,
magicEffectLasting = 5
};
damageable.ApplyDamage(message);
}
}
public Projectile(Unit parent, Damageable target, DamageEvent.DamageType type, float movementSpeed, int maxRange, int baseDamage)
{
this.parent = (Bowman)parent;
this.x = parent.x;
this.y = parent.y;
this.startX = this.x;
this.startY = this.y;
this.target = target;
this.type = type;
this.movementSpeed = movementSpeed;
this.maxRange = maxRange;
this.baseDamage = baseDamage;
//this.waypoint = Util.GetPointOnCircle(parent.GetLocation(),
// (int) Util.GetHypoteneuseLength(this.GetLocation(), target.GetLocation()),
// Util.GetHypoteneuseAngleDegrees(parent.GetLocation(), target.GetLocation()));
if (target is Unit)
{
int targetX = (int)((Unit)target).x;
int targetY = (int)((Unit)target).y;
this.waypoint = new Point(targetX, targetY);
SetMoveToTarget(targetX, targetY);
}
else
{
int targetX = (int)((Building)target).x;
int targetY = (int)((Building)target).y;
this.waypoint = new Point(targetX, targetY);
SetMoveToTarget(targetX, targetY);
}
if (Game1.GetInstance().IsMultiplayerGame())
{
Boolean isLocal = this.parent.player == Game1.CURRENT_PLAYER;
this.multiplayerData = new ProjectileMultiplayerData(this, isLocal);
if (isLocal)
{
this.multiplayerData.RequestServerID();
}
}
}
public void OnDeath(Damageable victim)
{
if(victim.team != player.team && !demoMode)
{
biffed += 1;
biffedGUI.text = biffed.ToString();
Camera.main.gameObject.SendMessage("DoEffect");
GameObject[] remaining = GameObject.FindGameObjectsWithTag("EnemyMob");
int remainingCount = remaining.Length - 1;
Debug.Log("remaining : " + remainingCount);
if( remainingCount <= 0 )
{
Debug.Log("next wave!");
StartCoroutine(NextWave());
}
}
}
public Projectile(Unit parent, Damageable target, DamageEvent.DamageType type, float movementSpeed, int maxRange, int baseDamage)
{
this.parent = (Bowman)parent;
this.x = parent.x + (23 * (float)Math.Cos(parent.rotation));
this.y = parent.y + (7 * (float)Math.Sin(parent.rotation));
this.startX = this.x;
this.startY = this.y;
this.target = target;
this.type = type;
this.movementSpeed = movementSpeed;
this.maxRange = maxRange;
this.baseDamage = baseDamage;
if (target is Unit)
{
int targetX = (int)((Unit)target).x;
int targetY = (int)((Unit)target).y;
this.waypoint = new Point(targetX, targetY);
SetMoveToTarget(targetX, targetY);
}
else
{
int targetX = (int)((Building)target).x;
int targetY = (int)((Building)target).y;
this.waypoint = new Point(targetX, targetY);
SetMoveToTarget(targetX, targetY);
}
if (Game1.GetInstance().IsMultiplayerGame())
{
Boolean isLocal = this.parent.player == Game1.CURRENT_PLAYER;
this.multiplayerData = new ProjectileMultiplayerData(this, isLocal);
if (isLocal)
{
this.multiplayerData.RequestServerID();
}
}
}
public DamageableDecorator(Damageable damageable)
{
this.damageable = damageable;
}
public Arrow(Unit parent, Damageable target)
: base(parent, target, DamageEvent.DamageType.Ranged, 4.0f, 300, 15)
{
this.texture = Game1.GetInstance().Content.Load<Texture2D>("Units/Projectiles/wooden_arrow_scale");
this.collisionPointTex = Game1.GetInstance().Content.Load<Texture2D>("Misc/solid");
}
void Start()
{
dude = GetComponent<Dude>();
swordzDude = GetComponent<SwordzDude>();
damageable = GetComponent<Damageable>();
actualAttackRate = attackRate + (Random.value - 0.5f) * attackRateFluctuation;
lastAttackTime = -actualAttackRate;
// HACK : get me outta here!
animated = swordzDude.animated; // transform.Find("graphics/bjorn");
avoider = gameObject.GetComponentInChildren<Avoider>();
if(avoider != null)
{
Physics.IgnoreCollision(collider, avoider.collider);
}
sqrAttackDistance = Mathf.Pow(attackDistance, 2);
sqrDangerDistance = Mathf.Pow(dangerDistance, 2);
// offset the start of the think ticks to spread the load out a little
lastThought += thinkPeriod * Random.value;
lastReact += reactPeriod * Random.value;
StartCoroutine("SummoningSickness");
}
public Arrow(Unit parent, Damageable target)
: base(parent, target, DamageEvent.DamageType.Ranged, 4.0f, 300, 15)
{
this.texture = TextureManager.GetInstance().GetArrowTexture();
this.collisionPointTex = TextureManager.GetInstance().GetSolidTexture();
}
public AggroEvent(Unit from, Damageable to, Boolean received)
{
this.from = from;
this.to = to;
this.received = received;
}
public static void RequestHealthbar(Damageable d)
{
HealthBar newHealthBar = Instantiate(instance.healthBarPrefab).GetComponent<HealthBar>();
newHealthBar.followTarget = d;
newHealthBar.transform.SetParent(instance.transform, false);
}
// Use this for initialization
void Awake()
{
controller = GetComponent<BaseController>();
animator = GetComponentInChildren<Animator>();
damageable = GetComponent<Damageable>();
}
public Armor(Damageable damageable, float armor)
: base(damageable)
{
this.armor = armor;
this.defaultArmor = armor;
}
// Use this for initialization
void Start ()
{
damageable = GetComponent<Damageable>();
minY = transform.position.y;
}
/// <summary> /// This unit will attempt to fire/swing/kill/cast! /// </summary> public abstract void Swing(Damageable target);
public override void Swing(Damageable target)
{
}
void OnCollisionEnter2D(Collision2D collision)
{
if (collision.gameObject.tag == "Player") {
switch (state) {
case State.Descending:
case State.Leaping:
state = State.Grappling;
grappleHitbox = collision.gameObject.GetComponent<Damageable>();
grappleHitbox.TakeDamage(grappleDamage);
timeSinceLastGrappleDamage = 0;
break;
}
}
else {
if (state == State.Leaping) {
state = State.Crawling;
}
}
}
// Use this for initialization
void Start()
{
damageable = new Health (maxHealth);
switch (healthType) {
case HealthType.WITH_ARMOR:
myArmor = Instantiate (armor);
myArmor.transform.parent = transform;
myArmor.transform.localPosition = Vector3.zero;
Armor a = new Armor (damageable, maxArmor);
a.ArmorDestroyed += () =>
{
Debug.Log ("Armor destryoed");
myArmor.gameObject.SetActive (false);
};
damageable = a;
break;
}
}
void Start()
{
movable = GetComponent<Movable>();
health = GetComponent<Damageable>();
}