Thread: chess playing Robot

Originally Posted by chess06

i need a C++ code which can control to robot.

And I need a million dollars. Neither of us is going to get what we "need" by asking for it on this forum.

Start by researching robotics on google. There's lots of people using Arduinos to control all kinds of robots. I'm sure you can find something that will get you started.

You need to do your own work, and ask for help when you get stuck. Getting "stuck" on starting your program doesn't count. You're likely to get answers like:

Code:

int main()
{
  return 0;
}

If you have a Grid class that can represent the board, you could make a class for each of the pieces. The class for the pieces could contain an array of vectors representing possible moves. Then you could make a method for the pieces class, called "look", that takes the grid as an argument. The "look" method would then construct an array of possible moves, based on information from the passed Grid and it's own moves.

In short pseudo-code what I'm thinking of is something like this:

Code:

// Where "this.moves" is an array of Vector representing possible moves
// The grid methods "isEnemy" or "isEmpty" take Vector for argument, 
// and return boolean value specifying what is at that space.

// You could also define a more general "Grid::get()" method that 
// returns an enum value specifying type.

Vector Horse::act (Grid grid)
{
    Vector move = chooseRandomElement(this.look(grid));
    return move;
}

std::vector<Vector> Horse::look (Grid grid)
{
    std::vector<Vector> result;

    for(int i = 0; i < this.moves.size(); i++)
    {
        if (grid.isEnemy(this.moves[i])
        {
            result.push(this.moves[i]);
            break;
        }
        else if (grid.isEmpty(this.moves[i]))
        {
            result.push(this.moves[i]);
        }
    }
    return result;
}

This code has a few problems, for one a static list of possible moves is not appropriate for every piece. The queen for instance can move in 8 directions, for the length of all valid squares. It might be better to instead create a method that constructs a list of moves dynamically, based on the pieces current position, then uses the "look" method to whittle down the possible list of moves.

Edit: The reason why I like this method, is that all pieces are generally the same. Every piece could theoretically derive from a base class that contains the "act" and "look" methods. So that the data structure representing the board could contain all types of pieces.