Составить алгоритм игры нахождения одинаковых соседних картинок

void __fastcall TGlav_Form::panelimageclick(TObject *Sender)
{
    if (!picturedown) {
        picturedown = true;
        picturecaption = ((TPanel*)Sender)->Caption;
        picturetag = ((TPanel*)Sender)->Tag;
        picturetop_ = ((TPanel*)Sender)->Top;
        pictureleft_ = ((TPanel*)Sender)->Left;
    }
    else {
        picturedown = false;
        String picturecaption_ = ((TPanel*)Sender)->Caption;
        int picturetag_ = ((TPanel*)Sender)->Tag;
        if ((picturecaption_ == picturecaption) && (picturetag_ != picturetag)){
            //-------------Обработка события нажатия-------------------------
            int picturetop_1 = ((TPanel*)Sender)->Top;
            int pictureleft_1 = ((TPanel*)Sender)->Left;
 
            int oldrow = picturetop_ / 60;
            int oldcolumn = (pictureleft_ - 5) / 60 + 1;
 
            int newrow = picturetop_1 / 60;
            int newcolumn = (pictureleft_1 - 5) / 60 + 1;
 
            if (((newrow == 1) && (oldrow == 1)) || ((newcolumn == 1) && (oldcolumn == 1)) ||
                ((newrow == 7) && (oldrow == 7)) || ((newcolumn == 12) && (oldcolumn == 12))) {
 
                if ((newrow == oldrow) || (newcolumn == oldcolumn)){
                    for(int p = 0; p < ControlCount; p++) {
                        Application->ProcessMessages();
                        if (Controls[p]->Tag == picturetag) {
                            delete Controls[p];
                            break;
                        }
                    }
                    for(int q = 0; q < ControlCount; q++) {
                        Application->ProcessMessages();
                        if (Controls[q]->Tag == picturetag_) {
                            delete Controls[q];
                            break;
                        }
                    }
                    matrix_x [newcolumn] [newrow] = 0;
                    matrix_x [oldcolumn] [oldrow] = 0;
                }
            }
            else {
                bool topgo = false;
                bool bottomgo = false;
                bool leftgo = false;
                bool rightgo = false;
                //Фишка вторая ниже первой
                if (newrow > oldrow) {
                    //Ряд фишек совпадает
                    if (newcolumn == oldcolumn) {
                        int raznistrok = newrow - oldrow;
                        if (raznistrok == 1) {
                            for(int p = 0; p < ControlCount; p++) {
                                Application->ProcessMessages();
                                if (Controls[p]->Tag == picturetag) {
                                    delete Controls[p];
                                    break;
                                }
                            }
                            for(int q = 0; q < ControlCount; q++) {
                                Application->ProcessMessages();
                                if (Controls[q]->Tag == picturetag_) {
                                    delete Controls[q];
                                    break;
                                }
                            }
                            matrix_x [newcolumn] [newrow] = 0;
                            matrix_x [oldcolumn] [oldrow] = 0;
                        }
                        else {
                            for (int i = oldrow + 1; i < newrow; i++) {
                                Application->ProcessMessages();
                                if (matrix_x [newcolumn] [i] != 0) {
                                    bottomgo = false;
                                    break;
                                }
                                else bottomgo = true;
                            }
                            if (bottomgo) {
                                for(int p = 0; p < ControlCount; p++) {
                                    Application->ProcessMessages();
                                    if (Controls[p]->Tag == picturetag) {
                                        delete Controls[p];
                                        break;
                                    }
                                }
                                for(int q = 0; q < ControlCount; q++) {
                                    Application->ProcessMessages();
                                    if (Controls[q]->Tag == picturetag_) {
                                        delete Controls[q];
                                        break;
                                    }
                                }
                                matrix_x [newcolumn] [newrow] = 0;
                                matrix_x [oldcolumn] [oldrow] = 0;
                            }
                        }
                    }
                    else
                    //Фишка вторая левее первой
                    if (newcolumn < oldcolumn) {
                        for (int i = newrow; i < oldrow; i++) {
                            Application->ProcessMessages();
 
                        }
                    }
                    else
                    //Фишка вторая правее первой
                    if (newcolumn > oldcolumn) {
 
                    }
                }
                else
                //Фишка вторая выше первой
                if (newrow < oldrow) {
                    int raznistrok;
                    //Ряд фишек совпадает
                    if (newcolumn == oldcolumn) {
                        int raznistrok = oldrow - newrow;
                        if (raznistrok == 1) {
                            for(int p = 0; p < ControlCount; p++) {
                                Application->ProcessMessages();
                                if (Controls[p]->Tag == picturetag) {
                                    delete Controls[p];
                                    break;
                                }
                            }
                            for(int q = 0; q < ControlCount; q++) {
                                Application->ProcessMessages();
                                if (Controls[q]->Tag == picturetag_) {
                                    delete Controls[q];
                                    break;
                                }
                            }
                            matrix_x [newcolumn] [newrow] = 0;
                            matrix_x [oldcolumn] [oldrow] = 0;
                        }
                        else {
                            for (int i = newrow + 1; i < oldrow; i++) {
                                Application->ProcessMessages();
                                if (matrix_x [newcolumn] [i] != 0) {
                                    bottomgo = false;
                                    break;
                                }
                                else bottomgo = true;
                            }
                            if (bottomgo) {
                                for(int p = 0; p < ControlCount; p++) {
                                    Application->ProcessMessages();
                                    if (Controls[p]->Tag == picturetag) {
                                        delete Controls[p];
                                        break;
                                    }
                                }
                                for(int q = 0; q < ControlCount; q++) {
                                    Application->ProcessMessages();
                                    if (Controls[q]->Tag == picturetag_) {
                                        delete Controls[q];
                                        break;
                                    }
                                }
                                matrix_x [newcolumn] [newrow] = 0;
                                matrix_x [oldcolumn] [oldrow] = 0;
                            }
                        }
                    }
                }
                else
                if (newrow == oldrow) {//Фишка на уровне первой
                    //Фишка вторая левее первой
                    if (newcolumn < oldcolumn) {
                        int raznicolumn = oldcolumn - newcolumn;
                        if (raznicolumn == 1) {
                            for(int p = 0; p < ControlCount; p++) {
                                Application->ProcessMessages();
                                if (Controls[p]->Tag == picturetag) {
                                    delete Controls[p];
                                    break;
                                }
                            }
                            for(int q = 0; q < ControlCount; q++) {
                                Application->ProcessMessages();
                                if (Controls[q]->Tag == picturetag_) {
                                    delete Controls[q];
                                    break;
                                }
                            }
                            matrix_x [newcolumn] [newrow] = 0;
                            matrix_x [oldcolumn] [oldrow] = 0;
                        }
                        else {
                            for (int i = newcolumn + 1; i < oldcolumn; i++) {
                                Application->ProcessMessages();
                                if (matrix_x [i] [newrow] != 0) {
                                    rightgo = false;
                                    break;
                                }
                                else rightgo = true;
                            }
                            if (rightgo) {
                                for(int p = 0; p < ControlCount; p++) {
                                    Application->ProcessMessages();
                                    if (Controls[p]->Tag == picturetag) {
                                        delete Controls[p];
                                        break;
                                    }
                                }
                                for(int q = 0; q < ControlCount; q++) {
                                    Application->ProcessMessages();
                                    if (Controls[q]->Tag == picturetag_) {
                                        delete Controls[q];
                                        break;
                                    }
                                }
                                matrix_x [newcolumn] [newrow] = 0;
                                matrix_x [oldcolumn] [oldrow] = 0;
                            }
                        }
                    }
                    else
                    //Фишка вторая правее первой
                    if (newcolumn > oldcolumn) {
                        int raznicolumn = newcolumn - oldcolumn;
                        if (raznicolumn == 1) {
                            for(int p = 0; p < ControlCount; p++) {
                                Application->ProcessMessages();
                                if (Controls[p]->Tag == picturetag) {
                                    delete Controls[p];
                                    break;
                                }
                            }
                            for(int q = 0; q < ControlCount; q++) {
                                Application->ProcessMessages();
                                if (Controls[q]->Tag == picturetag_) {
                                    delete Controls[q];
                                    break;
                                }
                            }
                            matrix_x [newcolumn] [newrow] = 0;
                            matrix_x [oldcolumn] [oldrow] = 0;
                        }
                        else {
                            for (int i = oldcolumn + 1; i < newcolumn; i++) {
                                Application->ProcessMessages();
                                if (matrix_x [i] [newrow] != 0) {
                                    leftgo = false;
                                    break;
                                }
                                else leftgo = true;
                            }
                            if (leftgo) {
                                for(int p = 0; p < ControlCount; p++) {
                                    Application->ProcessMessages();
                                    if (Controls[p]->Tag == picturetag) {
                                        delete Controls[p];
                                        break;
                                    }
                                }
                                for(int q = 0; q < ControlCount; q++) {
                                    Application->ProcessMessages();
                                    if (Controls[q]->Tag == picturetag_) {
                                        delete Controls[q];
                                        break;
                                    }
                                }
                                matrix_x [newcolumn] [newrow] = 0;
                                matrix_x [oldcolumn] [oldrow] = 0;
                            }
                        }
                    }
                }
            }
            //---------------------------------------------------------------
        }
    }
}

// создаем массив указателей
TImage **img = new TImage*[5];
short int test=0;
const int size = 64;
int tagn, tago;
 
//---------------------------------------------------------------------------
void __fastcall TForm2::ImgClick(TObject *Sender)
{
 test++;
 //Получаме тег выбранного изображения для индетификации
 tago = ((TImage*)Sender)->Tag;
 if (test == 2) {
   tago = 0;
   tagn = 0;
   test = 0;
 if (tago == tagn) {
   ShowMessage("Выбрано два одинаковых изображения!");
 }
 else
 {
  ShowMessage("Выбранные изображения не совпадают!");
 }
 }
else
 {
  tagn = ((TImage*)Sender)->Tag;
 }
}
 
void __fastcall TForm2::FormShow(TObject *Sender)
{
randomize();
// создаем объект присваеваем каждой ячейки массива адресс созданного изображения
for (int i=0; i<5; i++)
{
 img[i] = new TImage(Form2);
 img[i]->Parent = Form2;
 int name = rand() % 9 + 1;
 //Задаем тег изображения
 img[i]->Tag=name;
 img[i]->Left = i*size;
 img[i]->Top = 0;
 img[i]->AutoSize = true;
 //Тут я рандомно загружаю изображения(цифры от 1 до 9)
 img[i]->Picture->LoadFromFile( ExtractFilePath( Application->ExeName ) + "img\\"+IntToStr(name)+".bmp");
 img[i]->OnClick = ImgClick;
}
}
//---------------------------------------------------------------------------
 
 
void __fastcall TForm2::FormDestroy(TObject *Sender)
{
delete[] img;
}
//---------------------------------------------------------------------------

class gPicture
{
    private:
        String Name;
        String m;
    public:
        void Show();
        void Hide();
        void Move();
        void PicturePatch(String Patch);
        int xb;
        int yb;
        int tag;
    public:
        gPicture(int x0, int y0, String Name_T);
        ~gPicture();
};
//---------------------------------------------------------------------------

gPicture::gPicture(int x0, int y0, String Name_T)
{
    try {
        Name = Name_T;
        panelimage = new TPanel(Glav_Form);
        panelimage->Parent = Glav_Form;
        panelimage->Top = x0 * 60 + 60;
        panelimage->Left = y0 * 60 + 5;
        panelimage->Height = 60;
        panelimage->Width = 60;
        panelimage->Caption = Name;
        panelimage->Visible = true;
    } catch (...) {
    }
}
//---------------------------------------------------------------------------

    try {
        //Создание матрицы картинок
        int ob = 1;
        for (int col = 0; col < colim; col++) {
            Application->ProcessMessages();
            for (int row = 0; row < rowim; row++) {
                Application->ProcessMessages();
                matrix_x [col] [row] = (String)ob;
                ob++;
            }
        }
        //Микширование матрицы картинок
        MixerPicture(4);
        //Создание класса картинок
        for (int col = 0; col < colim; col++) {
            Application->ProcessMessages();
            for (int row = 0; row < rowim; row++) {
                Application->ProcessMessages();
                gPicture_R = new gPicture(col, row, matrix_x [col] [row]);
            }
        }
    } catch (...) {
    }

    try {
        TTime tekvrem = Now();
        Word h, m, sec, msec;
        DecodeTime(tekvrem, h, m, sec, msec);
        int indexpanelall, res_p;
        for (int kolpest = 0; kolpest < sec; kolpest++) {
            Application->ProcessMessages();
            Randomize();
            for (int col = 0; col < colim; col++) {
                Application->ProcessMessages();
                for (int row = 0; row < rowim; row++) {
                    Application->ProcessMessages();
                    res_p = StrToInt(matrix_x [col] [row]);
                    indexpanelall = random(84) + 1;
                    for (int col_ = 0; col_ < colim; col_++) {
                        Application->ProcessMessages();
                        for (int row_ = 0; row_ < rowim; row_++) {
                            Application->ProcessMessages();
                            if (matrix_x [col_] [row_] == IntToStr(indexpanelall)) {
                                matrix_x [col_] [row_] = IntToStr(res_p);
                                break;
                            }
                        }
                        matrix_x [col] [row] = IntToStr(indexpanelall);
                    }
                }
            }
        }
    } catch (...) {
    }

class TgPictureCard
{
    private:
        String name;
        int x0;
        int y0;
        int tag;
        String picturename;
        //TgPictureCard *gPictureCard[total];
    public:
        void Show();
        void Hide();
        void Move();
    public:
        TgPictureCard(int x0_T, int y0_T, String name_T, int tag_T, String picturename_T);
        ~TgPictureCard();
};

        int ob = 1;
        int col_m = 1;
        for (int col = 0; col < colim; col++) {
            Application->ProcessMessages();
            for (int row = 0; row < rowim; row++) {
                Application->ProcessMessages();
                if (col_m > 22) col_m = 1;
                gPictureCard[ob] = new TgPictureCard(col,
                                                     row,
                                                     IntToStr(ob),
                                                     col_m,
                                                     ExtractFilePath(Application->ExeName) + "Picture\\i" + col_m + ".bmp");
                //gPictureCard[ob]->Show(); [COLOR="Red"]Почему, если здесь снять комментарий показываются все карты[/COLOR]
                ob++;
                col_m++;
            }
        }

        for (int i = 1; i <= kol_card; i++) {
            Application->ProcessMessages();
            gPictureCard[i]->Show();
        }

void __fastcall TGlav_Form::MixerPicture(int kolpara)
{
    try {
        TTime tekvrem = Now();
        Word h, m, sec, msec;
        DecodeTime(tekvrem, h, m, sec, msec);
        int indexpanelall, res_p;
        TgPictureCard *gPictureCard_;
        for (int kolpest = 0; kolpest < sec; kolpest++) {
            Application->ProcessMessages();
            Randomize();
            for (int i = 1; i <= kol_card; i++) {
                gPictureCard_ = gPictureCard[i];
                indexpanelall = random(84) + 1;
                gPictureCard[i] = gPictureCard[indexpanelall];
                gPictureCard[indexpanelall] = gPictureCard_;
            }
        }
    } catch (...) {
    }
}
//---------------------------------------------------------------------------

typedef void __fastcall( __closure * t_cell_action )( int c, int r, TStringGrid * sg ); // сигнатура метода класса, предназначенного для действия над одной ячейкой
 
void do_for_each_cell( TStringGrid * sg, t_cell_action act ) // идем по всем ячейкам грида, для каждой выполняем переданный метод
{
    for ( int c( 0 ), c_limit( sg->ColCount ); c < c_limit; ++c )
    {
        for ( int r( 0 ), r_limit( sg->RowCount ); r < r_limit; ++r )
        {
            act( c, r, sg );
        }
    }
}
 
// ---------------------------------------------------------------------------
class Tform_game_field : public TForm
{
__published: // IDE-managed Components
 
    TStringGrid * sgrid_game_field;
    TTimer * tmr_animate;
 
    void __fastcall FormResize( TObject * Sender );
    void __fastcall sgrid_game_fieldClick( TObject * Sender );
    void __fastcall tmr_animateTimer( TObject * Sender );
 
public: // User declarations
 
    void __fastcall fill_empty_cells( TStringGrid * sg ) // смотрим все ячейки, пустые заполняем рандомно
    {
        do_for_each_cell( sg, & do_fill_empty_cells );
    }
 
    void __fastcall do_fill_empty_cells( int c, int r, TStringGrid * sg )
    {
        if ( sg->Cells[ c ][ r ].IsEmpty( ) )
        {
            sg->Cells[ c ][ r ] = IntToStr( Random( 6 ) );
            sg->Objects[ c ][ r ] = NULL;
        }
    }
 
    bool __fastcall mark_cells_chain( int c, int r, TStringGrid * sg ) // cмотрим всех соседей начальной ячейки, одинаковых помечаем визуально и через Objects; если одинаковых соседей нет, возвращаем false
    {
        return do_mark_cells_chain( c, r, sg->Cells[ c ][ r ], sg, true );
    }
 
    bool __fastcall do_mark_cells_chain( int c, int r, String val, TStringGrid * sg, bool is_first_cell = false ) // рекурсивно смотрим всех соседей начальной ячейки, одинаковых помечаем визуально и через Objects
    {
        if ( sg->Cells[ c ][ r ] == val && !sg->Objects[ c ][ r ] )
        {
            if ( !is_first_cell )
            {
                sg->Objects[ c ][ r ] = reinterpret_cast < TObject * > ( 1 );
                sg->Cells[ c ][ r ] = "-" + sg->Cells[ c ][ r ];
            }
 
            if ( c + 1 < sg->ColCount )
            {
                do_mark_cells_chain( c + 1, r, val, sg );
            }
            if ( c - 1 >= 0 )
            {
                do_mark_cells_chain( c - 1, r, val, sg );
            }
            if ( r + 1 < sg->RowCount )
            {
                do_mark_cells_chain( c, r + 1, val, sg );
            }
            if ( r - 1 >= 0 )
            {
                do_mark_cells_chain( c, r - 1, val, sg );
            }
            return true;
        }
        return false;
    }
 
    void __fastcall clear_marked_chains( TStringGrid * sg ) // чистим помеченные цепочки, вставляя пустые строки в ячейки
    {
        do_for_each_cell( sg, & do_clear_marked_chains );
    }
 
    void __fastcall do_clear_marked_chains( int c, int r, TStringGrid * sg )
    {
        if ( sg->Objects[ c ][ r ] )
        {
            sg->Cells[ c ][ r ] = "";
        }
    }
 
    void __fastcall shift_cells_down( TStringGrid * sg ) // двигаем верхние непустые(непомеченные) ячейки вниз, а все пустые(помеченные) перемещаем вверх колонки; объекты Objects, ассоциированные с перемещаемыми ячейками остаются связаны с ними же но на новом месте
    {
        std::auto_ptr < TStringList > sl( new TStringList( ) );
 
        for ( int c( 0 ), c_limit( sg->ColCount ); c < c_limit; ++c )
        {
            sl->Assign( sg->Cols[ c ] );
 
            for ( int i( 0 ), i_limit( sl->Count ); i < i_limit; ++i )
            {
                if ( sl->Objects[ i ] )
                {
                    sl->Move( i, 0 );
                }
            }
            sg->Cols[ c ]->Assign( sl.get( ) );
        }
    }
 
    __fastcall Tform_game_field( TComponent * Owner );
} ;

__fastcall Tform_game_field::Tform_game_field( TComponent * Owner )
    :
    TForm( Owner )
{
    Randomize( );
    fill_empty_cells( sgrid_game_field );
}
 
void __fastcall Tform_game_field::FormResize( TObject * Sender )
{
    TStringGrid * sg( sgrid_game_field );
 
    sg->DefaultColWidth = ( ClientWidth - sg->GridLineWidth * sg->ColCount ) / sg->ColCount;
    sg->DefaultRowHeight = ( ClientHeight - sg->GridLineWidth * sg->RowCount ) / sg->RowCount;
}
 
// ---------------------------------------------------------------------------
void __fastcall Tform_game_field::sgrid_game_fieldClick( TObject * Sender )
{
    if ( !tmr_animate->Enabled )
    {
        tmr_animate->Enabled = true;
    }
}
 
// ---------------------------------------------------------------------------
void __fastcall Tform_game_field::tmr_animateTimer( TObject * Sender )
{
    TStringGrid * sg( sgrid_game_field );
    enum
    {
        mark, clear, shift, refill
    } ;
    static int stage( mark );
 
    switch ( stage )
    {
    case mark:
        if ( !mark_cells_chain( sg->Col, sg->Row, sg ) )
        {
            tmr_animate->Enabled = false;
            return;
        }
        tmr_animate->Interval = 500;
        break;
    case clear:
        clear_marked_chains( sg );
        break;
    case shift:
        shift_cells_down( sg );
        break;
    case refill:
        fill_empty_cells( sg );
        break;
    }
    if ( ++stage > refill )
    {
        stage = mark;
        tmr_animate->Enabled = false;
        tmr_animate->Interval = 50;
    }
}