Jump to content
Vlăduț Rădulescu

Joc Tetris în C

Recommended Posts

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)

Share this post


Link to post
Share on other sites

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

Share this post


Link to post
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.


  • Recently Browsing   0 members

    No registered users viewing this page.

×
×
  • Create New...