libgdx multiplayer -如何处理不同的屏幕分辨率

Question

我正在用libgdx在android手机之间做一个多人空中曲棍球游戏。我已经能够用tcp连接连接这两个电话，它们交换了彼此的位置。这两个电话具有不同的分辨率，并且这导致图形问题，例如：-当其中一个电话中的锤子与另一个电话中的冰球在同一行时，该锤子不在冰球附近。http://en.wikipedia.org/wiki/Air_hockey，你可以在这里看到我说的是什么意思，当我说锤子和冰球时，直到我读到它，我才称它为工具和磁盘)

我需要做的是解决这个问题，这样不同屏幕大小的手机就可以毫不费力地对战了。以下是可能有帮助的其他信息：

游戏对象的大小和墙壁位置已经由屏幕的百分比确定，例如，锤子的半径是屏幕宽度的7%。此外，我通过0 -1之间的浮点数发送两个音素之间的坐标，例如中点(0.5，0.5)。但这并不能解决这个问题。

以下是我的渲染函数中与游戏图形相关的内容：

batch = new SpriteBatch();
camera = new OrthographicCamera();
height = Gdx.graphics.getWidth();
width = Gdx.graphics.getHeight();
camera.setToOrtho(false, height, width);

也许更改此函数中的任何参数可能会有所帮助，但我不知道是否需要在此处更改某些内容。

多亏了帮手。

Answer 1

好的，这个解决方案根本没有使用camera类，因此在我看来有点差强人意，但这是我大约一年前遇到类似问题时想出来的。

public abstract class BaseScreen implements Screen, InputProcessor
{
    protected int windowWidth;
    protected int windowHeight;

    public BaseScreen() 
    {
        windowWidth = Gdx.graphics.getWidth(); //width of screen
        windowHeight = Gdx.graphics.getHeight(); //height of screen
    }

    @Override
    public void resize(int width, int height)
    {
        windowWidth = width;
        windowHeight = height;
    }

    public void show()
    {
        Gdx.input.setInputProcessor(this);
    }

    public int getWindowWidth()
    {
        return windowWidth;
    }

    public int getWindowHeight()
    {
        return windowHeight;
    }

    public void setWindowWidth(int windowWidth)
    {
        this.windowWidth = windowWidth;
    }

    public void setWindowHeight(int windowHeight)
    {
        this.windowHeight = windowHeight;
    }

    ...

    public abstract void onTouchDown(float pointerX, float pointerY);
    public abstract void onTouchUp(float pointerX, float pointerY);

    @Override
    public final boolean touchDown(int screenX, int screenY, int pointer, int button)
    {
        float pointerX = InputTransform.getCursorToModelX(windowWidth, screenX);
        float pointerY = InputTransform.getCursorToModelY(windowHeight, screenY);
        onTouchDown(pointerX, pointerY);
        return false;
    }

    @Override
    public final boolean touchUp(int screenX, int screenY, int pointer, int     button) 
    {
            float pointerX = InputTransform.getCursorToModelX(windowWidth, screenX);
            float pointerY = InputTransform.getCursorToModelY(windowHeight,     screenY);
            onTouchUp(pointerX, pointerY);
            return false;
    }
}

其中appWidth是模型的宽度，appHeight是模型的高度，也就是世界的大小)

public class InputTransform
{
    private static int appWidth = 480;
    private static int appHeight = 320;

    public static float getCursorToModelX(int screenX, int cursorX) 
    {
        return (((float)cursorX) * appWidth) / ((float)screenX); 
    }

    public static float getCursorToModelY(int screenY, int cursorY) 
    {
        return ((float)(screenY - cursorY)) * appHeight / ((float)screenY) ; 
    }
}

然后，我为屏幕的视区变换和在0,480x0,320网格内绘制对象的投影变换设置了适当的参数：

    Gdx.gl.glViewport(0,  0,  Gdx.graphics.getWidth(), Gdx.graphics.getHeight()); //init screen to [0,ScreenWidth]x[0,ScreenHeight]
    Resources.batch = new SpriteBatch();
    Resources.normalProjection = new Matrix4().setToOrtho2D(0, 0, 480, 320); //create transform to [0,480]x[0,320] world grid
    Resources.batch.setProjectionMatrix(Resources.normalProjection); //initialize drawing with transform
    Resources.shapeRenderer.setProjectionMatrix(Resources.normalProjection); //initialize drawing with transform

但是如果您使用的是OrthographicCamera，那么您实际上只需要将InputTransform替换为camera.unproject()，并将摄影机视口设置为StretchViewport。考虑到我上面给出的方法有它的局限性，那就是你需要破解它才能真正从0480x0320网格中移动相机。

因此，根据页面上的文档，

private Viewport viewport;
private Camera camera;

public void create() {
    camera = new OrthographicCamera();
    viewport = new StretchViewport(480, 320, camera);
}

或者维基上的一个更完整的例子：

https://github.com/libgdx/libgdx/wiki/Orthographic-camera

或者，最重要的是，这是将正交摄影机与视口一起使用的示例：

http://www.gamefromscratch.com/post/2014/12/09/LibGDX-Tutorial-Part-17-Viewports.aspx

//copy paste from GameFromScratch:
package com.gamefromscratch;

import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.InputProcessor;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.Sprite;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.utils.viewport.StretchViewport;
import com.badlogic.gdx.utils.viewport.Viewport;

public class mouseproject extends ApplicationAdapter implements InputProcessor {
   SpriteBatch batch;
   Sprite aspectRatios;
   OrthographicCamera camera; //the camera 
   Viewport viewport; //the viewport

   @Override
   public void create () {
      batch = new SpriteBatch();
      aspectRatios = new Sprite(new Texture(Gdx.files.internal("Aspect.jpg")));
      aspectRatios.setPosition(0,0);
      aspectRatios.setSize(100,100);

      camera = new OrthographicCamera();
      viewport = new StretchViewport(100,100,camera); //stretch screen to [0,100]x[0,100] grid
      viewport.apply();

      camera.position.set(camera.viewportWidth/2,camera.viewportHeight/2,0); //set camera to look at center of viewport
      Gdx.input.setInputProcessor(this);
   }

   @Override
   public void render () {

      camera.update();
      Gdx.gl.glClearColor(1, 0, 0, 1);
      Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

      batch.setProjectionMatrix(camera.combined); //make batch draw to location defined by camera
      batch.begin();
      aspectRatios.draw(batch);
      batch.end();
   }

   @Override
   public void dispose(){
      aspectRatios.getTexture().dispose();
   }

   @Override
   public void resize(int width, int height){
      viewport.update(width, height);
      camera.position.set(camera.viewportWidth / 2, camera.viewportHeight / 2, 0);
   }

   @Override
   public boolean keyDown(int keycode) {
      return false;
   }

   @Override
   public boolean keyUp(int keycode) {
      return false;
   }

   @Override
   public boolean keyTyped(char character) {
      return false;
   }

   @Override
   public boolean touchDown(int screenX, int screenY, int pointer, int button) {

      Gdx.app.log("Mouse Event","Click at " + screenX + "," + screenY);
      Vector3 worldCoordinates = camera.unproject(new Vector3(screenX,screenY,0)); //obtain the touch in world coordinates: similar to InputTransform used above
      Gdx.app.log("Mouse Event","Projected at " + worldCoordinates.x + "," + worldCoordinates.y);
      return false;
   }

   @Override
   public boolean touchUp(int screenX, int screenY, int pointer, int button) {
      return false;
   }

   @Override
   public boolean touchDragged(int screenX, int screenY, int pointer) {
      return false;
   }

   @Override
   public boolean mouseMoved(int screenX, int screenY) {
      return false;
   }

   @Override
   public boolean scrolled(int amount) {
      return false;
   }
}