SFML community forums

Help => General => Topic started by: Dreamflask on April 11, 2015, 02:18:12 am

Title: Wrong position in View
Post by: Dreamflask on April 11, 2015, 02:18:12 am

Hi, I am currently working on a tile-map-editor (copy function), but I can not set up the right Sprite position in my MapView. Here is my Code i am currently using,  it is working UNTIL i change the View (move, zoom ...) and i do not get it working by myself or with google research.
Do you have some suggestions for me?

//Get the window mouse position
                                sf::Vector2f worldCoords = _window.mapPixelToCoords(mousePosition,_mapView);

                                //Convert to tile Position (chunksize = tilesize)
                                worldCoords.x = static_cast<int>((worldCoords.x / chunksize))*chunksize;
                                worldCoords.y = static_cast<int>((worldCoords.y / chunksize))*chunksize;

                                //Add offset (ix, iy) on converted tile-paste-position
                                worldCoords.x += (ix*chunksize);
                                worldCoords.y += (iy*chunksize);

                                //Set new position
                                newTile.setPosition(worldCoords);
 

Title: Re: Wrong position in View
Post by: G. on April 11, 2015, 03:53:25 am

What if you don't add your offset? :p

Title: Re: Wrong position in View
Post by: Dreamflask on April 11, 2015, 12:15:25 pm

The offset is needed for the current tile-position.
I copy a rectangle, then i paste it at mouse position.
So i copying tile for tile from old rect to new rect. In my array all is right, but i need to set the new Vertexarray position and this fails when i have moved the view or zoomed.

Here I paste you the full function:

(click to show/hide)

void TileMap::pasteSelectedTiles(sf::Vector2i mousePosition)
{
       
        sf::Vector2f mousePositionWorld = _window.mapPixelToCoords(mousePosition);

        if (!isAllowedPosition(mousePositionWorld)) return;    

        int left = _chunks.x;
        int top = _chunks.y;
        int bottom = 0;
        int right = 0;
        int numOfElements = 0;

        applyTileMapSelectionIndices(left,top,bottom,right, numOfElements);
       
       

        if (numOfElements <= 0)
                return;


                               
        //std::cout << "Got " << numOfElements << " for copy. " << "Left[" << left << "][" << top << "] to Bottom[" << right << "][" << bottom << "]" << std::endl;
        //Got Dimensions
        int x = static_cast<int>(mousePositionWorld.x / chunksize);
        int y = static_cast<int>(mousePositionWorld.y / chunksize);
        std::cout << "Paste at <" << x << ":" << y << ">" << std::endl;


        const int sizex = 1 + (right - left);
        const int sizey = 1 + (bottom - top);  
               

        //////////////////////////////////////////////////////////////////////////
        // Create temp Vector
        //////////////////////////////////////////////////////////////////////////     
        using DimVec = std::vector < std::vector< Tile*> > ;
        std::array< DimVec,count> _tempArray;
        for (int layer = 0; layer < Layer::count; layer++)
        {
                _tempArray[layer].assign(sizex,std::vector<Tile*>(sizey,nullptr));
        }

        //////////////////////////////////////////////////////////////////////////
        // Copy to temp Vector
        //////////////////////////////////////////////////////////////////////////
        for (int layer = 0; layer < Layer::count; layer++)
        {
                //minLeft selectedElement to maxRight selectedElement
                for (int ix = 0; ix < sizex; ++ix)
                {
                        if (!isAllowedPositionX(left + ix)) break;
                        //minTop selectedElement to maxBottom selectedElement
                        for (int iy = 0; iy < sizey; ++iy)
                        {
                                if (!isAllowedPositionY(top + iy)) break;
                                //std::cout << "Accessing <L" << layer << ":" << ix << ":" << iy << ">" << std::endl;
                                Tile& oldTile = _layeredChunks[layer][left + ix][top + iy];
                                //is Tile marked for copy?
                                if (oldTile.isCopyable())
                                {
                                        _tempArray[layer][ix][iy] = &oldTile;
                                }
                                else
                                {
                                        _tempArray[layer][ix][iy] = nullptr;
                                }
                        }
                }
        }
        //////////////////////////////////////////////////////////////////////////
        // Paste from temp Vector
        //////////////////////////////////////////////////////////////////////////

        sf::Vector2f targetWorldPosition;
        for (int layer = 0; layer < Layer::count; layer++)
        {
                //minLeft selectedElement to maxRight selectedElement
                for (int ix = 0; ix < sizex; ++ix)
                {
                        if (!isAllowedPositionX(x + ix)) break;
                        //minTop selectedElement to maxBottom selectedElement
                        for (int iy = 0; iy < sizey; ++iy)
                        {
                                if (!isAllowedPositionY(y + iy)) break;
                                //std::cout << "Accessing2 <L" << layer << ":" << ix << ":" << iy << ">" << std::endl;
                               
                                //std::cout << "Copying <L" << layer << ":" << ix << ":" << iy << ">" << std::endl;
                                Tile* oldTile = _tempArray[layer][ix][iy];
                                if (oldTile == nullptr) continue;


                                Tile& newTile = _layeredChunks[layer][x + ix][y + iy];                                                 
                                               
                                //Apply copy options
                                newTile = *oldTile;
                               
                                //////////////////////////////////////////////////////////////////////////
                                // Here is the PROBLEM! WorldCoordinates will be not correct if I zoom or move my _mapView
                                //////////////////////////////////////////////////////////////////////////
                                //Set converted worldMousePosition (Paste position start in mapView Coords)
                                sf::Vector2f pasteCoords(x*chunksize,y*chunksize);

                                //Add target offset (past position + offset) Where should the current tile be displayed?
                                pasteCoords.x += (ix*chunksize);
                                pasteCoords.y += (iy*chunksize);

                                //Set new tile position (Always right until i zoom or move view)
                                newTile.setPosition(pasteCoords);


                                newTile.setCopyable(false);
                                newTile.setSelected(false);
                                newTile.setVisible(true);
                               
                                if (_selectionCut)
                                {
                                        //Apply xcopy options
                                        oldTile->setVisible(false);
                                        oldTile->setCopyable(false);
                                }
                        }
                }
        }
}