Вложенные если-заявления

Question

C++

Я пишу программу Снейк в C++ (визуализация с JNI) и действительные кнопки перемещения либо влево (перемещение на 90 ° против часовой стрелки) или вправо (перемещение на 90 ° по часовой стрелке).

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

if(key_event != NULL){ 
    if(key_event == LEFT){ 
     if(moveDirection == UP || moveDirection == DOWN){ 
      moveDirection = LEFT; 
      (moveDirection == UP) ? /*change turn after head*/ : /*change turn after head*/; 
     } //else if (moveDir == LEFT || RIGHT) 
    } //else if (key_event == RIGHT) 
    //... 
} 

КРП с: /*change turn after head*/ является потому что если змея движется вниз и идет влево есть другой график для поворота тогда, когда это будет до и идет влево.

Это приводит к множеству if-утверждений и не очень читаемо, поэтому мне интересно, существует ли общий способ решения вложенных if-утверждений, подобных этому.

EDIT:
key_event и moveDirection - перечисления.

Answer 1

У меня лично была бы другая функция, чтобы применить ход.

if(key_event != NULL){ 
    if(key_event == LEFT){ 
     moveLeft(); 
    } 
    ... 
} 

void moveLeft() 
{ 
    switch(moveDirection) 
    { 
    case UP: 
    case DOWN: 
     moveDirection = LEFT; 
     break; 
    case ... 
    } 
} 

Я использую переключатель случай, на мой взгляд, больше чтения в состоянии для этого примера, а не если .. иначе если .. иначе если ...

Дело в том, когда у вас есть вложенные петли, посмотрите, можете ли вы разбить его на функцию, чтобы упростить задачу.

Надеюсь, это поможет.

Answer 2

Скорее всего, код будет более читабельным, если вы учитываете разделы проверок if в функциях. Не видя полного контекста выполняемой работы, трудно сказать наверняка, но что-то вроде get_new_direction(event, direction), вероятно, станет хорошим началом. Когда компоненты проверок if являются хорошо названными функциями, это поможет как читабельности, так и, возможно, уровням вложенности.

Answer 3

Если ваш key_event является int или char, вы можете использовать оператор switch, который может быть более читаемым.

if (moveDirection == UP || moveDirection == DOWN) 
{ 
    switch (key_event) 
    { 
     case LEFT: 
      //Turn snake left 
      break; 
     case RIGHT: 
      //Turn snake right 
      break; 
     default: 
      //Invalid turn, do nothing 
      break; 
    } 
} 
else if (moveDirection == LEFT || moveDirection == RIGHT) 
{ 
    switch (key_event) 
    { 
     case UP: 
      //Turn snake up 
      break; 
     case DOWN: 
      //Turn snake down 
      break; 
     default: 
      //Invalid turn, do nothing 
      break; 
    } 
} 

Answer 4

Похоже, Finite State Machine - это то, что вам нужно здесь. Вы можете определять ключи как события, змеиные позиции как состояния и описывать переходы из одного состояния в другое в зависимости от события (какая клавиша нажата). Это позволит решить проблему и использовать таблицу перехода вместо вложенных операторов if и сделать вашу реализацию менее подверженной ошибкам. Boost Statechart Library может помочь вам быстро реализовать его.

Answer 5

Ну, очевидно, вы могли бы устранить первое "если" что-то вроде этого:

if(keyEvent == null) 
return; 

Далее, использовать что-то вроде этого:

Action defaultAction = TurnLeftAction; 
if(keyEvent == Up) 
    defaultAction = TurnUpAction; 
else if(keyEvent == Down) 
defaultAction = TurnDownAction; 
else 
defaultAction = TurnRightAction; 

defaultAction.Execute(); 

Я надеюсь, что вы пойманной идею :)

Answer 6

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

Answer 7

Вы можете сделать это с объектами:

class MoveState { 
    public: 
     MoveState* getNextState(MoveDirection change); 
     GraphicsStuff* getDirectionChangeGraphics(MoveDirection change); 
     void setNextState(MoveDirection change, MoveState* nextState, GraphicsStuff* graphics); 
} 

Тогда у вас есть либо экземпляры MoveState, представляющих каждое направление движения. Ваш внешний код может быть следующим:

MoveState STATES[4]; 

void init() { 
    STATES[UP].setNextState(LEFT, &STATES[LEFT], whatever); 
    STATES[UP].setNextState(RIGHT, &STATES[RIGHT], whatever); 
    STATES[DOWN].setNextState(LEFT, &STATES[RIGHT], whatever); 
    STATES[DOWN].setNextState(RIGHT, &STATES[LEFT], whatever); 
    ... 
} 

void handleInput() { 
    ... 
    if(key_event != NULL){ 
     MoveDirection change = convertEventToDirection(key_event); 
     MoveState* nextState = currentState->getNextState(change); 
     if (nextState != NULL) { 
      drawCoolGraphics(currentState->getDirectionChangeGraphics(change); 
      currentState = nextState; 
     } 
    } 
} 

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

Это должно быть менее подвержено ошибкам, поскольку вы можете тестировать каждый экземпляр MoveState гораздо легче, чем большой оператор if-then-else или switch.

EDIT: Heh. Это в основном менее краткий вариант того, что предложил @Vlad.

Answer 8

Простая таблица поиска может помочь:

enum dir { UP, RIGHT, DOWN, LEFT }; 

dir lturn[] = {LEFT, UP, RIGHT, DOWN}; 
dir rturn[] = {RIGHT, DOWN, LEFT, UP}; 

, так что вы можете написать

dir curr_dir; 
if (moveDirection == LEFT) 
    curr_dir = lturn[curr_dir]; 
if (moveDirection == RIGHT) 
    curr_dir = rturn[curr_dir]; 

Answer 9

Я бы рекомендовал, представляющий направление змеи как вектор, четыре направления бытия (1 0) - правый, (-1 0) - левый, (0 1) - вверх и (0 -1) вниз. Это позволит устранить большинство коммутаторов в вашей программе, поскольку перемещение змеи обрабатывается простой математикой, а не путем сопоставления произвольных значений перечисления для перемещения.

struct Vector2D 
{ 
    int x, y; 
    Vector2D(int x, int y); 
    ... 
}; 

Затем поворот влево и вправо становится:

Vector2D turn_left(Vector2D direction) 
{ 
    return Vector2D(-direction.y, direction.x); 
} 

Vector2D turn_right(Vector2D direction) 
{ 
    return Vector2D(direction.y, -direction.x); 
} 

И ключи будут обрабатываться:

if (key_event == LEFT) snake_direction = turn_left(snake_direction); 
else if (key_event == RIGHT) snake_direction = turn_right(snake_direction);