Move.h && Move.c

最新推荐文章于 2021-10-10 14:15:11 发布
翻译 最新推荐文章于 2021-10-10 14:15:11 发布 · 888 阅读 · 0

本文详细介绍了2048游戏的基本实现原理和技术细节，包括游戏初始化、新方块生成、移动判断及处理等核心功能，并提供了具体的源代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

#ifndef	MOVE_H
#define	MOVE_H

#define	MOVE_UP		1
#define	MOVE_DOWN	2
#define	MOVE_LEFT	4
#define	MOVE_RIGHT	8

void initField(tHandle* handle);
int newTile(tHandle* handle);
int checkMoveable(tHandle* handle);
int makeMove(tHandle *handle,tUInt8 move);

#endif


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ncurses.h>
#include "Config.h"
#include "Datatypes.h"
#include "Move.h"
#include "Output.h"

void initField(tHandle* handle)
{
	int i;
	int j;
	
	for (i=0;i<TILE_ROWS;i++)
	{
		for (j=0;j<TILE_COLS;j++)
		{
			handle->actField.tile[i][j]=0;
		}
	}
	handle->score=0;
}

int newTile(tHandle* handle)
{
	int i;
	int j;
	tUInt32 r;
	int pos[TILE_MASK+1];
	tField nxtField;
	
	int cnt;
	
	cnt=0;	
	for (i=0; i<TILE_ROWS; i++)
	{
		for (j=0; j<TILE_COLS; j++)
		{
			if ( !handle->actField.tile[i][j]) 
				pos[cnt++] = i * TILE_COLS + j;
		}
	}
	if (cnt)
	{
		memcpy(&nxtField, &(handle->actField), sizeof(tField));
		r=cnt;
		while ( r >= cnt )
		{
			r = rand()&TILE_MASK;
		}
		cnt = pos[r];
		r = rand();
		if (r<0) r = -r;
		if ((r%TILE_4_PROB)==0) r=4;
		else r = 2;
		i = cnt/TILE_ROWS;
		j = cnt%TILE_ROWS;
		nxtField.tile[i][j] = r;
		// TODO: spawnTile(handle,i,j);
		memcpy(&(handle->actField), &nxtField, sizeof(tField));
		return 1;
	}
	else 
	{
		return 0;
	}
}

int checkMoveable(tHandle* handle)
{

	int i,j;
	int retval=0;
	
	for (i=0; i<TILE_ROWS; i++)
	{
		for (j=0; j<TILE_COLS; j++)
		{
			int x, y;
			x = handle->actField.tile[i][j];
			if (x)
			{
				if (j!=0) 
				{
					y = handle->actField.tile[i][j-1];
					if (y==0) retval |= MOVE_LEFT;
					if (x==y) retval |= (MOVE_LEFT|MOVE_RIGHT);
				}
				if (j != TILE_COLS-1) 
				{
					y = handle->actField.tile[i][j+1];
					if (y == 0) retval |= MOVE_RIGHT;
					if (x == y) retval |= (MOVE_LEFT|MOVE_RIGHT);
				}
			}
		}
	}

	for (i=0; i<TILE_COLS; i++)
	{
		for (j=0;j<TILE_ROWS;j++)
		{
			int x,y;
			x=handle->actField.tile[j][i];
			if (x)
			{
				if (j!=0) 
				{
					y=handle->actField.tile[j-1][i];
					if (y==0) retval|=MOVE_UP;
					if (x==y) retval|=(MOVE_UP|MOVE_DOWN);
				}
				if (j!=TILE_ROWS-1) 
				{
					y=handle->actField.tile[j+1][i];
					if (y==0) retval|=MOVE_DOWN;
					if (x==y) retval|=(MOVE_UP|MOVE_DOWN);
				}
			}
		}
	}


	return retval;	
}

int makeMove(tHandle *handle,tUInt8 move)
{
	signed int i,j,k;
	int moved;

	moved=0;	
	
	i=checkMoveable(handle);
	if (i&move)
	{
		switch (move)
		{
			case MOVE_UP:
				// 
				for (i=0; i<TILE_COLS; i++)
				{
					int newpos[TILE_ROWS];
					int newTiles[TILE_ROWS];
					int combined[TILE_ROWS];
					
					for (j=0; j<TILE_ROWS; j++) 
					{
						combined[j]=0;
						newTiles[j]=handle->actField.tile[j][i];
						newpos[j]=j;
					}
					for (j=0;j<TILE_ROWS;j++)
					{
						int found;
						combined[j]=0;
						if (newTiles[j])
						{
							found=-1;
							for (k=j-1;k>=0 && found==-1;k--)
							{
								if (newTiles[k]==0) newpos[j]=k;
								else found=k;
							}

							found=-1;
							for (k=j+1;k<TILE_ROWS && found==-1;k++)
							{
								if (newTiles[k])
								{
									found=k;
									if (newTiles[j]==newTiles[k])
									{
										handle->score+=newTiles[j];
										newpos[k]=newpos[j];
										newTiles[j]*=2;
										newTiles[k]=0;
										combined[j]=1;
										moved=1;
									}
								}
							}

							if (newpos[j]!=j)
							{
								transition(handle,handle->actField.tile[j][i], j,newpos[j], i,i);
								combined[newpos[j]]=combined[j];
								newTiles[newpos[j]]=newTiles[j];
								newTiles[j]=0;
								combined[j]=0;
								moved=1;
							}			
						}
					}
					// TODO: transition

					for (j=0;j<TILE_ROWS;j++)
					{
						handle->actField.tile[j][i]=newTiles[j];
					}
				}
				break;

			case MOVE_DOWN:
				// 
				for (i=0;i<TILE_COLS;i++)
				{
					int newpos[TILE_ROWS];
					int newTiles[TILE_ROWS];
					int combined[TILE_ROWS];
					
					for (j=TILE_ROWS-1;j>=0;j--)
					{
						combined[j]=0;
						newTiles[j]=handle->actField.tile[j][i];
						newpos[j]=j;
					}
					for (j=TILE_ROWS-1;j>=0;j--)
					{
						int found;
						combined[j]=0;
						newpos[j]=j;
						if (newTiles[j])
						{
							found=-1;
							for (k=j+1;k<TILE_ROWS && found==-1;k++)
							{
								if (newTiles[k]==0) newpos[j]=k;
								else found=k;
							}
							found=-1;
							for (k=j-1;k>=0 && found==-1;k--)
							{
								if (newTiles[k])
								{
									found=k;
									if (newTiles[j]==newTiles[k])
									{
										handle->score+=newTiles[j];
										newpos[k]=newpos[j];
										newTiles[j]*=2;
										newTiles[k]=0;
										combined[j]=1;
										moved=1;
									}
								}
							}

							if (newpos[j]!=j)
							{
								transition(handle,handle->actField.tile[j][i], j,newpos[j], i,i);
								combined[newpos[j]]=combined[j];
								newTiles[newpos[j]]=newTiles[j];
								newTiles[j]=0;
								combined[j]=0;
								moved=1;
							}			
						}
					}
					// TODO: transition

					for (j=0;j<TILE_ROWS;j++)
					{
						handle->actField.tile[j][i]=newTiles[j];
					}
				}
				break;

			case MOVE_LEFT:
				// 
				for (i=0;i<TILE_ROWS;i++)
				{
					int newpos[TILE_COLS];
					int newTiles[TILE_COLS];
					int combined[TILE_COLS];
					
					for (j=0;j<TILE_COLS;j++) 
					{
						combined[j]=0;
						newTiles[j]=handle->actField.tile[i][j];
						newpos[j]=j;
					}
					for (j=0;j<TILE_COLS;j++)
					{
						int found;
						combined[j]=0;
						newpos[j]=j;
						if (newTiles[j])
						{
							found=-1;
							for (k=j-1;k>=0 && found==-1;k--)
							{
								if (newTiles[k]==0) newpos[j]=k;
								else found=k;
							}

							found=-1;
							for (k=j+1;k<TILE_COLS && found==-1;k++)
							{
								if (newTiles[k])
								{
									found=k;
									if (newTiles[j]==newTiles[k])
									{
										handle->score+=newTiles[j];
										newpos[k]=newpos[j];
										newTiles[j]*=2;
										newTiles[k]=0;
										combined[j]=1;
										moved=1;
									}
								}
							}

							if (newpos[j]!=j)
							{
								transition(handle,handle->actField.tile[i][j], i,i, j,newpos[j]);
								combined[newpos[j]]=combined[j];
								newTiles[newpos[j]]=newTiles[j];
								newTiles[j]=0;
								combined[j]=0;
								moved=1;
							}			
						}
					}
					// TODO: transition

					for (j=0;j<TILE_COLS;j++)
					{
						handle->actField.tile[i][j]=newTiles[j];
					}
				}
				break;

			case MOVE_RIGHT:
				// 
				for (i=0;i<TILE_ROWS;i++)
				{
					int newpos[TILE_COLS];
					int newTiles[TILE_COLS];
					int combined[TILE_COLS];
					
					for (j=TILE_COLS-1;j>=0;j--)
					{
						combined[j]=0;
						newTiles[j]=handle->actField.tile[i][j];
						newpos[j]=j;
					}
					for (j=TILE_COLS-1;j>=0;j--)
					{
						int found;
						combined[j]=0;
						newpos[j]=j;
						if (newTiles[j])
						{
							found=-1;
							for (k=j+1;k<TILE_COLS && found==-1;k++)
							{
								if (newTiles[k]==0) newpos[j]=k;
								else found=k;
							}

							found=-1;
							for (k=j-1;k>=0 && found==-1;k--)
							{
								if (newTiles[k])
								{
									found=k;
									if (newTiles[j]==newTiles[k])
									{
										handle->score+=newTiles[j];
										newpos[k]=newpos[j];
										newTiles[j]*=2;
										newTiles[k]=0;
										combined[j]=1;
										moved=1;
									}
								}
							}

							if (newpos[j]!=j)
							{
								transition(handle,handle->actField.tile[i][j], i,i, j,newpos[j]);
								combined[newpos[j]]=combined[j];
								newTiles[newpos[j]]=newTiles[j];
								newTiles[j]=0;
								combined[j]=0;
								moved=1;
							}			
						}
					}
					// TODO: transition

					for (j=0;j<TILE_COLS;j++)
					{
						handle->actField.tile[i][j]=newTiles[j];
					}
				}
				break;
			}
		if (moved)
		{
			for (i=0;i<TILE_ROWS;i++)
			{
				for (j=0;j<TILE_COLS;j++)
				{
					if (moved<handle->actField.tile[i][j]) moved=handle->actField.tile[i][j];
				}
			}
		}
		if (handle->score>handle->best) handle->best=handle->score;
		return moved;
	} else {
		return 0;
	}
}

linux内核学习中--"list.h" del move splice 函数理解
ggxxkkll的专栏
05-22 2697
第三篇博客，主要是针对删除，移动，合并函数的理解,很简单的，相信大家一看就明白了。 static inline void __list_del(struct list_head * prev, struct list_head * next) //删除结点。删除链表中prev与next之间的元素 { next->prev = prev; prev->
Linux中List.h文件的分析和应用
fengel_cs的专栏
10-07 2572
本文介绍Linux中List.h文件，此文件中用双向链表实现了多种数据结构，比如队列，堆栈等，短小精湛，值得借鉴。此文件中还有哈希表的应用。
Move.c && Move.h
Achiberx
05-21 765
#include #include #include #include #include "Config.h" #include "Datatypes.h" #include "Move.h" #include "Output.h" void initField(tHandle* handle) { int i; int j; for (i=0;i<TILE_ROWS;i++)
std::forward和std::move源码分析
kupePoem的专栏
08-29 960
一、forward源码 /** * @brief Forward an lvalue. * @return The parameter cast to the specified type. * * This function is used to implement "perfect forwarding". */ template<typename _Tp> constexpr _Tp&& forward(typ
C/C++学习记录：std::move 源码分析
这里是河边
10-10 2773
抽空扣一点感兴趣的标准库源码，这里总结一下 std::move() 相关的分析 本文中 gcc version: 8.4.1 20200928 (Red Hat 8.4.1-1) (GCC) 其中c++库安装路径为 /usr/include/c++/8 目录一、源码与分析1. std::move 源码总览2. std::remove_reference 源码分析3. static_cast 分析4. std::move 分析5. std::move 中的引用折叠二、总结 一、源码与分析 1. std::.
指针||指针和数组||指针和函数||指针、数组、函数 案例描述：封装一个函数，利用冒泡排序，实现对整型数组的升序排序
qq_39368007的博客
02-08 495
指针 指针的基本概念 指针的作用： 可以通过指针间接访问内存 内存编号是从0开始记录的，一般用十六进制数字表示 可以利用指针变量保存地址 指针变量的定义和使用 指针变量定义语法： 数据类型 * 变量名； #include <iostream> using namespace std; int main() { //1、指针的定义 int a = 10...
我的Move.c文件已经包含了Timer.h，但在Move.c文件中进行结构体成员的赋值start_coord.x = 100;会报下面的错误，请分析原因并提出解决方案：Hardware\Move.c(12): error: #77-D: this declaration has no storage class or type specifier start_coord.x = 100; Hardware\Move.c(12): error: #147: declaration is incompatible with "volatile Coordinate start_coord" (declared at line 9 of ".\System\Timer.h") start_coord.x = 100; Hardware\Move.c(12): error: #65: expected a ";" start_coord.x = 100;
最新发布
03-18
现在在Move.c里包含Timer.h后，尝试给start_coord.x赋值时出现了三个编译错误。用户已经按照之前的建议检查了头文件保护和包含，但问题依旧存在。我需要仔细分析错误信息，找出根本原因。 首先看第一个错误：#77-D...
#include "move.h"
05-30
这段代码是C/C++中的预编译指令，它的作用是将名为"move.h"的头文件包含到当前代码文件中。这通常是在需要使用头文件中定义的函数、变量或宏等时使用的。通过包含头文件，可以让编译器知道需要使用哪些函数、变量或...
if(goal_state && !track_mode.data && navi_time_up && (goal_id_ <= goal_id_size)) { move_base_msgs::MoveBaseGoal mbf_goal; mbf_goal.target_pose.header.stamp = ros::Time::now(); mbf_goal.target_pose = patrol_list_[goal_id_]; mbf_client_->sendGoal(mbf_goal);
03-12
#include <move_base_msgs/MoveBaseAction.h> typedef actionlib::SimpleActionClient<move_base_msgs::MoveBaseAction> MoveBaseClient; void doneCb(const actionlib::SimpleClientGoalState& state, const ...
C语言conio.h头文件详解：图形函数与屏幕操作
"C语言 conio.h头文件包含了一系列用于控制字符屏幕输出、调整文本属性以及获取屏幕状态的函数，主要用于简单的图形编程。这些函数在Borland C++编译器中得到支持，允许程序员实现基本的屏幕操作和颜色设置。在字符...
c++ move和forward
kh815的博客
05-02 315
右值引用、移动语义和完美转发可以参考这篇文章 https://www.jianshu.com/p/d19fc8447eaa 一.move /usr/include/c++/7/bits/move.h template<typename _Tp> constexpr typename std::remove_reference<_Tp>::type&am...
第十章 编程练习
yituhuashi的博客
11-19 317
编程练习1//account.h #ifndef ACCOUNT_H_ #define ACCOUNT_H_#include <string> using std::string;class Account { private: string fullname; string ID; double deposit; public: Account(string, s
c语言 move函数,什么是C语言函数
weixin_35738619的博客
05-19 7156
什么是C语言函数else{move(n-1,x,z,y);printf("%c-->%c\n",x,z);move(n-1,y,x,z);}}main(){int h;printf("\ninput number:\n");scanf("%d",&h);printf("the step to moving %2d diskes:\n",h);move(h,'a','b','c');}...
关于两个类相互包含引用的思考
Angel69Devil的博客
08-19 643
今天遇到一个问题，编译时遇到了如下错误： 错误 1 error C2146: 语法错误: 缺少“;”(在标识符“move”的前面) 错误 2 error C4430: 缺少类型说明符 - 假定为 int。注意:  C++ 不支持默认 int 写个最简单的例子： #ifndef __ROBOT_H__ #define __ROBOT_H__ #include "mo
C++中move的使用
qq_41902325的博客
06-25 1万+
1.引言 在学习move使用的时候首先要分清C++中的左值和右值。 因为关于左值和右值区分比较复杂，我们可以采取一个简化的观点，这将在很大程度上满足我们的目的。 左值 最简单的做法是将左值(也称为定位器值)看作函数或对象(或计算为函数或对象的表达式)。所有的左值都分配了内存地址。最初定义左值时，它们被定义为“适合于赋值表达式左侧的值”。但是，后来在语言中添加了const关键字，左值被分为两个子类:可修改的左值(可以更改)和不可修改的左值(const)。 右值 最简单的做法是把右值想象成“所有不是左值的东西”
C++ premier plus 第六版 编程练习解答（第十章）
acslsr的博客
02-21 250
10.2 //1.person.h #ifndef PERSON_H_ #define PERSON_H_ class Person { private: static const int LIMIT = 25; string lname; char fname[LLIMIT]; public: Person(){lname = "";fname[0] = '\0';} Person(...
C语言之贪吃蛇（conio.h）
大田二十
02-27 2407
C语言之贪吃蛇（conio.h）
#include<time.h> 库函数详解
热门推荐
大米粒ing
03-16 2万+
time.h  有人总结成这么几句，的确是经典，自己好好编程试试效果吧， 两个类型： time_t：表示距离 UTC 时间 1970-01-01 00:00:00 的秒数。也叫做日历时。 struct tm：通常用于存储本地时。 几个函数： time：获取当前系统时间（UTC时间）的time_t值。 ctime：将time_t值转换为表示本地时间的字符串。 gmttime：将t
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值