Inheritance: MonoBehaviour
Example #1
0
    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;
    }
Example #2
0
 /// <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;
 }
Example #3
0
	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;
		}
	}
Example #4
0
 /// <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;
 }
Example #5
0
 /// <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);
 }
Example #6
0
 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;
 }
Example #7
0
    void Start () 
	{
        seeker = GetComponent<Seeker>(); 
		
		enemy = GetComponent<EnemyBase>();
		thisTransform = transform;
		
		constraint.tags = 1 << 2;
		constraint.constrainWalkability = true;
    }
Example #8
0
    public void Update()
    {
        enemy = GetEnemy();
        attackSpeedTimer += Time.deltaTime;

        if (attackSpeedTimer > attackSpeed)
        {
            Attack();
            attackSpeedTimer = 0;
        }
    }
Example #9
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> ();
    }
Example #11
0
	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");
		}
	}
Example #12
0
        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;
 }
Example #14
0
    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;
        }
    }
Example #15
0
 protected virtual void Start()
 {
     m_stateManager = GetComponent <StateManager>();
     m_enemyBase    = GetComponent <EnemyBase> ();
 }
Example #16
0
 void OnNodeExit()
 {
     if (target != null || !IsTargetInRange())
     {
         RemoveTargetCallbacks();
         target = null;
     }
 }
Example #17
0
 private void FindNewTarget()
 {
     foreach (Node node in nodesInRange)
     {
         if(node.enemie != null)
         {
             RemoveTargetCallbacks();
             target = node.enemie;
             target.Killed += OnTargetKilled;
             target.NodeExit += OnNodeExit;
         }
     }
 }
Example #18
0
        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;
            }
        }
Example #19
0
 // Use this for initialization
 void Start()
 {
     enemyBase     = GetComponent <EnemyBase>();
     startPosition = transform.position;
     GetComponentInChildren <SpriteRenderer>().color = enemyColor;
 }
Example #20
0
        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);
 }
Example #24
0
    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);
        }
    }
Example #25
0
    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;
    }
Example #26
0
 public override bool HitEvent(EnemyBase e)
 {
     return(base.HitEvent(e));
 }
Example #27
0
    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();
 }
Example #29
0
 void OnTargetKilled()
 {
     RemoveTargetCallbacks();
     target = null;
 }
 private void Start()
 {
     myBase = GetComponent <EnemyBase>();
 }
Example #31
0
 /// <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;
 }
Example #32
0
 public HealthListener(EnemySettings _enemySettings, EnemyBase _enemy)
 {
     enemySettings = _enemySettings;
     enemy         = _enemy;
 }
Example #33
0
 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();
            }
        }
    }
Example #35
0
	void onEnemyStatsChange( EnemyStats stats, EnemyBase._EnemyState state )
	{
		if( stats.health == 0 && state == EnemyBase._EnemyState.Dead )
		{
			StopAllCoroutines();
		}
	}
Example #36
0
 public static void RemoveEnemy(EnemyBase enemy)
 {
     instance._aliveEnemies.Remove(enemy);
 }
Example #37
0
 /// <summary>
 /// Adds the enemy.
 /// </summary>
 /// <param name="enemy">Enemy.</param>
 public void AddEntity(EnemyBase entity)
 {
     enemies.Add (entity);
 }
Example #38
0
 private void Start()
 {
     enemy  = GetComponentInParent <EnemyBase>();
     slider = GetComponent <Slider>();
 }
Example #39
0
        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;
                }
            }
        }
Example #40
0
 public static void AddEnemy(EnemyBase enemy)
 {
     instance._aliveEnemies.Add(enemy);
 }
Example #41
0
 public void DeReference(EnemyBase entity)
 {
     if (entity is EnemyBase) {
         enemies.Remove ((EnemyBase)entity);
     }
 }
Example #42
0
 public void SetTarget(Transform newTarget)
 {
     target      = newTarget;
     targetEnemy = newTarget.GetComponent <EnemyBase>();
 }