Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #include <stdio.h>
- #include <vector>
- #include <iostream>
- #include <memory>
- #include <string>
- #include <algorithm>
- #include <ctime>
- #include <random>
- enum Colors {
- white = 0,
- yellow = 1,
- red = 2,
- green = 3,
- orange = 4,
- blue = 5
- };
- enum Directions {
- x = 0,
- y = 1,
- z = 2
- };
- enum Movements {
- R = 0,
- Rp = 1,
- L = 2,
- Lp = 3,
- U = 4,
- Up = 5,
- D = 6,
- Dp = 7,
- F = 8,
- Fp = 9,
- B = 10,
- Bp = 11
- };
- class Piece {
- protected:
- public:
- virtual std::shared_ptr<Piece> copy() {}
- virtual int getColor() {}
- virtual int getColor(int i) {}
- virtual std::ostream& getStream(std::ostream& stream) {return stream;}
- virtual void rotate() {}
- virtual void rotate(int unchangedDirection) {}
- virtual std::vector<int> getAllColors() {}
- };
- class Corner : public Piece {
- private:
- int m_xColor;
- int m_yColor;
- int m_zColor;
- public:
- Corner(int xColor, int yColor, int zColor);
- virtual std::shared_ptr<Piece> copy();
- virtual int getColor(int i);
- virtual std::ostream& getStream(std::ostream& stream) override;
- virtual void rotate(int unchangedDirection);
- virtual std::vector<int> getAllColors();
- };
- class Edge : public Piece {
- private:
- int m_color1;
- int m_color2;
- public:
- // color1 is the color oriented to the white side or the yellow side.
- // If there is not, this is the color oriented to the red or the orange side.
- // color2 is the other color
- Edge(int color1, int color2);
- virtual std::shared_ptr<Piece> copy();
- virtual int getColor(int i);
- virtual std::ostream& getStream(std::ostream& stream) override;
- virtual void rotate();
- virtual std::vector<int> getAllColors();
- };
- class Center : public Piece {
- private:
- int m_color;
- public:
- Center(int color);
- virtual std::shared_ptr<Piece> copy();
- virtual int getColor();
- virtual std::ostream& getStream(std::ostream& stream) override;
- virtual std::vector<int> getAllColors();
- };
- typedef std::vector<std::vector<std::shared_ptr<Piece>>> vectorOfPieces;
- class Sequence {
- };
- class RubiksCube {
- private:
- vectorOfPieces m_possibility;
- void move(int corners[4][2], int edges[4][2], bool prime, bool doEdgesRotate, int cornerUnchangedDirection);
- void moveInterior(int edges[4][2], int centers[4][2], bool prime);
- bool isPieceWellPlaced(vectorOfPieces objective, std::shared_ptr<Piece> piece);
- std::vector<int> findPlaceOfPiece(std::shared_ptr<Piece> piece, vectorOfPieces possibility);
- // RESOLUTION
- // FIRST CROSS (WHITE FACE)
- void solveFirstCross(vectorOfPieces objective);
- void putEdgeDown(std::shared_ptr<Piece> edge);
- void placeEdge(vectorOfPieces objective, std::shared_ptr<Piece> edge);
- // 1st FACE (WHITE) = CORNERS
- void finishFirstFace(vectorOfPieces objective);
- void putCornerDown(std::shared_ptr<Piece> corner);
- void placeCorner(vectorOfPieces objective, std::shared_ptr<Piece> corner);
- void silentMovex();
- void silentMovexp();
- void silentMovey();
- void silentMoveyp();
- void silentMovez();
- void silentMovezp();
- public:
- static RubiksCube askForCube();
- static RubiksCube makeRandomCube();
- static RubiksCube makeRandomCube(vectorOfPieces possibility);
- static RubiksCube makeRandomCube(vectorOfPieces possibility, int seed);
- RubiksCube(vectorOfPieces possibility);
- void moveR();
- void moveRp();
- void moveL();
- void moveLp();
- void moveU();
- void moveUp();
- void moveD();
- void moveDp();
- void moveF();
- void moveFp();
- void moveB();
- void moveBp();
- void moveM();
- void movem();
- void moveE();
- void movee();
- void moveS();
- void moves();
- void movex();
- void movexp();
- void movey();
- void moveyp();
- void movez();
- void movezp();
- int getFaceColor();
- std::shared_ptr<Piece> getPiece(int ring, int i);
- Sequence goTo(vectorOfPieces objective);
- void getStats();
- void test();
- };
- // CONSTANTS
- vectorOfPieces RUBIKS_CUBE_FINISHED = {
- {
- std::shared_ptr<Piece>(new Center(Colors::white)),
- std::shared_ptr<Piece>(new Corner(Colors::green, Colors::white, Colors::red)),
- std::shared_ptr<Piece>(new Edge(Colors::white, Colors::green)),
- std::shared_ptr<Piece>(new Corner(Colors::green, Colors::white, Colors::orange)),
- std::shared_ptr<Piece>(new Edge(Colors::white, Colors::orange)),
- std::shared_ptr<Piece>(new Corner(Colors::blue, Colors::white, Colors::orange)),
- std::shared_ptr<Piece>(new Edge(Colors::white, Colors::blue)),
- std::shared_ptr<Piece>(new Corner(Colors::blue, Colors::white, Colors::red)),
- std::shared_ptr<Piece>(new Edge(Colors::white, Colors::red))
- },
- {
- std::shared_ptr<Piece>(new Edge(Colors::red, Colors::green)),
- std::shared_ptr<Piece>(new Center(Colors::green)),
- std::shared_ptr<Piece>(new Edge(Colors::orange, Colors::green)),
- std::shared_ptr<Piece>(new Center(Colors::orange)),
- std::shared_ptr<Piece>(new Edge(Colors::orange, Colors::blue)),
- std::shared_ptr<Piece>(new Center(Colors::blue)),
- std::shared_ptr<Piece>(new Edge(Colors::red, Colors::blue)),
- std::shared_ptr<Piece>(new Center(Colors::red))
- },
- {
- std::shared_ptr<Piece>(new Center(Colors::yellow)),
- std::shared_ptr<Piece>(new Corner(Colors::green, Colors::yellow, Colors::red)),
- std::shared_ptr<Piece>(new Edge(Colors::yellow, Colors::green)),
- std::shared_ptr<Piece>(new Corner(Colors::green, Colors::yellow, Colors::orange)),
- std::shared_ptr<Piece>(new Edge(Colors::yellow, Colors::orange)),
- std::shared_ptr<Piece>(new Corner(Colors::blue, Colors::yellow, Colors::orange)),
- std::shared_ptr<Piece>(new Edge(Colors::yellow, Colors::blue)),
- std::shared_ptr<Piece>(new Corner(Colors::blue, Colors::yellow, Colors::red)),
- std::shared_ptr<Piece>(new Edge(Colors::yellow, Colors::red))
- }
- };
- std::ostream& Corner::getStream(std::ostream& stream) {
- stream << "Corner(";
- int color;
- for (int i = 0; i < 3; i++) {
- stream << "Colors::";
- color = getColor(i);
- switch (color) {
- case Colors::white : stream << "white" ; break;
- case Colors::yellow : stream << "yellow" ; break;
- case Colors::red : stream << "red" ; break;
- case Colors::green : stream << "green" ; break;
- case Colors::orange : stream << "orange" ; break;
- case Colors::blue : stream << "blue" ; break;
- }
- stream << ", ";
- }
- stream << ")";
- return stream;
- }
- std::ostream& Edge::getStream(std::ostream& stream) {
- stream << "Edge(";
- int color;
- for (int i = 0; i < 2; i++) {
- stream << "Colors::";
- color = getColor(i);
- switch (color) {
- case Colors::white : stream << "white" ; break;
- case Colors::yellow : stream << "yellow" ; break;
- case Colors::red : stream << "red" ; break;
- case Colors::green : stream << "green" ; break;
- case Colors::orange : stream << "orange" ; break;
- case Colors::blue : stream << "blue" ; break;
- }
- stream << ", ";
- }
- stream << ")";
- return stream;
- }
- std::ostream& Center::getStream(std::ostream& stream) {
- stream << "Center(";
- stream << "Colors::";
- int color = getColor();
- switch (color) {
- case Colors::white : stream << "white" ; break;
- case Colors::yellow : stream << "yellow" ; break;
- case Colors::red : stream << "red" ; break;
- case Colors::green : stream << "green" ; break;
- case Colors::orange : stream << "orange" ; break;
- case Colors::blue : stream << "blue" ; break;
- default: stream << "oullalala la ya un pb la... color=" << color << std::endl;
- }
- stream << ", ";
- stream << ")";
- return stream;
- }
- std::ostream& operator<<(std::ostream& sortie, std::shared_ptr<Piece> piece) {
- return piece->getStream(sortie);
- }
- std::ostream& operator<<(std::ostream& stream, RubiksCube cube) {
- stream << "{" << std::endl;
- stream << "\t{" << std::endl;
- for (int i = 0; i < 9; i++) {
- stream << "\t\t" << cube.getPiece(0, i) << "," << std::endl;
- }
- stream << "\t}," << std::endl;
- stream << "\t{" << std::endl;
- for (int i = 0; i < 8; i++) {
- stream << "\t\t" << cube.getPiece(1, i) << "," << std::endl;
- }
- stream << "\t}," << std::endl;
- stream << "\t{" << std::endl;
- for (int i = 0; i < 9; i++) {
- stream << "\t\t" << cube.getPiece(2, i) << "," << std::endl;
- }
- stream << "\t}" << std::endl;
- stream << "}" << std::endl;
- return stream;
- }
- bool operator==(std::shared_ptr<Piece> piece1, std::shared_ptr<Piece> piece2) {
- std::vector<int> piece1Colors = piece1->getAllColors();
- std::vector<int> piece2Colors = piece2->getAllColors();
- if (piece1Colors.size() != piece2Colors.size()) return false;
- for (int i = 0; i < piece2Colors.size(); i++) {
- if (piece1Colors[i] != piece2Colors[i]) return false;
- } return true;
- }
- bool operator!=(std::shared_ptr<Piece> piece1, std::shared_ptr<Piece> piece2) {
- std::vector<int> piece1Colors = piece1->getAllColors();
- std::vector<int> piece2Colors = piece2->getAllColors();
- if (piece1Colors.size() != piece2Colors.size()) return true;
- for (int i = 0; i < piece2Colors.size(); i++) {
- if (std::find(piece1Colors.begin(), piece1Colors.end(), piece2Colors[i]) == piece1Colors.end()) {
- return true;
- }
- } return false;
- }
- Corner::Corner(int xColor, int yColor, int zColor) :
- m_xColor(xColor),
- m_yColor(yColor),
- m_zColor(zColor) {}
- Edge::Edge(int color1, int color2) :
- m_color1(color1),
- m_color2(color2) {}
- Center::Center(int color) :
- m_color(color) {}
- std::shared_ptr<Piece> Corner::copy() {
- return std::shared_ptr<Piece> (new Corner(m_xColor, m_yColor, m_zColor));
- }
- std::shared_ptr<Piece> Edge::copy() {
- return std::shared_ptr<Piece> (new Edge(m_color1, m_color2));
- }
- std::shared_ptr<Piece> Center::copy() {
- return std::shared_ptr<Piece> (new Center(m_color));
- }
- int Corner::getColor(int color) {
- switch (color) {
- case 0: return m_xColor;
- case 1: return m_yColor;
- case 2: return m_zColor;
- }
- }
- int Edge::getColor(int color) {
- switch (color) {
- case 0: return m_color1;
- case 1: return m_color2;
- }
- }
- int Center::getColor() {
- return m_color;
- }
- std::vector<int> Corner::getAllColors() {
- std::vector<int> colors = {m_xColor, m_yColor, m_zColor};
- return colors;
- }
- std::vector<int> Edge::getAllColors() {
- std::vector<int> colors = {m_color1, m_color2};
- return colors;
- }
- std::vector<int> Center::getAllColors() {
- std::vector<int> colors = {m_color};
- return colors;
- }
- void Corner::rotate(int unchangedDirection) {
- int directionsToChange[2];
- if (unchangedDirection == Directions::x) {
- int color = m_yColor;
- m_yColor = m_zColor;
- m_zColor = color;
- }
- if (unchangedDirection == Directions::y) {
- int color = m_xColor;
- m_xColor = m_zColor;
- m_zColor = color;
- }
- if (unchangedDirection == Directions::z) {
- int color = m_xColor;
- m_xColor = m_yColor;
- m_yColor = color;
- }
- }
- void Edge::rotate() {
- int color1 = m_color1;
- m_color1 = m_color2;
- m_color2 = color1;
- }
- RubiksCube::RubiksCube(vectorOfPieces possibility) :
- m_possibility(possibility) {}
- std::shared_ptr<Piece> RubiksCube::getPiece(int ring, int i) {
- return m_possibility[ring][i];
- }
- int RubiksCube::getFaceColor() {
- return m_possibility[1][7]->getColor();
- }
- void RubiksCube::move(int corners[4][2], int edges[4][2], bool prime, bool doEdgesRotate, int cornerUnchangedDirection) {
- std::vector<std::shared_ptr<Piece>> cornersVector = {
- m_possibility[corners[0][0]][corners[0][1]],
- m_possibility[corners[1][0]][corners[1][1]],
- m_possibility[corners[2][0]][corners[2][1]],
- m_possibility[corners[3][0]][corners[3][1]]
- };
- std::vector<std::shared_ptr<Piece>> edgesVector = {
- m_possibility[edges[0][0]][edges[0][1]],
- m_possibility[edges[1][0]][edges[1][1]],
- m_possibility[edges[2][0]][edges[2][1]],
- m_possibility[edges[3][0]][edges[3][1]]
- };
- if (!prime) {
- m_possibility[corners[0][0]][corners[0][1]] = cornersVector[3];
- m_possibility[corners[1][0]][corners[1][1]] = cornersVector[0];
- m_possibility[corners[2][0]][corners[2][1]] = cornersVector[1];
- m_possibility[corners[3][0]][corners[3][1]] = cornersVector[2];
- m_possibility[edges[0][0]][edges[0][1]] = edgesVector[3];
- m_possibility[edges[1][0]][edges[1][1]] = edgesVector[0];
- m_possibility[edges[2][0]][edges[2][1]] = edgesVector[1];
- m_possibility[edges[3][0]][edges[3][1]] = edgesVector[2];
- } else {
- m_possibility[corners[0][0]][corners[0][1]] = cornersVector[1];
- m_possibility[corners[1][0]][corners[1][1]] = cornersVector[2];
- m_possibility[corners[2][0]][corners[2][1]] = cornersVector[3];
- m_possibility[corners[3][0]][corners[3][1]] = cornersVector[0];
- m_possibility[edges[0][0]][edges[0][1]] = edgesVector[1];
- m_possibility[edges[1][0]][edges[1][1]] = edgesVector[2];
- m_possibility[edges[2][0]][edges[2][1]] = edgesVector[3];
- m_possibility[edges[3][0]][edges[3][1]] = edgesVector[0];
- }
- if (doEdgesRotate) {
- for (int i = 0; i < 4; i++) {
- m_possibility[edges[i][0]][edges[i][1]]->rotate();
- }
- }
- for (int i = 0; i < 4; i++) {
- m_possibility[corners[i][0]][corners[i][1]]->rotate(cornerUnchangedDirection);
- }
- }
- void RubiksCube::moveInterior(int edges[4][2], int centers[4][2], bool prime) {
- std::vector<std::shared_ptr<Piece>> edgesVector = {
- m_possibility[edges[0][0]][edges[0][1]],
- m_possibility[edges[1][0]][edges[1][1]],
- m_possibility[edges[2][0]][edges[2][1]],
- m_possibility[edges[3][0]][edges[3][1]]
- };
- std::vector<std::shared_ptr<Piece>> centersVector = {
- m_possibility[centers[0][0]][centers[0][1]],
- m_possibility[centers[1][0]][centers[1][1]],
- m_possibility[centers[2][0]][centers[2][1]],
- m_possibility[centers[3][0]][centers[3][1]]
- };
- if (!prime) {
- m_possibility[edges[0][0]][edges[0][1]] = edgesVector[3];
- m_possibility[edges[1][0]][edges[1][1]] = edgesVector[0];
- m_possibility[edges[2][0]][edges[2][1]] = edgesVector[1];
- m_possibility[edges[3][0]][edges[3][1]] = edgesVector[2];
- m_possibility[centers[0][0]][centers[0][1]] = centersVector[3];
- m_possibility[centers[1][0]][centers[1][1]] = centersVector[0];
- m_possibility[centers[2][0]][centers[2][1]] = centersVector[1];
- m_possibility[centers[3][0]][centers[3][1]] = centersVector[2];
- } else {
- m_possibility[edges[0][0]][edges[0][1]] = edgesVector[1];
- m_possibility[edges[1][0]][edges[1][1]] = edgesVector[2];
- m_possibility[edges[2][0]][edges[2][1]] = edgesVector[3];
- m_possibility[edges[3][0]][edges[3][1]] = edgesVector[0];
- m_possibility[centers[0][0]][centers[0][1]] = centersVector[1];
- m_possibility[centers[1][0]][centers[1][1]] = centersVector[2];
- m_possibility[centers[2][0]][centers[2][1]] = centersVector[3];
- m_possibility[centers[3][0]][centers[3][1]] = centersVector[0];
- }
- for (int i = 0; i < 4; i++) {
- m_possibility[edges[i][0]][edges[i][1]]->rotate();
- }
- }
- void RubiksCube::moveR() {
- int corners[4][2] = {{0,7}, {0,5}, {2,5}, {2,7}};
- int edges[4][2] = {{0,6}, {1,4}, {2,6}, {1,6}};
- int doEdgesRotate = getFaceColor() == Colors::blue || getFaceColor() == Colors::green;
- move(corners, edges, false, doEdgesRotate, Directions::x);
- }
- void RubiksCube::moveRp() {
- int corners[4][2] = {{0,7}, {0,5}, {2,5}, {2,7}};
- int edges[4][2] = {{0,6}, {1,4}, {2,6}, {1,6}};
- int doEdgesRotate = getFaceColor() == Colors::blue || getFaceColor() == Colors::green;
- move(corners, edges, true, doEdgesRotate, Directions::x);
- }
- void RubiksCube::moveL() {
- int corners[4][2] = {{0,3}, {0,1}, {2,1}, {2,3}};
- int edges[4][2] = {{0,2}, {1,0}, {2,2}, {1,2}};
- int doEdgesRotate = getFaceColor() == Colors::blue || getFaceColor() == Colors::green;
- move(corners, edges, false, doEdgesRotate, Directions::x);
- }
- void RubiksCube::moveLp() {
- int corners[4][2] = {{0,3}, {0,1}, {2,1}, {2,3}};
- int edges[4][2] = {{0,2}, {1,0}, {2,2}, {1,2}};
- int doEdgesRotate = getFaceColor() == Colors::blue || getFaceColor() == Colors::green;
- move(corners, edges, true, doEdgesRotate, Directions::x);
- }
- void RubiksCube::moveU() {
- int corners[4][2] = {{0,1}, {0,3}, {0,5}, {0,7}};
- int edges[4][2] = {{0,2}, {0,4}, {0,6}, {0,8}};
- int doEdgesRotate = getFaceColor() == Colors::white || getFaceColor() == Colors::yellow;
- move(corners, edges, false, doEdgesRotate, Directions::y);
- }
- void RubiksCube::moveUp() {
- int corners[4][2] = {{0,1}, {0,3}, {0,5}, {0,7}};
- int edges[4][2] = {{0,2}, {0,4}, {0,6}, {0,8}};
- int doEdgesRotate = getFaceColor() == Colors::white || getFaceColor() == Colors::yellow;
- move(corners, edges, true, false, Directions::y);
- }
- void RubiksCube::moveD() {
- int corners[4][2] = {{2,7}, {2,5}, {2,3}, {2,1}};
- int edges[4][2] = {{2,8}, {2,6}, {2,4}, {2,2}};
- int doEdgesRotate = getFaceColor() == Colors::white || getFaceColor() == Colors::yellow;
- move(corners, edges, false, false, Directions::y);
- }
- void RubiksCube::moveDp() {
- int corners[4][2] = {{2,7}, {2,5}, {2,3}, {2,1}};
- int edges[4][2] = {{2,8}, {2,6}, {2,4}, {2,2}};
- int doEdgesRotate = getFaceColor() == Colors::white || getFaceColor() == Colors::yellow;
- move(corners, edges, true, false, Directions::y);
- }
- void RubiksCube::moveF() {
- int corners[4][2] = {{0,1}, {0,7}, {2,7}, {2,1}};
- int edges[4][2] = {{0,8}, {1,6}, {2,8}, {1,0}};
- int doEdgesRotate = getFaceColor() == Colors::red || getFaceColor() == Colors::red;
- move(corners, edges, false, doEdgesRotate, Directions::z);
- }
- void RubiksCube::moveFp() {
- int corners[4][2] = {{0,1}, {0,7}, {2,7}, {2,1}};
- int edges[4][2] = {{0,8}, {1,6}, {2,8}, {1,0}};
- int doEdgesRotate = getFaceColor() == Colors::red || getFaceColor() == Colors::orange;
- move(corners, edges, true, doEdgesRotate, Directions::z);
- }
- void RubiksCube::moveB() {
- int corners[4][2] = {{0,3}, {2,3}, {2,5}, {0,5}};
- int edges[4][2] = {{0,4}, {1,2}, {2,4}, {1,4}};
- int doEdgesRotate = getFaceColor() == Colors::red || getFaceColor() == Colors::orange;
- move(corners, edges, false, doEdgesRotate, Directions::z);
- }
- void RubiksCube::moveBp() {
- int corners[4][2] = {{0,3}, {2,3}, {2,5}, {0,5}};
- int edges[4][2] = {{0,4}, {1,2}, {2,4}, {1,4}};
- int doEdgesRotate = getFaceColor() == Colors::red || getFaceColor() == Colors::orange;
- move(corners, edges, true, doEdgesRotate, Directions::z);
- }
- void RubiksCube::moveM() {
- int edges[4][2] = {{0,8}, {2,8}, {2,4}, {0,4}};
- int centers[4][2] = {{0,0}, {1,7}, {2,0}, {1,3}};
- moveInterior(edges, centers, false);
- }
- void RubiksCube::movem() {
- int edges[4][2] = {{0,8}, {2,8}, {2,4}, {0,4}};
- int centers[4][2] = {{0,0}, {1,7}, {2,0}, {1,3}};
- moveInterior(edges, centers, true);
- }
- void RubiksCube::moveE() {
- int edges[4][2] = {{1,0}, {1,2}, {1,4}, {1,6}};
- int centers[4][2] = {{1,7}, {1,1}, {1,3}, {1,5}};
- moveInterior(edges, centers, false);
- }
- void RubiksCube::movee() {
- int edges[4][2] = {{1,0}, {1,2}, {1,4}, {1,6}};
- int centers[4][2] = {{1,7}, {1,1}, {1,3}, {1,5}};
- moveInterior(edges, centers, true);
- }
- void RubiksCube::moveS() {
- int edges[4][2] = {{0,6}, {2,6}, {2,2}, {0,2}};
- int centers[4][2] = {{0,0}, {1,5}, {2,0}, {1,1}};
- moveInterior(edges, centers, false);
- }
- void RubiksCube::moves() {
- int edges[4][2] = {{0,6}, {2,6}, {2,2}, {0,2}};
- int centers[4][2] = {{0,0}, {1,5}, {2,0}, {1,1}};
- moveInterior(edges, centers, true);
- }
- void RubiksCube::movex() {
- moveR();
- movem();
- moveLp();
- }
- void RubiksCube::movexp() {
- moveRp();
- moveM();
- moveL();
- }
- void RubiksCube::movey() {
- moveU();
- moveE();
- moveDp();
- }
- void RubiksCube::moveyp() {
- moveUp();
- movee();
- moveD();
- }
- void RubiksCube::movez() {
- moveF();
- moveS();
- moveBp();
- }
- void RubiksCube::movezp() {
- moveFp();
- moveS();
- moveB();
- }
- void RubiksCube::silentMovex() {
- moveR();
- movem();
- moveLp();
- }
- void RubiksCube::silentMovexp() {
- moveRp();
- moveM();
- moveL();
- }
- void RubiksCube::silentMovey() {
- moveU();
- moveE();
- moveDp();
- }
- void RubiksCube::silentMoveyp() {
- moveUp();
- movee();
- moveD();
- }
- void RubiksCube::silentMovez() {
- moveF();
- moveS();
- moveBp();
- }
- void RubiksCube::silentMovezp() {
- moveFp();
- moveS();
- moveB();
- }
- RubiksCube RubiksCube::askForCube() {
- int faces[6][9];
- std::cout << "Les couleurs"
- << std::endl << "\t- Blanc : 0"
- << std::endl << "\t- Jaune : 1"
- << std::endl << "\t- Rouge : 2"
- << std::endl << "\t- Vert : 3"
- << std::endl << "\t- Orange : 4"
- << std::endl << "\t- Bleu : 5" << std::endl;
- std::string facesNames[6] = {"blanche", "jaune", "rouge", "verte", "orange", "bleue"};
- for (int face = 0; face < 6; face++) {
- std::cout << "Entrez la face " << facesNames[face] << " : (centre en premier)" << std::endl;
- for (int i = 0; i < 9; i++) {
- std::cout << "\t> ";
- std::cin >> faces[face][i];
- }
- }
- vectorOfPieces possibility = {
- {
- std::shared_ptr<Piece>(new Center(faces[0][0])),
- std::shared_ptr<Piece>(new Corner(faces[3][5], faces[0][1], faces[2][3])),
- std::shared_ptr<Piece>(new Edge(faces[0][2], faces[3][4])),
- std::shared_ptr<Piece>(new Corner(faces[3][3], faces[0][3], faces[4][5])),
- std::shared_ptr<Piece>(new Edge(faces[0][4], faces[4][4])),
- std::shared_ptr<Piece>(new Corner(faces[5][5], faces[0][5], faces[4][3])),
- std::shared_ptr<Piece>(new Edge(faces[0][6], faces[5][4])),
- std::shared_ptr<Piece>(new Corner(faces[5][3], faces[0][7], faces[2][5])),
- std::shared_ptr<Piece>(new Edge(faces[0][8], faces[2][4])),
- },
- {
- std::shared_ptr<Piece>(new Edge(faces[2][2], faces[3][6])),
- std::shared_ptr<Piece>(new Center(faces[3][0])),
- std::shared_ptr<Piece>(new Edge(faces[4][6], faces[3][2])),
- std::shared_ptr<Piece>(new Center(faces[4][0])),
- std::shared_ptr<Piece>(new Edge(faces[4][2], faces[5][6])),
- std::shared_ptr<Piece>(new Center(faces[5][0])),
- std::shared_ptr<Piece>(new Edge(faces[2][6], faces[5][2])),
- std::shared_ptr<Piece>(new Center(faces[2][0])),
- },
- {
- std::shared_ptr<Piece>(new Center(faces[1][0])),
- std::shared_ptr<Piece>(new Corner(faces[3][7], faces[1][3], faces[2][1])),
- std::shared_ptr<Piece>(new Edge(faces[1][2], faces[3][8])),
- std::shared_ptr<Piece>(new Corner(faces[3][1], faces[1][1], faces[4][7])),
- std::shared_ptr<Piece>(new Edge(faces[1][8], faces[4][8])),
- std::shared_ptr<Piece>(new Corner(faces[5][7], faces[1][7], faces[4][1])),
- std::shared_ptr<Piece>(new Edge(faces[1][6], faces[5][8])),
- std::shared_ptr<Piece>(new Corner(faces[5][1], faces[1][5], faces[2][7])),
- std::shared_ptr<Piece>(new Edge(faces[1][4], faces[2][8])),
- }
- };
- RubiksCube cube(possibility);
- return cube;
- }
- RubiksCube RubiksCube::makeRandomCube(vectorOfPieces possibility, int seed) {
- for (int i = 0; i < 9; i++) {
- possibility[0][i] = possibility[0][i]->copy();
- }
- for (int i = 0; i < 8; i++) {
- possibility[1][i] = possibility[1][i]->copy();
- }
- for (int i = 0; i < 9; i++) {
- possibility[2][i] = possibility[2][i]->copy();
- }
- srand(seed);
- RubiksCube cube(possibility);
- for (int i = 0; i < 100; i++) {
- switch(rand() % 11) {
- case Movements::R: cube.moveR();break;
- case Movements::Rp: cube.moveRp();break;
- case Movements::L: cube.moveL();break;
- case Movements::Lp: cube.moveLp();break;
- case Movements::U: cube.moveU();break;
- case Movements::Up: cube.moveUp();break;
- case Movements::D: cube.moveD();break;
- case Movements::Dp: cube.moveDp();break;
- case Movements::F: cube.moveF();break;
- case Movements::Fp: cube.moveFp();break;
- case Movements::B: cube.moveB();break;
- case Movements::Bp: cube.moveBp();break;
- }
- } return cube;
- }
- RubiksCube RubiksCube::makeRandomCube(vectorOfPieces possibility) {
- return makeRandomCube(possibility, time(NULL));
- }
- RubiksCube RubiksCube::makeRandomCube() {
- return makeRandomCube(RUBIKS_CUBE_FINISHED, time(NULL));
- }
- std::vector<int> RubiksCube::findPlaceOfPiece(std::shared_ptr<Piece> piece, vectorOfPieces possibility) {
- for (int i = 0; i < 9; i++) {
- if (!(possibility[0][i] != piece)) return std::vector<int> {0, i};
- }
- for (int i = 0; i < 8; i++) {
- if (!(possibility[1][i] != piece)) return std::vector<int> {1, i};
- }
- for (int i = 0; i < 9; i++) {
- if (!(possibility[2][i] != piece)) return std::vector<int> {2, i};
- }
- std::cout << "ERROR : Piece not found " << piece << std::endl;
- return std::vector<int> {-1, -1};
- }
- bool RubiksCube::isPieceWellPlaced(vectorOfPieces objective, std::shared_ptr<Piece> piece) {
- std::vector<int> movements;
- if (m_possibility[1][1]->getColor() == Colors::white || m_possibility[1][5]->getColor() == Colors::white) {
- silentMovex();
- movements.push_back(Directions::x);
- }
- while (m_possibility[0][0]->getColor() != Colors::white) {
- silentMovex();
- movements.push_back(Directions::x);
- }
- while (m_possibility[1][7]->getColor() != Colors::red) {
- silentMovey();
- movements.push_back(Directions::y);
- }
- std::vector<int> placeOnObjective = findPlaceOfPiece(piece, objective);
- std::vector<int> placeOnPossibility = findPlaceOfPiece(piece, m_possibility);
- bool response = placeOnObjective == placeOnPossibility;
- for (int i = movements.size() - 1; i >= 0; i--) {
- switch (movements[i]) {
- case Directions::x: silentMovexp();break;
- case Directions::y: silentMoveyp();break;
- case Directions::z: silentMovezp();break;
- }
- }
- return response;
- }
- Sequence RubiksCube::goTo(vectorOfPieces objective) {
- solveFirstCross(objective);
- finishFirstFace(objective);
- Sequence s;
- return s;
- }
- void RubiksCube::solveFirstCross(vectorOfPieces objective) {
- std::vector<std::shared_ptr<Piece>> edges = {
- objective[0][2],
- objective[0][4],
- objective[0][6],
- objective[0][8]
- };
- for (int i = 0; i < 4; i++) {
- moveyp();
- if (!isPieceWellPlaced(objective, edges[i])) {
- putEdgeDown(edges[i]);
- placeEdge(objective, edges[i]);
- }
- }
- }
- void RubiksCube::putEdgeDown(std::shared_ptr<Piece> edge) {
- std::vector<int> pos = findPlaceOfPiece(edge, m_possibility);
- for (int i = 0; i < pos[1] / 2; i++) {
- moveyp();
- }
- if (pos[0] == 0) {
- moveM();
- moveDp();
- movem();
- moveD();
- } else if (pos[0] == 1) {
- moveL();
- moveD();
- moveLp();
- }
- for (int i = 0; i < pos[1] / 2; i++) {
- movey();
- moveD();
- }
- }
- void RubiksCube::placeEdge(vectorOfPieces objective, std::shared_ptr<Piece> edge) {
- if (m_possibility[2][8]->getColor(1) == objective[0][findPlaceOfPiece(edge, objective)[1]]->getColor(0)) { // GOOD ORIENTATION
- moveDp();
- moveM();
- moveD();
- movem();
- } else { // BAD ORIENTATION
- moveM();
- moveD();
- moveD();
- movem();
- }
- }
- void RubiksCube::finishFirstFace(vectorOfPieces objective) {
- std::vector<std::shared_ptr<Piece>> corners = {
- objective[0][1],
- objective[0][3],
- objective[0][5],
- objective[0][7]
- };
- for (int i = 0; i < 4; i++) {
- moveyp();
- if (!isPieceWellPlaced(objective, corners[i])) {
- putCornerDown(corners[i]);
- placeCorner(objective, corners[i]);
- }
- }
- }
- void RubiksCube::putCornerDown(std::shared_ptr<Piece> corner) {
- std::vector<int> pos = findPlaceOfPiece(corner, m_possibility);
- for (int i = 0; i < (pos[1] + 1) / 2; i++) {
- moveyp();
- }
- if (pos[0] == 0) {
- moveRp();
- moveDp();
- moveR();
- moveD();
- }
- for (int i = 0; i < (pos[1] + 1) / 2; i++) {
- movey();
- moveD();
- }
- }
- void RubiksCube::placeCorner(vectorOfPieces objective, std::shared_ptr<Piece> corner) {
- int color = objective[0][findPlaceOfPiece(corner, objective)[1]]->getColor(1); // COLOR OF WHITE FACE
- //std::cout << objective << std::endl;
- //std::cout << color << findPlaceOfPiece(corner, objective)[0] << findPlaceOfPiece(corner, objective)[1];
- //std::cout << m_possibility[2][7] << std::endl;
- if (m_possibility[2][7]->getColor(0) == color) {
- moveRp();
- moveDp();
- moveR();
- } else if (m_possibility[2][7]->getColor(1) == color) {
- moveRp();
- moveD();
- moveD();
- moveR();
- moveD();
- moveRp();
- moveDp();
- moveR();
- } else if (m_possibility[2][7]->getColor(2) == color) {
- moveDp();
- moveRp();
- moveD();
- moveR();
- }
- }
- void RubiksCube::test() {
- std::cout << m_possibility.size() << m_possibility[0].size() << m_possibility[1].size() << m_possibility[2].size();
- }
- void getStats(bool debug) {
- std::vector<std::vector<int>> TO_VERIFY {
- {0, 0},
- {0, 1},
- {0, 2},
- {0, 3},
- {0, 4},
- {0, 5},
- {0, 6},
- {0, 7},
- {0, 8},
- };
- srand(time(NULL));
- int rights = 0;
- int tests = 1000;
- double startTime = time(NULL);
- for (int i = 0; i < tests; i++) {
- int seed = rand();
- RubiksCube cube = RubiksCube::makeRandomCube(RUBIKS_CUBE_FINISHED, seed);
- cube.goTo(RUBIKS_CUBE_FINISHED);
- bool error = false;
- for (int j = 0; j < TO_VERIFY.size(); j++) {
- if (cube.getPiece(TO_VERIFY[j][0], TO_VERIFY[j][1]) != RUBIKS_CUBE_FINISHED[TO_VERIFY[j][0]][TO_VERIFY[j][1]]) {
- error = true;
- }
- }
- if (!error) {
- rights += 1;
- } else if (debug) {
- std::cout << "FAILURE WITH SEED : " << seed << std::endl;
- }
- if (tests / 100 != 0 && i % (tests/100) == 0) {
- std::cout << i / (tests/100) << "% made" << std::endl;
- }
- }
- double endTime = time(NULL);
- std::cout << std::endl << std::endl;
- std::cout << "\t- Number of tests : " << tests << std::endl;
- std::cout << "\t- " << (((double)rights)/tests) * 100 << "% tests successfull (" << tests - rights << " failed)" << std::endl;
- std::cout << "\t- Execution time : " << endTime - startTime << "s" << std::endl;
- std::cout << "\t- " << (endTime - startTime) / tests << " s/test" << std::endl;
- std::cout << "\t- " << tests / (endTime - startTime) << " tests/s" << std::endl;
- }
- int main() {
- //RubiksCube cube = RubiksCube::makeRandomCube();
- //cube.goTo(RUBIKS_CUBE_FINISHED);
- //std::cout << cube;
- getStats(false);
- return 0;
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement