C++实现连连看游戏

本文实例为大家分享了C++实现连连看游戏的具体代码,供大家参考,具体内容如下

这个项目还是挺不错的,运行后也比较有意思,可以看看。

#include<iostream>
#include<conio.h>
#include<time.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
using namespace std;
 
void Initial(int a[8][8]);/*初始化*/
int Output(int a[8][8]);/*输出*/
void Sort(int a[8][8]);/*重排*/
void Change(int a[8][8],int x,int y,int x1,int y1);/*交换数组内两坐标对的符号值*/
void Judge(int a[8][8],int b[4]);/*判断是否能够消除*/
void Zero(int a[8][8],int b[4]);/*设置为零,即:消除*/
 
int Two(int a[8][8],int b[4]);/*两条线*/
 
void Check(int a[8][8],int x,int y,char c[5]);/*返回某点上下左右的情况*/
 
int  UpDown(int a[8][8],int b[4],int g);
int  LeftRight(int a[8][8],int b[4],int g);
 
int main()
{
    int flag=1,flag1=1;
    //flag用于标记是否已经初始化,flag=1表示未初始化;flag1标记用户是否选择了退出,flag1=1表示未选择。
    int a[8][8]={0};//0 表示空格。使用数组a[8][8]存放符号值,其中仅用了下标1-6.
    int b[4];/*接收坐标*/
    char ch;
    do 
    {
            int o;//用于标记是否已经获胜。
            if(flag)
            {
                Initial(a);
                flag=0;
            }
            o=Output(a);
            if(o==0)
            {
                char ch;
                system("cls");
                cout << "您已经获胜!!按Enter键确定。" << endl;
                while(1)//确保用户输入 的是Enter键
                {
                    ch=getch();
                    if(ch==13)
                        break;
                }
                flag=1;//标记为未初始化。
                system("cls");
                continue;//跳出本次循环,开始新的一局。                
            }
            while(1)//确保用户的输入符合要求
            {
                ch=getch();
                if(ch=='a'||ch=='A'
                   ||ch=='b'||ch=='B'
                   ||ch=='c'||ch=='C'
                   ||ch=='d'||ch=='D')
                
                {
                    putchar(ch);
                    break;
                }
            }
            switch(ch)//根据用户的选择进行处理。
            {
                case 'a':
                case 'A':
                    {
                        cout << endl;
                        cout << "请输入坐标:" << endl;
                        fflush(stdin);
                        cin >> b[0] >> b[1] >> b[2] >> b[3];
                        break;
                    }
                case 'b':
                case 'B':
                    {
                        Sort(a);
                        break;
                    }
                case 'c':
                case 'C':
                    {
                        flag=1;
                        break;
                    }
                case 'd':
                case 'D':
                    {
                        flag1=0;
                        break;
                    }
            }
            if(ch!='a'&&ch!='A')
                system("cls");
            else                 //若用户输入坐标,则进行判断
            {
                Judge(a,b);
                system("cls");
            }
    }while(flag1);
    cout << "游戏已退出!" << endl;
}
 
void Initial(int a[8][8])//用以初始化数组存放的符号值
{
    
    int i,j,m=0,k=1;//k值表示符号类别,m表示每个符号必须出现以2的倍数出现,出现两次
    for(i=1;i<=6;i++)
        for(j=1;j<=6;j++)
        {
           if(k>12)
               k=k%12;//k值大于12后,符号类型循环,最多11种符号,0表示空
           a[i][j]=k;
           m++;
           if(m%2==0)//每种符号赋两个,
              k++;
        }
    Sort(a);//进行随机重排。
}
 
int Output(int a[8][8])           /*输出,对应符号
   ☆ ★ ○ ● ◎ ◇ ■ ∷ ⊙ ﹫ ¤ ﹩
    
     同时,判断是否胜利 */
{
    int i,j,flag1=0;//flag1用于记录输出的空格数,当flag1=64时,表示所有的都已消完,获胜。
    for(i=0;i<8;i++)
    {
        for(j=0;j<8;j++)
        {
            switch(a[i][j])//根据二维数组a中的值输出相应的符号
            {
               case 0:
                   flag1++;
                   cout << "  ";
                   break;
               case 1:
                   cout << "☆";
                   break;                   
               case 2:
                   cout << "★";
                   break;
               case 3:
                   cout << "○";
                   break;
               case 4:
                   cout << "●";
                   break;
               case 5:
                   cout << "◎";
                   break;
               case 6:
                   cout << "◇";
                   break;
               case 7:
                   cout << "■";
                   break;
               case 8:
                   cout << "∷";
                   break;
               case 9:
                   cout << "⊙";
                   break;
               case 10:
                   cout << "﹫";
                   break;
               case 11:
                   cout << "¤";
                   break;
               case 12:
                   cout << "﹩";
                   break;
            }
        }
        if(i>0&&i<7)
        {
            cout << '\t' << '\t';            
            for(j=1;j<=6;j++)
            {
                cout << "<" << i << "," << j << ">,";                
            }
        }
        cout << endl;        
    }
    if(flag1==64)
            return 0;
    cout << endl;
    cout << "选项:" << endl;
    cout << '\t' << '\t' << 'a' << '\t' << "输入坐标;" << endl;
    cout << '\t' << '\t' << 'b' << '\t' << "重排;" << endl;
    cout << '\t' << '\t' << 'c' << '\t' << "重新开始;" << endl;
    cout << '\t' << '\t' << 'd' << '\t' << "退出;" << endl;
    cout << endl;
    cout << "坐标输入格式:" << endl << "1 2" << endl << "3 6" << endl <<"然后按Enter。" << endl;
    cout << "选择:";
    return 1;
}
 
void Change(int a[8][8],int x,int y,int x1,int y1)/*交换*/
{
    int temp;
    temp=a[x][y];
    a[x][y]=a[x1][y1];
    a[x1][y1]=temp;
}
 
void Sort(int a[8][8])//对数组内的符号随机交换,打乱符号的位置,注意坐标必须是1-6之间
{
    int x1,y1,i,j;
    srand((unsigned)time(NULL));
    for(i=1;i<=6;i++)
        for(j=1;j<=6;j++)
        {
            x1=rand()%(6-1+1)+1;
            y1=rand()%(6-1+1)+1;
            //随机产生一个坐标(x1,y1);
            Change(a,i,j,x1,y1);//将a(i,j)的值与a(x1,y1)的值交换
        }
 
}
void Judge(int a[8][8],int b[4])/*判断是否能够消除*/
{
    
   if(a[b[0]][b[1]]==a[b[2]][b[3]]&&!(b[0]==b[2]&&b[1]==b[3]))
   {
       
       if((b[0]==b[2]&&abs(b[3]-b[1])==1)
           ||(b[1]==b[3]&&abs(b[0]-b[2])==1))/*判断两点紧邻*/
       {      
           Zero(a,b);
           return;
       }
       if((b[0]==b[2]&&(b[0]==1||b[0]==6))
           ||(b[1]==b[3]&&(b[1]==6||b[1]==1)))/*判断两点在边界上*/
       {
           Zero(a,b);
           return;
       }
       if(b[0]==b[2])                      /*两点在同一行上*/
       {
           int n,m;//n为两个数中较大的值,m为两数中较小的。
           n=b[3]>b[1]?b[3]:b[1];
           m=b[3]>b[1]?b[1]:b[3];
           n=n-1;
           while(n>m)
           {
               //从右往左依次查看,看在此行,两点之间是否均为空格
               if(a[b[0]][n]==0)
                   n--;
               else
                  break;
           }
           if(n==m)//在此行,两点之间均为空格。
           {      
               Zero(a,b);
               return;
           }
       }
       if(b[1]==b[3])        /*两点在同一列*/
       {
           int n,m;//n为两个数中较大的值,m为两数中较小的。
           n=b[2]>b[0]?b[2]:b[0];
           m=b[2]>b[0]?b[0]:b[2];
           n=n-1;
           while(n>m)
           {
               //从下往上依次查看,看在此列,两点之间是否均为空格
               if(a[n][b[1]]==0)
                   n--;
               else
                   break;
           }
           if(n==m)//在此列,两点之间均为空格
           {
               Zero(a,b);
               return;
           }
 
       }
       if(1)//为了添加局部变量i,所以用if(1),优点:使变量i存在的时间尽可能短。
       {
           int i;//标记是否符合两条线的情况。i=1表示符合,
           i=Two(a,b);
           if(i==1)
             return;
       }
       if(1)//为了添加局部变量f,w,e,所以用if(1),优点:使变量f,e,w存在的时间尽可能短。
       {
           //三条线的情况
           int f,w;
           int e;
           char c1[5],c2[5],c3[5]="1111";
           //检查(b[0],b[1]),(b[2],b[3])上、下、左、右的情况
           Check(a,b[0],b[1],c1);
           Check(a,b[2],b[3],c2);
           if(strcmp(c1,c3)==0||strcmp(c2,c3)==0)//两点中只要有一点四周均不为空,两点就不能连通,即:不可消除。
               return;
           for(e=0;e<=3;e++)//比较两点四周的情况
           {
               int r[4];
               //b数组中的值不可变化,因此用r数组接收b数组中的值
               r[0]=b[0];
               r[1]=b[1];
               r[2]=b[2];
               r[3]=b[3];
               if(c1[e]==c2[e]&&c1[e]=='0')
               {
                   switch(e)
                   {
                     case 0://两点上方均有空格
                           //依次检查(b[0],b[1])上方的点是否为空格(直到边界),若为空格则检查该点与(b[2],b[3])
                           //是否能通过两条线连通
                           while(r[0]>0)
                           {
                               r[0]=r[0]-1;
                               if(a[r[0]][r[1]]!=0)//只要不为空格就已说明不可连通
                                   break;
                               if(Two(a,r)==1)
                               {   
                                   Zero(a,b);
                                   return;
                               }
                           }
                           break;
                     case 1://两点下方均有空格
                           //依次检查(b[0],b[1])下方的点是否为空格(直到边界),若为空格则检查该点与(b[2],b[3])
                           //是否能通过两条线连通
                           while(r[0]<8)
                           {
                               r[0]=r[0]+1;
                               if(a[r[0]][r[1]]!=0)//只要不为空格就已说明不可连通
                                   break;
                               if(Two(a,r)==1)
                               {
                                   Zero(a,b);
                                   return;
                               }
                           }
                           break;
                     case 2:
                         //两点左边均有空格
                           //依次检查(b[0],b[1])左边的点是否为空格(直到边界),若为空格则检查该点与(b[2],b[3])
                           //是否能通过两条线连通
                           while(r[1]>0)
                           {
                               r[1]=r[1]-1;
                               if(a[r[0]][r[1]]!=0)//只要不为空格就已说明不可连通
                                   break;
                               if(Two(a,r)==1)
                               {
                                   Zero(a,b);
                                   return;
                               }
 
                           }
                           break;
                     case 3:
                         //两点右边均有空格
                           //依次检查(b[0],b[1])右边的点是否为空格(直到边界),若为空格则检查该点与(b[2],b[3])
                           //是否能通过两条线连通
                           while(r[1]<8)
                           {
                               r[1]+=1;
                               if(a[r[0]][r[1]]!=0)//只要不为空格就已说明不可连通
                                   break;
                               if(Two(a,r)==1)
                               {
                                   Zero(a,b);
                                   return;
                               }
                           }
                           break;
                   }
               }
           }
 
           f=b[2]-b[0];//f>0表示(b[2],b[3])在(b[0],b[1])下方,f<0表示(b[2],b[3])在(b[0],b[1])上方
 
           w=b[3]-b[1];//w>0表示(b[2],b[3])在(b[0],b[1])右方,w<0表示(b[2],b[3])在(b[0],b[1])左方
 
 
           if(f>0&&w>0)                        /*(b[2],b[3])在(b[0],b[1])右下*/
           {
               if(c2[0]=='0'&&c1[1]=='0') //(b[2],b[3])的上方为空格,(b[0],b[1])的下方为空格
               { 
                  if(UpDown(a,b,1))
                       return;
               }
               if(c2[2]=='0'&&c1[3]=='0')//(b[2],b[3])的左边为空格,(b[0],b[1])的右边为空格
               {
                   if(LeftRight(a,b,1))
                       return;
               }
           }
           if(f<0&&w>0)                       /*(b[2],b[3])在(b[0],b[1])右上*/
           {
               if(c2[1]=='0'&&c1[0]=='0')   //(b[2],b[3])的下方为空格,(b[0],b[1])的上方为空格
               {
                   if(UpDown(a,b,0))
                       return;
               }
               if(c2[2]=='0'&&c1[3]=='0')//(b[2],b[3])的左边为空格,(b[0],b[1])的右边为空格
               {
                   if(LeftRight(a,b,1))
                       return;
               }
           }
           if(f>0&&w<0)                     /*(b[2],b[3])在(b[0],b[1])左下*/
           {
               if(c2[0]=='0'&&c1[1]=='0')//(b[2],b[3])的上方为空格,(b[0],b[1])的下方为空格
               {
                    if(UpDown(a,b,1))
                       return;
               }
               if(c2[3]=='0'&&c1[2]=='0')//(b[2],b[3])的右边为空格,(b[0],b[1])的左边为空格
               {
                   if(LeftRight(a,b,0))
                       return;
               }
           }
           if(f<0&&w<0)                    /*(b[2],b[3])在(b[0],b[1])左上*/
           {
               if(c2[1]=='0'&&c1[0]=='0') //(b[2],b[3])的下方为空格,(b[0],b[1])的上方为空格
               {
                   if(UpDown(a,b,0))
                       return;
               }
               if(c2[3]=='0'&&c1[2]=='0')//(b[2],b[3])的右边为空格,(b[0],b[1])的左边为空格
               {
                   if(LeftRight(a,b,0))
                       return;
               }
 
           }
 
           
        }
 
    }
       
 
}
void Zero(int a[8][8],int b[4])/*设置为零*/
{
    a[b[0]][b[1]]=0;
    a[b[2]][b[3]]=0;
}
void Check(int a[8][8],int x,int y,char c[5])/*返回某点上下左右的情况*/
{
    //1 表示不为空格,0表示为空格,
    //c[0],c[1],c[2],c[3]分别表示某点上下左右的情况
     if(a[x-1][y]==0)//(x,y)上一格为空
         c[0]='0';
     else
         c[0]='1';
 
     if(a[x+1][y]==0)//(x,y)下一格为空
         c[1]='0';
     else
         c[1]='1';
 
     if(a[x][y-1]==0)//(x,y)左一格为空
         c[2]='0';
     else
         c[2]='1';
 
     if(a[x][y+1]==0)//(x,y)右一格为空
         c[3]='0';
     else
         c[3]='1';
     c[4]='\0';
}
int Two(int a[8][8],int b[4])    /*两条线*/
{
    int m,n;
    int c,d; //(c,d)为可动检验点坐标
 
    n=b[2]-b[0];          /*行间距*/
    m=b[3]-b[1];         /*列间距*/
    d=b[2];
    c=b[3]-m;//b[1]
    while(c!=b[3])// 验证是否存在水平通道(b[2],b[3])到(b[2],b[1])。
    {
        if(a[d][c]==0)
            c+=(m/abs(m));
        else
            break;
    }
    if(c==b[3])//存在水平通道
    {
        c=b[3]-m;
        while(d!=b[0])//验证是否存在竖直通道(b[2],b[1])到(b[0],b[1])。
        {
            if(a[d][c]==0)
                d-=(n/abs(n));
            else
                break;
        }
        if(d==b[0])//存在竖直通道。
        {
            Zero(a,b);
            return 1;
        }
        
    }
    c=b[3];
    d=b[2]-n;
    while(d!=b[2])//验证是否存在竖直通道(b[2],b[3])到(b[0],b[3])。
    {
        if(a[d][c]==0)
            d+=(n/abs(n));
        else
            break;
    }
    if(d==b[2])//存在竖直通道
    {
        
        d=b[2]-n;
        while(c!=b[1])// 验证是否存在水平通道(b[0],b[3])到(b[0],b[1])。
        {
            if(a[d][c]==0)
                c-=(m/abs(m));
            else
                break;
        }
        if(c==b[1])
        {
            Zero(a,b);
            return 1;
        }
        else
            return 0;
    }    
}
int  UpDown(int a[8][8],int b[4],int g)
{
    int r[4],i;
    for(i=0;i<4;i++)
        r[i]=b[i];
    //g=1表示(b[2],b[3])在(b[0],b[1])的下方,g=0表示(b[2],b[3])在(b[0],b[1])的上方
    if(g)
    {  
         //依次检查(b[2],b[3])上边的点是否为空格(直到(b[0],b[3])下方紧邻点),若为空格则检查该点与(b[0],b[1])
        //是否能通过两条线连通
        r[0]=r[0]+1;
        while(r[2]>=r[0])
        {
           r[2]-=1;
           if(Two(a,r)==1)
           {
            Zero(a,b);
            return 1;
           }
        }
    }
    else
    {
         //依次检查(b[2],b[3])下边的点是否为空格(直到(b[0],b[3])上方紧邻点),若为空格则检查该点与(b[0],b[1])
        //是否能通过两条线连通
        r[0]=r[0]-1;
        while(r[2]<=r[0])
        {
           r[2]+=1;
           if(Two(a,r)==1)
           {
            Zero(a,b);
            return 1;
           }
        }
    }
    return 0;
}
 
int LeftRight(int a[8][8],int b[4],int g)
{
    int r[4],i;
    for(i=0;i<4;i++)
        r[i]=b[i];
    //g=1表示(b[2],b[3])在(b[0],b[1])的右方,g=0表示(b[2],b[3])在(b[0],b[1])的左方
    if(g)
    {
        //依次检查(b[2],b[3])左边的点是否为空格(直到(b[2],b[1]右边紧邻的点),若为空格则检查该点与(b[0],b[1])
        //是否能通过两条线连通
        r[1]=r[1]+1;
        while(r[3]>=r[1])
        {
           r[3]-=1;
           if(Two(a,r)==1)
           {
               Zero(a,b);
               return 1;
           }
        }
    }
    else
    {
        //依次检查(b[2],b[3])右边的点是否为空格(直到(b[2],b[1]左边紧邻的点),若为空格则检查该点与(b[0],b[1])
        //是否能通过两条线连通
        r[1]-=1;
        while(r[3]<=r[1])
        {
           r[3]+=1;
           if(Two(a,r)==1)
           {
               Zero(a,b);
               return 1;
           }
        }
 
    }
    return 0;
}

小编再为大家分享一段代码:连连看消除算法的C++代码实现,过程比较复杂。

#include<iostream>
#include<vector>
using namespace std;
bool CheckRemove(int x1,int y1,int x2,int y2,int rows,int cols,int ***pArray);
void Swap(int &a,int &b);
typedef struct
{
    int x;
    int y;
}point;
int main()
{
    int Num=0;
    while(Num<=15)
    {
        int m,n,t;
        cin>>m>>n>>t;
        int **store_num=new int*[m];
        int **t_pos=new int*[t];
        for(int i=0;i<m;i++)
        {
            store_num[i]=new int[n];
        }
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                store_num[i][j]=0;
            }
        }
        for(int i=0;i<t;i++)
        {
            t_pos[i]=new int[4];
        }
        for(int i=0;i<t;i++)
        {
            for(int j=0;j<4;j++)
            {
                t_pos[i][j]=0;
            }
        }
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                cin>>store_num[i][j];
            }
        }
        for(int i=0;i<t;i++)
        {
            for(int j=0;j<4;j++)
            {
                cin>>t_pos[i][j];
            }
        }
        int score=0;
        for(int i=0;i<t;i++)
        {
            if(CheckRemove(t_pos[i][0],t_pos[i][1],t_pos[i][2],t_pos[i][3],m,n,&store_num))
            {
                score++;
            }
        }
        cout<<score<<endl;
        Num++;
    }
    return 0;
}
bool CheckRemove(int x1,int y1,int x2,int y2,int rows,int cols,int ***pArray)
{
 
    int m1=x1-1;int n1=y1-1;
    int m2=x2-1;int n2=y2-1;
    if((*pArray)[m1][n1]!=(*pArray)[m2][n2])
    {
        return false;
    }
    if(m1==m2&&(m1==0||m1==rows-1))
    {
        (*pArray)[m1][n1]=0;
        (*pArray)[m2][n2]=0;
        return true;
    }
    if(n1==n2&&(n1==0||n1==cols-1))
    {
        (*pArray)[m1][n1]=0;
        (*pArray)[m2][n2]=0;
        return true;
    }
    vector<point>v_point;
    point p_in;
    int **pArray_incre=new int*[rows+2];
    for(int i=0;i<rows+2;i++)
    {
        pArray_incre[i]=new int [cols+2];
    }
    for(int i=0;i<rows+2;i++)
    {
        for(int j=0;j<cols+2;j++)
        {
            pArray_incre[i][j]=0;
        }
    }
    for(int i=1;i<rows+1;i++)
    {
        for(int j=1;j<cols+1;j++)
        {
            pArray_incre[i][j]=(*pArray)[i-1][j-1];
        }
    }
    for(int y=y1+1;y<cols+2;y++)
    {
        if(pArray_incre[x1][y]!=0)
        {
            break;
        }
        p_in.x=x1;
        p_in.y=y;
        v_point.push_back(p_in);
    }
    for(int y=0;y<y1;y++)
    {
        if(pArray_incre[x1][y]!=0)
        {
            break;
        }
        p_in.x=x1;
        p_in.y=y;
        v_point.push_back(p_in);
    }
    for(int y=y2+1;y<cols+2;y++)
    {
        if(pArray_incre[x2][y]!=0)
        {
            break;
        }
        p_in.x=x2;
        p_in.y=y;
        v_point.push_back(p_in);
    }
    for(int y=0;y<y2;y++)
    {
        if(pArray_incre[x2][y]!=0)
        {
            break;
        }
        p_in.x=x2;
        p_in.y=y;
        v_point.push_back(p_in);
    }
    for(int i=0;i<(int)v_point.size();i++)
    {
        for(int j=0;j<(int)v_point.size();j++)
        {
            if(j!=i)
            {
                if(v_point[i].y==v_point[j].y)
                {
                    int yy=v_point[i].y;
                    int xx1=v_point[i].x;
                    int xx2=v_point[j].x;
                    if(xx1>xx2)
                        Swap(xx1,xx2);
                    int num=xx2-xx1+1;
                    int count=0;
                    for(int h=xx1;h<=xx2;h++)
                    {
                        if(pArray_incre[h][yy]==0)
                        {
                            count++;
                        }
                    }
                    if(count==num)
                    {
                        (*pArray)[x1-1][y1-1]=0;
                        (*pArray)[x2-1][y2-1]=0;
                        v_point.empty();
                        return true;
                    }
                }
            }
        }
    }
    v_point.empty();
    for(int x=x1+1;x<rows+2;x++)
    {
        if(pArray_incre[x][y1]!=0)
        {
            break;
        }
        p_in.x=x;
        p_in.y=y1;
        v_point.push_back(p_in);
    }
    for(int x=0;x<x1;x++)
    {
        if(pArray_incre[x][y1]!=0)
        {
            break;
        }
        p_in.x=x;
        p_in.y=y1;
        v_point.push_back(p_in);
    }
    for(int x=x2+1;x<rows+2;x++)
    {
        if(pArray_incre[x][y2]!=0)
        {
            break;
        }
        p_in.x=x;
        p_in.y=y2;
        v_point.push_back(p_in);
    }
    for(int x=0;x<x2;x++)
    {
        if(pArray_incre[x][y2]!=0)
        {
            break;
        }
        p_in.x=x;
        p_in.y=y2;
        v_point.push_back(p_in);
    }
    for(int i=0;i<(int)v_point.size();i++)
    {
        for(int j=0;j<(int)v_point.size();j++)
        {
            if(j!=i)
            {
                if(v_point[i].x==v_point[j].x)
                {
                    int xx=v_point[i].x;
                    int yy1=v_point[i].y;
                    int yy2=v_point[j].y;
                    if(yy1>yy2)
                        Swap(yy1,yy2);
                    int num=yy2-yy1+1;
                    int count=0;
                    for(int h=yy1;h<=yy2;h++)
                    {
                        if(pArray_incre[xx][h]==0)
                        {
                            count++;
                        }
                    }
                    if(count==num)
                    {
                        (*pArray)[x1-1][y1-1]=0;
                        (*pArray)[x2-1][y2-1]=0;
                        v_point.empty();
                        return true;
                    }
                }
            }
        }
    }
 
 
    return false;
}
void Swap(int &a,int &b)
{
    int tmp;
    tmp=a;
    a=b;
    b=tmp;
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • C++实现连连看消除算法

    C++连连看消除代码的实现,过程比较复杂. #include<iostream> #include<vector> using namespace std; bool CheckRemove(int x1,int y1,int x2,int y2,int rows,int cols,int ***pArray); void Swap(int &a,int &b); typedef struct { int x; int y; }point; int main() {

  • C++实现连连看游戏核心代码

    这两天研究了一下连连看游戏的源代码,感觉它挺简单的,主要就是判断选中的两张图片能否消去.我参考了网上的源代码(抱歉的是,不记得当时下载的网址了,在此对原作者表示深深的歉意!),然后自己把核心代码整理如下,与大家共享.需要说明的是,这只是核心算法的代码,界面设计和操作的代码均已略去. #include <stdlib.h> #include <time.h> //图片类 class picture { public: int type;//图片的编号,共有n种,从0到n-1 bool

  • C++连连看判定图形消除算法

    我们玩过的连连看游戏,通过选定两个图形相同的元素,判定其是否可在三次转弯内连接起来,若能,则消去,若不能,则不可消去,直至最后全部消除. 本算法中不包括关于死锁状态判定. // 连连看.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <iostream.h> #include <vector> #include <queue

  • C++ 风靡一时的连连看游戏的实现流程详解

    随着Flash应用的流行,网上出现了多种在线Flash版本"连连看".如"水晶连连看"."果蔬连连看"等,流行的"水晶连连看"以华丽界面吸引了一大批的女性玩家. 2008年,随着社交网络的普及和开放平台的兴起,"连连看"被引入了社交网络."连连看"与个人空间相结合,被快速的传播,成为一款热门的社交游戏,其中以开发者Jonevey在Manyou开放平台上推出的"宠物连连看&quo

  • 原生JavaScript编写canvas版的连连看游戏

    本文实例为大家分享了JavaScript编写canvas版的连连看游戏的具体实现代码,供大家参考,具体内容如下 效果图: 实现代码: <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> <style> #box{ /*border: 1px solid #D1D1D1; */ overflow: hidden; pos

  • Android实现疯狂连连看游戏之加载界面图片和实现游戏Activity(四)

    正如在<我的Android进阶之旅------>Android疯狂连连看游戏的实现之状态数据模型(三)>一文中看到的,在AbstractBoard的代码中,当程序需要创建N个Piece对象时,程序会直接调用ImageUtil的getPlayImages()方法去获取图片,该方法会随机从res/drawable目录中取得N张图片. 下面是res/drawable目录视图: 为了让getPlayImages()方法能随机从res/drawable目录中取得N张图片,具体实现分为以下几步: 通

  • 原生JavaScript实现连连看游戏(附源码)

    向大家推荐一款原生JavaScript版连连看游戏,源码下载,首页如下图所示:  首先看一下html的布局方式在index.html文件中: 复制代码 代码如下: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html> <head>

  • 使用非html5实现js板连连看游戏示例代码

    向大家分享一款如何实现js版连连看游戏,如下图所示: 首先看一下html的布局方式在index.html文件中: 复制代码 代码如下: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html> <head> <meta http

  • Android实现疯狂连连看游戏之开发游戏界面(二)

    连连看的游戏界面十分简单,大致可以分为两个区域: --游戏主界面区 --控制按钮和数据显示区 1.开发界面布局 本程序使用一个RelativeLayout作为整体的界面布局元素,界面布局上面是一个自定义组件,下面是一个水平排列的LinearLayout. 下面是本程序的布局文件:/res/layout/main.xml <?xml version="1.0" encoding="utf-8"?> <RelativeLayout xmlns:andr

  • Android实现疯狂连连看游戏之状态数据模型(三)

    对于游戏玩家而言,游戏界面上看到的"元素"千变万化:但是对于游戏开发者而言,游戏界面上的元素在底层都是一些数据,不同数据所绘制的图片有所差异而已.因此建立游戏的状态数据模型是实现游戏逻辑的重要步骤. 1.定义数据模型 连连看的界面是一个NxM的"网格",每个网格上显示一张图片.而这个网格只需要一个二维数组来定义即可,而每个网格上所显示的图片,对于底层数据模型来说,不同的图片对于着不同的数值即可. 对于上图所示的数据模型,只要让数值为0的网格上不绘制图片,其他数值的网

  • Android实现疯狂连连看游戏之实现游戏逻辑(五)

    在上一篇<我的Android进阶之旅------>Android疯狂连连看游戏的实现之加载界面图片和实现游戏Activity(四)>中提到的两个类: GameConf:负责管理游戏的初始化设置信息. GameService:负责游戏的逻辑实现. 其中GameConf的代码如下:cn\oyp\link\utils\GameConf.java package cn.oyp.link.utils; import android.content.Context; /** * 保存游戏配置的对象

  • Android实现疯狂连连看游戏之游戏效果预览(一)

    今天看完了李刚老师的<疯狂Android讲义>一书中的第18章<疯狂连连看>,从而学会了如何编写一个简单的Android疯狂连连看游戏. 开发这个流行的小游戏,难度适中,而且能充分激发学习热情,适合Android初学者来说是一个不错的选择.对于该游戏的开发,需要重点掌握单机游戏的界面分析和数据建模能力:游戏玩家严重看到的是游戏界面,但是在开发者眼中看到的应该是数据模型.除此之外,单机游戏通常需要一个比较美观的界面,需要通过自定义View来实现游戏主界面. 开发连连看游戏除了需要理解

  • 原生javascript实现连连看游戏

    本文实例为大家分享了js实现连连看游戏的具体代码,供大家参考,具体内容如下 <!DOCTYPE html> <html> <head> <title>连连看</title> <meta charset="gbk"> <style type="text/css"> body { text-align: center; } .text {text-align: center; margi

随机推荐