mambax7 / chess

language/english/main.php

Spacing +205 added lines, -205 removed lines

@@ -18,287 +18,287 @@
 define('_MD_CHESS_DELETE_FORM', 'Delete challenge');
 
 // game type
-define('_MD_CHESS_LABEL_GAMETYPE',      'Game type');
+define('_MD_CHESS_LABEL_GAMETYPE', 'Game type');
 define('_MD_CHESS_LABEL_GAMETYPE_OPEN', 'Open challenge');
 define('_MD_CHESS_LABEL_GAMETYPE_USER', 'Individual challenge');
 define('_MD_CHESS_LABEL_GAMETYPE_SELF', 'Self-play');
-define('_MD_CHESS_MENU_GAMETYPE_OPEN',  _MD_CHESS_LABEL_GAMETYPE_OPEN . ' - anyone can accept your challenge');
-define('_MD_CHESS_MENU_GAMETYPE_USER',  _MD_CHESS_LABEL_GAMETYPE_USER . ' - only the specified user can accept your challenge');
-define('_MD_CHESS_MENU_GAMETYPE_SELF',  _MD_CHESS_LABEL_GAMETYPE_SELF . ' - play against yourself (for learning or testing)');
+define('_MD_CHESS_MENU_GAMETYPE_OPEN', _MD_CHESS_LABEL_GAMETYPE_OPEN.' - anyone can accept your challenge');
+define('_MD_CHESS_MENU_GAMETYPE_USER', _MD_CHESS_LABEL_GAMETYPE_USER.' - only the specified user can accept your challenge');
+define('_MD_CHESS_MENU_GAMETYPE_SELF', _MD_CHESS_LABEL_GAMETYPE_SELF.' - play against yourself (for learning or testing)');
 
 // opponent
 define('_MD_CHESS_LABEL_OPPONENT', 'Opponent');
 
 // FEN setup
-define('_MD_CHESS_LABEL_FEN_SETUP',   'FEN setup');
+define('_MD_CHESS_LABEL_FEN_SETUP', 'FEN setup');
 define('_MD_CHESS_LABEL_FEN_EXPLAIN', 'You may optionally provide a board setup position, using FEN (Forsyth-Edwards Notation).  If omitted, the standard board setup will be used.');
 
 // color preference
-define('_MD_CHESS_LABEL_COLOR',          'My color will be');
+define('_MD_CHESS_LABEL_COLOR', 'My color will be');
 define('_MD_CHESS_RADIO_COLOR_OPPONENT', 'Assigned by my opponent');
-define('_MD_CHESS_RADIO_COLOR_RANDOM',   'Assigned randomly');
-define('_MD_CHESS_RADIO_COLOR_WHITE',    'White');
-define('_MD_CHESS_RADIO_COLOR_BLACK',    'Black');
+define('_MD_CHESS_RADIO_COLOR_RANDOM', 'Assigned randomly');
+define('_MD_CHESS_RADIO_COLOR_WHITE', 'White');
+define('_MD_CHESS_RADIO_COLOR_BLACK', 'Black');
 
 // notifications
 define('_MD_CHESS_NEVT_ACPT_CHAL_CAP', 'Notify me when someone accepts my challenge to a game.');
-define('_MD_CHESS_NEVT_MOVE_CAP',      'Notify me when a new move is made in this game.');
+define('_MD_CHESS_NEVT_MOVE_CAP', 'Notify me when a new move is made in this game.');
 
 // buttons
-define('_MD_CHESS_CREATE_SUBMIT',  'Submit');
-define('_MD_CHESS_CREATE_ACCEPT',  'Accept');
-define('_MD_CHESS_CREATE_CANCEL',  'Cancel');
-define('_MD_CHESS_CREATE_DELETE',  'Delete');
+define('_MD_CHESS_CREATE_SUBMIT', 'Submit');
+define('_MD_CHESS_CREATE_ACCEPT', 'Accept');
+define('_MD_CHESS_CREATE_CANCEL', 'Cancel');
+define('_MD_CHESS_CREATE_DELETE', 'Delete');
 define('_MD_CHESS_CONFIRM_DELETE', 'Yes, I am sure I want to delete this');
 
 // errors
-define('_MD_CHESS_ERROR',             'Error');
-define('_MD_CHESS_GAMETYPE_INVALID',  'Game type not valid');
-define('_MD_CHESS_FEN_INVALID',       'FEN setup not valid');
-define('_MD_CHESS_OPPONENT_MISSING',  'You must specify the username of your opponent.');
-define('_MD_CHESS_OPPONENT_INVALID',  'That opponent is unknown or not available for game play.');
-define('_MD_CHESS_OPPONENT_SELF',     'You cannot challenge yourself.');
-define('_MD_CHESS_GAME_NOT_FOUND',    'Game not found.');
-define('_MD_CHESS_GAME_DELETED',      'Game deleted');
-define('_MD_CHESS_WRONG_PLAYER2',     'You may not accept a challenge offered to another user.');
-define('_MD_CHESS_SAME_PLAYER2',      'You may not accept a challenge from yourself.');
+define('_MD_CHESS_ERROR', 'Error');
+define('_MD_CHESS_GAMETYPE_INVALID', 'Game type not valid');
+define('_MD_CHESS_FEN_INVALID', 'FEN setup not valid');
+define('_MD_CHESS_OPPONENT_MISSING', 'You must specify the username of your opponent.');
+define('_MD_CHESS_OPPONENT_INVALID', 'That opponent is unknown or not available for game play.');
+define('_MD_CHESS_OPPONENT_SELF', 'You cannot challenge yourself.');
+define('_MD_CHESS_GAME_NOT_FOUND', 'Game not found.');
+define('_MD_CHESS_GAME_DELETED', 'Game deleted');
+define('_MD_CHESS_WRONG_PLAYER2', 'You may not accept a challenge offered to another user.');
+define('_MD_CHESS_SAME_PLAYER2', 'You may not accept a challenge from yourself.');
 define('_MD_CHESS_NO_CONFIRM_DELETE', 'You must check the confirmation box');
-define('_MD_CHESS_NO_JAVASCRIPT',     'Javascript not enabled. Moves must be made by text entry.');
-define('_MD_CHESS_MODHEAD_MISSING',   'WARNING: <{$xoops_module_header}> missing from themes/%s/theme.html.');
-define('_MD_CHESS_TOKEN_ERROR',       'Token missing or invalid.');
+define('_MD_CHESS_NO_JAVASCRIPT', 'Javascript not enabled. Moves must be made by text entry.');
+define('_MD_CHESS_MODHEAD_MISSING', 'WARNING: <{$xoops_module_header}> missing from themes/%s/theme.html.');
+define('_MD_CHESS_TOKEN_ERROR', 'Token missing or invalid.');
 
 // templates
-define('_MD_CHESS_LABEL_GAMES',         'Games');
-define('_MD_CHESS_LABEL_NO_GAMES',      'No games');
-define('_MD_CHESS_LABEL_GAME',          'Game');
-define('_MD_CHESS_LABEL_CREATED',       'Created');
-define('_MD_CHESS_LABEL_LAST_MOVE',     'Last move');
-define('_MD_CHESS_LABEL_STATUS',        'Status');
-define('_MD_CHESS_LABEL_VS',            'vs.');
-define('_MD_CHESS_LABEL_DRAW',          'Draw');
-define('_MD_CHESS_LABEL_WHITE_WON',     'White won');
-define('_MD_CHESS_LABEL_BLACK_WON',     'Black won');
-define('_MD_CHESS_LABEL_WHITE',         'White');
-define('_MD_CHESS_LABEL_BLACK',         'Black');
-define('_MD_CHESS_LABEL_TO_MOVE',       'to move');
+define('_MD_CHESS_LABEL_GAMES', 'Games');
+define('_MD_CHESS_LABEL_NO_GAMES', 'No games');
+define('_MD_CHESS_LABEL_GAME', 'Game');
+define('_MD_CHESS_LABEL_CREATED', 'Created');
+define('_MD_CHESS_LABEL_LAST_MOVE', 'Last move');
+define('_MD_CHESS_LABEL_STATUS', 'Status');
+define('_MD_CHESS_LABEL_VS', 'vs.');
+define('_MD_CHESS_LABEL_DRAW', 'Draw');
+define('_MD_CHESS_LABEL_WHITE_WON', 'White won');
+define('_MD_CHESS_LABEL_BLACK_WON', 'Black won');
+define('_MD_CHESS_LABEL_WHITE', 'White');
+define('_MD_CHESS_LABEL_BLACK', 'Black');
+define('_MD_CHESS_LABEL_TO_MOVE', 'to move');
 define('_MD_CHESS_LABEL_WHITE_TO_MOVE', 'White to move');
 define('_MD_CHESS_LABEL_BLACK_TO_MOVE', 'Black to move');
-define('_MD_CHESS_LABEL_CHALLENGES',    'Challenges');
+define('_MD_CHESS_LABEL_CHALLENGES', 'Challenges');
 define('_MD_CHESS_LABEL_NO_CHALLENGES', 'No challenges');
-define('_MD_CHESS_LABEL_TYPE',          'Type');
-define('_MD_CHESS_LABEL_CHALLENGER',    'Challenger');
-define('_MD_CHESS_LABEL_COLOR_OPTION',  'Color Option');
-define('_MD_CHESS_LABEL_GAME_OVER',     'Game over, score');
-define('_MD_CHESS_PGN_FULL',            'Portable Game Notation');
-define('_MD_CHESS_PGN_ABBREV',          'PGN');
-define('_MD_CHESS_FEN_FULL',            'Forsyth-Edwards Notation');
-define('_MD_CHESS_FEN_ABBREV',          'FEN');
-define('_MD_CHESS_LABEL_ERROR',         '*error*');
-define('_MD_CHESS_PROMOTE_TO',          'Promote pawn to');
-
-define('_MD_CHESS_ALT_EMPTY',   'empty square');
-define('_MD_CHESS_ALT_WKING',   'white king');
-define('_MD_CHESS_ALT_WQUEEN',  'white queen');
-define('_MD_CHESS_ALT_WROOK',   'white rook');
+define('_MD_CHESS_LABEL_TYPE', 'Type');
+define('_MD_CHESS_LABEL_CHALLENGER', 'Challenger');
+define('_MD_CHESS_LABEL_COLOR_OPTION', 'Color Option');
+define('_MD_CHESS_LABEL_GAME_OVER', 'Game over, score');
+define('_MD_CHESS_PGN_FULL', 'Portable Game Notation');
+define('_MD_CHESS_PGN_ABBREV', 'PGN');
+define('_MD_CHESS_FEN_FULL', 'Forsyth-Edwards Notation');
+define('_MD_CHESS_FEN_ABBREV', 'FEN');
+define('_MD_CHESS_LABEL_ERROR', '*error*');
+define('_MD_CHESS_PROMOTE_TO', 'Promote pawn to');
+
+define('_MD_CHESS_ALT_EMPTY', 'empty square');
+define('_MD_CHESS_ALT_WKING', 'white king');
+define('_MD_CHESS_ALT_WQUEEN', 'white queen');
+define('_MD_CHESS_ALT_WROOK', 'white rook');
 define('_MD_CHESS_ALT_WBISHOP', 'white bishop');
 define('_MD_CHESS_ALT_WKNIGHT', 'white knight');
-define('_MD_CHESS_ALT_WPAWN',   'white pawn');
-define('_MD_CHESS_ALT_BKING',   'black king');
-define('_MD_CHESS_ALT_BQUEEN',  'black queen');
-define('_MD_CHESS_ALT_BROOK',   'black rook');
+define('_MD_CHESS_ALT_WPAWN', 'white pawn');
+define('_MD_CHESS_ALT_BKING', 'black king');
+define('_MD_CHESS_ALT_BQUEEN', 'black queen');
+define('_MD_CHESS_ALT_BROOK', 'black rook');
 define('_MD_CHESS_ALT_BBISHOP', 'black bishop');
 define('_MD_CHESS_ALT_BKNIGHT', 'black knight');
-define('_MD_CHESS_ALT_BPAWN',   'black pawn');
+define('_MD_CHESS_ALT_BPAWN', 'black pawn');
 
-define('_MD_CHESS_CONFIRM',     'Confirm');
+define('_MD_CHESS_CONFIRM', 'Confirm');
 
 define('_MD_CHESS_BUTTON_MOVE', 'Submit');
 
-define('_MD_CHESS_NORMAL_MOVE',        'Normal move');
-define('_MD_CHESS_RESIGN',             'Resign');
-define('_MD_CHESS_OFFER_DRAW',         'Offer draw');
-define('_MD_CHESS_ACCEPT_DRAW',        'Accept draw');
-define('_MD_CHESS_REJECT_DRAW',        'Reject draw');
-define('_MD_CHESS_CLAIM_DRAW_50',      'Claim draw (50-move rule)');
-define('_MD_CHESS_CLAIM_DRAW_3',       'Claim draw (threefold repetition)');
-define('_MD_CHESS_RESTART',            'Restart game');
-define('_MD_CHESS_DELETE',             'Delete game');
-define('_MD_CHESS_WANT_ARBITRATION',   'Request arbitration');
-define('_MD_CHESS_MOVE_EXPLAIN',       'Please state reason.');
-define('_MD_CHESS_AFTER_MOVE',         'after move');
+define('_MD_CHESS_NORMAL_MOVE', 'Normal move');
+define('_MD_CHESS_RESIGN', 'Resign');
+define('_MD_CHESS_OFFER_DRAW', 'Offer draw');
+define('_MD_CHESS_ACCEPT_DRAW', 'Accept draw');
+define('_MD_CHESS_REJECT_DRAW', 'Reject draw');
+define('_MD_CHESS_CLAIM_DRAW_50', 'Claim draw (50-move rule)');
+define('_MD_CHESS_CLAIM_DRAW_3', 'Claim draw (threefold repetition)');
+define('_MD_CHESS_RESTART', 'Restart game');
+define('_MD_CHESS_DELETE', 'Delete game');
+define('_MD_CHESS_WANT_ARBITRATION', 'Request arbitration');
+define('_MD_CHESS_MOVE_EXPLAIN', 'Please state reason.');
+define('_MD_CHESS_AFTER_MOVE', 'after move');
 
 define('_MD_CHESS_DELETE_WARNING', 'This will permanently remove the game from the database!');
 
 define('_MD_CHESS_BUTTON_REFRESH', 'Refresh');
 
 define('_MD_CHESS_ORIENTATION_ACTIVE', 'Active color at bottom');
-define('_MD_CHESS_ORIENTATION_WHITE',  'White at bottom');
-define('_MD_CHESS_ORIENTATION_BLACK',  'Black at bottom');
-
-define('_MD_CHESS_ARBITER_CONTROLS',  'Arbiter Controls');
-define('_MD_CHESS_ARBITER_SUSPEND',   'Suspend play');
-define('_MD_CHESS_ARBITER_RESUME',    'Resume normal play');
-define('_MD_CHESS_ARBITER_DRAW',      'Declare draw');
-define('_MD_CHESS_ARBITER_EXPLAIN',   'Please state reason.');
-define('_MD_CHESS_ARBITER_DELETE',    'Delete game');
-define('_MD_CHESS_ARBITER_NOACTION',  'No action');
-define('_MD_CHESS_ARBITER_SHOWCTRL',  'Show arbiter controls');
+define('_MD_CHESS_ORIENTATION_WHITE', 'White at bottom');
+define('_MD_CHESS_ORIENTATION_BLACK', 'Black at bottom');
+
+define('_MD_CHESS_ARBITER_CONTROLS', 'Arbiter Controls');
+define('_MD_CHESS_ARBITER_SUSPEND', 'Suspend play');
+define('_MD_CHESS_ARBITER_RESUME', 'Resume normal play');
+define('_MD_CHESS_ARBITER_DRAW', 'Declare draw');
+define('_MD_CHESS_ARBITER_EXPLAIN', 'Please state reason.');
+define('_MD_CHESS_ARBITER_DELETE', 'Delete game');
+define('_MD_CHESS_ARBITER_NOACTION', 'No action');
+define('_MD_CHESS_ARBITER_SHOWCTRL', 'Show arbiter controls');
 
 define('_MD_CHESS_ARBITER_DELETE_WARNING', 'This will permanently remove the game from the database!');
 
 define('_MD_CHESS_BUTTON_ARBITRATE', 'Submit');
 
-define('_MD_CHESS_WHEN_SUSPENDED',    'When suspended');
-define('_MD_CHESS_SUSPENDED_BY',      'Suspended by');
-define('_MD_CHESS_SUSPENSION_TYPE',   'Suspension type');
+define('_MD_CHESS_WHEN_SUSPENDED', 'When suspended');
+define('_MD_CHESS_SUSPENDED_BY', 'Suspended by');
+define('_MD_CHESS_SUSPENSION_TYPE', 'Suspension type');
 define('_MD_CHESS_SUSPENSION_REASON', 'Suspension reason');
-define('_MD_CHESS_UNKNOWN',           '*unknown*');
+define('_MD_CHESS_UNKNOWN', '*unknown*');
 define('_MD_CHESS_SUSP_TYPE_ARBITER', 'Suspended by arbiter');
-define('_MD_CHESS_SUSP_TYPE_PLAYER',  'Arbitration requested');
+define('_MD_CHESS_SUSP_TYPE_PLAYER', 'Arbitration requested');
 
-define('_MD_CHESS_MOVE_ENTRY',      'Move Entry');
-define('_MD_CHESS_MOVE_LIST',       'Move List');
-define('_MD_CHESS_EXPORT_FORMATS',  'Export');
+define('_MD_CHESS_MOVE_ENTRY', 'Move Entry');
+define('_MD_CHESS_MOVE_LIST', 'Move List');
+define('_MD_CHESS_EXPORT_FORMATS', 'Export');
 define('_MD_CHESS_CAPTURED_PIECES', 'Captured Pieces');
 
 // Notifications
-define('_MD_CHESS_WHITE',          'White');
-define('_MD_CHESS_BLACK',          'Black');
-define('_MD_CHESS_RESIGNED',       'resigned.');
-define('_MD_CHESS_OFFERED_DRAW',   'offered a draw.');
-define('_MD_CHESS_ACCEPTED_DRAW',  'accepted a draw offer.');
-define('_MD_CHESS_REJECTED_DRAW',  'rejected a draw offer.');
-define('_MD_CHESS_RQSTED_ARBT',    'requested arbitration.');
+define('_MD_CHESS_WHITE', 'White');
+define('_MD_CHESS_BLACK', 'Black');
+define('_MD_CHESS_RESIGNED', 'resigned.');
+define('_MD_CHESS_OFFERED_DRAW', 'offered a draw.');
+define('_MD_CHESS_ACCEPTED_DRAW', 'accepted a draw offer.');
+define('_MD_CHESS_REJECTED_DRAW', 'rejected a draw offer.');
+define('_MD_CHESS_RQSTED_ARBT', 'requested arbitration.');
 define('_MD_CHESS_BEEN_SUSPENDED', 'Game suspended pending review by an arbiter.');
-define('_MD_CHESS_AS_ARBITER',     'acting as arbiter');
-define('_MD_CHESS_RESUMED_PLAY',   'resumed normal play.');
-define('_MD_CHESS_DECLARED_DRAW',  'declared a draw.');
-define('_MD_CHESS_DELETED_GAME',   'deleted the game.');
+define('_MD_CHESS_AS_ARBITER', 'acting as arbiter');
+define('_MD_CHESS_RESUMED_PLAY', 'resumed normal play.');
+define('_MD_CHESS_DECLARED_DRAW', 'declared a draw.');
+define('_MD_CHESS_DELETED_GAME', 'deleted the game.');
 define('_MD_CHESS_SUSPENDED_PLAY', '$username (acting as arbiter) suspended play.');
 
 // FEN setup errors
-define('_MD_CHESS_FENBAD_LENGTH',          'invalid length');
-define('_MD_CHESS_FENBAD_FIELD_COUNT',     'wrong number of fields');
-define('_MD_CHESS_FENBAD_PP_INVALID',      'piece placement invalid');
-define('_MD_CHESS_FENBAD_AC_INVALID',      'active color invalid');
-define('_MD_CHESS_FENBAD_CA_INVALID',      'castling availability invalid');
-define('_MD_CHESS_FENBAD_EP_INVALID',      'en passant target_square invalid');
-define('_MD_CHESS_FENBAD_HC_INVALID',      'halfmove clock invalid');
-define('_MD_CHESS_FENBAD_FN_INVALID',      'fullmove number invalid');
-define('_MD_CHESS_FENBAD_MATERIAL',        'insufficient mating material');
-define('_MD_CHESS_FENBAD_IN_CHECK',        'player to move cannot have opponent in check');
+define('_MD_CHESS_FENBAD_LENGTH', 'invalid length');
+define('_MD_CHESS_FENBAD_FIELD_COUNT', 'wrong number of fields');
+define('_MD_CHESS_FENBAD_PP_INVALID', 'piece placement invalid');
+define('_MD_CHESS_FENBAD_AC_INVALID', 'active color invalid');
+define('_MD_CHESS_FENBAD_CA_INVALID', 'castling availability invalid');
+define('_MD_CHESS_FENBAD_EP_INVALID', 'en passant target_square invalid');
+define('_MD_CHESS_FENBAD_HC_INVALID', 'halfmove clock invalid');
+define('_MD_CHESS_FENBAD_FN_INVALID', 'fullmove number invalid');
+define('_MD_CHESS_FENBAD_MATERIAL', 'insufficient mating material');
+define('_MD_CHESS_FENBAD_IN_CHECK', 'player to move cannot have opponent in check');
 define('_MD_CHESS_FENBAD_CA_INCONSISTENT', 'castling availability inconsistent with piece placement');
-define('_MD_CHESS_FENBAD_EP_COLOR',        'en passant target square wrong color');
-define('_MD_CHESS_FENBAD_EP_NO_PAWN',      'en passant target square for nonexistent pawn');
+define('_MD_CHESS_FENBAD_EP_COLOR', 'en passant target square wrong color');
+define('_MD_CHESS_FENBAD_EP_NO_PAWN', 'en passant target square for nonexistent pawn');
 
 // Move-messages
 // Some of these messages are processed with eval() in ChessGame::move_msg(), and may contain parameters $param[1], $param[2], etc.
-define('_MD_CHESS_MOVE_UNKNOWN',           'ERROR (autocomplete): format is totally unknown!');
-define('_MD_CHESS_MOVE_PAWN_MAY_BECOME',   'ERROR (autocomplete): A pawn may only become either a knight, a bishop, a rook or a queen!');
-define('_MD_CHESS_MOVE_USE_X',             'ERROR (autocomplete): use x to indicate an attack');
-define('_MD_CHESS_MOVE_COORD_INVALID',     'ERROR (autocomplete): coordinate {$param[1]} is invalid');
-define('_MD_CHESS_MOVE_CANNOT_FIND_PAWN',  'ERROR (autocomplete): cannot find {$param[1]} pawn in column {$param[2]}');
-define('_MD_CHESS_MOVE_USE_NOTATION',      'ERROR (autocomplete): please use denotation [a-h]x[a-h][1-8] for pawn attacks (see help for more information)');
-define('_MD_CHESS_MOVE_NO_PAWN',           'ERROR (autocomplete): there is no pawn in column {$param[1]}');
-define('_MD_CHESS_MOVE_TWO_PAWNS',         'ERROR (autocomplete): there is more than one pawn in column {$param[1]}');
-define('_MD_CHESS_MOVE_NO_FIGURE',         'ERROR (autocomplete): there is no figure {$param[1]} = {$param[2]}');
+define('_MD_CHESS_MOVE_UNKNOWN', 'ERROR (autocomplete): format is totally unknown!');
+define('_MD_CHESS_MOVE_PAWN_MAY_BECOME', 'ERROR (autocomplete): A pawn may only become either a knight, a bishop, a rook or a queen!');
+define('_MD_CHESS_MOVE_USE_X', 'ERROR (autocomplete): use x to indicate an attack');
+define('_MD_CHESS_MOVE_COORD_INVALID', 'ERROR (autocomplete): coordinate {$param[1]} is invalid');
+define('_MD_CHESS_MOVE_CANNOT_FIND_PAWN', 'ERROR (autocomplete): cannot find {$param[1]} pawn in column {$param[2]}');
+define('_MD_CHESS_MOVE_USE_NOTATION', 'ERROR (autocomplete): please use denotation [a-h]x[a-h][1-8] for pawn attacks (see help for more information)');
+define('_MD_CHESS_MOVE_NO_PAWN', 'ERROR (autocomplete): there is no pawn in column {$param[1]}');
+define('_MD_CHESS_MOVE_TWO_PAWNS', 'ERROR (autocomplete): there is more than one pawn in column {$param[1]}');
+define('_MD_CHESS_MOVE_NO_FIGURE', 'ERROR (autocomplete): there is no figure {$param[1]} = {$param[2]}');
 define('_MD_CHESS_MOVE_NEITHER_CAN_REACH', 'ERROR (autocomplete): neither of the {$param[1]} = {$param[2]} can reach {$param[3]}');
-define('_MD_CHESS_MOVE_BOTH_CAN_REACH',    'ERROR (autocomplete): both of the {$param[1]} = {$param[2]} can reach {$param[3]}');
-define('_MD_CHESS_MOVE_AMBIGUOUS',         'ERROR (autocomplete): ambiguity is not properly resolved');
-define('_MD_CHESS_MOVE_UNDEFINED',         'ERROR: undefined');
-define('_MD_CHESS_MOVE_GAME_OVER',         'ERROR: This game is over. It is not possible to enter any further moves.');
-define('_MD_CHESS_MOVE_NO_CASTLE',         'ERROR: You cannot castle.');
-define('_MD_CHESS_MOVE_INVALID_PIECE',     'ERROR: only N (knight), B (bishop), R (rook) and Q (queen) are valid chessman identifiers');
-define('_MD_CHESS_MOVE_UNKNOWN_FIGURE',    'ERROR: Figure {$param[1]} is unknown!');
-define('_MD_CHESS_MOVE_TILE_EMPTY',        'ERROR: Tile {$param[1]} is empty');
-define('_MD_CHESS_MOVE_NOT_YOUR_PIECE',    'ERROR: Figure does not belong to you!');
-define('_MD_CHESS_MOVE_NOEXIST_FIGURE',    'ERROR: Figure does not exist!');
-define('_MD_CHESS_MOVE_START_END_SAME',    'ERROR: Current position and destination are equal!');
-define('_MD_CHESS_MOVE_UNKNOWN_ACTION',    'ERROR: {$param[1]} is unknown! Please use "-" for a move and "x" for an attack.');
-define('_MD_CHESS_MOVE_OUT_OF_RANGE',      'ERROR: Tile {$param[1]} is out of range for {$param[2]} at {$param[3]}!');
-define('_MD_CHESS_MOVE_OCCUPIED',          'ERROR: Tile {$param[1]} is occupied. You cannot move there.');
-define('_MD_CHESS_MOVE_NO_EN_PASSANT'  ,   'ERROR: en-passant not possible!');
-define('_MD_CHESS_MOVE_ATTACK_EMPTY',      'ERROR: Tile {$param[1]} is empty. You cannot attack it."');
-define('_MD_CHESS_MOVE_ATTACK_SELF',       'ERROR: You cannot attack own unit at {$param[1]}.');
-define('_MD_CHESS_MOVE_IN_CHECK',          'ERROR: Move is invalid because king would be under attack then.');
-define('_MD_CHESS_MOVE_CASTLED_SHORT',     'You castled short.');
-define('_MD_CHESS_MOVE_CASTLED_LONG',      'You castled long.');
-define('_MD_CHESS_MOVE_MOVED',             '{$param[1]} moved from {$param[2]} to {$param[3]}');
-define('_MD_CHESS_MOVE_CAPTURED',          '{$param[1]} captured {$param[2]} from {$param[3]}');
-define('_MD_CHESS_MOVE_PROMOTED',          'and became a {$param[1]}!');
-define('_MD_CHESS_MOVE_CHECKMATE',         'checkmate!');
-define('_MD_CHESS_MOVE_STALEMATE',         'stalemate!');
-define('_MD_CHESS_MOVE_MATERIAL',          'insufficient mating material!');
-define('_MD_CHESS_MOVE_KING',              'king');
-define('_MD_CHESS_MOVE_QUEEN',             'queen');
-define('_MD_CHESS_MOVE_ROOK',              'rook');
-define('_MD_CHESS_MOVE_BISHOP',            'bishop');
-define('_MD_CHESS_MOVE_KNIGHT',            'knight');
-define('_MD_CHESS_MOVE_PAWN',              'pawn');
-define('_MD_CHESS_MOVE_EMPTY',             'empty');
+define('_MD_CHESS_MOVE_BOTH_CAN_REACH', 'ERROR (autocomplete): both of the {$param[1]} = {$param[2]} can reach {$param[3]}');
+define('_MD_CHESS_MOVE_AMBIGUOUS', 'ERROR (autocomplete): ambiguity is not properly resolved');
+define('_MD_CHESS_MOVE_UNDEFINED', 'ERROR: undefined');
+define('_MD_CHESS_MOVE_GAME_OVER', 'ERROR: This game is over. It is not possible to enter any further moves.');
+define('_MD_CHESS_MOVE_NO_CASTLE', 'ERROR: You cannot castle.');
+define('_MD_CHESS_MOVE_INVALID_PIECE', 'ERROR: only N (knight), B (bishop), R (rook) and Q (queen) are valid chessman identifiers');
+define('_MD_CHESS_MOVE_UNKNOWN_FIGURE', 'ERROR: Figure {$param[1]} is unknown!');
+define('_MD_CHESS_MOVE_TILE_EMPTY', 'ERROR: Tile {$param[1]} is empty');
+define('_MD_CHESS_MOVE_NOT_YOUR_PIECE', 'ERROR: Figure does not belong to you!');
+define('_MD_CHESS_MOVE_NOEXIST_FIGURE', 'ERROR: Figure does not exist!');
+define('_MD_CHESS_MOVE_START_END_SAME', 'ERROR: Current position and destination are equal!');
+define('_MD_CHESS_MOVE_UNKNOWN_ACTION', 'ERROR: {$param[1]} is unknown! Please use "-" for a move and "x" for an attack.');
+define('_MD_CHESS_MOVE_OUT_OF_RANGE', 'ERROR: Tile {$param[1]} is out of range for {$param[2]} at {$param[3]}!');
+define('_MD_CHESS_MOVE_OCCUPIED', 'ERROR: Tile {$param[1]} is occupied. You cannot move there.');
+define('_MD_CHESS_MOVE_NO_EN_PASSANT', 'ERROR: en-passant not possible!');
+define('_MD_CHESS_MOVE_ATTACK_EMPTY', 'ERROR: Tile {$param[1]} is empty. You cannot attack it."');
+define('_MD_CHESS_MOVE_ATTACK_SELF', 'ERROR: You cannot attack own unit at {$param[1]}.');
+define('_MD_CHESS_MOVE_IN_CHECK', 'ERROR: Move is invalid because king would be under attack then.');
+define('_MD_CHESS_MOVE_CASTLED_SHORT', 'You castled short.');
+define('_MD_CHESS_MOVE_CASTLED_LONG', 'You castled long.');
+define('_MD_CHESS_MOVE_MOVED', '{$param[1]} moved from {$param[2]} to {$param[3]}');
+define('_MD_CHESS_MOVE_CAPTURED', '{$param[1]} captured {$param[2]} from {$param[3]}');
+define('_MD_CHESS_MOVE_PROMOTED', 'and became a {$param[1]}!');
+define('_MD_CHESS_MOVE_CHECKMATE', 'checkmate!');
+define('_MD_CHESS_MOVE_STALEMATE', 'stalemate!');
+define('_MD_CHESS_MOVE_MATERIAL', 'insufficient mating material!');
+define('_MD_CHESS_MOVE_KING', 'king');
+define('_MD_CHESS_MOVE_QUEEN', 'queen');
+define('_MD_CHESS_MOVE_ROOK', 'rook');
+define('_MD_CHESS_MOVE_BISHOP', 'bishop');
+define('_MD_CHESS_MOVE_KNIGHT', 'knight');
+define('_MD_CHESS_MOVE_PAWN', 'pawn');
+define('_MD_CHESS_MOVE_EMPTY', 'empty');
 
 // miscellaneous
-define('_MD_CHESS_GAME_CONFIRM',         'Confirm your game preferences');
-define('_MD_CHESS_GAME_CREATED',         'Game created');
-define('_MD_CHESS_GAME_STARTED',         'Game started');
-define('_MD_CHESS_LABEL_DATE_CREATED',   'Date created');
+define('_MD_CHESS_GAME_CONFIRM', 'Confirm your game preferences');
+define('_MD_CHESS_GAME_CREATED', 'Game created');
+define('_MD_CHESS_GAME_STARTED', 'Game started');
+define('_MD_CHESS_LABEL_DATE_CREATED', 'Date created');
 define('_MD_CHESS_LABEL_GAME_SUSPENDED', 'Game suspended');
-define('_MD_CHESS_WHITE_OFFERED_DRAW',   'White has offered a draw. Black must either accept or reject the offer.');
-define('_MD_CHESS_BLACK_OFFERED_DRAW',   'Black has offered a draw. White must either accept or reject the offer.');
+define('_MD_CHESS_WHITE_OFFERED_DRAW', 'White has offered a draw. Black must either accept or reject the offer.');
+define('_MD_CHESS_BLACK_OFFERED_DRAW', 'Black has offered a draw. White must either accept or reject the offer.');
 
 // PGN movetext comments for drawn games - must not contain comment delimiters '{' or '}'
-define('_MD_CHESS_DRAW_STALEMATE',    'Drawn by stalemate.');
-define('_MD_CHESS_DRAW_NO_MATE',      'Drawn since no checkmate is possible.');
+define('_MD_CHESS_DRAW_STALEMATE', 'Drawn by stalemate.');
+define('_MD_CHESS_DRAW_NO_MATE', 'Drawn since no checkmate is possible.');
 define('_MD_CHESS_DRAW_BY_AGREEMENT', 'Drawn by mutual agreement.');
-define('_MD_CHESS_DRAW_DECLARED',     'Draw declared by arbiter, reason: %s.');
-define('_MD_CHESS_DRAW_50',           'Drawn by 50-move rule.');
-define('_MD_CHESS_DRAW_3',            'Drawn by threefold-repetition rule, based on board position immediately prior to moves %s.');
+define('_MD_CHESS_DRAW_DECLARED', 'Draw declared by arbiter, reason: %s.');
+define('_MD_CHESS_DRAW_50', 'Drawn by 50-move rule.');
+define('_MD_CHESS_DRAW_3', 'Drawn by threefold-repetition rule, based on board position immediately prior to moves %s.');
 
-define('_MD_CHESS_NO_DRAW_50',        'The conditions for claiming a draw under the 50-move rule have not been satisfied.');
-define('_MD_CHESS_NO_DRAW_3',         'The conditions for claiming a draw under the threefold-repetition rule have not been satisfied.');
+define('_MD_CHESS_NO_DRAW_50', 'The conditions for claiming a draw under the 50-move rule have not been satisfied.');
+define('_MD_CHESS_NO_DRAW_3', 'The conditions for claiming a draw under the threefold-repetition rule have not been satisfied.');
 
 // menu options
-define('_MD_CHESS_SHOW_GAMES_INPLAY',    'Show games in play only');
+define('_MD_CHESS_SHOW_GAMES_INPLAY', 'Show games in play only');
 define('_MD_CHESS_SHOW_GAMES_CONCLUDED', 'Show concluded games only');
-define('_MD_CHESS_SHOW_GAMES_BOTH',      'Show all games');
-define('_MD_CHESS_SHOW_GAMES_RATED',     'Show rated games only');
-define('_MD_CHESS_SHOW_GAMES_UNRATED',   'Show rated and unrated games');
+define('_MD_CHESS_SHOW_GAMES_BOTH', 'Show all games');
+define('_MD_CHESS_SHOW_GAMES_RATED', 'Show rated games only');
+define('_MD_CHESS_SHOW_GAMES_UNRATED', 'Show rated and unrated games');
 define('_MD_CHESS_SHOW_CHALLENGES_OPEN', 'Show open challenges only');
 define('_MD_CHESS_SHOW_CHALLENGES_USER', 'Show individual challenges only');
 define('_MD_CHESS_SHOW_CHALLENGES_BOTH', 'Show all challenges');
 
 // ratings
-define('_MD_CHESS_RATED_GAME',           'Rated game');
-define('_MD_CHESS_RATINGS_OFF',          'Rating feature not enabled.');
-define('_MD_CHESS_PLAYER_RATINGS',       'Chess Player Ratings');
-define('_MD_CHESS_RATING',               'Rating');
-define('_MD_CHESS_PLAYER',               'Player');
-define('_MD_CHESS_GAMES_PLAYED',         'Rated games played');
-define('_MD_CHESS_PROVISIONAL',          'Provisional rating (less than %s rated games played)');
-define('_MD_CHESS_NA',                   'n/a'); // not applicable or not available
-define('_MD_CHESS_NO_RATING_INFO',       'No rating information found.');
-define('_MD_CHESS_RECALC_RATINGS',       'Recalculate all player ratings (available only to module administrators)');
-define('_MD_CHESS_SUBMIT_BUTTON',        'Submit');
-define('_MD_CHESS_RECALC_CONFIRM',       'Yes, I am sure I want to do this.');
-define('_MD_CHESS_RECALC_DONE',          'Ratings recalculated.');
-define('_MD_CHESS_RECALC_NOT_DONE',      'Ratings not recalculated because confirmation box was not checked.');
-define('_MD_CHESS_LAST_ACTIVITY',        'Last activity');
-define('_MD_CHESS_STATUS',               'Status');
-define('_MD_CHESS_DRAWN',                'drawn');
-define('_MD_CHESS_WON',                  'won');
-define('_MD_CHESS_LOST',                 'lost');
-define('_MD_CHESS_RANKED',               'Ranked');
-define('_MD_CHESS_RATED_GAMES_PLAYED',   'Rated games played');
-define('_MD_CHESS_CHALLENGES_FOR',       'Chess challenges for: %s');
-define('_MD_CHESS_GAMES_FOR',            'Chess games for: %s');
-define('_MD_CHESS_STATS_FOR',            'Chess stats for: %s');
-define('_MD_CHESS_SELECT_PLAYER',        'Select player and display option');
-define('_MD_CHESS_USERNAME',             'Username');
-define('_MD_CHESS_SHOW_ALL_GAMES',       'Show all games');
+define('_MD_CHESS_RATED_GAME', 'Rated game');
+define('_MD_CHESS_RATINGS_OFF', 'Rating feature not enabled.');
+define('_MD_CHESS_PLAYER_RATINGS', 'Chess Player Ratings');
+define('_MD_CHESS_RATING', 'Rating');
+define('_MD_CHESS_PLAYER', 'Player');
+define('_MD_CHESS_GAMES_PLAYED', 'Rated games played');
+define('_MD_CHESS_PROVISIONAL', 'Provisional rating (less than %s rated games played)');
+define('_MD_CHESS_NA', 'n/a'); // not applicable or not available
+define('_MD_CHESS_NO_RATING_INFO', 'No rating information found.');
+define('_MD_CHESS_RECALC_RATINGS', 'Recalculate all player ratings (available only to module administrators)');
+define('_MD_CHESS_SUBMIT_BUTTON', 'Submit');
+define('_MD_CHESS_RECALC_CONFIRM', 'Yes, I am sure I want to do this.');
+define('_MD_CHESS_RECALC_DONE', 'Ratings recalculated.');
+define('_MD_CHESS_RECALC_NOT_DONE', 'Ratings not recalculated because confirmation box was not checked.');
+define('_MD_CHESS_LAST_ACTIVITY', 'Last activity');
+define('_MD_CHESS_STATUS', 'Status');
+define('_MD_CHESS_DRAWN', 'drawn');
+define('_MD_CHESS_WON', 'won');
+define('_MD_CHESS_LOST', 'lost');
+define('_MD_CHESS_RANKED', 'Ranked');
+define('_MD_CHESS_RATED_GAMES_PLAYED', 'Rated games played');
+define('_MD_CHESS_CHALLENGES_FOR', 'Chess challenges for: %s');
+define('_MD_CHESS_GAMES_FOR', 'Chess games for: %s');
+define('_MD_CHESS_STATS_FOR', 'Chess stats for: %s');
+define('_MD_CHESS_SELECT_PLAYER', 'Select player and display option');
+define('_MD_CHESS_USERNAME', 'Username');
+define('_MD_CHESS_SHOW_ALL_GAMES', 'Show all games');
 define('_MD_CHESS_SHOW_EXCEPT_SELFPLAY', 'Show all games except self-play');
-define('_MD_CHESS_SHOW_RATED_ONLY',      'Show rated games only');
-define('_MD_CHESS_PLAYER_NOT_FOUND',     'No game information found for player.');
-define('_MD_CHESS_VIEW_PROFILE',         'View player\'s profile');
+define('_MD_CHESS_SHOW_RATED_ONLY', 'Show rated games only');
+define('_MD_CHESS_PLAYER_NOT_FOUND', 'No game information found for player.');
+define('_MD_CHESS_VIEW_PROFILE', 'View player\'s profile');
 
 /**#@-*/
 

language/german/admin.php

Spacing +19 added lines, -19 removed lines

@@ -11,41 +11,41 @@
  * @ignore
  */
 
-define('_AM_CHESS_CONF',       'Schach');
+define('_AM_CHESS_CONF', 'Schach');
 
-define('_AM_CHESS_PREFS',      'Einstellungen');
+define('_AM_CHESS_PREFS', 'Einstellungen');
 define('_AM_CHESS_PREFS_DESC', 'Einstellungen bearbeiten');
 
-define('_AM_CHESS_SUSPENDED_GAMES',     'unterbrochene Partien');
+define('_AM_CHESS_SUSPENDED_GAMES', 'unterbrochene Partien');
 define('_AM_CHESS_SUSPENDED_GAMES_DES', 'Zeige unterbrochene Partien');
 
-define('_AM_CHESS_ACTIVE_GAMES',     'Aktive Partien');
+define('_AM_CHESS_ACTIVE_GAMES', 'Aktive Partien');
 define('_AM_CHESS_ACTIVE_GAMES_DES', 'Zeige aktive Partien');
 
-define('_AM_CHESS_CHALLENGES',     'Herausforderungen');
+define('_AM_CHESS_CHALLENGES', 'Herausforderungen');
 define('_AM_CHESS_CHALLENGES_DES', 'Zeige Herausforderungen');
 
-define('_AM_CHESS_GAME',           'Partie');
-define('_AM_CHESS_CHALLENGE',      'Herausforderung');
-define('_AM_CHESS_VS',             'gegen');
-define('_AM_CHESS_CHALLENGED',     'herausgefordert');
-define('_AM_CHESS_CREATED',        'gestartet');
+define('_AM_CHESS_GAME', 'Partie');
+define('_AM_CHESS_CHALLENGE', 'Herausforderung');
+define('_AM_CHESS_VS', 'gegen');
+define('_AM_CHESS_CHALLENGED', 'herausgefordert');
+define('_AM_CHESS_CREATED', 'gestartet');
 
-define('_AM_CHESS_WHEN_SUSPENDED',    'Wenn unterbrochen');
-define('_AM_CHESS_SUSPENDED_BY',      'Unterbrochen von');
-define('_AM_CHESS_SUSPENSION_TYPE',   'Art der Unterbrechung');
+define('_AM_CHESS_WHEN_SUSPENDED', 'Wenn unterbrochen');
+define('_AM_CHESS_SUSPENDED_BY', 'Unterbrochen von');
+define('_AM_CHESS_SUSPENSION_TYPE', 'Art der Unterbrechung');
 define('_AM_CHESS_SUSPENSION_REASON', 'Grund der Unterbrechung');
 define('_AM_CHESS_SUSP_TYPE_ARBITER', 'Vom Schiedsrichter unterbrochen');
-define('_AM_CHESS_SUSP_TYPE_PLAYER',  'Schiedsurteil angefordert');
+define('_AM_CHESS_SUSP_TYPE_PLAYER', 'Schiedsurteil angefordert');
 
-define('_AM_CHESS_ARBITRATE_SUBMIT',   'Schiedsspruch fällen');
+define('_AM_CHESS_ARBITRATE_SUBMIT', 'Schiedsspruch fällen');
 
 define('_AM_CHESS_NO_SUSPENDED_GAMES', 'Keine unterbrochenen Partien');
-define('_AM_CHESS_NO_ACTIVE_GAMES',    'Keine aktiven Partien');
-define('_AM_CHESS_NO_CHALLENGES',      'Keine Herausforderungen');
+define('_AM_CHESS_NO_ACTIVE_GAMES', 'Keine aktiven Partien');
+define('_AM_CHESS_NO_CHALLENGES', 'Keine Herausforderungen');
 
-define('_AM_CHESS_UNKNOWN_USER',       '*unbekannt*');
-define('_AM_CHESS_ERROR',              '*error*');
+define('_AM_CHESS_UNKNOWN_USER', '*unbekannt*');
+define('_AM_CHESS_ERROR', '*error*');
 
 /**#@-*/
 

language/german/help.php

Spacing +18 added lines, -18 removed lines

@@ -71,11 +71,11 @@ 
 
 define('_HE_CHESS_RATINGS_TITLE', 'Bewertungssystem');
 
-define('_HE_CHESS_RATINGS_CXR',  '
+define('_HE_CHESS_RATINGS_CXR', '
 	CXR - Eine Adaption des ELO Bewertungssystems, verwendet mit Genehmigung von <A target="_blank" href="http://chess-express.com/">Chess Express Ratings, Inc.</A>
 ');
 
-define('_HE_CHESS_RATINGS_LINEAR',  '
+define('_HE_CHESS_RATINGS_LINEAR', '
 	Linear - Ein sehr einfaches System, das für einen Sieg (Niederlage) eine feste Anzahl an Punkten addiert (subtrahiert).
 ');
 
@@ -248,22 +248,22 @@ 
 define('_HE_CHESS_NOTATION_020', '
 Die Zugsequenz eines Zuges setzt sich aus vier Teilen zusammen (und einem fünften bei Verwandlung eines Bauern):
 ');
-define('_HE_CHESS_NOTATION_020_1',   'Figur');
-define('_HE_CHESS_NOTATION_020_1_A',   'K (König)');
-define('_HE_CHESS_NOTATION_020_1_B',   'Q (Dame)');
-define('_HE_CHESS_NOTATION_020_1_C',   'R (Turm)');
-define('_HE_CHESS_NOTATION_020_1_D',   'B (Läufer)');
-define('_HE_CHESS_NOTATION_020_1_E',   'N (Springer)');
-define('_HE_CHESS_NOTATION_020_1_F',   'P (Bauer)');
-define('_HE_CHESS_NOTATION_020_2',   'Ausgangsfeld');
-define('_HE_CHESS_NOTATION_020_2_A',   'Beispiele: e4, f2, h8');
-define('_HE_CHESS_NOTATION_020_3',   'Aktion');
-define('_HE_CHESS_NOTATION_020_3_A',   '- (ziehen)');
-define('_HE_CHESS_NOTATION_020_3_B',   'x (schlagen)');
-define('_HE_CHESS_NOTATION_020_4',   'Zielfeld');
-define('_HE_CHESS_NOTATION_020_4_A',   'Beispiele: a8, c6, g5');
-define('_HE_CHESS_NOTATION_020_5',   'Bauernverwandlung in (sofern erlaubt)');
-define('_HE_CHESS_NOTATION_020_5_A',   'mögliche Werte: =Q, =R, =B, =N');
+define('_HE_CHESS_NOTATION_020_1', 'Figur');
+define('_HE_CHESS_NOTATION_020_1_A', 'K (König)');
+define('_HE_CHESS_NOTATION_020_1_B', 'Q (Dame)');
+define('_HE_CHESS_NOTATION_020_1_C', 'R (Turm)');
+define('_HE_CHESS_NOTATION_020_1_D', 'B (Läufer)');
+define('_HE_CHESS_NOTATION_020_1_E', 'N (Springer)');
+define('_HE_CHESS_NOTATION_020_1_F', 'P (Bauer)');
+define('_HE_CHESS_NOTATION_020_2', 'Ausgangsfeld');
+define('_HE_CHESS_NOTATION_020_2_A', 'Beispiele: e4, f2, h8');
+define('_HE_CHESS_NOTATION_020_3', 'Aktion');
+define('_HE_CHESS_NOTATION_020_3_A', '- (ziehen)');
+define('_HE_CHESS_NOTATION_020_3_B', 'x (schlagen)');
+define('_HE_CHESS_NOTATION_020_4', 'Zielfeld');
+define('_HE_CHESS_NOTATION_020_4_A', 'Beispiele: a8, c6, g5');
+define('_HE_CHESS_NOTATION_020_5', 'Bauernverwandlung in (sofern erlaubt)');
+define('_HE_CHESS_NOTATION_020_5_A', 'mögliche Werte: =Q, =R, =B, =N');
 
 define('_HE_CHESS_NOTATION_030', '
 Beispiele für Züge:

language/german/modinfo.php

Spacing +74 added lines, -74 removed lines

@@ -14,8 +14,8 @@ 
 // Warning: Some of the these constant values contain the sprintf format code "%s".  That format code must not be removed.
 
 // Main
-define('_MI_CHESS',         'Schach');
-define('_MI_CHESS_DES',     'Ermöglicht den Benutzern, gegeneinander Schach zu spielen.');
+define('_MI_CHESS', 'Schach');
+define('_MI_CHESS_DES', 'Ermöglicht den Benutzern, gegeneinander Schach zu spielen.');
 define('_MI_CHESS_CREDITS', '
 	Meiko Jensen (german language pack).
 	<BR />
@@ -23,24 +23,24 @@ 
 ');
 
 // Blocks
-define('_MI_CHESS_GAMES',          'Letzte Schachpartien');
-define('_MI_CHESS_GAMES_DES',      'Liste der letzten Schachpartien');
-define('_MI_CHESS_CHALLENGES',     'Letzte Schach-Herausforderungen');
+define('_MI_CHESS_GAMES', 'Letzte Schachpartien');
+define('_MI_CHESS_GAMES_DES', 'Liste der letzten Schachpartien');
+define('_MI_CHESS_CHALLENGES', 'Letzte Schach-Herausforderungen');
 define('_MI_CHESS_CHALLENGES_DES', 'Liste der letzten Schach-Herausforderungen');
-define('_MI_CHESS_PLAYERS',        'Beste Schachspieler');
-define('_MI_CHESS_PLAYERS_DES',    'Liste der besten Schachspieler');
+define('_MI_CHESS_PLAYERS', 'Beste Schachspieler');
+define('_MI_CHESS_PLAYERS_DES', 'Liste der besten Schachspieler');
 
 // Templates
-define('_MI_CHESS_INDEX',         'Schach Übersicht');
-define('_MI_CHESS_GAME',          'Schachpartie');
-define('_MI_CHESS_MOVE_FORM',     'Schachzug-Seite');
+define('_MI_CHESS_INDEX', 'Schach Übersicht');
+define('_MI_CHESS_GAME', 'Schachpartie');
+define('_MI_CHESS_MOVE_FORM', 'Schachzug-Seite');
 define('_MI_CHESS_PROMOTE_POPUP', 'Schach-Bauernverwandlungsfenster');
-define('_MI_CHESS_BOARD',         'Schachbrett');
-define('_MI_CHESS_PREFS_FORM',    'Einstellungen für Schach');
-define('_MI_CHESS_ARBITER_FORM',  'Schach-Schiedsrichter');
-define('_MI_CHESS_HELP',          'Schach-Hilfe');
-define('_MI_CHESS_RATINGS',       'Schachspieler-Bewertungen (alle Spieler)');
-define('_MI_CHESS_PLAYER_STATS',  'Schachspieler-Statistik');
+define('_MI_CHESS_BOARD', 'Schachbrett');
+define('_MI_CHESS_PREFS_FORM', 'Einstellungen für Schach');
+define('_MI_CHESS_ARBITER_FORM', 'Schach-Schiedsrichter');
+define('_MI_CHESS_HELP', 'Schach-Hilfe');
+define('_MI_CHESS_RATINGS', 'Schachspieler-Bewertungen (alle Spieler)');
+define('_MI_CHESS_PLAYER_STATS', 'Schachspieler-Statistik');
 
 // Menu
 define('_MI_CHESS_SMNAME1', 'Hilfe');
@@ -50,42 +50,42 @@ 
 define('_MI_CHESS_SMNAME5', 'Meine Partien');
 
 // Rating systems (used in config)
-define('_MI_CHESS_RATING_SYSTEM_NONE',    'kein');
-define('_MI_CHESS_RATING_SYSTEM_CXR',     'CXR');
-define('_MI_CHESS_RATING_SYSTEM_LINEAR',  'Linear');
+define('_MI_CHESS_RATING_SYSTEM_NONE', 'kein');
+define('_MI_CHESS_RATING_SYSTEM_CXR', 'CXR');
+define('_MI_CHESS_RATING_SYSTEM_LINEAR', 'Linear');
 
 // Config
-define('_MI_CHESS_GROUPS_PLAY',        'Schachspiel-Recht');
-define('_MI_CHESS_GROUPS_PLAY_DES',    'Ein Benutzer in jeder der ausgewählten Gruppen darf andere Spieler herausfordern, Herausforderungen annehmen und gegen sich selbst spielen.');
-define('_MI_CHESS_GROUPS_DELETE',      'Partie-löschen-Recht');
-define('_MI_CHESS_GROUPS_DELETE_DES',  'Ein Benutzer in jeder der ausgewählten Gruppen darf eine Partie löschen, die er selbst spielt. Unabhängig davon, ob er dieses Recht hat, darf er Partien gegen sich selbst jederzeit löschen.');
-define('_MI_CHESS_ALLOW_SETUP',        'Anfangsstellung ändern?');
-define('_MI_CHESS_ALLOW_SETUP_DES',    'Darf ein Spieler die anfängliche Stellung der Figuren auf dem Schachbrett über die Forsyth-Edwards Notation (FEN) ändern?');
-define('_MI_CHESS_MAX_ITEMS',          'Maximale Anzahl an Einträgen pro Seite');
-define('_MI_CHESS_MAX_ITEMS_DES',      'Bezogen auf Partien, Herausforderungen und Spieler.');
-define('_MI_CHESS_RATING_SYSTEM',      'Spielerbewertungssystem');
-define('_MI_CHESS_RATING_SYSTEM_DES',  '
+define('_MI_CHESS_GROUPS_PLAY', 'Schachspiel-Recht');
+define('_MI_CHESS_GROUPS_PLAY_DES', 'Ein Benutzer in jeder der ausgewählten Gruppen darf andere Spieler herausfordern, Herausforderungen annehmen und gegen sich selbst spielen.');
+define('_MI_CHESS_GROUPS_DELETE', 'Partie-löschen-Recht');
+define('_MI_CHESS_GROUPS_DELETE_DES', 'Ein Benutzer in jeder der ausgewählten Gruppen darf eine Partie löschen, die er selbst spielt. Unabhängig davon, ob er dieses Recht hat, darf er Partien gegen sich selbst jederzeit löschen.');
+define('_MI_CHESS_ALLOW_SETUP', 'Anfangsstellung ändern?');
+define('_MI_CHESS_ALLOW_SETUP_DES', 'Darf ein Spieler die anfängliche Stellung der Figuren auf dem Schachbrett über die Forsyth-Edwards Notation (FEN) ändern?');
+define('_MI_CHESS_MAX_ITEMS', 'Maximale Anzahl an Einträgen pro Seite');
+define('_MI_CHESS_MAX_ITEMS_DES', 'Bezogen auf Partien, Herausforderungen und Spieler.');
+define('_MI_CHESS_RATING_SYSTEM', 'Spielerbewertungssystem');
+define('_MI_CHESS_RATING_SYSTEM_DES', '
 	Verfügbare Bewertungssysteme:
 	<BR /><BR />
-	&nbsp;&nbsp;' ._MI_CHESS_RATING_SYSTEM_CXR. '    - Adaptation des ELO Bewertungssystem, Verwendung erlaubt durch <A target="_blank" href="http://chess-express.com/">Chess Express Ratings, Inc.</A>
+	&nbsp;&nbsp;' ._MI_CHESS_RATING_SYSTEM_CXR.'    - Adaptation des ELO Bewertungssystem, Verwendung erlaubt durch <A target="_blank" href="http://chess-express.com/">Chess Express Ratings, Inc.</A>
 	<BR /><BR />
-	&nbsp;&nbsp;' ._MI_CHESS_RATING_SYSTEM_LINEAR. ' - Ein sehr einfaches System, das für jeden Sieg (Niederlage) eine feste Anzahl an Punkten addiert (abzieht).
+	&nbsp;&nbsp;' ._MI_CHESS_RATING_SYSTEM_LINEAR.' - Ein sehr einfaches System, das für jeden Sieg (Niederlage) eine feste Anzahl an Punkten addiert (abzieht).
 	<BR /><BR />
-	Die Auswahl "' ._MI_CHESS_RATING_SYSTEM_NONE. '" schaltet das Bewertungssystem ab.
+	Die Auswahl "' ._MI_CHESS_RATING_SYSTEM_NONE.'" schaltet das Bewertungssystem ab.
 	<BR /><BR />
 	Nach Änderung dieser Auswahl sollten die Spielerbewertungen aktualisiert werden (unter Hauptmenü >> Schach >>
-	' ._MI_CHESS_SMNAME4. ').
+	' ._MI_CHESS_SMNAME4.').
 ');
-define('_MI_CHESS_INITIAL_RATING',     'Anfängliche Spielerbewertung');
+define('_MI_CHESS_INITIAL_RATING', 'Anfängliche Spielerbewertung');
 define('_MI_CHESS_INITIAL_RATING_DES', '
-	Falls das "' ._MI_CHESS_RATING_SYSTEM_CXR. '" Bewertungssystem gewählt wird, sollte dieser Wert zwischen 800 und 2000 liegen.
+	Falls das "' ._MI_CHESS_RATING_SYSTEM_CXR.'" Bewertungssystem gewählt wird, sollte dieser Wert zwischen 800 und 2000 liegen.
 	<BR /><BR />
 	Nur wirksam, falls ein Bewertungssystem ausgewählt wurde.
 	<BR /><BR />
-	Nach Änderung dieser Auswahl sollten die Spielerbewertungen aktualisiert werden (unter Hauptmenü >> Schach >> ' ._MI_CHESS_SMNAME4. ').
+	Nach Änderung dieser Auswahl sollten die Spielerbewertungen aktualisiert werden (unter Hauptmenü >> Schach >> ' ._MI_CHESS_SMNAME4.').
 ');
-define('_MI_CHESS_ALLOW_UNRATED',      'Unbewertete Partien erlauben?');
-define('_MI_CHESS_ALLOW_UNRATED_DES',  '
+define('_MI_CHESS_ALLOW_UNRATED', 'Unbewertete Partien erlauben?');
+define('_MI_CHESS_ALLOW_UNRATED_DES', '
 	Darf ein Benutzer bei einer Herausforderung auswählen, daß diese Partie nicht in die Bewertung eingeht?
 	<BR /><BR />
 	Nur wirksam, falls ein Bewertungssystem ausgewählt wurde.
@@ -93,36 +93,36 @@ 
 
 // Notifications
 
-define('_MI_CHESS_NCAT_GAME',           'Partie');
-define('_MI_CHESS_NCAT_GAME_DES',       'Dies ist die Kategorie Partie.');
+define('_MI_CHESS_NCAT_GAME', 'Partie');
+define('_MI_CHESS_NCAT_GAME_DES', 'Dies ist die Kategorie Partie.');
 
-define('_MI_CHESS_NCAT_GLOBAL',         'Global');
-define('_MI_CHESS_NCAT_GLOBAL_DES',     'Dies ist die Kategorie Schach.');
+define('_MI_CHESS_NCAT_GLOBAL', 'Global');
+define('_MI_CHESS_NCAT_GLOBAL_DES', 'Dies ist die Kategorie Schach.');
 
-define('_MI_CHESS_NEVT_MOVE',           'Neuer Zug');
-define('_MI_CHESS_NEVT_MOVE_CAP',       'Benachrichtigen, wenn in dieser Partie ein neuer Zug gemacht wurde.');
-define('_MI_CHESS_NEVT_MOVE_DES',       'Beschreibung des neuen Zuges');
-define('_MI_CHESS_NEVT_MOVE_SUB',       '[{X_SITENAME}] {X_MODULE} auto-notify : Neuer Zug');
+define('_MI_CHESS_NEVT_MOVE', 'Neuer Zug');
+define('_MI_CHESS_NEVT_MOVE_CAP', 'Benachrichtigen, wenn in dieser Partie ein neuer Zug gemacht wurde.');
+define('_MI_CHESS_NEVT_MOVE_DES', 'Beschreibung des neuen Zuges');
+define('_MI_CHESS_NEVT_MOVE_SUB', '[{X_SITENAME}] {X_MODULE} auto-notify : Neuer Zug');
 
-define('_MI_CHESS_NEVT_CHAL_USER',      'persönliche Herausforderung');
-define('_MI_CHESS_NEVT_CHAL_USER_CAP',  'Benachrichtigen, wenn ich herausgefordert werde.');
-define('_MI_CHESS_NEVT_CHAL_USER_DES',  '');
-define('_MI_CHESS_NEVT_CHAL_USER_SUB',  '[{X_SITENAME}] {X_MODULE} auto-notify : persönliche Herausforderung');
+define('_MI_CHESS_NEVT_CHAL_USER', 'persönliche Herausforderung');
+define('_MI_CHESS_NEVT_CHAL_USER_CAP', 'Benachrichtigen, wenn ich herausgefordert werde.');
+define('_MI_CHESS_NEVT_CHAL_USER_DES', '');
+define('_MI_CHESS_NEVT_CHAL_USER_SUB', '[{X_SITENAME}] {X_MODULE} auto-notify : persönliche Herausforderung');
 
-define('_MI_CHESS_NEVT_CHAL_OPEN',      'Offene Herausforderung');
-define('_MI_CHESS_NEVT_CHAL_OPEN_CAP',  'Benachrichtigen, wenn eine neue offene Herausforderung erstellt wird.');
-define('_MI_CHESS_NEVT_CHAL_OPEN_DES',  '');
-define('_MI_CHESS_NEVT_CHAL_OPEN_SUB',  '[{X_SITENAME}] {X_MODULE} auto-notify : Offene Herausforderung');
+define('_MI_CHESS_NEVT_CHAL_OPEN', 'Offene Herausforderung');
+define('_MI_CHESS_NEVT_CHAL_OPEN_CAP', 'Benachrichtigen, wenn eine neue offene Herausforderung erstellt wird.');
+define('_MI_CHESS_NEVT_CHAL_OPEN_DES', '');
+define('_MI_CHESS_NEVT_CHAL_OPEN_SUB', '[{X_SITENAME}] {X_MODULE} auto-notify : Offene Herausforderung');
 
-define('_MI_CHESS_NEVT_ACPT_CHAL',      'Herausforderung akzeptiert');
-define('_MI_CHESS_NEVT_ACPT_CHAL_CAP',  'Benachrichtigen, wenn jemand meine Herausforderung annimmt.');
-define('_MI_CHESS_NEVT_ACPT_CHAL_DES',  '');
-define('_MI_CHESS_NEVT_ACPT_CHAL_SUB',  '[{X_SITENAME}] {X_MODULE} auto-notify : Herausforderung angenommen');
+define('_MI_CHESS_NEVT_ACPT_CHAL', 'Herausforderung akzeptiert');
+define('_MI_CHESS_NEVT_ACPT_CHAL_CAP', 'Benachrichtigen, wenn jemand meine Herausforderung annimmt.');
+define('_MI_CHESS_NEVT_ACPT_CHAL_DES', '');
+define('_MI_CHESS_NEVT_ACPT_CHAL_SUB', '[{X_SITENAME}] {X_MODULE} auto-notify : Herausforderung angenommen');
 
-define('_MI_CHESS_NEVT_RQST_ARBT',      'Schiedsurteil angefordert (admin only)');
-define('_MI_CHESS_NEVT_RQST_ARBT_CAP',  'Benachrichtigen, wenn Schiedsurteil angefordert wird.');
-define('_MI_CHESS_NEVT_RQST_ARBT_DES',  '');
-define('_MI_CHESS_NEVT_RQST_ARBT_SUB',  '[{X_SITENAME}] {X_MODULE} auto-notify : Schiedsurteil angefordert');
+define('_MI_CHESS_NEVT_RQST_ARBT', 'Schiedsurteil angefordert (admin only)');
+define('_MI_CHESS_NEVT_RQST_ARBT_CAP', 'Benachrichtigen, wenn Schiedsurteil angefordert wird.');
+define('_MI_CHESS_NEVT_RQST_ARBT_DES', '');
+define('_MI_CHESS_NEVT_RQST_ARBT_SUB', '[{X_SITENAME}] {X_MODULE} auto-notify : Schiedsurteil angefordert');
 
 // Admin menu items
 define('_MI_CHESS_ADMENU1', 'Unterbrochene Partien');
@@ -130,19 +130,19 @@ 
 define('_MI_CHESS_ADMENU3', 'Herausforderungen');
 
 // Install/upgrade
-define('_MI_CHESS_OLD_VERSION',        'Direktes Update von Version "%s" nicht unterstützt! Bitte Datei "%s" lesen.');
-define('_MI_CHESS_RATINGS_TABLE_1',    'Prüfe, ob Tabelle "%s" bereits existiert ...');
-define('_MI_CHESS_RATINGS_TABLE_2',    ' ... Existenzprüfung fehlgeschlagen für Tabelle "%s": (%s) %s');
-define('_MI_CHESS_RATINGS_TABLE_3',    ' ... Tabelle "%s" existiert bereits, also wurde dieses Update vermutlich bereits ausgeführt.');
-define('_MI_CHESS_OK',                 ' ... Ok');
-define('_MI_CHESS_CHK_DB_TABLES',      'Prüfe Datenbank-Tabellen ...');
-define('_MI_CHESS_GAMES_TABLE_1',      'Inspiziere Tabelle "%s" vor der Änderung ...');
-define('_MI_CHESS_GAMES_TABLE_2',      ' ... Inspektion fehlgeschlagen für Tabelle "%s": (%s) %s');
-define('_MI_CHESS_GAMES_TABLE_3',      ' ... die Spalte "%s" in der Tabelle "%s" darf nur folgende Werte enthalten: %s.');
-define('_MI_CHESS_GAMES_TABLE_4',      ' ... Bitte die Fehler für diese Tabelle korrigieren und das Update erneut asführen.');
-define('_MI_CHESS_UPDATING_DATABASE',  'Aktualisiere Datenbank-Tabellen ...');
+define('_MI_CHESS_OLD_VERSION', 'Direktes Update von Version "%s" nicht unterstützt! Bitte Datei "%s" lesen.');
+define('_MI_CHESS_RATINGS_TABLE_1', 'Prüfe, ob Tabelle "%s" bereits existiert ...');
+define('_MI_CHESS_RATINGS_TABLE_2', ' ... Existenzprüfung fehlgeschlagen für Tabelle "%s": (%s) %s');
+define('_MI_CHESS_RATINGS_TABLE_3', ' ... Tabelle "%s" existiert bereits, also wurde dieses Update vermutlich bereits ausgeführt.');
+define('_MI_CHESS_OK', ' ... Ok');
+define('_MI_CHESS_CHK_DB_TABLES', 'Prüfe Datenbank-Tabellen ...');
+define('_MI_CHESS_GAMES_TABLE_1', 'Inspiziere Tabelle "%s" vor der Änderung ...');
+define('_MI_CHESS_GAMES_TABLE_2', ' ... Inspektion fehlgeschlagen für Tabelle "%s": (%s) %s');
+define('_MI_CHESS_GAMES_TABLE_3', ' ... die Spalte "%s" in der Tabelle "%s" darf nur folgende Werte enthalten: %s.');
+define('_MI_CHESS_GAMES_TABLE_4', ' ... Bitte die Fehler für diese Tabelle korrigieren und das Update erneut asführen.');
+define('_MI_CHESS_UPDATING_DATABASE', 'Aktualisiere Datenbank-Tabellen ...');
 define('_MI_CHESS_INIT_RATINGS_TABLE', 'Initialisiere Bewertungstabellen ...');
-define('_MI_CHESS_UPDATE_SUCCESSFUL',  'Update erfolgreich abgeschlossen.');
+define('_MI_CHESS_UPDATE_SUCCESSFUL', 'Update erfolgreich abgeschlossen.');
 
 /**#@-*/
 

language/german/blocks.php

Spacing +26 added lines, -26 removed lines

@@ -14,47 +14,47 @@
 // Warning: Some of the these constant values contain the sprintf format code "%s".  That format code must not be removed.
 
 // block editor
-define('_MB_CHESS_NUM_GAMES',            'Maximale Anzahl anzuzeigender Partien');
-define('_MB_CHESS_SHOW_GAMES_INPLAY',    'Nur aktive Partien anzeigen');
+define('_MB_CHESS_NUM_GAMES', 'Maximale Anzahl anzuzeigender Partien');
+define('_MB_CHESS_SHOW_GAMES_INPLAY', 'Nur aktive Partien anzeigen');
 define('_MB_CHESS_SHOW_GAMES_CONCLUDED', 'Nur abgeschlossene Partien anzeigen');
-define('_MB_CHESS_SHOW_GAMES_BOTH',      'Beides anzeigen');
-define('_MB_CHESS_SHOW_GAMES_RATED',     'Nur bewertete Partien anzeigen');
-define('_MB_CHESS_SHOW_GAMES_UNRATED',   'Bewertete und unbewertete Partien anzeigen');
-define('_MB_CHESS_NUM_CHALLENGES',       'Maximale Anzahl anzuzeigender Herausforderungen');
+define('_MB_CHESS_SHOW_GAMES_BOTH', 'Beides anzeigen');
+define('_MB_CHESS_SHOW_GAMES_RATED', 'Nur bewertete Partien anzeigen');
+define('_MB_CHESS_SHOW_GAMES_UNRATED', 'Bewertete und unbewertete Partien anzeigen');
+define('_MB_CHESS_NUM_CHALLENGES', 'Maximale Anzahl anzuzeigender Herausforderungen');
 define('_MB_CHESS_SHOW_CHALLENGES_OPEN', 'Nur offene Herausforderungen anzeigen');
 define('_MB_CHESS_SHOW_CHALLENGES_USER', 'Nur persönliche Herausforderungen anzeigen');
 define('_MB_CHESS_SHOW_CHALLENGES_BOTH', 'Beides anzeigen');
-define('_MB_CHESS_NUM_PLAYERS',          'Maximale anzuzeigende Spielerzahl');
-define('_MB_CHESS_SHOW_NONPROVISIONAL',  'Nur Spieler mit nicht vorläufigen Bewertungen anzeigen');
-define('_MB_CHESS_SHOW_ALL_RATINGS',     'Spieler mit allen Bewertungen anzeigen');
+define('_MB_CHESS_NUM_PLAYERS', 'Maximale anzuzeigende Spielerzahl');
+define('_MB_CHESS_SHOW_NONPROVISIONAL', 'Nur Spieler mit nicht vorläufigen Bewertungen anzeigen');
+define('_MB_CHESS_SHOW_ALL_RATINGS', 'Spieler mit allen Bewertungen anzeigen');
 
 // games
-define('_MB_CHESS_GAME',          'Partie');
-define('_MB_CHESS_DATE',          'Letzte Aktivität');
-define('_MB_CHESS_STATUS',        'Status');
-define('_MB_CHESS_VS',            'gegen');
-define('_MB_CHESS_DRAW',          'Remis');
-define('_MB_CHESS_WHITE_WON',     'Weiß gewinnt');
-define('_MB_CHESS_BLACK_WON',     'Schwarz gewinnt');
+define('_MB_CHESS_GAME', 'Partie');
+define('_MB_CHESS_DATE', 'Letzte Aktivität');
+define('_MB_CHESS_STATUS', 'Status');
+define('_MB_CHESS_VS', 'gegen');
+define('_MB_CHESS_DRAW', 'Remis');
+define('_MB_CHESS_WHITE_WON', 'Weiß gewinnt');
+define('_MB_CHESS_BLACK_WON', 'Schwarz gewinnt');
 define('_MB_CHESS_WHITE_TO_MOVE', 'Weiß ist am Zug');
 define('_MB_CHESS_BLACK_TO_MOVE', 'Schwarz ist am Zug');
-define('_MB_CHESS_NO_GAMES',      'Keine Partien');
+define('_MB_CHESS_NO_GAMES', 'Keine Partien');
 
 // challenges
-define('_MB_CHESS_TYPE',          'Typ');
-define('_MB_CHESS_CHALLENGER',    'Herausforderer');
-define('_MB_CHESS_CREATED',       'Gestartet');
+define('_MB_CHESS_TYPE', 'Typ');
+define('_MB_CHESS_CHALLENGER', 'Herausforderer');
+define('_MB_CHESS_CREATED', 'Gestartet');
 define('_MB_CHESS_GAMETYPE_OPEN', 'Offene Herausforderungen');
 define('_MB_CHESS_GAMETYPE_USER', 'Persönliche Herausforderungen');
 define('_MB_CHESS_NO_CHALLENGES', 'keine Herausforderungen');
 
 // players
-define('_MB_CHESS_RATINGS_OFF',      'Bewertungen sind abgeschaltet');
-define('_MB_CHESS_PLAYER',           'Spieler');
-define('_MB_CHESS_RATING',           'Bewertung');
-define('_MB_CHESS_GAMES_PLAYED',     'Bewertete beendete Partien');
-define('_MB_CHESS_PROVISIONAL',      'Vorläufige Bewertung (weniger als %s bewertete Partien gespielt)');
-define('_MB_CHESS_NO_RATED_GAMES',   'Es wurden keine bewerteten Partien beendet.');
+define('_MB_CHESS_RATINGS_OFF', 'Bewertungen sind abgeschaltet');
+define('_MB_CHESS_PLAYER', 'Spieler');
+define('_MB_CHESS_RATING', 'Bewertung');
+define('_MB_CHESS_GAMES_PLAYED', 'Bewertete beendete Partien');
+define('_MB_CHESS_PROVISIONAL', 'Vorläufige Bewertung (weniger als %s bewertete Partien gespielt)');
+define('_MB_CHESS_NO_RATED_GAMES', 'Es wurden keine bewerteten Partien beendet.');
 define('_MB_CHESS_NO_NONPROV_GAMES', 'Es wurden keine bewerteten Partien beendet (Spieler mit vorläufigen Bewertungen sind nicht aufgeführt).');
 
 // miscellaneous

language/german/main.php

Spacing +205 added lines, -205 removed lines

@@ -18,287 +18,287 @@
 define('_MD_CHESS_DELETE_FORM', 'Herausforderung löschen');
 
 // game type
-define('_MD_CHESS_LABEL_GAMETYPE',      'Art der Partie');
+define('_MD_CHESS_LABEL_GAMETYPE', 'Art der Partie');
 define('_MD_CHESS_LABEL_GAMETYPE_OPEN', 'Offene Herausforderung');
 define('_MD_CHESS_LABEL_GAMETYPE_USER', 'Persönliche Herausforderung');
 define('_MD_CHESS_LABEL_GAMETYPE_SELF', 'Spiel gegen sich selbst');
-define('_MD_CHESS_MENU_GAMETYPE_OPEN',  _MD_CHESS_LABEL_GAMETYPE_OPEN . ' - Jeder kann die Herausforderung annehmen');
-define('_MD_CHESS_MENU_GAMETYPE_USER',  _MD_CHESS_LABEL_GAMETYPE_USER . ' - nur der herausgeforderte Benutzer kann die Herausforderung annehmen');
-define('_MD_CHESS_MENU_GAMETYPE_SELF',  _MD_CHESS_LABEL_GAMETYPE_SELF . ' - Partie mit sich selbst spielen');
+define('_MD_CHESS_MENU_GAMETYPE_OPEN', _MD_CHESS_LABEL_GAMETYPE_OPEN.' - Jeder kann die Herausforderung annehmen');
+define('_MD_CHESS_MENU_GAMETYPE_USER', _MD_CHESS_LABEL_GAMETYPE_USER.' - nur der herausgeforderte Benutzer kann die Herausforderung annehmen');
+define('_MD_CHESS_MENU_GAMETYPE_SELF', _MD_CHESS_LABEL_GAMETYPE_SELF.' - Partie mit sich selbst spielen');
 
 // opponent
 define('_MD_CHESS_LABEL_OPPONENT', 'Gegner');
 
 // FEN setup
-define('_MD_CHESS_LABEL_FEN_SETUP',   'Ausgangssituation');
+define('_MD_CHESS_LABEL_FEN_SETUP', 'Ausgangssituation');
 define('_MD_CHESS_LABEL_FEN_EXPLAIN', 'Optional kann eine Ausgangssituation angegeben werden, die in FEN (Forsyth-Edwards Notation) angegeben wird. Ansonsten wird die Standard-Ausgangssituation gewählt.');
 
 // color preference
-define('_MD_CHESS_LABEL_COLOR',          'Meine Farbe wird');
+define('_MD_CHESS_LABEL_COLOR', 'Meine Farbe wird');
 define('_MD_CHESS_RADIO_COLOR_OPPONENT', 'von meinem Gegner bestimmt');
-define('_MD_CHESS_RADIO_COLOR_RANDOM',   'zufällig zugewiesen');
-define('_MD_CHESS_RADIO_COLOR_WHITE',    'Weiß');
-define('_MD_CHESS_RADIO_COLOR_BLACK',    'Schwarz');
+define('_MD_CHESS_RADIO_COLOR_RANDOM', 'zufällig zugewiesen');
+define('_MD_CHESS_RADIO_COLOR_WHITE', 'Weiß');
+define('_MD_CHESS_RADIO_COLOR_BLACK', 'Schwarz');
 
 // notifications
 define('_MD_CHESS_NEVT_ACPT_CHAL_CAP', 'Benachrichtigung senden, wenn meine Herausforderung angenommen wird.');
-define('_MD_CHESS_NEVT_MOVE_CAP',      'Benachrichtigung senden, wenn ein neuer Zug in dieser Partie gemacht wurde.');
+define('_MD_CHESS_NEVT_MOVE_CAP', 'Benachrichtigung senden, wenn ein neuer Zug in dieser Partie gemacht wurde.');
 
 // buttons
-define('_MD_CHESS_CREATE_SUBMIT',  'ziehen!');
-define('_MD_CHESS_CREATE_ACCEPT',  'akzeptieren');
-define('_MD_CHESS_CREATE_CANCEL',  'abbrechen');
-define('_MD_CHESS_CREATE_DELETE',  'löschen');
+define('_MD_CHESS_CREATE_SUBMIT', 'ziehen!');
+define('_MD_CHESS_CREATE_ACCEPT', 'akzeptieren');
+define('_MD_CHESS_CREATE_CANCEL', 'abbrechen');
+define('_MD_CHESS_CREATE_DELETE', 'löschen');
 define('_MD_CHESS_CONFIRM_DELETE', 'Ja, ich bin sicher, daß ich dies löschen will');
 
 // errors
-define('_MD_CHESS_ERROR',             'Error');
-define('_MD_CHESS_GAMETYPE_INVALID',  'Partie-Typ nicht gültig');
-define('_MD_CHESS_FEN_INVALID',       'Ausgangssituation/FEN nicht gültig');
-define('_MD_CHESS_OPPONENT_MISSING',  'Der Benutzername des Gegners muß angegeben werden.');
-define('_MD_CHESS_OPPONENT_INVALID',  'Der angegebene Benutzer ist unbekannt oder nicht für eine Partie verfügbar.');
-define('_MD_CHESS_OPPONENT_SELF',     'Es ist nicht möglich, sich selbst herauszufordern.');
-define('_MD_CHESS_GAME_NOT_FOUND',    'Partie nicht gefunden.');
-define('_MD_CHESS_GAME_DELETED',      'Partie gelöscht');
-define('_MD_CHESS_WRONG_PLAYER2',     'Es ist nicht möglich, eine Herausforderung zu akzeptieren, die an einen anderen Spieler gerichtet ist.');
-define('_MD_CHESS_SAME_PLAYER2',      'Es ist nicht möglich, eine Herausforderung von sich selbst anzunehmen.');
+define('_MD_CHESS_ERROR', 'Error');
+define('_MD_CHESS_GAMETYPE_INVALID', 'Partie-Typ nicht gültig');
+define('_MD_CHESS_FEN_INVALID', 'Ausgangssituation/FEN nicht gültig');
+define('_MD_CHESS_OPPONENT_MISSING', 'Der Benutzername des Gegners muß angegeben werden.');
+define('_MD_CHESS_OPPONENT_INVALID', 'Der angegebene Benutzer ist unbekannt oder nicht für eine Partie verfügbar.');
+define('_MD_CHESS_OPPONENT_SELF', 'Es ist nicht möglich, sich selbst herauszufordern.');
+define('_MD_CHESS_GAME_NOT_FOUND', 'Partie nicht gefunden.');
+define('_MD_CHESS_GAME_DELETED', 'Partie gelöscht');
+define('_MD_CHESS_WRONG_PLAYER2', 'Es ist nicht möglich, eine Herausforderung zu akzeptieren, die an einen anderen Spieler gerichtet ist.');
+define('_MD_CHESS_SAME_PLAYER2', 'Es ist nicht möglich, eine Herausforderung von sich selbst anzunehmen.');
 define('_MD_CHESS_NO_CONFIRM_DELETE', 'Es ist erforderlich, den Bestätigungskasten zu aktivieren');
-define('_MD_CHESS_NO_JAVASCRIPT',     'Javascript ist nicht aktiviert. Die Züge müssen durch textuelle Eintragung abgegeben werden.');
-define('_MD_CHESS_MODHEAD_MISSING',   'WARNUNG: <{$xoops_module_header}> fehlt in themes/%s/theme.html.');
-define('_MD_CHESS_TOKEN_ERROR',       'Figur fehlt oder ist ungültig.');
+define('_MD_CHESS_NO_JAVASCRIPT', 'Javascript ist nicht aktiviert. Die Züge müssen durch textuelle Eintragung abgegeben werden.');
+define('_MD_CHESS_MODHEAD_MISSING', 'WARNUNG: <{$xoops_module_header}> fehlt in themes/%s/theme.html.');
+define('_MD_CHESS_TOKEN_ERROR', 'Figur fehlt oder ist ungültig.');
 
 // templates
-define('_MD_CHESS_LABEL_GAMES',         'Partien');
-define('_MD_CHESS_LABEL_NO_GAMES',      'Keine Partien');
-define('_MD_CHESS_LABEL_GAME',          'Partie');
-define('_MD_CHESS_LABEL_CREATED',       'Begonnen');
-define('_MD_CHESS_LABEL_LAST_MOVE',     'Letzter Zug');
-define('_MD_CHESS_LABEL_STATUS',        'Status');
-define('_MD_CHESS_LABEL_VS',            'gegen');
-define('_MD_CHESS_LABEL_DRAW',          'Zug');
-define('_MD_CHESS_LABEL_WHITE_WON',     'Weiß gewinnt');
-define('_MD_CHESS_LABEL_BLACK_WON',     'Schwarz gewinnt');
-define('_MD_CHESS_LABEL_WHITE',         'Weiß');
-define('_MD_CHESS_LABEL_BLACK',         'Schwarz');
-define('_MD_CHESS_LABEL_TO_MOVE',       'ist am Zug');
+define('_MD_CHESS_LABEL_GAMES', 'Partien');
+define('_MD_CHESS_LABEL_NO_GAMES', 'Keine Partien');
+define('_MD_CHESS_LABEL_GAME', 'Partie');
+define('_MD_CHESS_LABEL_CREATED', 'Begonnen');
+define('_MD_CHESS_LABEL_LAST_MOVE', 'Letzter Zug');
+define('_MD_CHESS_LABEL_STATUS', 'Status');
+define('_MD_CHESS_LABEL_VS', 'gegen');
+define('_MD_CHESS_LABEL_DRAW', 'Zug');
+define('_MD_CHESS_LABEL_WHITE_WON', 'Weiß gewinnt');
+define('_MD_CHESS_LABEL_BLACK_WON', 'Schwarz gewinnt');
+define('_MD_CHESS_LABEL_WHITE', 'Weiß');
+define('_MD_CHESS_LABEL_BLACK', 'Schwarz');
+define('_MD_CHESS_LABEL_TO_MOVE', 'ist am Zug');
 define('_MD_CHESS_LABEL_WHITE_TO_MOVE', 'Weiß ist am Zug');
 define('_MD_CHESS_LABEL_BLACK_TO_MOVE', 'Schwarz ist am Zug');
-define('_MD_CHESS_LABEL_CHALLENGES',    'Herausforderungen');
+define('_MD_CHESS_LABEL_CHALLENGES', 'Herausforderungen');
 define('_MD_CHESS_LABEL_NO_CHALLENGES', 'Keine Herausforderungen');
-define('_MD_CHESS_LABEL_TYPE',          'Typ');
-define('_MD_CHESS_LABEL_CHALLENGER',    'Herausforderer');
-define('_MD_CHESS_LABEL_COLOR_OPTION',  'Farbwahl');
-define('_MD_CHESS_LABEL_GAME_OVER',     'Spiel beendet, Punktzahl');
-define('_MD_CHESS_PGN_FULL',            'Portable Game Notation');
-define('_MD_CHESS_PGN_ABBREV',          'PGN');
-define('_MD_CHESS_FEN_FULL',            'Forsyth-Edwards Notation');
-define('_MD_CHESS_FEN_ABBREV',          'FEN');
-define('_MD_CHESS_LABEL_ERROR',         '*error*');
-define('_MD_CHESS_PROMOTE_TO',          'Bauer verwandeln in');
-
-define('_MD_CHESS_ALT_EMPTY',   'leeres Feld');
-define('_MD_CHESS_ALT_WKING',   'weißer König');
-define('_MD_CHESS_ALT_WQUEEN',  'weiße Dame');
-define('_MD_CHESS_ALT_WROOK',   'weißer Turm');
+define('_MD_CHESS_LABEL_TYPE', 'Typ');
+define('_MD_CHESS_LABEL_CHALLENGER', 'Herausforderer');
+define('_MD_CHESS_LABEL_COLOR_OPTION', 'Farbwahl');
+define('_MD_CHESS_LABEL_GAME_OVER', 'Spiel beendet, Punktzahl');
+define('_MD_CHESS_PGN_FULL', 'Portable Game Notation');
+define('_MD_CHESS_PGN_ABBREV', 'PGN');
+define('_MD_CHESS_FEN_FULL', 'Forsyth-Edwards Notation');
+define('_MD_CHESS_FEN_ABBREV', 'FEN');
+define('_MD_CHESS_LABEL_ERROR', '*error*');
+define('_MD_CHESS_PROMOTE_TO', 'Bauer verwandeln in');
+
+define('_MD_CHESS_ALT_EMPTY', 'leeres Feld');
+define('_MD_CHESS_ALT_WKING', 'weißer König');
+define('_MD_CHESS_ALT_WQUEEN', 'weiße Dame');
+define('_MD_CHESS_ALT_WROOK', 'weißer Turm');
 define('_MD_CHESS_ALT_WBISHOP', 'weißer Läufer');
 define('_MD_CHESS_ALT_WKNIGHT', 'weißer Springer');
-define('_MD_CHESS_ALT_WPAWN',   'weißer Bauer');
-define('_MD_CHESS_ALT_BKING',   'schwarzer König');
-define('_MD_CHESS_ALT_BQUEEN',  'schwarze Dame');
-define('_MD_CHESS_ALT_BROOK',   'schwarzer Turm');
+define('_MD_CHESS_ALT_WPAWN', 'weißer Bauer');
+define('_MD_CHESS_ALT_BKING', 'schwarzer König');
+define('_MD_CHESS_ALT_BQUEEN', 'schwarze Dame');
+define('_MD_CHESS_ALT_BROOK', 'schwarzer Turm');
 define('_MD_CHESS_ALT_BBISHOP', 'schwarzer Läufer');
 define('_MD_CHESS_ALT_BKNIGHT', 'schwarzer Springer');
-define('_MD_CHESS_ALT_BPAWN',   'schwarzer Bauer');
+define('_MD_CHESS_ALT_BPAWN', 'schwarzer Bauer');
 
-define('_MD_CHESS_CONFIRM',     'bestätigen');
+define('_MD_CHESS_CONFIRM', 'bestätigen');
 
 define('_MD_CHESS_BUTTON_MOVE', 'ziehen');
 
-define('_MD_CHESS_NORMAL_MOVE',        'Normaler Zug');
-define('_MD_CHESS_RESIGN',             'Aufgeben');
-define('_MD_CHESS_OFFER_DRAW',         'Remis anbieten');
-define('_MD_CHESS_ACCEPT_DRAW',        'Remis annehmen');
-define('_MD_CHESS_REJECT_DRAW',        'Remis ablehnen');
-define('_MD_CHESS_CLAIM_DRAW_50',      'Remis fordern (50-Zug-Regel)');
-define('_MD_CHESS_CLAIM_DRAW_3',       'Remis fordern (dreifache Wiederholung)');
-define('_MD_CHESS_RESTART',            'Partie neu starten');
-define('_MD_CHESS_DELETE',             'Partie löschen');
-define('_MD_CHESS_WANT_ARBITRATION',   'Schiedsurteil anfordern');
-define('_MD_CHESS_MOVE_EXPLAIN',       'Bitte Begründung angeben.');
-define('_MD_CHESS_AFTER_MOVE',         'nach Zug');
+define('_MD_CHESS_NORMAL_MOVE', 'Normaler Zug');
+define('_MD_CHESS_RESIGN', 'Aufgeben');
+define('_MD_CHESS_OFFER_DRAW', 'Remis anbieten');
+define('_MD_CHESS_ACCEPT_DRAW', 'Remis annehmen');
+define('_MD_CHESS_REJECT_DRAW', 'Remis ablehnen');
+define('_MD_CHESS_CLAIM_DRAW_50', 'Remis fordern (50-Zug-Regel)');
+define('_MD_CHESS_CLAIM_DRAW_3', 'Remis fordern (dreifache Wiederholung)');
+define('_MD_CHESS_RESTART', 'Partie neu starten');
+define('_MD_CHESS_DELETE', 'Partie löschen');
+define('_MD_CHESS_WANT_ARBITRATION', 'Schiedsurteil anfordern');
+define('_MD_CHESS_MOVE_EXPLAIN', 'Bitte Begründung angeben.');
+define('_MD_CHESS_AFTER_MOVE', 'nach Zug');
 
 define('_MD_CHESS_DELETE_WARNING', 'Dieser Vorgang wird die Partie unwiederruflich aus der Datenbank löschen!');
 
 define('_MD_CHESS_BUTTON_REFRESH', 'Aktualisieren');
 
 define('_MD_CHESS_ORIENTATION_ACTIVE', 'Aktive Farbe unten');
-define('_MD_CHESS_ORIENTATION_WHITE',  'Weiß unten');
-define('_MD_CHESS_ORIENTATION_BLACK',  'Schwarz unten');
-
-define('_MD_CHESS_ARBITER_CONTROLS',  'Schiedsrichter-Optionen');
-define('_MD_CHESS_ARBITER_SUSPEND',   'Spiel unterbrechen');
-define('_MD_CHESS_ARBITER_RESUME',    'Spiel wieder aufnehmen');
-define('_MD_CHESS_ARBITER_DRAW',      'Remis verkünden');
-define('_MD_CHESS_ARBITER_EXPLAIN',   'Bitte Begründung angeben.');
-define('_MD_CHESS_ARBITER_DELETE',    'Partie löschen');
-define('_MD_CHESS_ARBITER_NOACTION',  'Keine Aktion');
-define('_MD_CHESS_ARBITER_SHOWCTRL',  'Schiedsrichter-Optionen zeigen');
+define('_MD_CHESS_ORIENTATION_WHITE', 'Weiß unten');
+define('_MD_CHESS_ORIENTATION_BLACK', 'Schwarz unten');
+
+define('_MD_CHESS_ARBITER_CONTROLS', 'Schiedsrichter-Optionen');
+define('_MD_CHESS_ARBITER_SUSPEND', 'Spiel unterbrechen');
+define('_MD_CHESS_ARBITER_RESUME', 'Spiel wieder aufnehmen');
+define('_MD_CHESS_ARBITER_DRAW', 'Remis verkünden');
+define('_MD_CHESS_ARBITER_EXPLAIN', 'Bitte Begründung angeben.');
+define('_MD_CHESS_ARBITER_DELETE', 'Partie löschen');
+define('_MD_CHESS_ARBITER_NOACTION', 'Keine Aktion');
+define('_MD_CHESS_ARBITER_SHOWCTRL', 'Schiedsrichter-Optionen zeigen');
 
 define('_MD_CHESS_ARBITER_DELETE_WARNING', 'Dieser Vorgang wird die Partie unwiederruflich aus der Datenbank löschen!');
 
 define('_MD_CHESS_BUTTON_ARBITRATE', 'absenden');
 
-define('_MD_CHESS_WHEN_SUSPENDED',    'Wenn unterbrochen');
-define('_MD_CHESS_SUSPENDED_BY',      'Unterbrochen von');
-define('_MD_CHESS_SUSPENSION_TYPE',   'Art der Unterbrechung');
+define('_MD_CHESS_WHEN_SUSPENDED', 'Wenn unterbrochen');
+define('_MD_CHESS_SUSPENDED_BY', 'Unterbrochen von');
+define('_MD_CHESS_SUSPENSION_TYPE', 'Art der Unterbrechung');
 define('_MD_CHESS_SUSPENSION_REASON', 'Grund der Unterbrechung');
-define('_MD_CHESS_UNKNOWN',           '*unbekannt*');
+define('_MD_CHESS_UNKNOWN', '*unbekannt*');
 define('_MD_CHESS_SUSP_TYPE_ARBITER', 'Vom Schiedsrichter unterbrochen');
-define('_MD_CHESS_SUSP_TYPE_PLAYER',  'Schiedsurteil angefordert');
+define('_MD_CHESS_SUSP_TYPE_PLAYER', 'Schiedsurteil angefordert');
 
-define('_MD_CHESS_MOVE_ENTRY',      'Zug-Eintrag');
-define('_MD_CHESS_MOVE_LIST',       'Liste der Züge');
-define('_MD_CHESS_EXPORT_FORMATS',  'Exportieren');
+define('_MD_CHESS_MOVE_ENTRY', 'Zug-Eintrag');
+define('_MD_CHESS_MOVE_LIST', 'Liste der Züge');
+define('_MD_CHESS_EXPORT_FORMATS', 'Exportieren');
 define('_MD_CHESS_CAPTURED_PIECES', 'Eroberte Figuren');
 
 // Notifications
-define('_MD_CHESS_WHITE',          'Weiß');
-define('_MD_CHESS_BLACK',          'Schwarz');
-define('_MD_CHESS_RESIGNED',       'hat aufgegeben.');
-define('_MD_CHESS_OFFERED_DRAW',   'hat Remis angeboten.');
-define('_MD_CHESS_ACCEPTED_DRAW',  'hat Remis angenommen.');
-define('_MD_CHESS_REJECTED_DRAW',  'hat Remis abgelehnt.');
-define('_MD_CHESS_RQSTED_ARBT',    'hat Schiedsurteil angefordert.');
+define('_MD_CHESS_WHITE', 'Weiß');
+define('_MD_CHESS_BLACK', 'Schwarz');
+define('_MD_CHESS_RESIGNED', 'hat aufgegeben.');
+define('_MD_CHESS_OFFERED_DRAW', 'hat Remis angeboten.');
+define('_MD_CHESS_ACCEPTED_DRAW', 'hat Remis angenommen.');
+define('_MD_CHESS_REJECTED_DRAW', 'hat Remis abgelehnt.');
+define('_MD_CHESS_RQSTED_ARBT', 'hat Schiedsurteil angefordert.');
 define('_MD_CHESS_BEEN_SUSPENDED', 'Partie ist unterbrochen, Schiedsurteil wird erwartet.');
-define('_MD_CHESS_AS_ARBITER',     'ist Schiedsrichter');
-define('_MD_CHESS_RESUMED_PLAY',   'hat Partie wieder aufgenommen.');
-define('_MD_CHESS_DECLARED_DRAW',  'hat Remis gefordert.');
-define('_MD_CHESS_DELETED_GAME',   'hat die Partie gelöscht.');
+define('_MD_CHESS_AS_ARBITER', 'ist Schiedsrichter');
+define('_MD_CHESS_RESUMED_PLAY', 'hat Partie wieder aufgenommen.');
+define('_MD_CHESS_DECLARED_DRAW', 'hat Remis gefordert.');
+define('_MD_CHESS_DELETED_GAME', 'hat die Partie gelöscht.');
 define('_MD_CHESS_SUSPENDED_PLAY', '$username (Schiedsrichter) hat die Partie unterbrochen.');
 
 // FEN setup errors
-define('_MD_CHESS_FENBAD_LENGTH',          'ungültige Länge');
-define('_MD_CHESS_FENBAD_FIELD_COUNT',     'falsche Anzahl an Feldern');
-define('_MD_CHESS_FENBAD_PP_INVALID',      'Figur ungültig plaziert.');
-define('_MD_CHESS_FENBAD_AC_INVALID',      'aktive Farbe ungültig');
-define('_MD_CHESS_FENBAD_CA_INVALID',      'ungültige Rochade');
-define('_MD_CHESS_FENBAD_EP_INVALID',      'en passant Zielfeld ungültig');
-define('_MD_CHESS_FENBAD_HC_INVALID',      'ungültige Zeit für halben Zug');
-define('_MD_CHESS_FENBAD_FN_INVALID',      'ungültige Zuganzahl');
-define('_MD_CHESS_FENBAD_MATERIAL',        'unzureichende Paar-Informationen');
-define('_MD_CHESS_FENBAD_IN_CHECK',        'aktiver Spieler darf Gegner nicht in Schach haben');
+define('_MD_CHESS_FENBAD_LENGTH', 'ungültige Länge');
+define('_MD_CHESS_FENBAD_FIELD_COUNT', 'falsche Anzahl an Feldern');
+define('_MD_CHESS_FENBAD_PP_INVALID', 'Figur ungültig plaziert.');
+define('_MD_CHESS_FENBAD_AC_INVALID', 'aktive Farbe ungültig');
+define('_MD_CHESS_FENBAD_CA_INVALID', 'ungültige Rochade');
+define('_MD_CHESS_FENBAD_EP_INVALID', 'en passant Zielfeld ungültig');
+define('_MD_CHESS_FENBAD_HC_INVALID', 'ungültige Zeit für halben Zug');
+define('_MD_CHESS_FENBAD_FN_INVALID', 'ungültige Zuganzahl');
+define('_MD_CHESS_FENBAD_MATERIAL', 'unzureichende Paar-Informationen');
+define('_MD_CHESS_FENBAD_IN_CHECK', 'aktiver Spieler darf Gegner nicht in Schach haben');
 define('_MD_CHESS_FENBAD_CA_INCONSISTENT', 'Möglichkeit zur Rochade in dieser Spielsituation ungültig');
-define('_MD_CHESS_FENBAD_EP_COLOR',        'en passant Zielfeld hat die falsche Farbe');
-define('_MD_CHESS_FENBAD_EP_NO_PAWN',      'en passant Zielfeld für nicht existenten Bauern');
+define('_MD_CHESS_FENBAD_EP_COLOR', 'en passant Zielfeld hat die falsche Farbe');
+define('_MD_CHESS_FENBAD_EP_NO_PAWN', 'en passant Zielfeld für nicht existenten Bauern');
 
 // Move-messages
 // Some of these messages are processed with eval() in ChessGame::move_msg(), and may contain parameters $param[1], $param[2], etc.
-define('_MD_CHESS_MOVE_UNKNOWN',           'ERROR (autocomplete): format ist unbekannt!');
-define('_MD_CHESS_MOVE_PAWN_MAY_BECOME',   'ERROR (autocomplete): Ein Bauer kann nur zu einem Turm, einem Läufer, einem Springer oder einer Dame werden!');
-define('_MD_CHESS_MOVE_USE_X',             'ERROR (autocomplete): x erforderlich, weist auf Angriff hin');
-define('_MD_CHESS_MOVE_COORD_INVALID',     'ERROR (autocomplete): Feld {$param[1]} existiert nicht');
-define('_MD_CHESS_MOVE_CANNOT_FIND_PAWN',  'ERROR (autocomplete): Kein {$param[1]} Bauer in Spalte {$param[2]}');
-define('_MD_CHESS_MOVE_USE_NOTATION',      'ERROR (autocomplete): Bitte folgende Notation für Bauernangriffe benutzen: [a-h]x[a-h][1-8] (siehe Hilfeseiten)');
-define('_MD_CHESS_MOVE_NO_PAWN',           'ERROR (autocomplete): Es gibt keinen Bauern in Spalte in {$param[1]}');
-define('_MD_CHESS_MOVE_TWO_PAWNS',         'ERROR (autocomplete): Es gibt mehr als einen Bauern in Spalte {$param[1]}');
-define('_MD_CHESS_MOVE_NO_FIGURE',         'ERROR (autocomplete): Es gibt keine Figur {$param[1]} = {$param[2]}');
+define('_MD_CHESS_MOVE_UNKNOWN', 'ERROR (autocomplete): format ist unbekannt!');
+define('_MD_CHESS_MOVE_PAWN_MAY_BECOME', 'ERROR (autocomplete): Ein Bauer kann nur zu einem Turm, einem Läufer, einem Springer oder einer Dame werden!');
+define('_MD_CHESS_MOVE_USE_X', 'ERROR (autocomplete): x erforderlich, weist auf Angriff hin');
+define('_MD_CHESS_MOVE_COORD_INVALID', 'ERROR (autocomplete): Feld {$param[1]} existiert nicht');
+define('_MD_CHESS_MOVE_CANNOT_FIND_PAWN', 'ERROR (autocomplete): Kein {$param[1]} Bauer in Spalte {$param[2]}');
+define('_MD_CHESS_MOVE_USE_NOTATION', 'ERROR (autocomplete): Bitte folgende Notation für Bauernangriffe benutzen: [a-h]x[a-h][1-8] (siehe Hilfeseiten)');
+define('_MD_CHESS_MOVE_NO_PAWN', 'ERROR (autocomplete): Es gibt keinen Bauern in Spalte in {$param[1]}');
+define('_MD_CHESS_MOVE_TWO_PAWNS', 'ERROR (autocomplete): Es gibt mehr als einen Bauern in Spalte {$param[1]}');
+define('_MD_CHESS_MOVE_NO_FIGURE', 'ERROR (autocomplete): Es gibt keine Figur {$param[1]} = {$param[2]}');
 define('_MD_CHESS_MOVE_NEITHER_CAN_REACH', 'ERROR (autocomplete): keiner von {$param[1]} = {$param[2]} kann {$param[3]} erreichen');
-define('_MD_CHESS_MOVE_BOTH_CAN_REACH',    'ERROR (autocomplete): beide {$param[1]} = {$param[2]} können {$param[3]} erreichen');
-define('_MD_CHESS_MOVE_AMBIGUOUS',         'ERROR (autocomplete): Mehrdeutigkeit konnte nicht gelöst werden');
-define('_MD_CHESS_MOVE_UNDEFINED',         'ERROR: undefiniert');
-define('_MD_CHESS_MOVE_GAME_OVER',         'ERROR: Diese Partie ist beendet. Es ist nicht möglich, weitere Züge abzusetzen.');
-define('_MD_CHESS_MOVE_NO_CASTLE',         'ERROR: Rochade nicht möglich.');
-define('_MD_CHESS_MOVE_INVALID_PIECE',     'ERROR: Nur N (Springer), B (Läufer), R (Turm) und Q (Dame) sind gültige Figurenbezeichner');
-define('_MD_CHESS_MOVE_UNKNOWN_FIGURE',    'ERROR: Figur {$param[1]} ist nicht bekannt!');
-define('_MD_CHESS_MOVE_TILE_EMPTY',        'ERROR: Feld {$param[1]} ist leer');
-define('_MD_CHESS_MOVE_NOT_YOUR_PIECE',    'ERROR: Diese Figur gehört nicht zu den eigenen!');
-define('_MD_CHESS_MOVE_NOEXIST_FIGURE',    'ERROR: Diese Figur existiert nicht!');
-define('_MD_CHESS_MOVE_START_END_SAME',    'ERROR: Position und Zielfeld sind identisch!');
-define('_MD_CHESS_MOVE_UNKNOWN_ACTION',    'ERROR: {$param[1]} ist unbekannt! Bitte "-" für Bewegungen und "x" für Angriffe angeben.');
-define('_MD_CHESS_MOVE_OUT_OF_RANGE',      'ERROR: Feld {$param[1]} ist außer Reichweite für {$param[2]} auf {$param[3]}!');
-define('_MD_CHESS_MOVE_OCCUPIED',          'ERROR: Feld {$param[1]} ist besetzt. Zug nicht möglich.');
-define('_MD_CHESS_MOVE_NO_EN_PASSANT'  ,   'ERROR: en-passant nicht möglich!');
-define('_MD_CHESS_MOVE_ATTACK_EMPTY',      'ERROR: Feld {$param[1]} ist leer. Angriff nicht möglich."');
-define('_MD_CHESS_MOVE_ATTACK_SELF',       'ERROR: Angriff auf eigene Figur auf {$param[1]} nicht möglich.');
-define('_MD_CHESS_MOVE_IN_CHECK',          'ERROR: Zug nicht möglich, würde den eigenen König in Schach setzen.');
-define('_MD_CHESS_MOVE_CASTLED_SHORT',     'Kurze Rochade ausgeführt.');
-define('_MD_CHESS_MOVE_CASTLED_LONG',      'Lange Rochade ausgeführt.');
-define('_MD_CHESS_MOVE_MOVED',             '{$param[1]} von {$param[2]} nach {$param[3]} gesetzt');
-define('_MD_CHESS_MOVE_CAPTURED',          '{$param[1]} schlägt {$param[2]} auf {$param[3]}');
-define('_MD_CHESS_MOVE_PROMOTED',          'und wird zu {$param[1]}!');
-define('_MD_CHESS_MOVE_CHECKMATE',         'Schachmatt!');
-define('_MD_CHESS_MOVE_STALEMATE',         'Patt!');
-define('_MD_CHESS_MOVE_MATERIAL',          'unzureichende Paar-Information!');
-define('_MD_CHESS_MOVE_KING',              'König');
-define('_MD_CHESS_MOVE_QUEEN',             'Dame');
-define('_MD_CHESS_MOVE_ROOK',              'Turm');
-define('_MD_CHESS_MOVE_BISHOP',            'Läufer');
-define('_MD_CHESS_MOVE_KNIGHT',            'Springer');
-define('_MD_CHESS_MOVE_PAWN',              'Bauer');
-define('_MD_CHESS_MOVE_EMPTY',             'leer');
+define('_MD_CHESS_MOVE_BOTH_CAN_REACH', 'ERROR (autocomplete): beide {$param[1]} = {$param[2]} können {$param[3]} erreichen');
+define('_MD_CHESS_MOVE_AMBIGUOUS', 'ERROR (autocomplete): Mehrdeutigkeit konnte nicht gelöst werden');
+define('_MD_CHESS_MOVE_UNDEFINED', 'ERROR: undefiniert');
+define('_MD_CHESS_MOVE_GAME_OVER', 'ERROR: Diese Partie ist beendet. Es ist nicht möglich, weitere Züge abzusetzen.');
+define('_MD_CHESS_MOVE_NO_CASTLE', 'ERROR: Rochade nicht möglich.');
+define('_MD_CHESS_MOVE_INVALID_PIECE', 'ERROR: Nur N (Springer), B (Läufer), R (Turm) und Q (Dame) sind gültige Figurenbezeichner');
+define('_MD_CHESS_MOVE_UNKNOWN_FIGURE', 'ERROR: Figur {$param[1]} ist nicht bekannt!');
+define('_MD_CHESS_MOVE_TILE_EMPTY', 'ERROR: Feld {$param[1]} ist leer');
+define('_MD_CHESS_MOVE_NOT_YOUR_PIECE', 'ERROR: Diese Figur gehört nicht zu den eigenen!');
+define('_MD_CHESS_MOVE_NOEXIST_FIGURE', 'ERROR: Diese Figur existiert nicht!');
+define('_MD_CHESS_MOVE_START_END_SAME', 'ERROR: Position und Zielfeld sind identisch!');
+define('_MD_CHESS_MOVE_UNKNOWN_ACTION', 'ERROR: {$param[1]} ist unbekannt! Bitte "-" für Bewegungen und "x" für Angriffe angeben.');
+define('_MD_CHESS_MOVE_OUT_OF_RANGE', 'ERROR: Feld {$param[1]} ist außer Reichweite für {$param[2]} auf {$param[3]}!');
+define('_MD_CHESS_MOVE_OCCUPIED', 'ERROR: Feld {$param[1]} ist besetzt. Zug nicht möglich.');
+define('_MD_CHESS_MOVE_NO_EN_PASSANT', 'ERROR: en-passant nicht möglich!');
+define('_MD_CHESS_MOVE_ATTACK_EMPTY', 'ERROR: Feld {$param[1]} ist leer. Angriff nicht möglich."');
+define('_MD_CHESS_MOVE_ATTACK_SELF', 'ERROR: Angriff auf eigene Figur auf {$param[1]} nicht möglich.');
+define('_MD_CHESS_MOVE_IN_CHECK', 'ERROR: Zug nicht möglich, würde den eigenen König in Schach setzen.');
+define('_MD_CHESS_MOVE_CASTLED_SHORT', 'Kurze Rochade ausgeführt.');
+define('_MD_CHESS_MOVE_CASTLED_LONG', 'Lange Rochade ausgeführt.');
+define('_MD_CHESS_MOVE_MOVED', '{$param[1]} von {$param[2]} nach {$param[3]} gesetzt');
+define('_MD_CHESS_MOVE_CAPTURED', '{$param[1]} schlägt {$param[2]} auf {$param[3]}');
+define('_MD_CHESS_MOVE_PROMOTED', 'und wird zu {$param[1]}!');
+define('_MD_CHESS_MOVE_CHECKMATE', 'Schachmatt!');
+define('_MD_CHESS_MOVE_STALEMATE', 'Patt!');
+define('_MD_CHESS_MOVE_MATERIAL', 'unzureichende Paar-Information!');
+define('_MD_CHESS_MOVE_KING', 'König');
+define('_MD_CHESS_MOVE_QUEEN', 'Dame');
+define('_MD_CHESS_MOVE_ROOK', 'Turm');
+define('_MD_CHESS_MOVE_BISHOP', 'Läufer');
+define('_MD_CHESS_MOVE_KNIGHT', 'Springer');
+define('_MD_CHESS_MOVE_PAWN', 'Bauer');
+define('_MD_CHESS_MOVE_EMPTY', 'leer');
 
 // miscellaneous
-define('_MD_CHESS_GAME_CONFIRM',         'Einstellungen für diese Partie bestätigen.');
-define('_MD_CHESS_GAME_CREATED',         'Partie erstellt');
-define('_MD_CHESS_GAME_STARTED',         'Partie begonnen');
-define('_MD_CHESS_LABEL_DATE_CREATED',   'Datum erstellt');
+define('_MD_CHESS_GAME_CONFIRM', 'Einstellungen für diese Partie bestätigen.');
+define('_MD_CHESS_GAME_CREATED', 'Partie erstellt');
+define('_MD_CHESS_GAME_STARTED', 'Partie begonnen');
+define('_MD_CHESS_LABEL_DATE_CREATED', 'Datum erstellt');
 define('_MD_CHESS_LABEL_GAME_SUSPENDED', 'Partie unterbrochen');
-define('_MD_CHESS_WHITE_OFFERED_DRAW',   'Weiß hat Remis angeboten. Schwarz muß annehmen oder ablehnen.');
-define('_MD_CHESS_BLACK_OFFERED_DRAW',   'Schwarz hat Remis angeboten. Weiß muß annehmen oder ablehnen.');
+define('_MD_CHESS_WHITE_OFFERED_DRAW', 'Weiß hat Remis angeboten. Schwarz muß annehmen oder ablehnen.');
+define('_MD_CHESS_BLACK_OFFERED_DRAW', 'Schwarz hat Remis angeboten. Weiß muß annehmen oder ablehnen.');
 
 // PGN movetext comments for drawn games - must not contain comment delimiters '{' or '}'
-define('_MD_CHESS_DRAW_STALEMATE',    'Remis durch Patt.');
-define('_MD_CHESS_DRAW_NO_MATE',      'Remis, da kein Schachmatt mehr möglich.');
+define('_MD_CHESS_DRAW_STALEMATE', 'Remis durch Patt.');
+define('_MD_CHESS_DRAW_NO_MATE', 'Remis, da kein Schachmatt mehr möglich.');
 define('_MD_CHESS_DRAW_BY_AGREEMENT', 'Remis in beidseitigem Einvernehmen.');
-define('_MD_CHESS_DRAW_DECLARED',     'Remis vom Schiedsrichter entschieden, Begründung: %s.');
-define('_MD_CHESS_DRAW_50',           'Remis durch 50-Zug-Regel.');
-define('_MD_CHESS_DRAW_3',            'Remis durch dreimalige-Wiederholung-Regel, ausgehend von Brettstellung vor den Zügen %s.');
+define('_MD_CHESS_DRAW_DECLARED', 'Remis vom Schiedsrichter entschieden, Begründung: %s.');
+define('_MD_CHESS_DRAW_50', 'Remis durch 50-Zug-Regel.');
+define('_MD_CHESS_DRAW_3', 'Remis durch dreimalige-Wiederholung-Regel, ausgehend von Brettstellung vor den Zügen %s.');
 
-define('_MD_CHESS_NO_DRAW_50',        'Die Bedingungen für ein Remis nach der 50-Zug-Regel wurden nicht erfüllt.');
-define('_MD_CHESS_NO_DRAW_3',         'Die Bedingungen für ein Remis nach der dreimalige-Wiederholung-Regel wurden nicht erfüllt.');
+define('_MD_CHESS_NO_DRAW_50', 'Die Bedingungen für ein Remis nach der 50-Zug-Regel wurden nicht erfüllt.');
+define('_MD_CHESS_NO_DRAW_3', 'Die Bedingungen für ein Remis nach der dreimalige-Wiederholung-Regel wurden nicht erfüllt.');
 
 // menu options
-define('_MD_CHESS_SHOW_GAMES_INPLAY',    'Zeige nur aktive Partien');
+define('_MD_CHESS_SHOW_GAMES_INPLAY', 'Zeige nur aktive Partien');
 define('_MD_CHESS_SHOW_GAMES_CONCLUDED', 'Zeige nur beendete Partien');
-define('_MD_CHESS_SHOW_GAMES_BOTH',      'Zeige alle Partien');
-define('_MD_CHESS_SHOW_GAMES_RATED',     'Zeige nur bewertete Partien');
-define('_MD_CHESS_SHOW_GAMES_UNRATED',   'Zeige bewertete und unbewertete Partien');
+define('_MD_CHESS_SHOW_GAMES_BOTH', 'Zeige alle Partien');
+define('_MD_CHESS_SHOW_GAMES_RATED', 'Zeige nur bewertete Partien');
+define('_MD_CHESS_SHOW_GAMES_UNRATED', 'Zeige bewertete und unbewertete Partien');
 define('_MD_CHESS_SHOW_CHALLENGES_OPEN', 'Zeige nur offene Herausforderungen');
 define('_MD_CHESS_SHOW_CHALLENGES_USER', 'Zeige nur persönliche Herausforderungen');
 define('_MD_CHESS_SHOW_CHALLENGES_BOTH', 'Zeige alle Herausforderungen');
 
 // ratings
-define('_MD_CHESS_RATED_GAME',           'Bewertete Partie');
-define('_MD_CHESS_RATINGS_OFF',          'Bewertungen nicht aktiv.');
-define('_MD_CHESS_PLAYER_RATINGS',       'Bewertung des Spielers');
-define('_MD_CHESS_RATING',               'Bewertung');
-define('_MD_CHESS_PLAYER',               'Spieler');
-define('_MD_CHESS_GAMES_PLAYED',         'Bewertete beendete Partien');
-define('_MD_CHESS_PROVISIONAL',          'vorläufige Bewertung (weniger als %s bewertete Partien gespielt)');
-define('_MD_CHESS_NA',                   'n/a'); // not applicable or not available
-define('_MD_CHESS_NO_RATING_INFO',       'Keine Bewertungen gefunden.');
-define('_MD_CHESS_RECALC_RATINGS',       'Bewertungen für alle Spieler neu berechnen (nur für Modul-Administratoren möglich)');
-define('_MD_CHESS_SUBMIT_BUTTON',        'absenden');
-define('_MD_CHESS_RECALC_CONFIRM',       'Ja, ich bin sicher, daß ich das tun will.');
-define('_MD_CHESS_RECALC_DONE',          'Bewertungen neu berechnet.');
-define('_MD_CHESS_RECALC_NOT_DONE',      'Bewertungen nicht neu berechnet, da Bestätigungskästchen nicht gesetzt war.');
-define('_MD_CHESS_LAST_ACTIVITY',        'Letzte Aktivität');
-define('_MD_CHESS_STATUS',               'Status');
-define('_MD_CHESS_DRAWN',                'Remis');
-define('_MD_CHESS_WON',                  'gewonnen');
-define('_MD_CHESS_LOST',                 'verloren');
-define('_MD_CHESS_RANKED',               'bewertet');
-define('_MD_CHESS_RATED_GAMES_PLAYED',   'bewertete Partien');
-define('_MD_CHESS_CHALLENGES_FOR',       'Herausforderungen für: %s');
-define('_MD_CHESS_GAMES_FOR',            'Schachpartien für: %s');
-define('_MD_CHESS_STATS_FOR',            'Statistiken für: %s');
-define('_MD_CHESS_SELECT_PLAYER',        'Auswahl Spieler und Sichtbarkeit');
-define('_MD_CHESS_USERNAME',             'Benutzername');
-define('_MD_CHESS_SHOW_ALL_GAMES',       'Zeige alle Partien');
+define('_MD_CHESS_RATED_GAME', 'Bewertete Partie');
+define('_MD_CHESS_RATINGS_OFF', 'Bewertungen nicht aktiv.');
+define('_MD_CHESS_PLAYER_RATINGS', 'Bewertung des Spielers');
+define('_MD_CHESS_RATING', 'Bewertung');
+define('_MD_CHESS_PLAYER', 'Spieler');
+define('_MD_CHESS_GAMES_PLAYED', 'Bewertete beendete Partien');
+define('_MD_CHESS_PROVISIONAL', 'vorläufige Bewertung (weniger als %s bewertete Partien gespielt)');
+define('_MD_CHESS_NA', 'n/a'); // not applicable or not available
+define('_MD_CHESS_NO_RATING_INFO', 'Keine Bewertungen gefunden.');
+define('_MD_CHESS_RECALC_RATINGS', 'Bewertungen für alle Spieler neu berechnen (nur für Modul-Administratoren möglich)');
+define('_MD_CHESS_SUBMIT_BUTTON', 'absenden');
+define('_MD_CHESS_RECALC_CONFIRM', 'Ja, ich bin sicher, daß ich das tun will.');
+define('_MD_CHESS_RECALC_DONE', 'Bewertungen neu berechnet.');
+define('_MD_CHESS_RECALC_NOT_DONE', 'Bewertungen nicht neu berechnet, da Bestätigungskästchen nicht gesetzt war.');
+define('_MD_CHESS_LAST_ACTIVITY', 'Letzte Aktivität');
+define('_MD_CHESS_STATUS', 'Status');
+define('_MD_CHESS_DRAWN', 'Remis');
+define('_MD_CHESS_WON', 'gewonnen');
+define('_MD_CHESS_LOST', 'verloren');
+define('_MD_CHESS_RANKED', 'bewertet');
+define('_MD_CHESS_RATED_GAMES_PLAYED', 'bewertete Partien');
+define('_MD_CHESS_CHALLENGES_FOR', 'Herausforderungen für: %s');
+define('_MD_CHESS_GAMES_FOR', 'Schachpartien für: %s');
+define('_MD_CHESS_STATS_FOR', 'Statistiken für: %s');
+define('_MD_CHESS_SELECT_PLAYER', 'Auswahl Spieler und Sichtbarkeit');
+define('_MD_CHESS_USERNAME', 'Benutzername');
+define('_MD_CHESS_SHOW_ALL_GAMES', 'Zeige alle Partien');
 define('_MD_CHESS_SHOW_EXCEPT_SELFPLAY', 'Zeige alle Partien außer denen gegen mich selbst');
-define('_MD_CHESS_SHOW_RATED_ONLY',      'Zeige nur bewertete Partien');
-define('_MD_CHESS_PLAYER_NOT_FOUND',     'Keine Partie-Informationen für diesen Spieler gefunden.');
-define('_MD_CHESS_VIEW_PROFILE',         'Zeige Profil dieses Spielers');
+define('_MD_CHESS_SHOW_RATED_ONLY', 'Zeige nur bewertete Partien');
+define('_MD_CHESS_PLAYER_NOT_FOUND', 'Keine Partie-Informationen für diesen Spieler gefunden.');
+define('_MD_CHESS_VIEW_PROFILE', 'Zeige Profil dieses Spielers');
 
 /**#@-*/
 

ratings.php

Spacing +17 added lines, -17 removed lines

@@ -35,20 +35,20 @@ 
 /**#@+
  */
 require_once '../../mainfile.php';
-require_once XOOPS_ROOT_PATH . '/class/xoopsformloader.php';
-require_once XOOPS_ROOT_PATH . '/class/pagenav.php';
-require_once XOOPS_ROOT_PATH . '/modules/chess/include/constants.inc.php';
-require_once XOOPS_ROOT_PATH . '/modules/chess/include/functions.inc.php';
-require_once XOOPS_ROOT_PATH . '/modules/chess/include/ratings.inc.php';
+require_once XOOPS_ROOT_PATH.'/class/xoopsformloader.php';
+require_once XOOPS_ROOT_PATH.'/class/pagenav.php';
+require_once XOOPS_ROOT_PATH.'/modules/chess/include/constants.inc.php';
+require_once XOOPS_ROOT_PATH.'/modules/chess/include/functions.inc.php';
+require_once XOOPS_ROOT_PATH.'/modules/chess/include/ratings.inc.php';
 
 // check whether the rating feature is enabled
 if (chess_moduleConfig('rating_system') == 'none') {
-	redirect_header(XOOPS_URL . '/modules/chess/index.php', _CHESS_REDIRECT_DELAY_FAILURE, _MD_CHESS_RATINGS_OFF);
+	redirect_header(XOOPS_URL.'/modules/chess/index.php', _CHESS_REDIRECT_DELAY_FAILURE, _MD_CHESS_RATINGS_OFF);
 }
 
 $xoopsOption['template_main'] = 'chess_ratings.html';
 $xoopsConfig['module_cache'][$xoopsModule->getVar('mid')] = 0; // disable caching
-require_once XOOPS_ROOT_PATH . '/header.php';
+require_once XOOPS_ROOT_PATH.'/header.php';
 
 // user input
 $submit_recalc_ratings  = isset($_POST['submit_recalc_ratings']);
@@ -59,8 +59,8 @@ 
 
 // If form-submit, check security token.
 if ($submit_recalc_ratings and is_object($GLOBALS['xoopsSecurity']) and !$GLOBALS['xoopsSecurity']->check()) {
-	redirect_header(XOOPS_URL . '/modules/chess/ratings.php', _CHESS_REDIRECT_DELAY_FAILURE,
-		_MD_CHESS_TOKEN_ERROR . '<br />' . implode('<br />', $GLOBALS['xoopsSecurity']->getErrors()));
+	redirect_header(XOOPS_URL.'/modules/chess/ratings.php', _CHESS_REDIRECT_DELAY_FAILURE,
+		_MD_CHESS_TOKEN_ERROR.'<br />'.implode('<br />', $GLOBALS['xoopsSecurity']->getErrors()));
 }
 
 $msg       = '';
@@ -81,7 +81,7 @@ 
 // Display the ratings.
 chess_ratings($start, $msg, $msg_class);
 
-require_once XOOPS_ROOT_PATH . '/footer.php';
+require_once XOOPS_ROOT_PATH.'/footer.php';
 /**#@-*/
 
 /**
@@ -143,9 +143,9 @@ 
 	$xoopsDB->freeRecordSet($result);
 
 	// get mapping of user IDs to usernames
-	$member_handler =& xoops_gethandler('member');
-	$criteria       =  new Criteria('uid', '(' . implode(',', $userids) . ')', 'IN');
-	$usernames      =  $member_handler->getUserList($criteria);
+	$member_handler = & xoops_gethandler('member');
+	$criteria       = new Criteria('uid', '('.implode(',', $userids).')', 'IN');
+	$usernames      = $member_handler->getUserList($criteria);
 
 	// add usernames to $players
 	foreach ($players as $k => $player) {
@@ -177,10 +177,10 @@ 
 // Template variables
 
 	$xoopsTpl->assign('chess_provisional_games', chess_ratings_num_provisional_games());
-	$xoopsTpl->assign('chess_msg',               $msg);
-	$xoopsTpl->assign('chess_msg_class',         $msg_class);
-	$xoopsTpl->assign('chess_players_pagenav',   $pagenav->renderNav());
-	$xoopsTpl->assign('chess_players',           $players);
+	$xoopsTpl->assign('chess_msg', $msg);
+	$xoopsTpl->assign('chess_msg_class', $msg_class);
+	$xoopsTpl->assign('chess_players_pagenav', $pagenav->renderNav());
+	$xoopsTpl->assign('chess_players', $players);
 }
 
 ?>

class/chessgame.inc.php

Indentation +581 added lines, -581 removed lines

@@ -53,34 +53,34 @@ 
 class ChessGame {
 
 	/**
-    * Indicates whether object is valid.
-    *
-    * If empty string (''), indicates this is a valid object; otherwise contains an error message.
+	 * Indicates whether object is valid.
+	 *
+	 * If empty string (''), indicates this is a valid object; otherwise contains an error message.
 	 * Should be checked after creating an instance of this class.
-    *
-    * @var string $error
-    */
+	 *
+	 * @var string $error
+	 */
 	var $error;
 
    /**
     * gamestate
     *
-	 * The game state is represented as an array with the following elements:
-	 *
-	 *  - 'fen_piece_placement'
-	 *  - 'fen_active_color'
-	 *  - 'fen_castling_availability'
-	 *  - 'fen_en_passant_target_square'
-	 *  - 'fen_halfmove_clock'
-	 *  - 'fen_fullmove_number'
-	 *  - 'pgn_result'
-	 *  - 'pgn_fen'
-	 *  - 'pgn_movetext'
-	 *
-	 * The elements prefixed with 'fen_' are standard Forsyth-Edwards Notation (FEN) elements,
-	 * and the elements prefixed with 'pgn_' are standard Portable Game Notation (PGN) elements.
-	 *
-	 * Each element is a string.
+    * The game state is represented as an array with the following elements:
+    *
+    *  - 'fen_piece_placement'
+    *  - 'fen_active_color'
+    *  - 'fen_castling_availability'
+    *  - 'fen_en_passant_target_square'
+    *  - 'fen_halfmove_clock'
+    *  - 'fen_fullmove_number'
+    *  - 'pgn_result'
+    *  - 'pgn_fen'
+    *  - 'pgn_movetext'
+    *
+    * The elements prefixed with 'fen_' are standard Forsyth-Edwards Notation (FEN) elements,
+    * and the elements prefixed with 'pgn_' are standard Portable Game Notation (PGN) elements.
+    *
+    * Each element is a string.
     *
     * @var array $gamestate
     */
@@ -89,23 +89,23 @@ 
    /**
     * board
     *
-	 * A 64-element array, constructed from fen_piece_placement, is used for handling moves.
-	 * Its indices are related to the standard tile coordinates as follows:
-	 *
+    * A 64-element array, constructed from fen_piece_placement, is used for handling moves.
+    * Its indices are related to the standard tile coordinates as follows:
+    *
     * <pre>
-	 * 8 | 56 57 58 59 60 61 62 63
-	 * 7 | 48 49 50 51 52 53 54 55
-	 * 6 | 40 41 42 43 44 45 46 47
-	 * 5 | 32 33 34 35 36 37 38 39
-	 * 4 | 24 25 26 27 28 29 30 31
-	 * 3 | 16 17 18 19 20 21 22 23
-	 * 2 |  8  9 10 11 12 13 14 15
-	 * 1 |  0  1  2  3  4  5  6  7
-	 *    ------------------------
-	 *      a  b  c  d  e  f  g  h
+    * 8 | 56 57 58 59 60 61 62 63
+    * 7 | 48 49 50 51 52 53 54 55
+    * 6 | 40 41 42 43 44 45 46 47
+    * 5 | 32 33 34 35 36 37 38 39
+    * 4 | 24 25 26 27 28 29 30 31
+    * 3 | 16 17 18 19 20 21 22 23
+    * 2 |  8  9 10 11 12 13 14 15
+    * 1 |  0  1  2  3  4  5  6  7
+    *    ------------------------
+    *      a  b  c  d  e  f  g  h
     * </pre>
-	 *
-	 * For example, $board[17] is tile b3 and $board[55] is tile h7.
+    *
+    * For example, $board[17] is tile b3 and $board[55] is tile h7.
     *
     * @var array $board
     */
@@ -131,13 +131,13 @@ 
 
 
    /**
-	 * updated by handleMove, not used now but might be used in future
+    * updated by handleMove, not used now but might be used in future
     * @var string $last_move
     */
 	var $last_move;
 
    /**
-	 * updated by handleMove, not used now but might be used in future
+    * updated by handleMove, not used now but might be used in future
     * @var string $captured_piece
     */
 	var $captured_piece;
@@ -455,65 +455,65 @@ 
   /* DEBUG:  echo "$fx,$fy --> $dx,$dy: "; */
   switch ( $fig )
   {
-    /* knight */
-    case 'N':
-      if ( abs($fx-$dx)==1 && abs($fy-$dy)==2 )
-        $result = 1;
-      if ( abs($fy-$dy)==1 && abs($fx-$dx)==2 )
-        $result = 1;
-      break;
-    /* bishop */
-    case 'B':
-      if ( abs($fx-$dx) != abs($fy-$dy) )
-        break;
-      if ( $dy < $fy ) $change = -8; else $change =  8;
-      if ( $dx < $fx ) $change -= 1; else $change += 1;
-      if ( $this->pathIsNotBlocked( $fig_pos+$change, $dest_pos, $change ) )
-        $result = 1;
-      break;
-    /* rook */
-    case 'R':
-      if ( $fx!=$dx && $fy!=$dy )
-        break;
-      if ( $fx==$dx ) 
-      {
-        if ( $dy<$fy ) $change = -8; else $change = 8;
-      }
-      else {
-        if ( $dx<$fx ) $change = -1; else $change = 1;
-      }
-      if ( $this->pathIsNotBlocked( $fig_pos+$change, $dest_pos, $change ) )
-        $result = 1;
-      break;
-    /* queen */
-    case 'Q':
-      if ( abs($fx-$dx) != abs($fy-$dy) && $fx!=$dx && $fy!=$dy )
-        break;
-      if ( abs($fx-$dx) == abs($fy-$dy) )
-      {
-        if ( $dy < $fy ) $change = -8; else $change =  8;
-        if ( $dx < $fx ) $change -= 1; else $change += 1;
-      }
-      else if ( $fx==$dx ) {
-        if ( $dy<$fy ) $change = -8; else $change = 8;
-      } 
-      else
-      {
-        if ( $dx<$fx ) $change = -1; else $change = 1;
-      }
-      if ( $this->pathIsNotBlocked( $fig_pos+$change, $dest_pos, $change ) )
-        $result = 1;
-      break;
-    /* king */
-    case 'K':
-      if ( abs($fx-$dx) > 1 || abs($fy-$dy) > 1 ) break;
-      $kings = 0;
-      $adj_tiles = $this->getAdjTiles( $dest_pos );
-      foreach( $adj_tiles as $tile )
-        if ($this->board[$tile]{1} == 'K' ) $kings++;
-      if ( $kings == 2 ) break;
-      $result = 1;
-      break;
+	/* knight */
+	case 'N':
+	  if ( abs($fx-$dx)==1 && abs($fy-$dy)==2 )
+		$result = 1;
+	  if ( abs($fy-$dy)==1 && abs($fx-$dx)==2 )
+		$result = 1;
+	  break;
+	/* bishop */
+	case 'B':
+	  if ( abs($fx-$dx) != abs($fy-$dy) )
+		break;
+	  if ( $dy < $fy ) $change = -8; else $change =  8;
+	  if ( $dx < $fx ) $change -= 1; else $change += 1;
+	  if ( $this->pathIsNotBlocked( $fig_pos+$change, $dest_pos, $change ) )
+		$result = 1;
+	  break;
+	/* rook */
+	case 'R':
+	  if ( $fx!=$dx && $fy!=$dy )
+		break;
+	  if ( $fx==$dx ) 
+	  {
+		if ( $dy<$fy ) $change = -8; else $change = 8;
+	  }
+	  else {
+		if ( $dx<$fx ) $change = -1; else $change = 1;
+	  }
+	  if ( $this->pathIsNotBlocked( $fig_pos+$change, $dest_pos, $change ) )
+		$result = 1;
+	  break;
+	/* queen */
+	case 'Q':
+	  if ( abs($fx-$dx) != abs($fy-$dy) && $fx!=$dx && $fy!=$dy )
+		break;
+	  if ( abs($fx-$dx) == abs($fy-$dy) )
+	  {
+		if ( $dy < $fy ) $change = -8; else $change =  8;
+		if ( $dx < $fx ) $change -= 1; else $change += 1;
+	  }
+	  else if ( $fx==$dx ) {
+		if ( $dy<$fy ) $change = -8; else $change = 8;
+	  } 
+	  else
+	  {
+		if ( $dx<$fx ) $change = -1; else $change = 1;
+	  }
+	  if ( $this->pathIsNotBlocked( $fig_pos+$change, $dest_pos, $change ) )
+		$result = 1;
+	  break;
+	/* king */
+	case 'K':
+	  if ( abs($fx-$dx) > 1 || abs($fy-$dy) > 1 ) break;
+	  $kings = 0;
+	  $adj_tiles = $this->getAdjTiles( $dest_pos );
+	  foreach( $adj_tiles as $tile )
+		if ($this->board[$tile]{1} == 'K' ) $kings++;
+	  if ( $kings == 2 ) break;
+	  $result = 1;
+	  break;
   }
 
   /* DEBUG: echo " $result<BR>"; */
@@ -533,17 +533,17 @@ 
 {
   if ( $this->board[$fig_pos]{0} == 'w' )
   {
-    if ( ($fig_pos % 8) > 0 && $dest_pos == $fig_pos+7 )
-      return 1;
-    if ( ($fig_pos % 8) < 7 && $dest_pos == $fig_pos+9 )
-      return 1;
+	if ( ($fig_pos % 8) > 0 && $dest_pos == $fig_pos+7 )
+	  return 1;
+	if ( ($fig_pos % 8) < 7 && $dest_pos == $fig_pos+9 )
+	  return 1;
   }
   else if ( $this->board[$fig_pos]{0} == 'b' )
   {
-    if ( ($fig_pos % 8) < 7 && $dest_pos == $fig_pos-7 )
-      return 1;
-    if ( ($fig_pos % 8) > 0 && $dest_pos == $fig_pos-9 )
-      return 1;
+	if ( ($fig_pos % 8) < 7 && $dest_pos == $fig_pos-7 )
+	  return 1;
+	if ( ($fig_pos % 8) > 0 && $dest_pos == $fig_pos-9 )
+	  return 1;
   }
   return 0;
 }
@@ -568,23 +568,23 @@ 
   
   if ( $this->board[$fig_pos]{0} == 'w' )
   {
-    if ( $fig_pos >= 8 && $fig_pos <= 15 )
-      $first_move = 1;
-    if ( $dest_pos==$fig_pos+8 )
-      return 1;
-    if ( $first_move && ( $dest_pos==$fig_pos+16 ) )
-    if ($this->is_empty_tile($fig_pos + 8))
-      return 1;
+	if ( $fig_pos >= 8 && $fig_pos <= 15 )
+	  $first_move = 1;
+	if ( $dest_pos==$fig_pos+8 )
+	  return 1;
+	if ( $first_move && ( $dest_pos==$fig_pos+16 ) )
+	if ($this->is_empty_tile($fig_pos + 8))
+	  return 1;
   }
   else if ($this->board[$fig_pos]{0} == 'b' )
   {
-    if ( $fig_pos >= 48 && $fig_pos <= 55 )
-      $first_move = 1;
-    if ( $dest_pos==$fig_pos-8 )
-      return 1;
-    if ( $first_move && ( $dest_pos==$fig_pos-16 ) )
-    if ($this->is_empty_tile($fig_pos - 8))
-      return 1;
+	if ( $fig_pos >= 48 && $fig_pos <= 55 )
+	  $first_move = 1;
+	if ( $dest_pos==$fig_pos-8 )
+	  return 1;
+	if ( $first_move && ( $dest_pos==$fig_pos-16 ) )
+	if ($this->is_empty_tile($fig_pos - 8))
+	  return 1;
   }
   return 0;
 }
@@ -602,16 +602,16 @@ 
 {
 #var_dump('tileIsUnderAttack, opp', $opp, 'dest_pos', $dest_pos, 'board', $board);#*#DEBUG#
   for ( $i = 0; $i < 64; $i++ )
-    if ($this->board[$i]{0} == $opp )
-    {
-      if ( ($this->board[$i]{1}=='P' && $this->checkPawnAttack($i,$dest_pos)) ||
-           ($this->board[$i]{1}!='P' && 
-                $this->tileIsReachable($this->board[$i]{1},$i,$dest_pos)) )
-      {
-        /*DEBUG: echo "attack test: $i: ",$opp,"P<BR>"; */
-        return 1;
-      }
-    }
+	if ($this->board[$i]{0} == $opp )
+	{
+	  if ( ($this->board[$i]{1}=='P' && $this->checkPawnAttack($i,$dest_pos)) ||
+		   ($this->board[$i]{1}!='P' && 
+				$this->tileIsReachable($this->board[$i]{1},$i,$dest_pos)) )
+	  {
+		/*DEBUG: echo "attack test: $i: ",$opp,"P<BR>"; */
+		return 1;
+	  }
+	}
   return 0;
 }
 
@@ -629,11 +629,11 @@ 
 
 #var_dump('kingIsUnderAttack, player', $player, 'opp', $opp, 'board', $board);#*#DEBUG#
   for ( $i = 0; $i < 64; $i++ )
-    if ($this->board[$i]{0} == $player && $this->board[$i]{1} == 'K' )
-    {
-      $king_pos = $i;
-      break;
-    }
+	if ($this->board[$i]{0} == $player && $this->board[$i]{1} == 'K' )
+	{
+	  $king_pos = $i;
+	  break;
+	}
   /*DEBUG: echo "$player king is at $king_pos<BR>"; */
   
   return $this->tileIsUnderAttack( $opp, $king_pos );
@@ -651,23 +651,23 @@ 
 function isCheckMate($player, $opp)
 {
   for ( $i = 0; $i < 64; $i++ )
-    if ($this->board[$i]{0} == $player && $this->board[$i]{1} == 'K' )
-    {
-      $king_pos = $i;
-      $king_x = $i % 8;
-      $king_y = floor($i/8);
-      break;
-    }
+	if ($this->board[$i]{0} == $player && $this->board[$i]{1} == 'K' )
+	{
+	  $king_pos = $i;
+	  $king_x = $i % 8;
+	  $king_y = floor($i/8);
+	  break;
+	}
 
   /* test adjacent tiles while king is temporarly removed */
   $adj_tiles = $this->getAdjTiles( $king_pos );
   $contents = $this->board[$king_pos]; $this->clear_tile($king_pos);
   foreach ( $adj_tiles as $dest_pos ) 
   {
-    if ($this->board[$dest_pos]{0} == $player ) continue;
-    if ( $this->tileIsUnderAttack($opp,$dest_pos) ) continue;
-    $this->board[$king_pos] = $contents;
-    return 0;
+	if ($this->board[$dest_pos]{0} == $player ) continue;
+	if ( $this->tileIsUnderAttack($opp,$dest_pos) ) continue;
+	$this->board[$king_pos] = $contents;
+	return 0;
   }
   $this->board[$king_pos] = $contents;
 
@@ -676,15 +676,15 @@ 
   /* get all figures that attack the king */
   $attackers = array(); $count = 0;
   for ( $i = 0; $i < 64; $i++ )
-    if ( $this->board[$i]{0} == $opp )
-    {
-      if ( ($this->board[$i]{1}=='P' && $this->checkPawnAttack($i,$king_pos)) ||
-           ($this->board[$i]{1}!='P' && 
-                $this->tileIsReachable($this->board[$i]{1},$i,$king_pos)) )
-      {
-          $attackers[$count++] = $i;
-      }
-    }
+	if ( $this->board[$i]{0} == $opp )
+	{
+	  if ( ($this->board[$i]{1}=='P' && $this->checkPawnAttack($i,$king_pos)) ||
+		   ($this->board[$i]{1}!='P' && 
+				$this->tileIsReachable($this->board[$i]{1},$i,$king_pos)) )
+	  {
+		  $attackers[$count++] = $i;
+	  }
+	}
   /* DEBUG: 
   for( $i = 0; $i < $count; $i++ )
     echo "Attacker: $attackers[$i] ";
@@ -696,32 +696,32 @@ 
   /* check whether attacker can be killed by own figure */
   $dest_pos = $attackers[0];
   for ( $i = 0; $i < 64; $i++ )
-    if ( $this->board[$i]{0} == $player )
-    {
-      if ( ($this->board[$i]{1}=='P' && $this->checkPawnAttack($i,$dest_pos)) ||
-           ($this->board[$i]{1}!='P' && $this->board[$i]{1}!='K' &&
-              $this->tileIsReachable($this->board[$i]{1},$i,$dest_pos)) ||
-           ($this->board[$i]{1}=='K' && 
-              $this->tileIsReachable($this->board[$i]{1},$i,$dest_pos) &&
-              !$this->tileIsUnderAttack($opp,$dest_pos)) )
-      {
-        /* DEBUG: echo "candidate: $i "; */
-        $can_kill_atk = 0;
-        $contents_def = $this->board[$i];
-        $contents_atk = $this->board[$dest_pos];
-        $this->board[$dest_pos] = $this->board[$i];
-        $this->clear_tile($i);
-        if ( !$this->tileIsUnderAttack($opp,$king_pos) )
-          $can_kill_atk = 1;
-        $this->board[$i] = $contents_def;
-        $this->board[$dest_pos] = $contents_atk;
-        if ( $can_kill_atk )
-        {
-          /* DEBUG: echo "$i can kill attacker"; */
-          return 0;
-        }    
-      }
-    }
+	if ( $this->board[$i]{0} == $player )
+	{
+	  if ( ($this->board[$i]{1}=='P' && $this->checkPawnAttack($i,$dest_pos)) ||
+		   ($this->board[$i]{1}!='P' && $this->board[$i]{1}!='K' &&
+			  $this->tileIsReachable($this->board[$i]{1},$i,$dest_pos)) ||
+		   ($this->board[$i]{1}=='K' && 
+			  $this->tileIsReachable($this->board[$i]{1},$i,$dest_pos) &&
+			  !$this->tileIsUnderAttack($opp,$dest_pos)) )
+	  {
+		/* DEBUG: echo "candidate: $i "; */
+		$can_kill_atk = 0;
+		$contents_def = $this->board[$i];
+		$contents_atk = $this->board[$dest_pos];
+		$this->board[$dest_pos] = $this->board[$i];
+		$this->clear_tile($i);
+		if ( !$this->tileIsUnderAttack($opp,$king_pos) )
+		  $can_kill_atk = 1;
+		$this->board[$i] = $contents_def;
+		$this->board[$dest_pos] = $contents_atk;
+		if ( $can_kill_atk )
+		{
+		  /* DEBUG: echo "$i can kill attacker"; */
+		  return 0;
+		}    
+	  }
+	}
  
   /* check whether own unit can block the way */
   
@@ -734,7 +734,7 @@ 
   $dest_x = $dest_pos % 8;
   $dest_y = floor($dest_pos/8);
   if ( abs($dest_x-$king_x)<=1 && abs($dest_y-$king_y)<=1 )
-    return 1;
+	return 1;
 
   /* get the list of tiles between king and attacking
    * unit that can be blocked to stop the attack */
@@ -744,17 +744,17 @@ 
   /* DEBUG: foreach( $path as $tile ) echo "tile: $tile "; */
   foreach( $path as $pos )
   {
-    for ( $i = 0; $i < 64; $i++ )
-      if ( $this->board[$i]{0} == $player )
-      {
-        if ( ($this->board[$i]{1}=='P' && $this->checkPawnMove($i,$pos)) ||
-             ($this->board[$i]{1}!='P' && $this->board[$i]{1}!='K' &&
-                  $this->tileIsReachable($this->board[$i]{1},$i,$pos)) )
-        {
-            /* DEBUG: echo "$i can block "; */
-            return 0;
-        }
-      }
+	for ( $i = 0; $i < 64; $i++ )
+	  if ( $this->board[$i]{0} == $player )
+	  {
+		if ( ($this->board[$i]{1}=='P' && $this->checkPawnMove($i,$pos)) ||
+			 ($this->board[$i]{1}!='P' && $this->board[$i]{1}!='K' &&
+				  $this->tileIsReachable($this->board[$i]{1},$i,$pos)) )
+		{
+			/* DEBUG: echo "$i can block "; */
+			return 0;
+		}
+	  }
   }
   return 1;
 }
@@ -773,62 +773,62 @@ 
 function isStaleMate($player, $opp)
 {
   for ( $i = 0; $i < 64; $i++ )
-    if ($this->board[$i]{0} == $player )
-      switch ($this->board[$i]{1} )
-      {
-        case 'K':
-          $adj_tiles = $this->getAdjTiles( $i );
-          foreach ( $adj_tiles as $pos ) 
-          {
-            if ( $this->board[$pos]{0} == $player ) continue;
-            if ( $this->tileIsUnderAttack($opp,$pos) ) continue;
-            return 0;
-          }
-          /* DEBUG:  echo "King cannot escape by itself! "; */
-          break;
-        case 'P':
-          if ( $player == 'w' )
-          {
-            if ($this->is_empty_tile($i + 8)) return 0;
-            if ( ($i%8) > 0 && $this->board[$i+7]{0} != $player ) return 0;
-            if ( ($i%8) < 7 && $this->board[$i+9]{0} != $player ) return 0;
-          }
-          else
-          {
-            if ($this->is_empty_tile($i - 8)) return 0;
-            if ( ($i%8) > 0 && $this->board[$i-9]{0} != $player ) return 0;
-            if ( ($i%8) < 7 && $this->board[$i-7]{0} != $player ) return 0;
-          }
-          break;
-        case 'B':
-          if ( $i-9 >= 0  && $this->board[$i-9]{0} != $player ) return 0;
-          if ( $i-7 >= 0  && $this->board[$i-7]{0} != $player ) return 0;
-          if ( $i+9 <= 63 && $this->board[$i+9]{0} != $player ) return 0;
-          if ( $i+7 <= 63 && $this->board[$i+7]{0} != $player ) return 0;
-          break;
-        case 'R':
-          if ( $i-8 >= 0  && $this->board[$i-8]{0} != $player ) return 0;
-          if ( $i-1 >= 0  && $this->board[$i-1]{0} != $player ) return 0;
-          if ( $i+8 <= 63 && $this->board[$i+8]{0} != $player ) return 0;
-          if ( $i+1 <= 63 && $this->board[$i+1]{0} != $player ) return 0;
-          break;
-        case 'Q':
-          $adj_tiles = $this->getAdjTiles( $i );
-          foreach ( $adj_tiles as $pos )
-            if ( $this->board[$pos]{0} != $player ) 
-              return 0;
-          break;
-        case 'N':
-          if ( $i-17 >= 0  && $this->board[$i-17]{0} != $player ) return 0; 
-          if ( $i-15 >= 0  && $this->board[$i-15]{0} != $player ) return 0;
-          if ( $i-6  >= 0  && $this->board[$i-6]{0}  != $player ) return 0;
-          if ( $i+10 <= 63 && $this->board[$i+10]{0} != $player ) return 0;
-          if ( $i+17 <= 63 && $this->board[$i+17]{0} != $player ) return 0;
-          if ( $i+15 <= 63 && $this->board[$i+15]{0} != $player ) return 0;
-          if ( $i+6  <= 63 && $this->board[$i+6]{0}  != $player ) return 0;
-          if ( $i-10 >= 0  && $this->board[$i-10]{0} != $player ) return 0;
-          break;
-      }
+	if ($this->board[$i]{0} == $player )
+	  switch ($this->board[$i]{1} )
+	  {
+		case 'K':
+		  $adj_tiles = $this->getAdjTiles( $i );
+		  foreach ( $adj_tiles as $pos ) 
+		  {
+			if ( $this->board[$pos]{0} == $player ) continue;
+			if ( $this->tileIsUnderAttack($opp,$pos) ) continue;
+			return 0;
+		  }
+		  /* DEBUG:  echo "King cannot escape by itself! "; */
+		  break;
+		case 'P':
+		  if ( $player == 'w' )
+		  {
+			if ($this->is_empty_tile($i + 8)) return 0;
+			if ( ($i%8) > 0 && $this->board[$i+7]{0} != $player ) return 0;
+			if ( ($i%8) < 7 && $this->board[$i+9]{0} != $player ) return 0;
+		  }
+		  else
+		  {
+			if ($this->is_empty_tile($i - 8)) return 0;
+			if ( ($i%8) > 0 && $this->board[$i-9]{0} != $player ) return 0;
+			if ( ($i%8) < 7 && $this->board[$i-7]{0} != $player ) return 0;
+		  }
+		  break;
+		case 'B':
+		  if ( $i-9 >= 0  && $this->board[$i-9]{0} != $player ) return 0;
+		  if ( $i-7 >= 0  && $this->board[$i-7]{0} != $player ) return 0;
+		  if ( $i+9 <= 63 && $this->board[$i+9]{0} != $player ) return 0;
+		  if ( $i+7 <= 63 && $this->board[$i+7]{0} != $player ) return 0;
+		  break;
+		case 'R':
+		  if ( $i-8 >= 0  && $this->board[$i-8]{0} != $player ) return 0;
+		  if ( $i-1 >= 0  && $this->board[$i-1]{0} != $player ) return 0;
+		  if ( $i+8 <= 63 && $this->board[$i+8]{0} != $player ) return 0;
+		  if ( $i+1 <= 63 && $this->board[$i+1]{0} != $player ) return 0;
+		  break;
+		case 'Q':
+		  $adj_tiles = $this->getAdjTiles( $i );
+		  foreach ( $adj_tiles as $pos )
+			if ( $this->board[$pos]{0} != $player ) 
+			  return 0;
+		  break;
+		case 'N':
+		  if ( $i-17 >= 0  && $this->board[$i-17]{0} != $player ) return 0; 
+		  if ( $i-15 >= 0  && $this->board[$i-15]{0} != $player ) return 0;
+		  if ( $i-6  >= 0  && $this->board[$i-6]{0}  != $player ) return 0;
+		  if ( $i+10 <= 63 && $this->board[$i+10]{0} != $player ) return 0;
+		  if ( $i+17 <= 63 && $this->board[$i+17]{0} != $player ) return 0;
+		  if ( $i+15 <= 63 && $this->board[$i+15]{0} != $player ) return 0;
+		  if ( $i+6  <= 63 && $this->board[$i+6]{0}  != $player ) return 0;
+		  if ( $i-10 >= 0  && $this->board[$i-10]{0} != $player ) return 0;
+		  break;
+	  }
       
   return 1;
 }
@@ -890,12 +890,12 @@ 
 
   if ( strlen($move)>=6 ) 
   {
-    /* full move: a pawn requires a ? in the end
+	/* full move: a pawn requires a ? in the end
      * to automatically choose a queen on last line */
-    if ( $move[0] == 'P' )
-    if ( $move[strlen($move)-1]<'A' || $move[strlen($move)-1]>'Z' )
-      $this->ac_move = "$move?";
-    return "";
+	if ( $move[0] == 'P' )
+	if ( $move[strlen($move)-1]<'A' || $move[strlen($move)-1]>'Z' )
+	  $this->ac_move = "$move?";
+	return "";
   }
 
   /* allow last letter to be a capital one indicating
@@ -905,186 +905,186 @@ 
   $pawn_upg = "?";
   if ( $move[strlen($move)-1]>='A' && $move[strlen($move)-1]<='Z' )
   {
-    $pawn_upg = $move[strlen($move)-1];
-    $move = substr( $move, 0, strlen($move)-1 );
+	$pawn_upg = $move[strlen($move)-1];
+	$move = substr( $move, 0, strlen($move)-1 );
   }
   // remove trailing '=', if present
   if ($move{strlen($move)-1} == '=') {
-    $move = substr($move, 0, strlen($move)-1);
+	$move = substr($move, 0, strlen($move)-1);
   }
   if ( $pawn_upg == "P" || $pawn_upg == "K" )
-    return _MD_CHESS_MOVE_PAWN_MAY_BECOME; // "A pawn may only become either a knight, a bishop, a rook or a queen!"
+	return _MD_CHESS_MOVE_PAWN_MAY_BECOME; // "A pawn may only become either a knight, a bishop, a rook or a queen!"
 
   if ( $move[0]>='a' && $move[0]<='h' )
   {
-    /* pawn move. either it's 2 or for characters as 
+	/* pawn move. either it's 2 or for characters as 
      * listed above */
-    if ( strlen($move) == 4 )
-    {
-      if ( $move[1] != 'x' )
-        return _MD_CHESS_MOVE_USE_X; // "use x to indicate an attack"
-      $dest_x = $move[2];
-      $dest_y = $move[3];
-      $src_x  = $move[0];
-      if ( $player == 'w' )
-        $src_y  = $dest_y-1;
-      else
-        $src_y  = $dest_y+1;
-      $this->ac_move = sprintf( "P%s%dx%s%d%s", 
-                          $src_x,$src_y,$dest_x,$dest_y,
-                          $pawn_upg );
-      return "";
-    }
-    else
-    if (strlen($move) == 2 )
-    {
-      $fig = sprintf( "%sP", $player );
-      if ( $move[1] >= '1' && $move[1] <= '8' )
-      {
-        /* pawn move */
-        $pos = $this->boardCoordToIndex( $move );
-        if ( $pos == 64 ) return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $move); // "coordinate $move is invalid"
-        if ( $player == 'w' )
-        {
-          while( $pos >= 0 && $this->board[$pos] != $fig ) $pos -= 8;
-          if ( $pos < 0 ) $not_found = 1;
-        }
-        else
-        {
-          while( $pos <= 63 && $this->board[$pos] != $fig ) $pos += 8;
-          if ( $pos > 63 ) $not_found = 1;
-        }
-        $pos = $this->boardIndexToCoord( $pos );
-        if ( (isset($not_found) && $not_found) || $pos == "" ) {
-          return $this->move_msg(_MD_CHESS_MOVE_CANNOT_FIND_PAWN, $player, $move[0]); // "cannot find $player pawn in column $move[0]"
-        } else {
-          $this->ac_move = sprintf( "P%s-%s%s", $pos, $move, $pawn_upg );
-          return "";
-        }
-      }
-      else
-      {
-        /* notation: [a-h][a-h] for pawn attack no longer allowed 
+	if ( strlen($move) == 4 )
+	{
+	  if ( $move[1] != 'x' )
+		return _MD_CHESS_MOVE_USE_X; // "use x to indicate an attack"
+	  $dest_x = $move[2];
+	  $dest_y = $move[3];
+	  $src_x  = $move[0];
+	  if ( $player == 'w' )
+		$src_y  = $dest_y-1;
+	  else
+		$src_y  = $dest_y+1;
+	  $this->ac_move = sprintf( "P%s%dx%s%d%s", 
+						  $src_x,$src_y,$dest_x,$dest_y,
+						  $pawn_upg );
+	  return "";
+	}
+	else
+	if (strlen($move) == 2 )
+	{
+	  $fig = sprintf( "%sP", $player );
+	  if ( $move[1] >= '1' && $move[1] <= '8' )
+	  {
+		/* pawn move */
+		$pos = $this->boardCoordToIndex( $move );
+		if ( $pos == 64 ) return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $move); // "coordinate $move is invalid"
+		if ( $player == 'w' )
+		{
+		  while( $pos >= 0 && $this->board[$pos] != $fig ) $pos -= 8;
+		  if ( $pos < 0 ) $not_found = 1;
+		}
+		else
+		{
+		  while( $pos <= 63 && $this->board[$pos] != $fig ) $pos += 8;
+		  if ( $pos > 63 ) $not_found = 1;
+		}
+		$pos = $this->boardIndexToCoord( $pos );
+		if ( (isset($not_found) && $not_found) || $pos == "" ) {
+		  return $this->move_msg(_MD_CHESS_MOVE_CANNOT_FIND_PAWN, $player, $move[0]); // "cannot find $player pawn in column $move[0]"
+		} else {
+		  $this->ac_move = sprintf( "P%s-%s%s", $pos, $move, $pawn_upg );
+		  return "";
+		}
+	  }
+	  else
+	  {
+		/* notation: [a-h][a-h] for pawn attack no longer allowed 
          * except for history browser */
-        if ( $this->browsing_mode == 0 )
-            return _MD_CHESS_MOVE_USE_NOTATION; // "please use denotation [a-h]x[a-h][1-8] for pawn attacks (see help for more information)"
-        /* pawn attack must be only one pawn in column! */
-        $pawns = 0;
-        $start = $this->boardCoordToIndex( sprintf( "%s1", $move[0] ) );
-        if ( $start == 64 ) return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $move[0]); // "coordinate $move[0] is invalid"
-        for ( $i = 1; $i <= 8; $i++, $start+=8 )
-          if ( $this->board[$start] == $fig ) 
-          {
-            $pawns++;
-            $pawn_line = $i;
-          }
-        if ( $pawns == 0 )
-          return $this->move_msg(_MD_CHESS_MOVE_NO_PAWN, $move[0]); // "there is no pawn in column $move[0]"
-        else if ( $pawns > 1 )
-          return $this->move_msg(_MD_CHESS_MOVE_TWO_PAWNS, $move[0]); // "there is more than one pawn in column $move[0]"
-        else
-        {
-          if ( $player == 'w' )
-            $dest_line = $pawn_line+1;
-          else
-            $dest_line = $pawn_line-1;
-          $this->ac_move = sprintf( "P%s%dx%s%d", 
-                            $move[0],$pawn_line,$move[1],$dest_line );
-          return "";
-        }
-      }
-    }
+		if ( $this->browsing_mode == 0 )
+			return _MD_CHESS_MOVE_USE_NOTATION; // "please use denotation [a-h]x[a-h][1-8] for pawn attacks (see help for more information)"
+		/* pawn attack must be only one pawn in column! */
+		$pawns = 0;
+		$start = $this->boardCoordToIndex( sprintf( "%s1", $move[0] ) );
+		if ( $start == 64 ) return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $move[0]); // "coordinate $move[0] is invalid"
+		for ( $i = 1; $i <= 8; $i++, $start+=8 )
+		  if ( $this->board[$start] == $fig ) 
+		  {
+			$pawns++;
+			$pawn_line = $i;
+		  }
+		if ( $pawns == 0 )
+		  return $this->move_msg(_MD_CHESS_MOVE_NO_PAWN, $move[0]); // "there is no pawn in column $move[0]"
+		else if ( $pawns > 1 )
+		  return $this->move_msg(_MD_CHESS_MOVE_TWO_PAWNS, $move[0]); // "there is more than one pawn in column $move[0]"
+		else
+		{
+		  if ( $player == 'w' )
+			$dest_line = $pawn_line+1;
+		  else
+			$dest_line = $pawn_line-1;
+		  $this->ac_move = sprintf( "P%s%dx%s%d", 
+							$move[0],$pawn_line,$move[1],$dest_line );
+		  return "";
+		}
+	  }
+	}
   }
   else
   {
-    /* figure move */
-    $dest_coord = substr( $move, strlen($move)-2, 2 );
-    $action = $move[strlen($move)-3];
-    if ( $action != 'x' ) $action = '-';
-    if ( $player == 'w' ) 
-      $figures = $this->w_figures;
-    else
-      $figures = $this->b_figures;
-    $fig_count = 0;
-    foreach( $figures as $figure )
-      if ( $figure[0] == $move[0] )
-      {
-        $fig_count++;
-        if ( $fig_count == 1 )
-          $pos1 = substr( $figure, 1, 2 );
-        else
-          $pos2 = substr( $figure, 1, 2 );
-      }
-    if ( $fig_count == 0 )
-      return $this->move_msg(_MD_CHESS_MOVE_NO_FIGURE, $move[0], $this->getFullFigureName($move[0])); // sprintf("there is no figure %s = %s", $move[0], $this->getFullFigureName($move[0]))
-    else
-    if ( $fig_count == 1 )
-    {
-       $this->ac_move = sprintf( "%s%s%s%s",
-                      $move[0], $pos1, $action, $dest_coord ); 
-       return "";
-    }
-    else
-    {
-      /* two figures which may cause ambiguity */
-      $dest_pos = $this->boardCoordToIndex( $dest_coord );
-      if ( $dest_pos == 64 ) 
-        return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $dest_coord); // "coordinate $dest_coord is invalid"
-      $fig1_can_reach = $this->tileIsReachable( $move[0], 
-                            $this->boardCoordToIndex($pos1), $dest_pos );
-      $fig2_can_reach = $this->tileIsReachable( $move[0], 
-                            $this->boardCoordToIndex($pos2), $dest_pos );
-      if ( !$fig1_can_reach && !$fig2_can_reach )
-        return $this->move_msg(_MD_CHESS_MOVE_NEITHER_CAN_REACH, $move[0], $this->getFullFigureName($move[0]), $dest_coord); // sprintf("neither of the %s = %s can reach %s", $move[0], $this->getFullFigureName($move[0]), $dest_coord)
-      else
-      if ( $fig1_can_reach && $fig2_can_reach )
-      {
-        /* ambiguity - check whether a hint is given */
-        if ( ($action=='-' && strlen($move)==4) ||
-             ($action=='x' && strlen($move)==5) )
-          $hint = $move[1];
-        if ( empty($hint) )
-          return $this->move_msg(_MD_CHESS_MOVE_BOTH_CAN_REACH, $move[0], $this->getFullFigureName($move[0]), $dest_coord); // sprintf("both of the %s = %s can reach %s", $move[0], $this->getFullFigureName($move[0]), $dest_coord)
-        else
-        {
-          $move_fig1 = 0;
-          $move_fig2 = 0;
-          if ( $hint>='1' && $hint<='8' )
-          {
-            if ( $pos1[1]==$hint && $pos2[1]!=$hint )
-              $move_fig1 = 1;
-            if ( $pos2[1]==$hint && $pos1[1]!=$hint )
-              $move_fig2 = 1;
-          }
-          else
-          {
-            if ( $pos1[0]==$hint && $pos2[0]!=$hint )
-              $move_fig1 = 1;
-            if ( $pos2[0]==$hint && $pos1[0]!=$hint )
-              $move_fig2 = 1;
-          }
-          if ( !$move_fig1 && !$move_fig2 )
-            return _MD_CHESS_MOVE_AMBIGUOUS; // "ambiguity is not properly resolved"
-          if ( $move_fig1 )
-            $this->ac_move = sprintf( "%s%s%s%s",
-                          $move[0], $pos1, $action, $dest_coord );
-          else
-            $this->ac_move = sprintf( "%s%s%s%s",
-                          $move[0], $pos2, $action, $dest_coord );
-          return;
-        }
-      }
-      else
-      {
-        if ( $fig1_can_reach )
-          $this->ac_move = sprintf( "%s%s%s%s",
-                        $move[0], $pos1, $action, $dest_coord ); 
-        else
-          $this->ac_move = sprintf( "%s%s%s%s",
-                        $move[0], $pos2, $action, $dest_coord ); 
-        return "";
-      }
-    }
+	/* figure move */
+	$dest_coord = substr( $move, strlen($move)-2, 2 );
+	$action = $move[strlen($move)-3];
+	if ( $action != 'x' ) $action = '-';
+	if ( $player == 'w' ) 
+	  $figures = $this->w_figures;
+	else
+	  $figures = $this->b_figures;
+	$fig_count = 0;
+	foreach( $figures as $figure )
+	  if ( $figure[0] == $move[0] )
+	  {
+		$fig_count++;
+		if ( $fig_count == 1 )
+		  $pos1 = substr( $figure, 1, 2 );
+		else
+		  $pos2 = substr( $figure, 1, 2 );
+	  }
+	if ( $fig_count == 0 )
+	  return $this->move_msg(_MD_CHESS_MOVE_NO_FIGURE, $move[0], $this->getFullFigureName($move[0])); // sprintf("there is no figure %s = %s", $move[0], $this->getFullFigureName($move[0]))
+	else
+	if ( $fig_count == 1 )
+	{
+	   $this->ac_move = sprintf( "%s%s%s%s",
+					  $move[0], $pos1, $action, $dest_coord ); 
+	   return "";
+	}
+	else
+	{
+	  /* two figures which may cause ambiguity */
+	  $dest_pos = $this->boardCoordToIndex( $dest_coord );
+	  if ( $dest_pos == 64 ) 
+		return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $dest_coord); // "coordinate $dest_coord is invalid"
+	  $fig1_can_reach = $this->tileIsReachable( $move[0], 
+							$this->boardCoordToIndex($pos1), $dest_pos );
+	  $fig2_can_reach = $this->tileIsReachable( $move[0], 
+							$this->boardCoordToIndex($pos2), $dest_pos );
+	  if ( !$fig1_can_reach && !$fig2_can_reach )
+		return $this->move_msg(_MD_CHESS_MOVE_NEITHER_CAN_REACH, $move[0], $this->getFullFigureName($move[0]), $dest_coord); // sprintf("neither of the %s = %s can reach %s", $move[0], $this->getFullFigureName($move[0]), $dest_coord)
+	  else
+	  if ( $fig1_can_reach && $fig2_can_reach )
+	  {
+		/* ambiguity - check whether a hint is given */
+		if ( ($action=='-' && strlen($move)==4) ||
+			 ($action=='x' && strlen($move)==5) )
+		  $hint = $move[1];
+		if ( empty($hint) )
+		  return $this->move_msg(_MD_CHESS_MOVE_BOTH_CAN_REACH, $move[0], $this->getFullFigureName($move[0]), $dest_coord); // sprintf("both of the %s = %s can reach %s", $move[0], $this->getFullFigureName($move[0]), $dest_coord)
+		else
+		{
+		  $move_fig1 = 0;
+		  $move_fig2 = 0;
+		  if ( $hint>='1' && $hint<='8' )
+		  {
+			if ( $pos1[1]==$hint && $pos2[1]!=$hint )
+			  $move_fig1 = 1;
+			if ( $pos2[1]==$hint && $pos1[1]!=$hint )
+			  $move_fig2 = 1;
+		  }
+		  else
+		  {
+			if ( $pos1[0]==$hint && $pos2[0]!=$hint )
+			  $move_fig1 = 1;
+			if ( $pos2[0]==$hint && $pos1[0]!=$hint )
+			  $move_fig2 = 1;
+		  }
+		  if ( !$move_fig1 && !$move_fig2 )
+			return _MD_CHESS_MOVE_AMBIGUOUS; // "ambiguity is not properly resolved"
+		  if ( $move_fig1 )
+			$this->ac_move = sprintf( "%s%s%s%s",
+						  $move[0], $pos1, $action, $dest_coord );
+		  else
+			$this->ac_move = sprintf( "%s%s%s%s",
+						  $move[0], $pos2, $action, $dest_coord );
+		  return;
+		}
+	  }
+	  else
+	  {
+		if ( $fig1_can_reach )
+		  $this->ac_move = sprintf( "%s%s%s%s",
+						$move[0], $pos1, $action, $dest_coord ); 
+		else
+		  $this->ac_move = sprintf( "%s%s%s%s",
+						$move[0], $pos2, $action, $dest_coord ); 
+		return "";
+	  }
+	}
   }
 
   return $error;
@@ -1111,37 +1111,37 @@ 
   /* valid pawn moves are always non-ambigious */
   if ( $move[0] == 'P' )
   {
-    /* skip P anycase. for attacks skip source digit
+	/* skip P anycase. for attacks skip source digit
        and for moves skip source pos and - */
-    if ( $move[3] == '-' )
-      $new_move = substr( $move, 4 );
-    else
-    if ( $move[3] == 'x' )
-      $new_move = sprintf("%s%s", $move[1], substr( $move, 3 ) );
+	if ( $move[3] == '-' )
+	  $new_move = substr( $move, 4 );
+	else
+	if ( $move[3] == 'x' )
+	  $new_move = sprintf("%s%s", $move[1], substr( $move, 3 ) );
   }
   else
   {
-    /* try to remove the source position and check whether it
+	/* try to remove the source position and check whether it
      * is a non-ambigious move. if it is add one of the components
      * and check again */
-    if ( $move[3] == '-' )
-      $dest = substr( $move, 4 );
-    else
-    if ( $move[3] == 'x' )
-      $dest = substr( $move, 3 );
-    $new_move = sprintf("%s%s", $move[0], $dest );
-    if ( $this->completeMove($player,$new_move) != "" )
-    {
-      /* add a component */
-      $new_move = sprintf("%s%s%s", $move[0], $move[1], $dest );
-      if ( $this->completeMove($player,$new_move) != "" )
-      {
-        /* add other component */
-        $new_move = sprintf("%s%s%s", $move[0], $move[2], $dest );
-        if ( $this->completeMove($player,$new_move) != "" )
-           $new_move = $move; /* give up */
-      }
-    }
+	if ( $move[3] == '-' )
+	  $dest = substr( $move, 4 );
+	else
+	if ( $move[3] == 'x' )
+	  $dest = substr( $move, 3 );
+	$new_move = sprintf("%s%s", $move[0], $dest );
+	if ( $this->completeMove($player,$new_move) != "" )
+	{
+	  /* add a component */
+	  $new_move = sprintf("%s%s%s", $move[0], $move[1], $dest );
+	  if ( $this->completeMove($player,$new_move) != "" )
+	  {
+		/* add other component */
+		$new_move = sprintf("%s%s%s", $move[0], $move[2], $dest );
+		if ( $this->completeMove($player,$new_move) != "" )
+		   $new_move = $move; /* give up */
+	  }
+	}
   }
   
   $this->ac_move = $old_ac_move;
@@ -1175,14 +1175,14 @@ 
   $cur_player = $this->gamestate['fen_active_color']; /* b or w */
 
   if ($cur_player != 'w' and $cur_player != 'b') {
-    return(array(false, "handleMove, internal error: player='$cur_player'"));
+	return(array(false, "handleMove, internal error: player='$cur_player'"));
   }
 
   $cur_opp = ($cur_player == 'w') ? 'b' : 'w';
 
   if ($this->gamestate['pgn_result'] != '*')
   { 
-    return(array(false, _MD_CHESS_MOVE_GAME_OVER));
+	return(array(false, _MD_CHESS_MOVE_GAME_OVER));
   }
 
 	// get castling availability flags
@@ -1327,83 +1327,83 @@ 
 
   else
   {
-    /* [PRNBQK][a-h][1-8][-:x][a-h][1-8][RNBQK] full move */
+	/* [PRNBQK][a-h][1-8][-:x][a-h][1-8][RNBQK] full move */
 
-    /* allow short move description by autocompleting to
+	/* allow short move description by autocompleting to
      * full description */
-    $ac_error = $this->completeMove( $cur_player, trim($move) );
-    if ( $ac_error != "" )
-      return(array(false, $ac_error)); // "ERROR: autocomplete: $ac_error"
-    else 
-      $move = $this->ac_move;
-    $this->last_move = str_replace( "?", "", $move );
+	$ac_error = $this->completeMove( $cur_player, trim($move) );
+	if ( $ac_error != "" )
+	  return(array(false, $ac_error)); // "ERROR: autocomplete: $ac_error"
+	else 
+	  $move = $this->ac_move;
+	$this->last_move = str_replace( "?", "", $move );
     
-    /* a final captial letter may only be N,B,R,Q for the
+	/* a final captial letter may only be N,B,R,Q for the
      * appropiate chessman */
-    $c = $move[strlen($move)-1];
-    if ( $c >= 'A' && $c <= 'Z' )
-    if ( $c != 'N' && $c != 'B' && $c != 'R' && $c != 'Q' )
-      return(array(false, _MD_CHESS_MOVE_INVALID_PIECE)); // "ERROR: only N (knight), B (bishop), R (rook) and Q (queen) are valid chessman identifiers"
+	$c = $move[strlen($move)-1];
+	if ( $c >= 'A' && $c <= 'Z' )
+	if ( $c != 'N' && $c != 'B' && $c != 'R' && $c != 'Q' )
+	  return(array(false, _MD_CHESS_MOVE_INVALID_PIECE)); // "ERROR: only N (knight), B (bishop), R (rook) and Q (queen) are valid chessman identifiers"
     
-    /* if it is a full move, try to shorten the history move */
-    if ( strlen( $history_move ) >= 6 )
-      $history_move = 
-          $this->convertFullToChessNotation($cur_player,$history_move);
-    /* DEBUG: echo "Move: $move ($history_move)<BR>"; */
+	/* if it is a full move, try to shorten the history move */
+	if ( strlen( $history_move ) >= 6 )
+	  $history_move = 
+		  $this->convertFullToChessNotation($cur_player,$history_move);
+	/* DEBUG: echo "Move: $move ($history_move)<BR>"; */
     
-    /* validate figure and position */
-    $fig_type = $move[0];
-    $fig_name = $this->getFullFigureName( $fig_type );
-    if ( $fig_name == "empty" )
-      return(array(false, $this->move_msg(_MD_CHESS_MOVE_UNKNOWN_FIGURE, $fig_type))); // "ERROR: Figure $fig_type is unknown!"
-    $fig_coord = substr($move,1,2);
-    $fig_pos = $this->boardCoordToIndex( $fig_coord );
-    if ( $fig_pos == 64 ) return(array(false, $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $fig_coord))); // "ERROR: $fig_coord is invalid!"
-    /* DEBUG  echo "fig_type: $fig_type, fig_pos: $fig_pos<BR>"; */
-    if ($this->is_empty_tile($fig_pos))
-      return(array(false, $this->move_msg(_MD_CHESS_MOVE_TILE_EMPTY, $fig_coord))); // "ERROR: Tile $fig_coord is empty."
-    if ( $this->board[$fig_pos]{0} != $cur_player )
-      return(array(false, _MD_CHESS_MOVE_NOT_YOUR_PIECE)); // "ERROR: Figure does not belong to you!"
-    if ( $this->board[$fig_pos]{1} != $fig_type )
-      return(array(false, _MD_CHESS_MOVE_NOEXIST_FIGURE)); // "ERROR: Figure does not exist!"
+	/* validate figure and position */
+	$fig_type = $move[0];
+	$fig_name = $this->getFullFigureName( $fig_type );
+	if ( $fig_name == "empty" )
+	  return(array(false, $this->move_msg(_MD_CHESS_MOVE_UNKNOWN_FIGURE, $fig_type))); // "ERROR: Figure $fig_type is unknown!"
+	$fig_coord = substr($move,1,2);
+	$fig_pos = $this->boardCoordToIndex( $fig_coord );
+	if ( $fig_pos == 64 ) return(array(false, $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $fig_coord))); // "ERROR: $fig_coord is invalid!"
+	/* DEBUG  echo "fig_type: $fig_type, fig_pos: $fig_pos<BR>"; */
+	if ($this->is_empty_tile($fig_pos))
+	  return(array(false, $this->move_msg(_MD_CHESS_MOVE_TILE_EMPTY, $fig_coord))); // "ERROR: Tile $fig_coord is empty."
+	if ( $this->board[$fig_pos]{0} != $cur_player )
+	  return(array(false, _MD_CHESS_MOVE_NOT_YOUR_PIECE)); // "ERROR: Figure does not belong to you!"
+	if ( $this->board[$fig_pos]{1} != $fig_type )
+	  return(array(false, _MD_CHESS_MOVE_NOEXIST_FIGURE)); // "ERROR: Figure does not exist!"
     
-    /* get target index */
-    $dest_coord = substr($move,4,2);
-    $dest_pos = $this->boardCoordToIndex( $dest_coord );
-    if ( $dest_pos == 64 )
-      return(array(false, $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $dest_coord))); // "ERROR: $dest_coord is invalid!"
-    if ( $dest_pos == $fig_pos )
-      return(array(false, _MD_CHESS_MOVE_START_END_SAME));
-    /* DEBUG  echo "dest_pos: $dest_pos<BR>"; */
-
-    /* get action */
-    $action = $move[3];
-    if ( $move[3] == "-" ) 
-      $action = 'M'; /* move */
-    else if ( $move[3] == 'x' )
-      $action = 'A'; /* attack */
-    else
-      return(array(false, $this->move_msg(_MD_CHESS_MOVE_UNKNOWN_ACTION, $action))); // "ERROR: $action is unknown! Please use \"-\" for a move and \"x\" for an attack."
-
-    /* if attack an enemy unit must be present on tile
+	/* get target index */
+	$dest_coord = substr($move,4,2);
+	$dest_pos = $this->boardCoordToIndex( $dest_coord );
+	if ( $dest_pos == 64 )
+	  return(array(false, $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $dest_coord))); // "ERROR: $dest_coord is invalid!"
+	if ( $dest_pos == $fig_pos )
+	  return(array(false, _MD_CHESS_MOVE_START_END_SAME));
+	/* DEBUG  echo "dest_pos: $dest_pos<BR>"; */
+
+	/* get action */
+	$action = $move[3];
+	if ( $move[3] == "-" ) 
+	  $action = 'M'; /* move */
+	else if ( $move[3] == 'x' )
+	  $action = 'A'; /* attack */
+	else
+	  return(array(false, $this->move_msg(_MD_CHESS_MOVE_UNKNOWN_ACTION, $action))); // "ERROR: $action is unknown! Please use \"-\" for a move and \"x\" for an attack."
+
+	/* if attack an enemy unit must be present on tile
      * and if move then tile must be empty. in both cases
      * the king must not be checked after moving. */
      
-    /* check whether the move is along a valid path and
+	/* check whether the move is along a valid path and
      * whether all tiles in between are empty thus the path
      * is not blocked. the final destination tile is not 
      * checked here. */
-    if ( $fig_type != 'P' )
-    {
-        if ( !$this->tileIsReachable( $fig_type, $fig_pos, $dest_pos ) )
-          return(array(false, $this->move_msg(_MD_CHESS_MOVE_OUT_OF_RANGE, $dest_coord, $fig_name, $fig_coord))); // "ERROR: Tile $dest_coord is out of moving range for $fig_name at $fig_coord!"
-    }
-    else {
-      if ( $action == 'M' && !$this->checkPawnMove( $fig_pos, $dest_pos ) )
-          return(array(false, $this->move_msg(_MD_CHESS_MOVE_OUT_OF_RANGE, $dest_coord, $fig_name, $fig_coord))); // "ERROR: Tile $dest_coord is out of moving range for $fig_name at $fig_coord!"
-      if ( $action == 'A' && !$this->checkPawnAttack( $fig_pos, $dest_pos ) )
-          return(array(false, $this->move_msg(_MD_CHESS_MOVE_OUT_OF_RANGE, $dest_coord, $fig_name, $fig_coord))); // "ERROR: Tile $dest_coord is out of attacking range for $fig_name at $fig_coord!"
-    }
+	if ( $fig_type != 'P' )
+	{
+		if ( !$this->tileIsReachable( $fig_type, $fig_pos, $dest_pos ) )
+		  return(array(false, $this->move_msg(_MD_CHESS_MOVE_OUT_OF_RANGE, $dest_coord, $fig_name, $fig_coord))); // "ERROR: Tile $dest_coord is out of moving range for $fig_name at $fig_coord!"
+	}
+	else {
+	  if ( $action == 'M' && !$this->checkPawnMove( $fig_pos, $dest_pos ) )
+		  return(array(false, $this->move_msg(_MD_CHESS_MOVE_OUT_OF_RANGE, $dest_coord, $fig_name, $fig_coord))); // "ERROR: Tile $dest_coord is out of moving range for $fig_name at $fig_coord!"
+	  if ( $action == 'A' && !$this->checkPawnAttack( $fig_pos, $dest_pos ) )
+		  return(array(false, $this->move_msg(_MD_CHESS_MOVE_OUT_OF_RANGE, $dest_coord, $fig_name, $fig_coord))); // "ERROR: Tile $dest_coord is out of attacking range for $fig_name at $fig_coord!"
+	}
      
 	$en_passant_capture_performed = 0; // 1 if en passant captured occurred, else 0
 	/* check action */
@@ -1427,43 +1427,43 @@ 
 		return(array(false, $this->move_msg(_MD_CHESS_MOVE_ATTACK_SELF, $dest_coord))); // "ERROR: You cannot attack own unit at $dest_coord."
 	}
 
-    /* backup affected tiles */
-    $old_fig_tile = $this->board[$fig_pos];
-    $old_dest_tile = $this->board[$dest_pos];
-
-    /* perform move */
-    $this->clear_tile($fig_pos);
-    if (!$this->is_empty_tile($dest_pos))
-      $this->piece_captured = sprintf("%s%s",$this->board[$dest_pos],$dest_pos);
-    $this->board[$dest_pos] = "$cur_player$fig_type";
-    if ( $en_passant_capture_performed ) {
-      /* kill pawn */
-      if ( $cur_player == 'w' ) 
-      {
-        $this->clear_tile($dest_pos - 8);
-        $this->piece_captured = sprintf("bP%s",$dest_pos-8);
-      }
-      else
-      {
-        $this->clear_tile($dest_pos + 8);
-        $this->piece_captured = sprintf("wP%s",$dest_pos+8);
-      }
-    }
-
-    /* check check :) */
-    if ( $this->kingIsUnderAttack( $cur_player, $cur_opp ) )
-    {
-      $this->board[$fig_pos] = $old_fig_tile;
-      $this->board[$dest_pos] = $old_dest_tile;
-      if ( $en_passant_capture_performed ) {
-       // restore pawn that was captured above, since that move is invalid
-        if ( $cur_player == 'w' ) 
-          $this->board[$dest_pos-8] = "bP";
-        else
-          $this->board[$dest_pos+8] = "wP";
-      }
-      return(array(false, _MD_CHESS_MOVE_IN_CHECK)); // "ERROR: Move is invalid because king would be under attack then."
-    }
+	/* backup affected tiles */
+	$old_fig_tile = $this->board[$fig_pos];
+	$old_dest_tile = $this->board[$dest_pos];
+
+	/* perform move */
+	$this->clear_tile($fig_pos);
+	if (!$this->is_empty_tile($dest_pos))
+	  $this->piece_captured = sprintf("%s%s",$this->board[$dest_pos],$dest_pos);
+	$this->board[$dest_pos] = "$cur_player$fig_type";
+	if ( $en_passant_capture_performed ) {
+	  /* kill pawn */
+	  if ( $cur_player == 'w' ) 
+	  {
+		$this->clear_tile($dest_pos - 8);
+		$this->piece_captured = sprintf("bP%s",$dest_pos-8);
+	  }
+	  else
+	  {
+		$this->clear_tile($dest_pos + 8);
+		$this->piece_captured = sprintf("wP%s",$dest_pos+8);
+	  }
+	}
+
+	/* check check :) */
+	if ( $this->kingIsUnderAttack( $cur_player, $cur_opp ) )
+	{
+	  $this->board[$fig_pos] = $old_fig_tile;
+	  $this->board[$dest_pos] = $old_dest_tile;
+	  if ( $en_passant_capture_performed ) {
+	   // restore pawn that was captured above, since that move is invalid
+		if ( $cur_player == 'w' ) 
+		  $this->board[$dest_pos-8] = "bP";
+		else
+		  $this->board[$dest_pos+8] = "wP";
+	  }
+	  return(array(false, _MD_CHESS_MOVE_IN_CHECK)); // "ERROR: Move is invalid because king would be under attack then."
+	}
 
 	// check whether this forbids any castling
 	if ($fig_type == 'K') {
@@ -1501,29 +1501,29 @@ 
 		$this->gamestate['fen_en_passant_target_square'] = '-';
 	}
 
-    if ($action == 'M' )
-      $result = $this->move_msg(_MD_CHESS_MOVE_MOVED, $fig_name, $fig_coord, $dest_coord);
-    else
-      $result = $this->move_msg(_MD_CHESS_MOVE_CAPTURED, $fig_name, $dest_coord, $fig_coord);
+	if ($action == 'M' )
+	  $result = $this->move_msg(_MD_CHESS_MOVE_MOVED, $fig_name, $fig_coord, $dest_coord);
+	else
+	  $result = $this->move_msg(_MD_CHESS_MOVE_CAPTURED, $fig_name, $dest_coord, $fig_coord);
     
-    /* if pawn reached last line convert into a queen */
-    if ( $fig_type == 'P' )
-    {
-      if ( ($cur_player=='w' && $dest_pos>= 56) || 
-           ($cur_player=='b' && $dest_pos<= 7 ) )
-      {
-        $pawn_upg = $move[strlen($move)-1];
-        if ( $pawn_upg == '?' ) 
-        {
-          $pawn_upg = 'Q';
-          $history_move = sprintf( "%sQ", $history_move );
-        }
-        $this->board[$dest_pos] = "$cur_player$pawn_upg";
-        $result .= ' ... ' . $this->move_msg(_MD_CHESS_MOVE_PROMOTED, $this->getFullFigureName($pawn_upg));
-      }
-    }
+	/* if pawn reached last line convert into a queen */
+	if ( $fig_type == 'P' )
+	{
+	  if ( ($cur_player=='w' && $dest_pos>= 56) || 
+		   ($cur_player=='b' && $dest_pos<= 7 ) )
+	  {
+		$pawn_upg = $move[strlen($move)-1];
+		if ( $pawn_upg == '?' ) 
+		{
+		  $pawn_upg = 'Q';
+		  $history_move = sprintf( "%sQ", $history_move );
+		}
+		$this->board[$dest_pos] = "$cur_player$pawn_upg";
+		$result .= ' ... ' . $this->move_msg(_MD_CHESS_MOVE_PROMOTED, $this->getFullFigureName($pawn_upg));
+	  }
+	}
   
-    $move_handled = 1;
+	$move_handled = 1;
   }
   
   /* if a legal move was performed test whether you
@@ -1752,19 +1752,19 @@ 
   //echo $coord," --> ";
   switch ( $coord[0] ) 
   {
-    case 'a': $x = 0; break;
-    case 'b': $x = 1; break;
-    case 'c': $x = 2; break;
-    case 'd': $x = 3; break;
-    case 'e': $x = 4; break;
-    case 'f': $x = 5; break;
-    case 'g': $x = 6; break;
-    case 'h': $x = 7; break;
-    default: return 64; /* erronous coord */
+	case 'a': $x = 0; break;
+	case 'b': $x = 1; break;
+	case 'c': $x = 2; break;
+	case 'd': $x = 3; break;
+	case 'e': $x = 4; break;
+	case 'f': $x = 5; break;
+	case 'g': $x = 6; break;
+	case 'h': $x = 7; break;
+	default: return 64; /* erronous coord */
   }
   $y = $coord[1]-1; 
   if ( $y < 0 || $y > 7 )
-    return 64; /* erronous coord */
+	return 64; /* erronous coord */
   $index = $y * 8 + $x;
   //echo "$index | ";
   return $index;
@@ -1782,7 +1782,7 @@ 
 {
   //echo $index," --> ";
   if ( $index < 0 || $index > 63 )
-    return "";
+	return "";
   $y = floor($index/8)+1;
   $x = chr( ($index%8)+97 );
   $coord = "$x$y";

Spacing +310 added lines, -310 removed lines

@@ -167,7 +167,7 @@ 
 function ChessGame($param = null)
 {
 	// for now
-	$this->browsing_mode  = 0;
+	$this->browsing_mode = 0;
 
 	if (is_array($param)) {
 
@@ -291,8 +291,8 @@ 
 	{
 		return _MD_CHESS_FENBAD_IN_CHECK; // player to move cannot have opponent in check
 	}
-	elseif ((strstr($this->gamestate['fen_castling_availability'], 'K') and ($this->board[ 4] != 'wK' or $this->board[ 7] != 'wR'))
-		or   (strstr($this->gamestate['fen_castling_availability'], 'Q') and ($this->board[ 4] != 'wK' or $this->board[ 0] != 'wR'))
+	elseif ((strstr($this->gamestate['fen_castling_availability'], 'K') and ($this->board[4] != 'wK' or $this->board[7] != 'wR'))
+		or   (strstr($this->gamestate['fen_castling_availability'], 'Q') and ($this->board[4] != 'wK' or $this->board[0] != 'wR'))
 		or   (strstr($this->gamestate['fen_castling_availability'], 'k') and ($this->board[60] != 'bK' or $this->board[63] != 'bR'))
 		or   (strstr($this->gamestate['fen_castling_availability'], 'q') and ($this->board[60] != 'bK' or $this->board[56] != 'bR')))
 	{
@@ -304,12 +304,12 @@ 
 		return _MD_CHESS_FENBAD_EP_COLOR; // en passant target square wrong color
 	}
 	elseif ($this->gamestate['fen_en_passant_target_square'] != '-' and $this->gamestate['fen_en_passant_target_square']{1} == 3
-		and $this->board[$this->boardCoordToIndex($this->gamestate['fen_en_passant_target_square']{0} . '4')] != 'wP')
+		and $this->board[$this->boardCoordToIndex($this->gamestate['fen_en_passant_target_square']{0}.'4')] != 'wP')
 	{
 		return _MD_CHESS_FENBAD_EP_NO_PAWN; // en passant target square for nonexistent pawn
 	}
 	elseif ($this->gamestate['fen_en_passant_target_square'] != '-' and $this->gamestate['fen_en_passant_target_square']{1} == 6
-		and $this->board[$this->boardCoordToIndex($this->gamestate['fen_en_passant_target_square']{0} . '5')] != 'bP')
+		and $this->board[$this->boardCoordToIndex($this->gamestate['fen_en_passant_target_square']{0}.'5')] != 'bP')
 	{
 		return _MD_CHESS_FENBAD_EP_NO_PAWN; // en passant target square for nonexistent pawn
 	}
@@ -397,11 +397,11 @@ 
 	$dx = $dest_pos % 8;
 	$dy = floor($dest_pos / 8);
 
-	switch ( $fig ) {
+	switch ($fig) {
 
 		/* bishop */
 		case 'B':
-			$change =  ($dy < $fy) ? -8 : 8;
+			$change = ($dy < $fy) ? -8 : 8;
 			$change += ($dx < $fx) ? -1 : 1;
 			break;
 
@@ -417,7 +417,7 @@ 
 		/* queen */
 		case 'Q':
 			if (abs($fx - $dx) == abs($fy - $dy)) {
-				$change =  ($dy < $fy) ? -8 : 8;
+				$change = ($dy < $fy) ? -8 : 8;
 				$change += ($dx < $fx) ? -1 : 1;
 			} elseif ($fx == $dx) {
 				$change = ($dy < $fy) ? -8 : 8;
@@ -448,70 +448,70 @@ 
  */
 function tileIsReachable($fig, $fig_pos, $dest_pos)
 {
-  if ( $fig_pos==$dest_pos) return;
+  if ($fig_pos == $dest_pos) return;
   $result = 0;
-  $fy = floor($fig_pos/8); $fx = $fig_pos%8;
-  $dy = floor($dest_pos/8); $dx = $dest_pos%8;
+  $fy = floor($fig_pos / 8); $fx = $fig_pos % 8;
+  $dy = floor($dest_pos / 8); $dx = $dest_pos % 8;
   /* DEBUG:  echo "$fx,$fy --> $dx,$dy: "; */
-  switch ( $fig )
+  switch ($fig)
   {
     /* knight */
     case 'N':
-      if ( abs($fx-$dx)==1 && abs($fy-$dy)==2 )
+      if (abs($fx - $dx) == 1 && abs($fy - $dy) == 2)
         $result = 1;
-      if ( abs($fy-$dy)==1 && abs($fx-$dx)==2 )
+      if (abs($fy - $dy) == 1 && abs($fx - $dx) == 2)
         $result = 1;
       break;
     /* bishop */
     case 'B':
-      if ( abs($fx-$dx) != abs($fy-$dy) )
+      if (abs($fx - $dx) != abs($fy - $dy))
         break;
-      if ( $dy < $fy ) $change = -8; else $change =  8;
-      if ( $dx < $fx ) $change -= 1; else $change += 1;
-      if ( $this->pathIsNotBlocked( $fig_pos+$change, $dest_pos, $change ) )
+      if ($dy < $fy) $change = -8; else $change = 8;
+      if ($dx < $fx) $change -= 1; else $change += 1;
+      if ($this->pathIsNotBlocked($fig_pos + $change, $dest_pos, $change))
         $result = 1;
       break;
     /* rook */
     case 'R':
-      if ( $fx!=$dx && $fy!=$dy )
+      if ($fx != $dx && $fy != $dy)
         break;
-      if ( $fx==$dx ) 
+      if ($fx == $dx) 
       {
-        if ( $dy<$fy ) $change = -8; else $change = 8;
+        if ($dy < $fy) $change = -8; else $change = 8;
       }
       else {
-        if ( $dx<$fx ) $change = -1; else $change = 1;
+        if ($dx < $fx) $change = -1; else $change = 1;
       }
-      if ( $this->pathIsNotBlocked( $fig_pos+$change, $dest_pos, $change ) )
+      if ($this->pathIsNotBlocked($fig_pos + $change, $dest_pos, $change))
         $result = 1;
       break;
     /* queen */
     case 'Q':
-      if ( abs($fx-$dx) != abs($fy-$dy) && $fx!=$dx && $fy!=$dy )
+      if (abs($fx - $dx) != abs($fy - $dy) && $fx != $dx && $fy != $dy)
         break;
-      if ( abs($fx-$dx) == abs($fy-$dy) )
+      if (abs($fx - $dx) == abs($fy - $dy))
       {
-        if ( $dy < $fy ) $change = -8; else $change =  8;
-        if ( $dx < $fx ) $change -= 1; else $change += 1;
+        if ($dy < $fy) $change = -8; else $change = 8;
+        if ($dx < $fx) $change -= 1; else $change += 1;
       }
-      else if ( $fx==$dx ) {
-        if ( $dy<$fy ) $change = -8; else $change = 8;
+      else if ($fx == $dx) {
+        if ($dy < $fy) $change = -8; else $change = 8;
       } 
       else
       {
-        if ( $dx<$fx ) $change = -1; else $change = 1;
+        if ($dx < $fx) $change = -1; else $change = 1;
       }
-      if ( $this->pathIsNotBlocked( $fig_pos+$change, $dest_pos, $change ) )
+      if ($this->pathIsNotBlocked($fig_pos + $change, $dest_pos, $change))
         $result = 1;
       break;
     /* king */
     case 'K':
-      if ( abs($fx-$dx) > 1 || abs($fy-$dy) > 1 ) break;
+      if (abs($fx - $dx) > 1 || abs($fy - $dy) > 1) break;
       $kings = 0;
-      $adj_tiles = $this->getAdjTiles( $dest_pos );
-      foreach( $adj_tiles as $tile )
-        if ($this->board[$tile]{1} == 'K' ) $kings++;
-      if ( $kings == 2 ) break;
+      $adj_tiles = $this->getAdjTiles($dest_pos);
+      foreach ($adj_tiles as $tile)
+        if ($this->board[$tile]{1} == 'K') $kings++;
+      if ($kings == 2) break;
       $result = 1;
       break;
   }
@@ -531,18 +531,18 @@ 
  */
 function checkPawnAttack($fig_pos, $dest_pos)
 {
-  if ( $this->board[$fig_pos]{0} == 'w' )
+  if ($this->board[$fig_pos]{0} == 'w')
   {
-    if ( ($fig_pos % 8) > 0 && $dest_pos == $fig_pos+7 )
+    if (($fig_pos % 8) > 0 && $dest_pos == $fig_pos + 7)
       return 1;
-    if ( ($fig_pos % 8) < 7 && $dest_pos == $fig_pos+9 )
+    if (($fig_pos % 8) < 7 && $dest_pos == $fig_pos + 9)
       return 1;
   }
-  else if ( $this->board[$fig_pos]{0} == 'b' )
+  else if ($this->board[$fig_pos]{0} == 'b')
   {
-    if ( ($fig_pos % 8) < 7 && $dest_pos == $fig_pos-7 )
+    if (($fig_pos % 8) < 7 && $dest_pos == $fig_pos - 7)
       return 1;
-    if ( ($fig_pos % 8) > 0 && $dest_pos == $fig_pos-9 )
+    if (($fig_pos % 8) > 0 && $dest_pos == $fig_pos - 9)
       return 1;
   }
   return 0;
@@ -566,23 +566,23 @@ 
 {
   $first_move = 0;
   
-  if ( $this->board[$fig_pos]{0} == 'w' )
+  if ($this->board[$fig_pos]{0} == 'w')
   {
-    if ( $fig_pos >= 8 && $fig_pos <= 15 )
+    if ($fig_pos >= 8 && $fig_pos <= 15)
       $first_move = 1;
-    if ( $dest_pos==$fig_pos+8 )
+    if ($dest_pos == $fig_pos + 8)
       return 1;
-    if ( $first_move && ( $dest_pos==$fig_pos+16 ) )
+    if ($first_move && ($dest_pos == $fig_pos + 16))
     if ($this->is_empty_tile($fig_pos + 8))
       return 1;
   }
-  else if ($this->board[$fig_pos]{0} == 'b' )
+  else if ($this->board[$fig_pos]{0} == 'b')
   {
-    if ( $fig_pos >= 48 && $fig_pos <= 55 )
+    if ($fig_pos >= 48 && $fig_pos <= 55)
       $first_move = 1;
-    if ( $dest_pos==$fig_pos-8 )
+    if ($dest_pos == $fig_pos - 8)
       return 1;
-    if ( $first_move && ( $dest_pos==$fig_pos-16 ) )
+    if ($first_move && ($dest_pos == $fig_pos - 16))
     if ($this->is_empty_tile($fig_pos - 8))
       return 1;
   }
@@ -601,12 +601,12 @@ 
 function tileIsUnderAttack($opp, $dest_pos)
 {
 #var_dump('tileIsUnderAttack, opp', $opp, 'dest_pos', $dest_pos, 'board', $board);#*#DEBUG#
-  for ( $i = 0; $i < 64; $i++ )
-    if ($this->board[$i]{0} == $opp )
+  for ($i = 0; $i < 64; $i++)
+    if ($this->board[$i]{0} == $opp)
     {
-      if ( ($this->board[$i]{1}=='P' && $this->checkPawnAttack($i,$dest_pos)) ||
-           ($this->board[$i]{1}!='P' && 
-                $this->tileIsReachable($this->board[$i]{1},$i,$dest_pos)) )
+      if (($this->board[$i]{1} == 'P' && $this->checkPawnAttack($i, $dest_pos)) ||
+           ($this->board[$i]{1} != 'P' && 
+                $this->tileIsReachable($this->board[$i]{1},$i, $dest_pos)))
       {
         /*DEBUG: echo "attack test: $i: ",$opp,"P<BR>"; */
         return 1;
@@ -628,15 +628,15 @@ 
 {
 
 #var_dump('kingIsUnderAttack, player', $player, 'opp', $opp, 'board', $board);#*#DEBUG#
-  for ( $i = 0; $i < 64; $i++ )
-    if ($this->board[$i]{0} == $player && $this->board[$i]{1} == 'K' )
+  for ($i = 0; $i < 64; $i++)
+    if ($this->board[$i]{0} == $player && $this->board[$i]{1} == 'K')
     {
       $king_pos = $i;
       break;
     }
   /*DEBUG: echo "$player king is at $king_pos<BR>"; */
   
-  return $this->tileIsUnderAttack( $opp, $king_pos );
+  return $this->tileIsUnderAttack($opp, $king_pos);
 }
 
 /**
@@ -650,22 +650,22 @@ 
  */
 function isCheckMate($player, $opp)
 {
-  for ( $i = 0; $i < 64; $i++ )
-    if ($this->board[$i]{0} == $player && $this->board[$i]{1} == 'K' )
+  for ($i = 0; $i < 64; $i++)
+    if ($this->board[$i]{0} == $player && $this->board[$i]{1} == 'K')
     {
       $king_pos = $i;
       $king_x = $i % 8;
-      $king_y = floor($i/8);
+      $king_y = floor($i / 8);
       break;
     }
 
   /* test adjacent tiles while king is temporarly removed */
-  $adj_tiles = $this->getAdjTiles( $king_pos );
+  $adj_tiles = $this->getAdjTiles($king_pos);
   $contents = $this->board[$king_pos]; $this->clear_tile($king_pos);
-  foreach ( $adj_tiles as $dest_pos ) 
+  foreach ($adj_tiles as $dest_pos) 
   {
-    if ($this->board[$dest_pos]{0} == $player ) continue;
-    if ( $this->tileIsUnderAttack($opp,$dest_pos) ) continue;
+    if ($this->board[$dest_pos]{0} == $player) continue;
+    if ($this->tileIsUnderAttack($opp, $dest_pos)) continue;
     $this->board[$king_pos] = $contents;
     return 0;
   }
@@ -675,12 +675,12 @@ 
 
   /* get all figures that attack the king */
   $attackers = array(); $count = 0;
-  for ( $i = 0; $i < 64; $i++ )
-    if ( $this->board[$i]{0} == $opp )
+  for ($i = 0; $i < 64; $i++)
+    if ($this->board[$i]{0} == $opp)
     {
-      if ( ($this->board[$i]{1}=='P' && $this->checkPawnAttack($i,$king_pos)) ||
-           ($this->board[$i]{1}!='P' && 
-                $this->tileIsReachable($this->board[$i]{1},$i,$king_pos)) )
+      if (($this->board[$i]{1} == 'P' && $this->checkPawnAttack($i, $king_pos)) ||
+           ($this->board[$i]{1} != 'P' && 
+                $this->tileIsReachable($this->board[$i]{1},$i, $king_pos)))
       {
           $attackers[$count++] = $i;
       }
@@ -691,19 +691,19 @@ 
   echo "Attackercount: ",count($attackers), " "; */
  
   /* if more than one there is no chance to escape */
-  if ( $count > 1 ) return 1;
+  if ($count > 1) return 1;
 
   /* check whether attacker can be killed by own figure */
   $dest_pos = $attackers[0];
-  for ( $i = 0; $i < 64; $i++ )
-    if ( $this->board[$i]{0} == $player )
+  for ($i = 0; $i < 64; $i++)
+    if ($this->board[$i]{0} == $player)
     {
-      if ( ($this->board[$i]{1}=='P' && $this->checkPawnAttack($i,$dest_pos)) ||
-           ($this->board[$i]{1}!='P' && $this->board[$i]{1}!='K' &&
-              $this->tileIsReachable($this->board[$i]{1},$i,$dest_pos)) ||
-           ($this->board[$i]{1}=='K' && 
-              $this->tileIsReachable($this->board[$i]{1},$i,$dest_pos) &&
-              !$this->tileIsUnderAttack($opp,$dest_pos)) )
+      if (($this->board[$i]{1} == 'P' && $this->checkPawnAttack($i, $dest_pos)) ||
+           ($this->board[$i]{1} != 'P' && $this->board[$i]{1} != 'K' &&
+              $this->tileIsReachable($this->board[$i]{1},$i, $dest_pos)) ||
+           ($this->board[$i]{1} == 'K' && 
+              $this->tileIsReachable($this->board[$i]{1},$i, $dest_pos) &&
+              !$this->tileIsUnderAttack($opp, $dest_pos)))
       {
         /* DEBUG: echo "candidate: $i "; */
         $can_kill_atk = 0;
@@ -711,11 +711,11 @@ 
         $contents_atk = $this->board[$dest_pos];
         $this->board[$dest_pos] = $this->board[$i];
         $this->clear_tile($i);
-        if ( !$this->tileIsUnderAttack($opp,$king_pos) )
+        if (!$this->tileIsUnderAttack($opp, $king_pos))
           $can_kill_atk = 1;
         $this->board[$i] = $contents_def;
         $this->board[$dest_pos] = $contents_atk;
-        if ( $can_kill_atk )
+        if ($can_kill_atk)
         {
           /* DEBUG: echo "$i can kill attacker"; */
           return 0;
@@ -727,29 +727,29 @@ 
   
   /* if attacking unit is a knight there
    * is no way to block the path */
-  if ( $this->board[$dest_pos]{1} == 'N' ) return 1;
+  if ($this->board[$dest_pos]{1} == 'N') return 1;
 
   /* if enemy is adjacent to king there is no
    * way either */
   $dest_x = $dest_pos % 8;
-  $dest_y = floor($dest_pos/8);
-  if ( abs($dest_x-$king_x)<=1 && abs($dest_y-$king_y)<=1 )
+  $dest_y = floor($dest_pos / 8);
+  if (abs($dest_x - $king_x) <= 1 && abs($dest_y - $king_y) <= 1)
     return 1;
 
   /* get the list of tiles between king and attacking
    * unit that can be blocked to stop the attack */
-  $change = $this->getPathChange($this->board[$dest_pos]{1},$dest_pos,$king_pos);
+  $change = $this->getPathChange($this->board[$dest_pos]{1},$dest_pos, $king_pos);
   /* DEBUG:  echo "path change: $change "; */
-  $path = $this->getPath($dest_pos+$change,$king_pos,$change);
+  $path = $this->getPath($dest_pos + $change, $king_pos, $change);
   /* DEBUG: foreach( $path as $tile ) echo "tile: $tile "; */
-  foreach( $path as $pos )
+  foreach ($path as $pos)
   {
-    for ( $i = 0; $i < 64; $i++ )
-      if ( $this->board[$i]{0} == $player )
+    for ($i = 0; $i < 64; $i++)
+      if ($this->board[$i]{0} == $player)
       {
-        if ( ($this->board[$i]{1}=='P' && $this->checkPawnMove($i,$pos)) ||
-             ($this->board[$i]{1}!='P' && $this->board[$i]{1}!='K' &&
-                  $this->tileIsReachable($this->board[$i]{1},$i,$pos)) )
+        if (($this->board[$i]{1} == 'P' && $this->checkPawnMove($i, $pos)) ||
+             ($this->board[$i]{1} != 'P' && $this->board[$i]{1} != 'K' &&
+                  $this->tileIsReachable($this->board[$i]{1},$i, $pos)))
         {
             /* DEBUG: echo "$i can block "; */
             return 0;
@@ -772,61 +772,61 @@ 
  */
 function isStaleMate($player, $opp)
 {
-  for ( $i = 0; $i < 64; $i++ )
-    if ($this->board[$i]{0} == $player )
+  for ($i = 0; $i < 64; $i++)
+    if ($this->board[$i]{0} == $player)
       switch ($this->board[$i]{1} )
       {
         case 'K':
-          $adj_tiles = $this->getAdjTiles( $i );
-          foreach ( $adj_tiles as $pos ) 
+          $adj_tiles = $this->getAdjTiles($i);
+          foreach ($adj_tiles as $pos) 
           {
-            if ( $this->board[$pos]{0} == $player ) continue;
-            if ( $this->tileIsUnderAttack($opp,$pos) ) continue;
+            if ($this->board[$pos]{0} == $player) continue;
+            if ($this->tileIsUnderAttack($opp, $pos)) continue;
             return 0;
           }
           /* DEBUG:  echo "King cannot escape by itself! "; */
           break;
         case 'P':
-          if ( $player == 'w' )
+          if ($player == 'w')
           {
             if ($this->is_empty_tile($i + 8)) return 0;
-            if ( ($i%8) > 0 && $this->board[$i+7]{0} != $player ) return 0;
-            if ( ($i%8) < 7 && $this->board[$i+9]{0} != $player ) return 0;
+            if (($i % 8) > 0 && $this->board[$i + 7]{0} != $player) return 0;
+            if (($i % 8) < 7 && $this->board[$i + 9]{0} != $player) return 0;
           }
           else
           {
             if ($this->is_empty_tile($i - 8)) return 0;
-            if ( ($i%8) > 0 && $this->board[$i-9]{0} != $player ) return 0;
-            if ( ($i%8) < 7 && $this->board[$i-7]{0} != $player ) return 0;
+            if (($i % 8) > 0 && $this->board[$i - 9]{0} != $player) return 0;
+            if (($i % 8) < 7 && $this->board[$i - 7]{0} != $player) return 0;
           }
           break;
         case 'B':
-          if ( $i-9 >= 0  && $this->board[$i-9]{0} != $player ) return 0;
-          if ( $i-7 >= 0  && $this->board[$i-7]{0} != $player ) return 0;
-          if ( $i+9 <= 63 && $this->board[$i+9]{0} != $player ) return 0;
-          if ( $i+7 <= 63 && $this->board[$i+7]{0} != $player ) return 0;
+          if ($i - 9 >= 0 && $this->board[$i - 9]{0} != $player) return 0;
+          if ($i - 7 >= 0 && $this->board[$i - 7]{0} != $player) return 0;
+          if ($i + 9 <= 63 && $this->board[$i + 9]{0} != $player) return 0;
+          if ($i + 7 <= 63 && $this->board[$i + 7]{0} != $player) return 0;
           break;
         case 'R':
-          if ( $i-8 >= 0  && $this->board[$i-8]{0} != $player ) return 0;
-          if ( $i-1 >= 0  && $this->board[$i-1]{0} != $player ) return 0;
-          if ( $i+8 <= 63 && $this->board[$i+8]{0} != $player ) return 0;
-          if ( $i+1 <= 63 && $this->board[$i+1]{0} != $player ) return 0;
+          if ($i - 8 >= 0 && $this->board[$i - 8]{0} != $player) return 0;
+          if ($i - 1 >= 0 && $this->board[$i - 1]{0} != $player) return 0;
+          if ($i + 8 <= 63 && $this->board[$i + 8]{0} != $player) return 0;
+          if ($i + 1 <= 63 && $this->board[$i + 1]{0} != $player) return 0;
           break;
         case 'Q':
-          $adj_tiles = $this->getAdjTiles( $i );
-          foreach ( $adj_tiles as $pos )
-            if ( $this->board[$pos]{0} != $player ) 
+          $adj_tiles = $this->getAdjTiles($i);
+          foreach ($adj_tiles as $pos)
+            if ($this->board[$pos]{0} != $player) 
               return 0;
           break;
         case 'N':
-          if ( $i-17 >= 0  && $this->board[$i-17]{0} != $player ) return 0; 
-          if ( $i-15 >= 0  && $this->board[$i-15]{0} != $player ) return 0;
-          if ( $i-6  >= 0  && $this->board[$i-6]{0}  != $player ) return 0;
-          if ( $i+10 <= 63 && $this->board[$i+10]{0} != $player ) return 0;
-          if ( $i+17 <= 63 && $this->board[$i+17]{0} != $player ) return 0;
-          if ( $i+15 <= 63 && $this->board[$i+15]{0} != $player ) return 0;
-          if ( $i+6  <= 63 && $this->board[$i+6]{0}  != $player ) return 0;
-          if ( $i-10 >= 0  && $this->board[$i-10]{0} != $player ) return 0;
+          if ($i - 17 >= 0 && $this->board[$i - 17]{0} != $player) return 0; 
+          if ($i - 15 >= 0 && $this->board[$i - 15]{0} != $player) return 0;
+          if ($i - 6 >= 0 && $this->board[$i - 6]{0} != $player) return 0;
+          if ($i + 10 <= 63 && $this->board[$i + 10]{0} != $player) return 0;
+          if ($i + 17 <= 63 && $this->board[$i + 17]{0} != $player) return 0;
+          if ($i + 15 <= 63 && $this->board[$i + 15]{0} != $player) return 0;
+          if ($i + 6 <= 63 && $this->board[$i + 6]{0} != $player) return 0;
+          if ($i - 10 >= 0 && $this->board[$i - 10]{0} != $player) return 0;
           break;
       }
       
@@ -888,12 +888,12 @@ 
 
   $this->ac_move = $move;
 
-  if ( strlen($move)>=6 ) 
+  if (strlen($move) >= 6) 
   {
     /* full move: a pawn requires a ? in the end
      * to automatically choose a queen on last line */
-    if ( $move[0] == 'P' )
-    if ( $move[strlen($move)-1]<'A' || $move[strlen($move)-1]>'Z' )
+    if ($move[0] == 'P')
+    if ($move[strlen($move) - 1] < 'A' || $move[strlen($move) - 1] > 'Z')
       $this->ac_move = "$move?";
     return "";
   }
@@ -903,62 +903,62 @@ 
    * when entering the last file. we split this character
    * to keep the autocompletion process the same. */
   $pawn_upg = "?";
-  if ( $move[strlen($move)-1]>='A' && $move[strlen($move)-1]<='Z' )
+  if ($move[strlen($move) - 1] >= 'A' && $move[strlen($move) - 1] <= 'Z')
   {
-    $pawn_upg = $move[strlen($move)-1];
-    $move = substr( $move, 0, strlen($move)-1 );
+    $pawn_upg = $move[strlen($move) - 1];
+    $move = substr($move, 0, strlen($move) - 1);
   }
   // remove trailing '=', if present
-  if ($move{strlen($move)-1} == '=') {
-    $move = substr($move, 0, strlen($move)-1);
+  if ($move{strlen($move) - 1} == '=') {
+    $move = substr($move, 0, strlen($move) - 1);
   }
-  if ( $pawn_upg == "P" || $pawn_upg == "K" )
+  if ($pawn_upg == "P" || $pawn_upg == "K")
     return _MD_CHESS_MOVE_PAWN_MAY_BECOME; // "A pawn may only become either a knight, a bishop, a rook or a queen!"
 
-  if ( $move[0]>='a' && $move[0]<='h' )
+  if ($move[0] >= 'a' && $move[0] <= 'h')
   {
     /* pawn move. either it's 2 or for characters as 
      * listed above */
-    if ( strlen($move) == 4 )
+    if (strlen($move) == 4)
     {
-      if ( $move[1] != 'x' )
+      if ($move[1] != 'x')
         return _MD_CHESS_MOVE_USE_X; // "use x to indicate an attack"
       $dest_x = $move[2];
       $dest_y = $move[3];
       $src_x  = $move[0];
-      if ( $player == 'w' )
-        $src_y  = $dest_y-1;
+      if ($player == 'w')
+        $src_y  = $dest_y - 1;
       else
-        $src_y  = $dest_y+1;
-      $this->ac_move = sprintf( "P%s%dx%s%d%s", 
-                          $src_x,$src_y,$dest_x,$dest_y,
-                          $pawn_upg );
+        $src_y  = $dest_y + 1;
+      $this->ac_move = sprintf("P%s%dx%s%d%s", 
+                          $src_x, $src_y, $dest_x, $dest_y,
+                          $pawn_upg);
       return "";
     }
     else
-    if (strlen($move) == 2 )
+    if (strlen($move) == 2)
     {
-      $fig = sprintf( "%sP", $player );
-      if ( $move[1] >= '1' && $move[1] <= '8' )
+      $fig = sprintf("%sP", $player);
+      if ($move[1] >= '1' && $move[1] <= '8')
       {
         /* pawn move */
-        $pos = $this->boardCoordToIndex( $move );
-        if ( $pos == 64 ) return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $move); // "coordinate $move is invalid"
-        if ( $player == 'w' )
+        $pos = $this->boardCoordToIndex($move);
+        if ($pos == 64) return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $move); // "coordinate $move is invalid"
+        if ($player == 'w')
         {
-          while( $pos >= 0 && $this->board[$pos] != $fig ) $pos -= 8;
-          if ( $pos < 0 ) $not_found = 1;
+          while ($pos >= 0 && $this->board[$pos] != $fig) $pos -= 8;
+          if ($pos < 0) $not_found = 1;
         }
         else
         {
-          while( $pos <= 63 && $this->board[$pos] != $fig ) $pos += 8;
-          if ( $pos > 63 ) $not_found = 1;
+          while ($pos <= 63 && $this->board[$pos] != $fig) $pos += 8;
+          if ($pos > 63) $not_found = 1;
         }
-        $pos = $this->boardIndexToCoord( $pos );
-        if ( (isset($not_found) && $not_found) || $pos == "" ) {
+        $pos = $this->boardIndexToCoord($pos);
+        if ((isset($not_found) && $not_found) || $pos == "") {
           return $this->move_msg(_MD_CHESS_MOVE_CANNOT_FIND_PAWN, $player, $move[0]); // "cannot find $player pawn in column $move[0]"
         } else {
-          $this->ac_move = sprintf( "P%s-%s%s", $pos, $move, $pawn_upg );
+          $this->ac_move = sprintf("P%s-%s%s", $pos, $move, $pawn_upg);
           return "";
         }
       }
@@ -966,30 +966,30 @@ 
       {
         /* notation: [a-h][a-h] for pawn attack no longer allowed 
          * except for history browser */
-        if ( $this->browsing_mode == 0 )
+        if ($this->browsing_mode == 0)
             return _MD_CHESS_MOVE_USE_NOTATION; // "please use denotation [a-h]x[a-h][1-8] for pawn attacks (see help for more information)"
         /* pawn attack must be only one pawn in column! */
         $pawns = 0;
-        $start = $this->boardCoordToIndex( sprintf( "%s1", $move[0] ) );
-        if ( $start == 64 ) return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $move[0]); // "coordinate $move[0] is invalid"
-        for ( $i = 1; $i <= 8; $i++, $start+=8 )
-          if ( $this->board[$start] == $fig ) 
+        $start = $this->boardCoordToIndex(sprintf("%s1", $move[0]));
+        if ($start == 64) return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $move[0]); // "coordinate $move[0] is invalid"
+        for ($i = 1; $i <= 8; $i++, $start += 8)
+          if ($this->board[$start] == $fig) 
           {
             $pawns++;
             $pawn_line = $i;
           }
-        if ( $pawns == 0 )
+        if ($pawns == 0)
           return $this->move_msg(_MD_CHESS_MOVE_NO_PAWN, $move[0]); // "there is no pawn in column $move[0]"
-        else if ( $pawns > 1 )
+        else if ($pawns > 1)
           return $this->move_msg(_MD_CHESS_MOVE_TWO_PAWNS, $move[0]); // "there is more than one pawn in column $move[0]"
         else
         {
-          if ( $player == 'w' )
-            $dest_line = $pawn_line+1;
+          if ($player == 'w')
+            $dest_line = $pawn_line + 1;
           else
-            $dest_line = $pawn_line-1;
-          $this->ac_move = sprintf( "P%s%dx%s%d", 
-                            $move[0],$pawn_line,$move[1],$dest_line );
+            $dest_line = $pawn_line - 1;
+          $this->ac_move = sprintf("P%s%dx%s%d", 
+                            $move[0], $pawn_line, $move[1], $dest_line);
           return "";
         }
       }
@@ -998,90 +998,90 @@ 
   else
   {
     /* figure move */
-    $dest_coord = substr( $move, strlen($move)-2, 2 );
-    $action = $move[strlen($move)-3];
-    if ( $action != 'x' ) $action = '-';
-    if ( $player == 'w' ) 
+    $dest_coord = substr($move, strlen($move) - 2, 2);
+    $action = $move[strlen($move) - 3];
+    if ($action != 'x') $action = '-';
+    if ($player == 'w') 
       $figures = $this->w_figures;
     else
       $figures = $this->b_figures;
     $fig_count = 0;
-    foreach( $figures as $figure )
-      if ( $figure[0] == $move[0] )
+    foreach ($figures as $figure)
+      if ($figure[0] == $move[0])
       {
         $fig_count++;
-        if ( $fig_count == 1 )
-          $pos1 = substr( $figure, 1, 2 );
+        if ($fig_count == 1)
+          $pos1 = substr($figure, 1, 2);
         else
-          $pos2 = substr( $figure, 1, 2 );
+          $pos2 = substr($figure, 1, 2);
       }
-    if ( $fig_count == 0 )
+    if ($fig_count == 0)
       return $this->move_msg(_MD_CHESS_MOVE_NO_FIGURE, $move[0], $this->getFullFigureName($move[0])); // sprintf("there is no figure %s = %s", $move[0], $this->getFullFigureName($move[0]))
     else
-    if ( $fig_count == 1 )
+    if ($fig_count == 1)
     {
-       $this->ac_move = sprintf( "%s%s%s%s",
-                      $move[0], $pos1, $action, $dest_coord ); 
+       $this->ac_move = sprintf("%s%s%s%s",
+                      $move[0], $pos1, $action, $dest_coord); 
        return "";
     }
     else
     {
       /* two figures which may cause ambiguity */
-      $dest_pos = $this->boardCoordToIndex( $dest_coord );
-      if ( $dest_pos == 64 ) 
+      $dest_pos = $this->boardCoordToIndex($dest_coord);
+      if ($dest_pos == 64) 
         return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $dest_coord); // "coordinate $dest_coord is invalid"
-      $fig1_can_reach = $this->tileIsReachable( $move[0], 
-                            $this->boardCoordToIndex($pos1), $dest_pos );
-      $fig2_can_reach = $this->tileIsReachable( $move[0], 
-                            $this->boardCoordToIndex($pos2), $dest_pos );
-      if ( !$fig1_can_reach && !$fig2_can_reach )
+      $fig1_can_reach = $this->tileIsReachable($move[0], 
+                            $this->boardCoordToIndex($pos1), $dest_pos);
+      $fig2_can_reach = $this->tileIsReachable($move[0], 
+                            $this->boardCoordToIndex($pos2), $dest_pos);
+      if (!$fig1_can_reach && !$fig2_can_reach)
         return $this->move_msg(_MD_CHESS_MOVE_NEITHER_CAN_REACH, $move[0], $this->getFullFigureName($move[0]), $dest_coord); // sprintf("neither of the %s = %s can reach %s", $move[0], $this->getFullFigureName($move[0]), $dest_coord)
       else
-      if ( $fig1_can_reach && $fig2_can_reach )
+      if ($fig1_can_reach && $fig2_can_reach)
       {
         /* ambiguity - check whether a hint is given */
-        if ( ($action=='-' && strlen($move)==4) ||
-             ($action=='x' && strlen($move)==5) )
+        if (($action == '-' && strlen($move) == 4) ||
+             ($action == 'x' && strlen($move) == 5))
           $hint = $move[1];
-        if ( empty($hint) )
+        if (empty($hint))
           return $this->move_msg(_MD_CHESS_MOVE_BOTH_CAN_REACH, $move[0], $this->getFullFigureName($move[0]), $dest_coord); // sprintf("both of the %s = %s can reach %s", $move[0], $this->getFullFigureName($move[0]), $dest_coord)
         else
         {
           $move_fig1 = 0;
           $move_fig2 = 0;
-          if ( $hint>='1' && $hint<='8' )
+          if ($hint >= '1' && $hint <= '8')
           {
-            if ( $pos1[1]==$hint && $pos2[1]!=$hint )
+            if ($pos1[1] == $hint && $pos2[1] != $hint)
               $move_fig1 = 1;
-            if ( $pos2[1]==$hint && $pos1[1]!=$hint )
+            if ($pos2[1] == $hint && $pos1[1] != $hint)
               $move_fig2 = 1;
           }
           else
           {
-            if ( $pos1[0]==$hint && $pos2[0]!=$hint )
+            if ($pos1[0] == $hint && $pos2[0] != $hint)
               $move_fig1 = 1;
-            if ( $pos2[0]==$hint && $pos1[0]!=$hint )
+            if ($pos2[0] == $hint && $pos1[0] != $hint)
               $move_fig2 = 1;
           }
-          if ( !$move_fig1 && !$move_fig2 )
+          if (!$move_fig1 && !$move_fig2)
             return _MD_CHESS_MOVE_AMBIGUOUS; // "ambiguity is not properly resolved"
-          if ( $move_fig1 )
-            $this->ac_move = sprintf( "%s%s%s%s",
-                          $move[0], $pos1, $action, $dest_coord );
+          if ($move_fig1)
+            $this->ac_move = sprintf("%s%s%s%s",
+                          $move[0], $pos1, $action, $dest_coord);
           else
-            $this->ac_move = sprintf( "%s%s%s%s",
-                          $move[0], $pos2, $action, $dest_coord );
+            $this->ac_move = sprintf("%s%s%s%s",
+                          $move[0], $pos2, $action, $dest_coord);
           return;
         }
       }
       else
       {
-        if ( $fig1_can_reach )
-          $this->ac_move = sprintf( "%s%s%s%s",
-                        $move[0], $pos1, $action, $dest_coord ); 
+        if ($fig1_can_reach)
+          $this->ac_move = sprintf("%s%s%s%s",
+                        $move[0], $pos1, $action, $dest_coord); 
         else
-          $this->ac_move = sprintf( "%s%s%s%s",
-                        $move[0], $pos2, $action, $dest_coord ); 
+          $this->ac_move = sprintf("%s%s%s%s",
+                        $move[0], $pos2, $action, $dest_coord); 
         return "";
       }
     }
@@ -1109,36 +1109,36 @@ 
                               will overwrite it */
                   
   /* valid pawn moves are always non-ambigious */
-  if ( $move[0] == 'P' )
+  if ($move[0] == 'P')
   {
     /* skip P anycase. for attacks skip source digit
        and for moves skip source pos and - */
-    if ( $move[3] == '-' )
-      $new_move = substr( $move, 4 );
+    if ($move[3] == '-')
+      $new_move = substr($move, 4);
     else
-    if ( $move[3] == 'x' )
-      $new_move = sprintf("%s%s", $move[1], substr( $move, 3 ) );
+    if ($move[3] == 'x')
+      $new_move = sprintf("%s%s", $move[1], substr($move, 3));
   }
   else
   {
     /* try to remove the source position and check whether it
      * is a non-ambigious move. if it is add one of the components
      * and check again */
-    if ( $move[3] == '-' )
-      $dest = substr( $move, 4 );
+    if ($move[3] == '-')
+      $dest = substr($move, 4);
     else
-    if ( $move[3] == 'x' )
-      $dest = substr( $move, 3 );
-    $new_move = sprintf("%s%s", $move[0], $dest );
-    if ( $this->completeMove($player,$new_move) != "" )
+    if ($move[3] == 'x')
+      $dest = substr($move, 3);
+    $new_move = sprintf("%s%s", $move[0], $dest);
+    if ($this->completeMove($player, $new_move) != "")
     {
       /* add a component */
-      $new_move = sprintf("%s%s%s", $move[0], $move[1], $dest );
-      if ( $this->completeMove($player,$new_move) != "" )
+      $new_move = sprintf("%s%s%s", $move[0], $move[1], $dest);
+      if ($this->completeMove($player, $new_move) != "")
       {
         /* add other component */
-        $new_move = sprintf("%s%s%s", $move[0], $move[2], $dest );
-        if ( $this->completeMove($player,$new_move) != "" )
+        $new_move = sprintf("%s%s%s", $move[0], $move[2], $dest);
+        if ($this->completeMove($player, $new_move) != "")
            $new_move = $move; /* give up */
       }
     }
@@ -1228,7 +1228,7 @@ 
 
 		/* short castling */
 
-		if ($cur_player=="b") {
+		if ($cur_player == "b") {
 
 			if (!$black_may_castle_short) {
 				return(array(false, _MD_CHESS_MOVE_NO_CASTLE)); // You cannot castle short any longer!
@@ -1236,10 +1236,10 @@ 
 			if (!$this->is_empty_tile(61) or !$this->is_empty_tile(62)) {
 				return(array(false, _MD_CHESS_MOVE_NO_CASTLE)); // Cannot castle short because the way is blocked!
 			}
-			if ($this->kingIsUnderAttack( "b", "w" )) {
+			if ($this->kingIsUnderAttack("b", "w")) {
 				return(array(false, _MD_CHESS_MOVE_NO_CASTLE)); // You cannot escape check by castling!
 			}
-			if ( $this->tileIsUnderAttack( "w", 62 ) || $this->tileIsUnderAttack( "w", 61 ) ) {
+			if ($this->tileIsUnderAttack("w", 62) || $this->tileIsUnderAttack("w", 61)) {
 				return(array(false, _MD_CHESS_MOVE_NO_CASTLE)); // A tile the king passes over or into would be under attack after short castling!
 			}
 			$this->clear_tile(60);
@@ -1257,10 +1257,10 @@ 
 			if (!$this->is_empty_tile(5) or !$this->is_empty_tile(6)) {
 				return(array(false, _MD_CHESS_MOVE_NO_CASTLE)); // Cannot castle short because the way is blocked!
 			}
-			if ( $this->kingIsUnderAttack( "w", "b" ) ) {
+			if ($this->kingIsUnderAttack("w", "b")) {
 				return(array(false, _MD_CHESS_MOVE_NO_CASTLE)); // You cannot escape check by castling!
 			}
-			if ( $this->tileIsUnderAttack( "b", 5 ) || $this->tileIsUnderAttack( "b", 6 ) ) {
+			if ($this->tileIsUnderAttack("b", 5) || $this->tileIsUnderAttack("b", 6)) {
 				return(array(false, _MD_CHESS_MOVE_NO_CASTLE)); // A tile the king passes over or into would be under attack after short castling!
 			}
 			$this->clear_tile(4);
@@ -1278,7 +1278,7 @@ 
 
 		/* long castling */
 
-		if ($cur_player=="b") {
+		if ($cur_player == "b") {
 
 			if (!$black_may_castle_long) {
 				return(array(false, _MD_CHESS_MOVE_NO_CASTLE)); // You cannot castle long any longer!
@@ -1286,10 +1286,10 @@ 
 			if (!$this->is_empty_tile(57) or !$this->is_empty_tile(58) or !$this->is_empty_tile(59)) {
 				return(array(false, _MD_CHESS_MOVE_NO_CASTLE)); // Cannot castle long because the way is blocked!
 			}
-			if ( $this->kingIsUnderAttack( "b", "w" ) ) {
+			if ($this->kingIsUnderAttack("b", "w")) {
 				return(array(false, _MD_CHESS_MOVE_NO_CASTLE)); // You cannot escape check by castling!
 			}
-			if ( $this->tileIsUnderAttack( "w", 58 ) || $this->tileIsUnderAttack( "w", 59 ) ) {
+			if ($this->tileIsUnderAttack("w", 58) || $this->tileIsUnderAttack("w", 59)) {
 				return(array(false, _MD_CHESS_MOVE_NO_CASTLE)); // A tile the king passes over or into would be under attack after short castling!
 			}
 			$this->clear_tile(56);
@@ -1307,10 +1307,10 @@ 
 			if (!$this->is_empty_tile(1) or !$this->is_empty_tile(2) or !$this->is_empty_tile(3)) {
 				return(array(false, _MD_CHESS_MOVE_NO_CASTLE)); // Cannot castle long because the way is blocked!
 			}
-			if ($this->kingIsUnderAttack( "w", "b" )) {
+			if ($this->kingIsUnderAttack("w", "b")) {
 				return(array(false, _MD_CHESS_MOVE_NO_CASTLE)); // You cannot escape check by castling!
 			}
-			if ( $this->tileIsUnderAttack( "b", 2 ) || $this->tileIsUnderAttack( "b", 3 ) ) {
+			if ($this->tileIsUnderAttack("b", 2) || $this->tileIsUnderAttack("b", 3)) {
 				return(array(false, _MD_CHESS_MOVE_NO_CASTLE)); // A tile the king passes over or into would be under attack after short castling!
 			}
 			$this->clear_tile(0);
@@ -1331,56 +1331,56 @@ 
 
     /* allow short move description by autocompleting to
      * full description */
-    $ac_error = $this->completeMove( $cur_player, trim($move) );
-    if ( $ac_error != "" )
+    $ac_error = $this->completeMove($cur_player, trim($move));
+    if ($ac_error != "")
       return(array(false, $ac_error)); // "ERROR: autocomplete: $ac_error"
     else 
       $move = $this->ac_move;
-    $this->last_move = str_replace( "?", "", $move );
+    $this->last_move = str_replace("?", "", $move);
     
     /* a final captial letter may only be N,B,R,Q for the
      * appropiate chessman */
-    $c = $move[strlen($move)-1];
-    if ( $c >= 'A' && $c <= 'Z' )
-    if ( $c != 'N' && $c != 'B' && $c != 'R' && $c != 'Q' )
+    $c = $move[strlen($move) - 1];
+    if ($c >= 'A' && $c <= 'Z')
+    if ($c != 'N' && $c != 'B' && $c != 'R' && $c != 'Q')
       return(array(false, _MD_CHESS_MOVE_INVALID_PIECE)); // "ERROR: only N (knight), B (bishop), R (rook) and Q (queen) are valid chessman identifiers"
     
     /* if it is a full move, try to shorten the history move */
-    if ( strlen( $history_move ) >= 6 )
+    if (strlen($history_move) >= 6)
       $history_move = 
-          $this->convertFullToChessNotation($cur_player,$history_move);
+          $this->convertFullToChessNotation($cur_player, $history_move);
     /* DEBUG: echo "Move: $move ($history_move)<BR>"; */
     
     /* validate figure and position */
     $fig_type = $move[0];
-    $fig_name = $this->getFullFigureName( $fig_type );
-    if ( $fig_name == "empty" )
+    $fig_name = $this->getFullFigureName($fig_type);
+    if ($fig_name == "empty")
       return(array(false, $this->move_msg(_MD_CHESS_MOVE_UNKNOWN_FIGURE, $fig_type))); // "ERROR: Figure $fig_type is unknown!"
-    $fig_coord = substr($move,1,2);
-    $fig_pos = $this->boardCoordToIndex( $fig_coord );
-    if ( $fig_pos == 64 ) return(array(false, $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $fig_coord))); // "ERROR: $fig_coord is invalid!"
+    $fig_coord = substr($move, 1, 2);
+    $fig_pos = $this->boardCoordToIndex($fig_coord);
+    if ($fig_pos == 64) return(array(false, $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $fig_coord))); // "ERROR: $fig_coord is invalid!"
     /* DEBUG  echo "fig_type: $fig_type, fig_pos: $fig_pos<BR>"; */
     if ($this->is_empty_tile($fig_pos))
       return(array(false, $this->move_msg(_MD_CHESS_MOVE_TILE_EMPTY, $fig_coord))); // "ERROR: Tile $fig_coord is empty."
-    if ( $this->board[$fig_pos]{0} != $cur_player )
+    if ($this->board[$fig_pos]{0} != $cur_player)
       return(array(false, _MD_CHESS_MOVE_NOT_YOUR_PIECE)); // "ERROR: Figure does not belong to you!"
-    if ( $this->board[$fig_pos]{1} != $fig_type )
+    if ($this->board[$fig_pos]{1} != $fig_type)
       return(array(false, _MD_CHESS_MOVE_NOEXIST_FIGURE)); // "ERROR: Figure does not exist!"
     
     /* get target index */
-    $dest_coord = substr($move,4,2);
-    $dest_pos = $this->boardCoordToIndex( $dest_coord );
-    if ( $dest_pos == 64 )
+    $dest_coord = substr($move, 4, 2);
+    $dest_pos = $this->boardCoordToIndex($dest_coord);
+    if ($dest_pos == 64)
       return(array(false, $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $dest_coord))); // "ERROR: $dest_coord is invalid!"
-    if ( $dest_pos == $fig_pos )
+    if ($dest_pos == $fig_pos)
       return(array(false, _MD_CHESS_MOVE_START_END_SAME));
     /* DEBUG  echo "dest_pos: $dest_pos<BR>"; */
 
     /* get action */
     $action = $move[3];
-    if ( $move[3] == "-" ) 
+    if ($move[3] == "-") 
       $action = 'M'; /* move */
-    else if ( $move[3] == 'x' )
+    else if ($move[3] == 'x')
       $action = 'A'; /* attack */
     else
       return(array(false, $this->move_msg(_MD_CHESS_MOVE_UNKNOWN_ACTION, $action))); // "ERROR: $action is unknown! Please use \"-\" for a move and \"x\" for an attack."
@@ -1393,26 +1393,26 @@ 
      * whether all tiles in between are empty thus the path
      * is not blocked. the final destination tile is not 
      * checked here. */
-    if ( $fig_type != 'P' )
+    if ($fig_type != 'P')
     {
-        if ( !$this->tileIsReachable( $fig_type, $fig_pos, $dest_pos ) )
+        if (!$this->tileIsReachable($fig_type, $fig_pos, $dest_pos))
           return(array(false, $this->move_msg(_MD_CHESS_MOVE_OUT_OF_RANGE, $dest_coord, $fig_name, $fig_coord))); // "ERROR: Tile $dest_coord is out of moving range for $fig_name at $fig_coord!"
     }
     else {
-      if ( $action == 'M' && !$this->checkPawnMove( $fig_pos, $dest_pos ) )
+      if ($action == 'M' && !$this->checkPawnMove($fig_pos, $dest_pos))
           return(array(false, $this->move_msg(_MD_CHESS_MOVE_OUT_OF_RANGE, $dest_coord, $fig_name, $fig_coord))); // "ERROR: Tile $dest_coord is out of moving range for $fig_name at $fig_coord!"
-      if ( $action == 'A' && !$this->checkPawnAttack( $fig_pos, $dest_pos ) )
+      if ($action == 'A' && !$this->checkPawnAttack($fig_pos, $dest_pos))
           return(array(false, $this->move_msg(_MD_CHESS_MOVE_OUT_OF_RANGE, $dest_coord, $fig_name, $fig_coord))); // "ERROR: Tile $dest_coord is out of attacking range for $fig_name at $fig_coord!"
     }
      
 	$en_passant_capture_performed = 0; // 1 if en passant captured occurred, else 0
 	/* check action */
-	if ( $action == 'M' && !$this->is_empty_tile($dest_pos)) {
+	if ($action == 'M' && !$this->is_empty_tile($dest_pos)) {
 		return(array(false, $this->move_msg(_MD_CHESS_MOVE_OCCUPIED, $dest_coord))); // "ERROR: Tile $dest_coord is occupied. You cannot move there."
 	}
-	if ( $action == 'A' && $this->is_empty_tile($dest_pos)) {
+	if ($action == 'A' && $this->is_empty_tile($dest_pos)) {
 		/* en passant of pawn? */
-		if ( $fig_type == 'P' ) {
+		if ($fig_type == 'P') {
 			if ($this->boardIndexToCoord($dest_pos) == $this->gamestate['fen_en_passant_target_square']) {
 				$en_passant_capture_performed = 1;
 			}
@@ -1423,7 +1423,7 @@ 
 			return(array(false, $this->move_msg(_MD_CHESS_MOVE_ATTACK_EMPTY, $dest_coord))); // "ERROR: Tile $dest_coord is empty. You cannot attack it."
 		}
 	}
-	if ( $action == 'A' && $this->board[$dest_pos]{0} == $cur_player ) {
+	if ($action == 'A' && $this->board[$dest_pos]{0} == $cur_player) {
 		return(array(false, $this->move_msg(_MD_CHESS_MOVE_ATTACK_SELF, $dest_coord))); // "ERROR: You cannot attack own unit at $dest_coord."
 	}
 
@@ -1434,33 +1434,33 @@ 
     /* perform move */
     $this->clear_tile($fig_pos);
     if (!$this->is_empty_tile($dest_pos))
-      $this->piece_captured = sprintf("%s%s",$this->board[$dest_pos],$dest_pos);
+      $this->piece_captured = sprintf("%s%s", $this->board[$dest_pos], $dest_pos);
     $this->board[$dest_pos] = "$cur_player$fig_type";
-    if ( $en_passant_capture_performed ) {
+    if ($en_passant_capture_performed) {
       /* kill pawn */
-      if ( $cur_player == 'w' ) 
+      if ($cur_player == 'w') 
       {
         $this->clear_tile($dest_pos - 8);
-        $this->piece_captured = sprintf("bP%s",$dest_pos-8);
+        $this->piece_captured = sprintf("bP%s", $dest_pos - 8);
       }
       else
       {
         $this->clear_tile($dest_pos + 8);
-        $this->piece_captured = sprintf("wP%s",$dest_pos+8);
+        $this->piece_captured = sprintf("wP%s", $dest_pos + 8);
       }
     }
 
     /* check check :) */
-    if ( $this->kingIsUnderAttack( $cur_player, $cur_opp ) )
+    if ($this->kingIsUnderAttack($cur_player, $cur_opp))
     {
       $this->board[$fig_pos] = $old_fig_tile;
       $this->board[$dest_pos] = $old_dest_tile;
-      if ( $en_passant_capture_performed ) {
+      if ($en_passant_capture_performed) {
        // restore pawn that was captured above, since that move is invalid
-        if ( $cur_player == 'w' ) 
-          $this->board[$dest_pos-8] = "bP";
+        if ($cur_player == 'w') 
+          $this->board[$dest_pos - 8] = "bP";
         else
-          $this->board[$dest_pos+8] = "wP";
+          $this->board[$dest_pos + 8] = "wP";
       }
       return(array(false, _MD_CHESS_MOVE_IN_CHECK)); // "ERROR: Move is invalid because king would be under attack then."
     }
@@ -1495,31 +1495,31 @@ 
 	// if a pawn moved two tiles, this will allow 'en passant' on next move
 	if ($fig_type == 'P' and abs($fig_pos - $dest_pos) == 16) {
 		$file_chars = 'abcdefgh';
-		$this->gamestate['fen_en_passant_target_square'] = $file_chars{$fig_pos % 8} . ($cur_player == 'w' ? '3' : '6');
+		$this->gamestate['fen_en_passant_target_square'] = $file_chars{$fig_pos % 8}.($cur_player == 'w' ? '3' : '6');
 	} else {
 		// clear 'en passant'
 		$this->gamestate['fen_en_passant_target_square'] = '-';
 	}
 
-    if ($action == 'M' )
+    if ($action == 'M')
       $result = $this->move_msg(_MD_CHESS_MOVE_MOVED, $fig_name, $fig_coord, $dest_coord);
     else
       $result = $this->move_msg(_MD_CHESS_MOVE_CAPTURED, $fig_name, $dest_coord, $fig_coord);
     
     /* if pawn reached last line convert into a queen */
-    if ( $fig_type == 'P' )
+    if ($fig_type == 'P')
     {
-      if ( ($cur_player=='w' && $dest_pos>= 56) || 
-           ($cur_player=='b' && $dest_pos<= 7 ) )
+      if (($cur_player == 'w' && $dest_pos >= 56) || 
+           ($cur_player == 'b' && $dest_pos <= 7))
       {
-        $pawn_upg = $move[strlen($move)-1];
-        if ( $pawn_upg == '?' ) 
+        $pawn_upg = $move[strlen($move) - 1];
+        if ($pawn_upg == '?') 
         {
           $pawn_upg = 'Q';
-          $history_move = sprintf( "%sQ", $history_move );
+          $history_move = sprintf("%sQ", $history_move);
         }
         $this->board[$dest_pos] = "$cur_player$pawn_upg";
-        $result .= ' ... ' . $this->move_msg(_MD_CHESS_MOVE_PROMOTED, $this->getFullFigureName($pawn_upg));
+        $result .= ' ... '.$this->move_msg(_MD_CHESS_MOVE_PROMOTED, $this->getFullFigureName($pawn_upg));
       }
     }
   
@@ -1538,28 +1538,28 @@ 
 
 		// handle check, checkmate and stalemate
 		$comment = '';
-		if ($this->kingIsUnderAttack( $cur_opp, $cur_player)) {
+		if ($this->kingIsUnderAttack($cur_opp, $cur_player)) {
 			// if this is check mate finish the game, otherwise if not just add a + to the move
 			if ($this->isCheckMate($cur_opp, $cur_player)) {
 				$this->gamestate['pgn_result'] = $cur_player == 'w' ? '1-0' : '0-1';
 				$history_move .= '#';
-				$result .= ' ... ' . _MD_CHESS_MOVE_CHECKMATE;
+				$result .= ' ... '._MD_CHESS_MOVE_CHECKMATE;
 			} else {
 				$history_move .= '+';
 			}
 		} elseif ($this->isStaleMate($cur_opp, $cur_player)) {
 			$this->gamestate['pgn_result'] = '1/2-1/2';
-			$result .= ' ... ' . _MD_CHESS_MOVE_STALEMATE;
+			$result .= ' ... '._MD_CHESS_MOVE_STALEMATE;
 			$comment = _MD_CHESS_DRAW_STALEMATE;
 		} elseif ($this->insufficient_mating_material()) {
 			$this->gamestate['pgn_result'] = '1/2-1/2';
-			$result .= ' ... ' . _MD_CHESS_MOVE_MATERIAL;
+			$result .= ' ... '._MD_CHESS_MOVE_MATERIAL;
 			$comment = _MD_CHESS_DRAW_NO_MATE;
 		}
 
 		// store possible castling-availability modification
-		$KQkq = ($white_may_castle_short ? 'K' : '') . ($white_may_castle_long ? 'Q' : '')
-				. ($black_may_castle_short ? 'k' : '') . ($black_may_castle_long ? 'q' : '');
+		$KQkq = ($white_may_castle_short ? 'K' : '').($white_may_castle_long ? 'Q' : '')
+				. ($black_may_castle_short ? 'k' : '').($black_may_castle_long ? 'q' : '');
 		$this->gamestate['fen_castling_availability'] = !empty($KQkq) ? $KQkq : '-';
 
 		// strip old result-string from end of movetext
@@ -1572,18 +1572,18 @@ 
 			if (!empty($this->gamestate['pgn_movetext'])) {
 				$this->gamestate['pgn_movetext'] .= ' ';
 			}
-			$this->gamestate['pgn_movetext'] .= $this->gamestate['fen_fullmove_number'] . '.';
+			$this->gamestate['pgn_movetext'] .= $this->gamestate['fen_fullmove_number'].'.';
 
 		// if black move, no moves yet, and game is setup, output move number with special '...' terminator
 		} elseif (empty($this->gamestate['pgn_movetext']) and !empty($this->gamestate['pgn_fen'])) {
-			$this->gamestate['pgn_movetext'] .= $this->gamestate['fen_fullmove_number'] . '...';
+			$this->gamestate['pgn_movetext'] .= $this->gamestate['fen_fullmove_number'].'...';
 		}
 
 		// update movetext
 		// comment is added only for a concluded game
-		$this->gamestate['pgn_movetext'] .= ' ' . $history_move . ' ' . $this->gamestate['pgn_result'];
+		$this->gamestate['pgn_movetext'] .= ' '.$history_move.' '.$this->gamestate['pgn_result'];
 		if (!empty($comment)) {
-			$this->gamestate['pgn_movetext'] .= ' {' . $comment . '}';
+			$this->gamestate['pgn_movetext'] .= ' {'.$comment.'}';
 		}
 
 		// if black move, increment move-number
@@ -1676,9 +1676,9 @@ 
 		$tile = $this->board[$i];
 		$coordinates = $this->boardIndexToCoord($i);
 		if ($tile{0} == 'w') {
-			$this->w_figures[] = $tile{1} . $coordinates;
+			$this->w_figures[] = $tile{1}.$coordinates;
 		} elseif ($tile{0} == 'b') {
-			$this->b_figures[] = $tile{1} . $coordinates;
+			$this->b_figures[] = $tile{1}.$coordinates;
 		}
 	}
 
@@ -1711,7 +1711,7 @@ 
 	}
 	// Concatenate the eight row-strings with the separator '/'.
 	// Then replace each string of x's with the string length.
-	$this->gamestate['fen_piece_placement'] = preg_replace_callback('/(x+)/', create_function('$matches','return strlen($matches[1]);'), implode('/', $rows));
+	$this->gamestate['fen_piece_placement'] = preg_replace_callback('/(x+)/', create_function('$matches', 'return strlen($matches[1]);'), implode('/', $rows));
 }
 
 /**
@@ -1747,10 +1747,10 @@ 
  *
  * @access private
  */
-function boardCoordToIndex( $coord )
+function boardCoordToIndex($coord)
 {
   //echo $coord," --> ";
-  switch ( $coord[0] ) 
+  switch ($coord[0]) 
   {
     case 'a': $x = 0; break;
     case 'b': $x = 1; break;
@@ -1762,8 +1762,8 @@ 
     case 'h': $x = 7; break;
     default: return 64; /* erronous coord */
   }
-  $y = $coord[1]-1; 
-  if ( $y < 0 || $y > 7 )
+  $y = $coord[1] - 1; 
+  if ($y < 0 || $y > 7)
     return 64; /* erronous coord */
   $index = $y * 8 + $x;
   //echo "$index | ";
@@ -1778,13 +1778,13 @@ 
  *
  * @access private
  */
-function boardIndexToCoord( $index )
+function boardIndexToCoord($index)
 {
   //echo $index," --> ";
-  if ( $index < 0 || $index > 63 )
+  if ($index < 0 || $index > 63)
     return "";
-  $y = floor($index/8)+1;
-  $x = chr( ($index%8)+97 );
+  $y = floor($index / 8) + 1;
+  $x = chr(($index % 8) + 97);
   $coord = "$x$y";
   //echo "$coord | ";
   return $coord;
@@ -1798,7 +1798,7 @@ 
  *
  * @access private
  */
-function getFullFigureName( $short )
+function getFullFigureName($short)
 {
 	static $names = array(
 		'K' => _MD_CHESS_MOVE_KING,
@@ -1819,20 +1819,20 @@ 
  *
  * @access private
  */
-function getAdjTiles( $fig_pos )
+function getAdjTiles($fig_pos)
 {
   $adj_tiles = array(); $i = 0;
 
-  $x = $fig_pos % 8; $y = floor( $fig_pos / 8 );
+  $x = $fig_pos % 8; $y = floor($fig_pos / 8);
   
-  if ( $x > 0 && $y > 0 ) $adj_tiles[$i++] = $fig_pos-9;
-  if (           $y > 0 ) $adj_tiles[$i++] = $fig_pos-8;
-  if ( $x < 7 && $y > 0 ) $adj_tiles[$i++] = $fig_pos-7;
-  if ( $x < 7           ) $adj_tiles[$i++] = $fig_pos+1;
-  if ( $x < 7 && $y < 7 ) $adj_tiles[$i++] = $fig_pos+9;
-  if (           $y < 7 ) $adj_tiles[$i++] = $fig_pos+8;
-  if ( $x > 0 && $y < 7 ) $adj_tiles[$i++] = $fig_pos+7;
-  if ( $x > 0           ) $adj_tiles[$i++] = $fig_pos-1;
+  if ($x > 0 && $y > 0) $adj_tiles[$i++] = $fig_pos - 9;
+  if ($y > 0) $adj_tiles[$i++] = $fig_pos - 8;
+  if ($x < 7 && $y > 0) $adj_tiles[$i++] = $fig_pos - 7;
+  if ($x < 7) $adj_tiles[$i++] = $fig_pos + 1;
+  if ($x < 7 && $y < 7) $adj_tiles[$i++] = $fig_pos + 9;
+  if ($y < 7) $adj_tiles[$i++] = $fig_pos + 8;
+  if ($x > 0 && $y < 7) $adj_tiles[$i++] = $fig_pos + 7;
+  if ($x > 0) $adj_tiles[$i++] = $fig_pos - 1;
 
   /* DEBUG:  foreach( $adj_tiles as $tile )
     echo "adj: $tile "; */

Braces +495 added lines, -292 removed lines

@@ -260,8 +260,7 @@ 
 	if (!$this->fen_piece_placement_to_board())
 	{
 		return _MD_CHESS_FENBAD_PP_INVALID; // piece_placement invalid
-	}
-	elseif ($this->gamestate['fen_active_color'] != 'w' and $this->gamestate['fen_active_color'] != 'b')
+	} elseif ($this->gamestate['fen_active_color'] != 'w' and $this->gamestate['fen_active_color'] != 'b')
 	{
 		return _MD_CHESS_FENBAD_AC_INVALID; // active_color invalid
 	}
@@ -269,46 +268,37 @@ 
 	elseif ($this->gamestate['fen_castling_availability'] != '-' and !preg_match('/^K?Q?k?q?$/', $this->gamestate['fen_castling_availability']))
 	{
 		return _MD_CHESS_FENBAD_CA_INVALID; // castling_availability invalid
-	}
-	elseif ($this->gamestate['fen_en_passant_target_square'] != '-' and !preg_match('/^[a-h][36]$/', $this->gamestate['fen_en_passant_target_square']))
+	} elseif ($this->gamestate['fen_en_passant_target_square'] != '-' and !preg_match('/^[a-h][36]$/', $this->gamestate['fen_en_passant_target_square']))
 	{
 		return _MD_CHESS_FENBAD_EP_INVALID; // en_passant_target_square invalid
-	}
-	elseif (!preg_match('/^\d{0,4}$/', $this->gamestate['fen_halfmove_clock']))
+	} elseif (!preg_match('/^\d{0,4}$/', $this->gamestate['fen_halfmove_clock']))
 	{
 		return _MD_CHESS_FENBAD_HC_INVALID; // halfmove_clock invalid
-	}
-	elseif (!preg_match('/^\d{0,4}$/', $this->gamestate['fen_fullmove_number']) or $this->gamestate['fen_fullmove_number'] < 1)
+	} elseif (!preg_match('/^\d{0,4}$/', $this->gamestate['fen_fullmove_number']) or $this->gamestate['fen_fullmove_number'] < 1)
 	{
 		return _MD_CHESS_FENBAD_FN_INVALID; // fullmove_number invalid
-	}
-	elseif ($this->insufficient_mating_material())
+	} elseif ($this->insufficient_mating_material())
 	{
 		return _MD_CHESS_FENBAD_MATERIAL; // insufficient mating material
-	}
-	elseif (($this->gamestate['fen_active_color'] == 'w' and $this->kingIsUnderAttack('b', 'w'))
+	} elseif (($this->gamestate['fen_active_color'] == 'w' and $this->kingIsUnderAttack('b', 'w'))
 		or   ($this->gamestate['fen_active_color'] == 'b' and $this->kingIsUnderAttack('w', 'b')))
 	{
 		return _MD_CHESS_FENBAD_IN_CHECK; // player to move cannot have opponent in check
-	}
-	elseif ((strstr($this->gamestate['fen_castling_availability'], 'K') and ($this->board[ 4] != 'wK' or $this->board[ 7] != 'wR'))
+	} elseif ((strstr($this->gamestate['fen_castling_availability'], 'K') and ($this->board[ 4] != 'wK' or $this->board[ 7] != 'wR'))
 		or   (strstr($this->gamestate['fen_castling_availability'], 'Q') and ($this->board[ 4] != 'wK' or $this->board[ 0] != 'wR'))
 		or   (strstr($this->gamestate['fen_castling_availability'], 'k') and ($this->board[60] != 'bK' or $this->board[63] != 'bR'))
 		or   (strstr($this->gamestate['fen_castling_availability'], 'q') and ($this->board[60] != 'bK' or $this->board[56] != 'bR')))
 	{
 		return _MD_CHESS_FENBAD_CA_INCONSISTENT; // castling availability inconsistent with piece placement
-	}
-	elseif (($this->gamestate['fen_en_passant_target_square'] != '-' and $this->gamestate['fen_en_passant_target_square']{1} == 3 and $this->gamestate['fen_active_color'] != 'b')
+	} elseif (($this->gamestate['fen_en_passant_target_square'] != '-' and $this->gamestate['fen_en_passant_target_square']{1} == 3 and $this->gamestate['fen_active_color'] != 'b')
 		or   ($this->gamestate['fen_en_passant_target_square'] != '-' and $this->gamestate['fen_en_passant_target_square']{1} == 6 and $this->gamestate['fen_active_color'] != 'w'))
 	{
 		return _MD_CHESS_FENBAD_EP_COLOR; // en passant target square wrong color
-	}
-	elseif ($this->gamestate['fen_en_passant_target_square'] != '-' and $this->gamestate['fen_en_passant_target_square']{1} == 3
+	} elseif ($this->gamestate['fen_en_passant_target_square'] != '-' and $this->gamestate['fen_en_passant_target_square']{1} == 3
 		and $this->board[$this->boardCoordToIndex($this->gamestate['fen_en_passant_target_square']{0} . '4')] != 'wP')
 	{
 		return _MD_CHESS_FENBAD_EP_NO_PAWN; // en passant target square for nonexistent pawn
-	}
-	elseif ($this->gamestate['fen_en_passant_target_square'] != '-' and $this->gamestate['fen_en_passant_target_square']{1} == 6
+	} elseif ($this->gamestate['fen_en_passant_target_square'] != '-' and $this->gamestate['fen_en_passant_target_square']{1} == 6
 		and $this->board[$this->boardCoordToIndex($this->gamestate['fen_en_passant_target_square']{0} . '5')] != 'bP')
 	{
 		return _MD_CHESS_FENBAD_EP_NO_PAWN; // en passant target square for nonexistent pawn
@@ -341,8 +331,9 @@ 
 
 		#echo "path: $pos: '$this->board[$pos]' "; #*#DEBUG#
 
-		if (!$this->is_empty_tile($pos))
-			return 0;
+		if (!$this->is_empty_tile($pos)) {
+					return 0;
+		}
 	}
 
 	return 1;
@@ -421,8 +412,7 @@ 
 				$change += ($dx < $fx) ? -1 : 1;
 			} elseif ($fx == $dx) {
 				$change = ($dy < $fy) ? -8 : 8;
-			} 
-			else {
+			} else {
 				$change = ($dx < $fx) ? -1 : 1;
 			}
 			break;
@@ -448,7 +438,9 @@ 
  */
 function tileIsReachable($fig, $fig_pos, $dest_pos)
 {
-  if ( $fig_pos==$dest_pos) return;
+  if ( $fig_pos==$dest_pos) {
+  	return;
+  }
   $result = 0;
   $fy = floor($fig_pos/8); $fx = $fig_pos%8;
   $dy = floor($dest_pos/8); $dx = $dest_pos%8;
@@ -457,61 +449,103 @@ 
   {
     /* knight */
     case 'N':
-      if ( abs($fx-$dx)==1 && abs($fy-$dy)==2 )
-        $result = 1;
-      if ( abs($fy-$dy)==1 && abs($fx-$dx)==2 )
-        $result = 1;
+      if ( abs($fx-$dx)==1 && abs($fy-$dy)==2 ) {
+              $result = 1;
+      }
+      if ( abs($fy-$dy)==1 && abs($fx-$dx)==2 ) {
+              $result = 1;
+      }
       break;
     /* bishop */
     case 'B':
-      if ( abs($fx-$dx) != abs($fy-$dy) )
-        break;
-      if ( $dy < $fy ) $change = -8; else $change =  8;
-      if ( $dx < $fx ) $change -= 1; else $change += 1;
-      if ( $this->pathIsNotBlocked( $fig_pos+$change, $dest_pos, $change ) )
-        $result = 1;
+      if ( abs($fx-$dx) != abs($fy-$dy) ) {
+              break;
+      }
+      if ( $dy < $fy ) {
+      	$change = -8;
+      } else {
+      	$change =  8;
+      }
+      if ( $dx < $fx ) {
+      	$change -= 1;
+      } else {
+      	$change += 1;
+      }
+      if ( $this->pathIsNotBlocked( $fig_pos+$change, $dest_pos, $change ) ) {
+              $result = 1;
+      }
       break;
     /* rook */
     case 'R':
-      if ( $fx!=$dx && $fy!=$dy )
-        break;
+      if ( $fx!=$dx && $fy!=$dy ) {
+              break;
+      }
       if ( $fx==$dx ) 
       {
-        if ( $dy<$fy ) $change = -8; else $change = 8;
+        if ( $dy<$fy ) {
+        	$change = -8;
+        } else {
+        	$change = 8;
+        }
+      } else {
+        if ( $dx<$fx ) {
+        	$change = -1;
+        } else {
+        	$change = 1;
+        }
       }
-      else {
-        if ( $dx<$fx ) $change = -1; else $change = 1;
+      if ( $this->pathIsNotBlocked( $fig_pos+$change, $dest_pos, $change ) ) {
+              $result = 1;
       }
-      if ( $this->pathIsNotBlocked( $fig_pos+$change, $dest_pos, $change ) )
-        $result = 1;
       break;
     /* queen */
     case 'Q':
-      if ( abs($fx-$dx) != abs($fy-$dy) && $fx!=$dx && $fy!=$dy )
-        break;
+      if ( abs($fx-$dx) != abs($fy-$dy) && $fx!=$dx && $fy!=$dy ) {
+              break;
+      }
       if ( abs($fx-$dx) == abs($fy-$dy) )
       {
-        if ( $dy < $fy ) $change = -8; else $change =  8;
-        if ( $dx < $fx ) $change -= 1; else $change += 1;
-      }
-      else if ( $fx==$dx ) {
-        if ( $dy<$fy ) $change = -8; else $change = 8;
-      } 
-      else
+        if ( $dy < $fy ) {
+        	$change = -8;
+        } else {
+        	$change =  8;
+        }
+        if ( $dx < $fx ) {
+        	$change -= 1;
+        } else {
+        	$change += 1;
+        }
+      } else if ( $fx==$dx ) {
+        if ( $dy<$fy ) {
+        	$change = -8;
+        } else {
+        	$change = 8;
+        }
+      } else
       {
-        if ( $dx<$fx ) $change = -1; else $change = 1;
+        if ( $dx<$fx ) {
+        	$change = -1;
+        } else {
+        	$change = 1;
+        }
+      }
+      if ( $this->pathIsNotBlocked( $fig_pos+$change, $dest_pos, $change ) ) {
+              $result = 1;
       }
-      if ( $this->pathIsNotBlocked( $fig_pos+$change, $dest_pos, $change ) )
-        $result = 1;
       break;
     /* king */
     case 'K':
-      if ( abs($fx-$dx) > 1 || abs($fy-$dy) > 1 ) break;
+      if ( abs($fx-$dx) > 1 || abs($fy-$dy) > 1 ) {
+      	break;
+      }
       $kings = 0;
       $adj_tiles = $this->getAdjTiles( $dest_pos );
-      foreach( $adj_tiles as $tile )
-        if ($this->board[$tile]{1} == 'K' ) $kings++;
-      if ( $kings == 2 ) break;
+      foreach( $adj_tiles as $tile ) {
+              if ($this->board[$tile]{1} == 'K' ) $kings++;
+      }
+      if ( $kings == 2 ) {
+      	break;
+      }
       $result = 1;
       break;
   }
@@ -533,17 +567,20 @@ 
 {
   if ( $this->board[$fig_pos]{0} == 'w' )
   {
-    if ( ($fig_pos % 8) > 0 && $dest_pos == $fig_pos+7 )
-      return 1;
-    if ( ($fig_pos % 8) < 7 && $dest_pos == $fig_pos+9 )
-      return 1;
-  }
-  else if ( $this->board[$fig_pos]{0} == 'b' )
+    if ( ($fig_pos % 8) > 0 && $dest_pos == $fig_pos+7 ) {
+          return 1;
+    }
+    if ( ($fig_pos % 8) < 7 && $dest_pos == $fig_pos+9 ) {
+          return 1;
+    }
+  } else if ( $this->board[$fig_pos]{0} == 'b' )
   {
-    if ( ($fig_pos % 8) < 7 && $dest_pos == $fig_pos-7 )
-      return 1;
-    if ( ($fig_pos % 8) > 0 && $dest_pos == $fig_pos-9 )
-      return 1;
+    if ( ($fig_pos % 8) < 7 && $dest_pos == $fig_pos-7 ) {
+          return 1;
+    }
+    if ( ($fig_pos % 8) > 0 && $dest_pos == $fig_pos-9 ) {
+          return 1;
+    }
   }
   return 0;
 }
@@ -568,23 +605,28 @@ 
   
   if ( $this->board[$fig_pos]{0} == 'w' )
   {
-    if ( $fig_pos >= 8 && $fig_pos <= 15 )
-      $first_move = 1;
-    if ( $dest_pos==$fig_pos+8 )
-      return 1;
-    if ( $first_move && ( $dest_pos==$fig_pos+16 ) )
-    if ($this->is_empty_tile($fig_pos + 8))
+    if ( $fig_pos >= 8 && $fig_pos <= 15 ) {
+          $first_move = 1;
+    }
+    if ( $dest_pos==$fig_pos+8 ) {
+          return 1;
+    }
+    if ( $first_move && ( $dest_pos==$fig_pos+16 ) ) {
+        if ($this->is_empty_tile($fig_pos + 8))
       return 1;
-  }
-  else if ($this->board[$fig_pos]{0} == 'b' )
+    }
+  } else if ($this->board[$fig_pos]{0} == 'b' )
   {
-    if ( $fig_pos >= 48 && $fig_pos <= 55 )
-      $first_move = 1;
-    if ( $dest_pos==$fig_pos-8 )
-      return 1;
-    if ( $first_move && ( $dest_pos==$fig_pos-16 ) )
-    if ($this->is_empty_tile($fig_pos - 8))
+    if ( $fig_pos >= 48 && $fig_pos <= 55 ) {
+          $first_move = 1;
+    }
+    if ( $dest_pos==$fig_pos-8 ) {
+          return 1;
+    }
+    if ( $first_move && ( $dest_pos==$fig_pos-16 ) ) {
+        if ($this->is_empty_tile($fig_pos - 8))
       return 1;
+    }
   }
   return 0;
 }
@@ -601,8 +643,8 @@ 
 function tileIsUnderAttack($opp, $dest_pos)
 {
 #var_dump('tileIsUnderAttack, opp', $opp, 'dest_pos', $dest_pos, 'board', $board);#*#DEBUG#
-  for ( $i = 0; $i < 64; $i++ )
-    if ($this->board[$i]{0} == $opp )
+  for ( $i = 0; $i < 64; $i++ ) {
+      if ($this->board[$i]{0} == $opp )
     {
       if ( ($this->board[$i]{1}=='P' && $this->checkPawnAttack($i,$dest_pos)) ||
            ($this->board[$i]{1}!='P' && 
@@ -610,6 +652,7 @@ 
       {
         /*DEBUG: echo "attack test: $i: ",$opp,"P<BR>"; */
         return 1;
+  }
       }
     }
   return 0;
@@ -628,10 +671,11 @@ 
 {
 
 #var_dump('kingIsUnderAttack, player', $player, 'opp', $opp, 'board', $board);#*#DEBUG#
-  for ( $i = 0; $i < 64; $i++ )
-    if ($this->board[$i]{0} == $player && $this->board[$i]{1} == 'K' )
+  for ( $i = 0; $i < 64; $i++ ) {
+      if ($this->board[$i]{0} == $player && $this->board[$i]{1} == 'K' )
     {
       $king_pos = $i;
+  }
       break;
     }
   /*DEBUG: echo "$player king is at $king_pos<BR>"; */
@@ -650,10 +694,11 @@ 
  */
 function isCheckMate($player, $opp)
 {
-  for ( $i = 0; $i < 64; $i++ )
-    if ($this->board[$i]{0} == $player && $this->board[$i]{1} == 'K' )
+  for ( $i = 0; $i < 64; $i++ ) {
+      if ($this->board[$i]{0} == $player && $this->board[$i]{1} == 'K' )
     {
       $king_pos = $i;
+  }
       $king_x = $i % 8;
       $king_y = floor($i/8);
       break;
@@ -664,8 +709,12 @@ 
   $contents = $this->board[$king_pos]; $this->clear_tile($king_pos);
   foreach ( $adj_tiles as $dest_pos ) 
   {
-    if ($this->board[$dest_pos]{0} == $player ) continue;
-    if ( $this->tileIsUnderAttack($opp,$dest_pos) ) continue;
+    if ($this->board[$dest_pos]{0} == $player ) {
+    	continue;
+    }
+    if ( $this->tileIsUnderAttack($opp,$dest_pos) ) {
+    	continue;
+    }
     $this->board[$king_pos] = $contents;
     return 0;
   }
@@ -675,14 +724,15 @@ 
 
   /* get all figures that attack the king */
   $attackers = array(); $count = 0;
-  for ( $i = 0; $i < 64; $i++ )
-    if ( $this->board[$i]{0} == $opp )
+  for ( $i = 0; $i < 64; $i++ ) {
+      if ( $this->board[$i]{0} == $opp )
     {
       if ( ($this->board[$i]{1}=='P' && $this->checkPawnAttack($i,$king_pos)) ||
            ($this->board[$i]{1}!='P' && 
                 $this->tileIsReachable($this->board[$i]{1},$i,$king_pos)) )
       {
           $attackers[$count++] = $i;
+  }
       }
     }
   /* DEBUG: 
@@ -691,12 +741,14 @@ 
   echo "Attackercount: ",count($attackers), " "; */
  
   /* if more than one there is no chance to escape */
-  if ( $count > 1 ) return 1;
+  if ( $count > 1 ) {
+  	return 1;
+  }
 
   /* check whether attacker can be killed by own figure */
   $dest_pos = $attackers[0];
-  for ( $i = 0; $i < 64; $i++ )
-    if ( $this->board[$i]{0} == $player )
+  for ( $i = 0; $i < 64; $i++ ) {
+      if ( $this->board[$i]{0} == $player )
     {
       if ( ($this->board[$i]{1}=='P' && $this->checkPawnAttack($i,$dest_pos)) ||
            ($this->board[$i]{1}!='P' && $this->board[$i]{1}!='K' &&
@@ -707,12 +759,14 @@ 
       {
         /* DEBUG: echo "candidate: $i "; */
         $can_kill_atk = 0;
+  }
         $contents_def = $this->board[$i];
         $contents_atk = $this->board[$dest_pos];
         $this->board[$dest_pos] = $this->board[$i];
         $this->clear_tile($i);
-        if ( !$this->tileIsUnderAttack($opp,$king_pos) )
-          $can_kill_atk = 1;
+        if ( !$this->tileIsUnderAttack($opp,$king_pos) ) {
+                  $can_kill_atk = 1;
+        }
         $this->board[$i] = $contents_def;
         $this->board[$dest_pos] = $contents_atk;
         if ( $can_kill_atk )
@@ -727,14 +781,17 @@ 
   
   /* if attacking unit is a knight there
    * is no way to block the path */
-  if ( $this->board[$dest_pos]{1} == 'N' ) return 1;
+  if ( $this->board[$dest_pos]{1} == 'N' ) {
+  	return 1;
+  }
 
   /* if enemy is adjacent to king there is no
    * way either */
   $dest_x = $dest_pos % 8;
   $dest_y = floor($dest_pos/8);
-  if ( abs($dest_x-$king_x)<=1 && abs($dest_y-$king_y)<=1 )
-    return 1;
+  if ( abs($dest_x-$king_x)<=1 && abs($dest_y-$king_y)<=1 ) {
+      return 1;
+  }
 
   /* get the list of tiles between king and attacking
    * unit that can be blocked to stop the attack */
@@ -744,8 +801,8 @@ 
   /* DEBUG: foreach( $path as $tile ) echo "tile: $tile "; */
   foreach( $path as $pos )
   {
-    for ( $i = 0; $i < 64; $i++ )
-      if ( $this->board[$i]{0} == $player )
+    for ( $i = 0; $i < 64; $i++ ) {
+          if ( $this->board[$i]{0} == $player )
       {
         if ( ($this->board[$i]{1}=='P' && $this->checkPawnMove($i,$pos)) ||
              ($this->board[$i]{1}!='P' && $this->board[$i]{1}!='K' &&
@@ -753,6 +810,7 @@ 
         {
             /* DEBUG: echo "$i can block "; */
             return 0;
+    }
         }
       }
   }
@@ -772,16 +830,21 @@ 
  */
 function isStaleMate($player, $opp)
 {
-  for ( $i = 0; $i < 64; $i++ )
-    if ($this->board[$i]{0} == $player )
+  for ( $i = 0; $i < 64; $i++ ) {
+      if ($this->board[$i]{0} == $player )
       switch ($this->board[$i]{1} )
       {
         case 'K':
           $adj_tiles = $this->getAdjTiles( $i );
+  }
           foreach ( $adj_tiles as $pos ) 
           {
-            if ( $this->board[$pos]{0} == $player ) continue;
-            if ( $this->tileIsUnderAttack($opp,$pos) ) continue;
+            if ( $this->board[$pos]{0} == $player ) {
+            	continue;
+            }
+            if ( $this->tileIsUnderAttack($opp,$pos) ) {
+            	continue;
+            }
             return 0;
           }
           /* DEBUG:  echo "King cannot escape by itself! "; */
@@ -789,44 +852,88 @@ 
         case 'P':
           if ( $player == 'w' )
           {
-            if ($this->is_empty_tile($i + 8)) return 0;
-            if ( ($i%8) > 0 && $this->board[$i+7]{0} != $player ) return 0;
-            if ( ($i%8) < 7 && $this->board[$i+9]{0} != $player ) return 0;
-          }
-          else
+            if ($this->is_empty_tile($i + 8)) {
+            	return 0;
+            }
+            if ( ($i%8) > 0 && $this->board[$i+7]{0} != $player ) {
+            	return 0;
+            }
+            if ( ($i%8) < 7 && $this->board[$i+9]{0} != $player ) {
+            	return 0;
+            }
+          } else
           {
-            if ($this->is_empty_tile($i - 8)) return 0;
-            if ( ($i%8) > 0 && $this->board[$i-9]{0} != $player ) return 0;
-            if ( ($i%8) < 7 && $this->board[$i-7]{0} != $player ) return 0;
+            if ($this->is_empty_tile($i - 8)) {
+            	return 0;
+            }
+            if ( ($i%8) > 0 && $this->board[$i-9]{0} != $player ) {
+            	return 0;
+            }
+            if ( ($i%8) < 7 && $this->board[$i-7]{0} != $player ) {
+            	return 0;
+            }
           }
           break;
         case 'B':
-          if ( $i-9 >= 0  && $this->board[$i-9]{0} != $player ) return 0;
-          if ( $i-7 >= 0  && $this->board[$i-7]{0} != $player ) return 0;
-          if ( $i+9 <= 63 && $this->board[$i+9]{0} != $player ) return 0;
-          if ( $i+7 <= 63 && $this->board[$i+7]{0} != $player ) return 0;
+          if ( $i-9 >= 0  && $this->board[$i-9]{0} != $player ) {
+          	return 0;
+          }
+          if ( $i-7 >= 0  && $this->board[$i-7]{0} != $player ) {
+          	return 0;
+          }
+          if ( $i+9 <= 63 && $this->board[$i+9]{0} != $player ) {
+          	return 0;
+          }
+          if ( $i+7 <= 63 && $this->board[$i+7]{0} != $player ) {
+          	return 0;
+          }
           break;
         case 'R':
-          if ( $i-8 >= 0  && $this->board[$i-8]{0} != $player ) return 0;
-          if ( $i-1 >= 0  && $this->board[$i-1]{0} != $player ) return 0;
-          if ( $i+8 <= 63 && $this->board[$i+8]{0} != $player ) return 0;
-          if ( $i+1 <= 63 && $this->board[$i+1]{0} != $player ) return 0;
+          if ( $i-8 >= 0  && $this->board[$i-8]{0} != $player ) {
+          	return 0;
+          }
+          if ( $i-1 >= 0  && $this->board[$i-1]{0} != $player ) {
+          	return 0;
+          }
+          if ( $i+8 <= 63 && $this->board[$i+8]{0} != $player ) {
+          	return 0;
+          }
+          if ( $i+1 <= 63 && $this->board[$i+1]{0} != $player ) {
+          	return 0;
+          }
           break;
         case 'Q':
           $adj_tiles = $this->getAdjTiles( $i );
-          foreach ( $adj_tiles as $pos )
-            if ( $this->board[$pos]{0} != $player ) 
+          foreach ( $adj_tiles as $pos ) {
+                      if ( $this->board[$pos]{0} != $player ) 
               return 0;
+          }
           break;
         case 'N':
-          if ( $i-17 >= 0  && $this->board[$i-17]{0} != $player ) return 0; 
-          if ( $i-15 >= 0  && $this->board[$i-15]{0} != $player ) return 0;
-          if ( $i-6  >= 0  && $this->board[$i-6]{0}  != $player ) return 0;
-          if ( $i+10 <= 63 && $this->board[$i+10]{0} != $player ) return 0;
-          if ( $i+17 <= 63 && $this->board[$i+17]{0} != $player ) return 0;
-          if ( $i+15 <= 63 && $this->board[$i+15]{0} != $player ) return 0;
-          if ( $i+6  <= 63 && $this->board[$i+6]{0}  != $player ) return 0;
-          if ( $i-10 >= 0  && $this->board[$i-10]{0} != $player ) return 0;
+          if ( $i-17 >= 0  && $this->board[$i-17]{0} != $player ) {
+          	return 0;
+          }
+          if ( $i-15 >= 0  && $this->board[$i-15]{0} != $player ) {
+          	return 0;
+          }
+          if ( $i-6  >= 0  && $this->board[$i-6]{0}  != $player ) {
+          	return 0;
+          }
+          if ( $i+10 <= 63 && $this->board[$i+10]{0} != $player ) {
+          	return 0;
+          }
+          if ( $i+17 <= 63 && $this->board[$i+17]{0} != $player ) {
+          	return 0;
+          }
+          if ( $i+15 <= 63 && $this->board[$i+15]{0} != $player ) {
+          	return 0;
+          }
+          if ( $i+6  <= 63 && $this->board[$i+6]{0}  != $player ) {
+          	return 0;
+          }
+          if ( $i-10 >= 0  && $this->board[$i-10]{0} != $player ) {
+          	return 0;
+          }
           break;
       }
       
@@ -892,9 +999,10 @@ 
   {
     /* full move: a pawn requires a ? in the end
      * to automatically choose a queen on last line */
-    if ( $move[0] == 'P' )
-    if ( $move[strlen($move)-1]<'A' || $move[strlen($move)-1]>'Z' )
+    if ( $move[0] == 'P' ) {
+        if ( $move[strlen($move)-1]<'A' || $move[strlen($move)-1]>'Z' )
       $this->ac_move = "$move?";
+    }
     return "";
   }
 
@@ -912,8 +1020,10 @@ 
   if ($move{strlen($move)-1} == '=') {
     $move = substr($move, 0, strlen($move)-1);
   }
-  if ( $pawn_upg == "P" || $pawn_upg == "K" )
-    return _MD_CHESS_MOVE_PAWN_MAY_BECOME; // "A pawn may only become either a knight, a bishop, a rook or a queen!"
+  if ( $pawn_upg == "P" || $pawn_upg == "K" ) {
+      return _MD_CHESS_MOVE_PAWN_MAY_BECOME;
+  }
+  // "A pawn may only become either a knight, a bishop, a rook or a queen!"
 
   if ( $move[0]>='a' && $move[0]<='h' )
   {
@@ -921,21 +1031,23 @@ 
      * listed above */
     if ( strlen($move) == 4 )
     {
-      if ( $move[1] != 'x' )
-        return _MD_CHESS_MOVE_USE_X; // "use x to indicate an attack"
+      if ( $move[1] != 'x' ) {
+              return _MD_CHESS_MOVE_USE_X;
+      }
+      // "use x to indicate an attack"
       $dest_x = $move[2];
       $dest_y = $move[3];
       $src_x  = $move[0];
-      if ( $player == 'w' )
-        $src_y  = $dest_y-1;
-      else
-        $src_y  = $dest_y+1;
+      if ( $player == 'w' ) {
+              $src_y  = $dest_y-1;
+      } else {
+              $src_y  = $dest_y+1;
+      }
       $this->ac_move = sprintf( "P%s%dx%s%d%s", 
                           $src_x,$src_y,$dest_x,$dest_y,
                           $pawn_upg );
       return "";
-    }
-    else
+    } else
     if (strlen($move) == 2 )
     {
       $fig = sprintf( "%sP", $player );
@@ -943,16 +1055,26 @@ 
       {
         /* pawn move */
         $pos = $this->boardCoordToIndex( $move );
-        if ( $pos == 64 ) return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $move); // "coordinate $move is invalid"
+        if ( $pos == 64 ) {
+        	return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $move);
+        }
+        // "coordinate $move is invalid"
         if ( $player == 'w' )
         {
-          while( $pos >= 0 && $this->board[$pos] != $fig ) $pos -= 8;
-          if ( $pos < 0 ) $not_found = 1;
-        }
-        else
+          while( $pos >= 0 && $this->board[$pos] != $fig ) {
+          	$pos -= 8;
+          }
+          if ( $pos < 0 ) {
+          	$not_found = 1;
+          }
+        } else
         {
-          while( $pos <= 63 && $this->board[$pos] != $fig ) $pos += 8;
-          if ( $pos > 63 ) $not_found = 1;
+          while( $pos <= 63 && $this->board[$pos] != $fig ) {
+          	$pos += 8;
+          }
+          if ( $pos > 63 ) {
+          	$not_found = 1;
+          }
         }
         $pos = $this->boardIndexToCoord( $pos );
         if ( (isset($not_found) && $not_found) || $pos == "" ) {
@@ -961,127 +1083,155 @@ 
           $this->ac_move = sprintf( "P%s-%s%s", $pos, $move, $pawn_upg );
           return "";
         }
-      }
-      else
+      } else
       {
         /* notation: [a-h][a-h] for pawn attack no longer allowed 
          * except for history browser */
-        if ( $this->browsing_mode == 0 )
-            return _MD_CHESS_MOVE_USE_NOTATION; // "please use denotation [a-h]x[a-h][1-8] for pawn attacks (see help for more information)"
+        if ( $this->browsing_mode == 0 ) {
+                    return _MD_CHESS_MOVE_USE_NOTATION;
+        }
+        // "please use denotation [a-h]x[a-h][1-8] for pawn attacks (see help for more information)"
         /* pawn attack must be only one pawn in column! */
         $pawns = 0;
         $start = $this->boardCoordToIndex( sprintf( "%s1", $move[0] ) );
-        if ( $start == 64 ) return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $move[0]); // "coordinate $move[0] is invalid"
-        for ( $i = 1; $i <= 8; $i++, $start+=8 )
-          if ( $this->board[$start] == $fig ) 
+        if ( $start == 64 ) {
+        	return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $move[0]);
+        }
+        // "coordinate $move[0] is invalid"
+        for ( $i = 1; $i <= 8; $i++, $start+=8 ) {
+                  if ( $this->board[$start] == $fig ) 
           {
             $pawns++;
+        }
             $pawn_line = $i;
           }
-        if ( $pawns == 0 )
-          return $this->move_msg(_MD_CHESS_MOVE_NO_PAWN, $move[0]); // "there is no pawn in column $move[0]"
-        else if ( $pawns > 1 )
-          return $this->move_msg(_MD_CHESS_MOVE_TWO_PAWNS, $move[0]); // "there is more than one pawn in column $move[0]"
+        if ( $pawns == 0 ) {
+                  return $this->move_msg(_MD_CHESS_MOVE_NO_PAWN, $move[0]);
+        }
+        // "there is no pawn in column $move[0]"
+        else if ( $pawns > 1 ) {
+                  return $this->move_msg(_MD_CHESS_MOVE_TWO_PAWNS, $move[0]);
+        }
+        // "there is more than one pawn in column $move[0]"
         else
         {
-          if ( $player == 'w' )
-            $dest_line = $pawn_line+1;
-          else
-            $dest_line = $pawn_line-1;
+          if ( $player == 'w' ) {
+                      $dest_line = $pawn_line+1;
+          } else {
+                      $dest_line = $pawn_line-1;
+          }
           $this->ac_move = sprintf( "P%s%dx%s%d", 
                             $move[0],$pawn_line,$move[1],$dest_line );
           return "";
         }
       }
     }
-  }
-  else
+  } else
   {
     /* figure move */
     $dest_coord = substr( $move, strlen($move)-2, 2 );
     $action = $move[strlen($move)-3];
-    if ( $action != 'x' ) $action = '-';
-    if ( $player == 'w' ) 
-      $figures = $this->w_figures;
-    else
-      $figures = $this->b_figures;
+    if ( $action != 'x' ) {
+    	$action = '-';
+    }
+    if ( $player == 'w' ) {
+          $figures = $this->w_figures;
+    } else {
+          $figures = $this->b_figures;
+    }
     $fig_count = 0;
-    foreach( $figures as $figure )
-      if ( $figure[0] == $move[0] )
+    foreach( $figures as $figure ) {
+          if ( $figure[0] == $move[0] )
       {
         $fig_count++;
-        if ( $fig_count == 1 )
-          $pos1 = substr( $figure, 1, 2 );
-        else
-          $pos2 = substr( $figure, 1, 2 );
+    }
+        if ( $fig_count == 1 ) {
+                  $pos1 = substr( $figure, 1, 2 );
+        } else {
+                  $pos2 = substr( $figure, 1, 2 );
+        }
       }
-    if ( $fig_count == 0 )
-      return $this->move_msg(_MD_CHESS_MOVE_NO_FIGURE, $move[0], $this->getFullFigureName($move[0])); // sprintf("there is no figure %s = %s", $move[0], $this->getFullFigureName($move[0]))
+    if ( $fig_count == 0 ) {
+          return $this->move_msg(_MD_CHESS_MOVE_NO_FIGURE, $move[0], $this->getFullFigureName($move[0]));
+    }
+    // sprintf("there is no figure %s = %s", $move[0], $this->getFullFigureName($move[0]))
     else
     if ( $fig_count == 1 )
     {
        $this->ac_move = sprintf( "%s%s%s%s",
                       $move[0], $pos1, $action, $dest_coord ); 
        return "";
-    }
-    else
+    } else
     {
       /* two figures which may cause ambiguity */
       $dest_pos = $this->boardCoordToIndex( $dest_coord );
-      if ( $dest_pos == 64 ) 
-        return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $dest_coord); // "coordinate $dest_coord is invalid"
+      if ( $dest_pos == 64 ) {
+              return $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $dest_coord);
+      }
+      // "coordinate $dest_coord is invalid"
       $fig1_can_reach = $this->tileIsReachable( $move[0], 
                             $this->boardCoordToIndex($pos1), $dest_pos );
       $fig2_can_reach = $this->tileIsReachable( $move[0], 
                             $this->boardCoordToIndex($pos2), $dest_pos );
-      if ( !$fig1_can_reach && !$fig2_can_reach )
-        return $this->move_msg(_MD_CHESS_MOVE_NEITHER_CAN_REACH, $move[0], $this->getFullFigureName($move[0]), $dest_coord); // sprintf("neither of the %s = %s can reach %s", $move[0], $this->getFullFigureName($move[0]), $dest_coord)
+      if ( !$fig1_can_reach && !$fig2_can_reach ) {
+              return $this->move_msg(_MD_CHESS_MOVE_NEITHER_CAN_REACH, $move[0], $this->getFullFigureName($move[0]), $dest_coord);
+      }
+      // sprintf("neither of the %s = %s can reach %s", $move[0], $this->getFullFigureName($move[0]), $dest_coord)
       else
       if ( $fig1_can_reach && $fig2_can_reach )
       {
         /* ambiguity - check whether a hint is given */
         if ( ($action=='-' && strlen($move)==4) ||
-             ($action=='x' && strlen($move)==5) )
-          $hint = $move[1];
-        if ( empty($hint) )
-          return $this->move_msg(_MD_CHESS_MOVE_BOTH_CAN_REACH, $move[0], $this->getFullFigureName($move[0]), $dest_coord); // sprintf("both of the %s = %s can reach %s", $move[0], $this->getFullFigureName($move[0]), $dest_coord)
+             ($action=='x' && strlen($move)==5) ) {
+                  $hint = $move[1];
+        }
+        if ( empty($hint) ) {
+                  return $this->move_msg(_MD_CHESS_MOVE_BOTH_CAN_REACH, $move[0], $this->getFullFigureName($move[0]), $dest_coord);
+        }
+        // sprintf("both of the %s = %s can reach %s", $move[0], $this->getFullFigureName($move[0]), $dest_coord)
         else
         {
           $move_fig1 = 0;
           $move_fig2 = 0;
           if ( $hint>='1' && $hint<='8' )
           {
-            if ( $pos1[1]==$hint && $pos2[1]!=$hint )
-              $move_fig1 = 1;
-            if ( $pos2[1]==$hint && $pos1[1]!=$hint )
-              $move_fig2 = 1;
-          }
-          else
+            if ( $pos1[1]==$hint && $pos2[1]!=$hint ) {
+                          $move_fig1 = 1;
+            }
+            if ( $pos2[1]==$hint && $pos1[1]!=$hint ) {
+                          $move_fig2 = 1;
+            }
+          } else
           {
-            if ( $pos1[0]==$hint && $pos2[0]!=$hint )
-              $move_fig1 = 1;
-            if ( $pos2[0]==$hint && $pos1[0]!=$hint )
-              $move_fig2 = 1;
+            if ( $pos1[0]==$hint && $pos2[0]!=$hint ) {
+                          $move_fig1 = 1;
+            }
+            if ( $pos2[0]==$hint && $pos1[0]!=$hint ) {
+                          $move_fig2 = 1;
+            }
           }
-          if ( !$move_fig1 && !$move_fig2 )
-            return _MD_CHESS_MOVE_AMBIGUOUS; // "ambiguity is not properly resolved"
-          if ( $move_fig1 )
-            $this->ac_move = sprintf( "%s%s%s%s",
+          if ( !$move_fig1 && !$move_fig2 ) {
+                      return _MD_CHESS_MOVE_AMBIGUOUS;
+          }
+          // "ambiguity is not properly resolved"
+          if ( $move_fig1 ) {
+                      $this->ac_move = sprintf( "%s%s%s%s",
                           $move[0], $pos1, $action, $dest_coord );
-          else
-            $this->ac_move = sprintf( "%s%s%s%s",
+          } else {
+                      $this->ac_move = sprintf( "%s%s%s%s",
                           $move[0], $pos2, $action, $dest_coord );
+          }
           return;
         }
-      }
-      else
+      } else
       {
-        if ( $fig1_can_reach )
-          $this->ac_move = sprintf( "%s%s%s%s",
-                        $move[0], $pos1, $action, $dest_coord ); 
-        else
-          $this->ac_move = sprintf( "%s%s%s%s",
-                        $move[0], $pos2, $action, $dest_coord ); 
+        if ( $fig1_can_reach ) {
+                  $this->ac_move = sprintf( "%s%s%s%s",
+                        $move[0], $pos1, $action, $dest_coord );
+        } else {
+                  $this->ac_move = sprintf( "%s%s%s%s",
+                        $move[0], $pos2, $action, $dest_coord );
+        }
         return "";
       }
     }
@@ -1113,22 +1263,23 @@ 
   {
     /* skip P anycase. for attacks skip source digit
        and for moves skip source pos and - */
-    if ( $move[3] == '-' )
-      $new_move = substr( $move, 4 );
-    else
-    if ( $move[3] == 'x' )
-      $new_move = sprintf("%s%s", $move[1], substr( $move, 3 ) );
-  }
-  else
+    if ( $move[3] == '-' ) {
+          $new_move = substr( $move, 4 );
+    } else
+    if ( $move[3] == 'x' ) {
+          $new_move = sprintf("%s%s", $move[1], substr( $move, 3 ) );
+    }
+  } else
   {
     /* try to remove the source position and check whether it
      * is a non-ambigious move. if it is add one of the components
      * and check again */
-    if ( $move[3] == '-' )
-      $dest = substr( $move, 4 );
-    else
-    if ( $move[3] == 'x' )
-      $dest = substr( $move, 3 );
+    if ( $move[3] == '-' ) {
+          $dest = substr( $move, 4 );
+    } else
+    if ( $move[3] == 'x' ) {
+          $dest = substr( $move, 3 );
+    }
     $new_move = sprintf("%s%s", $move[0], $dest );
     if ( $this->completeMove($player,$new_move) != "" )
     {
@@ -1138,8 +1289,10 @@ 
       {
         /* add other component */
         $new_move = sprintf("%s%s%s", $move[0], $move[2], $dest );
-        if ( $this->completeMove($player,$new_move) != "" )
-           $new_move = $move; /* give up */
+        if ( $this->completeMove($player,$new_move) != "" ) {
+                   $new_move = $move;
+        }
+        /* give up */
       }
     }
   }
@@ -1323,67 +1476,91 @@ 
 		$result = _MD_CHESS_MOVE_CASTLED_LONG;
 		$move_handled = 1;
 		$this->last_move = "O-O-O";
-	}
-
-  else
+	} else
   {
     /* [PRNBQK][a-h][1-8][-:x][a-h][1-8][RNBQK] full move */
 
     /* allow short move description by autocompleting to
      * full description */
     $ac_error = $this->completeMove( $cur_player, trim($move) );
-    if ( $ac_error != "" )
-      return(array(false, $ac_error)); // "ERROR: autocomplete: $ac_error"
-    else 
-      $move = $this->ac_move;
+    if ( $ac_error != "" ) {
+          return(array(false, $ac_error));
+    }
+    // "ERROR: autocomplete: $ac_error"
+    else {
+          $move = $this->ac_move;
+    }
     $this->last_move = str_replace( "?", "", $move );
     
     /* a final captial letter may only be N,B,R,Q for the
      * appropiate chessman */
     $c = $move[strlen($move)-1];
-    if ( $c >= 'A' && $c <= 'Z' )
-    if ( $c != 'N' && $c != 'B' && $c != 'R' && $c != 'Q' )
-      return(array(false, _MD_CHESS_MOVE_INVALID_PIECE)); // "ERROR: only N (knight), B (bishop), R (rook) and Q (queen) are valid chessman identifiers"
+    if ( $c >= 'A' && $c <= 'Z' ) {
+        if ( $c != 'N' && $c != 'B' && $c != 'R' && $c != 'Q' )
+      return(array(false, _MD_CHESS_MOVE_INVALID_PIECE));
+    }
+    // "ERROR: only N (knight), B (bishop), R (rook) and Q (queen) are valid chessman identifiers"
     
     /* if it is a full move, try to shorten the history move */
-    if ( strlen( $history_move ) >= 6 )
-      $history_move = 
+    if ( strlen( $history_move ) >= 6 ) {
+          $history_move = 
           $this->convertFullToChessNotation($cur_player,$history_move);
+    }
     /* DEBUG: echo "Move: $move ($history_move)<BR>"; */
     
     /* validate figure and position */
     $fig_type = $move[0];
     $fig_name = $this->getFullFigureName( $fig_type );
-    if ( $fig_name == "empty" )
-      return(array(false, $this->move_msg(_MD_CHESS_MOVE_UNKNOWN_FIGURE, $fig_type))); // "ERROR: Figure $fig_type is unknown!"
+    if ( $fig_name == "empty" ) {
+          return(array(false, $this->move_msg(_MD_CHESS_MOVE_UNKNOWN_FIGURE, $fig_type)));
+    }
+    // "ERROR: Figure $fig_type is unknown!"
     $fig_coord = substr($move,1,2);
     $fig_pos = $this->boardCoordToIndex( $fig_coord );
-    if ( $fig_pos == 64 ) return(array(false, $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $fig_coord))); // "ERROR: $fig_coord is invalid!"
+    if ( $fig_pos == 64 ) {
+    	return(array(false, $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $fig_coord)));
+    }
+    // "ERROR: $fig_coord is invalid!"
     /* DEBUG  echo "fig_type: $fig_type, fig_pos: $fig_pos<BR>"; */
-    if ($this->is_empty_tile($fig_pos))
-      return(array(false, $this->move_msg(_MD_CHESS_MOVE_TILE_EMPTY, $fig_coord))); // "ERROR: Tile $fig_coord is empty."
-    if ( $this->board[$fig_pos]{0} != $cur_player )
-      return(array(false, _MD_CHESS_MOVE_NOT_YOUR_PIECE)); // "ERROR: Figure does not belong to you!"
-    if ( $this->board[$fig_pos]{1} != $fig_type )
-      return(array(false, _MD_CHESS_MOVE_NOEXIST_FIGURE)); // "ERROR: Figure does not exist!"
+    if ($this->is_empty_tile($fig_pos)) {
+          return(array(false, $this->move_msg(_MD_CHESS_MOVE_TILE_EMPTY, $fig_coord)));
+    }
+    // "ERROR: Tile $fig_coord is empty."
+    if ( $this->board[$fig_pos]{0} != $cur_player ) {
+          return(array(false, _MD_CHESS_MOVE_NOT_YOUR_PIECE));
+    }
+    // "ERROR: Figure does not belong to you!"
+    if ( $this->board[$fig_pos]{1} != $fig_type ) {
+          return(array(false, _MD_CHESS_MOVE_NOEXIST_FIGURE));
+    }
+    // "ERROR: Figure does not exist!"
     
     /* get target index */
     $dest_coord = substr($move,4,2);
     $dest_pos = $this->boardCoordToIndex( $dest_coord );
-    if ( $dest_pos == 64 )
-      return(array(false, $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $dest_coord))); // "ERROR: $dest_coord is invalid!"
-    if ( $dest_pos == $fig_pos )
-      return(array(false, _MD_CHESS_MOVE_START_END_SAME));
+    if ( $dest_pos == 64 ) {
+          return(array(false, $this->move_msg(_MD_CHESS_MOVE_COORD_INVALID, $dest_coord)));
+    }
+    // "ERROR: $dest_coord is invalid!"
+    if ( $dest_pos == $fig_pos ) {
+          return(array(false, _MD_CHESS_MOVE_START_END_SAME));
+    }
     /* DEBUG  echo "dest_pos: $dest_pos<BR>"; */
 
     /* get action */
     $action = $move[3];
-    if ( $move[3] == "-" ) 
-      $action = 'M'; /* move */
-    else if ( $move[3] == 'x' )
-      $action = 'A'; /* attack */
-    else
-      return(array(false, $this->move_msg(_MD_CHESS_MOVE_UNKNOWN_ACTION, $action))); // "ERROR: $action is unknown! Please use \"-\" for a move and \"x\" for an attack."
+    if ( $move[3] == "-" ) {
+          $action = 'M';
+    }
+    /* move */
+    else if ( $move[3] == 'x' ) {
+          $action = 'A';
+    }
+    /* attack */
+    else {
+          return(array(false, $this->move_msg(_MD_CHESS_MOVE_UNKNOWN_ACTION, $action)));
+    }
+    // "ERROR: $action is unknown! Please use \"-\" for a move and \"x\" for an attack."
 
     /* if attack an enemy unit must be present on tile
      * and if move then tile must be empty. in both cases
@@ -1395,14 +1572,19 @@ 
      * checked here. */
     if ( $fig_type != 'P' )
     {
-        if ( !$this->tileIsReachable( $fig_type, $fig_pos, $dest_pos ) )
-          return(array(false, $this->move_msg(_MD_CHESS_MOVE_OUT_OF_RANGE, $dest_coord, $fig_name, $fig_coord))); // "ERROR: Tile $dest_coord is out of moving range for $fig_name at $fig_coord!"
-    }
-    else {
-      if ( $action == 'M' && !$this->checkPawnMove( $fig_pos, $dest_pos ) )
-          return(array(false, $this->move_msg(_MD_CHESS_MOVE_OUT_OF_RANGE, $dest_coord, $fig_name, $fig_coord))); // "ERROR: Tile $dest_coord is out of moving range for $fig_name at $fig_coord!"
-      if ( $action == 'A' && !$this->checkPawnAttack( $fig_pos, $dest_pos ) )
-          return(array(false, $this->move_msg(_MD_CHESS_MOVE_OUT_OF_RANGE, $dest_coord, $fig_name, $fig_coord))); // "ERROR: Tile $dest_coord is out of attacking range for $fig_name at $fig_coord!"
+        if ( !$this->tileIsReachable( $fig_type, $fig_pos, $dest_pos ) ) {
+                  return(array(false, $this->move_msg(_MD_CHESS_MOVE_OUT_OF_RANGE, $dest_coord, $fig_name, $fig_coord)));
+        }
+        // "ERROR: Tile $dest_coord is out of moving range for $fig_name at $fig_coord!"
+    } else {
+      if ( $action == 'M' && !$this->checkPawnMove( $fig_pos, $dest_pos ) ) {
+                return(array(false, $this->move_msg(_MD_CHESS_MOVE_OUT_OF_RANGE, $dest_coord, $fig_name, $fig_coord)));
+      }
+      // "ERROR: Tile $dest_coord is out of moving range for $fig_name at $fig_coord!"
+      if ( $action == 'A' && !$this->checkPawnAttack( $fig_pos, $dest_pos ) ) {
+                return(array(false, $this->move_msg(_MD_CHESS_MOVE_OUT_OF_RANGE, $dest_coord, $fig_name, $fig_coord)));
+      }
+      // "ERROR: Tile $dest_coord is out of attacking range for $fig_name at $fig_coord!"
     }
      
 	$en_passant_capture_performed = 0; // 1 if en passant captured occurred, else 0
@@ -1433,8 +1615,9 @@ 
 
     /* perform move */
     $this->clear_tile($fig_pos);
-    if (!$this->is_empty_tile($dest_pos))
-      $this->piece_captured = sprintf("%s%s",$this->board[$dest_pos],$dest_pos);
+    if (!$this->is_empty_tile($dest_pos)) {
+          $this->piece_captured = sprintf("%s%s",$this->board[$dest_pos],$dest_pos);
+    }
     $this->board[$dest_pos] = "$cur_player$fig_type";
     if ( $en_passant_capture_performed ) {
       /* kill pawn */
@@ -1442,8 +1625,7 @@ 
       {
         $this->clear_tile($dest_pos - 8);
         $this->piece_captured = sprintf("bP%s",$dest_pos-8);
-      }
-      else
+      } else
       {
         $this->clear_tile($dest_pos + 8);
         $this->piece_captured = sprintf("wP%s",$dest_pos+8);
@@ -1457,10 +1639,11 @@ 
       $this->board[$dest_pos] = $old_dest_tile;
       if ( $en_passant_capture_performed ) {
        // restore pawn that was captured above, since that move is invalid
-        if ( $cur_player == 'w' ) 
-          $this->board[$dest_pos-8] = "bP";
-        else
-          $this->board[$dest_pos+8] = "wP";
+        if ( $cur_player == 'w' ) {
+                  $this->board[$dest_pos-8] = "bP";
+        } else {
+                  $this->board[$dest_pos+8] = "wP";
+        }
       }
       return(array(false, _MD_CHESS_MOVE_IN_CHECK)); // "ERROR: Move is invalid because king would be under attack then."
     }
@@ -1501,10 +1684,11 @@ 
 		$this->gamestate['fen_en_passant_target_square'] = '-';
 	}
 
-    if ($action == 'M' )
-      $result = $this->move_msg(_MD_CHESS_MOVE_MOVED, $fig_name, $fig_coord, $dest_coord);
-    else
-      $result = $this->move_msg(_MD_CHESS_MOVE_CAPTURED, $fig_name, $dest_coord, $fig_coord);
+    if ($action == 'M' ) {
+          $result = $this->move_msg(_MD_CHESS_MOVE_MOVED, $fig_name, $fig_coord, $dest_coord);
+    } else {
+          $result = $this->move_msg(_MD_CHESS_MOVE_CAPTURED, $fig_name, $dest_coord, $fig_coord);
+    }
     
     /* if pawn reached last line convert into a queen */
     if ( $fig_type == 'P' )
@@ -1763,8 +1947,10 @@ 
     default: return 64; /* erronous coord */
   }
   $y = $coord[1]-1; 
-  if ( $y < 0 || $y > 7 )
-    return 64; /* erronous coord */
+  if ( $y < 0 || $y > 7 ) {
+      return 64;
+  }
+  /* erronous coord */
   $index = $y * 8 + $x;
   //echo "$index | ";
   return $index;
@@ -1781,8 +1967,9 @@ 
 function boardIndexToCoord( $index )
 {
   //echo $index," --> ";
-  if ( $index < 0 || $index > 63 )
-    return "";
+  if ( $index < 0 || $index > 63 ) {
+      return "";
+  }
   $y = floor($index/8)+1;
   $x = chr( ($index%8)+97 );
   $coord = "$x$y";
@@ -1825,14 +2012,30 @@ 
 
   $x = $fig_pos % 8; $y = floor( $fig_pos / 8 );
   
-  if ( $x > 0 && $y > 0 ) $adj_tiles[$i++] = $fig_pos-9;
-  if (           $y > 0 ) $adj_tiles[$i++] = $fig_pos-8;
-  if ( $x < 7 && $y > 0 ) $adj_tiles[$i++] = $fig_pos-7;
-  if ( $x < 7           ) $adj_tiles[$i++] = $fig_pos+1;
-  if ( $x < 7 && $y < 7 ) $adj_tiles[$i++] = $fig_pos+9;
-  if (           $y < 7 ) $adj_tiles[$i++] = $fig_pos+8;
-  if ( $x > 0 && $y < 7 ) $adj_tiles[$i++] = $fig_pos+7;
-  if ( $x > 0           ) $adj_tiles[$i++] = $fig_pos-1;
+  if ( $x > 0 && $y > 0 ) {
+  	$adj_tiles[$i++] = $fig_pos-9;
+  }
+  if (           $y > 0 ) {
+  	$adj_tiles[$i++] = $fig_pos-8;
+  }
+  if ( $x < 7 && $y > 0 ) {
+  	$adj_tiles[$i++] = $fig_pos-7;
+  }
+  if ( $x < 7           ) {
+  	$adj_tiles[$i++] = $fig_pos+1;
+  }
+  if ( $x < 7 && $y < 7 ) {
+  	$adj_tiles[$i++] = $fig_pos+9;
+  }
+  if (           $y < 7 ) {
+  	$adj_tiles[$i++] = $fig_pos+8;
+  }
+  if ( $x > 0 && $y < 7 ) {
+  	$adj_tiles[$i++] = $fig_pos+7;
+  }
+  if ( $x > 0           ) {
+  	$adj_tiles[$i++] = $fig_pos-1;
+  }
 
   /* DEBUG:  foreach( $adj_tiles as $tile )
     echo "adj: $tile "; */