detekcja kolizji:

bool IfCOllides1d(double p1, double p2, double p3, double p4){
	std::pair<double,double> first, second;
	if(p1 < p3){
		first=std::make_pair(p1,p2);
		second=std::make_pair(p3,p4);
	}
	else{
		first=std::make_pair(p3,p4);
		second=std::make_pair(p1,p2);
	}
	return (second.first-first.first) < (first.second - first.first);
}

bool Block::IfCollides(const Block& b2){
	if (!this->isColliding || !b2.isColliding){
		return false;
	}

	auto p1 = this->_pos.x + this->_movingVec.x;
	auto p2 = this->_pos.x + this->_size.x + this->_movingVec.x;
	auto p3 = b2._pos.x + b2._movingVec.x;
	auto p4 = b2._pos.x + b2._size.x + b2._movingVec.x;
	bool IfCOllidesX=IfCOllides1d(p1,p2,p3,p4);

	p1 = this->_pos.y + this->_movingVec.y;
	p2 = this->_pos.y + this->_size.y + this->_movingVec.y;
	p3 = b2._pos.y + b2._movingVec.y;
	p4 = b2._pos.y + b2._size.y + b2._movingVec.y;
	bool IfCOllidesY=IfCOllides1d(p1,p2,p3,p4);

	return IfCOllidesX && IfCOllidesY;
}


rozwiązywanie ich:
// run it when you are sure there is a collision
void Engine::ResolveCollision(size_t b1, size_t b2){
	// define rectangle as 2 points on cartesian space
	auto a=level.Objects[b1]->_pos;
	auto b=level.Objects[b1]->_pos + level.Objects[b1]->_size;

	auto c=level.Objects[b2]->_pos;
	auto d=level.Objects[b2]->_pos + level.Objects[b2]->_size;
	double scale=1.0;

	// pythagoras theorem
	double vecLength=sqrt(	level.Objects[b1]->_movingVec.x *
			level.Objects[b1]->_movingVec.x +
			level.Objects[b1]->_movingVec.y *
			level.Objects[b1]->_movingVec.y	);
	double limit=0;
	if(b.x <= c.x || a.x >= d.x){
		if(a.x <= c.x){
			// collision from left side
			limit=c.x-b.x;
		}
		else{
			// collision from right side
			limit=a.x-d.x;
		}
	}
	else{
		if(a.y <= c.y){
			// collision from upper side
			limit=c.y-b.y;
		}
		else{
			// collision from down side
			limit=a.y-d.y;
		}
	}
	if(vecLength != 0.0){ scale=limit/vecLength; };
	level.Objects[b1]->_movingVec *=scale;
	level.Objects[b2]->_movingVec *=scale;
}

void Engine::UpdateCollisions(){
	//std::cout<<level.Objects.size()<<std::endl;
	for(size_t p1=0; p1<level.Objects.size(); ++p1){
		for(size_t p2=p1+1; p2<level.Objects.size();++p2){
			if(level.Objects[p1]->IfCollides(*level.Objects[p2])){
				ResolveCollision(p1,p2);
			}
		}
		level.Objects[p1]->Update(renderer);
	}
}

bloki trzymam jako shared_ptr