[MMX指令版]黑白棋行动力的计算--指令拆分整理版（方便分析研究）

最新推荐文章于 2014-07-28 20:14:49 发布
最新推荐文章于 2014-07-28 20:14:49 发布
阅读量2.8k 收藏 1
点赞数
分类专栏： 黑白棋思想 文章标签： 汇编 数据结构 c 扩展 struct byte
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/shines/article/details/255735
版权

这个是去掉MMX指令配对和汇编指令配对，经过整理后的代码，阅读上应该更加直观一些，对于你理解其bitboard原理应该有很大的帮助，关于MMX指令的相关资料可以到google.com搜索一下，make_bitboard()函数是我的程序里的代码，由于篇幅不能列出所有代码，但我想聪明的你应该可以知道代码的大概意思。

有趣的是，经过整理，我发现有一句汇编指令是多余的，不知道是为了要配对还是什么其他原因。（不过是很久以前发现的，现在不记得了，你可以再次证实一下，在代码的末尾）

聪明的你也应该知道，这样不完全配对的指令，运行效率是很低的。

注：字体稍微增大了一号，优快云这个编辑器好难用哦，不过好歹看起来已经不错了。 

define   THITHER_COLOR(color)  ((~color)&0x03)


typedef struct
{
    UINT8 board[BOARD_ROWS+2][BOARD_COLS+2];
}   board_type;



static unsigned __int64 dir_mask0;
static unsigned __int64 dir_mask1;
static unsigned __int64 dir_mask2;
static unsigned __int64 dir_mask3;
static unsigned __int64 dir_mask4;
static unsigned __int64 dir_mask5;
static unsigned __int64 dir_mask6;
static unsigned __int64 dir_mask7;
static unsigned __int64 c0f;
static unsigned __int64 c33;
static unsigned __int64 c55;


void init_mmx( void )
{
    dir_mask0 = 0x007e7e7e7e7e7e00;
    dir_mask1 = 0x00ffffffffffff00;
    dir_mask2 = 0x007e7e7e7e7e7e00;
    dir_mask3 = 0x7e7e7e7e7e7e7e7e;
    dir_mask4 = 0x7e7e7e7e7e7e7e7e;
    dir_mask5 = 0x007e7e7e7e7e7e00;
    dir_mask6 = 0x00ffffffffffff00;
    dir_mask7 = 0x007e7e7e7e7e7e00;
    c0f = 0x0f0f0f0f0f0f0f0f;
    c33 = 0x3333333333333333;
    c55 = 0x5555555555555555;
}


void make_bitboard( board_type *board_ptr,
                   BitBoard &my_bits,
                   BitBoard &opp_bits,
                   UINT8 objcolor )
{
    UINT8 curcolor;
    UINT8 thithercolor = THITHER_COLOR(objcolor);
/*
    my_bits.high  = 0;
    my_bits.low   = 0;
    opp_bits.high = 0;
    opp_bits.low  = 0;
*/
    unsigned __int64 power = 0x0000000000000001;
    unsigned __int64 my_bits64  = 0x0000000000000000;
    unsigned __int64 opp_bits64 = 0x0000000000000000;


    for(int i=BOARD_ROWS; i>=1; i--)
    {
        for(int j=BOARD_COLS; j>=1; j--)
        {
            curcolor = board_ptr->board[i][j];
            if(curcolor == objcolor)
                my_bits64 |= power;
            else if(curcolor == thithercolor)
                opp_bits64 |= power;
            power <<= 1;
        }
    }


    my_bits.high  = (unsigned long)(my_bits64 >> 32);
    my_bits.low   = (unsigned long)(my_bits64 & 0xffffffff);
    opp_bits.high = (unsigned long)(opp_bits64 >> 32);
    opp_bits.low  = (unsigned long)(opp_bits64 & 0xffffffff);
}


int bitboard_mobility( const BitBoard my_bits, const BitBoard opp_bits )
{
    unsigned int count;
    //unsigned int count = 0;


    __asm {
        //push  eax                     ;
        /*
        push    ecx                     ;
        push    edx                     ;
        push    ebx                     ;
        push    esi                     ;
        push    edi                     ;
        //*/
        /* Ready for init data */
        //mov       eax, 0
        mov     ebx, my_bits.high       ;
        mov     ecx, my_bits.low        ;
        mov     edi, opp_bits.high      ;
        mov     esi, opp_bits.low       ;


        //
        movd    mm0, ebx                ;
        psllq   mm0, 32                 ;
        movd    mm3, ecx                ;
        por     mm0, mm3                ; mm0 is BitBoard of my_bits
        movd    mm1, edi                ;
        psllq   mm1, 32                 ;
        movd    mm4, esi                ;
        por     mm1, mm4                ; mm1 is BitBoard of opp_bits
        pxor    mm2, mm2                ; mm2 <- 0x0000000000000000



        /* shift=-9   rowDelta=-1   colDelta=-1 */
        /* shift=+9   rowDelta=+1   colDelta=+1 */


        /* Disc #1, flip direction 0. */
        /* Disc #1, flip direction 7. */
        movq    mm3, mm1                ; mm3 <- opp_bits
        movq    mm4, mm0                ; mm4 <- my_bits
        movq    mm6, mm0                ; mm6 <- backup of my_bits
        pand    mm3, dir_mask0          ; 0x007e7e7e7e7e7e00
                                        ; dir_mask0 of value:  
                                        ;   00000000
                                        ;   01111110
                                        ;   01111110
                                        ;   01111110
                                        ;   01111110
                                        ;   01111110
                                        ;   01111110
                                        ;   00000000
        psllq   mm4, 9                  ;
        psrlq   mm6, 9                  ;
        pand    mm4, mm3                ;
        pand    mm6, mm3                ;


        /* Disc #2, flip direction 0. */
        /* Disc #2, flip direction 7. */
        movq    mm5, mm4                ;
        movq    mm7, mm6                ;
        psllq   mm5, 9                  ;
        psrlq   mm7, 9                  ;
        pand    mm5, mm3                ;
        pand    mm7, mm3                ;
        por     mm4, mm5                ;
        por     mm6, mm7                ;


        /* Disc #3, flip direction 0. */
        /* Disc #3, flip direction 7. */
        movq    mm5, mm4                ;
        movq    mm7, mm6                ;
        psllq   mm5, 9                  ;
        psrlq   mm7, 9                  ;
        pand    mm5, mm3                ;
        pand    mm7, mm3                ;
        por     mm4, mm5                ;
        por     mm6, mm7                ;


        /* Disc #4, flip direction 0. */
        /* Disc #4, flip direction 7. */
        movq    mm5, mm4                ;
        movq    mm7, mm6                ;
        psllq   mm5, 9                  ;
        psrlq   mm7, 9                  ;
        pand    mm5, mm3                ;
        pand    mm7, mm3                ;
        por     mm4, mm5                ;
        por     mm6, mm7                ;


        /* Disc #5, flip direction 0. */
        /* Disc #5, flip direction 7. */
        movq    mm5, mm4                ;
        movq    mm7, mm6                ;
        psllq   mm5, 9                  ;
        psrlq   mm7, 9                  ;
        pand    mm5, mm3                ;
        pand    mm7, mm3                ;
        por     mm4, mm5                ;
        por     mm6, mm7                ;


        /* Disc #6, flip direction 0. */
        /* Disc #6, flip direction 7. */
        movq    mm5, mm4                ;
        movq    mm7, mm6                ;
        psrlq   mm7, 9                  ;
        psllq   mm5, 9                  ;
        pand    mm5, mm3                ;
        pand    mm7, mm3                ;
        por     mm4, mm5                ;
        por     mm6, mm7                ;
        psllq   mm4, 9                  ;
        psrlq   mm6, 9                  ;
        por     mm2, mm4                ;
        por     mm2, mm6                ;



        /* *************************** */
        push    esi                     ;
        push    edi                     ;
        push    ecx                     ;
        push    ebx                     ;


        and     edi, 0x7e7e7e7e         ; 0x7e7e7e7e
        and     esi, 0x7e7e7e7e         ; 0x7e7e7e7e
                                        ; value of:
                                        ; 011111110
                                        ; 011111110
                                        ; 011111110
                                        ; 011111110
        shl     ebx, 1                  ;
        shl     ecx, 1                  ;
        and     ebx, edi                ;
        and     ecx, esi                ;
        mov     eax, ebx                ;
        mov     edx, ecx                ;
        shl     edx, 1                  ;
        shl     eax, 1                  ;
        and     eax, edi                ;
        and     edx, esi                ;
        or      ebx, eax                ;
        or      ecx, edx                ;
        mov     eax, ebx                ;
        mov     edx, ecx                ;
        shl     edx, 1                  ;
        shl     eax, 1                  ;
        and     eax, edi                ;
        and     edx, esi                ;
        or      ebx, eax                ;
        or      ecx, edx                ;
        mov     eax, ebx                ;
        mov     edx, ecx                ;
        shl     edx, 1                  ;
        shl     eax, 1                  ;
        and     eax, edi                ;
        and     edx, esi                ;
        or      ebx, eax                ;
        or      ecx, edx                ;
        mov     eax, ebx                ;
        mov     edx, ecx                ;
        shl     edx, 1                  ;
        shl     eax, 1                  ;
        and     eax, edi                ;
        and     edx, esi                ;
        or      ebx, eax                ;
        or      ecx, edx                ;
        mov     eax, ebx                ;
        mov     edx, ecx                ;
        shl     edx, 1                  ;
        shl     eax, 1                  ;
        and     eax, edi                ;
        and     edx, esi                ;
        or      ebx, eax                ;
        or      ecx, edx                ;
        shl     ebx, 1                  ;
        shl     ecx, 1                  ;
        /* *************************** */



        /* shift=-8   rowDelta=-1   colDelta=0 */
        /* shift=+8   rowDelta=1   colDelta=0 */


        /* Disc #1, flip direction 1. */
        /* Disc #1, flip direction 6. */
        movq    mm3, mm1                ;
        movq    mm4, mm0                ;
        movq    mm6, mm0                ;
        pand    mm3, dir_mask1          ; 0x00ffffffffffff00;
                                        ; dir_mask1 of value:
                                        ;   00000000
                                        ;   11111111
                                        ;   11111111
                                        ;   11111111
                                        ;   11111111
                                        ;   11111111
                                        ;   11111111
                                        ;   00000000
        psllq   mm4, 8                  ;
        psrlq   mm6, 8                  ;


        pand    mm4, mm3                ;
        pand    mm6, mm3                ;


        /* Disc #2, flip direction 1. */
        /* Disc #2, flip direction 6. */
        movq    mm5, mm4                ;
        movq    mm7, mm6                ;
        psllq   mm5, 8                  ;
        psrlq   mm7, 8                  ;
        pand    mm5, mm3                ;
        pand    mm7, mm3                ;
        por     mm4, mm5                ;
        por     mm6, mm7                ;


        /* serialize here: add horizontal shl flips. */


        movd    mm5, ebx                ;
        psllq   mm5, 32                 ;
        movd    mm7, ecx                ;
        por     mm5, mm7                ;
        por     mm2, mm5                ;


        /* Disc #3, flip direction 1. */
        /* Disc #3, flip direction 6. */
        movq    mm5, mm4                ;
        movq    mm7, mm6                ;
        psllq   mm5, 8                  ;
        psrlq   mm7, 8                  ;
        pand    mm5, mm3                ;
        pand    mm7, mm3                ;
        por     mm4, mm5                ;
        por     mm6, mm7                ;


        /* Disc #4, flip direction 1. */
        /* Disc #4, flip direction 6. */
        movq    mm5, mm4                ;
        movq    mm7, mm6                ;
        psllq   mm5, 8                  ;
        psrlq   mm7, 8                  ;
        pand    mm5, mm3                ;
        pand    mm7, mm3                ;
        por     mm4, mm5                ;
        por     mm6, mm7                ;


        /* Disc #5, flip direction 1. */
        /* Disc #5, flip direction 6. */
        movq    mm5, mm4                ;
        movq    mm7, mm6                ;
        psllq   mm5, 8                  ;
        psrlq   mm7, 8                  ;
        pand    mm5, mm3                ;
        pand    mm7, mm3                ;
        por     mm4, mm5                ;
        por     mm6, mm7                ;


        /* Disc #6, flip direction 1. */
        /* Disc #6, flip direction 6. */
        movq    mm5, mm4                ;
        movq    mm7, mm6                ;
        psllq   mm5, 8                  ;
        psrlq   mm7, 8                  ;
        pand    mm5, mm3                ;
        pand    mm7, mm3                ;
        por     mm4, mm5                ;
        por     mm6, mm7                ;
        psllq   mm4, 8                  ;
        psrlq   mm6, 8                  ;
        por     mm2, mm4                ;
        por     mm2, mm6                ;



        /* *************************** */
        pop     ebx                     ;
        pop     ecx                     ;
        push    ecx                     ;
        push    ebx                     ;


        shr     ebx, 1                  ;
        shr     ecx, 1                  ;
        and     ebx, edi                ; edi = 0x7e7e7e7e
        and     ecx, esi                ; esi = 0x7e7e7e7e
                                        ; value of:
                                        ; 011111110
                                        ; 011111110
                                        ; 011111110
                                        ; 011111110
        mov     eax, ebx                ;
        mov     edx, ecx                ;
        shr     eax, 1                  ;
        shr     edx, 1                  ;
        and     eax, edi                ;
        and     edx, esi                ;
        or      ebx, eax                ;
        or      ecx, edx                ;
        mov     eax, ebx                ;
        mov     edx, ecx                ;
        shr     eax, 1                  ;
        shr     edx, 1                  ;
        and     eax, edi                ;
        and     edx, esi                ;
        or      ebx, eax                ;
        or      ecx, edx                ;
        mov     eax, ebx                ;
        mov     edx, ecx                ;
        shr     eax, 1                  ;
        shr     edx, 1                  ;
        and     eax, edi                ;
        and     edx, esi                ;
        or      ebx, eax                ;
        or      ecx, edx                ;
        mov     eax, ebx                ;
        mov     edx, ecx                ;
        shr     eax, 1                  ;
        shr     edx, 1                  ;
        and     eax, edi                ;
        and     edx, esi                ;
        or      ebx, eax                ;
        or      ecx, edx                ;
        mov     eax, ebx                ;
        mov     edx, ecx                ;
        shr     eax, 1                  ;
        shr     edx, 1                  ;
        and     eax, edi                ;
        and     edx, esi                ;
        or      ebx, eax                ;
        or      ecx, edx                ;
        mov     eax, ebx                ;
        mov     edx, ecx                ;
        shr     eax, 1                  ;
        shr     edx, 1                  ;
        and     eax, edi                ;
        and     edx, esi                ;
        or      ebx, eax                ;
        or      ecx, edx                ;
        shr     ebx, 1                  ;
        shr     ecx, 1                  ;
        /* *************************** */



        /* shift=-7   rowDelta=-1   colDelta=1 */
        /* shift=+7   rowDelta=1   colDelta=-1 */


        /* Disc #1, flip direction 2. */
        /* Disc #1, flip direction 5. */
        movq    mm3, mm1                ;
        movq    mm4, mm0                ;
        movq    mm6, mm0                ;
        pand    mm3, dir_mask2          ; 0x007e7e7e7e7e7e00;
                                        ; dir_mask2 of value:
                                        ;   00000000
                                        ;   01111110
                                        ;   01111110
                                        ;   01111110
                                        ;   01111110
                                        ;   01111110
                                        ;   01111110
                                        ;   00000000
        psllq   mm4, 7                  ;
        psrlq   mm6, 7                  ;
        pand    mm4, mm3                ;
        pand    mm6, mm3                ;


        /* Disc #2, flip direction 2. */
        /* Disc #2, flip direction 5. */
        movq    mm5, mm4                ;
        movq    mm7, mm6                ;
        psllq   mm5, 7                  ;
        psrlq   mm7, 7                  ;
        pand    mm5, mm3                ;
        pand    mm7, mm3                ;
        por     mm4, mm5                ;
        por     mm6, mm7                ;


        /* Disc #3, flip direction 2. */
        /* Disc #3, flip direction 5. */
        movq    mm5, mm4                ;
        movq    mm7, mm6                ;
        psllq   mm5, 7                  ;
        psrlq   mm7, 7                  ;
        pand    mm5, mm3                ;
        pand    mm7, mm3                ;
        por     mm4, mm5                ;
        por     mm6, mm7                ;


        /* Disc #4, flip direction 2. */
        /* Disc #4, flip direction 5. */
        movq    mm5, mm4                ;
        movq    mm7, mm6                ;
        psllq   mm5, 7                  ;
        psrlq   mm7, 7                  ;
        pand    mm5, mm3                ;
        pand    mm7, mm3                ;
        por     mm4, mm5                ;
        por     mm6, mm7                ;


        /* Disc #5, flip direction 2. */
        /* Disc #5, flip direction 5. */
        movq    mm5, mm4                ;
        movq    mm7, mm6                ;
        psllq   mm5, 7                  ;
        psrlq   mm7, 7                  ;
        pand    mm5, mm3                ;
        pand    mm7, mm3                ;
        por     mm4, mm5                ;
        por     mm6, mm7                ;


        /* serialize here: add horizontal shr flips. */


        movd    mm5, ebx                ;
        psllq   mm5, 32                 ;
        movd    mm7, ecx                ;
        por     mm5, mm7                ;
        por     mm2, mm5                ;


        pop     ebx                     ;
        pop     ecx                     ;
        pop     edi                     ;
        pop     esi                     ;


        /* Disc #6, flip direction 2. */
        /* Disc #6, flip direction 5. */
        movq    mm5, mm4                ;
        movq    mm7, mm6                ;
        psllq   mm5, 7                  ;
        psrlq   mm7, 7                  ;
        pand    mm5, mm3                ;
        pand    mm7, mm3                ;
        por     mm4, mm5                ;
        por     mm6, mm7                ;
        psllq   mm4, 7                  ;
        psrlq   mm6, 7                  ;
        por     mm2, mm4                ;
        por     mm2, mm6                ;


        /* mm2 is the pseudo-feasible moves at this point. */
        /* Let mm7 be the feasible moves, i.e., mm2 restricted to empty squares. */


        movq    mm7, mm0                ;
        por     mm7, mm1                ;
        pandn   mm7, mm2                ;


        /* Count the moves, i.e., the number of bits set in mm7. */


        movq    mm1, mm7                ;
        psrld   mm7, 1                  ;
        pand    mm7, c55                ; c55 = 0x5555555555555555
        psubd   mm1, mm7                ;
        movq    mm7, mm1                ;
        psrld   mm1, 2                  ;
        pand    mm7, c33                ; c33 = 0x3333333333333333;
        pand    mm1, c33                ; c33 = 0x3333333333333333;
        paddd   mm7, mm1                ;
        movq    mm1, mm7                ;
        psrld   mm7, 4                  ;
        paddd   mm7, mm1                ;
        pand    mm7, c0f                ; c0f = 0x0f0f0f0f0f0f0f0f;
        movq    mm1, mm7                ;
        psrld   mm7, 8                  ;
        paddd   mm7, mm1                ;
        movq    mm1, mm7                ;
        psrld   mm7, 16                 ;
        paddd   mm7, mm1                ;
        movq    mm1, mm7                ;
        psrlq   mm7, 32                 ;
        paddd   mm7, mm1                ;
        movd    eax, mm7                ;
        and     eax, 63                 ;
        mov     count, eax              ;
        //
        //
        emms                            ;


        /*
        pop     edi                     ;
        pop     esi                     ;
        pop     ebx                     ;
        pop     edx                     ;
        pop     ecx                     ;
        //*/
        //pop       eax                     ;
    }
    return count;
}

附：

MMX的数据结构
多媒体软件具有如下显著的特点：
1、 小整型数据类型（图形数据为8位 ，声频数据为16位）
2、 对小整型数据的频繁且重复的计算操作（例如被频繁的调用的核心算法）；
3、 许多操作具有内存的并行性（例如对大量的数据进行同一个加，减或乘法运算操作）；

MMX技术设计了一套基本的，通用的紧缩整形指令，共57条。

所谓“紧缩整形数据”是指多个8/16/32位的整形数据组合成为一个64位的数据.MMX指令主要就是使用
这种紧缩整形数据，它又分成4种整形类型：紧缩字节、紧缩字、紧缩双字、紧缩4字

。紧缩字节（Packed Byte）: 8个字节组合成一个64位的数据；
。紧缩字 （Packed Word）: 4个字组合成一个64位的数据；
。紧缩双字（Packed Doubleword）: 2个双字组合成一个64位的数据；
。紧缩4字 （Packed Quadword）:一个64位数据

这样一条MMX指令就能够同时处理8/4/2个数据单元，这就是所谓的“单指令多数据SIMD”结构。这种结构
是MMX技术把机器性能提高的最根本因素。

为了方便使用64位紧缩整形数据,MMX技术含有8个64位的MMX寄存器（MM0-----MM7），只有MMX指令可以使用MMX寄存器。


值得一提的是，MMX寄存器是随机存取的，但实际上是借用了8个浮点数据寄存器实现的。浮点处理单元FPU有8个浮点寄存器FPR，以堆栈方式存取。每个浮点数据寄存器有80位，高16位用于指数和符号，低64位用于有效数字。MMX利用其64位有效数字部分用做随机存取的64位的MMX寄存器。


 MMX指令集
1、算术运算：
PADD[B、W、D] 环绕加[字节，字，双字]
PADDS[B , W] 有符号饱和加[字节，字]
PADDUS[B , W] 无符号饱和加[字节，字]
PSUB[B、W、D] 环绕减[字节，字，双字]
PSUBS[B,W] 有符号饱和减[字节，字]
PSUBUS[D,W] 无符号饱和减【字节，字】
PMULHW 紧缩字乘后取高位
PMULLW 紧缩字乘后取低位
PMADDWD 紧缩字乘，积相加

2、比较：
PCMPEQ[B,W,D] 紧缩比较是否相等【字节，字，双字】
PCMPGT[B,W,D] 紧缩比较是否大于【字节，字，双字】

3、类型转换：
PACKUSWB 按无符号饱和压缩【字成字节】
PACKSS[WB,DW] 按有符号饱和压缩【字/双字成/字节/字】
PUNPCKH[BW,WD,DQ] 扩展高位【字节，字，双字成字，双字，4字】
PUNPCKL[BW,WD,DQ] 扩展地位【字节，字，双字成字，双字，4字】

4、逻辑运算：
PAND 紧缩逻辑与
PANDN 紧缩逻辑与非
POR 紧缩逻辑或
PXOR 紧缩逻辑异或

5、位移：
PSLL[W,D,Q] 紧缩逻辑左移[字，双字，4字]
PSRL[W,D,Q] 紧缩逻辑右移[字，双字，4字]
PSRA[W,D] 紧缩算术右移【字，双字】

7、数据传送：
MOV[D,Q] 从MMX寄存器传人/传出【双字/4字】

8、状态清除
EMMS 清除MMX状态
编写强力黑白棋的历程
老侃研究院优快云分院
07-04 6967
    我的决战黑白棋从开始编写到现在已经大约经历了1年的时间，其中有几次是重大改编，可以说整个数据结构完全重写了。    决战黑白棋刚开始的时候使用的是二维数组棋盘，估值函数基于棋子位置价值加行动力、潜在行动力，搜索深度大约是中局6层＋终局15层。棋力很不理想，如禁止它进行终局搜索，我自己可以不费太大精力取胜。可见其估值函数是很差的。    其后的一次重大改写是将二维棋盘改成了一维棋盘，是速度提
黑白棋模板估值简介
老侃研究院优快云分院
07-25 9342
    关于黑白棋的估值，有三个很重要的概念，行动力，潜在行动力和稳定子，还有一个概念是奇偶性，在终局时有些作用，而开局时没什么用处。对此不了解的朋友可以到网上搜索，有很多介绍。本文主要介绍一下模板估值的原理。    行动力，潜在行动力和稳定子，这些参数的计算都是比较复杂的，为了加速估值，提出了模板估值法。模板估值的思想是将全局的行动力，潜在行动力和稳定子化为局部的行动力，潜在行动力和稳定子，再将
python 黑白棋
09-16
同学大一时候的作业，感觉很不错就是算起来有点慢
[MMX指令版]黑白棋行动力的计算
shines77 的博客
01-17 3751
前言：这个东西老早就应该贴了，因为我已经在Nowcan的Blog帖子里说过了，一直没贴是因为没有心情，或者觉得自己还没有整理得足够好，现在先发未经过整理的上来冲冲数先吧。这段代码是WZebra的作者Gunnar Andersson写的，作用是计算《黑白棋》双方的行动力，其中使用了bitboard技术和MMX指令，作者说他已经考虑了指令配对，请不要随意修改代码的先后顺序，除非你真的确定你是对的。原来
[MMX指令版]黑白棋行动力的计算--原始版本(gcc汇编版)
shines77 的博客
01-17 2962
WZebra作者Gunnar Andersson提供的原始版本，具体的网页我已经记不住了，好像WZebra主页http://www.nada.kth.se/~gunnar/othello.html已经访问不了了，我也好久好久不关注WZebra了。使用了bitboard技术和MMX指令，这个是原始版本(gcc汇编版)，必须在gcc下才可能编译。作者曾说不喜欢VC的汇编格式(确切的说是Intel的习惯
黑白棋算法分析（一）
jcs130的专栏
08-01 4873
刚才去QQ黑白棋上和别人下了几局，关于黑白棋的下法总结了一下，准备写人机对战程序了~： 黑白棋和五子棋不同，棋盘各点的权值不是单纯的通过连子数决定，还和所下位置有很大关系！ 这个是黑白棋的棋盘：    黑白棋游戏的核心就是要抢占四个角！因为只要放到了角上，就不会被改变了。这就是“金角银边草肚皮”说法的由来 金角： 角的权值应设为最大。 相对应的，和四个角相邻的格...
(完整版)计算机组装与维修-模拟试题(-CPU习题).doc
11-15
3. CPU采用的扩展指令集有Intel公司的SSE、MMX和AMD公司的3DNOW!等几种。 4. CPU的性能指标主要有主频、字长、寻址空间、高速缓存和工作电压等几项。 5. 高速缓存也称Cache，一般将高速缓存分为一级缓存L1 cache和...
nasm-2.02-win32.zip_mmx_nasm 32_nasm-2.02-win_nasm2._out
09-20
NASM是一个为可移植性与模块化而设计的一个80x86的汇编器。它支持相当多的目标文件格式，包括Linux和 NetBSD/FreeBSD , a.out , ELF , COFF ,微软16位的 OBJ 和 Win32 。... , SSE and SSE2 指令集
Intel_IA-32指令集.zip_IA-32_IA-32.CHM_IA-32指令集_IA32指令集_inter_ia-32
09-20
Intel IA-32指令集是英特尔公司为x86架构设计的一种处理器指令集，它在1978年随着Intel 8086处理器的推出而首次亮相，并且在后续的众多Intel处理器中得到广泛使用，包括 Pentium、Pentium Pro、Pentium 4以及早期的...
JAVA黑白棋之算法浅析
wybwzl的博客
08-30 2886
 引言           本为主要对我在开发JAVA黑白棋人机算法过程中所用的博弈思想、估值函数、搜索算法分3个方面进行了阐述，由于本人水平有限，如果大家希望了解更多有关黑白棋博弈策略以及人机算法的深入的理论研究，可以参看本文最后的参考文献，或者搜索其他相关资料。         黑白棋，又叫反棋（Reversi）、奥赛罗棋（Othello）、苹果棋或翻转棋。黑白棋在西方和日本很流行。游...
游戏开发（三）——WIN32 黑白棋（一）——棋局逻辑的设计
zilaishuichina的专栏
07-28 7635
今天以黑白棋为例，开始给一个win32的小游戏设计， 这里打算分3部分介绍 1、棋局的现实 2、AI的现实 3、游戏画面的现实 提供一下完整项目下载 其中第一部分为黑白棋游戏的主要逻辑： 1、棋盘，以及棋盘上的棋子的存储形式。这里用到了位图。 2、是否可以落子的判断（黑白棋是只有你落子的位置，在横竖斜八个方向中任意一个方向，能吃掉对方的子，你才可以落在该位置，八个方向都
黑白棋开局库研究
老侃研究院优快云分院
12-21 5504
    众所周知，开局库在黑白棋中是非常重要的。以下是我设想的开局库数据结构。为了简单，设计成一个链表，而没有采用树形结构。align这些都是为了字节对齐而加的，没有实际意义。typedef struct  BOOK_MOVE_Tag{    char    x;      //走法    char    y;    char    _align0;    char    _align1;  
VC版黑白棋游戏
ithome
10-02 490
目 录 前 言... 2 1．课程设计计划... 3 2．功能需求... 3 3．总体设计... 5 4．详细设计... 6 5．测试与实现... 28 6．总结... 29 参考文献... 30 前 言 黑白棋，也称反棋(Reversi)、奥赛罗棋(Othello)，苹果棋，翻转棋是一个经典的策略性游戏。黑白棋是19世纪末英国人发明的。直到上个世纪...
一个JavaScript写的黑白棋AI
热门推荐
赖勇浩的编程私伙局
11-22 1万+
首先，这个代码不是我写的，但注释是我加上去的。作者是shaofei cheng，他的网站：http://shaofei.name。第二，目前这个代码只是使用了 alpha-beta 剪枝，棋力还弱，有很大的优化空间。但是代码写得非常清晰，如果有朋友对人机弈棋方面的课题有兴趣又还没有入门，这份代码作为一个例子是很棒的。第三，目前计算机只能搜索 3 层，我觉得加上迭代深化和历史启发算法之后，搜索到 5 层是不成问题的。现代 JavaScript 的性能不错。第四，作者在代码里展示了不少技巧，值得学习和借鉴，哪怕
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值