win8 开发之旅(14)

mofdan

先看看这个游戏的类结构的介绍
类结构
公共类层：
子弹帮助类、 BulletHepler，公共帮助类、 CommonHelper，图片帮助类、ImageHelper，精灵工厂类、SpriteFactory。
游戏元素层：
公有元素有精灵类、Sprite，精灵实体类、ModelSprite，英雄实体类、HeroSprite，游戏结束类、GameOver;
旗下又包括了Bullet层，Daoju层，Effect层，Enemy层。
Bullet层有一个基类BulletSprite，子弹精灵类。其他是具体的实现类EnemyBulletSprite、敌人子弹类，HeroCircleBulletSprite、英雄圆形子弹类，HeroNomalBulletSprite、英雄普通子弹类，LightningBulletSprite、闪电子弹类。
Daoju层有一个基类Support，道具类。其他是具体的实现类AddLife、加血的道具，CircleBullet、球形子弹道具，Clear、清空道具，LightningBullet、闪电子弹道具，PelletBullent、球形子弹道具，
Bomb层有一个类Bomb，爆炸效果类。
Enemy层有一个基类BaseEnemy、敌人基类，其他是具体实现类FristBoss、大佬怪类，HelicopterEnemy、直升飞机怪物类，NomalEnemy、普通敌人类，UFOEnemy、UFO敌人类。
相应枚举部分：
EnemyType、敌人枚举类型，HeroState、英雄状态和英雄子弹的枚举，SupportType、道具枚举，UserKeyDir、用户方向枚举。
代码我已经发布，可见做这样一个win8游戏并不难。今天讲准备工作，也就是所需要的开发工具。代码编写调试：VS2012，美术工具：美图秀秀（http://xiuxiu.web.meitu.com）。这是最简陋的开发工具，但已足够。最好再有Photoshop，NotePad++或UltraEdit等等你喜欢的文本编辑工具。

游戏代码分两部分，公共部分，元素部分。先说公共部分：包括两个部分，帮助类部分和工厂类部分。帮助类主要是将一些主要的逻辑的，工具的源代码封装在3个不同的帮助类中（子弹帮助类、 BulletHepler，公共帮助类、 CommonHelper，图片帮助类、ImageHelper）。而工厂类部分主要是用于产生了各种各样的游戏元素。这样在游戏元素类的部分只需要调用这个层封装各种各样的方法，就能够完成一个游戏的组装。
公共层的3个帮助类是：
①游戏的基本帮助类——主要完成一些游戏主要逻辑的判断
　　///
    /// 基本的帮助类
    /// 用于帮助游戏的逻辑的处理
    ///
    public class CommonHelper
    {
        /// 检测两个精灵是否发生了碰撞
        public static bool CheckHit(Sprite.Sprite spriteOne, Sprite.Sprite spriteTwo);
　　//获取主页
　　public static MainPage GetMain();
　　/// 添加精灵岛canvas中差不多
　　public static void AddToGetMianCanvas(Sprite.Sprite sprite)；
}
这是一个涉及游戏具体逻辑的类，它主要用用于①检测两个精灵是否发生了碰撞，②获取了主页的相应的信息，③把相应的游戏的每个元素添加到画布上，用于游戏渲染。
我们这里是如何完成一个简单的碰撞的检测的了，这里等效于判断两个元素的坐标的距离是不是小于两个圆心直接的距离，小于就相交，反之，就不相交。用数学公式来表示：（x1-x2）²+(y1-y2)² Math.PI * 2))
                    {
                        //英雄的圆圈的对象
                        HeroCircleBulletSprite herox = new HeroCircleBulletSprite();
                        //x坐标
                        herox.X = model.X+30;
                        //y坐标
                        herox.Y = model.Y;
                        //x方向上的速度
                        herox.Vx = Math.Sin(x) * 3;
                        //y方向上的速度
                        herox.Vy = Math.Cos(x) * 3;
                        //添加到页面上
                        CommonHelper.AddToGetMianCanvas(herox);
                        //x累加
                        x += 2 * Math.PI / 5;
                    }
                    break;
                    //光子弹的
                case SpriteBullet.Lightning:
                    //光子弹
                    LightningBulletSprite big = new LightningBulletSprite();
                    //光子弹的x坐标等于传进来的对象的x坐标的值
                    big.X = model.X;
                    //y坐标的值等于传进来y的值减高度
                    big.Y = model.Y - big.SpriteHeight;
                    //x坐标等于0
                    big.Vx = 0;
                    //y坐标等于-3
                    big.Vy = -3;
                    //添加到控件上
                    CommonHelper.AddToGetMianCanvas(big);
                    break;
　　而 敌人的子弹开火的方法，与英雄的子弹发出的方法一样的。此处略去n个字。
　　3个帮助类，说完了。说一说精灵的工厂类，这个精灵工厂类，与传统的工厂类是一模一样。就是传递给不同参数，产生了不同精灵的对象。再初始化相应的x,y坐标，x轴速度，y轴速度。代码如下：
　　public class SpriteFactory
    {
　　///
        /// 创建老怪
        ///
        /// 老怪的类型
        ///
        public static BaseEnemy CreateEnemy(EnemyType enemyType)
        {
            ///随机函数
            Random rd = new Random(DateTime.Now.Millisecond);
            //基本敌人的对象
            BaseEnemy enemy = null;
            //创建不同的敌人的对象
            switch (enemyType)
            {
               //直升飞机的敌人
                case EnemyType.Helicopter:
                    enemy = new HelicopterEnemy();
                    break;
                    //普通的敌人
                case EnemyType.Normal:
                    enemy = new NomalEnemy();
                    break;
                    //ufo敌人
                case EnemyType.UFO:
                    enemy = new UFOEnemy();
                    break;
            }
            //敌人的x坐标
            enemy.X = (rd.Next(0, 800 - enemy.Radius));
            //敌人的y坐标
            enemy.Y = -enemy.Radius;
            //敌人的x轴上的速度
            enemy.Vx = 0;
            //敌人的y轴上的速度
            enemy.Vy = 3;
            //返回建造的enemy的对象
            return enemy;
        }
        //参加相应的道具对象
        public static Support CreateSupport(SupportType supportType)
        {
            //随机函数
            Random rd = new Random(DateTime.Now.Millisecond);
          //道具对象
            Support support = null;
           //创建不同的道具的对象
            switch (supportType)
            {
                    //加血的道具
                case SupportType.AddLife:
                    support=new AddLife();
                    break;
                    //原性子弹的道具
                case SupportType.CircleBullet:
                    support = new CircleBullet();
                    break;
                    //球星子弹的道具
                case SupportType.PelletBullet:
                    support = new PelletBullet();
                    break;
                    //广石化的道具
                case SupportType.Lightning:
                    support = new LightningBullet();
                    break;
                    //晴空的道
                case SupportType.Clear:
                    support = new Clear();
                    break;
            }
　　//x的坐标
            support.X = (rd.Next(0, 800 - support.Radius));
            //y的坐标
            support.Y = -support.Radius;
            //x的速度
            support.Vx = rd.Next(0, 10);
            //y的速度
            support.Vy = 3;
            //返回道具的对象
            return support;
        }
　　//创建了大老怪
        public static FristBoss CreateBoss()
        {
            //随机函数
            Random rd = new Random(DateTime.Now.Millisecond);
            //的老怪的对象
            FristBoss boss = new FristBoss();
            //x的坐标
            boss.X = (rd.Next(0, 800 - boss.Radius));
            //y的坐标
            boss.Y = -boss.Radius;
            //返回了大老怪的对象
            return boss;
        }
　　}
　　上述的这些源代码是只是一个公共层的类概述和源代码简介。
　　说一说游戏元素层，这些层的是产生游戏核心元素——游戏元素的类。
　　这些游戏的类由于好多源代码和思路是大同小异的，这里只需要讲明白3个类。一个是所有这些类的基类——sprite,一个能活动的游戏元素的基类——Modelsprite,一个子弹的类。
　　①sprite类——这个类是所有的游戏元素的基类，它定义了这些游戏元素公有的属性，方法。他的结构如下：
　　public abstract class Sprite : Canvas
    {
        ///
        /// x的坐标 进行精灵的x坐标定位
        ///
        public double X
　　///
        /// y的坐标  进行精灵的y坐标定位
        ///
        public double Y
　　///
        /// x方向上的速度
        ///
        public double Vx { get; set; }
        ///
        /// y方向上的速度
        ///
        public double Vy { get; set; }
        ///
        /// 他所经过的半径区域
        ///
        public int Radius;
        ///
        /// 相应精灵的图片
        ///
        public Image SpriteImg;
        ///
        /// 精灵的宽度
        ///
        private int spriteWidth;
        ///
        /// 精灵的高度
        ///
        private int spriteHeight;
　　
        ///
        /// 构造函数
        ///
        public Sprite()；
　　///
        /// 移去相应的元素
        ///
        public virtual void Remove()；
　　///
         /// 进行了更新的操作
         ///
        public abstract void Update();
　　}
　　通过这样结构，我们可以知道他有x,y坐标，vx，vy的属性 这些都是用于定位于使飞机移动下来所必备的属性。而Image属性，是这些类背景图片又是哪一张。至于Remove操作，是使某个元素消亡以后，他从界面上移去的方法。至于说到所谓的更新操作，这个使飞机位于不同的位置。其中源代码如下：
　　public abstract class Sprite : Canvas
    {
        ///
        /// x的坐标 进行精灵的x定位
        ///
        public double X
        {
           
            get { return Canvas.GetLeft(this); }
            set { Canvas.SetLeft(this, value); }
        }
        ///
        /// y的坐标  进行精灵的y定位
        ///
        public double Y
        {
            get { return Canvas.GetTop(this); }
            set { Canvas.SetTop(this, value); }
        }
        ///
        /// x方向上的速度
        ///
        public double Vx { get; set; }
        ///
        /// y方向上的速度
        ///
        public double Vy { get; set; }
        ///
        /// 他所经过的半径区域
        ///
        public int Radius;
        ///
        /// 相应精灵的图片
        ///
        public Image SpriteImg;
        ///
        /// 精灵的宽度
        ///
        private int spriteWidth;
        ///
        /// 精灵的高度
        ///
        private int spriteHeight;
        ///
        /// 精灵的宽度
        ///
        public int SpriteWidth
        {
            get { return spriteWidth; }
            set
            {
                spriteWidth = value;
                SpriteImg.Width = value;
                Canvas.SetLeft(SpriteImg,value/2-1);
            }
        }
        ///
        /// 精灵的高度
        ///
        public int SpriteHeight
        {
            get { return spriteHeight; }
            set
            {
                spriteHeight = value;
                SpriteImg.Height = value;
                Canvas.SetTop(SpriteImg,value/2-1);
            }
        }
        ///
        /// 构造函数
        ///
        public Sprite()
        {
            SpriteImg = new Image();
            this.Children.Add(SpriteImg);
        }
        ///
        /// 移去相应的元素
        ///
        public virtual void Remove()
        {
            //canvas的对象
            Canvas canva = CommonHelper.GetMain().appCanvas;
            if (canva.Children.Contains(this))
            {
                  //移去对象
                (this.Parent as Canvas).Children.Remove(this);
　　}
            //包含相应的对象
            if (CommonHelper.GetMain().sprites.Contains(this))
            {
                //移去对象
                CommonHelper.GetMain().sprites.Remove(this);
            }
        }
         ///
         /// 进行了更新的操作
         ///
        public abstract void Update();
    }
　　②ModelSprite——基本的神灵的基本类，这是所有的英雄精灵类，各种各样的敌人精灵类都继承与他。他的架构如下：
　　///
    ///基本的精灵的类
    ///
    public class ModelSprite : Sprite
    {
        ///
        /// 最大的生命值
        ///
        private int maxlife;
        ///
        /// 最大的速度
        ///
        public int speed = 5;
        ///
        /// 最大的生命值(属性)
        ///
        public int MaxLife
        {
            //只读
            get {  return maxlife; }
            //属性
            set
            {
                maxlife = value;
            }
        }
        ///
        /// 精灵的子弹（属性）
        ///
        public SpriteBullet Bullet { get; set; }
        ///
        /// 精灵的更新状态(属性)
        ///
        public SpriteState State { get; set; }
　　///
        /// 进行更新的操作
        ///
        public override void Update()
///
　　/// 构造函数 进行了初始化的工作
　　///
        public ModelSprite()；
　　}
　　他包括这个最大生命值，最大运行的速度这些属性，update方法， 判断这个精灵生命值是不是小于0，就将他从界面上移去，并且把的坐标改变。
　　③BulletSprite——子弹的精灵基类，所有子弹继承与他。这包含了一个DPS——每秒钟刷新的频率。   他继承与精灵类。
　　后记
　　程序,乐趣无穷。在一篇文不加点情况下，一篇win8的飞机游戏介绍文章诞生了。
　　源码位置：http://51aspx.com/Code/Win8Fly