// board from here https://github.com/eulerscheZahl/2048/blob/master/src/main/java/engine/Board.java#L25

// to eventually visualise solvers for https://www.codingame.com/ide/puzzle/2048

​

​

const MOVE = "UDRL"

const SIZE = 4;

var CURR_SEED = 12;

​

function setup() {

  createCanvas(400, 400);

}

​

//https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log

function baseLog(x, y) {

  return Math.log(y) / Math.log(x);

}

​

​

class Graph {

  constructor(edges, n){

    this.adjList = []

    for (var i =0 ; i < n; i++ ){

      adjList.push([])

    }

    for (var [src, dest] of edges){

      this.adjList[src].push(dest)

      this.adjList[dest].push(src)

    }

  }

}

function boardTree(board, maxdepth) {

  // todo del boards that are drawn?

  var q = [];

  var boardNums = new Set();  // .add, .has

  q.push([board,0]);

  while (q ){

    var [state,depth] = q.shift();

    if(depth>maxdepth) {break; }

    for (var dir of [0,1,2,3]) {

    }

  }

}

​

class Board { 

    constructor  (seed) {

        this.grid = [...Array(SIZE)].map(e => Array(SIZE).fill(0));

        this.p = [];

        this.seed = seed;

        this.prevStates = this.p;

        this.prevSeeds = [];

      for(var i=0; i < 7; i++){

        this.spawnTile();

      }

    }

       applyMove( dir) {

        var turnScore = 0;

        var merged = [...Array(SIZE)].map(e => Array(SIZE).fill(0));

        var targetStart = [0, SIZE - 1, SIZE * (SIZE - 1), 0][dir];

        var targetStep = [1, SIZE, 1, SIZE][dir];

        var sourceStep = [SIZE, -1, -SIZE, 1][dir];

​

        for (var i = 0; i < SIZE; i++) {

            var finalTarget = targetStart + i * targetStep;

            for (var j = 1; j < SIZE; j++) {

                var source = finalTarget + j * sourceStep;

                var sourceX = source % SIZE;

                var sourceY = source / SIZE;

                if (this.grid[sourceX][sourceY] == 0) continue;

                for (var k = j - 1; k >= 0; k--) {

                    var intermediate = finalTarget + k * sourceStep;

​

                    var intermediateX = intermediate % SIZE;

                    var intermediateY = intermediate / SIZE;

                    if (this.grid[intermediateX][intermediateY] == 0) {

                        this.grid[intermediateX][intermediateY] = this.grid[sourceX][sourceY];

                        this.grid[sourceX][sourceY] = 0;

                        source = intermediate;

                        sourceX = source % SIZE;

                        sourceY = source / SIZE;

                    } else {

                        if (!merged[intermediateX][intermediateY] && this.grid[intermediateX][intermediateY] == this.grid[sourceX][sourceY]) {

                            this.grid[sourceX][sourceY] = 0;

                            this.grid[intermediateX][intermediateY] *= 2;

                            merged[intermediateX][intermediateY] = true;

                            turnScore += this.grid[intermediateX][intermediateY];

                        }

                        break;

                    }

                }

            }

        }

        return turnScore;

    }

    canMove(dir) {

​

        var backup = [...Array(4)].map(e => Array(4));

        for (var x = 0; x < SIZE; x++) {

            for (var y = 0; y < SIZE; y++) backup[x][y] = this.grid[x][y];

        }

​

        applyMove(dir);

        var moved = false;

        for (var x = 0; x < SIZE; x++) {

            for (var y = 0; y < SIZE; y++) {

                changed |= this.grid[x][y] != backup[x][y];

                grid[x][y] = backup[x][y];

            }

        }

        return moved; 

    }

​

    spawnTile() {

        var free = [];

        for (var y = 0; y < SIZE; y++) {

            for (var x = 0; x < SIZE; x++) {

                if (this.grid[x][y]==0) {free.push(x+(y*SIZE))}

            }

        }

        var i = free[this.seed % free.length]

        var value = (this.seed & 0x10) == 0 ? 2 : SIZE;

        this.grid[i % SIZE][i]=value;

​

        this.seed = this.seed * this.seed % 50515093;

    }

    playMove(d){

​

    }

    undoMove() {

​

    }

    /**

​

    */

  drawOff (x,y) {

      push()

      translate(x,y);

      var m = 15;

      rectMode(CENTER);

       for (var y = 0; y < 4; y++) {

            for (var x = 0; x < 4; x++) {

               fill('rgba(208,181,213,0.28)');

               rect(x*m,y*m,m,m);

                const power = baseLog(2,(this.grid[x][y]));

                var colpow = 0.2+map(power,0,2**15,0,1);

                print(colpow)

                fill(`rgba(255,235,59,${colpow})`)

                rect(x*m,y*m,m,m);

                fill(0)

                  text(this.grid[x][y],x*m,y*m)

​

            }

        }

​

      pop();

    }

    draw () {

      push()

      translate(width/2,height/2);

      var m = 15;

      rectMode(CENTER);

       for (var y = 0; y < 4; y++) {

            for (var x = 0; x < 4; x++) {

               fill('rgba(208,181,213,0.28)');

               rect(x*m,y*m,m,m);

                const power = baseLog(2,(this.grid[x][y]));

                var colpow = 0.2+map(power,0,2**15,0,1);

                print(colpow)

                fill(`rgba(255,235,59,${colpow})`)

                rect(x*m,y*m,m,m);

                fill(0)

                  text(this.grid[x][y],x*m,y*m+2)

​

            }

        }

​

      pop();

    }

}

​

function makeMat() {

  push();

  var m = 15;

  rectMode(CENTER);

  textAlign(CENTER);

  translate((width/2), (height/2));

  for (var y = 0; y < 4; y++) {

            for (var x = 0; x < 4; x++) {

                rect(x*m,y*m,m,m);

                text(y*4+x,x*m,y*m)

            }

        }

  pop();

}

​

function mouseClicked() {

  CURR_SEED++;

  loop();

}

​

function draw() {

  background(220);

  // makeMat();

  b = new Board(CURR_SEED);

  b.applyMove(2);

  b.applyMove(0);

  b.applyMove(2);

  b.draw();

  text('click to regenerate', 0,25);

  text(`seed is ${CURR_SEED}`,0,35)

  noLoop();

}