动物棋制作（C语言）

最新推荐文章于 2023-08-30 08:03:05 发布
最新推荐文章于 2023-08-30 08:03:05 发布
阅读量3.3k 收藏 13
点赞数 4
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuchiang03/article/details/122815572
版权

期末大作业要求：

1.完成动物棋的对局功能;

2.能够实现复盘的功能；

具体操作如下：（图形库用的是EasyX）

因为是第一次做，可能会有些乱，有的地方会比较繁琐，也欢迎指出问题。

开始是一些准备工作。

#include <stdio.h>                
#include <graphics.h>
#include <conio.h>
#include<stdlib.h>
#include<time.h>
#define R 16
//这里有用到一些全局变量
int a[14],b[14];
int A[14],B[14];
char c[14]={'E','E','T','T','L','L','W','W','D','D','C','C','M','M'};
char C[15];
int e[14],f[14];
int g[1000],h[1000];
//用结构体来标记棋子的位置
typedef struct locate
{
    int x;
    int y;
}Locate;
//用结构体来完成对棋子的计数
typedef struct num
{
    int E;
    int T;
    int L;
    int W;
    int D;
    int C;
    int M;
}player_1,player_2;

typedef struct num_x
{
    int a;
}sum,num_1,num_2;
//一些函数声明
void Draw();
void draw(player_1*m,player_2*n,sum*d);
void Chess();
void PutChess(Locate*p,player_1*m,player_2*n,sum*d);
void chess(Locate*p,player_1*m,player_2*n,sum*d,num_1*q);
void playgame();
void show(player_1*m,player_2*n);
void FuPan();

//主体框架
int main()
{
    int z;
    printf("1.开始游戏");
    printf("\n2.进行复盘");
    printf("\n选择：");
    scanf("%d",&z);
    switch(z)
    {
    case 1:{
    playgame();
    _getch();
    };
    break;
    case 2:{
    FuPan();
    _getch();
    };
    break;
    default:
        break;
    }
    return 0;
}

接下来是一些更多的代码段

1.画棋盘

void Draw()
{
    int i, j = 32;
    cleardevice();
    setlinestyle(PS_SOLID, 2);
    setcolor(RGB(0, 0, 0));

    for (i = 1; i <= 17; i++)
    {
        line(i * j, j, i * j, 17 * j);
        line(j, i * j, 17 * j, i * j);
    }
    circle(47, 47, R);
    setfillcolor(RGB(0, 0, 0));

    _getch();
}

2.敌我双方棋子的生成。

void draw(player_1*m,player_2*n,sum*d)
{
    int i, j = 32;
    cleardevice();
    setlinestyle(PS_SOLID, 2);
    setcolor(RGB(0, 0, 0));
    show(m,n);
    for (i = 1; i <= 17; i++)
    {
        line(i * j, j, i * j, 17 * j);
        line(j, i * j, 17 * j, i * j);
    }
    for(i=0;i<14;i++)
    {
        setfillcolor(BLACK);      //如果是所生成的随机数，则标黑
        outtextxy(44+a[i]*32,44+b[i]*32,c[i]);
        fillcircle(47+a[i]*32,47+b[i]*32,R);
    }
    for(i=0;i<=d->a;i++)
    {
        clearcircle(e[i],f[i],R);
    }
}

void Chess()                    //电脑自动生成棋子
{
    int m=32,x,y;
    int i,j;
    srand((int)time(0));
    a[0]=rand()%16;
    for(i=1;i<14;i++)
    {
        a[i]=rand()%16;
        for(j=0;j<i;j++)
        {
            if(a[i]==a[j])
            {
                i--;
            }
        }
    }
    b[0]=rand()%16;
    for(i=1;i<14;i++)
    {
        b[i]=rand()%16;
        for(j=0;j<i;j++)
        {
            if(b[i]==b[j])
            {
                i--;
            }
        }
    }
    for(i=0;i<14;i++)
    {
            for(x=47;x<47+16*32;)
            {
                for(y=47;y<47+16*32;)
                {
                    if(x==47+a[i]*32&&y==47+b[i]*32)
                    {
                        setfillcolor(BLACK);      //如果是所生成的随机数，则标黑
                        fillcircle(x,y,R);
                        //circle(x,y,R);
                    }
                    y+=m;
                }
                x+=m;
            }
    }
}

3.playgame的框架

void playgame()
{
    initgraph(600, 600);
    setbkcolor(WHITE);
    cleardevice();
    Draw();
    _getch();
    Chess();
    char ch_1;
    int i;
    sum d;
    num_1 q;
    d.a=0;
    q.a=0;
    Locate p;
    p.x = 47;
    p.y = 47;
    player_1 m;
    player_2 n;
    m.E=2;m.T=2;m.L=2;m.W=2;m.D=2;m.C=2;m.M=2;
    n.E=2;n.T=2;n.L=2;n.W=2;n.D=2;n.C=2;n.M=2;
    while(1)
    {
        if(m.E+m.T+m.L+m.W+m.D+m.C+m.M==0||n.E+n.T+n.L+n.W+n.D+n.C+n.M==0)
        {
            if(m.E+m.T+m.L+m.W+m.D+m.C+m.M==0)
            {
                outtextxy(300,250,"你赢了");
                FILE*fp;
                fp=fopen("1.dat","w");                      //每次要修改文件的名字
                int v=q.a;
                for(i=0;i<v;i++)
                    fprintf(fp,"%d\t%d\t%d\n",v,g[i],h[i]);
                for(i=0;i<14;i++)
                {
                    A[i]=44+a[i]*32;
                    B[i]=44+b[i]*32;
                    fprintf(fp,"%d\t%d%c\n",A[i],B[i],C[i]);
                }
                fclose(fp);
                _getch();
                break;
            }
            else
            {
                outtextxy(300,250,"你输了");
                FILE*fp;
                fp=fopen("1.dat","w");                       //每次要修改文件的名字
                int v=q.a;
                for(i=0;i<v;i++)
                    fprintf(fp,"%d\t%d\t%d\n",v,g[i],h[i]);
                for(i=0;i<14;i++)
                {
                    A[i]=44+a[i]*32;
                    B[i]=44+b[i]*32;
                    fprintf(fp,"%d\t%d%c\n",A[i],B[i],C[i]);
                }
                fclose(fp);
                _getch();
                break;
            }
        }
        else
        {
            ch_1=_getch();
            if(ch_1==' ')
        {
            PutChess(&p,&m,&n,&d);
        }
            else
            chess(&p,&m,&n,&d,&q);
        }
    }
}

4.控制棋子的移动并记录坐标

void chess(Locate *p,player_1*m,player_2*n,sum*d,num_1*q)
{
    int y=p->y;
    int x=p->x;
    char ch_1;
    ch_1 = _getch();
    switch (ch_1)
    {
    case 72: // up
    {
        if (y>47)
        {
            p->y = p->y - 32;
            draw(m,n,d);
            circle(p->x, p->y, R);
            g[q->a]=p->x;
            h[q->a]=p->y;
            q->a=q->a+1;
        }
        break;
    }
    case 80: // down
    {
        if (y<47+15*32)
        {
            p->y = p->y + 32;
            draw(m,n,d);
            circle(p->x, p->y, R);
            g[q->a]=p->x;
            h[q->a]=p->y;
            q->a=q->a+1;
        }
        break;
    }
    case 75: // left
    {
        if (x>47)
        {
            p->x = p->x - 32;
            draw(m,n,d);
            circle(p->x, p->y, R);
            g[q->a]=p->x;
            h[q->a]=p->y;
            q->a=q->a+1;
        }
        break;
    }
    case 77: // right
    {
        if (x<47+15*32)
        {
            p->x = p->x + 32;
            draw(m,n,d);
            circle(p->x, p->y, R);
            g[q->a]=p->x;
            h[q->a]=p->y;
            q->a=q->a+1;
        }
        break;
    }
    default:
        break;
    }
}

5.VS的逻辑

void PutChess(Locate*p,player_1*m,player_2*n,sum*d)         //下出棋子
{
    char ch_1, A;
    int i;
    ch_1 = _getch();
    switch (ch_1)
    {
    case 69:                                            //大象
    {
        if(n->E==0)
            outtextxy(300,300,"该类棋子已用完");
        else
     {
        A = 'E';
        C[d->a]='E';
        outtextxy(p->x, p->y, A);
       for(i=0;i<14;i++)
       {
        if(47+a[i]*32==p->x&&47+b[i]*32==p->y)
        {
            switch(c[i])
            {
                case 84:                        //电脑的字母小
                    {
                            m->T=m->T-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 76:                        //电脑的字母小
                    {
                            m->L=m->L-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 87:                        //电脑的字母小
                    {
                            m->W=m->W-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 68:                        //电脑的字母小
                    {
                            m->D=m->D-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 67:                        //电脑的字母小
                    {
                            m->C=m->C-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 77:                        //游戏玩家的字母小
                    {
                            n->E=n->E-1;
                    }
                    break;
                case 69:
                    {
                            m->E=m->E-1;
                            n->E=n->E-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                default:
                    break;
            }
        }
       }
     }
    }
    break;
    case 84:                                         //老虎
    {
        if(n->T==0)
        outtextxy(300,300,"该类棋子已用完");
        else
        {
            A = 'T';
            C[d->a]='T';
            outtextxy(p->x, p->y, A);
        for(i=0;i<14;i++)
       {
        if(47+a[i]*32==p->x&&47+b[i]*32==p->y)
        {
            switch(c[i])
            {
                case 76:                        //电脑的字母小
                    {
                            m->L=m->L-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 87:                        //电脑的字母小
                    {
                            m->W=m->W-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 68:                        //电脑的字母小
                    {
                            m->D=m->D-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 67:                        //电脑的字母小
                    {
                            m->C=m->C-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 77:                        //电脑的字母小
                    {
                            m->M=m->M-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 69:                        //游戏玩家的字母小
                    {
                            n->T=n->T-1;
                    }
                    break;
                case 84:
                    {
                            m->T=m->T-1;
                            n->T=n->T-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                default:
                    break;
            }
        }
       }
        }
    }
    break;
    case 76:                                       //狮子
    {
        if(n->L==0)
        outtextxy(300,300,"该类棋子已用完");
        else
        {
            A = 'L';
            C[d->a]='L';
            outtextxy(p->x, p->y, A);
        for(i=0;i<14;i++)
       {
        if(47+a[i]*32==p->x&&47+b[i]*32==p->y)
        {
            switch(c[i])
            {
                case 87:                        //电脑的字母小
                    {
                            m->W=m->W-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 68:                        //电脑的字母小
                    {
                            m->D=m->D-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 67:                        //电脑的字母小
                    {
                            m->C=m->C-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 77:                        //电脑的字母小
                    {
                            m->M=m->M-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 84:                        //游戏玩家的字母小
                    {
                            n->L=n->L-1;
                    }
                case 69:                        //游戏玩家的字母小
                    {
                            n->L=n->L-1;
                    }
                    break;
                case 76:
                    {
                            m->L=m->L-1;
                            n->L=n->L-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                default:
                    break;
            }
        }
        }
        }
    }
    break;
    case 87:
    {
        if(n->W==0)                             //狼
        outtextxy(300,300,"该类棋子已用完");
        else
        {
            A = 'W';
            C[d->a]='W';
            outtextxy(p->x, p->y, A);
        for(i=0;i<14;i++)
       {
        if(47+a[i]*32==p->x&&47+b[i]*32==p->y)
        {
            switch(c[i])
            {
                case 68:                        //电脑的字母小
                    {
                            m->D=m->D-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 67:                        //电脑的字母小
                    {
                            m->C=m->C-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 77:                        //电脑的字母小
                    {
                            m->M=m->M-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 76:                        //游戏玩家的字母小
                    {
                            n->W=n->W-1;
                    }
                    break;
                case 84:                        //游戏玩家的字母小
                    {
                            n->W=n->W-1;
                    }
                    break;
                case 69:                        //游戏玩家的字母小
                    {
                            n->W=n->W-1;
                    }
                    break;
                case 87:
                    {
                            m->W=m->W-1;
                            n->W=n->W-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                default:
                    break;
            }
        }
       }
        }
    }
    break;
    case 68:                                      //狗
    {
        if(n->D==0)
        outtextxy(300,300,"该类棋子已用完");
        else
        {
            A = 'D';
            C[d->a]='D';
            outtextxy(p->x, p->y, A);
        for(i=0;i<14;i++)
       {
        if(47+a[i]*32==p->x&&47+b[i]*32==p->y)
        {
            switch(c[i])
            {
                case 67:                        //电脑的字母小
                    {
                            m->C=m->C-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 77:                        //电脑的字母小
                    {
                            m->M=m->M-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 87:                        //游戏玩家的字母小
                    {
                            n->D=n->D-1;
                    }
                    break;
                case 76:                        //游戏玩家的字母小
                    {
                            n->D=n->D-1;
                    }
                    break;
                case 84:                        //游戏玩家的字母小
                    {
                            n->D=n->D-1;
                    }
                    break;
                case 69:                        //游戏玩家的字母小
                    {
                            n->D=n->D-1;
                    }
                    break;
                case 68:
                    {
                            m->D=m->D-1;
                            n->D=n->D-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                default:
                    break;
            }

        }
       }
        }
    }
    break;
    case 67:                                        //猫
    {
        if(n->C==0)
        outtextxy(300,300,"该类棋子已用完");
        else
        {
            A = 'C';
            C[d->a]='C';
            outtextxy(p->x, p->y, A);
        for(i=0;i<14;i++)
       {
        if(47+a[i]*32==p->x&&47+b[i]*32==p->y)
        {
            switch(c[i])
            {
                case 77:                        //电脑的字母小
                    {
                            m->M=m->M-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 68:                        //游戏玩家的字母小
                    {
                            n->C=n->C-1;
                    }
                    break;
                case 87:                        //游戏玩家的字母小
                    {
                            n->C=n->C-1;
                    }
                    break;
                case 76:                        //游戏玩家的字母小
                    {
                            n->C=n->C-1;
                    }
                    break;
                case 84:                        //游戏玩家的字母小
                    {
                            n->C=n->C-1;
                    }
                    break;
                case 69:                        //游戏玩家的字母小
                    {
                            n->C=n->C-1;
                    }
                    break;
                case 67:
                    {
                            m->C=m->C-1;
                            n->C=n->C-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                default:
                    break;
            }
        }
       }
        }
    }
    break;
    case 77:                                          //老鼠
    {
        if(n->M==0)
        outtextxy(300,300,"该类棋子已用完");
        else
        {
            A = 'M';
            C[d->a]='M';
            outtextxy(p->x, p->y, A);
        for(i=0;i<14;i++)
       {
        if(47+a[i]*32==p->x&&47+b[i]*32==p->y)
        {
            switch(c[i])
            {
                case 69:                        //电脑的字母小
                    {
                            m->E=m->E-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                case 67:                        //游戏玩家的字母小
                    {
                            n->M=n->M-1;
                    }
                    break;
                case 68:                        //游戏玩家的字母小
                    {
                            n->M=n->M-1;
                    }
                    break;
                case 87:                        //游戏玩家的字母小
                    {
                            n->M=n->M-1;
                    }
                    break;
                case 76:                        //游戏玩家的字母小
                    {
                            n->M=n->M-1;
                    }
                    break;
                case 84:                        //游戏玩家的字母小
                    {
                            n->M=n->M-1;
                    }
                    break;
                case 77:
                    {
                            m->M=m->M-1;
                            n->M=n->M-1;
                            clearcircle(47+a[i]*32,47+b[i]*32,R);
                            e[d->a]=47+a[i]*32;
                            f[d->a]=47+b[i]*32;
                            d->a+=1;
                    }
                    break;
                default:
                    break;
            }
        }
       }
        }
    }
    break;
    default:
        break;
    }
}

6.页面的布局 

void show(player_1*m,player_2*n)
{
    settextstyle(16,0,"微软黑体");
    char s[50];
    sprintf(s,"电脑：E:%d T:%d L:%d W:%d D:%d C:%d M:%d",m->E,m->T,m->L,m->W,m->D,m->C,m->M);
    outtextxy(10,3,s);
    char t[50];
    sprintf(t,"玩家：E:%d T:%d L:%d W:%d D:%d C:%d M:%d",n->E,n->T,n->L,n->W,n->D,n->C,n->M);
    outtextxy(10,550,t);
}

7.复盘

void FuPan()
{
    int q;
    int i;
    char M[50];
    printf("输入你要复盘的对局的文件名：");         
    scanf("%s",&M);
    FILE*fp;
    fp=fopen(M,"r");
    rewind(fp);
    fscanf(fp,"%d",&q);
    for(i=0;i<q;i++)
    {
        fscanf(fp,"%d%d",&h[i],&g[i]);
             fseek(fp,5L,SEEK_CUR);
    }
    fseek(fp,-3L,SEEK_CUR);
    for(i=0;i<14;i++)
    {
        fscanf(fp,"%d%d%c",&A[i],&B[i],&C[i]);//fscanf读取时中间不能有空格
        fseek(fp,1L,SEEK_CUR);
    }
    initgraph(600, 600);
    setbkcolor(WHITE);
    cleardevice();
    Draw();
    settextstyle(16,0,"微软黑体");
    outtextxy(10,3,"上方字母是你下的棋，下方字母是电脑下的棋");
    for(i=0;i<14;i++)
    {
        outtextxy(A[i],B[i],c[i]);
        outtextxy(A[i],B[i]-13,C[i]);
    }
    for(i=0;i<q;i++)
    {
        setfillcolor(BLACK);
        circle(h[i],g[i],R);
    }
    fclose(fp);
}

可能整体看下来比较繁琐，希望能够抛砖引玉。

赤昂DS
关注
kingofwild_斗兽棋代码_斗兽棋脚本_游戏_
10-01
HTML斗兽棋代码，包含JS脚本，图片资源，部分注释。游戏规则如下：双方有八只棋子，依大小顺序为象、狮、虎、豹、狼、犬、猫、鼠。较大的可吃较小的，同类可以互吃，而鼠则可吃象，象不能吃鼠。动物走一格，前后左右都可以。两者相同的相遇，执下一步棋的可吃对方而并不会与对方同归于尽。
C / C++：斗兽棋型比较大小
做一只猫的博客
08-17 1640
引入 相信大家都玩过斗兽棋，其规则是大动物能吃掉小动物，但最小的动物又能吃掉最大的动物，形成一个生物链闭环。 日常生活中形如这样的情形还有游戏中的属性克制、石头剪刀布等。 实际运用中我们需要对这些情形做出判断，得到结果。 基本思路 假设有四个A、B、C三个对象，A吃B，B吃C，C吃D，D吃A，对象容量为4。 将三者转换成数字，A→0，B→1，C→2，D→3。 可以发现 ①（0 + 1）% 4 == 1 ②（3 + 1）% 4 == 0 符合大吃小，最小吃最大的规律 模板 有n个对象，按从大到小的顺序排好，并
基于Python pygame简易版斗兽棋小游戏源代码
Python代码大全
12-02 2817
3.老鼠可以进河,老鼠在河里时,岸上的动物不能捕食他,他也不能捕食岸上的动物。4.狮\虎在河中没有老鼠阻挡时可以跳过河,并可吃掉对岸的较小的动物。基于Python pygame简易版斗兽棋小游戏源代码。5.进入敌方陷阱后,任意一个棋子都可以吃掉他。piece.json：储存了创建棋子实例的信息。piece.py：棋子类，提供控制棋子的方法。main.py：主程序，控制游戏的进行状况。1.象>狮>虎>豹>狼>狗>猫>鼠>象。level：棋局进行中的主要类和方法。2.同类棋子先行者吃掉对方。
Java Swing斗兽棋
m0_61799540的博客
08-30 189
不同的类代表了游戏中的不同实体和概念，如棋盘、棋子、玩家颜色等。棋子之间的互动规则在 ChessPiece 类中被定义，包括了棋子的移动和吃掉其他棋子的规则。PlayerColor 枚举类用于表示玩家的颜色，这在界面上用不同的颜色显示不同玩家的棋子。这个类表示棋子，包含了棋子的所有属性。每个颜色都与一个Java的Color对象关联，用于在界面上显示不同玩家的棋子。这个类代表棋盘上的一个格子，也就是棋盘上的一个位置。这个类代表棋盘上的一个点，使用行和列来标识棋盘上的位置。
c语言小游戏----改版斗兽棋
God_lonely_clown的博客
08-01 2254
一、项目背景 此游戏是笔者大二第一学期时受好友之托，重拾c语言编写的小程序，这篇文章主要介绍Game中的游主体逻辑部分。程序主体多用if-else，while，for等关键字，适合c语言初学者阅读，若有疑问或bug或建议可评论指出。 二、编程环境 笔者用的是Visual Studio2019，调用库有： #include <iostream> #include <windows.h> #include <conio.h> ...
五子棋（C语言版）
01-20
【五子棋C语言版】实现是一个典型的编程项目，它结合了C语言的基本语法和图形用户界面（GUI）设计。以下是对代码中的关键知识点的详细解释： 1. **C语言基础**： - `#include` 指令用于引入预处理指令，如 `...
C语言五子棋C语言五子棋
最新发布
03-25
五子棋c语言C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋C语言五子棋...
五子棋（C语言）_C语言_五子棋_
10-03
在本项目中，我们探讨的是如何使用C语言来实现一个简单的五子棋游戏。C语言是一种基础且强大的编程语言，适合开发系统级程序和小型应用，包括游戏。五子棋，又称连珠，是一种两人对弈的策略型棋类游戏，目标是先形成...
五子棋的c语言实现
07-12
本代码主要功能是用c语言实现五子棋，能够在vc6.0下完整的运行。
【斗兽棋】-单机游戏-微信小程序项目开发入门
TA远方
05-17 2974
还记得小时候玩过的斗兽棋游戏不，90后的经典怀旧游戏哦，笔者TA远方在读小学的时候，曾玩过的游戏名单就有它，也许有人忘记了，现在才想起，理清一下斗兽棋游戏的规则： 👉 游戏的基本规则 吃小：象 > 狮 > 虎 > 豹＞狼 > 狗 > 猫 > 鼠 吃大：只有鼠 能吃 象 同棋：互吃 潜水：只有鼠 能游在河里，河边的不能吃河里的，同样，河里的不能吃河边的 走法：只能往前后左右方向走一格，狮和虎可横向跳过小河 陷阱：对方的棋落入我方陷阱，我方的任意棋都可吃陷阱里的 嬴法：我
斗兽棋游戏-uniapp-项目源码
05-16
这是一个uniapp项目小程序源码，是经典怀旧的斗兽棋游戏，适合新手入门参考学习。 相关指导教程请看作者发表的文章https://blog.csdn.net/zs1028/article/details/124788721
unity 斗地主源代码__taikr_ Fight Against Landlord
10-16
unity 斗地主源代码__taikr_ Fight Against Landlord;泰课官网的资料
斗兽棋游戏-微信小程序-项目源码
05-16
这是一个微信小程序项目源码，是经典怀旧的斗兽棋游戏，适合新手入门参考学习。 相关指导教程请看作者发表的文章https://blog.csdn.net/zs1028/article/details/124788721
易语言斗兽棋
07-16
易语言斗兽棋源码,斗兽棋,初始化右棋子,所有右棋的当前位置,右棋子可到位置,右棋子不可到位置,初始化左棋子,所有左棋的当前位置,左棋子可到位置,左棋子不可到位置,播放牛叫,播放龙叫,播放鸡叫,播放狗叫,播放马叫,播放鼠叫,播放蛇叫,播放虎叫,播放你走错了,播
斗兽棋.zip
09-12
HTML斗兽棋代码，包含JS脚本，图片资源，部分注释。游戏规则如下：双方有八只棋子，依大小顺序为象、狮、虎、豹、狼、犬、猫、鼠。较大的可吃较小的，同类可以互吃，而鼠则可吃象，象不能吃鼠。动物走一格，前后左右都可以。两者相同的相遇，执下一步棋的可吃对方而并不会与对方同归于尽。
【Python游戏】Python基于pygame实现的人机大战的斗兽棋小游戏 | 附源码
Gtieguo的博客
07-28 1552
有粉丝说要我出一期Python版本的斗兽棋，今天宠粉狂魔的我不就来啦！！虽然是一个简单的小游戏，但是对于新手小伙伴来说还是有一定的小难度的哟！要是不理解都可以找到小编的哈！！游戏最终结果如何其实不是很重要，重要的是一个学习的过程，只有自己弄懂了这个过程，学起来才会有动力，本游戏的一些主要的代码我已经写出来了，还有部分代码我就没有展示了，需要源码的小伙伴可以看相关文件哟！！源码都是可以给大家作参考的哟！！！！希望大家多多支持小编，这样小编才能够给大家带来更多知识分享哟！！
python简单版斗兽棋
05-16 1787
纯粹练手哈，简单的实现了人机对战， 吃光为胜。电脑随机走棋= = jungle.py： #_*_coding:utf-8_*_ ''' Created on 2012-3-27 简单版斗兽棋 @author: myter7 ''' from animal import ...
小y斗兽棋
m0_75166525的博客
02-19 243
牛牛喜欢牛妹，而喜欢的最高境界就是舔，牛牛作为一个舔狗，终于在不断的舔之中获得了牛妹的真心，但是牛牛还是没有舔舒服，于是他们今天又在玩游戏。 每个人有四个棋子，分别是“elephant”，“tiger”，“cat”，“mouse”，分别代表大象、老虎、猫、老鼠，（大象吃老虎，老虎吃猫，猫吃老鼠，老鼠吃大象），每次出一个棋子。 你能知道谁能获得胜利吗？
Easyx-----c语言实现斗兽棋
weixin_60569662的博客
03-16 5775
原游戏链接：新斗兽棋_新斗兽棋html5游戏_4399h5游戏-h.4399.com #include<stdio.h> #include<easyx.h> #include<stdlib.h> #include<time.h> #define IMAGE_NUM_ANIMAL 8 //动物图片数量 /* 动物类型枚举 从弱到强*/ enum AnimalType { AT_None, //没有 AT_Mouse, //老鼠 AT_C....
C语言实现五子棋程序
为了追踪棋子的颜色并确保黑白棋交替放置，作者定义了一个名为`color`的结构体，其中包含一个位域`piececolor`。`piececolor`用1代表黑棋，0代表白棋，每次下棋时会根据这个值切换下棋的颜色。 主循环`while(1)`中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值