libGDX Welt speichern

[cool_brivk24]

Hallo liebes Forum:

Ich habe mir ein Minecraft-clone mit LibGDX(Desktop) programmiert und wollte fragen ob es möglich wäre die generierte Plattform, die ich schon bebaut habe, zu speichern und als Datei später zu laden. Speichern, fände ich noch Okay. Ich weiß, dass dies mehrere Funktionen benötigt, bzw. eine getBlocks Funktion. Ich poste mal den Code der HauptKlasse des core, in der alles steht.

package com.coolbrick.minecraft;
import javax.swing.text.html.HTML.Tag;
import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.PerspectiveCamera;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.graphics.g3d.Environment;
import com.badlogic.gdx.graphics.g3d.ModelBatch;
import com.badlogic.gdx.graphics.g3d.attributes.ColorAttribute;
import com.badlogic.gdx.graphics.g3d.environment.DirectionalLight;
public class MinecraftClone extends ApplicationAdapter {
 
 //Camera
 public final float field_of_view = 67f;
 public final float camera_near = 1;
 public final float camera_far = 300;
 public final float camera_velocity = 15;
 public final float camera_degrees_per_pixel = 0.08f;
 public final float crosshair_size = 25;
 
 public Environment env;
 public PerspectiveCamera camera;
 public SpriteBatch batch;
 public ModelBatch model;
 public Texture crosshair;
 public FPSControll camera_controller;
 public Grid grid;
 public TagNacht instance;
 public float clearColor1 = 0.5f;
 public float clearColor2 = 0.8f;
 public float clearColor3 = 1f;
 public float clearColorAlpha = 1f;
 
 @Override
 public void create() {
 
 
  env = new Environment();
  env.set(new ColorAttribute(ColorAttribute.AmbientLight, 0.5f, 0.5f, 0.5f, 1f));
  env.add(new DirectionalLight().set(252f, 233f, 79f, -1f, -0.8f, -0.5f));
  env.add(new DirectionalLight().set(0.6f, 0.6f, 0.6f, 1f, 0.8f, 0.5f));
 
  batch = new SpriteBatch();
  model = new ModelBatch();
  instance = new TagNacht();
 
 
 
  camera = new PerspectiveCamera(field_of_view, Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
  camera.position.set(0f, 10f, 10f);
  camera.near = camera_near;
  camera.far = camera_far;
 
  camera_controller = new FPSControll(camera) {
   @Override
   public boolean touchDown(int screenX, int screenY, int pointer, int button) {
    if(button == 0) {
     grid.editBoxByRayCast(camera.position, camera.direction, null);
    } else if(button == 1) {
     grid.editBoxByRayCast(camera.position, camera.direction, Block.Type.DirtBlock);
    } else if(button == 2) {
     grid.editBoxByRayCast(camera.position, camera.direction, Block.Type.StoneBlock);
    }
    return super.touchDown(screenX, screenY, pointer, button);
   }
  };
  camera_controller.setDegreesPerPixel(camera_degrees_per_pixel);
  camera_controller.setVelocity(camera_velocity);
 
  crosshair = new Texture(Gdx.files.internal("interface/Crosshair.png"));
 
  grid = new Grid();
 
  Gdx.input.setInputProcessor(camera_controller);
  Gdx.input.setCursorCatched(true);
 
 
 }
 @Override
 public void render() {
  camera_controller.update();
  Gdx.gl.glClearColor(clearColor1, clearColor2, clearColor3, clearColorAlpha);
  Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT | GL20.GL_DEPTH_BUFFER_BIT);
 
  model.begin(camera);
  grid.renderGrid(model, env);
  model.end();
 
  float crosshair_x = (Gdx.graphics.getWidth() - crosshair_size) / 2;
  float crosshair_y = (Gdx.graphics.getHeight() - crosshair_size) / 2;
 
  batch.begin();
 
  batch.draw(crosshair, crosshair_x, crosshair_y, crosshair_size, crosshair_size);
 
  batch.end();
 }
 @Override
 public void dispose() {
  grid.dispose();
  crosshair.dispose();
 }
}

Und meiner Block.java Klasse

package com.coolbrick.minecraft;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.VertexAttributes;
import com.badlogic.gdx.graphics.g3d.Material;
import com.badlogic.gdx.graphics.g3d.Model;
import com.badlogic.gdx.graphics.g3d.ModelInstance;
import com.badlogic.gdx.graphics.g3d.attributes.TextureAttribute;
import com.badlogic.gdx.graphics.g3d.utils.MeshPartBuilder;
import com.badlogic.gdx.graphics.g3d.utils.ModelBuilder;
import com.badlogic.gdx.graphics.g3d.utils.shapebuilders.BoxShapeBuilder;
import com.badlogic.gdx.math.Matrix4;
import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.utils.Disposable;
public class Block implements Disposable {
 
 private final float box_size = 5f;
 
 private static ModelBuilder model_builder = new ModelBuilder();
 private Material mat;
 private Type type;
 private ModelInstance instance;
 private Model model;
 
 public Block(Texture texture, Type type) {
  this.type = type;
  mat = new Material(TextureAttribute.createDiffuse(texture));
  model_builder.begin();
  MeshPartBuilder mesh_part_builder = model_builder.part("box", GL20.GL_TRIANGLES,
    VertexAttributes.Usage.Position | VertexAttributes.Usage.Normal | VertexAttributes.Usage.TextureCoordinates, mat);
 
  BoxShapeBuilder.build(mesh_part_builder, box_size, box_size, box_size);
 
  model = model_builder.end();
 
  instance = new ModelInstance(model);
 }
 
 public void setPosition(float x, float y, float z) {
  instance.transform = new Matrix4().translate(x, y, z);
 }
 
 public Vector3 getPosition() {
  float x = instance.transform.getValues()[Matrix4.M03];
  float y = instance.transform.getValues()[Matrix4.M13];
  float z = instance.transform.getValues()[Matrix4.M23];
  return new Vector3(x,y,z);
 }
 
 public Model getModel() {
  return model;
 }
 
 public ModelInstance getInstance() {
  return instance;
 
 }
 @Override
 public void dispose() {
  model.dispose();
 }
 
 
 public enum Type{
  DirtBlock,
  StoneBlock,
  GrassBlock,
  SandBlock,
  GlassBlock
 
 }
 
}

Nicht zu vergessen die Grid.java Klasse

package com.coolbrick.minecraft;
import com.badlogic.gdx.graphics.g3d.Environment;
import com.badlogic.gdx.graphics.g3d.ModelBatch;
import com.badlogic.gdx.math.Vector3;
import com.badlogic.gdx.utils.Disposable;
public class Grid implements Disposable{
 private final int grid_size = 40;
 private final float field_size = 5f;
 private Block field[][][];
 
 public Grid() {
  field = new Block[grid_size][grid_size][grid_size];
  for(int i = 0; i < grid_size; i++) {
   for(int k = 0; k < grid_size; k++) {
     field[i][0][k] = new StoneBlock();
 
   }
  }
  updatePosition();
 }
 
 public void updatePosition() {
  for(int i = 0; i < grid_size; i++) {
   for(int j = 0; j < grid_size; j++) {
    for(int k = 0; k < grid_size; k++) {
     float x = i * field_size;
     float y = j * field_size;
     float z = k * field_size;
     
     if(field[i][j][k] != null) {
      field[i][j][k].setPosition(x, y, z);
     }
     
     
    }
   }
  }
 }
 
 public void renderGrid(ModelBatch batch, Environment env) {
  for(int i = 0; i < grid_size; i++) {
   for(int j = 0; j < grid_size; j++) {
    for(int k = 0; k < grid_size; k++) {
     if(field[i][j][k] != null) {
      batch.render(field[i][j][k].getInstance(), env);
     }
    }
   }
  }
     
  
 }
 
 public void editBoxByRayCast(Vector3 start_point, Vector3 direction, Block.Type type) {
  int lastPosX = 0;
  int lastPosY = 0;
  int lastPosZ = 0;
  
  for(int i = 1; i < grid_size * 2; i++) {
   Vector3 tmp_start = new Vector3(start_point);
   Vector3 tmp_direct = new Vector3(direction);
   tmp_direct.nor();
   tmp_direct.scl(i);
   Vector3 line = tmp_start.add(tmp_direct);
   line.scl(1 / field_size);
   int x = Math.round(line.x);
   int y = Math.round(line.y);
   int z = Math.round(line.z);
   
   if(x > (grid_size - 1) || y > (grid_size - 1) || z > (grid_size -1) || x < 0 || y < 0 || z < 0) {
    break;
   }
   
   if(field[x][y][z] != null) {
    if(type == null) {
     if(field[x][y][z] != null) {
      field[x][y][z].dispose();
      field[x][y][z] = null;
      updatePosition();
     }
    } else if (type == Block.Type.DirtBlock) {
     field[lastPosX][lastPosY][lastPosZ] = new DirtBlock();
     updatePosition();
    
    } else if (type == Block.Type.StoneBlock) {
     field[lastPosX][lastPosY][lastPosZ] = new StoneBlock();
     updatePosition();
    }
    break;
   }
   
   lastPosX = x;
   lastPosY = y;
   lastPosZ = z;
   
  }
 }
 
 
 @Override
 public void dispose() {
  for(int i = 0; i < grid_size; i++) {
   for(int j = 0; j < grid_size; j++) {
    for(int k = 0; k < grid_size; k++) {
     if(field[i][j][k] != null) {
      field[i][j][k].dispose();
     }
    }
   }
  }
  
 }
}

mfg

-cool_brick24