Exemplo n.º 1
0
 bool PixelPerfectTest(const sf::Sprite& Object1, const sf::Sprite& Object2, sf::Uint8 AlphaLimit) {
     sf::FloatRect Intersection;
     if (Object1.getGlobalBounds().intersects(Object2.getGlobalBounds(), Intersection)) {
         sf::IntRect O1SubRect = Object1.getTextureRect();
         sf::IntRect O2SubRect = Object2.getTextureRect();
         
         sf::Uint8* mask1 = Bitmasks.GetMask(Object1.getTexture());
         sf::Uint8* mask2 = Bitmasks.GetMask(Object2.getTexture());
         
         // Loop through our pixels
         for (int i = Intersection.left; i < Intersection.left+Intersection.width; i++) {
             for (int j = Intersection.top; j < Intersection.top+Intersection.height; j++) {
                 
                 sf::Vector2f o1v = Object1.getInverseTransform().transformPoint(i, j);
                 sf::Vector2f o2v = Object2.getInverseTransform().transformPoint(i, j);
                 
                 // Make sure pixels fall within the sprite's subrect
                 if (o1v.x > 0 && o1v.y > 0 && o2v.x > 0 && o2v.y > 0 &&
                     o1v.x < O1SubRect.width && o1v.y < O1SubRect.height &&
                     o2v.x < O2SubRect.width && o2v.y < O2SubRect.height) {
                     
                     if (Bitmasks.GetPixel(mask1, Object1.getTexture(), (int)(o1v.x)+O1SubRect.left, (int)(o1v.y)+O1SubRect.top) > AlphaLimit &&
                         Bitmasks.GetPixel(mask2, Object2.getTexture(), (int)(o2v.x)+O2SubRect.left, (int)(o2v.y)+O2SubRect.top) > AlphaLimit)
                         return true;
                     
                 }
             }
         }
     }
     return false;
 }
Exemplo n.º 2
0
void afficheConstructible  (sf::RenderWindow &App, sf::Sprite &SpriteTower ,sf::Shape &PolygonPorte,Constructible* maCons,int cote, int offSetX, int offSetY )
{
    // affichage du sprite de la construction
    int i = maCons->getPosition()->getI();
    int j = maCons->getPosition()->getJ();


    drawHexagoneIJ ( i,j, SpriteTower, cote, offSetX,  offSetY);
    //SpriteTower.SetCenter(SpriteTower.GetSize().x/2,SpriteTower.GetSize().y/2);

    sf::Vector2f positionAvant = SpriteTower.getPosition();
    SpriteTower.setPosition(positionAvant.x-SpriteTower.getTextureRect().height,positionAvant.y-SpriteTower.getTextureRect().width);
    App.draw(SpriteTower);


    // affichage de la porté
    std::set<Case *> cibles = maCons->getCaseAPorteDEffet();
    std::set<Case *>::iterator its;
    for ( its= cibles.begin() ; its != cibles.end() ; ++its )
    {
        drawHexagoneIJ ( (*its)->getI() , (*its)->getJ(), PolygonPorte, cote, offSetX,  offSetY);
         App.draw(PolygonPorte);
    }
    // les point de vue ( mon dieu c'est moche le code graphique )
    double centreX = SpriteTower.getTextureRect().width /2  ;//  SpriteTower.getTexture().getSize().x/2;
    double centreY = SpriteTower.getTextureRect().height/2 ;
    /*sf::Shape pv   = sf::Shape::Line (0,0, 0+maCons->getPV()/2 ,0,5,sf::Color::Black);
    drawHexagoneIJ (  i,j, pv, cote, offSetX,  offSetY);
    pv.Move(0-centreX,0-centreY);
    App.draw(pv);*/

}
void Animation::SetSprite(const sf::Sprite& sprite, const int frameCount)
{
	m_frameWidth	= sprite.getTextureRect().width/frameCount;
	m_frameHeight	= sprite.getTextureRect().height;
	m_sprite		= sprite;
	m_frameCount	= frameCount;

	Reset();
}
Exemplo n.º 4
0
	KeyObject::KeyObject(float x, float y, sf::Sprite sprite, sf::Color outline, sf::String word, key_callback_t callback, bool active, bool visible) :
		GameObject(x, y, (float)sprite.getTexture()->getSize().x, (float)sprite.getTexture()->getSize().y),
		outline_(outline),
		word_(word),
		active_(active),
		focused_(false),
		visible_(visible),
		callback_(callback),
		state_(DEFAULT)
	{
		this->rect_.width = sprite.getTextureRect().width;
		this->rect_.height = sprite.getTextureRect().height;
		SetSprite(sprite);
	}
Exemplo n.º 5
0
sf::Vector2f getCenter(const sf::Sprite& sprite)
{
    sf::Vector2f center = sprite.getPosition();
    center.x += sprite.getTextureRect().width  / 2.f;
    center.y += sprite.getTextureRect().height / 2.f;
    return center;
}
Exemplo n.º 6
0
	void _Log::load_image(){
		if( image_loaded == false && image_path.length() != 0 ) {
			texture_1.loadFromFile( image_path );

			Sprite.setTexture( texture_1, false );
			sf::IntRect spr_data = Sprite.getTextureRect();
			float x,y = WINDOW_HEIGHT - spr_data.height;

			switch( align ){

			case 1: x = 0.f; break;
			case 2: x = WINDOW_WIDTH * 0.25 - spr_data.width /2; break;
			case 3: x = WINDOW_WIDTH * 0.5  - spr_data.width /2; break;
			case 4: x = WINDOW_WIDTH * 0.75  - spr_data.width /2; break;
			case 5: x = WINDOW_WIDTH - spr_data.width; break;

			}

			Sprite.setPosition( x, y );

			cout << x << " " << y << endl;

			image_loaded = true;
		}
	}
Exemplo n.º 7
0
 bool testForStanding(sf::Sprite sp2) {
     if ((sp2.getGlobalBounds().left+sp2.getGlobalBounds().width > sprite.getPosition().x) &&
         (sp2.getGlobalBounds().left < sprite.getPosition().x+sprite.getTextureRect().width*sprite.getScale().x)) {
         return true;
     }
     return false;
 }
Exemplo n.º 8
0
sf::Vector2f Collision2D::GetSize(const sf::Sprite& sprite)
{
	// Return the size of the sprite adjusting for scale
	const sf::IntRect iOriginalSize = sprite.getTextureRect();
	const sf::Vector2f fScale = sprite.getScale();
	return sf::Vector2f(iOriginalSize.width * fScale.x, iOriginalSize.height * fScale.y);
}
Exemplo n.º 9
0
bool ImageButton(const sf::Sprite& sprite, const sf::Vector2f& size,
    const int framePadding, const sf::Color& bgColor, const sf::Color& tintColor)
{
    const sf::Texture* texturePtr = sprite.getTexture();
    if (!texturePtr) { return false; }
    return ::imageButtonImpl(*texturePtr, static_cast<sf::FloatRect>(sprite.getTextureRect()), size, framePadding, bgColor, tintColor);
}
Exemplo n.º 10
0
void resize(sf::Sprite& sprite, float width, float height)
{
    int local_width  = sprite.getTextureRect().width;
    int local_height = sprite.getTextureRect().height;

    if ((local_width > 0) && (local_height > 0))
        sprite.setScale(width / local_width, height / local_height);
}
Exemplo n.º 11
0
void Graphics::draw(sf::Vector2f position, sf::Vector2f hitbox, sf::Sprite sprite)
{
    sprite.setOrigin(0, hitbox.y);
    sf::Vector2f roundedPosition = sf::Vector2f(position.x - 0.5, position.y - 0.5);

    //Translate position
    translatePosition(roundedPosition, window_);

    //Set Position
    sprite.setPosition(roundedPosition);

    //Scale if necessary
    sprite.scale(hitbox.x / sprite.getTextureRect().width, hitbox.y / sprite.getTextureRect().height);

    window_->draw(sprite);
    return;
}
Exemplo n.º 12
0
    SpriteAnimator::SpriteAnimator(sf::Sprite &sprite)
        : Animator()
        , invertXOffset(false)
        , invertYOffset(false)
        , sprite(sprite)
        , sourceRectangle(sprite.getTextureRect()) {

    }
Exemplo n.º 13
0
 OrientedBoundingBox (const sf::Sprite& Object) // Calculate the four points of the OBB from a transformed (scaled, rotated...) sprite
 {
     sf::Transform trans = Object.getTransform();
     sf::IntRect local = Object.getTextureRect();
     Points[0] = trans.transformPoint(0.f, 0.f);
     Points[1] = trans.transformPoint(local.width, 0.f);
     Points[2] = trans.transformPoint(local.width, local.height);
     Points[3] = trans.transformPoint(0.f, local.height);
 }
Exemplo n.º 14
0
void Image(const sf::Sprite& sprite, const sf::Vector2f& size,
    const sf::Color& tintColor, const sf::Color& borderColor)
{
    const sf::Texture* texturePtr = sprite.getTexture();
    // sprite without texture cannot be drawn
    if (!texturePtr) { return; }

    Image(*texturePtr, size, static_cast<sf::FloatRect>(sprite.getTextureRect()), tintColor, borderColor);
}
Exemplo n.º 15
0
// The flip function works well TODO MOVE THIS SHIT
void Player::Flip(sf::Sprite& sprite)
{
    if (Player::Direction==-1)
    {
        sprite.setTextureRect(
            sf::IntRect(
                sprite.getTextureRect().width, //TODO left+width?
                0,
                -sprite.getTextureRect().width,
                sprite.getTextureRect().height
            )
        );
    }
    else
    {
        sprite.setTextureRect(Player::TextureRect);
    }
}
Exemplo n.º 16
0
	void KeyObject::SetSprite(sf::Sprite sprite) {
		sprite_ = sprite;

		sf::RenderTexture temp;
		temp.create(sprite.getTextureRect().width, sprite.getTextureRect().height);
		temp.draw(sprite);

		sf::Image outline_image = temp.getTexture().copyToImage();
		outline_image.flipVertically();
		sf::Vector2u size = outline_image.getSize();

		sf::Image new_image;
		new_image.create(size.x, size.y, sf::Color::Transparent);

		int i, j, min_i, max_i, min_j, max_j, local_i, local_j;
		int radius = 7;
		for (i = 0; i < size.x; ++i) {
			for (j = 0; j < size.y; ++j) {

				min_i = std::max(0, i - radius);
				max_i = std::min(size.x, (unsigned) i + radius);
				min_j = std::max(0, j - radius);
				max_j = std::min(size.y, (unsigned) j + radius);

				float strength = 0;
				for (local_i = min_i; local_i < max_i; ++local_i) {
					for (local_j = min_j; local_j < max_j; ++local_j) {
						if (outline_image.getPixel(local_i, local_j).a > 50)  {
							float distSquared = std::pow(i - local_i, 2.f) + std::pow(j - local_j, 2.f);
							strength += 1.f / std::pow(distSquared, 1.5f);
						}
					}
				}
				
				if (strength > 0) {
					outline_.a = std::min(255.f, 255.f * 1.5f * strength);
					new_image.setPixel(i, j, outline_);
				}
			}
		}

		texture_outline_.loadFromImage(new_image);
		sprite_outline_.setTexture(texture_outline_, true);
	}
Exemplo n.º 17
0
    void Sprite2VertexArray(const sf::Sprite & sprite,sf::VertexArray & vertices)
    {
        sf::IntRect texBox = sprite.getTextureRect();
        sf::FloatRect box = sprite.getGlobalBounds();

		vertices.append(sf::Vertex(sf::Vector2f(box.left, box.top), sf::Vector2f((float)texBox.left, (float)texBox.top)));
		vertices.append(sf::Vertex(sf::Vector2f(box.left, box.top + box.height), sf::Vector2f((float)texBox.left, (float)(texBox.top + texBox.height))));
		vertices.append(sf::Vertex(sf::Vector2f(box.left + box.width, box.top + box.height), sf::Vector2f((float)(texBox.left + texBox.width), (float)(texBox.top + texBox.height))));
		vertices.append(sf::Vertex(sf::Vector2f(box.left + box.width, box.top), sf::Vector2f((float)(texBox.left + texBox.width), (float)texBox.top)));
    }
Exemplo n.º 18
0
void Animation::get_sprite(int frame, sf::Sprite& sprite) const
{
    if ( d->tileset )
    {
        d->tileset->get_tile(d->start_tile+frame,sprite);
        sf::IntRect ir = sprite.getTextureRect();
        ir.left += d->offset.x;
        ir.top += d->offset.y;
        sprite.setTextureRect(ir);
    }
}
Exemplo n.º 19
0
//otestad (har inga vettiga cirklar) att testa med)
bool CollisionManager::Circle_CircleCollision(const sf::Sprite& sprite1, const sf::Sprite& sprite2)
{
    // avståndet mellan cirklarnas mittpunkter
    sf::Vector2f distance =
    sf::Vector2f(sprite1.getGlobalBounds().left + sprite1.getGlobalBounds().width / 2.0f,
                 sprite1.getGlobalBounds().top + sprite1.getGlobalBounds().height / 2.0f)
    -
    sf::Vector2f(sprite2.getGlobalBounds().left + sprite2.getGlobalBounds().width / 2.0f,
                 sprite2.getGlobalBounds().top + sprite2.getGlobalBounds().height / 2.0f);
    
    float magnitudeOfDistanceSquared = distance.x * distance.x + distance.y * distance.y;
    // beräkna radien på båda objekten
    float radius1 = (sprite1.getTextureRect().width * sprite1.getScale().x +
                     sprite1.getTextureRect().height * sprite1.getScale().y)/4;
    float radius2 = (sprite2.getTextureRect().width * sprite2.getScale().x +
                     sprite2.getTextureRect().height * sprite2.getScale().y)/4;
    
    float maximumCollidingDistanceBetweenBoundings = (radius1 + radius1) * (radius2 + radius2);
    
    return (magnitudeOfDistanceSquared <= maximumCollidingDistanceBetweenBoundings);
}
Exemplo n.º 20
0
bool DebugHud::Button(sf::RenderWindow* window, sf::Sprite buttonSprite) {

    //get width/height
    int width = buttonSprite.getTextureRect().width;
    int height =  buttonSprite.getTextureRect().height;

    float x = buttonSprite.getPosition().x ;
    float y = buttonSprite.getPosition().y ;


    //text mouse
    sf::Vector2i mousePos = sf::Mouse::getPosition(*window);
    if (mousePos.x < x) return false;
    if (mousePos.y < y) return false;
    if (mousePos.x > x + width) return false;
    if (mousePos.y > y + height) return false;

    buttonSprites[3].setPosition(x - width /4,y - height / 2);
    window->draw(buttonSprites[3]);
    return sf::Mouse::isButtonPressed(sf::Mouse::Button::Left);
}
Exemplo n.º 21
0
void Animation::create(const sf::Sprite& spritesheet, const sf::IntRect spriteArea, sf::Time duration)
{
    // We get the first's frame rect
    _frameRect = spriteArea;
    // The number of sprites there is on this area
    _numberFrames = spritesheet.getTextureRect().width / spriteArea.width;

    // Setting the texture to own it
    _sprite.setTexture(*spritesheet.getTexture());
    _sprite.setTextureRect(spriteArea);

    // the duration of the animation
    _duration = duration;

    // we can say the animation is ready
    _isLoaded = true;
}
Exemplo n.º 22
0
 static std::vector<sf::Sprite> split4(sf::Sprite sprite)
 {
     std::vector<sf::Sprite> splits = std::vector<sf::Sprite>(0);
     const sf::Texture* texture = sprite.getTexture();
     sf::IntRect baseRect = sprite.getTextureRect();
     sf::Vector2f position = sprite.getPosition();
     splits.push_back(sf::Sprite(*texture, sf::IntRect(baseRect.left,baseRect.top,baseRect.width/2,baseRect.height/2)));
     splits[0].setPosition(position.x,position.y);
     splits[0].setColor(sprite.getColor());
     splits.push_back(sf::Sprite(*texture, sf::IntRect(baseRect.left+(baseRect.width/2), baseRect.top, baseRect.width/2, baseRect.height/2)));
     splits[1].setPosition(position.x+baseRect.width/2,position.y);
     splits[1].setColor(sprite.getColor());
     splits.push_back(sf::Sprite(*texture, sf::IntRect(baseRect.left, baseRect.top+(baseRect.height/2), baseRect.width/2 , baseRect.height/2)));
     splits[2].setPosition(position.x,position.y+baseRect.height/2);
     splits[2].setColor(sprite.getColor());
     splits.push_back(sf::Sprite(*texture, sf::IntRect(baseRect.left+(baseRect.width/2), baseRect.top+(baseRect.height/2), baseRect.width/2 , baseRect.height/2)));
     splits[3].setPosition(position.x+baseRect.width/2,position.y+baseRect.height/2);
     splits[3].setColor(sprite.getColor());
     return splits;
 }
Exemplo n.º 23
0
 sf::Vector2f GetSpriteSize (const sf::Sprite& Object)
 {
     sf::IntRect OriginalSize = Object.getTextureRect();
     sf::Vector2f Scale = Object.getScale();
     return sf::Vector2f (OriginalSize.width*Scale.x, OriginalSize.height*Scale.y);
 }
Exemplo n.º 24
0
/**
Affiche le monstre la ou il doit etre sur la case, avec le bon angle et la bonne position
affiche également les points de vie du moob
*/
void afficheMonstre        (sf::RenderWindow &App, sf::Sprite  &SpriteMoob ,Monstre* monMoob,int cote, int offSetX, int offSetY ,  std::list<Tour*> &listTour)
{
   using namespace std;

    Case* caseMoob = monMoob->CaseCourante();

    drawHexagoneIJ ( caseMoob->getI() , caseMoob->getJ(), SpriteMoob, cote, offSetX,  offSetY);
    //sf::Shape pv   = sf::RectangleShape (0,0, 0+monMoob->getPV()/2 ,0,5,sf::Color::Black);

    sf::RectangleShape pv (sf::Vector2f(5,monMoob->getPV()/2));
    pv.setFillColor(sf::Color::Black);
    /// Moche

    drawHexagoneIJ ( caseMoob->getI() , caseMoob->getJ(), pv, cote, offSetX,  offSetY);
    // on centre le moob

    int etape;
    Direction dtion = monMoob->quelleDirection(etape);
    // on bouge en fonction de la direction
    double moobOffSetX=0,moobOffSetY=0,moobAvancement;
    if ( etape == 0)
    {
        moobAvancement = ((1000-monMoob->getAvancement())/1000)*cote*(sqrt(3));
    }
    else
    {
        moobAvancement = ((500-monMoob->getAvancement())/1000)*cote*(sqrt(3));
    }

    double angle = 0;
    switch (dtion)
    {
        case Est  : {
            moobOffSetX = moobAvancement;
            moobOffSetY =0;
            angle = -90;
            if ( etape == 0)
            {
                moobOffSetX -= (sqrt(3)/2) *cote;

            }

            break;}
        case NordEst : {
            moobOffSetX = moobAvancement / 2 ;
            moobOffSetY = -moobAvancement * (sqrt(3)/2) ;

            if ( etape == 0)
            {
                moobOffSetX -= (sqrt(3)/2) *cote /2;
                moobOffSetY += (sqrt(3)/2) *cote *(sqrt(3)/2);

            }
            angle = -30;
            break;}
        case NordOuest : {
            moobOffSetX = -moobAvancement / 2 ;
            moobOffSetY = -moobAvancement * (sqrt(3)/2) ;
            if ( etape == 0)
            {
                moobOffSetX += (sqrt(3)/2) *cote /2;
                moobOffSetY += (sqrt(3)/2) *cote *(sqrt(3)/2);

            }
            angle = 30;
            break;}
        case Ouest : {
            moobOffSetX = - moobAvancement;
            moobOffSetY = 0;
            if ( etape == 0)
            {
                moobOffSetX += (sqrt(3)/2) *cote;


            }
            angle = 90;
            break;}
        case SudOuest : {
             angle = 160;
            moobOffSetX = -moobAvancement / 2 ;
            moobOffSetY = moobAvancement * (sqrt(3)/2) ;
             if ( etape == 0)
            {
                moobOffSetX += (sqrt(3)/2) *cote /2;
                moobOffSetY -= (sqrt(3)/2) *cote *(sqrt(3)/2);

            }

            break;}
        case SudEst: {
             angle = -160;
             moobOffSetX = moobAvancement / 2 ;
            moobOffSetY = moobAvancement * (sqrt(3)/2) ;
              if ( etape == 0)
            {
                moobOffSetX -= (sqrt(3)/2) *cote /2;
                moobOffSetY -= (sqrt(3)/2) *cote *(sqrt(3)/2);

            }

            break;}
    }

    SpriteMoob.move(moobOffSetX,moobOffSetY);
   //double centreX = SpriteMoob.getSize().x/2;

   // double centreY = SpriteMoob.getSize().y/2 ;


    double centreX = SpriteMoob.getTextureRect().width /2  ;//  SpriteTower.getTexture().getSize().x/2;
    double centreY = SpriteMoob.getTextureRect().height/2 ;
    SpriteMoob.setPosition(centreX,centreY);
    SpriteMoob.rotate(angle);

    pv.  move(moobOffSetX-centreX,moobOffSetY-centreY);
    App.draw(pv);
    App.draw(SpriteMoob);

    //la gestion de l'attaque n'est pas encore definie
    if ( monMoob != NULL )
    {

        using namespace std;

        Case* laCase = monMoob->CaseCourante();

        if (laCase != NULL )
        {


            std::list<Tour*>::iterator itt = listTour.begin();

            for ( itt; itt != listTour.end() ; ++itt)
            {
                if ( (*itt)->getCible() == monMoob)
                {

                    sf::Vector2<int> ij;
                    sf::Vector2<double>xy;
                    ij.x = (*itt)->getPosition()->getI();
                    ij.y = (*itt)->getPosition()->getJ();
                    xy = IJtoXY (ij, cote, offSetX,  offSetY);
                   // sf::Shape Line   = sf::Shape::Line(SpriteMoob.GetPosition().x,SpriteMoob.GetPosition().y,xy.x,xy.y, 2, sf::Color::Red);
                   // App.Draw(Line);

                }
            }
        }
    }

}
Exemplo n.º 25
0
bool CollisionManager::Circle_WallCollision(const sf::Sprite& sprite)
{
    float radius = (sprite.getTextureRect().width * sprite.getScale().x +
                     sprite.getTextureRect().height * sprite.getScale().y)/6;
    sf::Vector2f coordinates = sf::Vector2f(sprite.getGlobalBounds().left + sprite.getGlobalBounds().width / 2.0f,
                                            sprite.getGlobalBounds().top + sprite.getGlobalBounds().height / 2.0f);
    //hämta antalet väggar att kolla
    for (int i = 0; i < m_wallManager->GetCount(); i++)
    {
        //hämta antalet punkter i en convex form
        for (int j = 0; j < m_wallManager->GetWall(i)->getPointCount(); j++)
        {
            //hämta startpunkten
            sf::Vector2f A = m_wallManager->GetWall(i)->getPosition() + m_wallManager->GetWall(i)->getPoint(j);
            //hämta slutpunkten
            sf::Vector2f B;
            if (j==0)
            {
                B = m_wallManager->GetWall(i)->getPosition() + m_wallManager->GetWall(i)->getPoint(m_wallManager->GetWall(i)->getPointCount()-1);
            }
            else
            {
                B = m_wallManager->GetWall(i)->getPosition() + m_wallManager->GetWall(i)->getPoint(j-1);
            }
            sf::Vector2f C = coordinates;
            
            //räkna ut avstånden mellan punkterna
            sf::Vector2f f = A - C;
            sf::Vector2f t = B - C;
            sf::Vector2f l = t - f;
            
            
            float a = l.x * l.x + l.y * l.y ;
            float b = 2*(l.x * f.x + l.y * f.y) ;
            float c = f.x * f.x + f.y * f.y - radius*radius ;
            
            float discriminant = b*b-4*a*c;
            if( discriminant < 0 )
            {
                continue;
            }
            else
            {
                discriminant = sqrt( discriminant );
                
                // cirkeln kan penetreras på två olika punkter, ingångspunkten och utgångspunkten
                float t1 = (-b - discriminant)/(2*a);
                float t2 = (-b + discriminant)/(2*a);
                
                // om t1 och t2 är mellan 0 och 1 har linjen gått igenom cirkeln
                // om t1 eller t2 är mellan 0 och 1 har linjen gått in i men inte igenom cirkeln
                if( t1 >= 0 && t1 <= 1 )
                {
					return true ;
                }
                if( t2 >= 0 && t2 <= 1 )
                {
                    return true ;
                }
                //om t1 och t2 är större än 1 eller mindre än 0 har linjen missat cirkeln helt
            }
            
        }
    }
    //har den gått igenom alla former och kommit till slutet har ingen kollision sket mellan några punkter
    return false;
}
Exemplo n.º 26
0
	MainMenu() : system(TextureManager::instance().getTexture("assets/rticle.png"))
	{
		pointer.setTexture(TextureManager::instance().getTexture("assets/two_pointer.png"));
		//pointer.setPosition(1183, 427);

		//system = new thor::ParticleSystem();

		emitter.setEmissionRate(0.5f);
		emitter.setParticleLifetime( sf::seconds(40) );

		emitter.setParticleRotation( thor::Distributions::uniform(0.f, 360.f) );
		emitter.setParticlePosition( sf::Vector2f(1260,740) );
		emitter.setParticleScale(sf::Vector2f(0.1,0.1));

		system.addEmitter(thor::refEmitter(emitter));

		thor::ColorGradient gradient;
		gradient[0.0f] = sf::Color::Magenta;
		gradient[0.1f] = sf::Color::Red;
		gradient[0.2f] = sf::Color::Blue;
		gradient[0.3f] = sf::Color::Cyan;
		gradient[0.4f] = sf::Color::Green;
		gradient[0.5f] = sf::Color::Red;
		gradient[0.6f] = sf::Color::Magenta;
		gradient[0.7f] = sf::Color::Cyan;
		gradient[0.8f] = sf::Color::Red;
		gradient[0.9f] = sf::Color::Blue;
		gradient[1.0f] = sf::Color::Red;

		thor::ColorAnimation colorizer(gradient);
		thor::FadeAnimation fader(0.1f, 0.1f);

		system.addAffector( thor::ScaleAffector(sf::Vector2f(0.1f,0.1)));	
		system.addAffector( thor::AnimationAffector(fader) );
		system.addAffector( thor::AnimationAffector(colorizer) );

		sprite = AnimatedSprite(sf::seconds(0.3));

		v.setTexture(TextureManager::instance().getTexture("assets/one_upper.png"));
		back2.setTexture(TextureManager::instance().getTexture("assets/two_menu.png"));
		logo.setTexture(TextureManager::instance().getTexture("assets/one_logo.png"));
		press.setTexture(TextureManager::instance().getTexture("assets/one_anybutton.png"));
		anim.setSpriteSheet(TextureManager::instance().getTexture("assets/one_animooted.jpg"));

		for (int i = 0; i < 5; i++)
		{
			anim.addFrame(sf::IntRect(0, 800 * i, WIDTH, HEIGHT));
		}

		sprite.setAnimation(anim);
		sprite.setLooped(true);
		sprite.play();

		logo.setColor(sf::Color(255,255,255,0));
		press.setColor(sf::Color(255,255,255,0));
		pointer.setColor(sf::Color(255,255,255,0));
		press.setPosition(WIDTH/2 - press.getTextureRect().width/2, HEIGHT/2 - press.getTextureRect().height/2 + 100);
		pressFading = true;

		newLogoY = 800;
		oTweener.addTween(&CDBTweener::TWEQ_BACK, CDBTweener::TWEA_INOUT, 2.f, &newLogoY, 0.0f);

		first = true;

		pressFactor = 0.2;
		transition = false;
		check = false;
		
		sm.init(sf::Vector2f(WIDTH, HEIGHT));
		rt.create(WIDTH, HEIGHT);

		MusicManager::instance().playMusicFast("low");

		selection = 1;
	};
Exemplo n.º 27
0
sf::Vector2f size(const sf::Sprite& sprite)
{
    const sf::IntRect& rect = sprite.getTextureRect();
    return sf::Vector2f(rect.width * sprite.getScale().x, rect.height * sprite.getScale().y);
}
Exemplo n.º 28
0
bool CollisionManager::Circle_FurnitureCollision(const sf::Sprite& player, const Furniture& furniture)
{
    if(furniture.GetNoise() == 0)
    {
        return false;
    }
    float radius = (player.getTextureRect().width * player.getScale().x +
                    player.getTextureRect().height * player.getScale().y)/6;
    sf::Vector2f coordinates = sf::Vector2f(player.getGlobalBounds().left + player.getGlobalBounds().width / 2.0f,
                                            player.getGlobalBounds().top + player.getGlobalBounds().height / 2.0f);
    
        //hämta antalet punkter i en convex form
        for (int j = 0; j < furniture.getPointCount(); j++)
        {
            float m_degree = furniture.getRotation();
            
            //hämta startpunkten
            sf::Vector2f A_point = furniture.getPoint(j) - furniture.getOrigin();
            //hämta slutpunkten
            sf::Vector2f B_point;
            if (j==0)
            {
                B_point = furniture.getPoint(furniture.getPointCount()-1) - furniture.getOrigin();
            }
            else
            {
                B_point = furniture.getPoint(j-1) - furniture.getOrigin();
            }
            
            sf::Vector2f newCirclePosition;
            newCirclePosition.x = B_point.x * cosf(m_degree * (M_PI / 180)) - B_point.y * sinf(m_degree * (M_PI / 180));
            newCirclePosition.y = B_point.x * sinf(m_degree * (M_PI / 180)) + B_point.y * cosf(m_degree * (M_PI / 180));
            B_point = newCirclePosition;
            newCirclePosition.x = A_point.x * cosf(m_degree * (M_PI / 180)) - A_point.y * sinf(m_degree * (M_PI / 180));
            newCirclePosition.y = A_point.x * sinf(m_degree * (M_PI / 180)) + A_point.y * cosf(m_degree * (M_PI / 180));
            A_point = newCirclePosition;
            
            sf::Vector2f A = furniture.getPosition() + A_point;
            sf::Vector2f B = furniture.getPosition() + B_point;
            sf::Vector2f C = coordinates;
            
            //räkna ut avstånden mellan punkterna
            sf::Vector2f f = A - C;
            sf::Vector2f t = B - C;
            sf::Vector2f l = t - f;
            
            
            float a = l.x * l.x + l.y * l.y ;
            float b = 2*(l.x * f.x + l.y * f.y) ;
            float c = f.x * f.x + f.y * f.y - radius*radius ;
            
            float discriminant = b*b-4*a*c;
            if( discriminant < 0 )
            {
                continue;
            }
            else
            {
                discriminant = sqrt( discriminant );
                
                // cirkeln kan penetreras på två olika punkter, ingångspunkten och utgångspunkten
                float t1 = (-b - discriminant)/(2*a);
                float t2 = (-b + discriminant)/(2*a);
                
                // om t1 och t2 är mellan 0 och 1 har linjen gått igenom cirkeln
                // om t1 eller t2 är mellan 0 och 1 har linjen gått in i men inte igenom cirkeln
                if( t1 >= 0 && t1 <= 1 )
                {
					return true ;
                }
                if( t2 >= 0 && t2 <= 1 )
                {
                    return true ;
                }
                //om t1 och t2 är större än 1 eller mindre än 0 har linjen missat cirkeln helt
            }
            
        }
    //har den gått igenom alla former och kommit till slutet har ingen kollision sket mellan några punkter
    return false;
}