Plex-FAWE/src/main/java/com/sk89q/worldedit/CuboidClipboard.java

425 lines
12 KiB
Java
Raw Normal View History

2010-10-02 23:11:44 +00:00
// $Id$
/*
* WorldEdit
* Copyright (C) 2010 sk89q <http://www.sk89q.com> and contributors
2010-10-02 23:11:44 +00:00
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package com.sk89q.worldedit;
import com.sk89q.worldedit.blocks.*;
import com.sk89q.worldedit.data.*;
import com.sk89q.worldedit.schematic.SchematicFormat;
2011-12-25 23:36:23 +00:00
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
2010-10-02 23:11:44 +00:00
/**
* The clipboard remembers the state of a cuboid region.
2010-10-02 23:11:44 +00:00
*
* @author sk89q
2010-10-02 23:11:44 +00:00
*/
public class CuboidClipboard {
2010-11-27 06:15:21 +00:00
/**
* Flip direction.
*/
public enum FlipDirection {
NORTH_SOUTH,
WEST_EAST,
UP_DOWN
}
private BaseBlock[][][] data;
private Vector offset;
private Vector origin;
private Vector size;
private List<CopiedEntity> entities = new ArrayList<CopiedEntity>();
2010-10-02 23:11:44 +00:00
/**
* Constructs the clipboard.
*
* @param size
*/
public CuboidClipboard(Vector size) {
this.size = size;
data = new BaseBlock[size.getBlockX()][size.getBlockY()][size.getBlockZ()];
origin = new Vector();
offset = new Vector();
}
/**
* Constructs the clipboard.
*
* @param size
* @param origin
*/
public CuboidClipboard(Vector size, Vector origin) {
this.size = size;
data = new BaseBlock[size.getBlockX()][size.getBlockY()][size.getBlockZ()];
this.origin = origin;
offset = new Vector();
}
/**
* Constructs the clipboard.
*
* @param size
2010-10-02 23:11:44 +00:00
* @param origin
2011-09-24 19:32:03 +00:00
* @param offset
2010-10-02 23:11:44 +00:00
*/
public CuboidClipboard(Vector size, Vector origin, Vector offset) {
this.size = size;
data = new BaseBlock[size.getBlockX()][size.getBlockY()][size.getBlockZ()];
2010-10-02 23:11:44 +00:00
this.origin = origin;
this.offset = offset;
2010-10-02 23:11:44 +00:00
}
/**
* Get the width (X-direction) of the clipboard.
*
2010-10-11 15:56:19 +00:00
* @return width
*/
public int getWidth() {
return size.getBlockX();
}
/**
* Get the length (Z-direction) of the clipboard.
*
2010-10-11 15:56:19 +00:00
* @return length
*/
public int getLength() {
return size.getBlockZ();
}
/**
* Get the height (Y-direction) of the clipboard.
*
2010-10-11 15:56:19 +00:00
* @return height
*/
public int getHeight() {
return size.getBlockY();
}
/**
* Rotate the clipboard in 2D. It can only rotate by angles divisible by 90.
2010-11-27 06:15:21 +00:00
*
* @param angle in degrees
*/
public void rotate2D(int angle) {
angle = angle % 360;
if (angle % 90 != 0) { // Can only rotate 90 degrees at the moment
return;
}
boolean reverse = angle < 0;
2011-11-23 01:29:48 +00:00
int numRotations = Math.abs((int) Math.floor(angle / 90.0));
int width = getWidth();
int length = getLength();
int height = getHeight();
Vector sizeRotated = size.transform2D(angle, 0, 0, 0, 0);
int shiftX = sizeRotated.getX() < 0 ? -sizeRotated.getBlockX() - 1 : 0;
int shiftZ = sizeRotated.getZ() < 0 ? -sizeRotated.getBlockZ() - 1 : 0;
BaseBlock newData[][][] = new BaseBlock
[Math.abs(sizeRotated.getBlockX())]
[Math.abs(sizeRotated.getBlockY())]
[Math.abs(sizeRotated.getBlockZ())];
for (int x = 0; x < width; ++x) {
for (int z = 0; z < length; ++z) {
Vector v = (new Vector(x, 0, z)).transform2D(angle, 0, 0, 0, 0);
int newX = v.getBlockX();
int newZ = v.getBlockZ();
for (int y = 0; y < height; ++y) {
BaseBlock block = data[x][y][z];
newData[shiftX + newX][y][shiftZ + newZ] = block;
2011-09-24 19:32:03 +00:00
if (reverse) {
for (int i = 0; i < numRotations; ++i) {
block.rotate90Reverse();
}
} else {
for (int i = 0; i < numRotations; ++i) {
block.rotate90();
}
}
}
}
}
data = newData;
size = new Vector(Math.abs(sizeRotated.getBlockX()),
Math.abs(sizeRotated.getBlockY()),
Math.abs(sizeRotated.getBlockZ()));
offset = offset.transform2D(angle, 0, 0, 0, 0)
.subtract(shiftX, 0, shiftZ);
}
/**
* Flip the clipboard.
2011-09-24 19:32:03 +00:00
*
* @param dir direction to flip
*/
public void flip(FlipDirection dir) {
flip(dir, false);
}
2010-11-27 06:15:21 +00:00
/**
* Flip the clipboard.
*
* @param dir direction to flip
* @param aroundPlayer flip the offset around the player
2010-11-27 06:15:21 +00:00
*/
public void flip(FlipDirection dir, boolean aroundPlayer) {
final int width = getWidth();
final int length = getLength();
final int height = getHeight();
2010-11-27 06:15:21 +00:00
switch (dir) {
case NORTH_SOUTH:
final int wid = (int) Math.ceil(width / 2.0f);
for (int xs = 0; xs < wid; ++xs) {
for (int z = 0; z < length; ++z) {
for (int y = 0; y < height; ++y) {
BaseBlock old = data[xs][y][z].flip(dir);
if (xs == width - xs - 1) continue;
data[xs][y][z] = data[width - xs - 1][y][z].flip(dir);
data[width - xs - 1][y][z] = old;
2010-11-27 06:15:21 +00:00
}
}
}
if (aroundPlayer) {
offset = offset.setX(1 - offset.getX() - width);
}
break;
case WEST_EAST:
final int len = (int) Math.ceil(length / 2.0f);
for (int zs = 0; zs < len; ++zs) {
for (int x = 0; x < width; ++x) {
for (int y = 0; y < height; ++y) {
BaseBlock old = data[x][y][zs].flip(dir);
if (zs == length - zs - 1) continue;
data[x][y][zs] = data[x][y][length - zs - 1].flip(dir);
data[x][y][length - zs - 1] = old;
2010-11-27 06:15:21 +00:00
}
}
}
if (aroundPlayer) {
offset = offset.setZ(1 - offset.getZ() - length);
}
break;
case UP_DOWN:
final int hei = (int) Math.ceil(height / 2.0f);
for (int ys = 0; ys < hei; ++ys) {
for (int x = 0; x < width; ++x) {
for (int z = 0; z < length; ++z) {
BaseBlock old = data[x][ys][z].flip(dir);
if (ys == height - ys - 1) continue;
data[x][ys][z] = data[x][height - ys - 1][z].flip(dir);
data[x][height - ys - 1][z] = old;
2010-11-27 06:15:21 +00:00
}
}
}
if (aroundPlayer) {
offset = offset.setY(1 - offset.getY() - height);
}
break;
2010-11-27 06:15:21 +00:00
}
}
2010-10-02 23:11:44 +00:00
/**
* Copy to the clipboard.
*
* @param editSession
*/
public void copy(EditSession editSession) {
for (int x = 0; x < size.getBlockX(); ++x) {
for (int y = 0; y < size.getBlockY(); ++y) {
for (int z = 0; z < size.getBlockZ(); ++z) {
data[x][y][z] =
2011-11-23 01:29:48 +00:00
editSession.getBlock(new Vector(x, y, z).add(getOrigin()));
2010-10-02 23:11:44 +00:00
}
}
}
}
public void paste(EditSession editSession, Vector newOrigin, boolean noAir)
throws MaxChangedBlocksException {
paste(editSession, newOrigin, noAir, false);
}
2010-10-02 23:11:44 +00:00
/**
* Paste from the clipboard.
*
* @param editSession
2010-10-11 15:56:19 +00:00
* @param newOrigin Position to paste it from
2010-10-02 23:11:44 +00:00
* @param noAir True to not paste air
* @throws MaxChangedBlocksException
2010-10-02 23:11:44 +00:00
*/
public void paste(EditSession editSession, Vector newOrigin, boolean noAir, boolean entities)
throws MaxChangedBlocksException {
place(editSession, newOrigin.add(offset), noAir);
if (entities) {
pasteEntities(newOrigin.add(offset));
}
}
/**
* Places the blocks in a position from the minimum corner.
2011-09-24 19:32:03 +00:00
*
* @param editSession
* @param pos
* @param noAir
* @throws MaxChangedBlocksException
*/
2011-11-23 01:29:48 +00:00
public void place(EditSession editSession, Vector pos, boolean noAir) throws MaxChangedBlocksException {
for (int x = 0; x < size.getBlockX(); ++x) {
for (int y = 0; y < size.getBlockY(); ++y) {
for (int z = 0; z < size.getBlockZ(); ++z) {
2011-11-23 01:29:48 +00:00
if (noAir && data[x][y][z].isAir()) {
continue;
2011-11-23 01:29:48 +00:00
}
2011-11-23 01:29:48 +00:00
editSession.setBlock(new Vector(x, y, z).add(pos), data[x][y][z]);
2010-10-02 23:11:44 +00:00
}
}
}
}
2011-09-24 19:32:03 +00:00
public LocalEntity[] pasteEntities(Vector pos) {
LocalEntity[] entities = new LocalEntity[this.entities.size()];
for (int i = 0; i < this.entities.size(); ++i) {
CopiedEntity copied = this.entities.get(i);
if (copied.entity.spawn(copied.entity.getPosition().setPosition(copied.relativePosition.add(pos)))) {
entities[i] = copied.entity;
}
}
return entities;
}
public void storeEntity(LocalEntity entity) {
this.entities.add(new CopiedEntity(entity));
}
2011-01-30 09:01:11 +00:00
/**
* Get one point in the copy. The point is relative to the origin
* of the copy (0, 0, 0) and not to the actual copy origin.
2011-09-24 19:32:03 +00:00
*
2011-01-30 09:01:11 +00:00
* @param pos
* @return null
* @throws ArrayIndexOutOfBoundsException
*/
public BaseBlock getPoint(Vector pos) throws ArrayIndexOutOfBoundsException {
return data[pos.getBlockX()][pos.getBlockY()][pos.getBlockZ()];
}
2011-09-24 19:32:03 +00:00
/**
* Get one point in the copy. The point is relative to the origin
* of the copy (0, 0, 0) and not to the actual copy origin.
*
* @param pos
* @return null
* @throws ArrayIndexOutOfBoundsException
*/
public void setBlock(Vector pt, BaseBlock block) {
data[pt.getBlockX()][pt.getBlockY()][pt.getBlockZ()] = block;
}
2011-01-30 08:34:13 +00:00
/**
* Get the size of the copy.
2011-09-24 19:32:03 +00:00
*
2011-01-30 08:34:13 +00:00
* @return
*/
public Vector getSize() {
return size;
}
/**
* Saves the clipboard data to a .schematic-format file.
*
* @param path
* @throws IOException
* @throws DataException
*/
@Deprecated
public void saveSchematic(File path) throws IOException, DataException {
SchematicFormat.MCEDIT.save(this, path);
}
/**
* Load a .schematic file into a clipboard.
2011-09-24 19:32:03 +00:00
*
* @param path
2010-10-11 15:56:19 +00:00
* @return clipboard
* @throws DataException
* @throws IOException
*/
@Deprecated
public static CuboidClipboard loadSchematic(File path)
throws DataException, IOException {
return SchematicFormat.MCEDIT.load(path);
}
/**
* @return the origin
*/
public Vector getOrigin() {
return origin;
}
/**
* @param origin the origin to set
*/
public void setOrigin(Vector origin) {
this.origin = origin;
}
/**
* @return the offset
*/
public Vector getOffset() {
return offset;
}
/**
2011-09-24 19:32:03 +00:00
* @param offset
*/
public void setOffset(Vector offset) {
this.offset = offset;
}
private class CopiedEntity {
private final LocalEntity entity;
private final Vector relativePosition;
public CopiedEntity(LocalEntity entity) {
this.entity = entity;
this.relativePosition = entity.getPosition().getPosition().subtract(getOrigin());
}
}
2010-10-02 23:11:44 +00:00
}