C# if statements

Question

I am currently working on a C# checkers game for a university project in programming. But i have came to the point where i need to check whether a piece can be moved, or jump, but i feel like i'm using lots of code that isn't necessary to get true or false answers.

if (arrayX == 0)
{
    if (board.GetBoard(arrayX + 1, arrayY - 1).Piece == null)
    {
        return true;
    }
}
else if (arrayX == 7)
{
    if (board.GetBoard(arrayX - 1, arrayY - 1).Piece == null)
    {
        return true;
    }
}

For example, is there a more efficient way of doing these if statements? In the code i have more if statements branching off other if statements. So in summary, is there a way you can check loads of parameters, efficiently, without using loads of if statements branching off of one another?

Answer 1

You may start by creating a method inside the Board class which makes your code slightly shorter:

public class Board()
{
    public bool IsPieceMissing(x, y)
    {
        return this.GetBoard(x, y).Piece == null;
    }
}

...

if (arrayX == 0)
{
    if (board.IsPieceMissing(arrayX + 1, arrayY - 1))
    {
        return true;
    }
}
else if (arrayX == 7)
{
    if (board.IsPieceMissing(arrayX - 1, arrayY - 1))
    {
        return true;
    }
}

The next thing is to work on the business logic, but for that, you need to provide a more global picture. What is the complete body of the method? Is it returning false at the end? Assuming it contains only the part you already provided and the return false; at the end, like this:

private bool DoSomething(arrayX, arrayY)
{
    if (arrayX == 0)
    {
        if (board.IsPieceMissing(arrayX + 1, arrayY - 1))
        {
            return true;
        }
    }
    else if (arrayX == 7)
    {
        if (board.IsPieceMissing(arrayX - 1, arrayY - 1))
        {
            return true;
        }
    }

    return false;
}

you can return immediately instead of waiting until the end. The method becomes:

private bool DoSomething(arrayX, arrayY)
{
    if (arrayX == 0)
    {
        return board.IsPieceMissing(arrayX + 1, arrayY - 1);
    }
    else if (arrayX == 7)
    {
        return board.IsPieceMissing(arrayX - 1, arrayY - 1);
    }

    return false;
}

Since the first condition now returns something anyway, you don't need the else:

private bool DoSomething(arrayX, arrayY)
{
    if (arrayX == 0)
    {
        return board.IsPieceMissing(arrayX + 1, arrayY - 1);
    }

    if (arrayX == 7)
    {
        return board.IsPieceMissing(arrayX - 1, arrayY - 1);
    }

    return false;
}

Answer 2

I looked at your code and it does not seem to me that it can be simplified in the sense of reducing the total number of lines. It could be made less verbose if you got rid of some of the unnecessary, annoying curly brackets, but I suppose if you liked that idea you would have already done it:

        if (arrayX == 0)
        {
            if (board.GetBoard(arrayX + 1, arrayY - 1).Piece == null)
                return true;
        }
        else if (arrayX == 7)
        {
            if (board.GetBoard(arrayX - 1, arrayY - 1).Piece == null)
                return true;
        }

However, there is one thing that you could try and see if it would simplify your code: define an immutable struct to hold a point.

struct Point
{
    readonly int x; //these are 32-bit, so the entire struct will fit inside a
    readonly int y; //   machine word in a 64-bit architecture.
    Point( int x, int y )
    { 
        Assert( x >= 0 && x < 7 );  
        Assert( y >= 0 && y < 7 ); 
        this.x = x;  
        this.y = y; 
    }
    Point left { get { Assert( x >= 0 );  return new Point( x - 1, y ); } }
    Point right { get { Assert( x <= 7 );  return new Point( x + 1, y ); } }
    bool isLeftmost { get { return x == 0; } }
    bool isRightmost { get { return x == 7; } }
    ...
}

then, you will be able to add cool things to your structure, like this:

    IEnumerable<Point> EnumerateSurrounding()
    {
        for( int dx = -1;  dx <= 1;  dx++ )
        {
            for( int dy = -1;  dy <= 1;  dy++ )
            {
                int xx = x + dx; 
                int yy = y + dy;
                if( xx < 0 || xx > 7 )
                     continue;
                if( yy < 0 || yy > 7 )
                     continue;
                if( xx == 0 && yy == 0 )
                     continue;
                yield return new Point( xx, xy );
            }
        }
    }

So, you will be able to visit all cells surrounding a given cell like this:

foreach( Point p in mypoint.EnumerateSurrounding() )
{
    //do something with p here
}

Disclaimer: I just typed all of the above code, so it is bound to have syntax errors, and perhaps even logical errors. Do not rely on it blindly, read it carefully and use your judgement.

Answer 3

It looks like you are testing edge cases. You can often cut way down on the edge case testing by removing the edges from the problem. Instead of the 8x8 board of checkers, internally make the board 12x12. (Note that this would be easier in a language like Pascal that permits non-standard array bounds.) Now you don't have to worry about most edge case testing--there's enough space out there that the destination of any possible move exists. You still need to reject moves that would go off the edge of the board but even this can be done with a single statement (have an array of good and bad squares, if the prospect cell is a bad cell reject the move.)