path: root/jeu-test/tetris_lan_src/game.c

#include "includes.h"

// Lg jeu = 10. +1 mur et 2 vides de chaque côté.
// Ht jeu = 22. +4 en haut pour apparition, +1 sol et 2 vides en dessous.
#define	TET_AREA_LG 16	//16
#define TET_AREA_HT 29	//25

#define	TET_DRAW_LG (TET_AREA_LG-6)
#define TET_DRAW_HT (TET_AREA_HT-7)

#define	TET_INTRO_CST	((TET_DRAW_HT << 2) | 0x03)		// Constante pour intro/outro.
#define	TET_WAIT_CST	10

#define TET_GFX_P1_OffsX	10		// Offset aire de jeu player 1.
#define TET_GFX_P1_OffsY	10
#define TET_GFX_P1_OffsNextX	130	// Offset Next pièce.
#define TET_GFX_P1_OffsNextY	24

#define TET_GFX_P2_OffsX	210		// Offset aire de jeu player 2.
#define TET_GFX_P2_OffsY	10
#define TET_GFX_P2_OffsNextX	138	// Offset Next pièce.
#define TET_GFX_P2_OffsNextY	139

#define	FNT_SH_OffsX	2		// Offset de l'ombre des fontes.
#define	FNT_SH_OffsY	2
#define	FNT_SH_Color	224		// Index de la couleur noir (voir la palette du fichier gfx).

#define TET_Score_Block		4
#define TET_Score_1Line		10
#define TET_Score_2Lines	25
#define TET_Score_3Lines	50
#define TET_Score_4Lines	100

#define TET_LinesPerLevel	10
#define TET_MaxLevel		10

enum
{
	TET_State_Play = 0,
	TET_State_GameOver,
	TET_State_Pause,
	TET_State_PauseLAN,
	TET_State_FadeIn,
	TET_State_Intro,
	TET_State_FadeOut,
	TET_State_CnxOpen,		// Ouverture de la connexion TCP.
	TET_State_Connect,		// Attente de la connexion TCP.
	TET_State_EndWait,
};

#define MAX_PIECES 15

#define	BLOCKS_MOD_NORM	7
#define	BLOCKS_MOD_EXT	MAX_PIECES

// Les pièces sur tous leurs 4 angles.
u8 gpPieces[MAX_PIECES][4][16] =		// 4 angles * tableau 4*4.
{
	// Pièce 1 : Barre.
	{
		{ 0,0,0,0,
		  1,1,1,1,
		  0,0,0,0,
		  0,0,0,0 },
		{ 0,1,0,0,
		  0,1,0,0,
		  0,1,0,0,
		  0,1,0,0 },
		{ 0,0,0,0,
		  1,1,1,1,
		  0,0,0,0,
		  0,0,0,0 },
		{ 0,1,0,0,
		  0,1,0,0,
		  0,1,0,0,
		  0,1,0,0 }
	},
	// Pièce 2 : L à l'endroit.
	{
		{ 0,2,0,0,
		  0,2,0,0,
		  0,2,2,0,
		  0,0,0,0 },
		{ 0,0,0,0,
		  2,2,2,0,
		  2,0,0,0,
		  0,0,0,0 },
		{ 0,2,2,0,
		  0,0,2,0,
		  0,0,2,0,
		  0,0,0,0 },
		{ 0,0,2,0,
		  2,2,2,0,
		  0,0,0,0,
		  0,0,0,0 }
	},
	// Pièce 3 : L à l'envers.
	{
		{ 0,0,3,0,
		  0,0,3,0,
		  0,3,3,0,
		  0,0,0,0 },
		{ 3,0,0,0,
		  3,3,3,0,
		  0,0,0,0,
		  0,0,0,0 },
		{ 0,3,3,0,
		  0,3,0,0,
		  0,3,0,0,
		  0,0,0,0 },
		{ 0,0,0,0,
		  3,3,3,0,
		  0,0,3,0,
		  0,0,0,0 }
	},
	// Pièce 4 : T retourné.
	{
		{ 0,0,0,0,
		  0,4,0,0,
		  4,4,4,0,
		  0,0,0,0 },
		{ 0,4,0,0,
		  0,4,4,0,
		  0,4,0,0,
		  0,0,0,0 },
		{ 0,0,0,0,
		  4,4,4,0,
		  0,4,0,0,
		  0,0,0,0 },
		{ 0,4,0,0,
		  4,4,0,0,
		  0,4,0,0,
		  0,0,0,0 }
	},
	// Pièce 5 : Carré.
	{
		{ 0,0,0,0,
		  0,5,5,0,
		  0,5,5,0,
		  0,0,0,0 },
		{ 0,0,0,0,
		  0,5,5,0,
		  0,5,5,0,
		  0,0,0,0 },
		{ 0,0,0,0,
		  0,5,5,0,
		  0,5,5,0,
		  0,0,0,0 },
		{ 0,0,0,0,
		  0,5,5,0,
		  0,5,5,0,
		  0,0,0,0 }
	},
	// Pièce 6 : S.
	{
		{ 0,6,0,0,
		  0,6,6,0,
		  0,0,6,0,
		  0,0,0,0 },
		{ 0,0,0,0,
		  0,6,6,0,
		  6,6,0,0,
		  0,0,0,0 },
		{ 0,6,0,0,
		  0,6,6,0,
		  0,0,6,0,
		  0,0,0,0 },
		{ 0,0,0,0,
		  0,6,6,0,
		  6,6,0,0,
		  0,0,0,0 }
	},
	// Pièce 7 : S à l'envers.
	{
		{ 0,0,7,0,
		  0,7,7,0,
		  0,7,0,0,
		  0,0,0,0 },
		{ 0,0,0,0,
		  7,7,0,0,
		  0,7,7,0,
		  0,0,0,0 },
		{ 0,0,7,0,
		  0,7,7,0,
		  0,7,0,0,
		  0,0,0,0 },
		{ 0,0,0,0,
		  7,7,0,0,
		  0,7,7,0,
		  0,0,0,0 }
	},

	// Extended blocks.
	// Pièce 8.
	{
		{ 1,1,0,0,
		  0,1,0,0,
		  0,1,1,0,
		  0,0,0,0 },
		{ 0,0,1,0,
		  1,1,1,0,
		  1,0,0,0,
		  0,0,0,0 },
		{ 1,1,0,0,
		  0,1,0,0,
		  0,1,1,0,
		  0,0,0,0 },
		{ 0,0,1,0,
		  1,1,1,0,
		  1,0,0,0,
		  0,0,0,0 },
	},
	// Pièce 9.
	{
		{ 2,0,0,0,
		  2,0,0,0,
		  2,2,2,0,
		  0,0,0,0 },
		{ 2,2,2,0,
		  2,0,0,0,
		  2,0,0,0,
		  0,0,0,0 },
		{ 2,2,2,0,
		  0,0,2,0,
		  0,0,2,0,
		  0,0,0,0 },
		{ 0,0,2,0,
		  0,0,2,0,
		  2,2,2,0,
		  0,0,0,0 },
	},
	// Pièce 10.
	{
		{ 0,0,3,0,
		  0,3,3,0,
		  3,3,0,0,
		  0,0,0,0 },
		{ 3,0,0,0,
		  3,3,0,0,
		  0,3,3,0,
		  0,0,0,0 },
		{ 0,3,3,0,
		  3,3,0,0,
		  3,0,0,0,
		  0,0,0,0 },
		{ 3,3,0,0,
		  0,3,3,0,
		  0,0,3,0,
		  0,0,0,0 },
	},
	// Pièce 11.
	{
		{ 0,4,0,0,
		  4,4,4,0,
		  0,4,0,0,
		  0,0,0,0 },
		{ 0,4,0,0,
		  4,4,4,0,
		  0,4,0,0,
		  0,0,0,0 },
		{ 0,4,0,0,
		  4,4,4,0,
		  0,4,0,0,
		  0,0,0,0 },
		{ 0,4,0,0,
		  4,4,4,0,
		  0,4,0,0,
		  0,0,0,0 },
	},
	// Pièce 12.
	{
		{ 0,5,5,0,
		  0,5,5,0,
		  0,5,0,0,
		  0,0,0,0 },
		{ 0,0,0,0,
		  5,5,5,0,
		  0,5,5,0,
		  0,0,0,0 },
		{ 0,5,0,0,
		  5,5,0,0,
		  5,5,0,0,
		  0,0,0,0 },
		{ 5,5,0,0,
		  5,5,5,0,
		  0,0,0,0,
		  0,0,0,0 },
	},
	// Pièce 13.
	{
		{ 0,6,6,0,
		  6,6,0,0,
		  0,6,0,0,
		  0,0,0,0 },
		{ 0,6,0,0,
		  6,6,6,0,
		  0,0,6,0,
		  0,0,0,0 },
		{ 0,6,0,0,
		  0,6,6,0,
		  6,6,0,0,
		  0,0,0,0 },
		{ 6,0,0,0,
		  6,6,6,0,
		  0,6,0,0,
		  0,0,0,0 },
	},
	// Pièce 14.
	{
		{ 7,7,7,0,
		  0,7,0,0,
		  0,7,0,0,
		  0,0,0,0 },
		{ 0,0,7,0,
		  7,7,7,0,
		  0,0,7,0,
		  0,0,0,0 },
		{ 0,7,0,0,
		  0,7,0,0,
		  7,7,7,0,
		  0,0,0,0 },
		{ 7,0,0,0,
		  7,7,7,0,
		  7,0,0,0,
		  0,0,0,0 },
	},
	// Pièce 15.
	{
		{ 0,0,0,0,
		  1,0,1,0,
		  1,1,1,0,
		  0,0,0,0 },
		{ 0,1,1,0,
		  0,1,0,0,
		  0,1,1,0,
		  0,0,0,0 },
		{ 0,0,0,0,
		  1,1,1,0,
		  1,0,1,0,
		  0,0,0,0 },
		{ 1,1,0,0,
		  0,1,0,0,
		  1,1,0,0,
		  0,0,0,0 },
	},

};


// Messages.
enum
{
	e_Msg_NextPiece = 0,	// Next piece : Pièce.
	e_Msg_PieceMove,		// Déplacement d'une pièce : Pièce, x, y, angle.
	e_Msg_PiecePose,		// Une pièce pose > On l'incruste dans le tableau de jeu : Pièce, x, y, angle.
	e_Msg_LinesSend,		// Envoi de x lignes. Celui qui envoie des lignes envoie ce message.
	e_Msg_LinesRecv,		// X lignes reçues. Celui qui reçoit des lignes envoie ce message.

	e_Msg_HolePos,			// Position du trou, envoyé en début de partie par le master si nécessaire.
	e_Msg_PauseOn,			// Déclenchement de la pause.
	e_Msg_PauseOff,			// Arrêt de la pause.
	e_Msg_Dead,				// Mort du joueur.
	e_Msg_StartingLevel,	// Level en cours, envoyé en début de partie. Simplement pour avoir un affichage du n° de niveau cohérent, pas d'incidence sur le jeu.

// prévoir un msg leave (sortie d'un des joueurs) ?

};


#define	MSG_MAX	16
struct SMsg
{
	u8	nType;
	u8	pData[7];
};

// Structures à faire pointer sur pData en fonction du type de message.
struct SMsg_Data0			// Pour move, pose.
{
	u8	nPiece;
	u8	nX, nY, nAngle;
};
struct SMsg_Data1			// Générique pour plusieurs messages différents n'utilisant qu'un prm.
{
	union
	{
		u8	nLinesNb;		// Nb de lignes.
		u8	nHolePos;		// Position du trou.
		u8	nStartingLevel;	// Niveau de départ.
	};
};

#define	MAX_PLAYERS	2
struct STetris
{
	u8	pArea[TET_AREA_LG * TET_AREA_HT];	// Aire de jeu.
	u8	pLines[TET_AREA_HT];			// Flag pour ligne complète.

	u8	pRndLimit[MAX_PIECES];		// Pour limite des pièces identiques.

	u32	nMaster;			// Le slot est celui de la machine master ou celui de la machine esclave. Important pour le système de message.

	u32	nCurPiece;
	u32	nCurPieceNoDraw;	// P2: Pour ne pas afficher la pièce en cours. On pose une pièce, et on n'aurait pas encore reçu la suivante.
	u32	nNextPiece;
	u32	nNextPieceNoDraw;	// P2: Pour ne pas afficher la next pièce.

	u32	nPosX, nPosY;		// Pos (x,y) de la pièce (du bloc 4*4) dans l'aire de jeu.
	u32	nSpeed, nSpdInc;
	u32	nAngle;			// [0;3].

	u32	nBottomLines;	// Nombre de lignes que nous envoie l'autre joueur, on les rajoute en bas dès qu'on pose la pièce en cours.

	u32	nWait;			// Si pas 0, nb de frames pendant lesquelles on fait clignoter les lignes pleines.
	u32	nGameOver;		// LAN : =1 si le joueur a perdu.

	u32	nScore, nLines, nLevel;

	struct SMsg	pMsgStack[MSG_MAX];	// File d'attente, messages reçus.
	u32	nMsgInStack;	// Nb de messages dans la file d'attente.

};
struct STetris	gTetris[MAX_PLAYERS];


struct STetGen
{
	u32	nGameState, nLastState;	// Phase en cours.
	s32	nFadeVal;		// Valeur du fade.
	u32	nIntroVar;		// Variable pour montée/descente de lignes pendant l'intro/outro.

	u32	nVar0;		// Variable misc 0.

	u32	nHolePos;	// Position du trou en LAN. 0 si pas de random (OPT_LAN_Hole).

};
struct STetGen	gTetGen;


void Sub_PutPieceInArea(struct STetris *pPlyr);
u32 Sub_CheckLines(struct STetris *pPlyr);


//-----------------------------------------------------------------------------
// Chaque machine gère son aire de jeu normalement et gère de façon très simplifiée l'aire de l'ennemi :
// - Quand on reçoit un "posé", on teste les lignes et on les supprime si nécessaire.
//   + on attend le message de rajout de lignes dans son aire.

// Envoi d'un message à l'autre machine.
void Msg_Send(struct STetris *pPlyr, u32 nMsgNo)
{
	struct SMsg	sMsg;

	if (gVar.nGameMode != GAME_MODE_LAN) return;

	sMsg.nType = nMsgNo;
	switch (nMsgNo)
	{
	case e_Msg_NextPiece :	// Next piece : Pièce.
		{
			struct SMsg_Data0	*pData = (struct SMsg_Data0 *)sMsg.pData;
			pData->nPiece = pPlyr->nNextPiece;
		}
		break;

	case e_Msg_PieceMove :	// Déplacement d'une pièce : Pièce, x, y, angle.
	case e_Msg_PiecePose :	// Une pièce pose > On l'incruste dans le tableau de jeu : Pièce, x, y, angle.
		{
			struct SMsg_Data0	*pData = (struct SMsg_Data0 *)sMsg.pData;
			pData->nPiece = pPlyr->nCurPiece;
			pData->nX = pPlyr->nPosX;
			pData->nY = pPlyr->nPosY;
			pData->nAngle = pPlyr->nAngle;
		}
		break;

	case e_Msg_LinesSend :	// Envoi de x lignes. Celui qui envoie des lignes envoie ce message.
	case e_Msg_LinesRecv :	// X lignes reçues. Celui qui reçoit des lignes envoie ce message.
		{
			struct SMsg_Data1	*pData = (struct SMsg_Data1 *)sMsg.pData;
			pData->nLinesNb = gTetGen.nVar0;
		}
		break;

	case e_Msg_PauseOn :	// Déclenchement de la pause.
	case e_Msg_PauseOff :	// Arrêt de la pause.
	case e_Msg_Dead :		// Mort du joueur.
		break;

	case e_Msg_HolePos :	// Position du trou.
		{
			struct SMsg_Data1	*pData = (struct SMsg_Data1 *)sMsg.pData;
			pData->nHolePos = gTetGen.nHolePos;
		}
		break;

	case e_Msg_StartingLevel :	// Niveau de départ pour affichage. P1 > P2.
		{
			struct SMsg_Data1	*pData = (struct SMsg_Data1 *)sMsg.pData;
			pData->nStartingLevel = pPlyr->nLevel;
		}
		break;

	}

	// Envoi du message.
	TCP_Send((u8 *)&sMsg, sizeof(sMsg));

}

// Réception des messages.
// On stocke les messages dans la file d'attente du joueur qu'il faut.
// On sait qui reçoit quoi ! En gros, c'est le joueur 2 qui reçoit tout, sauf le "LinesSend". Donc je n'ai pas mis de destinataire.
void Msg_Receive(void)
{
	struct SMsg	*pMsg;
	u8	pBuf[1024];
	u32	nRcvSz;

	if (gVar.nGameMode != GAME_MODE_LAN) return;

	while (TCP_Receive((u8 *)pBuf, sizeof(pBuf), &nRcvSz))	// remplacer par un if ?
	{
		// On peut recevoir plusieurs messages bout à bout. Traitement.
		pMsg = (struct SMsg *)pBuf;
		while (nRcvSz >= sizeof(struct SMsg))
		{
			switch (pMsg->nType)
			{
			case e_Msg_NextPiece :	// Next piece : Pièce.
			case e_Msg_PieceMove :	// Déplacement d'une pièce : Pièce, x, y, angle.
			case e_Msg_PiecePose :	// Une pièce pose > On l'incruste dans le tableau de jeu : Pièce, x, y, angle.
			case e_Msg_LinesRecv :	// X lignes reçues. Celui qui reçoit des lignes envoie ce message.
			case e_Msg_Dead :		// Mort du joueur.
			case e_Msg_StartingLevel :	// Niveau de départ pour affichage. P1 > P2.
				if (gTetris[1].nMsgInStack >= MSG_MAX) { printf("P2: Stack overflow !\n"); break; }
				memcpy(&gTetris[1].pMsgStack[gTetris[1].nMsgInStack], pMsg, sizeof(struct SMsg));
				gTetris[1].nMsgInStack++;
				break;

			case e_Msg_HolePos :	// Position du trou.
			case e_Msg_PauseOn :	// Déclenchement de la pause.
			case e_Msg_PauseOff :	// Arrêt de la pause.
			case e_Msg_LinesSend :	// Envoi de x lignes. Celui qui envoie des lignes envoie ce message.
				if (gTetris[0].nMsgInStack >= MSG_MAX) { printf("P1: Stack overflow !\n"); break; }
				memcpy(&gTetris[0].pMsgStack[gTetris[0].nMsgInStack], pMsg, sizeof(struct SMsg));
				gTetris[0].nMsgInStack++;
				break;

			default :
				printf("Unknown message type received (%d)! Ignored.\n", (int)pMsg->nType);
				break;
			}

			pMsg++;
			nRcvSz -= sizeof(struct SMsg);
		}

		if (nRcvSz) printf("Warning: Receive: %d remaining bytes.\n", (int)nRcvSz);	// Note : Ca n'est encore jamais arrivé.

	}

}

// Teste la file d'attente des messages.
void Msg_Check(struct STetris *pPlyr)
{
	u32	i;
	u32	nPoseLn = 0;	// Pour compter les pièces qui posent et génèrent des lignes.

	for (i = 0; i < pPlyr->nMsgInStack; i++)
	{
		switch (pPlyr->pMsgStack[i].nType)
		{
		case e_Msg_NextPiece :	// Next piece : Pièce.
			{
				struct SMsg_Data0	*pData = (struct SMsg_Data0 *)pPlyr->pMsgStack[i].pData;
				//
				pPlyr->nNextPiece = pData->nPiece;
				pPlyr->nNextPieceNoDraw = 0;
			}
			break;

		case e_Msg_PiecePose :	// Une pièce pose > On l'incruste dans le tableau de jeu : Pièce, x, y, angle.
			if (nPoseLn)
			{
				// Cas foireux : Un pièce générant des lignes a déjà été posée, et on a une autre
				// pièce qui doit poser (et normalement, ça devrait être après la disparition des
				// lignes de la pièce d'avant !).
				// > On recopie les messages en début de liste, et on quitte. Les messages restants seront traités APRES la disparition des lignes.
				u32	j, nRemMsg;

printf("Pose+ln!\n");	// Affichage de debug. Testé, mais normalement, ce cas ne devrait pas trop arriver.
				nRemMsg = pPlyr->nMsgInStack - i;
				for (j = 0; i < pPlyr->nMsgInStack; i++, j++) memcpy(&pPlyr->pMsgStack[j], &pPlyr->pMsgStack[i], sizeof(struct SMsg));
				pPlyr->nMsgInStack = nRemMsg;
				return;
			}
			// Pas de break !
		case e_Msg_PieceMove :	// Déplacement d'une pièce : Pièce, x, y, angle.
			{
				struct SMsg_Data0	*pData = (struct SMsg_Data0 *)pPlyr->pMsgStack[i].pData;
				u8	nPrevAngle = pPlyr->nAngle;
				//
				pPlyr->nCurPiece = pData->nPiece;
				pPlyr->nPosX = pData->nX;
				pPlyr->nPosY = pData->nY;
				pPlyr->nAngle = pData->nAngle;
				pPlyr->nCurPieceNoDraw = 0;
				// Sfx.
				if (pPlyr->nAngle != nPrevAngle) Sfx_PlaySfx(e_Sfx_PieceRotate, e_SfxPrio_10);
			}
			// Une pièce pose, on regarde si des lignes disparaissent.
			if (pPlyr->pMsgStack[i].nType == e_Msg_PiecePose)
			{
				// Incruste la pièce dans l'aire de jeu.
				Sub_PutPieceInArea(pPlyr);
				// La pièce a été incrustée, en attendant un msg de nouvelle pièce, on cache la pièce en cours.
				pPlyr->nCurPieceNoDraw = 1;
				// Test des lignes.
				if (Sub_CheckLines(pPlyr)) nPoseLn++;
			}
			break;

		case e_Msg_LinesSend :	// Envoi de x lignes. Celui qui envoie des lignes envoie ce message.
			{
				struct SMsg_Data1	*pData = (struct SMsg_Data1 *)pPlyr->pMsgStack[i].pData;
				// On reçoit un "Send" > on se prend des lignes...
				pPlyr->nBottomLines += pData->nLinesNb;
				if (pPlyr->nBottomLines > TET_DRAW_HT) pPlyr->nBottomLines = TET_DRAW_HT;	// Limite max.
				// ...et on envoie un "Receive" pour affichage sur l'autre machine.
				gTetGen.nVar0 = pData->nLinesNb;
				Msg_Send(pPlyr, e_Msg_LinesRecv);
			}
			break;

		case e_Msg_LinesRecv :	// X lignes reçues. Celui qui reçoit des lignes envoie ce message.
			{
				struct SMsg_Data1	*pData = (struct SMsg_Data1 *)pPlyr->pMsgStack[i].pData;
				// On reçoit un "Receive" > On ajoute le nb de lignes à l'adversaire.
				pPlyr->nBottomLines += pData->nLinesNb;
				if (pPlyr->nBottomLines > TET_DRAW_HT) pPlyr->nBottomLines = TET_DRAW_HT;	// Limite max.
			}
			break;

		case e_Msg_Dead :		// Mort du joueur adverse.
printf("Death: Msg received.\n");
			pPlyr->nGameOver = 1;
			gTetGen.nGameState = TET_State_GameOver;
			gTetGen.nIntroVar = TET_INTRO_CST;
			break;

		case e_Msg_HolePos :	// Position du trou.
			{
				struct SMsg_Data1	*pData = (struct SMsg_Data1 *)pPlyr->pMsgStack[i].pData;
				gTetGen.nHolePos = pData->nHolePos;
			}
			break;

		case e_Msg_StartingLevel :	// Niveau de départ pour affichage. P1 > P2.
			{
				struct SMsg_Data1	*pData = (struct SMsg_Data1 *)pPlyr->pMsgStack[i].pData;
				pPlyr->nLevel = pData->nStartingLevel;
			}
			break;

		case e_Msg_PauseOn :	// L'autre joueur a déclenché la pause.
			// Cas foireux ou les 2 joueurs font pause en même temps. Le Master garde la main.
			if (gTetGen.nGameState == TET_State_Pause)
			{
				if (gVar.nTCPMaster) break;	// Master, garde l'état TET_State_Pause.
				gTetGen.nGameState = TET_State_PauseLAN;	// Slave, passe de TET_State_Pause à TET_State_PauseLAN.
				break;
			}
			// Cas normal.
			gTetGen.nLastState = gTetGen.nGameState;
			gTetGen.nGameState = TET_State_PauseLAN;
			break;

		case e_Msg_PauseOff :	// L'autre joueur a arrêté la pause.
			gTetGen.nGameState = gTetGen.nLastState;
			break;
		}

	}
	pPlyr->nMsgInStack = 0;

}

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


// Nouvelle pièce.
void NewBlock(struct STetris *pPlyr)
{
	static	u8	nCnt;	// Incrémentée à chaque passage. Si on tire trop de blocs étendus, c'est injouable.

/*
// Version 1 :
	// Tirage de la nouvelle pièce.
	gTetris.nCurPiece = gTetris.nNextPiece;
	//gTetris.nNextPiece = rand() % (gVar.nOptFlags & OPT_BlocksSet ? BLOCKS_MOD_EXT : BLOCKS_MOD_NORM);
	gTetris.nNextPiece = rand() % ((gVar.nOptFlags & OPT_BlocksSet) && (++nCnt & 1) ? BLOCKS_MOD_EXT : BLOCKS_MOD_NORM);
*/


// Version 2 :
	// Quand toutes les pièces "normales" on été tirées au moins 1 fois, on décrémente les cases.
	// Entre temps, chaque pièce ne sort au maximum que 2 fois.
	u32	i;

	// Tirage de la nouvelle pièce.
	pPlyr->nCurPiece = pPlyr->nNextPiece;
	pPlyr->nNextPiece = rand() % ((gVar.nOptFlags & OPT_BlocksSet) && (++nCnt & 1) ? BLOCKS_MOD_EXT : BLOCKS_MOD_NORM);
	while (pPlyr->pRndLimit[pPlyr->nNextPiece] > 1)
	{
		pPlyr->nNextPiece++;
		if (pPlyr->nNextPiece >= BLOCKS_MOD_NORM) pPlyr->nNextPiece = 0;
	}
	pPlyr->pRndLimit[pPlyr->nNextPiece]++;
	for (i = 0; i < BLOCKS_MOD_NORM; i++) if (pPlyr->pRndLimit[i] == 0) break;
	if (i == BLOCKS_MOD_NORM)
	{
		for (i = 0; i < BLOCKS_MOD_NORM; i++) pPlyr->pRndLimit[i]--;	// On décrémente les pièces normales...
		for (; i < MAX_PIECES; i++) pPlyr->pRndLimit[i] = 0;			// ... et on raz des pièces étendues.
	}
//< v2


	// Reset position.
	pPlyr->nPosX = (TET_AREA_LG / 2) - 2;	// Le bloc fait 4x4.
	pPlyr->nPosY = 0;
	pPlyr->nAngle = 0;
	// RAZ virgule vitesse.
	pPlyr->nSpeed = 0;
}

// Initialise la vitesse en fonction du niveau.
void InitSpeed(struct STetris *pPlyr)
{
	// Level de 1 à 10.
	pPlyr->nSpdInc = (0x30 * pPlyr->nLevel) / TET_MaxLevel;

}

// Init générale.
void TetrisInit(void)
{
	u32	i, p;

	for (p = 0; p < MAX_PLAYERS; p++)
	{
		// Clean toute la zone.
		for (i = 0; i < TET_AREA_LG * TET_AREA_HT; i++)
		{
			gTetris[p].pArea[i] = 0;
		}
		// Place les murs (limites droite et gauche).
		for (i = 0; i < TET_AREA_HT; i++)
		{
			gTetris[p].pArea[2 + (i * TET_AREA_LG)] = 1;
			gTetris[p].pArea[3 + TET_DRAW_LG + (i * TET_AREA_LG)] = 1;
			gTetris[p].pLines[i] = 0;				// + clear flag lignes complètes.
		}
		// Place le sol.
		for (i = 0; i < TET_AREA_LG; i++)
		{
			gTetris[p].pArea[i + ((TET_AREA_HT - 3) * TET_AREA_LG)] = 1;
		}

		// Placement du handicap de départ (si nécessaire, et pas en LAN).
		if (gVar.nGameMode != GAME_MODE_LAN)
		for (i = 0; i < gExg.nHandicap * 2; i++)
		{
			u32	j, k;

			for (j = 0; j < 3; j++)
			{
				k = rand() % TET_DRAW_LG;
				gTetris[p].pArea[k + 3 + ((TET_AREA_HT - 3 - (i+1)) * TET_AREA_LG)] = 1;
			}
		}

		// Clean table des pièces identiques.
		for (i = 0; i < MAX_PIECES; i++) gTetris[p].pRndLimit[i] = 0;

		// Init de la nouvelle pièce. 2 fois pour init Next et Current.
		srand(time(NULL));		// Init hasard.
		NewBlock(&gTetris[p]);
		NewBlock(&gTetris[p]);

		// Misc.
		gTetris[p].nCurPieceNoDraw = 0;
		gTetris[p].nNextPieceNoDraw = 0;
		gTetris[p].nBottomLines = 0;
		//
		gTetris[p].nWait = 0;
		gTetris[p].nGameOver = 0;
		gTetris[p].nNextPiece = gTetris[p].nCurPiece;
		//
		gTetris[p].nScore = 0;
		gTetris[p].nLines = 0;
		gTetris[p].nLevel = gExg.nStartingLevel;
		InitSpeed(&gTetris[p]);			// Initialise la vitesse.

		gTetris[p].nMsgInStack = 0;	// Nb de messages dans la file d'attente.

	}

	// Id : Slot du master ou du slave.
	gTetris[0].nMaster = gVar.nTCPMaster;
	gTetris[1].nMaster = gVar.nTCPMaster ^ 1;
printf("M/S : slot0:%d  / slot1:%d\n", (int)gTetris[0].nMaster, (int)gTetris[1].nMaster);

	// P2 : On attend les messages next piece et piece move pour l'affichage.
	gTetris[1].nCurPieceNoDraw = 1;
	gTetris[1].nNextPieceNoDraw = 1;
	gTetris[1].nLevel = 1;		// Par défaut, le P2 est au niveau 1.

	// Misc.
	gTetGen.nFadeVal = 0;
	gTetGen.nIntroVar = TET_INTRO_CST;
	gTetGen.nGameState = TET_State_FadeIn;
	gTetGen.nHolePos = 0;	// Par défaut, trou à gauche.

}

// Check !
// On regarde s'il y a collision en (x,y) pour une pièce.
u32 Check(struct STetris *pPlyr, u32 nPosX, u32 nPosY, u32 nAngle)
{
	u32	x, y;

	for (y = 0; y < 4; y++)
	{
		for (x = 0; x < 4; x++)
		{
			if (gpPieces[pPlyr->nCurPiece][nAngle][(y * 4) + x] &&
					pPlyr->pArea[((nPosY + y) * TET_AREA_LG) + (nPosX + x)])
			{
				return (1);	// Collision.
			}
		}
	}

	// Il n'y a pas eu de collisions.
	return (0);
}

// Dessine un bloc à l'écran.
// !!! L'écran doit être locké !!!
void DrawBlockGfx(u32 nScrPosX, u32 nScrPosY, u32 nColor)
{
	u32	j;
	u8	*pDst, *pSrc;

	// Init Src et Dst.
	pDst = (u8 *)gVar.pScreen->pixels;
	pSrc = (u8 *)gVar.pBackground->pixels;
	pSrc += (SCR_Height * SCR_Width) + (nColor * 10);
	// Dessin du bloc 10x10.
	for (j = 0; j < 10; j++)
	{
		*(u32 *)(pDst + ((j + nScrPosY) * SCR_Width) + nScrPosX) = *(u32 *)(pSrc + (j * SCR_Width));
		*(u32 *)(pDst + ((j + nScrPosY) * SCR_Width) + nScrPosX + 4) = *(u32 *)(pSrc + (j * SCR_Width) + 4);
		*(u16 *)(pDst + ((j + nScrPosY) * SCR_Width) + nScrPosX + 8) = *(u16 *)(pSrc + (j * SCR_Width) + 8);
	}

}

// Dessin de l'aire de jeu, sous-routine d'affichage.
void Sub_Draw(struct STetris *pPlyr, u32 nOffsX, u32 nOffsY)
{
	u32	x, y;
	u32	nVal;

	// Parcours de l'aire de jeu.
	for (y = 0; y < TET_DRAW_HT; y++)
	{
		for (x = 0; x < TET_DRAW_LG; x++)
		{
			nVal = pPlyr->pArea[((y + 4) * TET_AREA_LG) + (x + 3)];
			if (nVal)
			{
				DrawBlockGfx((x * 10) + nOffsX, (y * 10) + nOffsY, nVal - 1);
			}
		}
	}

	if (pPlyr->nCurPieceNoDraw) return;		// Stop ici s'il ne faut pas afficher la pièce en cours.

	// Ghost ?
	if ((gVar.nOptFlags & OPT_Ghost) && pPlyr->nWait == 0)
	{
		u32	nGhostY;

		// Recherche de la position du ghost.
		nGhostY = pPlyr->nPosY;
		while (Check(pPlyr, pPlyr->nPosX, nGhostY + 1, pPlyr->nAngle) == 0) nGhostY++;
		// Dessin du ghost.
		if (nGhostY != pPlyr->nPosY)
		for (y = 0; y < 4; y++)
		{
			if ((s32)(y + nGhostY - 4) >= 0)
			for (x = 0; x < 4; x++)
			{
				nVal = gpPieces[pPlyr->nCurPiece][pPlyr->nAngle][(y * 4) + x];
				if (nVal)
				{
					DrawBlockGfx(((x + pPlyr->nPosX - 3) * 10) + nOffsX, ((y + nGhostY - 4) * 10) + nOffsY, 8);
				}
			}
		}
	}

	// Dessin de la pièce en cours.
	for (y = 0; y < 4; y++)
	{
		if ((s32)(y + pPlyr->nPosY - 4) >= 0)
		for (x = 0; x < 4; x++)
		{
			nVal = gpPieces[pPlyr->nCurPiece][pPlyr->nAngle][(y * 4) + x];
			if (nVal)
			{
				DrawBlockGfx(((x + pPlyr->nPosX - 3) * 10) + nOffsX, ((y + pPlyr->nPosY - 4) * 10) + nOffsY, nVal - 1);
			}
		}
	}

}

// Dessin de l'aire de jeu.
void Draw(void)
{
	SDL_LockSurface(gVar.pScreen);

	Sub_Draw(&gTetris[0], TET_GFX_P1_OffsX, TET_GFX_P1_OffsY);
	if (gVar.nGameMode == GAME_MODE_LAN) Sub_Draw(&gTetris[1], TET_GFX_P2_OffsX, TET_GFX_P2_OffsY);

	SDL_UnlockSurface(gVar.pScreen);

}

// Dessin de la next piece, sous-routine d'affichage.
void Sub_DrawNext(struct STetris *pPlyr, u32 nOffsX, u32 nOffsY)
{
	s32	x, y, offsx, offsy;
	u32	nVal;
	s8	pOffs[MAX_PIECES * 2] =
		{ 5,10, 5,10, 5,10, 10,5, 4,5, 5,10, 5,10,				// Normaux.
		  10,10, 10,10, 10,10, 10,10, 5,10, 10,10, 10,10, 10,5 };		// Extended.

	if (pPlyr->nNextPieceNoDraw) return;		// Stop ici s'il ne faut pas afficher la next pièce.

	// Décalages suivant les pièces.
	offsx = nOffsX + pOffs[pPlyr->nNextPiece * 2];
	offsy = nOffsY + pOffs[(pPlyr->nNextPiece * 2) + 1];

	// Dessin de la pièce suivante.
	for (y = 0; y < 4; y++)
	{
		for (x = 0; x < 4; x++)
		{
			nVal = gpPieces[pPlyr->nNextPiece][0][(y * 4) + x];
			if (nVal)
			{
				DrawBlockGfx((x  * 10) + offsx, (y * 10) + offsy, nVal - 1);
			}
		}
	}

}

// Dessine la Next Piece.
void DrawNext(void)
{
	SDL_LockSurface(gVar.pScreen);

	Sub_DrawNext(&gTetris[0], TET_GFX_P1_OffsNextX, TET_GFX_P1_OffsNextY);
	if (gVar.nGameMode == GAME_MODE_LAN) Sub_DrawNext(&gTetris[1], TET_GFX_P2_OffsNextX, TET_GFX_P2_OffsNextY);

	SDL_UnlockSurface(gVar.pScreen);

}

// Intro, petite présentation au départ.
// L'aire de jeu est pleine et se vide.
void DrawIntro(void)
{
	s32	y, x;

	if (gTetGen.nGameState != TET_State_Intro &&
		gTetGen.nGameState != TET_State_FadeIn &&
		gTetGen.nGameState != TET_State_CnxOpen &&
		gTetGen.nGameState != TET_State_Connect) return;

	SDL_LockSurface(gVar.pScreen);

	// Dessin des lignes.
	x = 0;
	for (y = gTetGen.nIntroVar >> 2; y > 0; y--)
	{
		for (x = 0; x < TET_DRAW_LG; x++)
		{
			DrawBlockGfx((x * 10) + TET_GFX_P1_OffsX, ((TET_DRAW_HT - y) * 10) + TET_GFX_P1_OffsY, 7);
			DrawBlockGfx((x * 10) + TET_GFX_P2_OffsX, ((TET_DRAW_HT - y) * 10) + TET_GFX_P2_OffsY, 7);
		}
	}

	SDL_UnlockSurface(gVar.pScreen);

}

// Affichage du win/lose/draw (LAN).
void DrawWinLose(void)
{
	if (gVar.nGameMode != GAME_MODE_LAN) return;

	char *pGame = "GAME", *pOver = "OVER";
	char *pWin = "WINNER", *pLose = "LOSER", *pDraw = "DRAW", *pWins = "WINS";
	char *pP1, *pP2;

	u8	pClr[4] = { 252, 253, 254, 253 };	// Blanc / gris clair / gris foncé / gris clair.
	static u8 nClr = 0;
	nClr++;
	nClr &= 15;

	// 1er temps : Game Over (En plus, ça laisse le temps aux derniers messages le temps d'arriver).
	if (gTetGen.nIntroVar)// > TET_INTRO_CST / 2)
	{
		// Game Over sur aire P1.
		FontPrintClr((SCR_Width * (TET_GFX_P1_OffsY + FNT_SH_OffsY + ((TET_DRAW_HT * 10) / 2) - 18)) + (TET_GFX_P1_OffsX + FNT_SH_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pGame) * 16) / 2)), pGame, FNT_SH_Color);
		FontPrintClr((SCR_Width * (TET_GFX_P1_OffsY + ((TET_DRAW_HT * 10) / 2) - 18)) + (TET_GFX_P1_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pGame) * 16) / 2)), pGame, pClr[nClr >> 2]);
		FontPrintClr((SCR_Width * (TET_GFX_P1_OffsY + FNT_SH_OffsY + ((TET_DRAW_HT * 10) / 2) + 2)) + (TET_GFX_P1_OffsX + FNT_SH_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pOver) * 16) / 2)), pOver, FNT_SH_Color);
		FontPrintClr((SCR_Width * (TET_GFX_P1_OffsY + ((TET_DRAW_HT * 10) / 2) + 2)) + (TET_GFX_P1_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pOver) * 16) / 2)), pOver, pClr[nClr >> 2]);
		// Game Over sur aire P2.
		FontPrintClr((SCR_Width * (TET_GFX_P2_OffsY + FNT_SH_OffsY + ((TET_DRAW_HT * 10) / 2) - 18)) + (TET_GFX_P2_OffsX + FNT_SH_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pGame) * 16) / 2)), pGame, FNT_SH_Color);
		FontPrintClr((SCR_Width * (TET_GFX_P2_OffsY + ((TET_DRAW_HT * 10) / 2) - 18)) + (TET_GFX_P2_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pGame) * 16) / 2)), pGame, pClr[nClr >> 2]);
		FontPrintClr((SCR_Width * (TET_GFX_P2_OffsY + FNT_SH_OffsY + ((TET_DRAW_HT * 10) / 2) + 2)) + (TET_GFX_P2_OffsX + FNT_SH_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pOver) * 16) / 2)), pOver, FNT_SH_Color);
		FontPrintClr((SCR_Width * (TET_GFX_P2_OffsY + ((TET_DRAW_HT * 10) / 2) + 2)) + (TET_GFX_P2_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pOver) * 16) / 2)), pOver, pClr[nClr >> 2]);
	}
	else
	// Second temps : Winner / Loser.
	{
		// Sélection des phrases pour P1 et P2.
		if (gTetris[0].nGameOver && gTetris[1].nGameOver)
		{
			// Draw game.
			pP1 = pP2 = pDraw;
		}
		else
		{
			if (gTetris[0].nGameOver)
			{
				pP1 = pLose;
				pP2 = pWin;
			}
			else
			{
				pP1 = pWin;
				pP2 = pLose;
			}
		}

		// Affichage P1.
		char	pStrWins[] = "      ";
		char	*pStrPtr;
		FontPrintClr((SCR_Width * (TET_GFX_P1_OffsY + FNT_SH_OffsY + ((TET_DRAW_HT * 10) / 2) - 40)) + (TET_GFX_P1_OffsX + FNT_SH_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pP1) * 16) / 2)), pP1, FNT_SH_Color);
		FontPrintClr((SCR_Width * (TET_GFX_P1_OffsY + ((TET_DRAW_HT * 10) / 2) - 40)) + (TET_GFX_P1_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pP1) * 16) / 2)), pP1, pClr[nClr >> 2]);
		//
		FontPrintClr((SCR_Width * (TET_GFX_P1_OffsY + FNT_SH_OffsY + ((TET_DRAW_HT * 10) / 2) + 0)) + (TET_GFX_P1_OffsX + FNT_SH_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pWins) * 16) / 2)), pWins, FNT_SH_Color);
		FontPrintClr((SCR_Width * (TET_GFX_P1_OffsY + ((TET_DRAW_HT * 10) / 2) + 0)) + (TET_GFX_P1_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pWins) * 16) / 2)), pWins, pClr[nClr >> 2]);
		//
		MyItoa(gVar.pWins[0], pStrWins);
		pStrPtr = pStrWins;
		while (*pStrPtr == ' ') pStrPtr++;
		FontPrintClr((SCR_Width * (TET_GFX_P1_OffsY + FNT_SH_OffsY + ((TET_DRAW_HT * 10) / 2) + 20)) + (TET_GFX_P1_OffsX + FNT_SH_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pStrPtr) * 16) / 2)), pStrPtr, FNT_SH_Color);
		FontPrintClr((SCR_Width * (TET_GFX_P1_OffsY + ((TET_DRAW_HT * 10) / 2) + 20)) + (TET_GFX_P1_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pStrPtr) * 16) / 2)), pStrPtr, pClr[nClr >> 2]);

		// Affichage P2.
		memset(pStrWins, ' ', strlen(pStrWins));
		FontPrintClr((SCR_Width * (TET_GFX_P2_OffsY + FNT_SH_OffsY + ((TET_DRAW_HT * 10) / 2) - 40)) + (TET_GFX_P2_OffsX + FNT_SH_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pP2) * 16) / 2)), pP2, FNT_SH_Color);
		FontPrintClr((SCR_Width * (TET_GFX_P2_OffsY + ((TET_DRAW_HT * 10) / 2) - 40)) + (TET_GFX_P2_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pP2) * 16) / 2)), pP2, pClr[nClr >> 2]);
		//
		FontPrintClr((SCR_Width * (TET_GFX_P2_OffsY + FNT_SH_OffsY + ((TET_DRAW_HT * 10) / 2) + 0)) + (TET_GFX_P2_OffsX + FNT_SH_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pWins) * 16) / 2)), pWins, FNT_SH_Color);
		FontPrintClr((SCR_Width * (TET_GFX_P2_OffsY + ((TET_DRAW_HT * 10) / 2) + 0)) + (TET_GFX_P2_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pWins) * 16) / 2)), pWins, pClr[nClr >> 2]);
		//
		MyItoa(gVar.pWins[1], pStrWins);
		pStrPtr = pStrWins;
		while (*pStrPtr == ' ') pStrPtr++;
		FontPrintClr((SCR_Width * (TET_GFX_P2_OffsY + FNT_SH_OffsY + ((TET_DRAW_HT * 10) / 2) + 20)) + (TET_GFX_P2_OffsX + FNT_SH_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pStrPtr) * 16) / 2)), pStrPtr, FNT_SH_Color);
		FontPrintClr((SCR_Width * (TET_GFX_P2_OffsY + ((TET_DRAW_HT * 10) / 2) + 20)) + (TET_GFX_P2_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pStrPtr) * 16) / 2)), pStrPtr, pClr[nClr >> 2]);

	}

}

// Affichage du texte de synchro.
void DrawSync(void)
{
	if (gTetGen.nGameState != TET_State_Connect) return;
	if (gVar.nGameMode != GAME_MODE_LAN) return;

	u8	pClr[4] = { 252, 253, 254, 253 };	// Blanc / gris clair / gris foncé / gris clair.
	static u8 nClr = 0;
	nClr++;
	nClr &= 15;

	// Affichage.
	char *pSync = "SYNCHRO";
	FontPrintClr((SCR_Width * (TET_GFX_P1_OffsY + FNT_SH_OffsY + ((TET_DRAW_HT * 10) / 2) - 8)) + (TET_GFX_P1_OffsX + FNT_SH_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pSync) * 16) / 2)), pSync, FNT_SH_Color);
	FontPrintClr((SCR_Width * (TET_GFX_P1_OffsY + ((TET_DRAW_HT * 10) / 2) - 8)) + (TET_GFX_P1_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pSync) * 16) / 2)), pSync, pClr[nClr >> 2]);
	FontPrintClr((SCR_Width * (TET_GFX_P2_OffsY + FNT_SH_OffsY + ((TET_DRAW_HT * 10) / 2) - 8)) + (TET_GFX_P2_OffsX + FNT_SH_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pSync) * 16) / 2)), pSync, FNT_SH_Color);
	FontPrintClr((SCR_Width * (TET_GFX_P2_OffsY + ((TET_DRAW_HT * 10) / 2) - 8)) + (TET_GFX_P2_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pSync) * 16) / 2)), pSync, pClr[nClr >> 2]);

}

// Pause, s'il y a qque chose à dessiner, c'est ici.
void DrawPause(void)
{
	if (gTetGen.nGameState != TET_State_Pause &&
		gTetGen.nGameState != TET_State_PauseLAN) return;

	// Affichage.
	char *pSync = "PAUSE";
	FontPrintClr((SCR_Width * (TET_GFX_P1_OffsY + FNT_SH_OffsY + ((TET_DRAW_HT * 10) / 2) - 8)) + (TET_GFX_P1_OffsX + FNT_SH_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pSync) * 16) / 2)), pSync, FNT_SH_Color);
	FontPrint((SCR_Width * (TET_GFX_P1_OffsY + ((TET_DRAW_HT * 10) / 2) - 8)) + (TET_GFX_P1_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pSync) * 16) / 2)), pSync);
	if (gVar.nGameMode == GAME_MODE_LAN)
	{
		FontPrintClr((SCR_Width * (TET_GFX_P2_OffsY + FNT_SH_OffsY + ((TET_DRAW_HT * 10) / 2) - 8)) + (TET_GFX_P2_OffsX + FNT_SH_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pSync) * 16) / 2)), pSync, FNT_SH_Color);
		FontPrint((SCR_Width * (TET_GFX_P2_OffsY + ((TET_DRAW_HT * 10) / 2) - 8)) + (TET_GFX_P2_OffsX + ((TET_DRAW_LG * 10) / 2) - ((strlen(pSync) * 16) / 2)), pSync);
	}

}

// Affichage du score, du niveau, du nombre de lignes.
void DrawScores(void)
{
	u32	i;

	// Score, Lines, Level.
	char	pStr[] = "      ";
	// P1.
	MyItoa(gTetris[0].nLevel, pStr);
	Font8Print((SCR_Width * 81) + 147, pStr);
	MyItoa(gTetris[0].nLines, pStr);
	Font8Print((SCR_Width * 94) + 147, pStr);
	MyItoa(gTetris[0].nScore, pStr);
	Font8Print((SCR_Width * 107) + 147, pStr);

	if (gVar.nGameMode == GAME_MODE_1Player) return;	// Stop en 1 player.

	// P2.
	memset(pStr, ' ', strlen(pStr));
	MyItoa(gTetris[1].nLevel, pStr);
	Font8Print((SCR_Width * 196) + 155, pStr);
	MyItoa(gTetris[1].nLines, pStr);
	Font8Print((SCR_Width * 209) + 155, pStr);
	MyItoa(gTetris[1].nScore, pStr);
	Font8Print((SCR_Width * 222) + 155, pStr);

	// Affichage de la position du trou sur les aires de jeu.
	Font8Print((SCR_Width * (SCR_Height - 8)) + TET_GFX_P1_OffsX + (gTetGen.nHolePos * 10), "^");
	Font8Print((SCR_Width * (SCR_Height - 8)) + TET_GFX_P2_OffsX + (gTetGen.nHolePos * 10), "^");

	// Affichage du nombre de lignes à se prendre.
	for (i = 0; i < gTetris[0].nBottomLines; i++)
		Font8Print((SCR_Width * (TET_GFX_P1_OffsY + (TET_DRAW_HT * 10) - 8 - (i * 4))) + TET_GFX_P1_OffsX - 8, "_");
	for (i = 0; i < gTetris[1].nBottomLines; i++)
		Font8Print((SCR_Width * (TET_GFX_P2_OffsY + (TET_DRAW_HT * 10) - 8 - (i * 4))) + TET_GFX_P2_OffsX + (TET_DRAW_LG * 10) + 1, "_");

}

// Game Over.
// L'aire de jeu se remplit de lignes.
void DrawGameOver(void)
{
	s32	y, x;

	if (gTetGen.nGameState != TET_State_GameOver &&
		gTetGen.nGameState != TET_State_EndWait &&
		gTetGen.nGameState != TET_State_FadeOut) return;

	SDL_LockSurface(gVar.pScreen);

	// Dessin des lignes.
	x = 0;
	for (y = TET_DRAW_HT - (gTetGen.nIntroVar >> 2); y > 0; y--)
	{
		for (x = 0; x < TET_DRAW_LG; x++)
		{
			DrawBlockGfx((x * 10) + TET_GFX_P1_OffsX, ((TET_DRAW_HT - y) * 10) + TET_GFX_P1_OffsY, 7);
			DrawBlockGfx((x * 10) + TET_GFX_P2_OffsX, ((TET_DRAW_HT - y) * 10) + TET_GFX_P2_OffsY, 7);
		}
	}

	SDL_UnlockSurface(gVar.pScreen);

	DrawWinLose();		// Affichage du win/lose (LAN).

}

// Fade.
void Fade(s32 nFadeVal, SDL_Surface *pSurf)
{
	if (nFadeVal < 0) return;

	SDL_Color	pPal[256];
	SDL_Color	*pSrc = pSurf->format->palette->colors;
	u32	i, nNbColors;

	nNbColors = pSurf->format->palette->ncolors;
	if (nFadeVal > 255) nFadeVal = 255;
	for (i = 0; i < nNbColors; i++)
	{
		pPal[i].r = (pSrc->r * nFadeVal) / 255;
		pPal[i].g = (pSrc->g * nFadeVal) / 255;
		pPal[i].b = (pSrc->b * nFadeVal) / 255;
		pSrc++;
	}
	SDL_SetPalette(gVar.pScreen, SDL_PHYSPAL, pPal, 0, nNbColors);

}

// Gestion état Wait : En attente avant de faire disparaitre les lignes complètes.
void TetrisWait(struct STetris *pPlyr)
{
	u32	x, y;
	u32	y2;

	pPlyr->nWait--;
	if (pPlyr->nWait == 0)
	{
		// Timer à 0, on dégage les lignes.

		// Suppression des lignes.
		for (y = TET_DRAW_HT + 4 - 1; y >= 1; y--)
		{
			if (pPlyr->pLines[y])
			{
				// Recopie.
				for (y2 = y; y2 >= 1; y2--)
				{
					for (x = 0; x < TET_DRAW_LG; x++)
					{
						pPlyr->pArea[(y2 * TET_AREA_LG) + (x + 3)] =
							pPlyr->pArea[((y2 - 1) * TET_AREA_LG) + (x + 3)];
					}
					pPlyr->pLines[y2] = pPlyr->pLines[y2 - 1];
				}
				// Première ligne à 0.
				for (x = 0; x < TET_DRAW_LG; x++)
				{
					pPlyr->pArea[x + 3] = 0;
				}
				pPlyr->pLines[0] = 0;
				y++;
			}
		}

		// RAZ flags lignes.
		for (y = 0; y < TET_AREA_HT; y++)
		{
			pPlyr->pLines[y] = 0;
		}

	}
	else
	{
		// En attente.

		// On fait clignoter les lignes complètes.
		for (y = 0; y < TET_DRAW_HT; y++)
		{
			if (pPlyr->pLines[y + 4])
			for (x = 0; x < TET_DRAW_LG; x++)
			{
				pPlyr->pArea[((y + 4) * TET_AREA_LG) + (x + 3)] = pPlyr->nWait & 7;
			}
		}

	}

}


// Ajoute des lignes à la table joueur par le bas (au moment ou une pièce pose, juste avant de jouer la nouvelle pièce).
void LinesAdd(struct STetris *pPlyr)
{
	u32	x, y;
	u32	nOffs;

	if (pPlyr->nBottomLines == 0) return;

// peut-être limiter à 3 lignes par 3 lignes ? > à tester.

	// Décalage.
	nOffs = pPlyr->nBottomLines;
	for (y = 0; y <= TET_DRAW_HT + 4 - 1 - nOffs; y++)
	{
		for (x = 0; x < TET_DRAW_LG; x++)
		{
			pPlyr->pArea[(y * TET_AREA_LG) + (x + 3)] =
				pPlyr->pArea[((y + nOffs) * TET_AREA_LG) + (x + 3)];
		}
	}

	// Remplissage des lignes du bas.
	for (; y <= TET_DRAW_HT + 4 - 1; y++)
	{
		for (x = 0; x < TET_DRAW_LG; x++)
		{
			pPlyr->pArea[(y * TET_AREA_LG) + (x + 3)] = 8;
		}
		// Trou.
		pPlyr->pArea[(y * TET_AREA_LG) + (gTetGen.nHolePos + 3)] = 0;
	}

	// RAZ lignes.
	pPlyr->nBottomLines = 0;

}


// Sous-routine, incruste la pièce en cours dans l'aire de jeu.
void Sub_PutPieceInArea(struct STetris *pPlyr)
{
	u32	x, y;

	// Incruste la pièce dans l'aire de jeu.
	for (y = 0; y < 4; y++)
	{
		for (x = 0; x < 4; x++)
		{
			if (gpPieces[pPlyr->nCurPiece][pPlyr->nAngle][(y * 4) + x])
			{
				pPlyr->pArea[((pPlyr->nPosY + y) * TET_AREA_LG) + (pPlyr->nPosX + x)] =
					gpPieces[pPlyr->nCurPiece][pPlyr->nAngle][(y * 4) + x];
			}
		}
	}
	// Score de la pièce.
	pPlyr->nScore += TET_Score_Block;

	// Rajout des lignes de malus si nécessaire.
	LinesAdd(pPlyr);

}

// Sous-routine, test des lignes.
// Out : Le nombre de lignes pour envoi de merde à l'autre joueur.
u32 Sub_CheckLines(struct STetris *pPlyr)
{
	u32	x, y;
	u32	nLn, nLn2;
	u32	nVal;

	// Test des lignes.
	nLn2 = 0;
	for (y = 0; y < TET_DRAW_HT + 4; y++)
	{
		nLn = 0;
		for (x = 0; x < TET_DRAW_LG; x++)
		{
			nVal = pPlyr->pArea[(y * TET_AREA_LG) + (x + 3)];
			if (nVal)
			{
				nLn++;
			}
		}
		// Ligne complète ?
		if (nLn == TET_DRAW_LG)
		{
			pPlyr->pLines[y] = 1;			// On flague.
			nLn2++;
		}
	}
	// Y-a-t'il eu des lignes ?
	if (nLn2)
	{
		pPlyr->nWait = TET_WAIT_CST;	// Attente de x frames.

		// Score pour lignes.
		u32	pScLn[4] = { TET_Score_1Line, TET_Score_2Lines, TET_Score_3Lines, TET_Score_4Lines };
		pPlyr->nScore += pScLn[nLn2 - 1];
		// Nb de lignes ++.
		u32	nOld = pPlyr->nLines;
		pPlyr->nLines += nLn2;
		// Level passé ?
		if (pPlyr->nLevel < TET_MaxLevel &&
			pPlyr->nLines / TET_LinesPerLevel != nOld / TET_LinesPerLevel)	// Avec les /, permet de changer de niveau même en ne començant pas au niveau 1.
		{
			// Level up !
			pPlyr->nLevel++;
			InitSpeed(pPlyr);
			// Sfx.
			Sfx_PlaySfx(e_Sfx_LevelUp, e_SfxPrio_20);
		}

		// Sfx ligne complète.
		Sfx_PlaySfx(e_Sfx_Explosion2, e_SfxPrio_10);

	}
	else
	{
		// Sfx pièce posée.
		Sfx_PlaySfx(e_Sfx_PieceSticks, e_SfxPrio_10);
	}

	return (nLn2);
}


#define	KB_REPEAT_1ST	12
// Game : La gestion du jeu normal.
void TetrisGame(struct STetris *pPlyr)
{
	u32	nLn2;

	u32	nLastPosX, nLastPosY, nLastAngle;	// Pour envoi de message.
	nLastPosX = pPlyr->nPosX;
	nLastPosY = pPlyr->nPosY;
	nLastAngle = pPlyr->nAngle;

	static	u32	nRepeatR, nRepeatL;		// !!! ATTENTION !!! Avec les variables statiques, ce n'est pas prévu pour plusieurs joueurs en local ! Si on veut faire un multiplayer en local, il faut sortir ces variables.

	// Gestion de la répétition des touches.
	if (gVar.pKeys[SDLK_RIGHT] == 0) nRepeatR = 0;
	nRepeatR++;
	if (nRepeatR > KB_REPEAT_1ST && (nRepeatR & 0x03) == 0) gVar.pKeysTrig[TRIG_RIGHT] = 1;
	if (gVar.pKeys[SDLK_LEFT] == 0) nRepeatL = 0;
	nRepeatL++;
	if (nRepeatL > KB_REPEAT_1ST && (nRepeatL & 0x03) == 0) gVar.pKeysTrig[TRIG_LEFT] = 1;

	// Déplacement ?
	if (gVar.pKeysTrig[TRIG_RIGHT])
	{
		if (Check(pPlyr, pPlyr->nPosX + 1, pPlyr->nPosY, pPlyr->nAngle) == 0)
		{
			pPlyr->nPosX += 1;
		}
	}
	if (gVar.pKeysTrig[TRIG_LEFT])
	{
		if (Check(pPlyr, pPlyr->nPosX - 1, pPlyr->nPosY, pPlyr->nAngle) == 0)
		{
			pPlyr->nPosX -= 1;
		}
	}
	// Rotation ?
	if (gVar.pKeysTrig[TRIG_UP])
	{
		s32	nRot = (gVar.nOptFlags & OPT_Rotation ? -1 : 1);	// Sens de rotation.
		u8	nPrevAngle = pPlyr->nAngle;

		if (Check(pPlyr, pPlyr->nPosX, pPlyr->nPosY, (pPlyr->nAngle + nRot) & 3) == 0)
		{
			pPlyr->nAngle += nRot;
			pPlyr->nAngle &= 3;
		}

		else
		{
			// Aide : Si on ne peut pas tourner, on regarde une case à droite et à gauche.
			// Si ça passe, on y va.
			if (Check(pPlyr, pPlyr->nPosX - 1, pPlyr->nPosY, (pPlyr->nAngle + nRot) & 3) == 0)
			{
				pPlyr->nPosX -= 1;
				pPlyr->nAngle += nRot;
				pPlyr->nAngle &= 3;
			}
			else
			if (Check(pPlyr, pPlyr->nPosX + 1, pPlyr->nPosY, (pPlyr->nAngle + nRot) & 3) == 0)
			{
				pPlyr->nPosX += 1;
				pPlyr->nAngle += nRot;
				pPlyr->nAngle &= 3;
			}

		}

		// Sfx.
		if (pPlyr->nAngle != nPrevAngle) Sfx_PlaySfx(e_Sfx_PieceRotate, e_SfxPrio_10);

	}

	// Vitesse.
	if (gVar.pKeysTrig[TRIG_Space])	// Espace : On pose la pièce directement.
	{
		// On teste toutes les lignes jusqu'à ce qu'on ne puisse plus descendre.
		while (Check(pPlyr, pPlyr->nPosX, pPlyr->nPosY + 1, pPlyr->nAngle) == 0) pPlyr->nPosY++;
		pPlyr->nSpeed |= 0x100;	// On va forcer la dernière descente de ligne.
	}
	if (gVar.pKeys[SDLK_DOWN])
	{
		// Accélération.
		pPlyr->nSpeed += 0x80;		// Revoir. Pas bien. Quand une pièce pose, il faut un trigger pour ne pas descendre la suivante.
	}
	else
	{
		// Vitesse normale.
		pPlyr->nSpeed += pPlyr->nSpdInc;
	}
	// Faut-il descendre d'une ligne ?
	if (pPlyr->nSpeed & ~0xFF)
	{
		pPlyr->nSpeed &= 0xFF;

		// Peut-on descendre d'une ligne ?
		if (Check(pPlyr, pPlyr->nPosX, pPlyr->nPosY + 1, pPlyr->nAngle) == 0)
		{
			// Oui.
			pPlyr->nPosY += 1;
			// Msg.
			Msg_Send(pPlyr, e_Msg_PieceMove);
		}
		else
		{
			// Msg.
			Msg_Send(pPlyr, e_Msg_PiecePose);
			// Non, on incruste la pièce dans l'aire de jeu.
			Sub_PutPieceInArea(pPlyr);
			// Test de lignes.
			if ((nLn2 = Sub_CheckLines(pPlyr)) >= 2)
			{
				// Msg : Envoi de lignes.
				gTetGen.nVar0 = nLn2 - 1;
				Msg_Send(pPlyr, e_Msg_LinesSend);
			}

			// Nouvelle pièce.
			NewBlock(pPlyr);
			Msg_Send(pPlyr, e_Msg_NextPiece);	// Id de la next piece.
			Msg_Send(pPlyr, e_Msg_PieceMove);	// + déplacement immédiat de la nouvelle pièce pour affichage !
			// Pas de pb pour la nouvelle pièce ?
			if (Check(pPlyr, pPlyr->nPosX, pPlyr->nPosY, pPlyr->nAngle) != 0)
			{
				// Si. Game Over.
				Msg_Send(pPlyr, e_Msg_Dead);	// Mort du joueur.
				//
				pPlyr->nGameOver = 1;
				gTetGen.nGameState = TET_State_GameOver;
				gTetGen.nIntroVar = TET_INTRO_CST;
				//
				pPlyr->nNextPiece = pPlyr->nCurPiece;		// Pour éviter les deux Next pièces qui s'enchainent quand perdu.
				Msg_Send(pPlyr, e_Msg_NextPiece);	// Id de la next piece.

			}

			gVar.pKeys[SDLK_DOWN] = 0;	// RAZ flèche bas. Oblige à relacher et réappuyer.

		}
	}
	else
	{
		// Pas de posé, pas de descente de ligne, msg de déplacement si nécessaire.
		if (nLastPosX != pPlyr->nPosX || nLastPosY != pPlyr->nPosY || nLastAngle != pPlyr->nAngle)
		{
			Msg_Send(pPlyr, e_Msg_PieceMove);
		}
	}

}

/*
// Traitement de l'aire de jeu du joueur 2 en mode LAN.
void TetrisGameLAN(struct STetris *pPlyr)
{

}
*/

// Tetris - Main.
u32 TetrisMain(void)
{
	u32	nRetVal = GAME_Null;		// Valeur de sortie.

	// Selon l'état.
	switch (gTetGen.nGameState)
	{
	case TET_State_CnxOpen :	// LAN : Ouverture de la connexion TCP.
		TCP_CnxOpen();
		gTetGen.nGameState = TET_State_Connect;
		break;

	case TET_State_Connect :	// LAN : Attente de la connexion TCP.
		if (TCP_CnxWait())
		{
			gTetGen.nGameState = TET_State_Intro;
			// Envoi de la pièce en cours et de la next piece.
			Msg_Send(&gTetris[0], e_Msg_NextPiece);
			Msg_Send(&gTetris[0], e_Msg_PieceMove);
			// Envoi de son niveau de départ.
			Msg_Send(&gTetris[0], e_Msg_StartingLevel);
			// Master : Position du trou.
			if (gVar.nTCPMaster && (gVar.nOptFlags & OPT_LAN_Hole))
			{
				gTetGen.nHolePos = rand() % TET_DRAW_LG;
				Msg_Send(&gTetris[0], e_Msg_HolePos);
			}
		}
		break;

	case TET_State_Play :
		// Réception des messages en mode LAN.
		Msg_Receive();

		// En attente quand des lignes sont faites ?
		if (gTetris[0].nWait)
		{
			// En attente.
			TetrisWait(&gTetris[0]);
		}
		else
		{
			// Boucle normale.
			Msg_Check(&gTetris[0]);		// Traitement des messages reçus.
			TetrisGame(&gTetris[0]);
		}

		// Si LAN, 2ème joueur.
		if (gVar.nGameMode == GAME_MODE_LAN)
		{
			// En attente quand des lignes sont faites ?
			if (gTetris[1].nWait)
			{
				// En attente.
				TetrisWait(&gTetris[1]);
			}
			else
			{
				// Boucle normale.
				Msg_Check(&gTetris[1]);		// Traitement des messages reçus.
				//TetrisGameLAN(&gTetris[1]);	// Finalement, rien de spécial à faire ici.
			}
		}

		// On veut une pause ? / Le && State_Play, c'est parce qu'on peut déjà être passé en State_Pause par les messages !
		if (gVar.pKeysTrig[TRIG_KeyP] && gTetGen.nGameState == TET_State_Play)
		{
			gTetGen.nLastState = gTetGen.nGameState;
			gTetGen.nGameState = TET_State_Pause;
			// LAN.
			Msg_Send(&gTetris[0], e_Msg_PauseOn);
		}
		break;

	case TET_State_GameOver :
		// Pendant le début de la montée des lignes, on continue à recevoir les messages pour dernières mises à jour (pièce en cours, autre message de mort...).
		if (gTetGen.nIntroVar > TET_INTRO_CST - 32)
		{
			Msg_Receive();
			// Traitement des messages reçus.
			Msg_Check(&gTetris[0]);
			Msg_Check(&gTetris[1]);
		}
		// Transmissions terminées. Incrémentation du nombre de victoires général.
		else if (gTetGen.nIntroVar == TET_INTRO_CST - 32)
		{
			if (gVar.nGameMode == GAME_MODE_LAN)
			if (!(gTetris[0].nGameOver && gTetris[1].nGameOver))	// Pas si match nul.
			{
				gVar.pWins[(gTetris[0].nGameOver ? 1 : 0)]++;
			}
		}

		// Les lignes.
		if (gTetGen.nIntroVar)
		{
			gTetGen.nIntroVar--;
			// Si terminé, fade out.
			if (gTetGen.nIntroVar == 0) gTetGen.nFadeVal = 256;
		}
		else
		{
			if (gVar.nGameMode == GAME_MODE_LAN)
			{
				// LAN, on va passer dans une phase d'attente.
				gTetGen.nGameState = TET_State_EndWait;
				TCP_CnxClose();
			}
			else
			{
				// 1 player : On quitte.
				gTetGen.nGameState = TET_State_FadeOut;
			}
		}
		break;

	case TET_State_EndWait :	// Mode 2 joueurs, Win/Lose. Attente d'une touche.
		if (gVar.pKeysTrig[TRIG_Space])	// Espace.
		{
			gTetGen.nGameState = TET_State_FadeOut;
		}
		break;

	case TET_State_FadeOut :
		// Fade out.
		{
			if (gTetGen.nFadeVal >= 0)
			{
				gTetGen.nFadeVal -= 4;	// Attention, ça tombe bien...
			}
			else
			{
				// On quitte ici, quand FadeVal tombe sous 0.
				gExg.nScore = gTetris[0].nScore;	// Pour les High scores.
				nRetVal = GAME_GameOver;
				//TCP_CnxClose();
			}
		}
		break;

	case TET_State_FadeIn :
		// Le fade.
		if (gTetGen.nFadeVal >= 0 && gTetGen.nFadeVal < 256)
		{
			gTetGen.nFadeVal += 4;
		}
		else
		{
			gTetGen.nFadeVal = -1;	// Arrêt du fade.
			gTetGen.nGameState = (gVar.nGameMode == GAME_MODE_LAN ? TET_State_CnxOpen : TET_State_Intro);
		}
		break;

	case TET_State_Intro :
		// Réception des messages en mode LAN.
		Msg_Receive();
		// Traitement des messages reçus.
		Msg_Check(&gTetris[0]);
		Msg_Check(&gTetris[1]);

		// Les lignes qui descendent.
		{
			// Terminé ?
			if (--gTetGen.nIntroVar == 0)
			{
				gTetGen.nGameState = TET_State_Play;
				//
				NewBlock(&gTetris[0]);		// => On récupère la Next pièce => Affichage correct !
				Msg_Send(&gTetris[0], e_Msg_NextPiece);	// revoir...
				Msg_Send(&gTetris[0], e_Msg_PieceMove);	// revoir...
			}
		}
		break;

	case TET_State_Pause :
		// On reprend ?
		if (gVar.pKeysTrig[TRIG_KeyP])
		{
			gTetGen.nGameState = gTetGen.nLastState;
			// LAN.
			Msg_Send(&gTetris[0], e_Msg_PauseOff);
			break;
		}
		// ... et on enchaîne pour recevoir les messages, toujours au cas où les 2 joueurs appuient en même temps.
	case TET_State_PauseLAN :	// En LAN, celui qui n'a pas déclenché la pause se retrouve dans cet état. L'autre est en pause normale.
		// Réception des messages en mode LAN.
		Msg_Receive();
		// Traitement des messages reçus.
		Msg_Check(&gTetris[0]);
		break;

	}

	// Dessin du jeu.
	Draw();
	DrawNext();
	DrawScores();
	DrawPause();
	DrawIntro();
	DrawSync();		// Texte de synchro.
	DrawGameOver();
	Fade(gTetGen.nFadeVal, gVar.pBackground);

	return (nRetVal);
}