Beispiel #1
0
void checkExplosion(int *indices, int num_indices)
{
	fprintf(flog,"checkExplosion start\n");
	int origin = *(jewels+indices[0]);
	if(num_indices>2)
	{
		if(origin & JEWEL_BOMB)
		{
			int col = indices[0] % 8;
			int row = indices[0] / 8;
			makeExplosion(origin,col,row);
		}
		for(int i=1;i<num_indices;++i)
		{
			int type = *(jewels+indices[i]);
			if(type & JEWEL_BOMB)
			{
				int col = indices[i] % 8;
				int row = indices[i] / 8;
				makeExplosion(type,col,row);
			}
			else
			{
				*(jewels+indices[i]) = 0;
			}
			fprintf(flog,"index:%d\n",indices[i]);
		}
	}
}
Beispiel #2
0
void makeExplosion(int type, int col, int row)
{
	fprintf(flog,"makeExplosion\n");
	if(type & JEWEL_DIR_NONE)
	{
		for(int i=-1;i<=1;i++)
		{
			for(int j=-1;j<=1;j++)
			{
				int neighbor_col = col + i;
				int neighbor_row = row + j;
				if( (neighbor_col >=0 && neighbor_col< NUM_COLS) && (neighbor_row >=0 && neighbor_row < NUM_ROWS) )
				{
					int index = neighbor_row * NUM_COLS + neighbor_col;
					if(neighbor_row == row && neighbor_col == col) 
						*(jewels+index) = 0;
					else if(*(jewels+index) & JEWEL_BOMB)
						makeExplosion(*(jewels+index),neighbor_col,neighbor_row);
					else
						*(jewels+index) = 0;
				}
			}
		}
	}
	else if(type & JEWEL_DIR_HERIZ)
	{
		for(int i=0;i<NUM_COLS;++i)
		{
			int index = row * NUM_COLS + i;
			if( (*(jewels+index) & JEWEL_BOMB) && i != col)
				makeExplosion(*(jewels+index),i,row);
			else
				*(jewels+index) = 0;
		}
	}
	else if(type & JEWEL_DIR_VERTI)
	{
		fprintf(flog,"verti Explosion\n");
		for(int i=0;i<NUM_COLS;++i)
		{
			int index = col + NUM_COLS * i;
			if((*(jewels+index) & JEWEL_BOMB) && i != row)
				makeExplosion(*(jewels+index),col,i);
			else
				*(jewels+index) = 0;
		}
	}
}
void blowUpRandomShape(void)
{
	if (finishedShapes.size() > 0) {
		int index = randFloat(0, finishedShapes.size() - 1);
		for (std::vector<Vertex>::iterator j = finishedShapes[index].vertices.begin(); j != finishedShapes[index].vertices.end(); j++) {
			makeExplosion(*j);
		}
		finishedShapes.erase(finishedShapes.begin() + index);
	}
}
 virtual void keyPressed(const KeyEventUnrecPtr e)
 {
     if(e->getKey() == KeyEvent::KEY_Q && e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
     {
         TutorialWindow->closeWindow();
     }
     switch(e->getKey())
     {
     case KeyEvent::KEY_S:
          {
              allPhysicsBodies.push_back(buildSphere());
          }
          break;
     case KeyEvent::KEY_B:
          {
              allPhysicsBodies.push_back(buildBox());
          }
          break;
     case KeyEvent::KEY_E:
         makeExplosion(Pnt3f(0.0f,0.0f,-5.0f), 1280.0f);
         break;
     case KeyEvent::KEY_1:
         makeExplosion(Pnt3f(0.0f,0.0f,-5.0f), 20.0f);
         break;
     case KeyEvent::KEY_2:
         makeExplosion(Pnt3f(0.0f,0.0f,-5.0f), 80.0f);
         break;
     case KeyEvent::KEY_3:
         makeExplosion(Pnt3f(0.0f,0.0f,-5.0f), 320.0f);
         break;
     case KeyEvent::KEY_4:
         makeExplosion(Pnt3f(0.0f,0.0f,-5.0f), 1280.0f);
         break;
     case KeyEvent::KEY_5:
         makeExplosion(Pnt3f(0.0f,0.0f,-5.0f), 5120.0f);
         break;
     case KeyEvent::KEY_6:
         makeExplosion(Pnt3f(0.0f,0.0f,-5.0f), 20480.0f);
         break;
     }
 }
Beispiel #5
0
void Plateau::renderLogic()
{
    if(test == 4)
    {
        test = 0;
        float bulletPosX , bulletPosY = 0.f;

        float enemyPosX , enemyPosY = 0.f;

        auto scene = myApplication.getCurrentScene();
        for(std::unordered_set<std::shared_ptr<Bullet> >::iterator i = myBullets.begin(); i!=myBullets.end();)
        {

            std::shared_ptr<Bullet> bullet = *i;

            bulletPosX = bullet->myEntity->getPosition().x;
            bulletPosY = bullet->myEntity->getPosition().y;

            if(bullet->unregistered)
            {
                myBullets.erase(*(i++));
            }
            else
            {
                for(std::unordered_set<std::shared_ptr<Ennemi> >::iterator e = myEnnemis.begin(); e!=myEnnemis.end();)
                {
                    std::shared_ptr<Ennemi> ennemi = *e;
                    enemyPosX = ennemi->myEntity->getPosition().x;
                    enemyPosY = ennemi->myEntity->getPosition().y;

                    if(ennemi->unregistered)
                    {
                        myEnnemis.erase(*(e++));
                    }
                    else
                    {
                        if(bullet->owner == Bullet::PLAYER&&ennemi->collision(*bullet))
                        {
                            bullet->unregister();
                            ennemi->unregister();
                            myJoueur->points++;
                            if(myJoueur->points%10==0)
                            {
                                myPopTime = myPopTime/1.5;

                                if(scene->getCurrentMusic().getStatus() != sf::Music::Stopped)
                                {
                                    scene->loadMusic(MUSIC[myZikIndex++%3]);
                                    scene->playMusic();
                                }
                            }

                            scene->addTemporaryParticleEntity(enemyPosX,enemyPosY,30,30,0,700000,EXPLOSIONS,EXPLOSION);
                            scene->addTemporaryParticleEntity(enemyPosX,enemyPosY,32,32,0,15000000,BLAST[myBlastIndex],BLAST[myBlastIndex]);
                            myBlastIndex = (myBlastIndex+1)%3;
                            scene->addTemporarySoundEntity(EXPLOSION);
                            scene->makeExplosion(b2Vec2(se::Utils::pixelsToMeters(ennemi->myEntity->getPosition().x),se::Utils::pixelsToMeters(ennemi->myEntity->getPosition().y)),5.0f,0.2f);
                        }
                        ++e;
                    }
                }
                if(bullet->owner == Bullet::ENNEMI&&myJoueur->collision(*bullet))
                {
                    bullet->unregister();
                    myJoueur->lowerHealth();

                    scene->addTemporaryParticleEntity(bulletPosX,bulletPosY,64,64,0,50000,HITS,HIT);
                    scene->addTemporarySoundEntity(IMPACT);

                }
                ++i;
            }

        }

        if(myClock.getElapsedTime().asMicroseconds()>=myPopTime&&myEnnemis.size()<MAX_ENNEMI)
            //if(!one)
        {
            one=true;
            myClock.restart();
            std::shared_ptr<Ennemi> newEnnemi = std::make_shared<Ennemi>(myApplication,*this);

            auto scene = myApplication.getCurrentScene();
            scene->registerRenderable(newEnnemi->myEntity);
            scene->registerRenderable(newEnnemi->myShadow);

            scene->registerRenderable(newEnnemi);
            myEnnemis.insert(newEnnemi);
        }
    }

    test++;
}