// Kostka Rubika na ekranie, wersja 2D :)
// TO DO:
// widok na trzy sciany
// animacja ruchu
// alokacja penow

#include <proto/exec.h>
#include <proto/intuition.h>
#include <proto/graphics.h>
#include <proto/gadtools.h>
#include <proto/dos.h>
#include <proto/icon.h>
#include <proto/diskfont.h>
#include <exec/types.h>
#include <exec/libraries.h>
#include <dos/dos.h>
#include <dos/dostags.h>
#include <intuition/intuition.h>
#include <libraries/gadtools.h>
#include <workbench/startup.h>

#include <stdlib.h>
#include <stdio.h>

#define SCIANA_L 0
#define SCIANA_F 1
#define SCIANA_P 2
#define SCIANA_T 3
#define SCIANA_G 4
#define SCIANA_D 5

#define KOLOR_NI 0
#define KOLOR_CZ 1
#define KOLOR_ZI 2
#define KOLOR_PO 3
#define KOLOR_ZO 4
#define KOLOR_BI 5
#define KOLOR_CR 6

#define KIERUNEK_L 1
#define KIERUNEK_P 2
#define KIERUNEK_G 3
#define KIERUNEK_D 4
#define KIERUNEK_Z 5
#define KIERUNEK_N 6

#define GAD_NXN_ID   10
#define GAD_MIX_ID   11
#define GAD_LOAD_ID  12
#define GAD_SAVE_ID  13
#define GAD_LEFT_ID  14
#define GAD_PAUSE_ID 15

#define L_CLEAR   20
#define L_REFRESH 21

#define RM_LMB  30
#define RM_RMB  31
#define RM_DOWN 32

#define OS_FULL 40
#define OS_COL  41
#define OS_ROW  42

#define OK_FULL  50
#define OK_COL   51
#define OK_ROW_G 52
#define OK_ROW_F 53

FILE *File;

APTR VI;
char Time[10] = {" 0:00:00\0"};

BOOL Quit      = FALSE,
     Mix       = FALSE,
     Pause     = TRUE,
     Solved    = FALSE,
     Zegar_End = FALSE;

char version[]="$VER: A-RubikX 0.2.6 (30.12.2013) by Robert 'Phibrizzo' Krajcarz";
char Czas[3] = {0, 0, 0};

int KLOCEK=3, Licznik=0;
int mouse_xx, mouse_yy, pole_x, pole_y;

char Kostka[6][10][10];
int Sciana[10][10];
int Kolory[7];
char Rekordy[10][3];

struct IntuitionBase *IntuitionBase = NULL;
struct Screen        *Ekran;
struct Window        *Okno;
struct MsgPort       *PortOkna;
struct RastPort      *RastPort;
struct Library       *GadToolsBase = NULL,
                     *DiskfontBase = NULL,
                     *DosBase      = NULL;

struct Process *P_Czas = NULL;
struct Task    *T_MainTask;

struct TextAttr TA_Topaz8  = {"topaz.font",  8, 0, FPF_ROMFONT};
struct TextAttr TA_Times36 = {"Times.font", 36, 0, FPF_DISKFONT};

struct IntuiText IT_Solved = {1, 0, JAM1, 0, 0, &TA_Times36, "You Solved\0", NULL};
struct IntuiText IT_Record = {1, 0, JAM1, 0, 0, &TA_Times36, "New Record\0", NULL};

struct TextFont *TF_Times;

struct Gadget *Gad_First  = NULL,
              *Gad_NxN    = NULL,
              *Gad_Mix    = NULL,
              *Gad_Load   = NULL,
              *Gad_Save   = NULL,
              *Gad_Moves  = NULL,
              *Gad_Pause  = NULL,
              *Gad_Time   = NULL,
              *Gad_Record = NULL;

struct NewGadget NG_NxN    = {510, 200, 80, 17, "Mode", NULL,
                              GAD_NXN_ID, PLACETEXT_ABOVE, NULL, NULL};

struct NewGadget NG_Mix    = {510, 230, 80, 17, "Mix", NULL,
                              GAD_MIX_ID, 0 ,NULL, NULL};

struct NewGadget NG_Load   = {510, 440, 80, 17, "Load", NULL,
                              GAD_LOAD_ID, 0, NULL, NULL};

struct NewGadget NG_Save   = {510, 470, 80, 17, "Save", NULL,
                              GAD_SAVE_ID, 0, NULL, NULL};

struct NewGadget NG_Moves  = {510,  25, 80, 17, "Moves", NULL,
                              0, PLACETEXT_ABOVE, NULL, NULL};

struct NewGadget NG_Time   = {510,  65, 80, 17, "Time", NULL,
                              0, PLACETEXT_ABOVE, NULL, NULL};

struct NewGadget NG_Pause  = {510,  90, 80, 17, "Pause", NULL,
                              GAD_PAUSE_ID, 0 ,NULL, NULL};

struct NewGadget NG_Record = {510, 130, 80, 17, "Record", NULL,
                              0, PLACETEXT_ABOVE, NULL, NULL};

STRPTR Gad_NXN[]={" 2x2 ",
                  " 3x3 ",
                  " 4x4 ",
                  " 5x5 ",
                  " 6x6 ",
                  " 7x7 ",
                  " 8x8 ",
                  " 9x9 ",
                  "10x10",
                  NULL    };

void OtworzBiblioteki(void);
void Koniec(void);
void DekodujIDCMP(struct IntuiMessage *KomIDCMP);
void Wykonaj(UWORD Polecenie);
void TablicaKolorow(void);
void UwolnijKolory(void);
void RuchMyszy(int M_X, int M_Y, int TAG);

void UzupelnijKolory(void);
void ObrocSciane(int SCIANA, int KIERUNEK);
void ObrocPlasterLP(int PLASTER, int KIERUNEK);
void ObrocPlasterGD(int PLASTER, int KIERUNEK);
void ObrocPlasterFT(int PLASTER, int KIERUNEK);
void ObrocKostkePL(int KIERUNEK);
void ObrocKostkeGD(int KIERUNEK);
void ObrocKostkeFT(int KIERUNEK);
void ObrysujKostke2(int TAG, int PLASTER);
void ObrysujScianeG(int TAG, int PLASTER);
void ObrysujScianeF(int TAG, int PLASTER);
void RysujSiatke(void);

void Zapisz(void);
void Wczytaj(void);
void Mieszaj(void);
void LicznikRuchow(int TAG);
void LicznikCzasu(int TAG);
void Zegar(void);
void TestUlozenia(void);
void WczytajRekordy(void);
void ZapiszRekordy(void);
void PokazRekord(void);

int main(void)
{
        struct IntuiMessage *KomIDCMP,KopiaIDCMP;

        OtworzBiblioteki();

        if (!(Ekran = LockPubScreen(NULL)))
        {
                Koniec();
        }

        if (!(VI = GetVisualInfoA(Ekran, NULL)))
        {
                UnlockPubScreen(NULL, Ekran);
                Koniec();
        }

        Okno = OpenWindowTags(NULL,
                              WA_Left, 100,
                              WA_Top, 50,
                              WA_InnerWidth, 600,
                              WA_InnerHeight, 500,
                              WA_ReportMouse, TRUE,
                              WA_MouseQueue, 3,
                              WA_Flags,WFLG_CLOSEGADGET|
                                       WFLG_DRAGBAR|
                                       WFLG_DEPTHGADGET|
                                       WFLG_ACTIVATE|
                                       WFLG_NOCAREREFRESH|
                                       WFLG_SMART_REFRESH|
                                       WFLG_RMBTRAP,
                              WA_IDCMP,BUTTONIDCMP|
                                       IDCMP_CLOSEWINDOW|
                                       IDCMP_GADGETUP|
                                       IDCMP_MOUSEMOVE|
                                       IDCMP_MOUSEBUTTONS,
                              WA_Title, (ULONG)("A-RubiX 0.2.6"),
                              WA_ScreenTitle, (ULONG)("Kostka Rubika na WB"),
                              WA_PubScreenName, NULL,
                              TAG_END);
        if (Okno == NULL)
        {
                puts("Nie mogė otworzyź okna!\n");
                Koniec();
        }

        PortOkna = Okno->UserPort;
        RastPort = Okno->RPort;

        TablicaKolorow();

        UnlockPubScreen(NULL,Ekran);

        CreateContext(&Gad_First);

        NG_NxN.ng_LeftEdge += Okno->BorderLeft;
        NG_NxN.ng_TopEdge  += Okno->BorderTop;
        NG_NxN.ng_TextAttr = &TA_Topaz8;
        NG_NxN.ng_VisualInfo = VI;
        Gad_NxN = CreateGadget(CYCLE_KIND, Gad_First, &NG_NxN,
                               GTCY_Labels, (ULONG)Gad_NXN,
                               GTCY_Active, 1,
                               TAG_END); 

        NG_Mix.ng_LeftEdge += Okno->BorderLeft;
        NG_Mix.ng_TopEdge  += Okno->BorderTop;
        NG_Mix.ng_TextAttr = &TA_Topaz8;
        NG_Mix.ng_VisualInfo = VI;
        Gad_Mix = CreateGadget(BUTTON_KIND, Gad_NxN, &NG_Mix,
                               TAG_END);

        NG_Load.ng_LeftEdge += Okno->BorderLeft;
        NG_Load.ng_TopEdge  += Okno->BorderTop;
        NG_Load.ng_TextAttr = &TA_Topaz8;
        NG_Load.ng_VisualInfo = VI;
        Gad_Load = CreateGadget(BUTTON_KIND, Gad_Mix, &NG_Load,
                                TAG_END);

        NG_Save.ng_LeftEdge += Okno->BorderLeft;
        NG_Save.ng_TopEdge  += Okno->BorderTop;
        NG_Save.ng_TextAttr = &TA_Topaz8;
        NG_Save.ng_VisualInfo = VI;
        Gad_Save = CreateGadget(BUTTON_KIND, Gad_Load, &NG_Save,
                               TAG_END);

        NG_Moves.ng_LeftEdge += Okno->BorderLeft;
        NG_Moves.ng_TopEdge  += Okno->BorderTop;
        NG_Moves.ng_TextAttr = &TA_Topaz8;
        NG_Moves.ng_VisualInfo = VI;
        Gad_Moves = CreateGadget(NUMBER_KIND, Gad_Save, &NG_Moves,
                                 GTNM_Border, TRUE,
                                 GTNM_Justification, GTJ_CENTER,
                                 GTNM_Number, Licznik,
                                 TAG_END);

        NG_Time.ng_LeftEdge += Okno->BorderLeft;
        NG_Time.ng_TopEdge  += Okno->BorderTop;
        NG_Time.ng_TextAttr = &TA_Topaz8;
        NG_Time.ng_VisualInfo = VI;
        Gad_Time = CreateGadget(TEXT_KIND, Gad_Moves, &NG_Time,
                                 GTTX_Border, TRUE,
                                 GTTX_Justification, GTJ_CENTER,
                                 GTTX_Text, (ULONG)Time,
                                 TAG_END);

        NG_Pause.ng_LeftEdge += Okno->BorderLeft;
        NG_Pause.ng_TopEdge  += Okno->BorderTop;
        NG_Pause.ng_TextAttr = &TA_Topaz8;
        NG_Pause.ng_VisualInfo = VI;
        Gad_Pause = CreateGadget(BUTTON_KIND, Gad_Time, &NG_Pause,
                               TAG_END);

        NG_Record.ng_LeftEdge += Okno->BorderLeft;
        NG_Record.ng_TopEdge  += Okno->BorderTop;
        NG_Record.ng_TextAttr = &TA_Topaz8;
        NG_Record.ng_VisualInfo = VI;
        Gad_Record = CreateGadget(TEXT_KIND, Gad_Pause, &NG_Record,
                                  GTTX_Border, TRUE,
                                  GTTX_Justification, GTJ_CENTER,
                                  GTTX_Text, (ULONG)Time,
                                  TAG_END);
        
        if (Gad_Record)
        {
                AddGList(Okno, Gad_First, (UWORD)~0, (UWORD)~0, NULL);
                RefreshGadgets(Gad_First, Okno, NULL);
                GT_RefreshWindow(Okno, NULL);
        }

        SetAPen(RastPort, Kolory[KOLOR_CR]);
        Move(RastPort, Okno->BorderLeft + 500, Okno->BorderTop);
        Draw(RastPort, Okno->BorderLeft + 598, Okno->BorderTop);
        Draw(RastPort, Okno->BorderLeft + 598, Okno->BorderTop + 498);
        Draw(RastPort, Okno->BorderLeft + 500, Okno->BorderTop + 498);
        Draw(RastPort, Okno->BorderLeft + 500, Okno->BorderTop);

        SetAPen(RastPort, Kolory[KOLOR_BI]);
        Move(RastPort, Okno->BorderLeft + 501, Okno->BorderTop + 498);
        Draw(RastPort, Okno->BorderLeft + 501, Okno->BorderTop + 1);
        Draw(RastPort, Okno->BorderLeft + 597, Okno->BorderTop + 1);
        Move(RastPort, Okno->BorderLeft + 599, Okno->BorderTop + 1);
        Draw(RastPort, Okno->BorderLeft + 599, Okno->BorderTop + 499);
        Draw(RastPort, Okno->BorderLeft + 501, Okno->BorderTop + 499);

        WczytajRekordy();
        PokazRekord();
        UzupelnijKolory();
        RysujSiatke();
        ObrysujKostke2(OK_FULL, 0);

        T_MainTask = FindTask(NULL);

        P_Czas = CreateNewProcTags(NP_Entry, (ULONG)&Zegar,
                                   NP_Priority, 0,
                                   NP_Name, (ULONG)"Czas ukladania",
                                   TAG_END);

        while(Quit == FALSE)
        {
                WaitPort(PortOkna);

                while(KomIDCMP = GT_GetIMsg(PortOkna))
                {
                        CopyMem(KomIDCMP, &KopiaIDCMP, sizeof(struct IntuiMessage));
                        GT_ReplyIMsg(KomIDCMP);

                        DekodujIDCMP(&KopiaIDCMP);
                }
        }

        Zegar_End = TRUE;
        Wait(SIGBREAKF_CTRL_C);

//printf("drugi proces zakonczony\n");

        Koniec();
}

void OtworzBiblioteki(void)
{
 IntuitionBase=(struct IntuitionBase *)OpenLibrary("intuition.library",36);
 if(IntuitionBase==NULL)
  {
   puts("Nie mogė otworzyź intuition.library w wersji 36+\n");
   Koniec();
  }
 
 DosBase=OpenLibrary("dos.library",0);
 if(DosBase==NULL)
  {
   puts("Nie mogė otworzyź dos.library\n");
   Koniec();
  }

 GfxBase=(struct GfxBase *)OpenLibrary("graphics.library",0);
 if(GfxBase==NULL)
  {
   puts("Nie mogė otworzyź graphics.library\n");
   Koniec();
  }

 GadToolsBase=OpenLibrary("gadtools.library",36);
 if(GadToolsBase==NULL)
  {
   puts("Nie mogė otworzyź gadtools.library\n");
   Koniec();
  }

 DiskfontBase=OpenLibrary("diskfont.library",0);
 if(DiskfontBase==NULL)
  {
   puts("Nie mogė otworzyź diskfont.library\n");
   Koniec();
  }

 TF_Times = OpenDiskFont(&TA_Times36);
 if(TF_Times == NULL)
  {
   puts("Brak czcionki Times 36\n");
   Koniec();
  }

}

void Koniec(void)
{
        UwolnijKolory();

        if(Okno) CloseWindow(Okno);
        if(Gad_First) FreeGadgets(Gad_First);
        if(VI) FreeVisualInfo(VI);
        if(GfxBase) CloseLibrary((struct Library *)GfxBase);
        if(GadToolsBase) CloseLibrary(GadToolsBase);
        if(TF_Times) CloseFont(TF_Times);
        if(DiskfontBase) CloseLibrary(DiskfontBase);
        if(DosBase) CloseLibrary(DosBase);
        if(IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);

        exit(0);
}

void DekodujIDCMP(struct IntuiMessage *KomIDCMP)
{
        int mouse_x, mouse_y;

        mouse_x = KomIDCMP->MouseX;
        mouse_y = KomIDCMP->MouseY;

//printf("x = %d, y = %d\n", mouse_x, mouse_y);

        switch(KomIDCMP->Class)
        {
                case IDCMP_CLOSEWINDOW:
                        Quit = TRUE;
                        break;

                case MOUSEBUTTONS:
                switch (KomIDCMP->Code)
                {
                        case SELECTDOWN:
                                if(Solved == TRUE)
                                {
                                        RysujSiatke();
                                        ObrysujKostke2(OK_FULL, 0);
                                        Solved = FALSE;
                                }

                                RuchMyszy(mouse_x, mouse_y, RM_DOWN);

                                break;

                        case SELECTUP:
                                if(pole_x < 0 || pole_y < (-KLOCEK + 1) ||
                                   pole_x > (KLOCEK - 1) || pole_y > (KLOCEK - 1))
                                        break;

                                RuchMyszy(mouse_x, mouse_y, RM_LMB);

                                TestUlozenia();
                                       
                                Pause = FALSE;

                                break;

                        case MENUDOWN:
                                if(Solved == TRUE)
                                {
                                        RysujSiatke();
                                        ObrysujKostke2(OK_FULL, 0);
                                        Solved = FALSE;
                                }

                                RuchMyszy(mouse_x, mouse_y, RM_DOWN);

                                break;
                                
                        case MENUUP:
                                RuchMyszy(mouse_x, mouse_y, RM_RMB);

                                Pause = FALSE;

                                break;
                }
                
                case IDCMP_GADGETUP:
                 switch(((struct Gadget *)KomIDCMP->IAddress)->GadgetID)
                 {
                        case GAD_NXN_ID:
                                KLOCEK = (KomIDCMP->Code) + 2;
//printf("typ kostki %dx%d \n", Klocek, Klocek);                              

                                UzupelnijKolory();
                                RysujSiatke();
                                ObrysujKostke2(OK_FULL, 0);
                                PokazRekord();
                                
                                Pause = TRUE;
                                Mix   = FALSE;
                                
                                LicznikRuchow(L_CLEAR);
                                LicznikCzasu(L_CLEAR);
                                break;

                        case GAD_MIX_ID:
                                if(Solved == TRUE)
                                {
                                        RysujSiatke();
                                        
                                        Solved = FALSE;
                                }

                                Mieszaj();
                                ObrysujKostke2(OK_FULL, 0);
                                break;
                         
                        case GAD_LOAD_ID:
                                Wczytaj();
                                
                                // Mix   = TRUE;
                                Pause = TRUE;

                                LicznikRuchow(L_REFRESH);
                                LicznikCzasu(NULL);
                                RysujSiatke();
                                ObrysujKostke2(OK_FULL, 0);
                                break;
                        
                        case GAD_SAVE_ID:
                                Zapisz();
                                break;
                        
                        case GAD_PAUSE_ID:
                                Pause = TRUE;
                                break;
                 }
        }
}

void TablicaKolorow(void)
{
        // kolor niebieski
        Kolory[KOLOR_NI] = ObtainBestPen(Ekran->ViewPort.ColorMap,
                                 0, 0, 255<<24,
                                 OBP_Precision, PRECISION_EXACT,
                                 TAG_DONE);

        // kolor czerwony
        Kolory[KOLOR_CZ] = ObtainBestPen(Ekran->ViewPort.ColorMap,
                                 255<<24, 0, 0,
                                 OBP_Precision, PRECISION_EXACT,
                                 TAG_DONE);

        // kolor zielony
        Kolory[KOLOR_ZI] = ObtainBestPen(Ekran->ViewPort.ColorMap,
                                 0, 255<<24, 0,
                                 OBP_Precision, PRECISION_EXACT,
                                 TAG_DONE);
        // kolor pomaranczowy
        Kolory[KOLOR_PO] = ObtainBestPen(Ekran->ViewPort.ColorMap,
                                 255<<24, 160<<24, 0,
                                 OBP_Precision, PRECISION_EXACT,
                                 TAG_DONE);
        // kolor zolty
        Kolory[KOLOR_ZO] = ObtainBestPen(Ekran->ViewPort.ColorMap,
                                 255<<24, 255<<24, 0,
                                 OBP_Precision, PRECISION_EXACT,
                                 TAG_DONE);
        // kolor bialy
        Kolory[KOLOR_BI] = ObtainBestPen(Ekran->ViewPort.ColorMap,
                                 255<<24, 255<<24, 255<<24,
                                 OBP_Precision, PRECISION_EXACT,
                                 TAG_DONE);
        // kolor czarny
        Kolory[KOLOR_CR] = ObtainBestPen(Ekran->ViewPort.ColorMap,
                                 0, 0, 0,
                                 OBP_Precision, PRECISION_EXACT,
                                 TAG_DONE);
}

void UwolnijKolory(void)
{
        int x;
        
        for(x=0; x<7; x++)
        {
                ReleasePen(Ekran->ViewPort.ColorMap, Kolory[x]);
        }
}

void RuchMyszy(int M_X, int M_Y, int TAG)
{
        int delta_x, delta_y;
        int temp, cons;
        int kierunek = 0;

        temp = M_Y - 235;

        if(TAG == RM_DOWN)
        {
                mouse_xx = M_X;
                mouse_yy = M_Y;
                
                if(temp > 0) cons = 210;
                else         cons = 150;
                
                pole_x = (M_X - 150) / (210  / KLOCEK);
                pole_y = temp        / (cons / KLOCEK);
                
                return;
        }

        delta_x = mouse_xx - M_X;
        delta_y = mouse_yy - M_Y;

        if( abs(delta_x) > abs(delta_y) )
        {
                if(delta_x < 0) kierunek = KIERUNEK_P;
                if(delta_x > 0) kierunek = KIERUNEK_L;

                if(TAG == RM_LMB)
                {
                        if(temp > 0)
                        {
                                ObrocPlasterLP(pole_y, kierunek);
                                ObrysujKostke2(OK_ROW_F, pole_y);
                        }
                        else
                        {
                                ObrocPlasterFT(abs(pole_y), kierunek);
                                ObrysujKostke2(OK_ROW_G, KLOCEK - 1 - abs(pole_y));
                        }
                }
                
                if(TAG == RM_RMB)
                {
                        if(temp > 0)
                        {
                                ObrocKostkePL(kierunek);
                        }
                        else
                        {
                                ObrocKostkeFT(kierunek);
                        }
                        
                        ObrysujKostke2(OK_FULL, 0);    
                }

//printf("x = %d, y = %d, temp = %d\n", pole_x, pole_y, temp);
//printf("Kierunek LP = %d\n", kierunek);
        }
                                
        if( abs(delta_x) < abs(delta_y) )
        {
                if(delta_y < 0) kierunek = KIERUNEK_D;
                if(delta_y > 0) kierunek = KIERUNEK_G;

                if(TAG == RM_LMB)
                {
                        ObrocPlasterGD(pole_x, kierunek);
                        ObrysujKostke2(OK_COL, pole_x);
                }
                
                if(TAG == RM_RMB)
                {
                        ObrocKostkeGD(kierunek);
                        ObrysujKostke2(OK_FULL, 0);
                }

//printf("x = %d, y = %d, temp = %d\n", pole_x, pole_y, temp);
//printf("Kierunek GD = %d\n", kierunek);
        }

        if( delta_x != delta_y )
        {
                LicznikRuchow(NULL);
        }
}

void UzupelnijKolory(void)
{
        int x, y, z;
        
        // uzupelnij tablice kolorami (kostka ulozona)
        
        for(z=0; z<6; z++)
        {
                for(x=0; x<KLOCEK; x++)
                {
                        for(y=0; y<KLOCEK; y++)
                        {
                                Kostka[z][x][y] = z;
                        }
                }
        }

//Kostka[SCIANA_G][0][0] = KOLOR_CR;
//Kostka[SCIANA_G][0][1] = KOLOR_CR;
//Kostka[SCIANA_G][0][2] = KOLOR_CR;
}

void ObrocSciane(int SCIANA, int KIERUNEK)
{
        int x, y;
        
        // obroc scianka zewnetrzna

        if(KIERUNEK == KIERUNEK_Z)
        {
                // obrot zgodny z kierunkiem zegara
                
                for(x=0; x<KLOCEK; x++)
                {
                        for(y=0; y<KLOCEK; y++)
                        {
                                Sciana[x][y] = Kostka[SCIANA][y][KLOCEK - x - 1];
                        }
                }
        }
        else
        {
                // obrot w przeciwna strone zegara

                for(x=0; x<KLOCEK; x++)
                {
                        for(y=0; y<KLOCEK; y++)
                        {
                                Sciana[x][y] = Kostka[SCIANA][KLOCEK - y - 1][x];
                        }
                }
        }
        
        // przepisz obrot
        
        for(x=0; x<KLOCEK; x++)
        {
                for(y=0; y<KLOCEK; y++)
                {
                        Kostka[SCIANA][x][y] = Sciana[x][y];
                }
        }
}

void ObrocPlasterLP(int PLASTER, int KIERUNEK)
{
        int x, d;

        d = KLOCEK - 1;
        
        if(KIERUNEK == KIERUNEK_L)
        {
                for(x=0; x<KLOCEK; x++)
                {
                        Sciana[d-x][PLASTER] = Kostka[SCIANA_L][x][PLASTER];
                }

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_L][x][PLASTER] = Kostka[SCIANA_F][x][PLASTER];
                }

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_F][x][PLASTER] = Kostka[SCIANA_P][x][PLASTER];
                }                

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_P][d-x][PLASTER] = Kostka[SCIANA_T][x][PLASTER];
                }

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_T][x][PLASTER] = Sciana[x][PLASTER];
                }

                if(PLASTER == 0)
                {
                        ObrocSciane(SCIANA_G, KIERUNEK_Z);
                }
                
                if(PLASTER == (KLOCEK - 1))
                {
                        ObrocSciane(SCIANA_D, KIERUNEK_N);
                }
        }
        else
        {
                for(x=0; x<KLOCEK; x++)
                {
                        Sciana[x][PLASTER] = Kostka[SCIANA_L][x][PLASTER];
                }

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_L][d-x][PLASTER] = Kostka[SCIANA_T][x][PLASTER];
                }

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_T][d-x][PLASTER] = Kostka[SCIANA_P][x][PLASTER];
                }                

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_P][x][PLASTER] = Kostka[SCIANA_F][x][PLASTER];
                }

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_F][x][PLASTER] = Sciana[x][PLASTER];
                }

                if(PLASTER == 0)
                {
                        ObrocSciane(SCIANA_G, KIERUNEK_N);
                }
                
                if(PLASTER == (KLOCEK - 1))
                {
                        ObrocSciane(SCIANA_D, KIERUNEK_Z);
                }
        }
}

void ObrocPlasterGD(int PLASTER, int KIERUNEK)
{
        int x, d;
        
        d = KLOCEK - 1;
        
        if(KIERUNEK == KIERUNEK_D)
        {
                for(x=0; x<KLOCEK; x++)
                {
                        Sciana[PLASTER][x] = Kostka[SCIANA_F][PLASTER][x];
                }

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_F][PLASTER][x] = Kostka[SCIANA_G][PLASTER][x];
                }

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_G][PLASTER][d-x] = Kostka[SCIANA_T][PLASTER][x];
                }                

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_T][PLASTER][d-x] = Kostka[SCIANA_D][PLASTER][x];
                }

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_D][PLASTER][x] = Sciana[PLASTER][x];
                }

                if(PLASTER == 0)
                {
                        ObrocSciane(SCIANA_L, KIERUNEK_Z);
                }
                
                if(PLASTER == (KLOCEK - 1))
                {
                        ObrocSciane(SCIANA_P, KIERUNEK_N);
                }
        }
        else
        {
                for(x=0; x<KLOCEK; x++)
                {
                        Sciana[PLASTER][x] = Kostka[SCIANA_F][PLASTER][x];
                }

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_F][PLASTER][x] = Kostka[SCIANA_D][PLASTER][x];
                }

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_D][PLASTER][d-x] = Kostka[SCIANA_T][PLASTER][x];
                }                

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_T][PLASTER][d-x] = Kostka[SCIANA_G][PLASTER][x];
                }

                for(x=0; x<KLOCEK; x++)
                {
                        Kostka[SCIANA_G][PLASTER][x] = Sciana[PLASTER][x];
                }

                if(PLASTER == 0)
                {
                        ObrocSciane(SCIANA_L, KIERUNEK_N);
                }
                
                if(PLASTER == (KLOCEK - 1))
                {
                        ObrocSciane(SCIANA_P, KIERUNEK_Z);
                }
        }        
}

void ObrocPlasterFT(int PLASTER, int KIERUNEK)
{
        ObrocKostkePL(KIERUNEK_L);

        if(KIERUNEK == KIERUNEK_P)
        {
                ObrocPlasterGD(PLASTER, KIERUNEK_D);
        }
        else
        {
                ObrocPlasterGD(PLASTER, KIERUNEK_G);
        }

        ObrocKostkePL(KIERUNEK_P);
}

void ObrocKostkePL(int KIERUNEK)
{
        int x;
                
        for(x=0; x<KLOCEK; x++)
        {
                ObrocPlasterLP(x, KIERUNEK);
        }
}

void ObrocKostkeGD(int KIERUNEK)
{
        int x;
        
        for(x=0; x<KLOCEK; x++)
        {
                ObrocPlasterGD(x, KIERUNEK);
        }
}

void ObrocKostkeFT(int KIERUNEK)
{
        ObrocKostkeGD(KIERUNEK_D);

        if(KIERUNEK == KIERUNEK_L)
        {
                ObrocKostkePL(KIERUNEK_L);
        }
        else
        {
                ObrocKostkePL(KIERUNEK_P);
        }        

        ObrocKostkeGD(KIERUNEK_G);
}

void ObrysujScianeG(int TAG, int PLASTER)
{
        int x, y, x_s, x_e, y_s, y_e, bok_x, bok_y;
        int skok1_x, skok2_y;
        double skok1, skok2; 

        skok1 = 210.0f / (double)(KLOCEK);
        skok2 = 150.0f / (double)(KLOCEK);

        bok_x = (int)(skok1 - 8.0f);
        bok_y = (int)(skok2 - 8.0f);

        x_s = 0;
        x_e = KLOCEK;
                
        y_s = 0;
        y_e = KLOCEK;

        if(TAG == OS_COL)
        {
                x_s = PLASTER;
                x_e = PLASTER + 1;
        }

        if(TAG == OS_ROW)
        {
                y_s = PLASTER;
                y_e = PLASTER + 1;
        }

        for(x=x_s; x<x_e; x++)
        {
                skok1_x = (int)((double)(x) * skok1);
                
                for(y=y_s; y<y_e; y++)
                {
                        skok2_y = (int)((double)(y) * skok2);

                        SetAPen(RastPort, Kolory[Kostka[SCIANA_G][x][y]]);

                        RectFill(RastPort,
                                 Okno->BorderLeft + 148 + skok1_x,
                                 Okno->BorderTop  +  73 + skok2_y,
                                 Okno->BorderLeft + 150 + skok1_x + bok_x,
                                 Okno->BorderTop  +  75 + skok2_y + bok_y);
                }
        }
}

void ObrysujScianeF(int TAG, int PLASTER)
{
        int x, y, x_s, x_e, y_s, y_e, bok_x;
        int skok1_x, skok1_y;
        double skok1; 

        skok1 = 210.0f / (double)(KLOCEK);

        bok_x = (int)(skok1 - 8.0f);

        x_s = 0;
        x_e = KLOCEK;
                
        y_s = 0;
        y_e = KLOCEK;

        if(TAG == OS_COL)
        {
                x_s = PLASTER;
                x_e = PLASTER + 1;
        }

        if(TAG == OS_ROW)
        {
                y_s = PLASTER;
                y_e = PLASTER + 1;
        }

        for(x=x_s; x<x_e; x++)
        {
                skok1_x = (int)((double)(x) * skok1);
                
                for(y=y_s; y<y_e; y++)
                {
                        skok1_y = (int)((double)(y) * skok1);
                        
                        SetAPen(RastPort, Kolory[Kostka[SCIANA_F][x][y]]);

                        RectFill(RastPort,
                                 Okno->BorderLeft + 148 + skok1_x,
                                 Okno->BorderTop  + 223 + skok1_y,
                                 Okno->BorderLeft + 150 + skok1_x + bok_x,
                                 Okno->BorderTop  + 225 + skok1_y + bok_x);
                }
        }
}

void ObrysujKostke2(int TAG, int PLASTER)
{
        if(TAG == OK_FULL)
        {
                ObrysujScianeG(OS_FULL, 0);
                ObrysujScianeF(OS_FULL, 0);
                
                return;
        }
        
        if(TAG == OK_COL)
        {
                ObrysujScianeG(OS_COL, PLASTER);
                ObrysujScianeF(OS_COL, PLASTER);
                
                return;
        }
        
        if(TAG == OK_ROW_G)
        {
                ObrysujScianeG(OS_ROW, PLASTER);

                if(PLASTER == KLOCEK - 1)
                {
                        ObrysujScianeF(OS_FULL, 0);
                }
                
                return;
        }

        if(TAG == OK_ROW_F)
        {
                ObrysujScianeF(OS_ROW, PLASTER);

                if(PLASTER == 0)
                {
                        ObrysujScianeG(OS_FULL, 0);
                }
        }
}

void RysujSiatke(void)
{
        double x, stala=210.0f, skok;

        // rysuj siatke

        SetAPen(RastPort, 0);
        RectFill(RastPort,
                 Okno->BorderLeft + 50,
                 Okno->BorderTop  + 10,
                 Okno->BorderLeft + 449,
                 Okno->BorderTop  + 449);

        SetAPen(RastPort, Kolory[KOLOR_BI]);

        skok = stala / (double)(KLOCEK);

        for(x=0; x<stala + 1.0f; x = x + skok)
        {
                Move(RastPort,
                     Okno->BorderLeft+50 +  95,
                     Okno->BorderTop+50  + 170 + (int)(x));

                Draw(RastPort,
                     Okno->BorderLeft+50 + 305,
                     Okno->BorderTop+50  + 170 + (int)(x));

                Move(RastPort,
                     Okno->BorderLeft+50 +  95 + (int)(x),
                     Okno->BorderTop+50  + 20);

                Draw(RastPort,
                     Okno->BorderLeft+50 + 95 + (int)(x),
                     Okno->BorderTop+50  + 170 + 210);
        }

        skok = 150.0f / (double)(KLOCEK);

        for(x=0; x<150.0f; x = x + skok)
        {
                Move(RastPort,
                     Okno->BorderLeft+50 + 95,
                     Okno->BorderTop+50  + 20 + (int)(x));

                Draw(RastPort,
                     Okno->BorderLeft+50 + 305,
                     Okno->BorderTop+50  +  20 + (int)(x));
        }

        Move(RastPort, Okno->BorderLeft+50 + 94,  Okno->BorderTop+50 + 19);
        Draw(RastPort, Okno->BorderLeft+50 + 306, Okno->BorderTop+50 + 19);
        Draw(RastPort, Okno->BorderLeft+50 + 306, Okno->BorderTop+50 + 171 +210);
        Draw(RastPort, Okno->BorderLeft+50 + 94,  Okno->BorderTop+50 + 171 + 210);
        Draw(RastPort, Okno->BorderLeft+50 + 94,  Okno->BorderTop+50 + 19);

        Move(RastPort, Okno->BorderLeft+50 + 95,  Okno->BorderTop+50 + 169);
        Draw(RastPort, Okno->BorderLeft+50 + 305, Okno->BorderTop+50 + 169);
}

void Zapisz(void)
{
        char name[20];

        sprintf(name, "progdir:Kostka%d.sav", KLOCEK - 1);

        if(File = fopen(name, "wb"))
        {
                fprintf(File,"%d\n", Licznik);
                fprintf(File,"%c\n", Mix);

                fwrite(Czas  , sizeof(Czas)  , 1, File);
                fwrite(Kostka, sizeof(Kostka), 1, File);

                fclose(File);
        }
        else
        {
                puts("Nie moge zapisac stanu gry\n");
        }
}

void Wczytaj(void)
{
        char text[10], name[20];

        sprintf(name, "progdir:Kostka%d.sav", KLOCEK - 1);

        if(File = fopen(name, "rb"))
        {
                fgets(text, 10, File);
                Licznik = atol(text);

                fgets(text, 10, File);
                Mix = (BOOL)(text[0]);

                fread(Czas  , sizeof(Czas)  , 1, File);
                fread(Kostka, sizeof(Kostka), 1, File);
                
                fclose(File);
        }
}

void Mieszaj(void)
{
        char plaster, funkcja;
        int x;

        for(x=0; x<KLOCEK * 20; x++)
        {
                plaster = (char)(((rand()%33)^rand())%KLOCEK);
                funkcja = (char)(((rand()%33)^rand())%6);
                
                if(funkcja == 0) ObrocPlasterFT(plaster, KIERUNEK_L);
                if(funkcja == 1) ObrocPlasterFT(plaster, KIERUNEK_P);
                
                if(funkcja == 2) ObrocPlasterLP(plaster, KIERUNEK_L);
                if(funkcja == 3) ObrocPlasterLP(plaster, KIERUNEK_P);
                
                if(funkcja == 4) ObrocPlasterGD(plaster, KIERUNEK_G);
                if(funkcja == 5) ObrocPlasterGD(plaster, KIERUNEK_D);
                
//printf("plaster nr = %d, funkcja = %d\n", plaster, funkcja);
        }

        LicznikRuchow(L_CLEAR);
        LicznikCzasu(L_CLEAR);

        Mix    = TRUE;
        Solved = FALSE;
        Pause  = TRUE;
}

void LicznikRuchow(int TAG)
{
        if(TAG == L_CLEAR)
        {
                Licznik = 0;
        }
        
        if(Mix == TRUE && TAG == NULL)
        {
                Licznik++;
        }

        GT_SetGadgetAttrs(Gad_Moves, Okno, NULL,
                          GTNM_Number, Licznik,
                          TAG_END);
}

void LicznikCzasu(int TAG)
{
        if(TAG == L_CLEAR)
        {
                Czas[0] = 0;
                Czas[1] = 0;
                Czas[2] = 0;
        }

        sprintf(Time,"%2d:%02d:%02d\0", Czas[2], Czas[1], Czas[0]);

        GT_SetGadgetAttrs(Gad_Time, Okno, NULL,
                          GTTX_Text, (ULONG)Time,
                          TAG_END);
}

void Zegar(void)
{
        int r1, r2, pen;

        while(Zegar_End == FALSE)
        {
                if(Pause == FALSE && Mix == TRUE)
                {
                        Czas[0]++;
                        if(Czas[0] > 59)
                        {
                                Czas[0] = 0;
                                Czas[1]++;
                        }
        
                        if(Czas[1] > 59)
                        {
                                Czas[1] = 0;
                                Czas[2]++;
                        }
        
                        r1 = (Rekordy[KLOCEK - 2][2]<<14) | (Rekordy[KLOCEK - 2][1]<<7) | Rekordy[KLOCEK - 2][0];
                        r2 = (Czas[2]<<14) | (Czas[1]<<7) | Czas[0];

                        pen = 1;

                        if(r2 < r1)
                        {
                                pen = 2;
                        }

                        sprintf(Time, "%2d:%02d:%02d\0", Czas[2], Czas[1], Czas[0]);

                        GT_SetGadgetAttrs(Gad_Time, Okno, NULL,
                                          GTTX_Text, (ULONG)Time,
                                          GTTX_FrontPen, pen,
                                          TAG_END);        
                }

                Delay(50);
        }
        
        Forbid();
        Signal(T_MainTask, SIGBREAKF_CTRL_C);
        Permit();
}

void TestUlozenia(void)
{
        int sciana, t, x, y, r1, r2, poz_x=170;

//        PrintIText(RastPort,
//                   &IT_Solved,
//                   Okno->BorderLeft + 70,
//                   Okno->BorderTop  + 20);

//        PrintIText(RastPort,
//                   &IT_Record,
//                   Okno->BorderLeft + 265,
//                   Okno->BorderTop  +  20);

        if(Mix == FALSE) return;
        
        for(sciana=0; sciana<5; sciana++)
        {
                t = Kostka[sciana][0][0];
                
                for(x=0; x<KLOCEK; x++)
                {
                        for(y=0; y<KLOCEK; y++)
                        {
                                if(t != Kostka[sciana][x][y]) return;
                        }
                }
        }

        Mix    = FALSE;
        Solved = TRUE;
        Pause  = TRUE;

        r1 = (Rekordy[KLOCEK - 2][2]<<14) | (Rekordy[KLOCEK - 2][1]<<7) | Rekordy[KLOCEK - 2][0];
        r2 = (Czas[2]<<14) | (Czas[1]<<7) | Czas[0];

        if(r2 < r1)
        {
                Rekordy[KLOCEK - 2][0] = Czas[0];
                Rekordy[KLOCEK - 2][1] = Czas[1];
                Rekordy[KLOCEK - 2][2] = Czas[2]; 

                PokazRekord();
                ZapiszRekordy();
        
                poz_x = 70;

                PrintIText(RastPort,
                           &IT_Record,
                           Okno->BorderLeft + 265,
                           Okno->BorderTop  +  20);
        }

        PrintIText(RastPort,
                   &IT_Solved,
                   Okno->BorderLeft + poz_x,
                   Okno->BorderTop  + 20);

}

void WczytajRekordy(void)
{
        int x;
        
        if(File = fopen("progdir:Kostka.rec", "rb"))
        {
                fread(Rekordy, sizeof(Rekordy), 1, File);

                fclose(File);
        }
        else
        {
                for(x=0; x<10; x++)
                {
                        Rekordy[x][0] = 59;
                        Rekordy[x][1] = 59;
                        Rekordy[x][2] = 99;
                }
        }
}

void ZapiszRekordy(void)
{
        if(File = fopen("progdir:Kostka.rec", "wb"))
        {
                fwrite(Rekordy, sizeof(Rekordy), 1, File);

                fclose(File);
        }
        else
        {
                puts("Nie moge zapisac rekordow\n");
        }
}

void PokazRekord(void)
{
        sprintf(Time, "%2d:%02d:%02d\0", Rekordy[KLOCEK - 2][2], Rekordy[KLOCEK - 2][1], Rekordy[KLOCEK - 2][0]);

        GT_SetGadgetAttrs(Gad_Record, Okno, NULL,
                          GTTX_Text, (ULONG)Time,
                          TAG_END);
}