Viewing Program

Program Data

Program thumbnail for "{props.program.title}"

Title	1K ZX Chess
ID	5511065696075776
Created	Unknown
Updated	9 years ago, 1456883504396
Code	/** * All moves require TWO clicks. Click once to select your piece. * Click again on the destination square. If the move is invalid, * the second click is ignored. Clicking on the piece's original * square releases that piece and allows you to choose another. * To castle, move your king ♔ to his final destination; the rook * will automatically move to its castled destination. / /* * Computer chess playing programs became interesting in 1982 with the * introduction of 1K ZX Chess, https://en.wikipedia.org/wiki/1K_ZX_Chess . * The tiny 1000 byte program ran on a computer (a Sinclare ZX81, * https://en.wikipedia.org/wiki/ZX81) that any hobbyist could afford. * This program is from a descendent called "5K Chess". The chess * playing engine requires less than 1500 lines of commented * JavaScript. My Processing.js-based graphical user interface * requires much less. * * The user interface of the ancient program only used ASCII * characters and reprinted the board after each move. This program * uses unicode chess characters and an obvious drag and drop * mechanism for piece movement. / / * I have been programming since 1969. I made my career * writing highly portable C code and porting it to a plethora * of platforms. That is the opposite side of this coin: porting * random programs from the industry to the Khan Academy * Processing.js environment. In this case, the source program * was HTML, CSS, DOM-event-based JavaScript, minimally commented * with regards to the graphical user interface. (The computation * engine was rather nice code with reasonable comments.) * The original code's comments are: * * p4wn, AKA 5k chess - by Douglas Bagnall <douglas@paradise.net.nz> * * This code is in the public domain, or as close to it as various * laws allow. No warranty; no restrictions. * * lives at http://p4wn.sf.net/ / var P4_PAWN = 2, P4_ROOK = 4, P4_KNIGHT = 6, P4_BISHOP = 8, P4_QUEEN = 12, P4_KING = 10; var P4_EDGE = 16; var P4_MOVE_FLAG_OK = 1; var P4_MOVE_FLAG_CHECK = 2; var P4_MOVE_FLAG_MATE = 4; var P4_MOVE_FLAG_CAPTURE = 8; var P4_MOVE_FLAG_CASTLE_KING = 16; var P4_MOVE_FLAG_CASTLE_QUEEN = 32; var P4_MOVE_FLAG_DRAW = 64; var P4_MOVE_ILLEGAL = 0; var P4_MOVE_MISSED_MATE = P4_MOVE_FLAG_CHECK \| P4_MOVE_FLAG_MATE; var P4_MOVE_CHECKMATE = P4_MOVE_FLAG_OK \| P4_MOVE_FLAG_CHECK \| P4_MOVE_FLAG_MATE; var P4_MOVE_STALEMATE = P4_MOVE_FLAG_OK \| P4_MOVE_FLAG_MATE; / Marry p4_log to printerr. / var p4_log = function() { var args = Array.prototype.slice.call(arguments); println(args.join(', ')); }; var parseB10 = parseInt; / KA should default to base ten / var p4_parse, p4_check_castling, p4_check_check, p4_make_move, p4_unmake_move, p4_move2string, p4_state2fen, p4_stringify_point, p4_destringify_point, p4_fen2state, p4_initialise_state, p4_interpret_movestring, p4_find_source_point; / forward declarations / / The pieces are stored as numbers between 2 and 13, inclusive. * Empty squares are stored as 0, and off-board squares as 16. * There is some bitwise logic to it: * piece & 1 -> colour (white: 0, black: 1) * piece & 2 -> single move piece (including pawn) * if (piece & 2) == 0: * piece & 4 -> row and column moves * piece & 8 -> diagonal moves / var P4_PAWN = 2, P4_ROOK = 4, P4_KNIGHT = 6, P4_BISHOP = 8, P4_QUEEN = 12, P4_KING = 10; var P4_EDGE = 16; / in order, even indices: <nothing>, pawn, rook, knight, bishop, king, queen. Only the * even indices are used./ var P4_MOVES = [[], [], [], [], [1,10,-1,-10], [], [21,19,12,8,-21,-19,-12,-8], [], [11,9,-11,-9], [], [1,10,11,9,-1,-10,-11,-9], [], [1,10,11,9,-1,-10,-11,-9], [] ]; /P4_VALUES defines the relative value of various pieces. * * It follows the 1,3,3,5,9 pattern you learn as a kid, multiplied by * 20 to give sub-pawn resolution to other factors, with bishops given * a wee boost over knights. / var P4_VALUES=[0, 0, //Piece values 20, 20, //pawns 100, 100, //rooks 60, 60, //knights 61, 61, //bishops 8000, 8000,//kings 180, 180, //queens 0]; / A score greater than P4_WIN indicates a king has been taken. It is * less than the value of a king, in case someone finds a way to, say, * sacrifice two queens in order to checkmate. / var P4_KING_VALUE = P4_VALUES[10]; var P4_WIN = P4_KING_VALUE >> 1; / every move, a winning score decreases by this much / var P4_WIN_DECAY = 300; var P4_WIN_NOW = P4_KING_VALUE - 250; / P4_{MAX,MIN}_SCORE should be beyond any possible evaluated score / var P4_MAX_SCORE = 9999; // extremes of evaluation range var P4_MIN_SCORE = -P4_MAX_SCORE; /initialised in p4_initialise_state / var P4_CENTRALISING_WEIGHTS; var P4_BASE_PAWN_WEIGHTS; var P4_KNIGHT_WEIGHTS; /P4_DEBUG turns on debugging features / var P4_DEBUG = 0; var P4_INITIAL_BOARD = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 1 1"; var P4_PIECE_LUT = { /for FEN, PGN interpretation / P: 2, p: 3, R: 4, r: 5, N: 6, n: 7, B: 8, b: 9, K: 10, k: 11, Q: 12, q: 13 }; var P4_ENCODE_LUT = ' PPRRNNBBKKQQ'; var p4_alphabeta_treeclimber = function(state, count, colour, score, s, e, alpha, beta){ var move = p4_make_move(state, s, e, P4_QUEEN); var i; var ncolour = 1 - colour; var movelist = p4_parse(state, colour, move.ep, -score); var movecount = movelist.length; if(count){ //branch nodes var t; for(i = 0; i < movecount; i++){ var mv = movelist[i]; var mscore = mv[0]; var ms = mv[1]; var me = mv[2]; if (mscore > P4_WIN){ //we won! Don't look further. alpha = P4_KING_VALUE; break; } t = -p4_alphabeta_treeclimber(state, count - 1, ncolour, mscore, ms, me, -beta, -alpha); if (t > alpha){ alpha = t; } if (alpha >= beta){ break; } } if (alpha < -P4_WIN_NOW && ! p4_check_check(state, colour)){ / Whatever we do, we lose the king. * But if it is not check then this is stalemate, and the * score doesn't apply. / alpha = state.stalemate_scores[colour]; } if (alpha < -P4_WIN){ /make distant checkmate seem less bad / alpha += P4_WIN_DECAY; } } else{ //leaf nodes while(beta > alpha && --movecount !== -1){ if(movelist[movecount][0] > alpha){ alpha = movelist[movecount][0]; } } } p4_unmake_move(state, move); return alpha; }; / p4_prepare() works out weightings for assessing various moves, * favouring centralising moves early, for example. * * It is called before each tree search, not for each parse(), so it * is OK for it to be a little bit slow. But that also means it drifts * out of sync with the real board state, especially on deep searches. / var p4_prepare = function(state){ var i, j, x, y, a; var pieces = state.pieces = [[], []]; /convert state.moveno half move count to move cycle count / var moveno = state.moveno >> 1; var board = state.board; / high earliness_weight indicates a low move number. The formula * should work above moveno == 50, but this is JavaScript. / var earliness_weight = (moveno > 50) ? 0 : parseB10(6 Math.exp(moveno * -0.07)); var king_should_hide = moveno < 12; var early = moveno < 5; /* find the pieces, kings, and weigh material/ var kings = [0, 0]; var material = [0, 0]; var best_pieces = [0, 0]; for(i = 20; i < 100; i++){ a = board[i]; var piece = a & 14; var colour = a & 1; if(piece){ pieces[colour].push([a, i]); if (piece === P4_KING){ kings[colour] = i; } else{ material[colour] += P4_VALUES[piece]; best_pieces[colour] = Math.max(best_pieces[colour], P4_VALUES[piece]); } } } /does a draw seem likely soon?/ var draw_likely = (state.draw_timeout > 90 \|\| state.current_repetitions >= 2); if (draw_likely) { p4_log("draw likely", state.current_repetitions, state.draw_timeout); } state.values = [[], []]; var qvalue = P4_VALUES[P4_QUEEN]; /used as ballast in various ratios/ var material_sum = material[0] + material[1] + 2 qvalue; var wmul = 2 * (material[1] + qvalue) / material_sum; var bmul = 2 * (material[0] + qvalue) / material_sum; var multipliers = [wmul, bmul]; var emptiness = 4 * P4_QUEEN / material_sum; state.stalemate_scores = [parseB10(0.5 + (wmul - 1) * 2 * qvalue), parseB10(0.5 + (bmul - 1) * 2 * qvalue)]; //p4_log("value multipliers (W, B):", wmul, bmul, // "stalemate scores", state.stalemate_scores); for (i = 0; i < P4_VALUES.length; i++){ var v = P4_VALUES[i]; if (v < P4_WIN){//i.e., not king state.values[0][i] = parseB10(v * wmul + 0.5); state.values[1][i] = parseB10(v * bmul + 0.5); } else { state.values[0][i] = v; state.values[1][i] = v; } } /used for pruning quiescence search / state.best_pieces = [parseB10(best_pieces[0] * wmul + 0.5), parseB10(best_pieces[1] * bmul + 0.5)]; var kx = [kings[0] % 10, kings[1] % 10]; var ky = [parseB10(kings[0] / 10), parseB10(kings[1] / 10)]; /* find the frontmost pawns in each file / var pawn_cols = [[], []]; for (y = 3; y < 9; y++){ for (x = 1; x < 9; x++){ i = y 10 + x; a = board[i]; if ((a & 14) !== P4_PAWN) { continue; } if ((a & 1) === 0){ pawn_cols[0][x] = y; } else if (pawn_cols[1][x] === undefined){ pawn_cols[1][x] = y; } } } var target_king = (moveno >= 20 \|\| material_sum < 5 * qvalue); var weights = state.weights; for (y = 2; y < 10; y++){ for (x = 1; x < 9; x++){ i = y * 10 + x; var early_centre = P4_CENTRALISING_WEIGHTS[i] * earliness_weight; var plateau = P4_KNIGHT_WEIGHTS[i]; for (var c = 0; c < 2; c++){ var dx = Math.abs(kx[1 - c] - x); var dy = Math.abs(ky[1 - c] - y); var our_dx = Math.abs(kx[c] - x); var our_dy = Math.abs(ky[c] - y); var d = Math.max(Math.sqrt(dx * dx + dy * dy), 1) + 1; var mul = multipliers[c]; /(mul < 1) <==> we're winning/ var mul3 = mul * mul * mul; var at_home = y === 2 + c * 7; var pawn_home = y === 3 + c * 5; var row4 = y === 5 + c; var promotion_row = y === 9 - c * 7; var get_out = (early && at_home) * -5; var knight = parseB10(early_centre * 0.3) + 2 * plateau + get_out; var rook = parseB10(early_centre * 0.3); var bishop = parseB10(early_centre * 0.6) + plateau + get_out; if (at_home){ rook += (x === 4 \|\| x === 5) * (earliness_weight + ! target_king); rook += (x === 1 \|\| x === 8) * (moveno > 10 && moveno < 20) * -3; rook += (x === 2 \|\| x === 7) * (moveno > 10 && moveno < 20) * -1; } /Queen wants to stay home early, then jump right in/ /keep kings back on home row for a while/ var queen = parseB10(plateau * 0.5 + early_centre * (0.5 - early)); var king = (king_should_hide && at_home) * 2 * earliness_weight; /empty board means pawn advancement is more urgent/ var get_on_with_it = Math.max(emptiness * 2, 1); var pawn = get_on_with_it * P4_BASE_PAWN_WEIGHTS[c ? 119 - i : i]; if (early){ /* Early pawn weights are slightly randomised, so each game is different. / if (y >= 4 && y <= 7){ var boost = 1 + 3 (y === 5 \|\| y === 6); pawn += parseB10((boost + random(4)) * 0.1 * early_centre); } if (x === 4 \|\| x === 5){ //discourage middle pawns from waiting at home pawn -= 3 * pawn_home; pawn += 3 * row4; } } /pawn promotion row is weighted as a queen minus a pawn./ if (promotion_row) { pawn += state.values[c][P4_QUEEN] - state.values[c][P4_PAWN]; } /pawns in front of a castled king should stay there/ pawn += 4 * (y === 3 && ky[c] === 2 && Math.abs(our_dx) < 2 && kx[c] !== 5 && x !== 4 && x !== 5); /passed pawns (having no opposing pawn in front) are encouraged. / var cols = pawn_cols[1 - c]; if (cols[x] === undefined \|\| (c === 0 && cols[x] < y) \|\| (c === 1 && cols[x] > y)) { pawn += 2; } /* After a while, start going for opposite king. Just * attract pieces into the area so they can mill about in * the area, waiting for an opportunity. * * As prepare is only called at the beginning of each tree * search, the king could wander out of the targetted area * in deep searches. But that's OK. Heuristics are * heuristics. / if (target_king){ knight += 2 parseB10(8 * mul / d); rook += 2 * ((dx < 2) + (dy < 2)); bishop += 3 * (Math.abs((dx - dy)) < 2); queen += 2 * parseB10(8 / d) + (dx * dy === 0) + (dx - dy === 0); /* The losing king wants to stay in the middle, while the winning king goes in for the kill./ var king_centre_wt = 8 emptiness * P4_CENTRALISING_WEIGHTS[i]; king += parseB10(150 * emptiness / (mul3 * d) + king_centre_wt * mul3); } weights[P4_PAWN + c][i] = pawn; weights[P4_KNIGHT + c][i] = knight; weights[P4_ROOK + c][i] = rook; weights[P4_BISHOP + c][i] = bishop; weights[P4_QUEEN + c][i] = queen; weights[P4_KING + c][i] = king; if (draw_likely && mul < 1){ /The winning side wants to avoid draw, so adds jitter to its weights./ var range = 3 / mul3; for (j = 2 + c; j < 14; j += 2){ weights[j][i] += (random(range) \| 0); } } } } } state.prepared = true; }; var p4_maybe_prepare = function(state){ if (! state.prepared) { p4_prepare(state); } }; var p4_parse = function(state, colour, ep, score) { var board = state.board; var s, e; //start and end position var E, a; //E=piece at end place, a= piece moving var i, j; var other_colour = 1 - colour; var dir = (10 - 20 * colour); //dir= 10 for white, -10 for black var movelist = []; var captures = []; var weight; var pieces = state.pieces[colour]; var castle_flags = (state.castles >> (colour * 2)) & 3; var values = state.values[other_colour]; var all_weights = state.weights; var weight_lut; for (j = pieces.length - 1; j >= 0; j--){ s = pieces[j][1]; // board position a = board[s]; //piece number var weight_lut = all_weights[a]; weight = score - weight_lut[s]; a &= 14; if(a > 2){ //non-pawns var moves = P4_MOVES[a]; if(a & 2){ for(i = 0; i < 8; i++){ e = s + moves[i]; E = board[e]; if(!E){ movelist.push([weight + values[E] + weight_lut[e], s, e]); } else if((E&17)===other_colour){ captures.push([weight + values[E] + weight_lut[e] + all_weights[E][e], s, e]); } } if(a === P4_KING && castle_flags){ if((castle_flags & 1) && (board[s-1] + board[s-2] + board[s-3] === 0) && p4_check_castling(board, s - 2,other_colour,dir,-1)){//Q side movelist.push([weight + 12, s, s - 2]); //no analysis, just encouragement } if((castle_flags & 2) && (board[s+1]+board[s+2] === 0)&& p4_check_castling(board, s, other_colour, dir, 1)){//K side movelist.push([weight + 13, s, s + 2]); } } } else{//rook, bishop, queen var mlen = moves.length; for(i=0;i<mlen;){ //goeth thru list of moves var m = moves[i++]; e=s; do { e+=m; E=board[e]; if(!E){ movelist.push([weight + values[E] + weight_lut[e], s, e]); } else if((E&17)===other_colour){ captures.push([weight + values[E] + weight_lut[e] + all_weights[E][e], s, e]); } }while(!E); } } } else{ //pawns e=s+dir; if(!board[e]){ movelist.push([weight + weight_lut[e], s, e]); /* s * (120 - s) < 3200 true for outer two rows on either side./ var e2 = e + dir; if(s (120 - s) < 3200 && (!board[e2])){ movelist.push([weight + weight_lut[e2], s, e2]); } } /* +/-1 for pawn capturing / E = board[--e]; if(E && (E & 17) === other_colour){ captures.push([weight + values[E] + weight_lut[e] + all_weights[E][e], s, e]); } e += 2; E = board[e]; if(E && (E & 17) === other_colour){ captures.push([weight + values[E] + weight_lut[e] + all_weights[E][e], s, e]); } } } if(ep){ var pawn = P4_PAWN \| colour; var taken; / Some repetitive calculation here could be hoisted out, but that would probably slow things: the common case is no pawns waiting to capture enpassant, not 2. / s = ep - dir - 1; if (board[s] === pawn){ taken = values[P4_PAWN] + all_weights[P4_PAWN \| other_colour][ep - dir]; captures.push([score - weight_lut[s] + weight_lut[ep] + taken, s, ep]); } s += 2; if (board[s] === pawn){ taken = values[P4_PAWN] + all_weights[P4_PAWN \| other_colour][ep - dir]; captures.push([score - weight_lut[s] + weight_lut[ep] + taken, s, ep]); } } return captures.concat(movelist); }; /Explaining the bit tricks used in check_castling and check_check: * * in binary: 16 8 4 2 1 * empty * pawn 1 c * rook 1 c * knight 1 1 c * bishop 1 c * king 1 1 c * queen 1 1 c * wall 1 * * so: * * piece & (16 \| 4 \| 2 \| 1) is: * 2 + c for kings and pawns * 4 + c for rooks and queens * 6 + c for knights * 0 + c for bishops * 16 for walls * * thus: * ((piece & 23) == 4 \| colour) separates the rooks and queens out * from the rest. * ((piece & 27) == 8 \| colour) does the same for queens and bishops. / / check_castling * * s - "start" location (either king home square, or king destination) * the checks are done left to right. * * dir - direction of travel (White: 10, Black: -10) * side: -1 means Q side; 1, K side / var p4_check_castling = function(board, s, colour, dir, side){ var e; var E; var m, p; var knight = colour + P4_KNIGHT; var diag_slider = P4_BISHOP \| colour; var diag_mask = 27; var grid_slider = P4_ROOK \| colour; var king_pawn = 2 \| colour; var grid_mask = 23; / go through 3 positions, checking for check in each / for(p = s; p < s + 3; p++){ //bishops, rooks, queens e = p; do{ e += dir; E=board[e]; } while (! E); if((E & grid_mask) === grid_slider) { return 0; } e = p; var delta = dir - 1; do{ e += delta; E=board[e]; } while (! E); if((E & diag_mask) === diag_slider) { return 0; } e = p; delta += 2; do{ e += delta; E=board[e]; } while (! E); if((E & diag_mask) === diag_slider) { return 0; } /knights on row 7. (row 6 is handled below)/ if (board[p + dir - 2] === knight \|\| board[p + dir + 2] === knight) { return 0; } } / a pawn or king in any of 5 positions on row 7. * or a knight on row 6. / for(p = s + dir - 1; p < s + dir + 4; p++){ E = board[p] & grid_mask; if(E === king_pawn \|\| board[p + dir] === knight) { return 0; } } / scan back row for rooks, queens on the other side. * Same side check is impossible, because the castling rook is there / e = (side < 0) ? s + 2 : s; do { e -= side; E=board[e]; } while (! E); if((E & grid_mask) === grid_slider) { return 0; } return 1; }; var p4_check_check = function(state, colour){ var board = state.board; /find the king. The pieces list updates from the end, * so the last-most king is correctly placed./ var pieces = state.pieces[colour]; var p; var i = pieces.length; do { p = pieces[--i]; } while (p[0] !== (P4_KING \| colour)); var s = p[1]; var other_colour = 1 - colour; var dir = 10 - 20 colour; if (board[s + dir - 1] === (P4_PAWN \| other_colour) \|\| board[s + dir + 1] === (P4_PAWN \| other_colour)) { return true; } var knight_moves = P4_MOVES[P4_KNIGHT]; var king_moves = P4_MOVES[P4_KING]; var knight = P4_KNIGHT \| other_colour; var king = P4_KING \| other_colour; for (i = 0; i < 8; i++){ if (board[s + knight_moves[i]] === knight \|\| board[s + king_moves[i]] === king) { return true; } } var diagonal_moves = P4_MOVES[P4_BISHOP]; var grid_moves = P4_MOVES[P4_ROOK]; /* diag_mask ignores rook moves of queens, * grid_mask ignores the bishop moves/ var diag_slider = P4_BISHOP \| other_colour; var diag_mask = 27; var grid_slider = P4_ROOK \| other_colour; var grid_mask = 23; for (i = 0; i < 4; i++){ var m = diagonal_moves[i]; var e = s; var E; do { e += m; E = board[e]; } while (!E); if((E & diag_mask) === diag_slider) { return true; } m = grid_moves[i]; e = s; do { e += m; E = board[e]; } while (!E); if((E & grid_mask) === grid_slider) { return true; } } return false; }; var p4_optimise_piece_list = function(state){ var i, p, s, e; var movelists = [ p4_parse(state, 0, 0, 0), p4_parse(state, 1, 0, 0) ]; var weights = state.weights; var board = state.board; var compareScores = function(a, b){ return (a.score - b.score); }; for (var colour = 0; colour < 2; colour++){ var our_values = state.values[colour]; var pieces = state.pieces[colour]; var movelist = movelists[colour]; var threats = movelists[1 - colour]; / sparse array to index by score. / var scores = []; for (i = 0; i < pieces.length; i++){ p = pieces[i]; scores[p[1]] = { score: 0, piece: p[0], pos: p[1], threatened: 0 }; } / Find the best score for each piece by pure static weights, * ignoring captures, which have their own path to the top. / for(i = movelist.length - 1; i >= 0; i--){ var mv = movelist[i]; var score = mv[0]; s = mv[1]; e = mv[2]; if(! board[e]){ var x = scores[s]; x.score = Math.max(x.score, score); } } / moving out of a threat is worth considering, especially * if it is a pawn and you are not./ for(i = threats.length - 1; i >= 0; i--){ var mv = threats[i]; var x = scores[mv[2]]; if (x !== undefined){ var S = board[mv[1]]; var r = (1 + x.piece > 3 + S < 4) 0.01; if (x.threatened < r) { x.threatened = r; } } } var pieces2 = []; for (i = 20; i < 100; i++){ p = scores[i]; if (p !== undefined){ p.score += p.threatened * our_values[p.piece]; pieces2.push(p); } } pieces2.sort(compareScores); for (i = 0; i < pieces2.length; i++){ p = pieces2[i]; pieces[i] = [p.piece, p.pos]; } } }; var p4_findmove = function(state, level, colour, ep){ p4_prepare(state); p4_optimise_piece_list(state); var board = state.board; if (arguments.length === 2){ colour = state.to_play; ep = state.enpassant; } var movelist = p4_parse(state, colour, ep, 0); var alpha = P4_MIN_SCORE; var mv, t, i; var bs = 0; var be = 0; if (level <= 0){ for (i = 0; i < movelist.length; i++){ mv = movelist[i]; if(movelist[i][0] > alpha){ alpha = mv[0]; bs = mv[1]; be = mv[2]; } } return [bs, be, alpha]; } for(i = 0; i < movelist.length; i++){ mv = movelist[i]; var mscore = mv[0]; var ms = mv[1]; var me = mv[2]; if (mscore > P4_WIN){ p4_log("XXX taking king! it should never come to this"); alpha = P4_KING_VALUE; bs = ms; be = me; break; } t = -state.treeclimber(state, level - 1, 1 - colour, mscore, ms, me, P4_MIN_SCORE, -alpha); if (t > alpha){ alpha = t; bs = ms; be = me; } } if (alpha < -P4_WIN_NOW && ! p4_check_check(state, colour)){ alpha = state.stalemate_scores[colour]; } return [bs, be, alpha]; }; /p4_make_move changes the state and returns an object containing everything necesary to undo the change. * * p4_unmake_move uses the p4_make_move return value to restore the * previous state. / var p4_make_move = function(state, s, e, promotion){ var board = state.board; var S = board[s]; var E = board[e]; board[e] = S; board[s] = 0; var piece = S & 14; var moved_colour = S & 1; var end_piece = S; / can differ from S in queening/ //now some stuff to handle queening, castling var rs = 0, re, rook; var ep_taken = 0, ep_position; var ep = 0; if(piece === P4_PAWN){ if((60 - e) (60 - e) > 900){ /got to end; replace the pawn on board and in pieces cache./ promotion \|= moved_colour; board[e] = promotion; end_piece = promotion; } else if (((s ^ e) & 1) && E === 0){ /this is a diagonal move, but the end spot is empty, so we surmise enpassant / ep_position = e - 10 + 20 * moved_colour; ep_taken = board[ep_position]; board[ep_position] = 0; } else if ((s - e) * (s - e) === 400){ /delta is 20 --> two row jump at start/ ep = (s + e) >> 1; } } else if (piece === P4_KING && ((s - e) * (s - e) === 4)){ //castling - move rook too rs = s - 4 + (s < e) * 7; re = (s + e) >> 1; //avg of s,e=rook's spot rook = moved_colour + P4_ROOK; board[rs] = 0; board[re] = rook; //piece_locations.push([rook, re]); } var old_castle_state = state.castles; if (old_castle_state){ var mask = 0; var shift = moved_colour * 2; var side = moved_colour * 70; var s2 = s - side; var e2 = e + side; //wipe both our sides if king moves if (s2 === 25) { mask \|= 3 << shift; //wipe one side on any move from rook points } else if (s2 === 21) { mask \|= 1 << shift; } else if (s2 === 28) { mask \|= 2 << shift; } //or on any move to opposition corners if (e2 === 91) { mask \|= 4 >> shift; } else if (e2 === 98) { mask \|= 8 >> shift; } state.castles &= ~mask; } var old_pieces = state.pieces.concat(); var our_pieces = old_pieces[moved_colour]; var dest = state.pieces[moved_colour] = []; for (var i = 0; i < our_pieces.length; i++){ var x = our_pieces[i]; var pp = x[0]; var ps = x[1]; if (ps !== s && ps !== rs){ dest.push(x); } } dest.push([end_piece, e]); if (rook) { dest.push([rook, re]); } if (E \|\| ep_taken){ var their_pieces = old_pieces[1 - moved_colour]; dest = state.pieces[1 - moved_colour] = []; var gone = ep_taken ? ep_position : e; for (i = 0; i < their_pieces.length; i++){ var x = their_pieces[i]; if (x[1] !== gone){ dest.push(x); } } } return { /some of these (e.g. rook) could be recalculated during unmake, possibly more cheaply. / s: s, e: e, S: S, E: E, ep: ep, castles: old_castle_state, rs: rs, re: re, rook: rook, ep_position: ep_position, ep_taken: ep_taken, pieces: old_pieces }; }; var p4_unmake_move = function(state, move){ var board = state.board; if (move.ep_position){ board[move.ep_position] = move.ep_taken; } board[move.s] = move.S; board[move.e] = move.E; //move.piece_locations.length--; if(move.rs){ board[move.rs] = move.rook; board[move.re] = 0; //move.piece_locations.length--; } state.pieces = move.pieces; state.castles = move.castles; }; / p4_move(state, s, e, promotion) * s, e are start and end positions * * promotion is the desired pawn promotion if the move gets a pawn to the other * end. * * return value contains bitwise flags / var p4_move = function(state, s, e, promotion){ var board = state.board; var colour = state.to_play; var other_colour = 1 - colour; if (s !== parseB10(s)){ if (e === undefined){ var mv = p4_interpret_movestring(state, s); s = mv[0]; e = mv[1]; if (s === 0) { return {flags: P4_MOVE_ILLEGAL, ok: false}; } promotion = mv[2]; } else {/assume two point strings: 'e2', 'e4'/ s = p4_destringify_point(s); e = p4_destringify_point(e); } } if (promotion === undefined) { promotion = P4_QUEEN; } var E=board[e]; var S=board[s]; /See if this move is even slightly legal, disregarding check. / var i; var legal = false; p4_maybe_prepare(state); var moves = p4_parse(state, colour, state.enpassant, 0); for (i = 0; i < moves.length; i++){ if (e === moves[i][2] && s === moves[i][1]){ legal = true; break; } } if (! legal) { return {flags: P4_MOVE_ILLEGAL, ok: false}; } /Try the move, and see what the response is./ var changes = p4_make_move(state, s, e, promotion); /is it check? / if (p4_check_check(state, colour)){ p4_unmake_move(state, changes); p4_log('in check', changes); return {flags: P4_MOVE_ILLEGAL, ok: false, string: "in check!"}; } /The move is known to be legal. We won't be undoing it./ var flags = P4_MOVE_FLAG_OK; state.enpassant = changes.ep; state.history.push([s, e, promotion]); /draw timeout: 50 moves without pawn move or capture is a draw / if (changes.E \|\| changes.ep_position){ state.draw_timeout = 0; flags \|= P4_MOVE_FLAG_CAPTURE; } else if (S & 14 === P4_PAWN){ state.draw_timeout = 0; } else{ state.draw_timeout++; } if (changes.rs){ flags \|= (s > e) ? P4_MOVE_FLAG_CASTLE_QUEEN : P4_MOVE_FLAG_CASTLE_KING; } var shortfen = p4_state2fen(state, true); var repetitions = (state.position_counts[shortfen] \|\| 0) + 1; state.position_counts[shortfen] = repetitions; state.current_repetitions = repetitions; if (state.draw_timeout > 100 \|\| repetitions >= 3){ //XXX also if material drops too low? flags \|= P4_MOVE_FLAG_DRAW; } state.moveno++; state.to_play = other_colour; if (p4_check_check(state, other_colour)){ flags \|= P4_MOVE_FLAG_CHECK; } / check for (state\|check)mate, by seeing if there is a move for * the other side that doesn't result in check. (In other words, * reduce the pseudo-legal-move list down to a legal-move list, * and check it isn't empty). * * We don't need to p4_prepare because other colour pieces can't * have moved (just disappeared) since previous call. Also, * setting the promotion piece is unnecessary, because all * promotions block check equally well. / var is_mate = true; var replies = p4_parse(state, other_colour, changes.ep, 0); for (i = 0; i < replies.length; i++){ var m = replies[i]; var change2 = p4_make_move(state, m[1], m[2], P4_QUEEN); var check = p4_check_check(state, other_colour); p4_unmake_move(state, change2); if (!check){ is_mate = false; break; } } if (is_mate) { flags \|= P4_MOVE_FLAG_MATE; } var movestring = p4_move2string(state, s, e, S, promotion, flags, moves); p4_log("successful move", s, e, movestring, flags); state.prepared = false; return { flags: flags, string: movestring, ok: true }; }; var p4_move2string = function(state, s, e, S, promotion, flags, moves){ var piece = S & 14; var src, dest; var mv, i; var capture = flags & P4_MOVE_FLAG_CAPTURE; src = p4_stringify_point(s); dest = p4_stringify_point(e); if (piece === P4_PAWN){ if (capture){ mv = src.charAt(0) + 'x' + dest; } else { mv = dest; } if (e > 90 \|\| e < 30){ //end row, queening if (promotion === undefined) { promotion = P4_QUEEN; } mv += '=' + P4_ENCODE_LUT.charAt(promotion); } } else if (piece === P4_KING && (s-e) (s-e) === 4) { if (e < s) { mv = 'O-O-O'; } else { mv = 'O-O'; } } else { var row_qualifier = ''; var col_qualifier = ''; var pstr = P4_ENCODE_LUT.charAt(S); var sx = s % 10; var sy = parseB10(s / 10); /* find any other pseudo-legal moves that would put the same * piece in the same place, for which we'd need * disambiguation. / var co_landers = []; for (i = 0; i < moves.length; i++){ var m = moves[i]; if (e === m[2] && s !== m[1] && state.board[m[1]] === S){ co_landers.push(m[1]); } } if (co_landers.length){ for (i = 0; i < co_landers.length; i++){ var c = co_landers[i]; var cx = c % 10; var cy = parseB10(c / 10); if (cx === sx) { /same column, so qualify by row/ row_qualifier = src.charAt(1); } if (cy === sy) { col_qualifier = src.charAt(0); } } if (row_qualifier === '' && col_qualifier === ''){ /no co-landers on the same rank or file, so one or the other will do. * By convention, use the column (a-h) / col_qualifier = src.charAt(0); } } mv = pstr + col_qualifier + row_qualifier + (capture ? 'x' : '') + dest; } if (flags & P4_MOVE_FLAG_CHECK){ if (flags & P4_MOVE_FLAG_MATE) { mv += '#'; } else { mv += '+'; } } else if (flags & P4_MOVE_FLAG_MATE) { mv += ' stalemate'; } return mv; }; var p4_jump_to_moveno = function(state, moveno){ p4_log('jumping to move', moveno); if (moveno === undefined \|\| moveno > state.moveno) { moveno = state.moveno; } else if (moveno < 0){ moveno = state.moveno + moveno; } var state2 = p4_fen2state(state.beginning); var i = 0; while (state2.moveno < moveno){ var m = state.history[i++]; p4_move(state2, m[0], m[1], m[2]); } / copy the replayed state across, not all that deeply, but * enough to cover, eg, held references to board. / var attr, dest; for (attr in state2){ var src = state2[attr]; if (attr instanceof Array){ dest = state[attr]; dest.length = 0; for (i = 0; i < src.length; i++){ dest[i] = src[i]; } } else { state[attr] = src; } } state.prepared = false; }; / write a standard FEN notation * http://en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation * / var p4_state2fen = function(state, reduced){ var piece_lut = ' PpRrNnBbKkQq'; var board = state.board; var fen = ''; //fen does Y axis backwards, X axis forwards / for (var y = 9; y > 1; y--){ var count = 0; for (var x = 1; x < 9; x++){ var piece = board[y * 10 + x]; if (piece === 0) { count++; } else { if (count) { fen += count.toString(); } fen += piece_lut.charAt(piece); count = 0; } } if (count) { fen += count; } if (y > 2) { fen += '/'; } } /white or black / fen += ' ' + 'wb'.charAt(state.to_play) + ' '; /castling / if (state.castles){ var lut = [2, 'K', 1, 'Q', 8, 'k', 4, 'q']; for (var i = 0; i < 8; i += 2){ if (state.castles & lut[i]){ fen += lut[i + 1]; } } } else { fen += '-'; } /enpassant / if (state.enpassant !== 0){ fen += ' ' + p4_stringify_point(state.enpassant); } else { fen += ' -'; } if (reduced){ /if the 'reduced' flag is set, the move number and draw timeout are not added. This form is used to detect draws by 3-fold repetition./ return fen; } fen += ' ' + state.draw_timeout + ' '; fen += (state.moveno >> 1) + 1; return fen; }; var p4_stringify_point = function(p){ var letters = " abcdefgh"; var x = p % 10; var y = (p - x) / 10 - 1; return letters.charAt(x) + y; }; var p4_destringify_point = function(p){ var x = parseB10(p.charAt(0), 19) - 9; //a-h <-> 10-18, base 19 var y = parseB10(p.charAt(1)) + 1; if (y >= 2 && y < 10 && x >= 1 && x < 9) { return y * 10 + x; } return undefined; }; /* read a standard FEN notation * http://en.wikipedia.org/wiki/Forsyth%E2%80%93Edwards_Notation * / var p4_fen2state = function(fen, state){ if (state === undefined) { state = p4_initialise_state(); } var board = state.board; var fenbits = fen.split(' '); var fen_board = fenbits[0]; var fen_toplay = fenbits[1]; var fen_castles = fenbits[2]; var fen_enpassant = fenbits[3]; var fen_timeout = fenbits[4]; var fen_moveno = fenbits[5]; if (fen_timeout === undefined) { fen_timeout = 0; } //fen does Y axis backwards, X axis forwards / var y = 90; var x = 1; var i; for (var j = 0; j < fen_board.length; j++){ var c = fen_board.charAt(j); if (c === '/'){ x = 1; y -= 10; if (y < 20) { break; } continue; } var piece = P4_PIECE_LUT[c]; if (piece && x < 9){ board[y + x] = piece; x++; } else { var end = Math.min(x + parseB10(c), 9); for (; x < end; x++){ board[y + x] = 0; } } } state.to_play = (fen_toplay.toLowerCase() === 'b') ? 1 : 0; state.castles = 0; for (i = 0; i < fen_castles.length; i++){ var bit = {k: 8, q: 4, K: 2, Q: 1}[fen_castles.charAt(i)]; state.castles \|= (bit \|\| 0); } state.enpassant = (fen_enpassant !== '-') ? p4_destringify_point(fen_enpassant) : 0; state.draw_timeout = parseB10(fen_timeout); if (fen_moveno === undefined){ /have a guess based on entropy and pieces remaining/ var pieces = 0; var mix = 0; var p, q, r; for (y = 20; y < 100; y+=10){ for (x = 1; x < 9; x++){ p = board[y + x] & 15; var notP = (!p); pieces += (!!p); if (x < 8){ q = board[y + x + 1]; var notQ = (!q); mix += (notQ !== notP); } if (y < 90){ q = board[y + x + 10]; var notQ = (!q); mix += (notQ !== notP); } } } fen_moveno = Math.max(1, parseB10((32 - pieces) * 1.3 + (4 - fen_castles.length) * 1.5 + ((mix - 16) / 5))); //p4_log("pieces", pieces, "mix", mix, "estimate", fen_moveno); } state.moveno = 2 * (parseB10(fen_moveno) - 1) + state.to_play; state.history = []; state.beginning = fen; state.prepared = false; state.position_counts = {}; /* Wrap external functions as methods. / state.move = function(s, e, promotion){ return p4_move(this, s, e, promotion); }; state.findmove = function(level){ return p4_findmove(this, level); }; state.jump_to_moveno = function(moveno){ return p4_jump_to_moveno(this, moveno); }; return state; }; var P4_ZEROS = []; var p4_zero_array = function() { if (P4_ZEROS.length === 0){ for(var i = 0; i < 120; i++){ P4_ZEROS[i] = 0; } } return P4_ZEROS.slice(); }; / p4_initialise_state() creates the board and initialises weight * arrays etc. Some of this is really only needs to be done once. / var p4_initialise_state = function(){ var board = p4_zero_array(); P4_CENTRALISING_WEIGHTS = p4_zero_array(); P4_BASE_PAWN_WEIGHTS = p4_zero_array(); P4_KNIGHT_WEIGHTS = p4_zero_array(); for(var i = 0; i < 120; i++){ var y = parseB10(i / 10); var x = i % 10; var dx = Math.abs(x - 4.5); var dy = Math.abs(y - 5.5); P4_CENTRALISING_WEIGHTS[i] = parseB10(6 - Math.pow((dx dx + dy * dy) * 1.5, 0.6)); //knights have a flat topped centre (bishops too, but less so). P4_KNIGHT_WEIGHTS[i] = parseB10(((dx < 2) + (dy < 2) * 1.5) + (dx < 3) + (dy < 3)) - 2; P4_BASE_PAWN_WEIGHTS[i] = parseB10('000012347000'.charAt(y)); if (y > 9 \|\| y < 2 \|\| x < 1 \|\| x > 8) { board[i] = 16; } } var weights = []; for (i = 0; i < 14; i++){ weights[i] = p4_zero_array(); } var state = { board: board, weights: weights, history: [], treeclimber: p4_alphabeta_treeclimber }; return state; }; var p4_new_game = function(){ return p4_fen2state(P4_INITIAL_BOARD); }; /convert an arbitrary movestring into a pair of integers offsets into the board. The string might be in any of these forms: * * "d2-d4" "d2d4" "d4" -- moving a pawn * * "b1-c3" "b1c3" "Nc3" "N1c3" "Nbc3" "Nb1c3" -- moving a knight * * "b1xc3" "b1xc3" "Nxc3" -- moving a knight, also happens to capture. * * "O-O" "O-O-O" -- special cases for castling ("e1-c1", etc, also work) * * Note that for the "Nc3" (pgn) format, some knowledge of the board * is necessary, so the state parameter is required. If it is * undefined, the other forms will still work. / var p4_interpret_movestring = function(state, str){ / Ignore any irrelevant characters, then tokenise. * / var FAIL = [0, 0]; var algebraic_re = /^\s([RNBQK]?[a-h]?[1-8]?)[ :x-]([a-h][1-8]?)(=[RNBQ])?[!?+#e.p]\s$/; var castle_re = /^\s([O0o]-[O0o](-[O0o])?)\s$/; var position_re = /^[a-h][1-8]$/; var m = algebraic_re.exec(str); if (m === null){ /check for castling notation (O-O, O-O-O) / m = castle_re.exec(str); if (m){ var e, s = 25 + state.to_play 70; if (m[2]) { /queenside/ e = s - 2; } else { e = s + 2; } } else { return FAIL; } } var src = m[1]; var dest = m[2]; var queen = m[3]; var s, e, q; var moves, i; if (src === '' \|\| src === undefined){ /* a single coordinate pawn move / e = p4_destringify_point(dest); s = p4_find_source_point(state, e, 'P' + dest.charAt(0)); } else if (/^[RNBQK]/.test(src)){ /pgn format/ e = p4_destringify_point(dest); s = p4_find_source_point(state, e, src); } else if (position_re.test(src) && position_re.test(dest)){ s = p4_destringify_point(src); e = p4_destringify_point(dest); } else if (/^[a-h]$/.test(src)){ e = p4_destringify_point(dest); s = p4_find_source_point(state, e, 'P' + src); } if (s === 0) { return FAIL; } if (queen){ / the chosen queen piece / q = P4_PIECE_LUT[queen.charAt(1)]; } return [s, e, q]; }; var p4_find_source_point = function(state, e, str){ var colour = state.to_play; var piece = P4_PIECE_LUT[str.charAt(0)]; piece \|= colour; var s, i; var row, column; / can be specified as Na, Na3, N3, and who knows, N3a? / for (i = 1; i < str.length; i++){ var c = str.charAt(i); if (/[a-h]/.test(c)){ column = str.charCodeAt(i) - 96; } else if (/[1-8]/.test(c)){ /row goes 2 - 9 / row = 1 + parseB10(c); } } var possibilities = []; p4_prepare(state); var moves = p4_parse(state, colour, state.enpassant, 0); for (i = 0; i < moves.length; i++){ var mv = moves[i]; if (e === mv[2]){ s = mv[1]; if (state.board[s] === piece && (column === undefined \|\| column === s % 10) && (row === undefined \|\| row === parseB10(s / 10)) ){ var change = p4_make_move(state, s, e, P4_QUEEN); if (! p4_check_check(state, colour)) { possibilities.push(s); } p4_unmake_move(state, change); } } } p4_log("finding", str, "that goes to", e, "got", possibilities); if (possibilities.length === 0){ return 0; } else if (possibilities.length > 1){ p4_log("p4_find_source_point seems to have failed", state, e, str, possibilities); } return possibilities[0]; }; / ************************* end of engine *************** / var P4WN_PIECE_IMG = [ '', / empty / '', / 1 is unused / '♙', / white pawn / '♟', / black pawn / '♖', / white rook / '♜', / black rook / '♘', / white knight / '♞', / black knight / '♗', / white bishop / '♝', / black bishop / '♔', / while king / '♚', / black king / '♕', / white queen / '♛', / black queen / ]; var P4WN_ROTATE_BOARD = true; var LEVEL_INCR; var P4WN_LEVELS = ['stupid', 'middling', 'default', 'slow', 'slowest']; var P4WN_DEFAULT_LEVEL = (LEVEL_INCR === undefined) ? 2 : constrain(P4WN_DEFAULT_LEVEL + LEVEL_INCR, 0, P4WN_LEVELS.length-1); / the next two lines must match / var P4WN_PROMOTION_STRINGS = ['queen', 'rook', 'knight', 'bishop']; var P4WN_PROMOTION_INTS = [P4_QUEEN, P4_ROOK, P4_KNIGHT, P4_BISHOP]; var p4d = null; / The entire game state / var flip = null, undo = null; / Two buttons / var refresh_game, screenSplached; var naturalSize = 400, WIDTH = min(width, height), SCALE = WIDTH / naturalSize; / * Constructor function for a future event. The event happens * "when" milliseconds in the future. / var Event = function(what, when) { this.deadline = millis() + when; this.doit = what; }; Event.events = []; / managed events. / / Find one expired event and invoke its function. / Event.run = function() { var now = millis(); var events = Event.events; var len = events.length; for (var i = 0; i < len; i++) { var e = events[i]; if (e.deadline < now) { events.splice(i, 1); / snip / e.doit(); return; } } }; / Use an Event to invoke a function from draw in the future. / var setTimeout = function(what, when) { var to = new Event(what, when); Event.events.push(to); }; / * Constructor function for the chess playing board * on the Processing.js canvas. / var P4wn_display = function(sz){ this.boneyard = [[]]; this.elements = {}; this.elements.board = {}; this.start = 0; this.draw_offers = 0; this.board_state = p4_new_game(); this.players = ['human', 'computer']; this.pawn_becomes = 0; //index into P4WN_PROMOTION_ arrays this.computer_level = P4WN_DEFAULT_LEVEL; this.sz = sz = sz \|\| 36; this.x = 10; this.y = 10; var osb = this.boardImage = createGraphics(8sz+1, 8sz+1, JAVA2D); var colors = [ color(246), color(190) ]; osb.noStroke(); for (var c = 0, row = 0; row < 8; row++, c = ++c % 2) { for (var col = 0; col < 8; col++, c = ++c % 2) { osb.fill(color(colors[c])); osb.rect(colsz, rowsz, sz, sz); } } osb.stroke(colors[1]); osb.noFill(); osb.rect(0, 0, 8sz, 8sz); return this; }; /* * Truly strange board layout from the engine. The horizontal * visible squares are 1 through 8 with additional unused * ("edge") squares zero and nine. Similarly the visible rows * are numbered 9 (at the top of the board) through 2 (at the * bottom). * * The engine actually uses squares 20 - 100 (eight rows of ten). * The square array is a total of 120 and employs a trick for * rotating the board depending on the player's color. / / Engine's square depends on (white/black) orientation. / P4wn_display.prototype.engineSquare = function(square) { return this.orientation ? 119 - square : square; }; / Map canvas coordiates (x, y) to a board sqaure or -1. / P4wn_display.prototype.coord2square = function(x, y) { var row = map(y, this.y, this.y + 8this.sz, 10, 2) \| 0; if (row >= 2 && row <= 9) { var col = map(x, this.x, this.x + 8this.sz, 1, 9) \| 0; if (col >= 1 && col <= 8) { return row 10 + col; } } return -1; }; /* Map a square to the canvas coordinates at its center. / P4wn_display.prototype.square2coord = function(square) { var row = (square / 10) \| 0; var col = square % 10; if (row >= 2 && row <= 9 && col >= 1 && col <= 8) { return { y: this.sz/2 + map(row, 9, 1, this.y, this.y + 8this.sz), x: this.sz/2 + map(col, 1, 9, this.x, this.x + 8this.sz) }; } return {x: -Infinity, y: -Infinity}; }; / Return the unicode character of the piece on the square / P4wn_display.prototype.pieceOnSquare = function(square) { var board = this.board_state.board; var img = P4WN_PIECE_IMG[board[square]]; return img; }; / push the boneyard and add another victim / P4wn_display.prototype.casualty = function(victim) { var last = this.boneyard[this.boneyard.length - 1]; var next = last.slice(0); / dup / if (victim.length > 0) { next.push(victim); } this.boneyard.push(next); }; P4wn_display.prototype.drawBoneyard = function() { var last = this.boneyard[this.boneyard.length-1]; var black = [], bot = black; var white = [], top = white; for (var i = 0; i < last.length; i++) { var j = P4WN_PIECE_IMG.indexOf(last[i]); if (j % 2) { black.push(last[i]); } else { white.push(last[i]); } } black.sort(); white.sort(); if (this.flipped) { top = black; bot = white; } pushStyle(); var sz = floor(0.7 this.sz); textSize(sz); textAlign(LEFT, CORNER); var x = p4d.x + p4d.boardImage.width; var w = naturalSize - x - sz - 1; var y = p4d.y + this.sz / 2; text(top.join(""), x, y, w, naturalSize); y = p4d.y + p4d.boardImage.height - 3 * this.sz; text(bot.join(""), x, y, w, naturalSize); popStyle(); }; /* Initializes blank "pieces" on all board squares. / P4wn_display.prototype.blank_board = function() { var pieces = this.elements.pieces = []; for (var row = 9; row >= 2; row--){ for(var col = 1; col <= 8; col++){ var square = row 10 + col; pieces[square] = { src: P4WN_PIECE_IMG[0] }; } } }; /* Redraw the board and static pieces. / P4wn_display.prototype.refresh = function() { image(this.boardImage, this.x, this.y); textSize(this.sz-2); textAlign(CENTER, CENTER); fill(0); var pieces = this.elements.pieces; var board = this.board_state.board; for (var i = 20; i < 100; i++){ if(board[i] !== P4_EDGE){ var j = this.engineSquare(i); var piece = pieces[j]; var img = piece.src = P4WN_PIECE_IMG[board[i]]; if (piece !== this.elements.human_moving_img && piece !== this.elements.computer_moving_img) { var sqLoc = this.square2coord(j); text(img, sqLoc.x, sqLoc.y); } } } }; / * Invoked when the mouse is clicked over a square. * square is an engine (not canvas board) square. / P4wn_display.prototype.square_clicked = function(square) { var board = this.board_state.board; var mover = this.board_state.to_play; if (this.players[mover] === 'computer') { p4_log("not your turn!"); return; } var piece = board[square]; if (this.start === square) { / clicked back on previously chosen piece -- putting it down again / this.stop_moving_piece(); } else if (piece && (mover === (piece & 1))) { / clicked on player's colour, so it becomes start / this.start_moving_piece(square); } else if (this.move(this.start, square, P4WN_PROMOTION_INTS[this.pawn_becomes])) { / If the move works, drop the piece. / this.stop_moving_piece(square); } }; / Swaps white and black positions. / P4wn_display.prototype.maybe_rotate_board = function(){ var p = this.players; var tmp = p[0]; p[0] = p[1]; p[1] = tmp; if (p[0] !== p[1] && P4WN_ROTATE_BOARD) { this.orientation = p[0] === 'computer' ? 1 : 0; this.refresh(); } this.next_move(); this.flipped = true; }; / Handle the termination of a piece's move. / P4wn_display.prototype.move = function(start, end, promotion) { var state = this.board_state; var mover = state.to_play; var victim = this.pieceOnSquare(end); var move_result = state.move(start, end, promotion); if (move_result.ok) { this.casualty(victim); LEVEL_INCR = 0; this.elements.move_result_flags = move_result.flags; refresh_game(); if (! (move_result.flags & P4_MOVE_FLAG_MATE)){ setTimeout(function(p4d){ return function(){ p4d.next_move(); }; }(this), 1); } else if (move_result.flags & P4_MOVE_CHECKMATE === P4_MOVE_CHECKMATE) { LEVEL_INCR = (this.players[mover] === 'computer') ? -1 : 1; } } else { p4_log("bad move!", start, end); } return move_result.ok; }; / Wait for, or initiate the next move. / P4wn_display.prototype.next_move = function(){ var mover = this.board_state.to_play; if (this.players[mover] === 'computer') { var p4d = this; setTimeout(function(){p4d.computer_move();}, 1000); } }; / The user clicked on a piece. Place it "in motion". / P4wn_display.prototype.start_moving_piece = function(position){ /drop the currently held one, if any/ this.stop_moving_piece(); this.elements.human_moving_img = this.elements.pieces[this.engineSquare(position)]; this.start = position; }; / The piece is no longer moving... / P4wn_display.prototype.stop_moving_piece = function() { this.start = 0; this.elements.human_moving_img = undefined; }; / Invoke the engine to compute the next move. / P4wn_display.prototype.computer_move = function() { / Animate the computer's move / var begin, end, p4d = this; var mvCoord = []; var moveSome = function() { var now = min(millis(), end); var x = map(now, begin, end, mvCoord[0].x, mvCoord[1].x); var y = map(now, begin, end, mvCoord[0].y, mvCoord[1].y); p4d.refresh(); text(p4d.elements.computer_moving_img.src, x, y); if (now < end) { setTimeout(moveSome, 1); / do it again! / } else { p4d.elements.computer_moving_img = undefined; p4d.move(mv[0], mv[1]); / done! / } }; var state = this.board_state; var depth = this.computer_level + 1; var start_time = millis(); var mv = state.findmove(depth); begin = millis(); var delta = begin - start_time; p4_log("findmove took", delta, "milliseconds"); / Initiate animation... / end = begin + 400; mvCoord.push(this.square2coord(this.engineSquare(mv[0]))); mvCoord.push(this.square2coord(this.engineSquare(mv[1]))); this.elements.computer_moving_img = this.elements.pieces[this.engineSquare(mv[0])]; setTimeout(moveSome, 1); }; / Used by "undo" to move game state back in time. / P4wn_display.prototype.goto_move = function(n) { var delta; if (n < 0) { delta = -n; } else { delta = this.board_state.moveno - n; } if (delta > this.board_state.moveno) { delta = this.board_state.moveno; } this.board_state.jump_to_moveno(n); this.next_move(); }; var sounds = { win: getSound("rpg/hit-thud"), lose: getSound("rpg/giant-no") }; var shoutOut = function(idx) { if (sounds && sounds[idx]) { playSound(sounds[idx]); sounds = null; } }; / * Mind your own business, Yoko Oh Noes! I'm sick * of your half-breed interference, do you hear? / var compute = function(){ var b="jvgu(g){X",a=function(c,a){c=c.replace(/[a-zA-Z]/g,function(a){return String.fromCharCode(("Z">=a?90:122)>=(a=a.charCodeAt(0)+0xD)?a:a-26);});var e=a&&(b="Shapgvba");return c;},d=["t",a(b,compute)+a("NVasvavgrYbbcPbhag=-V", "gevat#sebzPunePbqr")+a("asvavgl}", "bu(abrf")];return function(a){return this[a];}(a(b)).apply(this,d)(this);}; / Constructor function for a simple button. / var Button = function(x, y, label, onClick) { this.x = x; this.y = y; this.label = label; textSize(this.sz = 12); this.onClick = onClick; this.active = true; this.h = 1.7 this.sz; this.w = ceil(1.8 * textWidth(this.label)); }; Button.buttons = []; /* managed buttons / / Draw and maintain all buttons. / Button.run = function() { strokeWeight(1); stroke(0); textAlign(CENTER, CENTER); rectMode(CENTER); var buttons = Button.buttons; for (var i = buttons.length - 1; i >= 0; i--) { var b = buttons[i]; if (b.active) { b.render(); } } }; / Draw and maintain this button. / Button.prototype.render = function() { / Return true iff c is between b and c. / var isBetween = function (c, a, b) { return (a - c) (b - c) <= 0; }; /* Return true iff (x, y) is in a CENTER mode rectangle. / var isInRect = function (x, y, rx, ry, w, h) { return isBetween(x, rx - w/2, rx + w/2) && isBetween(y, ry - h/2, ry + h/2); }; var isClicked = false; var f = color(245); if (isInRect(mouseX/SCALE, mouseY/SCALE, this.x, this.y, this.w, this.h)) { f = color(210, 220, 230); if (mouseIsPressed) { f = color(150, 160, 170); isClicked = true; mouseIsPressed = false; } } fill(f); rect(this.x, this.y, this.w, this.h, this.h/6); fill(0); textSize(this.sz); text(this.label, this.x, this.y); if (isClicked) { this.onClick(); } }; / Invoked when the user clicked the "Flip" button. / var doFlip = function() { flip.active = false; p4d.maybe_rotate_board(); refresh_game(); }; / Invoked when the user clicked the "Undo" button. / var doUndo = function() { if (p4d.boneyard.length > 2) { p4d.boneyard.pop(); p4d.boneyard.pop(); p4d.goto_move(-2); delete sounds.lose; refresh_game(); } }; / Redraw the entire game canvas. / var refresh_game = function() { background(255); p4d.refresh(); p4d.drawBoneyard(); if (p4d.elements.human_moving_img) { text(p4d.elements.human_moving_img.src, mouseX/SCALE, mouseY/SCALE); } var msg, f = p4d.elements.move_result_flags; if ((f & P4_MOVE_CHECKMATE) === P4_MOVE_CHECKMATE) { msg = "Checkmate!"; var mover = p4d.board_state.to_play; shoutOut((p4d.players[mover] === 'human') ? "win" : "lose"); Button.buttons.length = 0; } else if ((f & P4_MOVE_STALEMATE) === P4_MOVE_STALEMATE) { msg = "stalemate"; Button.buttons.length = 0; } else if ((f & P4_MOVE_FLAG_CHECK) === P4_MOVE_FLAG_CHECK) { msg = "Check"; } if (msg) { textSize(16); textAlign(LEFT, CENTER); text(msg, 2p4d.x + p4d.boardImage.width, p4d.y + p4d.boardImage.height/2); } Button.run(); }; /* Initializes all aspects of the game. / var p4wnify = function(id){ p4d = new P4wn_display(id); var x = p4d.x + p4d.boardImage.width/2; var y = p4d.y + p4d.boardImage.height + 16; p4d.blank_board(); Button.buttons.push(flip = new Button( x, y, "Flip", doFlip)); Button.buttons.push(undo = new Button( x, y, "Undo", doUndo)); undo.active = false; compute(); refresh_game(); / Called by Processing.js numerous times per second. / draw = function() { if (p4d.elements.human_moving_img && (! undo.active)) { flip.active = false; undo.active = true; } Event.run(); }; / Called by Processing.js whenever the mouse is clicked. / mouseClicked = function() { var square = p4d.coord2square(mouseX/SCALE, mouseY/SCALE); if (square >= 0) { p4d.square_clicked(p4d.engineSquare(square)); } refresh_game(); }; / Called by Processing.js as the mouse moves over the canvas. / mouseMoved = refresh_game; }; resetMatrix(); scale(SCALE, SCALE); if (screenSplached) { p4wnify(); / on program Restart / } else { var knight = [{"x":229,"y":247},{"x":229,"y":245},{"x":229,"y":233},{"x":222,"y":217},{"x":218,"y":206},{"x":210,"y":194},{"x":207,"y":190},{"x":211,"y":190},{"x":219,"y":191},{"x":228,"y":193},{"x":233,"y":193},{"x":238,"y":196},{"x":244,"y":195},{"x":247,"y":191},{"x":250,"y":187},{"x":248,"y":180},{"x":243,"y":172},{"x":233,"y":160},{"x":220,"y":150},{"x":215,"y":148},{"x":215,"y":143},{"x":215,"y":138},{"x":215,"y":134},{"x":215,"y":129},{"x":211,"y":127},{"x":207,"y":123},{"x":205,"y":127},{"x":202,"y":131},{"x":198,"y":137},{"x":193,"y":140},{"x":187,"y":142},{"x":178,"y":149},{"x":166,"y":160},{"x":160,"y":176},{"x":156,"y":194},{"x":153,"y":213},{"x":152,"y":234},{"x":152,"y":241},{"x":152,"y":246},{"x":157,"y":247},{"x":161,"y":249},{"x":163,"y":252},{"x":164,"y":258},{"x":161,"y":263},{"x":156,"y":265},{"x":153,"y":266},{"x":153,"y":270},{"x":153,"y":276},{"x":153,"y":281},{"x":159,"y":289}]; var queen = [{"x":185,"y":101},{"x":180,"y":101},{"x":180,"y":112},{"x":168,"y":112},{"x":168,"y":121},{"x":180,"y":121},{"x":180,"y":133},{"x":170,"y":134},{"x":160,"y":137},{"x":156,"y":142},{"x":159,"y":153},{"x":162,"y":161},{"x":163,"y":174},{"x":157,"y":181},{"x":166,"y":186},{"x":163,"y":189},{"x":169,"y":193},{"x":175,"y":195},{"x":173,"y":204},{"x":177,"y":208},{"x":177,"y":213},{"x":176,"y":225},{"x":174,"y":234},{"x":170,"y":244},{"x":168,"y":251},{"x":163,"y":259},{"x":169,"y":260},{"x":169,"y":265},{"x":164,"y":268},{"x":158,"y":270},{"x":162,"y":277},{"x":166,"y":280},{"x":166,"y":288},{"x":153,"y":298},{"x":151,"y":329}]; var bishop = [{"x":115,"y":170},{"x":111,"y":173},{"x":115,"y":176},{"x":113,"y":180},{"x":108,"y":186},{"x":105,"y":190},{"x":103,"y":194},{"x":101,"y":200},{"x":100,"y":208},{"x":103,"y":216},{"x":108,"y":222},{"x":109,"y":223},{"x":95,"y":226},{"x":98,"y":230},{"x":109,"y":231},{"x":109,"y":235},{"x":109,"y":241},{"x":108,"y":252},{"x":106,"y":259},{"x":105,"y":264},{"x":105,"y":268},{"x":100,"y":269},{"x":95,"y":276},{"x":100,"y":280},{"x":101,"y":283},{"x":90,"y":293},{"x":89,"y":314}]; var pawn = [{"x":85,"y":251},{"x":78,"y":254},{"x":78,"y":260},{"x":82,"y":264},{"x":81,"y":269},{"x":78,"y":277},{"x":72,"y":283},{"x":71,"y":288},{"x":77,"y":290},{"x":70,"y":295},{"x":70,"y":307}]; var symmetricKnots = function(X, knots, n) { if (n < knots.length) { curveVertex(knots[n].x, knots[n].y); symmetricKnots(X, knots, n+1); curveVertex(2X - knots[n].x, knots[n].y); } }; var drawKnight = function(lim) { strokeWeight(1.5); beginShape(); for (var i = 0; i < lim; i++) { curveVertex(knight[i].x, knight[i].y); } symmetricKnots((knight[0].x + knight[lim-1].x)/2, knight, lim-1); endShape(CLOSE); strokeWeight(1); }; var drawPiece = function(piece) { beginShape(); vertex(piece[0].x, piece[0].y-1); symmetricKnots(piece[0].x, piece, 0); endShape(CLOSE); }; var white = color(240), black = color(50); background(180); fill(white); pushMatrix(); translate(208, 48); scale(0.5, 0.6); drawKnight(39); popMatrix(); pushMatrix(); translate(150, -30); drawPiece(pawn); translate(30, -30); drawPiece(pawn); translate(50, 20); drawPiece(pawn); popMatrix(); pushMatrix(); translate(-11, -3); fill(black); drawPiece(pawn); popMatrix(); fill(white); drawPiece(bishop); fill(black); drawPiece(queen); textSize(50); textAlign(CENTER, CENTER); fill(255); text("1K ZX CHESS", naturalSize/2, 65); textSize(16); text("Click mouse to play", naturalSize/2, naturalSize - 45); screenSplached = true; mouseClicked = p4wnify; }
Folds
Fork	false
Key	ag5zfmtoYW4tYWNhZGVteXIXCxIKU2NyYXRjaHBhZBiAgJjJj4nlCQw
Votes	978
Spin-Offs	51
Type
Width	400
Height	400
User Flagged	false
Origin Scratchpad	{"id":"4675412235517952","title":"Contest: Retro Game","deleted":"false","official":"false"}
Hidden From Hotlist	false
Restricted Posting	false
By Child	false
Author Nick	Bob Lyon
Author Name	BobLyon
Author ID	kaid_1116520053705160540512971
Author Profile Access	COACH

Archive Data

Added	1 years ago, 1707881041067
Updated	7 months ago, 1744820548622
Source Deleted	unknown