public static void RemoveTargetable(Team team, Killable killable)
{
if (targetables.ContainsKey(team))
targetables[team].Remove(killable);
//Debug.Log("- TEAM: " + team + " COUNT: " + targetables[team].Count);
}
void Start () {
k = GameObject.Find("Player").GetComponent<Killable>();
Debug.Assert(k);
//w = GameObject.Find("MagicSauce").GetComponent<WaveManager>();
//Debug.Assert(w);
StartCoroutine(ShowLevel());
}
private void Awake()
{
rBody = GetComponent<Rigidbody>();
killable = GetComponent<Killable>();
killable.OnDie += CorpseExplode;
}
public override void TakingDamage(int pointsDamage, Killable enemyHitBy)
{
base.TakingDamage(pointsDamage, enemyHitBy);
Debug.Log("[Taking damage] Plyer is taking dmage");
FireCustomEvent(NamesEventGamekit.PLAYER_TAKING_DAMAGE, _transform.position);
RootPlayerDataManager.Instance.ChangeHealthCurrentBy(pointsDamage);
}
public override void TakingDamage (int pointsDamage, Killable enemyHitBy)
{
if (isCrit && enemyHitBy != null)
{
OnCrititcalHit();
}
base.TakingDamage (pointsDamage, enemyHitBy);
}
public static void AddTargetable(Team team, Killable killable)
{
if (targetables == null)
targetables = new Dictionary<Team, List<Killable>>();
if (!targetables.ContainsKey(team))
targetables.Add(team, new List<Killable>());
targetables[team].Add(killable);
//Debug.Log("+ TEAM: " + team +" COUNT: " + targetables[team].Count);
}
public Health(int amount, Killable owner, Armor armor)
{
if (amount <= 0) {
throw new System.ArgumentException("Healthes with a negative amount aren't allowed");
}
MaxAmount = amount;
Amount = amount;
Owner = owner;
Armor = armor;
}
public override void TakingDamage (int pointsDamage, Killable enemyHitBy)
{
base.TakingDamage (pointsDamage, enemyHitBy);
if (Random.Range(0f, 1f) < ChanceToApply)
{
if (enemyHitBy.GetComponent<StatusEffectReceiver>() != null)
{
enemyHitBy.GetComponent<StatusEffectReceiver>().ApplyEffect(EffectToApply, NumberOfStacks);
}
}
}
private void OnContainerDie(Killable sender)
{
var dropAmount = Random.Range(MinDropCount, MaxDropCount + 1);
for (var i = 0f; i < dropAmount; i++)
{
var dropPosition = sender.transform.position + Random.onUnitSphere * 1.5f;
var collectible = DropItemPrefab;
var dropItem = ((GameObject)Instantiate(collectible, dropPosition, Quaternion.identity)).GetComponent<Collectible>();
dropItem.Shiftable.SetShiftPosition(Universe.Current.GetUniversePosition(dropPosition));
dropItem.SetVelocity(Random.onUnitSphere * 5f);
}
var distantHitContainer = DistantContainers.First(c => c.name == sender.name);
distantHitContainer.GetComponent<MeshRenderer>().enabled = false;
}
private void OnKill(Killable sender)
{
_liveCount--;
Debug.Log("MOTHERSHIP LIVE COUNT: " + _liveCount);
if (_liveCount <= 0)
{
Debug.Log("MOTHERSHIP DESTROYED!!!");
HeadsUpDisplay.Current.DisplayMessage("MOTHERSHIP NEUTRALIZED", 3f);
if (DefeatedSound != null)
{
var sound = ResourcePoolManager.GetAvailable(SoundPrefab, Universe.Current.ViewPort.transform.position, Quaternion.identity).GetComponent<AnonymousSound>();
sound.PlayAt(DefeatedSound, Universe.Current.ViewPort.transform.position, 1f, false);
}
MapPin.SetPinState(MapPin.MapPinState.Inactive);
}
}
private void SetupKillable()
{
if (null == Player)
{
PlayerKillable = null;
return;
}
var k = Player.GetComponent<Killable>();
if (!k)
{
Debug.LogWarning("Killable is not found on player instance object!");
return;
}
PlayerKillable = k;
}
public override void TakingDamage (int pointsDamage, Killable enemyHitBy)
{
base.TakingDamage (pointsDamage, enemyHitBy);
if (OnPickedUp(enemyHitBy))
{
if (DespawnOnPickup)
{
myKillable.DestroyKillable();
}
SpawnPickupEffect();
}
}
public override void DestroyingKillable(Killable deadKillable)
{
//check bullet color vs enemy color
if (deadKillable.KilledBy != null)
{
BulletMovement bullet = deadKillable.KilledBy.GetComponent<BulletMovement>();
if (bullet != null)
{
PatternColor bulletColor = deadKillable.KilledBy.GetComponent<ColorComponent>().MyColor;
PatternColor enemyColor = deadKillable.GetComponent<ColorComponent>().MyColor;
bullet.PlayerRef.EnemyKilled(bulletColor, enemyColor, PatternShape.none);
}
}
myController.CoreDestroyed(deadKillable.GetComponent<ColorComponent>());
}
private void Start()
{
mEnemy = GetComponent <Enemy>();
mStatistics = GetComponent <CharacterStatistics>();
mKillable = GetComponent <Killable>();
mTeleport = GetComponent <EnemyTeleport>();
mSimpleMovement = GetComponent <SimpleMovement>();
mSimpleAttack = GetComponent <SimpleAttack>();
mAnimator = GetComponentInChildren <Animator>();
mEnemy.SetEnemyAI(this);
Game.instance.hud.bossHealth.gameObject.SetActive(true);
Game.instance.hud.bossHealth.SetWithValues(0, mKillable.health, mKillable.health);
Game.instance.hud.bossHealth.transform.localScale = Vector3.zero;
Game.instance.hud.bossHealth.transform.DOScale(1f, 0.5f);
}
public MissileParabolic(string _towerType, Texture _texture, Vector2 _position, Vector2 _size, float _damage, float _speed, Killable _target, float _parabolicHeight)
{
towerType = _towerType;
gameObject = GamePullController.CreateImage();
GameController.missiles.Add(this);
mapPosition = _position;
damage = _damage;
target = _target;
texture = _texture;
size = _size;
speed = _speed;
layer = _target.layer;
parabolicHeight = _parabolicHeight;
startPosition = mapPosition;
}
private void GetNearbyTarget()
{
// init target list
possibleTargets = new List <Killable>();
GameObject[] gos = GameObject.FindGameObjectsWithTag("Fighter");
foreach (GameObject go in gos)
{
Killable killable = go.GetComponent <Killable> ();
float distance = Vector3.Distance(killable.transform.position, transform.position);
if (killable != null && distance < 1000)
{
if (FactionRelationshipManager.IsHostile(killable._faction, _faction))
{
possibleTargets.Add(killable);
}
}
}
//If no possible targets found, go to battle center
if (possibleTargets.Count == 0)
{
if (currentWaypoint == null)
{
//targetTransform = battleCenter.transform;
targetNavWaypoint = battleCenter.navWaypoints;
GetNextTarget();
}
return;
}
// Randomize the targets
target = possibleTargets[Random.Range(0, possibleTargets.Count - 1)];
if (target != null)
{
targetTransform = target.transform;
targetNavWaypoint = target.navWaypoints;
// set first target
GetNextTarget();
}
}
private bool InstaKill(Killable target)
{
// If this is the player attacking and the player has the Saw, it may insta-kill
if (gameObject.layer == mPlayerLayer && Game.instance.playerStats.IsItemEquipped <Saw>())
{
Enemy targetEnemy = target.GetComponent <Enemy>();
if (targetEnemy != null && !targetEnemy.isBoss)
{
int val = Random.Range(0, 100);
if (val < 5) // Don't apply luck - it's supposed to be very rare
{
return(true);
}
}
}
return(false);
}
void Died(Entity ent)
{
if (ent == this._entity)
{
if (this.realMeter != null)
{
Killable entityComponent = ent.GetEntityComponent <Killable>();
if (entityComponent == null)
{
this.realMeter.SetHealth(0f, false);
}
else
{
this.realMeter.SetHealth(Mathf.Max(0f, entityComponent.CurrentHp), false);
}
}
this.Disconnect();
}
}
private void OnDie(Killable sender)
{
Killable.OnDie -= OnDie;
// Drop valuable
var dropItem = ((GameObject)Instantiate(_dropItem, transform.position, Quaternion.identity)).GetComponent<Collectible>();
dropItem.Shiftable.SetShiftPosition(Universe.Current.GetUniversePosition(transform.position));
dropItem.SetVelocity(_velocity * Random.Range(-0.5f, 0.5f));
// Drop junk
var dropCount = Random.Range(DropJunkMinCount, DropJunkMaxCount);
for (var i = 0; i < DropJunkMaxCount; i++)
{
var dropPosition = transform.position + Random.onUnitSphere * 1.5f;
var fromCentre = dropPosition - transform.position;
var dropJunk = ((GameObject)Instantiate(DropJunk, transform.position + Random.onUnitSphere * 1.5f, Quaternion.identity)).GetComponent<Collectible>();
dropJunk.Shiftable.SetShiftPosition(Universe.Current.GetUniversePosition(dropPosition));
dropJunk.SetVelocity(_velocity + fromCentre.normalized * Random.Range(5f, 15f));
}
}
public EntityHUD.HealthMeterTag ConnectHealthMeter(Entity ent, string meterId)
{
this.Setup();
HealthMeterBase healthMeterForId = this._data.GetHealthMeterForId(meterId);
Killable entityComponent = ent.GetEntityComponent <Killable>();
if (healthMeterForId != null && entityComponent != null)
{
HealthMeterBase pooledWindow = OverlayWindow.GetPooledWindow <HealthMeterBase>(healthMeterForId);
EntityHUD.ConnectedHealthMeter connectedHealthMeter = new EntityHUD.ConnectedHealthMeter(ent, entityComponent, pooledWindow);
this.healthMeters.Add(connectedHealthMeter);
if (this.ShouldHideStuff())
{
connectedHealthMeter.Hide();
}
return(new EntityHUD.HealthMeterTag(this, connectedHealthMeter));
}
return(null);
}
public override void TakingDamage(int pointsDamage, Killable enemyHitBy)
{
if (enemyHitBy != null && enemyHitBy != lastHit)
{
if (enemyHitBy.GetComponent<BulletMovement>() != null)
{
PatternColor m_color = GetComponent<ColorComponent>().MyColor;
PatternColor bulletColor = enemyHitBy.GetComponent<ColorComponent>().MyColor;
if (m_color == bulletColor)
{
//Double Damage;
lastHit = enemyHitBy;
m_killable.TakeDamage(pointsDamage, enemyHitBy);
}
}
}
base.TakingDamage(pointsDamage, enemyHitBy);
}
void CheckForKillsAndCollisions()
{
Vector3 avoidVector = Vector3.zero;
foreach (GameObject agent in detector.nearbyAgents)
{
Killable killable = agent.GetComponent <Killable>();
if (killable)
{
// Draw rays to debug
Vector3 raystart = transform.position + Vector3.up * 5;
Vector3 direction = agent.transform.position + Vector3.up * 2 - raystart;
Debug.DrawRay(raystart, direction, Color.green);
Debug.DrawRay(raystart, direction.normalized * killDistance, Color.blue);
//print("distance: " + direction.magnitude);
// Distance to target's head or thereabuots
if (Vector3.Distance(transform.position + Vector3.up * 2, agent.transform.position) < killDistance)
{
killable.Kill();
}
}
else
{
Vector3 raystart = transform.position + Vector3.up * 5;
Vector3 direction = agent.transform.position + Vector3.up * 5 - raystart;
Debug.DrawRay(raystart, direction, Color.green);
Debug.DrawRay(raystart, direction.normalized * killDistance, Color.magenta);
if (Vector3.Distance(transform.position + Vector3.up * 5, agent.transform.position) < killDistance)
{
avoidVector += direction.normalized * avoidForceMultiplier / direction.magnitude;
}
}
}
// apply aviod force
if (avoidVector.magnitude > maxAvoidForce)
{
avoidVector = avoidVector.normalized * maxAvoidForce;
}
body.AddForce(avoidVector);
}
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);
}
public void OnHit(float damage, Killable attacker)
{
// If friendly fire, ignore
if (!FactionRelationshipManager.IsHostile(_faction, attacker._faction))
{
return;
}
//In case resistance value is invalid
if (_resistance > 100 || _resistance < 0)
{
print("Resistance value invalid!");
_resistance = 0;
}
// Decrease health
_hitPoints -= (damage - (damage * _resistance) / 100);
if (_hitPoints <= 0)
{
Killed();
if (attacker._faction == Faction.PLAYER)
{
PlayerScore.instance.OnKilledEnemy();
}
_hitPoints = 100;
}
else
{
if (attacker._faction == Faction.PLAYER)
{
PlayerScore.instance.OnHitEnemy();
}
}
if (OnHitEvent != null)
{
OnHitEvent();
}
OnHitAdditional();
}
private void OnDeath(Killable entity)
{
if (!isAlive)
{
return;
}
isAlive = false;
if (Game.instance.finishedTutorial)
{
Game.instance.RunEnded(false);
}
commonComponents.animator.Play("Death");
Invoke("DeathSFX", 0.75f);
Invoke("TransitionAfterDelay", 2.5f);
}
protected override void CreateComponents()
{
base.CreateComponents();
_abilitiable = new Abilitiable(this);
_armorable = new Armorable(this);
_healthable = new Healthable(this);
_magicable = new Magicable(this);
_teamable = new Teamable(this);
_attackerable = new Attackerable(this, _teamable);
var agent = GetComponent <NavMeshAgent>();
var obstacle = GetComponent <NavMeshObstacle>();
_movable = new Movable(this, agent, obstacle);
_targetable = new Targetable(this);
_killable = new Killable(this);
_damageTarget = new Damageable(this, _healthable, _killable, _armorable);
_modifiable = new Modifiable(this);
_inventoryable = new Inventoryable <IItem>(this, new LimitedInventory <IItem>(6));
_healable = new Healable(this, _healthable);
}
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();
}
}
private void OnDamage(Killable sender, Vector3 position, Vector3 normal, GameObject attacker)
{
if (!hasBeenShot)
{
hasBeenShot = true;
for (var i = 0; i < GroupCount; i++)
{
var fromPoint = transform.position + Random.onUnitSphere * SpawnDistance;
var rotFacing = Quaternion.LookRotation(fromPoint - transform.position);
for (var j = 0; j < GroupMemberCount; j++)
{
var spawner = Instantiate(SpawnerPrefab);
spawner.Shifter = Shiftable;
spawner.transform.position = fromPoint + rotFacing * Formations.GetArrowOffset(j, 5f);
spawner.Spawn(i * 1.5f + Random.Range(0.2f, 0.5f));
}
}
}
}
// 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);
}
}
public override IEnumerable <Relation <Object, PrefabEventType> > GetRelations(Object entity)
{
var asGameObject = entity as GameObject;
Killable asKillable = (asGameObject != null) ? asGameObject.GetComponent <Killable>() : entity as Killable;
if (asKillable != null)
{
foreach (PrefabEventType type in System.Enum.GetValues(typeof(PrefabEventType)))
{
if ((includeEvents & type) == 0)
{
continue;
}
var handler = prefabEventData[type];
if (handler.useSpecific(asKillable))
{
var prefabTransform = handler.getSpecificPrefab(asKillable);
if (prefabTransform != null)
{
yield return(new Relation <Object, PrefabEventType>(entity, prefabTransform.gameObject, type));
}
}
else if (handler.usePool(asKillable))
{
var pool = LevelSettings.GetFirstMatchingPrefabPool(handler.getPoolName(asKillable));
if (pool == null)
{
continue;
}
foreach (var item in pool.poolItems)
{
yield return(new Relation <Object, PrefabEventType>(entity, item.prefabToSpawn.gameObject, type));
}
}
}
yield break;
}
}
void ApplyHit(GameObject collider)
{
Killable targetKillable = collider.GetComponentInParent <Killable>();
if (targetKillable != null && targetKillable.gameObject.layer != gameObject.layer && !mEnemiesHit.Contains(targetKillable))
{
// If the victim was the player & the player has a mirror shield, reflect!
if (targetKillable.gameObject.layer == LayerMask.NameToLayer("Player"))
{
if (Game.instance.playerStats.IsItemEquipped <MirrorShield>())
{
MirrorShield shield = Game.instance.playerStats.GetComponentInChildren <MirrorShield>();
shield.Reflect(this);
return;
}
}
CharacterStatistics stats = targetKillable.GetComponent <CharacterStatistics>();
int defense = stats == null ? 0 : stats.ModifiedStatValue(CharacterStatType.Defense, targetKillable.gameObject);
int damage = strength * 4 - defense * 2;
mEnemiesHit.Add(targetKillable);
targetKillable.TakeDamage(null, damage, DamageReason.Projectile);
if (destroyOnEnemyHit)
{
Destroy(gameObject);
PlayHitVFX();
}
}
else
{
if (destroyOnEnvironmentHit)
{
Destroy(gameObject);
PlayHitVFX();
}
}
}
public void Update()
{
if (target == null)
{
GetNearbyTarget();
}
else
{
timeCount += Time.deltaTime;
if (timeCount > timeToResetTarget)
{
timeCount = 0;
target = null;
GetNearbyTarget();
print("TARGET RESETTED");
}
}
//if( currentTarget == null ) return;
UpdateMovement();
}
void OnTriggerEnter(Collider other)
{
if (other.gameObject.GetInstanceID() == transform.parent.gameObject.GetInstanceID())
{
//print("didn't add " + other.gameObject.ToString() + " because i'm " + transform.parent.gameObject.ToString());
return;
}
Killable agent = other.gameObject.GetComponent <Killable>();
//if (other.CompareTag(NPCTag))
if (agent && agent.dead)
{
//print("ignoring dead");
}
else
{
//print("adding a " + other.ToString());
nearbyAgents.Add(other.gameObject);
}
}
public void ForceRespawn()
{
if (this.inForceRespawn)
{
return;
}
this.inForceRespawn = true;
if (this.WillChangeLevels())
{
this.localPauseTag = ObjectUpdater.Instance.RequestPause(null);
Killable entityComponent = this.ent.GetEntityComponent <Killable>();
if (entityComponent != null)
{
entityComponent.CurrentHp = entityComponent.MaxHp;
}
this.ChangeLevelRespawn();
return;
}
ObjectUpdater.PauseTag pauseTag = ObjectUpdater.Instance.RequestPause(null);
OverlayFader.OnDoneFunc onDoneFunc = delegate()
{
this.inForceRespawn = false;
pauseTag.Release();
Killable entityComponent2 = this.ent.GetEntityComponent <Killable>();
if (entityComponent2 != null)
{
Killable.DeathData deathData = new Killable.DeathData(true);
entityComponent2.ForceDeath(0f, deathData, true);
}
};
if (this._fadeOut != null)
{
Vector3 value = CoordinateTransformer.ToViewport("Main Camera", this.ent.WorldPosition);
OverlayFader.StartFade(this._fadeOut, true, onDoneFunc, new Vector3?(value));
}
else
{
onDoneFunc();
}
}
private void OnHit(Killable entity)
{
if (!mIsPrimary)
{
return;
}
int prevPhase = mCurrentPhase;
if (CurrentTotalHealth() < totalHealth * 0.33f)
{
mCurrentPhase = 2;
}
else if (CurrentTotalHealth() < totalHealth * 0.66f)
{
mCurrentPhase = 1;
}
else
{
mCurrentPhase = 0;
}
if (prevPhase == mCurrentPhase)
{
return;
}
if (mCurrentPhase == 0)
{
Game.instance.hud.bossHealth.fullImage.color = new Color(121 / 255.0f, 100 / 255.0f, 64 / 255.0f);
}
else if (mCurrentPhase == 1)
{
Game.instance.hud.bossHealth.fullImage.color = new Color(1, 1, 0);
}
else
{
Game.instance.hud.bossHealth.fullImage.color = new Color(1, 0, 0);
}
}
private void Update()
{
mLateUpdateProcessed = false;
Killable killable = KillableMap.instance.KillableAtWorldPosition(transform.position);
if (killable != null && killable.gameObject.layer == LayerMask.NameToLayer("Player"))
{
mInAnyLava = true;
mTimer += Time.deltaTime;
if (mTimer > 0.75f)
{
if (!Game.instance.playerStats.IsItemEquipped <IronBoots>())
{
killable.TakeDamage(gameObject, 5, DamageReason.Trap);
}
mTimer = 0f;
}
}
}
void Awake()
{
_healthHandler = GetComponent <Killable>();
player = GameObject.Find("Ship");
heightChangeTimer = 5.0f;
speed = player.GetComponent <Ship> ().ShipSpeed;
_ship = player.GetComponent <Ship> ();
//speed = 0.05f;
heightAscent = randomOffset(-2, -1);
_closenessThreshold = randomOffset(2, 4);
//currentHealth = 25;
_spriteFeedback.SetActive(false);
targeted = false;
isChasing = true;
_rigidBody = gameObject.GetComponent <Rigidbody2D> ();
//####Changes
eLOS = Instantiate(eLOS, transform.position, Quaternion.identity) as GameObject;
eLOS.GetComponent <LineOfSight>().setAssigned(gameObject);
eLOS.SetActive(false);
_healthHandler.Health = currentHealth;
_healthHandler.MaximumHealth = currentHealth;
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
Killable killable = (Killable)target;
if (Application.isPlaying)
{
if (GUILayout.Button("Kill"))
{
killable.Kill();
}
if (GUILayout.Button("¨Destroy"))
{
killable.Destroy();
}
if (GUILayout.Button("Resurrect"))
{
killable.Resurrect();
}
}
}
private void OnTriggerEnter(Collider collision)
{
if (timeCount < 1f)
{
return;
}
ExplosionObject explosion = ObjectPool.instance.GetExplosionObject();
explosion.transform.position = transform.position;
explosion.Live();
Killable killable = Target.GetComponent <Killable> ();
if (killable != null)
{
//Cause damage
killable.OnHit(500, _Owner);
}
Destroy(gameObject);
}
public virtual void Initialize(BattleCenter battleCenter, Bigship _owner)
{
targetNavWaypoint = new List <GameObject> ();
possibleTargets = new List <Killable> ();
target = null;
targetTransform = null;
// for demo only - i've varied the sensitivity and speed so that they react/behave differently
// in a game situation, where you want to target the other enemies, you'll have to
// set the speed to the same as the player to make it work, unless you provide the player
// with controls to change speed.
actualSensitivity = Random.Range(actualSensitivity - .2f, actualSensitivity + .2f);
originalSensitivity = actualSensitivity;
speed = Random.Range(speed - 5f, speed + 5f);
targetLight.enabled = false;
this.battleCenter = battleCenter;
this._owner = _owner;
CreateField();
}
public static Killable FindNearest(Team team, Vector3 fromPosition, float maxDistance)
{
Killable target = null;
if (targetables.ContainsKey(team))
{
var targetCandidates = targetables[team];
if (targetCandidates.Any())
{
var smallestDistanceSquared = maxDistance * maxDistance;
foreach (var candidate in targetCandidates)
{
var toTarget = candidate.transform.position - fromPosition;
if (toTarget.sqrMagnitude < smallestDistanceSquared)
{
smallestDistanceSquared = toTarget.sqrMagnitude;
target = candidate;
}
}
}
}
return(target);
}
private Killable FindFarestEnemyToAttack()
{
Killable result = null;
int maxProgress = 0;
foreach (Killable unit in GameController.units)
{
if (!unit.isKilling && unit.color != color)
{
if ((Mathf.Pow(mapPosition.x - unit.mapPosition.x, 2) + Mathf.Pow(mapPosition.y - unit.mapPosition.y, 2)
<= Mathf.Pow(attackRange + 0.1f, 2)))
{
if (maxProgress < unit.roadProgress)
{
maxProgress = unit.roadProgress;
result = unit;
}
}
}
}
return(result);
}
private void OnHit(Killable entity)
{
if (!string.IsNullOrEmpty(activationCinematicEvent) && !mActivationCinematicEventFired)
{
if (playSound)
{
Game.instance.soundManager.PlaySound("boss_intro");
}
mActivationCinematicEventFired = true;
Game.instance.cinematicDirector.PostCinematicEvent(activationCinematicEvent);
Vector3 dir = Game.instance.avatar.transform.position - transform.position;
dir.y = 0f;
if (Mathf.Abs(dir.x) > Mathf.Abs(dir.y))
{
dir.y = 0f;
}
else
{
dir.x = 0f;
}
dir.Normalize();
SimpleMovement.OrientToDirection(GetComponentInChildren <Animator>().gameObject, dir);
}
if (enemyMeleeController != null)
{
enemyMeleeController.enabled = true;
}
if (enemyProjectileController != null)
{
enemyProjectileController.enabled = true;
}
}
private void CorpseExplode(Killable sender)
{
if (ExplosionPrefab != null)
{
var explodeInstance = ResourcePoolManager.GetAvailable(ExplosionPrefab, rBody.position, rBody.rotation);
explodeInstance.transform.localScale = transform.localScale;
var explodeShiftable = explodeInstance.GetComponent<Shiftable>();
if (explodeShiftable != null)
explodeShiftable.SetShiftPosition(Universe.Current.GetUniversePosition(rBody.position));
}
if (DebrisPrefab != null)
{
var debrisInstance = (GameObject)Instantiate(DebrisPrefab, rBody.position, rBody.rotation);
var rBodies = debrisInstance.GetComponentsInChildren<Rigidbody>();
foreach (var debrisrBody in rBodies)
{
debrisrBody.velocity = rBody.velocity;
debrisrBody.AddExplosionForce(200f, transform.position, 20f, 0f, ForceMode.Impulse);
var debrisShiftable = debrisrBody.GetComponent<Shiftable>();
debrisShiftable.SetShiftPosition(Universe.Current.GetUniversePosition(debrisrBody.position));
}
}
if (SmokeInstance != null)
{
SmokeInstance.transform.parent = null;
var woundParticles = SmokeInstance.GetComponent<ParticleSystem>();
if (woundParticles != null)
woundParticles.Stop();
StartCoroutine(DelayedSmokeDestroy(woundParticles.duration + 0.5f));
}
Destroy(gameObject);
}
void DamageAllKillablesNearPlayer()
{
if (KillableMap.instance == null)
{
return;
}
List <Killable> allKillables = KillableMap.instance.allKillables;
for (int i = 0; i < allKillables.Count; ++i)
{
Killable killable = allKillables[i];
if (killable.gameObject == Game.instance.avatar.gameObject)
{
continue;
}
float distance = Vector3.Distance(Game.instance.avatar.transform.position, killable.transform.position);
if (distance < 4f)
{
killable.TakeDamage(gameObject, 1, DamageReason.Spell);
}
}
}
private void SquadronMember_OnDie(Killable sender)
{
PlayerController.Current.ResetThreatCooldown();
// This should on refresh the current squadron member's icon.
HeadsUpDisplay.Current.RefreshSquadronIcons();
sender.OnDamage -= SquadronMember_OnDamage;
sender.OnDie -= SquadronMember_OnDie;
var shieldRegenerator = sender.GetComponent<ShieldRegenerator>();
if (shieldRegenerator != null)
shieldRegenerator.OnRegenerate -= SquadronMember_OnRegenerate;
}
private void SquadronMember_OnDamage(Killable sender, Vector3 position, Vector3 normal, GameObject attacker)
{
if (PlayerController.Current.VehicleInstance != null)
{
if (attacker == PlayerController.Current.VehicleInstance.gameObject)
{
var member = sender.GetComponent<Vehicle>().Controller.GetComponent<Fighter>();
var profile = member.GetComponent<ShipProfile>();
CommMessaging.Current.ShowMessage(attacker, profile.CallSign, GetFriendlyFireMessage(PlayerController.Current.GetCallSign(), profile.CallSign));
}
}
// This should on refresh the current squadron member's icon.
HeadsUpDisplay.Current.RefreshSquadronIcons();
}
private void Update()
{
isFiring = false;
if (IsLive)
{
HideMuzzle();
if (reconsiderCooldown > 0)
reconsiderCooldown -= Time.deltaTime;
if (Vector3.Distance(agent.destination, transform.position) < 0.05f)
{
reconsiderCooldown = -1f;
//animationControl.CrossFade("Idle");
}
else
{
//animationControl.animation["Walk"].speed = agent.velocity.magnitude / WalkVelAnimCoeff;
//animationControl.CrossFade("Walk");
}
if (target != null)
{
var toTarget = target.GetTargetPoint() - transform.position;
var destination = target.transform.position;
if ((transform.position - agent.destination).sqrMagnitude < ShootDistance*ShootDistance)
{
var toTargetPosition = target.transform.position - transform.position;
RaycastHit sightHit;
var sightRay = new Ray(transform.position + toTargetPosition.normalized * 0.8f, toTargetPosition.normalized);
Physics.Raycast(sightRay, out sightHit);
if (sightHit.collider != null)
{
if (sightHit.collider.name == "Player")
{
//Debug.Log("I SEE YOU");
if (toTarget.sqrMagnitude > StopDistance*StopDistance)
{
destination = target.transform.position - StopDistance*toTargetPosition.normalized;
agent.destination = destination;
}
else
{
agent.destination = transform.position;
}
}
}
}
if (reconsiderCooldown < 0)
{
reconsiderCooldown = ReconsiderRate;
var toTargetPosition = target.transform.position - transform.position;
RaycastHit sightHit;
var sightRay = new Ray(transform.position + toTargetPosition.normalized * 0.8f, toTargetPosition.normalized);
Physics.Raycast(sightRay, out sightHit);
if (sightHit.collider != null)
{
if (sightHit.collider.name == "PlayerCollider")
destination = target.transform.position - StopDistance*toTarget.normalized;
}
agent.destination = destination;
}
// Shooting
var aimDirection = Quaternion.LookRotation(target.GetTargetPoint() - primaryWeapon.ShootPoint.position);
if (toTarget.magnitude < ShootDistance)
{
var yawDiff = Mathf.DeltaAngle(aimDirection.eulerAngles.y, transform.rotation.eulerAngles.y);
if (Mathf.Abs(yawDiff) < AimAngleTolerance)
{
// Do not shoot if ally in way
var shootRay = new Ray(primaryWeaponShootPoint.position, aimDirection * new Vector3(0, 0, 1));
RaycastHit shootHit;
var dontShoot = false;
if (Physics.Raycast(shootRay, out shootHit))
{
if (shootHit.collider.name != "EnemyCollider")
dontShoot = true;
}
if (dontShoot)
{
//animationControl.CrossFade("Shoot");
primaryWeapon.TriggerShoot(aimDirection);
}
}
}
}
else
{
target = FindTarget();
}
// Animation
Debug.Log(agent.velocity.normalized.magnitude);
enemyAnimator.SetFloat("Speed", Mathf.Clamp(agent.velocity.normalized.magnitude, 0f, 1f));
enemyAnimator.SetFloat("ForwardBackward", Mathf.Clamp(agent.velocity.normalized.z, -1f, 1f));
enemyAnimator.SetFloat("LeftRight", Mathf.Clamp(agent.velocity.normalized.x, -1f, 1f));
enemyAnimator.SetBool("IsFiring", isFiring);
UpdateKillable();
}
}
private void AsteroidField_OnDie(Killable sender)
{
// TODO: This isn't perfect, whenever an asteroid is destroyed a new one will be respawned,
// really the asteroid should just be hidden and reset when it falls out of the range
MakeAvailable(sender.gameObject);
}
private void OnSpawnedDie(Killable sender)
{
_liveCount--;
Debug.Log("SPAWNED DIED!");
}
public virtual void DestroyingKillable(Killable deadKillable)
{
// your code here.
}
private void RemoveTarget(Killable target)
{
_targets.Remove(target);
}
public override void TakingDamage(int pointsDamage, Killable enemyHitBy)
{
base.TakingDamage(pointsDamage, enemyHitBy);
// your code here.
}
void Start()
{
body = GetComponent<SpaceGravityBody> ();
killable = GetComponent<Killable> ();
characterController = GetComponent<CharacterController> ();
attackController = GetComponent<CharacterAttackController> ();
GameObject attack = GameObject.Find("skillAttack");
initializePlayerRotation ();
bpAnimator = animationBigPappada.GetComponent<Animator>();
pappadaC = pappada.GetComponent<PappadaController> ();
flyParticles = flyingParticles.GetComponent<ParticleSystem> ();
getHurtBigPappada = GameObject.Instantiate (getHurtBigPappadaPrefab) as GameObject;
initializeVariables ();
StartCoroutine ("resetWeaponTrail");
}
private void OnHit(Killable entity)
{
SwitchPhaseIfNecessary();
}
private void Awake()
{
killable = GetComponent<Killable>();
killable.OnDamage += OnKillableDamage;
}
private void PlayerController_OnDie(Killable sender)
{
_noThreatCooldown = NoThreatTime;
_deathCooldown = DeathOptionTime;
_lastDeathUniversePosition = new UniversePosition(_playVehicleInstance.Shiftable.UniversePosition.CellIndex, _playVehicleInstance.Shiftable.UniversePosition.CellLocalPosition);
Debug.Log("PLAYER VEHICLE DESTROYED AT: " + _lastDeathUniversePosition.CellIndex);
HeadsUpDisplay.Current.RefreshSquadronIcon(0);
HeadsUpDisplay.Current.TriggerCrosshairFadeOut();
}
public virtual void WaitingToDestroyKillable(Killable deadKillable)
{
// your code here;
}
// Use this for initialization
void Start()
{
killable = GetComponent<Killable> ();
}
private void PlayerController_OnDamage(Killable sender, Vector3 position, Vector3 normal, GameObject attacker)
{
HeadsUpDisplay.Current.Hit();
Universe.Current.ViewPort.GetComponent<VehicleCamera>().TriggerShake(0.3f, 0.7f, 0.1f);
HeadsUpDisplay.Current.RefreshSquadronIcon(0);
if (VehicleInstance.Killable.Shield > 0f)
{
HeadsUpDisplay.Current.TriggerShieldHit();
}
else
{
HeadsUpDisplay.Current.TriggerHealthHit();
}
}
