bool overlap(sf::Sprite& sprite1, sf::Sprite& sprite2)
{
    sf::FloatRect rectangle1 = sprite1.getGlobalBounds();
    sf::FloatRect rectangle2 = sprite2.getGlobalBounds();

    // Rectangles with negative dimensions are allowed, so we must handle them correctly
    // Compute the min and max of the first rectangle on both axes
    float r1MinX = std::min(rectangle1.left, rectangle1.left + rectangle1.width); //left
    float r1MaxX = std::max(rectangle1.left, rectangle1.left + rectangle1.width);//right
    float r1MinY = std::min(rectangle1.top, rectangle1.top + rectangle1.height); // top
    float r1MaxY = std::max(rectangle1.top, rectangle1.top + rectangle1.height); // bottom of the maincharactersprite

    // Compute the min and max of the second rectangle on both axes
    float r2MinX = std::min(rectangle2.left, rectangle2.left + rectangle2.width);//left
    float r2MaxX = std::max(rectangle2.left, rectangle2.left + rectangle2.width);//right
    float r2MinY = std::min(rectangle2.top, rectangle2.top + rectangle2.height);//top of the blocksprite
    float r2MaxY = std::max(rectangle2.top, rectangle2.top + rectangle2.height); // bottom

    // Compute the intersection boundaries
    float interLeft = std::max(r1MinX, r2MinX);//get the most right one
    float interTop = std::max(r1MinY, r2MinY);//get the higher one
    float interRight = std::min(r1MaxX, r2MaxX);// get the most left one
    float interBottom = std::min(r1MaxY, r2MaxY);// the the lowest one

    //want to check if bottom of the mainCharacterSprite and top of the Block sprite are overlaping

    // If the intersection is valid (positive non zero area), then there is an intersection
    return ((interLeft <= interRight) && (interTop <= interBottom));
}
	void set_color()
	{
		
		int opaque{abs(static_cast<int>(m_strength*255.0f))};
		
		if (opaque > 255)
		{
			
			opaque = 255;
			
		}
		
		if (m_strength < 0.0f)
		{
			
			sf::Color light_red{m_light_red};			
			light_red.a = opaque;			
			m_sprite.setColor(light_red);
			
		}
		else
		{
			
			sf::Color light_blue{m_light_blue};			
			light_blue.a = opaque;			
			m_sprite.setColor(light_blue);
			
		}
		
	}
Example #3
0
/*!
 * \param Obj The object
 * \return The bounding box of the object
 */
sf::IntRect Collision::GetBoundingBox(const sf::Sprite &Obj)
{
    const sf::Vector2f &Position(Obj.GetPosition());
    const sf::IntRect &SubRect(Obj.GetSubRect());
    return sf::IntRect(Position.x, Position.y, Position.x + SubRect.GetWidth(),
                       Position.y + SubRect.GetHeight());
}
Example #4
0
 float distance(sf::Sprite spA, sf::Sprite spB)
 {
     return sqrt((spA.getPosition().x - spB.getPosition().x) *
                 (spA.getPosition().x - spB.getPosition().x) +
                 (spA.getPosition().y - spB.getPosition().y) *
                 (spA.getPosition().y - spB.getPosition().y));
 }
Example #5
0
	void Update(float fTime)
	{
		FRect.left += dx * fTime;

		// x
		Collision(0);

		if (!bOnGround)
			dy = dy + 0.0005f * fTime;

		FRect.top += dy * fTime;

		bOnGround = false;

		// y
		Collision(1);

		fCurrentFrame += 0.005f * fTime;
		if (fCurrentFrame > 3)
			fCurrentFrame -= 3;

		if(dx > 0)
			SSprite.setTextureRect(sf::IntRect(112 + 30 * int(fCurrentFrame), 144, 16, 16));
		if(dx < 0)
			SSprite.setTextureRect(sf::IntRect(112 + 30 * int(fCurrentFrame) + 16, 144, -16, 16));

		SSprite.setPosition(FRect.left - g_fOffsetX, FRect.top - g_fOffsetY);

		dx = 0;
	}
Example #6
0
void StateGameMenu::Update()
{
	if(Gamepad::isButtonPressed(id, Gamepad::BUTTON_A))
	{
		if(toggle)
		{
			MenuFX::PlaySfx(MenuFX::SELECT);
			StateManager::Pop();
		}
		else
		{
			MenuFX::PlaySfx(MenuFX::BACK);
			Music::Play(Music::MENU);
			StateManager::Pop();
			StateManager::Pop();
		}
		return;
	}

	if(sf::Joystick::getAxisPosition(id,sf::Joystick::Y) < -50 && !toggle)
	{
		MenuFX::PlaySfx(MenuFX::CHANGE);
		toggle = true;
		menu_pointer_sprt.setPosition(208, 178);
	}
	else if(sf::Joystick::getAxisPosition(id,sf::Joystick::Y) > 50 && toggle)
	{
		MenuFX::PlaySfx(MenuFX::CHANGE);
		toggle = false;
		menu_pointer_sprt.setPosition(225, 203);
	}
}
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);*/

}
Example #8
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;
}
Example #9
0
 bool isAbove(sf::Sprite sp2) {
     if ((sp2.getPosition().y < sprite.getPosition().y)!=playerAbove) {
         playerAbove=!playerAbove;
         return true;
     }
     return false;
 }
Example #10
0
bool overlap(sf::Sprite& sprite1, sf::Sprite& sprite2)
{
	sf::FloatRect rectangle1 = sprite1.getGlobalBounds();
	sf::FloatRect rectangle2 = sprite2.getGlobalBounds();

	// Rectangles with negative dimensions are allowed, so we must handle them correctly
	// Compute the min and max of the first rectangle on both axes
	float r1MinX = std::min(rectangle1.left, rectangle1.left + rectangle1.width);
	float r1MaxX = std::max(rectangle1.left, rectangle1.left + rectangle1.width);
	float r1MinY = std::min(rectangle1.top, rectangle1.top + rectangle1.height);
	float r1MaxY = std::max(rectangle1.top, rectangle1.top + rectangle1.height);

	// Compute the min and max of the second rectangle on both axes
	float r2MinX = std::min(rectangle2.left, rectangle2.left + rectangle2.width);
	float r2MaxX = std::max(rectangle2.left, rectangle2.left + rectangle2.width);
	float r2MinY = std::min(rectangle2.top, rectangle2.top + rectangle2.height);
	float r2MaxY = std::max(rectangle2.top, rectangle2.top + rectangle2.height);

	// Compute the intersection boundaries
	float interLeft = std::max(r1MinX, r2MinX);
	float interTop = std::max(r1MinY, r2MinY);
	float interRight = std::min(r1MaxX, r2MaxX);
	float interBottom = std::min(r1MaxY, r2MaxY);

	// If the intersection is valid (positive non zero area), then there is an intersection
	return ((interLeft <= interRight) && (interTop <= interBottom));
}
Example #11
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);
}
Example #12
0
void movement(sf::Sprite& character, sf::RenderWindow& window)
{
	float moveSpeed = 0.1, moveSpeedR = -0.1;

	if (sf::Keyboard::isKeyPressed(sf::Keyboard::LShift))
	{
		moveSpeed /= 2.2;
		moveSpeedR /= 2.2;
	}

	if (sf::Keyboard::isKeyPressed(sf::Keyboard::Z))
	{
		moveSpeed *= 2.2;
		moveSpeedR *= 2.2;
	}

	if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up))
	{
		character.move(0, moveSpeedR);
	}
	if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
	{
		character.move(0, moveSpeed);
	}
	if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
	{
		character.move(moveSpeed, 0);
	}
	if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
	{
		character.move(moveSpeedR, 0);
	}
}
Example #13
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;
 }
Example #14
0
void drawSprite(int x, int y, double w, double h, TextureIndex textureIndex)
{
	freeSprite.setPosition(x, y);
	freeSprite.setTexture(getTexture(textureIndex));
	freeSprite.setScale(w / getTexture(textureIndex).getSize().x, h / getTexture(textureIndex).getSize().y);
	window->draw(freeSprite);
}
Example #15
0
Bala::Bala(float _v, sf::Sprite& _cannon, sf::Image& imagen)
{
	float cannonA, cannonX, cannonY, cannonH;

	//Cargo sprite
	sprite.SetImage(imagen);
	sprite.SetCenter(imagen.GetWidth()/2, imagen.GetHeight()/2);

	//Inicializo variables
	dt = 0.0f;
	cannonA = _cannon.GetRotation();
	cannonX = _cannon.GetPosition().x;
	cannonY = _cannon.GetPosition().y;
	//Tomo el tamaño sobre el eje x como el largo del cañon
	//porque sin rotar la misma se encuentra en horizontal
	cannonH = _cannon.GetSize().x;

	//Descompongo la velocidad inicial
	vx = _v * (cos(cannonA/180*PI));
	vy = _v * (sin(cannonA/180*PI));

	//Posicion inicial bala según la posición del cañon
	//usando trigonometria
	xi = cannonX + ((cos(cannonA/180*PI) * cannonH));
	yi = cannonY - ((sin(cannonA/180*PI) * cannonH));

	sprite.SetPosition(xi, yi);
}
Example #16
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;
 }
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()));
}
	void init() {
		m_first_trip = false;
		m_current_state = IDLE;

		getBody()->GetFixtureList()->SetUserData("Checkpoint");
		getBody()->SetUserData(this);

		//Load Texture
		s_texture = "Assets/Game/cp_ps.png";
		m_text_size = sf::Vector2u(42, 94);
		m_sprite.setTexture(ResourceManager<sf::Texture>::instance()->get(s_texture));
		m_sprite.setOrigin(m_text_size.x / 2, m_text_size.y / 2);
		m_sprite.setPosition(vHelper::toSF(getBody()->GetPosition()));

		addFrames(frame_idle,	0, 0, 1, 42, 94, 1.0f);
		addFrames(frame_trip,	1, 0, 5, 42, 94, 1.0f);
		addFrames(frame_active, 2, 0, 3, 42, 94, 1.0f);

		m_animator.addAnimation(IDLE,	frame_idle,		sf::seconds(1.0f));
		m_animator.addAnimation(TRIP,	frame_trip,		sf::seconds(0.4f));
		m_animator.addAnimation(ACTIVE, frame_active,	sf::seconds(0.3f));

		//Load Audio
		s_noise = "Assets/Audio/Game/cp.wav";
		m_noise.setBuffer(ResourceManager<sf::SoundBuffer>::instance()->get(s_noise));
	}
Example #19
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;
		}
	}
Example #20
0
	//Enemy sprite render.
	void update(float deltaTime, char** levelMap, struct config* config) {

		if(mDirection == 0) {mMovement.x = 0;		mMovement.y = -mSpeed;}
		if(mDirection == 1) {mMovement.x = mSpeed;	mMovement.y = 0;}
		if(mDirection == 2) {mMovement.x = 0;		mMovement.y = mSpeed;}
		if(mDirection == 3) {mMovement.x = mSpeed;	mMovement.y = 0;}

		mRect.left += mMovement.x * deltaTime;
		collision(levelMap, config);
		mRect.top += mMovement.y * deltaTime;
		collision(levelMap, config);

		//Enemy animation.
		mCurrentFrame += mAnimationSpeed * deltaTime;
		if(mCurrentFrame > mFrameCount) mCurrentFrame -= mFrameCount;

		if(mMovement.x > 0) mSprite.setTextureRect(sf::IntRect(mRect.width * int(mCurrentFrame), 925, mRect.width, mRect.height));
		if(mMovement.x < 0) mSprite.setTextureRect(sf::IntRect(mRect.width * int(mCurrentFrame), 667, mRect.width, mRect.height));
		if(mMovement.y > 0) mSprite.setTextureRect(sf::IntRect(mRect.width * int(mCurrentFrame), 535, mRect.width, mRect.height));
		if(mMovement.y < 0) mSprite.setTextureRect(sf::IntRect(mRect.width * int(mCurrentFrame), 787, mRect.width, mRect.height));

		mSprite.setPosition(mRect.left - offsetX, mRect.top - offsetY);
		mTextName.setPosition(mRect.left - offsetX, mRect.top - mTextName.getCharacterSize() - offsetY);

	}
Example #21
0
/**
*\fn void moveLeft(void)
*\brief allows the Tamagotchi to move
*\param None
*\return Null
*/
void moveLeft(sf::Sprite &t, sf::Texture &t1, sf::Texture &t2)
{
	sf::Vector2f pos = t.getPosition();
	

	if(pos.x < 2)
	{
		D = 0;
	}

	if(pos.x > 600)
	{
		D = 1;
	}

	if(D == 0)
	{
		t.move(+1, 0);
		t.setTexture(t2, 1);
	}

	if(D == 1)
	{
		t.move(-1, 0);
		t.setTexture(t1, 1);
	}
}
Example #22
0
	//Player constructor.
	Player(sf::Texture& texture, sf::Texture& hpImage, int x, int y, sf::Font& font) {

		mSprite.setTexture(texture);
		mRect = sf::FloatRect(x, y, 120, 110);					//Character x, y, width, height.
		
		mName = "Player 1";
		mTextName.setString(mName);
		mTextName.setFont(font);
		mTextName.setCharacterSize(30);
		mTextName.setStyle(sf::Text::Bold);
		mTextName.setColor(sf::Color::Red);
		
		mHpSprite.setTexture(hpImage);
		mHpSprite.setTextureRect(sf::IntRect(0, 0, 100, 10));

		mSprite.setTextureRect(sf::IntRect(0, 15, 120, 110));
	
		mSpeed = 0.1;
		mMovement.x = 0;
		mMovement.y = 0;

		mCurrentFrame = 0;
		mAnimationSpeed = 0.005;

		mIsAlive = true;
		mHP = 100;
		mMaxHp = 100;
		mMP = 100;
	}
Example #23
0
void Camara::moveRight(sf::Sprite &personaje){
    
    if(desplazamientoCamara==0){
        //comprobamos que la posicion del personaje sea mayor que la camara y que el centro de la camara sea menor del fondo
        if(personaje.getPosition().x >= camara->getSize().x*0.6 && camara->getCenter().x <=(background.getLocalBounds().width*0.79)){
        //if(personaje.getPosition().x >= camara->getSize().x*0.6 && camara->getCenter().x <=(mapa->_tileWidth*mapa->_width*0.79)){
            std::cout<<( _tileWidth_Map*_width_Map*0.79)<<std::endl;
            //con background.getLocalBounds().width*0.79 calculo la parte derecha del mapa para fijar la camara
            camara->move(kVel,0);
            desplazamientoCamara=desplazamientoCamara+kVel; 
        }
        /*if(personaje.getPosition().x >= camara->getSize().x*0.6 && camara->getCenter().x <=(background.getLocalBounds().width*0.79)){
            //con background.getLocalBounds().width*0.79 calculo la parte derecha del mapa para fijar la camara
            camara->move(kVel,0);
            desplazamientoCamara=desplazamientoCamara+kVel; 
        }*/

    }else{
        //con esto averiguamos el margen derecho para saber cuando parar la camara al llegar al final del mapa
        int margen= background.getLocalBounds().width-(background.getLocalBounds().width*0.79);
        if(personaje.getPosition().x>= camara->getSize().x*0.6 + desplazamientoCamara && camara->getCenter().x<=(personaje.getPosition().x+margen) &&
            (personaje.getPosition().x+margen)<(_tileWidth_Map*_width_Map)){
        //if(personaje.getPosition().x>= camara->getSize().x*0.6 + desplazamientoCamara && camara->getCenter().x<=(background.getLocalBounds().width*0.79)){
        //if(personaje.getPosition().x>= camara->getSize().x*0.6 + desplazamientoCamara && camara->getCenter().x<=(mapa->_tileWidth*mapa->_width*0.79)){
            camara->move(kVel,0);
            desplazamientoCamara=desplazamientoCamara+kVel;  

        }
    } 
}
Example #24
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);
}
Example #25
0
// fucntion to handle player input during the game
void Inputer(sf::Sprite &playerSprite, float deltaTime) 
{
	// Check the boundry
	int boundry[4] = 
	{ 
		0,
		0,
		4000,
		4000 
	};
	
	// declare vector2f variable to store player position
	sf::Vector2f pos = playerSprite.getPosition();

	// move player at a velocity of 300 * variable deltaTime
	float velocity = 300.0f * deltaTime;

	// take key input from player, check boundary, and move accordingly at stored velocity
	if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) 
	{
		if (pos.x > boundry[0]) playerSprite.move(-velocity, 0);
	}
	if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
	{
		if (pos.x < boundry[2]) playerSprite.move(velocity, 0);
	}
	if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up)) 
	{
		if (pos.y > boundry[1]) playerSprite.move(0, -velocity);
	}
	if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down)) 
	{
		if (pos.y < boundry[3]) playerSprite.move(0, velocity);
	}
}
Example #26
0
	//Drop item constructor.
	DropItem(sf::Texture& texture, std::string type, int effect, int x, int y) {
		mSprite.setTexture(texture);
		mRect = sf::FloatRect(x, y, 32, 32);
		mSprite.setTextureRect(sf::IntRect(0, 0, 32, 32));
		mCurrentFrame = 0;
		mEffectValue = effect;
		mIsMarkedForRemoval = false;
	}
Example #27
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);
}
Example #28
0
void Camera::follow(sf::Sprite& sp, float d)
{
	Vector2D vd(0, d);
	vd.rotate( sp.getRotation());

	setRotation(sp.getRotation());
	setCenter( sp.getPosition() + vd);
}
Example #29
0
sf::IntRect Colision::getIntRect(const sf::Sprite &sprite) 
{ 
	const sf::Vector2f &pos(sprite.GetPosition()); 
	const sf::IntRect  &sub_rect(sprite.GetSubRect()); 
	sf::IntRect int_rect((int)pos.x, (int)pos.y, (int)(pos.x + sub_rect.GetWidth()), (int)(pos.y + sub_rect.GetHeight()));

	return (int_rect); 
} 
Example #30
0
 SpriteNode(const sf::Texture& t,
            sf::Vector2f pos)
 : mSprite(t)
 {
    sf::FloatRect bounds = mSprite.getLocalBounds();
    mSprite.setOrigin(bounds.width / 2.f, bounds.height / 2.f);
    mSprite.setPosition(pos);
 };