public override bool OnWorldEditCommand(WorldEdit worldEdit, CmdArgs args)
{
switch (args.PopWord())
{
case "tr":
{
int rad = (int)args.PopInt(32);
SearchRadius = rad;
worldEdit.Good(workspace.ToolName + " search radius " + SearchRadius + " set.");
return(true);
}
case "tce":
{
CheckEnclosure = (bool)args.PopBool(true);
worldEdit.Good(workspace.ToolName + " check enclosure set to " + CheckEnclosure);
return(true);
}
case "tm":
{
Mode = (int)args.PopInt(2);
worldEdit.Good(workspace.ToolName + " mode set to " + Mode + "D");
return(true);
}
}
return(false);
}
public override bool OnWorldEditCommand(WorldEdit worldEdit, CmdArgs args)
{
switch (args[0])
{
case "tremove":
PlaceMode = args.Length > 1 && (args[1] == "1" || args[1] == "on");
worldEdit.Good(workspace.ToolName + " remove mode now " + (PlaceMode ? "on" : "off"));
return(true);
case "tm":
EnumLineStartPoint startpoint = EnumLineStartPoint.LineStrip;
if (args.Length > 1)
{
int index;
int.TryParse(args[1], out index);
if (Enum.IsDefined(typeof(EnumLineStartPoint), index))
{
startpoint = (EnumLineStartPoint)index;
}
}
LineMode = startpoint;
worldEdit.Good(workspace.ToolName + " mode " + startpoint + " set.");
workspace.ResendBlockHighlights(worldEdit);
return(true);
}
return(false);
}
public override bool OnWorldEditCommand(WorldEdit worldEdit, CmdArgs args)
{
switch (args[0])
{
case "tm":
EnumGrowShrinkMode mode = EnumGrowShrinkMode.Any;
if (args.Length > 1)
{
int index;
int.TryParse(args[1], out index);
if (Enum.IsDefined(typeof(EnumGrowShrinkMode), index))
{
mode = (EnumGrowShrinkMode)index;
}
}
GrowShrinkMode = mode;
worldEdit.Good(workspace.ToolName + " mode " + mode + " set.");
return(true);
case "tr":
BrushRadius = 0;
if (args.Length > 1)
{
float size;
float.TryParse(args[1], out size);
BrushRadius = size;
}
worldEdit.Good("Grow/Shrink radius " + BrushRadius + " set");
return(true);
case "tgr":
BrushRadius++;
worldEdit.Good("Grow/Shrink radius " + BrushRadius + " set");
return(true);
case "tsr":
BrushRadius = Math.Max(0, BrushRadius - 1);
worldEdit.Good("Grow/Shrink radius " + BrushRadius + " set");
return(true);
}
return(false);
}
public override bool OnWorldEditCommand(WorldEdit worldEdit, CmdArgs args)
{
string cmd = args.PopWord();
switch (cmd)
{
case "tm":
{
EnumMoveToolMode mode = EnumMoveToolMode.MoveBlocks;
if (args.Length > 0)
{
int index;
int.TryParse(args[0], out index);
if (Enum.IsDefined(typeof(EnumMoveToolMode), index))
{
mode = (EnumMoveToolMode)index;
}
}
MoveRepeatMode = mode;
worldEdit.Good(Lang.Get("Tool mode now set to {0}", mode));
return(true);
}
case "am":
{
Amount = (int)args.PopInt(1);
worldEdit.Good(Lang.Get("Amount set to {0}", Amount));
return(true);
}
case "north":
case "east":
case "west":
case "south":
case "up":
case "down":
{
BlockFacing facing = BlockFacing.FromCode(cmd);
Handle(worldEdit, facing.Normali);
return(true);
}
}
return(false);
}
public override void OnBreak(WorldEdit worldEdit, BlockSelection blockSel, ref EnumHandling handling)
{
handling = EnumHandling.PreventDefault;
startPos = blockSel.Position.Copy();
worldEdit.Good("Line Tool start position set");
//int blockId = blockAccessRev.GetBlockId(blockSel.Position);
//worldEdit.sapi.World.BlockAccessor.SetBlock(oldBlockId, blockSel.Position);
//blockAccessRev.SetHistoryStateBlock(blockSel.Position.X, blockSel.Position.Y, blockSel.Position.Z, oldBlockId, oldBlockId);
//blockAccessRev.Commit();
}
public override bool OnWorldEditCommand(WorldEdit worldEdit, CmdArgs args)
{
switch (args[0])
{
case "tr":
Radius = 0;
if (args.Length > 1)
{
float size;
float.TryParse(args[1], NumberStyles.Any, GlobalConstants.DefaultCultureInfo, out size);
Radius = size;
}
worldEdit.Good("Air Brush Radius " + Radius + " set.");
return(true);
case "tgr":
Radius++;
worldEdit.Good("Air Brush Radius " + Radius + " set");
return(true);
case "tsr":
Radius = Math.Max(0, Radius - 1);
worldEdit.Good("Air Brush Radius " + Radius + " set");
return(true);
case "tq":
Quantity = 0;
if (args.Length > 1)
{
float quant;
float.TryParse(args[1], NumberStyles.Any, GlobalConstants.DefaultCultureInfo, out quant);
Quantity = quant;
}
worldEdit.Good("Quantity " + Quantity + " set.");
return(true);
case "tm":
EnumAirBrushMode mode = EnumAirBrushMode.Add;
if (args.Length > 1)
{
int index;
int.TryParse(args[1], out index);
if (Enum.IsDefined(typeof(EnumAirBrushMode), index))
{
mode = (EnumAirBrushMode)index;
}
}
Mode = mode;
worldEdit.Good(workspace.ToolName + " mode " + mode + " set.");
worldEdit.ResendBlockHighlights();
return(true);
case "ta":
EnumAirBrushApply apply = EnumAirBrushApply.AnyFace;
if (args.Length > 1)
{
int index;
int.TryParse(args[1], out index);
if (Enum.IsDefined(typeof(EnumAirBrushApply), index))
{
apply = (EnumAirBrushApply)index;
}
}
Apply = apply;
worldEdit.Good(workspace.ToolName + " apply " + apply + " set.");
worldEdit.ResendBlockHighlights();
return(true);
}
return(false);
}
public override bool OnWorldEditCommand(WorldEdit worldEdit, CmdArgs args)
{
switch (args.PopWord())
{
case "magic":
{
MagicSelect = (bool)args.PopBool(false);
worldEdit.Good("Magic select now " + (MagicSelect ? "on" : "off"));
return(true);
}
case "edgeblocks":
{
string arg = args.PopWord("list");
switch (arg)
{
case "list":
worldEdit.Good("Edge blocks: " + string.Join(", ", EdgeBlocks));
break;
case "add":
string blockcode = args.PopAll();
if (matchesAnyBlock(worldEdit.sapi, blockcode))
{
EdgeBlocks = EdgeBlocks.Append(args.PopAll());
worldEdit.Good("Ok, edge block '" + blockcode + "' added.");
SetEdgeBlocks(worldEdit.sapi.World, EdgeBlocks);
}
else
{
worldEdit.Good("Error, block code/wildcard '" + blockcode + "' does not match any known blocks.");
}
break;
case "remove":
List <string> elems = new List <string>(EdgeBlocks);
if (elems.Remove(args.PopAll()))
{
worldEdit.Good("Ok, edge block removed.");
SetEdgeBlocks(worldEdit.sapi.World, elems.ToArray());
}
else
{
worldEdit.Good("No such edge block in list.");
}
break;
default:
worldEdit.Bad("Invalid arg. Syntax: /we edgeblocks or /we edgeblocks [list|add|remove] [blockcode]");
break;
}
}
return(true);
}
return(false);
}
public override bool OnWorldEditCommand(WorldEdit worldEdit, CmdArgs args)
{
switch (args[0])
{
case "tr":
Radius = 0;
if (args.Length > 1)
{
float size;
float.TryParse(args[1], out size);
Radius = size;
}
worldEdit.Good("Raise/Lower radius " + Radius + " set.");
return(true);
case "tgr":
Radius++;
worldEdit.Good("Raise/Lower radius " + Radius + " set");
return(true);
case "tsr":
Radius = Math.Max(0, Radius - 1);
worldEdit.Good("Raise/Lower radius " + Radius + " set");
return(true);
case "tdepth":
Depth = 0;
if (args.Length > 1)
{
float size;
float.TryParse(args[1], out size);
Depth = size;
}
worldEdit.Good("Raise/Lower depth " + Depth + " set.");
return(true);
case "tm":
Mode = EnumHeightToolMode.Uniform;
if (args.Length > 1)
{
int mode;
int.TryParse(args[1], out mode);
try
{
Mode = (EnumHeightToolMode)mode;
} catch (Exception) { }
}
worldEdit.Good("Raise/Lower mode " + Mode + " set.");
return(true);
}
return(false);
}
public override bool OnWorldEditCommand(WorldEdit worldEdit, CmdArgs args)
{
switch (args[0])
{
case "imc":
if (workspace.clipboardBlockData != null)
{
this.blockDatas = new BlockSchematic[] { workspace.clipboardBlockData };
worldEdit.Good("Ok, using copied blockdata");
nextRnd = 0;
workspace.ResendBlockHighlights(worldEdit);
}
else
{
worldEdit.Good("No copied block data available");
}
return(true);
case "ims":
string exportFolderPath = worldEdit.sapi.GetOrCreateDataPath("WorldEdit");
List <string> filenames = new List <string>();
for (int i = 1; i < args.Length; i++)
{
string filename = Path.GetFileName(args[i]);
string filepath = Path.Combine(exportFolderPath, args[i]);
if (!filename.EndsWith("*") && !filename.EndsWith("/") && !filename.EndsWith(".json"))
{
filename += ".json";
}
try
{
string[] foundFilePaths = Directory.GetFiles(Path.GetDirectoryName(filepath), filename);
for (int j = 0; j < foundFilePaths.Length; j++)
{
filenames.Add(foundFilePaths[j].Substring(exportFolderPath.Length + 1));
}
} catch (Exception)
{
worldEdit.Bad("Unable to read files from this source");
return(true);
}
}
if (filenames.Count > 0)
{
BlockDataFilenames = string.Join(",", filenames);
LoadBlockdatas(worldEdit.sapi, worldEdit);
worldEdit.Good("Ok, found " + filenames.Count + " block data source files");
}
else
{
BlockDataFilenames = null;
this.blockDatas = new BlockSchematic[0];
worldEdit.Good("No source files under this name/wildcard found");
}
nextRnd = rand.Next(blockDatas.Length);
workspace.ResendBlockHighlights(worldEdit);
return(true);
case "imo":
Origin = EnumOrigin.BottomCenter;
if (args.Length > 1)
{
int origin;
int.TryParse(args[1], out origin);
if (Enum.IsDefined(typeof(EnumOrigin), origin))
{
Origin = (EnumOrigin)origin;
}
}
worldEdit.Good("Paste origin " + Origin + " set.");
workspace.ResendBlockHighlights(worldEdit);
return(true);
case "tm":
ReplaceMode = EnumReplaceMode.Replaceable;
if (args.Length > 1)
{
int replaceable = 0;
int.TryParse(args[1], out replaceable);
if (Enum.IsDefined(typeof(EnumReplaceMode), replaceable))
{
ReplaceMode = (EnumReplaceMode)replaceable;
}
}
worldEdit.Good("Replace mode " + ReplaceMode + " set.");
workspace.ResendBlockHighlights(worldEdit);
return(true);
case "imrrand":
RandomRotate = args.Length > 1 && (args[1] == "1" || args[1] == "true" || args[1] == "on");
worldEdit.Good("Random rotation now " + (RandomRotate ? "on" : "off"));
SetRandomAngle(worldEdit.sapi.World);
workspace.ResendBlockHighlights(worldEdit);
return(true);
case "imn":
nextRnd = rand.Next(blockDatas.Length);
workspace.ResendBlockHighlights(worldEdit);
break;
case "imr":
if (blockDatas == null || blockDatas.Length == 0)
{
worldEdit.Bad("Please define a block data source first.");
return(true);
}
int angle = 90;
if (args.Length > 1)
{
if (!int.TryParse(args[1], out angle))
{
worldEdit.Bad("Invalid Angle (not a number)");
return(true);
}
}
if (angle < 0)
{
angle += 360;
}
if (angle != 0 && angle != 90 && angle != 180 && angle != 270)
{
worldEdit.Bad("Invalid Angle, allowed values are -270, -180, -90, 0, 90, 180 and 270");
return(true);
}
for (int i = 0; i < blockDatas.Length; i++)
{
blockDatas[i].TransformWhilePacked(worldEdit.sapi.World, EnumOrigin.BottomCenter, angle, null);
}
workspace.ResendBlockHighlights(worldEdit);
worldEdit.Good("Ok, all schematics rotated by " + angle + " degrees");
return(true);
case "imflip":
if (blockDatas == null || blockDatas.Length == 0)
{
worldEdit.Bad("Please define a block data source first.");
return(true);
}
for (int i = 0; i < blockDatas.Length; i++)
{
blockDatas[i].TransformWhilePacked(worldEdit.sapi.World, EnumOrigin.BottomCenter, 0, EnumAxis.Y);
}
workspace.ResendBlockHighlights(worldEdit);
worldEdit.Good("Ok, imported sources flipped");
return(true);
case "immirror":
if (blockDatas == null || blockDatas.Length == 0)
{
worldEdit.Bad("Please define a block data source first.");
return(true);
}
EnumAxis axis = EnumAxis.X;
if (args.PopWord().ToLowerInvariant() == "z")
{
axis = EnumAxis.Z;
}
for (int i = 0; i < blockDatas.Length; i++)
{
blockDatas[i].TransformWhilePacked(worldEdit.sapi.World, EnumOrigin.BottomCenter, 0, axis);
}
workspace.ResendBlockHighlights(worldEdit);
worldEdit.Good("Ok, imported sources mirrored around " + axis + " axis");
return(true);
}
return(false);
}
public override bool OnWorldEditCommand(WorldEdit worldEdit, CmdArgs args)
{
switch (args[0])
{
case "tm":
EnumBrushMode brushMode = EnumBrushMode.Fill;
if (args.Length > 1)
{
int index;
int.TryParse(args[1], out index);
if (Enum.IsDefined(typeof(EnumBrushMode), index))
{
brushMode = (EnumBrushMode)index;
}
}
BrushMode = brushMode;
worldEdit.Good(workspace.ToolName + " mode " + brushMode + " set.");
workspace.ResendBlockHighlights(worldEdit);
return(true);
case "tdl":
EnumDepthLimit depthLimit = EnumDepthLimit.NoLimit;
if (args.Length > 1)
{
int index;
int.TryParse(args[1], out index);
if (Enum.IsDefined(typeof(EnumDepthLimit), index))
{
depthLimit = (EnumDepthLimit)index;
}
}
DepthLimit = depthLimit;
worldEdit.Good(workspace.ToolName + " depth limit set to " + depthLimit);
workspace.ResendBlockHighlights(worldEdit);
return(true);
case "ts":
EnumBrushShape shape = EnumBrushShape.Ball;
if (args.Length > 1)
{
int index;
int.TryParse(args[1], out index);
if (Enum.IsDefined(typeof(EnumBrushShape), index))
{
shape = (EnumBrushShape)index;
}
}
BrushShape = shape;
worldEdit.Good(workspace.ToolName + " shape " + BrushShape + " set.");
GenBrush();
workspace.ResendBlockHighlights(worldEdit);
return(true);
case "tsx":
case "tsy":
case "tsz":
{
float size = 0;
if (args.Length > 1)
{
float.TryParse(args[1], out size);
}
if (args[0] == "tsx")
{
BrushDim1 = size;
}
if (args[0] == "tsy")
{
BrushDim2 = size;
}
if (args[0] == "tsz")
{
BrushDim3 = size;
}
string text = dimensionNames[(int)BrushShape][0] + "=" + BrushDim1;
text += ", " + dimensionNames[(int)BrushShape][1] + "=" + BrushDim2;
text += ", " + dimensionNames[(int)BrushShape][2] + "=" + BrushDim3;
worldEdit.Good(workspace.ToolName + " dimensions " + text + " set.");
GenBrush();
workspace.ResendBlockHighlights(worldEdit);
return(true);
}
case "tr":
{
BrushDim1 = 0;
float size;
if (args.Length > 1 && float.TryParse(args[1], out size))
{
BrushDim1 = size;
}
if (args.Length > 2 && float.TryParse(args[2], out size))
{
BrushDim2 = size;
}
else
{
BrushDim2 = BrushDim1;
}
if (args.Length > 3 && float.TryParse(args[3], out size))
{
BrushDim3 = size;
}
else
{
BrushDim3 = BrushDim2;
}
string text = dimensionNames[(int)BrushShape][0] + "=" + BrushDim1;
text += ", " + dimensionNames[(int)BrushShape][1] + "=" + BrushDim2;
text += ", " + dimensionNames[(int)BrushShape][2] + "=" + BrushDim3;
worldEdit.Good(workspace.ToolName + " dimensions " + text + " set.");
GenBrush();
workspace.ResendBlockHighlights(worldEdit);
}
return(true);
case "tcx":
case "tcy":
case "tcz":
{
float size = 0;
if (args.Length > 1)
{
float.TryParse(args[1], out size);
}
if (args[0] == "tcx")
{
CutoutDim1 = size;
}
if (args[0] == "tcy")
{
CutoutDim2 = size;
}
if (args[0] == "tcz")
{
CutoutDim3 = size;
}
string text = dimensionNames[(int)BrushShape][0] + "=" + CutoutDim1;
text += ", " + dimensionNames[(int)BrushShape][1] + "=" + CutoutDim2;
text += ", " + dimensionNames[(int)BrushShape][2] + "=" + CutoutDim3;
worldEdit.Good(workspace.ToolName + " cutout dimensions " + text + " set.");
GenBrush();
workspace.ResendBlockHighlights(worldEdit);
return(true);
}
case "tcr":
{
CutoutDim1 = 0;
float size;
if (args.Length > 1 && float.TryParse(args[1], out size))
{
CutoutDim1 = size;
}
if (args.Length > 2 && float.TryParse(args[2], out size))
{
CutoutDim2 = size;
}
else
{
CutoutDim2 = CutoutDim1;
}
if (args.Length > 3 && float.TryParse(args[3], out size))
{
CutoutDim3 = size;
}
else
{
CutoutDim3 = CutoutDim2;
}
string text = dimensionNames[(int)BrushShape][0] + "=" + CutoutDim1;
text += ", " + dimensionNames[(int)BrushShape][1] + "=" + CutoutDim2;
text += ", " + dimensionNames[(int)BrushShape][2] + "=" + CutoutDim3;
worldEdit.Good("Cutout " + workspace.ToolName + " dimensions " + text + " set.");
GenBrush();
workspace.ResendBlockHighlights(worldEdit);
}
return(true);
case "tgr":
{
BrushDim1++;
BrushDim2++;
BrushDim3++;
string text = dimensionNames[(int)BrushShape][0] + "=" + BrushDim1;
text += ", " + dimensionNames[(int)BrushShape][1] + "=" + BrushDim2;
text += ", " + dimensionNames[(int)BrushShape][2] + "=" + BrushDim3;
worldEdit.Good(workspace.ToolName + " dimensions " + text + " set.");
GenBrush();
workspace.ResendBlockHighlights(worldEdit);
}
return(true);
case "tsr":
{
BrushDim1 = Math.Max(0, BrushDim1 - 1);
BrushDim2 = Math.Max(0, BrushDim2 - 1);
BrushDim3 = Math.Max(0, BrushDim3 - 1);
string text = dimensionNames[(int)BrushShape][0] + "=" + BrushDim1;
text += ", " + dimensionNames[(int)BrushShape][1] + "=" + BrushDim2;
text += ", " + dimensionNames[(int)BrushShape][2] + "=" + BrushDim3;
worldEdit.Good(workspace.ToolName + " dimensions " + text + " set.");
GenBrush();
workspace.ResendBlockHighlights(worldEdit);
}
return(true);
}
return(false);
}
public override bool OnWorldEditCommand(WorldEdit.WorldEdit worldEdit, CmdArgs args)
{
if (treeGenerators == null)
{
treeGenerators = new TreeGeneratorsUtil(worldEdit.sapi);
}
string cmd = args.PopWord();
switch (cmd)
{
case "tsizemin":
{
float size = 0.7f;
if (args.Length > 0)
{
float.TryParse(args[0], NumberStyles.Any, GlobalConstants.DefaultCultureInfo, out size);
}
MinTreeSize = size;
worldEdit.Good("Tree Min Size=" + size + " set.");
return(true);
}
case "tsizemax":
{
float size = 0.7f;
if (args.Length > 0)
{
float.TryParse(args[0], NumberStyles.Any, GlobalConstants.DefaultCultureInfo, out size);
}
MaxTreeSize = size;
worldEdit.Good("Tree Max Size=" + size + " set.");
return(true);
}
case "tsize":
{
float min = 0.7f;
if (args.Length > 0)
{
float.TryParse(args[0], NumberStyles.Any, GlobalConstants.DefaultCultureInfo, out min);
}
MinTreeSize = min;
float max = 1.3f;
if (args.Length > 1)
{
float.TryParse(args[1], NumberStyles.Any, GlobalConstants.DefaultCultureInfo, out max);
}
MaxTreeSize = max;
worldEdit.Good("Tree Min Size=" + min + ", max size =" + MaxTreeSize + " set.");
return(true);
}
case "trnd":
return(true);
case "tv":
int index = 0;
string variant = args.PopWord();
bool numeric = int.TryParse(variant, NumberStyles.Any, GlobalConstants.DefaultCultureInfo, out index);
treeGenerators.ReloadTreeGenerators();
if (numeric)
{
var val = treeGenerators.GetGenerator(index);
if (val.Key == null)
{
worldEdit.Bad("No such tree variant found.");
return(true);
}
TreeVariant = val.Key.ToShortString();
worldEdit.Good("Tree variant " + val.Key + " set.");
}
else
{
if (variant != null && treeGenerators.GetGenerator(new AssetLocation(variant)) != null)
{
TreeVariant = variant;
worldEdit.Good("Tree variant " + variant + " set.");
}
else
{
worldEdit.Bad("No such tree variant found.");
}
}
return(true);
}
return(false);
}
public override bool OnWorldEditCommand(WorldEdit worldEdit, CmdArgs args)
{
switch (args[0])
{
case "tusb":
bool val = (bool)args.PopBool(false);
if (val)
{
worldEdit.Good("Will use only selected block for placement");
}
else
{
worldEdit.Good("Will use erode away placed blocks");
}
UseSelectedBlock = val;
return(true);
case "tr":
BrushRadius = 0;
if (args.Length > 1)
{
float size;
float.TryParse(args[1], NumberStyles.Any, GlobalConstants.DefaultCultureInfo, out size);
BrushRadius = size;
}
worldEdit.Good("Erode radius " + BrushRadius + " set");
return(true);
case "tgr":
BrushRadius++;
worldEdit.Good("Erode radius " + BrushRadius + " set");
return(true);
case "tsr":
BrushRadius = Math.Max(0, BrushRadius - 1);
worldEdit.Good("Erode radius " + BrushRadius + " set");
return(true);
case "tkr":
KernelRadius = 0;
if (args.Length > 1)
{
int size;
int.TryParse(args[1], NumberStyles.Any, GlobalConstants.DefaultCultureInfo, out size);
KernelRadius = size;
}
if (KernelRadius > 10)
{
KernelRadius = 10;
worldEdit.SendPlayerWorkSpace(workspace.PlayerUID);
worldEdit.Good("Erode kernel radius " + KernelRadius + " set (limited to 10)");
}
else
{
worldEdit.Good("Erode kernel radius " + KernelRadius + " set");
}
PrecalcKernel();
return(true);
case "ti":
Iterations = 1;
if (args.Length > 1)
{
int iters;
int.TryParse(args[1], NumberStyles.Any, GlobalConstants.DefaultCultureInfo, out iters);
Iterations = iters;
}
if (Iterations > 10)
{
Iterations = 10;
worldEdit.SendPlayerWorkSpace(workspace.PlayerUID);
worldEdit.Good("Iterations " + Iterations + " set (limited to 10)");
}
else
{
worldEdit.Good("Iterations " + Iterations + " set");
}
return(true);
}
return(false);
}
