LibGDX TiledMap की सीमा के भीतर कैमरा रखते हैं

Question

मेरे पास एक साधारण TiledMap है जिसे मैं ठीक प्रस्तुत कर सकता हूं। मेरे पास एक खिलाड़ी hopping (Box2D के साथ) के आसपास है और मेरा कैमरा खिलाड़ी के आसपास इस प्रकार है:

cam.position.set(
    player.position().x * Game.PPM + Game.V_WIDTH / 4,
    player.position().y * Game.PPM,
    0
);
cam.update();

हालाँकि, कैमरा TiledMap से "बंद" हो जाएगा। मैं TiledMap पर अपना कैमरा कैसे रख सकता हूं, इसलिए जब मैं अपने मानचित्र के किनारों के पास होता हूं, तो कैमरा स्क्रॉल करना बंद कर देता है और खिलाड़ी कैमरा के किनारे की ओर बढ़ जाता है।

Answer 1

ठीक है, इसलिए आप यहां दो आयतों के साथ काम कर रहे हैं। एक बड़ा स्थिर एक (नक्शा) और उसके अंदर एक छोटा घूमता हुआ (कैमरा)। आप जो चाहते हैं, वह छोटी आयत की सीमाओं को बड़ी आयत के भीतरी सीमा से बाहर नहीं जाने देना है।

// These values likely need to be scaled according to your world coordinates.
// The left boundary of the map (x)
int mapLeft = 0;
// The right boundary of the map (x + width)
int mapRight = 0 + map.getWidth();
// The bottom boundary of the map (y)
int mapBottom = 0;
// The top boundary of the map (y + height)
int mapTop = 0 + map.getHeight();
// The camera dimensions, halved
float cameraHalfWidth = cam.viewportWidth * .5f;
float cameraHalfHeight = cam.viewportHeight * .5f;

// Move camera after player as normal

float cameraLeft = cam.position.x - cameraHalfWidth;
float cameraRight = cam.position.x + cameraHalfWidth;
float cameraBottom = cam.position.y - cameraHalfHeight;
float cameraTop = cam.position.y + cameraHalfHeight;

// Horizontal axis
if(map.getWidth() < cam.viewportWidth)
{
    cam.position.x = mapRight / 2;
}
else if(cameraLeft <= mapLeft)
{
    cam.position.x = mapLeft + cameraHalfWidth;
}
else if(cameraRight >= mapRight)
{
    cam.position.x = mapRight - cameraHalfWidth;
}

// Vertical axis
if(map.getHeight() < cam.viewportHeight)
{
    cam.position.y = mapTop / 2;
}
else if(cameraBottom <= mapBottom)
{
    cam.position.y = mapBottom + cameraHalfHeight;
}
else if(cameraTop >= mapTop)
{
    cam.position.y = mapTop - cameraHalfHeight;
}

तो तर्क बहुत आसान है। छोटे बॉक्स को बड़े बॉक्स के अंदर रखें। एक बार जब आप समझते हैं कि विचार उस कोड को नीचे गिराने के लिए स्वतंत्र महसूस करता है। यदि आप चाहें तो आप इसे अपने कैमरा स्थिति ट्रैकिंग में नेस्टेड मिन / मैक्स स्टेटमेंट की एक श्रृंखला में स्थानांतरित कर सकते हैं।

Comments

मुझे पहले बिस्तर पर जाना चाहिए। मेरे पास कुछ ऐसा था जिसे लागू किया गया, लेकिन यह काम नहीं कर सका। लेकिन एक अच्छी setPosition()विधि को कॉल करने के बजाय , यह सीमा को ठीक कर देगा, मैं अभी भी कैम स्थिति को सीधे सेट कर रहा था (जैसे cam.position.set()) यह एक आकर्षण की तरह काम करता है! स्पष्टीकरण के लिए धन्यवाद!

— आर्यजन

Answer 2

आप कैमरे की स्थिति को आसानी से इस तरह से मानचित्र की सीमाओं में जकड़ सकते हैं:

camera.position.x = MathUtils.clamp(camera.position.x, camViewportHalfX, mapWidth - camViewportHalfX);
camera.position.y = MathUtils.clamp(camera.position.y, camViewportHalfY, mapHeight - camViewportHalfY);

Comments

क्या है camViewportHalfXऔर camViewportHalfY?

— साइफ्रे

@ चक्र: यह व्यूपोर्ट X और Y अक्ष का आधा आकार है।

— मथायस

तो camViewportHalfXके बराबर होगा camera.viewportWidth / 2?

— साइफर

Answer 3

सीमा Cameraमें स्थानांतरित करने के लिए इस्तेमाल किया गया था।TiledMapOrthogonalTiledMapRenderer

मैंने यह भी देखा है कि यह अनपेक्षित रूप से व्यवहार करता है: जबकि Cameraनक्शे की सीमा तक पहुंच जाता है, जड़ता द्वारा टाइल किए गए नक्शे की तरह, कुछ पिक्सेल बहुत आगे बढ़ते हैं (यह स्वाइप के वेग पर निर्भर करता है)।

एक समाधान के रूप में , प्रत्येक Cameraआंदोलन पर, Cameraजबरन नक्शा सीमा में डाला जाता है। putInMapBounds()विधि देखें ।

TiledMapप्रतिपादन में glitches से बचने के लिए , इस्तेमाल किया Math.min(float, float)।

अपने को संभालने के लिए इस श्रोता का उपयोग करें Camera:

/**
 * @author Gram <[e-mail]>
 */
public class CameraListener extends InputAdapter {

    private final UIStage stage;
    private final Camera camera;
    private final Vector3 curr;
    private final Vector3 last;
    private final Vector3 delta;
    private final int mapWidth;
    private final int mapHeight;

    public CameraListener(UIStage stage) {
        this.stage = stage;
        this.camera = stage.getViewport().getCamera();

        curr = new Vector3();
        last = new Vector3(-1, -1, -1);
        delta = new Vector3();

        TiledMapTileLayer layer = stage.getLevel().getMap().getFirstLayer();
        mapWidth = layer.getWidth() * DDGame.TILE_HEIGHT;
        mapHeight = layer.getHeight() * DDGame.TILE_HEIGHT;
    }

    @Override
    public boolean touchDragged(int x, int y, int pointer) {

        camera.unproject(curr.set(x, y, 0));

        if (!(last.x == -1 && last.y == -1 && last.z == -1)) {
            camera.unproject(delta.set(last.x, last.y, 0));
            delta.sub(curr);
            camera.translate(Math.min(delta.x, 5), Math.min(delta.y, 5), 0);
            if (isInMapBounds()) {
                stage.moveBy(Math.min(delta.x, 5), Math.min(delta.y, 5));
            }
        }

        last.set(x, y, 0);

        putInMapBounds();

        return false;
    }


    private boolean isInMapBounds() {

        return camera.position.x >= camera.viewportWidth / 2f
                && camera.position.x <= mapWidth - camera.viewportWidth / 2f
                && camera.position.y >= camera.viewportHeight / 2f
                && camera.position.y <= mapHeight - camera.viewportHeight / 2f;

    }

    private void putInMapBounds() {

        if (camera.position.x < camera.viewportWidth / 2f)
            camera.position.x = camera.viewportWidth / 2f;
        else if (camera.position.x > mapWidth - camera.viewportWidth / 2f)
            camera.position.x = mapWidth - camera.viewportWidth / 2f;

        if (camera.position.y < camera.viewportHeight / 2f)
            camera.position.y = camera.viewportHeight / 2f;
        else if (camera.position.y > mapHeight - camera.viewportHeight / 2f)
            camera.position.y = mapHeight - camera.viewportHeight / 2f;

        stage.moveTo(
                camera.position.x,
                camera.position.y);

    }

    @Override
    public boolean touchUp(int x, int y, int pointer, int button) {
        last.set(-1, -1, -1);
        Log.info("Camera at " + camera.position.x + ":" + camera.position.y);
        return false;
    }
}

Answer 4

यदि आपके पास देखभाल करने के लिए ज़ूम फैक्टर है, तो मुझे यह बेहतर काम करने के लिए मिला:

public void fixBounds() {
    float scaledViewportWidthHalfExtent = viewportWidth * zoom * 0.5f;
    float scaledViewportHeightHalfExtent = viewportHeight * zoom * 0.5f;

    // Horizontal
    if (position.x < scaledViewportWidthHalfExtent)
        position.x = scaledViewportWidthHalfExtent;
    else if (position.x > xmax - scaledViewportWidthHalfExtent)
        position.x = xmax - scaledViewportWidthHalfExtent;

    // Vertical
    if (position.y < scaledViewportHeightHalfExtent)
        position.y = scaledViewportHeightHalfExtent;
    else if (position.y > ymax - scaledViewportHeightHalfExtent)
        position.y = ymax - scaledViewportHeightHalfExtent;
}