Need help with shape collision in tetris clone

[shywolf91]

I need help detecting other blocks. right now the block will go through other blocks.

new code:

//Dark GDK - The Game Creators - www.thegamecreators.com

//the wizard has created a very simple project that uses Dark GDK
//it contains the basic code for a GDK application

//whenever using Dark GDK you must ensure you include the header file
#include "DarkGDK.h"
#include <cstdlib>
#include <ctime>


//Global
int Block_Size=20; 
int grid[20][10];
//colors
const DWORD Red = dbRGB(255,0,0);
const DWORD Green = dbRGB(0,255,0);
const DWORD Blue = dbRGB(0,0,255);
const DWORD Magenta = dbRGB(255,0,255);
const DWORD Black = dbRGB(0,0,0);
const DWORD White = dbRGB(255,255,255);
const DWORD Yellow = dbRGB(255,255,0);
const DWORD Cyan = dbRGB(0,255,255);
const DWORD Orange = dbRGB(255,165,0);
const DWORD Grey = dbRGB(177,177,177);
//end colors
//end global

//Classes

class Block {
private:
	DWORD color;
	//int blocks[4];
public:
	int x,y;
	Block();
	Block(int, int, DWORD);
	void draw();
	void move(int, int);
	void clear();
	void rotation(int,int);
	
};
Block::Block(){
x = 0;
y = 0;
color = White;
}
//Methods (Block)
void Block::rotation(int px , int py)
{
	int xp, yp;

	xp=px-py+y;
	yp=px+py-x;

	x=xp;
	y=yp;
	dbInk(color, Grey);
	draw();

}

Block::Block(int X, int Y, DWORD COLOR)
{
	x=X;
	y=Y;
	color=COLOR;
}

void Block::draw()
{
	int x1, y1, x2, y2;
	x1=x*Block_Size;
	y1=y*Block_Size;
	x2=x1+Block_Size;
	y2=y1+Block_Size;

//	dbInk(color, Black);
	dbBox(x1,y1,x2,y2);
}

void Block::clear()
{

	dbInk(Grey, Grey);
	//dbBox(x1,y1,x2,y2);
	draw();
}

void Block::move(int dx, int dy)
{
	x=x+dx;
	y=y+dy;
	dbInk(color, Grey);
	draw();
}

//End Method (Block)

class Shape {

private:
	Block blocks[4];
	//int pos[8];
public:
	int pos[8];
	DWORD color;
    Shape();
	void make_ishape();
	void make_oshape();
	void make_jshape();
	void make_lshape();
	void make_tshape();
	void make_zshape();
	void make_sshape();
	void move_shape(int,int);
	void draw_shape();
	bool col(int,int);
	bool colnew(int,int);
	void rotate_shape();
	//void rotate_zshape();
	//void rot(int,int);
	
};
//Methods (Shape)
Shape::Shape() {
blocks[0] = Block(0,0, White);
blocks[1] = Block(0,0, White);
blocks[2] = Block(0,0, White);
blocks[3] = Block(0,0, White);
}
bool Shape::col(int dx, int dy)
{
	for (int i=0; i<=4; i++)
	{
		if (blocks[i].y + dy > 19 || blocks[i].x + dx < 0 || blocks[i].x +dx > 9)
		{
			return false;
		}
		
	}
	return true;
}
bool Shape::colnew(int dx, int dy)
{
	for (int i=0; i<=4; i++)
	{
		if (blocks[i].y + dy > 19)
		{
			return false;
		}
		
	}
	return true;
}



void Shape::make_ishape()
{
	blocks[0] = Block(pos[0],pos[1],Blue);
	blocks[1] = Block(pos[2],pos[3],Blue);
	blocks[2] = Block(pos[4],pos[5],Blue);
	blocks[3] = Block(pos[6],pos[7],Blue);
	
}
void Shape::make_oshape()
{
	blocks[0] = Block(pos[0],pos[1],Green);
	blocks[1] = Block(pos[2],pos[3],Green);
	blocks[2] = Block(pos[4],pos[5],Green);
	blocks[3] = Block(pos[6],pos[7],Green);
	
}
void Shape::make_jshape()
{
	blocks[0] = Block(pos[0],pos[1],Yellow);
	blocks[1] = Block(pos[2],pos[3],Yellow);
	blocks[2] = Block(pos[4],pos[5],Yellow);
	blocks[3] = Block(pos[6],pos[7],Yellow);
	
}
void Shape::make_lshape()
{
	blocks[0] = Block(pos[0],pos[1],Orange);
	blocks[1] = Block(pos[2],pos[3],Orange);
	blocks[2] = Block(pos[4],pos[5],Orange);
	blocks[3] = Block(pos[6],pos[7],Orange);
	
}
void Shape::make_tshape()
{
	blocks[0] = Block(pos[0],pos[1],Cyan);
	blocks[1] = Block(pos[2],pos[3],Cyan);
	blocks[2] = Block(pos[4],pos[5],Cyan);
	blocks[3] = Block(pos[6],pos[7],Cyan);
	
}
void Shape::make_zshape()
{
	blocks[0] = Block(pos[0],pos[1],Red);
	blocks[1] = Block(pos[2],pos[3],Red);
	blocks[2] = Block(pos[4],pos[5],Red);
	blocks[3] = Block(pos[6],pos[7],Red);
	
}
/*/void Shape::rotate_zshape()
{
	blocks[0] = Block(pos[0],pos[1],Red);
	blocks[1] = Block(pos[2],pos[3],Red);
	blocks[2] = Block(pos[4],pos[5],Red);
	blocks[3] = Block(pos[6],pos[7],Red);
}
	/*/
void Shape::make_sshape()
{
	blocks[0] = Block(pos[0],pos[1],Magenta);
	blocks[1] = Block(pos[2],pos[3],Magenta);
	blocks[2] = Block(pos[4],pos[5],Magenta);
	blocks[3] = Block(pos[6],pos[7],Magenta);
	
}
void Shape::draw_shape()
{
	for (int i=0; i<4; i++)
	{
		blocks[i].draw();
	}
}

void Shape::move_shape(int dx, int dy)
{
	for (int i=0; i<4; i++)
	{
		blocks[i].clear();
	}
	for (int i=0; i<4; i++)
	{
		blocks[i].move(dx,dy);
	}
}

void Shape::rotate_shape()
{
	for (int i=0; i<4; i++)
	{
		blocks[i].clear();
	}
	for (int i=0; i<4; i++)
	{
		blocks[i].rotation(blocks[1].x,blocks[1].y);

	}
	
}

class I_Shape: public Shape{
public:
	I_Shape(int,int);
	
private:
	DWORD color;
	//int pos[8];
};

//Methods (I_Shape)


I_Shape::I_Shape(int x, int y):Shape()
{

	color=Blue;
	pos[0]=x-1;
	pos[1]=y;
	pos[2]=x;
	pos[3]=y;
	pos[4]=x+1;
	pos[5]=y;
	pos[6]=x+2;
	pos[7]=y;
	make_ishape(); //makes I_Shape
}


class O_Shape: public Shape{
public:
	O_Shape(int,int);
private:
	DWORD color;
};
O_Shape::O_Shape(int x, int y):Shape()
{
	color=Red;
	pos[0]=x;
	pos[1]=y;
	pos[2]=x;
	pos[3]=y-1;
	pos[4]=x+1;
	pos[5]=y-1;
	pos[6]=x+1;
	pos[7]=y;
	make_oshape(); //makes O_Shape

}

class J_Shape: public Shape{
public:
	J_Shape(int,int);
private:
	DWORD color;
};
J_Shape::J_Shape(int x, int y):Shape()
{
	color=Yellow;
	pos[0]=x-1;
	pos[1]=y;
	pos[2]=x;
	pos[3]=y;
	pos[4]=x+1;
	pos[5]=y;
	pos[6]=x+1;
	pos[7]=y-1;
	make_jshape(); //makes I_Shape
}

class L_Shape: public Shape{
public:
	L_Shape(int,int);
private:
	DWORD color;
};
L_Shape::L_Shape(int x, int y):Shape()
{
	color=Orange;
	pos[0]=x+1;
	pos[1]=y;
	pos[2]=x;
	pos[3]=y;
	pos[4]=x-1;
	pos[5]=y;
	pos[6]=x-1;
	pos[7]=y-1;
	make_lshape(); //makes L_Shape
}

class T_Shape: public Shape{
public:
	T_Shape(int,int);
private:
	DWORD color;
};
T_Shape::T_Shape(int x, int y):Shape()
{
	color=Cyan;
	pos[0]=x-1;
	pos[1]=y;
	pos[2]=x;
	pos[3]=y;
	pos[4]=x;
	pos[5]=y-1;
	pos[6]=x+1;
	pos[7]=y;
	make_tshape(); //makes T_Shape
}

class Z_Shape: public Shape{
public:
	Z_Shape(int,int);
	//Rotate_Z(int,int);
private:
	DWORD color;
};
Z_Shape::Z_Shape(int x, int y):Shape()
{
	color=Red;
	pos[0]=x-1;
	pos[1]=y;
	pos[2]=x;
	pos[3]=y;
	pos[4]=x;
	pos[5]=y+1;
	pos[6]=x+1;
	pos[7]=y+1;
	make_zshape(); //makes Z_Shape
	
}
//new code 

Shape* random()
{
	int x=3;
	int y=1;
    Shape *currentshape;
	unsigned seed = time(0);

	srand(seed);

	int random = 1 + rand() % 6;
	switch (random)
	{
	case 1:
		currentshape = new I_Shape(x,y);
		break;
	case 2:
		currentshape = new L_Shape(x,y);
		break;
	case 3:
		currentshape = new J_Shape(x,y);
		break;
	case 4:
		currentshape = new Z_Shape(x,y);
		break;
	case 5:
		currentshape = new T_Shape(x,y);
		break;
	case 6:
		currentshape = new O_Shape(x,y);
		break;
	}
		return currentshape;
}


/*/class S_Shape: public Shape{
public:
	S_Shape(int,int);
private:
	DWORD color;
};
S_Shape::S_Shape(int x, int y):Shape()
{
	color=Magenta;
	pos[0]=x-1;
	pos[1]=y;
	pos[2]=x;
	pos[3]=y;
	pos[4]=x;
	pos[5]=y+1;
	pos[6]=x-1;
	pos[7]=y+1;
	make_sshape(); //makes S_Shape
}/*/

// the main entry point for the application is this function 
//(MAIN)
void DarkGDK ( void )
{
	dbInk(Grey,Grey);
	dbBox(0,0,200,400);
	
	//I_Shape First(3,1);
	//O_Shape First(3,1);
	//J_Shape First(3,1);
	//L_Shape First(3,1);
	//T_Shape First(3,1);
	//Z_Shape First(3,1);
	Shape *currentshape;
	currentshape=random();
	currentshape->draw_shape();
	
	// turn on sync rate and set maximum rate to 1 fps
	dbSyncOn   ( );
	dbSyncRate (1);
	//First.draw_shape();
	//First.move_shape(5,4);
	

	// our main loop
	while ( LoopGDK ( ) )
	{ 
		
		if (grid[20][10]!=Grey)
		{
			if (dbLeftKey())
			{
				if (currentshape->col(-1,0))
				{	
				currentshape->move_shape(-1,0);
				}
			}
			if (dbRightKey())
			{
				if (currentshape->col(1,0))
				{
				currentshape->move_shape(1,0);
				}
			}	

		
			if (dbDownKey())
			{
				if (currentshape->col(0,1))
				{
				currentshape->move_shape(0,1);		
				}
			}
			else if (currentshape->col(0,1))
				{
				currentshape->move_shape(0,1);		
				}
			else
			{
				currentshape=random();
			}
			if (dbUpKey())
			{
			//	if (First.col(0,1))
			//	{
				currentshape->rotate_shape();		
			//	}
			}
		}
		
		// update the screen
		dbSync ( );
		//dbWaitKey();
	}
	
	
	// return back to windows
	return;
}

[o3hC5Di1]

Hi there,

I don't see any "board" matrix in your code which stores the position of blocks.

Take a look at following tutorials, which will explain it to you in detail.
They don't use darkGDK, but the concepts should still apply.

http://javilop.com/gamedev/tetris-tutorial-in-c-platform-independent-focused-in-game-logic-for-beginners/
http://www.gamedev.net/topic/192483-tetris-clone-in-an-hour-with-c/

Hope that helps.

All the best,

NwN