Maze resolver (bad version)

maze.java

/*
rouge: personnage
bleu: win !
noir: mur
blanc: vide
*/

boolean			touch_wall = false;
int				compteur = 0;

int				[]choixDuPixel() {

	int			what_pos[] = {0, 0};
	int			pos[] = {0, 0};
	int			bad_pos;
	int			color_pos[] = {0, 0, 0};

	do {

		what_pos[0] = getX();
		what_pos[1] = getY();
		while (what_pos[0] == getX() && what_pos[1] == getY()) {

			// infinite loop ? obligatoire
			pos[0] = getX();
			pos[1] = getY();
		}
		color_pos = getPixelColor(pos[0], pos[1]);
		if (color_pos[0] < 127 && color_pos[1] < 127 && color_pos[2] < 127) {

			println("Erreur: vous n'etes pas sur du blanc");
			println("veuillez choisir une autre position");
			bad_pos = 1;
		}
		else
			bad_pos = 0;
	}
	while (bad_pos == 1);
	return (pos);
}

boolean			cmpAutour(int a[][], int b[][]) {

	for (int i = 0; i < 3; ++i) {

		for (int j = 0; j < 3; ++j) {

			if (a[i][j] == -1 || b[i][j] == -1)
				continue ;
			if (a[i][j] != b[i][j])
				return (false);
		}
	}
	return (true);
}

int				[]computNewSens(int a[], int b[], int sens[])
{
	int			[]ret = {0, 0};

	ret[0] = b[1] - a[1];
	ret[1] = b[0] - a[0];

	if (ret[0] == 0 && ret[1] == 0)
		return (sens);

	return (ret);
}

boolean			isBlue(int pos[]) {

	int			color_pos[] = {0, 0, 0};

	color_pos = getPixelColor(pos[0], pos[1]);
	if (color_pos[0] < 127 && color_pos[1] < 127 && color_pos[2] > 200) // bleu
		return (true);
	return (false);
}

boolean			isWhite(int pos[]) {

	int			color_pos[] = {0, 0, 0};

	color_pos = getPixelColor(pos[0], pos[1]);
	if (color_pos[0] > 127 && color_pos[1] > 127 && color_pos[2] > 127)
		return (true);
	return (false);
}

boolean			isBlack(int pos[]) {

	int			color_pos[] = {0, 0, 0};

	color_pos = getPixelColor(pos[0], pos[1]);
	if (color_pos[0] < 127 && color_pos[1] < 127 && color_pos[2] < 127)
		return (true);
	return (false);
}

int				[]move(int a[], int b[]) {

	if (isWhite(b) == true || isBlue(b) == true) {

		setPixel(a[0], a[1], 255, 255, 255);
		setPixel(b[0], b[1], 255, 0, 0);
		return (b);
	}
	return (a);
}

// tout droit
int				[]getForward(int pos[], int sens[], int autour[][]) {

	int			new_pos[] = {0, 0};

	new_pos[0] = pos[0] + sens[1]; // inversé, merci java
	new_pos[1] = pos[1] + sens[0]; // inversé, merci java

	if (autour[1 + new_pos[1] - pos[1]][1 + new_pos[0] - pos[0]] == 0)
	{
		return (new_pos);
	}
	return (pos);
}

// rotation droite
int				[]rotateRight(int sens[]) {

	int			new_sens[] = {0, 0};

	if (sens[0] == 0) // vertical
	{
		if (sens[1] == -1) // gauche
		{
			new_sens[0] = -1; // haut
		}
		else if (sens[1] == 1) // droite
		{
			new_sens[0] = 1; // bas
		}
	}
	else if (sens[1] == 0) // horizontal
	{
		if (sens[0] == -1) // haut
		{
			new_sens[1] = 1; // droite
		}
		else if (sens[0] == 1) // bas
		{
			new_sens[1] = -1; // gauche
		}
	}
	return (new_sens);
}

// rotation gauche
int				[]rotateLeft(int sens[]) {

	int			new_sens[] = {0, 0};

	if (sens[0] == 0) // vertical
	{
		if (sens[1] == -1) // gauche
		{
			new_sens[0] = 1; // bas
		}
		else if (sens[1] == 1) // droite
		{
			new_sens[0] = -1; // haut
		}
	}
	else if (sens[1] == 0) // horizontal
	{
		if (sens[0] == -1) // haut
		{
			new_sens[1] = -1; // gauche
		}
		else if (sens[0] == 1) // bas
		{
			new_sens[1] = 1; // droite
		}
	}
	return (new_sens);
}

int				[][]completeAutour(int pos[]) {

	int			tmp_pos[] = {0, 0};
	int			x;
	int			y;
	int			autour[][] = {	{0, 0, 0},
								{0, 0, 0},
								{0, 0, 0}	};

	x = 0;
	while (x < 3)
	{
		y = 0;
		while (y < 3)
		{
			tmp_pos[0] = pos[0] + x - 1;
			tmp_pos[1] = pos[1] + y - 1;
			if (isBlack(tmp_pos) == true) // mur noir
			{
				autour[y][x] = 1;
			}
			y++;
		}
		x++;
	}
	return (autour);
}

int				[][]rotateMatrix(int matrix[][]) {

	int			[][]ret = {	{0, 0, 0},
							{0, 0, 0},
							{0, 0, 0}	};

	for (int layer = 0; layer < 3 / 2; layer++) {

		int first = layer;
		int last = 3 - 1 - first;
		for (int i = first; i < last; i++) {

			int offset = i - first;
			int temp = matrix[first][i];
			ret[first][i] = matrix[last-offset][first];
			ret[last-offset][first] = matrix[last][last-offset];
			ret[last][last-offset] = matrix[i][last];
			ret[i][last] = temp;
		}
	}
	return (ret);
}

int				[][]rotateAutourWithSens(int autour[][], int sens[])
{
	int			ret_autour[][] = {	{0, 0, 0},
									{0, 0, 0},
									{0, 0, 0}	};

	if (sens[0] == -1) // haut
	{
		// don't rotate
		ret_autour = autour;
	}
	else if (sens[0] == 1) // bas
	{
		// rotate 180°
		ret_autour = rotateMatrix(autour);
		ret_autour = rotateMatrix(ret_autour);
	}
	else if (sens[1] == -1) // gauche
	{
		// rotate 90°
		ret_autour = rotateMatrix(autour);
	}
	else if (sens[1] == 1) // droite
	{
		// rotate 270°
		ret_autour = rotateMatrix(autour);
		ret_autour = rotateMatrix(ret_autour);
		ret_autour = rotateMatrix(ret_autour);
	}

	return (ret_autour);
}

int				[]getNextMove(int pos[], int sens[], int autour[][]) {

	//static int	compteur = 0;

	int			new_pos[] = {0, 0};
	int			tmp_autour[][] = {			{0, 0, 0},
											{0, 0, 0},
											{0, 0, 0}	};

	int			mur_face[][] = {			{-1, 1, -1},
											{-1, -1, -1},
											{-1, -1, -1}	};

	int			angle_mur_gauche[][] = {	{-1, 1, -1},
											{1, 0, 0},
											{-1, -1, -1}	};

	int			angle_mur_droit[][] = {		{-1, 1, -1},
											{0, 0, 1},
											{-1, -1, -1}	};

	int			mur_arriere_gauche[][] = {	{-1, -1, -1},
											{0, 0, -1},
											{1, -1, -1}	};

	tmp_autour = rotateAutourWithSens(autour, sens);

	//println(compteur);
	if (touch_wall == false || compteur != 0)
	{
		if (cmpAutour(tmp_autour, angle_mur_droit) == true)
		{
			touch_wall = true;
			sens = rotateRight(sens);
			compteur--;
			sens = rotateRight(sens);
			compteur--;
		}
		else if (cmpAutour(tmp_autour, mur_face) == true)
		{
			// tourner droite
			touch_wall = true;
			sens = rotateRight(sens);
			compteur--;
		}
		else if (compteur != 0 && cmpAutour(tmp_autour, angle_mur_gauche) == true)
		{
			sens = rotateRight(sens);
			compteur--;
		}
		else if (compteur != 0 && cmpAutour(tmp_autour, mur_arriere_gauche) == true)
		{
			// tourner gauche (suivre le mur)
			sens = rotateLeft(sens);
			compteur++;
		}
	}
	else if (compteur == 0)
	{
		touch_wall = false;
		sens[0] = -1;
		sens[1] = 0;
	}

	new_pos = getForward(pos, sens, autour);
	return (new_pos);
}

void			main() {

	boolean		win = false;
	int			pos[] = {0, 0};
	int			tmp_pos[] = {0, 0};
	int			new_pos[] = {0, 0};
	int			sens[] = { -1, 0 }; // haut
	int			autour[][] = {	{0, 0, 0},
								{0, 0, 0},
								{0, 0, 0}	};

	load("labyrinthe.jpg", false);

	compteur = 0;
	touch_wall = false;

	// get pixel position
	pos = choixDuPixel();

	// tant que je ne suis pas sur du bleu
	while (win == false)
	{
		autour = completeAutour(pos);

		// get next move (longer les murs)
		new_pos = getNextMove(pos, sens, autour);

		// comput new sens
		sens = computNewSens(pos, new_pos, sens);

		if (isWhite(new_pos) == true || isBlue(new_pos) == true)
		{
			// savoir si l'on a gagné avant de l'ecraser de rouge
			if (isBlue(new_pos) == true)
				win = true;
			tmp_pos = move(pos, new_pos);
			pos[0] = tmp_pos[0];
			pos[1] = tmp_pos[1];
		}
		sleep(30);
	}
	println("BRAVO TU AS TROUVÉ LA SORTIE !!!");
	//println(compteur);
}