public static CubeCoordinates GetTargetedNewCube(this CubeWorld cubeWorld, Camera camera, int maxLayingDistance) // is not 100% trustworthy, and is not powerful, be careful
{
Vector3 checkPosition = camera.ScreenPosition * cubeWorld.GetGraphicsCubeRatio();
CubeCoordinates oldPosition = null;
CubeCoordinates actualPosition = null;
CubeCoordinates convertedCheckPosition;
const int checkIntensity = 100;
float checkIncrement = (float)maxLayingDistance / checkIntensity;
for (int i = 0; i < checkIntensity; i++)
{ // in World, is free space
checkPosition += camera.Front * checkIncrement; // increment check zone
convertedCheckPosition = CubeCoordinates.FromVector3(checkPosition);
if (convertedCheckPosition == actualPosition) // perf maintainer
{
if (!(oldPosition is null) && !cubeWorld.IsFreeSpace(convertedCheckPosition)) // check if it's a free space
{
return(oldPosition);
}
else if (!(actualPosition is null)) // or accept the new checkable position (or exit if actualPosition wasn't initialized)
{
oldPosition = actualPosition;
}
}
actualPosition = convertedCheckPosition;
}
public override void Update(GameTime gameTime)
{
fpsCounter.Update(gameTime);
state = GetLitteralState();
PlayerCoordinates = Nocubeless.CubeWorld.GetCoordinatesFromGraphics(Nocubeless.Camera.ScreenPosition);
ChunkCoordinates = CubeChunkHelper.FindBaseCoordinates(PlayerCoordinates);
int margin = 2;
coordinatesDrawPosition = new Vector2(margin, margin);
fpsDrawPosition = new Vector2(GraphicsDevice.Viewport.Width / 2, margin);
base.Update(gameTime);
string GetLitteralState()
{
switch (Nocubeless.CurrentState)
{
case NocubelessState.Playing:
return("Playing");
case NocubelessState.Editing:
return("Editing world");
case NocubelessState.ColorPicking:
return("Picking a color...");
default:
return("Unknown");
}
}
}
public static CubeCoordinates GetTargetedCube(this CubeWorld cubeWorld, Camera camera, int maxLayingDistance) // is not 100% trustworthy, and is not powerful, be careful
{
Vector3 checkPosition = camera.ScreenPosition * cubeWorld.GetGraphicsCubeRatio(); // Not a beautiful way!
CubeCoordinates actualPosition = null;
CubeCoordinates convertedCheckPosition;
const int checkIntensity = 100;
float checkIncrement = (float)maxLayingDistance / checkIntensity;
for (int i = 0; i < checkIntensity; i++)
{ // in World, is free space
checkPosition += camera.Front * checkIncrement; // increment check zone
convertedCheckPosition = CubeCoordinates.FromVector3(checkPosition);
if (convertedCheckPosition == actualPosition)
{
if (!cubeWorld.IsFreeSpace(convertedCheckPosition)) // check if it's a free space
{
return(convertedCheckPosition);
}
}
actualPosition = convertedCheckPosition;
}
return(actualPosition);
}
public static int GetIndexFromCoordinates(CubeCoordinates cubeCoordinates) // get position of the cube in the chunk from lamba cube coordinates
{
if (cubeCoordinates == null)
{
throw new NullReferenceException();
}
int x = GetRemainder(cubeCoordinates.X),
y = GetRemainder(cubeCoordinates.Y),
z = GetRemainder(cubeCoordinates.Z);
return(x + (y * CubeChunk.Size) + (z * CubeChunk.Size * CubeChunk.Size));
int GetRemainder(int value) // x < 0 please
{
int remainder = value % CubeChunk.Size;
if (value >= 0)
{
return(remainder);
}
else
{
if (remainder == 0) // when (-)x%size == 0
{
return(0);
}
else
{
return(CubeChunk.Size + remainder);
}
}
}
}
public override void Process()
{
var direction = new CubeCoordinates(0, 0, 0);
if (Input.WasJustPressed(Nocubeless.Settings.Keys.MoveRight))
{
direction = new CubeCoordinates(Nocubeless.Camera.Right);
}
else if (Input.WasJustPressed(Nocubeless.Settings.Keys.MoveLeft))
{
direction = new CubeCoordinates(-Nocubeless.Camera.Right);
}
else if (Input.WasJustPressed(Nocubeless.Settings.Keys.MoveForward))
{
direction = new CubeCoordinates(Nocubeless.Camera.Front);
}
else if (Input.WasJustPressed(Nocubeless.Settings.Keys.MoveBackward))
{
direction = new CubeCoordinates(-Nocubeless.Camera.Front);
}
else if (Input.WasJustPressed(Nocubeless.Settings.Keys.MoveUpward))
{
direction = new CubeCoordinates(Nocubeless.Camera.Up);
}
else if (Input.WasJustPressed(Nocubeless.Settings.Keys.MoveDown))
{
direction = new CubeCoordinates(-Nocubeless.Camera.Up);
}
Nocubeless.CubeWorld.PreviewableCube.Coordinates += direction;
if (Input.WasJustPressed(Nocubeless.Settings.Keys.ToggleLayBreak))
{
shouldBreakCube = !shouldBreakCube;
}
var cubeToLay = new Cube(Nocubeless.Player.NextColorToLay /*TODO: Change with a kind of Editing/NextColorToLay*/, Nocubeless.CubeWorld.PreviewableCube.Coordinates); // Make the Editor Cube class
Nocubeless.CubeWorld.PreviewCube(cubeToLay);
if (Input.WasRightMouseButtonJustPressed() && !shouldBreakCube)
{
Nocubeless.CubeWorld.LayCube(cubeToLay);
}
if (Input.WasLeftMouseButtonJustPressed() && shouldBreakCube)
{
Nocubeless.CubeWorld.BreakCube(Nocubeless.CubeWorld.PreviewableCube.Coordinates);
}
if (Input.WasMiddleMouseButtonJustPressed() && shouldBreakCube)
{
Pick();
}
if (Input.WasJustPressed(Nocubeless.Settings.Keys.SetPreviewableCubeAtTheFront))
{
Nocubeless.CubeWorld.PreviewableCube.Coordinates = Nocubeless.CubeWorld.GetCoordinatesFromGraphics(Nocubeless.Camera.Target);
}
}
public static CubeCoordinates FindBaseCoordinates(CubeCoordinates cubeCoordinates) // find real chunk coordinates from lamba cube coordinates
{
if (cubeCoordinates == null)
{
throw new NullReferenceException();
}
int x = FindCloserLeftMultiple(cubeCoordinates.X),
y = FindCloserLeftMultiple(cubeCoordinates.Y),
z = FindCloserLeftMultiple(cubeCoordinates.Z);
return(new CubeCoordinates(x, y, z));
/// <summary>
/// This method find the first value that is a multiple of a CubeChunk Size by crossing from the left.
/// </summary>
int FindCloserLeftMultiple(int value)
{
while (value % CubeChunk.Size != 0)
{
value--;
}
return(value);
}
}
public void BreakCube(CubeCoordinates coordinates)
{
var chunkCoordinates = CubeChunkHelper.FindBaseCoordinates(coordinates);
var tookChunk = TakeChunkAt(chunkCoordinates);
int cubePositionInChunk = CubeChunkHelper.GetIndexFromCoordinates(coordinates);
tookChunk[cubePositionInChunk] = null;
}
public CubeColor GetCubeColorAt(CubeCoordinates coordinates) // TODO: Redundance fix
{
var chunkCoordinates = CubeChunkHelper.FindBaseCoordinates(coordinates);
var tookChunk = TakeChunkAt(chunkCoordinates);
int cubePositionInChunk = CubeChunkHelper.GetIndexFromCoordinates(coordinates);
return(tookChunk[cubePositionInChunk]);
}
public bool ChunkExistsAt(CubeCoordinates coordinates)
{
var dataOffset = GetChunkDataOffset(coordinates);
if (dataOffset == -1)
{
return(false);
}
else
{
return(true);
}
}
public void LoadChunk(CubeCoordinates chunkCoordinates)
{
var gotChunk = GetChunkAt(chunkCoordinates);
if (gotChunk != null)
{
LoadedChunks.Add(gotChunk);
}
else
{
LoadedChunks.Add(new CubeChunk(chunkCoordinates)); // TODO: ForceGetChunkAt
}
}
public CubeChunk GetChunkAt(CubeCoordinates coordinates)
{
var dataOffset = GetChunkDataOffset(coordinates);
if (dataOffset == -1)
{
return(null);
}
else
{
var readChunk = new CubeChunk(coordinates);
ReadChunkData(ref readChunk, (int)dataOffset);
return(readChunk);
}
}
public bool ChunkExistsAt(CubeCoordinates coordinates)
{
var gotChunk = (from chunk in chunks
where chunk.Coordinates.Equals(coordinates)
select chunk).FirstOrDefault();
if (gotChunk == null)
{
return(false);
}
else
{
return(true);
}
}
void UnloadFarChunks(CubeCoordinates playerCoordinates) // TODO: no need this argument now
{
int viewingCubes = CubeChunk.Size * Nocubeless.Settings.Graphics.ChunkViewDistance;
int min = -(viewingCubes / 2);
int max = viewingCubes / 2;
for (int i = 0; i < Nocubeless.CubeWorld.LoadedChunks.Count; i++)
{
var playerMinCoordinates = CubeChunkHelper.FindBaseCoordinates(new CubeCoordinates(playerCoordinates.X + min, playerCoordinates.Y + min, playerCoordinates.Z + min));
var playerMaxCoordinates = CubeChunkHelper.FindBaseCoordinates(new CubeCoordinates(playerCoordinates.X + max, playerCoordinates.Y + max, playerCoordinates.Z + max));
if (Nocubeless.CubeWorld.LoadedChunks[i].Coordinates <playerMinCoordinates ||
Nocubeless.CubeWorld.LoadedChunks[i].Coordinates> playerMaxCoordinates)
{
var gotChunk = Nocubeless.CubeWorld.TakeChunkAt(Nocubeless.CubeWorld.LoadedChunks[i].Coordinates);
Nocubeless.CubeWorld.UnloadChunk(gotChunk);
}
}
}
public override void Process()
{
if (Input.WasJustPressed(Nocubeless.Settings.Keys.ToggleLayBreak))
{
shouldLayCube = !shouldLayCube;
}
if (Input.WasMiddleMouseButtonJustPressed())
{
Pick();
}
if (shouldLayCube)
{
CubeCoordinates cubeToPreviewPosition = Nocubeless.CubeWorld.GetTargetedNewCube((PlayingCamera)Nocubeless.Camera, Nocubeless.Settings.CubeHandler.MaxLayingDistance);
Cube cubeToLay = new Cube(Nocubeless.Player.NextColorToLay, cubeToPreviewPosition);
if (!AreColliding(Nocubeless.Player, cubeToLay))
{
Nocubeless.CubeWorld.PreviewCube(cubeToLay);
if (Input.WasRightMouseButtonJustPressed())
{
Nocubeless.CubeWorld.LayCube(cubeToLay);
}
}
else
{
Nocubeless.CubeWorld.PreviewCube(null);
}
}
else
{ // break
Nocubeless.CubeWorld.PreviewCube(null);
if (Input.WasLeftMouseButtonJustPressed())
{
CubeCoordinates cubeToBreakPosition = Nocubeless.CubeWorld.GetTargetedCube((PlayingCamera)Nocubeless.Camera, Nocubeless.Settings.CubeHandler.MaxLayingDistance);
Nocubeless.CubeWorld.BreakCube(cubeToBreakPosition);
}
}
}
public CubeChunk GetChunkAt(CubeCoordinates coordinates)
{
var gotChunk = (from chunk in chunks
where chunk.Coordinates.Equals(coordinates)
select chunk).FirstOrDefault();
if (gotChunk != null) // shallow copy
{
var newChunk = new CubeChunk(gotChunk.Coordinates);
for (int i = 0; i < CubeChunk.TotalSize; i++)
{
newChunk[i] = gotChunk[i];
}
return(newChunk);
}
else
{
return(null);
}
}
public bool IsFreeSpace(CubeCoordinates coordinates) // TO-OPTIMIZE
{
var chunkCoordinates = CubeChunkHelper.FindBaseCoordinates(coordinates);
var gotChunk = (from chunk in LoadedChunks
where chunk.Coordinates == chunkCoordinates
select chunk).FirstOrDefault();
if (gotChunk == null) // don't try to check in a not loaded chunk, or it will crash
{
return(false);
}
int cubePositionInChunk = CubeChunkHelper.GetIndexFromCoordinates(coordinates);
if (!(gotChunk[cubePositionInChunk] == null))
{
return(false);
}
return(true);
}
private int GetChunkDataOffset(CubeCoordinates chunkCoordinates)
{
int dataSize = CubeChunk.TotalSize * 3;
var stream = File.OpenRead(FilePath);
using (var reader = new BinaryReader(stream))
{
while (stream.Position < stream.Length)
{
var foundCoordinates = new CubeCoordinates(reader.ReadInt32(),
reader.ReadInt32(),
reader.ReadInt32());
if (foundCoordinates == chunkCoordinates)
{
return((int)stream.Position);
}
stream.Seek(dataSize, SeekOrigin.Current); // jump to the next coordinates
}
}
return(-1); // no offset found
}
private void LoadChunks(CubeCoordinates playerCoordinates) // it's the big cube algorithm
{
int viewingCubes = CubeChunk.Size * Nocubeless.Settings.Graphics.ChunkViewDistance;
int min = -(viewingCubes / 2);
int max = viewingCubes / 2;
for (int x = min; x < max; x += CubeChunk.Size)
{
for (int y = min; y < max; y += CubeChunk.Size)
{
for (int z = min; z < max; z += CubeChunk.Size)
{ // explore chunks to load
var chunkCoordinates = CubeChunkHelper.FindBaseCoordinates(new CubeCoordinates(playerCoordinates.X + x, playerCoordinates.Y + y, playerCoordinates.Z + z));
var tookChunk = Nocubeless.CubeWorld.TakeChunkAt(chunkCoordinates);
if (tookChunk == null)
{
Nocubeless.CubeWorld.LoadChunk(chunkCoordinates);
}
}
}
}
}
private static void WriteChunkCoordinates(CubeCoordinates chunkCoordinates, BinaryWriter writer)
{
writer.Write(chunkCoordinates.X);
writer.Write(chunkCoordinates.Y);
writer.Write(chunkCoordinates.Z);
}
public Cube(CubeColor color, CubeCoordinates position)
{
Coordinates = position;
Color = color;
}
public WorldCoordinates(CubeCoordinates coordinates, Vector3 positionOnCube)
: base(coordinates.X, coordinates.Y, coordinates.Z)
{
PositionOnCurrentCube = positionOnCube;
}
private CubeChunk GetChunkAt(CubeCoordinates coordinates)
{
return(Handler.GetChunkAt(coordinates));
}
public CubeChunk TakeChunkAt(CubeCoordinates chunkCoordinates)
{
return((from chunk in LoadedChunks
where chunk.Coordinates == chunkCoordinates
select chunk).FirstOrDefault());
}
public CubeChunk(CubeCoordinates coordinates)
{
Coordinates = coordinates;
cubeColors = new CubeColor[Size * Size * Size];
}
