/+
A board is an array of 16 cells to make a 4 x 4 layout
The Tiles have the values 0 - 16 where 16 is the 'Space'
Thus, if the index is the same as the value for all 16 places
   the board is in a winning configuration.

Use vi keys to shift one tile to the left, right, up, down
Use x to leave the game
+/

import std.algorithm.mutation : swap;
import std.range : iota;
import std.stdio : write, writef, writefln, writeln, stdout;
import std.array : array;
import std.random : choice;

private:
@safe:

extern(C) int getch();

const SIZE = 4;           // an n x n board
const RANDOMLEVEL = 600;  // Bigger is harder (more shuffling)

const BOARDSIZE = SIZE * SIZE;
const BLANKHOME = BOARDSIZE - 1;

const auto boardInit = iota(0,BOARDSIZE).array;
int[BOARDSIZE] board;
long blankPos = BOARDSIZE;
auto blankRow() { return blankPos / SIZE; }
auto blankCol() { return blankPos % SIZE; }

bool qGameOver;
void   setGameOver() { qGameOver = true; }
void resetGameOver() { qGameOver = false; }

long moves;

@trusted
void anotherGame() {
    static void playGame() {
        static void initGame() {
            board[]  = boardInit;
            blankPos = BLANKHOME;
            resetGameOver();
        }
        static void moveTile( long stride ) { 
            // These use board indexes
            static void swapTiles( long i1, long i2 ) {
                swap( board[i1], board[i2] );
            }

            swapTiles( blankPos, blankPos + stride );
            blankPos += stride;
            moves++ ;
        }
        static void left()  { moveTile( 1 ); }
        static void down()  { moveTile( -SIZE ); }
        static void up()    { moveTile( SIZE ); }
        static void right() { moveTile( -1 ); }

        // These are the valid move checks
        static bool isValidLeft()  { return blankCol() != (SIZE - 1); }
        static bool isValidDown()  { return blankRow() != 0; }
        static bool isValidUp()    { return blankRow() != (SIZE - 1); }
        static bool isValidRight() { return blankCol() != 0; } // 0 is invalid, 1 2 3 are all true

        static void doLeft()  { if ( isValidLeft() )  left(); }
        static void doDown()  { if ( isValidDown() )  down(); }
        static void doUp()    { if ( isValidUp() )    up(); }
        static void doRight() { if ( isValidRight() ) right(); }

        static void shuffleBoard() {
            static void shuffleOneMove() {
                final switch( [ 0, 1, 2, 3 ].choice() )
                {
                    case 0: write(" L"); doLeft();  break;
                    case 1: write(" D"); doDown();  break;
                    case 2: write(" U"); doUp();    break;
                    case 3: write(" R"); doRight(); break;
                }
            }

            for ( long i = 0; i < RANDOMLEVEL; i++ )
                shuffleOneMove();
        }

        static void gameLoop()
        {

            static bool qWinner() { return board[] == boardInit; }
            static void congratulate() {
                writeln("\r");
                writefln( " !!! Congratulations on winning the game !!!\r" );
                writefln( " It took %s moves to complete.\r", moves );
            }
            static void leaveGame() { 
                writeln( " Leaving game.  Thank you for playing.\r");
                setGameOver();
            }

            static void doHelp() {   writeln();
                writefln( "   h or left  arrow moves tile left  into blank space.\r" );
                writefln( "   l or right arrow moves tile right into blank space.\r" );
                writefln( "   j or down  arrow moves tile down  into blank space.\r" );
                writefln( "   k or up    arrow moves tile up    into blank space.\r" );
                writefln( "   x,q Abandons current game.\r" );
                writefln( "   ? This help screen.\r" );
            }

            static void showBoard( ) {
                static void qNewLine( long index ) {
                    if ( index % SIZE == 0 )
                        writefln!"\r";
                }
                static void showTile( long tile ) {
                    if ( tile == BLANKHOME )
                        write( "   " );
                    else
                        writef( " %2s", tile );
                }

                foreach( i, t; board ) {
                    qNewLine( i );
                    showTile( t );
                }
            }

            static void turn() {
                @trusted
                static void askForMove() {
                    write( " hjklxq?> " );
                    stdout.flush( );
                }
                static void handleKey( int asciiKey ) {
                    switch ( asciiKey ) {
                        case 'q': leaveGame(); break;  // 'q'
                        case 'x': leaveGame(); break;  // 'x'
                        case 'l': board.doLeft();    break;  // 'l'
                        case 'j': board.doDown();    break;  // 'j'
                        case 'k': board.doUp();      break;  // 'k'
                        case 'l': board.doRight();   break;  // 'l'
                        case  68: doLeft();    break;  // arrows
                        case  66: doDown();    break;
                        case  65: doUp();      break;
                        case  67: doRight();   break;
                        case  63: doHelp();    break;  
                        default:
                            writefln( " You pressed %s\r", asciiKey );
                    }
                }

                showBoard();
                writeln("\r");
                askForMove();
                auto ch = getch();
                writeln("\r");
                handleKey( ch );
            }

            turn();
            if (qWinner() ) {
                showBoard();
                congratulate();
                setGameOver();
            }
        }
        static void resetMoves() { moves = 0; }

        initGame();
        shuffleBoard();
        resetMoves();
        while( !qGameOver ) {
            gameLoop();
        }
    }

    do {
        playGame();
        writeln("\r");
        writeln("\r");
        write( " Would you like to play again, y/n?" );
        stdout.flush( );
    }
    while ( getch() == 121 );  // 'y'
}

int main() {
    import nwin;
    initializeNCurses();
    scope(exit) { teardownNCurses(); }
    anotherGame();
    return 0;
}

/+
A board is an array of 16 cells to make a 4 x 4 layout
The Tiles have the values 0 - 16 where 16 is the 'Space'
Thus, if the index is the same as the value for all 16 places
   the board is in a winning configuration.

Use vi keys to shift one tile to the left, right, up, down
Use x to leave the game
+/

import std.algorithm.mutation : swap;
import std.range : iota;
import std.stdio : write, writef, writefln, writeln, stdout;
import std.array : array;
import std.random : choice;
import std.format : format;

private:
@safe:

extern(C) int getch();

const SIZE = 4;           // an n x n board
const RANDOMLEVEL = 20;  // Bigger is harder (more shuffling)

const BOARDSIZE = SIZE * SIZE;
const BLANKHOME = BOARDSIZE - 1;

public class Board
{
private:
    const auto boardInit = iota(0,BOARDSIZE).array;
    int[BOARDSIZE] board;
    long moves;

    long blankPos;
    auto blankRow() const { return blankPos / SIZE; }
    auto blankCol() const { return blankPos % SIZE; }

    void init()
    {
        board[]  = boardInit;
        blankPos = BLANKHOME;
        moves    = 0;
    }
    void moveTile( long stride ) { 
        // These use board indexes
        void swapTiles( long i1, long i2 ) {
            swap( board[i1], board[i2] );
        }

        swapTiles( blankPos, blankPos + stride );
        blankPos += stride;
        moves++ ;
    }
    void left()  { moveTile( 1 ); }
    void down()  { moveTile( -SIZE ); }
    void up()    { moveTile( SIZE ); }
    void right() { moveTile( -1 ); }

    // These are the valid move checks
    bool isValidLeft()  { return blankCol() != (SIZE - 1); }
    bool isValidDown()  { return blankRow() != 0; }
    bool isValidUp()    { return blankRow() != (SIZE - 1); }
    bool isValidRight() { return blankCol() != 0; } // 0 is invalid, 1 2 3 are all true

    void doLeft()  { if ( isValidLeft() )  left(); }
    void doDown()  { if ( isValidDown() )  down(); }
    void doUp()    { if ( isValidUp() )    up(); }
    void doRight() { if ( isValidRight() ) right(); }
    bool qWinner() { return board[] == boardInit; }

    void show( ) {
        static void qNewLine( long index ) {
            if ( index % SIZE == 0 )
                writefln!"\r";
        }
        static void showTile( long tile ) {
            if ( tile == BLANKHOME )
                write( "   " );
            else
                writef( " %2s", tile );
        }

        foreach( i, t; board ) {
            qNewLine( i );
            showTile( t );
        }
    }


}

public class Game
{
private:
    bool qGameOver;
    void   setGameOver() { qGameOver = true; }
    void resetGameOver() { qGameOver = false; }

    Board board;
    this( Board board_ )
    {
        board = board_;
        initGame();
    }

    void initGame() {
        board.init();
        qGameOver = false;
    }

    void playGame() {
        void shuffleBoard() {
            void shuffleOneMove() {
                final switch( [ 0, 1, 2, 3 ].choice() )
                {
                    case 0: write(" L"); board.doLeft();  break;
                    case 1: write(" D"); board.doDown();  break;
                    case 2: write(" U"); board.doUp();    break;
                    case 3: write(" R"); board.doRight(); break;
                }
            }

            for ( long i = 0; i < RANDOMLEVEL; i++ )
                shuffleOneMove();
        }

        void gameLoop()
        {
            void congratulate() const {
                writeln("\r");
                writefln( " !!! Congratulations on winning the game !!!\r" );
                writefln( " It took %s moves to complete.\r", board.moves );
            }
            void leaveGame() { 
                writeln( " Leaving game.  Thank you for playing.\r");
                setGameOver();
            }

            static void doHelp() {   writeln();
                writefln( "   h or left  arrow moves tile left  into blank space.\r" );
                writefln( "   l or right arrow moves tile right into blank space.\r" );
                writefln( "   j or down  arrow moves tile down  into blank space.\r" );
                writefln( "   k or up    arrow moves tile up    into blank space.\r" );
                writefln( "   x,q Abandons current game.\r" );
                writefln( "   ? This help screen.\r" );
            }

            void turn() {
                @trusted
                static void askForMove() {
                    write( " hjklxq?> " );
                    stdout.flush( );
                }
                void handleKey( int asciiKey ) {
                    switch ( asciiKey ) {
                        case 'q': leaveGame(); break;  // 'q'
                        case 'x': leaveGame(); break;  // 'x'
                        case 'l': board.doLeft();    break;  // 'l'
                        case 'j': board.doDown();    break;  // 'j'
                        case 'k': board.doUp();      break;  // 'k'
                        case 'l': board.doRight();   break;  // 'l'
                        case  68: board.doLeft();    break;  // arrows
                        case  66: board.doDown();    break;
                        case  65: board.doUp();      break;
                        case  67: board.doRight();   break;
                        case  63: doHelp();    break;  
                        default:
                            writefln( " You pressed %s\r", asciiKey );
                    }
                }

                board.show();
                writeln("\r");
                askForMove();
                auto ch = getch();
                writeln("\r");
                handleKey( ch );
            }

            turn();
            if (board.qWinner() ) {
                board.show();
                congratulate();
                setGameOver();
            }
        }

        initGame();
        shuffleBoard();
        while( !qGameOver ) {
            gameLoop();
        }
    }

    @trusted
    public void anotherGame( ) {

        do {
            playGame();
            writeln("\r");
            writeln("\r");
            write( " Would you like to play again, y/n?" );
            stdout.flush( );
        }
        while ( getch() == 121 );  // 'y'
    }
}

int main() {
    import nwin;
    initializeNCurses();
    scope(exit) { teardownNCurses(); }
    auto board = new Board();
    auto game = new Game( board );
    game.anotherGame();
    return 0;
}