博客园_wangergo

写在"CastleDefense"上市1周月之际

2012-01-14T15:10:00Z

2011年10月1日，MagicJelly Game Studio成立。

2011年11月21日，Game Kingdom Studio成立。

2011年12月14日， "CastleDefense"由Game Kingdom Studio发布。

2011年12月30日，"果冻军团"由MagicJelly Game Studio发布。

截止2012年1月14日，"CastleDefense"排名MarketPlace美国市场游戏“策略模拟”分类第12位，总排名TOP119位。“果冻军团"排名MarketPlace美国市场游戏”家庭“分类第4位，总排名TOP59位，MarketPlace香港市场游戏”家庭“分类第1位，总排名Top6。

我作为MagicJelly Game Studio和Game Kingdom Studio的创始成员之一，这两个游戏的唯一开发人员。直接操作了游戏的发布过程，掌握了这两个游戏的第一手销售资料。

让我觉得不解的是，”果冻军团“曾经排名美国市场前50位，评分5星，收益却不如评分3.5分的”CastleDefense“。我认真思考了很久，一款游戏的收益只能由市场评判，市场才是公正的裁判。

总结如下：

1.目前WP7市场重点在欧美，最重要的市场是美国，所以欧美画风的CastleDefense获得欧美市场的认可要高，付费比率也要高出不少。

2.果冻军团在香港等中文市场排名靠前，一方面做过7天的免费推广，所以下载量超过CastleDefense不少，但游戏并不为欧美市场认可。

3.等待中国市场开放，果冻军团应该收益接近CastleDefense.

对我个人而言，这2个月左右的经历收获不少，之前只所以没有对朋友们公开我要做什么，是因为我不是一个什么都没做出来就宣扬的人。

从一个职责单纯的开发人员到一个成立游戏工作室的游戏制作人，我遇到的迷惑和困难超出我的想象，现在理清思路，我应该是走在一个正确的方向上。

1.就目前市场容量来说，1年之内CastleDefense的成本应该可以回收，所以1年的坚持和运作很重要。

2.WP7的市场随着Nokia的加入应该会增大而不是萎缩。

3.国外一名独立游戏制作者去年发布了13款游戏，全部是免费的，靠广告收入6W美元，我们应该不会比他差。

4.盈利模式很清晰，没有中间的渠道环节来增加成本，做一个好点的游戏，就能收入美元，关键是游戏的质量。

5.中国的人力成本，特别是武汉的人力成本是外国开发者不能比的。

我遇到的压力和困难：

1.从一个稳定的高收入者到一个不稳定的负收入者，经济和心理压力都比较大。

2.工作室的运作会遇到人才和资金压力，如果找到合适的人才，何时寻找或者不寻找天使投资？

3.我们要做什么样的游戏，创新还是山寨？

我的对策：

1.我起起伏伏好几次了，曾经被偷成零资产，遇到比这困难的事也不少了，所以就算失败了也没什么。

2.我会培养XNA的开发人员，同时把自己变成一个精通XNA开发的人。

3.多和武汉的朋友交往，多接触类似于投资方，运营，培训行业的朋友。

4.努力提升游戏质量，多关注市场。

2012，加油吧！用CastleDefense过关画面来勉励自己：Fight!I'll win!

最后宣传下我的工作室:Http://gamekingdom.us

本文链接

如何在WP7上用XNA写2D游戏（五）

2011-11-27T08:21:00Z

第 4 章XNA里的2D动画

4.1 播放游戏精灵动画

第二章里我们提到了如何把2D的纹理用SpriteBatch显示。对于游戏而言，一个精灵(sprite，在游戏编程里指一个对象的原型，比如一个战士，一个怪物)不可能不做动作，就拿简单的走动来说，手脚一定会是要动的，那么如何真实得展现一个人物在屏幕上走动呢？在2D游戏编程里，我们通常就是把人物的动作拆成一帧帧图片，通过连续播放来欺骗人眼产生动画的效果，其实胶片电影也是这个原理。

如下图4-1，是一个小兵的行走动画，可以看到是由12张图片组成，那么如何能连续循环播放呢

图4-1

一想到循环，我们就很容易想到for循环，如果我们把这12张图片的纹理放到一个Texture2D[] 数组里那么，通过for循环不就可以实现了么？

for(int i=0;i<SoldierTextures.Count;i++) //伪代码

{

spriteBatch.Draw(SoldierTextures[i]);

}

当然，这个循环只能循环一遍，如果做到从头到尾不停的循环呢？

前面我们提到XNA里的Update函数，它就是不停执行的一个函数，执行的时间间隔是一个固定值.我们就可以把这个函数当做是一个特殊的for循环.

我们需要用上一个全局的计数器FrameCount.

int FrameCount=0;

void Update() //在update函数里改变计数器

{

FrameCount++;

if(FrameCount>SoilderTextures.Length-1)//如果播完最后一帧

{

FrameCount=0; //就回到第一帧

}

void Draw() //在Draw函数里绘制出纹理

{

spriteBatch.Draw(SoilderTextures[FrameCount]);

}

以上代码都是伪代码，便于大家理解，实际编程中的代码比这里要复杂点。

1.在GameMainScreen类里写上构造函数：

Texture2D[] soilderTextures;

public GameMainScreen()

{

soilderTextures=new Texture2D[12];//初始化士兵纹理数组

}

2.把12张士兵跑动图片放到Content项目下的一个Enemy文件夹的子文件夹Run中，如果4-2：

3.用for循环加载这12张图片纹理,如下:

public override void LoadContent()

{

base.LoadContent();

playerTexture = ScreenManager.Game.Content.Load<Texture2D>("Player/1");

for (int i = 0; i < 12;i++ )

{

soilderTextures[i] =ScreenManager.Game.Content.Load<Texture2D>("Enemy/Run/"+(i+1));

}

4.在Draw里绘制出当前帧:

public override void Draw(GameTime gameTime)

{

ScreenManager.SpriteBatch.Begin();

ScreenManager.SpriteBatch.Draw(soilderTextures[FrameCount],new Vector2(100,200), Color.White);

ScreenManager.SpriteBatch.End();

}

图4-2

5.在Update里更新当前帧的位置，依次向后播放:

public override void Update(GameTime gameTime, bool otherScreenHasFocus, bool coveredByOtherScreen)

{

base.Update(gameTime, otherScreenHasFocus,coveredByOtherScreen);

float elapsedTime = (float)gameTime.ElapsedGameTime.TotalSeconds;

FrameCount++;

if(FrameCount > soilderTextures.Length - 1)//如果播完最后一帧

{

FrameCount = 0; //就回到第一帧

}

6.在模拟器最后运行效果如图4-3:

我们执行上面写好的代码后，就在模拟器里发现人物就循环播放动画了，不过出现了新问题：士兵的跑动动作频率不够合理，像一个超人一样飞速得在奔跑。

这是为什么呢？

因为人物动画帧播放的时间间隔其实是要远大于update函数执行的时间间隔的，比如说人物动画是1秒播放一帧，而update函数是1/30秒(0.3333秒)播放一帧。那么我们如何处理这个问题呢？

在回到上面的代码里，其实只要控制 FrameCount++执行的时间间隔就可以了。如何控制？那么我们需要用到另外一个计数器updateCount;

updateCount++;

if(updateCount>TimeSpan) //伪代码,TimeSpan为时间间隔量

{

FrameCount++;

updateCount=0;

}

这样我们通过修改TimeSpan的值就能控制FrameCount++执行的时间间隔了。比如TimeSpan=30, 那么update函数要执行30次，FrameCount++才执行一次。也就说FrameCount++执行的时间间隔为 30*0.33333秒=1秒。

经过合理调整，我们发现TimeSpan=2时，士兵的动作频率最协调，代码如下:

int updateCount=0,timeSpan=2;

public override void Update(GameTime gameTime, bool otherScreenHasFocus, bool coveredByOtherScreen)

{

base.Update(gameTime,otherScreenHasFocus, coveredByOtherScreen);

float elapsedTime = (float)gameTime.ElapsedGameTime.TotalSeconds;

updateCount++;

if(updateCount > timeSpan) // timeSpan为时间间隔量

{

FrameCount++;

updateCount = 0;

}

if(FrameCount > soilderTextures.Length - 1)//如果播完最后一帧

{

FrameCount = 0; //就回到第一帧

}

写完以上代码，我们就能看到精灵动画能够自如的播放了。不过这个小兵精灵并不能移动，所以有些别扭。那么我们下面一节就要研究如何让精灵移动起来。

4.2游戏精灵的矢量移动

我们在前面第二章讲过可以指定得把一个2D纹理绘制在特定的坐标位置上。在WP7的XNA里，坐标系如下，原点的位置是左上角，X轴向右延伸，Y轴向下延伸。

在XNA里，2维坐标用Vector2对象来表示：

Vector2 position = new Vector2(X,Y);

了解了XNA里2维坐标概念后，我们还需要知道一个概念就是运动矢量,什么叫运动矢量呢?比如我向右走，也就是笔直沿X轴增大的方向走，这样我行走的方向就确定了，但是我行走的时候可快可慢，这就涉及到速度的问题。运动矢量就包含了方向和速度两个概念。在2维坐标系里，运动矢量也用Vector2 对象来表示。我用20单位的速度向右走就可以表示为 new Vector2(20,0); 很容易理解此时在X轴方向上以20单位的速度在增大（向右运动），在Y轴上没有变化。

那么随着时间流逝，我们就能得到运动中的精灵在当前时刻所在坐标位置，用矢量计算公式：

Vector2 speed = new Vector2(20,0);

Vector2 EndPosition = position + speed*elipsetime;

计算出EndPosition后，我们就在Draw方法里

spriteBatch.Draw(Texture2D,EndPosition);

这样我们的精灵就能移动了，改变speed运动矢量，我们就能控制精灵的运动速度和方向。当然，要让精灵停下来也很简单，speed = new Vector2(0,0)就可以了。

改进后的代码如下：

int FrameCount= 0;

Vector2 endPosition = new Vector2(0,200);

public override void Draw(GameTime gameTime)

{

float elapsedTime = (float)gameTime.ElapsedGameTime.TotalSeconds;

float totalTime = (float)gameTime.TotalGameTime.TotalSeconds;

ScreenManager.SpriteBatch.Begin();

ScreenManager.SpriteBatch.Draw(soilderTextures[FrameCount], endPosition,Color.White);

ScreenManager.SpriteBatch.End();

}

int updateCount=0,timeSpan=2;

Vector2 speed=new Vector2(100,0);

public override void Update(GameTime gameTime, bool otherScreenHasFocus, bool coveredByOtherScreen)

{

base.Update(gameTime,otherScreenHasFocus, coveredByOtherScreen);

float elapsedTime = (float)gameTime.ElapsedGameTime.TotalSeconds;

updateCount++;

if(updateCount > timeSpan) //TimeSpan为时间间隔量

{

FrameCount++;

updateCount = 0;

}

if(FrameCount > soilderTextures.Length - 1)//如果播完最后一帧

{

FrameCount = 0; //就回到第一帧

}

endPosition += elapsedTime * speed;

if(endPosition.X>800)

{

endPosition = new Vector2(0,200);

}

按F5运行模拟器后，我们会看到一个不停奔跑的士兵。

4.3制作可控的游戏精灵

在手机游戏里，主角一般都是方向可控的，如下图4-4是一个带十字方向键的iphone游戏界面:

图4-4

结合我们第3章讲的WP7的触控操作，我们也能实现十字方向键控制的游戏精灵。

1. 首先找到一个十字键图片，把它绘制到手机左下角，如图4-5：

图4-5

2. 设定4个方向点的矩形范围。

Rectangle topRect = newRectangle

{

Location = newPoint { X = 40, Y = 380 },

Width = 30,

Height = 30,

};

Rectangle bottomRect = new Rectangle

{

Location = new Point { X = 40, Y = 460 },

Width = 30,

Height = 30,

};

Rectangle leftRect = new Rectangle

{

Location = new Point { X = 2, Y = 410 },

Width = 30,

Height = 30,

};

Rectangle rightRect = new Rectangle

{

Location = new Point { X = 80, Y = 410 },

Width = 30,

Height = 30,

};

2. 重写HandleInput函数，接受触控操作:

public override void HandleInput(InputHelperinput)

{

TouchCollection touchState = TouchPanel.GetState();

foreach(TouchLocation tl in touchState)

{

if(topRect.Contains(new Point{ X = (int)tl.Position.X, Y = (int)tl.Position.Y }) && tl.State == TouchLocationState.Pressed)

{

speed = new Vector2(0,-100);

}

if(bottomRect.Contains(new Point { X = (int)tl.Position.X,Y = (int)tl.Position.Y }) &&tl.State==TouchLocationState.Pressed)

{

speed = new Vector2(0,100);

}

if(leftRect.Contains(new Point{ X = (int)tl.Position.X, Y = (int)tl.Position.Y }) && tl.State == TouchLocationState.Pressed)

{

speed = new Vector2(-100,0);

}

if(rightRect.Contains(new Point { X = (int)tl.Position.X,Y = (int)tl.Position.Y }) && tl.State== TouchLocationState.Pressed)

{

speed = new Vector2(100,0);

}

if(tl.State==TouchLocationState.Released)

{

speed = new Vector2(0,0);

}

3. 写好以上代码后，按F5调试，在游戏主界面，我们就看到如图4-6的效果:

图4-6

当然这只是个简单的DEMO，士兵后退，向上，向下的动画都不对，不过原理和士兵前进的动画一样。更复杂的动画，我们会在下一章来讲解。

本文链接

如何在WP7上用XNA写2D游戏（四）

2011-11-19T06:41:00Z

第 3 章创建XNA 游戏菜单
3.1 WP7里XNA游戏的触控操作
上一章节，我们了解了制作XNA 2D游戏的常用组件已及使用ScreenManage管理场景。可以说对XNA 2D游戏有了入门，不过我们玩游戏不会一开始就进入到游戏场景里的，总是会有启动界面，loading界面，然后到了游戏菜单。然后让用户选择“开始”，“继续”，“帮助”等选项，如下图3-1，就是一个常见的游戏界面。

图3-1

和PC上的运行的XNA游戏不同，我们在WP7上是靠触摸屏操作的，这和用鼠标操作还是不同的。那么我们就需要先了解WP7里XNA的触控操作。

现在的触摸屏手机基本都支持“多点触控”，比如拉伸，缩放，玩过Iphone上《愤怒的小鸟》就明白游戏画面可以用两个手指拉伸和缩放。还有很有名的《水果忍者》也是“多点触控”的好游戏，你用三个手指在屏幕上划拉，屏幕上就显出三个爪子印。

当然啦"单点触摸"也是支持的，你用一个指头也能操作的，比如你用一个指头在《愤怒的小鸟》里拉动弹弓。我们就从简单的“单点触控”开始了解吧。

当我们把一个指头在屏幕上操作，可能会有这样三种动作：按，移动，移开。就拿《愤怒的小鸟》里拉动弹弓这个动作，首先我们是按下一个指头，然后向后移动，然后在屏幕上移开这个手指。

那么这三个操作在WP7的XNA里如何获取呢？我们就需要了解XNA里的TouchPanel和TouchCollection这两个类。

TouchCollection touchState= TouchPanel.GetState();

Foreach(TouchLocation location in touchState)

        switch(location.State)

            case TouchLocationState.Pressed://按下

             ……

            break;

case TouchLocationState.Moved://移动

             ……

            break;

case TouchLocationState.Released://释放

             ……

            break;

和触控操作类似的还有叫“手势”的，也算复杂的触控吧。

TouchPanel.EnabledGestures = GestureType.FreeDrag;//用来指定手势，必须要先设定，否则报错

if (TouchPanel.EnabledGestures != GestureType.None)

{

switch (TouchPanel.ReadGesture())

{

case GestureType.Tap: //单击

break;

case GestureType.DoubleTap://双击

break;

case GestureType.FreeDrag://自由拖动

break;

case GestureType.DragComplete://拖动完成

break;

case GestureType.Flick://轻弹

break;

case GestureType.Hold://按住不动

break;

case GestureType.HorizontalDrag://横向拖动

break;

case GestureType.None://无手势

break;

case GestureType.Pinch://捏

break;

case GestureType.PinchComplete://捏完

break;

case GestureType.VerticalDrag://纵向拖动

break;

}

3.2        编写MenuEntry类

如图3-1每一个菜单界面里都有多个菜单项，为了表示单个菜单项，我们就需要写一个MenuEntry类。

    菜单项可以在屏幕上输出文字来表示，为了美化还可以绘制图片来完成。菜单项一般都是纵向排列的，每个菜单项的坐标都不同，所以有这样两个属性:

       /// <summary>

        /// 菜单项文本内容

        /// </summary>

        public string Text

        {

            get { return text; }

            set { text = value; }

        }

        /// <summary>

        /// 菜单项文本的位置

        /// </summary>

        public Vector2 Position

        {

            get { return position; }

            set { position = value; }

        }

  由于每个菜单项都会响应点击事件，所以我们需要声明一个事件：

       /// <summary>

        ///菜单项的选中事件

        /// </summary>

        public event EventHandler Selected;

        /// <summary>

        ///选中菜单项函数

        /// </summary>

        internal void OnSelectEntry()

        {

            if (Selected != null)

            {

                isPress = true;



            }

        }

如果菜单项是图片构成的，为了让菜单项有按下动感，我们用图3-2里的三个图片来做一个三帧动画。

                                                    图3-2

      所以我们要用到四个变量：public Texture2D menuTexture,showTexture,pressTexture,releaseTexture;

      在菜单项的update函数里要做这样的处理

   private TimeSpan duration = TimeSpan.FromSeconds(0.4);//菜单动画的执行时间为0.2秒

   public void Update(bool isSelected, GameTime gameTime)

        {

            if(isPress)

            {

                duration -=gameTime.ElapsedGameTime;

              if (duration <= TimeSpan.FromSeconds(0.2)&& duration > TimeSpan.FromSeconds(0.1))

                {

                    showTexture = pressTexture; //0.2-0.1秒之间显示三张图片中第二个图片

                }

                else if (duration<= TimeSpan.FromSeconds(0.1) &&duration>TimeSpan.Zero)

                {

                    showTexture =eleaseTexture;//0.1-0秒间显示三张图片中第三个图片

                }

                else if (duration <= TimeSpan.Zero)

                {

                    Selected(this, new PlayerIndexEventArgs(playerIndex));//菜单项按下动画完成触发Selected事件

                    duration = TimeSpan.FromSeconds(0.4);

                    isPress = false;

                }

            }

        }

3.3 编写MenuScreen类

    由于菜单界面也是一个特殊的场景，所以MenuScreen继承于GameScreen。

   如图3-3，MenuScreen类结构如下：

                       图3-3

     我们着重分析下HandleInput方法:

public override void HandleInput(InputHelper input)

        {

                TouchCollection touchState =TouchPanel.GetState();

               bool touchDetected = false; //是否触碰菜单

                Vector2 touchPosition = new Vector2();

               foreach(TouchLocation location in touchState)

             {

                    switch(location.State)

                    {

                           case TouchLocationState.Pressed:

                                      touchDetected = true;

                                      touchPosition = location.Position;

                                      break;

                             case TouchLocationState.Moved:

                                      break;

                             case TouchLocationState.Released:

                                      break;

                  }

              }

      if(touchDetected)

{

foreach (MenuEntrymenuEntry in menuEntries)

                    {

                            Rectangle    touchRect = new Rectangle((int)touchPosition.X - 5, (int)touchPosition.Y- 5,10, 10);

                            Rectangle entryRect = new Rectangle((int)menuEntry.Position.X- 5, (int)menuEntry.Position.Y -                 5,menuEntry.GetWidth(this), menuEntry.GetHeight(this));

                   if(entryRect.Intersects(touchRect)) //如果触摸点在菜单项的矩形区域内

               menuEntry.OnSelectEntry();//触发菜单选中事件。

                }

      }

      ………………….

}

3.4编写MainMenuScreen类

      对于游戏主菜单界面而言，点击“Play” 菜单项意味着要切入到游戏主场景里,点击“Exit Game”菜单意味着退出游戏，那么就需要在MenuScreen扩展游戏场景切换的方法。在前一章节里我们简单介绍了游戏场景的管理类ScreenManager，在这里就派上用途了。

      首先我们让MainMenuScreen继承于MenuScreen:

public class MainMenuScreen:MenuScreen

      {

}

然后我们添加了如下等方法：

/// <summary>

         /// 增加菜单项

           /// </summary>

         /// <param name="name">菜单文字</param>

         /// <param name="screen">点击对应要启动的Screen</param>

          /// <param name="isExitItem">是否是退出菜单</param>

          /// <param name="isShowLoading">是否显示loading界面</param>

         /// <param name="position">菜单的坐标</param>
   public void AddMainMenuItem(string name, GameScreen screen, bool isExitItem, bool isShowLoading,Vector2 position)

       {

           this.isShowLoading= isShowLoading;

           MenuEntry entry = new MenuEntry(name,screen,isExitItem, position);

           entry.Selected += new System.EventHandler(entry_Selected);

           MenuEntries.Add(entry);

       }

       /// <summary>

       /// 菜单点击事件

       /// </summary>

       /// <param name="sender"></param>

       /// <param name="e"></param>

     void entry_Selected(object sender, EventArgs e)

       {

           MenuEntry menu = sender as MenuEntry;

           if(menu.IsExitItem) //如果是退出菜单

           {

               ScreenManager.Game.Exit();

           }

           else

           {
                ScreenManager.AddScreen(menu.Screen,null);

           }

       }

此外，我们还需要写上InputHelper类,修改上一章节的GameScreen类，ScreenManager类，在这两个类里加上对输入的支持。

在GameScreen类里我们加上HandleInput方法:

                public virtual void HandleInput(InputHelper input)

                 {

                }

    在ScreenManager里我们需要修改Update方法，增加对screen的输入响应：

       if(!otherScreenHasFocus)

        {

              screen.HandleInput(input);

             otherScreenHasFocus = true;

        }

      具体代码修改请看具体的XNAGameSample3这个Demo。

     然后在Game1.cs里的Initialize()方法里我们就加上如下代码即可：

        MainMenuScreen mainMenu = newMainMenuScreen("Castle Defense");

       GameMainScreen main = new GameMainScreen();

        Vector2 position = new Vector2{ X = 0f, Y = 0f };

        mainMenu.AddMainMenuItem("Play", main, false,true, position);

        mainMenu.AddMainMenuItem("Exit", null,true, false,position);

        screenManager.AddScreen(mainMenu, null);

最后的代码运行效果如图3-4：

demo 下载地址：/Files/wangergo/XNAGameSample3.rar

本文链接

如何在WP7上用XNA写2D游戏（三）

2011-10-29T15:02:00Z

第 2 章制作XNA 2D游戏的常用组件

2.1使用LoadContent加载2D图片资源

在XNA项目中，如果制作2D游戏，那么都会涉及到图片资源。比如人物的行走动画可以由连续播放一系列帧图片完成。如何在XNA里加载图片资源就是我们首先要掌握的。

在上一章节，我们建了一个XNA项目解决方案，里面就带有一个Content项目。我们游戏所用的图片，音效，字体等资源都是放在这个项目里的。当然这个项目你可以认为是储存游戏资源的文件夹，方便来管理游戏资源。

如何在Content项目里把不同类型的文件放置呢？跟普通站点项目一样，同类型的文件一般都放在一个文件夹里。比如图片资源都放在UI文件夹，音效文件放在Sound文件夹。

下面我们演示如何把UI文件里的一个.png图片添加进Content项目里。如图2-1，我们在UI文件夹上右键，选择“Add”,再选择“Existing Item”。

图2-1

然后如图2-2选择我们预先放在UI文件夹里的loading.png的图片，点击确定。

图2-2

添加完毕图片，效果如图2-3.右键点击图片我们可以看到属性。其中Asset Name 是我们在XNA里引用资源的唯一标识。“Copy to Output Directory”我们默认选择“Do not copy” 如果选择了其他两项选项，那么会在我们最终生产的XAP文件里包含进了原始的.png文件。一般来说图片文件会变成.xnb文件，这就是XNA游戏运行时的资源文件。如果选择了复制，那么还会把原始的.png文件也复制进去，这样就造成了XAP体积不必要的增大。要想把最终生成的XAP游戏包精简，就不要选择“Copy”。

需要说明的是，在XNA里支持的图片纹理文件除了.png还有.dds,.jpg,.bmp,.tga.等类型的文件。

图2-3

2.2 使用SpriteBatch绘制2D纹理

在我们添加了图片资源以后，我们就可以用Texture2D这个对象来在XNA里处理了。代码如下:

Texture2D loadingTexture=Content.Load<Texture2D>(“UI/loading”);

有了2D纹理对象loadingTexture 后，我们就可以把图片绘制出来了,如图2-4。

图2-4。

这样我们就加载了loading.png这个纹理到loadingTexture对象里，接下来，我们只需要如图2-5在Draw函数里用SpriteBatch把纹理绘制出来：

spriteBatch.Draw(loadingTexture,new Vector2(0,0),Color.White);

图2-5

然后我们按F5,就能在模拟器里看到效果，如图2-6:

图2-6

如何把图片绘制出来，并且能缩放，旋转，透明等处理？XNA里的SpriteBatch类完全就可以满足我们的要求。

比如，在图2-6里我们把上面加载好的loadingTexture对象绘制在屏幕左上角，也就是坐标 Vector2(0,0);

spriteBatch.Begin();

spriteBatch.Draw(loadingTexture,new Vector2(0,0),Color.White);

spriteBatch.End();

当然，我们做游戏的时候，一个场景里肯定不可能只使用一张图片，那么就需要我们同时绘制多个纹理到屏幕上。不过不用担心，一个SpriteBatch对象可以多次调用Draw方法来绘制不同的Texture2D对象。

spriteBatch.Begin();

spriteBatch.Draw(loadingTexture,new Vector2(0,0),Color.White);

spriteBatch.Draw(playerTexture,new Vector2(260,100),Color.White);

spriteBatch.End();

这段代码绘制的结果如图2-7,这样我们就把一个弓箭手绘制在城堡上面：

图2-7

在绘制多个图片的时候可能出现纹理堆叠的情况，在XNA里最后绘制的默认在最上层，当然也可以指定绘制的层次。这些高级的Draw方法的应用，就需要深入我们了解SpriteBatch对象。

SpriteBatch对象的Draw方法有不同的重载，其中最复杂的如下：

public void Draw (Texture2D texture,Vector2 position,Nullable<Rectangle> sourceRectangle,Color color,float rotation,Vector2 origin,Vector2 scale,SpriteEffects effects,float layerDepth)

这个Draw方法的第三个参数sourceRectangle为制定绘制纹理的那个矩形部分。这个参数非常有用，比如游戏编程里我们为了减少图片的数量和大小，我们总是把很多帧动画绘制在一张图片上如图2-8，如果我们要绘制单帧图片的话，我们就需要制定绘制这个图片的单帧大小的矩形范围。当然如果想要把图片完整的现实出来，只需要把这个参数设置为null就行了。

图2-8

还有其他高级用法，比如：旋转某个纹理。

旋转

那么我们就需要使用rotation 参数旋转一个图像。你需要使用弧度值指定这个旋转角度，所以如果你想让图像顺时针旋转20度，你可以使用MathHelper.ToRadians(20)。

需要注意的是旋转一个图片，我们总是要指定旋转中心点的，origin这个参数就是旋转中心点。当然origin不光是在旋转时有用。origin可以指定你想让图像上的哪个点位于屏幕上你在position参数中指定的位置上。例如，如果你将position,origin两个参数都指定为(0,0)，那么图像的左上角将位于屏幕的左上角，如图2-9：

图2-9

如果一张80 × 60大小的图像，你将屏幕位置指定为(0,0)，origin指定为(40,30)，那么图像的中心点将位于屏幕的左上角，如图2-10所示。

图2-10

如果两个参数都是(40,30)，那么图像的中心点将位于屏幕的(40,30)位置。这时的结果与图2-9一样。

在图片旋转的时候如果把(0,0)为图像的origin，这个图像会围绕这个点旋转，如图所示。如果你指定(32,32)为图像的origin，这个图像会围绕它的中心点旋转，如图2-11:

图2-11

缩放某个纹理也是我们常见的。

缩放

如果你想放大/缩小图像，可以设置参数scale。因为这个参数是一个Vector2，你可以对图像的水平方向和竖直方向施加不同的缩放值。例如，设置为(0.5f, 2.0f)将会使宽度变为原始宽度的一半，高度变为原始高度的2倍。如图2-12：

图2-12

其他还有

镜像
参数effects让你可以水平或竖直翻转图像。通过flags，你可以使用SpriteEffects.FlipHorizontally|SpriteEffects.FlipVertically同时进行这两个操作，这和将图像旋转180度的效果是相同的。

层深度
最后一个参数layerDepth让你可以指定图像位于哪个层，当你想将多个图像在有重叠时层的概念是很有用的。
需要注意的是
1.  layerDepth是一个介于0.0-1.0之间的float值，一般默认为0.0，如果是0.0那么就指定系统最后绘制，如果是1.0那么指定系统最先绘制。通俗的来讲，layerDepth值越小就越在其他纹理上面。
2.   需要使用spriteBatch.Begin的一个重载函数:
          SpriteBatch.Begin(SpriteSortMode.BackToFront,BlendState.AlphaBlend);

2.2        使用ScreenManager管理游戏场景
    在一个稍微复杂的游戏里，我们都需要用到场景来处理。什么是场景，简单的来讲，比如一个过关游戏，第一关就是一个场景，第二关就是另外一个场景。每个场景里有不过的背景图片，不同的精灵角色，有不同的关卡设计。场景里的资源如何展示，从一个场景到另一个场景如何切换,这些我们需要写一个专门的类ScreenManager来处理。
微软WP7开发者官方网站http://create.msdn.com上就有XNA的小游戏示例代码，里面就有这样的ScreenManager类，下面我们来简要分析下这个类，为后面我们设计游戏菜单打下基础。我省掉了中间的一些代码，大家可以看函数来理解这个类的作用。
namespace WPGame2D.Screens
{
    /// <summary>
///画面管理类，负责管理多个画面
/// </summary>
    public class ScreenManager : DrawableGameComponent
    {
        public Camera2D Camera;
        public ContentManager ContentManager;
        /// <summary>
        ///所有用到的文字资源
        /// </summary>
        public SpriteFonts SpriteFonts;
        ……..
        private List<GameScreen> screens = new List<GameScreen>();
        private List<GameScreen> screensToUpdate = new List<GameScreen>();
        private SpriteBatch spriteBatch;
        ……..
        /// <summary>
        ///构造函数
        /// </summary>
        public ScreenManager(Game game)
            : base(game)
        {
            TouchPanel.EnabledGestures = GestureType.None;
            ContentManager = game.Content;
            ContentManager.RootDirectory = "Content";
        }
        /// <summary>
        ///游戏通用默认SpriteBatch对象。每个场景都同享它,缓存了每个场景所用到的文件资源
        /// <summary>
        public SpriteBatch SpriteBatch
        {
            get { return spriteBatch; }
        }
        /// <summary>
        ///初始化ContentManager对象
        /// </summary>
        public override void Initialize()
        {
            SpriteFonts = new SpriteFonts(ContentManager);
            base.Initialize();
            isInitialized = true;
        }
        public void ResetTargets()
        {
            transitions.Clear();
        }
        /// <summary>
        ///加载游戏资源
        /// </summary>
        protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(GraphicsDevice);
            blankTexture = ContentManager.Load<Texture2D>("Common/blank");
            Camera = new Camera2D(GraphicsDevice);
            // 让每个场景加载所用的资源
            foreach (GameScreen screen in screens)
            {
                screen.LoadContent();
           }
        }
        /// <summary>
        /// 卸载所用的游戏资源
        /// </summary>
        protected override void UnloadContent()
        {
            foreach (GameScreen screen in screens)
            {
                screen.UnloadContent();
            }
        }
        /// <summary>
        /// 让每个场景执行update操作,执行游戏逻辑-
        /// </summary>
        public override void Update(GameTime gameTime)
        {
            input.Update();
            Camera.Update();
            screensToUpdate.Clear();
            foreach (GameScreen screen in screens)
                screensToUpdate.Add(screen);
           ………..
        }
        /// <summary>
        ///开始渲染每个场景
        /// </summary>
        public override void Draw(GameTime gameTime)
        {
            int transitionCount = 0;
            foreach (GameScreen screen in screens)
            {
              ……..
             screen.Draw(gameTime);
              …….
            }
           ……..
        }
        /// <summary>
        /// 添加一个新的场景到管理器中
        /// </summary>
        public void AddScreen(GameScreen screen, PlayerIndex? controllingPlayer)
        {
            …….
            if (isInitialized)
            {
                screen.LoadContent();
            }
            screens.Add(screen);
           ……….
        }
        /// <summary>
        /// 移除指定的场景。不过通常调用GameScreen.ExitScreen来代替这个方法。这样比直接调用RemoveScreen好，中间有一个过渡过程。
        /// </summary>
        public void RemoveScreen(GameScreen screen)
        {
            if (isInitialized)
            {
                screen.UnloadContent();
            }
            ……..
        }
    }
}
   分析这个类，我们可以看到该类继承于DrawableGameComponent,   从字面意思我们就可以理解到这是一个在XNA里可绘制出来的组件的基类。我们把场景继承于这个类，是因为每一个Screen里的东西基本都是可绘制的。我们在这个类上按F12，可以看到类的结构如图2-13：
   图2-13
比如我们从一个场景到另一个场景，我们就可以用到RemoveScreen和AddScreen方法。
   需要注意的是，ScreenManager类里含有Draw方法是实现基类DrawableGameComponent里定义的方法。在这个方法里我们负责把场景里的元素绘制出来。
          ScreenManager类里还涉及到GameScreen类，我放到XNAGameSample2里提供给大家下载阅读，在下一章里，我们会介绍菜单的制作，配合2.3章节的ScreenManager类和GameScreen类实现点击菜单项就完成了不同游戏场景的切换。
           XNAGameSample2下载地址:/Files/wangergo/XNAGameSample2.rar

本文链接

如何在WP7上用XNA写2D游戏（二）

2011-10-15T11:53:00Z

准备写一系列XNA里设计2D游戏的文章，这是第一章。

1.XNA里的hello world

1.1创建XNA游戏开发项目

我们初学程序的时候，总是爱写一个hello world 来体验下。可以说写出hello world 是我们了解一个语言或者框架最简单的做法。那么我们如何在wp7(windows phone 7)里用xna游戏框架在屏幕输出hello world呢。

其实微软的开发工具对开发者而言是很友好的。我们打开vs2010 Express for Windows Phone,选择File->New Project菜单,新建项目XNAGameSample，如图1-1:

图1-1

于是我们看到如下图1-2这样的解决方案：

图1-2

对这个解决方案，在右侧的解决方案资源管理器（Solution Explorer）里我们可以看到两个项目:

XNAGameSample和XNAGameSampleContent.

在我们项目储存的硬盘上我们可以看到图1-3这样的目录结构：

图1-3

其中XNAGameSampleContent项目是我们用来管理游戏资源文件的项目，我们以后用到贴图，模型，声音等资源都会放在这里管理。

XNAGameSample是我们的主项目。

在XNAGameSample项目里我们开打game1.cs文件，这是游戏运行的主入口,如图1-4:

图1-4

在Game1.cs里面有Initialize,LoadContent,UnloadContent,Update,Draw五个方法。

那么这五个方法各自在游戏里起什么作用呢?在后面的章节里我们会了解到这五个方法各自的用途。

1.2 update 和draw

从函数命名上，我们可以猜测得到LoadContent是负责加载游戏资源的。Draw 是用来绘制游戏界面的。那么Update呢，从字面意思上我们可以看到是”更新”的意思，那么这个方法里更新什么呢?

举一个简单的游戏场景来说。如果我们绘制一个手拿盾牌的小兵，让他从手机屏幕的左边跑到右边，那么我们怎么做呢。

首先，我们会用LoadContent来加载这个小兵所使用到的所有贴图资源。然后用Draw 方法把贴图绘制到屏幕制定的位置。但是我们要求的是小兵是移动的，从左边跑到右边，在跑的过程中还涉及到帧动画的变化。那么这些问题我们都需要在Update里来处理。简单来说,我们需要在Update里改变小兵的坐标位置和变换所用到的贴图资源。

我们需要了解的是Update 和Draw 在游戏运行过程中是按一定时间间隔不停被调用的方法，这样我们才能看到连续的动画。用流程图我们可以这样来描述：

我们在WP7上写XNA游戏的时候，需要了解一个很重要的概念，就是刷新率是多少？通俗的说，1秒钟Draw和Update 被调用多少次。

只有弄清楚这个问题，我们才能控制2D游戏动画的播放速度。WP7里xna的刷新率默认为30fps.也就是说1秒钟Draw 和Update 要被调用30次。如图1-4，我们展开Game1函数，可以看到如下代码:

public Game1()

   {
   graphics = new GraphicsDeviceManager(this);
   Content.RootDirectory = "Content";
        // Frame rate is 30 fps by default for Windows Phone.
   TargetElapsedTime = TimeSpan.FromTicks(333333);
   }

其中有一段英文注释是"Frame rate is 30 fps by default for Windows Phone.",意思是Windows Phone 的默认FPS是30.

1.3 LoadContent 和 UnloadContent

在1.2章节里我们已经简单介绍了LoadContent和UnloadContent的作用，如果我们需要在WP7里输出一段文字，我们就需要用到LoadContent了，在XNA里我们要经常接触到SpriteFont对象，这个对象是负责控制输出字体的，在XNA里字体的样式我们需要用一个XML文件来控制。如图1-5，我们在XNAGameSampleContent项目里创建一个新的文件夹“Fonts”,然后我们在XNAGameSampleContent项目里新建的Fonts文件夹上点击右键选择Add,然后选择New Item,再选择sprite font ，把Name改成default.spritefont,最后点击 add。

图1-5

然后，如图1-6，我们修改default.spritefont的内容为：

图1-6

做好了上面的准备工作,我们在Game1.cs里增加一个新的对象font,然后在LoadContent函数里添加如下代码:

font = Content.Load<SpriteFont>("Fonts/default");

如图1-7：

图1-7

接着在Draw函数里写下如下代码:

   spriteBatch.Begin();
   spriteBatch.DrawString(font, "Hello world", new Vector2(200,100), Color.Black);
   spriteBatch.End();

如图1-8：

图1-8

然后我们只需要在工具条的最右边选择"Window Phone 7 Emulator"按下F5,在模拟器模式下就能运行这个小小的demo了,如图1-9:

图1-9

那么我们怎么要在真机上调试呢？在下一章节我们就会讲到。

1.4调试和部署XNA项目

首先，我们需要装上Zune,我们的wp7手机也需要解锁。解锁需要我们拥有WP7开发者账号。注册地址：http://create.msdn.com/。如图1-10：

Tips:如果你有.edu的学生邮箱，又通过dreamSpark认证，就可以免去$99的年费。

图1-10

准备好这些后，我们用数据线连上WP7真机，如果WP7被识别，会自动启动Zune。如图1-11：

图1-11

然后我们在vs2010 Express for Windows Phone的工具条最右边选择"Windows Phone 7 Device"。再按F5。等几秒钟后，我们的项目编译后产生的XAP文件就被部署到真机里运行了。

demo源代码下载地址：/Files/wangergo/XNAGameSample1.rar

本文链接

如何在WP7上用XNA写2D游戏（一）

2011-08-17T03:25:00Z

游戏背景：

时间是欧洲中世纪，一位英雄坚守着他国家最后的城堡。一旦敌人攻破这个城堡，他的任务就失败了。这位英雄有着百步穿杨的本领，还有强大的魔法技能。虽然敌人发起了一波波潮水般的攻击，但他都顽强的击退了。

敌人不甘失败，派出了各种兵力，长矛兵，盾牌兵，骑兵，后来还调来投石车，空中的狮鹫骑士。敌人势要把这个城堡攻下，这位最后的英雄能守住城堡吗？

开发历程：

这个游戏我从过年开始构思，然后和美术方面的朋友沟通，本打算用XCODE写在Iphone上，后来发现自己XCODE游戏开发经验不是很足，并且App store上的游戏竞争激烈，类似的游戏也有了。于是我转到WP7平台上，用自己最拿手的C#来开发。

我花了2周左右的时间熟悉了XNA框架，本来想用Sliverlight写的，权衡了下，觉得在WP7上写游戏还是XNA正统。游戏原型出来，验证用手拉动弓箭来控制方向和力度能够实现后，我就开始正式写这个游戏。

期间，对于操作模式有两种打算，一种是用手拉，一种自动射击模式。用手来可以考验用户的操作性，但是时间长了，玩家就会觉得手很疲劳。于是我又写了自动射击模式，玩家只要手点到某个方向，就可以自动射击。在游戏正式发布时，我想提供这两种模式，提供给用户切换。

然后就是和朋友沟通游戏UI方面的问题，探讨兵种的动画设计，技能设计。

完成的功能有：

1.给城堡设置了血量，降到0就失败，城堡损伤效果会有动态效果。

2.写出了普通，火，冰箭的魔法飞行效果

3.模拟出了重力加速度下的飞行抛物线。

4.游戏的设置保存XML并储存，以及序列化和反序列化

5.选中技能图标的闪烁动画。

6.写完了多重，多重火，冰箭

7.给兵种添加了阴影效果

8.增加了技能CD效果

9.增加了技能树界面，新的技能需要金币来学习

开发心得：

CastleDefense 游戏开发到现在，基本完成核心的功能，但是游戏关卡的可玩性感觉还不够高，游戏难度需要精心调整。坦白的说，和国外团队游戏大作相比，自己写的游戏还是比较简陋。

不过，任何一个游戏和开发者都是需要成长的，就算暴雪也是从一个小工作室起步的。希望大家给出中肯的意见，欢迎拍砖和鼓励。

我也是在工作之余来开发的，时间精力的确有限。不管怎么样，我会继续完成这个游戏。

游戏玩法：

点击屏幕，让弓箭射向进攻的小兵。屏幕左下角是技能图标，可以点击选择技能，如果技能为红色，说明没有学习该技能，技能有CD限制。

屏幕下方中央齿轮按钮点击后出现技能学习界面，需要花金币来学习技能。

Tips: 投石车最怕火攻，体积大的兵种是BOSS，最好优先消灭，请使用冰冻箭降低它的速度。

游戏难度现在设定很高，我玩到第9关就手忙脚乱了，当然这个只是测试版，还需要做很大修正的。请大家多提意见，好来完善这个游戏。

游戏视频：

CastleDefense视频

游戏Demo下载XAP包地址:

微软APP HUB的Beta测试也在提交中，如果希望未来在Zune里下载到Beta测试版，请留下你的LiveID(也就是你的wp7手机关联的LiveID,也就是电子邮件地址).

本文链接

我的2010年

2010-12-25T09:25:00Z

今天不是圣诞节么？对我来说，是一个休息的好借口，项目组的成员都小小的身体不适过，的确比较辛苦，我这个月几乎天天迟到。一周三次更新版本让大家都神情紧张，精神不佳。我想如果办公室里有沙袋的话，我会天天胖揍它一顿。其实这个主意不错，买一个沙袋和拳击手套放到公司里，让大家不爽的时候出出气啥的。

好多同学也许要问，老师，你现在在做什么项目啊。说来话长，就从年初开始讲起吧。

1月份的时候，我到北京面试成功，职位是web game开发小组的 Team leader.薪水达到了我的预期。我决定离职，离开工作了3年多的北大青鸟。为了离职我准备了近一年的时候，一方面我对技术进行了储备，学了asp.net MVC,SL。另一方面我在考虑个人创业的可能。

离职的过程是友好的，我骨子里是一个不安分的人，当然生活的压力是重要的外因，性格是内因。2009年我的工作离我的预期有差距，我的目标是做高端点的培训的，不想再重复简单的东西。我个人不是一个有耐心的人，简而言之就是急性子。其实我的性格变化挺大的。在学校里，性子慢着呢，口头禅是：“慢慢来嘛”。等工作了，我就变了，时间，目标，预期是我看重的。

回武汉的旅途中还有个小插曲，一位副局长和我神侃后强要把我拉到他们那里帮他做一个项目。用软件行业的话来说，就是一位位高权重有决定权的客户和一位资深软件工程师兼培训讲师进过需求沟通后。客户对工程师的业务水平和相关开发经验很有信心，觉得他是完成这个潜在项目最佳人选。我的Demo和沟通让他知道了他需要做一个什么样的软件，大概功能是什么样的。说实在的他对数据的理解就是台账，权限设置也表述得太口语化。

结果呢，我本来没打算再做私活的，却中途下了火车，一顿吃吃喝喝后，副局长找来一位科长和我沟通需求，我于是在本本上记录了10几条需求作为备忘。

好了，第二天我就被司机送到回武汉的车上。不过晚回北大青鸟，让我去北京的行程暴露了。于是我迅速离职了，拜拜，兄弟们，我走了。

到北京后，项目启动的不顺利。人手，BOSS的规划似乎都没有一个明确的说法。我上半年就写了一个SL小游戏，做了公司的产品网站，弄了一个分布式文件系统，还用C++写起了手游的服务端。总之，是一个没有正式项目，没有正式成员的TL.

至到这个项目开始，我才回到正轨上。我的身份是WEB 前端开发的头，主要负责智能手机（Iphone,andriod）的web项目以及PC上的网站项目。目前的重点是手机上的LBS项目。

这个项目的难点是Javascript，html5,css3。当然权重最大的还是JS，我从来没写过前端是纯JS的项目，也就是说页面的呈现完全用JS来完成。至于技术上的心得以后再写。

可以透露下，QQ邮箱里的漂流瓶也许大家都玩过，不过我觉得和我们目前这个项目比起来，QQ的不好玩。一，QQ的地理位置不明确，从一般浏览器上用IP地址来定位很不准确的。二，QQ的漂流瓶用户互动不够，让人没有一直交流下去的欲望。三。QQ的漂流瓶可玩性不高。

我的未来工作还是继续完成项目的研发，在过年前把版本稳定到一个版本上。团队建设上，我还需要两个懂JS的C#开发人员，如果有同学对JS有较好的使用，对ASP.MVC有了解，一年以上工作经验，还能忍受我像曼联弗格森式“电吹风”样对你工作咆哮的话可以和我联系。当然啦，我不会为一点小失误就咆哮的，年轻人失误不可避免，但你要让我看到你工作的态度，别把生活上的事放到工作中，别刚下班就一阵烟就溜了。别在工作时打马虎，睡懒觉。这个团队需要有战斗力，对手太强大，敌人太狡猾，同志需要努力。

也许你要问这么辛苦干什么，为什么神马要赶进度。说实在的，让我高负荷工作我也会骂娘。骂归骂，把眼光放远点。互联网上成功的不少，失败的也很多。你占了先机，你才有那么一点话语权。虽说中国的局域网很扯淡，但是你一个小公司，一个小团队，落后了连扯淡的机会都没有。

其实我工作失误也有，主要在管理上。对未来面试人员的印象有点片面，纸上来之终觉浅。只看简历，有时会漏掉素质不错的人，虽然简历看上去不那么吸引人。所以同学们，别在简历上堆砌太多不能访问的网站，也不能放些太多雷同的项目。突出你的技术能力，项目经验，一定要写清楚。比如我看完30封简历，只会有一个还过得去的。神马22岁工作才一年的技术总监，搞网络的来投WEB开发。毕业时间和工作经历差太离谱的。在我这里就通过不了，没有面试机会。

在小组成员的代码Code View上做得不够，审核力度不够。对他们的任务分配不够有计划。对他们的技术指导也没规划。和他们的沟通不够多。

扯了这么多工作上的，也无趣的很。不过没办法，这个社会普通人都要工作，都想挣钱，都想有房有车。有时候你懂的，你月薪1,2千和1,2万的人比，你还很些差距。当你月薪几千元的时候，吃了喝了租房了，每个月所剩无几，不小心还月光了。一些投资机会你看着也没办法，你没法跑赢CPI的增长。

其实理财，说来很俗。我当年高傲的说：“钱乃身外物”，等若干年后，银行没存款，混得灰头土脸，年级一大把还飘来飘去。心爱的人被人用房子勾跑了你就知道：“咦，我是神马玩意。”像我这样的男人还真是一抓一大把。

我买过1万多的笔记本，现在贬值得只有千把块。我还被人偷了近5W块钱，其实这是因为目光短浅，只知道把钱放银行里，不知道不能把“鸡蛋放到一个篮子”里造成的。这都是年轻的代价。钱没了，大家就同情下。自己呢，打落牙齿往肚里咽，至于损失其实都不是钱上面的，都是机会上的损失。

大家都知道的，房价是越来越高，都说是泡沫，很疯狂。我当年也在08年乐观的认为，大家会理智的。等后来我就完全看明白了本质的原因。土地是国有的，Z F要弄钱，官员们要腐败，股市也很低迷，丈母娘也喜欢房子。于是房子就成了投资对象，跌，没神马东西不会跌的，没神马不可以涨的，当然工资除外。

于是我们就骂娘，骂开发商，骂女人只看中房子。女人为神马要看中房子啊，因为房子价值高，不好弄啊。女人归根结底是物质的，你要懂她们是为下一代考虑的，找个能提供比较丰厚物质养活她们的无可厚非。就像大家都喜欢找美女做老婆，找富翁做老公一样。从生物学角度上讲，这叫做基因的战争，大家都想求一个好的基因。可好的毕竟是少数，于是就有了竞争，于是就有了大家的逐利行为。于是就有了房子，车子的要求，本质上讲就是一个竞争门槛的问题。不说有句话么？能用钱解决的问题都不是问题，问题是没钱。所以，少年们，向着太阳奔跑吧。去努力工作，努力捞钱吧。

我承认我很俗，我教坏少年。不过勤奋向上一点总不是坏事。

于是我要忍受工作的辛苦，在住的地方忍受二手烟的熏陶，要每天耳朵里被重复得灌着同一首歌。谁让我08年没看好自己的财产，自己损失的东西只好自己奋起点弄回来。

6月份的时候，我就准备投资房子。这些都是我在过年的时候计划的，本来是5月份要做的。我当时对李果说：“明年房子在5月份不是大涨就是跌，我大概到5月份能有多少多少钱。”反正一副财迷的样子，没办法啊，过去过得太潇洒，是得吃苦头了。一番周折，在大家抢房子就像抢白菜一样交了定金。这个时候神马国几条出来啦，同事说你不怕跌吗。我当然怕啦，不过大学里不是学过马克主义经济学的么？价格总是由价值决定的，价格总会回归于价值。房子的价值不光是住，还跟户口神马的扯在一起就是隐性价值。光从一般价值来看，就我了解房子的建筑成本在小地方是800左右/平方。同时钢材，水泥还在涨价。如果房子的价格比1000元/平方高不了台离谱，那么我就不怕。

半年房奴也快做完了，的确有些压力，不过比起银行5%不到的，基金18%（这还是我在最低点时候的投资）的收益。房子让我把以前的经济损失补回来了。当然这个房子的命运估计会在适当的时候被我卖掉。不过也许我以后混得不好用来养老也说不准。

总之，2010就要告别的，我基本以经济建设为中心。来年，生活会好一点吧，让我开心点吧，能做成一点神马吧。家人都要好好的，朋友要常见面。工资要努力跑赢CPI，争取明年年底送自己一个大礼物。

本文链接

Silverlight MMORPG WebGame游戏设计(七)-----IsolatedStorage,想说爱你不容易

2010-05-26T14:52:00Z

在我开始写Web传奇的时候，就在想一个问题：如果我把所有的地图，怪物图片，音效等游戏资源都放在XAP包里，这个XAP包就会越来越大。在我很早以前玩传奇2的时候，安装包就300多M，后来传奇3就有1G多了。如果等我的web传奇越写越大的时候，那我的游戏需要loading多久啊，玩家可等不了。所以我把微软的文档找来，发现有独立储存区域这个东西，微软的解释如下：

通过使用独立存储，数据将始终按用户在虚拟文件系统中隔离，虚拟文件系统可以是根目录中的一个文件，也可以是一个目录和文件树。
独立存储数据舱是一个抽象的存储位置，而不是一个具体的存储位置。它由一个或多个独立的存储文件（称为存储区）组成，这些存储文件包含存储数据的实际目录位置。任何类型的数据都可以保存到存储区中。

于是我就有这样的设想：

1.把游戏所需的资源从服务端下载silverlight客户端的独立存储区域里。这样游戏客户端第一次下载完毕后，下次登陆就不用下载这些资源了，可以很快的进入游戏。

2.按每个地图分别做成不同的zip包，如果开新的地图只需要在服务端放上新的地图包，在客户端登陆的时候通知其下载就可以了。

3.xap包里的资源尽量少，除了必要的dll文件，其他都不放，这样我们就能把xap包控制在300K以内，客户端loading的速度就很快了。

根据微软的silverlight3文档，我写了一个独立存储区域资源读写类

/// <summary>
    /// 独立存储区域操作类 by williams
    /// </summary>
    internal class IsolatedStorageUtil
    {
        #region 私有成员
        IsolatedStorageFile store ;
        internal long availableFreeSpace;
        internal long totalSpace;
        #endregion

        #region 构造函数
        internal  IsolatedStorageUtil()
        {
            store = IsolatedStorageFile.GetUserStoreForSite();
            availableFreeSpace = store.AvailableFreeSpace;
            totalSpace = store.Quota;
        }
        #endregion

        #region 操作方法
        /// <summary>
        /// 增加新的空间
        /// </summary>
        /// <param name="spaceSize"></param>
        internal bool AddNewSpace(long spaceSize)
        {
           return store.IncreaseQuotaTo(spaceSize);
        }
        /// <summary>
        /// 得到独立存储区域里的目录
        /// </summary>
        /// <returns></returns>
        internal string[] GetDirectoryNames()
        {
            if (store != null)
            {
                return store.GetDirectoryNames();
            }
            else
            {
                return new string[] {""};
            }
        }
        /// <summary>
        /// 得到独立存储区域里的目录
        /// </summary>
        /// <param name="searchStr">可以使用?,*匹配符号</param>
        /// <returns></returns>
        internal string[] GetDirectoryNames(string searchStr)
        {
            if (store != null)
            {
                return store.GetDirectoryNames(searchStr);
            }
            else
            {
                return new string[] { "" };
            }
        }
        /// <summary>
        /// 检查文件夹是否存在
        /// </summary>
        /// <param name="directName"></param>
        /// <returns></returns>
        internal bool DirectorExist(string directName)
        {
            return store.DirectoryExists(directName);

        }
        /// <summary>
        /// 判断文件是否存在
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        internal bool FileExist(string filePath)
        {
            return store.FileExists(filePath);
        }
        /// <summary>
        /// 获取独立存储区域里的所有文件名
        /// </summary>
        /// <returns></returns>
        internal string[] GetFileNames()
        {
            if (store != null)
            {
                return store.GetFileNames();
            }
            else
            {
                return new string[] { "" };
            }
        }
        /// <summary>
        /// 在独立存储区域里新建目录
        /// </summary>
        /// <param name="DirectoryName"></param>
        /// <returns></returns>
        internal bool CreateDirectory(string DirectoryName)
        {
            if (store != null)
            {
                store.CreateDirectory(DirectoryName);
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 根据制定文件地址创建文件，如果路径不存在，则自动创建目录
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        internal IsolatedStorageFileStream CreateFile(string filePath)
        {
            if (store != null)
            {
              filePath =  filePath.Replace('\\','/');
                //设定文件夹只有两层,比如data/objects.zip
                if (filePath.Contains("/"))
                {
                    string diractory = filePath.Substring(0, filePath.IndexOf("/"));// 得到data
                    string filename = filePath.Substring(filePath.LastIndexOf("/") + 1);//得到filename
                    if (!DirectorExist(diractory))
                    {
                        CreateDirectory(diractory);
                    }
                }
               return store.CreateFile(filePath);
            }
            else
            {
                return null;
            }
        }
        /// <summary>
        /// 把制定内容写入到指定文件中
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="content"></param>
        /// <returns></returns>
        internal bool WriteToFile(string filePath,string content)
        {
            if (store.FileExists(filePath))
            {
                try
                {
                    using (StreamWriter sw =
                        new StreamWriter(store.OpenFile(filePath,
                            FileMode.Open, FileAccess.Write)))
                    {
                        sw.WriteLine(content);
                        return true;
                    }
                }
                catch (IsolatedStorageException ex)
                {
                    return false;

                }
            }
            else
            {
                return false;
            }

        }
        /// <summary>
        /// 把制定的流数据写入到指定数据中
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="fs"></param>
        /// <returns></returns>
        internal bool WriteToFile(string filePath, Stream fs)
        {
            if (store.FileExists(filePath))
            {
                try
                {
                    using (Stream sw =store.OpenFile(filePath,
                            FileMode.Open, FileAccess.Write))
                    {
                        Byte[] data = new byte[fs.Length];
                        fs.Read(data, 0, (int)fs.Length);
                        sw.Write(data, 0, (int)fs.Length);
                        sw.Flush();
                        sw.Close();
                        return true;
                    }
                }
                catch (IsolatedStorageException ex)
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 从指定文件中读取内容
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        internal string ReadContentFromFile(string filePath)
        {
            try
            {
                using (StreamReader reader =
                    new StreamReader(store.OpenFile(filePath,
                        FileMode.Open, FileAccess.Read)))
                {
                    string contents = reader.ReadToEnd();
                    return contents;
                }
            }
            catch (IsolatedStorageException)
            {
                return "";
            }

        }
        /// <summary>
        /// 读取指定文件的流
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        internal Stream ReadStreamFromFile(string filePath)
        {
           return  store.OpenFile(filePath, FileMode.Open, FileAccess.Read);
        }
        /// <summary>
        /// 删除指定的文件
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        internal bool DeleteFile(string filePath)
        {
            try
            {
                if (store.FileExists(filePath))
                {
                    store.DeleteFile(filePath);
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (IsolatedStorageException)
            {
                return false;
            }

        }
        /// <summary>
        /// 删除指定的目录
        /// </summary>
        /// <param name="dirDelete"></param>
        /// <returns></returns>
        internal bool DeleteDirectory(string dirDelete )
        {
            try
            {
                if (store.DirectoryExists(dirDelete))
                {
                    store.DeleteDirectory(dirDelete);
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (IsolatedStorageException ex)
            {
                return false;
            }
        }

        #endregion
    }

IsolatedStorageUtil类里的代码很简单，但在后面却非常频繁的使用到。写完了IsolatedStorageUtil类，大家就会问了，那服务端的文件如何如何下载到客户端呢？xap包是自动下载到内存，可是现在我们的资源没有放到xap包里，怎么办？

还是那句话，看微软的官方文档。什么？你说你从来没看过文档，那真可惜了，作为一个.net程序员，“红宝书”般的东西，不说倒背如流，遇到问题的时候翻翻，总能让你茅塞顿开。

我当时在群里大喊：“兄弟们，如果下载文件包到本地啊？”喊了几声，没人回答我。那时候我们群里用silverlight写比较大点的游戏的就5个人，深蓝，我，潮州人，开心银光，上海goods。深蓝写了非常有名的系列文章，潮州人写了SNS社区的游戏，开心银光写了“冒险岛”，上海goods写的就杂了：德州扑克，把深蓝的游戏改成网络版，我呢，就一门心思想把“传奇”搬到web上来。

没人回答我，是因为大家都是才跟随“深蓝”的脚步，踏入silverlight游戏开发的不毛之地，大家都是摸着石头过河，只能靠自己摸索了。

我见没人解答我的问题，想起“红宝书”，忙翻开一看，在“网络和通讯”章节里有一篇叫“按需下载”，这一定是我要的。我现在做的东西不就是“按需下载”么？

原来，从silverlight2后webclient取代了Downloader 地位，专门负责silverlight客户端的网络下载。文档里写的清清楚楚，明明白白，真是“众里寻他千百度，蓦然回首，却在灯火阑珊处。”

大家可以打开MSDN里的文章看看，不是“红宝书”是什么？

看完“红宝书”，我赶忙写出了DownloadHelper类，在这里我有个疑问，我想写一个批量下载多个文件的方法，效果却不是太好，连续下载的文件一多，文件的保存就有问题，有的文件保存失败，如果有谁能改进下这个类里的DownloadFilesByWhile()方法，不盛感激，现在我只用这个方法下载单个文件。

写完后，在测试过程收获还不小，如下：

  1.文件下载用webclient受服务器配置文件的限制，只能下载200M以内的，能不能下载还要受策略文件的影响。

   2.webclient异步下载返回的e.resault 转化成stream可以，不能强行转化为filestream

   3.把下载完成后的e.resault转化成stream后作保存操作时，结束的时候流不能关闭，和我们通常的操作不一样，所以这就是为什么我第一个文件能保存，后面不能保存的原因了。我猜测是这个流处于缓冲区里，关闭的话会清空缓冲区，导致后面下载的文件流也被清空。

   4.开单独线程下载，和界面线程通讯的话要用线程间通讯的post,或者get方法

   5.多文件下载要用循环，但是文件什么时候下载完是不确定的，又是异步的，所以要把下载线程阻止，在一个文件被下载完之前，当文件下载完毕后在解除阻止，进行循环的下一步。

DownloadHelper类：

/// <summary>
    /// 资源下载类，使用webclient, by williams
    /// </summary>
    internal class DownloadHelper:IDisposable
    {
        #region 私有成员
        IsolatedStorageUtil isu;
        private WebClient client;
        IGameCmd downloadEvent;
        private SynchronizationContext ui;
        private bool isThreadSingle=true;
        System.Threading.Thread t;
        private ManualResetEvent downloadDone = new ManualResetEvent(false);
        private String[] filePaths;
        private bool isDownLoadIng=false;
        private DownLoadTypeEnum type = DownLoadTypeEnum.Map;
        #endregion

        internal DownloadHelper(IGameCmd up)
        {
            isu = new IsolatedStorageUtil();
            client = new WebClient();
            client.AllowReadStreamBuffering = true;
            ui = System.Threading.SynchronizationContext.Current;
            downloadEvent = up;
        }
        /// <summary>
        /// 批量异步下载多个文件，效果需要验证
        /// </summary>
        /// <param name="filepaths"></param>
        internal void DownloadMultiFile(String[] filepaths,DownLoadTypeEnum type)
        {
            filePaths = filepaths;
            t = new Thread(DownloadFilesByWhile);
            t.IsBackground = true;
            t.Start();
            isThreadSingle = false;
            this.type = type;
        }
        private void DownloadFilesByWhile()
        {
            foreach (string filePath in filePaths)
            {
                if (isu.FileExist(filePath))
                {
                    continue;
                }
                if (!client.IsBusy)
                {

                    downloadDone.Reset();
                    client.DownloadProgressChanged += new DownloadProgressChangedEventHandler(client_DownloadProgressChanged);
                    client.OpenReadCompleted += new OpenReadCompletedEventHandler(client_OpenReadCompleted);
                    client.OpenReadAsync(new Uri(filePath, UriKind.Relative), filePath);
                    downloadDone.WaitOne();
                }

            }

            byte type =Convert.ToByte(GameCmdEnums.GetFileOk);
            byte flag = Convert.ToByte(this.type);
            byte[] content = System.Text.UTF8Encoding.UTF8.GetBytes("文件全部获取完毕");
           ui.Post(downloadEvent.DownloadFilesComplete, new Message { Class=type, Flag=flag, Content=content, Size=content.Length });
        }
        /// <summary>
        /// 下载指定文件
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        internal bool DownloadFile(string filePath)
        {
            if (!string.IsNullOrEmpty(filePath))
            {
                    if (!client.IsBusy)
                    {
                        client.DownloadProgressChanged += new DownloadProgressChangedEventHandler(client_DownloadProgressChanged);
                        client.OpenReadCompleted += new OpenReadCompletedEventHandler(client_OpenReadCompleted);
                        client.OpenReadAsync(new Uri(filePath, UriKind.Relative), filePath);
                        return true;
                    }
                    else
                    {
                        return false;
                    }
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 下载进度发生变化时
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void client_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)
        {
                string mess = "下载:" + e.UserState.ToString() + "中... " + e.ProgressPercentage.ToString() + "%";
                if (e.ProgressPercentage == 100)
                {
                    mess = "下载:" + e.UserState.ToString() + "完成";
                }
                ui.Post(downloadEvent.DownloadProgressChange, mess);
        }

      /// <summary>
      /// 文件下载完成后，储存进独立存储区域
      /// </summary>
      /// <param name="sender"></param>
      /// <param name="e"></param>
        void client_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
        {
            Stream fs = e.Result as Stream;
            if (fs != null)
            {
                long filezise = fs.Length;

                ui.Post(downloadEvent.DownloadComplete, e);
                if (filezise < isu.availableFreeSpace)//独立存储区域的初始大小是1M
                {
                    SaveInIsolatedSpace(fs, e.UserState.ToString());
                }
                else
                {
                    ui.Post(this.downloadEvent.DownloadError, "存储空间不够");
                }
            }
            else
            {
                ui.Post(this.downloadEvent.DownloadError, "文件读取失败");
            }
            if (!isThreadSingle)
            {
                downloadDone.Set();
            }

        }
        /// <summary>
        /// 把文件存入独立储存区里
        /// </summary>
        /// <param name="fs"></param>
        /// <param name="filename"></param>
        void SaveInIsolatedSpace(Stream fs, string filename)
        {
            try
            {
                if (!isu.FileExist(filename))
                {
                    Stream newfs = isu.CreateFile(filename);//事先把地图文件名存储在 e 里。
                    newfs.Close();
                }
                isu.WriteToFile(filename, fs);

            }
             catch(IsolatedStorageException ex)
            {

                 ui.Post(downloadEvent.DownloadError,"文件保存失败");
            }
            catch
            {
                ui.Post(downloadEvent.DownloadError, "文件保存失败");
            }

        }

        #region IDisposable 成员

        public void Dispose()
        {
            if (t != null)
            {
                t.Abort();
            }
        }

        #endregion

在游戏里的运行效果如图：

不过让我不爽的是：微软为了安全的原因，增加独立存储区域的时候，非要用户点下确定按钮，这样给用户体验不太好，为什么不能向flash game那样，直接就下载下来呢？

还有一个让我也不爽的是：从独立存储区域存放的zip文件里读取资源的时候，明显感觉速度慢，导致游戏人物播放帧动画的时候很卡，我只好在游戏开始前把资源预先加载到内存里。这个问题群里的nowpaper也说读取速度慢。

基于以上两点，我觉得这让独立存储区域成了有点“鸡肋”般东西，如果微软能改进下，那么用silverlight开发大型MMorpg游戏还是不错的选择。

IsolatedStorage,想说爱你不容易！

本文链接

Silverlight MMORPG WebGame游戏设计(六)-----Server和Client的婚后协议[附上完整15M游戏DEMO]

2010-05-08T17:14:00Z

上回说到Server少爷和Client小姐好不容易踏入婚姻的殿堂，洞房花烛之夜，Client小姐却要Server少爷签下婚后协议。Server一脸不快：“都一家人还签什么协议啊？”Client道：“你们男人啊，就是花心，不看紧点，不知道跑那野去了。为了以后我们能琴瑟相合，还是签了协议的好。”Server呵呵一笑：“好老婆，那就签吧，你开心的时候，我就陪你开心；你不开心的时候，我会哄你开心...”一番话哄得Client心花怒放，看着Server写完“奴隶宣言”，拿到手里仔细查看，却见Server写到:

  public enum WifeCmd
  {
         哄老婆开心，
         上交工资，
         陪老婆逛街，
         带老婆去兜风
         ......
  }

Client看到这里，笑颜如花，连enum都用上了，真是个好夫君，这美满的婚姻也真是来之不易。

-----------------------------------------------分割线，以上Server和Client的爱情剧完美剧终---------------------------------

前五章，我们用讲故事的方式把Server端和Client的通讯机制讲解了下。此后我们要在此基础上开始我们的Web传奇的开发之路，让我们感谢Server和Client的精彩演出。

每一个玩过传奇的人都记得那古朴的登录画面，当我们输入账号和密码，点击登录，随着铿锵的击鼓声，一扇石门徐徐而开，一个游戏的世界在向我们召唤，让我们赶快开启我们的传奇之旅吧！！

游戏的开始，我们需要注册账号。这账号数据放在那里呢？放客户端，显然不可能，用户数据太不安全了。只好放服务端了，再说用户账号数据可是很重要，那些网游公司为此争得头破血流。经典的案例那是网易从九城夺取“魔兽世界”的代理权，期间坎坎坷坷，勾心斗角，俨然一部商业大片。还是“魔兽世界”的开发公司暴雪大神有远见，所有的用户数据都是属于暴雪的，这500W用户账号是属于暴雪公司的，数据库里的这些数据早就在停服前被暴雪的技术人员备份走了。

所以说我们做Web传奇也要有远见，这个账号信息呢，还是归我williams所有吧，我把它们都储存在Sql Server2005数据库里呢。

一张简单的账号表如下:

账号信息表 Users
字段名称	数据类型	含义	约束
UserID	int
UEmail	Nvarchar(32)
Upwd	Nvarchar(16)
UaddTime	DateTime
Ubalance	int	用户账号金额，用来消费
UloginTime	DateTime
UloginIP	Nvarchar(32)
Ustate	int	账号状态

看到这里,你们会说这咋个和做网站的差不多呀？反正也不用忽悠大家，WebGame上的注册和网站注册有啥区别呢？本质上没什么区别，不就是把用户输入数据写到数据库里。

用asp.net做过网站的都知道，做一个注册页面很简单，双击按钮写事件，调用BLL层的方法，执行insert语句就OK。但是在silverlight里，客户端不能直接和数据库打交道，怎么办呢?

如果你看了前五章，你很容易想到客户端可以把用户数据放到byte[]数组里，封装到一个Message里发给服务端就可以了。服务端收到这个Message，判定后再调用BLL层的方法执行Insert语句也就可以了。和asp.net网站不同的是，在silverlight WebGame里数据是从Silverlight客户端发送到服务端，而在网站里数据是通过表单提交到Web服务端，asp.nett网站表单提交数据的过程作一个asp.net程序员可以不关心是怎么传递的，但是对于silverlight客户端来说，由于选用了原生态的Socket的通讯方式，我们得了解清楚些。

看到这里，你可能豁然开朗，前五章讲的那肉麻的爱情故事就是为了方便的传递数据啊。哎，谁让我们这些asp.net程序员比较少接触到Socket通讯方式呢，我也是花了一周才看个明白点。

罗嗦了这么多，让我们开始设计界面吧，我这个人很喜欢怀旧的，也没有美术功底，就把传奇里的界面搬来了，我在这里特此声明：本教程只供学习研究，所有素材来自网络，请勿跨省，勿发律师函。

注册界面:

我们先来完成注册界面的功能，玩一个游戏，如果不注册个账号，是没办法登陆进去的，玩过游戏的都知道。

void btnReg_Click(object sender, RoutedEventArgs e)
   {
            Users user = new Users { UserName = this.txtUserName.Text, Upwd =GameCMDFormat.HashFormat(this.txtPwd.Password), Uemail = this.txtUserName.Text, Ustate = 1 };
            MessagePool.AddSendMessage(GameCMDFormat.CreateNewUser(user));//把发送的消息放到消息队列里
     }

①这里我们用一个User对象来保存了用户注册数据，这样才显得OO一些。

②这里我们写了一个GameCMDFormat类来产生Message对象

   /// <summary>
        /// 新建账号命令
        /// </summary>
        /// <param name="user"></param>
        /// <returns></returns>
        internal static SocketClient.Message CreateNewUser(Users user)
        {
            return new SocketClient.Message(Convert.ToByte(GameCmdEnums.CreateNewUser), 1, System.Text.UTF8Encoding.UTF8.GetBytes(SerializeUtil.Encoder<Users>(user)));
        }

让我重点来介绍下这个GameCMDFormat类，以后我们的命令基本上都是这个类帮我们产生的。

在构造返回的Message对象时，第一个参数是class参数，我们用来存放命令的类型，这里我们用到的就是enum,这就是我们的server少爷和client小姐签婚后协议用到的。女人都喜欢男人专一点，enum值是唯一的，刚好满足女人的要求。当然这协议嘛，男方女方手里都有一份才算有效。所以server端有这样的enum,client端也会有这样的enum

/// <summary>
    /// 客户端的请求,或服务器发给客户端的命令
    /// </summary>
    public enum GameCmdEnums
    {
        /// <summary>
        /// 注册新账号
        /// </summary>
        CreateNewUser,
    }
     /// <summary>
    /// 服务器执行结果
    /// </summary>
    public enum GameCmdResult
    {
       CreateUserTrue,
       CreateUserFalse,
    }

这协议一式两份，童叟无欺，大家都看得明白，无可非议，客户端端告诉服务端: CreateNewUser,服务端拿来相同的enum一比对，哦，原来是要我去建一个新账号，那好我就把新用户数据写入到数据库。写完了，服务端发送一个Message给客户端，这个Message带的命令是CreateUserTrue，客户端拿来enum一看，哦，账号建立成功了。

③这里我们用了SerializeUtil.Encoder<Users>(user)方法，这里用的是json序列化，为什么要用json序列化呢？你想啊，一个User对象，我怎么好放到byte[]数组里，这个比较难，不太好描述。如果你想想我们在.net里的序列化，我们可以把一个对象变成xml数据或者二进制流。

但是很多平常在.net framework里使用的序列化和反序列化帮助类（如System.Runtime.Serialization命名空间下的许多类和方法）在SilverLight下都不可使用了。谁让silverlight是个精简框架呢。

查下资料发现

Silverlight可以用序列化，但是不能直接使用，必须通过服务来调用，比如WCF和Web Service。

Silverlight 内置支持WCF的 DataContractSerializer 和 DataContractJsonSerializer 两种序列化方式，也可以用System.Xml.Serialization 里的 XmlSerializer 。

一般的过程是，通过服务提供序列化的对象，然后Silverlight调用服务获得这些对象。

请参考：Silverlight中的序列化

不过我们这里用的是socket,以上的方式不适合了，还有XML序列化的结果比json的数据量要大不少，为了减少通讯量，在描述同样数据的情况下我选择了json序列化，我在网上我找到了一个.net下的 json序列化组件:

Json.NET.

使用了里面的两个方法:

    /// <summary>
    /// 对象序列化和反序列化,Json序列化
    /// </summary>
    public class SerializeUtil
    {

        /// <summary>
        /// 序列化
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="data"></param>
        /// <returns></returns>
        public static string Encoder<T>(T data)
        {
            return JsonConvert.SerializeObject(data);
        }
        /// <summary>
        /// 反序列化
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="data"></param>
        /// <returns></returns>
        public static T Decoder<T>(string data)
        {
            return  JsonConvert.DeserializeObject<T>(data);
        }
    }

这样我们很方便把一个对象放变成string，再把string用 System.Text.UTF8Encoding.UTF8.GetBytes()方法变成byte[]存放到一个Message对象就可以了。

④我们用到了自己写的消息队列类MessagePool类里的AddSendMessage方法。

至于为什么要用队列来储存发送的消息，这是由于MMorpg客户端和服务端交换数据很频繁，大量的数据如果拥塞在一起发送就不太好，你说我们中国人就是多，春节买火车票如果我们不排队，都挤到售票窗口去抢，那不乱了套么？

在MessagePool类里，我用了多线程发送，这里就涉及到了队列queue<T>的线程不安全问题，如何保证线程安全，就要用到了lock锁定,至于是否会影响效率，JeffreyZhao在一篇文章里说，也许lock的影响微乎其微，我没有做实验来判定，有兴趣的同学检验下。

可能对于一些.net初学者来说在多个线程中保证queue<T>的线程安全不太好理解，那就多查查资料吧，我也是查资料，花了些时间写好的。

当然，客户端发送数据的同时，也是要接受数据的，所以MessagePool类里有发送队列也有接受队列。

对于MessagePool类我这里就不多讲了，留着专门一节再讲消息队列。我们本节的重点是要完成注册的过程。

以上四点只是为了说明我们要把一个Message对象组装起来放到消息队列里中间的过程也不简单，涉及到队列，序列化，线程安全，做游戏不容易，反正我觉得比做网站要难一些。

好了，我们折腾了这么久，那么服务端接收到这个客户端发送的这个消息后会这么做呢?

   /// <summary>
        /// 执行客户端发送来的请求
        /// </summary>
        /// <param name="cmdstr"></param>
       internal static Message ExcuteCmd(int type, int flag, string cmdstr,System.Net.Sockets.Socket clientSocket)
       {
           GameServerCmd cmd = new GameServerCmd();
           GameCmdEnums t = (GameCmdEnums)Enum.Parse(typeof(GameCmdEnums), type.ToString());
           byte[] content = UTF8Encoding.UTF8.GetBytes(".");
           switch (t)
           {

               case GameCmdEnums.CreateNewUser:
                   {
                       int userID = 0;
                       if (cmd.CreateNewUser(cmdstr))//执行注册命令
                       {
                           return new Message((byte)GameCmdResult.CreateUserTrue, (byte)userID, content, clientSocket);
                       }
                       else
                       {
                           return new Message((byte)GameCmdResult.CreateUserFalse, (byte)userID, content, clientSocket);
                       }
                   }

               }

GameServerCmd 这是个命令执行类，它调用了BLL层里的方法。

  /// <summary>
        /// 注册新账号
        /// </summary>
        /// <param name="cmdstr"></param>
        /// <returns></returns>
        internal bool CreateNewUser(string cmdstr)
        {
            Users user = SerializeUtil.Decoder<Users>(cmdstr);
            if (UsersCtrlBase.Instance().CreateNewUser(user))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

写入账号信息到数据库后，然后发送一个注册成功的Message对象，我们也把它装到服务端的消息队列里等待发送给客户端，在服务端同理我们也有接收队列和发送队列，服务端接收和发送的队列是客户端的N倍，你可以近似估计N为客户端的个数，如果一个服1000人，那么就至少是1000倍于客户端。不开多线程，服务端估计是不能快速处理完这些数据。写到这里我想到，现在服务端早就是多核了，是不是要在服务端要到多核编程呢？把服务端多核优势发挥出来。这就留给大家去实现吧，我也是要花些时间研究下多核编程的。

不小心写了这么多，我喜欢写游戏，去年我下班后吃完饭就写Web传奇，中间遇到不少的困难，一路摸索，是梦想支撑着我，前方困难重重，我们只有披荆斩棘，努力前行。

我说过这篇文章里，我要把Demo提供给大家，由于持续花了近3个月的业余时间，写的代码有点多，从创建人物到下载数据，保存数据，合成地图，人物，怪物，再到即时的PK，中途还写WPF的地图编辑器，一下子把这些东西都发出来，估计看得也是头痛。我就一步步把这些代码精简出来吧。

下载文件列表:

1.数据库设计文档 2.json.net组件

3.MyMirWebGameDemo1

4.MyMirWebGameDB.

5.怪物数据包（重要：请放在MyMirWebGame.Web项目的clientbin里的Data文件夹下）

有兄弟反应MyMirWebGameDemo1无法下载，我做了分包文件。

MyMirWebGameVS2010D.part1

MyMirWebGameVS2010D.part2

MyMirWebGameVS2010D.part3

MyMirWebGameVS2010D.part4

Demo框架机构图：

Demo运行提示:

1.附加MyMirGameDB数据库

2.修改MyMirGameServer里的app.config里的connectstring数据库连接字符串

3.启动MyMirGameServer项目里bin/debug里的MyMirGameServer.exe程序

4.在IIS里hostMyMirWebGame.web站点。

5.账号 w,密码1;账号xiangwei,密码:1,当然也可以注册账号

6.游戏只实现了男战士职业，只完成了物理PK过程

7.只做了人物之间的PK互动，人与怪物间的PK互动还没写完。

Demo的客户端已经升级到SL4，建议使用vs2010,并下载 Silverlight 4 Tools RC2 for Visual Studio 2010.

Demo测试环境：win7+ms sqlserver2005+silverlight4;

局域网测试通过，感谢以前在武汉创美的同事们。

互联网测试通过，感谢"深蓝WPF/Silverlight(群号:73068105)"群里的兄弟们。

申明：Web传奇客户端代码是在“深蓝色右手”silverlight 游戏引擎基础上开发做了30%左右的变动，特此申明。

备注：代码文件已经上传，附上PK画面:

本文链接

Silverlight MMORPG WebGame游戏设计(五)-----Client的嫁妆

2010-05-03T05:25:00Z

新郎Server的房子装修好了，就看这边Client 的嫁妆准备如何了。Client小姐出身Silverlight名门，天生高傲较贵，只让给她服务的仆人使用TCP协议，UDP都不能考虑。

至于Client家的仆人做事，那是大家风范，全部使用"异步"方式。你看看他们的名字：一个是ConnectAsync,一个是SendAsync,还有一个是ReceiveAsync。另外还有两个打杂，负责关门看院的小厮：Shutdown和Close 。

你看看Client小姐所在的城堡，真是气派:

整日闷坐在城堡里的Client小姐听说Server少爷那边房子准备好了，就安奈不住芳心，想催问婚礼什么时候举行。

她忙叫来ConnectAsync，他主要负责和Server联络,

ConnectAsync让MessageStream马夫牵来socket宝马，坐上刻着SocketAsyncEventArgs字样的族徽的豪华马车，向Server家奔去。

socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//使用Tcp套接字
          stream = new MessageStream();//使用MessageStream消息辅助类
          SocketAsyncEventArgs args = new SocketAsyncEventArgs();
          args.RemoteEndPoint = new DnsEndPoint(SvIP, Sport);//设定和Server的通讯地址和端口
          args.Completed += new EventHandler<SocketAsyncEventArgs>(OnSocketConnectCompleted);//连接完成后做出OnSocketConnectCompleted报告。
          socket.ConnectAsync(args);//开始异步连接

等ConnectAsync从风尘仆仆得从Server家联络回来后，就向马不停蹄得向Client报告：“小姐，我已经禀报了Server少爷那边,就等那边回消息了。”Client一听，展颜一笑：“是么，快让ReceiveAsync准备笔墨，等公子那边的回复。”

ReceiveAsync一听，赶忙准备1024字节的纸张：

byte[] response = new byte[1024];
e.SetBuffer(response, 0, response.Length);

那厢ConnectAsync完成跑腿的任务，一边歇息去了：

e.Completed -= new EventHandler<SocketAsyncEventArgs>(OnSocketConnectCompleted);

就在Client翘首等待之际，少爷那边的仆人催快马已到，高声通报：“少爷那边来消息了。”，Client一听,忙让MessageStream读取私人密信。上次我们说过，Server少爷和Client小姐比较注意隐私，不用String类型的明文信件，用的是byte字节，这解读密信的差事就交给MessageStream去做了：

this.stream.Write(e.Buffer, e.Offset, e.BytesTransferred);
Message message;
while (stream.Read(out message))
{
//记下message内容

}

MessageStream不费吹灰之力读完密信，放到Message盒子里双手呈给了Client小姐。

Client小姐接过Message盒子，看完信件：

8月11日,此乃良辰吉日，愿于卿结秦晋之好

your lover:Server

Client心中石头终于落地，忙叫来SendAsync仆人：“快回Server少爷，万事具备，只盼佳期”。

SendAsync也开心领命：“小姐，我这就去办!”,他也让MessageStream领来Socket宝马，套上刻着SocketAsyncEventArgs字样族徽的豪华马车，立马启程，当然身上还是带着 Message盒子,Client小姐回复的信件放在里面。

SocketAsyncEventArgs myMsg = new SocketAsyncEventArgs();
myMsg.RemoteEndPoint = socket.RemoteEndPoint;
Message message = msg;
byte[] buffer = message.ToBytes();
myMsg.SetBuffer(buffer, 0, buffer.Length);
socket.SendAsync(myMsg);

至此繁琐的婚前准备终于完成，婚礼只待良辰吉日，Server少爷和Client小姐的未来婚后生活是否完美呢？

请看下一篇文章：

Silverlight MMORPG WebGame游戏设计(六)-----Server和Client的婚后协议

本文链接

博客园_wangergo

写在"CastleDefense"上市1周月之际

如何在WP7上用XNA写2D游戏（五）

如何在WP7上用XNA写2D游戏（四）

如何在WP7上用XNA写2D游戏（三）

镜像参数effects让你可以水平或竖直翻转图像。通过flags，你可以使用SpriteEffects.FlipHorizontally|SpriteEffects.FlipVertically同时进行这两个操作，这和将图像旋转180度的效果是相同的。

如何在WP7上用XNA写2D游戏（二）

如何在WP7上用XNA写2D游戏（一）

我的2010年

Silverlight MMORPG WebGame游戏设计(七)-----IsolatedStorage,想说爱你不容易

Silverlight MMORPG WebGame游戏设计(六)-----Server和Client的婚后协议[附上完整15M游戏DEMO]

Silverlight MMORPG WebGame游戏设计(五)-----Client的嫁妆

镜像
参数effects让你可以水平或竖直翻转图像。通过flags，你可以使用SpriteEffects.FlipHorizontally|SpriteEffects.FlipVertically同时进行这两个操作，这和将图像旋转180度的效果是相同的。