Beispiel #1
0
void Car::update(GLdouble delta_t) {
    if(_left_pressed == true && _right_pressed == false) {
        turn(1, delta_t);
        _front_wheel_rotation = 50;
    }
    else if(_left_pressed == false && _right_pressed == true) {
        turn(-1, delta_t);
        _front_wheel_rotation = -50;
    }
    else {
        _front_wheel_rotation = 0;
        turn(0, delta_t);
    }


    if(_up_pressed == true && _down_pressed == false) {
        move(1, delta_t);
    }
    else if (_up_pressed == false && _down_pressed == true) {
        move(-1, delta_t);
    }
    else {
        move(0, delta_t);
    }

    if (checkOutOfBounds() == true) {
        GameManager::getCurrentInstance()->GGWP();
    }
}
Beispiel #2
0
void Bakoom::timerEvent(QTimerEvent *event)
{
    // create random scenery
    createRandomScenery();
    // level 6 and 7 enemy spawns
    if(level >= 6)
        for(int i = 0; i < enemies_.size(); i++)
            if(rand()%1000 < 5 && enemies_.size() <= 12) enemies_.push_back(new Interceptor(enemies_.at(i)->getRect().x(), enemies_.at(i)->getRect().y()));
    // move scenery
    for(int i = 0; i < scenery_.size(); i++)
        scenery_.at(i)->autoMove();
    // move enemies
    moveEnemies();
    // make enemies shoot
    createEnemyProjectiles();
    // automove credits
    for(int i = 0; i < credits_.size(); i++)
        credits_.at(i)->autoMove();
    // automove medipaks_
    for(int i = 0; i < medipaks_.size(); i++)
        medipaks_.at(i)->autoMove();
    // automove projectiles_
    for(int i = 0; i < projectiles_.size(); i++)
    {
        // homing projectiles_
        if(projectiles_.at(i)->isHoming())
        {
            int proj_x = projectiles_.at(i)->getRect().x(), proj_y = projectiles_.at(i)->getRect().y();
            int enem_x = nearestEnemyTo(proj_x, proj_y)->getRect().x(), enem_y = nearestEnemyTo(proj_x, proj_y)->getRect().y();
            if(distanceBetween(enem_x, enem_y, proj_x, proj_y) < 250)
            {
                if(projectiles_.at(i)->isEnemyProjectile())
                    enem_x = player_ ->getRect().x();
                if(enem_x+40 > proj_x) projectiles_.at(i)->setXdir(1);
                else if(enem_x-40 < proj_x) projectiles_.at(i)->setXdir(-1);
                else projectiles_.at(i)->setXdir(0);
            }
        }
        projectiles_.at(i)->autoMove();
    }
	checkCollision();
	checkOutOfBounds();
	deleteDead();
    // check for win condition
    if(enemies_.size() == 0 && credits_.size() == 0)
    {
        shield = player_ ->getHealth();     // update shield variable before exiting
        qApp->exit();
    }
    // auto heal if applicable
    if(hasItem[15])
        autoHeal();
    playerKeyEvents();
	//deleteDead();
    // move player
    player_->autoUpdateRect();
    spawnMedipaks();
	repaint();
}
Beispiel #3
0
void Butter::update(GLdouble delta_t) 
{
	
	DynamicObject::update(delta_t);

	if (checkOutOfBounds() == true)
        DynamicObject::reset();
}
Beispiel #4
0
void Orange::update(GLdouble delta_t)
{
	_speed = _speed_modifier*_base_speed;
	//setPosition(_position._x + _speedModifier*_speed*delta_t*_direction._x , _position._y,
		//_position._z + _speedModifier*_speed*delta_t*_direction._z);
	DynamicObject::move(delta_t);

	_rotation.set(_direction._z, _direction._y,- _direction._x);
	_rotangle += delta_t*50*_speed;

	if (checkOutOfBounds() == true) {
		_draw = false;
		setOrangeRespawnCallback();
		setPosition(0, 0, 0);
    }
}
void main()
	{
	menu();
	while(true){
	sf::Clock clock, clockInvincible;
    score1 = 0;
	int  xBlock, yBlock, x, y, seconds = 0, red, green, blue;
	int direction = 0, directionOfBack = 0, size;
	bool checkGameOver = false, outOfBounds = false, restarter = false, breaker = false;
			size = Robjects.size();
			Robjects.erase(Robjects.begin()+0, Robjects.begin()+size);
			window.clear();
	//---------------------------------------------------------------------------
	//sf::RenderWindow window(sf::VideoMode(600, 500), "Testing");
	//---------------------------------------------------------------------------
	event.type = sf::Event::Count;
	sf::RectangleShape square(sf::Vector2f(sizex, sizey));
	square.setFillColor(sf::Color(200, 60, 0));
	square.setOutlineThickness(2);
    square.setOutlineColor(sf::Color(140, 30, 0));
	//---------------------------------------------------------------------------
	sf::RectangleShape egg(sf::Vector2f(sizex + 2, sizey + 2));
	egg.setFillColor(sf::Color(red, green, blue));
	egg.setOutlineThickness(2);
    egg.setOutlineColor(sf::Color(200, 200, 200));
	//---------------------------------------------------------------------------
	setAll(x, y, xBlock, yBlock);
	//---------------------------------------------------------------------------
  	egg.setPosition(xBlock, yBlock);
	//---------------------------------------------------------------------------
	setEgg(red, green, blue);
 while(window.isOpen())
	  {
		  if(invincible1 == true){
			  invincible2(x, y);
		for(int i = 0; i < Robjects.size(); i++){
	Robjects[i].setFillColor(sf::Color(200, 50, 50));
	Robjects[i].setOutlineThickness(2);
    Robjects[i].setOutlineColor(sf::Color(40, 40, 40));
		}
		  }
		  else 
              outOfBounds = checkOutOfBounds(x , y);

	sf::Time elapsed1 = clock.getElapsedTime();
	seconds = elapsed1.asMilliseconds();
	//---------------------------------------------------------------------------
    restarter = updateGame(x, y, xBlock, yBlock, direction, directionOfBack, checkGameOver, seconds, red, green, blue);

	egg.setFillColor(sf::Color(red, green, blue));
	if(restarter == true)
	clock.restart();
	directionOfBack = CreateTail(x, y, direction, checkGameOver, false);
   	//---------------------------------------------------------------------------
	if((x % 25 == 0)&&(y % 25 == 0)){
		//------------------------------------------------------------
		  while(window.pollEvent(event)) {
			  if(event.type == sf::Event::Closed){
			size = Robjects.size();
			Robjects.erase(Robjects.begin()+0, Robjects.begin()+size);
				  window.close();

			  }
			  //---------------------------------------------------------------------
			  if((event.key.code == sf::Keyboard::P)&&(event.type == sf::Event::KeyPressed)){
			  window.draw(square);
			  for(int i = 0; i < Robjects.size(); i++)
			  window.draw(Robjects[i]);

			  if(eggs == true){}
			  else
			  window.draw(egg);

			  window.draw(score);
		      window.display();
				  while(true){
			  while(window.pollEvent(event)) {
			  if((event.key.code == sf::Keyboard::P)&&(event.type == sf::Event::KeyPressed))
				  breaker = true;
			  			  }
			  if(breaker == true)
				  break;
			  }
			  }
				  breaker = false;
				  event.key.code == sf::Keyboard::Q;
			  if(event.type == sf::Event::KeyPressed){
			  direction = move(direction, x, y);
			  square.setPosition(x,y);
			  }
		    }
		  }
	//---------------------------------------------------------------------------
		if((checkGameOver == true)||(outOfBounds == true))
		{
			  window.clear();
		      window.draw(square);
			  for(int i = 0; i < Robjects.size(); i++)
			  window.draw(Robjects[i]);
			  window.draw(egg);
			  window.draw(score);
			  window.draw(gameOver);
              exit();
			  window.clear();
			  menu();
			  break;
		 }
	//---------------------------------------------------------------------------
		  square.setPosition(x,y);
		  egg.setPosition(xBlock, yBlock);

		  	  window.clear();
		      window.draw(square);
			  for(int i = 0; i < Robjects.size(); i++)
			  window.draw(Robjects[i]);

			  if(eggs == false){
				    window.draw(egg);
			  }
			  else{
		for(int i = 0; i < 120; i++)
		window.draw(egger[i]); 
			  }
			  			if(invincible == true)
	{
			invincible3.setString("I");
	        invincible3.setFont(font);
	        invincible3.setCharacterSize(10);
	        invincible3.setColor(sf::Color(255, 255, 255));
	        invincible3.setPosition(xBlock + 4, yBlock + 4);
			window.draw(invincible3);
	}
			  window.draw(score);
		      window.display();
			  if(eggs == true)
				  sf::sleep(sf::seconds(.0009));
			  else
			 sf::sleep(sf::seconds(.003));
	  }
}
    //return 0;
}
Beispiel #6
0
void Projectile::updateCurrent(sf::Time dt){
    move(getVelocity() * dt.asSeconds());
    checkOutOfBounds();

}