// Start is called before the first frame update void Start() { enemy = GetComponent <EnemyTarget>(); navMesh = GetComponentInParent <NavMeshAgent>(); navMesh.speed = enemy.startSpeed; }
void SearchTarget() { GameObject[] enemies = GameObject.FindGameObjectsWithTag("Enemy"); GameObject nearestEnemy = null; shortestDistance = Mathf.Infinity; foreach (GameObject enemy in enemies) { float distanceToEnemy = Vector3.Distance(transform.position, enemy.transform.position); if (distanceToEnemy < shortestDistance) { shortestDistance = distanceToEnemy; nearestEnemy = enemy; targetEnemy = nearestEnemy.GetComponent <EnemyTarget>(); } } if (nearestEnemy != null && shortestDistance <= range) { target = nearestEnemy.transform; } else { target = null; } }
void HandeleLookToEnemyRotation(float d) { if (lookToEnemy) { Vector3 targetDir = lockonTransform.position - this.transformCache.position; targetDir.Normalize(); if (targetDir == Vector3.zero) { targetDir = this.transformCache.forward; } Quaternion targetRot = Quaternion.LookRotation(targetDir); targetRot.x = 0; targetRot.z = 0; if (targetRot.eulerAngles.y + 5f > transformCache.rotation.eulerAngles.y && transformCache.rotation.eulerAngles.y > targetRot.eulerAngles.y - 5f) { lockonTarget = null; lockonTransform = null; lockon = false; lookToEnemy = false; return; } transformCache.rotation = Quaternion.Slerp(transformCache.rotation, targetRot, d * 20); lookAngle = transformCache.rotation.eulerAngles.y; } }
public void SeesEnemy(HumanoidModel enemy, Vector3 location) { /* * first remove the nearest enemy marker that is in range * if seeing enemy for the first time */ EnemyTarget target = null; viewableEnemies.TryGetValue(enemy, out target); if (target == null) { foreach (CommunicatableEnemyMarker marker in hiddenEnemies) { if (Vector3.Distance(location, marker.GetEnemyMarker().GetLocation()) < hiddenEnemyRadius) { marker.Invalidate(); HumanoidTargeterCommunication.Communicate( new CommunicationPackage( GetDeepCopyOfHiddenEnemies(), this ) ); RemoveHiddenEnemy(marker); break; } } } // next add viewable enemy viewableEnemies[enemy] = new EnemyTarget(enemy, location); }
public void Configure(SpawnConfig config, EnemyTarget target, Wave wave, PrecalculatedPath path) { // just for reference currentConfig = config; currentWave = wave; color = config.color; spriteRenderer.sprite = sprites.GetSprite(currentConfig.kind); switch (currentConfig.color) { case ColorType.Red: spriteRenderer.color = Color.red; gameObject.layer = LayerMask.NameToLayer("EnemyRed"); break; case ColorType.Green: spriteRenderer.color = Color.green; gameObject.layer = LayerMask.NameToLayer("EnemyGreen"); break; case ColorType.Blue: spriteRenderer.color = Color.blue; gameObject.layer = LayerMask.NameToLayer("EnemyBlue"); break; } health = currentConfig.health; spinner.speed = currentConfig.spinSpeed; pathFollower.speed = currentConfig.walkSpeed; pathFollower.target = target; pathFollower.UpdatePath(path.path, path.calculatedAt); }
public CommunicatableEnemyTarget( EnemyTarget t ) { target = t; isValid = true; }
void Explode() { // Show effect GameObject explosion = Instantiate(explosionEffect, transform.position, transform.rotation); Collider[] colliders = Physics.OverlapSphere(transform.position, radius); foreach (Collider nearbyObject in colliders) { Rigidbody rb = nearbyObject.GetComponent <Rigidbody>(); if (rb != null) { rb.AddExplosionForce(force, transform.position, radius, upforce, ForceMode.Impulse); } EnemyTarget nearbyTarget = nearbyObject.transform.root.gameObject.GetComponent <EnemyTarget>(); if (nearbyTarget != null) { float proximity = (transform.position - nearbyTarget.transform.position).magnitude; int explosiveEffect = 1 - (int)(proximity / radius); nearbyTarget.TakeDamage(explosiveEffect * 7); } } // Remove grenade Destroy(gameObject); Destroy(explosion, 2.5f); }
public void Shoot() { currentAmmo--; Debug.Log("currentammo:" + currentAmmo); muzzleFlash.Play(); RaycastHit hit; if (Physics.Raycast(fpsCam.transform.position, fpsCam.transform.forward, out hit, range)) { EnemyTarget enemyTarget = hit.transform.GetComponent <EnemyTarget>(); // convert this to abstract class if (enemyTarget != null) { enemyTarget.KillDamage(fireDamage); } if (hit.rigidbody != null) { hit.rigidbody.AddForce(-hit.normal * rifleImpactForce); } GameObject impactGameObject = Instantiate(impactEffect, hit.point, Quaternion.LookRotation(hit.normal)); Destroy(impactGameObject, 1.4f); GameObject bulletObject = Instantiate(bulletTex[UnityEngine.Random.Range(0, 2)], hit.point, Quaternion.FromToRotation(Vector3.up, hit.normal)); bulletObject.transform.parent = hit.transform; // we made bullets the children of the object they hit, so there will be no floating bullet texture on dynamic objects. Destroy(bulletObject, 2f); } }
/// <summary> /// Attackings coroutine that is called every 1 sec. /// </summary> /// <returns></returns> private IEnumerator Attacking() { while (true) { Animator.SetTrigger("Smash Attack"); EnemyTarget.SetDamage(_damage); yield return(new WaitForSeconds(1)); } }
void FixedUpdate() { EnemyTarget enemyTarget = GetComponent <EnemyTarget>(); if (enemyTarget) { //Attach progress bar if (!progressBar) { GameObject go = Instantiate(PrefabManager.instance.progressBarType, transform.position, Quaternion.identity); go.transform.Translate(new Vector3(0.3f, +0.5f)); progressBar = go.GetComponent <HealthBar>(); } //Detect if any enemy in range GameObject[] enemies = EnemiesInRange(); if (enemies.Length > 0) { enemyTowerProgress += enemies.Length / 5f; progressBar.SetHealthRatio(enemyTowerProgress / 100f); if (enemyTowerProgress >= 100f) { if (towerController == null) { tower = FindObjectOfType <TowerSpawner>().InitTower(transform); towerController = tower.GetComponentInChildren <TowerController>(); towerType = tower.GetComponentInChildren <TowerType>(); isOccupied = true; towerController.UpdateOwnerToEnemy(); } else if (towerController.owner != TowerOwner.ENEMY) { towerController.UpdateOwnerToEnemy(); } else if (towerController.owner == TowerOwner.ENEMY) { towerController.UpgradeTower(); } Destroy(progressBar.gameObject); progressBar = null; enemyTowerProgress = 0f; } } } else { enemyTowerProgress = 0f; if (progressBar) { Destroy(progressBar.gameObject); progressBar = null; } } }
void hitDamage(Transform enemy) { EnemyTarget e = enemy.GetComponent <EnemyTarget>(); if (e != null) { e.TakeDamage(damage); } //Destroy(enemy.gameObject); }
bool CheckForBackStab(Action slot) { //If the weapon has no back stab ability, skip if (!slot.canBackStab) { return(false); } EnemyStates backStabTarget = null; Vector3 origin = transform.position; origin.y += 1; Vector3 raycastDir = transform.forward; RaycastHit hit; if (Physics.Raycast(origin, raycastDir, out hit, 1, ignoreLayers)) { backStabTarget = hit.transform.GetComponentInParent <EnemyStates>(); } if (backStabTarget == null) { return(false); } //Direction towards the player Vector3 direction = transform.position - backStabTarget.transform.position; direction.Normalize(); direction.y = 0; float angle = Vector3.Angle(backStabTarget.transform.forward, direction); Debug.Log("Backstab angle: " + angle); if (angle > 150) { //Get target position Vector3 targetPos = direction * backStabOffset; targetPos += backStabTarget.transform.position; transform.position = targetPos; backStabTarget.transform.rotation = transform.rotation; backStabTarget.IsGettingBackStabbed(slot, inventoryManager.GetCurrentWeapon(slot.mirror)); onEmpty = false; canMove = false; canAttack = false; inAction = true; animator.SetBool(StaticStrings.animParam_Mirror, slot.mirror); animator.CrossFade(StaticStrings.animParam_ParryAttack, 0.2f); lockOnTarget = null; return(true); } return(false); }
private void MarkTileAsTarget() { TileScript[] tiles = FindObjectsOfType <TileScript>(); int index = (int)Random.Range(0, tiles.Length); GameObject tile = tiles[index].gameObject; tile.AddComponent <EnemyTarget>(); tile.GetComponent <SpriteRenderer>().color = new Color(222f / 255f, 71f / 255f, 224f / 255f); tileTarget = tile.GetComponent <EnemyTarget>(); }
bool CheckForBackstab(Action slot) { if (!slot.canBackstab) { return(false); } EnemyStates backstabTarget = null; Vector3 origin = transform.position; origin.y += 1; Vector3 rayDir = transform.forward; RaycastHit hit; if (Physics.Raycast(origin, rayDir, out hit, 3, ignoreLayers)) { backstabTarget = hit.transform.GetComponentInParent <EnemyStates>(); } if (backstabTarget == null) { return(false); } Vector3 dir = transform.position - backstabTarget.transform.position; dir.Normalize(); dir.y = 0; float angle = Vector3.Angle(backstabTarget.transform.forward, dir); if (angle > 150) { Vector3 targetPos = dir * backstabOffset; targetPos += backstabTarget.transform.position; transform.position = targetPos; backstabTarget.transform.rotation = transform.rotation; backstabTarget.IsGettingBackstabbed(slot, inventoryManager.GetCurrentWeapon(slot.mirror)); onEmpty = false; canAttack = false; canMove = false; inAction = true; anim.SetBool(StaticStrings.mirror, slot.mirror); anim.CrossFade(StaticStrings.parry_attack, 0.2f); lockonTarget = null; return(true); } return(false); }
void SpawnMiniBoss() { EnemyTarget playerTarget = GameObject.FindGameObjectWithTag("Player").GetComponent <EnemyTarget>(); GameObject newEnemy = CreateSimpleEnemy(PrefabManager.instance.enemy_tower_builder, playerTarget); newEnemy.transform.localScale = new Vector3(2, 2, 1); newEnemy.GetComponent <SimpleEnemyController>().maxHp = powerRuleForMiniBossMaxHp.retrieveValueForLevel(GameManager.instance.wave); newEnemy.GetComponent <SimpleEnemyController>().coinDrop = (int)powerRuleForMiniBossCoinDrop.retrieveValueForLevel(GameManager.instance.wave); newEnemy.GetComponent <EnemyController>().baseCoolDownTime = newEnemy.GetComponent <EnemyController>().baseCoolDownTime / 2f; newEnemy.GetComponent <EnemyController>().baseForce = powerRuleForMiniBossForce.retrieveValueForLevel(GameManager.instance.wave); newEnemy.GetComponent <EnemyController>().Speed = powerRuleForMiniBossSpeed.retrieveValueForLevel(GameManager.instance.wave); }
void OnCollisionEnter(Collision collision) { ContactPoint contact = collision.contacts[0]; Instantiate(impactEffect, contact.point, Quaternion.LookRotation(contact.normal)); if (collision.gameObject.tag == "Enemy") { EnemyTarget target = collision.transform.gameObject.GetComponent <EnemyTarget>(); target.ApplyDamage(damage); } Destroy(gameObject); }
void Update() { //Press Space Key To Lock On if (Input.GetKeyDown(KeyCode.Q) && !lockedOn) { if (nearByEnemies.Count >= 1) { lockedOn = true; image.enabled = true; //Lock On To First Enemy In List By Default lockedEnemy = 0; target = nearByEnemies[lockedEnemy]; } } //Turn Off Lock On When Space Is Pressed Or No More Enemies Are In The List else if ((Input.GetKeyDown(KeyCode.Q) && lockedOn) || nearByEnemies.Count == 0) { lockedOn = false; image.enabled = false; lockedEnemy = 0; target = null; } if (Input.GetKeyDown(KeyCode.E)) { if (lockedEnemy == nearByEnemies.Count - 1) { //If End Of List Has Been Reached, Start Over lockedEnemy = 0; target = nearByEnemies[lockedEnemy]; } else { //Move To Next Enemy In List lockedEnemy++; target = nearByEnemies[lockedEnemy]; } } if (lockedOn && PauseMenu.GameIsPaused == false) { target = nearByEnemies[lockedEnemy]; //Determine Crosshair Location Based On The Current Target gameObject.transform.position = cam.WorldToScreenPoint(target.transform.position); //Rotate Crosshair gameObject.transform.Rotate(new Vector3(0, 0, -1)); } }
public Transform CreateAvoidanceTarget(Vector3 heading) { if (enemyTarget) { enemyTarget.transform.position = GetRotatedHeading(heading); } else { enemyTarget = Instantiate(targetPrefab, GetRotatedHeading(heading), Quaternion.identity) as EnemyTarget; enemyTarget.targetEnemy = enemy; } return enemyTarget.transform; }
public static void FlankLeftVisibleEnemy(EnemyTarget enemy) { AttackableObject <EnemyTarget> info = instance.targetsForAttack.Find(m => { return(m.GetObject() == enemy); }); if (info == null) { Debug.LogError("No enemy target found!"); } else { info.AddLeftFlanker(); } }
public static void NoLongerSuppressVisibleEnemy(EnemyTarget enemy) { AttackableObject <EnemyTarget> info = instance.targetsForAttack.Find(m => { return(m.GetObject() == enemy); }); if (info == null) { Debug.LogError("No enemy target found!"); } else { info.RemoveSuppressor(); } }
public void Initialization() { AgentAI = GetComponent <NavMeshAgent>(); RIGI.isKinematic = true; RIGI = GetComponent <Rigidbody>(); anim = GetComponentInChildren <Animator>(); ETarget = GetComponent <EnemyTarget>(); ETarget.Init(this); InitRagDoll(); EparryIsON = false; IgnoreLayers = ~(1 << 9); EnemyPos = this.transform.position; }
public EnemyTarget GetEnemy(Vector3 from) { EnemyTarget r = null; float minDis = float.MaxValue; for (int i = 0; i < enemyTargets.Count; i++) { float tDis = Vector3.Distance(from, enemyTargets[i].GetTarget().position); if (tDis < minDis) { minDis = tDis; r = enemyTargets[i]; } } return(r); }
public static int GetSuppressorsOnVisibleEnemy( EnemyTarget target ) { AttackableObject <EnemyTarget> info = instance.targetsForAttack.Find(m => { return(m.GetObject() == target); }); if (info == null) { Debug.LogError("No enemy target found!"); return(0); } else { return(info.GetCoveringFireAttackers()); } }
/// <summary> /// Checks line of sight to a target object or the "Player" based on a raycast to the target object. This raycast will not hit trigger colliders; /// </summary> /// <param name="actor"></param> /// <returns></returns> private void LookForActor(GameObject actor) { //TODO set up field of view RaycastHit hit; Vector3 direction = actor.transform.position - this.transform.position; Ray sightLine = new Ray(this.transform.position, direction); //make sure if the player isn't seen, the flag is not true targetInSight = false; if (Physics.Raycast(sightLine, out hit)) { //Raycasts to the player to check line of sight if (hit.collider.gameObject.transform.tag == "Player") { targetInSight = true; lastPlayerPos = actor.transform; enemyTarget = EnemyTarget.Player; } //Raycasts to the player to check line of sight if (hit.collider.gameObject.transform.tag == "Survivor") { targetInSight = true; lastPlayerPos = actor.transform; enemyTarget = EnemyTarget.Survivor; } } if (Physics.Raycast(sightLine, out hit, maxSightDistance, buildLayer, QueryTriggerInteraction.Collide)) { //If the player can not be seen and a wall is in the way, target that wall enemyTarget = EnemyTarget.Structure; targetInSight = true; targetwall = hit.collider.gameObject.GetComponent <BaseWall>(); hasAttackPosition = true; } if (!targetInSight) { enemyTarget = EnemyTarget.None; } }
private GameObject CreateSimpleEnemy(GameObject enemyPrefab, EnemyTarget enemyTarget) { GameObject newEnemy = Instantiate(enemyPrefab); newEnemy.GetComponent <EnemyController>().Target = enemyTarget; float randX = Random.Range(-horzExtent * 0.8f, +horzExtent * 0.8f); float randY = Random.Range(vertExtent, vertExtent + vertExtent / 10); newEnemy.transform.position = new Vector3(randX, randY, 0); newEnemy.GetComponent <SimpleEnemyController>().healthBarType = PrefabManager.instance.healthBarType.GetComponent <HealthBar>(); newEnemy.GetComponent <SimpleEnemyController>().maxHp = powerRuleForEnemyMaxHp.retrieveValueForLevel(GameManager.instance.wave); newEnemy.GetComponent <SimpleEnemyController>().coinDrop = (int)powerRuleForEnemyCoinDrop.retrieveValueForLevel(GameManager.instance.wave); newEnemy.GetComponent <EnemyController>().baseForce = powerRuleForEnemyForce.retrieveValueForLevel(GameManager.instance.wave); newEnemy.GetComponent <EnemyController>().Speed = powerRuleForEnemySpeed.retrieveValueForLevel(GameManager.instance.wave); return(newEnemy); }
void Start() { health = 10000000; anim = GetComponentInChildren <Animator>(); enemyTarget = GetComponent <EnemyTarget>(); enemyTarget.Init(this); rigid = GetComponent <Rigidbody>(); a_hook = anim.GetComponent <AnimatorHook>(); if (a_hook == null) { a_hook = anim.gameObject.AddComponent <AnimatorHook>(); } a_hook.Init(null, this); InitRagdoll(); parryIsOn = false; }
private static void BitchThatWasMyKill() { var enemies = GameObjects.Enemy.Where(e => e.IsValidTarget(Shotgun.Range) && e != null); //Menu var UseShotgun = Config["killsteal"]["ks.shotgun"].GetValue <MenuBool>().Enabled; var UseTrap = Config["killsteal"]["ks.trap"].GetValue <MenuBool>().Enabled; var UseDash = Config["killsteal"]["ks.dash"].GetValue <MenuBool>().Enabled; foreach (var EnemyTarget in enemies) { if (EnemyTarget.IsValid && EnemyTarget != null) { //Prediction var ShotgunPred = Shotgun.GetPrediction(EnemyTarget).Hitchance >= HitChance.High; var TrapPred = Trap.GetPrediction(EnemyTarget).Hitchance >= HitChance.High; var DashPred = Dash.GetPrediction(EnemyTarget).Hitchance >= HitChance.High; //Damages double DashDmg = DashDamage(EnemyTarget); double AADamage = ObjectManager.Player.GetAutoAttackDamage(EnemyTarget); double ShotgunDmg = ShotgunDamage(EnemyTarget); double TrapDmg = TrapDamage(EnemyTarget); if (!Mounted() && EnemyTarget.Health < ShotgunDmg && UseShotgun && EnemyTarget.IsValidTarget(Shotgun.Range) && ShotgunPred) { Shotgun.Cast(EnemyTarget); } if (Mounted()) { if (EnemyTarget.Health < TrapDmg && UseTrap && EnemyTarget.IsValidTarget(Trap.Range) && TrapPred) { Trap.Cast(EnemyTarget); } if (EnemyTarget.Health < TrapDmg && UseDash && EnemyTarget.IsValidTarget(Dash.Range) && DashPred) { Dash.Cast(EnemyTarget); } } } } }
public void Init() { health = 100; anim = GetComponentInChildren <Animator>(); enTarget = GetComponent <EnemyTarget>(); enTarget.Init(this); rigid = GetComponent <Rigidbody>(); agent = GetComponent <NavMeshAgent>(); rigid.isKinematic = true; a_hook = anim.GetComponent <AnimtorHook>(); if (a_hook == null) { a_hook = anim.gameObject.AddComponent <AnimtorHook>(); } a_hook.Init(null, this); InitRagDoll(); //dataRecolected = GameObject.Find("DataRecolected").GetComponent<DataRecolected>(); ignoreLayers = ~(1 << 9); }
void StartSpawn() { spawnCount = powerRuleForEnemyNumbers.retrieveValueForLevel(GameManager.instance.wave); towerBuilderSpawnCount = powerRuleForEnemyBuilderNumbers.retrieveValueForLevel(GameManager.instance.wave); currentCount = spawnCount + towerBuilderSpawnCount; isMiniBossSpawned = false; MarkTileAsTarget(); EnemyTarget playerTarget = GameObject.FindGameObjectWithTag("Player").GetComponent <EnemyTarget>(); for (int i = 0; i < spawnCount; i++) { CreateSimpleEnemy(PrefabManager.instance.enemy, playerTarget); } for (int i = 0; i < towerBuilderSpawnCount; i++) { CreateSimpleEnemy(PrefabManager.instance.enemy_tower_builder, tileTarget); } }
protected EnemyIntent GenerateIntent() { if (GameManager.instance.turn % 2 == 0) { // Attack Direction direction = GenEnemyTargetDirection(); Vector2 start = (Vector2)transform.position; Vector2 location = start + DirectionToCoordinates(direction); EnemyTarget enemyTarget = Instantiate(enemyTargetPrefab, location, Quaternion.identity); return(new AttackLocation(location)); } else { // Move Direction direction; if (Mathf.Abs(target.position.x - transform.position.x) < float.Epsilon) { direction = target.position.y > transform.position.y ? Direction.U : Direction.D; } else { direction = target.position.x > transform.position.x ? Direction.R : Direction.L; } Vector2 start = (Vector2)transform.position; Vector2 location = start + DirectionToCoordinates(direction); EnemyMove enemyMove = Instantiate(enemyMovePrefab, transform.position, Quaternion.identity); SpriteRenderer spriteRenderer = enemyMove.GetComponent <SpriteRenderer>(); spriteRenderer.sprite = GetSpriteFromDirection(direction); return(new MoveToLocation(location)); } }
protected IEnumerator RestartOrbitRoutine(EnemyTarget enemy, float duration) { this.OrbitEnabled = false; float halfDuration = duration / 2.0f; iTween.EaseType goEase = iTween.EaseType.easeOutQuad; iTween.EaseType backEase = iTween.EaseType.linear; this.gameObject.MoveTo( enemy.transform.position ).Time( halfDuration ).EaseType(goEase).Execute(); // note: use local coordinates here to return to the target // this only works if the projectiles are children of the target!!! this.gameObject.MoveTo( target.transform.InverseTransformPoint( target.transform.position ) ).IsLocal(true).Time ( halfDuration ).EaseType(backEase).Delay( halfDuration ).Execute(); yield return new WaitForSeconds( halfDuration ); if( enemy != null ) { SoundManager.use.PlaySFX( SoundManager.use.enemyHit ); enemy.OnAttacked(); GameObject.Destroy( enemy.gameObject ); } yield return new WaitForSeconds( halfDuration ); iTween.Stop( this.gameObject ); transform.position = GetOrbitStartPosition(); OrbitEnabled = true; }
public void Attack(EnemyTarget target, float duration) { LugusCoroutines.use.StartRoutine( RestartOrbitRoutine(target, duration) ); }
public EnemyMarker(EnemyTarget target, HumanoidTargeter founder) : this(target.GetEnemy(), target.GetLocation(), founder) { }
void Start() { m_target = GameObject.Find("EnemyTarget").GetComponent<EnemyTarget>(); m_enemyMan = GameObject.Find("EnemyManager").GetComponent<EnemyManager>(); m_gameKB = GameObject.Find("GameKeyboard").GetComponent<GameKeyboard>(); m_gameKB.lockKeyboard(false); }