羽柴|鬼铃-blog - 游戏算法

[开源]06年开发的FMS 在线换装聊天室游戏

yuchaiyuwei@163.com(admin) — Wed,30 Jun 2010 22:55:40 +0800

[开源]06年开发的FMS 在线换装聊天室游戏

换装小游戏聊天室.
带客房端及服务端。 06年开发的小游戏，目前开源。可能有很多纰漏。

//=====================================
//
//转载请注明出处：羽柴鬼铃-blog
// www.ycflash.com/
//
//=====================================

忘了贴源码，现在补上

源码下载
点击下载此文件

跨层级加载时相对路径的问题

yuchaiyuwei@163.com(admin) — Wed,15 Jul 2009 17:38:16 +0800

今天刚好在做多层级加载时发现了这个问题.就把解决方法贴出来了
问题描术:
路径结构是：根级：A.swf  data(文件夹)     data文件夹中有 B.swf   c.swf
在B的代码中有加载C.swf 单独运行B时正常。  用A加载B的时候，问题就出现B不会加载c.swf了。
得把c.swf移到和A.swf同级别。

问题原因:
所有加载的swf都是以最外层swf所在目录为根目录
被网页加载的swf都是以网页所在目录为根目录

解决方法:
function 计算文件目录() {
    var 目录索引 = _url.lastIndexOf("/");
    var 目录 = _url.substring(0, 目录索引);
    var 文件名 = _url.substring(目录索引+1);
    return [目录, 文件名];
}
trace(_url)
trace(计算文件目录())

//*****重点. 以上函数并把目录和文件名分离了. 所以返回值的[0]是目录 [1]是文件名.这样用起来就更方便了

利用上面的函数,先分析得到主加载器的绝对目录.  这时候不论下级载体或下下级载体. 再调用一次该函数
得到下下级载体的绝对目录.

这样就能得到2个绝对地址  然后用字符串分析方法(IndexOf) 找出相同的部分.去掉, 剩下的就是需要的相对路径了. 这样在加载时把这个路径追加上.就能正常的加载N级关系的文件了.

本教程为本人原创，只供学习如转载教程请注明出处：www.ycflash.com/
                    ----羽柴

//再把对比方法也补充上吧. 比较简单.
//========计算自己的相对路径=========
var 目录索引=文件目录[0].indexOf(_root.文件目录[0])
var 相对路径=文件目录[0].substring(目录索引+_root.文件目录[0].length+1)
trace("相对路径="+相对路径)

//=====trace环境===解析成功.
主文件目录=file:///F|/制作/A
子文件目录=file:///F|/制作/A/data
相对路径=data

五子棋算法 + 五子棋AI 估价算法(含源码)

yuchaiyuwei@163.com(admin) — Mon,01 Jun 2009 20:50:08 +0800

今天有人提起五子棋的算法问题，就把以前开发的源码直接贴出来了。大家去看源码学习吧

因为五子棋算法如果要写说明可能会写非常大一贴。所以在此就只做简单的原理说明，具体的下载源码研究吧。

很多人第1步肯定会问起五子棋如何判断5子相连。基本只要熟悉2维数组应用的程序员就比较容易理解了。
在此用2维数组白字为0  黑子为1 用数组判断，很快就能判断出是否五子相连

比如用这样的小数组表示棋盘：

arr[0]=[0,0,0,0,1]
arr[1]=[1,1,1,1,1]
arr[2]=[0,1,1,1,0]
arr[3]=[0,0,1,0,0]
arr[4]=[1,0,0,0,1]

上图是一个2维数组。    用肉眼很简单就能判断出 arr1这一行5个1。存在，同理。只要从一点出去（最后下的那步）进行8方面5个点的延伸出去，如果这5个点数值都一样则表示相连了

再来就是AI（机器人），先从最基本的AI谈起。
五子棋如何做机器人呢？  简单的方法就是估价。什么是估价，就是当对手每走一步。就对整个棋牌每个点做估价。然后找出价值最高的点那就是机器人要走的点。我写的AI估价表如下，当然越详细的估价及棋路判断最多那机器人就越强。

估价表(空值)

当前玩家    连成的子数    权值
PC        成活2         1
对手        成活2        2
PC        成活3        3
对手        成活3        4
PC        成活4        5
对手        成活4        6

PC        成活5        7
对手        成活5        8

估价表(全值)

对手        成活挡2        1
PC        成活挡2        2
对手        成活空2        3
PC        成活空2        4
对手        成活挡3        5
PC        成活挡3        6
对手        成活空3        7
PC        成活空3        8
对手        成活挡4        9
PC        成活挡4        10
对手        成活空4        11
PC        成活空4        12
对手        成活挡5        14
PC        成活挡5        15

棋子数    2 3 4    5
倍率    1 2 2.5    3

PC    4 8 12
对手    3 7 11
PC    2 6 10    15
对手    1 5 9    14

公式
对手空    子数*倍率+2
PC空    子数*倍率+1
对手挡    子数*倍率
PC挡    子数*倍率-1

可能一开始看上表完全不理解，这很正常。不过在此只说原理，至于实现方法看源码就行。
用如下例子来说明什么是估价，如何做估价。
最基本的就是：用一开始的判断输赢的方法，能取到1个点延伸8方向所得到8个方向8种排列的棋子情况。然后找出这8个方向中棋子拥有最多的数量就是这个点的估价。用通俗的话来解释下。
比如一开始那个数组：

arr[0]=[0,0,0,0,1]
arr[1]=[1,？,1,1,1]
arr[2]=[0,1,1,1,0]
arr[3]=[0,0,1,0,0]
arr[4]=[1,0,0,0,1]

大家看arr[1]这列，？处的估价是多少呢？首先从这点出发，8方向找出子最多的一条则是估价。从肉眼上看一看就明白了那就是？处的右边。有3个1。子越多，表示他的价值最高。取出子最多的一方向就是这个点的估价。

这时候大家应该知道1个点的价价了。但这是不够的，省下的就是用同样的方法，找出整个棋盘里面没有下棋子的地方，然后用同样的方法计算它们的估价。价值最高的点。就是AI要走的点。

//==========源码点击此处下载=========
点击下载此文件

本源码入教程为本人原创，只供学习，如用至违法用途与作者无关。
如转载教程请注明出处：www.ycflash.com/ycblog

                    ----羽柴

功能说明：
五子棋 AS2版。开发环境flash8 开发时间2006年7月

骰子游戏根据总数随机显示骰子值[反算法]

yuchaiyuwei@163.com(admin) — Fri,01 May 2009 17:38:45 +0800

在开发网络版关于 1-2颗骰子游戏过程中，经常会出现这样的情况。服务端随机取了骰子的总数，在客户端得根据这个骰子总数随机分配。1颗骰子当然就没必要了。主要是2颗骰子
比如：服务端发来骰子和： 8点   客户端的2颗骰子就要随机显示，  有可能1,7  2,6    3,5   4,4   5,3  6,2   7,1 这样的结果。现在把算法列出来。

//==============算法如下====================
function 计算骰子值(总值, 骰子数) {
    var 骰子值 = new Array();
    if (骰子数 == 1) {
        骰子值 = [总值, 0];
    } else if (骰子数 == 2) {
        if (总值>6) {
            var 随机最小值 = 总值-6;
            var 随机最大值 = 6;
            if (随机最小值 == 随机最大值) {
                var ran值 = 6;
                骰子值 = [ran值, 总值-ran值];
            } else {
                var ran值 = random(6-随机最小值)+随机最小值;
                骰子值 = [ran值, 总值-ran值];
            }
        } else {
            var 随机最小值 = 1;
            var 随机最大值 = 总值;
            if (总值 == 6) {
                随机最大值 = 5;
            }
            //trace("随机最小值="+随机最小值)
            //trace("随机最大值="+随机最大值)
            //trace(随机最大值-随机最小值+1)
            var ran值 = random(随机最大值-随机最小值)+随机最小值;
            骰子值 = [ran值, 总值-ran值];
        }
    }
    //trace("骰子值="+骰子值);
    return 骰子值;
}
//========================调试方法======================
for (var i = 0; i<1000; i++) {
    var 总值 = random(11)+2;
    var 骰子值 = 计算骰子值(总值, 2);
    var OK = "不成立";
    if (总值 == 骰子值[0]+骰子值[1] && 骰子值[0]>0 && 骰子值[0]<7 && 骰子值[1]>0 && 骰子值[1]<7) {
        OK = "成立";
    }
    trace("总值="+总值+" 骰子值="+骰子值+" "+OK);
    if (OK=="不成立") {
        trace("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
        //trace("总值="+总值+" 骰子值="+骰子值+" "+OK);
    }
}
//=====================================
//
//转载请注明出处：羽柴鬼铃-blog  www.ycflash.com/blog
//
//=====================================

牌类游戏中取出顺子的算法

yuchaiyuwei@163.com(admin) — Mon,26 Nov 2007 23:26:11 +0800

//一直忙啊，都好长时间没写BLOG了。。今天刚写到一个自动从一套牌中取出顺子的算法就贴上来吧
//以下用斗地主作为例子：把代码贴到FLASH中导出即可看到效果，只限FLASH8  AS2版本
散牌组 = [[17, 4], [12, 3], [15, 0], [14, 2], [14, 3], [10, 3], [5, 3], [11, 3], [12, 1], [3, 0], [8, 0], [15, 3], [6, 3], [13, 1], [14, 1], [7, 2], [4, 3], [10, 1], [15, 2]];
散牌组.sortOn(0, 1 | 16);
顺子牌组 = new Array();
//建立调试点数
调试点数 = new Array();
for (var i = 0; i<散牌组.length; i++) {
    调试点数.push(散牌组[i][0]);
}
trace("原牌组="+调试点数);
for (var i = 0; i<散牌组.length-5; i++) {
    //用来记录合格的编号
    var 编号数组 = new Array();
    //追加值用来判断如果成对的跳跃判断数
    var 跳跃值 = 0;
    for (var j = 0; j<散牌组.length-i; j++) {
        //trace(散牌组[i+j][0]+"=="+(散牌组[i+j+1][0]-1+跳跃值)+" 跳跃值="+跳跃值);
        if (散牌组[i+j][0]+跳跃值 == 散牌组[i+j+1][0]+跳跃值 && 散牌组[i+j+1][0]<=15) {
            跳跃值++;
        } else if (散牌组[i+j][0]+跳跃值 == 散牌组[i+j+1][0]-1+跳跃值 && 散牌组[i+j+1][0]<=15) {
            编号数组.push(i+j);
        } else {
            break;
        }
    }
    if (编号数组.length>=5) {
        var 临时牌组 = new Array();
        var 减编号 = 0;
        for (var j = 0; j<编号数组.length; j++) {
            var 删除值 = 散牌组.splice(编号数组[j]-减编号, 1);
            减编号++;
            临时牌组.push(删除值[0]);
        }
        顺子牌组.push(临时牌组);
        i = 0;
    }
}
trace("抽取的组队数="+顺子牌组.length);
trace("=============处理取牌后的结果=========");
for (var n = 0; n<顺子牌组.length; n++) {
    调试点数 = new Array();
    for (var i = 0; i<顺子牌组[n].length; i++) {
        调试点数.push(顺子牌组[n][i][0]);
    }
    trace("顺子牌组"+n+"="+调试点数);
}
调试点数 = new Array();
for (var i = 0; i<散牌组.length; i++) {
    调试点数.push(散牌组[i][0]);
}
trace("抽取后剩下的散牌="+调试点数);
//=====================================
//
//转载请注明出处：羽柴鬼铃-blog  www.ycflash.com/blog
//
//=====================================

类似俄罗斯式拼方块游戏。[含源码]

yuchaiyuwei@163.com(admin) — Sun,28 Oct 2007 17:02:18 +0800

昨天朋友急需开发一个类似俄罗斯式拼方块游戏。在赶项目过程中，只有花去晚上3小时赶出了这个游戏。基原理和俄罗斯方块一样简单，维持2维数组碰撞。成形后消除，现发上来给大家研究下吧。

拼成如下图形后消失。

============核心源码===========
function 变量初始() {
    场景高格数 = 12;
    场景宽格数 = 12;
    单元格高宽 = 30;
    移动时间 = 1000;
    游戏结束 = false;
    场景数组 = new Array();
    //生成2维数组
    for (var i = 0; i<场景高格数; i++) {
        场景数组[i] = new Array();
        for (var j = 0; j<场景宽格数; j++) {
            场景数组[i][j] = 0;
            //动态生出测试文本
            this.createTextField("文本"+i+"@"+j, (i*场景高格数+j)*10, i*单元格高宽, j*单元格高宽, 100, 100);
            this["文本"+i+"@"+j].color = 0xff0000;
            this["文本"+i+"@"+j].text = 0;
        }
    }
    //
    出现位置 = [5, 0];
    方块数量 = 0;
    生成方块();
    //在原点上的增加位 2维增加位 [1,1],[0,0]  前2位为第1行,后2位为第2行
    形状数组 = [["无需数据"], [1, 0], [0, 1], [-1, 0], [0, -1]];
}
变量初始();
//
function 生成方块() {
    trace("ss");
    if (!游戏结束) {
        方块数量++;
        attachMovie("方块", "方块"+方块数量, 方块数量);
        形状 = int(random(4))+1;
        当前操作方块 = this["方块"+方块数量];
        this["方块"+方块数量].形状 = 形状;
        this["方块"+方块数量].gotoAndStop(形状);
        this["方块"+方块数量].运行 = 运行;
        this["方块"+方块数量].移动 = 移动;
        this["方块"+方块数量].计算可否移动 = 计算可否移动;
        this["方块"+方块数量]._x = 出现位置[0]*单元格高宽+15;
        this["方块"+方块数量]._y = 出现位置[1]*单元格高宽+15;
        this["方块"+方块数量].运行(移动时间, 形状);
    }
}
function 运行(移动时间, 形状) {
    this.移动间隔 = setInterval(移动, 移动时间, this);
}
function 移动($this) {
    //trace("移动 "+$this);
    $this._y += 30;
    //计算可否移动
    计算可否移动($this, $this._x, $this._y, $this.形状);
}
function 横向移动($this, 方向) {
    var 二维坐标 = [int($this._x/单元格高宽), int($this._y/单元格高宽)];
    //trace(二维坐标)
    if (方向 == "左" && (场景数组[二维坐标[0]-1][二维坐标[1]] == 0 && 场景数组[二维坐标[0]+形状数组[$this.形状][0]-1][二维坐标[1]+形状数组[$this.形状][1]] == 0)) {
        $this._x -= 30;
    } else if (方向 == "右" && (场景数组[二维坐标[0]+1][二维坐标[1]] == 0 && 场景数组[二维坐标[0]+形状数组[$this.形状][0]+1][二维坐标[1]+形状数组[$this.形状][1]] == 0)) {
        $this._x += 30;
    }
}
function 计算可否移动($this, X, Y, 形状) {
    当前2维坐标 = [int(X/单元格高宽), int(Y/单元格高宽)];
    //trace(当前2维坐标)
    //trace(场景数组[当前2维坐标[0]][当前2维坐标[1]+1]);
    //判断游戏是否结束
    //判断是否碰到阻碍
    if (场景数组[当前2维坐标[0]][当前2维坐标[1]+1] != 0 || 场景数组[当前2维坐标[0]+形状数组[$this.形状][0]][当前2维坐标[1]+形状数组[$this.形状][1]+1] != 0) {
        //trace("形状="+$this.形状);
        //trace("形状数组="+形状数组[$this.形状]);
        场景数组[当前2维坐标[0]][当前2维坐标[1]] = 1;
        this["文本"+当前2维坐标[0]+"@"+当前2维坐标[1]].text = 1;
        场景数组[当前2维坐标[0]+形状数组[形状][0]][当前2维坐标[1]+形状数组[$this.形状][1]] = 2;
        this["文本"+(当前2维坐标[0]+形状数组[$this.形状][0])+"@"+(当前2维坐标[1]+形状数组[$this.形状][1])].text = 1;
        //trace(this["文本"+(当前2维坐标[0]+形状数组[$this.形状][0])+"@"+(当前2维坐标[1]+形状数组[$this.形状][1])]);
        var temp形状 = $this.形状;
        clearInterval($this.移动间隔);
        $this.removeMovieClip();
        //trace(this["方块"+当前2维坐标[0]+"@"+当前2维坐标[1]]);
        //
        是否清除 = 判断可否消除();
        if (是否清除) {
        } else {
            //同位置生成
            attachMovie("方块", "方块"+当前2维坐标[0]+"@"+当前2维坐标[1], 方块数量);
            this["方块"+当前2维坐标[0]+"@"+当前2维坐标[1]]._x = 当前2维坐标[0]*单元格高宽+15;
            this["方块"+当前2维坐标[0]+"@"+当前2维坐标[1]]._y = 当前2维坐标[1]*单元格高宽+15;
            this["方块"+当前2维坐标[0]+"@"+当前2维坐标[1]].形状 = temp形状;
            this["方块"+当前2维坐标[0]+"@"+当前2维坐标[1]].gotoAndStop(temp形状);
        }
        if (当前2维坐标[1]-1 == 0 || (当前2维坐标[1]+形状数组[$this.形状][1])-1 == 0) {
            trace("======游戏结束=======");
            游戏结束 = true;
            return;
        } else {
            生成方块();
        }
    }
}
function 判断可否消除() {
    for (var i = 1; i<场景高格数-1; i++) {
        for (var j = 1; j<场景宽格数-1; j++) {
            if (场景数组[i-1][j-1] == 1 && 场景数组[i][j-1] == 2 && 场景数组[i+1][j-1] == 1 && 场景数组[i-1][j] == 2 && 场景数组[i+1][j] ==2 && 场景数组[i-1][j+1] == 1 && 场景数组[i][j+1] == 2 && 场景数组[i+1][j+1] == 1) {
                trace("拼成一个 "+i+"@"+j);
                this["文本"+(i-1)+"@"+(j-1)].text = 0;
                this["文本"+(i)+"@"+(j-1)].text = 0;
                this["文本"+(i+1)+"@"+(j-1)].text = 0;
                this["文本"+(i-1)+"@"+(j)].text = 0;
                this["文本"+(i+1)+"@"+(j)].text = 0;
                this["文本"+(i-1)+"@"+(j+1)].text = 0;
                this["文本"+(i)+"@"+(j+1)].text = 0;
                this["文本"+(i+1)+"@"+(j+1)].text = 0;
                //
                this["方块"+(i-1)+"@"+(j-1)].removeMovieClip();
                this["方块"+(i+1)+"@"+(j-1)].removeMovieClip();
                this["方块"+(i-1)+"@"+(j+1)].removeMovieClip();
                this["方块"+(i+1)+"@"+(j+1)].removeMovieClip();
                //
                场景数组[i-1][j-1] = 0;
                场景数组[i][j-1] = 0;
                场景数组[i+1][j-1] = 0;
                场景数组[i-1][j] = 0;
                场景数组[i+1][j] = 0;
                场景数组[i-1][j+1] = 0;
                场景数组[i][j+1] = 0;
                场景数组[i+1][j+1] = 0;
                return true;
            }
        }
    }
    return false;
}
//热键
var keyListener:Object = new Object();
keyListener.onKeyDown = function() {
    //trace(Key.getCode());
    //空格键
    if (Key.isDown(32) || Key.isDown(38)) {
        当前操作方块.形状++;
        if (当前操作方块.形状>4) {
            当前操作方块.形状 = 1;
        }
        当前操作方块.gotoAndStop(当前操作方块.形状);
    }
    //向下键
    if (Key.isDown(40)) {
        if (!游戏结束) {
            移动(当前操作方块);
        }
    }
    if (Key.isDown(37)) {
        横向移动(当前操作方块, "左");
    }
    if (Key.isDown(39)) {
        横向移动(当前操作方块, "右");
    }
};
Key.addListener(keyListener);
//=====================================
//
//转载请注明出处：羽柴鬼铃-blog  www.ycflash.com/blog
//
//=====================================

源码下载：
点击下载此文件

RPG地图程序模块

yuchaiyuwei@163.com(admin) — Fri,14 Sep 2007 13:01:47 +0800

功能说明：
RPG 45度地图编辑器

特色：
windows人性化操作，支持Ctrl键多选地图单元，或shift点头再点结束点选启矩形区域。* windows的鼠标框选地图操作，按住鼠标拖动放开鼠标选中区域。

后期修改:
1 修改物体深度的bug
//=====================================
//
//转载请注明出处：羽柴鬼铃-blog
// www.ycflash.com/blog
//
//=====================================

点击下载此文件

网络版21点第1步：游戏准备+发牌动作

yuchaiyuwei@163.com(admin) — Fri,14 Sep 2007 12:42:39 +0800

一直以来有很多朋友都要我提供一些FLASH+FMS 开发的教程或样例。由于时间太忙，而且要做的事情也太多。挑了21点来做，然后共享给大家。但工作关系，只能一步一步的增加完善。请自行安装FMS服务端软件把源文件中的card21文件夹放至服务端 applications目录中
//----------------------------------------------------------------------------
//================客户端代码如下：================
//----------------------------------------------------------------------------
myinfo = new Object();
//测试用户
myname = "临时"+int(random(99));
myinfo = ({姓名:myname, 积分:1000});
//===================连接实例===============
// 客户端连接
nc = new NetConnection();
// 处理来自伺候器的任何状态变化和反应
nc.onStatus = function(info) {
    //连接成功进入
    if (info.code == "NetConnection.Connect.Success") {
        trace("连接成功");
        准备按钮._visible = true;
    } else if (info.code == "NetConnection.Connect.Closed") {
        trace("断开连接 ");
    } else if (info.code == "NetConnection.Connect.Rejected") {
        trace("无法连接出错信息="+info.application.message);
    }
};
nc.connect("rtmp:/card21", myinfo);
显隐牌 = function (id, 显隐, index, 长度) {
    if (index == undefined) {
        index = 0;
    }
    if (长度 == undefined) {
        长度 = 5;
    }
    for (var i = index; i        this["玩家牌"+id+i]._visible = 显隐;
    }
};
牌形 = function (对象, 点数, 花色) {
    //trace(this["牌组"+myID]);
    //牌形
    //改变牌形
    trace("执行牌形 "+对象+" "+花色+" "+点数);
    //把数字花色换为字符花色
    if (花色 == 0) {
        花色 = "方块";
    } else if (花色 == 1) {
        花色 = "梅花";
    } else if (花色 == 2) {
        花色 = "红桃";
    } else if (花色 == 3) {
        花色 = "黑桃";
    }
    对象.黑桃._visible = false;
    对象.红桃._visible = false;
    对象.梅花._visible = false;
    对象.方块._visible = false;
    对象.王._visible = false;
    对象[花色]._visible = true;
    对象[花色].gotoAndStop(点数);
};
初始数据 = function () {
    //让所有牌隐藏
    for (var i = 0; i<6; i++) {
        显隐牌(i, false);
    }
    准备按钮._visible = false;
};
初始数据();
//==============按钮事件==============
准备按钮.onRelease = function() {
    nc.call("game_start");
    this._visible = false;
};
//
//=============服务端传来事件==========
thisObj = this;
nc.开始游戏 = function(牌组) {
    trace("开始游戏");
    //显示刷新牌
    for (var i = 0; i<5; i++) {
        trace(牌组[i]);
        显隐牌(i, true, 0, 牌组[i].length);
        for (var j = 0; j<牌组[i].length; j++) {
            牌形(thisObj["玩家牌"+i+j], 牌组[i][j][0], 牌组[i][j][1]);
        }
    }
};

//----------------------------------------------------------------------------
//================服务端代码如下：================
//----------------------------------------------------------------------------

//==========================
thisObj=this
new_data = function () {
    //最大玩家
    p_max = 6;
    //每个玩家牌初始
    gm_start=new Array()
    cards = new Array();
    for (var i = 0; i<6; i++) {
        cards[i] = new Array();
        gm_start[i]=false
    }
    //游戏是否开始
    game_strat=false

};
//-----------------------
new_data();
//-------------
//玩家群信息
p_info = new Array();
for (var i = 0; i    p_info[i] = new Object();
}
//p_score = [0, 0, 0];
//IP群
ip_array = ["", "", ""];
//----------------------------------------

//-----------------------------------------------------------
application.onConnect = function(newClient,  my_info) {
    var err = new Object();
    if (!game_strat) {
        //分配ID索引
        for (var i = 0; i            if (p_info[i]["姓名"] == undefined) {
                application.acceptConnection(newClient);
                trace("分配ID "+i);
                newClient.nickname = my_info["姓名"];
                newClient.myID = i;
                p_info[i] = my_info;
                newClient.call("初始数据", null, i);
                //统计人数并跳出循环
                return;
            }
        }
        err.message = "人数已满";
        application.rejectConnection(newClient,err);
    } else {
        err.message = "已经开始游戏";
        application.rejectConnection(newClient,err);
    }
};
application.onDisconnect = function(newClient) {
    p_info[newClient.myID]=new Object()
    //删除大厅列表数据
    if (newClient.myID != undefined) {
        if (game_strat) {
            trace("游戏开始时有玩家退出");
            game_strat=false
            new_data()
        } else {
        }
    }
};
//检测在线情况
online = function () {
    //trace("30秒检测在线情况");
    for (var i = 0; i        if (application.clients[i].ping()) {
        } else {
            application.disconnect(application.clients[i]);
        }
    }
};
setInterval(online, 30000);
//-----------------------------------------------
//--------------------游戏开始函数----------------
//multiple:倍率用于开始下注
Client.prototype.game_start = function(multiple) {
    //让开始数组中的自己开始
    gm_start[this.myID] = true;
    //追加自己的信息
    //p_info[this.myID] = my_info;
    //准备数
    var st_count = 0;
    //判断是否都开始游戏了
    for (var i = 0; i        if (gm_start[i]) {
            st_count++;
        }
    }
    //全部都准备了 2玩家以上才能开始
    if (st_count == application.clients.length  && st_count>=2) {
        trace("开始游戏")
        game_strat = true;
        //洗牌
        shuffle();
        //抽牌
        for (var i = 0; i            //判断是否该玩家开始才抽牌
            if (gm_start[i]) {
                //初始抽取2张牌
                pickUp_card(i)
                pickUp_card(i)
            }
        }
        //发送牌数据给客户端
        application.broadcastMsg("开始游戏",cards)
    }
    //
};
//--------------------------------------------------------------------
//洗牌函数
shuffle = function () {
    //动态设置allcard52张
    allcard = new Array();
    for (var i = 0; i<4; i++) {
        for (var j = 3; j<=15; j++) {
            allcard.push([j, i]);
        }
    }
};
//提取牌参数说明：取牌ID
pickUp_card = function (id) {
    //随机取出一张牌
    var tempID = Math.floor(Math.random()*allcard.length);
    var tempCard = allcard.splice(tempID, 1);
    cards[id].push(tempCard[0]);
};
//
//=====================================================================
//O==[]:::::::::::::::::::::>
//
//O:::::::::::::::::::::::[]->
//=====================================================================
//--------------------------****核心算法***----------------------------
//主要执行的函数判断并评估牌值
estimate_card = function (choose_card) {
           //待加中
};

//=====================================
//
//转载请注明出处：羽柴鬼铃-blog
//     www.ycflash.com/blog
//
//=====================================

源码：
点击下载此文件

棋牌游戏梭哈发牌和比牌算法

yuchaiyuwei@163.com(admin) — Thu,06 Sep 2007 09:43:58 +0800

//梭哈发牌和比牌算法
演示如下：

Flash动画

在线播放

牌形 = function (对象, 花色, 点数) {
    //trace("执行牌形 "+对象+" "+花色+" "+点数);
    //把数字花色换为字符花色
    if (花色 == 0) {
        花色 = "方块";
    } else if (花色 == 1) {
        花色 = "梅花";
    } else if (花色 == 2) {
        花色 = "红桃";
    } else if (花色 == 3) {
        花色 = "黑桃";
    }
    this[对象].黑桃._visible = false;
    this[对象].红桃._visible = false;
    this[对象].梅花._visible = false;
    this[对象].方块._visible = false;
    this[对象][花色]._visible = true;
    this[对象][花色].gotoAndStop(点数);
};
洗牌 = function () {
    //动态设置总牌52张
    var 总牌:Array = new Array();
    for (var i = 0; i<4; i++) {
        for (var j = 8; j<=14; j++) {
            总牌.push([i, j]);
        }
    }
    //设置玩家的牌组
    //5个玩家
    for (var i = 1; i<=5; i++) {
        this["牌组"+i] = new Array();
        //发牌数据给玩家(5张)
        for (var j = 1; j<=5; j++) {
            //随机抽总牌
            var 随机值 = int(random(总牌.length));
            //添进牌组
            var 抽中值 = 总牌.splice(随机值, 1);
            this["牌组"+i].push(抽中值[0]);
            //让牌数据形象化
            牌形(("玩家"+i+j), 抽中值[0][0], 抽中值[0][1]);
            //this["玩家"+i+j].牌形(this["牌组"+i][0, this["牌组"+i][1]]);
        }
    }
    /*
    for (var i = 1; i<=4; i++) {
    trace(this["牌组"+i]);
    }
    */
};
洗牌();
//牌级分类
类型数组 = ["散牌", "对子", "双对", "三条", "顺子", "同花", "葫芦", "铁支", "同花顺"];
判断牌类型 = function (牌, 判断起始) {
    牌数 = 牌.length;
    var 牌组 = new Array();
    //设置默认值
    if (判断起始 == undefined) {
        判断起始 = 0;
    }
    if (牌数 == undefined) {
        牌数 = 5;
    }
    var 最终类型 = "";
    var 追加值 = [0, 0];
    牌数--;
    //排序
    if (判断起始 == 0) {
        //trace("排序牌");
        牌组 = 牌;
    } else {
        for (var i = 判断起始; i<=牌数; i++) {
            牌组.push(牌[i]);
        }
    }
    牌组.sortOn(1, 2 | 16);
    //trace(牌组);
    //临时显示
    /*
    var 显示 = "";
    for (var i = 0; i<牌数; i++) {
    显示 += 牌组[i][1]+" ";
    }
    //trace(显示);
    //
    */
    //牌数为4 从0算起
    if (牌数 == 4) {
        var 对比值 = 牌组[0][1];
        //检测是否是顺子
        for (var i = 1; i<5; i++) {
            对比值--;
            if (对比值 != 牌组[i][1]) {
                //返回不是同花顺也不是顺子
                //return false;
                最终类型 = 0;
                break;
            }
        }
        //检测是否是同花
        var 对比值 = 牌组[0][0];
        for (var i = 1; i<5; i++) {
            if (对比值 != 牌组[i][0]) {
                if (最终类型 != 0) {
                    最终类型 = 4;
                    break;
                }
            }
        }
        if (最终类型 == "") {
            最终类型 = 8;
        }
    } else {
        最终类型 = 0;
    }
    //追加最大牌的花色和牌面
    if (判断起始 == 0) {
        追加值 = [牌组[0][1], 牌组[0][0]];
    } else {
        追加值 = [牌组[判断起始-1][1], 牌组[判断起始-1][0]];
    }
    //检查对子
    var 对比值 = 0;
    var 牌类型 = 0;
    var 对子数 = 1;
    var 最终对子数 = 0;
    var temp = 0;
    if (判断起始 != 0) {
        判断起始--;
    }
    for (var i = 判断起始; i<=牌数; i++) {
        /*
        trace("");
        trace("i="+i);
        trace("对比值"+对比值);
        trace("牌值"+牌组[i][1]);
        */
        if (对比值 != 牌组[i][1]) {
            //trace("牌不同");
            if (对子数>最终对子数) {
                最终对子数 = 对子数;
                //trace("最终对子数"+最终对子数);
            }
            对子数 = 1;
            对比值 = 牌组[i][1];
            //牌类如果全散牌为5点。2对为2类或3类
            牌类型++;
        } else {
            //trace("牌同");
            //对子数++;
            对子数++;
            //对子数追加
            //单对追加
            if (temp == 0 or 对子数>=3) {
                追加值[0] = 牌组[i][1];
                追加值[1] = 0;
                temp = 牌类型;
            } else if (temp != 牌类型) {
                //双对追加
                if (追加值[0]>牌组[i][1]) {
                    追加值[1] = 牌组[i][1];
                } else {
                    //当位置1小于位置2时换位
                    var temp_h = 追加值[0];
                    追加值[0] = 牌组[i][1];
                    追加值[1] = temp_h;
                }
            }
        }
    }
    if (对子数>最终对子数) {
        最终对子数 = 对子数;
        //trace("最终对子数"+最终对子数);
    }
    //判断类型
    var 类型值 = [牌类型, 最终对子数];
    trace("类型值="+类型值);
    if (类型值.toString() == "2,4") {
        //4带1
        最终类型 = 7;
    } else if (类型值.toString() == "2,3") {
        //3带对
        最终类型 = 6;
    } else if (类型值.toString() == (牌数-1)+",3") {
        //3带1
        最终类型 = 3;
    } else if (类型值.toString() == (牌数-1)+",2") {
        //双对
        最终类型 = 2;
    } else if (类型值.toString() == 牌数+",2") {
        //单对
        最终类型 = 1;
    }
    //判断同色
    if (牌数 == 4) {
        if (最终类型 != 8) {
            var 对比值 = 牌组[0][0];
            for (var i = 1; i<5; i++) {
                if (对比值 != 牌组[i][0]) {
                    i = 10;
                }
            }
            //trace(i);
            if (i == 5) {
                最终类型 = 5;
            }
        }
    }
    //trace("追加值="+追加值);
    //trace(最终类型);
    trace("牌类型及大小： "+[最终类型, 追加值[0], 追加值[1]]);
    trace("");
    return [最终类型, 追加值[0], 追加值[1]];
};
//比较牌大小
比较牌 = function () {
    //显示各玩家牌级
    比牌级 = new Array();
    for (var i = 1; i<=5; i++) {
        返回值 = 判断牌类型(this["牌组"+i], 0);
        返回值.push("牌组"+i);
        比牌级.push(返回值);
        this["状态"+i].text = 类型数组[返回值[0]];
    }
    比牌级.sortOn([0, 1, 2], 2 | 16);
    //trace(比牌级);
    //trace(比牌级[0][3]);
    //显示
    for (var i = 0; i<5; i++) {
        _root["大小"+比牌级[i][3].charAt(2)].text = "第"+(i+1);
    }
};
比较牌();
//按钮重刷
button1.onRelease = function() {
    trace("---------------------");
    洗牌();
    比较牌();
};

//=====================================
//
//转载请注明出处：羽柴鬼铃-blog
//     www.ycflash.com/blog
//
//=====================================
点击下载此文件

如果让大家了解牌类游戏的网络化编写。

yuchaiyuwei@163.com(admin) — Fri,24 Aug 2007 14:50:47 +0800

从建了blog后，有很多同行朋友让我多提供网络游戏的编写教程。当然由于自己的工作情况，我只能抽取业余时间来完成。在后面的日子，我就用简单的牌类游戏21点，做成网络版。并写成相关教程，教大家如何把棋牌游戏编写成网络化的。因为只是用业余时间，只能在后面一步一步加入所以请大家多多见谅。