public void Initialize()
{
enemy = GetComponentInParent <EnemyTest>();
enemy.stealth = GameObject.FindGameObjectWithTag("Player").GetComponent <StealthSystem>();
timeToDetect = enemy.stealth.timeToDetect;
//FinalRayPos = enemy.stealth.sightFinalRayPos;
}
private void OnCollisionEnter(Collision collision)
{
if (!playOneTime)
{
source.ChangePitchAndVolume(0.7f, 1, 0.95f, 1.05f);
source.Play();
Instantiate(explosionParticle, transform.position, Quaternion.identity);
playOneTime = true;
}
Renderer renderer = GetComponent <Renderer>();
renderer.enabled = false;
explosionArea.GetComponent <Renderer>().enabled = false;
Collider[] colliders = Physics.OverlapSphere(transform.position, explosionRadius, explosionLayer);
foreach (Collider objectsToExplode in colliders)
{
if (objectsToExplode.tag == "Enemy")
{
EnemyTest enemy = objectsToExplode.GetComponent <EnemyTest>();
enemy.Damage(misileDamage);
}
}
Destroy(gameObject, 5);
}
public void Explode()
{
finalPos = transform.position;
//Get Objects
Collider[] colliders = Physics.OverlapSphere(transform.position, radius, layer);
source.ChangePitchAndVolume(0.7f, 1, 0.95f, 1.05f);
source.PlayOneShot(explosionClip);
foreach (Collider nearbyObject in colliders)
{
if (nearbyObject.tag == "Enemy")
{
EnemyTest enemy = nearbyObject.GetComponent <EnemyTest>();
enemy.positionWhereSound = finalPos;
/*if (enemy.wantToHear)
* {
* enemy.SetLook(enemy.positionWhereSound);
* }*/
Debug.Log("Vector Set");
}
}
//Remove Granade
coll.enabled = false;
rb.detectCollisions = false;
mesh.enabled = false;
//Destroy(gameObject, 5);
}
public void OnTriggerEnter(Collider other)
{
if (other.tag == "Enemy")
{
Debug.Log("Enemy");
EnemyTest enemy = other.GetComponent <EnemyTest>();
if (!enemy.dead)
{
enemy.anim.SetAnimHit();
}
enemy.StunnedSet(StunedTime);
if (!player.GM.improved)
{
enemy.Damage(player.normalModeFistDamage);
}
else
{
enemy.Damage(player.improvedModeFistDamage);
}
enemy.Detected = true;
if (!enemy.dead)
{
basicSource.ChangePitchAndVolume(0.7f, 1, 0.95f, 1.05f);
basicSource.PlayOneShot(HitSound);
}
}
}
void Burning()
{
Collider[] objects = Physics.OverlapBox(transform.position, halfSize, transform.rotation, layer);
foreach (Collider objectsBurning in objects)
{
if (objectsBurning.tag == "Object" | objectsBurning.tag == "Enemy")
{
Fireable fireable = objectsBurning.GetComponent<Fireable>();
if (objectsBurning.tag == "Enemy")
{
EnemyTest enemy = objectsBurning.GetComponent<EnemyTest>();
if (enemy.dead)
{
return;
}
}
if (fireable != null)
{
fireable.timeCounter += Time.deltaTime;
}
}
}
}
public void Reset(LevelType theLevelType, Byte theEnemySpawn, UInt16 minDelay, UInt16 maxDelay, Byte enemyTotal)
{
levelType = theLevelType;
maxEnemySpawn = theEnemySpawn;
if (maxEnemySpawn > Constants.MAX_ENEMYS_SPAWN)
{
maxEnemySpawn = Constants.MAX_ENEMYS_SPAWN;
}
MinDelay = minDelay;
MaxDelay = maxDelay;
// Reset all enemies but not the list as will clear.
for (Byte index = 0; index < maxEnemySpawn; index++)
{
EnemyList[index].Reset();
}
EnemyTest.Clear();
EnemyDict.Clear();
// Ensure total at least the max.
if (enemyTotal < maxEnemySpawn)
{
enemyTotal = maxEnemySpawn;
}
EnemyTotal = enemyTotal;
EnemySpawn = 0;
}
void CheckReset()
{
if (constantDistToEnemy >= distToReset)
{
nearestDistance = Mathf.Infinity;
nearestEnemy = null;
constantDistToEnemy = 0;
}
}
/* ************************************************ */
/* Main Functions */
/* ************************************************ */
void Start()
{
_parent = transform.parent.gameObject;
_enemyScript = _parent.GetComponent <EnemyTest>();
_detectorScript = _parent.transform.GetChild(0).GetComponent <ObjectDetector>();
_audioScript = _parent.transform.GetChild(2).GetComponent <AudioManager>();
_myPrefab = GetAmmoType();
}
public void Initialize()
{
enemy = GetComponentInParent <EnemyTest>();
playerDetector = GetComponent <SphereCollider>();
timeToRest = initialRestValue;
playerDetector.radius = radiusOfDetection;
timeToDetect = enemy.stealth.timeToDetect;
closeDistance = initCloseDistance;
closeTimeToDetect = initCloseTimeToDetect;
}
/* ************************************************ */
/* Apply damages on player functions */
/* ************************************************ */
private void _ApplyDamageFromEnemy(EnemyTest enemy, Player player)
{
if (enemy.AttackTypePhysic)
{
player.LooseLife(enemy.Strength);
}
if (enemy.AttackTypeMagic)
{
player.LooseMana(enemy.Strength);
}
}
void GainStamina()
{
if (nearestEnemy != null && nearestEnemy.addStamina > 0 && nearestEnemy.addLife > 0)
{
if (nearestEnemy.absorbTimeCounter >= nearestEnemy.maxTimeToAbsorb)
{
nearestEnemy.absorbPercentage = 1;
if (howMuchToAddStamina == 0 && howMuchToAddLife == 0)
{
howMuchToAddStamina += nearestEnemy.addStamina * nearestEnemy.absorbPercentage;
howMuchToAddLife += nearestEnemy.addLife * nearestEnemy.absorbPercentage;
Debug.Log(howMuchToAddStamina + "FromGain");
}
nearestEnemy.addStamina = 0;
nearestEnemy.addLife = 0;
nearestEnemy.absorbTimeCounter = 0;
IWM.player.stop = false;
IWM.absorbing = false;
IWM.stamina += howMuchToAddStamina;
IWM.player.life.health += howMuchToAddLife;
howMuchToAddStamina = 0;
howMuchToAddLife = 0;
IWM.addConstantLife = true;
IWM.addConstantStamina = true;
Destroy(nearestEnemy.gameObject, 5);
nearestEnemy = null;
IWM.player.CC.canHit = true;
if (source.isPlaying)
{
source.loop = false;
source.Stop();
playSound = false;
}
source.ChangePitchAndVolume(0.7f, 1, 0.95f, 1.05f);
//source.PlayOneShot(absorbed);
}
else
{
nearestEnemy.absorbTimeCounter += Time.deltaTime;
nearestEnemy.absorbPercentage = Mathf.Clamp01(nearestEnemy.absorbTimeCounter / nearestEnemy.maxTimeToAbsorb);
}
}
}
/* ************************************************ */
/* Main Functions */
/* ************************************************ */
void Start()
{
_parent = transform.parent.gameObject;
_rb2d = _parent.GetComponent <Rigidbody2D>();
_sprite = _parent.GetComponent <SpriteRenderer>();
_enemyScript = _parent.GetComponent <EnemyTest>();
_collider = GetComponent <BoxCollider2D>();
IsKnock = false;
}
public void Update(GameTime gameTime)
{
EnemyTest.Clear();
for (Byte index = 0; index < maxEnemySpawn; index++)
{
Enemy enemy = EnemyList[index];
enemy.Update(gameTime);
if (EnemyType.Test == enemy.EnemyType)
{
EnemyTest.Add(enemy);
}
}
}
/* ************************************************ */
/* Coroutines */
/* ************************************************ */
/* KnockBack */
private IEnumerator _KnockBackTimeEnemyCo(GameObject enemy)
{
// Get Direction of knockback
Vector2 directionKnock = CalculateKnockBackDirection(enemy.transform.position);
EnemyTest enemyTest = enemy.GetComponent <EnemyTest>();
KnockToggleParam(true);
_BlockMovement(true);
// Application de la nouvelle force
_ApplyThrustOnPlayer(directionKnock * enemyTest.Thrust);
_CallHurt();
yield return(new WaitForSeconds(enemyTest.KnockBackTime));
_BlockMovement(false);
}
void Start()
{
itsef = gameObject.GetComponent <EnemyTest>();
currentLife = maxLife;
agent = GetComponent <NavMeshAgent>();
player = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerController>();
gm = GameObject.FindGameObjectWithTag("Managers").GetComponent <GameManager>();
audPlay = GetComponentInChildren <AudioPlayer>();
stealth = player.GetComponentInChildren <StealthSystem>();
playerDetector = GetComponentInChildren <EnemyPlayerDetector>();
sight = GetComponentInChildren <EnemySight>();
attack = GetComponentInChildren <EnemyAttackArea>();
execution = GetComponentInChildren <ExecutionArea>();
rigid = GetComponent <Rigidbody>();
anim = GetComponent <EnemyAnimations>();
anim.Initialize();
playerDetector.Initialize();
sight.Initialize();
execution.Initialize();
states = State.Stationary;
StationarySet();
generalWaitOnPointTime = initGeneralWaitOnPointTime;
waitOnPointTime = initWaitOnPointTime;
waitComeFromSound = initWaitComeFromSound;
percentageOfWait = initPercentageOfWait;
}
// Update is called once per frame
void Update()
{
findWeapon();
determineDamage();
//if player pressed left mouse (attack)
if (Input.GetMouseButtonDown(0))
{
Physics2D.queriesStartInColliders = false;
//uses raycast at the moment. May change later
RaycastHit2D hit = Physics2D.Raycast(new Vector2(transform.position.x, transform.position.y), Vector2.right * transform.localScale.x, range);
if (hit.collider != null && hit.collider.gameObject.layer == 10) //enemy layer is 10
{
Debug.Log("Player Done: " + damage + " damage");
EnemyTest enem = hit.collider.gameObject.GetComponent <EnemyTest> ();
enem.takeDamage(damage);
}
}
}
public void Hit()
{
switch (type)
{
case Type.EnemyA:
enemyAScript = GetComponent <EnemyTest>();
enemyAScript.newPosition();
GameObject.Find("Player").GetComponent <PlayerHandler>().updateScore();
break;
case Type.EnemyB:
break;
case Type.Object:
break;
}
}
public void Explode()
{
Debug.Log("Booom");
// Show Effects
GameObject GranadeExplosion = Instantiate(explosionEffect, transform.position, transform.rotation);
Destroy(GranadeExplosion, 10);
source.ChangePitchAndVolume(0.7f, 1, 0.95f, 1.05f);
source.PlayOneShot(explosionClip);
//Get Objects
Collider[] colliders = Physics.OverlapSphere(transform.position, radius, layer);
foreach (Collider nearbyObject in colliders)
{
//Add Force to objects
Rigidbody rb = nearbyObject.GetComponent <Rigidbody>();
if (rb != null)
{
rb.AddExplosionForce(force, transform.position, radius);
}
if (nearbyObject.tag == "Enemy")
{
EnemyTest enemy = nearbyObject.GetComponent <EnemyTest>();
//rb.AddExplosionForce(force, transform.position, radius);
enemy.Damage(enemy.maxLife);
}
}
//Damage enemies
//Remove Granade
coll.enabled = false;
rb.detectCollisions = false;
mesh.enabled = false;
Destroy(gameObject, 5);
}
public void Explode()
{
Debug.Log("Booom");
// Show Effects
//Instantiate(explosionEffect, transform.position, transform.rotation);
source.ChangePitchAndVolume(0.7f, 1, 0.95f, 1.05f);
source.PlayOneShot(explosionClip);
//Get Objects
Collider[] colliders = Physics.OverlapSphere(transform.position, radius, layer);
foreach (Collider nearbyObject in colliders)
{
//animacion y particula de quemar
if (nearbyObject.tag == "Enemy")
{
EnemyTest enemy = nearbyObject.GetComponent <EnemyTest>();
enemy.Damage(enemy.currentLife);
enemy.dead = true;
//Debug.Log("Killed By Molotov");
}
else if (nearbyObject.tag == "Fireable")
{
Destroy(nearbyObject.gameObject, 2f);
}
}
GameObject fireZone = Instantiate(fireZonePrefab, new Vector3(transform.position.x, 0, transform.position.z), Quaternion.Euler(0, 0, 0));
//Damage enemies
//Remove Molotov
coll.enabled = false;
rb.detectCollisions = false;
mesh.enabled = false;
Destroy(gameObject, 5);
}
// Start is called before the first frame update
void Start()
{
List <string> deck = GMScript.CreateDeck();
gm = FindObjectOfType <GMScript>();
SSC = FindObjectOfType <SortingAndSetCreating>();
SOG = FindObjectOfType <MyGameStates>();
ET = FindObjectOfType <EnemyTest>();
int i = 0;
foreach (string card in deck)
{
if (this.name == card)
{
Cardfaces = gm.Cards[i];
break;
}
i++;
}
Sprender = GetComponent <SpriteRenderer>();
selectable = GetComponent <selectable>();
}
void DetectNearestAbsorb()
{
Collider[] colliders = Physics.OverlapSphere(transform.position, radius, layer);
foreach (Collider nearByObject in colliders)
{
if (nearByObject.tag == "Enemy")
{
EnemyTest enemy = nearByObject.GetComponent <EnemyTest>();
if (enemy.dead && enemy.addStamina > 0)
{
float distance = Vector3.Distance(transform.position, enemy.transform.position);
if (distance < nearestDistance)
{
nearestDistance = distance;
nearestEnemy = enemy;
}
}
}
}
}
public void ChargedLaserGun()
{
damage = MaxchargedDamage * perceentage;
IWM.stamina -= maxRestStamina * perceentage;
timeCounter = 0;
perceentage = 0;
//chargedLaserShotParticle.Play();
//GameObject part = Instantiate(chargedParticle, chargedParticlePos.position, Quaternion.Euler(transform.rotation.x,0, transform.rotation.x));
//Destroy(part, 2);
if (baseSource.isPlaying)
{
baseSource.Stop();
}
baseSource.ChangePitchAndVolume(0.7f, 1, 0.95f, 1.05f);
baseSource.PlayOneShot(shotChargedShot);
Collider[] enemiesInArea = Physics.OverlapBox(areaPos.position, halfAreaSize, transform.rotation, layer);
foreach (Collider nearbyObject in enemiesInArea)
{
if (nearbyObject.tag == ("Enemy"))
{
Debug.Log("Enemy");
EnemyTest enemy = nearbyObject.GetComponent <EnemyTest>();
enemy.Damage(damage);
}
}
playChargingSound = false;
}
//public float fireableIndex;
public void Start()
{
enemy = GetComponent <EnemyTest>();
}
public void LoadEntities(AbstractScene scene, string levelID)
{
foreach (EntityInstance entity in world.ParseLevel(scene, levelID))
{
Vector2 position = new Vector2(entity.Px[0], entity.Px[1]);
if (entity.Identifier.Equals("Hero"))
{
hero = new Hero(scene, position);
}
else if (entity.Identifier.Equals("Lava"))
{
new Lava(scene, (int)entity.Width, (int)entity.Height, position);
}
else if (entity.Identifier.Equals("Spikes"))
{
Direction dir = default;
foreach (FieldInstance field in entity.FieldInstances)
{
if (field.Identifier == "Direction")
{
dir = Enum.Parse(typeof(Direction), field.Value);
}
}
float size = entity.Width > entity.Height ? entity.Width : entity.Height;
new Spikes(scene, position, (int)size, dir);
}
else if (entity.Identifier.Equals("Fuel"))
{
float amount = 0;
bool gravity = true;
foreach (FieldInstance field in entity.FieldInstances)
{
if (field.Identifier == "Amount")
{
amount = (float)field.Value;
}
else if (field.Identifier == "HasGravity")
{
gravity = field.Value;
}
}
FuelCan can = new FuelCan(scene, position, amount);
can.HasGravity = gravity;
}
else if (entity.Identifier.Equals("EnemyPatrolTrigger"))
{
new EnemyPatrolTrigger(scene, (int)entity.Width, (int)entity.Height, position);
}
else if (entity.Identifier.Equals("Enemy"))
{
Direction dir = Direction.WEST;
bool patrol = true;
bool tutorial = false;
Newtonsoft.Json.Linq.JArray array = null;
foreach (FieldInstance field in entity.FieldInstances)
{
if (field.Identifier == "Direction")
{
dir = Enum.Parse(typeof(Direction), field.Value);
}
else if (field.Identifier == "Patrol")
{
patrol = field.Value;
}
else if (field.Identifier == "Tutorial")
{
tutorial = field.Value;
}
else if (field.Identifier == "CarriedItems")
{
array = field.Value;
}
}
List <string> carriedItems = array.ToObject <List <string> >();
EnemyTest enemy = new EnemyTest(scene, position, dir);
enemy.Patrol = patrol;
enemy.Tutorial = tutorial;
if (carriedItems != null && carriedItems.Count > 0)
{
enemy.CarriedItems = carriedItems;
}
}
else if (entity.Identifier.Equals("Door"))
{
bool locked = false;
foreach (FieldInstance field in entity.FieldInstances)
{
if (field.Identifier == "Locked")
{
locked = field.Value;
}
}
new Door(scene, position, (int)entity.Height, locked);
}
else if (entity.Identifier.Equals("MountedGun"))
{
Direction dir = default;
Newtonsoft.Json.Linq.JArray array = null;
foreach (FieldInstance field in entity.FieldInstances)
{
if (field.Identifier == "Direction")
{
dir = Enum.Parse(typeof(Direction), field.Value);
}
else if (field.Identifier == "Integer")
{
array = field.Value;
}
}
List <int> param = array.ToObject <List <int> >();
new MountedGun(scene, position, dir, param[0], param[1], param[2], param[3]);
}
else if (entity.Identifier.Equals("Saw"))
{
bool horizontal = false;
foreach (FieldInstance field in entity.FieldInstances)
{
if (field.Identifier == "Horizontal")
{
horizontal = field.Value;
}
}
new Saw(scene, position, horizontal);
}
else if (entity.Identifier.Equals("TrapTrigger"))
{
new TrapTrigger(scene, position, (int)entity.Width, (int)entity.Height);
}
else if (entity.Identifier.Equals("TutorialTrigger"))
{
string tutorial = "";
foreach (FieldInstance field in entity.FieldInstances)
{
if (field.Identifier == "Tutorial")
{
tutorial = field.Value;
}
}
new TutorialTrigger(scene, position, (int)entity.Width, (int)entity.Height, tutorial);
}
else if (entity.Identifier.Equals("Ammo"))
{
Type weaponType = null;
int amount = 0;
foreach (FieldInstance field in entity.FieldInstances)
{
if (field.Identifier == "Weapon")
{
if (field.Value == "Handgun")
{
weaponType = typeof(Handgun);
}
else if (field.Value == "Machinegun")
{
weaponType = typeof(Machinegun);
}
else if (field.Value == "Shotgun")
{
weaponType = typeof(Shotgun);
}
}
else if (field.Identifier == "Amount")
{
amount = (int)field.Value;
}
}
new Ammo(scene, position, amount, weaponType);
}
else if (entity.Identifier.Equals("HealthPickup"))
{
new HealthPickup(scene, position);
}
else if (entity.Identifier.Equals("EndGameTrigger"))
{
new EndGameTrigger(scene, position, (int)entity.Width, (int)entity.Height);
}
}
}
public void Shot()
{
if (isReloading || isShoting)
{
return;
}
if (currentAmmo <= 0)
{
Reload();
return;
}
isShoting = true;
currentAmmo--;
//audPlay.Play(0, 1, Random.Range(0.95f, 1.05f));
//ammoReloaded--;
basicSource.ChangePitchAndVolume(0.7f, 1, 0.95f, 1.05f);
basicSource.PlayOneShot(ShotClips.clips[weapon.WeaponSelected]);
muzzleParticle.Play();
if (weapon.WeaponSelected != 1)
{
Ray ray = Camera.main.ViewportPointToRay(new Vector3(0.5f, 0.5f, 0));
RaycastHit hit = new RaycastHit();// que hemos golpeado primero
if (Physics.Raycast(ray, out hit, fireDist, weaponLayer))
{
//Debug.Log(hit.collider.tag);
Debug.Log(hit.collider.name);
if (hit.collider.tag == "Flesh")
{
GameObject particle = (GameObject)Instantiate(bloodParticle, hit.point, Quaternion.FromToRotation(Vector3.forward, hit.normal));
Destroy(particle, 10);
hit.transform.SendMessage("StunnedSet", stunedTime, SendMessageOptions.RequireReceiver);
hit.transform.SendMessage("Damage", bulletDamage, SendMessageOptions.RequireReceiver);
EnemyTest enemy = hit.transform.GetComponent <EnemyTest>();
if (enemy != null)
{
enemy.Detected = true;
enemy.anim.SetAnimHit();
}
}
else if (hit.collider.tag == "Metal")
{
GameObject particle = (GameObject)Instantiate(sparklePartcile, hit.point, Quaternion.FromToRotation(Vector3.forward, hit.normal));
hit.transform.SendMessage("Damage", bulletMetalDamage, SendMessageOptions.RequireReceiver);
EnemyTest enemy = hit.transform.GetComponent <EnemyTest>();
if (enemy != null)
{
enemy.Detected = true;
enemy.anim.SetAnimHit();
}
basicSource.ChangePitchAndVolume(0.7f, 1, 0.95f, 1.05f);
basicSource.PlayOneShot(MetalClip);
Destroy(particle, 10);
}
}
}
else
{
for (int i = 0; i < shotGunSpreads; i++)
{
Ray ray = Camera.main.ViewportPointToRay(new Vector3(Random.Range(0.3f, 0.7f), Random.Range(0.3f, 0.7f), 0));
RaycastHit hit = new RaycastHit();// que hemos golpeado primero
Debug.DrawRay(ray.origin, ray.direction * fireDist, Color.red, 0.5f);
if (Physics.Raycast(ray, out hit, fireDist))
{
Debug.Log(hit.collider.name);
if (hit.collider.tag == "Flesh")
{
GameObject particle = (GameObject)Instantiate(bloodParticle, hit.point, Quaternion.FromToRotation(Vector3.forward, hit.normal));
Destroy(particle, 10);
hit.transform.SendMessage("StunnedSet", stunedTime, SendMessageOptions.RequireReceiver);
hit.transform.SendMessage("Damage", bulletDamage, SendMessageOptions.RequireReceiver);
EnemyTest enemy = hit.transform.GetComponent <EnemyTest>();
if (enemy != null)
{
enemy.anim.SetAnimHit();
enemy.Detected = true;
}
}
else if (hit.collider.tag == "Metal")
{
GameObject particle = (GameObject)Instantiate(sparklePartcile, hit.point, Quaternion.FromToRotation(Vector3.forward, hit.normal));
hit.transform.SendMessage("Damage", bulletMetalDamage, SendMessageOptions.RequireReceiver);
basicSource.ChangePitchAndVolume(0.7f, 1, 0.95f, 1.05f);
basicSource.PlayOneShot(MetalClip);
Destroy(particle, 10);
}
}
Debug.Log(hit.point);
/*Ray ray = Camera.main.ViewportPointToRay(new Vector3(0.5f, 0.5f, 0));
* RaycastHit hit = new RaycastHit();// que hemos golpeado primero
*
* whereToShot.transform.position = ray.origin;
* whereToShot.transform.rotation = Quaternion.Euler(Random.Range(-7, 7), Random.Range(-7, 7), whereToShot.localEulerAngles.z);
*
* if (Physics.Raycast(whereToShot.position, whereToShot.forward, out hit, fireDist))
* {
* Instantiate(bulletHole, hit.point, Quaternion.FromToRotation(Vector3.forward, hit.normal));
* }*/
}
}
if (isAutomatic)
{
StartCoroutine(ResetShot());
}
}
public void Initialize()
{
enemy = GetComponentInParent <EnemyTest>();
area = GetComponent <BoxCollider>();
}
public void DoHit()
{
if (canHit)
{
player.anims.SetAnimFist();
}
if (canHit && !player.canExecute)
{
player.crouching = false;
player.GM.ableToInput = false;
player.axis = Vector2.zero;
point = true;
StartCoroutine(TurnOffPoint());
TimeCounter = 0;
Hited = true;
triggerAnim = true;
canHit = false;
//ejecutar animcion
player.anims.HitAnimations();
if (!player.GM.improved)
{
normalModeHit.AppearHit();
}
else
{
improvedModeHit.AppearHit();
}
basicSource.ChangePitchAndVolume(0.7f, 1, 0.95f, 1.05f);
basicSource.PlayOneShot(hitClips);
ActualHit++;
if (ActualHit < maximumHits)
{
secondsAbleToImput = initialSecondsAbleToInput;
}
else if (ActualHit >= maximumHits)
{
secondsAbleToImput = finalSecondsAbleToInput;
}
if (ActualHit > maximumHits)
{
ActualHit = 1;
}
if (ActualHit == 1)
{
Hited = false;
}
Debug.Log(ActualHit);
//canHit = true; // se ha de hacer al acabar la animacion.
StartCoroutine(SetAbleToImput());
}
if (player.canExecute)
{
if (enemyToExecute != null)
{
enemyToExecute.Damage(enemyToExecute.currentLife);
basicSource.ChangePitchAndVolume(0.7f, 1, 0.95f, 1.05f);
basicSource.PlayOneShot(executionClip);
enemyToExecute.executionCollider.enabled = false;
enemyToExecute = null;
player.canExecute = false;
}
}
}
public void Clear()
{
EnemyTest.Clear();
EnemyDict.Clear();
}
public void Update(GameTime gameTime)
{
EnemyController = 0.0f;
Boolean launchCheck = false;
EnemyTest.Clear();
for (Byte index = 0; index < maxEnemySpawn; index++)
{
Enemy enemy = EnemyList[index];
enemy.Update(gameTime);
// Check if controller should rumble.
if (enemy.EnemyMotor > 0)
{
Single enemyMotor = enemy.EnemyMotor;
if (EnemyController < enemyMotor)
{
EnemyController = enemyMotor;
}
}
// Check if should move enemy ship...
if (enemy.EnemyChange)
{
if (MoveType.None != enemy.MoveType)
{
Boolean enemyMoving = MyGame.Manager.MoverManager.ShouldEnemyMove(enemy.FrameIndex, levelType);
enemy.SetEnemyMoving(enemyMoving);
if (enemyMoving)
{
Boolean updateVelocity = MyGame.Manager.MoverManager.UpdateVelocity(enemy.FrameIndex, enemy.MoveType, levelType);
if (updateVelocity)
{
Vector2 velocity = MyGame.Manager.MoverManager.GetEnemyVelocity(enemy.MoveType);
enemy.SetEnemyVelocity(velocity);
}
}
else
{
enemy.SetEnemyVelocity(Vector2.Zero);
}
}
}
if (enemy.EnemyLaunch)
{
launchCheck = true;
EnemyStart++;
enemy.ResetLaunch();
}
if (EnemyType.Test == enemy.EnemyType)
{
EnemyTest.Add(enemy);
}
}
if (launchCheck)
{
EnemyStartText = EnemyStart.ToString().PadLeft(3, '0');
EnemyPercentage = (EnemyStart / (Single)EnemyTotal) * 100.0f;
}
}
public void Initialize()
{
anim = GetComponentInChildren <Animator>();
enemy = GetComponent <EnemyTest>();
}
