Estoy teniendo problemas a la hora de crear el juego del 2048 de Fibonachi en primer lugar lo estoy tomando como si fuera un 2048 normal y ya aquí tengo un problema con la puntuación que no sé como hacer que me sume. Además si alguien me da ideas para pasarlo a Fibonachi se lo agradecería. Sí es un código imperativo porque así lo pide mi profesora.

package Fibonachi_2048;
import java.util.*;

public class Main {
static Scanner sc = new Scanner(System.in);
static int[][] tablero = new int[4][4];
static char movimiento; //Posteriormente se definirá a L(left),R(right),U(Up),D(Down) o valor no válido
static int puntuacion;

public static void main(String[] args){

//Esta primera parte nos muestra el tablero inicializado
inicializarTablero(tablero,puntuacion);
mostrarTablero(tablero,puntuacion);
movimiento(tablero,puntuacion,movimiento);
generar(tablero);
mostrarTablero(tablero, puntuacion);

while(Over(tablero) || win(tablero)){
movimiento(tablero,puntuacion,movimiento);
generar(tablero);
mostrarTablero(tablero,puntuacion);
}
}

//Métodos que intervendrán en el main:
public static void inicializarTablero(int[][] t,int p){
p=0;
for(int i =0;i<4;i++){
for(int j=0;j<4;j++){
t[i][j]=0;
}
}

System.out.println("Los controles son: l,r,u,d.");

int i1 = (int) Math.floor(Math.random() * 4);
int j1 = (int) Math.floor(Math.random() * 4);
int i2 = (int) Math.floor(Math.random() * 4);
int j2 = (int) Math.floor(Math.random() * 4);

if ((i1 == i2) && (j1 == j2)) {
t[i1][j1] = 2;
while ((i2==i1)&&(j1==j2)){
i2 = (int) Math.floor(Math.random() * 4);
j2 = (int) Math.floor(Math.random() * 4);
}
t[i2][j2] = 1;
} else {
t[i1][j1] = 1;
t[i2][j2] = 1;
}
}

//Muestra el tablero
public static void mostrarTablero(int[][] t,int p){
for(int i =0;i<4;i++){
System.out.print("|");
for(int j=0;j<4;j++){
System.out.print(" "+ t[i][j] + " ");
}
System.out.println("|");
}
System.out.println("Puntuación: "+p);
}

//Leera el movimiento y actuara con respecto a este
public static void movimiento(int[][]t,int p,char m){
m = sc.next().charAt(0);

switch (m){
case 'l':
movimientoIzquierda(tablero,p);
break;
case 'r':
movimientoDerecha(t,p);
break;
case 'u':
movimientoArriba(t,p);
break;
case 'd':
movimientoAbajo(t,p);
break;
default:
System.out.println("Movimiento no válido");
break;
}
}

//L moverá las casillas a la izquierda
public static int movimientoIzquierda(int[][]t,int p){
//Ojo esto es para un 2048 normal el fibonachi requiere revision

//Mueve hacia la izquierda todos los numeros de manera que los ceros en caso de que hubiera son desplazados a la derecha
for(int j=0;j<4;j++){
for(int c=0;c<3;c++){
for(int i=0;i<3;i++){
if(t[j][i]==0){
t[j][i]=t[j][i+1];
t[j][i+1]=0;
}
}
}
}

//Con estos if encadenados se sumarán los valores que sean iguales
for(int j=0;j<4;j++){
if(t[j][0]!=t[j][1]){
if(t[j][1]!=t[j][2]){
if(t[j][2]==t[j][3]){
t[j][2]=t[j][2]+t[j][3];
t[j][3]=0;
}
}else{
t[j][1]=t[j][1]+t[j][2];
t[j][2]=0;
}
}else{
t[j][0]=t[j][0]+t[j][1];
t[j][1]=0;
p=p+t[j][0];
if(t[j][2]==t[j][3]){
t[j][2]=t[j][2]+t[j][3];
t[j][3]=0;
}
}
}

//Mueve en el caso de que halla quedado algún cero por el camino
for(int j=0;j<4;j++){
for(int c=0;c<3;c++){
for(int i=0;i<3;i++){
if(t[j][i]==0){
t[j][i]=t[j][i+1];
t[j][i+1]=0;
}
}
}
}
return p;
}

//R moverá las casillas a la derecha(se basa en el movimiento a la izquierda)
public static void movimientoDerecha(int[][]t,int p){

for(int j=0;j<4;j++){
for(int c=0;c<3;c++){
for(int i=3;i>0;i--){
if(t[j][i]==0){
t[j][i]=t[j][i-1];
t[j][i-1]=0;
}
}
}
}

for(int j=0;j<4;j++){
if(t[j][3]!=t[j][2]){
if(t[j][2]!=t[j][1]){
if(t[j][1]==t[j][0]){
t[j][1]=t[j][1]+t[j][0];
t[j][0]=0;
p=p+t[j][1];
}
}else{
t[j][2]=t[j][2]+t[j][1];
t[j][1]=0;
p=p+t[j][2];
}
}else{
t[j][3]=t[j][3]+t[j][2];
t[j][2]=0;
p=p+t[j][3];
if(t[j][1]==t[j][0]){
t[j][1]=t[j][1]+t[j][0];
t[j][0]=0;
p=p+t[j][1];
}
}
}

for(int j=0;j<4;j++){
for(int c=0;c<3;c++){
for(int i=3;i>0;i--){
if(t[j][i]==0){
t[j][i]=t[j][i-1];
t[j][i-1]=0;
}
}
}
}
}

//U moverá las casillas arriba(Aplica lo mismo que movimiento Izquierda)
public static void movimientoArriba(int[][]t,int p){

for(int i=0;i<4;i++){
for(int c=0;c<3;c++){
for(int j=0;j<3;j++){
if(t[j][i]==0){
t[j][i]=t[j+1][i];
t[j+1][i]=0;
}
}
}
}

for(int i=0;i<4;i++){
if(t[0][i]!=t[1][i]){
if(t[1][i]!=t[2][i]){
if(t[2][i]==t[3][i]){
t[2][i]=t[2][i]+t[3][i];
t[3][i]=0;
p=p+t[2][i];
}
}else{
t[1][i]=t[1][i]+t[2][i];
t[2][i]=0;
p=p+t[1][i];
}
}else{
t[0][i]=t[0][i]+t[1][i];
t[1][i]=0;
p=p+t[0][i];
if(t[2][i]==t[3][i]){
t[2][i]=t[2][i]+t[3][i];
t[3][i]=0;
p=p+t[2][i];
}
}
}

for(int i=0;i<4;i++){
for(int c=0;c<3;c++){
for(int j=0;j<3;j++){
if(t[j][i]==0){
t[j][i]=t[j+1][i];
t[j+1][i]=0;
}
}
}
}
}


//D moverá las casillas abajo(Aplica lo mismo que movimiento Derecha)
public static void movimientoAbajo(int[][]t,int p){
for(int i=0;i<4;i++){
for(int c=0;c<3;c++){
for(int j=3;j>0;j--){
if(t[j][i]==0){
t[j][i]=t[j-1][i];
t[j-1][i]=0;
}
}
}
}

for(int i=0;i<4;i++){
if(t[3][i]!=t[2][i]){
if(t[2][i]!=t[1][i]){
if(t[1][i]==t[0][i]){
t[1][i]=t[1][i]+t[0][i];
t[0][i]=0;
p=p+t[1][i];
}
}else{
t[2][i]=t[2][i]+t[1][i];
t[1][i]=0;
p=p+t[2][i];
}
}else{
t[3][i]=t[3][i]+t[2][i];
t[2][i]=0;
p=p+t[3][i];
if(t[1][i]==t[0][i]){
t[1][i]=t[1][i]+t[0][i];
t[0][i]=0;
p=p+t[1][i];
}
}
}

for(int i=0;i<4;i++){
for(int c=0;c<3;c++){
for(int j=3;j>0;j--){
if(t[j][i]==0){
t[j][i]=t[j-1][i];
t[j-1][i]=0;
}
}
}
}
}

public static void serieFibonachi(){
int valor1 = 0;
int valor2 = 1;
int[] Fibonachi = new int[30];

for(int i=0;i<=16;i++){
Fibonachi[i]=valor1+valor2;
valor1=valor2;
valor2=Fibonachi[i];
System.out.print(" "+Fibonachi[i]);
}
}

public static void generar(int[][]t){
//Genera dos posiciones aleatorias del tablero
int i =0, j=0, i1=0, j1=0;
boolean zeroTrue=false;

for (i=0; i<4; i++){
for (j=0; j<4; j++){
if (t[i][j]==0){
zeroTrue=true;
}
}
if (zeroTrue){
i1 = (int) Math.floor(Math.random() * 4);
j1 = (int) Math.floor(Math.random() * 4);
if (t[i1][j1]!=0){
if (t[i1][j1]==1){
t[i1][j1] = 2;
}
i1 = (int) Math.floor(Math.random() * 4);
j1 = (int) Math.floor(Math.random() * 4);
while (t[i1][j1]!=0 ){
i1 = (int) Math.floor(Math.random() * 4);
j1 = (int) Math.floor(Math.random() * 4);
}
t [i1][j1]=1;
}else {
t [i1][j1]=1;
}
zeroTrue=false;
for (i=0; i<4; i++){
for (j=0; j<4; j++){
if (t[i][j]==0){
zeroTrue=true;
}
}
}
}
}
}

public static boolean Over(int[][] t){
boolean mov=false;
for (int i=0; i<4; i++){ //comprueba los ceros
for (int j=0; j<4; j++){
if (t[i][j]==0){
return true;
}
}
}
for (int i=0; i<4; i++){ //verifica los movimientos horizontales
for (int j=0; j<3; j++){
if (t[i][j]==0 || t[i][j+1]==t[i][j]){
return true;
}
}
}
for (int i=0; i<3; i++){ //verifica los movimientos verticales
for (int j=0; j<4; j++){
if (t[i][j]==0 || t[i+1][j]==t[i][j])
return true;
}
}
return mov;
}

public static boolean win(int[][]t){
boolean win=false;
for(int i =0;i<4;i++){
for(int j=0;j<4;j++){
if(t[i][j]==2548){
win=true;
}
}
}
if(win==true){
System.out.println("Has ganado");
}

return win;
}
}