void HandleOther(Player p, string[] parts, int offsetIndex)
{
CopyArgs cArgs = new CopyArgs();
cArgs.offsetIndex = offsetIndex;
for (int i = 0; i < parts.Length; i++)
{
string opt = parts[i];
if (opt.CaselessEq("cut"))
{
cArgs.cut = true;
}
else if (opt.CaselessEq("air"))
{
cArgs.air = true;
}
else if (opt.Length > 0)
{
Help(p); return;
}
}
if (!p.Ignores.DrawOutput || !p.Supports(CpeExt.MessageTypes))
{
p.Message("Place or break two blocks to determine the edges.");
}
int marks = cArgs.offsetIndex != -1 ? 3 : 2;
p.MakeSelection(marks, "Selecting region for &SCopy", cArgs, DoCopy, DoCopyMark);
}
void HandleOther(Player p, string[] parts, int offsetIndex)
{
CopyArgs cArgs = new CopyArgs();
cArgs.offsetIndex = offsetIndex;
for (int i = 0; i < parts.Length; i++)
{
string opt = parts[i];
if (opt.CaselessEq("cut"))
{
cArgs.cut = true;
}
else if (opt.CaselessEq("air"))
{
cArgs.air = true;
}
else if (opt.Length > 0)
{
Help(p);
}
}
Player.Message(p, "Place or break two blocks to determine the edges.");
int marks = cArgs.offsetIndex != -1 ? 3 : 2;
p.MakeSelection(marks, "Selecting region for %SCopy", cArgs, DoCopy, DoCopyMark);
}
protected virtual void PopulateCopy(CopyArgs args, MetadataTreeNode copy)
{
copy.EnsureNotNull(nameof(copy));
//
var copyMetadataElement = default(IMetadataTreeElement);
var copyChildrenBuffer = new List <IMetadataTreeNode>();
var copyInclusionsBuffer = new List <IMetadataTreeNodeInclusion>();
try {
var copyChildren = copy.ReadDA(ref copy._children);
foreach (var childOfThis in Children)
{
copyChildrenBuffer.Add(childOfThis.CreateCopy(readOnlyState: null));
copyChildren.AddComponent(copyChildrenBuffer[copyChildrenBuffer.Count - 1]);
}
//
var copyInclusions = copy.ReadDA(ref copy._inclusions);
foreach (var inclusionOfThis in Inclusions)
{
copyInclusionsBuffer.Add(inclusionOfThis.CreateCopy(readOnlyState: null));
copyInclusions.AddComponent(copyInclusionsBuffer[copyInclusionsBuffer.Count - 1]);
}
//
copyMetadataElement = MetadataElement?.CreateCopy(readOnlyState: null);
var copyMetadataElementLink = new Link <IMetadataTreeNode, IMetadataTreeElement>(copy, copyMetadataElement);
copy.SetMetadataElement(copyMetadataElementLink);
//
}
catch (Exception firstException) {
DisposeManyDeep(firstException, copyMetadataElement, copyInclusionsBuffer, copyChildrenBuffer);
throw;
}
}
private void CopyItem(object state)
{
// get the CopyArgs instance from state param
CopyArgs args = state as CopyArgs;
try
{
// Copy the item calling the appropriate method
if (args.IsFolder)
{
this.CopyFolder(args.Source, args.Destination);
}
else
{
this.CopyFile(args.Source, args.Destination);
}
}
catch (Exception ex)
{
// swallow any exception since there is no point throwing from the thread pool thread
// track the number of items that failed to copy
Interlocked.Increment(ref this.failedItems);
this.traceSource.WriteError(ClassName, "CopyItem failed: source {0}, destination {1}, exception {2}\r\n", args.Source, args.Destination, ex);
}
finally
{
// Decrement work item and dequeue
this.DecrementWorkItem();
}
}
/// <summary>
/// Вызывается при копировании объекта.
/// <para>Выполняет заполнение копии объекта <paramref name="copy"/>.</para>
/// <para>Связь данного элемента с объектом метаданных (<seealso cref="MetadataTreeElementBase.MetadataLink"/>) в объект <paramref name="copy"/> не копируется.</para>
/// </summary>
/// <param name="args">Параметры копирования.</param>
/// <param name="copy">Копия объекта.</param>
protected sealed override void PopulateCopy(CopyArgs args, MetadataTreeElementBase copy)
{
var locCopy = copy.EnsureNotNull(nameof(copy)).EnsureOfType <MetadataTreeElementBase, EmbeddedMetadataTreeElement>().Value;
//
locCopy._embeddedMetadata = null;
PopulateCopy(args, locCopy);
base.PopulateCopy(args, copy);
}
protected sealed override void PopulateCopy(CopyArgs args, MetadataTreeStructureComponentBase copy)
{
var locCopy =
copy
.EnsureNotNull(nameof(copy))
.EnsureOfType <MetadataTreeStructureComponentBase, MetadataTreeNodeInclusionBase>()
.Value;
//
PopulateCopy(args, locCopy);
}
/// <summary>
/// Вызывается при копировании объекта.
/// <para>Выполняет заполнение копии объекта <paramref name="copy"/>.</para>
/// <para>Связь данного элемента с объектом метаданных (<seealso cref="MetadataLink"/>) в объект <paramref name="copy"/> не копируется.</para>
/// </summary>
/// <param name="args">Параметры копирования.</param>
/// <param name="copy">Копия объекта.</param>
protected virtual void PopulateCopy(CopyArgs args, MetadataTreeElementBase copy)
{
copy.EnsureNotNull(nameof(copy));
//
if (args.Node != null)
{
var link = new Link <IMetadataTreeNode, IMetadataTreeElement>(args.Node, copy);
copy.WriteDA(ref copy._nodeLink, link);
args.Node.SetMetadataElement(link);
}
}
protected virtual void PopulateCopy(CopyArgs copyArgs, CopyableReadOnlyScopeBase copy)
{
copy.EnsureNotNull(nameof(copy));
//
if ((copyArgs?.ReadOnlyState) is null)
{
copy.WriteDA(ref copy._readOnlyState, ReadOnlyState);
}
else
{
copy.WriteDA(ref copy._readOnlyState, copyArgs.ReadOnlyState);
}
}
void CompleteCopy(Player p, Vec3S32[] m, CopyArgs cArgs)
{
if (!cArgs.cut)
{
return;
}
DrawOp op = new CuboidDrawOp();
op.Flags = BlockDBFlags.Cut;
Brush brush = new SolidBrush(Block.Air);
DrawOpPerformer.Do(op, brush, p, new Vec3S32[] { m[0], m[1] }, false);
}
protected sealed override void PopulateCopy(CopyArgs args, CopyableReadOnlyScopeBase copy)
{
var locCopy =
copy
.EnsureNotNull(nameof(copy))
.EnsureOfType <CopyableReadOnlyScopeBase, MetadataTreeStructureComponentBase>()
.Value;
//
locCopy._parentLink = null;
//
PopulateCopy(args, locCopy);
//
base.PopulateCopy(args, copy);
}
protected virtual void PopulateCopy(CopyArgs args, MetadataBase copy)
{
copy.EnsureNotNull(nameof(copy));
//
if (args.Element != null)
{
var link = new Link <IMetadataTreeElement, IVh <IMetadata> >(source: args.Element, target: copy.ToValueHolder(ownsValue: true));
copy.WriteDA(location: ref copy._treeElementLink, value: link);
args.Element.SetMetadata(link: link);
}
//
foreach (var referenceSet in EnumerateDA(value: P_GetCopyOfReferenceSetRegistry().Select(locItem => locItem.Set), considerDisposeRequest: true))
{
copy.RegisterReferenceSet(referenceSet: referenceSet.CreateCopy(args: null), useDeserializationContext: true);
}
}
/// <summary>
/// Вызывается при копировании объекта.
/// <para>Выполняет заполнение копии объекта <paramref name="copy"/>.</para>
/// </summary>
/// <param name="args">Параметры копирования.</param>
/// <param name="copy">Копия объекта.</param>
protected virtual void PopulateCopy(CopyArgs args, EmbeddedMetadataTreeElement copy)
{
copy.EnsureNotNull(nameof(copy));
//
var originalEmbeddedMetadata = EmbeddedMetadata;
var copyEmbeddedMetadata = default(IMetadata);
try {
copy.WriteDA(
ref _embeddedMetadata,
originalEmbeddedMetadata == null ? null : (copyEmbeddedMetadata = originalEmbeddedMetadata.CreateCopy(readOnlyState: null)).ToValueHolder(true));
}
catch (Exception firstException) {
DisposeMany(firstException, copyEmbeddedMetadata);
throw;
}
}
void HandleOther(Player p, string opt, string[] parts, int offsetIndex)
{
CopyArgs cArgs = default(CopyArgs);
cArgs.offsetIndex = offsetIndex;
if (opt == "cut")
{
cArgs.type = 1;
}
else if (opt == "air")
{
cArgs.type = 2;
}
else if (!String.IsNullOrEmpty(opt))
{
Help(p); return;
}
Player.Message(p, "Place two blocks to determine the edges.");
p.MakeSelection(2, cArgs, DoCopy);
}
void DoCopyMark(Player p, Vec3S32[] m, int i, object state, BlockID block)
{
CopyArgs cArgs = (CopyArgs)state;
if (i == 2)
{
CopyState copy = p.CurrentCopy;
copy.Offset.X = copy.OriginX - m[i].X;
copy.Offset.Y = copy.OriginY - m[i].Y;
copy.Offset.Z = copy.OriginZ - m[i].Z;
p.Message("Set offset of where to paste from.");
CompleteCopy(p, m, cArgs);
return;
}
if (i != 1)
{
return;
}
Vec3S32 min = Vec3S32.Min(m[0], m[1]), max = Vec3S32.Max(m[0], m[1]);
ushort minX = (ushort)min.X, minY = (ushort)min.Y, minZ = (ushort)min.Z;
ushort maxX = (ushort)max.X, maxY = (ushort)max.Y, maxZ = (ushort)max.Z;
CopyState cState = new CopyState(minX, minY, minZ, maxX - minX + 1,
maxY - minY + 1, maxZ - minZ + 1);
cState.OriginX = m[0].X; cState.OriginY = m[0].Y; cState.OriginZ = m[0].Z;
int index = 0; cState.UsedBlocks = 0;
cState.PasteAir = cArgs.air;
for (ushort y = minY; y <= maxY; ++y)
{
for (ushort z = minZ; z <= maxZ; ++z)
{
for (ushort x = minX; x <= maxX; ++x)
{
block = p.level.GetBlock(x, y, z);
if (!p.group.Blocks[block])
{
index++; continue;
}
if (block != Block.Air || cState.PasteAir)
{
cState.UsedBlocks++;
}
cState.Set(block, index);
index++;
}
}
}
if (cState.UsedBlocks > p.group.DrawLimit)
{
p.Message("You tried to copy {0} blocks. You cannot copy more than {1} blocks.",
cState.UsedBlocks, p.group.DrawLimit);
cState.Clear(); cState = null;
p.ClearSelection();
return;
}
cState.CopySource = "level " + p.level.name;
p.CurrentCopy = cState;
p.Message("Copied &a{0} &Sblocks, origin at ({1}, {2}, {3}) corner", cState.UsedBlocks,
cState.OriginX == cState.X ? "Min" : "Max",
cState.OriginY == cState.Y ? "Min" : "Max",
cState.OriginZ == cState.Z ? "Min" : "Max");
if (!cState.PasteAir)
{
p.Message("To also copy air blocks, use &T/Copy Air");
}
if (cArgs.offsetIndex != -1)
{
p.Message("Place a block to determine where to paste from");
}
else
{
CompleteCopy(p, m, cArgs);
}
}
void DoCopyMark(Player p, Vec3S32[] m, int i, object state, ExtBlock block)
{
if (i == 2)
{
CopyState copy = p.CopySlots[p.CurrentCopySlot];
copy.Offset.X = copy.OriginX - m[i].X;
copy.Offset.Y = copy.OriginY - m[i].Y;
copy.Offset.Z = copy.OriginZ - m[i].Z;
Player.Message(p, "Set offset of where to paste from.");
return;
}
if (i != 1)
{
return;
}
CopyArgs cArgs = (CopyArgs)state;
Vec3S32 min = Vec3S32.Min(m[0], m[1]), max = Vec3S32.Max(m[0], m[1]);
ushort minX = (ushort)min.X, minY = (ushort)min.Y, minZ = (ushort)min.Z;
ushort maxX = (ushort)max.X, maxY = (ushort)max.Y, maxZ = (ushort)max.Z;
CopyState cState = new CopyState(minX, minY, minZ, maxX - minX + 1,
maxY - minY + 1, maxZ - minZ + 1);
cState.OriginX = m[0].X; cState.OriginY = m[0].Y; cState.OriginZ = m[0].Z;
int index = 0; cState.UsedBlocks = 0;
cState.PasteAir = cArgs.air;
for (ushort y = minY; y <= maxY; ++y)
{
for (ushort z = minZ; z <= maxZ; ++z)
{
for (ushort x = minX; x <= maxX; ++x)
{
block = p.level.GetBlock(x, y, z);
if (!p.group.Blocks[block.BlockID])
{
index++; continue;
} // TODO: will need to fix this when extblock permissions
if (block.BlockID != Block.Air || cState.PasteAir)
{
cState.UsedBlocks++;
}
cState.Set(block, index);
index++;
}
}
}
if (cState.UsedBlocks > p.group.DrawLimit)
{
Player.Message(p, "You tried to copy {0} blocks. You cannot copy more than {1} blocks.",
cState.UsedBlocks, p.group.DrawLimit);
cState.Clear(); cState = null;
p.ClearSelection();
return;
}
cState.CopySource = "level " + p.level.name;
p.SetCurrentCopy(cState);
if (cArgs.cut)
{
DrawOp op = new CuboidDrawOp();
op.Flags = BlockDBFlags.Cut;
Brush brush = new SolidBrush(ExtBlock.Air);
DrawOpPerformer.Do(op, brush, p, new Vec3S32[] { min, max }, false);
}
Player.Message(p, "Copied &a{0} %Sblocks, origin at ({1}, {2}, {3}) corner", cState.UsedBlocks,
cState.OriginX == cState.X ? "Min" : "Max",
cState.OriginY == cState.Y ? "Min" : "Max",
cState.OriginZ == cState.Z ? "Min" : "Max");
if (!cState.PasteAir)
{
Player.Message(p, "To also copy air blocks, use %T/Copy Air");
}
if (cArgs.offsetIndex != -1)
{
Player.Message(p, "Place a block to determine where to paste from");
}
}
protected abstract void PopulateCopy(CopyArgs args, MetadataTreeStructureComponentBase copy);
public void Copy(CopyArgs args)
{
var provider = new CopyProvider(args);
provider.Copy();
}
bool DoCopy(Player p, Vec3S32[] m, object state, byte type, byte extType)
{
CopyArgs cArgs = (CopyArgs)state;
ushort minX = (ushort)Math.Min(m[0].X, m[1].X), maxX = (ushort)Math.Max(m[0].X, m[1].X);
ushort minY = (ushort)Math.Min(m[0].Y, m[1].Y), maxY = (ushort)Math.Max(m[0].Y, m[1].Y);
ushort minZ = (ushort)Math.Min(m[0].Z, m[1].Z), maxZ = (ushort)Math.Max(m[0].Z, m[1].Z);
CopyState cState = new CopyState(minX, minY, minZ, maxX - minX + 1,
maxY - minY + 1, maxZ - minZ + 1);
cState.OriginX = m[0].X; cState.OriginY = m[0].Y; cState.OriginZ = m[0].Z;
int index = 0; cState.UsedBlocks = 0;
cState.PasteAir = cArgs.type == 2;
for (ushort yy = minY; yy <= maxY; ++yy)
{
for (ushort zz = minZ; zz <= maxZ; ++zz)
{
for (ushort xx = minX; xx <= maxX; ++xx)
{
byte b = p.level.GetTile(xx, yy, zz), extB = 0;
if (!Block.canPlace(p, b))
{
index++; continue;
}
if (b == Block.custom_block)
{
extB = p.level.GetExtTile(xx, yy, zz);
}
if (b != Block.air || cState.PasteAir)
{
cState.UsedBlocks++;
}
cState.Blocks[index] = b;
cState.ExtBlocks[index] = extB;
index++;
}
}
}
if (cState.UsedBlocks > p.group.maxBlocks)
{
Player.Message(p, "You tried to copy {0} blocks. You cannot copy more than {1} blocks.",
cState.UsedBlocks, p.group.maxBlocks);
cState.Blocks = null; cState.ExtBlocks = null; cState = null;
return(false);
}
p.CopyBuffer = cState;
if (cArgs.type == 1)
{
DrawOp op = new CuboidDrawOp();
op.Flags = BlockDBFlags.Cut;
Brush brush = new SolidBrush(Block.air, 0);
Vec3S32[] marks = { new Vec3S32(minX, minY, minZ), new Vec3S32(maxX, maxY, maxZ) };
DrawOp.DoDrawOp(op, brush, p, marks, false);
}
string format = "Copied &a{0} %Sblocks." +
(cState.PasteAir ? "" : " To also copy air blocks, use %T/copy air");
Player.Message(p, format, cState.UsedBlocks);
if (cArgs.offsetIndex != -1)
{
Player.Message(p, "Place a block to determine where to paste from");
p.Blockchange += BlockchangeOffset;
}
return(false);
}
/// <summary>
/// End copy delegate that is used to perform post copy completion task.
/// </summary>
/// <param name="state">
/// Instance of CopyArgs that contains the source and destination folders
/// </param>
private void EndCopy(object state)
{
this.internalCopyAsyncEvent.WaitOne();
CopyArgs args = state as CopyArgs;
string oldDstFolderOriginal = args.Destination + FolderCopy.OldExtension;
string oldDstFolderNew = args.Destination + FolderCopy.OldExtension;
string newDstFolderNew = args.Destination + FolderCopy.NewExtension;
string dstFolderOld = args.Destination;
string dstFolderNew = args.Destination;
try
{
if (!this.skipCopy && (this.copyFlag == CopyFlag.AtomicCopy || this.copyFlag == CopyFlag.AtomicCopySkipIfExists) &&
this.failedItems == 0 /* rename only if copying all items is successfull */)
{
for (int i = 1; i <= MaxRetryAttempts; i++)
{
try
{
// Step 3, 4 & 5
if (oldDstFolderOriginal != null && FabricDirectory.Exists(oldDstFolderOriginal))
{
FabricDirectory.Delete(oldDstFolderOriginal, recursive: true, deleteReadOnlyFiles: true);
oldDstFolderOriginal = null;
}
if (dstFolderOld != null && FabricDirectory.Exists(dstFolderOld))
{
this.RenameFolder(dstFolderOld, oldDstFolderNew);
dstFolderOld = null;
}
if (dstFolderNew != null)
{
this.RenameFolder(newDstFolderNew, dstFolderNew);
dstFolderNew = null;
}
if (oldDstFolderNew != null && FabricDirectory.Exists(oldDstFolderNew))
{
FabricDirectory.Delete(oldDstFolderNew, recursive: true, deleteReadOnlyFiles: true);
oldDstFolderNew = null;
}
break;
}
catch (Exception ex)
{
this.traceSource.WriteError(
ClassName,
"EndCopy exception: destination {0}, current object {1} exception {2}\r\n",
args.Destination,
oldDstFolderOriginal ?? dstFolderOld ?? dstFolderNew ?? oldDstFolderNew ?? "(null)",
ex);
if (ExceptionHandler.IsFatalException(ex))
{
throw;
}
if (i >= MaxRetryAttempts)
{
Interlocked.Increment(ref this.failedItems);
}
else
{
Thread.Sleep(500);
}
}
}
}
}
finally
{
if (newDstFolderNew != null && FabricDirectory.Exists(newDstFolderNew))
{
FabricDirectory.Delete(newDstFolderNew, recursive: true, deleteReadOnlyFiles: true);
}
}
// Signal completion of copy task.
this.asyncEvent.Set();
}
protected abstract void PopulateCopy(CopyArgs args, MetadataTreeNodeInclusionBase copy);
protected virtual void PopulateCopy(CopyArgs args, MetadataTreeNodeDirectoryInclusion copy)
{
copy.EnsureNotNull(nameof(copy));
//
}
