James Seibel
777 lines
18 KiB
Java
777 lines
18 KiB
Java
package com.backsun.lod.objects;
|
|
|
|
import java.awt.Color;
|
|
|
|
import com.backsun.lod.util.enums.ColorDirection;
|
|
import com.backsun.lod.util.enums.LodCorner;
|
|
import com.backsun.lod.util.enums.LodLocation;
|
|
|
|
import net.minecraft.block.Blocks;
|
|
import net.minecraft.client.Minecraft;
|
|
import net.minecraft.client.renderer.color.BlockColors;
|
|
import net.minecraft.world.World;
|
|
import net.minecraft.world.chunk.Chunk;
|
|
import net.minecraft.world.chunk.ChunkSection;
|
|
|
|
/**
|
|
* This object contains position
|
|
* and color data for an LOD object.
|
|
*
|
|
* @author James Seibel
|
|
* @version 02-13-2021
|
|
*/
|
|
public class LodChunk
|
|
{
|
|
/** how many different pieces of data are in one line */
|
|
private static final int DATA_DELIMITER_COUNT = 28;
|
|
|
|
/** This is what separates each piece of data in the toData method */
|
|
public static final char DATA_DELIMITER = ',';
|
|
|
|
public static final int WIDTH = 16;
|
|
|
|
private static final int CHUNK_DATA_WIDTH = WIDTH;
|
|
private static final int CHUNK_DATA_HEIGHT = WIDTH;
|
|
|
|
/**
|
|
* This is how many blocks are
|
|
* required at a specific y-value
|
|
* to constitute a LOD point
|
|
*/
|
|
private final int LOD_BLOCK_REQ = 16;
|
|
// the max number of blocks per layer = 64 (8*8)
|
|
// since each layer is 1/4 the chunk
|
|
|
|
|
|
/** The x coordinate of the chunk. */
|
|
public int x;
|
|
/** The z coordinate of the chunk. */
|
|
public int z;
|
|
|
|
// each short is the height of
|
|
// that 8th of the chunk.
|
|
public short top[];
|
|
public short bottom[];
|
|
|
|
/** The average color of each 6 cardinal directions */
|
|
public Color colors[];
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//==============//
|
|
// constructors //
|
|
//==============//
|
|
|
|
/**
|
|
* Create an empty invisible LodChunk at (0,0)
|
|
*/
|
|
public LodChunk()
|
|
{
|
|
x = 0;
|
|
z = 0;
|
|
|
|
top = new short[4];
|
|
bottom = new short[4];
|
|
colors = new Color[6];
|
|
|
|
// by default have the colors invisible
|
|
for(ColorDirection dir : ColorDirection.values())
|
|
{
|
|
colors[dir.value] = new Color(0, 0, 0, 0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates an LodChunk from the string
|
|
* generated by the toData method.
|
|
*
|
|
* @throws IllegalArgumentException if the data isn't valid to create a LodChunk
|
|
* @throws NumberFormatException if the data can't be converted into an int at any point
|
|
*/
|
|
public LodChunk(String data) throws IllegalArgumentException, NumberFormatException
|
|
{
|
|
/*
|
|
* data format:
|
|
* x, z, top data, bottom data, rgb color data
|
|
*
|
|
* example:
|
|
* 5,8, 4,4,4,4, 0,0,0,0, 255,255,255, 255,255,255, 255,255,255, 255,255,255, 255,255,255, 255,255,255,
|
|
*/
|
|
|
|
// make sure there are the correct number of entries
|
|
// in the data string (28)
|
|
int count = 0;
|
|
|
|
for(int i = 0; i < data.length(); i++)
|
|
{
|
|
if(data.charAt(i) == DATA_DELIMITER)
|
|
{
|
|
count++;
|
|
}
|
|
}
|
|
|
|
if(count != DATA_DELIMITER_COUNT)
|
|
{
|
|
throw new IllegalArgumentException("LodChunk constructor givin an invalid string. The data given had " + count + " delimiters when it should have had " + DATA_DELIMITER_COUNT + ".");
|
|
}
|
|
|
|
|
|
|
|
// index we will use when going through the String
|
|
int index = 0;
|
|
int lastIndex = 0;
|
|
|
|
|
|
|
|
// x and z position
|
|
index = data.indexOf(DATA_DELIMITER, 0);
|
|
x = Integer.parseInt(data.substring(0,index));
|
|
|
|
lastIndex = index;
|
|
index = data.indexOf(DATA_DELIMITER, lastIndex + 1);
|
|
z = Integer.parseInt(data.substring(lastIndex+1,index));
|
|
|
|
|
|
|
|
// top
|
|
top = new short[4];
|
|
for(LodLocation loc : LodLocation.values())
|
|
{
|
|
lastIndex = index;
|
|
index = data.indexOf(DATA_DELIMITER, lastIndex + 1);
|
|
|
|
top[loc.value] = Short.parseShort(data.substring(lastIndex+1,index));
|
|
}
|
|
|
|
|
|
// bottom
|
|
bottom = new short[4];
|
|
for(LodLocation loc : LodLocation.values())
|
|
{
|
|
lastIndex = index;
|
|
index = data.indexOf(DATA_DELIMITER, lastIndex + 1);
|
|
|
|
bottom[loc.value] = Short.parseShort(data.substring(lastIndex+1,index));
|
|
}
|
|
|
|
|
|
// color
|
|
colors = new Color[6];
|
|
for(ColorDirection dir : ColorDirection.values())
|
|
{
|
|
int red = 0;
|
|
int green = 0;
|
|
int blue = 0;
|
|
|
|
// get r,g,b
|
|
for(int i = 0; i < 3; i++)
|
|
{
|
|
lastIndex = index;
|
|
index = data.indexOf(DATA_DELIMITER, lastIndex + 1);
|
|
|
|
String raw = "";
|
|
switch(i)
|
|
{
|
|
case 0:
|
|
raw = data.substring(lastIndex+1,index);
|
|
red = Short.parseShort(raw);
|
|
break;
|
|
case 1:
|
|
raw = data.substring(lastIndex+1,index);
|
|
green = Short.parseShort(raw);
|
|
break;
|
|
case 2:
|
|
raw = data.substring(lastIndex+1,index);
|
|
blue = Short.parseShort(raw);
|
|
break;
|
|
}
|
|
}
|
|
|
|
colors[dir.value] = new Color(red, green, blue);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a LodChunk for a chunk in the given world. <br>
|
|
* Note: The world is required to determine each block's color
|
|
*
|
|
* @throws IllegalArgumentException
|
|
* thrown if either the chunk or world is null.
|
|
*/
|
|
public LodChunk(Chunk chunk, World world) throws IllegalArgumentException
|
|
{
|
|
if(chunk == null)
|
|
{
|
|
throw new IllegalArgumentException("LodChunk constructor given a null chunk");
|
|
}
|
|
if(world == null)
|
|
{
|
|
throw new IllegalArgumentException("LodChunk constructor given a null world");
|
|
}
|
|
|
|
|
|
x = chunk.getPos().x;
|
|
z = chunk.getPos().z;
|
|
|
|
top = new short[4];
|
|
bottom = new short[4];
|
|
colors = new Color[6];
|
|
|
|
// generate the top and bottom points of this LOD
|
|
for(LodLocation loc : LodLocation.values())
|
|
{
|
|
top[loc.value] = generateLodCorner(chunk, SectionGenerationMode.GENERATE_TOP, loc);
|
|
bottom[loc.value] = generateLodCorner(chunk, SectionGenerationMode.GENERATE_BOTTOM, loc);
|
|
}
|
|
|
|
// determine the average color for each direction
|
|
for(ColorDirection dir : ColorDirection.values())
|
|
{
|
|
colors[dir.value] = generateLodColorForDirection(chunk, world, dir);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//=====================//
|
|
// constructor helpers //
|
|
//=====================//
|
|
|
|
|
|
/**
|
|
* Generate the height for the given LodLocation, either the top or bottom.
|
|
* <br><br>
|
|
* If invalid/null/empty chunks are given
|
|
* crashes may occur.
|
|
*/
|
|
public short generateLodCorner(Chunk chunk, SectionGenerationMode generationMode, LodLocation lodLoc)
|
|
{
|
|
// should have a length of 16
|
|
// (each storage is 16x16x16 and the
|
|
// world height is 256)
|
|
ChunkSection[] chunkSections = chunk.getSections();
|
|
|
|
|
|
|
|
int startX = 0;
|
|
int endX = 0;
|
|
|
|
int startZ = 0;
|
|
int endZ = 0;
|
|
|
|
// determine where we should look in this
|
|
// chunk
|
|
switch(lodLoc)
|
|
{
|
|
case NE:
|
|
// -N
|
|
startZ = 0;
|
|
endZ = (CHUNK_DATA_WIDTH / 2) - 1;
|
|
// +E
|
|
startX = CHUNK_DATA_WIDTH / 2;
|
|
endX = CHUNK_DATA_WIDTH - 1;
|
|
break;
|
|
|
|
case SE:
|
|
// +S
|
|
startZ = CHUNK_DATA_WIDTH / 2;
|
|
endZ = CHUNK_DATA_WIDTH;
|
|
// +E
|
|
startX = CHUNK_DATA_WIDTH / 2;
|
|
endX = CHUNK_DATA_WIDTH;
|
|
break;
|
|
|
|
case SW:
|
|
// +S
|
|
startZ = CHUNK_DATA_WIDTH / 2;
|
|
endZ = CHUNK_DATA_WIDTH;
|
|
// -W
|
|
startX = 0;
|
|
endX = (CHUNK_DATA_WIDTH / 2) - 1;
|
|
break;
|
|
|
|
case NW:
|
|
// -N
|
|
startZ = 0;
|
|
endZ = CHUNK_DATA_WIDTH / 2;
|
|
// -W
|
|
startX = 0;
|
|
endX = CHUNK_DATA_WIDTH / 2;
|
|
break;
|
|
}
|
|
|
|
|
|
if(generationMode == SectionGenerationMode.GENERATE_TOP)
|
|
return determineTopPoint(chunkSections, startX, endX, startZ, endZ);
|
|
else
|
|
return determineBottomPoint(chunkSections, startX, endX, startZ, endZ);
|
|
}
|
|
/** GENERATE_TOP, GENERATE_BOTTOM */
|
|
private enum SectionGenerationMode
|
|
{
|
|
GENERATE_TOP,
|
|
GENERATE_BOTTOM;
|
|
}
|
|
|
|
/**
|
|
* Find the lowest valid point from the bottom.
|
|
*/
|
|
private short determineBottomPoint(ChunkSection[] chunkSections, int startX, int endX, int startZ, int endZ)
|
|
{
|
|
// search from the bottom up
|
|
for(int i = 0; i < chunkSections.length; i++)
|
|
{
|
|
for(int y = 0; y < CHUNK_DATA_HEIGHT; y++)
|
|
{
|
|
|
|
if(isLayerValidLodPoint(chunkSections, startX, endX, startZ, endZ, i, y))
|
|
{
|
|
// we found
|
|
// enough blocks in this
|
|
// layer to count as an
|
|
// LOD point
|
|
return (short) (y + (i * CHUNK_DATA_HEIGHT));
|
|
}
|
|
}
|
|
}
|
|
|
|
// we never found a valid LOD point
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Find the highest valid point from the Top
|
|
*/
|
|
private short determineTopPoint(ChunkSection[] chunkSections, int startX, int endX, int startZ, int endZ)
|
|
{
|
|
// search from the top down
|
|
for(int i = chunkSections.length - 1; i >= 0; i--)
|
|
{
|
|
for(int y = CHUNK_DATA_WIDTH - 1; y >= 0; y--)
|
|
{
|
|
if(isLayerValidLodPoint(chunkSections, startX, endX, startZ, endZ, i, y))
|
|
{
|
|
// we found
|
|
// enough blocks in this
|
|
// layer to count as an
|
|
// LOD point
|
|
return (short) (y + (i * CHUNK_DATA_HEIGHT));
|
|
}
|
|
}
|
|
}
|
|
|
|
// we never found a valid LOD point
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Is the layer between the given X, Z, and dataIndex
|
|
* values a valid LOD point?
|
|
*/
|
|
private boolean isLayerValidLodPoint(
|
|
ChunkSection[] chunkSections,
|
|
int startX, int endX,
|
|
int startZ, int endZ,
|
|
int sectionIndex, int y)
|
|
{
|
|
// search through this layer
|
|
int layerBlocks = 0;
|
|
|
|
for(int x = startX; x < endX; x++)
|
|
{
|
|
for(int z = startZ; z < endZ; z++)
|
|
{
|
|
if(chunkSections[sectionIndex] == null)
|
|
{
|
|
// this section doesn't have any blocks,
|
|
// it is not a valid section
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if(chunkSections[sectionIndex].getBlockState(x, y, z) != null && chunkSections[sectionIndex].getBlockState(x, y, z).getBlock() != Blocks.AIR)
|
|
{
|
|
// we found a valid block in
|
|
// in this layer
|
|
layerBlocks++;
|
|
|
|
if(layerBlocks >= LOD_BLOCK_REQ)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
} // z
|
|
} // x
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Generate the color of the given ColorDirection at the given chunk
|
|
* in the given world.
|
|
*/
|
|
private Color generateLodColorForDirection(Chunk chunk, World world, ColorDirection colorDir)
|
|
{
|
|
Minecraft mc = Minecraft.getInstance();
|
|
BlockColors bc = mc.getBlockColors();
|
|
|
|
switch (colorDir)
|
|
{
|
|
case TOP:
|
|
return generateLodColorVertical(chunk, colorDir, world, bc);
|
|
case BOTTOM:
|
|
return generateLodColorVertical(chunk, colorDir, world, bc);
|
|
|
|
case N:
|
|
return generateLodColorHorizontal(chunk, colorDir, world, bc);
|
|
case S:
|
|
return generateLodColorHorizontal(chunk, colorDir, world, bc);
|
|
|
|
case E:
|
|
return generateLodColorHorizontal(chunk, colorDir, world, bc);
|
|
case W:
|
|
return generateLodColorHorizontal(chunk, colorDir, world, bc);
|
|
}
|
|
|
|
return new Color(0, 0, 0, 0);
|
|
}
|
|
|
|
/**
|
|
* Generates the color of the top or bottom of a given chunk in the given world.
|
|
*
|
|
* @throws IllegalArgumentException if given a ColorDirection other than TOP or BOTTOM
|
|
*/
|
|
private Color generateLodColorVertical(Chunk chunk, ColorDirection colorDir, World world, BlockColors bc)
|
|
{
|
|
if(colorDir != ColorDirection.TOP && colorDir != ColorDirection.BOTTOM)
|
|
{
|
|
throw new IllegalArgumentException("generateLodColorVertical only accepts the ColorDirection TOP or BOTTOM");
|
|
}
|
|
|
|
ChunkSection[] chunkSections = chunk.getSections();
|
|
|
|
int numbOfBlocks = 0;
|
|
int red = 0;
|
|
int green = 0;
|
|
int blue = 0;
|
|
|
|
boolean goTopDown = (colorDir == ColorDirection.TOP);
|
|
|
|
|
|
// either go top down or bottom up
|
|
int dataStart = goTopDown? chunkSections.length - 1 : 0;
|
|
int dataMax = chunkSections.length;
|
|
int dataMin = 0;
|
|
int dataIncrement = goTopDown? -1 : 1;
|
|
|
|
int topStart = goTopDown? CHUNK_DATA_HEIGHT - 1 : 0;
|
|
int topMax = CHUNK_DATA_HEIGHT;
|
|
int topMin = 0;
|
|
int topIncrement = goTopDown? -1 : 1;
|
|
|
|
for(int x = 0; x < CHUNK_DATA_WIDTH; x++)
|
|
{
|
|
for(int z = 0; z < CHUNK_DATA_WIDTH; z++)
|
|
{
|
|
boolean foundBlock = false;
|
|
|
|
for(int i = dataStart; !foundBlock && i >= dataMin && i < dataMax; i += dataIncrement)
|
|
{
|
|
if(!foundBlock && chunkSections[i] != null)
|
|
{
|
|
for(int y = topStart; !foundBlock && y >= topMin && y < topMax; y += topIncrement)
|
|
{
|
|
int ci;
|
|
ci = chunkSections[i].getBlockState(x, y, z).materialColor.colorValue;
|
|
|
|
if(ci == 0)
|
|
{
|
|
// skip air or invisible blocks
|
|
continue;
|
|
}
|
|
|
|
Color c = intToColor(ci);
|
|
|
|
red += c.getRed();
|
|
green += c.getGreen();
|
|
blue += c.getBlue();
|
|
|
|
numbOfBlocks++;
|
|
|
|
|
|
// we found a valid block, skip to the
|
|
// next x and z
|
|
foundBlock = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if(numbOfBlocks == 0)
|
|
numbOfBlocks = 1;
|
|
|
|
red /= numbOfBlocks;
|
|
green /= numbOfBlocks;
|
|
blue /= numbOfBlocks;
|
|
|
|
return new Color(red, green, blue);
|
|
}
|
|
|
|
/**
|
|
* Generates the color of the side of a given chunk in the given world for the given ColorDirection.
|
|
*
|
|
* @throws IllegalArgumentException if given a ColorDirection other than N, S, W, E (North, South, East, West)
|
|
*/
|
|
private Color generateLodColorHorizontal(Chunk chunk, ColorDirection colorDir, World world, BlockColors bc)
|
|
{
|
|
if(colorDir != ColorDirection.N && colorDir != ColorDirection.S && colorDir != ColorDirection.E && colorDir != ColorDirection.W)
|
|
{
|
|
throw new IllegalArgumentException("generateLodColorHorizontal only accepts the ColorDirection N (North), S (South), E (East), or W (West)");
|
|
}
|
|
|
|
ChunkSection[] chunkSections = chunk.getSections();
|
|
|
|
int numbOfBlocks = 0;
|
|
int red = 0;
|
|
int green = 0;
|
|
int blue = 0;
|
|
|
|
|
|
// these don't change since the over direction doesn't matter
|
|
int overStart = 0;
|
|
int overIncrement = 1;
|
|
|
|
// determine which direction is "in"
|
|
int inStart = 0;
|
|
int inIncrement = 1;
|
|
switch (colorDir)
|
|
{
|
|
case N:
|
|
inStart = 0;
|
|
inIncrement = 1;
|
|
break;
|
|
case S:
|
|
inStart = CHUNK_DATA_WIDTH - 1;
|
|
inIncrement = -1;
|
|
break;
|
|
case E:
|
|
inStart = 0;
|
|
inIncrement = 1;
|
|
break;
|
|
case W:
|
|
inStart = CHUNK_DATA_WIDTH - 1;
|
|
inIncrement = -1;
|
|
break;
|
|
default:
|
|
// we were given an invalid position, return invisible.
|
|
// this shouldn't happen and is mostly here to make the
|
|
// compiler happy
|
|
return new Color(0,0,0,0);
|
|
}
|
|
|
|
|
|
for (int i = 0; i < chunkSections.length; i++)
|
|
{
|
|
if (chunkSections[i] != null)
|
|
{
|
|
for (int y = 0; y < CHUNK_DATA_HEIGHT; y++)
|
|
{
|
|
boolean foundBlock = false;
|
|
|
|
// over moves "over" the side of the chunk
|
|
// in moves "into" the chunk until it finds a block
|
|
|
|
for (int over = overStart; !foundBlock && over >= 0 && over < CHUNK_DATA_WIDTH; over += overIncrement)
|
|
{
|
|
for (int in = inStart; !foundBlock && in >= 0 && in < CHUNK_DATA_WIDTH; in += inIncrement)
|
|
{
|
|
int x = -1;
|
|
int z = -1;
|
|
|
|
// determine which should be X and Z
|
|
switch(colorDir)
|
|
{
|
|
case N:
|
|
x = over;
|
|
z = in;
|
|
break;
|
|
case S:
|
|
x = over;
|
|
z = in;
|
|
break;
|
|
case E:
|
|
x = in;
|
|
z = over;
|
|
break;
|
|
case W:
|
|
x = in;
|
|
z = over;
|
|
break;
|
|
default:
|
|
// this will never happen, it would have
|
|
// been caught by the switch before the loops
|
|
break;
|
|
}
|
|
|
|
int ci;
|
|
ci = chunkSections[i].getBlockState(x, y, z).getMaterial().getColor().colorValue;
|
|
|
|
if (ci == 0) {
|
|
// skip air or invisible blocks
|
|
continue;
|
|
}
|
|
|
|
Color c = intToColor(ci);
|
|
|
|
red += c.getRed();
|
|
green += c.getGreen();
|
|
blue += c.getBlue();
|
|
|
|
numbOfBlocks++;
|
|
|
|
// we found a valid block, skip to the
|
|
// next x and z
|
|
foundBlock = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if(numbOfBlocks == 0)
|
|
numbOfBlocks = 1;
|
|
|
|
red /= numbOfBlocks;
|
|
green /= numbOfBlocks;
|
|
blue /= numbOfBlocks;
|
|
|
|
return new Color(red, green, blue);
|
|
}
|
|
|
|
/**
|
|
* Convert a BlockColors int into a Color object.
|
|
*/
|
|
private Color intToColor(int num)
|
|
{
|
|
int filter = 0b11111111;
|
|
|
|
int red = (num >> 16 ) & filter;
|
|
int green = (num >> 8 ) & filter;
|
|
int blue = num & filter;
|
|
|
|
return new Color(red, green, blue);
|
|
}
|
|
|
|
/**
|
|
* Convert a Color into a BlockColors object.
|
|
*/
|
|
@SuppressWarnings("unused")
|
|
private int colorToInt(Color color)
|
|
{
|
|
return color.getRGB();
|
|
}
|
|
|
|
|
|
|
|
|
|
//================//
|
|
// misc functions //
|
|
//================//
|
|
|
|
/**
|
|
* If this LOD is either invisible from every
|
|
* direction or doesn't have a valid height
|
|
* it is empty.
|
|
*/
|
|
public boolean isLodEmpty()
|
|
{
|
|
for(LodCorner corner : LodCorner.values())
|
|
if(top[corner.value] != -1 || bottom[corner.value] != -1)
|
|
// at least one corner is valid
|
|
return false;
|
|
|
|
Color invisible = new Color(0,0,0,0);
|
|
for(ColorDirection dir : ColorDirection.values())
|
|
if(!colors[dir.value].equals(invisible))
|
|
// at least one direction has a non-invisible color
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//========//
|
|
// output //
|
|
//========//
|
|
|
|
|
|
|
|
/**
|
|
* Outputs all data in csv format
|
|
* with the given delimiter.
|
|
* <br>
|
|
* Exports data in the form:
|
|
* <br>
|
|
* x, z, top data, bottom data, rgb color data
|
|
*
|
|
* <br>
|
|
* example output:
|
|
* <br>
|
|
* 5,8, 4,4,4,4, 0,0,0,0 255,255,255, 255,255,255, 255,255,255, 255,255,255, 255,255,255, 255,255,255,
|
|
*/
|
|
public String toData()
|
|
{
|
|
String s = "";
|
|
|
|
s += Integer.toString(x) + DATA_DELIMITER + Integer.toString(z) + DATA_DELIMITER;
|
|
|
|
for(int i = 0; i < top.length; i++)
|
|
{
|
|
s += Short.toString(top[i]) + DATA_DELIMITER;
|
|
}
|
|
|
|
for(int i = 0; i < bottom.length; i++)
|
|
{
|
|
s += Short.toString(bottom[i]) + DATA_DELIMITER;
|
|
}
|
|
|
|
for(int i = 0; i < colors.length; i++)
|
|
{
|
|
s += Integer.toString(colors[i].getRed()) + DATA_DELIMITER + Integer.toString(colors[i].getGreen()) + DATA_DELIMITER + Integer.toString(colors[i].getBlue()) + DATA_DELIMITER;
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
|
|
@Override
|
|
public String toString()
|
|
{
|
|
String s = "";
|
|
|
|
s += "x: " + x + " z: " + z + "\t";
|
|
|
|
s += "(" + colors[ColorDirection.TOP.value].getRed() + ", " + colors[ColorDirection.TOP.value].getGreen() + ", " + colors[ColorDirection.TOP.value].getBlue() + ")";
|
|
|
|
return s;
|
|
}
|
|
}
|