File Cube.cpp of Package God-Algorithm

Overview Repositories Revisions Requests Users Attributes Meta

File Cube.cpp of Package God-Algorithm

/*
 * 
 * Cube.cpp
 * Author: Brandon Toner
 * Date:   31-10-2011
 * 
 */

#include <iostream>
#include <fstream>
#include "../Cube/Cube.h"

using ::std::ifstream;
using ::std::ofstream;

Cube* Cube::EmptyCube() {
    Cube* outputProgress = new Cube();
    outputProgress->moveCount = 0;
    memset(&outputProgress->top, 1, 9);
    memset(&outputProgress->bottom, 2, 9);
    memset(&outputProgress->left, 3, 9);
    memset(&outputProgress->right, 4, 9);
    memset(&outputProgress->front, 5, 9);
    memset(&outputProgress->back, 6, 9);
    memset(&outputProgress->moves, 0, 30);
    outputProgress->top[9] = 0;
    outputProgress->bottom[9] = 0;
    outputProgress->left[9] = 0;
    outputProgress->right[9] = 0;
    outputProgress->front[9] = 0;
    outputProgress->back[9] = 0;
    return outputProgress;
}

Cube::Cube() { }

Cube::Cube(Cube* toCopy) {
    if (toCopy == NULL)
        throw 20;
    moveCount = toCopy->moveCount;
    memcpy(&moves, &toCopy->moves, 30);
    memcpy(&top, &toCopy->top, 10);
    memcpy(&bottom, &toCopy->bottom, 10);
    memcpy(&left, &toCopy->left, 10);
    memcpy(&right, &toCopy->right, 10);
    memcpy(&front, &toCopy->front, 10);
    memcpy(&back, &toCopy->back, 10);
}

Cube::Cube(char* top, char* bottom, char* left, char* right, char* front,
        char* back, char* moves, int MovesCount) {
    memcpy(&this->top, top, 10);
    memcpy(&this->bottom, bottom, 10);
    memcpy(&this->left, left, 10);
    memcpy(&this->right, right, 10);
    memcpy(&this->front, front, 10);
    memcpy(&this->back, back, 10);
    memcpy(&this->moves, moves, 30);
    this->moveCount = MovesCount;
}

char* Cube::GetSortedFileName() const {
    char* filename = new char[Settings::StringLength];
    char* dir = Settings::GetDir(Sorted);
    snprintf(filename, Settings::StringLength, "%s%c%c%c%c%c.rbx",
            dir, top[0], top[1], top[2], top[3], top[5]);
    delete[] dir;
    return filename;
}

int Cube::CompareTo(Cube* other) const {
    int outputProgress = 0;
    outputProgress = memcmp(&top, &other->top, 9);
    if (outputProgress != 0) return outputProgress;
    outputProgress = memcmp(&bottom, &other->bottom, 9);
    if (outputProgress != 0) return outputProgress;
    outputProgress = memcmp(&left, &other->left, 9);
    if (outputProgress != 0) return outputProgress;
    outputProgress = memcmp(&right, &other->right, 9);
    if (outputProgress != 0) return outputProgress;
    outputProgress = memcmp(&front, &other->front, 9);
    if (outputProgress != 0) return outputProgress;
    outputProgress = memcmp(&back, &other->back, 9);
    if (outputProgress != 0) return outputProgress;
    return 0;
}

char* Cube::Compress(const Cube* input) {
    int i = 0;
    const char* InputData = reinterpret_cast<const char*> (input);
    char* output = new char[48];
    for (int outputPosition = 0; outputPosition < 48; outputPosition++) {
        output[outputPosition] = (InputData[i] << 4) | InputData[i+1];
        i += 2;
        //output[outputPosition] = (InputData[i++] << 4);
        //output[outputPosition] |= InputData[i++];
    }
    return output;
}

Cube* Cube::Decompress(const char* InputData) {
    Cube* output = new Cube();
    char* outputData = reinterpret_cast<char*> (output);
    int outputPosition = 0;
    for (int i = 0; i < 48; i++) {
        outputData[outputPosition++] = (InputData[i] & 0xF0) >> 4;
        outputData[outputPosition++] = InputData[i] & 0x0F;
    }
    return output;
}

bool Cube::CompressAndSerialize(ofstream* output,const Cube* input) {
    char* compressedData = Compress(input);
    output->write(compressedData, 48);
    delete[] compressedData;
    if (output->bad())
        return false;
    return true;
}

Cube* Cube::DecompressAndDeserialize(ifstream* input) {
    char* compressedData = new char[48];
    input->read(compressedData, 48);
    Cube* output = Decompress(compressedData);
    delete[] compressedData;
    if (input->eof() || input->bad() || input->fail()) {
        delete output;
        return NULL;
    }
    return output;
}

bool Cube::Serialize(ofstream* output, const Cube* input) {
    return CompressAndSerialize(output, input);
}

Cube* Cube::Deserialize(ifstream* intput) {
    return DecompressAndDeserialize(intput);
}

const char* ConvertMoveToString(int move) {
    switch (move) {
        case 1:
            return "U";
            break;
        case 2:
            return "Ui";
            break;
        case 3:
            return "F";
            break;
        case 4:
            return "Fi";
            break;
        case 5:
            return "L";
            break;
        case 6:
            return "Li";
            break;
        case 7:
            return "R";
            break;
        case 8:
            return "Ri";
            break;
        case 9:
            return "D";
            break;
        case 10:
            return "Di";
            break;
        case 11:
            return "B";
            break;
        case 12:
            return "Bi";
            break;
    }
    return "";
}

char* Cube::GetMovesString() const {
    char* outputProgress = new char[100];
    memset(outputProgress, 0, 100);
    for (int i = 0; i < moveCount; i++) {
        strcat(outputProgress, ConvertMoveToString(moves[i]));
        strcat(outputProgress, " ");
    }
    return outputProgress;
}

char* Cube::GetReversedMovesString() const {
    char* reversedMoves = GetReversedMoves();
    char* outputProgress = new char[100];
    memset(outputProgress, 0, 100);
    for (int i = 0; i < moveCount; i++) {
        strcat(outputProgress, ConvertMoveToString(reversedMoves[i]));
        strcat(outputProgress, " ");
    }
    return outputProgress;
}

char* Cube::GetReversedMoves() const {
    char* outputProgress = new char[30];
    memset(outputProgress, 0, 30);
    for (int i = moveCount - 1; i >= 0; i--) {
        int move = moves[i];
        int outmove = 0;
        if (move % 2 == 0)
            outmove = move - 1;
        else
            outmove = move + 1;
        outputProgress[moveCount - 1 - i] = outmove;
    }
    return outputProgress;
}

Cube* Cube::DoMove(int moveNumber) const {
    switch (moveNumber) {
        case 1:
            return Up();
        case 2:
            return UpInverted();
        case 3:
            return Front();
        case 4:
            return FrontInverted();
        case 5:
            return Left();
        case 6:
            return LeftInverted();
        case 7:
            return Right();
        case 8:
            return RightInverted();
        case 9:
            return Down();
        case 10:
            return DownInverted();
        case 11:
            return Back();
        case 12:
            return BackInverted();
        default:
            return NULL;
    }
}

void Cube::PossibleMoves(Cube** outputProgress) const {
    for (int i = 0; i < 12; i++)
        outputProgress[i] = this->DoMove(i + 1);
}

Cube* Cube::Up() const {
    Cube* outputProgress = new Cube();
    memset(outputProgress, 0, sizeof(Cube));

outputProgress->moveCount = moveCount + 1;

memcpy(&outputProgress->top, top, 10);
    memcpy(&outputProgress->bottom, bottom, 10);
    memcpy(&outputProgress->left, left, 10);
    memcpy(&outputProgress->right, right, 10);
    memcpy(&outputProgress->front, front, 10);
    memcpy(&outputProgress->back, back, 10);
    memcpy(&outputProgress->moves, moves, 30);

outputProgress->top[0] = top[6];
    outputProgress->top[1] = top[3];
    outputProgress->top[2] = top[0];
    outputProgress->top[5] = top[1];
    outputProgress->top[8] = top[2];
    outputProgress->top[7] = top[5];
    outputProgress->top[6] = top[8];
    outputProgress->top[3] = top[7];

outputProgress->right[0] = back[0];
    outputProgress->right[1] = back[1];
    outputProgress->right[2] = back[2];

outputProgress->front[0] = right[0];
    outputProgress->front[1] = right[1];
    outputProgress->front[2] = right[2];

outputProgress->left[0] = front[0];
    outputProgress->left[1] = front[1];
    outputProgress->left[2] = front[2];

outputProgress->back[0] = left[0];
    outputProgress->back[1] = left[1];
    outputProgress->back[2] = left[2];

outputProgress->moves[moveCount] = 1;

return outputProgress;
}

Cube* Cube::UpInverted() const {
    Cube* outputProgress = new Cube();
    memset(outputProgress, 0, sizeof(Cube));

outputProgress->moveCount = moveCount + 1;

outputProgress->top[0] = top[2];
    outputProgress->top[1] = top[5];
    outputProgress->top[2] = top[8];
    outputProgress->top[5] = top[7];
    outputProgress->top[8] = top[6];
    outputProgress->top[7] = top[3];
    outputProgress->top[6] = top[0];
    outputProgress->top[3] = top[1];

outputProgress->front[0] = left[0];
    outputProgress->front[1] = left[1];
    outputProgress->front[2] = left[2];

outputProgress->left[0] = back[0];
    outputProgress->left[1] = back[1];
    outputProgress->left[2] = back[2];

outputProgress->right[0] = front[0];
    outputProgress->right[1] = front[1];
    outputProgress->right[2] = front[2];

outputProgress->back[0] = right[0];
    outputProgress->back[1] = right[1];
    outputProgress->back[2] = right[2];

outputProgress->moves[moveCount] = 2;

return outputProgress;
}

Cube* Cube::Front() const {
    Cube* outputProgress = new Cube();
    memset(outputProgress, 0, sizeof(Cube));

outputProgress->moveCount = moveCount + 1;

outputProgress->front[2] = front[0];
    outputProgress->front[5] = front[1];
    outputProgress->front[8] = front[2];
    outputProgress->front[7] = front[5];
    outputProgress->front[6] = front[8];
    outputProgress->front[3] = front[7];
    outputProgress->front[0] = front[6];
    outputProgress->front[1] = front[3];

outputProgress->top[6] = left[8];
    outputProgress->top[7] = left[5];
    outputProgress->top[8] = left[2];

outputProgress->left[2] = bottom[0];
    outputProgress->left[5] = bottom[1];
    outputProgress->left[8] = bottom[2];

outputProgress->bottom[0] = right[6];
    outputProgress->bottom[1] = right[3];
    outputProgress->bottom[2] = right[0];

outputProgress->right[6] = top[8];
    outputProgress->right[3] = top[7];
    outputProgress->right[0] = top[6];

outputProgress->moves[moveCount] = 3;

return outputProgress;
}

Cube* Cube::FrontInverted() const {
    Cube* outputProgress = new Cube();
    memset(outputProgress, 0, sizeof(Cube));

outputProgress->moveCount = moveCount + 1;

outputProgress->front[0] = front[2];
    outputProgress->front[1] = front[5];
    outputProgress->front[2] = front[8];
    outputProgress->front[5] = front[7];
    outputProgress->front[8] = front[6];
    outputProgress->front[7] = front[3];
    outputProgress->front[6] = front[0];
    outputProgress->front[3] = front[1];

outputProgress->left[8] = top[6];
    outputProgress->left[5] = top[7];
    outputProgress->left[2] = top[8];

outputProgress->bottom[0] = left[2];
    outputProgress->bottom[1] = left[5];
    outputProgress->bottom[2] = left[8];

outputProgress->right[6] = bottom[0];
    outputProgress->right[3] = bottom[1];
    outputProgress->right[0] = bottom[2];

outputProgress->top[8] = right[6];
    outputProgress->top[7] = right[3];
    outputProgress->top[6] = right[0];

outputProgress->moves[moveCount] = 4;

return outputProgress;
}

Cube* Cube::Left() const {
    Cube* outputProgress = new Cube();
    memset(outputProgress, 0, sizeof(Cube));

outputProgress->moveCount = moveCount + 1;

outputProgress->left[0] = left[6];
    outputProgress->left[1] = left[3];
    outputProgress->left[2] = left[0];
    outputProgress->left[5] = left[1];
    outputProgress->left[8] = left[2];
    outputProgress->left[7] = left[5];
    outputProgress->left[6] = left[8];
    outputProgress->left[3] = left[7];

outputProgress->front[0] = top[0];
    outputProgress->front[3] = top[3];
    outputProgress->front[6] = top[6];

outputProgress->top[0] = back[8];
    outputProgress->top[3] = back[5];
    outputProgress->top[6] = back[2];

outputProgress->back[8] = bottom[0];
    outputProgress->back[5] = bottom[3];
    outputProgress->back[2] = bottom[6];

outputProgress->bottom[0] = front[0];
    outputProgress->bottom[3] = front[3];
    outputProgress->bottom[6] = front[6];

outputProgress->moves[moveCount] = 5;

return outputProgress;
}

Cube* Cube::LeftInverted() const {
    Cube* outputProgress = new Cube();
    memset(outputProgress, 0, sizeof(Cube));

outputProgress->moveCount = moveCount + 1;

outputProgress->left[6] = left[0];
    outputProgress->left[3] = left[1];
    outputProgress->left[0] = left[2];
    outputProgress->left[1] = left[5];
    outputProgress->left[2] = left[8];
    outputProgress->left[5] = left[7];
    outputProgress->left[8] = left[6];
    outputProgress->left[7] = left[3];

outputProgress->top[0] = front[0];
    outputProgress->top[3] = front[3];
    outputProgress->top[6] = front[6];

outputProgress->back[8] = top[0];
    outputProgress->back[5] = top[3];
    outputProgress->back[2] = top[6];

outputProgress->bottom[0] = back[8];
    outputProgress->bottom[3] = back[5];
    outputProgress->bottom[6] = back[2];

outputProgress->front[0] = bottom[0];
    outputProgress->front[3] = bottom[3];
    outputProgress->front[6] = bottom[6];

outputProgress->moves[moveCount] = 6;

return outputProgress;
}

Cube* Cube::Right() const {
    Cube* outputProgress = new Cube();
    memset(outputProgress, 0, sizeof(Cube));

outputProgress->moveCount = moveCount + 1;

outputProgress->right[0] = right[6];
    outputProgress->right[1] = right[3];
    outputProgress->right[2] = right[0];
    outputProgress->right[5] = right[1];
    outputProgress->right[8] = right[2];
    outputProgress->right[7] = right[5];
    outputProgress->right[6] = right[8];
    outputProgress->right[3] = right[7];

outputProgress->top[8] = front[8];
    outputProgress->top[5] = front[5];
    outputProgress->top[2] = front[2];

outputProgress->front[8] = bottom[8];
    outputProgress->front[5] = bottom[5];
    outputProgress->front[2] = bottom[2];

outputProgress->bottom[8] = back[0];
    outputProgress->bottom[5] = back[3];
    outputProgress->bottom[2] = back[6];

outputProgress->back[0] = top[8];
    outputProgress->back[3] = top[5];
    outputProgress->back[6] = top[2];

outputProgress->moves[moveCount] = 7;

return outputProgress;
}

Cube* Cube::RightInverted() const {
    Cube* outputProgress = new Cube();
    memset(outputProgress, 0, sizeof(Cube));

outputProgress->moveCount = moveCount + 1;

outputProgress->right[6] = right[0];
    outputProgress->right[3] = right[1];
    outputProgress->right[0] = right[2];
    outputProgress->right[1] = right[5];
    outputProgress->right[2] = right[8];
    outputProgress->right[5] = right[7];
    outputProgress->right[8] = right[6];
    outputProgress->right[7] = right[3];

outputProgress->bottom[8] = front[8];
    outputProgress->bottom[5] = front[5];
    outputProgress->bottom[2] = front[2];

outputProgress->front[8] = top[8];
    outputProgress->front[5] = top[5];
    outputProgress->front[2] = top[2];

outputProgress->back[0] = bottom[8];
    outputProgress->back[3] = bottom[5];
    outputProgress->back[6] = bottom[2];

outputProgress->top[8] = back[0];
    outputProgress->top[5] = back[3];
    outputProgress->top[2] = back[6];

outputProgress->moves[moveCount] = 8;

return outputProgress;
}

Cube* Cube::Down() const {
    Cube* outputProgress = new Cube();
    memset(outputProgress, 0, sizeof(Cube));

outputProgress->moveCount = moveCount + 1;

outputProgress->bottom[0] = bottom[6];
    outputProgress->bottom[1] = bottom[3];
    outputProgress->bottom[2] = bottom[0];
    outputProgress->bottom[5] = bottom[1];
    outputProgress->bottom[8] = bottom[2];
    outputProgress->bottom[7] = bottom[5];
    outputProgress->bottom[6] = bottom[8];
    outputProgress->bottom[3] = bottom[7];

outputProgress->front[6] = left[6];
    outputProgress->front[7] = left[7];
    outputProgress->front[8] = left[8];

outputProgress->left[6] = back[6];
    outputProgress->left[7] = back[7];
    outputProgress->left[8] = back[8];

outputProgress->back[6] = right[6];
    outputProgress->back[7] = right[7];
    outputProgress->back[8] = right[8];

outputProgress->right[6] = front[6];
    outputProgress->right[7] = front[7];
    outputProgress->right[8] = front[8];

outputProgress->moves[moveCount] = 9;

return outputProgress;
}

Cube* Cube::DownInverted() const {
    Cube* outputProgress = new Cube();
    memset(outputProgress, 0, sizeof(Cube));

outputProgress->moveCount = moveCount + 1;

outputProgress->bottom[6] = bottom[0];
    outputProgress->bottom[3] = bottom[1];
    outputProgress->bottom[0] = bottom[2];
    outputProgress->bottom[1] = bottom[5];
    outputProgress->bottom[2] = bottom[8];
    outputProgress->bottom[5] = bottom[7];
    outputProgress->bottom[8] = bottom[6];
    outputProgress->bottom[7] = bottom[3];

outputProgress->left[6] = front[6];
    outputProgress->left[7] = front[7];
    outputProgress->left[8] = front[8];

outputProgress->back[6] = left[6];
    outputProgress->back[7] = left[7];
    outputProgress->back[8] = left[8];

outputProgress->right[6] = back[6];
    outputProgress->right[7] = back[7];
    outputProgress->right[8] = back[8];

outputProgress->front[6] = right[6];
    outputProgress->front[7] = right[7];
    outputProgress->front[8] = right[8];

outputProgress->moves[moveCount] = 10;

return outputProgress;
}

Cube* Cube::Back() const {
    Cube* outputProgress = new Cube();
    memset(outputProgress, 0, sizeof(Cube));

outputProgress->moveCount = moveCount + 1;

outputProgress->back[0] = back[6];
    outputProgress->back[1] = back[3];
    outputProgress->back[2] = back[0];
    outputProgress->back[5] = back[1];
    outputProgress->back[8] = back[2];
    outputProgress->back[7] = back[5];
    outputProgress->back[6] = back[8];
    outputProgress->back[3] = back[7];

outputProgress->top[0] = right[2];
    outputProgress->top[1] = right[5];
    outputProgress->top[2] = right[8];

outputProgress->right[2] = bottom[8];
    outputProgress->right[5] = bottom[7];
    outputProgress->right[8] = bottom[6];

outputProgress->bottom[8] = left[6];
    outputProgress->bottom[7] = left[3];
    outputProgress->bottom[6] = left[0];

outputProgress->left[6] = top[0];
    outputProgress->left[3] = top[1];
    outputProgress->left[0] = top[2];

outputProgress->moves[moveCount] = 11;

return outputProgress;
}

Cube* Cube::BackInverted() const {
    Cube* outputProgress = new Cube();
    memset(outputProgress, 0, sizeof(Cube));

outputProgress->moveCount = moveCount + 1;

outputProgress->back[6] = back[0];
    outputProgress->back[3] = back[1];
    outputProgress->back[0] = back[2];
    outputProgress->back[1] = back[5];
    outputProgress->back[2] = back[8];
    outputProgress->back[5] = back[7];
    outputProgress->back[8] = back[6];
    outputProgress->back[7] = back[3];

outputProgress->right[2] = top[0];
    outputProgress->right[5] = top[1];
    outputProgress->right[8] = top[2];

outputProgress->bottom[8] = right[2];
    outputProgress->bottom[7] = right[5];
    outputProgress->bottom[6] = right[8];

outputProgress->left[6] = bottom[8];
    outputProgress->left[3] = bottom[7];
    outputProgress->left[0] = bottom[6];

outputProgress->top[0] = left[6];
    outputProgress->top[1] = left[3];
    outputProgress->top[2] = left[0];

outputProgress->moves[moveCount] = 12;

return outputProgress;
}

Places

File Cube.cpp of Package God-Algorithm

Places