[Util/Class] Evas - Schematics ganz einfach

Hier könnt ihr anderen Leuten helfen, indem ihr Anleitungen oder praktische Codesegmente zur Verfügung stellt.

[Util/Class] Evas - Schematics ganz einfach

Beitragvon Yekllurt » So 8. Feb 2015, 08:59

Hi liebe Forum Mitglieder,

ich habe bereits vor einiger Zeit im Bukkkit Forum meine Klasse gepostet, da ich nun hier jedoch aktiver bin, habe ich mich entschieden diese auch hier zu posten.

Mit der Klasse Evas, ist es möglich einfach Regionen abzuspeichern, diese auch bei Bedarf zu reseten, zu dem hat sie noch ein paar Methoden, die nützlich sein könnten.

Die Evas Iterator Klasse ist vom KingFaris11 (http://bukkit.org/members/kingfaris11.90856141/)

Code: Alles auswählen
  1. import java.io.File;
  2. import java.io.IOException;
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5. import java.util.List;
  6. import org.bukkit.Bukkit;
  7. import org.bukkit.Location;
  8. import org.bukkit.Material;
  9. import org.bukkit.World;
  10. import org.bukkit.block.Block;
  11. import org.bukkit.configuration.file.YamlConfiguration;
  12. import org.bukkit.entity.Player;
  13. /**
  14. *
  15. * @author Yekllurt
  16. * copyright 2014
  17. */
  18. public class Evas {
  19.    enum EvasType{
  20.       Square;
  21.       public static EvasType type;
  22.    }
  23.    private int CordinateX, CordinateY, CordinateZ, CordinateX1, CordinateY1, CordinateZ1, size;
  24.    private World CordinateWorld;
  25.    private EvasType evasType;
  26.    private String name;
  27.    private File file;
  28.    private YamlConfiguration yml;
  29.    /**
  30.    * @param Erstellt ein neues Evas Objekt
  31.    * @param World world : ist die Welt in der die Evas ist
  32.    * @param Integer x : ist die x Cordinate, Ecke 1 falls EvasType.Square
  33.    * @param Integer y : ist die y Cordinate, Ecke 1 falls EvasType.Square
  34.    * @param Integer z : ist die z Cordinate, Ecke 1 falls EvasType.Square
  35.    * @param Integer x1 : ist die x Cordinate, Ecke 2 falls EvasType.Square
  36.    * @param Integer y1 : ist die y Cordinate, Ecke 2 falls EvasType.Square
  37.    * @param Integer z1 : ist die t Cordinate, Ecke 2 falls EvasType.Square
  38.    */
  39.    public Evas(World world, int x, int y, int z, int x1, int y1, int z1, EvasType type, String name, String savePath){
  40.       this.CordinateWorld = world;
  41.       this.name = name;
  42.       //this.file = new File("plugins/Evas/Evas", name + ".evas");
  43.       this.file = new File(savePath, name + ".evas");
  44.       try {
  45.          this.file.createNewFile();
  46.          this.file.setReadable(false);
  47.          this.yml = YamlConfiguration.loadConfiguration(file);
  48.       } catch (IOException e) {
  49.          e.printStackTrace();
  50.       }
  51.       switch (type) {
  52.       case Square:
  53.          if(y > y1){
  54.             this.CordinateX = Math.min(x1, x);
  55.             this.CordinateY = Math.min(y1, y);
  56.             this.CordinateZ = Math.min(z1, z);
  57.             this.CordinateX1 = Math.max(x1, x);
  58.             this.CordinateY1 = Math.max(y1, y);
  59.             this.CordinateZ1 = Math.max(z1, z);
  60.          }else{
  61.             this.CordinateX = Math.min(x, x1);
  62.             this.CordinateY = Math.min(y, y1);
  63.             this.CordinateZ = Math.min(z, z1);
  64.             this.CordinateX1 = Math.max(x, x1);
  65.             this.CordinateY1 = Math.max(y, y1);
  66.             this.CordinateZ1 = Math.max(z, z1);
  67.          }
  68.          break;
  69.       }
  70.       this.evasType = type;
  71.    }
  72.    /**
  73.    * Lädt ein Evas mit vom Namen
  74.    */
  75.    public Evas(String name, String savePath){
  76.       //this.file = new File("plugins/Evas/Evas/" + name + ".evas");
  77.       this.file = new File(savePath, name + ".evas");
  78.       this.yml = YamlConfiguration.loadConfiguration(this.file);
  79.       ArrayList<String> importantData = (ArrayList<String>) yml.getList("ImportantData");
  80.       this.CordinateWorld = Bukkit.getWorld(importantData.get(0));
  81.       this.CordinateX = Integer.valueOf(importantData.get(1));
  82.       this.CordinateY = Integer.valueOf(importantData.get(2));
  83.       this.CordinateZ = Integer.valueOf(importantData.get(3));
  84.       this.CordinateX1 = Integer.valueOf(importantData.get(4));
  85.       this.CordinateY1 = Integer.valueOf(importantData.get(5));
  86.       this.CordinateZ1 = Integer.valueOf(importantData.get(6));
  87.       this.size = Integer.valueOf(importantData.get(7));
  88.    }
  89.    //Erhalte wichtige Informationen der Klasse
  90.    
  91.    /**
  92.    * Gibt X 1 zurück
  93.    */
  94.    public int getX(){
  95.       return this.CordinateX;
  96.    }
  97.    
  98.    /**
  99.    * Gibt Y 1 zurück
  100.    */
  101.    public int getY(){
  102.       return this.CordinateY;
  103.    }
  104.    
  105.    /**
  106.    * Gibt Z 1 zurück
  107.    */
  108.    public int getZ(){
  109.       return this.CordinateZ;
  110.    }
  111.    
  112.    /**
  113.    * Gibt X 2 zurück
  114.    */
  115.    public int getX1(){
  116.       return this.CordinateX1;
  117.    }
  118.    
  119.    /**
  120.    * Gibt Y 2 zurück
  121.    */
  122.    public int getY1(){
  123.       return this.CordinateY1;
  124.    }
  125.    
  126.    /**
  127.    * Gibt Z 2 zurück
  128.    */
  129.    public int getZ1(){
  130.       return this.CordinateZ1;
  131.    }
  132.    
  133.    /**
  134.    * Gibt die Welt zurück
  135.    */
  136.    public World getWorld(){
  137.       return this.CordinateWorld;
  138.    }
  139.    
  140.    /**
  141.    * Gibt den aktuellen Namen zurück
  142.    */
  143.    public String getName(){
  144.       return this.name;
  145.    }
  146.    /**
  147.    *
  148.    * @return Gibt die Anzahl an Blöcken der Evas zurück
  149.    */
  150.    public int size(){
  151.       this.size = getBlocks().size();
  152.       return getBlocks().size();
  153.    }
  154.    /**
  155.    * @param Füllt die Blöcke mit die Luft sind mit dem gegeben Material
  156.    * @param material Das material type
  157.    * @param damage Das material byte
  158.    */
  159.    public void fill(Material material, byte damage){
  160.       List<Block> blocks = getBlocks();
  161.       for(Block block : blocks){
  162.          Block locBlock = block.getWorld().getBlockAt(block.getX(), block.getY(), block.getZ());
  163.          if(locBlock.getType() == Material.AIR){
  164.             locBlock.setType(material);
  165.             locBlock.setData(damage);
  166.          }
  167.       }
  168.    }
  169.    /**
  170.    * @param Setzt alle Blöcke zu einem Material
  171.    * @param material Das material type
  172.    * @param damage Das material byte
  173.    */
  174.    public void set(Material material, byte damage){
  175.       List<Block> blocks = getBlocks();
  176.       for(Block block : blocks){
  177.          Block locBlock = block.getWorld().getBlockAt(block.getX(), block.getY(), block.getZ());
  178.          locBlock.setType(material);
  179.          locBlock.setData(damage);
  180.       }
  181.    }
  182.    /**
  183.    * @param Ersetzt alle Blöcke mit den @material & @damage durch @toReplace & @toReplaceByte
  184.    */
  185.    public void replace(Material material, byte damage, Material toReplace, byte toReplaceByte){
  186.       List<Block> blocks = getBlocks();
  187.       for(Block block : blocks){
  188.          Block locBlock = block.getWorld().getBlockAt(block.getX(), block.getY(), block.getZ());
  189.          if(locBlock.getType() == toReplace && locBlock.getData() == toReplaceByte){
  190.          locBlock.setType(material);
  191.          locBlock.setData(damage);
  192.          }
  193.       }
  194.    }
  195.    /**
  196.    *
  197.    * @return Gibt alle Blöcke zurück
  198.    */
  199.    public List<Block> getBlocks() {
  200.    Iterator<Block> block = this.iterator();
  201.    List<Block> copy = new ArrayList<Block>();
  202.    while (block.hasNext()){
  203.       copy.add(block.next());
  204.    }
  205.    return copy;
  206.    }
  207.    
  208.    public Iterator<Block> iterator() {
  209.       return new EvasIterator(this.CordinateWorld, this.CordinateX, this.CordinateY, this.CordinateZ, this.CordinateX1, this.CordinateY1, this.CordinateZ1);
  210.    }
  211.    
  212.    public class EvasIterator implements Iterator<Block> {
  213.       private World w;
  214.       private int baseX, baseY, baseZ;
  215.       private int x, y, z;
  216.       private int sizeX, sizeY, sizeZ;
  217.    
  218.       public EvasIterator(World w, int x1, int y1, int z1, int x2, int y2, int z2) {
  219.          this.w = w;
  220.          this.baseX = x1;
  221.          this.baseY = y1;
  222.          this.baseZ = z1;
  223.          this.sizeX = Math.abs(x2 - x1) + 1;
  224.          this.sizeY = Math.abs(y2 - y1) + 1;
  225.          this.sizeZ = Math.abs(z2 - z1) + 1;
  226.          this.x = this.y = this.z = 0;
  227.       }
  228.    
  229.       public boolean hasNext() {
  230.          return this.x < this.sizeX && this.y < this.sizeY && this.z < this.sizeZ;
  231.       }
  232.    
  233.       public Block next() {
  234.       Block b = this.w.getBlockAt(this.baseX + this.x, this.baseY + this.y, this.baseZ + this.z);
  235.       if (++x >= this.sizeX) {
  236.          this.x = 0;
  237.          if (++this.y >= this.sizeY) {
  238.             this.y = 0;
  239.             ++this.z;
  240.          }
  241.       }
  242.       return b;
  243.       }
  244.    
  245.    
  246.    }
  247.    
  248.    /**
  249.    * Speichere die Evas in die Datei
  250.    */
  251.    public void save(){
  252.       ArrayList<String> importantData = new ArrayList<>();
  253.       importantData.add(this.CordinateWorld.getName());
  254.       importantData.add(String.valueOf(this.CordinateX));
  255.       importantData.add(String.valueOf(this.CordinateY));
  256.       importantData.add(String.valueOf(this.CordinateZ));
  257.       importantData.add(String.valueOf(this.CordinateX1));
  258.       importantData.add(String.valueOf(this.CordinateY1));
  259.       importantData.add(String.valueOf(this.CordinateZ1));
  260.       importantData.add(String.valueOf(size()));
  261.       //String[] importantData = {this.CordinateWorld.getName(), String.valueOf(this.CordinateX), String.valueOf(this.CordinateY), String.valueOf(this.CordinateZ), String.valueOf(this.CordinateX1), String.valueOf(this.CordinateY1), String.valueOf(this.CordinateZ1), String.valueOf(size())};
  262.       this.yml.set("ImportantData", importantData);
  263.       List<Block> blocks = getBlocks();
  264.       int count = 0;
  265.       for(Block block : blocks){
  266.          List<String> blockString = new ArrayList<>();
  267.          blockString.add(String.valueOf(block.getX()));
  268.          blockString.add(String.valueOf(block.getY()));
  269.          blockString.add(String.valueOf(block.getZ()));
  270.          blockString.add(String.valueOf(block.getType()));
  271.          blockString.add(String.valueOf(block.getData()));
  272.          //blockString = new String[]{block.getWorld().getName(), String.valueOf(block.getX()), String.valueOf(block.getY()), String.valueOf(block.getZ()), String.valueOf(block.getType()), String.valueOf(block.getData())};
  273.          count++;
  274.          yml.set(String.valueOf(count), blockString);
  275.       }
  276.       try {
  277.          this.yml.save(this.file);
  278.       } catch (IOException e) {
  279.          e.printStackTrace();
  280.       }
  281.    
  282.    }
  283.    
  284.    /**
  285.    * Setzt alle Blöcke in der Evas zum letzten gespeicherten Punkt zurück
  286.    */
  287.    public void reset(){
  288.       ArrayList<String> importantData = (ArrayList<String>) yml.getList("ImportantData");
  289.       int size = Integer.valueOf((String) importantData.get(7));
  290.       String world = importantData.get(0);
  291.       for(int i = 1; i <= size; i++){
  292.          ArrayList<String> blockString = (ArrayList<String>) this.yml.getList(String.valueOf(i));
  293.          Block b = Bukkit.getWorld(world).getBlockAt(Integer.valueOf(blockString.get(0)), Integer.valueOf(blockString.get(1)), Integer.valueOf(blockString.get(2)));
  294.          b.setType(Material.valueOf(blockString.get(3)));
  295.          b.setData(Byte.valueOf(blockString.get(4)));
  296.       }
  297.    }
  298.    
  299.    
  300.    /**
  301.    * Guck ob diese File exestiert
  302.    * @return boolean
  303.    */
  304.    public static boolean exists(String name, String path){
  305.       File f = new File(path);
  306.       for(File file : f.listFiles()){
  307.          if(file.getName().equals(name + ".evas")){
  308.             return true;
  309.          }else{
  310.             return false;
  311.          }
  312.       }
  313.       return false;
  314.    }
  315.    
  316.    
  317.    /**
  318.    * Erhalte die Location der Mitte zurpück
  319.    * @return Location
  320.    */
  321.    public Location getCenter() {
  322.       int x1 = this.CordinateX + 1;
  323.       int y1 = this.CordinateY + 1;
  324.       int z1 = this.CordinateZ + 1;
  325.       return new Location(this.getWorld(), this.CordinateX1 + (x1 - this.CordinateX1) / 2.0, this.CordinateY1 + (y1 - this.CordinateY1) / 2.0, this.CordinateZ1 + (z1 - this.CordinateZ1) / 2.0);
  326.    }
  327.    
  328.    /**
  329.    * Guck ob die Location sich in der Evas befindet
  330.    * @return
  331.    */
  332.    public boolean contains(int x, int y, int z) {
  333.       return x >= this.CordinateX && x <= this.CordinateX1 && y >= this.CordinateY && y <= this.CordinateY1 && z >= this.CordinateZ && z <= this.CordinateZ1;
  334.    }
  335.    
  336.    /**
  337.    * Benutze das im PlayerMoveEvent, um zu gucken ob der Spieler die Region betritt
  338.    * @param a e.getTo();
  339.    * @param b e.getFrom();
  340.    * @return
  341.    */
  342.    public boolean enter(Location a, Location b){
  343.       if(this.contains(a.getBlockX(), a.getBlockY(), a.getBlockZ()) && !this.contains(b.getBlockX(), b.getBlockY(), b.getBlockZ())){
  344.          return true;
  345.       }else{
  346.          return false;
  347.       }
  348.    }
  349.    
  350.    /**
  351.    * Benutze das im PlayerMoveEvent, um zu gucken ob der Spieler die Region verlässt
  352.    * @param a e.getTo();
  353.    * @param b e.getFrom();
  354.    * @return
  355.    */
  356.    public boolean leave(Location a, Location b){
  357.       if(!this.contains(a.getBlockX(), a.getBlockY(), a.getBlockZ()) && this.contains(b.getBlockX(), b.getBlockY(), b.getBlockZ())){
  358.          return true;
  359.       }else{
  360.          return false;
  361.       }
  362.    }
  363.    
  364. }


Hier noch eine kleine Java Docs:

Code: Alles auswählen
  1. Evas evas;
  2. //Erstelle ein neues Evas mit dem Namen Spawn
  3. evas = new Evas(Bukkit.getWorld("world"), 0, 0, 0, 10, 10, 10, EvasType.Square, "Spawn", "plugins/YourName/Evas");
  4. evas.save();
  5. //Lade ein Evas mit dem Namen Spawn
  6. evas = new Evas("Spawn", "plugins/YourName/Evas");
  7. //Setze die Evas Spawn zum letzten gespeicherten Stand
  8. evas.reset();
Oh, schön, dass du die Signatur liest!
Benutzeravatar
Yekllurt
 
Beiträge: 23
Registriert: Sa 7. Feb 2015, 17:31

Zurück zu Anleitungen

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 7 Gäste

cron