public void parseLevelData() { TextAsset file = (TextAsset)Resources.Load("levels/level" + this.level); System.IO.StringReader reader = new System.IO.StringReader(file.text); string[] baseCords = reader.ReadLine().Split(' '); this.BaseX = Convert.ToInt32(baseCords[0]); this.BaseY = Convert.ToInt32(baseCords[1]); string line = reader.ReadLine(); // read enemy bases Match match = Regex.Match(line, @"(\d+) (\d+)"); while (match.Success) { Console.WriteLine(match.Value); EnemyBase enemyBase = new EnemyBase(); enemyBase.BaseX = Convert.ToInt32(match.Groups[1].Value); enemyBase.BaseY = Convert.ToInt32(match.Groups[2].Value); enemyBaseList.Add(enemyBase); match = match.NextMatch(); } while ((line = reader.ReadLine()) != null) { this.map.Add(line); } this.height = this.map.Count(); this.width = this.map[0].Length; }
/// <summary> /// Initializes an instance of <see cref="DebuffBase"/>. /// </summary> /// <param name="owner">The agent under the effect.</param> /// <param name="duration">The length of time the buff is active.</param> /// <param name="slowPercent">The percentage of the agent's speed to subtract.</param> public Slow(EnemyBase owner, float duration, float slowPercent) { this.objectManager = ObjectManager.GetInstance(); this.owner = owner; this.duration = duration; this.slowAmmount = this.owner.Speed * slowPercent; }
void onEnemyStatsChange( EnemyStats stats, EnemyBase._EnemyState state ) { scaleToScale = transform.localScale; scaleToScale.x = ORIGINAL_SCALE.x * ( stats.health / 100f ); scaleToScale.x = ( scaleToScale.x > 0 ) ? scaleToScale.x : 0f; Color tweenToColor; if( stats.health > 50 ) tweenToColor = ( ( FULL_HEALTH_COLOR - MIDDLE_COLOR ) * ( ( stats.health -50 ) / 50f ) ) + MIDDLE_COLOR; else tweenToColor = ( ( MIDDLE_COLOR - FULL_DEAD_COLOR ) * ( stats.health / 50f ) ) + FULL_DEAD_COLOR; TweenColor.Begin( transform.gameObject, 0.15f, tweenToColor ); iTween.Stop(gameObject); iTween.ScaleTo( gameObject, iTween.Hash( "scale", scaleToScale, "islocal", true, "time", 0.15f, "easetype", iTween.EaseType.easeOutExpo ) ); if( stats.health == 0 && state == EnemyBase._EnemyState.Dead ) { thisSprite.enabled = false; healthBarBG.enabled = false; } }
/// <summary> /// Initializes an instance of <see cref="DebuffBase"/>. /// </summary> /// <param name="owner">The agent under the effect.</param> /// <param name="duration">The length of time the buff is active.</param> /// <param name="reductionAmmount">The ammount to reduce the armor by.</param> public ArmorReduce(EnemyBase owner, float duration, int reductionAmmount) { this.objectManager = ObjectManager.GetInstance(); this.owner = owner; this.duration = duration; this.reductionAmmount = reductionAmmount; }
/// <summary> /// Initializes an instance of <see cref="DebuffBase"/>. /// </summary> /// <param name="owner">The agent under the effect.</param> /// <param name="duration">The length of time the buff is active.</param> /// <param name="totalDamage">The total damage done.</param> /// <param name="interval">The interval to apply damage.</param> public DamageOverTime(EnemyBase owner, float duration, int totalDamage, float interval) { this.objectManager = ObjectManager.GetInstance(); this.owner = owner; this.duration = duration; this.interval = interval; this.damageSegment = totalDamage / (int)(duration / this.interval); }
public Debuff(EnemyBase owner, int magnitude, float duration, float interval, float startTime, EnemyState enemyState) { this.owner = owner; this.magnitude = magnitude; this.enemyState = enemyState; this.duration = duration; this.interval = interval; this.startTime = startTime; }
void Start () { seeker = GetComponent<Seeker>(); enemy = GetComponent<EnemyBase>(); thisTransform = transform; constraint.tags = 1 << 2; constraint.constrainWalkability = true; }
public void Update() { enemy = GetEnemy(); attackSpeedTimer += Time.deltaTime; if (attackSpeedTimer > attackSpeed) { Attack(); attackSpeedTimer = 0; } }
void onEnemyStatsChange( EnemyStats stats, EnemyBase._EnemyState state ) { if( stats.health == 0 && state == EnemyBase._EnemyState.Dead ) { thisLabel.enabled = true; iTween.ScaleTo( gameObject, iTween.Hash( "scale", ORIGINAL_SCALE * 1.3f, "islocal", true, "time", 0.2f, "looptype", iTween.LoopType.pingPong, "easetype", iTween.EaseType.easeOutQuad ) ); } }
void Awake() { if (Instance != null && Instance != this) { DestroyImmediate(gameObject); return; } Instance = this; DontDestroyOnLoad (gameObject); SetupLevel (); playerRef = GameObject.FindGameObjectWithTag ("Player").transform.GetComponent<Player> (); pBaseRef = GameObject.FindGameObjectWithTag ("PlayerBase").transform.GetComponent<PlayerBase> (); eBaseRef = GameObject.FindGameObjectWithTag ("EnemyBase").transform.GetComponent<EnemyBase> (); }
void onEnemyStatsChange( EnemyStats stats, EnemyBase._EnemyState state ) { if( state == EnemyBase._EnemyState.Dead ) { GameState = _GameState.Results; onUIUpdate( DBAccess.instance.userPrefs.userGun, GameState, null, stats ); DBAccess.instance.userPrefs.wins++; if( GameCenterBinding.isPlayerAuthenticated() ) GameCenterBinding.reportScore( (long)DBAccess.instance.userPrefs.wins, "Leaderboard_Win"); } }
public BarbarianCards() { cardPool = new Dictionary <string, CardBase>(); // Common cardPool.Add("Axe Swing", new CardBase() { name = "Axe Swing", cost = 1, cardText = delegate(PlayerClassBase caster) { int damMod = caster.getModdedDamage(this.GetCard("Axe Swing").baseDamage, DamageTypes.PHYSICAL); return($"Deals {damMod} slashing damage"); }, cardType = CardTypes.ATTACK, targetType = TargetTypes.ENEMY, baseDamage = 6, action = delegate(object targetObj, PlayerClassBase caster) { EnemyBase target = (EnemyBase)targetObj; Barbarian me = (Barbarian)caster; int damMod = me.getModdedDamage(this.GetCard("Axe Swing").baseDamage, DamageTypes.PHYSICAL); int meDmg = (int)Mathf.Floor(damMod / 4); target.TakeDamage(damMod, DamageTypes.PHYSICAL); Debug.Log($"axe swing hit for {damMod}"); } }); cardPool.Add("Drop Shoulder", new CardBase() { name = "Drop Shoulder", cost = 1, cardText = delegate(PlayerClassBase caster) { return("Gain 5 physical armor"); }, cardType = CardTypes.SKILLS, targetType = TargetTypes.SELF, action = delegate(object target, PlayerClassBase caster) { PlayerClassBase t = (PlayerClassBase)target; t.gainArmour(DamageTypes.PHYSICAL, 5); } }); // Uncommon cardPool.Add("Enrage", new CardBase() { name = "Enrage", cost = 1, cardText = delegate(PlayerClassBase caster) { return("Become Enraged\n(Increase physical damage by 50% and\nphysical damage taken by 25%)"); }, cardType = CardTypes.AURA, targetType = TargetTypes.SELF, action = delegate(object target, PlayerClassBase caster) { PlayerClassBase t = (PlayerClassBase)target; t.statuses.Add(new Enrage()); t.UpdateStatuses(); } }); cardPool.Add("Wild Swing", new CardBase() { name = "Wild Swing", cost = 2, cardText = delegate(PlayerClassBase caster) { int damMod = caster.getModdedDamage(this.GetCard("Wild Swing").baseDamage, DamageTypes.PHYSICAL); return($"Deals {damMod} slashing damage. \nTake a quarter as" + " much physical \ndamage rounded down."); }, cardType = CardTypes.ATTACK, targetType = TargetTypes.ENEMY, baseDamage = 16, action = delegate(object targetObj, PlayerClassBase caster) { EnemyBase target = (EnemyBase)targetObj; Barbarian me = (Barbarian)caster; int damMod = me.getModdedDamage(this.GetCard("Wild Swing").baseDamage, DamageTypes.PHYSICAL); int meDmg = (int)Mathf.Floor(damMod / 4); target.TakeDamage(damMod, DamageTypes.PHYSICAL); me.TakeDamage(meDmg, DamageTypes.PHYSICAL); Debug.Log($"wild swing hits for {damMod} and caster takes {meDmg}"); } }); }
public EnemyWithPosition(EnemyBase enemy, Vector3 pos) { this.enemy = enemy; this.originalPosition = pos; }
void Fire(EnemyBase myTarget) { var targetPosition = myTarget.transform.position; var aimError = Random.Range (-accuracyError, accuracyError); var aimPoint = new Vector3 (targetPosition.x + aimError, targetPosition.y + aimError, targetPosition.z + aimError); nextDamageEvent = Time.time + AttackDelay; GameObject projectileObject = Instantiate (projectileType, transform.position, Quaternion.LookRotation (targetPosition)) as GameObject; Projectile projectile = projectileObject.GetComponent<Projectile> (); projectile.Damage = damage; projectile.DamageOverTime = damageOverTime; projectile.Slow = Slow; projectile.SlowDuration = SlowDuration; projectile.target = myTarget; projectile.targetPosition = aimPoint; projectile.Owner = this; // Turret is AoE enabled. Do stuff. if (aoeDamage > 0 && aoeRange > 0) { projectile.AoeDamage = aoeDamage; projectile.AoeRange = AoeRange; } }
protected virtual void Start() { m_stateManager = GetComponent <StateManager>(); m_enemyBase = GetComponent <EnemyBase> (); }
void OnNodeExit() { if (target != null || !IsTargetInRange()) { RemoveTargetCallbacks(); target = null; } }
private void FindNewTarget() { foreach (Node node in nodesInRange) { if(node.enemie != null) { RemoveTargetCallbacks(); target = node.enemie; target.Killed += OnTargetKilled; target.NodeExit += OnNodeExit; } } }
private void OnState2Update() { bool isInScreen = MathUtil.DetectCollisionBetweenAABBAndAABB(_curPos, _size, _size, Vector2.zero, 192, 224); if (_target == null || (_target != null && _target.GetInstanceID() != _targetInstID)) { _target = FindTarget(); if (_target != null) { _targetInstID = _target.GetInstanceID(); } } if (_target != null) { float an = MathUtil.GetAngleBetweenXAxis(_target.GetPosition() - _curPos); float a = an - _curRot; a = MathUtil.ClampAngle(a); if (a >= 180) { a -= 360; } float da = 1200f / (Vector2.Distance(_target.GetPosition(), _curPos) + 1); if (da >= Mathf.Abs(a)) { _curRot = an; } else { _curRot += da * Mathf.Sign(a); } //Logger.Log(string.Format("a={0},da={1},curRot={2}", a, da, _curRot)); } float dx = 8f * Mathf.Cos(Mathf.Deg2Rad * _curRot); float dy = 8f * Mathf.Sin(Mathf.Deg2Rad * _curRot); if (isInScreen) { if (_curPos.x > 192) { _curPos.x = 192; dx = dy = 0; } if (_curPos.x < -192) { _curPos.x = -192; dx = dy = 0; } if (_curPos.y < -224) { _curPos.y = -224; dx = dy = 0; } if (_curPos.y > 224) { _curPos.y = 224; dx = dy = 0; } } _curPos += new Vector2(dx, dy); _tf.localPosition = _curPos; if (_timer >= 230) { _dmg = _dmg * 0.4f; _size = _size * 2; _collider.SetSize(64, 64); _collider.SetHitEnemyDamage(_dmg); _state = 3; } }
// Use this for initialization void Start() { enemyBase = GetComponent <EnemyBase>(); startPosition = transform.position; GetComponentInChildren <SpriteRenderer>().color = enemyColor; }
public override void Action(CharacterBase character, SceneBattle battle) { if (SaveData.HAVEVirus[this.id] == null) { if (character.waittime == 3) { this.sound.PlaySE(SoundEffect.throwbomb); } character.animationpoint = CharacterAnimation.BombAnimation(character.waittime); if (character.waittime == 6) { int num = this.power + this.pluspower; int t = 40; Point end = new Point(character.position.X + 3 * this.UnionRebirth(character.union), character.position.Y); battle.attacks.Add(this.Paralyze(new VirusBall(this.sound, character.parent, character.position.X, character.position.Y, character.union, this.Power(character), 1, new Vector2(character.positionDirect.X, character.positionDirect.Y - 16f), end, t, this.id))); } if (character.waittime != 25) { return; } base.Action(character, battle); } else if (character.waittime <= 3) { character.animationpoint = new Point(0, 1); } else if (character.waittime <= 12) { character.animationpoint = new Point((character.waittime - 3) / 3, 1); } else if (character.waittime < 24) { character.animationpoint = new Point(3, 1); } else if (character.waittime == 24) { if (character.Canmove(character.positionold)) { this.sound.PlaySE(SoundEffect.enterenemy); Virus haveViru; EnemyBase e; haveViru = SaveData.HAVEVirus[this.id]; var newVirus = new Virus { type = haveViru.type, eatBug = haveViru.eatBug, eatError = haveViru.eatError, eatFreeze = haveViru.eatFreeze, }; if ((character as Player)?.addonSkill[73] == true) { var enemies = battle.AllChara().Where(c => character.UnionEnemy == c.union); var maxEnemyRank = enemies.Max(c => (c as EnemyBase)?.version ?? 0); if (enemies.Any(c => c is NaviBase)) { maxEnemyRank++; } var rankUpgrades = Math.Max(0, maxEnemyRank - haveViru.rank - (3 - haveViru.rank)); newVirus.eatBug += 20 * rankUpgrades; newVirus.ReturnVirus(newVirus.type); } e = new EnemyBase(this.sound, battle, character.positionold.X, character.positionold.Y, 0, character.union, newVirus.rank); EnemyBase enemyBase = EnemyBase.EnemyMake(newVirus.type, e, false); enemyBase.number = battle.enemys.Count; if (this.randomSeed != null) { enemyBase.randomSeed = this.randomSeed; } enemyBase.HPset(newVirus.HP); enemyBase.power = newVirus.Power; if (enemyBase.Canmove(enemyBase.position)) { battle.enemys.Add(enemyBase); enemyBase.Init(); enemyBase.InitAfter(); } else { battle.effects.Add(new MoveEnemy(this.sound, battle, character.positionold.X, character.positionold.Y)); } } } else if (character.waittime >= 48) { base.Action(character, battle); } }
public void init(EnemyBase enemy, int type, string imaPath, float count, long id) { mId = id; init(enemy, type, imaPath, count); }
public void RemoveEnemyFromZone(EnemyBase enemy) { inZoneEnemies.Remove(enemy); enemy.LosePlayer(); }
public void AddEnemyInZone(EnemyBase enemy) { inZoneEnemies.Add(enemy); enemy.DetectFirstPersonCharacter(thirdPersonCharacter); }
public static void RemoveObject(EnemyBase e) { if (instance) { if (instance.ActivePool.Contains(e)) instance.ActivePool.Remove(e); if (!instance.InActivePool.Contains(e)) instance.InActivePool.Add(e); if (e) { e.transform.position = new Vector3(0, 500, -50); e.RemoveFromView(false); } if (instance.onRemove != null) instance.onRemove(e); } }
public static EnemyBase GetObject(EnemyBase.Enemytype Type) { if (instance) { EnemyBase e; if (instance.InActivePool.Any(i => i.etype == Type)) { e = instance.InActivePool.First(i => i.etype == Type); instance.InActivePool.Remove(e); instance.ActivePool.Add(e); e.gameObject.SetActive(true); } else { GameObject g = Instantiate(Resources.Load("Object/Enemies/" + Application.loadedLevelName + "/" + Type.ToString()), Vector3.zero, Quaternion.identity) as GameObject; if(!g) g = Instantiate(Resources.Load("Object/Enemies/" + Type.ToString()), Vector3.zero, Quaternion.identity) as GameObject; g.name = Type.ToString() + " - " + (instance.ActivePool.Count + instance.InActivePool.Count); e = g.GetComponent<EnemyBase>(); instance.ActivePool.Add(e); e.transform.SetParent(instance.transform, false); } e.gameObject.SendMessage("startBehaviours", SendMessageOptions.DontRequireReceiver); return e; } return null; }
public override bool HitEvent(EnemyBase e) { return(base.HitEvent(e)); }
void Fire(EnemyBase myTarget) { var targetPosition = myTarget.transform.position; nextDamageEvent = Time.time + AttackDelay; ////GameObject projectileObject = Instantiate (projectileType, transform.position, Quaternion.LookRotation (targetPosition)) as GameObject; ////Projectile projectile = projectileObject.GetComponent<Projectile> (); var projectile = projectileType.GetObjectFromPool<Projectile>( projectileType.name, transform.position, Quaternion.LookRotation(targetPosition)); projectile.gameObject.name = projectileType.name; projectile.Damage = turretModel.damage; projectile.DamageOverTime = turretModel.damageOverTime; projectile.Slow = turretModel.Slow; projectile.SlowDuration = turretModel.SlowDuration; projectile.target = myTarget; projectile.targetPosition = targetPosition; projectile.Owner = this; // Turret is AoE enabled. Do stuff. if (turretModel.aoeDamage > 0 && turretModel.aoeRange > 0) { projectile.AoeDamage = turretModel.aoeDamage; projectile.AoeRange = AoeRange; } }
public ClosestTargetCommandSequence(params CharacterObservable[] humans) { _selfAsEnemy = (EnemyBase)Observable; SelectTarget(humans); EvaluateCommandSequence(); }
void OnTargetKilled() { RemoveTargetCallbacks(); target = null; }
private void Start() { myBase = GetComponent <EnemyBase>(); }
/// <summary> /// Initializes an instance of <see cref="DebuffBase"/>. /// </summary> /// <param name="owner">The agent under the effect.</param> /// <param name="duration">The length of time the buff is active.</param> public ReverseDirection(EnemyBase owner, float duration) { this.objectManager = ObjectManager.GetInstance(); this.owner = owner; this.duration = duration; }
public HealthListener(EnemySettings _enemySettings, EnemyBase _enemy) { enemySettings = _enemySettings; enemy = _enemy; }
public EnemyHitBox(string filename, bool weakSpot, EnemyBase enemy) : base(filename) { _weakSpot = weakSpot; _enemy = enemy; }
public void UpdateTrajectoriesPreview(Dictionary <DiscScript, DiscTrajectoryParameters> discTrajectories) { List <DiscScript> previousDiscsUntreated = new List <DiscScript>(); foreach (DiscScript discToTreat in hitByDiscTrajectories.Keys) { previousDiscsUntreated.Add(discToTreat); } DiscTrajectoryParameters trajParams = default; List <Vector3> treatedPositions = new List <Vector3>(); RaycastHit[] hitResults = new RaycastHit[0]; Vector3 checkStartPos = Vector3.zero; Vector3 checkEndPos = Vector3.zero; Vector3 checkMovement = Vector3.zero; Vector3 discLocalCenter = Vector3.zero; LayerMask checkMask = default; float checkRadius = default; bool blockedByEnemies = false; Transform touchedEnemy = default; int counter = 0; foreach (DiscScript disc in discTrajectories.Keys) { if (previousDiscsUntreated.Contains(disc)) { previousDiscsUntreated.Remove(disc); } if (!hitByDiscTrajectories.ContainsKey(disc)) { hitByDiscTrajectories.Add(disc, new Dictionary <GameObject, EnemyBase>()); } List <GameObject> previousEnemiesUntreated = new List <GameObject>(); foreach (GameObject enemyToTreat in hitByDiscTrajectories[disc].Keys) { previousEnemiesUntreated.Add(enemyToTreat); } if (counter > currentNumberOfShownArrowPreviews) { Debug.LogWarning("WARNING : Updating more arrows than shown"); } trajParams = discTrajectories[disc]; treatedPositions = new List <Vector3>(); hitResults = new RaycastHit[0]; discLocalCenter = trajParams.disc.GetColliderLocalCenter; checkMask = trajParams.disc.GetTrajectoryCheckLayerMask; checkRadius = trajParams.disc.GetColliderRadius; blockedByEnemies = trajParams.disc.GetBlockedByEnemies; touchedEnemy = null; treatedPositions.Add(trajParams.trajectoryPositions[0]); bool goesThrough = true; #region Treat Positions for (int j = 1; j < trajParams.trajectoryPositions.Count; j++) { checkStartPos = trajParams.trajectoryPositions[j - 1] + discLocalCenter; checkEndPos = trajParams.trajectoryPositions[j] + discLocalCenter; checkMovement = checkEndPos - checkStartPos; #region Test hitResults = Physics.SphereCastAll(checkStartPos, checkRadius, checkMovement.normalized, checkMovement.magnitude, checkMask); foreach (RaycastHit hitResult in hitResults.OrderBy(h => h.distance)) { GameObject hitObject = hitResult.collider.gameObject; switch (hitObject.layer) { // Enemy case (10): if (!hitByDiscTrajectories[disc].ContainsKey(hitObject)) { EnemyBase hitEnemy = hitObject.GetComponent <EnemyBase>(); if (hitEnemy != null) { hitEnemy.ShowWillBeHitIndicator(); hitByDiscTrajectories[disc].Add(hitObject, hitEnemy); } } else { previousEnemiesUntreated.Remove(hitObject); } if (blockedByEnemies) { goesThrough = false; } else { goesThrough = true; touchedEnemy = hitResult.collider.transform; } break; // Shield case (12): goesThrough = false; if (hitResult.collider.transform.parent != null) { if (hitResult.collider.transform.parent.parent != null) { if (hitResult.collider.transform.parent.parent == touchedEnemy) { goesThrough = true; } } } break; // Obstacle case (14): goesThrough = false; break; } if (!goesThrough) { treatedPositions.Add(hitResult.point - discLocalCenter); break; } } if (!goesThrough) { break; } #endregion #endregion treatedPositions.Add(trajParams.trajectoryPositions[j]); } #endregion foreach (GameObject untreatedEnemy in previousEnemiesUntreated) { hitByDiscTrajectories[disc][untreatedEnemy].HideWillBeHitIndicator(); hitByDiscTrajectories[disc].Remove(untreatedEnemy); } arrowPreviews[counter].SetPositions(treatedPositions); counter++; } foreach (DiscScript untreatedDisc in previousDiscsUntreated) { foreach (EnemyBase enemy in hitByDiscTrajectories[untreatedDisc].Values) { enemy.HideWillBeHitIndicator(); } } }
void onEnemyStatsChange( EnemyStats stats, EnemyBase._EnemyState state ) { if( stats.health == 0 && state == EnemyBase._EnemyState.Dead ) { StopAllCoroutines(); } }
public static void RemoveEnemy(EnemyBase enemy) { instance._aliveEnemies.Remove(enemy); }
/// <summary> /// Adds the enemy. /// </summary> /// <param name="enemy">Enemy.</param> public void AddEntity(EnemyBase entity) { enemies.Add (entity); }
private void Start() { enemy = GetComponentInParent <EnemyBase>(); slider = GetComponent <Slider>(); }
private void TryFire() { Vector3 pos = Transform.Pos; foreach (GameObject o in api.ActiveObjects) { EnemyBase enemy = o as EnemyBase; if (enemy != null && !enemy.IsInvulnerable && enemy.CanCollideWithAmmo) { Vector3 newPos = enemy.Transform.Pos; if ((IsFacingLeft && newPos.X > pos.X) || (!IsFacingLeft && newPos.X < pos.X)) { continue; } float distance = (newPos - pos).Length; if (distance > 260f) { continue; } switch (type) { case 0: { // Chuck (red) pos.Z += 2f; AmmoBlaster newAmmo = new AmmoBlaster(); newAmmo.OnActivated(new ActorActivationDetails { Api = api, Pos = pos, Params = new ushort[] { 0 } }); api.AddActor(newAmmo); newAmmo.OnFire(owner, pos, Speed, 0f, IsFacingLeft); newAmmo = new AmmoBlaster(); newAmmo.OnActivated(new ActorActivationDetails { Api = api, Pos = pos, Params = new ushort[] { 0 } }); api.AddActor(newAmmo); newAmmo.OnFire(owner, pos, Speed, IsFacingLeft ? -0.18f : 0.18f, IsFacingLeft); PlaySound("Fire", 0.5f); fireCooldown = 48f; break; } case 1: { // Birdy (yellow) SetAnimation(AnimState.Shoot); Vector3 attackSpeed = (newPos - pos).Normalized; speedX = attackSpeed.X * 6f; speedY = attackSpeed.Y * 6f; Transform.Angle = MathF.Atan2(speedY, speedX); if (IsFacingLeft) { Transform.Angle += MathF.Pi; } attackTime = distance * 0.2f; fireCooldown = 140f; collisionFlags = CollisionFlags.CollideWithOtherActors; break; } } break; } } }
public static void AddEnemy(EnemyBase enemy) { instance._aliveEnemies.Add(enemy); }
public void DeReference(EnemyBase entity) { if (entity is EnemyBase) { enemies.Remove ((EnemyBase)entity); } }
public void SetTarget(Transform newTarget) { target = newTarget; targetEnemy = newTarget.GetComponent <EnemyBase>(); }