蛇游戏——尾巴运动

Question

I'm making a snake game and having trouble with the tail movement. I understand the logic for this part, which is that each segment of the tail follows the previous segment, starting from the end of the tail. I am looking at someone else's code, and it looks like this

 #include <iostream>
#include <conio.h>
#include <windows.h>
using namespace std;
bool gameOver;
const int width = 20;
const int height = 20;
int x, y, fruitX, fruitY, score;
int tailx[100], taily[100];
int nTail;
enum eDirecton { Stop, Left, Right, Up, Down } dir;

void Setup()
{
 gameOver = false;
 dir = Stop;
 x = width / 2;
 y = height / 2;
 fruitX = rand() % width;
 fruitY = rand() % height;
 score = 0;
}
void Draw()
{
 system("cls"); 
 for (int i = 0; i < width + 2; i++)
     cout << "#";
 cout << endl;

 for (int i = 0; i < height; i++)
 {
     for (int j = 0; j < width; j++)
     {
         if (j == 0)
             cout << "#";
         if (i == y && j == x)
             cout << "O";
         else if (i == fruitY && j == fruitX)
             cout << "F";
         else
         {
             bool print = false;
             for (int k = 0; k < nTail; k++)
             {
                 if (tailx[k] == j && taily[k] == i)
                 {
                     cout << "o";
                     print = true;
                 }
             }
             if (!print)
                 cout << " ";
         }


         if (j == width - 1)
             cout << "#";
     }
     cout << endl;
 }

 for (int i = 0; i < width + 2; i++)
     cout << "#";
 cout << endl;
 cout << "Score:" << score << endl;
}
void Input()
{
 if (_kbhit())
 {
     switch (_getch())
     {
     case 'a':
         dir = Left;
         break;
     case 'd':
         dir = Right;
         break;
     case 'w':
         dir = Up;
         break;
     case 's':
         dir = Down;
         break;
     case 'x':
         gameOver = true;
         break;
     }
 }
}
void Logic()
{
 for (int i = nTail - 1; i > 0; i--)
 {
     tailx[i] = tailx[i - 1];
     taily[i] = taily[i - 1];
 }
 tailx[0] = x;
 taily[0] = y;

 switch (dir)
 {
 case Left:
     x--;
     break;
 case Right:
     x++;
     break;
 case Up:
     y--;
     break;
 case Down:
     y++;
     break;
 default:
     break;
 }

 if (x >= width) x = 0; else if (x < 0) x = width - 1;
 if (y >= height) y = 0; else if (y < 0) y = height - 1;

 for (int i = 0; i < nTail; i++)
     if (tailx[i] == x && taily[i] == y)
         gameOver = true;

 if (x == fruitX && y == fruitY)
 {
     score += 10;
     fruitX = rand() % width;
     fruitY = rand() % height;
     nTail++;
 }
}
int main()
{
 Setup();
 while (!gameOver)
 {
     Draw();
     Input();
     Logic();
     Sleep(50); 
 }
 return 0;
}

I understand the logic but I don't understand why it works. When we create an array, the value of each element is just a garbage value without initializing each element. So in the code above, when doing

tailx[i] = tailx[i-1];
taily[i] = taily[i-1];

what value is assigned to each element? When displaying the snake, it has a for loop to go through every coordinate of the screen and inside it has another for loop to compare tailx[i] and taily[i] with each coordinate to find out the right position to print each segment of the tail. Since tailx and tialy are not storing the coordinates of the segments of the tail, how come this code works?

Thank you so much!!

Answer 1

Presumably, you're missing a line at the end that looks something like:

if(nTail < 100) { nTail++; }

Assuming that's the case, nTail is initialized to 0 and that this is all in a loop, the code probably looks something like (I'm using a size of 5 instead of 100 to make visualizing easier)

int tailx[5];
int taily[5];
int nTail = 0; //length

while(true) {
    for(int i = nTail -1; i > 0; i--)
    {
         tailx[i] = tailx[i-1];
         taily[i] = taily[i-1];
    }

    // Let's assume there's some logic here the fetches a new
    //   x and y. For the sake of debugging, let's assume the
    //   values will be {(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)}

    tailx[0] = x; // x is the x-coordinate of the head
    taily[0] = y; //y is the y-coordinate of the head
    if(nTail < 5) { nTail++; }
}

Let's step through this!

Before we enter the loop, your tail arrays are going to look like: (I'm using NA here to mean "Garbage")

nTail = 0

+-------------------------+
|Name | 0 | 1 | 2 | 3 | 4 |
|-------------------------|
|  X  | NA| NA| NA| NA| NA|
+-------------------------+
|  Y  | NA| NA| NA| NA| NA|
+-------------------------+

We enter the loop, initialize i to nTail - 1 which is -1 . This doesn't pass the check of i > 0 , so we don't even enter the loop.

We'll now grab new x and y vals and assign them into the tails, along with incrementing nTail . So going into the next loop our variables will look like:

nTail = 1

+-------------------------+
|Name | 0 | 1 | 2 | 3 | 4 |
|-------------------------|
|  X  | 1 | NA| NA| NA| NA|
+-------------------------+
|  Y  | 1 | NA| NA| NA| NA|
+-------------------------+

We'll head on in, initialize i to nTail - 1 => 0 . This DOESN'T pass the check of i > 0 , so again we don't enter the loop (which sounds wrong to me...maybe you're initializing nTail to 1 instead of 0?).

We head on down, grab new x/y vals and increment nTail and restart the loop with:

nTail = 2

+-------------------------+
|Name | 0 | 1 | 2 | 3 | 4 |
|-------------------------|
|  X  | 2 | NA| NA| NA| NA|
+-------------------------+
|  Y  | 2 | NA| NA| NA| NA|
+-------------------------+

Initializing i to nTail - 1 => 1 means since i > 0 we'll finally enter the inner loop.

With i = 1 , we update our tail arrays:

tailx[1] = tailx[0];
taily[1] = taily[0];

Then head down, grab new values and increment nTail . Our variables now look like:

nTail = 3

+-------------------------+
|Name | 0 | 1 | 2 | 3 | 4 |
|-------------------------|
|  X  | 3 | 2 | NA| NA| NA|
+-------------------------+
|  Y  | 3 | 2 | NA| NA| NA|
+-------------------------+

After the next loop, things will look like:

nTail = 4

+-------------------------+
|Name | 0 | 1 | 2 | 3 | 4 |
|-------------------------|
|  X  | 4 | 3 | 2 | NA| NA|
+-------------------------+
|  Y  | 4 | 3 | 2 | NA| NA|
+-------------------------+

I'll leave it to you to keep tracing if you so desire.

Answer 2

You're right; this code cannot work, and it has undefined behaviour.

nTail isn't even initialised to anything.

Are you sure it's a full program, and not just snippets glued together? Or a sort of "pseudocode" to show the logic without being actual valid C++? You'd need values for nTail and all the array elements.