博客园-深蓝色右手

Silverlight游戏研发手记：(五)SLG动感增效之《幻影粒子》

Thu, 19 Jan 2012 18:49:00 +0800

随着电子技术发展与普及，人们使用电脑时间越来越长，由于人类自身身体比如眩晕症、眼球衰老等客观因素存在，未来玩家会更加倾向于低视疲劳度/低神经刺激的绿色健康休闲2D游戏而非3D。《希魔复活》2D/3D双版本发售后截然不同的反响再一次向印证了2D游戏是永远不会被3D取代的，甚至超越！当然，超越的关键便在于游戏的动态细节处理与把握，这是一种历史必然的进化而非简单回归。

如果说过去，因为计算机的性能瓶颈开发不出高画质、华丽的SLG游戏；但今天，足够的条件让这一切成为现实：Silverlight + 《幻影粒子》，我们正全力打造下一代动感十足之SLG。

还在为游戏中华丽的魔法特技而流口水吗？

其实这一切效果包括阳光、雨滴、瀑布、火焰、爆炸、烟雾、涟漪、魔法等等，我们都可以通过一款名为《幻影粒子》的工具轻松制作：

《幻影粒子》是一款专业级的2D动画特效制作软件(自带有庞大的粒子特效库，官方定期更新，且网上也可以找到很多第三方发布的特效库)，绝对是2D游戏锦上添花之利器，其做出来的粒子效果毫不逊色于3D。不夸张的说，甚至完全可以制作仿真级电影级特效。

没错，是它让我深刻感受到，动画已不再是美术的专利，《幻影粒子》让万能的游戏程序员神奇崛起！

当然，本人也仅仅是一名初学者，有兴趣深入学习的朋友可以在网上搜罗大量相关教程；对于大多数游戏开发者来说，以修改现成的案例作为入门，可以更好的了解该软件的整体使用流程和大致细节处理，掌握在如此庞大而现成的粒子效果库上进行修改和二次创作是性价比最高的使用方案。

那么就暂且班门弄斧一回，分享一下我为本系列教程SLG Demo添加几味特效的制作过程。

以上为一幅传统的RPG地图，对于老游戏来说，或许这样的效果已经很精致了；但是现在的多核电子设备迅猛如此迅猛，以至于为了不让性能白白浪费，我们完全可以在画面方面更进一步，让效果最大化。

如何让静止的烟囱冒出滚滚浓烟？如何让古老的宝箱闪闪发光？如何让失落的水井格外突出？

传说，森林中的每一口水井深处都隐藏着神秘宝藏，当它的主人出现时便会放射出耀眼的绿色光芒。那好吧，我们就先为这口水井添加一道绿光吧！

循着光的轨迹，我们打开《幻影粒子》：

在库面板上右键->快速载入粒子库，我们可以看到已经集成了十多款非常经典的的粒子特效库。

其中的“火花粒子”库中便有一款很有神秘感名为Star Trail 3的粒子特效：

播放后发现尺寸大了些且颜色也不对，必须得修改。于是我们双击打开它的“发射器属性”并对其局部细节及“缩放”和“粒子颜色”属性进行调整：

对比地图中水井的大致尺寸对整个项目进行缩放：

接下来在项目窗口正中间点击一下，便可将该特效放置于项目中：

点击绿色播放按钮，嘿嘿~闪耀的绿光出现啦~！

剩下的问题是，在Silverlight的游戏中如何使用它？当然，首先得将这个动画进行输出：

《幻影粒子》提供的输出格式还挺多的，经过本人一一测试，最终的结论是：只有AVI(无损)和PNG(有损)比较靠谱，分别对应电影特效和游戏特效应用领域。

对于Silverlight来说，毫无疑问，当然选择PNG。当然，特别需要注意的是尽量规避黑色的元素部件；因为《幻影粒子》导出的PNG并非无损，尤其是粒子效果中若掺杂有黑色像素，导出的图片相当糟糕：

OK，按照以上参数点击确定后，我们便可得到连续的120帧粒子动画PNG序列图片。实际上绝大多数2D游戏基本都用不上如此高的帧频，所以我们可以根据游戏的实际品质需求，截取中间部分，并间隔提取必要帧图，比如每间隔4提取一张便足以构建一个连贯循环的绿光动画，再以连续有规律的数字对它们进行命名：

最后，将这些图帧添加到游戏中并通过一个名为Animation的控件呈现出来。以同样的方法，我们在《幻影粒子》中也能找到现成类似的冒烟及闪光动画，将它们稍作修改后便可加入到游戏中烟囱和宝箱上面~哈，瞬间整个游戏生动了许多！

这是一款基于Silverlight的SLG游戏引擎的一部分，在线演示Demo如下(点击下载该Demo源码)：

手记思考：其实，最让人兴奋的莫过于通过《幻影粒子》制作出来的动画特效所有权完全属于制作者，制作者们再也不用担心版权问题(如此大量的变化参数，改动后的样式外观都会发生千变万化)，在它的辅助下进行Silverlight游戏开发真乃如鱼得水~高性能开发效率搭配高品质，这难道不是我们所有游戏开发者最梦寐的追求吗！

中游在线的《WOWO世界开源》，所有游戏厂商都开始在移动平台布局；随着多核手机将成为趋势，手机游戏中多量炫彩动画将不再成为性能问题。近期诺基亚宣布亚太总部将由新加坡迁至北京，这对于Windows Phone应用开发来说锦上添花！加油吧，开发者们！

本文链接

Google的Native Client微笑着抽了HTML5一记漂亮的耳光

Wed, 14 Dec 2011 19:40:00 +0800

日前，Google在加州总部的一次会议上首次公开演示了Native Client项目（简称“NaCl”），Google已经花了三年多时间研发此项目并表示未来的浏览器中将整合该技术，同时宣布Native Client即将起飞，开发者们准备好了吗？

Native Client究竟是啥东西？Google居然撇开HTML5释放如此妖怪，摘录相关介绍中的一段话：Native Client 简单来说就是一套让网络应用 / 软件开发者能够直接利用计算机中资源，而不需要间接透过浏览器来执行的开放原始码技术，技术上跟 ActiveX、Adobe 的 Alchemy 类似。

此文一出，众人纷纷表示那么它肯定是类似.net或者java之类的技术，Google在重新发明ActiveX/Flash。习惯了Google和各位跟班每天叫嚣着HTML5就是未来，就是上帝，就是如来；怎知却实在忍不住蹦出个Google版Flash - Native Client，着实让诸位HTML5崇拜者大跌眼镜：不是约定好了不玩插件了吗？不是说ActiveX是垃圾吗？我靠，又被断臂，你让HTML5崇拜者情何以堪？难道2012真是世界末日？

顺便引用Zipline Game首席执行官的话：“许多人都在谈论HTML5。但其中大多是虚假宣传。目前，我觉得它根本就是名不副实。”Hooper说道，“HTML5开发小组在各大发布会上吹得天花乱坠，但我们却没能见到游戏成品。实际情况是，大部分游戏开发者都不是HTML5程序员。而且，大部分游戏程序员都不愿意使用JavaScript。”

世界就是这样，微软的官僚作风让人难以接受，Google的无间道更让人云里雾里。

或许还是老人家说得对：成功，只青睐行动和事实，而非口舌之快者。Silverlight再好其本身也不会给你带来什么，HTML5目前更不可能带来什么，问下你自己的双手吧，它们给你带来了什么？

本文链接

Silverlight游戏研发手记：(四)SLG无限自由之过场动画

Mon, 05 Dec 2011 10:32:00 +0800

最初迷恋《火纹》，便是因为战斗时的场景切换（战斗特写）；《梦幻模拟战》、《高达》、《高级大战争》亦如是。特别喜欢这些电子公仔上演一幕幕华丽的战局，如果要说一款战棋类SLG的精髓在哪？毫无疑问：没有战斗特写的SLG永远无法成为经典与永恒。

战斗特写，即SLG中角色对战时对战斗场景的放大，让玩家身临其境的感受战斗的激烈与乐趣，细腻而畅快。

在游戏设计设方面，战斗特写无外乎是两个Scene的切换，一个隐藏，一个显示，这并不困难；而最华丽又最能吸引眼球的关键其实便是夹于其中的过场切换动画：

有的一扫而过，有的发散放大，有的肢离破碎，亦有渐隐渐现，旋转、波纹无不天马行空，成为每款SLG所独具韵味之地。

看似复杂的效果，其实我们只需借助一张纹路图片配以相应的HLSL解析便可完成。

乍一看，这些都是神马？3D地形材质？确实有些异曲同工之妙。通过HLSL编写对像素边缘的查找，再以动画形式处理其中的Progress参数，见证奇迹的时刻：

                transition.Visibility = Visibility.Visible;
                double progress = 0;
                //战斗
                transition.Source = Global.GetImage(string.Format("Battle/{0}.jpg", Global.RandomSeed.Next(5)));
                //实景
                ImageBrush real = new ImageBrush() { ImageSource = Screenshot() };
                //切换
                ImageBrush cutover = new ImageBrush() { ImageSource = Global.GetImage(string.Format("Transition/{0}.jpg", Convert.ToInt32(((ComboBoxItem)comboBox4.SelectedItem).Tag))) };
                switch (Convert.ToInt32(((ComboBoxItem)comboBox5.SelectedItem).Tag)) {
                    case 0:
                        effect = new Transition_RadialWiggle() { RandomSeed = 0, Texture2 = real, TextureMap = cutover };
                        progress = 100;
                        break;
                    case 1:
                        effect = new Transition_CloudReveal() { Texture2 = real, TextureMap = cutover };
                        progress = 50;
                        break;
                    case 2:
                        effect = new Transition_RotateCrumble() { RandomSeed = 0, Texture2 = real, TextureMap = cutover };
                        progress = 100;
                        break;
                    case 3:
                        effect = new Transition_Blood() { RandomSeed = 0, Texture2 = real, TextureMap = cutover };
                        progress = 100;
                        break;
                }
                transition.Effect = effect;
                Storyboard storyboard = new Storyboard();
                int easing = Convert.ToInt32(((ComboBoxItem)comboBox6.SelectedItem).Tag);
                storyboard.Children.Add(Global.CreateDoubleAnimation(effect, "Progress", 0, progress, TimeSpan.FromMilliseconds(slider1.Value), (easing == 2 ? null:new PowerEase() { EasingMode =  (EasingMode)easing })));
                storyboard.Completed += delegate {
                    Global.SetTimeout(delegate {
                        container.Visibility = Visibility.Visible;
                        storyboard = new Storyboard();
                        storyboard.Children.Add(Global.CreateDoubleAnimation(transition, "Opacity", 1, 0, TimeSpan.FromMilliseconds(600), new PowerEase() { EasingMode = EasingMode.EaseOut }));
                        storyboard.Completed += delegate {
                            transition.Opacity = 1;
                            transition.Visibility = Visibility.Collapsed;
                        };
                        storyboard.Begin();
                    }, 600);
                };
                storyboard.Begin();
            };

本节，我为大家准备了4种动画形式，并倾囊所出，为大家提供了近百张过场纹路素材，嘿嘿~无限自由拓展，你感动了吗？

这是一款基于Silverlight的SLG游戏引擎的一部分，在线演示Demo如下(点击下载该Demo源码)：

其实，将此类过场动画运用到Silverlight企业项目中，效果同样增色不少，用户体验大幅提升直接影响软件好评，何乐不为？

一切都快了，人们高节奏的生活习惯让复杂而缓慢的战棋SLG逐年衰退，虽然页游方面在努力弥补，但具有纯正血统战斗特写的几乎没有，这也是为什么至今我们这些电玩人依旧每天期盼着《火纹》新作。我不想用预防老年痴呆这个理由来挽救战棋SLG，在利益与理想面前，大家通常会选择背弃，突然有一天或许你发现，原来人生的意义并不仅仅是获取。

后妈Adobe断臂Flash和FLEX，HTML5除了帮你泡妞，带来任何金钱了吗？Silverlight 5 的3D性能突飞猛进，WP7的蓄势待发，强大的势力正在席卷全球，Silverlight 6 ! 一个必将改变世界的力量，今天的你，还在迷失吗？

本文链接

Silverlight游戏研发手记：(三)蜂窝拓扑结构在SLG地图布局中的应用

Mon, 17 Oct 2011 00:24:00 +0800

上一节给大家讲解了如何在四边形单元格基础上构建SLG地图场景，并实现移动、战斗的基础框架；热爱SLG的朋友一定非常清楚，绝大多数的SLG游戏地形单元格都可归为四类：四边四向、四边八向和四边六向、六边六向：

粗看，六边六向是其中构建最复杂的地形，它的称谓很多，比如六面网格、六边网格、晶体网格、蜂窝网格等等，不管叫什么，它总能给我们一种严谨而完美的直观印象。这种奇妙的感觉缘何而来？雪花、分子、螺帽、蜂巢、球网、芯片……在现实生活中，它的身影似乎无处不在。

困惑再一次升级：自然界为何偏偏热衷于复杂？网上的答复让人摸不着头脑，有朋友说六边形结构最省材，有的则说六边形结构最稳定，那难道三角形就不稳定了吗？有的朋友则又说，六边形最牢固且能耗最低，林林种种……

于是迫在眉睫的证据让我阅穿百页搜索，一篇《“天人合一”在六边形里》使我茅塞顿开：

基于空间填充原理：在一个平面中，只有正三角形、正四边形、正六边形三种图形可以完全填满平面，即不互相重叠，也不留下空隙。但是在这三种图形中，如果同样的周长，正六边形的面积最大。也就是说，六边形具有“完全填充”和“最具效率”的双重优势。同时亦遵循着自然界最普遍原理 - 最小作用量原理。

相当给力！

不过，高兴似乎还早了些，Hold住。难道所有的SLG游戏开发者仅仅都因为以上原因而在设计之初选择六边形单元格吗？毫无疑问，非也。游戏，若过分掺杂着教条主义则必将与娱乐背道而驰。要回答这个问题我们还得追溯到SLG游戏的发展史：

SLG游戏类型是最古老的游戏类型之一，其逻辑AI的复杂性也是所有游戏中最高的。在我的印象中，基于六向的SLG游戏最早见于红白机上的《大战略》：

游戏中采用了中庸的四边六向单元格，这样的地图布局起来比六边形构造更简单，但效果却一摸一样。日本厂商不乏类似的SLG大作，比如3D的《三国志11》依旧选择采用这种形式来布局地形：

当然，市面上六向的SLG游戏大多还是采用正统的六边形单元格，比如经典的《天使帝国》和《文明》：

到此，我们将以上四部作品与其他采用四边形单元格的SLG游戏相比较便会发现，基于四边形网格的地图具有局限性，从每个单元格的中心到相邻单元格的中心距离不尽相等,沿纵、横方向上相同,但不同于对角线方向上的距离，即对角线移动比直线移动更快，战略上讲这是非常不公平的；而使用六边形网格地图，其放射对称性原理（单元格中心到所有方向上的相邻单元格中心点的距离均相等）使得游戏更加真实与严谨，此类游戏尤其能体现单位与临接单位之间的绝对公平的相互作用关系。

综合以上分析得出：正六边形单元格是最饱满，且边、角交汇最省的单元格，加上前文所述完全填充且最具效率的双重优势，游戏中使用六向网格结构比传统四边形网格结构更具立体层次感，且比基于四边八向地形更能体现游戏的公平性，因此其构建的地图最贴近真实世界 - 地理路网拓扑系统。

云开见日，有了以上的理论依据，接下来我们便可将真实世界的地理路网映射到游戏中，抽象成基于六边形蜂窝拓扑结构的战略地图：

开始动手吧，打开上一节的Silverlight源码，我们首先要做的就是修改将游戏坐标转换成窗口像素位置的方法(GetPositionFromCoordinate())，这个算法怎么改？似乎还找不着头绪。按照上图布局，我们不妨先做个例枚举，然后通过分析找出其中规律所在。

不难看出，虽然每个单元格都拥有六方向，但它们的坐标同样基于二维的X,Y构成，大体看来，Y坐标是连续的，X坐标则是规律起伏的。接下来我们进一步明确，六边形地砖的铺设(拼接)是以左上角最大宽、高作处作为起点:

假设(0,0)单元格的窗口像素位置为(0,0)，那么(0,1)、(0,2)、(1,0)、(1,1)、(1,2)、(2,0)、(2,1)、(2,2)的像素坐标分别是多少？？

如上图，坐标为(0,0)的六边形单元格，其铺设位置起点为O点；坐标为(1,0)的六边形单元格，其铺设位置为M点；而坐标为(0,1)的六边形单元格，其铺设位置为N点，以此类推。于是，我们要分别得到O、M、N的像素位置，则必须知道正六边形的边长以及a、b的长度值：

假设正六边形地砖的边长为L，根据三角形内角和为180度，则六边形内角和为720度，那么正六边形每个角为120度，于是可以得到b与L的夹角为30度。根据三角函数公式可知L、a、b之间的转换公式如下：

a = L * Sin 30°

b = L * Cos30°

同时，我们分别对(0,0)至(2,2)这九个单元格进行枚举，会发现如下规律：

坐标(0,0) 对应的窗口像素位置为(0,0)

坐标(0,1) 对应的窗口像素位置为(0,2b)

坐标(0,2) 对应的窗口像素位置为(0,4b)

……

坐标(1,0) 对应的窗口像素位置为(a+L,b)

坐标(1,1) 对应的窗口像素位置为(a+L,2b+b)

坐标(1,2) 对应的窗口像素位置为(a+L,4b+b)

……

坐标(2,0) 对应的窗口像素位置为(2*(a+L),0)

坐标(2,1) 对应的窗口像素位置为(2*(a+L),2b)

坐标(2,2) 对应的窗口像素位置为(2*(a+L),4b)

……

依次类推

是不是开始有些激动了？其实重点就在于当坐标X为奇数时，Y多加一个b值。假如坐标为(X,Y)的六边形单元格，其所对应的窗口像素位置为(A,B)，则A=X*L*(1+Sin30)，B=(Y*2+X%2)*L*Cos30

最后转换成Silverlight编程语言，GetPositionFromCoordinate()方法修改如下：

        /// <summary>
        /// 获取窗口Canvas中的位置Position(通过空间坐标系中的坐标Coordinate换算而来)
        /// </summary>
        public Point GetPositionFromCoordinate(Point p) {
            double radian30 = 30 * Math.PI / 180;
            double x = p.X * GridSide * (1 + Math.Sin(radian30));
            double y = (p.Y * 2 + p.X % 2) * GridSide * Math.Cos(radian30);
            return TileType == TileTypes.Flat ? new Point(x, y) : new Point(y, x);
        }

如此大的周折也仅仅是完成了蜂窝拓扑结构地砖铺设而已，下一个任务便是修改角色的移动范围算法；有了前面详尽的分析，这道工序相对简单了很多。基于上一节四叉树遍历算法基础上我们进行如下修改：

        /// <summary>
        /// 六方遍历扫描
        /// </summary>
        Dictionary<Point2D, int> RangeScan(Dictionary<Point2D, int> tempList, Dictionary<Point2D, int> rangeList, int moveLimit) {
            Dictionary<Point2D, int> result = new Dictionary<Point2D, int>();
            for (int i = 0; i < tempList.Count; i++) {
                KeyValuePair<Point2D, int> kvp = tempList.ElementAt(i);
                DirectionScan(new Point2D(kvp.Key.X, kvp.Key.Y - 1), kvp.Value, result, rangeList, moveLimit);
                DirectionScan(new Point2D(kvp.Key.X + 1, kvp.Key.Y), kvp.Value, result, rangeList, moveLimit);
                DirectionScan(new Point2D(kvp.Key.X, kvp.Key.Y + 1), kvp.Value, result, rangeList, moveLimit);
                DirectionScan(new Point2D(kvp.Key.X - 1, kvp.Key.Y), kvp.Value, result, rangeList, moveLimit);
                if (kvp.Key.X % 2 == 0) {
                    DirectionScan(new Point2D(kvp.Key.X + 1, kvp.Key.Y - 1), kvp.Value, result, rangeList, moveLimit);
                    DirectionScan(new Point2D(kvp.Key.X - 1, kvp.Key.Y - 1), kvp.Value, result, rangeList, moveLimit);
                } else {
                    DirectionScan(new Point2D(kvp.Key.X - 1, kvp.Key.Y + 1), kvp.Value, result, rangeList, moveLimit);
                    DirectionScan(new Point2D(kvp.Key.X + 1, kvp.Key.Y + 1), kvp.Value, result, rangeList, moveLimit);
                }
            }
            return result;
        }

完了吗？还没，最关键的时刻到了，上一节的A*算法只能满足四向或八向寻路，如何实现六向寻路A*算法？重写一个？NO，其实我们只需对方向遍历模块进行修改，使之变成六向检索，且每个单元格的移动消耗设置一致即可：

以A*算法中的PathFinderFast为例，修为内容如下：

                    if (mLocationX % 2 == 0) { //六向
                        mDirection = new sbyte[6, 2] { { 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 }, { 1, -1 }, { -1, -1 } };
                    } else {
                        mDirection = new sbyte[6, 2] { { 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 }, { -1, 1 }, { 1, 1 } };
                    }
                    for (int i=0; i< 6; i++)
                    {
                        mNewLocationX = (ushort) (mLocationX + mDirection[i,0]);
                        mNewLocationY = (ushort) (mLocationY + mDirection[i,1]);

......

                        mNewG = mCalcGrid[mLocation].G + (int) (mGrid[mNewLocationX, mNewLocationY] * 2); //一致化
                        ......
                    }

终于大功告成。当然，SLG中蜂窝结构地图亦并非是十全十美的，其在移动及战斗(范围)方面的灵活性与趣味性表现相对较差。

比如，四边形地图可轻松实现十字斩，那么六边形地图呢？

同时，由于X坐标方向高低起伏，角色X方向的移动会显得特别别扭：

当然，我们是可以通过一些人性化设置来规避这些尴尬的。最经典的以《英雄无敌3》为例，计算好寻路后只需执行起点与终点之间的直线移动即可，而范围攻击则可使用六边形外接圆形式巧取而代之，等等。

非常值得一提的是，蜂窝拓扑结构基础单元格常用的除了平型(比如前文提到的《天使帝国》)，还有尖形(例如前文提到的《文明》)：

两者的互换只需对单元格素材进行30度旋转，同时在坐标转换时将X与Y的位置互换即可：

终于完工了。

这是一款基于Silverlight的SLG游戏引擎的一部分，在线演示Demo 如下(点击下载该Demo源码)：

手记小结：蜂窝拓扑结构在计算机网络概述中有详细讲解，其应用领域亦非常广泛；除游戏外，蜂窝拓扑结构在无线通信网络技术、图像显示，地理信息布局等领域都极具优势，非常值得大家深度研究。

一则令人兴奋的消息：微软应用商店(Marketplace)已向中国开发人员开放，同时种种迹象证实了微软正在研发下一代XBOX，是的，微软正将使用Silverlight开发新一代XBOX程序！有限的生命只需精通最完美的技术足以，或许我们是时候丢掉垃圾，对不需要的技术说“不”了。Let,s focus on Silverlight！Come on

本文链接

Silverlight游戏研发手记：(二)四叉树遍历与人工智能A*算法在SLG移动路径范围测算中的应用

Wed, 21 Sep 2011 17:28:00 +0800

除战斗范围设定外，说到SLG中最有趣而经典的算法莫过于角色可移动范围的测算与寻路。当前成熟的SLG商业游戏中，以《火焰纹章》、《高级大战争》等系列新作为代表，它们在传统的基础上将可移动范围进行了拓展，组合上攻击范围并配合移动指向路径箭头，使得整场战局每个“棋子”的操控感受和趣味性都无与伦比。

SLG角色移动从程序设计的角度可大致分为3个步骤：

1）呈现可移动路径范围

2）确定移动目的地单元格

3）沿着路径移动到目的地

以四向为基础的Silverlight 2D SLG游戏，我们首先想到的当然是采用四叉树遍历算法来实现其中的角色可移动路径范围测算。

不要被它的行头所吓到，其实它只是一种很简单的四向延展循环遍历，我们不妨先来看下图：

每个角色以其所处的格子(坐标)为中心，第一步可移动的格子只有：北、东、南、西；那么要测算其可移动范围，首先得分析周围这4个格子角色是否可以移动到，其中判断的依据有地形矩阵边界、机动力极限（或四叉树深度）以及地形机动力消耗等元素；如果判断为可行，则将此格子进行标记(存储进可移动范围List<Point>表中)；接下来再以同样的步骤，分别以这些被标记过的格子为中心，继续四向延伸遍历 (以减去当前单元格机动力消耗为基础)；额外的，此时除了判断是否可以移动外，还需判断子节点是否有效(List中是否存在重复，如果重复哪一个Path的机动力消耗最小则替换掉，Path是否回头等逻辑)。于是，最终我们可以得出类似如下算法：

        /// <summary>
        /// 显示可移动范围路径
        /// </summary>
        public void ShowPathRange(Sprite sprite) {
            sprite.PathRange.Clear();
            ClearAllRange();
            Dictionary<Point2D, int> rangeList = new Dictionary<Point2D, int>();
            Dictionary<Point2D, int> tempList = new Dictionary<Point2D, int>();
            Point2D center = new Point2D((int)sprite.Coordinate.X, (int)sprite.Coordinate.Y);
            rangeList.Add(center, 0);
            tempList.Add(center, 0);
            int countPoint = 0;
            while (countPoint < sprite.Mov) {
                tempList = RangeScan(tempList, rangeList, sprite.Mov);
                countPoint++;
            }
            //绘制所有格子
            for (int i = 0; i < rangeList.Count; i++) {
                Point p = rangeList.ElementAt(i).Key.ToPoint();
                sprite.PathRange.Add(p);
                EntityObject box = new EntityObject() {
                    Source = GetImage("MoveBox.png"),
                    Position = GetPositionFromCoordinate(p),
                };
                pathRangeSystem.Children.Add(box);
                MouseButtonEventHandler handler=null;
                box.MouseLeftButtonDown += handler = delegate {
                    box.MouseLeftButtonDown -= handler;
                    sprite.MoveTo(p, Matrix);
                };
            }
        }

        /// <summary>
        /// 四叉树遍历扫描
        /// </summary>
        Dictionary<Point2D, int> RangeScan(Dictionary<Point2D, int> tempList, Dictionary<Point2D, int> rangeList, int moveLimit) {
            Dictionary<Point2D, int> result = new Dictionary<Point2D, int>();
            for (int i = 0; i < tempList.Count; i++) {
                KeyValuePair<Point2D, int> kvp = tempList.ElementAt(i);
                DirectionScan(new Point2D(kvp.Key.X, kvp.Key.Y - 1), kvp.Value, result, rangeList, moveLimit); //北
                DirectionScan(new Point2D(kvp.Key.X + 1, kvp.Key.Y), kvp.Value, result, rangeList, moveLimit); //东
                DirectionScan(new Point2D(kvp.Key.X, kvp.Key.Y + 1), kvp.Value, result, rangeList, moveLimit); //南
                DirectionScan(new Point2D(kvp.Key.X - 1, kvp.Key.Y), kvp.Value, result, rangeList, moveLimit); //西
            }
            return result;
        }

        /// <summary>
        /// 基于方向的扫描
        /// </summary>
        void DirectionScan(Point2D direction, int matrix, Dictionary<Point2D, int> tempList, Dictionary<Point2D, int> range, int moveLimit) {
            if (!range.ContainsKey(direction) && IsEffectivelyCoordinate(direction) && Matrix[direction.X, direction.Y] != 0) {
                int value = matrix + Matrix[direction.X, direction.Y];
                if (value <= moveLimit) {
                    if (!tempList.ContainsKey(direction)) {
                        tempList.Add(direction, value);
                    } else if (value < tempList[direction]) { //各方向到达同一地点，只取最小机动力消耗
                        tempList[direction] = value;
                    }
                    if (!range.ContainsKey(direction)) {
                        range.Add(direction, value);
                    }

                }
            }
        }

        /// <summary>
        /// 坐标是否有效
        /// </summary>
        bool IsEffectivelyCoordinate(Point2D p) {
            return p.X >= 0 && p.Y >= 0 && p.X < dimension && p.Y < dimension ? true : false;
        }

顺便说明一下，SLG地形设计千变万化，本节中我仅仅设置了5种地形：障碍(无法通行)、平原/草地(机动力消耗1)、森林/丘陵 (机动力消耗2)、沙漠/沼泽(机动力消耗3)、山地(机动力消耗4)、河流(机动力消耗5)等，其枚举如下（对应的枚举值也是该地形的机动力消耗，当然实际情况要比这复杂，比如不同地形相同机动力消耗等）：

    /// <summary>
    /// 地形类型
    /// </summary>
    public enum TerrainTypes {
        /// <summary>
        /// 障碍
        /// </summary>
        Obstacle = 0,
        /// <summary>
        /// 平地
        /// </summary>
        Ground = 1,
        /// <summary>
        /// 森林
        /// </summary>
        Forest = 2,
        /// <summary>
        /// 沙漠
        /// </summary>
        Desert = 3,
        /// <summary>
        /// 雪地
        /// </summary>
        Snow = 4,
    }

当我们计算并呈现完角色可移动范围后，接下来玩家便需要指挥角色向目标位置移动，人工智能A*算法又一次的派上了用场；Silverlight中我们可以通过创建Storyboard关键帧动画的简单形式配合上A*算法得到的Path路径点轻松实现非对角线式的角色寻路移动（其中的A*代码为国外高人编写，可参考我曾写过的一篇文章，本文就不再班门弄斧了）。：

        /// <summary>
        /// A*寻路向目的地移动
        /// </summary>
        public void MoveTo(Point destination, byte[,] matrix) {
            PathFinderFast pathFinderFast = new PathFinderFast(matrix) {
                Diagonals = false,
                HeuristicEstimate = 2,
                SearchLimit = 1000,
            };
            List<PathFinderNode> path = pathFinderFast.FindPath(new Point2D() {
                X = (int)Coordinate.X,
                Y = (int)Coordinate.Y
            }, new Point2D() {
                X = (int)destination.X,
                Y = (int)destination.Y
            });
            if (path == null || path.Count < 1) {
                //路径不存在
                return;
            } else {
                PointAnimationUsingKeyFrames pointAnimationUsingKeyFrames = new PointAnimationUsingKeyFrames() {
                    Duration = new Duration(TimeSpan.FromMilliseconds((path.Count - 1) * speed))
                };
                Storyboard.SetTarget(pointAnimationUsingKeyFrames, this);
                Storyboard.SetTargetProperty(pointAnimationUsingKeyFrames, new PropertyPath("Coordinate"));
                //匀速关键帧
                for (int i = path.Count - 1; i >= 0; i--) {
                    pointAnimationUsingKeyFrames.KeyFrames.Add(
                        new LinearPointKeyFrame() {
                            KeyTime = KeyTime.FromTimeSpan(TimeSpan.FromMilliseconds((path.Count - 1 - i) * speed)),
                            Value = new Point(path[i].X, path[i].Y)
                        }
                    );
                }
                storyboard.Pause();
                storyboard.Completed -= storyboard_Completed;
                storyboard = new Storyboard();
                storyboard.Children.Add(pointAnimationUsingKeyFrames);
                storyboard.Completed += new EventHandler(storyboard_Completed);
                storyboard.Begin();
            }
        }

这是一款基于Silverlight的SLG游戏引擎的一部分，在线演示Demo 如下(点击下载该Demo源码)，大家不妨刷刷怪和地形，然后移动角色试试，非常有趣：

手记感悟：回想之前曾写过的一个三国策的SLG Demo，为了省事，当时写的移动范围算法其实是错误的；大量测试证明，SLG中的移动范围不能使用A*寻路算法替代，虽然看上去似乎减少了工作量，但实际操作过程中你会发现对可及范围所有格子都使用一次A*算法极其消耗性能；另外，就目前我所用到的A*算法来说，根本就无法正确显示角色的可移动范围(由于A*算法原理所致)，要么漏掉几格，要么多出几格，越是复杂且障碍物无规律的地形表现越突出。

手记小结：通过四叉树遍历算法可以很有趣的将SLG游戏角色可移动范围形象化、直观化，此算法的实现和优化无止尽，仁者见仁智者见智，期待您更优秀的实现，让思维的创新来得更猛烈些吧！

本文链接

Silverlight游戏研发手记：(一)差集运算在SLG战斗范围设定中的应用

Fri, 19 Aug 2011 23:50:00 +0800

战棋游戏通常指以回合制为基础，角色在地图上按格移动作战的游戏，好比下棋一样，该类型游戏更侧重于策略，节奏较缓慢，注重精美、绚丽的画面，考验的是玩家运筹全局的智慧。耳熟能详的比如《梦幻模拟战》、《火焰纹章》、《大战略》、《炎龙骑士团》、《幻世录》等经典。

战棋游戏占据了我太多记忆，每次看到类似的游戏都会激动不已，尤其是远距离攻击类型的弓箭手和魔法师，战局扭转往往就在一步之间。

今天，作为一名游戏开发者，当技术与思想逐步成熟，理想似乎已不再是那么的遥不可及。以SLG战棋游戏战斗范围为例，我们可以巧妙的通过集合运算来实现几乎所有你能想到的角色战斗范围设定。

动手前我们不妨先看一下《曹操传》中所有的战斗范围图例：

见到此类素材大家会否觉得实在亲切。没错，就是我们小时候读书最常玩的找规律数学题。

既然要找出规律，那么就得先分析出其中的共性与变化。最直接的共性便是所有的格子均是“对称”的；而发生变化的则是某些图例似乎都被“挖”去了一些；再往下想，这些被“挖”掉的格子同样也是“对称”的。由此，基于集合的差集运算第一时间浮现在脑海。

规律把握的是否正确离不开证明过程，接下来我们随便以上图中任意几个图例为例加以验证：

……

是不是开始有些激动了？

最后的总结：所有“对称”的战斗范围都可以是基于某种规律N格长度的范围与基于另一种规律M格长度范围的差集，其中这两种规律可以相同，N与M也可以相同。由此便可衍生出如文中开头所有的战斗范围，以及更多未列出来的。

有了以上强大的理论依据作为基础，接下来的编码便是手到擒来，我的思路大致如下。

第一步，定义最常用的基本规律（即连续的战斗范围类型）：

    /// <summary>
    /// 战斗范围类型
    /// </summary>
    public enum AttackRangeTypes {
        /// <summary>
        /// 无
        /// </summary>
        None = 0,
        /// <summary>
        /// 全八面(方形)
        /// </summary>
        Square = 1,
        /// <summary>
        /// 斜四面(菱形)
        /// </summary>
        Diamond = 2,
        /// <summary>
        /// 正四向(十字)
        /// </summary>
        Cross = 3,
        /// <summary>
        /// 斜四向(交叉)
        /// </summary>
        Oblique = 4,
    }

除None外，它们2长度范围分别对应以下图例：

第二步，以这些战斗范围(List<Point>)为返回值构造方法：

        List<Point> GetRange(Point center, AttackRangeTypes attackRangeType, int range) {
            List<Point> points = new List<Point>();
            for (int x = -range; x <= range; x++) {
                for (int y = -range; y <= range; y++) {
                    switch (attackRangeType) {
                        case AttackRangeTypes.None:
                            continue;
                        case AttackRangeTypes.Square:
                            break;
                        case AttackRangeTypes.Diamond:
                            if (Math.Abs(x) + Math.Abs(y) > range) { continue; }
                            break;
                        case AttackRangeTypes.Cross:
                            if (Math.Abs(x) != 0 && Math.Abs(y) != 0) { continue; }
                            break;
                        case AttackRangeTypes.Oblique:
                            if (Math.Abs(x) != Math.Abs(y)) { continue; }
                            break;
                    }
                    points.Add(new Point(center.X + x, center.Y + y));
                }
            }
            return points;
        }

        /// <summary>
        /// 获取攻击范围坐标列表
        /// </summary>
        /// <param name="rangeType">范围类型</param>
        /// <param name="range">范围</param>
        /// <param name="exclusionRangeType">排除范围类型</param>
        /// <param name="exclusionRange">排除范围</param>
        /// <returns></returns>
        public List<Point> AttackRange(AttackRangeTypes rangeType, int range, AttackRangeTypes exclusionRangeType, int exclusionRange) {
            List<Point> points = GetRange(Coordinate, rangeType, range);
            List<Point> excludePoints = GetRange(Coordinate, exclusionRangeType, exclusionRange);
            return points.Except(excludePoints).ToList();
        }

第三步，游戏中，将玩家控制的角色坐标Coordinate作为以上方法的Center参数，通过前文提到的组合方式最终完成SLG战棋角色战斗范围动态设定：

……

这是一款基于Silverlight的SLG游戏引擎的一部分，在线演示Demo 如下(点击下载该Demo源码)：

通过动态组合差集的方式设定SLG战棋角色的攻击范围，无论是灵活性、适用性还是拓展性都显得极其强大。当然，每个人的思维方式不一样，写出的算法也会大相径庭，游戏开发的乐趣就在于此：优化永无止尽。

手记思考：当问题出现时若能正确的把握其本质规律，一切都将显得那么的简单。

本文链接

Silverlight 2.5D RPG游戏技巧与特效处理：（完结篇）革新之路

Thu, 07 Jul 2011 15:48:00 +0800

谨以此文献给自己和我，深爱的游戏。

整整两年零四个月的Silverlight游戏教程编写终于放心的画上句号。有时也觉得很不可思议，把对儿时的梦想与坚持化作动力居然出了五部作品……，不知能否算是对这已近畸形的国度奉献的微薄之力，仅此。

中国网游在急功近利中成长，逐步呈现两极分化。一方面是大手笔、大成本的大制作，靠乱七八糟看也看不懂，扭也扭不清的故事情节、或恢弘却空洞的时空场景、超量的魔法/角色/动作来吸引玩家，似乎时下的玩家已不太买账了；与之相反，由年轻一代的游戏开发者们打造，凭借Web这个开放式平台不断涌现出许多短小精悍、创意无限的小制作，虽然简单却不失趣味，休闲娱乐一体，备受热捧；除此之外的都是剩品，或缺少资金导致研发周期加倍拖长、或依赖那些早已过时N年老旧不堪的引擎重新美术包装，换汤不换药的陈年旧饭；事实证明了中庸之路必将被这高节奏时代无情淘汰。

不比10年前了，还记得《龙族》《红月》《万王之王》吗？用90后的眼光去看待它们显得极其不屑：没有绚丽的画面，没有SNS元素，没有百宝箱，没有…….；可是，它们对于我来说却是弥足珍贵的记忆。太多人丢失了当年游戏人对艺术与创造的追求，拜倒在金钱的石榴裙下山寨，去吧！去剽窃，去复制。

难道经典对于我们来说总是那么的遥不可及？？科技如此神速发展的今天，如果一款游戏需要3年左右研发时间，可以明确一点：落伍是注定的。客户端网游的诟病越发显著，就如创新工场所形容的：太重了。近两年的市场充分反映，大投资的客户端网游往往比不上小成本的页游赚钱，亦印证了时代赋予游戏的革新之路：轻量化。

所有深入看过Silverlight游戏相关教程的朋友应该都有这样感触：其实游戏开发并非那么的遥不可及。Silverlight开发网游相比传统的客户端有着极其显著特点：多语言、多平台；低投入、高效率、长期效应、持续发展、绿色低碳环保；研发周期短而更易于创新；模式变化无穷且不拘于特定引擎；拓展维护方便，是.NET体系中集大成者与未来方向的引导者。Silverlight页游将引领世界的第四次游戏革命：全球化综合娱乐体验。

朋友，或许你还用插件安装量来衡量今天的Silverlight，那么只能送你两个字：Out Man。不就是个插件，WIN8+毫无疑问必然集成，至于其他操作系统？Silverlight的静默安装模式让你一键搞定用户，比起每天都因为漏洞而不停弹出更新的其他RIA来说，这个算是小Case了。不清楚Javascript的10个设计缺陷以及WebGL的先天不良是否能成就前途未卜的HTML5黄粱美梦暂且不提，Silverlight 与 Flash，王者与王者的对决似乎注定了HTML5的最终命运：走好。

又要动身了，当然，这次为了另一个希望而扬帆。留在博客里的所有代码与浅薄思想与大家一同分享，祝愿，让光的力量指引我们终有一天梦想成真。

时间很快，每次整理好思路，编写完代码，叙述清来龙去脉后，我整个身心便会有一种莫名的愉悦与解脱；是，欣慰自己还活着，因为从未揪心过啥时会“被跨省”、“被沉海”；时至今日，我总算能够与80多岁的老革命一起看《董_存_瑞》而热泪盈眶，就像他们所说的，只有像我这样的贫民才能痛彻心底的感悟那深藏于心底的五个大字：我爱你，中国。借此铭记被和谐社会所埋葬的“裸婚时代”。

深蓝色右手所有Demo在线演示地址：http://silverfuture.cn/

深蓝色右手最新Silverlight 2.5D RPG游戏引擎下载地址：见目录

深蓝色右手唯一超级QQ群(Silverlight 秘密)：73068105，欢迎Silverlight专业人士加入(证明身份或出示作品)。

本文链接

Silverlight 2.5D RPG游戏技巧与特效处理：（二十一）自定义路径动画

Wed, 29 Jun 2011 16:54:00 +0800

一直在想应该用什么作为《Silverlight 2.5D RPG游戏技巧与特效处理系列教程》的终结，既要实用而不拖泥带水；又要通用而不哗众取宠。于是一不小心便成就了我一个未了心愿：一切基于动态绘制路径而生成的万象动画作为这又一部作品的谢幕，足矣。

还记得我们小时候玩的《坦克大战》、《雷电》吗？在那狭小的弹粒缝隙间躲闪追逐成为了每每课后最快乐的回忆：

还记得高三那年的春天吗？每次丢下书包第一时间总会跑进网吧与同学们联网《星级争霸》、《帝国时代》；4V4、罗马战车VS投石车，炮火与弓箭的洗礼下，我们幸福的青春就这样被无限的释放：

大学里，《博德之门》、《奇迹》、《半条命》、《破碎银河系》等N多顶级游戏/网游让我短暂的忘却了时代赋予大学生的苦闷，人生除了现实，其实成为一名虚拟的王者未必不是今生一件幸事。“魔法飞弹”横空掠过、“蓝翎弩”三重穿梭、“手雷”华丽的抛物线、“跟踪弹”锲而不舍的精神如同网吧中弥漫着无上团结的凝聚力，走过了4年，也走过了最让我留念和感动的“兄弟年代”：

直至今日，当我们坐在凳子上开始编写属于自己的游戏时，当年战斗的画面早已模糊不清，残留的仅剩无数的弹粒在天空中你来我往，毫无眷恋。一直在想是否能够通过一块画板外加几个选项来完成所有一切的自定义路径动画，从而让游戏设计中那些如此神秘而又变幻莫测的“弹道轨迹”变得简单而轻松？

之前便有很多人公开了他们的相关成果，关于Silverlight中的路径动画(Path Animation)实现，比如下面两个链接：

http://www.codeproject.com/KB/silverlight/PathAnimation.aspx

http://geekswithblogs.net/cskardon/archive/2010/09/21/path-animation-in-silverlight.aspx

很可惜它们均为外国人所作，第一篇重新封装了一个名为PathAnimation的类，基于Blend绘制Path坐标数据实现路径动画；而后者则完全是通过Blend绘制的路径动画。虽然均能达到效果，但易用性及拓展性显然不够强。想想，怎样的自定义路径动画才能最大化适应当下绝大多数(各类型)游戏的需要？尤其在RPG游戏中，能为之增添无限乐趣和优秀的玩家视觉体验。

思路再一次回到那块画板上，通过鼠标在画板上移动，然后将鼠标所经过的轨迹以一定的密度绘制在其上并按顺序保存到List<Point>中，最后通过Storyboard的关键帧动画将所有的Point连成一个完整的路径动画。其中通过简单的顺时针/逆时针判断公式及匀加/减速度计算公式(任何公式都可以随意拓展)来分别实现动画延路径移动时的动态朝向及变速运动效果；当然，再配合上坐标缩放系数，从而最终整个自定义路径动画所实现的效果可完美无缝的移植到任何有相关需求的Silverlight游戏中：

                        Bullet bullet = new Bullet(new BulletDatas() { Code = pathAnimationPainter[n].AnimationCode, Loop = true, Type = BulletTypes.Animation }) { Z = 100 };
                        bullet.Center = bullet.Offset;
                        tabCanvas2.Children.Add(bullet);
                        Storyboard storyboard = new Storyboard();
                        PointAnimationUsingKeyFrames pointAnimationUsingKeyFrames = new PointAnimationUsingKeyFrames();
                        Storyboard.SetTarget(pointAnimationUsingKeyFrames, bullet);
                        Storyboard.SetTargetProperty(pointAnimationUsingKeyFrames, new PropertyPath("Position"));
                        DoubleAnimationUsingKeyFrames doubleAnimationUsingKeyFrames = new DoubleAnimationUsingKeyFrames();
                        Storyboard.SetTarget(doubleAnimationUsingKeyFrames, bullet);
                        Storyboard.SetTargetProperty(doubleAnimationUsingKeyFrames, new PropertyPath("Angle"));
                        double speed = pathAnimationPainter[n].Rate;
                        double a = 0.002; //加速系数
                        double timeSpanTemp = 0;
                        double durationTemp = 0;
                        double angleTemp = 0;
                        int circle = 0;
                        if (pathAnimationPainter[n].Easing == 2) {  //加速逆行即减速
                            for (int i = 0; i < pathAnimationPainter[n].Path.Count; i++)
                            { speed += a * i; }
                        }
                        for (int i = 0; i < pathAnimationPainter[n].Path.Count; i++) {
                            TimeSpan timeSpan = new TimeSpan();
                            Point lastPath = (i == 0 ? pathAnimationPainter[n].Path[0] : pathAnimationPainter[n].Path[i - 1]);
                            Point nowPath = pathAnimationPainter[n].Path[i];
                            Point nextPath = (i == pathAnimationPainter[n].Path.Count - 1 ? pathAnimationPainter[n].Path[pathAnimationPainter[n].Path.Count - 1] : pathAnimationPainter[n].Path[i + 1]);
                            switch (pathAnimationPainter[n].Easing) {
                                case 0:
                                    timeSpanTemp = GlobalMethod.GetDistance(lastPath, nowPath) / speed;
                                    durationTemp += timeSpanTemp;
                                    timeSpan = TimeSpan.FromMilliseconds(durationTemp);
                                    break;
                                case 1:
                                    speed += a * i;
                                    timeSpanTemp = GlobalMethod.GetDistance(lastPath, nowPath) / speed;
                                    durationTemp += timeSpanTemp;
                                    timeSpan = TimeSpan.FromMilliseconds(durationTemp);
                                    break;
                                case 2:
                                    speed -= a * (pathAnimationPainter[n].Path.Count - 1 - i);
                                    timeSpanTemp = GlobalMethod.GetDistance(lastPath, nowPath) / speed;
                                    durationTemp += timeSpanTemp;
                                    timeSpan = TimeSpan.FromMilliseconds(durationTemp);
                                    break;
                            }
                            pointAnimationUsingKeyFrames.KeyFrames.Add(
                                new LinearPointKeyFrame() {
                                    KeyTime = KeyTime.FromTimeSpan(timeSpan),
                                    Value = new Point() { X = nowPath.X * pathAnimationPainter[n].Proportion, Y = nowPath.Y * pathAnimationPainter[n].Proportion }
                                }
                            );
                            double angle = GlobalMethod.GetAngle(nowPath.Y - lastPath.Y, nowPath.X - lastPath.X) + 360 * circle;
                            //check大于0为顺时针个方向
                            double check = (nowPath.X - lastPath.X) * (nextPath.Y - nowPath.Y) - (nowPath.Y - lastPath.Y) * (nextPath.X - nowPath.X);
                            if (check > 0) {
                                if (angleTemp > 360 * circle && angle < 360 * circle) { angle += 360; } else if (angleTemp > 360 * circle + 180 && angle < angleTemp) { angle += 360; circle++; }
                            } else {
                                if (angleTemp < 360 * circle && angle > 360 * circle) { angle -= 360; } else if (angleTemp < 360 * circle - 180 && angle > angleTemp) { angle -= 360; circle--; }
                            }
                            angleTemp = angle; //用于旋转时的角度衔接
                            doubleAnimationUsingKeyFrames.KeyFrames.Add(
                                new LinearDoubleKeyFrame() {
                                    KeyTime = KeyTime.FromTimeSpan(timeSpan),
                                    Value = angle
                                }
                            );
                        }
                        pointAnimationUsingKeyFrames.Duration = new Duration(TimeSpan.FromMilliseconds(durationTemp));
                        storyboard.Children.Add(pointAnimationUsingKeyFrames);
                        if (pathAnimationPainter[n].Direction == 0) { storyboard.Children.Add(doubleAnimationUsingKeyFrames); }
                        EventHandler handler = null;
                        storyboard.Completed += handler = delegate {
                            storyboard.Completed -= handler;
                            tabCanvas2.Children.Remove(bullet);
                            bullet.Move_Completed(bullet, null);
                        };
                        storyboard.Begin();

还在羡慕《倩女幽魂Online》交织穿梭的吸血法术吗？

还在嫉妒《星辰变》中的移动粒子施法吗？还在恨2D/2.5D无法实现类似3D游戏中那些高随意性的路径动画吗？

有了本节的自定义路径动画攻略，大家只需一个描述路径的List<Point>，配合上几个参数而已，一切效果随手创造：

看到这你是否开始心动了？没错，尤其是在角色位置相对固定的回合制、SLG等类型游戏中，在发动者与它的目标之间创造出你认为最华丽的路径，无论魔法的走位还是角色的各类移动等效果都将变得轻而易举，这就是Silverlight给我们游戏开发者所带来的奇迹~！

Silverlight 时代即将来临，您准备好了吗？

本系列源码请到目录中下载

在线演示地址：http://silverfuture.cn

本文链接

Silverlight 2.5D RPG游戏技巧与特效处理：（二十）副本系统

Thu, 23 Jun 2011 10:58:00 +0800

前段时间晚上把小孩哄睡后带着老婆体验了一把《星辰变》，让我印象较深的可怜只有其副本系统，这里想说并不是《星辰变》的副本有多么有趣；相反，其枯燥到了无生趣可言，几乎你每天都得花费2个小时用在那重复重复再重复，屈指可数那3-5个一成不变的副本任务上，所以没几天我们便厌倦了。自从《魔兽世界》开始侵噬中华网游大地那刻，一款网游“副本系统”设计的好坏往往被商家定位成事关整个游戏品质的极重要环节。为什么地下城模式的副本总能让玩家遐想连篇、无限回味，每一次的进入都能感受新鲜如初？国产网游所谓的副本却永远若脱离不了具有中国特色的任务模式，能不悲哀？

副本系统设计很困难吗？

如果你玩过那些带副本的游戏，相信在你脑海中对于副本这个概念已不陌生。作为策划而言，副本赋予更多的含义是“团队协作”、“独立性”与“探险精神”，回报更加丰富而神秘，让人向往。在我看来，游戏副本是基于一个特殊的场景搭建的独立空间，辅以诸多规则、限制与达成、触发条件等，配上计时器统和而成。网游副本，其最初存在的目的是为了弥补多玩家交互而导致的单个/私人领域体验的缺失，即融入更多单机游戏的元素/特性到网游中。如果将网游的主线任务看做是一个故事的线索，那么副本便是游戏的分支剧情，它通常描述着许多精简却非常饱满而完整的故事情节。

话说编写具体副本类实在是太过瘾，用代码书写故事剧本，感觉贼带劲。如前文所述，副本，我们可以看做是特殊的场景空间配上一些UI(阶段描述，任务叙述，倒计时等文字/图形界面)。

于是首先第一步还是创建一个基于ObjectBase的副本基类 – InstanceBase：

    /// <summary>
    /// 副本类型
    /// </summary>
    public enum InstanceTypes {
        /// <summary>
        /// 无
        /// </summary>
        None = -1,
        /// <summary>
        /// 猎杀蜘蛛魔王
        /// </summary>
        HuntingSpiderKind = 0,
        /// <summary>
        /// 神邸秘境
        /// </summary>
        GodFam = 1,
    }

    public class AddRolesEventArgs : EventArgs {
        public int Num { get; set; }
        public int Mode { get; set; }
        public States State { get; set; }
        public Professions Profession { get; set; }
        public TacticAIs TacticAI { get; set; }
    }

    public class LeaveEventArgs : EventArgs {
        public Teleport Destination { get; set; }
    }

    /// <summary>
    /// 副本基类
    /// </summary>
    public abstract class InstanceBase : ObjectBase {

        /// <summary>
        /// 添加角色(测试用)
        /// </summary>
        public event EventHandler<AddRolesEventArgs> AddRoles;

        /// <summary>
        /// 脱离副本
        /// </summary>
        public event EventHandler<LeaveEventArgs> Leave;

        protected Grid grid = new Grid();
        protected TextBlock title = new TextBlock() { Foreground = new SolidColorBrush(Colors.Red), FontSize = 24 };
        protected TextBlock description = new TextBlock() { Foreground = new SolidColorBrush(Colors.White), FontSize = 22, TextWrapping = TextWrapping.Wrap };
        protected TextBlock additionalInformation = new TextBlock() { Foreground = new SolidColorBrush(Colors.Orange), FontSize = 20 };
        protected DispatcherTimer checkTimer = new DispatcherTimer() { Interval = TimeSpan.FromMilliseconds(500) };
        protected DispatcherTimer countdownTimer = new DispatcherTimer() { Interval = TimeSpan.FromSeconds(1) };

        ///<summary>副本所属空间</summary>
        protected Space space;
        ///<summary>参与副本的所有玩家</summary>
        protected List<RoleBase> players;

        public InstanceBase() {
            this.IsHitTestVisible = false;
            RowDefinition row = new RowDefinition();
            grid.RowDefinitions.Add(row);
            grid.Children.Add(title); Grid.SetRow(title, 0); title.HorizontalAlignment = HorizontalAlignment.Center;
            row = new RowDefinition();
            grid.RowDefinitions.Add(row);
            grid.Children.Add(description); Grid.SetRow(description, 1); description.HorizontalAlignment = HorizontalAlignment.Center;
            row = new RowDefinition();
            grid.RowDefinitions.Add(row);
            grid.Children.Add(additionalInformation); Grid.SetRow(additionalInformation, 2); additionalInformation.HorizontalAlignment = HorizontalAlignment.Center;
            this.Children.Add(grid); Canvas.SetTop(grid, 85);
            checkTimer.Tick += new EventHandler(StepCheck);
            countdownTimer.Tick += new EventHandler(Countdown);
            AdaptiveWindowSize();
        }

        /// <summary>
        /// 获取或设置是否触发各阶段机关
        /// </summary>
        public bool[] TriggerOrgan { get; set; }

        protected void AddRolesEvent(AddRolesEventArgs e) {
            if (AddRoles != null) { AddRoles(this, e); }
        }

        protected void LeaveEvent(LeaveEventArgs e) {
            if (Leave != null) { Leave(this, e); }
        }

        protected abstract void StepCheck(object sender, EventArgs e);

        protected abstract void Countdown(object sender, EventArgs e);

        /// <summary>
        /// 触发/运行
        /// </summary>
        public abstract void Run(List<RoleBase> players, Space space);

        /// <summary>
        /// 设置动画描述文本
        /// </summary>
        /// <param name="value"></param>
        protected void SetDescription(string value) {
            if (description.Text != value) {
                description.Text = value;
                GlobalMethod.RunEffectAnimation(description, new RadialBlur(), false, false, "Progress", 0, 100, TimeSpan.FromMilliseconds(1800), new ExponentialEase() { EasingMode = EasingMode.EaseIn }, true);
            }
        }

        /// <summary>
        /// 自适应游戏窗口尺寸
        /// </summary>
        public virtual void AdaptiveWindowSize() {
            grid.Width = Application.Current.Host.Content.ActualWidth;
        }

        /// <summary>
        /// 离开
        /// </summary>
        protected void Exit(string titleText) {
            Dispose(this, null);
            title.Text = titleText;
            description.Text = "5秒后自动离开副本";
            GlobalMethod.RunEffectAnimation(title, new Ripple(), false, false, "Progress", 0, 100, TimeSpan.FromMilliseconds(2000), new ExponentialEase() { EasingMode = EasingMode.EaseOut }, true);
            GlobalMethod.SetTimeout(delegate {
                //退出
                LeaveEvent(new LeaveEventArgs() { Destination = new Teleport() { Instance = InstanceTypes.None, ToSpace = 0, ToDirection = Directions.SouthEast, ToCoordinate = new Point(57, 28) } });
            }, 5000);
        }

    }

以本节Demo源码中的副本-【猎杀蜘蛛魔王】(HuntingSpiderKind.cs)为例，首先是定义其中的阶段(用Enum来描述它的故事脉络)，这里我用到了中文编码，事实证明了本土语言枚举在副本实现中拥有极高的灵活性，且非常有利于拓展、阅读与维护(前提是还未使用脚本来描述副本)：

       /// <summary>副本阶段(用本土语言枚举非常有利于拓展维护及阅读)</summary>
       public enum Steps {
            设置右键魔法8级连锁闪电或6级石封箭 = 0,
            十二秒内到达传送点 = 1,
            等待4秒翼族来袭 = 2,
            消灭所有翼族 = 3,
            进入传送点到达山的彼岸 = 4,
            设置右键魔法为7级陨石坠落 = 5,
            等待3秒刺客来袭 = 6,
            消灭所有刺客 = 7,
            骑上马并移动到59_60附近开启封印 = 8,
            在23秒内为武器附上烟火粒子 = 9,
            在180秒内消灭蜘蛛魔王 = 10,
            副本完成通过传送门离开 = 11,
        }

        Dictionary<Steps, string> stepExplanation = new Dictionary<Steps, string>() {
            {Steps.设置右键魔法8级连锁闪电或6级石封箭, "切换到【主角】菜单，将右键魔法设置为8级【连环闪电】或6级【石封箭】"},
            {Steps.十二秒内到达传送点, "传送点已开启，<紧急>请在12秒内穿过石门找到传送点并进入"},
            {Steps.等待4秒翼族来袭, "危险！4秒后【翼族】来袭，准备好你的家伙"},
            {Steps.消灭所有翼族, "用【连环闪电】或【石封箭】干掉他们"},
            {Steps.进入传送点到达山的彼岸, "通过传送点到达山的彼岸"},
            {Steps.设置右键魔法为7级陨石坠落, "注意！大规模【守护刺客】将至，将右键魔法设置为7级【陨石坠落】"},
            {Steps.等待3秒刺客来袭, "危险！3秒后敌军来袭！！"},
            {Steps.消灭所有刺客, "来一杀一，用【陨石坠落】干掉他们"},
            {Steps.骑上马并移动到59_60附近开启封印, "【骑上马】并移动到坐标【59,60】附近，点击【主角】菜单中的【开启封印】释放【蜘蛛魔王】！"},
            {Steps.在23秒内为武器附上烟火粒子, "<紧急>【蜘蛛魔王】23秒后将出现！快速点击【主角】菜单，为【武器】附上【烟火】粒子效果"},
            {Steps.在180秒内消灭蜘蛛魔王, "3分钟内必须消灭【蜘蛛魔王】，否则世界将被瞬间毁灭！！"},
            {Steps.副本完成通过传送门离开, "副本完成，从传送门离开"},
        };

副本的故事基于阶段性发展，即完成一个阶段故事才会向下一阶段延续，直到达成该阶段完成条件为止，此时就涉及到副本系统规则的设定、达成判定等处理。我的做法是通过计时器状态机配合倒计时器及角色坐标改变事件来处理所有的逻辑判断，这样的框架性效比极好且能实现任意的副本设计需求：

        public Steps Step { get; private set; }
        Steps countdownStep;
        int secondsRemaining;

        public HuntingSpiderKind() {
            title.Text = "副本【猎杀蜘蛛魔王】";
            TriggerOrgan = new bool[stepExplanation.Count];
        }

        /// <summary>
        /// 开始
        /// </summary>
        public override void Run(List<RoleBase> players, Space space) {
            this.space = space;
            this.players = players;
            players[0].PositionChanged += new DependencyPropertyChangedEventHandler(player0_PositionChanged);
            checkTimer.Start();
            //离开的传送门(测试用)
            space.AddAnimation(new AnimationBase() {
                ID = 0,
                Code = 81,
                Position = new Point(-1320, 1970),
                Z = 1970,
                Tip = "离开副本",
                Loop = true,
            });
            space.RunWeather(WeatherTypes.Cloud, 50);
        }

        ///<summary>进度检查(网络版中为所有玩家都要检测，目前单机只检测players[0]即主角)</summary>
       protected override void StepCheck(object sender, EventArgs e) {
            SetDescription(string.Format("Step {0}:  {1}", (int)Step, stepExplanation[Step]));
            switch (Step) {
                case Steps.设置右键魔法8级连锁闪电或6级石封箭:
                    if ((players[0].CurrentMagic.Level == 8 && players[0].CurrentMagic.Code == 9) || (players[0].CurrentMagic.Level == 6 && players[0].CurrentMagic.Code == 12)) {
                        space.AddAnimation(new AnimationBase() {
                            ID = 0,
                            Code = 82,
                            Position = new Point(-583, 1695),
                            Z = 1695,
                            Tip = "传送点",
                            Loop = true,
                        });
                        space.Terrain.AddTeleport(new Teleport() {
                            Code = 0,
                            ToSpace = space.Code,
                            Instance = InstanceTypes.None,
                            ToCoordinate = new Point(46, 72),
                            ToDirection = Directions.SouthEast
                        }, "45_68_0,46_68_0,");
                        StartCountdown(Steps.十二秒内到达传送点, 12);
                    }
                    break;
                case Steps.消灭所有翼族:
                    if (space.AllRoles().Count == players.Count) { //这样的检测方案只是暂定的，很可能存在BUG
                        Step = Steps.进入传送点到达山的彼岸;
                        space.AddAnimation(new AnimationBase() {
                            ID = 0,
                            Code = 82,
                            Position = new Point(-238, 2018),
                            Z = 2018,
                            Tip = "传送点",
                            Loop = true,
                        });
                        space.Terrain.AddTeleport(new Teleport() {
                            Code = 1,
                            ToSpace = space.Code,
                            Instance = InstanceTypes.None,
                            ToCoordinate = new Point(73, 25),
                            ToDirection = Directions.SouthWest
                        }, "63_71_0,62_70_0,62_72_0,");
                    }
                    break;
                case Steps.设置右键魔法为7级陨石坠落:
                    if (players[0].CurrentMagic.Level == 7 && players[0].CurrentMagic.Code == 7) {
                        StartCountdown(Steps.等待3秒刺客来袭, 3);
                    }
                    break;
                case Steps.消灭所有刺客:
                    if (space.AllRoles().Count == players.Count) {
                        Step = Steps.骑上马并移动到59_60附近开启封印;
                    }
                    break;
                case Steps.骑上马并移动到59_60附近开启封印:
                    if (TriggerOrgan[(int)Step]) {
                        StartCountdown(Steps.在23秒内为武器附上烟火粒子, 23);
                    }
                    break;
                case Steps.在23秒内为武器附上烟火粒子:
                    if (players[0].DisplayWeaponParticle) {
                        StartCountdown(Steps.在180秒内消灭蜘蛛魔王, 180);
                        Monster boss = new Monster(space.Terrain) {
                            ID = 3120000,
                            //AttachID = 4100000,
                            Code = 2,
                            FullName = "蜘蛛魔王",
                            LearnedMagic = new Dictionary<int, int>() { { 0, 6 }, { 1, 6 }, { 2, 6 }, { 3, 6 }, { 4, 6 }, { 5, 6 }, { 6, 6 }, { 7, 6 }, { 8, 6 }, { 9, 6 }, { 10, 6 }, { 11, 6 }, { 12, 6 }, { 13, 6 }, { 14, 6 }, { 15, 6 }, { 16, 6 }, { 17, 6 }, { 18, 6 } },
                            Profession = Professions.Monster,
                            ArmorCode = 16,
                            Direction = Directions.SouthEast,
                            State = States.Walking,
                            Camp = Camps.Eval,
                            TacticAI = TacticAIs.GoalLeader,
                            ActionAI = ActionAIs.Persistent,
                            LifeMax = 640000,
                            Life = 640000,
                            ATK = 24059,
                            DEF = 1500,
                            MAG = 500,
                            DEX = ObjectBase.RandomSeed.Next(0, 30),
                            Coordinate = new Point(49, 59)
                        };
                        space.AddRole(boss, new RoleAddedEventArgs() {
                            RegisterDisposedEvent = true,
                            RegisterIntervalTriggerEvent = true,
                            RegisterActionTriggerEvent = true,
                            RegisterDoAttackEvent = true,
                            RegisterDoCastingEvent = true,
                            RegisterPositionChangedEvent = true,
                            RegisterLifeChangedEvent = true,
                        });
                        space.MusicUri = "Boss";
                    }
                    break;
                case Steps.在180秒内消灭蜘蛛魔王:
                    if (space.AllRoles().Count == players.Count) {
                        Step = Steps.副本完成通过传送门离开;
                        space.MusicUri = "100";
                        space.AddAnimation(new AnimationBase() {
                            ID = 0,
                            Code = 81,
                            Position = new Point(-300, 1591),
                            Z = 1591,
                            Tip = "传送到【废墟秘境】",
                            Loop = true,
                        });
                    }
                    break;
            }
        }

       /// <summary>
       /// 开始倒计时
       /// </summary>
       void StartCountdown(Steps step, int remaining) {
           countdownStep = Step = step;
           secondsRemaining = remaining;
           countdownTimer.Start();
       }

        /// <summary>
        /// 倒计时
        /// </summary>
        protected override void Countdown(object sender, EventArgs e) {
            if (Step != countdownStep) {
                countdownTimer.Stop();
                additionalInformation.Text = "";
            } else {
                additionalInformation.Text = string.Format("倒计时: {0}", secondsRemaining);
                if (secondsRemaining == 0) {
                    additionalInformation.Text = "";
                    switch (Step) {
                        case Steps.十二秒内到达传送点:
                        case Steps.在23秒内为武器附上烟火粒子:
                        case Steps.在180秒内消灭蜘蛛魔王:
                            Exit("副本【猎杀蜘蛛魔王】  战斗失败");
                            break;
                        case Steps.等待4秒翼族来袭:
                            Step = Steps.消灭所有翼族;
                            AddRolesEvent(new AddRolesEventArgs() { Num = 10, Mode = 1, Profession = Professions.Archer, State = States.Riding, TacticAI = TacticAIs.GoalLeader });
                            break;
                        case Steps.等待3秒刺客来袭:
                            Step = Steps.消灭所有刺客;
                            AddRolesEvent(new AddRolesEventArgs() { Num = 30, Mode = 2, Profession = Professions.Assassin, State = States.Walking, TacticAI = TacticAIs.GoalLeader });
                            break;
                    }
                }
                secondsRemaining--;
            }
        }

        void player0_PositionChanged(object sender, DependencyPropertyChangedEventArgs e) {
            Point p = (Point)(e.NewValue);
            int x = (int)p.X;
            int y = (int)p.Y;
            if ((x == 41 && y == 90) || (x == 40 && y == 91)) {
                LeaveEvent(new LeaveEventArgs() { Destination = new Teleport() { Instance = InstanceTypes.None, ToSpace = 0, ToDirection = Directions.SouthEast, ToCoordinate = new Point(57, 28) } });
                Dispose(this, null);
            } else if (Step == Steps.十二秒内到达传送点 && x == 46 && y == 72) {
                StartCountdown(Steps.等待4秒翼族来袭, 4);
            } else if (Step == Steps.进入传送点到达山的彼岸 && x == 73 && y == 25) {
                Step = Steps.设置右键魔法为7级陨石坠落;
            } else if (Step == Steps.副本完成通过传送门离开 && ((x == 48 && y == 59) || (x == 48 && y == 58) || (x == 47 && y == 58))) {
                LeaveEvent(new LeaveEventArgs() { Destination = new Teleport() { Instance = InstanceTypes.GodFam, ToSpace = 101, ToDirection = Directions.NorthWest, ToCoordinate = new Point(60, 44) } });
                Dispose(this, null);
            }
        }

本节源码中我为大家提供了两个副本做为参考：【猎杀蜘蛛魔王】和【神邸秘境】，它们可以独立进行，同时当杀掉【猎杀蜘蛛魔王】副本中的BOSS后，通过传送门同样可以进入到下一副本【神邸秘境】，这样就构成了副本系统中的连锁副本设计，从而形成无线连通的副本世界，能够满足所有一切的副本设计需求。另外每个副本都包含有10几个阶段，比如让玩家改变属性、移动到指定坐标、进入传送点、杀光怪、倒计时行为、开启封印(使用道具，物品道具都应有相关属性来记录它的各类效果或触发事件)、杀掉BOSS、定时刷怪、跟随移动、对话、守护等等，基于本节副本系统框架制作的副本只有想不到的，没有做不到的(功能实现暂时是硬编码，以后有机会再进一步完善，细节/方法还可以再优化)。

做为商业游戏开发，副本系统可以基于脚本构建，同时副本编辑器也必不可少，设计起来并不难，关键点本文已讲述得很清楚了。本文，我以副本功能的实现让大家对副本系统的设计有个入门概念，如何将其制定成像场景一样可动态编辑的对象，这个需要预先对游戏产品中所有副本可能需要拥有最极限的功能需求进行分析，然后在制作好副本编辑器后配以脚本和xml描述文件最终实现最完美的副本系统。另外，如果你体验过本节的Demo相信应该还会有这样的领悟：这副本咋和新手指导(入门演示)如此相似？没错，其实它们本就同根同源，想想原理便一清二楚了。

副本的最后一个要素便是场景的渲染和背景音乐烘托，在云雾缭绕的秘境中伴随着激荡人心的音乐与BOSS华丽一战，相信那样的体验足够你珍惜与回味。

深思呀，国产网游；副本不仅仅代表着财宝与经验，韵味深长的用户体验才是至尊之道。

本系列源码请到目录中下载

在线演示地址：http://silverfuture.cn

本文链接

Silverlight 2.5D RPG游戏技巧与特效处理：（十九）基于WCF的注册与登录

Wed, 08 Jun 2011 16:26:00 +0800

最后还剩下游戏入口部分，Silverlight是客户端插件，因此首选WCF作为它与服务器端数据库的桥接。撇去UI方面华丽的动态角色创建与选择不再多说，本节的重点便是在教程Demo的基础上整合进基于WCF的注册与登陆等操作，使之最终成为一款相对完整而五脏俱全的RPG作品。

依旧钟情于LINQ，因此LINQ to SQL成为我操作数据库的首选。强烈建议大家首先参考这篇文章：数据库LINQ TO SQL在Silverlight中的应用(WCF) ,其中的所有细节都已阐述得相当详细。如果你的电脑中存有之前的Demo源码，那么接下来你可以按照下面的步骤跟着我一步步从零开始搭建游戏的登陆部分，真真切切的体会WCF技术在Silverlight中的常规应用。

第一步：依照游戏中角色注册、创建、相关信息及登录等需求设计数据库，并编写好相应可能会用到的增删改查等存储过程(本节Demo源码中附带了名为FS3.sql的数据库文件，表和存储过程都在其中)。

第二步：在Silverlight的寄主Web项目中右键->添加新项目->LINQ to SQL映射类，这里我取名为L2S.dbml：

第三步：打开VS视图中的服务器资源管理器，右键添加SQL连接到FS3(SQL版本最好2005以上)后将其中的表和存储过程等均拖到L2S.dbml的设计窗口中形成大家再熟悉不过的映射：

第四步：此时便可编写WCF操作类了,在Silverlight的寄主Web项目中右键->添加WCF服务，取名为WCFService.svc：

需要特别注意的是带返回类型的存储过程需要修改其相应属性为表实体，否则后面的逻辑查找不到：

第五步：编写具体操作逻辑，搞过WCF开发的朋友此处可完全忽略，超级简单；没搞过的也很容易看懂，具体就不多说啦，直接列代码：

    [ServiceContract(Namespace = "")]
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    [ServiceBehavior(IncludeExceptionDetailInFaults = true)]
    public class WCFService {
        [OperationContract]
        public void DoWork() { }

        /// <summary>
        /// 添加新用户(添加过程中字符型超出限制长度则自动截取)
        /// </summary>
        /// <returns>新用户的ID，0则表示失败</returns>
        [OperationContract]
        public long InsertUser(string userName, string password, string realName, string idCard, string eMail, string address) {
            using (L2SDataContext dc = new L2SDataContext()) {
                return Convert.ToInt64(dc.p_InsertUser(userName, password, realName, idCard, eMail, address, "", "").ReturnValue);
            }
        }

        /// <summary>
        /// 用户资料验证
        /// </summary>
        /// <param name="userName">用户名</param>
        /// <returns>0表示不存在</returns>
        [OperationContract]
        public int CheckUserExist(string userName) {
            using (L2SDataContext dc = new L2SDataContext()) {
                return dc.p_CheckUserExist(userName);
            }
        }

        /// <summary>
        /// 用户登陆验证
        /// </summary>
        /// <param name="userName">用户名</param>
        /// <param name="password">密码</param>
        /// <returns>0表示不匹配</returns>
        [OperationContract]
        public int UserLogonValidate(string userName, string password) {
            using (L2SDataContext dc = new L2SDataContext()) {
                return dc.p_CheckUserLogon(userName, password);
            }
        }

        /// <summary>
        /// 检查角色是否已存在
        /// </summary>
        /// <param name="name">角色名</param>
        /// <returns>0表示不存在</returns>
        [OperationContract]
        public int CheckRoleExist(string name) {
            using (L2SDataContext dc = new L2SDataContext()) {
                return dc.p_CheckRoleExist(name);
            }
        }

        /// <summary>
        /// 检查用户创建的角色数量
        /// </summary>
        /// <param name="userName">用户名</param>
        /// <returns>角色数</returns>
        [OperationContract]
        public int GetUserRoleNum(string userName) {
            using (L2SDataContext dc = new L2SDataContext()) {
                return dc.p_GetUserRoleNum(userName);
            }
        }

        /// <summary>
        /// 添加新角色
        /// </summary>
        /// <returns>新角色的ID，0则表示失败</returns>
        [OperationContract]
        public long InsertRole(string userName, string name, byte avatar, byte sex, byte occupation, byte roleLevel, long experience, long mapID, string lastIP, string remarks) {
            using (L2SDataContext dc = new L2SDataContext()) {
                return Convert.ToInt64(dc.p_InsertRole(userName, name, avatar, sex, occupation, roleLevel, experience, mapID, lastIP, "").ReturnValue);
            }
        }

        /// <summary>
        /// 根据用户名获取该用户的所有角色
        /// </summary>
        /// <param name="userName">用户名</param>
        /// <returns>创建的所有角色</returns>
        [OperationContract]
        public List<Role> GetRoleByUserName(string userName) {
            using (L2SDataContext dc = new L2SDataContext()) {
                return dc.p_GetRoleByUserName(userName).ToList<Role>();
            }
        }

        /// <summary>
        /// 删除角色记录
        /// </summary>
        /// <param name="roleName">角色名</param>
        /// <returns>失败0，成功1</returns>
        [OperationContract]
        public int DeleteRole(string roleName) {
            using (L2SDataContext dc = new L2SDataContext()) {
                return dc.p_DeleteRole(roleName);
            }
        }

    }

第六步：也是最后一步，在RPGEffectsDemo项目中右键添加服务引用(Service References)，然后检索到WCFService.svc完成即可。接着发布网站，并在服务器端配置好IIS，整个流程到此结束。

参照如上步骤搭建的WCF框架，如果服务器(IIS)或数据库相关数据参数发生变动则仅需修改以下两个文件：ServiceReferences.ClientConfig和Web.config，具体位置如下，参数很好理解，尤其是搞过这方面开发的朋友更无须多说：

一切OK后，以游戏登陆时输入用户名与密码的窗体为例，我们可通过类似以下的代码创建WCF连接以及处理相应逻辑：

                WCFServiceClient wcfServiceClient = new WCFServiceClient();
wcfServiceClient.UserLogonValidateAsync(userName.Text.Trim(), GlobalMethod.Encrypt(pwd.Password));
                wcfServiceClient.UserLogonValidateCompleted += (wcfs1, wcfe1) => {
                    if (wcfe1.Result != 0) {
                        LoginManager.UserName = userName.Text.Trim();
                        if (Login != null) { Login(this, null); }
                    } else {
                        LoginManager.loading.Hide();
                        LoginManager.loginTip.Show(GetLanguagePackContent(11), LoginTipMode.TipOnly);
                    }
                    wcfServiceClient.CloseAsync();
                };

与ASP.NET页面设计类似，游戏中比如语言选择、版本说明、登陆、注册、角色创建、角色选择、物品窗口、属性窗口等每个窗体我们都可以单独的控件类文件存在，并为它们内部的每个需要交互的按钮设置对应的事件以实现与其他对象的交互消灭耦合：

另外，Demo使用了动态多国语言设计，众所周知同一词汇在不同语言书写中存在长度差异，因此语言包中还应在需要的地方添加上Offset和FontSize参数以使得界面看上去更协调整洁：

Silverlight动态多国语言设计模式对于WebGame来说可轻松实现玩家跨国交互和竞技，可谓真正能实现网游国际化的RIA技术；这才是Silverlight页游即将为世界所缔造的网游领域新的蓝海！第四次游戏革命：网页网游全球一体化。试想不同民族、不同国籍的玩家在一款游戏中同场竞技或SNS中相互交流，尤其是亚洲，中、港、台、日、韩、越、泰等周边国家的游戏玩家齐聚一堂，共享世纪网游大作，那将是一件多么伟大而具有划时代意义的历史记忆！不远了，多少前辈曾经为了这个梦想而奋斗青春，当微软为了Silverlight能兼具更强劲的GPU而收购NVIDIA时，当Silverlight 5正式版浩瀚问世之时，那才是网游世界新的春天！

XNA已成为Silverlight.XNA，无可厚非Silverlight必将成为微软未来平台统一与兼容的首选~!兼具高开发效率、优秀用户体验及跨平台等诸多优势最具潜力的RIA技术，未来将与HTML5共舞，优势互补一统所有网络应用。

本系列源码请到目录中下载

在线演示地址：http://silverfuture.cn

本文链接