Code game rắn săn mồi trên console bằng C++

2456

Bài viết được sự cho phép của tác giả Khiêm Lê

Chắc hẳn tuổi thơ của mỗi chúng ta thì không còn xa lạ gì với tựa game Snake hay tiếng Việt là rắn săn mồi đúng không. Hôm nay chúng ta sẽ cùng code lại game đó trên console bằng C++.

Nếu bạn đang thắc mắc vì sao lại là console mà không phải một nền tảng nào khác, giao diện, đồ họa đẹp hơn thì đơn giản là vì nó dễ. Hơn nữa, mới bắt đầu học lập trình thì hầu hết mọi người đều học trên nền console app nên việc tiếp cận game bằng console app cũng trở nên vô cùng dễ dàng.

  15 game miễn phí giúp bạn luyện code mỗi ngày
  7 game miễn phí giúp bạn nâng cao kỹ năng lập trình

Bạn nào thấy code game trên console chán quá thì có thể thoát ngay post này, xem code snake game bằng python trên kênh Youtube của mình nha. Link video tại đây, có code trên github dưới phần mô tả video.

Demo game

Trước khi bắt đầu để mấy bạn có hứng thú một chút thì cùng xem qua thành phẩm sau khi code xong nha!

Thì game này khá là đơn giản, chỉ bằng việc sử dụng các kiến thức cơ bản đã học trong C++, cũng như lên mạng tìm thêm 1 số hàm, thư viện hỗ trợ việc làm việc trên console nữa là được. Bây giờ hãy cùng xem cách tạo ra game này như thế nào nha!

Lưu ý là code của bài này khá dài nên mình sẽ không show hết ra được, các bạn có thể xem code trên Github nha.

Game hoạt động như thế nào

Game rắn săn mồi đã quá phổ biến nên mình chỉ mô tả đơn giản. Trong game này, người chơi sẽ điều khiển con rắn đi ăn những quả táo, khi ăn thì con rắn sẽ ngày càng dài thêm. Người chơi sẽ bị thua khi đụng tường bao quanh hoặc con rắn tự cắn chính bản thân nó.

Đơn giản chỉ có vậy thôi, việc của chúng ta là làm sao để tạo ra được game đó. Thì chúng ta sẽ vẽ lại con rắn trên màn hình console sử dụng các ký tự. Khi con rắn di chuyển, chúng ta sẽ vẽ lại con rắn đó để thể hiện sự di chuyển của nó. Vì con rắn di chuyển liên tục nên chúng ta sẽ đặt nó trong một vòng lặp.

Đến đây thì chắc các bạn đã hình dung ra được cách code game này như thế nào rồi đúng không! Cùng bắt đầu thôi!

Tạo con rắn và vẽ lên màn hình

Vì game này là 1 game 2D nên đầu tiên, mình sẽ xây dựng struct Point biểu diễn 1 điểm trước. Con rắn của mình sẽ được thể hiện bằng một dãy các điểm này, thể hiện vị trí của nó trên mặt phẳng 2D. Do đó mình sẽ dùng vector để lưu con rắn, mình sẽ khởi tạo con rắn ban đầu luôn.

Bạn nào không biết vector là gì thì có thể xem lại bài viết của mình tại đây nha.

struct Point
{
	int x;
	int y;
};

vector<Point> snake = {
	Point{ WIDTH / 2 + 2, HEIGHT / 2 },
	Point{ WIDTH / 2 + 1, HEIGHT / 2 },
	Point{ WIDTH / 2, HEIGHT / 2 },
	Point{ WIDTH / 2 - 1, HEIGHT / 2 },
	Point{ WIDTH / 2 - 2, HEIGHT / 2 }
};

Để vẽ con rắn lên màn hình thì mình chỉ cần di chuyển con trỏ đến vị trí đó (dùng hàm gotoxy) và in ra là được. Hàm gotoxy thì các bạn xem trong code trên Github nha.

void drawSnakePart(Point p)
{
	gotoxy(p.x, p.y);
	// BODY là ký tự đại diện cho phần thân của con rắn
	cout << BODY;
}

void drawSnake()
{
	for (size_t i = 0; i < snake.size(); i++)
		drawSnakePart(snake[i]);
}

Di chuyển

Tất nhiên trong mặt phẳng thì chỉ có 4 hướng di chuyển thôi, mình sẽ quy định các hướng di chuyển đó bằng enum class. Đương nhiên là sẽ có 1 biến toàn cục để biết hướng hiện tại của con rắn.

enum class Direction
 {
	up,
	right,
	down,
	left
};

Direction direction = Direction::right;

Khi con rắn di chuyển, các bạn để ý phần đầu con rắn đi qua đâu thì phần đuôi chắc chắn phải đi theo đó. Ta sẽ quy định phần đầu con rắn là phần tử đầu tiên. Vậy để làm con rắn di chuyển, chúng ta sẽ cập nhật lại các giá trị tọa độ các phần của con rắn.

Cụ thể chúng ta sẽ dịch các phần tử về bên phải (con rắn đang bò theo phần đầu) và chừa chỗ trống cho phần đầu nhận giá trị mới. Giá trị tọa độ mới của phần đầu sẽ tùy theo hướng đang di chuyển.

void move()
{
	for (size_t i = snake.size() - 1; i > 0; i--)
		snake[i] = snake[i - 1];
	if (direction == Direction::up)
		snake[0].y -= 1;
	else if (direction == Direction::down)
		snake[0].y += 1;
	else if (direction == Direction::left)
		snake[0].x -= 1;
	else if (direction == Direction::right)
		snake[0].x += 1;
}

Tiếp theo, như mình đã nói ở đầu bài viết, khi con rắn di chuyển chúng ta sẽ vẽ lại chuyển động của nó. Do đó mình sẽ dùng một vòng lặp, giữa các lần lặp sẽ nhận điều khiển từ bàn phím, di chuyển con rắn và vẽ lại, sau đó chờ (để người dùng có thể nhìn thấy sự di chuyển đó).

Mình sẽ sử dụng các phím A, W, S, D để điều khiển con rắn.

while (true)
{
	// Nếu có nhấn phím
	if (_kbhit())
	{
		// Đọc phím vừa nhấn
		char ch = _getch();
		// lower để nhận được cả in hoa và in thường
		ch = tolower(ch);
		if (ch == 'a')
			direction = Direction::left;
		else if (ch == 'w')
			direction = Direction::up;
		else if (ch == 's')
			direction = Direction::down;
		else if (ch == 'd')
			direction = Direction::right;
		else if (ch == 'q') // Quit game
			break;
	}
	move();
	drawSnake();
	// Có thể xem REFRESH_RATE chính là tốc độ của con rắn
	// Nếu REFRESH_RATE càng nhỏ thì càng nhan và ngược lại
	Sleep(REFRESH_RATE);
	// Sau khi xong thì xóa để vẽ lần tiếp theo
	system("cls");
}

Giờ thì bạn có thể run thử app để xem kết quả. Cái cách cứ vẽ xong lại xóa, rồi lại vẽ lại toàn bộ con rắn này không được tối ưu lắm, chút nữa mình sẽ thực hiện 1 cách khác tối ưu hơn.

Giới hạn khu vực chơi

Tiếp theo chúng ta sẽ giới hạn khu vực chơi bằng cách vẽ ra các bức tường, mình gọi là box (thông cảm vì tiếng anh mình hơi kém ^^). Để vẽ ra các bức tường này thì cũng đơn giản, chỉ cần cho vòng lặp rồi in ra các ký tự thể hiện cho các bức tường thôi, sau đó chúng ta sẽ gọi hàm vẽ này trong vòng lặp lúc nảy để nó vẽ lại box mỗi lần con rắn di chuyển ở mỗi frame.

void drawBox()
{

	// WIDTH và HEIGHT là kích thước hộp được đặt trước
	for (size_t i = 0; i < WIDTH; i++)
		cout << '=';
	gotoxy(0, HEIGHT);
	for (size_t i = 0; i < WIDTH; i++)
		cout << '=';
	for (size_t i = 1; i < HEIGHT; i++)
	{
		gotoxy(0, i);
		cout << '|';
	}
	for (size_t i = 1; i < HEIGHT; i++)
	{
		gotoxy(WIDTH, i);
		cout << '|';
	}
}

// Và trong vòng lặp
move();
drawBox();
drawSnake();

Tiếp tục bạn có thể run app để check thử!

Thêm logic cho game

Tiếp theo chúng ta cần xử lý các trường hợp con rắn tự cắn chính nó, đụng vào tường và nó không được quay đầu 180 độ.

Cái dễ làm trước, để tránh việc con rắn quay đầu 180 độ, mình chỉ cần kiểm tra lúc người dùng điều khiển con rắn xem là hướng vừa được chọn có đối với hướng hiện tại không thôi.

if (ch == 'a' && direction != Direction::right)
	direction = Direction::left;
else if (ch == 'w' && direction != Direction::down)
	direction = Direction::up;
else if (ch == 's' && direction != Direction::up)
	direction = Direction::down;
else if (ch == 'd' && direction != Direction::left)
	direction = Direction::right;
else if (ch == 'q') // Quit game
	break;

Tiếp theo xem con rắn có đụng tường hay không cũng đơn giản, bạn kiểm tra xem phần đầu của con rắn chính là phần tử đầu tiên, tọa độ của nó có trùng với box không.

bool isHitWall()
{
	return snake[0].x == 0 || snake[0].y == 0 || snake[0].x == WIDTH || snake[0].y == HEIGHT;
}

Phần cuối cùng là kiểm tra xem con rắn nó có tự cắn chính mình không, đơn giản chúng ta chỉ cần kiểm tra xem phần đầu nó có bị trùng với phần thân nào không, như vậy là nó đang cắn chính mình.

bool isBiteItself()
{
	Point head = snake[0];
	for (size_t i = 1; i < snake.size(); i++)
		if (head.x == snake[i].x && head.y == snake[i].y)
			return true;
	return false;
}

Và cuối cùng, nhớ thêm các logic này vào vòng lặp lúc đầu.

move();
if (isBiteItself())
	break;
if (isHitWall())
	break;
drawSnake();

Tương tự như lúc nảy, bạn có thể run app để check thử xem các logic trên đã hoạt động hay chưa.

Tối ưu hiệu năng

Như đã nói lúc nảy, cứ mỗi 1 khung hình lại phải vẽ lại 1 lần cả con rắn và cả box, mình sẽ xử lý chuyện này như sau: mình sẽ tránh việc sử dụng lệnh xóa màn hình để tránh phải vẽ lại toàn bộ, thay vào đó mình sẽ vẽ box chỉ 1 lần, vẽ toàn bộ con rắn 1 lần đầu tiên. Tiếp theo đó, mình sẽ vẽ thêm phần đầu mới cho con rắn và xóa bỏ phần đuôi cũ. Như vậy hiệu năng sẽ được cải thiện đáng kể.

Để làm được việc đó, mình cần 1 biến lưu phần đuôi cũ của con rắn, sau đó cập nhật phần đuôi cũ này trong hàm move. Sau đó mình sẽ viết hàm drawHeadnTail để thực hiện việc vẽ đàu và xóa đuôi cũ đi.

Point prevTail;

void move()
{
	// lưu phần đuôi cũ lại
	prevTail = snake.back();
	// code gores here
}

void drawHeadnTail()
{
	gotoxy(snake[0].x, snake[0].y);
	cout << BODY;
 // vẽ phần đầu mới
	Point tail = snake.back();
	gotoxy(prevTail.x, prevTail.y);
	cout << ' '; // xóa phần đuôi cũ đi
}

Chức năng cuối cùng – Ăn mồi

Như đã nói thì mồi ở đây mình sẽ cho là những quả táo. Mình sẽ tạo ngẫu nhiên những quả táo trong khu vực chơi, khi con rắn ăn được thì nó sẽ dài ra thêm và 1 quả táo khác được tạo ra và cứ thế tiếp tục.

Để tạo quả táo thì cũng đơn giản, mình chỉ cần gán tọa độ x, y của quả táo ngẫu nhiên trong khoảng x thuộc (0; WIDTH) và y thuộc (0; HEIGHT). Hàm sinh quả táo của mình như sau:

Point apple;

void genApple()
{
	srand(time(0));
	int x = rand() % (WIDTH - 1) + 1;
	int y = rand() % (HEIGHT - 1) + 1;
	apple = {
		x,
		y,
	};
	// Sau khi có tọa độ quả táo thì vẽ lên màn hình
	gotoxy(x, y);
	cout << APPLE;
}

Tiếp theo chúng ta sẽ kiểm tra xem trái táo đã được ăn chưa, chỉ cần kiểm tra xem đầu của con rắn của trùng với quả táo hay không là được.

bool isAteApple()
{
	return snake[0].x == apple.x && snake[0].y == apple.y;
}

Khi mà đã ăn được mồi thì phải tăng chiều dài của con rắn lên, mình sẽ thực hiện thêm 1 phần tử vào đuôi của con rắn. Phần đuôi này cũng đơn giản không kém, mình chỉ cần thêm lại phần đuôi trước đó vào thôi, mình sẽ code như sau:

void growing()
{
	snake.push_back(prevTail);
}

Như vậy là chúng ta đã viết xong các hàm cần thiết, giờ thì chúng ta chỉ cần thêm chúng vào vòng lặp của game là xong. Chúng ta sẽ kiểm tra nếu con rắn ăn được mồi thì cần phải tạo quả táo khác và tăng chiều dài con rắn lên. Mình sẽ thêm đoạn code sau:

if (isAteApple())
{
	growing();
	genApple();
}

Đến đây xem như game của mình đã hoàn thành. Việc còn lại chỉ là cho hiện điểm số, các menu start, hiện kết quả sau khi chơi xong… Phần này thì các bạn có thể xem code trong Github nha.

Lời kết

Như vậy là trong bài viết này mình đã hướng dẫn các bạn cách code game Snake đơn giản trên console. Thực tế thì chả ai lại đi làm game trên console cả, nhưng nó lại là lựa chọn hợp lý cho mọi sự bắt đầu của lập trình, trong đó có cả game.

Trong bài này mình viết mọi thứ hết trong một file và không code theo OOP (do mình lười quá “=))”). Các bạn có thể refactor code của mình lại theo OOP cho dễ quản lý, nâng cấp và nhìn professional hơn nha. Trên trang của mình có chuỗi bài viết về OOP, các bạn có thể search trên trang mình nha ^^.

Nếu các bạn có bất kỳ thắc mắc nào hoặc góp ý, đừng ngần ngại comment phía bên dưới bài viết để mình phát triển bài viết tốt hơn nha. Cảm ơn các bạn đã đọc bài viết!

Bài viết gốc được đăng tải tại khiemle.dev

Có thể bạn quan tâm:

Xem thêm các việc làm Developer hấp dẫn tại TopDev

Báo cáo bài viết vi phạm bản quyền>>