Mamy już wszystko, co potrzebne do utworzenia procedury rysującej planszę
gry. Poniżej znajduje się program testujący rysowanie planszy gry. Nie jest
to jeszcze właściwa gra. Pamiętaj, aby do katalogu projektowego przekopiować
czcionkę
vecprop9x12.fnt.
// I Liceum Ogólnokształcące
// w Tarnowie
// Koło informatyczne
//
// P055A - Test rysowania planszy do gry Go Moku
//----------------------------------------------
#include <SDL/SDL_gfx.h>
#include <SDL/SDL_gui.h>
// Stałe globalne
//---------------
const int SCRX = 640; // stałe określające szerokość i wysokość
const int SCRY = 480; // ekranu w pikselach
const int C_LOW = 0xffcc99; // kolor normalny tła
const int C_HIGH = 0xffffcc; // kolor podświetlonego tła
const int C_CODE = 0x10; // maska koloru tła
const int T_CODE = 0xB; // maska typu pola
const int P_CODE = 0x3; // maska koloru pionów
const int P_BLACK = 1; // kod czarnego gracza
const int P_WHITE = 2; // kod białego gracza
const int P_LAST = 4; // ostatni pion
const int P_WIN = 8; // pion zwycięski
// Zmienne globalne, widoczne we wszystkich funkcjach
//---------------------------------------------------
SDL_Surface * screen;
gfxFont * font = gfxOpenFont("vecprop9x12.fnt");
Uint32 pfsize; // rozmiar planszy w wierszach/kolumnach = 15 lub 19
Uint32 pfx,pfy; // współrzędne lewego górnego narożnika planszy
Uint32 pfwh; // szerokość/wysokość planszy w pikselach
Uint32 pwh; // szerokość/wysokość pola gry
// Funkcje usługowe
//-----------------
// Funkcja oblicza wszystkie wymiary nowej planszy.
// ps - liczba kolumn/wierszy na planszy = 15 lub 19
//--------------------------------------------------
void calcNewPlayfield(Uint32 ps)
{
pfsize = ps;
pfx = 16;
pfwh = screen->h - 32;
pwh = pfwh / ps;
if(!(pwh % 2)) pwh--;
pfwh = pwh * ps;
pfx = pfy = (screen->h - pfwh) >> 1;
}
// Funkcja rysuje tło planszy wraz
// z opisem kolumn i wierszy
//-----------------------------------
void DrawPlayfield()
{
if(SDL_MUSTLOCK(screen)) if(SDL_LockSurface(screen) < 0) exit(-1);
SDL_Rect r;
r.x = r.y = 0;
r.w = r.h = screen->h;
SDL_FillRect(screen, &r, C_LOW);
// rysujemy opisy kolumn na dole planszy
char c[3]; // przechowuje tekst kolumn lub wierszy
Uint32 x, y, i;
x = pfx + (pwh >> 1); // pozycja x pierwszego znaku
y = pfwh + pfx + ((pfx - font->h) >> 1);
c[0] = 'a'; c[1] = 0;
for(i = 0; i < pfsize; i++)
{
gfxDrawText(screen, font, c, x - (gfxTextLength(font, c) >> 1), y, 0, -1);
c[0]++;
x += pwh;
}
// rysujemy opisy wierszy
x = pfx >> 1;
y = pfwh + pfx - (pwh >> 1) - (font->h >> 1);
for(i = 1; i <= pfsize; i++)
{
c[0] = 48 + (i % 10);
if(i > 9)
{
c[1] = c[0]; c[0] = '1'; c[2] = 0;
}
else c[1] = 0;
gfxDrawText(screen, font, c, x - (gfxTextLength(font, c) >> 1), y, 0, -1);
y -= pwh;
}
if(SDL_MUSTLOCK(screen)) SDL_UnlockSurface(screen);
SDL_UpdateRect(screen, 0, 0, screen->h, screen->h);
}
// Funkcja rysuje pole planszy
// pcol - numer kolumny
// prow - numer wiersza
// pcode - kod pola
//----------------------------
void DrawCell(Uint32 pcol, Uint32 prow, Uint32 pcode)
{
if(SDL_MUSTLOCK(screen)) if(SDL_LockSurface(screen) < 0) exit(-1);
SDL_Rect r;
// wypełniamy tło
r.x = (pcol - 1) * pwh + pfx;
r.y = (pfsize - prow) * pwh + pfy;
r.w = r.h = pwh;
SDL_FillRect(screen, &r, (pcode & C_CODE) ? C_HIGH : C_LOW);
// rysujemy linie siatki
Uint32 lcx = r.x + pwh / 2;
Uint32 lcy = r.y + pwh / 2;
Uint32 lrx = r.x + pwh - 1;
Uint32 lly = r.y + pwh - 1;
Uint32 llen = 1 + (pwh >> 1);
if(prow < pfsize) gfxVLine(screen, lcx, r.y, 0, llen);
if(prow > 1) gfxVLine(screen, lcx, lcy, 0, llen);
if(pcol < pfsize) gfxHLine(screen, lcx, lcy, 0, llen);
if(pcol > 1) gfxHLine(screen, r.x, lcy, 0, llen);
// w 9 polach środkowych planszy rysujemy małe koła na przecięciu linii
Uint32 fs = (pfsize + 1) >> 1;
if(((prow == fs - 2) || (prow == fs) || (prow == fs + 2)) &&
((pcol == fs - 2) || (pcol == fs) || (pcol == fs + 2)))
gfxFillCircle(screen, lcx, lcy, 2, 0);
// rysujemy piona
Uint32 pr = (llen * 3) / 4;
if(pcode & P_CODE)
{
gfxFillCircle(screen, lcx, lcy, pr, (pcode & P_BLACK) ? 0x1f1f1f : 0xffffff);
gfxCircle(screen, lcx, lcy, pr, 0);
if(pcode & P_LAST)
{
Uint32 clen = 1 + (pwh >> 1);
gfxHLine(screen, (r.x + lcx) >> 1, lcy, 0xff0000, clen);
gfxVLine(screen, lcx, (r.y + lcy) >> 1, 0xff0000, clen);
}
else if(pcode & P_WIN)
{
pr >>= 2;
if(pr < 3) pr = 3;
gfxFillCircle(screen, lcx, lcy, pr, 0xff0000);
}
}
if(SDL_MUSTLOCK(screen)) SDL_UnlockSurface(screen);
SDL_UpdateRect(screen, r.x, r.y, r.w, r.h);
}
//***********************
// *** Program główny ***
//***********************
int main(int argc, char * argv[])
{
if(SDL_Init(SDL_INIT_VIDEO)) exit(-1);
atexit(SDL_Quit);
if(!(screen = SDL_SetVideoMode(SCRX, SCRY, 32, SDL_HWSURFACE))) exit(-1);
SDL_WM_SetCaption("Test Go Moku","");
// ustalamy tryb 15 x 15
calcNewPlayfield(15);
DrawPlayfield();
// czekamy na klawisz ESC lub zamknięcie okna
SDL_Event event; // Unia zawierająca struktury zdarzeń
bool running = true; // zmienna decyzyjna
while(running)
{
// rysujemy planszę gry z przypadkowymi typami pól
for(int i = 1; i <= pfsize; i++)
for(int j = 1; j <= pfsize; j ++)
if(!(rand() % 5))
DrawCell(i, j, rand());
else
DrawCell(i, j, 0);
SDL_WaitEvent(&event); // czekamy na zdarzenie
switch(event.type) // sprawdzamy, co się wydarzyło
{
case SDL_KEYDOWN: if(event.key.keysym.sym != SDLK_ESCAPE) break;
case SDL_QUIT: running = false; break;
}
}
// zamykamy czcionkę
gfxCloseFont(font);
return 0;
}
Go Moku w
języku japońskim oznacza "Pięć Kamieni". Jest to
starożytna gra logiczna wywodząca się z Azji - bardzo popularna w Japonii i
w Chinach. Jeśli zapytamy o nią początkującego w tej grze, to odpowie
nam, że jest bardzo prosta, z kolei mistrz odpowie, że jest bardzo trudna.
Wszystko zależy od poziomu gracza. Gra jest bardzo
"uzależniająca", lecz jednocześnie uczy logicznego myślenia oraz
przewidywania i konsekwencji różnych posunięć. Biegłość osiąga się po
kilkunastu miesiącach nauki, natomiast poziom mistrzowski jest dostępny
tylko dla uzdolnionych graczy po kilku latach intensywnego treningu.
