amethyst/NBTExplorer
1
0
Fork 0
forked from mirrors/NBTExplorer
Code Pull requests Activity

Dropping NBToolkit from Repo (it will move to its own)

Browse source
This commit is contained in:
Justin Aquadro 2011-10-08 00:03:54 -04:00
parent e23ab933ef
commit 2ecac106ac
18 changed files with 0 additions and 3478 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

188
NBToolkit/BlockFilter.cs
View file

@ -1,188 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using NDesk.Options;
namespace NBToolkit
{
public interface IBlockFilterable
{
IBlockFilter GetBlockFilter ();
}
public interface IBlockFilter
{
int? XAboveEq { get; }
int? XBelowEq { get; }
int? YAboveEq { get; }
int? YBelowEq { get; }
int? ZAboveEq { get; }
int? ZBelowEq { get; }
bool InvertXYZ { get; }
IEnumerable<int> IncludedBlocks { get; } // MatchAny
IEnumerable<int> ExcludedBlocks { get; } // MatchAny
int IncludedBlockCount { get; }
int ExcludedBlockCount { get; }
double? ProbMatch { get; }
bool IncludedBlocksContains (int id);
bool ExcludedBlocksContains (int id);
}
public class BlockFilter : IOptions, IBlockFilter
{
protected int? _xAboveEq = null;
protected int? _xBelowEq = null;
protected int? _yAboveEq = null;
protected int? _yBelowEq = null;
protected int? _zAboveEq = null;
protected int? _zBelowEq = null;
protected bool _invertXYZ = false;
protected List<int> _includedBlocks = new List<int>();
protected List<int> _excludedBlocks = new List<int>();
protected double? _prob = null;
protected OptionSet _options;
public int? XAboveEq
{
get { return _xAboveEq; }
set { _xAboveEq = value; }
}
public int? XBelowEq
{
get { return _xBelowEq; }
set { _xBelowEq = value; }
}
public int? YAboveEq
{
get { return _yAboveEq; }
}
public int? YBelowEq
{
get { return _yBelowEq; }
}
public int? ZAboveEq
{
get { return _zAboveEq; }
}
public int? ZBelowEq
{
get { return _zBelowEq; }
}
public bool InvertXYZ
{
get { return _invertXYZ; }
}
public IEnumerable<int> IncludedBlocks
{
get { return _includedBlocks; }
}
public IEnumerable<int> ExcludedBlocks
{
get { return _excludedBlocks; }
}
public int IncludedBlockCount
{
get { return _includedBlocks.Count; }
}
public int ExcludedBlockCount
{
get { return _excludedBlocks.Count; }
}
public double? ProbMatch
{
get { return _prob; }
}
public BlockFilter ()
{
_options = new OptionSet() {
{ "bxr|BlockXRange=", "Include blocks with X-coord between {0:V1} and {1:V2}, inclusive. V1 or V2 may be left blank.",
(v1, v2) => {
try { _xAboveEq = Convert.ToInt32(v1); } catch (FormatException) { }
try { _xBelowEq = Convert.ToInt32(v2); } catch (FormatException) { }
} },
{ "byr|BlockYRange=", "Include blocks with Y-coord between {0:V1} and {1:V2}, inclusive. V1 or V2 may be left blank.",
(v1, v2) => {
try { _yAboveEq = Convert.ToInt32(v1); } catch (FormatException) { }
try { _yBelowEq = Convert.ToInt32(v2); } catch (FormatException) { }
} },
{ "bzr|BlockZRange=", "Include blocks with Z-chunk coord between {0:V1} and {1:V2}, inclusive. V1 or V2 may be left blank.",
(v1, v2) => {
try { _zAboveEq = Convert.ToInt32(v1); } catch (FormatException) { }
try { _zBelowEq = Convert.ToInt32(v2); } catch (FormatException) { }
} },
{ "brv|BlockInvertXYZ", "Inverts the block selection created by --cxr, --cyr and --czr when all three options are used.",
v => _invertXYZ = true },
{ "bi|BlockInclude=", "Match blocks of type {ID}. This option is repeatable.",
v => _includedBlocks.Add(Convert.ToInt32(v) % 256) },
{ "bir|BlockIncludeRange=", "Match blocks of type between {0:V1} and {1:V2}, inclusive. This option is repeatable.",
(v1, v2) => {
int i1 = Math.Max(0, Math.Min(255, Convert.ToInt32(v1)));
int i2 = Math.Max(0, Math.Min(255, Convert.ToInt32(v2)));
for (int i = i1; i <= i2; i++) {
_includedBlocks.Add(i);
}
} },
{ "bx|BlockExclude=", "Match all blocks except blocks of type {ID}. This option is repeatable.",
v => _excludedBlocks.Add(Convert.ToInt32(v) % 256) },
{ "ber|BlockExcludeRange=", "Match all blocks except blocks of type between {0:V1} and {1:V2}, inclusive. This option is repeatable.",
(v1, v2) => {
int i1 = Math.Max(0, Math.Min(255, Convert.ToInt32(v1)));
int i2 = Math.Max(0, Math.Min(255, Convert.ToInt32(v2)));
for (int i = i1; i <= i2; i++) {
_excludedBlocks.Add(i);
}
} },
{ "bp|BlockProbability=", "Selects a matching block with probability {VAL} (0.0-1.0)",
v => _prob = Convert.ToDouble(v) },
};
}
public BlockFilter (string[] args)
: this()
{
Parse(args);
}
public void Parse (string[] args)
{
_options.Parse(args);
}
public void PrintUsage ()
{
Console.WriteLine("Block Filtering Options:");
_options.WriteOptionDescriptions(Console.Out);
}
public bool IncludedBlocksContains (int id)
{
return _includedBlocks.Contains(id);
}
public bool ExcludedBlocksContains (int id)
{
return _excludedBlocks.Contains(id);
}
}
}

188
NBToolkit/ChunkFilter.cs
View file

@ -1,188 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using NDesk.Options;
namespace NBToolkit
{
public interface IChunkFilterable
{
IChunkFilter GetChunkFilter ();
}
public interface IChunkFilter
{
int? XAboveEq { get; }
int? XBelowEq { get; }
int? ZAboveEq { get; }
int? ZBelowEq { get; }
bool InvertXZ { get; }
IEnumerable<int> IncludedBlocks { get; }
IEnumerable<int> ExcludedBlocks { get; }
int IncludedBlockCount { get; }
int ExcludedBlockCount { get; }
bool IncludeMatchAny { get; }
bool IncludeMatchAll { get; }
bool ExcludeMatchAny { get; }
bool ExcludeMatchAll { get; }
double? ProbMatch { get; }
bool IncludedBlocksContains (int id);
bool ExcludedBlocksContains (int id);
}
public class ChunkFilter : IOptions, IChunkFilter
{
protected int? _xAboveEq = null;
protected int? _xBelowEq = null;
protected int? _zAboveEq = null;
protected int? _zBelowEq = null;
protected bool _invertXZ = false;
protected List<int> _includedBlocks = new List<int>();
protected List<int> _excludedBlocks = new List<int>();
protected bool _includeAny = true;
protected bool _excludeAny = true;
protected double? _prob = null;
protected OptionSet _options;
public int? XAboveEq
{
get { return _xAboveEq; }
set { _xAboveEq = value; }
}
public int? XBelowEq
{
get { return _xBelowEq; }
set { _xBelowEq = value; }
}
public int? ZAboveEq
{
get { return _zAboveEq; }
set { _zAboveEq = value; }
}
public int? ZBelowEq
{
get { return _zBelowEq; }
set { _zBelowEq = value; }
}
public bool InvertXZ
{
get { return _invertXZ; }
}
public IEnumerable<int> IncludedBlocks
{
get { return _includedBlocks; }
}
public IEnumerable<int> ExcludedBlocks
{
get { return _excludedBlocks; }
}
public int IncludedBlockCount
{
get { return _includedBlocks.Count; }
}
public int ExcludedBlockCount
{
get { return _excludedBlocks.Count; }
}
public bool IncludeMatchAny
{
get { return _includeAny; }
}
public bool IncludeMatchAll
{
get { return !_includeAny; }
}
public bool ExcludeMatchAny
{
get { return _excludeAny; }
}
public bool ExcludeMatchAll
{
get { return !_excludeAny; }
}
public double? ProbMatch
{
get { return _prob; }
}
public ChunkFilter ()
{
_options = new OptionSet () {
{ "cxr|ChunkXRange=", "Include chunks with X-chunk coord between {0:V1} and {1:V2}, inclusive. V1 or V2 may be left blank.",
(v1, v2) => {
try { _xAboveEq = Convert.ToInt32(v1); } catch (FormatException) { }
try { _xBelowEq = Convert.ToInt32(v2); } catch (FormatException) { }
} },
{ "czr|ChunkZRange=", "Include chunks with Z-chunk coord between {0:V1} and {1:V2}, inclusive. V1 or V2 may be left blank.",
(v1, v2) => {
try { _zAboveEq = Convert.ToInt32(v1); } catch (FormatException) { }
try { _zBelowEq = Convert.ToInt32(v2); } catch (FormatException) { }
} },
{ "crv|ChunkInvertXZ", "Inverts the chunk selection created by --cxr and --czr when both options are used.",
v => _invertXZ = true },
{ "ci|ChunkInclude=", "Include chunks that contain blocks of type {ID}. This option is repeatable.",
v => _includedBlocks.Add(Convert.ToInt32(v) % 256) },
{ "cx|ChunkExclude=", "Exclude chunks that contain blocks of type {ID}. This option is repeatable.",
v => _excludedBlocks.Add(Convert.ToInt32(v) % 256) },
{ "cia|ChunkIncludeAll", "If multiple --ci options, chunk must match all of them to be included.",
v => _includeAny = false },
{ "ciy|ChunkIncludeAny", "If multiple --ci options, chunk can match any of them to be included. (default)",
v => _includeAny = true },
{ "cxa|ChunkExcludeAll", "If multiple --cx options, chunk must match all of them to be excluded.",
v => _includeAny = false },
{ "cxy|ChunkExcludeAny", "If multiple --cx options, chunk can match any of them to be excluded. (default)",
v => _includeAny = true },
{ "cp|ChunkProbability=", "Selects a matching chunk with probability {VAL} (0.0-1.0)",
v => _prob = Convert.ToDouble(v) },
};
}
public ChunkFilter (string[] args) : this()
{
Parse(args);
}
public void Parse (string[] args) {
_options.Parse(args);
}
public void PrintUsage () {
Console.WriteLine("Chunk Filtering Options:");
_options.WriteOptionDescriptions(Console.Out);
}
public bool IncludedBlocksContains (int id)
{
return _includedBlocks.Contains(id);
}
public bool ExcludedBlocksContains (int id)
{
return _excludedBlocks.Contains(id);
}
}
}

151
NBToolkit/Dump.cs
View file

@ -1,151 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using NDesk.Options;
using Substrate;
using Substrate.Nbt;
using Substrate.Core;
namespace NBToolkit
{
public class DumpOptions : TKOptions, IChunkFilterable
{
private OptionSet _filterOpt = null;
private ChunkFilter _chunkFilter = null;
public string _outFile = "";
public bool _dumpBlocks = false;
public bool _dumpEntities = false;
public bool _dumpTileEntities = false;
public DumpOptions ()
: base()
{
_filterOpt = new OptionSet()
{
{ "out|OutFile=", "Path of file to write JSON data into",
var => _outFile = var },
{ "b|BlockData", "Dump block data (type, data, light arrays)",
var => _dumpBlocks = true },
{ "e|Entities", "Dump complete entity data",
var => _dumpEntities = true },
{ "t|TileEntities", "Dump complete tile entity data",
var => _dumpTileEntities = true },
};
_chunkFilter = new ChunkFilter();
}
public DumpOptions (string[] args)
: this()
{
Parse(args);
}
public override void Parse (string[] args)
{
base.Parse(args);
_filterOpt.Parse(args);
_chunkFilter.Parse(args);
}
public override void PrintUsage ()
{
Console.WriteLine("Usage: nbtoolkit dump [options]");
Console.WriteLine();
Console.WriteLine("Options for command 'dump':");
_filterOpt.WriteOptionDescriptions(Console.Out);
Console.WriteLine();
_chunkFilter.PrintUsage();
Console.WriteLine();
base.PrintUsage();
}
public override void SetDefaults ()
{
base.SetDefaults();
if (_outFile.Length == 0) {
Console.WriteLine("Error: You must specify an output file");
Console.WriteLine();
this.PrintUsage();
throw new TKOptionException();
}
}
public IChunkFilter GetChunkFilter ()
{
return _chunkFilter;
}
}
class Dump : TKFilter
{
private DumpOptions opt;
public Dump (DumpOptions o)
{
opt = o;
}
public override void Run ()
{
NbtWorld world = GetWorld(opt);
IChunkManager cm = world.GetChunkManager(opt.OPT_DIM);
FilteredChunkManager fcm = new FilteredChunkManager(cm, opt.GetChunkFilter());
StreamWriter fstr;
try {
fstr = new StreamWriter(opt._outFile, false);
}
catch (IOException e) {
Console.WriteLine(e.Message);
return;
}
fstr.WriteLine("[");
bool first = true;
foreach (ChunkRef chunk in fcm) {
if (!first) {
fstr.Write(",");
}
Chunk c = chunk.GetChunkRef();
if (!opt._dumpBlocks) {
c.Tree.Root["Level"].ToTagCompound().Remove("Blocks");
c.Tree.Root["Level"].ToTagCompound().Remove("Data");
c.Tree.Root["Level"].ToTagCompound().Remove("BlockLight");
c.Tree.Root["Level"].ToTagCompound().Remove("SkyLight");
c.Tree.Root["Level"].ToTagCompound().Remove("HeightMap");
}
if (!opt._dumpEntities) {
c.Tree.Root["Level"].ToTagCompound().Remove("Entities");
}
if (!opt._dumpTileEntities) {
c.Tree.Root["Level"].ToTagCompound().Remove("TileEntities");
}
string s = JSONSerializer.Serialize(c.Tree.Root["Level"], 1);
fstr.Write(s);
first = false;
}
fstr.WriteLine();
fstr.WriteLine("]");
fstr.Close();
}
}
}

245
NBToolkit/FilteredChunkManager.cs
View file

@ -1,245 +0,0 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using Substrate;
using Substrate.Core;
namespace NBToolkit
{
class FilteredChunkManager : IChunkManager, IEnumerable<ChunkRef>
{
private IChunkManager _cm;
private IChunkFilter _filter;
public FilteredChunkManager (IChunkManager cm, IChunkFilter filter)
{
_cm = cm;
_filter = filter;
}
#region IEnumerable<ChunkRef> Members
public IEnumerator<ChunkRef> GetEnumerator ()
{
return new ChunkEnumerator(_cm, _filter);
}
#endregion
#region IEnumerable Members
IEnumerator IEnumerable.GetEnumerator ()
{
return new ChunkEnumerator(_cm, _filter);
}
#endregion
public class ChunkEnumerator : IEnumerator<ChunkRef>
{
private IChunkManager _cm;
private IChunkFilter _filter;
private IEnumerator<ChunkRef> _enum;
private static Random _rand = new Random();
public ChunkEnumerator (IChunkManager cm, IChunkFilter filter)
{
_cm = cm;
_filter = filter;
_enum = _cm.GetEnumerator();
}
#region IEnumerator<ChunkRef> Members
public ChunkRef Current
{
get { return _enum.Current; }
}
#endregion
#region IDisposable Members
public void Dispose ()
{
}
#endregion
#region IEnumerator Members
object IEnumerator.Current
{
get { return _enum.Current; }
}
public bool MoveNext ()
{
while (true) {
if (_enum.MoveNext() == false) {
return false;
}
// Filter by coordinates
if (_filter.InvertXZ) {
if (_filter.XAboveEq != null && _filter.XBelowEq != null &&
_filter.ZAboveEq != null && _filter.ZBelowEq != null &&
Current.X >= _filter.XAboveEq && Current.X <= _filter.XBelowEq &&
Current.Z >= _filter.ZAboveEq && Current.Z <= _filter.ZBelowEq) {
continue;
}
}
else {
if (_filter.XAboveEq != null && Current.X < _filter.XAboveEq) {
continue;
}
if (_filter.XBelowEq != null && Current.X > _filter.XBelowEq) {
continue;
}
if (_filter.ZAboveEq != null && Current.Z < _filter.ZAboveEq) {
continue;
}
if (_filter.ZBelowEq != null && Current.Z > _filter.ZBelowEq) {
continue;
}
}
// Filter out chunks that do not contain required blocks (included list)
if (_filter.IncludedBlockCount > 0) {
int matchCount = 0;
foreach (int block in _filter.IncludedBlocks) {
if (Current.Blocks.CountByID(block) > 0) {
matchCount++;
}
}
if (_filter.IncludeMatchAny && matchCount == 0) {
continue;
}
if (_filter.IncludeMatchAll && matchCount != _filter.IncludedBlockCount) {
continue;
}
}
// Filter out chunks that contain forbiddon blocks (excluded list)
if (_filter.ExcludedBlockCount > 0) {
int matchCount = 0;
foreach (int block in _filter.ExcludedBlocks) {
if (Current.Blocks.CountByID(block) > 0) {
matchCount++;
}
}
if (_filter.ExcludeMatchAny && matchCount > 0) {
continue;
}
if (_filter.ExcludeMatchAll && matchCount == _filter.ExcludedBlockCount) {
continue;
}
}
// Filter out randomly matching chunks (according to probability value)
if (_filter.ProbMatch != null) {
double r = _rand.NextDouble();
if (r > _filter.ProbMatch) {
continue;
}
}
return true;
}
}
public void Reset ()
{
_enum.Reset();
}
#endregion
}
#region IChunkContainer Members
public int ChunkGlobalX (int cx)
{
return _cm.ChunkGlobalX(cx);
}
public int ChunkGlobalZ (int cz)
{
return _cm.ChunkGlobalZ(cz);
}
public int ChunkLocalX (int cx)
{
return _cm.ChunkLocalX(cx);
}
public int ChunkLocalZ (int cz)
{
return _cm.ChunkLocalZ(cz);
}
public Chunk GetChunk (int cx, int cz)
{
return _cm.GetChunk(cx, cz);
}
public ChunkRef GetChunkRef (int cx, int cz)
{
return _cm.GetChunkRef(cx, cz);
}
public ChunkRef CreateChunk (int cx, int cz)
{
return _cm.CreateChunk(cx, cz);
}
public bool ChunkExists (int cx, int cz)
{
return _cm.ChunkExists(cx, cz);
}
public bool DeleteChunk (int cx, int cz)
{
return _cm.DeleteChunk(cx, cz);
}
public int Save ()
{
return _cm.Save();
}
public bool SaveChunk (Chunk chunk)
{
return _cm.SaveChunk(chunk);
}
public ChunkRef SetChunk (int cx, int cz, Chunk chunk)
{
return _cm.SetChunk(cx, cz, chunk);
}
#endregion
#region IChunkContainer Members
public bool CanDelegateCoordinates
{
get { return false; }
}
#endregion
}
}

193
NBToolkit/GenOres.cs
View file

@ -1,193 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using Substrate;
using Substrate.Core;
namespace NBToolkit
{
public interface IGenerator
{
bool Generate (IBlockManager blockMan, Random rand, int x, int y, int z);
}
/**
* This class is derived from Mojang sources, the algorithm in particular
* is subject to Mojang copyright and restrictions. Mathfix patch by
* jaquadro.
*/
public class NativeGenOre : IGenerator
{
private int _blockId = 0;
private int _blockData = 0;
private int _size = 0;
private bool _mathFix = false;
public NativeGenOre (int blockId, int size)
{
_blockId = blockId;
_size = size;
}
public NativeGenOre (int blockId, int blockData, int size)
{
_blockId = blockId;
_blockData = blockData;
_size = size;
}
public bool MathFix
{
get
{
return _mathFix;
}
set
{
_mathFix = value;
}
}
public bool Generate (IBlockManager blockMan, Random rand, int x, int y, int z)
{
float rpi = (float)(rand.NextDouble() * Math.PI);
double x1 = x + 8 + MathHelper.Sin(rpi) * _size / 8.0F;
double x2 = x + 8 - MathHelper.Sin(rpi) * _size / 8.0F;
double z1 = z + 8 + MathHelper.Cos(rpi) * _size / 8.0F;
double z2 = z + 8 - MathHelper.Cos(rpi) * _size / 8.0F;
double y1 = y + rand.Next(3) + 2;
double y2 = y + rand.Next(3) + 2;
for (int i = 0; i <= _size; i++) {
double xPos = x1 + (x2 - x1) * i / _size;
double yPos = y1 + (y2 - y1) * i / _size;
double zPos = z1 + (z2 - z1) * i / _size;
double fuzz = rand.NextDouble() * _size / 16.0D;
double fuzzXZ = (MathHelper.Sin((float)(i * Math.PI / _size)) + 1.0F) * fuzz + 1.0D;
double fuzzY = (MathHelper.Sin((float)(i * Math.PI / _size)) + 1.0F) * fuzz + 1.0D;
int xStart, yStart, zStart, xEnd, yEnd, zEnd;
if (_mathFix) {
xStart = (int)Math.Floor(xPos - fuzzXZ / 2.0D);
yStart = (int)Math.Floor(yPos - fuzzY / 2.0D);
zStart = (int)Math.Floor(zPos - fuzzXZ / 2.0D);
xEnd = (int)Math.Floor(xPos + fuzzXZ / 2.0D);
yEnd = (int)Math.Floor(yPos + fuzzY / 2.0D);
zEnd = (int)Math.Floor(zPos + fuzzXZ / 2.0D);
}
else {
xStart = (int)(xPos - fuzzXZ / 2.0D);
yStart = (int)(yPos - fuzzY / 2.0D);
zStart = (int)(zPos - fuzzXZ / 2.0D);
xEnd = (int)(xPos + fuzzXZ / 2.0D);
yEnd = (int)(yPos + fuzzY / 2.0D);
zEnd = (int)(zPos + fuzzXZ / 2.0D);
}
for (int ix = xStart; ix <= xEnd; ix++) {
double xThresh = (ix + 0.5D - xPos) / (fuzzXZ / 2.0D);
if (xThresh * xThresh < 1.0D) {
for (int iy = yStart; iy <= yEnd; iy++) {
double yThresh = (iy + 0.5D - yPos) / (fuzzY / 2.0D);
if (xThresh * xThresh + yThresh * yThresh < 1.0D) {
for (int iz = zStart; iz <= zEnd; iz++) {
double zThresh = (iz + 0.5D - zPos) / (fuzzXZ / 2.0D);
if (xThresh * xThresh + yThresh * yThresh + zThresh * zThresh < 1.0D) {
AlphaBlockRef block = blockMan.GetBlockRef(ix, iy, iz);
if (block.IsValid) {
block.ID = _blockId;
block.Data = _blockData;
}
}
}
}
}
}
}
}
return true;
}
}
/*public class LegacyGenOre {
public bool Generate (BlockManager blockMan, Random rand, int x, int y, int z)
{
double x_scale = 0.25 + (rand.NextDouble() * 0.75);
double y_scale = 0.25 + (rand.NextDouble() * 0.75);
double z_scale = 0.25 + (rand.NextDouble() * 0.75);
if (opt.OPT_VV) {
Console.WriteLine("Selected scale: {0}, {1}, {2}", x_scale, y_scale, z_scale);
}
double x_len = (double)opt.OPT_SIZE / 8.0 * x_scale;
double z_len = (double)opt.OPT_SIZE / 8.0 * z_scale;
double y_len = ((double)opt.OPT_SIZE / 16.0 + 2.0) * y_scale;
if (opt.OPT_VV) {
Console.WriteLine("Selected length: {0}, {1}, {2}", x_len, y_len, z_len);
}
double xpos = x;
double ypos = y;
double zpos = z;
if (opt.OPT_VV) {
Console.WriteLine("Selected initial position: {0}, {1}, {2}", xpos, ypos, zpos);
}
int sample_size = 2 * (int)opt.OPT_SIZE;
double fuzz = 0.25;
double x_step = x_len / sample_size;
double y_step = y_len / sample_size;
double z_step = z_len / sample_size;
for (int i = 0; i < sample_size; i++) {
int tx = (int)Math.Floor(xpos + i * x_step);
int ty = (int)Math.Floor(ypos + i * y_step);
int tz = (int)Math.Floor(zpos + i * z_step);
int txp = (int)Math.Floor(xpos + i * x_step + fuzz);
int typ = (int)Math.Floor(ypos + i * y_step + fuzz);
int tzp = (int)Math.Floor(zpos + i * z_step + fuzz);
if (tx < 0) tx = 0;
if (ty < 0) ty = 0;
if (tz < 0) tz = 0;
if (tx >= 16) tx = 15;
if (ty >= 128) ty = 127;
if (tz >= 16) tz = 15;
if (txp < 0) txp = 0;
if (typ < 0) typ = 0;
if (tzp < 0) tzp = 0;
if (txp >= 16) txp = 15;
if (typ >= 128) typ = 127;
if (tzp >= 16) tzp = 15;
UpdateBlock(world, chunk, tx, ty, tz);
UpdateBlock(world, chunk, txp, ty, tz);
UpdateBlock(world, chunk, tx, typ, tz);
UpdateBlock(world, chunk, tx, ty, tzp);
UpdateBlock(world, chunk, txp, typ, tz);
UpdateBlock(world, chunk, tx, typ, tzp);
UpdateBlock(world, chunk, txp, ty, tzp);
UpdateBlock(world, chunk, txp, typ, tzp);
}
}
}*/
}

19
NBToolkit/License.txt
View file

@ -1,19 +0,0 @@
Copyright (C) 2011 by Justin Aquadro
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

33
NBToolkit/MathHelper.cs
View file

@ -1,33 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
/**
* The following is adapted directly from Mojang sources and is
* subject to Mojang copyright and restrictions.
*/
namespace NBToolkit
{
public class MathHelper
{
private static float[] trigTable = new float[65536];
static MathHelper ()
{
for (int i = 0; i < 65536; i++) {
trigTable[i] = (float)Math.Sin(i * Math.PI * 2.0D / 65536.0D);
}
}
public static float Sin (float angle)
{
return trigTable[((int)(angle * 10430.378F) & 0xFFFF)];
}
public static float Cos (float angle)
{
return trigTable[((int)(angle * 10430.378F + 16384.0F) & 0xFFFF)];
}
}
}

128
NBToolkit/NBToolkit.csproj
View file

@ -1,128 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{68207314-C080-4823-97F1-A6623145AA00}</ProjectGuid>
<OutputType>Exe</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>NBToolkit</RootNamespace>
<AssemblyName>NBToolkit</AssemblyName>
<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<PublishUrl>publish\</PublishUrl>
<Install>true</Install>
<InstallFrom>Disk</InstallFrom>
<UpdateEnabled>false</UpdateEnabled>
<UpdateMode>Foreground</UpdateMode>
<UpdateInterval>7</UpdateInterval>
<UpdateIntervalUnits>Days</UpdateIntervalUnits>
<UpdatePeriodically>false</UpdatePeriodically>
<UpdateRequired>false</UpdateRequired>
<MapFileExtensions>true</MapFileExtensions>
<ApplicationRevision>0</ApplicationRevision>
<ApplicationVersion>1.0.0.%2a</ApplicationVersion>
<IsWebBootstrapper>false</IsWebBootstrapper>
<UseApplicationTrust>false</UseApplicationTrust>
<BootstrapperEnabled>true</BootstrapperEnabled>
<FileUpgradeFlags>
</FileUpgradeFlags>
<OldToolsVersion>3.5</OldToolsVersion>
<UpgradeBackupLocation />
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<DocumentationFile>
</DocumentationFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<DocumentationFile>
</DocumentationFile>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
</ItemGroup>
<ItemGroup>
<Compile Include="BlockFilter.cs" />
<Compile Include="Dump.cs" />
<Compile Include="ChunkFilter.cs" />
<Compile Include="FilteredChunkManager.cs" />
<Compile Include="GenOres.cs" />
<Compile Include="MathHelper.cs" />
<Compile Include="NDesk\Options.cs" />
<Compile Include="Oregen.cs" />
<Compile Include="Purge.cs" />
<Compile Include="Relight.cs" />
<Compile Include="Replace.cs" />
<Compile Include="TKFilter.cs" />
<Compile Include="TKOptions.cs" />
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
</ItemGroup>
<ItemGroup>
<None Include="app.config" />
<None Include="Makefile" />
<Content Include="License.txt" />
<None Include="nbtoolkit" />
</ItemGroup>
<ItemGroup>
<BootstrapperPackage Include="Microsoft.Net.Client.3.5">
<Visible>False</Visible>
<ProductName>.NET Framework Client Profile</ProductName>
<Install>false</Install>
</BootstrapperPackage>
<BootstrapperPackage Include="Microsoft.Net.Framework.2.0">
<Visible>False</Visible>
<ProductName>.NET Framework 2.0 %28x86%29</ProductName>
<Install>false</Install>
</BootstrapperPackage>
<BootstrapperPackage Include="Microsoft.Net.Framework.3.0">
<Visible>False</Visible>
<ProductName>.NET Framework 3.0 %28x86%29</ProductName>
<Install>false</Install>
</BootstrapperPackage>
<BootstrapperPackage Include="Microsoft.Net.Framework.3.5">
<Visible>False</Visible>
<ProductName>.NET Framework 3.5</ProductName>
<Install>false</Install>
</BootstrapperPackage>
<BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
<Visible>False</Visible>
<ProductName>.NET Framework 3.5 SP1</ProductName>
<Install>true</Install>
</BootstrapperPackage>
<BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
<Visible>False</Visible>
<ProductName>Windows Installer 3.1</ProductName>
<Install>true</Install>
</BootstrapperPackage>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Substrate\SubstrateCS\Substrate.csproj">
<Project>{AFE30E14-3F2F-4461-9F7D-147AB4DCA4C3}</Project>
<Name>Substrate</Name>
</ProjectReference>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>

1105
NBToolkit/NDesk/Options.cs
View file

File diff suppressed because it is too large Load diff

299
NBToolkit/Oregen.cs
View file

@ -1,299 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using NDesk.Options;
using Substrate;
using Substrate.Core;
namespace NBToolkit
{
public class OregenOptions : TKOptions, IChunkFilterable
{
private OptionSet _filterOpt = null;
private ChunkFilter _chunkFilter = null;
public int? OPT_ID = null;
public int? OPT_DATA = null;
public int? OPT_ROUNDS = null;
public int? OPT_SIZE = null;
public int? OPT_MIN = null;
public int? OPT_MAX = null;
public bool OPT_OO = false;
public bool OPT_OA = false;
public bool OPT_MATHFIX = true;
public List<int> OPT_OB_INCLUDE = new List<int>();
public List<int> OPT_OB_EXCLUDE = new List<int>();
private class OreType
{
public int id;
public string name;
public int rounds;
public int min;
public int max;
public int size;
};
private OreType[] oreList = new OreType[] {
new OreType() { id = 16, name = "Coal", rounds = 20, min = 0, max = 127, size = 16 },
new OreType() { id = 15, name = "Iron", rounds = 20, min = 0, max = 63, size = 8 },
new OreType() { id = 14, name = "Gold", rounds = 2, min = 0, max = 31, size = 8 },
new OreType() { id = 73, name = "Redstone", rounds = 8, min = 0, max = 15, size = 7 },
new OreType() { id = 56, name = "Diamond", rounds = 1, min = 0, max = 15, size = 7 },
new OreType() { id = 21, name = "Lapis", rounds = 1, min = 0, max = 31, size = 7 },
};
public OregenOptions ()
: base()
{
_filterOpt = new OptionSet()
{
{ "b|Block=", "Generate blocks of type {ID} (0-255)",
v => OPT_ID = Convert.ToByte(v) % 256 },
{ "d|Data=", "Set the block's data value to {VAL} (0-15)",
v => OPT_DATA = Convert.ToInt32(v) % 16 },
{ "r|Rounds=", "Geneate {NUM} deposits per chunk",
v => OPT_ROUNDS = Convert.ToInt32(v) },
{ "min|MinDepth=", "Generates deposits no lower than depth {VAL} (0-127)",
v => OPT_MIN = Convert.ToInt32(v) % 128 },
{ "max|MaxDepth=", "Generates deposits no higher than depth {VAL} (0-127)",
v => OPT_MAX = Convert.ToInt32(v) % 128 },
{ "s|Size=", "Generates deposits containing roughly up to {VAL} blocks",
v => OPT_SIZE = Convert.ToInt32(v) % 128 },
{ "oo|OverrideOres", "Generated deposits can replace other existing ores",
v => OPT_OO = true },
{ "oa|OverrideAll", "Generated deposits can replace any existing block",
v => OPT_OA = true },
{ "oi|OverrideInclude=", "Generated deposits can replace the specified block type {ID} [repeatable]",
v => OPT_OB_INCLUDE.Add(Convert.ToInt32(v) % 256) },
{ "ox|OverrideExclude=", "Generated deposits can never replace the specified block type {ID} [repeatable]",
v => OPT_OB_EXCLUDE.Add(Convert.ToInt32(v) % 256) },
{ "nu|NativeUnpatched", "Use MC native ore generation algorithm without distribution evenness patch",
v => OPT_MATHFIX = false },
};
_chunkFilter = new ChunkFilter();
}
public OregenOptions (string[] args)
: this()
{
Parse(args);
}
public override void Parse (string[] args)
{
base.Parse(args);
_filterOpt.Parse(args);
_chunkFilter.Parse(args);
}
public override void PrintUsage ()
{
Console.WriteLine("Usage: nbtoolkit oregen -b <id> -w <path> [options]");
Console.WriteLine();
Console.WriteLine("Options for command 'oregen':");
_filterOpt.WriteOptionDescriptions(Console.Out);
Console.WriteLine();
_chunkFilter.PrintUsage();
Console.WriteLine();
base.PrintUsage();
}
public override void SetDefaults ()
{
base.SetDefaults();
foreach (OreType ore in oreList) {
if (OPT_ID != ore.id) {
continue;
}
if (OPT_ROUNDS == null) {
OPT_ROUNDS = ore.rounds;
}
if (OPT_MIN == null) {
OPT_MIN = ore.min;
}
if (OPT_MAX == null) {
OPT_MAX = ore.max;
}
if (OPT_SIZE == null) {
OPT_SIZE = ore.size;
}
}
// Check for required parameters
if (OPT_ID == null) {
Console.WriteLine("Error: You must specify a Block ID");
Console.WriteLine();
PrintUsage();
throw new TKOptionException();
}
if (OPT_ROUNDS == null) {
OPT_ROUNDS = 1;
}
if (OPT_MIN == null || OPT_MAX == null || OPT_SIZE == null) {
if (OPT_MIN == null) {
Console.WriteLine("Error: You must specify the minimum depth for non-ore blocks");
}
if (OPT_MAX == null) {
Console.WriteLine("Error: You must specify the maximum depth for non-ore blocks");
}
if (OPT_SIZE == null) {
Console.WriteLine("Error: You must specify the deposit size for non-ore blocks");
}
Console.WriteLine();
PrintUsage();
throw new TKOptionException();
}
}
public IChunkFilter GetChunkFilter ()
{
return _chunkFilter;
}
}
public class Oregen : TKFilter
{
private OregenOptions opt;
private static Random rand = new Random();
public Oregen (OregenOptions o)
{
opt = o;
}
public override void Run ()
{
NbtWorld world = GetWorld(opt);
IChunkManager cm = world.GetChunkManager(opt.OPT_DIM);
FilteredChunkManager fcm = new FilteredChunkManager(cm, opt.GetChunkFilter());
int affectedChunks = 0;
foreach (ChunkRef chunk in fcm) {
if (chunk == null || !chunk.IsTerrainPopulated) {
continue;
}
if (opt.OPT_V) {
Console.WriteLine("Processing Chunk (" + chunk.X + "," + chunk.Z + ")");
}
affectedChunks++;
ApplyChunk(world, chunk);
fcm.Save();
}
Console.WriteLine("Affected Chunks: " + affectedChunks);
}
public void ApplyChunk (NbtWorld world, ChunkRef chunk)
{
if (opt.OPT_V) {
Console.WriteLine("Generating {0} size {1} deposits of {2} between {3} and {4}",
opt.OPT_ROUNDS, opt.OPT_SIZE, opt.OPT_ID, opt.OPT_MIN, opt.OPT_MAX);
}
IGenerator generator;
if (opt.OPT_DATA == null) {
generator = new NativeGenOre((int)opt.OPT_ID, (int)opt.OPT_SIZE);
((NativeGenOre)generator).MathFix = opt.OPT_MATHFIX;
}
else {
generator = new NativeGenOre((int)opt.OPT_ID, (int)opt.OPT_DATA, (int)opt.OPT_SIZE);
((NativeGenOre)generator).MathFix = opt.OPT_MATHFIX;
}
IChunkManager cm = world.GetChunkManager(opt.OPT_DIM);
IBlockManager bm = new GenOreBlockManager(cm, opt);
for (int i = 0; i < opt.OPT_ROUNDS; i++) {
if (opt.OPT_VV) {
Console.WriteLine("Generating round {0}...", i);
}
int x = chunk.X * chunk.Blocks.XDim + rand.Next(chunk.Blocks.XDim);
int y = (int)opt.OPT_MIN + rand.Next((int)opt.OPT_MAX - (int)opt.OPT_MIN);
int z = chunk.Z * chunk.Blocks.ZDim + rand.Next(chunk.Blocks.ZDim);
generator.Generate(bm, rand, x, y, z);
}
}
}
public class GenOreBlockManager : BlockManager
{
public const int BLOCK_STONE = 1;
public const int BLOCK_DIRT = 3;
public const int BLOCK_GRAVEL = 13;
public const int BLOCK_GOLD = 14;
public const int BLOCK_IRON = 15;
public const int BLOCK_COAL = 16;
public const int BLOCK_LAPIS = 21;
public const int BLOCK_DIAMOND = 56;
public const int BLOCK_REDSTONE = 73;
protected OregenOptions opt;
public GenOreBlockManager (IChunkManager bm, OregenOptions o)
: base(bm)
{
opt = o;
}
protected override bool Check (int x, int y, int z)
{
if (!base.Check(x, y, z)) {
return false;
}
int blockID = cache.Blocks.GetID(x & chunkXMask, y & chunkYMask, z & chunkZMask);
if (
((opt.OPT_OA) && (blockID != opt.OPT_ID)) ||
((opt.OPT_OO) && (
blockID == BLOCK_COAL || blockID == BLOCK_IRON ||
blockID == BLOCK_GOLD || blockID == BLOCK_REDSTONE ||
blockID == BLOCK_DIAMOND || blockID == BLOCK_LAPIS ||
blockID == BLOCK_DIRT || blockID == BLOCK_GRAVEL) && (blockID != opt.OPT_ID)) ||
(opt.OPT_OB_INCLUDE.Count > 0) ||
(blockID == BLOCK_STONE)
) {
// If overriding list of ores, check membership
if (opt.OPT_OB_INCLUDE.Count > 0 && !opt.OPT_OB_INCLUDE.Contains(blockID)) {
return false;
}
// Check for any excluded block
if (opt.OPT_OB_EXCLUDE.Contains(blockID)) {
return false;
}
// We're allowed to update the block
return true;
}
return false;
}
}
}

151
NBToolkit/Program.cs
View file

@ -1,151 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using Substrate;
namespace NBToolkit
{
class Program
{
static void Main (string[] args)
{
//Harness harness = new Harness();
if (args.Length < 1) {
args = new string[1] { "" };
}
try {
if (args[0] == "oregen") {
OregenOptions options = new OregenOptions(args);
Oregen filter = new Oregen(options);
options.SetDefaults();
filter.Run();
}
else if (args[0] == "replace") {
ReplaceOptions options = new ReplaceOptions(args);
Replace filter = new Replace(options);
options.SetDefaults();
filter.Run();
}
else if (args[0] == "purge") {
PurgeOptions options = new PurgeOptions(args);
Purge filter = new Purge(options);
options.SetDefaults();
filter.Run();
}
else if (args[0] == "dump") {
DumpOptions options = new DumpOptions(args);
Dump filter = new Dump(options);
options.SetDefaults();
filter.Run();
}
else if (args[0] == "relight") {
RelightOptions options = new RelightOptions(args);
Relight filter = new Relight(options);
options.SetDefaults();
filter.Run();
}
else if (args[0] == "help") {
if (args.Length < 2) {
args = new string[2] { "help", "help" };
}
Console.WriteLine("Command: " + args[1]);
Console.WriteLine();
TKOptions options = null;
if (args[1] == "oregen") {
options = new OregenOptions(args);
WriteBlock("Generates one or more structured deposits of a single block type randomly within each chunk selected for update. The deposits are similar to natural ore deposits that appear in the world. Default values for depth, size, and number of rounds are provided for the true ores (coal, iron, gold, etc,). Other block types can be used as long as these values are specified in the command.");
Console.WriteLine();
options.PrintUsage();
}
else if (args[1] == "replace") {
options = new ReplaceOptions(args);
WriteBlock("Replaces one block type with another. By default all matching blocks in the world will be replaced, but updates can be restricted by the available options. This command can be used to set a new data value on blocks by replacing a block with itself.");
Console.WriteLine();
options.PrintUsage();
}
else if (args[1] == "purge") {
options = new PurgeOptions(args);
WriteBlock("Deletes all chunks matching the chunk filtering options. If no options are specified, all world chunks will be deleted. Region files that have all of their chunks purged will also be deleted from the world directory.");
Console.WriteLine();
options.PrintUsage();
}
else if (args[1] == "dump") {
options = new DumpOptions(args);
WriteBlock("Dumps out chunk data in a readable JSON file. Block data, which are byte arrays, are printed as Bas64-encoded strings.");
Console.WriteLine();
options.PrintUsage();
}
else if (args[1] == "relight") {
options = new RelightOptions(args);
WriteBlock("Recalculates the blocklight and/or skylight values for selected chunks. This completely resets the lighting in a chunk, recalculates it from existing light sources, then stiches the lighting seamlessly back into neighboring chunks.");
Console.WriteLine();
options.PrintUsage();
}
else {
WriteBlock("Prints help and usage information for another command. Available commands are 'oregen', 'replace', 'purge', 'dump', 'relight'.");
Console.WriteLine();
Console.WriteLine("Usage: nbtoolkit help <command>");
}
return;
}
else {
TKOptions options = null;
try {
options = new TKOptions(args);
}
catch (TKOptionException) { }
Console.WriteLine("Usage: nbtoolkit <command> [options]");
Console.WriteLine();
Console.WriteLine("Available commands:");
Console.WriteLine(" help Get help and usage info for another command");
Console.WriteLine(" oregen Generate structured deposits of a single block type");
Console.WriteLine(" replace Replace one block type with another");
Console.WriteLine(" purge Delete chunks");
Console.WriteLine(" dump Dump parsed chunk data to a readable JSON file");
Console.WriteLine(" relight Recalculate lighting on chunks");
Console.WriteLine();
options.PrintUsage();
return;
}
}
catch (TKOptionException) {
return;
}
Console.WriteLine("Done");
}
public static void WriteBlock (string str)
{
string buf = "";
while (str.Length > 78) {
for (int i = 78; i >= 0; i--) {
if (str[i] == ' ') {
if (buf.Length > 0) {
buf += " ";
}
buf += str.Substring(0, i) + "\n";
str = str.Substring(i + 1);
break;
}
}
}
buf += " " + str;
Console.WriteLine(buf);
}
}
}

36
NBToolkit/Properties/AssemblyInfo.cs
View file

@ -1,36 +0,0 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("NBToolkit")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("NBToolkit")]
[assembly: AssemblyCopyright("Copyright © Justin Aquadro 2011")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("7eece4a1-8471-43dc-b3b8-fb6b2dc3773e")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

86
NBToolkit/Purge.cs
View file

@ -1,86 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using NDesk.Options;
using Substrate;
using Substrate.Core;
namespace NBToolkit
{
public class PurgeOptions : TKOptions, IChunkFilterable
{
private OptionSet _filterOpt = null;
private ChunkFilter _chunkFilter = null;
public PurgeOptions ()
: base()
{
_filterOpt = new OptionSet();
_chunkFilter = new ChunkFilter();
}
public PurgeOptions (string[] args)
: this()
{
Parse(args);
}
public override void Parse (string[] args)
{
base.Parse(args);
_filterOpt.Parse(args);
_chunkFilter.Parse(args);
}
public override void PrintUsage ()
{
Console.WriteLine("Usage: nbtoolkit purge [options]");
Console.WriteLine();
Console.WriteLine("Options for command 'purge':");
_filterOpt.WriteOptionDescriptions(Console.Out);
Console.WriteLine();
_chunkFilter.PrintUsage();
Console.WriteLine();
base.PrintUsage();
}
public override void SetDefaults ()
{
base.SetDefaults();
}
public IChunkFilter GetChunkFilter ()
{
return _chunkFilter;
}
}
public class Purge : TKFilter
{
private PurgeOptions opt;
public Purge (PurgeOptions o)
{
opt = o;
}
public override void Run ()
{
NbtWorld world = GetWorld(opt);
IChunkManager cm = world.GetChunkManager(opt.OPT_DIM);
FilteredChunkManager fcm = new FilteredChunkManager(cm, opt.GetChunkFilter());
int affectedChunks = 0;
foreach (ChunkRef chunk in fcm) {
affectedChunks++;
fcm.DeleteChunk(chunk.X, chunk.Z);
}
Console.WriteLine("Purged Chunks: " + affectedChunks);
}
}
}

154
NBToolkit/Relight.cs
View file

@ -1,154 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using NDesk.Options;
using Substrate;
using Substrate.Core;
namespace NBToolkit
{
public class RelightOptions : TKOptions, IChunkFilterable
{
private OptionSet _filterOpt = null;
private ChunkFilter _chunkFilter = null;
public bool BlockLight = false;
public bool SkyLight = false;
public bool HeightMap = false;
public RelightOptions ()
: base()
{
_filterOpt = new OptionSet()
{
{ "b|BlockLight", "Recalculate the block light values (block light sources) of selected chunks",
v => BlockLight = true },
{ "s|SkyLight", "Recalculate the skylight values (natural sunlight) of selected chunks",
v => SkyLight = true },
{ "m|HeightMap", "Recalculate the height map of selected chunks",
v => HeightMap = true },
};
_chunkFilter = new ChunkFilter();
}
public RelightOptions (string[] args)
: this()
{
Parse(args);
}
public override void Parse (string[] args)
{
base.Parse(args);
_filterOpt.Parse(args);
_chunkFilter.Parse(args);
}
public override void PrintUsage ()
{
Console.WriteLine("Usage: nbtoolkit relight [options]");
Console.WriteLine();
Console.WriteLine("Options for command 'relight':");
_filterOpt.WriteOptionDescriptions(Console.Out);
Console.WriteLine();
_chunkFilter.PrintUsage();
Console.WriteLine();
base.PrintUsage();
}
public override void SetDefaults ()
{
base.SetDefaults();
}
public IChunkFilter GetChunkFilter ()
{
return _chunkFilter;
}
}
public class Relight : TKFilter
{
private RelightOptions opt;
public Relight (RelightOptions o)
{
opt = o;
}
public override void Run ()
{
NbtWorld world = GetWorld(opt);
IChunkManager cm = world.GetChunkManager(opt.OPT_DIM);
FilteredChunkManager fcm = new FilteredChunkManager(cm, opt.GetChunkFilter());
if (opt.OPT_V) {
Console.WriteLine("Clearing existing chunk lighting...");
}
int affectedChunks = 0;
foreach (ChunkRef chunk in fcm) {
if (opt.OPT_VV) {
Console.WriteLine("Resetting chunk {0},{1}...", chunk.X, chunk.Z);
}
if (opt.HeightMap) {
chunk.Blocks.RebuildHeightMap();
}
if (opt.BlockLight) {
chunk.Blocks.ResetBlockLight();
}
if (opt.SkyLight) {
chunk.Blocks.ResetSkyLight();
}
fcm.Save();
affectedChunks++;
}
if (opt.OPT_V) {
Console.WriteLine("Rebuilding chunk lighting...");
}
foreach (ChunkRef chunk in fcm) {
if (opt.OPT_VV) {
Console.WriteLine("Lighting chunk {0},{1}...", chunk.X, chunk.Z);
}
if (opt.BlockLight) {
chunk.Blocks.RebuildBlockLight();
}
if (opt.SkyLight) {
chunk.Blocks.RebuildSkyLight();
}
fcm.Save();
}
if (opt.OPT_V) {
Console.WriteLine("Reconciling chunk edges...");
}
foreach (ChunkRef chunk in fcm) {
if (opt.OPT_VV) {
Console.WriteLine("Stitching chunk {0},{1}...", chunk.X, chunk.Z);
}
if (opt.BlockLight) {
chunk.Blocks.StitchBlockLight();
}
if (opt.SkyLight) {
chunk.Blocks.StitchSkyLight();
}
fcm.Save();
}
Console.WriteLine("Relit Chunks: " + affectedChunks);
}
}
}

377
NBToolkit/Replace.cs
View file

@ -1,377 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.Globalization;
using NDesk.Options;
using Substrate;
using Substrate.Core;
namespace NBToolkit
{
public class ReplaceOptions : TKOptions, IChunkFilterable, IBlockFilterable
{
private OptionSet _filterOpt = null;
private ChunkFilter _chunkFilter = null;
private BlockFilter _blockFilter = null;
public int? OPT_BEFORE = null;
public int? OPT_AFTER = null;
public int? OPT_DATA = null;
public double? OPT_PROB = null;
// Block coordinate conditions
public int? BL_X_GE = null;
public int? BL_X_LE = null;
public int? BL_Y_GE = null;
public int? BL_Y_LE = null;
public int? BL_Z_GE = null;
public int? BL_Z_LE = null;
// Neighbor conditions
public int? OPT_NEIGHBOR = null;
public int? OPT_NEIGHBOR_SIDE = null;
public int? OPT_NEIGHBOR_E = null;
public int? OPT_NEIGHBOR_W = null;
public int? OPT_NEIGHBOR_N = null;
public int? OPT_NEIGHBOR_S = null;
public int? OPT_NEIGHBOR_T = null;
public int? OPT_NEIGHBOR_B = null;
public ReplaceOptions ()
: base()
{
_filterOpt = new OptionSet()
{
/*{ "b|before=", "Replace instances of block type {ID} with another block type. This option is repeatable.",
v => _includedBlocks.Add(Convert.ToInt32(v) % 256) },*/
{ "a|after=", "Replace the selected blocks with block type {ID}",
v => OPT_AFTER = Convert.ToInt32(v) % 256 },
{ "d|data=", "Set the new block's data value to {VAL} (0-15)",
v => OPT_DATA = Convert.ToInt32(v) % 16 },
/*{ "p|prob=", "Replace any matching block with probability {VAL} (0.0-1.0)",
v => { OPT_PROB = Convert.ToDouble(v, new CultureInfo("en-US"));
OPT_PROB = Math.Max((double)OPT_PROB, 0.0);
OPT_PROB = Math.Min((double)OPT_PROB, 1.0); } },
{ "bxr|BlockXRange=", "Update blocks with X-coord between {0:V1} and {1:V2}, inclusive. V1 or V2 may be left blank.",
(v1, v2) => {
try { BL_X_GE = Convert.ToInt32(v1); } catch (FormatException) { }
try { BL_X_LE = Convert.ToInt32(v2); } catch (FormatException) { }
} },
{ "byr|BlockYRange=", "Update blocks with Y-coord between {0:V1} and {1:V2}, inclusive. V1 or V2 may be left blank",
(v1, v2) => {
try { BL_Y_GE = Convert.ToInt32(v1); } catch (FormatException) { }
try { BL_Y_LE = Convert.ToInt32(v2); } catch (FormatException) { }
} },
{ "bzr|BlockZRange=", "Update blocks with Z-coord between {0:V1} and {1:V2}, inclusive. V1 or V2 may be left blank",
(v1, v2) => {
try { BL_Z_GE = Convert.ToInt32(v1); } catch (FormatException) { }
try { BL_Z_LE = Convert.ToInt32(v2); } catch (FormatException) { }
} },*/
/*{ "nb=", "Update blocks that have block type {ID} as any neighbor",
v => OPT_NEIGHBOR = Convert.ToInt32(v) % 256 },
{ "nbs=", "Update blocks that have block type {ID} as any x/z neighbor",
v => OPT_NEIGHBOR_SIDE = Convert.ToInt32(v) % 256 },
{ "nbxa=", "Update blocks that have block type {ID} as their south neighbor",
v => OPT_NEIGHBOR_S = Convert.ToInt32(v) % 256 },
{ "nbxb=", "Update blocks that have block type {ID} as their north neighbor",
v => OPT_NEIGHBOR_N = Convert.ToInt32(v) % 256 },
{ "nbya=", "Update blocks that have block type {ID} as their top neighbor",
v => OPT_NEIGHBOR_T = Convert.ToInt32(v) % 256 },
{ "nbyb=", "Update blocks that have block type {ID} as their bottom neighbor",
v => OPT_NEIGHBOR_B = Convert.ToInt32(v) % 256 },
{ "nbza=", "Update blocks that have block type {ID} as their west neighbor",
v => OPT_NEIGHBOR_W = Convert.ToInt32(v) % 256 },
{ "nbzb=", "Update blocks that have block type {ID} as their east neighbor",
v => OPT_NEIGHBOR_E = Convert.ToInt32(v) % 256 },*/
};
_chunkFilter = new ChunkFilter();
_blockFilter = new BlockFilter();
}
public ReplaceOptions (string[] args)
: this()
{
Parse(args);
}
public override void Parse (string[] args)
{
base.Parse(args);
_filterOpt.Parse(args);
_chunkFilter.Parse(args);
_blockFilter.Parse(args);
}
public override void PrintUsage ()
{
Console.WriteLine("Usage: nbtoolkit replace -a <id> [options]");
Console.WriteLine();
Console.WriteLine("Options for command 'replace':");
_filterOpt.WriteOptionDescriptions(Console.Out);
Console.WriteLine();
_chunkFilter.PrintUsage();
Console.WriteLine();
_blockFilter.PrintUsage();
Console.WriteLine();
base.PrintUsage();
}
public override void SetDefaults ()
{
base.SetDefaults();
// Check for required parameters
if (OPT_AFTER == null) {
Console.WriteLine("Error: You must specify a replacement Block ID");
Console.WriteLine();
PrintUsage();
throw new TKOptionException();
}
if (_blockFilter.XAboveEq != null) {
int cx = (int)_blockFilter.XAboveEq >> 5;
_chunkFilter.XAboveEq = Math.Max(_chunkFilter.XAboveEq ?? cx, cx);
}
if (_blockFilter.XBelowEq != null) {
int cx = (int)_blockFilter.XBelowEq >> 5;
_chunkFilter.XBelowEq = Math.Min(_chunkFilter.XBelowEq ?? cx, cx);
}
if (_blockFilter.ZAboveEq != null) {
int cx = (int)_blockFilter.ZAboveEq >> 5;
_chunkFilter.ZAboveEq = Math.Max(_chunkFilter.ZAboveEq ?? cx, cx);
}
if (_blockFilter.ZBelowEq != null) {
int cx = (int)_blockFilter.ZBelowEq >> 5;
_chunkFilter.ZBelowEq = Math.Min(_chunkFilter.ZBelowEq ?? cx, cx);
}
}
public IChunkFilter GetChunkFilter ()
{
return _chunkFilter;
}
public IBlockFilter GetBlockFilter ()
{
return _blockFilter;
}
}
public class Replace : TKFilter
{
private ReplaceOptions opt;
private static Random rand = new Random();
private List<BlockKey>[] _sort = new List<BlockKey>[256];
public Replace (ReplaceOptions o)
{
opt = o;
for (int i = 0; i < 256; i++) {
_sort[i] = new List<BlockKey>();
}
}
public override void Run ()
{
NbtWorld world = GetWorld(opt);
IChunkManager cm = world.GetChunkManager(opt.OPT_DIM);
FilteredChunkManager fcm = new FilteredChunkManager(cm, opt.GetChunkFilter());
int affectedChunks = 0;
foreach (ChunkRef chunk in fcm) {
if (opt.OPT_V) {
Console.WriteLine("Processing chunk {0},{1}...", chunk.X, chunk.Z);
}
ApplyChunk(world, chunk);
affectedChunks += fcm.Save() > 0 ? 1 : 0;
}
Console.WriteLine("Affected Chunks: " + affectedChunks);
}
public void ApplyChunk (NbtWorld world, ChunkRef chunk)
{
IBlockFilter opt_b = opt.GetBlockFilter();
int xBase = chunk.X * chunk.Blocks.XDim;
int zBase = chunk.Z * chunk.Blocks.ZDim;
// Determine X range
int xmin = 0;
int xmax = 15;
if (opt_b.XAboveEq != null) {
xmin = (int)opt_b.XAboveEq - xBase;
}
if (opt_b.XBelowEq != null) {
xmax = (int)opt_b.XBelowEq - xBase;
}
xmin = (xmin < 0) ? 0 : xmin;
xmax = (xmax > 15) ? 15 : xmax;
if (xmin > 15 || xmax < 0 || xmin > xmax) {
return;
}
// Determine Y range
int ymin = 0;
int ymax = 127;
if (opt_b.YAboveEq != null) {
ymin = (int)opt_b.YAboveEq;
}
if (opt_b.YBelowEq != null) {
ymax = (int)opt_b.YBelowEq;
}
if (ymin > ymax) {
return;
}
// Determine X range
int zmin = 0;
int zmax = 15;
if (opt_b.ZAboveEq != null) {
zmin = (int)opt_b.ZAboveEq - zBase;
}
if (opt_b.ZBelowEq != null) {
zmax = (int)opt_b.ZBelowEq - zBase;
}
zmin = (zmin < 0) ? 0 : zmin;
zmax = (zmax > 15) ? 15 : zmax;
if (zmin > 15 || zmax < 0 || zmin > zmax) {
return;
}
int xdim = chunk.Blocks.XDim;
int ydim = chunk.Blocks.YDim;
int zdim = chunk.Blocks.ZDim;
// Bin blocks
for (int y = ymin; y <= ymax; y++) {
for (int x = xmin; x <= xmax; x++) {
for (int z = zmin; z <= zmax; z++) {
int id = chunk.Blocks.GetID(x, y, z);
_sort[id].Add(new BlockKey(x, y, z));
}
}
}
// Process bins
for (int i = 0; i < 256; i++) {
if (_sort[i].Count == 0) {
continue;
}
if (opt_b.IncludedBlockCount > 0 & !opt_b.IncludedBlocksContains(i)) {
continue;
}
if (opt_b.ExcludedBlockCount > 0 & opt_b.ExcludedBlocksContains(i)) {
continue;
}
foreach (BlockKey key in _sort[i]) {
chunk.Blocks.SetID(key.x, key.y, key.z, (int)opt.OPT_AFTER);
if (opt.OPT_VV) {
int gx = chunk.X * xdim + key.x;
int gz = chunk.Z * zdim + key.z;
Console.WriteLine("Replaced block {0} at {1},{2},{3}", i, gx, key.y, gz);
}
if (opt.OPT_DATA != null) {
chunk.Blocks.SetData(key.x, key.y, key.z, (int)opt.OPT_DATA);
}
}
}
// Reset bins
for (int i = 0; i < 256; i++) {
_sort[i].Clear();
}
// Process Chunk
/*for (int y = ymin; y <= ymax; y++) {
for (int x = xmin; x <= xmax; x++) {
for (int z = zmin; z <= zmax; z++) {
// Probability test
if (opt_b.ProbMatch != null) {
double c = rand.NextDouble();
if (c > opt_b.ProbMatch) {
continue;
}
}
int lx = x % xdim;
int ly = y % ydim;
int lz = z % zdim;
// Get the old block
int oldBlock = chunk.Blocks.GetID(lx , ly, lz);
// Skip block if it doesn't match the inclusion list
if (opt_b.IncludedBlockCount > 0) {
bool match = false;
foreach (int ib in opt_b.IncludedBlocks) {
if (oldBlock == ib) {
match = true;
break;
}
}
if (!match) {
continue;
}
}
// Skip block if it does match the exclusion list
if (opt_b.ExcludedBlockCount > 0) {
bool match = false;
foreach (int xb in opt_b.ExcludedBlocks) {
if (oldBlock == xb) {
match = true;
break;
}
}
if (match) {
continue;
}
}
// Replace the block
chunk.Blocks.SetID(lx, ly, lz, (int)opt.OPT_AFTER);
if (opt.OPT_VV) {
int gx = chunk.X * xdim + lx;
int gz = chunk.Z * zdim + lz;
Console.WriteLine("Replaced block at {0},{1},{2}", gx, ly, gz);
}
if (opt.OPT_DATA != null) {
chunk.Blocks.SetData(lx, ly, lz, (int)opt.OPT_DATA);
}
}
}
}*/
}
}
}

33
NBToolkit/TKFilter.cs
View file

@ -1,33 +0,0 @@
using System;
using Substrate;
namespace NBToolkit
{
public abstract class TKFilter
{
//public abstract void ApplyChunk (NBT_Tree root);
public abstract void Run ();
public NbtWorld GetWorld (TKOptions opt)
{
NbtWorld world = null;
try {
if (opt.OPT_ALPHA) {
world = AlphaWorld.Open(opt.OPT_WORLD);
}
else {
world = BetaWorld.Open(opt.OPT_WORLD);
}
}
catch (Exception ex) {
Console.WriteLine("Error: " + ex.Message);
Environment.Exit(1);
}
return world;
}
}
}

89
NBToolkit/TKOptions.cs
View file

@ -1,89 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text;
using NDesk.Options;
using System.IO;
namespace NBToolkit
{
public interface IOptions
{
void Parse (string[] args);
void PrintUsage ();
}
public class TKOptions : IOptions
{
private OptionSet commonOpt = null;
public string OPT_WORLD = "";
public int OPT_DIM = 0;
// Verbosity
public bool OPT_V = false;
public bool OPT_VV = false;
public bool OPT_HELP = false;
public bool OPT_ALPHA = false;
public TKOptions ()
{
commonOpt = new OptionSet()
{
{ "w|world=", "World directory",
v => OPT_WORLD = v },
{ "h|help", "Print this help message",
v => OPT_HELP = true },
{ "alpha", "Specify that the world is stored as individual chunk files",
v => OPT_ALPHA = true },
{ "nether", "Update the Nether instead of the main region",
v => OPT_DIM = -1 },
{ "v", "Verbose output",
v => OPT_V = true },
{ "vv", "Very verbose output",
v => { OPT_V = true; OPT_VV = true; } },
};
}
public TKOptions (string[] args)
: this()
{
Parse(args);
}
public virtual void Parse (string[] args)
{
commonOpt.Parse(args);
}
public virtual void PrintUsage ()
{
Console.WriteLine("Common Options:");
commonOpt.WriteOptionDescriptions(Console.Out);
}
public virtual void SetDefaults ()
{
if (OPT_HELP) {
this.PrintUsage();
throw new TKOptionException();
}
if (OPT_WORLD.Length == 0) {
Console.WriteLine("Error: You must specify a World path");
Console.WriteLine();
this.PrintUsage();
throw new TKOptionException();
}
}
}
public class TKOptionException : Exception
{
public TKOptionException () { }
public TKOptionException (String msg) : base(msg) { }
public TKOptionException (String msg, Exception innerException) : base(msg, innerException) { }
}
}

3
NBToolkit/app.config
View file

@ -1,3 +0,0 @@
<?xml version="1.0"?>
<configuration>
<startup/></configuration>