Snake Program stops running without exception

Question

I am trying to program snake in console. After a random amount of steps the snake takes, a new GameObject spawns (e.g. an apple that makes the snake grow or a mushroom which makes the snake faster).

I create a random gameObject (on random (left, top) coordinates and then I need to check if that gameObject spawns on top of a snakeBodyPart or on top of another gameObject. If that is the case, I create a new gameObject and try the same again. Only if it doesn´t collide with another gameObject or the Snake, it will spawn.

snakeElemnts = a list, which has all the snake- body-parts; gameObjects = a list with all existing gameObjects;

If the noCollisionAmount == the amount of snakeElements and GameObjects, there should be no collision and the new GameObject should spawn.

Unfortunately at one point (early on), the snake just stops moving and nothing happens (no exception or anything).

I can´t debug because I have a KeyboardWatcher running, which checks if a key gets pressed. Therefore when I press break, I can only examine the keyboardwatcher.

Setting a breakpoint is not useful, because I never break when the problem arises.

if (this.randomStepNumber == 0)                
{
    int noCollision = 0; // this variable counts the amount of times there was no collision

    GameObject validGameObject;

          while (true)
          {
             validGameObject = this.snakeGameObjectFactory.Generate();

             foreach (SnakeElements element in snakeElements)
             {
                   if (validGameObject.XPosition != element.XPosition || validGameObject.YPosition != element.YPosition)
                    {
                      noCollision++;
                    }
                    else
                    {
                       break;
                    }
               }

              foreach (GameObject gameObject in gameObjects)
              {
                  if (noCollision == snakeElements.Count) // if there was no collision of the new gameobject with an element of the snake, the gameobjects will get checked
                  {
                       if (validGameObject.XPosition != gameObject.XPosition || validGameObject.YPosition != gameObject.YPosition)
                       {
                           noCollision++;
                       }
                       else
                       {
                           break;
                        }
                  }
                  else
                  {
                      break;
                   }
               }

               if (noCollision == snakeElements.Count + gameObjects.Count) // if there was no collision at all, the check is ended
               {
                   break;
               }
               else
               {
                  noCollision = 0;
               }
           }

       this.gameObjects.Add(validGameObject);

       this.randomStepNumber = this.random.Next(10, 30);
}

Answer 1

Based on your comments that removing this block of code causes the problem to cease, I thought maybe it would be good to clean up the code a little and remove that potential infinite loop with the continue statement. Making use of a little LINQ Enumerable.Any and a do-while loop, we can simplify the logic of the above code. There isn't really a need to be counting collisions, since the purpose of the code is to create a new object iff a collision is detected. That means if we detect a collision with the snake, then we want to generate a new object, or if we detect a collision with another existing object, then we want to generate a new object. So instead of counting, we use the Any statement to check if there is any collision with the snake or an existing object. If there is, then generate a new object. If not, then use that object and continue. Note: In order to use the Enumerable.Any you will need to add a using statement for the namespace System.Linq.

if (randomStepNumber == 0)                
{    
    GameObject validGameObject;
    do
    {
        validGameObject = snakeGameObjectFactory.Generate();
    }
    while(snakeElements.Any(s => validGameObject.XPosition == s.XPosition && validGameObject.YPosition == s.YPosition) ||
         gameObjects.Any(o => validGameObject.XPosition == o.XPosition && validGameObject.YPosition == o.YPosition));

    gameObjects.Add(validGameObject);
    randomStepNumber = random.Next(10, 30);
}

As a side note. I removed the this keyword as it appeared you were not using it in all cases in your code, and if you do not have to use it, it makes the code a little more readable because it is less wordy. If it needs to be added back because of variable collisions, then I would suggest renaming the variables as having member and local variables with the same name can also be confusing when trying to debug something.

Secondary note - here is a version of the code not using LINQ, in case that is not allowed for your homework.

if (randomStepNumber == 0)                
{    
    GameObject validGameObject = null;
    while(validGameObject == null)
    {
        validGameObject = snakeGameObjectFactory.Generate();
        foreach(var snake in snakeElements)
        {
            if (validGameObject.XPosition == snake.XPosition &&
                validGameObject.YPosition == snake.YPosition)
            {
                validGameObject = null;
                break;
            }
        }

        if (validGameObject != null)
        {
            foreach(var gameObject in gameObjects)
            {
                if (validGameObject.XPosition == gameObject.XPosition &&
                    validGameObject.YPosition == gameObject.YPosition)
                {
                    validGameObject = null;
                    break;
                }
            }
        }
    }

    gameObjects.Add(validGameObject);
    randomStepNumber = random.Next(10, 30);
}