Tworzenie gry w karty - Pasjans.

[czeri]

Znowu źle się wyraziłem, problemy były z odpaleniem projektu. Aplikacja działała bez zarzutu.
Wywala coś takiego:

Error reading PaintBox1->ExplicitLeft: Property ExplicitLeft does not exist. Ignore the error and continue? NOTE: Ignoring the error may cause components to be deleted or property values to be lost

[Cyfrowy Baron]

Projekty stworzone w nowszych wersjach środowiska nie są kompatybilne wstecz. Nie rozumiem więc Twojego zdziwienia, że projekt napisany w C++Builder 2010 nie daje się uruchomić w środowisku C++Builder 6. To chyba oczywiste, co więcej - o ile przeniesienie projektu z C++Builder 6 do C++Builder 2010 jest proste, o tyle wymaga naniesienia poprawek do kodu, gdyż zmiany w bibliotekach między tymi środowiskami są duże, a poza tym w C++Builder 2010 domyślnym typem nie jest już AnsiString, lecz UnicodeString, co wymaga znajomości konwersji. Jeżeli więc korzystasz teraz z próbnej wersji środowiska C++Builder 2010, to powinieneś zapoznać się z tym postem: http://programowanie.cal.pl/forum/viewtopic.php?f=16&t=1098#p7401

[czeri]

Takie pytanie obiekt bCard przechowuje wszystkie załadowane bitmapy jako całość czy mogę się do nich odwołać pojedynczo po indeksach.

Kod: Zaznacz cały

void __fastcall TForm1::DrawCards(void)
{
auto_ptr<Graphics::TBitmap> bCard(new Graphics::TBitmap);
bCard->Width  = 114;
bCard->Height = 154;

int m = 10; // margines
int s = 4; // przerwa między kartami

int l = 0, t = 0;
for(int i = 0; i < vCards.size(); i++)
{
  bCard->LoadFromResourceName((int)HInstance, vCards[i]);

  if( (i % 6) == 0 && i > 0)
  {
   l = 0;
   t += 164;
  }

  int cLeft = m + (l * s) + (l * bCard->Width);
  int cTop  = m + t;

  PaintBox1->Canvas->Draw( cLeft, cTop, bCard.get());

  l++;
}
}

Zamiast rysowania w Paintboxie kart chciałbym każdą kartę załadować do obiektu Image

Kod: Zaznacz cały

PaintBox1->Canvas->Draw( cLeft, cTop, bCard.get());

Wiem, że ten kawałek kodu jest zły chciałem tylko zoobrazować o co mi chodzi

Kod: Zaznacz cały

Image1->Canvas->Draw( cLeft, cTop, bCard.get(0));
Image2->Canvas->Draw( cLeft, cTop, bCard.get(1));
Image3->Canvas->Draw( cLeft, cTop, bCard.get(2));
...


[czeri]

Zrobiłem coś takiego. Działa, ale nie jest to zbyt optymalne rozwiązanie

Kod: Zaznacz cały

for(int i = 0; i < vCards.size(); i++)
{
  bCard->LoadFromResourceName((int)HInstance, vCards[i]);
   switch(i)
   {

             case 1:  Image1->Canvas->Draw( cLeft, cTop, bCard.get());  break;
             case 2:  Image2->Canvas->Draw( cLeft, cTop, bCard.get());  break;
             case 3:  Image3->Canvas->Draw( cLeft, cTop, bCard.get());  break;
             case 4:  Image4->Canvas->Draw( cLeft, cTop, bCard.get());   break;
             case 5:  Image5->Canvas->Draw( cLeft, cTop, bCard.get());   break;
             ...
        }
}


[Cyfrowy Baron]

Takie pytanie obiekt bCard przechowuje wszystkie załadowane bitmapy jako całość czy mogę się do nich odwołać pojedynczo po indeksach.

Obiekt bCard jest tymczasowym obiektem typu TBitmap i na dłuższą metę niczego nie przechowuje, jest niszczony po zakończeniu działania funkcji. Służy tylko do odrysowania karty na PaintBox. Karty - bitmapy przechowywane są w zasobach i maja przypisane identyfikatory - patrz plik cards.rc. Bitmapy pobierane są z zasobów tylko wtedy gdy są potrzebne w oparciu o identyfikator zasobu przypisany do każdej karty. Wektor vCards przechowuje identyfikatory zasobów i wq oparciu o ten identyfikator wczytywana jest odpowiednia bitmapa z zasobów:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

bCard->LoadFromResourceName((int)HInstance, vCards[i]);

---

Zamiast rysowania w Paintboxie kart chciałbym każdą kartę załadować do obiektu Image

Po co? Przecież w ostatecznym rozrachunku wszystko jest rysowane na formularzu.

---

Wiem, że ten kawałek kodu jest zły chciałem tylko zoobrazować o co mi chodzi

Jeżeli chcesz to ładować do Image, to nie trzeba tego odrysowywać, wystarczy tak:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

for(int i = 0; i < vCards.size(); i++)
 dynamic_cast<TImage *>( FindComponent( "Image" + IntToStr( i + 1 ) ) )->
    Picture->Bitmap->LoadFromResourceName((int)HInstance, vCards[i]);
 

[czeri]

Po co? Przecież w ostatecznym rozrachunku wszystko jest rysowane na formularzu.

Bo chiałbym później przesuwać te karty po formularzu (jak to jest w pasjansie z kupki na kupkę), i wiem, że da się to zrealizować na imagach

[Cyfrowy Baron]

Idziesz po prostu na łatwiznę. Rysunki też da się przesuwać mimo iż są tylko narysowane, ale to wymaga oprogramowania całej procedury. Przykład takiego przesuwania grafiki po innej grafice został szeroko omówiony w tym wątku http://programowanie.cal.pl/forum/viewtopic.php?f=4&t=1232.

[Cyfrowy Baron]

Pokażę Tobie jak można przesuwać karty po jednym obiekcie TImage będący planszą dla kart.

Plik nagłówkowy Unit1.h

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

//---------------------------------------------------------------------------

#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>

#include <vector>
#include <map>
//---------------------------------------------------------------------------
using namespace std;

class TForm1 : public TForm
{
__published:    // IDE-managed Components
        TPanel *Panel1;
        TButton *Button1;
        TButton *Button2;
        TImage *Image1;
        void __fastcall Button1Click(TObject *Sender);
        void __fastcall Button2Click(TObject *Sender);
        void __fastcall FormClose(TObject *Sender, TCloseAction &Action);
        void __fastcall Image1MouseMove(TObject *Sender, TShiftState Shift, int X,
          int Y);
        void __fastcall Image1MouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift,
          int X, int Y);
        void __fastcall Image1MouseUp(TObject *Sender, TMouseButton Button, TShiftState Shift,
          int X, int Y);
private:        // User declarations
        void __fastcall LoadCardToVector(void);
        void __fastcall DealCards(void);
        void __fastcall ShuffleCards(void);
        void __fastcall SetPosCards(String Key, int Index);
        void __fastcall DrawCards(void);
        void __fastcall DrawSelectedCard(TPoint mPoint);
        void __fastcall DrawCopyCard(TRect rCopy);
        BOOL __fastcall FindCard(int X, int Y, String &Key);

        vector<String> vCards;
        map<String, POINT> mCards;

        Graphics::TBitmap *Buffer;

        bool dealCards, moveCard, firstDraw;
        UINT moveIndex;
        TPoint scPoint;

public:         // User declarations
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

Plik źródłowy Unit1.cpp

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include <memory>
#include <algorithm>
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
 randomize();

 LoadCardToVector();
 Buffer = new Graphics::TBitmap;
 Buffer->Width  =Image1->Width;
 Buffer->Height =Image1->Height;
 Buffer->Canvas->Brush->Color = clGreen;
 Buffer->Canvas->FillRect(Rect(0, 0, Buffer->Width, Buffer->Height));

 dealCards = false;
 moveCard = false;
 firstDraw = false;
 moveIndex = -1;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::LoadCardToVector(void)
{
 for(int i = 1; i <= 24; i++)
 {
  vCards.push_back(LoadStr(i));
 }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::DealCards(void)
{
 dealCards = true;
 firstDraw = false;
 DrawCards();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ShuffleCards(void)
{
 firstDraw = false;
 for(int i = 0; i < 10; i++)
   random_shuffle(vCards.begin(), vCards.end());

 DrawCards();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SetPosCards(String Key, int Index)
{

}
//---------------------------------------------------------------------------
BOOL __fastcall TForm1::FindCard(int X, int Y, String &Key)
{
 for(int i = vCards.size() - 1; i >= 0; i--)
 {
  if( (X >= mCards[vCards[i]].x && X <= mCards[vCards[i]].x + 114) &&
      (Y >= mCards[vCards[i]].y && Y <= mCards[vCards[i]].y + 154)
      )
  {
   Key = vCards[i];
   moveIndex = i;
   return true;
  }
 }
 return false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::DrawCopyCard(TRect rCopy)
{
 Image1->Canvas->CopyMode = cmSrcCopy;

 Image1->Canvas->CopyRect(rCopy, Buffer->Canvas, rCopy);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::DrawSelectedCard(TPoint mPoint)
{
 auto_ptr<Graphics::TBitmap> bCard(new Graphics::TBitmap);
 bCard->Width  = 114;
 bCard->Height = 154;
 bCard->Transparent = true;

 String Key = vCards[moveIndex];
 bCard->LoadFromResourceName((int)HInstance, Key);

 Image1->Canvas->Draw(mPoint.x, mPoint.y, bCard.get());
 mCards[Key] = mPoint;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::DrawCards(void)
{
 Buffer->Canvas->Brush->Color = clGreen;
 Buffer->Canvas->FillRect(Rect(0, 0, Buffer->Width, Buffer->Height));

 auto_ptr<Graphics::TBitmap> bCard(new Graphics::TBitmap);
 bCard->Width  = 114;
 bCard->Height = 154;
 bCard->Transparent = true;

 int m = 10; // margines
 int s = 8;  // odstęp między kartami

 int l = 0, t = 0;
 for(UINT i = 0; i < vCards.size(); i++)
 {
  bCard->LoadFromResourceName((int)HInstance, vCards[i]);

  if( (i % 6) == 0 && i > 0)
  {
   l = 0;
   t += 124 + (s * 6);
  }

  int cLeft = m + (l * s) + t;
  int cTop  = m + (l * s);

  if(!firstDraw)
  mCards[vCards[i]] = TPoint(cLeft, cTop);


  TPoint mPoint = mCards[vCards[i]];

  if(moveIndex != i)
  Buffer->Canvas->Draw( mPoint.x, mPoint.y, bCard.get());

  l++;
 }

 Image1->Canvas->Draw(0, 0, Buffer);
 firstDraw = true;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
 delete Buffer;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
 DealCards();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
 ShuffleCards();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Image1MouseMove(TObject *Sender, TShiftState Shift,
          int X, int Y)
{
 if(!moveCard) return;

 TRect scRect = TRect(
                      mCards[vCards[moveIndex]].x - 8,
                      mCards[vCards[moveIndex]].y - 8,
                      mCards[vCards[moveIndex]].x + 122,
                      mCards[vCards[moveIndex]].y + 162
                     );

 DrawCopyCard(scRect);

 int left = X - scPoint.x;
 int top  = Y - scPoint.y;
 mCards[vCards[moveIndex]].x = left;
 mCards[vCards[moveIndex]].y = top;

 DrawSelectedCard(mCards[vCards[moveIndex]]);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Image1MouseDown(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y)
{
 String Key;
 if(FindCard(X, Y, Key))
 {
  Screen->Cursor = crSizeAll;

  scPoint.x = X - mCards[Key].x;
  scPoint.y = Y - mCards[Key].y;

  Caption = Key + "   " + scPoint.x + ", " + scPoint.y;
  DrawCards();
  DrawSelectedCard(scPoint);
  moveCard = true;
 }
 else moveCard = false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Image1MouseUp(TObject *Sender, TMouseButton Button,
          TShiftState Shift, int X, int Y)
{
 Screen->Cursor = crDefault;
 if(!moveCard) return;

 String vText = vCards[moveIndex];
 int size = vCards.size() - 1;


 for(int i = moveIndex; i < size; i++) /* przesuwanie karty na wierzch */
 {
   String vText = vCards[i];
   vCards[i] = vCards[i + 1] ;
   vCards[i + 1] = vText;
 }

 moveIndex = -1;
 DrawCards();
 moveCard = false;
}
//---------------------------------------------------------------------------
 

Jak widać kod trochę się skomplikował, gdyż oprócz wektora musiałem skorzystać również z tablicy asocjacyjnej reprezentowanej tutaj przez mapę.

---

[czeri]

Kawał dobrego kodu, dzięki wielkie, teraz tylko go przeanalizuje dokładniej i mam nadzieje, że sklece mojego pasjansa

[Cyfrowy Baron]

Do tego wszystkiego masz talię kart.

---

[czeri]

Pokażę Tobie jak można przesuwać karty po jednym obiekcie TImage będący planszą dla kart.

Takie przesuwanie kart jest cięższe do zarządzania (bynajmniej w moim odczuciu) chodzi mi tu o ustawienie zmiennej ilości kart na stosach, oraz ustawienie stosów z kartami w zadanych miejscach.

[Cyfrowy Baron]

Takie zarządzanie kartami i ich przesuwaniem jest banalnie proste, gdyż wszystkim steruje mapa tutaj mCards, która jako klucz ma ustawiony identyfikator karty, a jako wartość dwie współrzędne karty w strukturze POINT. Do rysowania niczego nie trzeba dodawać, wystarczy odpowiednio zmieniać kolejność wektora vCards.
Problemy to będziesz miał jak stworzysz wiele obiektów TImage, nie mówiąc już o tym, że przy takiej liczbie obiektów rysowanie będzie niewydajne.
Masz z tym problemy, gdyż nie rozumiesz kodu. Nie wiesz co z czego się bierze i jak to na siebie wpływa. Całością steruje wektor vCards, który przechowuje indeksy kart czyli bitmap w zasobach. Wybrany wektor vCards[int ID] przekazywany jako klucz do mapy mCards[String Key] pozwala sterować każdą kartą.
Gdzieś i tak będziesz musiał przechowywać pozycję kart, a mapy doskonale się do tego nadają. Poza tym w programie brakuje jeszcze jednego elementu - wartości kart, które podobnie jak pozycję można przechowywać w kolejnej mapie.

Musisz wiedzieć o jednym, ani TImage, ani TPaintBox nie posiadają własnej powierzchni, więc wszystko jest rysowane na powierzchni na której te obiekty są umieszczone. Czy użyjesz jednego TImage, czy 50, to rysowanie i tak odbywa się na jednej powierzchni. W moim kodzie zamiast wielu TImage są wektory i mapy, a Ty chcesz oprzeć kod na wielu TImage, ale i tak będziesz potrzebował jakiejś listy do zarządzania taką ilością obiektów.

Dałem Tobie już szkielet programu, który można oprogramować wg. własnych potrzeb. Rysowanie zostało już oprogramowane i niczego w zasadzie do przesuwania kart nie trzeba już dodawać.

---

Jeżeli zajrzy tutaj polymorphism to mam pytanie, czy wiesz jak zamieniać miejscami pozycje w wektorze i mapie, ale chodzi o przesuwanie, np. z pozycji 5 na 10, ale po kolei, a nie zamiana 5 na 10, a 10 na 5, czyli tak jak to jest w tym fragmencie kodu:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

 int size = vCards.size() - 1;

 for(int i = moveIndex; i < size; i++) /* przesuwanie karty na wierzch */
 {
   String vText = vCards[i];
   vCards[i] = vCards[i + 1] ;
   vCards[i + 1] = vText;
 }

Mogę to rozbić za pomocą pętli, ale może istnieje jakaś funkcja, która to zadanie realizuje.

[polymorphism]

W obu przypadkach trzeba usunąć element i wstawić go na koniec kontenera. Oczywiście w mapie musisz ustawić odpowiedni klucz, tak żeby wstawiany element znalazł się na końcu zbioru.

[czeri]

Rozmieszczenie kart zrobiłem tak:

Kod: Zaznacz cały

     mCards[vCards[1]] = TPoint(10, 10);
     mCards[vCards[2]] = TPoint(10, 10);
     mCards[vCards[3]] = TPoint(10, 10);
     mCards[vCards[4]] = TPoint(10, 10);
     mCards[vCards[5]] = TPoint(10, 10);
     mCards[vCards[6]] = TPoint(10, 10);
     mCards[vCards[7]] = TPoint(10, 10);
     mCards[vCards[8]] = TPoint(10, 10);
     mCards[vCards[9]] = TPoint(10, 10);
     mCards[vCards[10]] = TPoint(10, 10);
     mCards[vCards[11]] = TPoint(10, 10);
     mCards[vCards[12]] = TPoint(10, 10);
     mCards[vCards[13]] = TPoint(10, 10);
     mCards[vCards[14]] = TPoint(10, 10);
     mCards[vCards[15]] = TPoint(10, 10);
     mCards[vCards[16]] = TPoint(10, 10);
     mCards[vCards[17]] = TPoint(10, 10);
     mCards[vCards[18]] = TPoint(10, 10);
     mCards[vCards[19]] = TPoint(10, 10);
     mCards[vCards[20]] = TPoint(10, 10);
     mCards[vCards[21]] = TPoint(10, 10);
     mCards[vCards[22]] = TPoint(10, 10);
     mCards[vCards[23]] = TPoint(10, 10);
     mCards[vCards[24]] = TPoint(10, 10);
     mCards[vCards[25]] = TPoint(10, 300);
     mCards[vCards[26]] = TPoint(140, 300);
     mCards[vCards[27]] = TPoint(140, 310);
     mCards[vCards[28]] = TPoint(270, 300);
     mCards[vCards[29]] = TPoint(270, 310);
     mCards[vCards[30]] = TPoint(270, 320);
     mCards[vCards[31]] = TPoint(400, 300);
     mCards[vCards[32]] = TPoint(400, 310);
     mCards[vCards[33]] = TPoint(400, 320);
     mCards[vCards[34]] = TPoint(400, 330);
     mCards[vCards[35]] = TPoint(530, 300);
     mCards[vCards[36]] = TPoint(530, 310);
     mCards[vCards[37]] = TPoint(530, 320);
     mCards[vCards[38]] = TPoint(530, 330);
     mCards[vCards[39]] = TPoint(530, 340);
     mCards[vCards[40]] = TPoint(660, 300);
     mCards[vCards[41]] = TPoint(660, 310);
     mCards[vCards[42]] = TPoint(660, 320);
     mCards[vCards[43]] = TPoint(660, 330);
     mCards[vCards[44]] = TPoint(660, 340);
     mCards[vCards[45]] = TPoint(660, 350);
     mCards[vCards[46]] = TPoint(790, 300);
     mCards[vCards[47]] = TPoint(790, 310);
     mCards[vCards[48]] = TPoint(790, 320);
     mCards[vCards[49]] = TPoint(790, 330);
     mCards[vCards[50]] = TPoint(790, 340);
     mCards[vCards[51]] = TPoint(790, 350);
          mCards[vCards[52]] = TPoint(790, 360);



To teraz jeśli dobrze zrozumiałem to będe potrzebował 2 map

Kod: Zaznacz cały

   
                map<String, INT> wCards;
                map<String, String> kCards;


Jedna na wartość karty druga na jej kolor, żeby można było nakładać na siebie tylko karty o tych samch kolorach.

---

Wtedy gdy będe chciał przełożyć kartę z jednego stosu na drugi to będe musiał sprawdzić czy aktualnie przekładana karta jest na wierzchu, czy wartość karty na stosie na który chce przełożyć daną karte jest o jeden większa od aktualnie przekładanej oraz sprawdzić czy zgadzają się kolory

Czyli będziemy operować tutaj na mapach?
Czy dobrze rozumuje?

[Cyfrowy Baron]

Rozmieszczenie kart zrobiłem tak:

Po co ten wianuszek, przecież można to zrobić w pętli, co zresztą pokazałem w swoim kodzie.

To teraz jeśli dobrze zrozumiałem to będe potrzebował 2 map

Jednej mapy, do przechowywania pozycji masz: map<String, TPoint> a do przechowywania wartości wystarczy map<String, int>, przecież klucz jest jednocześnie nazwą karty więc wystarczy powiązać z tą nawą jej wartość. Tworzenie drugiej mapy przechowującej nazwy niczego nie wnosi, gdyż jak już wspomniałem klucz jest nazwą. Reszta to algorytm, który będzie sprawdzał czy nakładane karty są w tym samym kolorze, wszak z klucza możesz wyciągnąć kolor, należy przy tym pamiętać, że klucz dla mapy jest przechowywany w wektorze, więc nazwę można wyciągnąć tak:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

int x = vCards[numer_indeksu].LastDelimiter("_"); /* gdzie klucz to np. DAMA_PIK */
String jaki_kolor = vCards[numer_indeksu].SubString( x + 1, 4 );
String jaka_karta = vCards[numer_indeksu].SubString( 1, x - 1);