/* -*- c++ -*-
FILE: Puzzlest.cpp
RCS REVISION: $Revision: 1.13 $

COPYRIGHT: (c) 1999 -- 2003 Melinda Green, Don Hatch, and Jay Berkenbilt - Superliminal Software

LICENSE: Free to use and modify for non-commercial purposes as long as the
    following conditions are adhered to:
    1) Obvious credit for the source of this code and the designs it embodies
       are clearly made, and
    2) Ports and derived versions of 4D Magic Cube programs are not distributed
       without the express written permission of the authors.

DESCRIPTION:
    Implementation of PuzzleState class
*/

#include "Puzzlest.h"

#include "Polymgr.h"
#include "Math4d.h"
#include "Preferences.h"



PuzzleState::PuzzleState(Preferences& p, PolygonManager4D *polymgr) :
    preferences(p)
{
    m_polymgr = polymgr;
    reset(p.getLength());
}

/*
 * Set the puzzle to the pristine state
 */
void PuzzleState::reset(int new_length)
{
    if (new_length != -1)
    {
        this->length = new_length;
        nstickers = NFACES * length * length * length;
    }
    int i, nstickersperface = length * length * length;
    for(i=0; i<nstickers; ++i)
        the_state[i] = i / nstickersperface;
}

int PuzzleState::isSolved()
{
    int i, nstickersperface = length * length * length;
    for(i=0; i<nstickers; ++i)
        if(the_state[i] !=
            the_state[i / nstickersperface * nstickersperface])
            return 0;
    return 1;
}

int PuzzleState::idToColor(int id)
{
    return the_state[id];
}

void PuzzleState::applyMove(struct stickerspec *grip, int dir, int slicesmask)
{
    int         i, j;
    int         dest[MAXSTICKERS];
    int         nranges, ranges[MAXLENGTH][2];
    int         mat[4][4];
    int         sgn, whichax;

    /*============= this is verbatim from polymgr.c =========*/
    /*====== FIX THIS === it's a ridiculous hack =============*/
    // It just got even more ridiculous getting it to compile -- DG
    {
        real        center[4], real_stickercoords[4], realmat[4][4];
        real        total_angle;

        /*
         * Note: due to run-time errors, I changed the ternary initialization
         * of total_angle into a switch statement below. - DG
         */
        switch (grip->dim)
        {
        case 0:
            total_angle = 2 * PI / 3 * dir;
            break;
        case 1:
            total_angle = 2 * PI / 2 * dir;
            break;
        case 2:
            total_angle = 2 * PI / 4 * dir;
            break;
        default:
            abort();
        }
        /*
         * Calculate rotation center; it's the center of the face containing
         * the grip
         */
        whichax = -1;
        for (i = 0; i < NDIMS; ++i)
        {
            if (ABS(grip->coords[i]) == 3)
            {
                center[i] = grip->coords[i];
                whichax = i;
            }
            else
                center[i] = 0;
        }
        assert(INRANGE(0 <=, whichax, <NDIMS));

        SET4(real_stickercoords, grip->coords);

        Math4d::get4dRotMatrix(center, real_stickercoords,
                               total_angle, realmat);
        for (i = 0; i < 4; ++i)
            for (j = 0; j < 4; ++j)
            {
                mat[i][j] = ROUND(realmat[i][j]);
                assert(ABS(realmat[i][j] - mat[i][j]) < .0001);
            }
        sgn = SGN(center[whichax]);
        nranges = m_polymgr->makeRangesInt(slicesmask, whichax, sgn, ranges);
    }
    /*=========================================================*/

    for (i = 0; i < nstickers; ++i)
    {
        struct stickerspec tempsticker;
        tempsticker.id_within_cube = i;
        m_polymgr->fillStickerspecFromId(&tempsticker);
        for (j = 0; j < nranges; ++j)
        {
            if (INRANGE(ranges[j][0] <=, tempsticker.coords[whichax],
                        <=ranges[j][1]))
            {
                VXM4i(tempsticker.coords, tempsticker.coords, mat);
                m_polymgr->fillStickerspecFromCoords(&tempsticker);
                assert(INRANGE(0 <=, tempsticker.id_within_cube, <nstickers));
                dest[tempsticker.id_within_cube] = the_state[i];
                break;
            }
        }
        if (j == nranges)       /* it didn't fall in any of the ranges */
            dest[i] = the_state[i];
    }


    for (i = 0; i < nstickers; ++i)
        the_state[i] = dest[i];
}


void PuzzleState::dump(FILE *fp)
{
    int i, nstickersperface = length * length * length;
    for (i=0; i<nstickers; ++i)
    {
        fprintf(fp, "%d", the_state[i]);
        if ((i + 1) % nstickersperface == 0)
            fprintf(fp, "\n");
    }
}

int PuzzleState::isSane(int state[MAXSTICKERS])
{
    int         i, counts[NFACES];

    for (i = 0; i < NFACES; ++i)
        counts[i] = 0;
    for (i = 0; i < nstickers; ++i)
        counts[state[i]]++;
    for (i = 0; i < NFACES; ++i)
        if (counts[i] != length * length * length)
            return 0;
    return 1;
}

/*
 * Return 1 on success, 0 on error.
 * FIX THIS-- decide whether we want to also print an error message.
 */
int PuzzleState::read(FILE *fp)
{
    int         i;
    int         temp_state[MAXSTICKERS];

    for (i = 0; i < nstickers; ++i)
    {
        if (fscanf(fp, "%1d", &temp_state[i]) != 1)
            return 0;
    }

    if (!isSane(temp_state))
    {
        /* fprintf(stderr, "That puzzle state was insane!\n"); */
        return 0;
    }
    else
    {
        for (i = 0; i < nstickers; ++i)
            the_state[i] = temp_state[i];
        return 1;
    }
}

// Local Variables:
// c-basic-offset: 4
// c-comment-only-line-offset: 0
// c-file-offsets: ((defun-block-intro . +) (block-open . 0) (substatement-open . 0) (statement-cont . +) (statement-case-open . +4) (arglist-intro . +) (arglist-close . +) (inline-open . 0))
// indent-tabs-mode: nil
// End: