Пример #1
0
 /// <summary>
 /// 对敌人的技能判定
 /// </summary>
 /// <param name="e">判定的敌人对象</param>
 /// <param name="msg">返回的判定信息</param>
 /// <returns>是否进入判定域</returns>
 public virtual bool AttackCollision(Enemy e, ref MessageManager msg)
 {
     return false;
 }
Пример #2
0
 /// <summary>
 /// 对子弹的技能判定
 /// </summary>
 /// <param name="bullet">判定的子弹对象</param>
 /// <param name="msg">返回的判定信息</param>
 /// <returns>是否进入判定域</returns>
 public virtual bool AttackCollision(Bullet bullet, ref MessageManager msg)
 {
     return false;
 }
Пример #3
0
 public override bool AttackCollision(Bullet bullet, ref MessageManager msg)
 {
     //是否存在判定成功的情况
     bool result = false;
     //对每一个组件都进行目标判定,并获得反馈结果
     foreach (CollisionComponent c in AttackComponents)
     {
        if( c.Collision(bullet, ref msg))
            result = true;
     }
     return result;
 }
Пример #4
0
 public bool AttackCollision(Bullet bullet, ref MessageManager msg)
 {
     return CurrentCharactor.AttackCollision(bullet, ref msg);
 }
Пример #5
0
        //所有游戏对象的逻辑更新
        void EntitiesUpdate(double elapsedTime)
        {
            //玩家逻辑更新
            GamePlayer.Update(elapsedTime);
            //玩家的子弹的队列装填  (从GamePlayer中获取子弹)
            foreach (Bullet b in GamePlayer.bullet_toAdd)
            {
                GamePlayer.Bullets.Add(b);
                Player_Bullets_toAdd.Add(b);
            }
            GamePlayer.bullet_toAdd.Clear();
            //添加玩家子弹进全局
            foreach (Bullet b in Player_Bullets_toAdd)
            {
                Player_Bullets.Add(b);
            }
            Player_Bullets_toAdd.Clear();
            //子弹逻辑更新
            foreach (Bullet b in Player_Bullets)
            {
                b.Update(elapsedTime);
                if (b.disabled)
                {
                    Player_Bullets_toRemove.Add(b);
                }
            }
            //删除无效子弹
            foreach (Bullet b in Player_Bullets_toRemove)
            {
                Player_Bullets.Remove(b);
            }
            Player_Bullets_toRemove.Clear();
            //自机子弹的碰撞判定
            {
                foreach (Bullet b in Player_Bullets)
                {
                    foreach (Enemy e in Enemys)
                    {
                        if (e.living)
                        if (b.Collision(e))
                        {
                               b.Hit(e);     //引发击中事件
                        }
                    }
                }
            }

            //敌人逻辑更新
            foreach (Enemy e in Enemys_ToAdd)
            {
                Enemys.Add(e);
            }
            Enemys_ToAdd.Clear();
            for (int i = 0; i < Enemys.Count; i++)
            {
                Enemy e = Enemys[i];
                e.Update(elapsedTime);

                //将敌人的子弹队列填充到整个游戏的子弹队列中
                foreach (Bullet b in e.bullet_toAdd)
                {
                    e.Bullets.Add(b);
                    Enemys_Bullets_toAdd.Add(b);
                }
                e.bullet_toAdd.Clear();
                //消除无效敌机
                if (e.disabled)
                {
                    Enemys_ToRemove.Add(e);
                }
            }
            //删除无效敌机
            foreach (Enemy e in Enemys_ToRemove)
            {
                Enemys.Remove(e);
            }
            Enemys_ToRemove.Clear();

            //添加敌机子弹
            foreach (Bullet b in Enemys_Bullets_toAdd)
            {
                Enemys_Bullets.Add(b);
            }
            Enemys_Bullets_toAdd.Clear();
            //敌人的子弹逻辑更新
            foreach (Bullet b in Enemys_Bullets)
            {
                b.Update(elapsedTime);
                //消除无效子弹
                if (b.disabled)
                {
                    Enemys_Bullets_toRemove.Add(b);
                }
            }
            //删除敌机子弹
            foreach (Bullet b in Enemys_Bullets_toRemove)
            {
                Enemys_Bullets.Remove(b);
            }
            Enemys_Bullets_toRemove.Clear();

            //敌人子弹的碰撞判定 && 技能检测
            foreach (Bullet b in Enemys_Bullets)
            {
                //先判定擦弹,再判定碰撞
                Vector2D vct = new Vector2D(0,0);                //获取的方向矢量
                Item itm = new Item();                           //获取的道具
                if (b.MissBullet(GamePlayer, ref vct, ref itm))  //擦弹判定
                {
                    GamePlayer.MissBullet(b);           //玩家也会方向的触发擦弹状态(因此产生擦弹特效)
                    Items_toAdd.Add(itm);
                    _breakParticles.AddParticle(GamePlayer.Position,1);     //溅射效果
                }
                //碰撞检测
                if (b.Collision(GamePlayer))
                {
                    b.Hit(GamePlayer);
                    if (GamePlayer.Hitted())
                    {
                        Hp--;
                        Booms = 3;
                        Datas.Hp = Hp;
                        Datas.booms = Booms;
                    }
                }
                //玩家技能检测(ComponentMessage)
                MessageManager msg = new MessageManager();
                if (GamePlayer.AttackCollision(b, ref msg))
                {
                    CmpMessage[] mss = msg.SelectMessages(CmpMessage.CollisionMasseageNormal);
                    foreach (CmpMessage ms in mss)
                    {
                        b.AcceptMessage(ms);
                    }
                }

                if (b.disabled == true)                 //子弹销毁
                {
                    Enemys_Bullets_toRemove.Add(b);
                }
            }
            //道具逻辑的更新
            foreach (Item item in Items_toAdd)
            {
                Items.Add(item);
            }
            Items_toAdd.Clear();
            foreach (Item item in Items)
            {
                item.Update(elapsedTime);
                //碰撞判定
                if (item.Collision(GamePlayer))
                {
                    if (item.Type == Item.P_Point)
                    {
                        Power++;
                        item.disabled = true;
                    }
                    if (item.Type == Item.BigP_Point)          //大P点+10w分
                    {
                        Power+=10;
                        item.disabled = true;
                        //获取分数后添加一个分数道具
                        ScoreItems.Add(new IScore(item.Position.X, item.Position.Y + 10, 100000));
                    }
                    if (item.Type == Item.Blue_Point)
                    {
                        itemdata.BluePoint mp = (itemdata.BluePoint)item.ItemData;
                        int score = mp.getsocre();
                        this.score += score;
                        //获取分数后添加一个分数道具
                        ScoreItems.Add(new IScore(item.Position.X, item.Position.Y + 10, score));
                        item.disabled = true;
                    }
                    if (item.Type == Item.Boom_Point)
                    {
                        Booms++;
                        item.disabled = true;
                    }
                    if (item.Type == Item.Help_Point)
                    {
                        Hp++;
                        item.disabled = true;
                    }

                }

                //“擦弹,满力攻击” 不需要经过碰撞判定,直接逻辑处理
                if (item.Type == Item.Miss_Point)
                {
                    if (item.working)
                    {
                        itemdata.MissPoint mp = (itemdata.MissPoint)item.ItemData;
                        int score = mp.getsocre();
                        this.score += score;
                        int point = mp.getPoint();
                        this.Graze += point;
                        //获取分数后添加一个分数道具
                        //ScoreItems.Add(new IScore(item.Position.X, item.Position.Y + 10, score));
                        item.working = false;          //仅工作一次
                        item.disabled = true;          //不显示
                        _soundmanager.Play("Graze");           //设置一个功能,防止过快的重复播放从而影响运行速度
                    }
                }
                if (item.disabled)
                {
                    Items_toRemove.Add(item);
                }
            }
            foreach (Item item in Items_toRemove)
            {
                Items.Remove(item);
            }
            Items_toRemove.Clear();

            //分数道具逻辑
            foreach(IScore i in ScoreItems)
            {
                i.Update(elapsedTime);
                if (i.disabled)
                {
                    ScoreItems_ToRemove.Add(i);
                }
            }
            foreach (IScore i in ScoreItems_ToRemove)
            {
                ScoreItems.Remove(i);
            }
            ScoreItems_ToRemove.Clear();
        }
Пример #6
0
 /// <summary>
 /// 对敌人的技能判定
 /// </summary>
 /// <param name="e">判定的敌人对象</param>
 /// <param name="msg">返回的判定信息</param>
 /// <returns>是否进入判定域</returns>
 public virtual bool AttackCollision(Enemy e, ref MessageManager msg)
 {
     return(false);
 }
Пример #7
0
 /// <summary>
 /// 对子弹的技能判定
 /// </summary>
 /// <param name="bullet">判定的子弹对象</param>
 /// <param name="msg">返回的判定信息</param>
 /// <returns>是否进入判定域</returns>
 public virtual bool AttackCollision(Bullet bullet, ref MessageManager msg)
 {
     return(false);
 }
Пример #8
0
 public bool AttackCollision(Bullet bullet, ref MessageManager msg)
 {
     return(CurrentCharactor.AttackCollision(bullet, ref msg));
 }