Any programmers on? I have no idea where to start for this

Even if you did that, I wouldn't be able to focus long enough to understand it.

This is why I never learn anything in class...

struct Your_type_name {
int value;
char * whatever;
};

What do you not understand specifically?

how to figure out which piece on the board out of all the other pieces can make the move.

Say if it's a pawn moving to f4, am I supposed to just go over each pawn one at a time until I find one that's within bounds of the move? It seems so inefficient...

Well i don't know what type of help you expect then...

It's not that complicated really
If you have initial position it's cool right?
you just do if(x1 != null && y1!=null)
if that's true then you already know which piece it is.
If not, you see where it ends up and what type it is. You have only few types. Like if you have pawn and you know it ends up at [x][y], it had to be at [x][y-1] or [x-1][y-1] etc.

I got it. Not great considering programming doesn't use implicit statements.
3/10
Because 2 is a reply and 3 is a little better than 2

Well I assume you will have a struct for each piece right? Based on the one that is moving (the one that goes into the function?) It will have its current position saved in the struct right? (x,y) coords will be easier than F4 etc.

what language...?

To expand on this:

bool check_move(piece piece_to_check) {
//piece is the struct you defined
switch(piece_to_check.type)
//etc
}

it comes from an algebraic chess notation string.

usually it only shows the piece type and where the piece is going, unless it's an ambiguous case, everything else you're supposed to infer.

here's what the struct looks like:

typedef struct Location
{
// the square's column ('a' through 'h')
char col;

// the square's row (1 through 8)
int row;
} Location;

typedef struct Move
{
// location where this piece is moving from
Location from_loc;

// location where this piece is moving to
Location to_loc;

// what type of chess piece is being moved
char piece;

// whether this move captures another piece
short int isCapture;

// the color of the piece being moved
Color color;
} Move;

C

Are you sure programming is for you bro? It kinda requires focus.

God no, but physics majors require a CS1 credit...

I can't focus with programming, but in math and physics I do just fine.

I guess I'm probably just going to end up doing this.

Thanks for the help guys.

Either will work, its just about understanding what method you use. I program in C++ if you have more questions.

I am a programmer. checking out this thread.

I dare you to find a way to differentiate diagonal pawn captures and bishop captures which are identical.

Well you always know whether the piece is a pawn or bishop, so that doesn't really matter...

does it?

t. Big Blue

Pic you?

nah, that's from game grumps.

1. If the starting position is given:
1.1. Return the piece at that position

2. If the starting column is given:
2.1. For each space in the column:
2.1.1. Check the piece on the space
2.1.2. If it's the right piece, return that piece

3. For each row in board
3.1. For each space in row
3.1.1. Check the piece on the space
3.1.2. If it's the right piece, return that piece

Subroutine for checking a piece:
1. If the piece isn't the right type, return that it's the wrong piece
2. If the piece isn't the right colour, return that it's the wrong piece
3. If the target position is /not/ a valid move for the piece, return that it's the wrong piece
4. Return that it's the right piece