Jump to content

Joc Tetris în C

Vlăduț Rădulescu

By +Vlăduț Rădulescu
in C / C++ / C#

 Share

Recommended Posts

Vlăduț Rădulescu Mentor

+Vlăduț Rădulescu

Posted
Posted

Salutare, PC Troubleshooting! Mi-a fost dor de voi, sincer. Păcat că n-am timp să intru.

 

Vin cu o problemă. Apelez destul de târziu, dar am de făcut ca temă la programare jocul Tetris în C. Vă arăt ce am făcut până acum:

  

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <Windows.h>
#include <WinBase.h>
#include <conio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>


#define DIM_X 40
#define DIM_Y 20

#define CHR_STANGA_SUS 201
#define CHR_STANGA_JOS 200
#define CHR_DREAPTA_SUS 187
#define CHR_DREAPTA_JOS 188
#define CHR_BARA_VERTICALA 186
#define CHR_BARA_ORIZONTALA 205

int viteza_x = 0, viteza_y = 1;
int x_nou = 15, x_vechi = 15;
int y_nou = 5, y_vechi = 5;
struct ecran
{
	CHAR unecran[14][21];
	CHAR unlinie;
};
struct piesa
{
	char opiesa[4][4];
	char oX;
	char oY;
};
double g_fLastTime = 0.0;
HBRUSH g_hbrBlock = CreateSolidBrush(RGB(100, 100, 120));
HBRUSH g_hbrSpace = CreateSolidBrush(RGB(0, 0, 0));
ecran g_Board = { 0 };
piesa g_Block = { 0 };
BOOL g_bDoUpdate = FALSE;

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

//                            Ascunderea cursorului

//---------------------------------------------------------------------------------
void hidecursor()
{
	HANDLE consoleHandle = GetStdHandle(STD_OUTPUT_HANDLE);
	CONSOLE_CURSOR_INFO info;
	info.dwSize = 100;
	info.bVisible = FALSE;
	SetConsoleCursorInfo(consoleHandle, &info);
}


void gotoXY(int x, int y)
{
	COORD coord = { x, y };

	SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
}

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

//               Generarea ecranului (fără bara orizontală sus)

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

void afiseaza_chenar()
{
	system("cls");
	for (int j = 0; j < DIM_Y; j++)
	{
		printf("%c", CHR_BARA_VERTICALA);
		for (int i = 0; i < DIM_X; i++) printf(" ");
		printf("%c\n", CHR_BARA_VERTICALA);
	}
	printf("%c", CHR_STANGA_JOS);
	for (int j = 0; j < DIM_X; j++)
		printf("%c", CHR_BARA_ORIZONTALA);
	printf("%c", CHR_DREAPTA_JOS);
}


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

//                               Construcția pieselor

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



const char linie[4][4] = {
	{0,1,0,0},
	{0,1,0,0},
	{0,1,0,0},
	{0,1,0,0}
};
const char L[4][4] = {
	{ 1,0,0,0 },
	{ 1,0,0,0 },
	{ 1,1,0,0 },
	{ 0,0,0,0 }
}; 
const char J[4][4] = {
	{ 0,1,0,0 },
	{ 0,1,0,0 },
	{ 1,1,0,0 },
	{ 0,0,0,0 }
}; 
const char S[4][4] = {
	{ 1,0,0,0 },
	{ 1,1,0,0 },
	{ 0,1,0,0 },
	{ 0,0,0,0 }
};
const char T[4][4] = {
	{ 0,1,0,0 },
	{ 1,1,1,0 },
	{ 0,0,0,0 },
	{ 0,0,0,0 }
}; 
const char Z[4][4] = {
	{ 0,1,0,0 },
	{ 1,1,0,0 },
	{ 1,0,0,0 },
	{ 0,0,0,0 }
}; 
const char patrat[4][4] = {
	{ 1,1,0,0 },
	{ 1,1,0,0 },
	{ 0,0,0,0 },
	{ 0,0,0,0 }
};

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

//                               Generarea pieselor

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

void genereaza_piesa()
{
	char piesa_g = (rand() % 7) + 1;
	switch (piesa_g)
	{
	case 1: memcpy(g_Block.opiesa, linie, 16);
	case 2: memcpy(g_Block.opiesa, L, 16);
	case 3: memcpy(g_Block.opiesa, J, 16);
	case 4: memcpy(g_Block.opiesa, S, 16);
	case 5: memcpy(g_Block.opiesa, Z, 16);
	case 6: memcpy(g_Block.opiesa, T, 16);
	case 7: memcpy(g_Block.opiesa, patrat, 16);

	}
}

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

//                               Căderea pieselor

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

BOOL verifica_coliziunea(char opiesa[4][4])
{
	for (int i = 0; i < 4; ++i)
		for (int j = 0; j < 4; ++j)
			if (opiesa[j][i] == 0)
				break;
			else
				if (g_Board.unecran[j + g_Block.oX][i + g_Block.oY] + opiesa[j][i] != opiesa[j][i])
					return TRUE;
	return FALSE;
}
//---------------------------------------------------------------------------------

//                               Mișcarea pieselor

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

BOOL misca_piesa(int ndX, int ndY)
{
	int nTempX, nTempY;
	nTempX = g_Block.oX;
	nTempY = g_Block.oY;
	g_Block.oX += ndX;
	g_Block.oY += ndY;
	if (TRUE == verifica_coliziunea(g_Block.opiesa))
	{
		g_Block.oX = nTempX;
		g_Block.oY = nTempY;
		return TRUE;
	}
	return FALSE;
}

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

//                              Rotirea pieselor

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

void roteste_piesa()
{
	char i, j, figura[4][4];
	for (i = 0; i < 4; ++i)
		for (j = 0; j < 4; ++j)
			figura[j][i] = g_Block.opiesa[4 - i][j];
	if (TRUE == verifica_coliziunea(figura))
		return;
	for (i = 0; i < 4; ++i)
		for (j = 0; j < 4; ++j)
			figura[j][i] = g_Block.opiesa[j][i];
}
//---------------------------------------------------------------------------------

//                          Căutarea liniilor complete

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

/*void cauta_linia()
{
	char NumBlocks = 0;
	for (int i=0;i<21;++i)
		for (int j=0;j<13;++j)

}*/
//---------------------------------------------------------------------------------

//                         Ștergerea liniilor complete

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

/*void sterge_linia(uint linieverticala)
{
	for (int i = linieverticala; i > 0; --i)
		for (int j = 1; j < 13; ++j)
			g_Board.opiesa[j][i] = g_Board.opiesa[j][i - 1];
}*/
int main()
{
	hidecursor();
	afiseaza_chenar();
	genereaza_piesa();
	

}

 

Menționez că sunt începător în programare, m-a mâncat în cur să dau la Academia Tehnică Militară. Nici nu știu dacă e bine ce am făcut aici. Vă rămân dator dacă mă ajutați

Programul în care lucrez e Visual Studio 2017 (de ce nu se lucrează cu acesta și în liceu, nu știu, se preferă CodeBlocks care e nasol)

Vlăduț Rădulescu Mentor

+Vlăduț Rădulescu

Posted
  • Author
Posted

Se pare că tot singur l-am rezolvat

 

Am aici aproape 600 de linii de cod, bazat pe structuri de date, pentru cei care vreți să copiați la examene: 

	#include <stdio.h>
	#include <Windows.h>
	#include <stdlib.h>
	#include <time.h>
	#include <conio.h>
	#include <math.h>
	 
	//----------------------------------------------------------------------
	 
	//                       Definirea laturilor
	 
	//----------------------------------------------------------------------
	 
	#define PATRAT 219
	#define PERETE 200
	#define LATIME 12
	#define LUNGIME 21
	 
	//----------------------------------------------------------------------
	 
	//                Butoanele cu care poți juca jocul
	 
	//---------------------------------------------------------------------- 
	 
	#define STANGA 'a'
	#define DREAPTA 'd'
	#define SUS 'w'
	#define JOS 's'
	 
	//----------------------------------------------------------------------
	 
	//          Structurarea coordonatelor și punctelor pieselor
	 
	//----------------------------------------------------------------------
	 
	struct punct {
	    int x;                
	    int y;
	};
	 
	struct piesa {
	    punct p0;
	    punct p1;
	    punct p2;
	    punct p3;
	};
	 
	int matrice[LATIME][LUNGIME];
	int scor = 0;
	piesa patrat, J, L, T, S, Z, linie;
	 
	void gotoXY(int x, int y)
	{
	    COORD coord = { x, y };
	 
	    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
	}
	 
	void put() {
	    printf("%c", PATRAT);
	}
	 
	void erase() {
	    printf(" ");
	}
	 
	//----------------------------------------------------------------------
	 
	//                        Ascunderea cursorului
	 
	//----------------------------------------------------------------------
	 
	void hidecursor()
	{
	    HANDLE consoleHandle = GetStdHandle(STD_OUTPUT_HANDLE);
	    CONSOLE_CURSOR_INFO info;
	    info.dwSize = 100;
	    info.bVisible = FALSE;
	    SetConsoleCursorInfo(consoleHandle, &info);
	}
	 
	//----------------------------------------------------------------------
	 
	//                         Chenarul și decorul
	 
	//----------------------------------------------------------------------
	 
	void plansa_joc() {
	    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 8);
	    for (int i = 0; i < LUNGIME - 1; i++) {
	        printf("%c          %c\n", PATRAT, PATRAT);
	    }
	    for (int i = 0; i < LATIME; i++) {
	        printf("%c", PATRAT);
	    }
	 
	    for (int i = 2; i < 8; i++) {
	        gotoXY(13, i);
	        printf("%c        %c", PATRAT, PATRAT);
	    }
	    gotoXY(13, 2);
	    for (int i = 0; i < 10; i++) {
	        put();
	    }
	    gotoXY(13, 8);
	    for (int i = 0; i < 10; i++) {
	        put();
	    }
	    gotoXY(13, 1);
	    printf("Piesa urmatoare:");
	 
	    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 4);
	    gotoXY(2, 22);
	    printf("Scor:");
	}
	 
	//----------------------------------------------------------------------
	 
	//                        Definirea pieselor
	 
	//----------------------------------------------------------------------
	 
	void piese() {
	    patrat.p0.x = 5;
	    patrat.p0.y = 0;
	    patrat.p1.x = 5;
	    patrat.p1.y = 1;
	    patrat.p2.x = 6;
	    patrat.p2.y = 0;
	    patrat.p3.x = 6;
	    patrat.p3.y = 1;
	 
	    J.p0.x = 5;
	    J.p0.y = 0;
	    J.p1.x = 5;
	    J.p1.y = 1;
	    J.p2.x = 5;
	    J.p2.y = 2;
	    J.p3.x = 4;
	    J.p3.y = 2;
	 
	    L.p0.x = 5;
	    L.p0.y = 0;
	    L.p1.x = 5;
	    L.p1.y = 1;
	    L.p2.x = 5;
	    L.p2.y = 2;
	    L.p3.x = 6;
	    L.p3.y = 2;
	 
	    T.p0.x = 4;
	    T.p0.y = 0;
	    T.p1.x = 5;
	    T.p1.y = 0;
	    T.p2.x = 6;
	    T.p2.y = 0;
	    T.p3.x = 5;
	    T.p3.y = 1;
	 
	    S.p0.x = 5;
	    S.p0.y = 0;
	    S.p1.x = 5;
	    S.p1.y = 1;
	    S.p2.x = 4;
	    S.p2.y = 1;
	    S.p3.x = 4;
	    S.p3.y = 2;
	 
	    Z.p0.x = 5;
	    Z.p0.y = 0;
	    Z.p1.x = 5;
	    Z.p1.y = 1;
	    Z.p2.x = 6;
	    Z.p2.y = 1;
	    Z.p3.x = 6;
	    Z.p3.y = 2;
	 
	    linie.p0.x = 5;
	    linie.p0.y = 0;
	    linie.p1.x = 5;
	    linie.p1.y = 1;
	    linie.p2.x = 5;
	    linie.p2.y = 2;
	    linie.p3.x = 5;
	    linie.p3.y = 3;
	}
	 
	//----------------------------------------------------------------------
	 
	//                       Inițializarea matricei
	 
	//----------------------------------------------------------------------
	 
	void incepe_joc() {
	    for (int i = 0; i < LUNGIME; i++) {
	        matrice[0][i] = PERETE;
	        matrice[11][i] = PERETE;
	    }
	    for (int i = 0; i < LATIME; i++) {
	        matrice[i][LUNGIME - 1] = PERETE;
	    }
	}
	 
	void afiseaza_piesele(piesa p) {
	    gotoXY(p.p0.x, p.p0.y);
	    put();
	    gotoXY(p.p1.x, p.p1.y);
	    put();
	    gotoXY(p.p2.x, p.p2.y);
	    put();
	    gotoXY(p.p3.x, p.p3.y);
	    put();
	    matrice[p.p0.x][p.p0.y] = PATRAT;
	    matrice[p.p1.x][p.p1.y] = PATRAT;
	    matrice[p.p2.x][p.p2.y] = PATRAT;
	    matrice[p.p3.x][p.p3.y] = PATRAT;
	}
	 
	void sterge_piesele(piesa p) {
	    gotoXY(p.p0.x, p.p0.y);
	    erase();
	    gotoXY(p.p1.x, p.p1.y);
	    erase();
	    gotoXY(p.p2.x, p.p2.y);
	    erase();
	    gotoXY(p.p3.x, p.p3.y);
	    erase();
	    matrice[p.p0.x][p.p0.y] = 0;
	    matrice[p.p1.x][p.p1.y] = 0;
	    matrice[p.p2.x][p.p2.y] = 0;
	    matrice[p.p3.x][p.p3.y] = 0;
	}
	 
	//----------------------------------------------------------------------
	 
	//             Funcțiile de rotație, coborâre și mișcare
	 
	//----------------------------------------------------------------------
	 
	void rotatie(piesa &p) {
	 
	    sterge_piesele(p);
	 
	    int distX, distY;
	 
	    distX = p.p0.x - p.p1.x;
	    distY = -(p.p0.y - p.p1.y);
	    p.p0.x = p.p1.x + distY;
	    p.p0.y = p.p1.y + distX;
	 
	    distX = p.p2.x - p.p1.x;
	    distY = -(p.p2.y - p.p1.y);
	    p.p2.x = p.p1.x + distY;
	    p.p2.y = p.p1.y + distX;
	 
	    distX = p.p3.x - p.p1.x;
	    distY = -(p.p3.y - p.p1.y);
	    p.p3.x = p.p1.x + distY;
	    p.p3.y = p.p1.y + distX;
	 
	    afiseaza_piesele(p);
	}
	 
	void coborare(piesa &p) {
	    sterge_piesele(p);
	    p.p0.y++;
	    p.p1.y++;
	    p.p2.y++;
	    p.p3.y++;
	    afiseaza_piesele(p);
	}
	 
	void miscare_stanga(piesa &p) {
	    sterge_piesele(p);
	    p.p0.x--;
	    p.p1.x--;
	    p.p2.x--;
	    p.p3.x--;
	    afiseaza_piesele(p);
	}
	 
	void miscare_dreapta(piesa &p) {
	    sterge_piesele(p);
	    p.p0.x++;
	    p.p1.x++;
	    p.p2.x++;
	    p.p3.x++;
	    afiseaza_piesele(p);
	}
	 
	int testare_jos(piesa p) {
	    int adevar = 1;
	    if (matrice[p.p0.x][p.p0.y + 1] == PERETE)
	        adevar = 0;
	    if (matrice[p.p1.x][p.p1.y + 1] == PERETE)
	        adevar = 0;
	    if (matrice[p.p2.x][p.p2.y + 1] == PERETE)
	        adevar = 0;
	    if (matrice[p.p3.x][p.p3.y + 1] == PERETE)
	        adevar = 0;
	    return adevar;
	}
	 
	int testare_stanga(piesa p) {
	    int adevar = 1;
	    if (matrice[p.p0.x - 1][p.p0.y] == PERETE)
	        adevar = 0;
	    if (matrice[p.p1.x - 1][p.p1.y] == PERETE)
	        adevar = 0;
	    if (matrice[p.p2.x - 1][p.p2.y] == PERETE)
	        adevar = 0;
	    if (matrice[p.p3.x - 1][p.p3.y] == PERETE)
	        adevar = 0;
	    return adevar;
	}
	 
	int testare_dreapta(piesa p) {
	    int adevar = 1;
	    if (matrice[p.p0.x + 1][p.p0.y] == PERETE)
	        adevar = 0;
	    if (matrice[p.p1.x + 1][p.p1.y] == PERETE)
	        adevar = 0;
	    if (matrice[p.p2.x + 1][p.p2.y] == PERETE)
	        adevar = 0;
	    if (matrice[p.p3.x + 1][p.p3.y] == PERETE)
	        adevar = 0;
	    return adevar;
	}
	 
	int testare_rotatie(piesa p) {
	 
	    int distX = p.p0.x - p.p1.x;
	    int distY = -(p.p0.y - p.p1.y);
	    p.p0.x = p.p1.x + distY;
	    p.p0.y = p.p1.y + distX;
	 
	    distX = p.p2.x - p.p1.x;
	    distY = -(p.p2.y - p.p1.y);
	    p.p2.x = p.p1.x + distY;
	    p.p2.y = p.p1.y + distX;
	 
	    distX = p.p3.x - p.p1.x;
	    distY = -(p.p3.y - p.p1.y);
	    p.p3.x = p.p1.x + distY;
	    p.p3.y = p.p1.y + distX;
	 
	    int adevar = 1;
	    if (matrice[p.p0.x][p.p0.y] == PERETE)
	        adevar = 0;
	    if (matrice[p.p1.x][p.p1.y] == PERETE)
	        adevar = 0;
	    if (matrice[p.p2.x][p.p2.y] == PERETE)
	        adevar = 0;
	    if (matrice[p.p3.x][p.p3.y] == PERETE)
	        adevar = 0;
	    return adevar;
	}
	 
	void blocheaza(piesa p) {
	    matrice[p.p0.x][p.p0.y] = PERETE;
	    matrice[p.p1.x][p.p1.y] = PERETE;
	    matrice[p.p2.x][p.p2.y] = PERETE;
	    matrice[p.p3.x][p.p3.y] = PERETE;
	}
	 
	//----------------------------------------------------------------------
	 
	//                   Ștergerea liniilor complete
	 
	//----------------------------------------------------------------------
	 
	void stergere_linie(int linia) {
	 
	    for (int j = 1; j < LATIME - 1; j++) {
	        matrice[j][linia] = 0;
	        gotoXY(j, linia);
	        printf(" ");
	    }
	 
	    for (int i = linia; i >= 1; i--) {
	        for (int j = 1; j < LATIME - 1; j++) {
	            if (matrice[j][i - 1] == PERETE) {
	                gotoXY(j, i - 1);
	                erase();
	                gotoXY(j, i);
	                put();
	            }
	            matrice[j][i] = matrice[j][i - 1];
	        }
	    }
	}
	 
	int verificare_linie() {
	    int complet;
	    for (int i = LUNGIME - 2; i >= 0; i--) {
	        complet = 1;
	        for (int j = 1; j < LATIME - 1; j++) {
	            if (matrice[j][i] == 0) {
	                complet = 0;
	                break;
	            }
	        }
	 
	        if (complet == 1) {
	            stergere_linie(i);
	            return 1;
	        }
	    }
	    return 0;
	}
	 
	//----------------------------------------------------------------------
	 
	//                 Generarea aleatorie a pieselor
	 
	//----------------------------------------------------------------------
	 
	piesa generare_piesa() {
	    switch (rand() % 7 + 1) {
	    case 1: return patrat; break;
	    case 2: return J; break;
	    case 3: return L; break;
	    case 4: return T; break;
	    case 5: return S; break;
	    case 6: return Z; break;
	    case 7: return linie; break;
	    }
	}
	 
	//----------------------------------------------------------------------
	 
	//                Verificarea sfârșitului jocului
	 
	//----------------------------------------------------------------------
	 
	void verificare_gameover(piesa p) {
	    int gameOver = 0;
	    if (matrice[p.p0.x][p.p0.y] == PERETE) {
	        gameOver = 1;
	    }
	    if (matrice[p.p1.x][p.p1.y] == PERETE) {
	        gameOver = 1;
	    }
	    if (matrice[p.p2.x][p.p2.y] == PERETE) {
	        gameOver = 1;
	    }
	    if (matrice[p.p3.x][p.p3.y] == PERETE) {
	        gameOver = 1;
	    }
	    if (gameOver == 1) {
	        gotoXY(2, 11);
	        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 5);
	        printf("GAME OVER");
	        gotoXY(2, 24);
	        exit(0);
	    }
	}
	 
	//----------------------------------------------------------------------
	 
	//                    Afișarea piesei următoare
	 
	//----------------------------------------------------------------------
	 
	void piesa_asteptare(piesa p) {
	    piesa copie = p;
	 
	    copie.p0.x += 12;
	    copie.p1.x += 12;
	    copie.p2.x += 12;
	    copie.p3.x += 12;
	 
	    copie.p0.y += 3;
	    copie.p1.y += 3;
	    copie.p2.y += 3;
	    copie.p3.y += 3;
	 
	    afiseaza_piesele(copie);
	}
	 
	void sterge_piesa_asteptare(piesa p) {
	    piesa copie = p;
	 
	    copie.p0.x += 12;
	    copie.p1.x += 12;
	    copie.p2.x += 12;
	    copie.p3.x += 12;
	 
	    copie.p0.y += 3;
	    copie.p1.y += 3;
	    copie.p2.y += 3;
	    copie.p3.y += 3;
	 
	    sterge_piesele(copie);
	}
	 
	void afisare_scor() {
	    gotoXY(11, 22);
	    printf("%d", scor);
	}
	 
	//----------------------------------------------------------------------
	 
	//                         Începerea jocului
	 
	//----------------------------------------------------------------------
	 
	void start_joc() {
	    piesa curent = generare_piesa();
	    piesa in_asteptare = generare_piesa();
	    piesa_asteptare(in_asteptare);
	    afiseaza_piesele(curent);
	    afisare_scor();
	    char input = 0;
	    int i = 0;
	    int gasit = 0;
	    while (1) {
	        if (_kbhit()) {
	            input = _getch();
	        }
	        switch (input) {
	        case STANGA:
	            if (testare_stanga(curent))
	                miscare_stanga(curent);
	            break;
	        case DREAPTA:
	            if (testare_dreapta(curent))
	                miscare_dreapta(curent);
	            break;
	        case SUS:
	            if (testare_rotatie(curent))
	                rotatie(curent);
	            break;
	        case JOS:
	            if (testare_jos(curent))
	                coborare(curent);
	            else {
	                blocheaza(curent);
	                gasit = verificare_linie();
	                while (gasit == 1) {
	                    gasit = verificare_linie();
	                    scor += 100;
	                    afisare_scor();
	                }
	                sterge_piesa_asteptare(in_asteptare);
	                curent = in_asteptare;
	                in_asteptare = generare_piesa();
	                piesa_asteptare(in_asteptare);
	                verificare_gameover(curent);
	                afiseaza_piesele(curent);
	            }
	            break;
	        default:
	            break;
	        }
	        if (i == 20000) {
	            if (testare_jos(curent))
	                coborare(curent);
	            else {
	                blocheaza(curent);
	                gasit = verificare_linie();
	                while (gasit == 1) {
	                    gasit = verificare_linie();
	                    scor += 100;
	                    afisare_scor();
	                }
	                sterge_piesa_asteptare(in_asteptare);
	                curent = in_asteptare;
	                in_asteptare = generare_piesa();
	                piesa_asteptare(in_asteptare);
	                verificare_gameover(curent);
	                afiseaza_piesele(curent);
	            }
	            i = 0;
	        }
	        input = 0;
	        i++;
	    }
	}
	 
	//----------------------------------------------------------------------
	 
	//                        Funcția principală
	 
	//----------------------------------------------------------------------
	 
	void main() {
	    srand(time(NULL));
	 
	    plansa_joc();
	    piese();
	    incepe_joc();
	 
	    start_joc();
	 
	 
	    gotoXY(15, 10);
	}

  • Like 1
  • Thanks 1

Please sign in to comment

You will be able to leave a comment after signing in



Sign In Now
 Share
Go to topic listing

  • Recently Browsing   0 members

    • No registered users viewing this page.
×
×
  • Create New...

Important Information

We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.