为什么我的播放器遵循OrthographicCamera

时间:2014-03-01 11:18:46

标签: libgdx

我的游戏呈现平铺地图。我让OrthographicCamera将其position.x更改为右侧,并可以看到背景(平铺地图)滚动。这很好。

但是其他物体(玩家和一些球)会(视觉上)改变他们对应于相机的位置。它们不应该移动,因为只有相机移动。

package com.me.drop;
import java.util.Iterator;
import com.badlogic.gdx.ApplicationListener;
import com.badlogic.gdx.Game;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input.Keys;
import com.badlogic.gdx.audio.Music;
import com.badlogic.gdx.audio.Sound;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL10;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.PerspectiveCamera;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.VertexAttributes.Usage;
import com.badlogic.gdx.graphics.g2d.Sprite;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.graphics.g3d.Environment;
import com.badlogic.gdx.graphics.g3d.Material;
import com.badlogic.gdx.graphics.g3d.Model;
import com.badlogic.gdx.graphics.g3d.ModelBatch;
import com.badlogic.gdx.graphics.g3d.ModelInstance;
import com.badlogic.gdx.graphics.g3d.attributes.ColorAttribute;
import com.badlogic.gdx.graphics.g3d.environment.DirectionalLight;
import com.badlogic.gdx.graphics.g3d.utils.ModelBuilder;
import com.badlogic.gdx.maps.tiled.TiledMap;
import com.badlogic.gdx.maps.tiled.TiledMapRenderer;
import com.badlogic.gdx.maps.tiled.TiledMapTileLayer;
import com.badlogic.gdx.maps.tiled.TmxMapLoader;
import com.badlogic.gdx.maps.tiled.renderers.OrthogonalTiledMapRenderer;
import com.badlogic.gdx.math.Circle;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.math.Rectangle;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.physics.box2d.Body;
import com.badlogic.gdx.physics.box2d.BodyDef;
import com.badlogic.gdx.physics.box2d.BodyDef.BodyType;
import com.badlogic.gdx.physics.box2d.Box2DDebugRenderer;
import com.badlogic.gdx.physics.box2d.CircleShape;
import com.badlogic.gdx.physics.box2d.Fixture;
import com.badlogic.gdx.physics.box2d.FixtureDef;
import com.badlogic.gdx.physics.box2d.PolygonShape;
import com.badlogic.gdx.physics.box2d.World;
import com.badlogic.gdx.utils.Array;
import com.badlogic.gdx.utils.GdxNativesLoader;
import com.badlogic.gdx.utils.TimeUtils;


public class MyTestGame extends Game {
   Texture dropImage;
   Texture bucketImage;
   Sound dropSound;
   Music rainMusic;
   SpriteBatch batch;
   OrthographicCamera camera;
   Rectangle bucket;
   Array<Rectangle> raindrops;
   long lastDropTime;


   Animator animator = new Animator();
   Body animatorBody;
   private Physics physics;

   public Environment environment;
  // public PerspectiveCamera cam;
   public Model model;
   public ModelBatch modelBatch;
   public ModelInstance instance;


   static final int WIDTH  = 1600;
   static final int HEIGHT = 960;
   public final static float ORTHO_SCALE=1;
   public final static float WORLD_SCALE=32;

   Ball balls[] = new Ball[10];
   Spieler player;


   @Override
   public void create() {

       environment = new Environment();
       environment.set(new ColorAttribute(ColorAttribute.AmbientLight, 0.4f, 0.4f, 0.4f, 1f));
       environment.add(new DirectionalLight().set(0.8f, 0.8f, 0.8f, -1f, -0.8f, -0.2f));


       glViewport = new Rectangle(0, 0, WIDTH, HEIGHT);


      // load the images for the droplet and the bucket, 64x64 pixels each
      dropImage = new Texture(Gdx.files.internal("droplet.png"));
      bucketImage = new Texture(Gdx.files.internal("bucket.png"));

      // load the drop sound effect and the rain background "music"
      dropSound = Gdx.audio.newSound(Gdx.files.internal("drop.wav"));
      rainMusic = Gdx.audio.newMusic(Gdx.files.internal("rain.mp3"));

      // start the playback of the background music immediately
      rainMusic.setLooping(true);
      rainMusic.play();

      // create the camera and the SpriteBatch
      camera = new OrthographicCamera();
      //camera.setToOrtho(false, 400, 240);
      camera.setToOrtho(false, 800/ORTHO_SCALE, 480/ORTHO_SCALE);
      batch = new SpriteBatch();


      ModelBuilder modelBuilder = new ModelBuilder();
      model = modelBuilder.createBox(5f, 5f, 5f,
          new Material(ColorAttribute.createDiffuse(Color.GREEN)),
          Usage.Position | Usage.Normal);
      instance = new ModelInstance(model);

      // Box2d
      physics = Physics.getInstance();

      // floor
      physics.initFloor(0f, 0f, camera.viewportWidth, 0f);
      // ceiling
     // physics.initFloor(0f, camera.viewportHeight, camera.viewportWidth, 10f);
      // left Wall
      physics.initFloor(0f, 0f, 0f, camera.viewportHeight);
      // right Wall   
      physics.initFloor(camera.viewportWidth, 0f, 0f, camera.viewportHeight);


      float x = 150;
      float y = camera.viewportHeight;
      for (int i = 0; i < balls.length; i++) {
          if (i%10==0) {
              x += 10;
              y = camera.viewportHeight / 2;
          }
          y += x;
         balls[i] = new Ball(x, y , 20f , 20f, 0.4f, 0.8f);
      }
      player = new Spieler(50, camera.viewportHeight, 60f, 120f);

      loadBackground();
   }


   TiledMapRenderer tileRenderer;

   public void loadBackground() {
       TiledMap map = new TmxMapLoader().load("maps/mymap.tmx");
       System.out.println(map.getTileSets().toString());
       float unitScale = 1 / 1;
       tileRenderer = new OrthogonalTiledMapRenderer(map, unitScale);


       physics.createFixturesForMap(map);
   }




   private Rectangle           glViewport;


   //@Override
   public void render() {


      GL10 gl = Gdx.graphics.getGL10();

      // Camera --------------------- /
      gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
      gl.glViewport((int) glViewport.x, (int) glViewport.y,
              (int) glViewport.width, (int) glViewport.height);
//


      // tell the camera to update its matrices.
      camera.update();
      camera.apply(gl);


      // tell the SpriteBatch to render in the
      // coordinate system specified by the camera.
      batch.setProjectionMatrix(camera.combined);



   // background
      tileRenderer.setView(camera);
      tileRenderer.render();


      for (Ball b : balls)
          b.render();


      player.render();

      grabUserAction();


      // Box2d
      physics.step();
      updateObjects();
      physics.debugRenderer.render(physics.world, camera.combined);

   }

    private void grabUserAction() {
          // process user input
          if(Gdx.input.isTouched()) {
             Vector3 touchPos = new Vector3();
             touchPos.set(Gdx.input.getX(), Gdx.input.getY(), 0);
             camera.unproject(touchPos);
             bucket.x = touchPos.x - 64 / 2;
          }


        Vector2 vel = this.player.getBody().getLinearVelocity();
        Vector2 pos = this.player.getBody().getPosition();
        // apply left impulse, but only if max velocity is not reached yet
        if (Gdx.input.isKeyPressed(Keys.LEFT)) { // && vel.x > -MAX_VELOCITY) {
            // this.animatorBody.localPoint2.x -= 200 *
            // Gdx.graphics.getDeltaTime();
            pos.x -= 2 * Gdx.graphics.getDeltaTime();
            this.player.getBody().setTransform(pos, 0);
            // this.animatorBody.applyLinearImpulse(0, -0.8f, pos.x, pos.y,
            // true);
            // this.animatorBody.applyLinearImpulse(-5000, 0, pos.x, pos.y,
            // true);
        }

        // apply right impulse, but only if max velocity is not reached yet
        if (Gdx.input.isKeyPressed(Keys.RIGHT)) { // && vel.x < MAX_VELOCITY) {
            // this.animatorBody.localPoint2.x += 200 *
            // Gdx.graphics.getDeltaTime();
            pos.x += 2 * Gdx.graphics.getDeltaTime();
            this.player.getBody().setTransform(pos, 0);
            // this.animatorBody.applyLinearImpulse(5000, 0, pos.x, pos.y,
            // true);

        }

        if (Gdx.input.isKeyPressed(Keys.UP)) {
            Vector2 impuls = new Vector2(0, 500f);
            this.player.getBody().applyLinearImpulse(impuls, player.getBody().getWorldCenter(),true);
//          this.animatorBody.applyAngularImpulse(-5.0f, true);
            //(impulse, wake);(new b2Vec2(0.0, -3.0), Body.GetWorldCenter());
        }

        if (Gdx.input.isKeyPressed(Keys.D)) {
            this.camera.position.x += 2;
            this.camera.update();

        }
        else if (Gdx.input.isKeyPressed(Keys.A)) {
            this.camera.position.x -= 2;
            this.camera.update();
        }

    }

   private void updateObjects() {
       Array<Body> array = new Array<Body>();
       physics.world.getBodies(array);
       Iterator<Body> bi = array.iterator();

       while (bi.hasNext()){
           Body b = bi.next();


           // Get the body's user data - in this example, our user 
           // data is an instance of the Entity class
           IObject e = (IObject) b.getUserData();


           if (e != null) {
               // Update the entities/sprites position and angle
               e.setPosition((b.getPosition().x - e.getWidth()/2/WORLD_SCALE) * WORLD_SCALE 
                           , (b.getPosition().y - e.getHeight()/2/WORLD_SCALE) * WORLD_SCALE);
               // We need to convert our angle from radians to degrees
               //e.setRotation(MathUtils.radiansToDegrees * b.getAngle());
           }
       }
   }

   @Override
   public void dispose() {
      // dispose of all the native resources
      dropImage.dispose();
      bucketImage.dispose();
      dropSound.dispose();
      rainMusic.dispose();
      batch.dispose();

    //  modelBatch.dispose();
      model.dispose();
   }

   @Override
   public void resize(int width, int height) {
       super.resize(width, height);
//     
//     Vector3 oldpos = new Vector3(camera.position);
//     camera.setToOrtho(false,
//                        width/WORLD_SCALE,
//                        height/WORLD_SCALE);
//     camera.translate(oldpos.x-camera.position.x,oldpos.y-camera.position.y);
   }

   @Override
   public void pause() {
       super.pause();
   }

   @Override
   public void resume() {
       super.resume();
   }
}

0 个答案:

没有答案