大大维的游戏机计划2--一个自制的类似2048的小游戏

最新推荐文章于 2024-05-15 07:31:04 发布
最新推荐文章于 2024-05-15 07:31:04 发布
阅读量700 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/umke888/article/details/54851513
版权

承接上篇，这几日，笔者本来打算写一个2048的，但写着写着，突然有个想法，能不能搞一个将2048和消消乐结合起来的游戏，于是，笔者便写出了如下这个小游戏。

值得一提的是，整个游戏完全由笔者独自写成，并没有参考任何网上的代码，这跟上次写贪吃蛇前学了老半天网上已有代码就显得独立了很多。看来贪食蛇的书写还是让笔者受益匪浅

定义的游戏规则如下：

1.采用类似2048的游戏规则合成数字

2.加入消消乐的点选作用（类似于在PC端模拟了一下触摸屏）

3.加入地图压缩规则

4.由于游戏像2048，就叫他NEW2048吧

虽然笔者将游戏按照所想做了出来，但笔者玩了一下，可玩性并不高。甚至十分枯燥！！！

尽管如此，这个游戏还是笔者完全独立书写的第一个游戏，意义还是蛮大的，因此笔者还是在此记录一笔。日后再翻出来改改，说不定能更好玩些。

大家可以试试这个游戏，并提提意见，可能有些bug，也请指正。

以后还是接着计划写剩余的游戏，加油。

  1 #include<iostream>
  2 #include<string>
  3 #include<cmath>
  4 #include<ctime>
  5 #include<cstdlib>
  6 #include<conio.h>
  7 using namespace std;
  8 constexpr unsigned HIGH=4;
  9 constexpr unsigned LENG=4;
 10 ///当前地图状态:READY，即()，可以进行moveAndAddData()操作;WAIT，即[],可以进行chooseMapSpace()操作
 11 enum state {READY,WAIT};
 12 ///当前操作块的移动方向及操作:UP,上;DOWN,下;LEFT,左;RIGHT,右;CHANGE,改变状态;DEFAULT,其他
 13 enum dir {UP,DOWN,LEFT,RIGHT,CHANGE,DEFAULT};
 14 class MapNew2048
 15 {
 16 public:
 17     MapNew2048();///构造函数，初始化数据
 18     void printMap();///地图打印
 19     void chooseMapSpace();///操作块移动，选择想要处理的地图块
 20     void moveAndAddData();///移动和相加选中块的数据
 21     ///压缩地图，将有意义的数值向左(上)角靠拢
 22     void mapSortToUp();
 23     void mapSortToLeft();
 24     ///当一行（一列）完全为空时，随机生成一个数加入地图（这个数不能大于当前所合成的最大数的一半）
 25     void dataCreate();
 26     void stateChange();///状态切换函数
 27     bool isLive();///是否存活判断
 28     state getState();///获取当前地图状态
 29     dir setDir();///输入操作块的移动方向
 30     unsigned getMaxData();
 31     string dataToPrintData(int n);///data到printData的转换函数
 32 private:
 33     unsigned data[HIGH][LENG];///设要显示数据为x，data=log2(x)，空白时，data=0
 34     string printData[HIGH][LENG];///存储规范化的输出数据
 35     int nowX;///记录当前操作块的位置
 36     int nowY;
 37     state sta;///记录当前地图状态，确定执行chooseMapSpace()还是moveAndAddData()
 38     bool flag;///记录上次moveAndAddData()操作是否成功
 39 };
 40 
 41 MapNew2048::MapNew2048()
 42 {
 43     for(int i=0; i<HIGH; i++)
 44         for(int j=0; j<LENG; j++)
 45         {
 46             data[i][j]=1;
 47             srand((unsigned)time(NULL)+(2*i+3*j));///确保每一次，地图的每一格生成的data都是随机的
 48             unsigned p=rand()%5;
 49             if(p!=0)
 50                 data[i][j]=p;
 51         }
 52     for(int i=0; i<HIGH; i++)
 53         for(int j=0; j<LENG; j++)
 54             printData[i][j]=dataToPrintData(data[i][j]);
 55     nowX=nowY=0;
 56     printData[nowX][nowY][0]='[';
 57     printData[nowX][nowY][7]=']';
 58     sta=WAIT;
 59 }
 60 
 61 state MapNew2048::getState()
 62 {
 63     return sta;
 64 }
 65 
 66 dir MapNew2048::setDir()
 67 {
 68     char keydown=getch();///读取按键
 69     switch(keydown)
 70     {
 71     case 'w':
 72         return UP;
 73         break;
 74     case 'W':
 75         return UP;
 76         break;
 77     case 's':
 78         return DOWN;
 79         break;
 80     case 'S':
 81         return DOWN;
 82         break;
 83     case 'a':
 84         return LEFT;
 85         break;
 86     case 'A':
 87         return LEFT;
 88         break;
 89     case 'd':
 90         return RIGHT;
 91         break;
 92     case 'D':
 93         return RIGHT;
 94         break;
 95     case ' ':
 96         return CHANGE;
 97         break;
 98     default:
 99         return DEFAULT;
100         break;
101     }
102 }
103 unsigned MapNew2048::getMaxData()
104 {
105     unsigned temp=data[0][0];
106     for(int i=0; i<HIGH; i++)
107         for(int j=0; j<LENG; j++)
108         {
109             temp=temp>data[i][j]?temp:data[i][j];
110         }
111     return temp;
112 }
113 void MapNew2048::printMap()
114 {
115     cout<<"            NEW   2    0    4    8"<<endl;
116     cout<<"-----------------------------------------------------"<<endl;
117     for(int i=0; i<HIGH; i++)
118     {
119         for(int j=0; j<LENG; j++)
120         {
121             if(data[i][j]!=0)
122                 cout<<"|  "<<printData[i][j]<<"  ";
123             else
124                 cout<<"|  "<<printData[i][j][0]<<"      "<<printData[i][j][7]<<"  ";
125         }
126         cout<<"|"<<endl<<"-----------------------------------------------------"<<endl;
127     }
128 }
129 
130 string MapNew2048::dataToPrintData(int n)
131 {
132 
133     int count=0;
134     int m=pow(2,n);
135     ///str的初始化基于如下数学关系：4*4的地图下，2048游戏能合成数，理论上最大值131072(2^17),即data最大为17
136     string str {' ',m/100000+48,(m/10000)%10+48,(m/1000)%10+48,(m/100)%10+48,(m/10)%10+48,m%10+48,' '};
137     ///对冗余0的处理
138     for(int i=1; i<7; i++)
139     {
140         if(str[i]=='0')
141         {
142             count++;
143             str[i]=' ';
144         }
145         else
146             break;
147     }
148     switch(count)///格式调整
149     {
150     case 2:///不加break会在执行完第一条语句后自动执行break
151     {
152         str[2]=str[3];
153         str[3]=str[4];
154         str[4]=str[5];
155         str[5]=str[6];
156         str[6]=' ';
157         break;
158     }
159     case 3:
160     {
161         str[3]=str[4];
162         str[4]=str[5];
163         str[5]=str[6];
164         str[6]=' ';
165         break;
166     }
167     case 4:
168     {
169         str[3]=str[5];
170         str[4]=str[6];
171         str[5]=' ';
172         str[6]=' ';
173         break;
174     }
175     case 5:
176     {
177         str[4]=str[6];
178         str[6]=' ';
179         break;
180     }
181     }
182     return str;
183 }
184 void MapNew2048::chooseMapSpace()
185 {
186 
187     if(sta==WAIT)
188     {
189         printData[nowX][nowY][0]=printData[nowX][nowY][7]=' ';
190         dir DIR=setDir();
191         switch(DIR)
192         {
193         case LEFT:
194         {
195             nowY--;
196             if(nowY<0)
197                 nowY=LENG-1;
198             printData[nowX][nowY][0]='[';
199             printData[nowX][nowY][7]=']';
200             break;
201         }
202         case RIGHT:
203         {
204             nowY++;
205             if(nowY>LENG-1)
206                 nowY=0;
207             printData[nowX][nowY][0]='[';
208             printData[nowX][nowY][7]=']';
209             break;
210         }
211         case UP:
212         {
213             nowX--;
214             if(nowX<0)
215                 nowX=HIGH-1;
216             printData[nowX][nowY][0]='[';
217             printData[nowX][nowY][7]=']';
218             break;
219         }
220         case DOWN:
221         {
222             nowX++;
223             if(nowX>HIGH-1)
224                 nowX=0;
225             printData[nowX][nowY][0]='[';
226             printData[nowX][nowY][7]=']';
227             break;
228         }
229         case CHANGE:
230             stateChange();
231             break;
232         case DEFAULT:
233         {
234             printData[nowX][nowY][0]='[';
235             printData[nowX][nowY][7]=']';
236             break;
237         }
238         }
239     }
240 }
241 void MapNew2048::moveAndAddData()
242 {
243     if(sta==READY)
244     {
245         printData[nowX][nowY][0]=printData[nowX][nowY][7]=' ';
246         dir DIR=setDir();
247         switch(DIR)
248         {
249         case LEFT:
250         {
251             if((data[nowX][nowY]==data[nowX][nowY-1])&&(nowY>0)&&(data[nowX][nowY-1]>0))
252             {
253                 data[nowX][nowY]=0;
254                 nowY--;
255                 data[nowX][nowY]++;
256                 printData[nowX][nowY]=dataToPrintData(data[nowX][nowY]);
257                 printData[nowX][nowY][0]='(';
258                 printData[nowX][nowY][7]=')';
259             }
260             else
261             {
262                 printData[nowX][nowY][0]='(';
263                 printData[nowX][nowY][7]=')';
264             }
265             mapSortToLeft();
266             mapSortToUp();
267             break;
268         }
269         case RIGHT:
270         {
271             if((data[nowX][nowY]==data[nowX][nowY+1])&&(nowY<LENG-1)&&(data[nowX][nowY+1]>0))
272             {
273                 data[nowX][nowY]=0;
274                 nowY++;
275                 data[nowX][nowY]++;
276                 printData[nowX][nowY]=dataToPrintData(data[nowX][nowY]);
277                 printData[nowX][nowY][0]='(';
278                 printData[nowX][nowY][7]=')';
279             }
280             else
281             {
282                 printData[nowX][nowY][0]='(';
283                 printData[nowX][nowY][7]=')';
284             }
285             mapSortToLeft();
286             mapSortToUp();
287             break;
288         }
289         case UP:
290         {
291             if((data[nowX][nowY]==data[nowX-1][nowY])&&(nowX>0)&&(data[nowX-1][nowY]>0))
292             {
293                 data[nowX][nowY]=0;
294                 nowX--;
295                 data[nowX][nowY]++;
296                 printData[nowX][nowY]=dataToPrintData(data[nowX][nowY]);
297                 printData[nowX][nowY][0]='(';
298                 printData[nowX][nowY][7]=')';
299             }
300             else
301             {
302                 printData[nowX][nowY][0]='(';
303                 printData[nowX][nowY][7]=')';
304             }
305             mapSortToUp();
306             mapSortToLeft();
307             break;
308         }
309         case DOWN:
310         {
311             if((data[nowX][nowY]==data[nowX+1][nowY])&&(nowX<HIGH-1)&&(data[nowX+1][nowY]>0))
312             {
313                 data[nowX][nowY]=0;
314                 nowX++;
315                 data[nowX][nowY]++;
316                 printData[nowX][nowY]=dataToPrintData(data[nowX][nowY]);
317                 printData[nowX][nowY][0]='(';
318                 printData[nowX][nowY][7]=')';
319             }
320             else
321             {
322                 printData[nowX][nowY][0]='(';
323                 printData[nowX][nowY][7]=')';
324             }
325             mapSortToUp();
326             mapSortToLeft();
327             break;
328         }
329         case CHANGE:
330             stateChange();
331             break;
332         case DEFAULT:
333         {
334             printData[nowX][nowY][0]='(';
335             printData[nowX][nowY][7]=')';
336             break;
337         }
338         }
339     }
340 }
341 
342 void MapNew2048::stateChange()
343 {
344     if(sta==WAIT)
345     {
346         sta=READY;
347         printData[nowX][nowY][0]='(';
348         printData[nowX][nowY][7]=')';
349     }
350     else
351     {
352         sta=WAIT;
353         printData[nowX][nowY][0]='[';
354         printData[nowX][nowY][7]=']';
355     }
356 }
357 
358 void MapNew2048::mapSortToUp()///地图向上压缩
359 {
360     for(int n=0; n<LENG; n++)
361     {
362         for(int m=0; m<HIGH; m++)
363         {
364             if(data[m][n]==0&&m<HIGH-1)
365             {
366                 for(int k=m; k<HIGH-1; k++)
367                 {
368                     data[k][n]=data[k+1][n];
369                     printData[k][n]=dataToPrintData(data[k][n]);
370                 }
371                 data[HIGH-1][n]=0;
372             }
373         }
374     }
375     ///调整时，会将printData[nowX][nowY]的标志冲掉，需要恢复一步
376     printData[nowX][nowY][0]='(';
377     printData[nowX][nowY][7]=')';
378 }
379 void MapNew2048::mapSortToLeft()///地图向左压缩
380 {
381     for(int m=0; m<HIGH; m++)
382     {
383         for(int n=0; n<LENG; n++)
384         {
385             if(data[m][n]==0&&n<LENG-1)
386             {
387                 for(int k=n; k<LENG-1; k++)
388                 {
389                     data[m][k]=data[m][k+1];
390                     printData[m][k]=dataToPrintData(data[m][k]);
391                 }
392                 data[m][LENG-1]=0;
393             }
394         }
395     }
396     printData[nowX][nowY][0]='(';
397     printData[nowX][nowY][7]=')';
398 }
399 
400 //void MapNew2048::dataCreate()
401 //{
402 //    bool dataCreateFlag1=true;///列向生成newData标志
403 //    bool dataCreateFlag2=true;///横向生成newData标志
404 //    for(int i=0; i<HIGH; i++)
405 //        if(data[i][LENG-1]!=0)
406 //        {
407 //            dataCreateFlag1=false;
408 //            break;
409 //        }
410 //    for(int i=0; i<LENG; i++)
411 //        if(data[HIGH-1][i]!=0)
412 //        {
413 //            dataCreateFlag2=false;
414 //            break;
415 //        }
416 //    if(!dataCreateFlag1&&!dataCreateFlag2);///不用生成newData
417 //    else
418 //    {
419 //        unsigned max=getMaxData();
420 //        ///创建的数不大于当前地图显示的合成的最大数的一半,newData最大为max-1
421 //        srand((unsigned int)time(NULL));
422 //        unsigned newData=rand()%max;
423 //        if(newData==0)
424 //            newData++;
425 //        /**经过上述的newData生成算法，P(newData=1)=2/(max-1),P(newData=other)=1/(max-1)**/
426 //
427 //        /**下面的几行语句用于确定newData在地图中的位置**/
428 //        if(dataCreateFlag1&&!dataCreateFlag2)
429 //        {
430 //            srand((unsigned int)time(NULL));
431 //            int a=rand()%HIGH;
432 //            data[a][LENG-1]=newData;
433 //            printData[a][LENG-1]=dataToPrintData(data[a][LENG-1]);
434 //            mapSortToLeft();///地图压缩
435 //        }
436 //        else if(!dataCreateFlag1&&dataCreateFlag2)
437 //        {
438 //            srand((unsigned int)time(NULL));
439 //            int b=rand()%LENG;
440 //            data[HIGH-1][b]=newData;
441 //            printData[HIGH-1][b]=dataToPrintData(data[HIGH-1][b]);
442 //            mapSortToUp();///地图压缩
443 //        }
444 //        else if(dataCreateFlag1&&dataCreateFlag2)
445 //        {
446 //            srand((unsigned int)time(NULL));
447 //            int a=rand()%HIGH;
448 //            data[a][LENG-1]=newData;
449 //            printData[a][LENG-1]=dataToPrintData(data[a][LENG-1]);
450 //            if(a==HIGH-1)
451 //            {
452 //                mapSortToLeft();///地图压缩
453 //                mapSortToUp();
454 //            }
455 //            else
456 //                mapSortToLeft();
457 //        }
458 //    }
459 //}
460 
461 
462 bool MapNew2048::isLive()
463 {
464     ///isLive函数基于如下数学关系：反复使用向右，向下查询（最右行只向下）,
465     ///最底行只向右，可以将他的所有邻居遍历一次
466     bool liveFlag=false;
467     for(int i=0; i<HIGH; i++)
468     {
469         for(int j=0; j<LENG; j++)
470         {
471             if(i!=HIGH-1&&j!=LENG-1&&data[i][j]!=0)
472             {
473                 if(data[i][j]==data[i+1][j]||data[i][j]==data[i][j+1])
474                 {
475                     liveFlag=true;
476                     return liveFlag;
477                 }
478             }
479             else if(i==HIGH-1&&j!=LENG-1&&data[i][j]!=0)
480             {
481                 if(data[i][j]=data[i+1][j])
482                 {
483                     liveFlag=true;
484                     return liveFlag;
485                 }
486             }
487             else if(i!=HIGH-1&&j==LENG-1&&data[i][j]!=0)
488             {
489                 if(data[i][j]=data[i][j+1])
490                 {
491                     liveFlag=true;
492                     return liveFlag;
493                 }
494             }
495         }
496     }
497     return liveFlag;
498 }
499 
500 int main()
501 {
502     bool gameOverFlag=false;
503     MapNew2048 map;
504     map.printMap();
505     while(!gameOverFlag)
506     {
507         while(kbhit())
508         {
509             system("cls");
510         if(map.getState()==WAIT)
511             map.chooseMapSpace();
512         else
513         {
514             map.moveAndAddData();
515 //            map.dataCreate();
516         }
517         if(!map.isLive())
518             gameOverFlag=true;
519         map.printMap();
520         }
521 
522     }
523     cout<<endl<<"The Max is:  "<<pow(2,map.getMaxData())<<endl;
524 }
View Code

付几张游戏截图：

 

umke888
关注
1.第一章 计算机基础和Linux安装 -- 计算机基础（一）
Raymond的博客
12-01 886
基于电路设计的复杂性和成本考虑，对于当前计算机来讲，是基于二进制来处理数据的（未来或许不是这样，如量子计算机）。比如可以用高低电平，磁极的正反，光照的有无等分别表示1和0，相对其它进制更容易实现，成本也更低。进制数值表示英文简写特性二进制0、1BinaryBIN或B逢二进一八进制OctalOCT或O逢八进一十进制DecimalDEC或D逢十进一十六进制HEX或H逢十六进一表1-1 常见进制数值表示和特性那么什么是二进制呢？
计算机网络原理 - 网络层、链路层总结笔记
BaiKnow的博客
02-05 6528
计算机网络原理 - 网络层、链路层 ##4.网络层 网络层主要是利用IP上的传输，在路由器中最高达到的层次为网络层，分组交换机只到链路层；IP准确来说不是一个主机的地址，而是一个接口的地址。 4.1 概述 网络层的作用：将分组从一台发送主机移动到一台接收主机。 4.1.1 转发和路由选择 转发：当一个分组到达路由器的一条输入链路时，路由器必须将该分组移动到适当的输出链路 路由选择：分组从发送方流向接收方时，网络层必须决定这些分组采用的路由或路径，路由选择算法 概述： 转发是路由器本地动作，路由
自己制作的一个小游戏
12-11
public static CardBigType getBigType(int id) { CardBigType bigType = null; if (id >= 1 && id <= 13) { bigType = CardBigType.FANG_KUAI; } else if (id >= 14 && id <= 26) { bigType = CardBigType.MEI_HUA; } else if (id >= 27 && id <= 39) { bigType = CardBigType.HONG_TAO; } else if (id >= 40 && id <= 52) { bigType = CardBigType.HEI_TAO; } else if (id == 53) { bigType = CardBigType.XIAO_WANG; } else if (id == 54) { bigType = CardBigType.DA_WANG; } return bigType;
自制小游戏代码
01-24
自制的贪食蛇小游戏
c++自制小游戏（源码）
最新发布
ybt_answer的博客
05-15 153
【代码】c++自制小游戏（源码）
Python嘎嘎涨知识的7个小游戏，玩过的都爱不释手（附源码，直接运行就可）
xff123456_的博客
06-19 1671
今天星期七，是一个快乐的日子。上班族不用上班，学生不用学习。我也不想分享太多的知识去为难大家，就给大家七个小游戏吧，从周一玩到周日的那种，学会了记得来找我PK…玩法：三个相连就能消除源码分享： 玩法：童年经典，普通模式没啥意思，小时候我们都是玩加速的。源码分享： 玩法：童年经典，普通魔术也没啥意思，小时候玩的也是加速的。源码分享： 4、24点小游戏 玩法：通过加减乘除操作，小学生都没问题的。源码分享： 玩法：也是小时候的经典游戏，控制左右就行，到后面才有一点点难度。源码分享： 6、外星人入侵 玩法：这让我想
游戏引擎全剖析
kellymalan的专栏
01-05 3434
第1部分: 游戏引擎介绍， 渲染和构造3D世界  介绍　　自Doom游戏时代以来我们已经走了很远。 DOOM不只是一款伟大的游戏，它同时也开创了一种新的游戏编程模式: 游戏 "引擎"。 这种模块化，可伸缩和扩展的设计观念可以让游戏玩家和程序设计者深入到游戏核心，用新的模型，场景和声音创造新的游戏， 或向已有的游戏素材中添加新的东西。大量的新游戏根据已经存在的游戏引擎开发出来，而大多数都以I
具有 Unity Terrain 功能的简单环境设计
分享身边生活经验blog
10-17 2556
Unity Terrain是用于关卡和环境设计的Unity 原生、强大且通用的工具。它提供了简单的机制来使用高度图的概念来塑造和修改地形。在本文中，我们将了解如何使用此工具及其主要功能的基础知识。我们从使用高度图如何生成地形的理论开始。然后我们将讨论修改地形的主要机制。在文章的最后，我介绍了使用免费资源和 Unity Terrain 工具制作精美 Unity 场景的典型工作流程。从高度图到地形Unity 地形设置雕刻和改变地形的选项种树、种草和……石头？具有 LOD 组的更多功能树。
ps2工具碟ulaunchELF4.4
11-05
2. 文件管理： ulaunchELF 提供了一个类似FTP的界面，用户可以通过记忆卡或连接的USB设备浏览、复制、移动、删除、重命名文件和目录。这对于备份和恢复游戏数据，以及组织PS2上的文件非常有用。 3. 游戏加载：...
小游戏制作源码
01-22
小游戏制作，可以帮助新手快速入门，我们不生产源码，我们只是源码的搬运工
用HTML编写的小游戏(源代码).zip
01-09
用HTML编写的小游戏(源代码).zip
自制抽奖游戏源码
09-24
本文以通俗易懂的方式解析网络游戏抽奖模块如何开发 抽装备模块如何写
贪吃蛇小游戏代码html,自制贪吃蛇小游戏代码
weixin_35697651的博客
06-01 1461
package game;import java.awt.*;import java.awt.event.*;import javax.swing.*;public class Game_Start extends JFrame{JFrame frame = new JFrame();JButton btn1 = new JButton("开始游戏");JButton btn2 = new JBu...
一百行写一个2048
盼盼的博客
07-29 219
文章目录零、写在之前壹、设计思路贰、主程序的构建叁、随机出生模块肆、检查模块伍、显示模块陆、移动模块柒、完全代码展示捌、一点感想 零、写在之前 这个2048小游戏是后面为了用来做强化学习而写的游戏，这里并没有图形化界面，但后面会用pygame补充一下显示界面。 然后简单减少一下本次实验的环境： pycharm2021 python3.9 第三方库:numpy 然后让我们来看一下成果图 壹、设计思路 无论做什么，在前期都有必要做一个设计思路的概要，计时后面你发现他有很多不完善的地方，但是他却可以给你的设
python制作简单小游戏代码,用python做简单的小游戏
Night368的博客
03-25 712
大家好，小编来为大家解答以下问题，用python做一个简单小游戏，python制作简单小游戏代码，现在让我们一起来看看吧！大家好，我是小F~经常听到有朋友说，学习编程是一件非常枯燥无味的事情。其实，大家有没有认真想过，可能是我们的学习方法不对？比方说，你有没有想过，可以通过打游戏来学编程？今天我想跟大家分享，教你如何通过边打游戏边学编程！相关文件及代码都已上传，公众号回复【】即可获取。接下来就一起来看看吧~
一个自制的小游戏
qq_34739497的博客
06-03 786
很久没写博客了，来分享一个自己结合Orange老师讲的自己做了个Doodle jump小游戏，陆陆续续每天花的时间不一，几乎茶余饭后做一个，算是一个比较完整的Unity的demo，下面我会给出资源链接，里面包含了许多小的知识点，基本上百度都能找到，但是 也有一些需要自己慢慢琢磨才能做出来，其中比如一些物体之间的碰撞，安卓平台的发布，手机重力感应控制物体移动，其中也有许多卡了很久的知识点，但是过几天
python编写小游戏的代码,python游戏编程代码大全
2401_82891570的博客
03-15 1128
玩法：这让我想起了魂斗罗那第几关的boss，有点类似，不过魂斗罗那个难度肯定高点。玩法：童年经典，普通模式没啥意思，小时候我们都是玩加速的。玩法：童年经典，普通魔术也没啥意思，小时候玩的也是加速的。玩法：三个相连就能消除。玩法：也是小时候的经典。
用代码制作小游戏：简单制作给孩子幸福童年
LLand520的博客
01-06 7557
利用jQuery实现拼图游戏： 代码结构 引入CSS 1.<link rel="stylesheet" href="css/index.css"> 引入JS <script type="text/javascript" src="js/jquery.min.js"></script> <script type="text/javascript...
C++实现简易版2048小游戏教程
资源摘要信息:"2048游戏是一款在2014年发布于互联网上的数字拼图游戏。玩家通过上下左右滑动...通过学习和实现一个像2048这样的小游戏，初学者不仅能够对C++编程有更深入的理解，还能学会如何组织和管理一个小型项目。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值