Post Undeleted by ajax333221
    Post Deleted by ajax333221
3 added 115 characters in body
source | link

Edit: promoting to anything different than queen will make everything explode. It will also be very hard to support this (my program for Part 2 supports underpromotion, but storing the info of Part 1 purely by reading pixels is a nightmare).

Edit2: I just noticed you mean real board chess to PGN, so this is all useless and I will most likely delete my answer.

Part 1: storing the squares using pixel readers

It is totally possible, the steps needed would be:

  1. change the set up of the board so it highlights the last move (prefereably not just the border)
  2. write a program that reads pixels on given (x,y)
  3. make it read about 5+ pixels on each square (so it is impossible for the cursor/piece to cover all the pixels to be read)
  4. convert the HEX to RBG, then give a range of accepted values of what we deem to be considered close to the "last move" color
  5. save the moves on an array with a format ["h1-h8", "e4-e5", ...] just the initial and ending squares (order unimportant)

Note: from here we can't really know from which square was the initial/ending position, but there are only 2 posibilities and only 1 of them is legal.

I have written simple pixel-based macros/bots for RPGs games in C#, I can guarantee this is not that difficult, given that:

  1. the cam is static (so the x,y values don't get messed up)
  2. you previously know the background color or you can set it up before playing

Basically, it is best if the game is played online and you are recording directly from the screen.

Sorry, no program avaiable for part #1


Part 2: exporting that list into PGN

To turn this list into a real PGN, you can use a program I wrote in JavaScript that records moves, and one of the functions moveCaller() you pass two squares positions and it searches the final_pos in the legal moves of initial_pos and if there is a match then it calls makeMove(). So we can call it twice e5 to e4 and e4 to e5 and I guarantee it will ignore the illegal one.

  1. download the project (direct link .zip)
  2. uncompress the .zip
  3. change the JavaScript of the index.html file with this:

'

$(function(){
    initBoard("xboard",null,false);

    var arr=["e4-e2","e7-e5","f3-g1"];//notice the initial-final might be switched

    for(var i=0;i<arr.length;i++){
        var temp=arr[i].split("-");

        //one of the two following lines will silently fail
        moveCaller(bosToPos(temp[0]),bosToPos(temp[1]),window["xboard"]);
        moveCaller(bosToPos(temp[1]),bosToPos(temp[0]),window["xboard"]);
    }
});

.4. copy the move list and add some PGN headers above it like [WhiteElo "2400"] etc.

Edit: promoting to anything different than queen will make everything explode. It will also be very hard to support this (my program for Part 2 supports underpromotion, but storing the info of Part 1 purely by reading pixels is a nightmare).

Part 1: storing the squares using pixel readers

It is totally possible, the steps needed would be:

  1. change the set up of the board so it highlights the last move (prefereably not just the border)
  2. write a program that reads pixels on given (x,y)
  3. make it read about 5+ pixels on each square (so it is impossible for the cursor/piece to cover all the pixels to be read)
  4. convert the HEX to RBG, then give a range of accepted values of what we deem to be considered close to the "last move" color
  5. save the moves on an array with a format ["h1-h8", "e4-e5", ...] just the initial and ending squares (order unimportant)

Note: from here we can't really know from which square was the initial/ending position, but there are only 2 posibilities and only 1 of them is legal.

I have written simple pixel-based macros/bots for RPGs games in C#, I can guarantee this is not that difficult, given that:

  1. the cam is static (so the x,y values don't get messed up)
  2. you previously know the background color or you can set it up before playing

Basically, it is best if the game is played online and you are recording directly from the screen.

Sorry, no program avaiable for part #1


Part 2: exporting that list into PGN

To turn this list into a real PGN, you can use a program I wrote in JavaScript that records moves, and one of the functions moveCaller() you pass two squares positions and it searches the final_pos in the legal moves of initial_pos and if there is a match then it calls makeMove(). So we can call it twice e5 to e4 and e4 to e5 and I guarantee it will ignore the illegal one.

  1. download the project (direct link .zip)
  2. uncompress the .zip
  3. change the JavaScript of the index.html file with this:

'

$(function(){
    initBoard("xboard",null,false);

    var arr=["e4-e2","e7-e5","f3-g1"];//notice the initial-final might be switched

    for(var i=0;i<arr.length;i++){
        var temp=arr[i].split("-");

        //one of the two following lines will silently fail
        moveCaller(bosToPos(temp[0]),bosToPos(temp[1]),window["xboard"]);
        moveCaller(bosToPos(temp[1]),bosToPos(temp[0]),window["xboard"]);
    }
});

.4. copy the move list and add some PGN headers above it like [WhiteElo "2400"] etc.

Edit: promoting to anything different than queen will make everything explode. It will also be very hard to support this (my program for Part 2 supports underpromotion, but storing the info of Part 1 purely by reading pixels is a nightmare).

Edit2: I just noticed you mean real board chess to PGN, so this is all useless and I will most likely delete my answer.

Part 1: storing the squares using pixel readers

It is totally possible, the steps needed would be:

  1. change the set up of the board so it highlights the last move (prefereably not just the border)
  2. write a program that reads pixels on given (x,y)
  3. make it read about 5+ pixels on each square (so it is impossible for the cursor/piece to cover all the pixels to be read)
  4. convert the HEX to RBG, then give a range of accepted values of what we deem to be considered close to the "last move" color
  5. save the moves on an array with a format ["h1-h8", "e4-e5", ...] just the initial and ending squares (order unimportant)

Note: from here we can't really know from which square was the initial/ending position, but there are only 2 posibilities and only 1 of them is legal.

I have written simple pixel-based macros/bots for RPGs games in C#, I can guarantee this is not that difficult, given that:

  1. the cam is static (so the x,y values don't get messed up)
  2. you previously know the background color or you can set it up before playing

Basically, it is best if the game is played online and you are recording directly from the screen.

Sorry, no program avaiable for part #1


Part 2: exporting that list into PGN

To turn this list into a real PGN, you can use a program I wrote in JavaScript that records moves, and one of the functions moveCaller() you pass two squares positions and it searches the final_pos in the legal moves of initial_pos and if there is a match then it calls makeMove(). So we can call it twice e5 to e4 and e4 to e5 and I guarantee it will ignore the illegal one.

  1. download the project (direct link .zip)
  2. uncompress the .zip
  3. change the JavaScript of the index.html file with this:

'

$(function(){
    initBoard("xboard",null,false);

    var arr=["e4-e2","e7-e5","f3-g1"];//notice the initial-final might be switched

    for(var i=0;i<arr.length;i++){
        var temp=arr[i].split("-");

        //one of the two following lines will silently fail
        moveCaller(bosToPos(temp[0]),bosToPos(temp[1]),window["xboard"]);
        moveCaller(bosToPos(temp[1]),bosToPos(temp[0]),window["xboard"]);
    }
});

.4. copy the move list and add some PGN headers above it like [WhiteElo "2400"] etc.

2 added 253 characters in body
source | link

Edit: promoting to anything different than queen will make everything explode. It will also be very hard to support this (my program for Part 2 supports underpromotion, but storing the info of Part 1 purely by reading pixels is a nightmare).

Part 1: storing the squares using pixel readers

It is totally possible, the steps needed would be:

  1. change the set up of the board so it highlights the last move (prefereably not just the border)
  2. write a program that reads pixels on given (x,y)
  3. make it read about 5+ pixels on each square (so it is impossible tofor the cursor/piece covers theto cover all the pixels to be read)
  4. convert the HEX to RBG, then give a range of accepted values of what we deem to be considered close to the "last move" color
  5. save the moves on an array with a format ["h1-h8", "e4-e5", ...] just the initial and ending squares (order unimportant)

Note: from here we can't really know from which square was the initial/ending position, but there are only 2 posibilities and only 1 of them is legal.

I have written simple pixel-based macros/bots for RPGs games in C#, I can guarantee this is not that difficult, given that:

  1. the cam is static (so the x,y values don't get messed up)
  2. you previously know the background color or you can set it up before playing

Basically, it is best if the game is played online and you are recording directly from the screen.

Sorry, no program avaiable for part #1


Part 2: exporting that list into PGN

To turn this list into a real PGN, you can use a program I wrote in JavaScript that records moves, and one of the functions moveCaller() you pass two squares positions and it searches the final_pos in the legal moves of initial_pos and if there is a match then it calls makeMove(). So we can call it twice e5 to e4 and e4 to e5 and I guarantee it will ignore the illegal one.

  1. download the project (direct link .zip)
  2. uncompress the .zip
  3. change the JavaScript of the index.html file with this:

'

$(function(){
    initBoard("xboard",null,false);

    var arr=["e4-e2","e7-e5","f3-g1"];//notice the initial-final might be switched

    for(var i=0;i<arr.length;i++){
        var temp=arr[i].split("-");

        //one of the two following lines will silently fail
        moveCaller(bosToPos(temp[0]),bosToPos(temp[1]),window["xboard"]);
        moveCaller(bosToPos(temp[1]),bosToPos(temp[0]),window["xboard"]);
    }
});

.4. copy the move list and add some PGN headers above it like [WhiteElo "2400"] etc.

Part 1: storing the squares using pixel readers

It is totally possible, the steps needed would be:

  1. change the set up of the board so it highlights the last move (prefereably not just the border)
  2. write a program that reads pixels on given (x,y)
  3. make it read about 5+ pixels on each square (so it is impossible to the cursor/piece covers the all the pixels to be read)
  4. convert the HEX to RBG, then give a range of accepted values of what we deem to be considered close to the "last move" color
  5. save the moves on an array with a format ["h1-h8", "e4-e5", ...] just the initial and ending squares

Note: from here we can't really know from which square was the initial/ending position, but there are only 2 posibilities and only 1 of them is legal.

I have written simple pixel-based macros/bots for RPGs games in C#, I can guarantee this is not that difficult, given that:

  1. the cam is static (so the x,y values don't get messed up)
  2. you previously know the background color or you can set it up before playing

Basically, it is best if the game is played online and you are recording directly from the screen.

Sorry, no program avaiable for part #1


Part 2: exporting that list into PGN

To turn this list into a real PGN, you can use a program I wrote in JavaScript that records moves, and one of the functions moveCaller() you pass two squares positions and it searches the final_pos in the legal moves of initial_pos and if there is a match then it calls makeMove(). So we can call it twice e5 to e4 and e4 to e5 and I guarantee it will ignore the illegal one.

  1. download the project (direct link .zip)
  2. uncompress the .zip
  3. change the JavaScript of the index.html file with this:

'

$(function(){
    initBoard("xboard",null,false);

    var arr=["e4-e2","e7-e5","f3-g1"];//notice the initial-final might be switched

    for(var i=0;i<arr.length;i++){
        var temp=arr[i].split("-");

        //one of the two following lines will silently fail
        moveCaller(bosToPos(temp[0]),bosToPos(temp[1]),window["xboard"]);
        moveCaller(bosToPos(temp[1]),bosToPos(temp[0]),window["xboard"]);
    }
});

.4. copy the move list and add some PGN headers above it like [WhiteElo "2400"] etc.

Edit: promoting to anything different than queen will make everything explode. It will also be very hard to support this (my program for Part 2 supports underpromotion, but storing the info of Part 1 purely by reading pixels is a nightmare).

Part 1: storing the squares using pixel readers

It is totally possible, the steps needed would be:

  1. change the set up of the board so it highlights the last move (prefereably not just the border)
  2. write a program that reads pixels on given (x,y)
  3. make it read about 5+ pixels on each square (so it is impossible for the cursor/piece to cover all the pixels to be read)
  4. convert the HEX to RBG, then give a range of accepted values of what we deem to be considered close to the "last move" color
  5. save the moves on an array with a format ["h1-h8", "e4-e5", ...] just the initial and ending squares (order unimportant)

Note: from here we can't really know from which square was the initial/ending position, but there are only 2 posibilities and only 1 of them is legal.

I have written simple pixel-based macros/bots for RPGs games in C#, I can guarantee this is not that difficult, given that:

  1. the cam is static (so the x,y values don't get messed up)
  2. you previously know the background color or you can set it up before playing

Basically, it is best if the game is played online and you are recording directly from the screen.

Sorry, no program avaiable for part #1


Part 2: exporting that list into PGN

To turn this list into a real PGN, you can use a program I wrote in JavaScript that records moves, and one of the functions moveCaller() you pass two squares positions and it searches the final_pos in the legal moves of initial_pos and if there is a match then it calls makeMove(). So we can call it twice e5 to e4 and e4 to e5 and I guarantee it will ignore the illegal one.

  1. download the project (direct link .zip)
  2. uncompress the .zip
  3. change the JavaScript of the index.html file with this:

'

$(function(){
    initBoard("xboard",null,false);

    var arr=["e4-e2","e7-e5","f3-g1"];//notice the initial-final might be switched

    for(var i=0;i<arr.length;i++){
        var temp=arr[i].split("-");

        //one of the two following lines will silently fail
        moveCaller(bosToPos(temp[0]),bosToPos(temp[1]),window["xboard"]);
        moveCaller(bosToPos(temp[1]),bosToPos(temp[0]),window["xboard"]);
    }
});

.4. copy the move list and add some PGN headers above it like [WhiteElo "2400"] etc.

1
source | link

Part 1: storing the squares using pixel readers

It is totally possible, the steps needed would be:

  1. change the set up of the board so it highlights the last move (prefereably not just the border)
  2. write a program that reads pixels on given (x,y)
  3. make it read about 5+ pixels on each square (so it is impossible to the cursor/piece covers the all the pixels to be read)
  4. convert the HEX to RBG, then give a range of accepted values of what we deem to be considered close to the "last move" color
  5. save the moves on an array with a format ["h1-h8", "e4-e5", ...] just the initial and ending squares

Note: from here we can't really know from which square was the initial/ending position, but there are only 2 posibilities and only 1 of them is legal.

I have written simple pixel-based macros/bots for RPGs games in C#, I can guarantee this is not that difficult, given that:

  1. the cam is static (so the x,y values don't get messed up)
  2. you previously know the background color or you can set it up before playing

Basically, it is best if the game is played online and you are recording directly from the screen.

Sorry, no program avaiable for part #1


Part 2: exporting that list into PGN

To turn this list into a real PGN, you can use a program I wrote in JavaScript that records moves, and one of the functions moveCaller() you pass two squares positions and it searches the final_pos in the legal moves of initial_pos and if there is a match then it calls makeMove(). So we can call it twice e5 to e4 and e4 to e5 and I guarantee it will ignore the illegal one.

  1. download the project (direct link .zip)
  2. uncompress the .zip
  3. change the JavaScript of the index.html file with this:

'

$(function(){
    initBoard("xboard",null,false);

    var arr=["e4-e2","e7-e5","f3-g1"];//notice the initial-final might be switched

    for(var i=0;i<arr.length;i++){
        var temp=arr[i].split("-");

        //one of the two following lines will silently fail
        moveCaller(bosToPos(temp[0]),bosToPos(temp[1]),window["xboard"]);
        moveCaller(bosToPos(temp[1]),bosToPos(temp[0]),window["xboard"]);
    }
});

.4. copy the move list and add some PGN headers above it like [WhiteElo "2400"] etc.