Ejemplo n.º 1
0
void Creature::move(const Level& lvl, const std::vector<RObject*>& obstacles, const SDL_Rect* p_camera)
{
	if (m_keep_action) return;

	m_box.x += m_delta_x;
	if (lvl.outOfBoardersX(m_box) || isCollision(obstacles))
	{
		m_box.x -= m_delta_x;
	}
	else if (p_camera)
	{
		if (m_box.x < p_camera->x || m_box.x + m_box.w > p_camera->x + p_camera->w)
		{
			m_box.x -= m_delta_x;
		}
	}

	m_box.y += m_delta_y;
	if (lvl.outOfBoardersY(m_box) || isCollision(obstacles))
	{
		m_box.y -= m_delta_y;
	}
	else if (p_camera)
	{
		if (m_box.y < p_camera->y || m_box.y + m_box.h > p_camera->y + p_camera->h)
		{
			m_box.y -= m_delta_y;
		}
	}
}
Ejemplo n.º 2
0
/*
 * Moves the piece to rigth with collision detection
 * moving a piece is just a shift of the 4 chars of the piece
 */
void goRigth() {
    /* 
     * try to move piece only if it still fits in the field after rotation
     * the trick is check if one of the less significant bits of each char is equal to 1 
     */
    if (((actualPiece[0] | actualPiece[1] | actualPiece[2] | actualPiece[3]) & 0x01) == 0x00) {
        /*
         * first deletes the actual piece from the field and then
         * checks is there is no collision with the new position. if the
         * piece fits beetween the other pieces adds it to fild. else retores the original
         * piece if collides with other pieces 
         */
        deletePiece();                  // deletes the actual piece from field
        updateTempPiece();              // updates temp piece
        shiftRigth(tempPiece);          // shifts the temp piece
        if (isCollision() == 0x00) {    // no collision? shifts the actual piece
            shiftRigth(actualPiece);    //  and adds it to the field
            addPiece();
            updateTempPiece();
            pieceShift++;
        }
        addPiece();                     // no collision? replace the actual piece on field
        updateDisplayField();           // updates the display field
    }
}
Ejemplo n.º 3
0
/*
 * Rotates the actual piece CCW with collision detection
 * the rotation is just a piece layout change with the actual piecePos,
 * rotates only if is possible.
 */
void rotate() {

    char i = 0;
    // try to rotate piece only if it still fits in the field after rotation
    if (pieceNum != 0x00 && getMaxLeftShift() <= pieceShift && pieceShift <= getMaxRigthShift()) {

        /*
         * first deletes the actual piece from the field and then
         * checks is there is no collision with the new position. if the
         * piece fits beetween the other pieces adds it to fild. else retores the original
         * piece if collides with other pieces 
         */
        deletePiece();              // deletes the actual piece from field
        piecePos++;                 // increments the piece y position
        if (piecePos == 0x04) {     // controls the rotation position range
            piecePos = 0x00;
        }
        tempPiece[0] = pieces[pieceNum][piecePos][0]; // updates the temp piece
        tempPiece[1] = pieces[pieceNum][piecePos][1];
        tempPiece[2] = pieces[pieceNum][piecePos][2];
        tempPiece[3] = pieces[pieceNum][piecePos][3];

        if (pieceShift < 0x00) { // shifts the temp piece to actal x position
            for (i = (-1) * pieceShift; i > 0; i--) {
                shiftLeft(tempPiece);
            }
        } else {
            for (i = pieceShift; i > 0; i--) {
                shiftRigth(tempPiece);
            }
        }

        if (isCollision() == 0x00) { // no collision? aplies the new rotation position
            actualPiece[0] = pieces[pieceNum][piecePos][0];
            actualPiece[1] = pieces[pieceNum][piecePos][1];
            actualPiece[2] = pieces[pieceNum][piecePos][2];
            actualPiece[3] = pieces[pieceNum][piecePos][3];
            
            // shifts the new piece to the last X position
            if (pieceShift < 0x00) {
                for (i = (-1) * pieceShift; i > 0; i--) {
                    shiftLeft(actualPiece);
                }
            } else {
                for (i = pieceShift; i > 0; i--) {
                    shiftRigth(actualPiece);
                }
            }
        } else { // collision? just go back and aplies the last piece
            if (piecePos == 0x00) {
                piecePos = 0x03;
            } else {
                piecePos--;
            }
        }

        addPiece();
        updateDisplayField(); // updates the display field
    }
}
Ejemplo n.º 4
0
void Enemy::update() {

	m_velocity.setY(5);
	
	m_currentFrame = (int)((SDL_GetTicks() / 100) % m_numsprites);
	if (isCollision())
	{
		if (m_velocity.getX() <= 0) {
			
			if (flip == SDL_FLIP_NONE) {
				m_velocity.setX(-m_originalVelocity.getX());
				flip = SDL_FLIP_HORIZONTAL;
				m_position.setX(m_position.getX() + 2);
			}
			else {
				m_velocity.setX(m_originalVelocity.getX());
				flip = SDL_FLIP_NONE;
				m_position.setX(m_position.getX() - 2);
			}
		}
		collision = false;
	}

	CollisionObject::update();
}
Ejemplo n.º 5
0
void Enemy::checkCollision(visualObj *star) {
	bool interact = isCollision(star);
	int healthColor = (105 + health * 50);

	///Enemy interection with star
	if (interact == true) {
		if (collisionTimer == 0)
			health--;
		if (health == 0 && respawnTimer == 0)	///If enemy has no health left
			respawnTimer = rand_int(5, 8) * 1000;	//Generates a random time for the enemy to respawn
		setColor(255, 0, 0);					//Enemy Collision [Damage taken, changes Red]
		collisionTimer = 400;					//Enemy turns red for certain period of time based on this
	}
	///Collision Timer counts down/makes enemy red
	if (collisionTimer > 0)
		collisionTimer--;							//Collision Timer count down
	else if (collisionTimer == 0)
		setColor(255, healthColor, healthColor);	//Changes enemy's color back after certain period of time
	///Respawn Timer
	if (respawnTimer > 0)
		respawnTimer--;	//Counts Down
	else if (respawnTimer == 0 && dead == true)
		respawn();		//Respawns after timer is up

	death();	//If Health = 0, Enemy is Dead
}
Ejemplo n.º 6
0
bool Exporter::isMeshGroup(INode *maxNode, bool root)
{
	if (root)
	{
		if (!maxNode->IsGroupHead())
			return false;
	} 
	else
	{
		if (!isCollision(maxNode))
		{
			TimeValue t = 0;
			ObjectState os = maxNode->EvalWorldState(t); 
			if (os.obj->SuperClassID() == GEOMOBJECT_CLASS_ID)
				return true;
		}
	}

	for (int i=0; i<maxNode->NumberOfChildren(); i++) 
	{
		if (isMeshGroup(maxNode->GetChildNode(i), false))
			return true;
	}

	return false;
}
Ejemplo n.º 7
0
/*Larger operation to perform than the other collision tests
 *due to it being a little more complex. Therefore encapsulate
 *it into a separate function for readability.*/
int isSailCollision(struct vertex projPos, struct vertex sailCenter)
{
    if(isCollision(projPos, sailCenter, RADIUS, SAIL_SIZE))
    {
        int startfrom = 0;

        for(int j = 0; j < NUM_SHADOWS; j++)
        {
            /*Shadow breaks holds the integers where one shadow stops and another
             *should begin. That is why the startfrom variable is included to return
             *k to the value it was before the previous iteration completed.*/
            for(int k = startfrom; k < globalGeometry.shadowBreaks[j]; k++, startfrom++)
            {
                struct vertex sail;
                
                sail.x = globalGeometry.shadow[k].x * (SAIL_SIZE + 0.001);
                sail.y = globalGeometry.shadow[k].y * (SAIL_SIZE + 0.001);
                sail.z = globalGeometry.shadow[k].z;
                
                float dist = distance(projPos, sail);
                
                /*Magic number which seems to work well.*/
                if(dist <= SAIL_COLLISION_DIST)
                    return TRUE;
            }
        }
    }
    return FALSE;
}
Ejemplo n.º 8
0
///
// Recalculate and set the lowest valid Y position for the current piece.
///
void updateHardDropY(FSEngine *f)
{
    int y = f->y;
    while (!isCollision(f, f->x, y, f->theta)) {
        y += 1;
    }

    f->hardDropY = y - 1;
}
Ejemplo n.º 9
0
        void Player::actionIfCollision(Ball &ball) {
            Uint16 ballY = ball.getY();
            if (isCollision(ball.getX(), ballY)) {
                Uint16 _y = y;
                double halfY = _y + HEIGHT/2;
                double influence = (30 * (ballY - halfY) / (HEIGHT/2)) * M_PI / 180;

                ball.changeAngle(influence, velocityY);
            }
        }
Ejemplo n.º 10
0
bool J2DPhysicalGameObject::checkSupportedByObject(J2DGameObject* target) {
	Uint32 dir = isCollision(*target->getInnerRect(), *this->getInnerRect());
	if (dir == JLIB_COLLIDE_BOTTOM || dir == JLIB_COLLIDE_BOTTOMLEFT
			|| dir == JLIB_COLLIDE_BOTTOMRIGHT || dir == JLIB_COLLIDE_RIGHT
			|| dir == JLIB_COLLIDE_LEFT)
	{
		return true;
	}
	return false;
}
Ejemplo n.º 11
0
void BattleScene::createNPCs()
{
	BricksVec freeBricks;
	std::copy_if(_bricks.begin(), _bricks.end(), back_inserter(freeBricks), [this](Brick* brick) { 
		bool canCreate = true;
		for (auto player : _players)
		{
			if (isCollision(brick, player, Size(240, 240)))
			{
				canCreate = false;
				break;
			}
		}
		return brick->getType() == EBACKGROUND && canCreate; });
	std::random_shuffle(freeBricks.begin(), freeBricks.end());

	auto vec = NPCManager::Instance()->createNPCs(accordion, 4);
	for (size_t i = 0; i < vec.size(); i++)
	{
		setDefaultParametrNpc(vec[i], freeBricks[i]->getPosition());
	}

	BricksVec bricks;
	std::copy_if(_bricks.begin(), _bricks.end(), back_inserter(bricks), [this](Brick* brick) {
		bool canCreate = true;
		for (auto player : _players)
		{
			if (isCollision(brick, player, Size(240, 240)))
			{
				canCreate = false;
				break;
			}
		}
		return brick->getType() != EBRICK && canCreate; });
	std::random_shuffle(bricks.begin(), bricks.end());

	vec = NPCManager::Instance()->createNPCs(brush, 2);
	for (size_t i = 0; i < vec.size(); i++)
	{
		setDefaultParametrNpc(vec[i], bricks[i]->getPosition());
	}
}
Ejemplo n.º 12
0
void moveDown()
{
	currentBlock.position.y++;

	if (isCollision() == 1)
	{		
		currentBlock.position.y--;
		setBlockInCanvas();
		resetBlock();
	}
}
Ejemplo n.º 13
0
/* Checks if direction is OK for moving (no collision, stc.) */
int dbDirSucceeded(t_Direction dir)
{
    switch(dir)
    {
        case DIR_UP:
            return  (isCollision(   currentLevel.DrunkenBots[0].posX,
                                    currentLevel.DrunkenBots[0].posY-STEP) |
                                    isOutOfBounds(currentLevel.DrunkenBots[0].posX,
                                                  currentLevel.DrunkenBots[0].posY-STEP)) ?
                                                        0 : 1;
                                                        break;

        case DIR_RIGHT:
            return  (isCollision(   currentLevel.DrunkenBots[0].posX+STEP,
                                    currentLevel.DrunkenBots[0].posY) |
                                    isOutOfBounds(currentLevel.DrunkenBots[0].posX+STEP,
                                                  currentLevel.DrunkenBots[0].posY)) ?
                                                        0 : 1;
                                                        break;

        case DIR_DOWN:
            return  (isCollision(   currentLevel.DrunkenBots[0].posX,
                                    currentLevel.DrunkenBots[0].posY+STEP) |
                                    isOutOfBounds(currentLevel.DrunkenBots[0].posX,
                                                  currentLevel.DrunkenBots[0].posY+STEP)) ?
                                                        0 : 1;
                                                        break;

        case DIR_LEFT:
            return  (isCollision(   currentLevel.DrunkenBots[0].posX-STEP,
                                    currentLevel.DrunkenBots[0].posY) |
                                    isOutOfBounds(currentLevel.DrunkenBots[0].posX-STEP,
                                                  currentLevel.DrunkenBots[0].posY)) ?
                                                        0 : 1;
                                                        break;

        default: return 1;
    }

    return 1;
}
Ejemplo n.º 14
0
void calcBallPosition(ball *aBall, paddle *p1, paddle *p2){
  uint32_t collisionType = isCollision(aBall,p1,p2);
  uint32_t blue = 0x000099; //black = 0x0;

  if (collisionType == P1){
    if( p1->direction == UP ) {
      aBall->vY = aBall->vY - 1;
      aBall->vX = -aBall->vX;
    } 
    else if( p1->direction == DOWN ) {
      aBall->vY = aBall->vY + 1;
      aBall->vX = -aBall->vX;
    }
    else if( p1->direction == IDLE ) {
      aBall->vY = aBall->vY;
      aBall->vX = -aBall->vX;
    }
  } 
  else if (collisionType == P2){
    if( p2->direction == UP ) {
      aBall->vY = aBall->vY - 1;
      aBall->vX = -aBall->vX;
    } 
    else if( p2->direction == DOWN ) {
      aBall->vY = aBall->vY + 1;
      aBall->vX = -aBall->vX;
    }
    else if( p2->direction == IDLE ) {
      aBall->vY = aBall->vY;
      aBall->vX = -aBall->vX;
    }
  }

  ballInBounds(aBall);

  // erase ball
  drawBall(blue,aBall);  

  // calculate new positions
  aBall->x = aBall->x + aBall->vX;
  aBall->y = aBall->y + aBall->vY;
  
  updateFrame(p1->y, p2->y, aBall->x, aBall->y, aBall, p1, p2);

  if ( !isXInBounds( aBall->x ) ) {

    if ( aBall->vX == VEL_X ) {
      p1->score = p1->score + 1;
    } else p2->score = p2->score + 1;

    initializeGame(aBall, p1, p2);
  }
}
Ejemplo n.º 15
0
void fetchUserInput()
{

	Block orgBlock = currentBlock;

	if (gameState == 0)
	{
		switch (getch())
		{
			case KEY_LEFT:
				moveLeft();
				break;

			case KEY_RIGHT:
				moveRight();
				break;

			case KEY_UP:
				rotateBlock();
				break;

			case KEY_DOWN:
				moveDown();
				break;

			case 'p':
				gameState = 1;
				break;
		}
	} else {
		switch (getch())
		{
			case 'p':
				if (gameState == 1)
				{
					gameState = 0;
				}
				break;
			case 'r':
				resetGame();
				break;
			case 'q':
				inGame = 0;
				break;
		}
	}

	if (isCollision())
	{
		currentBlock = orgBlock;
	}
}
Ejemplo n.º 16
0
/*Find the sum of the radii of a projectile
 *and given base.*/
int isBaseCollision(struct projectile proj, struct vertex base, 
                    char color)
{
    /*Base = RADIUS * BASE_SIZE as it's been scaled.*/
    float baseRadius = RADIUS * BASE_SIZE;
   
    /*Projectile has original radius size.*/
    int collided = isCollision(proj.position, base, RADIUS, baseRadius);
    
    if(collided && proj.color != color)
        return TRUE; 
    return FALSE; 
}
Ejemplo n.º 17
0
void GameMainLayer::update(float time)
{
    if (hero->state == 0)
        this->isHeroDrop();
    CCPoint pos1 = (map->getChildByTag(0))->getPosition();
    CCPoint pos2 = (map->getChildByTag(1))->getPosition();
    //检测主角是否吃到星星
    for (int i = 0; i < 5; i++) {
        if (pos1.x <= 100 && (pos1.x + 480) >= 100) {
            GameObjStar *star = (GameObjStar *)(map->stars1)->objectAtIndex(i);
            if (star->get_visible() && isCollision(ccp(100,hero->getPosition().y + 62.5), ccp(pos1.x + 86 + 96*i, 280), 40, 35, 18.25, 17.75)) {
                star->set_visible(false);
                gameMark->addNumber(100);
            }
        } else {
            GameObjStar *star = (GameObjStar *)(map->stars2)->objectAtIndex(i);
            if (star->get_visible() && isCollision(ccp(100,hero->getPosition().y + 62.5), ccp(pos2.x + 86 + 96*i, 280), 40, 35, 18.25, 17.75)) {
                star->set_visible(false);
                gameMark->addNumber(100);
            }
        }
    }
}
Ejemplo n.º 18
0
    bool makeRoomSilentlyFail( Level & level, uint32_t & gen, OcclusionBuffer& occ ) {
        uint32_t x( nextRandomGenerator_( gen ) % TILE_DIM );
        uint32_t y( nextRandomGenerator_( gen ) % TILE_DIM );
        uint32_t w( (nextRandomGenerator_( gen ) % RESTWIDMAX) + WIDMIN );
        uint32_t h( (nextRandomGenerator_( gen ) % RESTWIDMAX) + WIDMIN );

        if( (x+w) < TILE_DIM-1 && (y+h) < TILE_DIM-1 && x != 0 && y != 0 &&
            !isCollision( x, y, w, h, occ ) ) {
                occ.Occlude(x, y, x+w, y+h);
                level.rooms.emplace_back(x, y, w, h, (uint32_t)(level.rooms.size() + 1));
                return true;
        }
        return false;
    }
Ejemplo n.º 19
0
void Tetromino::computeTargetNodePos(const int* bgInfo)
{
	m_targetRow = m_row;
	int rowTest = m_targetRow-1;
	
	while(!isCollision(m_col,rowTest,m_rotate,bgInfo))
	{
		m_targetRow = rowTest;
		rowTest--;
	}

	if(m_targetBlockNode)
		m_targetBlockNode->setPosition(Vec2(-m_blockSize*m_col,m_blockSize*m_targetRow));
}
Ejemplo n.º 20
0
void Timer(int)
{
	if (ball.active)
	{
		ball.move();
		//collision with a block
		for (int i = 0; i < 10; i++)
		{
			for (int j = 0; j < 15; j++)
			{
				Brick &b = brick[i][j];
				if (isCollision(ball, b))
				{
					//if a ball is above or below
					if (fabs(ball.x - b.col*b.w - b.w / 2) < fabs(ball.y - b.row*b.h - b.h / 2))
					{
						ball.dy *= -1;
					}
					//if a ball is left or right
					else if (fabs(ball.x - b.col*b.w - b.w / 2) > fabs(ball.y - b.row*b.h - b.h / 2))
					{
						ball.dx *= -1;
					}
					//a ball is on the diagonal side of the block 
					else
					{
						if (ball.dx>0)
						{
							if (ball.x < b.col*b.w + 1) ball.dx *= -1;
						}
						else if (ball.x >(b.col + 1)*b.w - 1) ball.dx *= -1;
						if (ball.dy>0)
						{
							if (ball.y < b.row*b.h + 1) ball.dy *= -1;
						}
						else if (ball.y >(b.row + 1)*b.h - 1) ball.dy *= -1;
					}
					//If "life" block is equal to 0
					if (--b.hit == 0)
					{
						b.active = false;
					}
				}
			}
		}
	}
    Draw();
	glutTimerFunc(33, Timer, 0);
}
Ejemplo n.º 21
0
/*Test whether this projectile has collided with any others.
 *Return the position of the other projectile it collided with.
 *This function will return NO_COLLISION if no collision occured.*/
int projectileCollided(struct vertex projPos, int posIndex)
{
    for(int i = 0; i < globalProjectile.pIndex; i++)
    {
        /*If i and posIndex are the same then its the same 
         *projectile and the loop should skip it.*/
        if(i == posIndex)
            continue;

        if(isCollision(projPos, globalProjectile.projectiles[i].position,
                    RADIUS, RADIUS))
            return i;
    }
    return NO_COLLISION;
}
Ejemplo n.º 22
0
/*Check whether any collisions occurred.*/
void checkForCollisions()
{
    struct vertex center = {0.0, 0.0, 0.0};
  
    for(int i = 0; i < globalProjectile.pIndex; i++)
    {
        struct vertex projPos = globalProjectile.projectiles[i].position;

        checkBaseCollisions(globalProjectile.projectiles[i], i);
       
        /*Test for outer ring collision. Negate the collision result 
         *to get when the sum of the radii is less than the distance.*/
        if(!isCollision(projPos, center, RADIUS, RING_SIZE))
            handleCollision(i);

        /*Test sun collision.*/
        if(isCollision(projPos, center, RADIUS, RADIUS))
            handleCollision(i);

        /*Test for sail collision.*/
        if(isSailCollision(projPos, center))
            handleCollision(i);

        /*Test if this projectile colllided with another projectile.*/
        int collided = projectileCollided(projPos, i);
        if(collided != NO_COLLISION)
        {
            printf("Got a collision! Proj:%d\n", i);
            deleteProjectile(i);
            /*Subtract 1 as the previously deleted projectile
             *will move the array one step to the left.*/
            deleteProjectile(collided - 1);
            playCrashSound();
        }
    }
}
Ejemplo n.º 23
0
void Player::processInput(Display* display) {
	
	toBoat(display);

	if(keyboard->getState(SDLK_x) && !left_projectile->isActive() && shipState) {
		fireProjectile();
	} 

	if(keyboard->getState(SDLK_UP)) { 
		direction = 0;
		if(!isCollision(display)) {
			y--;
		}
	}

	else if(keyboard->getState(SDLK_DOWN)) {
		direction = 2;
		if(!isCollision(display)) {
			y++;
		}
	}
	
	else if(keyboard->getState(SDLK_LEFT)) {
		direction = 3;
		if(!isCollision(display)) {
			x--;
		}
	}
	
	else if(keyboard->getState(SDLK_RIGHT)) {
		direction = 1;
		if(!isCollision(display)) {
			x++;
		}
	}
}
Ejemplo n.º 24
0
bool Tetromino::drop(const int* bgInfo)
{
	int rowTest = m_row-1;
	
	if(!isCollision(m_col,rowTest,m_rotate,bgInfo))
	{
		m_row = rowTest;

		m_curBlockNode->setPosition(Vec2(-m_blockSize*m_col,m_blockSize*m_row));

		return true;
	}

	return false;
}
Ejemplo n.º 25
0
bool Tetromino::setRow(int r,const int* bgInfo) 
{
	if(!isCollision(m_col,r,m_rotate,bgInfo))
	{
		m_row = r;

		m_curBlockNode->setPosition(Vec2(-m_blockSize*m_col,m_blockSize*m_row));

		if(m_targetBlockNode)
			computeTargetNodePos(bgInfo);

		return true;
	}

	return false;
}
/**
 * Method is used to detect collision. Use Bounding Box algorithm.
 */
void CollisionDetector::detectCollision()
{
    vector< boost::shared_ptr<SceneEntity> >* scene = gameScene->getWorldScene();

    unsigned int size = scene->size();

    for(unsigned int i = 0; i < size; ++i)
    {
        BoundingBox firstBox;
        firstBox.max =  scene->at(i).get()->getBoundingBox()->max;
        firstBox.min =  scene->at(i).get()->getBoundingBox()->min;
        firstBox.max += scene->at(i).get()->position;
        firstBox.min += scene->at(i).get()->position;

        bool firstHaveCollided = scene->at(i).get()->haveCollided;

        for(unsigned int j = 3; j < size; ++j)
        {
            if(i == j)
                continue;

            BoundingBox secondBox;
            bool secondHaveCollided = scene->at(j).get()->haveCollided;

            secondBox.max =  scene->at(j).get()->getBoundingBox()->max;
            secondBox.min =  scene->at(j).get()->getBoundingBox()->min;
            secondBox.max += scene->at(j).get()->position;
            secondBox.min += scene->at(j).get()->position;

            Faction atypeID_1 = scene->at(i).get()->faction;
            Faction atypeID_2 = scene->at(j).get()->faction;

            if(isCollision(firstBox,secondBox))
            {
                scene->at(i).get()->haveCollided = true;
                scene->at(j).get()->haveCollided = true;
                //handler->collisionCollection.push_back(Collision(scene->at(j).get()->position,i,j));
                Faction typeID_1 = scene->at(i).get()->faction;
                Faction typeID_2 = scene->at(j).get()->faction;

                handler->collisionCollection.push_back(
                    createCollisionObject(typeID_1, typeID_2, scene->at(j).get()->position, i, j, gameScene));
            }
        }
    }
}
Ejemplo n.º 27
0
    void makeRoomSilentlyFail( Level & level )
    {
        uint32_t r1 = nextRandomGenerator_();
        uint32_t r2 = nextRandomGenerator_();
        uint32_t x( r1 % TILE_DIM );
        uint32_t y( r2 % TILE_DIM );
        uint32_t w( (r1 % MAXWID) + MIW );
        uint32_t h( (r2 % MAXWID) + MIW );

        if( (x+w) >= TILE_DIM || (y+h) >= TILE_DIM || x == 0 || y == 0 ) return;

        if( !isCollision( level.rooms, x, y, w, h ) )
        {
            Room r( x, y, w, h, level.rooms.size() + 1 );
            level.rooms.push_back( r );
        }
    }
Ejemplo n.º 28
0
void spawnNewBlock()
{
	if (isGameMoving() == 0)
	{
		if (currentBlockInBatch >= 7)
		{
			createNewBlockBatch();
			currentBlockInBatch = 0;
		}
		currentBlock = blockBatch[currentBlockInBatch];
		currentBlockInBatch++;
	}
	if (isCollision())
	{
		gameState = 2;
	}
}
Ejemplo n.º 29
0
bool Tetromino::move(bool bLeft,const int* bgInfo)
{
	int colTest = bLeft ? m_col+1 : m_col-1;
	
	if(!isCollision(colTest,m_row,m_rotate,bgInfo))
	{
		m_col = colTest;
		
		m_curBlockNode->setPosition(Vec2(-m_blockSize*m_col,m_blockSize*m_row));

		if(m_targetBlockNode)
			computeTargetNodePos(bgInfo);

		return true;
	}

	return false;
}
Ejemplo n.º 30
0
vector findCollisionLineToBox(line l1, box b2){
	vector l[] = { l1.pE1->position,
		l1.pE2->position,
	};
	box b1;
	b1.position = { ((l[0].x + l[1].x) / 2), ((l[0].y + l[1].y) / 2) };
	if ((l[0].x - l[1].x) == 0)
		b1.rotation = 0;
	else
		b1.rotation = atan2((l[0].x - l[1].x), (l[0].y - l[1].y));

	b1.width = { sqrt(pow(l[0].x - l[1].x, 2) + pow(l[0].y - l[1].y, 2)), 2.0 };

	

	if (isCollision(b1, b2)){
		vector vertexs[4];
		b2.getVertexs(vertexs);
		vector l[] = { l1.pE1->position,
			l1.pE2->position,
			vertexs[1],
			vertexs[2],
			vertexs[3],
			vertexs[0]
		};
		double temp[] = { getDistanceBetweenPointAndLine(l[0].x, l[0].y, l[2].x, l[2].y, l[3].x, l[3].y),
			getDistanceBetweenPointAndLine(l[1].x, l[1].y, l[2].x, l[2].y, l[3].x, l[3].y),
			getDistanceBetweenPointAndLine(l[2].x, l[2].y, l[0].x, l[0].y, l[1].x, l[1].y),
			getDistanceBetweenPointAndLine(l[3].x, l[3].y, l[0].x, l[0].y, l[1].x, l[1].y)
		};
		double shortDistance = temp[0];
		int index = 0;
		for (int i = 1; i < 4; i++){
			if (shortDistance>temp[i]){
				shortDistance = temp[i];
				index = i;
			}
		}
		return l[index];
	}

	return vector();

}