Exemple #1
0
void Model::update( const sf::Sprite& parent)
{
	float alfa=((parent.getRotation() + rotAround)* M_PI) /180.f;
	sf::Vector2f v,p(pos.x * parent.getScale().x, pos.y * parent.getScale().y);

	v.x = p.x * cos(alfa) - p.y * sin(alfa);
	v.y = p.x * sin(alfa) + p.y * cos(alfa);

	setRotation(parent.getRotation() + rot);
	setPosition(parent.getPosition() + v + posNoRot);

	sf::Sprite::setScale(	ModelDef::scale.x * parent.getScale().x, 
							ModelDef::scale.y * parent.getScale().y	);

	//setColor( sf::Color( clR, clG, clB, clA ) );
}
void cursor::setTexture(string cursorPass)
{
    sprite.setTexture(textureManager.get(cursorPass));
    sprite.setOrigin((Collision::GetSpriteSize(sprite).x / sprite.getScale().x / 2), (Collision::GetSpriteSize(sprite).y / sprite.getScale().y / 2));
    sprite.rotate(-90);
    sprite.setColor(sf::Color(255, 255, 255, settings.getCursorAplha()));
}
Exemple #3
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);
}
//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);
}
Exemple #5
0
void Bola::colidiu(sf::Sprite lightsaber){//Testar se realmente funcionou a colisao com sabre menor/maior
    if(this->getGlobalBounds().intersects((lightsaber.getGlobalBounds())))
    {
        laser2.play();
        if(this->getPosition().y<lightsaber.getPosition().y){
            speed.y *=(-1);

            float a=this->getPosition().x-(lightsaber.getPosition().x-(50*lightsaber.getScale().x));
            if(a<-10){//Lado esquerdo
                a*=-1;
                if(speed.x>0)
                    speed.x-=a*0.1;
                else
                    speed.x-=a*0.1;
            }else if(a>10){//Lado direito
                if(speed.x>0)
                    speed.x+=a*0.1;
                else
                    speed.x+=a*0.1;
            }
        }else
            speed.x*=-1;
    }
}
Exemple #6
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);
}
Exemple #7
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);
 }
inline sf::Vector2f ManageLevel::getToolTipScale() const
{
    return m_tooltip.getScale();
}
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;
}
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;
}
 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;
 }