Игра Жизни Жизни Конвея не корректируется должным образом

Question

Извините, если мне удалось что-то испортить. Когда вы запускаете код, он должен делать игру жизни Конвея. Первый совет работает как надо, показывая X`s и .`s, но все последующие кадры просто .`s

Я считаю, что этот вопрос будет в nextL, но я не уверен ...

#include <iostream> 
#include <cstdlib> 
#include <unistd.h> 

int C = 0, R = 0; 

void initL(char L[22][22]) 
{ 
    for(C = 0; C < 22; C++) 
     L[C][0] = '0'; 

    for(R = 0; R < 22; R++) 
     L[0][R] = '0'; 

    for(C = 0; C < 22; C++) 
     L[C][21] = '0'; 

    for(R = 0; R < 22; R++) 
     L[21][R] = '0'; 


    for(C = 1; C < 21; C++) 
     for(R = 1;R < 21; R++) 
      L[C][R] = '.'; 

    for(C = 1; C < 21; C++) 
     for(R = 1; R < 21; R++) 
      L[C][R] = (rand() % 2) ? '.': 'x'; 
} 

void printL(char L[22][22]) 
{ 
    int C, R; 

    for(C = 1; C < 21; C++) 
    { 
     std::cout << "\n"; 
     for(R = 1; R < 21; R++) 
      std::cout << " " << L[C][R]; 
    } 

    std::cout << "\n\n"; 
} 

void nextL(char L[22][22]) 
{ 
    for(C = 1; C < 21; C++) 
    { 
     for(R = 1; R < 21; R++) 
     { 
      int LiveCnt = 0; 

      if(L[C - 1][R-1] == 'X') 
       LiveCnt++; 

      if(L[C - 1][R] == 'X') 
       LiveCnt++; 

      if(L[C - 1][R + 1] == 'X') 
       LiveCnt++; 

      if(L[C][R - 1] == 'X') 
       LiveCnt++; 

      if (L[C][R + 1] == 'X') 
       LiveCnt++; 

      if (L[C + 1][R - 1]=='X') 
       LiveCnt++; 

      if(L[C + 1][R + 1] == 'X') 
       LiveCnt++; 

      if(L[C + 1][R] == 'X') 
       LiveCnt++; 

      L[C][R] = '.'; 

      if(L[C][R] == 'X' && LiveCnt < 2) //rule 1 
       L[C][R] = '.'; 
      else if(L[C][R] == 'X' && (LiveCnt == 2 || LiveCnt == 3)) //rule 2 
       L[C][R] = 'X'; 
      else if(L[C][R] == 'X' && LiveCnt > 3) //rule 3 
       L[C][R] = '.'; 
      else if(L[C][R] == '.' && LiveCnt == 3) //rule 4 
       L[R][C]='.'; 
     } 
    } 
} 

int main() 
{ 
    char L[22][22]; 
    int T; 

    initL(L); 
    for (T = 0; T < 4; T++) 
    { 
     printL(L); 
     nextL(L); 
    } 
} 

Answer 1

Право, проблема заключается в nextL, фактически в строке L[C][R] = '.'; перед применением правил. Эта строка безоговорочно устанавливает каждую ячейку в .. Удалите его, чтобы получить правильные результаты.

Фрагмент рабочего кода с его консольным выходом может быть проверен в http://cpp.sh/2egdu.

Answer 2

Ваша проблема связана с тем, что вы изменяете значение каждой ячейки при прохождении через массив. Проблема заключается в том, что вы получаете нечеткие подсчеты соседей, потому что значения ячеек меняются в неподходящее время. Вам нужно рассчитать, что каждая ячейка изменит на следующий кадр и сохранит эту информацию во временном месте, а затем, после вычисления всех новых значений для каждой ячейки, вам необходимо изменить все значения на их новое значение.

Пример: Ваш метод:

001 
100 
110 

Если вы применили свой алгоритм к сетке выше, начиная с верхнего левого угла, он останется неизменным (правильно). Двигаясь слева направо, а затем вниз, вторая ячейка не изменяется (правильно), третья ячейка умирает (правильно), четвертая клетка живет (правильно), пятая ячейка оживляется (некорректно), потому что третья ячейка умерла раньше пятая ячейка могла рассчитать ее соседи.

Вам необходимо написать алгоритм, чтобы сначала вычислить число соседей сот, не меняя их, а затем обновить значения после вычисления всех соседей.

Как так:

calcNeighbors(); //loop through and find the neighbors of each cell storing them in a temporary array or class 
updateCells(); //use temporary neighbor array and current cell value to change cell values to the correct value for next iteration