internal void RegisterPiece(string pieceTable, GameObject prefab)
{
PieceTable table = getPieceTable(pieceTable);
// Error checking
if (!table)
{
Debug.LogError("Failed to register piece, Piece table does not exist: " + pieceTable);
return;
}
if (!prefab)
{
Debug.LogError("Failed to register Piece with null prefab");
return;
}
if (!prefab.GetComponent <Piece>())
{
Debug.LogError("Failed to register piece, Prefab does not have Piece component: " + prefab.name);
return;
}
// Set layer if not already set
if (prefab.layer == 0)
{
prefab.layer = LayerMask.NameToLayer("piece");
}
// Add prefab
table.m_pieces.Add(prefab);
Debug.Log("Registered piece: " + prefab.name + " to " + pieceTable);
}
public void PreviousPointOfEndPoint()
{
var table = PieceTable.ForString("0");
var pointAfterLast = table[0].Next;
Assert.AreEqual('0', pointAfterLast.Previous.GetValue());
}
public TextSnapshot(ITextBuffer owner, PieceTable <char> text, TextSnapshotLines lines)
{
_owner = owner;
_text = text;
_lines = lines;
_lines.Owner = this;
}
private void AddPieceWithAllCategoryToAvailablePieces(PieceTable pieceTable)
{
// pieces with All category are always available at the first category
List <Piece> firstCategory = pieceTable.m_availablePieces.FirstOrDefault();
if (firstCategory == null)
{
return;
}
List <Piece> piecesWithAllCategory = firstCategory.FindAll(i => i.m_category == Piece.PieceCategory.All);
for (int i = 0; i < (int)PieceCategoryMax; i++)
{
int index = 0;
foreach (var piece in piecesWithAllCategory)
{
// m_availablePieces are already populated. Add pieces at the beginning of the list, to replicate vanilla behaviour
if (pieceTable.m_availablePieces[i].Contains(piece))
{
pieceTable.m_availablePieces[i].Remove(piece);
}
pieceTable.m_availablePieces[i].Insert(Mathf.Min(index, pieceTable.m_availablePieces.Count), piece);
index++;
}
}
}
public static void PieceTable_SetCategory(PieceTable __instance, int index)
{
if (PieceTableCategories.currentActive != null)
{
PieceTableCategories.currentActive.PieceTable_SetCategory(__instance, index);
}
}
static bool Prefix(Player __instance, bool takeInput, float dt, PieceTable ___m_buildPieces, GameObject ___m_placementGhost)
{
if (!AllowByKey() || !CheckKeyHeld(pullItemsKey.Value) || !__instance.InPlaceMode() || !takeInput || Hud.IsPieceSelectionVisible())
{
return(true);
}
if (ZInput.GetButtonDown("Attack") || ZInput.GetButtonDown("JoyPlace"))
{
Piece selectedPiece = ___m_buildPieces.GetSelectedPiece();
if (selectedPiece != null)
{
if (selectedPiece.m_repairPiece)
{
return(true);
}
if (___m_placementGhost != null)
{
int placementStatus = (int)typeof(Player).GetField("m_placementStatus", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(__instance);
if (placementStatus == 0)
{
Dbgl($"pulling resources to player inventory for piece {selectedPiece.name}");
PullResources(__instance, selectedPiece.m_resources, 0);
}
}
}
}
return(false);
}
public void IntensiveEditingSession()
{
var table = PieceTable.ForArray(new int[0]);
const int iterations = 10 * 1000;
const int insertionsPerIteration = 30;
const int deletionsPerIteration = 2;
var random = new Randomizer(42);
var totalTime = BenchmarkIterations(iterations, delegate
{
var insertionPoint = random.Next(table.Length);
for (var i = 0; i < insertionsPerIteration; ++i)
{
table = table.Insert(insertionPoint + i, i);
}
var readPosition = random.Next(table.Length);
table.ToArray(readPosition, Math.Min(table.Length - readPosition, insertionsPerIteration));
for (var i = 0; i < deletionsPerIteration; ++i)
{
table = table.Delete(random.Next(table.Length), 1);
}
});
const int totalNumberOfOperations = iterations * (insertionsPerIteration + deletionsPerIteration);
ReportTotalNumberOfOperations(totalTime, totalNumberOfOperations);
Assert.AreEqual(iterations * insertionsPerIteration - iterations * deletionsPerIteration, table.Length);
}
public TextSnapshot(ITextBuffer owner, PieceTable<char> text, TextSnapshotLines lines)
{
_owner = owner;
_text = text;
_lines = lines;
_lines.Owner = this;
}
private Piece SetPieceTablePosition(string pieceTableName, string pieceName, int position)
{
logger.LogInfo("Moving " + pieceName + " to position " + position + " in " + pieceTableName);
Object[] array = Resources.FindObjectsOfTypeAll(typeof(PieceTable));
for (int i = 0; i < array.Length; i++)
{
pieceTable = (PieceTable)array[i];
string name = pieceTable.gameObject.name;
if (pieceTableName == name)
{
logger.LogInfo("Found PieceTable " + pieceTableName);
int currentPosition = pieceTable.m_pieces.FindIndex(piece => piece.name == pieceName);
if (currentPosition >= 0)
{
logger.LogInfo("Found Piece " + pieceName + " at position " + currentPosition);
GameObject @object = pieceTable.m_pieces[currentPosition];
pieceTable.m_pieces.RemoveAt(currentPosition);
logger.LogInfo("Moving to position " + position);
pieceTable.m_pieces.Insert(position, @object);
return(@object.GetComponent <Piece>());
}
}
}
return(null);
}
public static void Postfix(ref PieceTable __instance)
{
if (BuildExpansionMod.isEnabled.Value)
{
HudPatches.needRefresh = true;
}
}
public static IEnumerable<LineSpan> LineSpansFor(PieceTable<char> text)
{
var length = text.Length;
if (length == 0)
{
yield return new LineSpan(0, 0, 0);
yield break;
}
var offset = 0;
var textLength = 0;
var iterator = text[0];
do
{
var c = iterator.GetValue();
if (c == '\n')
{
const int lineBreakLength = 1;
yield return new LineSpan(offset, textLength, lineBreakLength);
offset += textLength + lineBreakLength;
textLength = 0;
}
else
++textLength;
iterator = iterator.Next;
}
while (iterator.Position < length);
if (textLength > 0 || iterator.Previous.GetValue() == '\n')
yield return new LineSpan(offset, textLength, 0);
}
public static bool Prefix(ref PieceTable __instance)
{
if (BuildExpansionMod.isEnabled.Value)
{
if (__instance.m_availablePieces[(int)__instance.m_selectedCategory].Count <= 1)
{
return(false);
}
int lastRowElems = Player.m_localPlayer.GetBuildPieces().Count % BuildExpansionMod.newGridWidth.Value;
Vector2Int vector2Int = __instance.m_selectedPiece[(int)__instance.m_selectedCategory];
vector2Int.y = vector2Int.y + 1;
if (vector2Int.y >= HudPatches.calculatedRows)
{
vector2Int.y = 0;
}
if (vector2Int.y >= HudPatches.calculatedRows - 1 && lastRowElems != 0 && vector2Int.x > lastRowElems - 1)
{
vector2Int.x = lastRowElems - 1;
}
__instance.m_selectedPiece[(int)__instance.m_selectedCategory] = vector2Int;
HudPatches.visibilityInsurance.CenterOnItem(Hud.instance.m_pieceIcons[vector2Int.x + vector2Int.y * BuildExpansionMod.newGridWidth.Value].m_go.transform as RectTransform);
return(false);
}
return(true);
}
public static void PieceTable_PrevCategory_Postfix(PieceTable __instance, ref Piece.PieceCategory __state)
{
if (PieceTableCategories.currentActive != null)
{
PieceTableCategories.currentActive.PieceTable_PrevCategory(__instance, __state);
}
}
public void InsertFollowedByInsert(int index, string s)
{
var v0 = PieceTable.ForString(s);
var v1 = v0.Insert(index, '*');
var v2 = v1.Insert(index + 1, '-');
Assert.AreEqual(s.Insert(index, "*-"), StringFor(v2));
}
public void InsertingAdjacentElementDoesNotCausePieceTableGrowth(string s, int index)
{
var v0 = PieceTable.ForString(s);
var v1 = v0.Insert(index, '*');
var v2 = v1.Insert(index + 1, '-');
Assert.AreEqual(v1.PieceCount, v2.PieceCount);
}
public void Delete(int position, int length, string expectedString)
{
const string originalString = "0123";
var v0 = PieceTable.ForString(originalString);
var v1 = v0.Delete(position, length);
Assert.AreEqual(expectedString, StringFor(v1));
}
public void ItRemovesTextAtTheEnd()
{
var tbl = new PieceTable("Hello worldasdasd");
tbl.Remove(11, 6);
Assert.AreEqual("Hello world", tbl.ToString());
}
public void ItRemovesTextAtTheBeginning()
{
var tbl = new PieceTable("asdasd Hello world");
tbl.Remove(0, 7);
Assert.AreEqual("Hello world", tbl.ToString());
}
public void ItRemovesText()
{
var tbl = new PieceTable("Hello asdasd world");
tbl.Remove(6, 7);
Assert.AreEqual("Hello world", tbl.ToString());
}
public void ItInsertsTextInTheMiddle()
{
var tbl = new PieceTable("Lorem dolor sit amet");
tbl.Insert(" ipsum", 5);
Assert.AreEqual("Lorem ipsum dolor sit amet", tbl.ToString());
}
internal void ScanHammer(bool lateAdd)
{
try
{
logger.LogDebug("Scanning Hammer PieceTable for Pieces");
foreach (GameObject hammerRecipe in PieceManager.Instance.GetPieceTable("Hammer").m_pieces)
{
if (hammerRecipe == null)
{
logger.LogWarning("null recipe in Hammer PieceTable");
continue;
}
Piece piece = hammerRecipe.GetComponent <Piece>();
if (piece.name == "piece_repair")
{
if (!addedHammer)
{
PieceTable planHammerPieceTable = PieceManager.Instance.GetPieceTable(PlanHammerPrefabConfig.pieceTableName);
if (planHammerPieceTable != null)
{
planHammerPieceTable.m_pieces.Add(hammerRecipe);
addedHammer = true;
}
}
continue;
}
if (planPiecePrefabConfigs.ContainsKey(piece.name))
{
continue;
}
if (!piece.m_enabled ||
piece.GetComponent <Ship>() != null ||
piece.GetComponent <Plant>() != null ||
piece.GetComponent <TerrainModifier>() != null ||
piece.m_resources.Length == 0)
{
continue;
}
PlanPiecePrefabConfig prefabConfig = new PlanPiecePrefabConfig(piece);
PieceManager.Instance.AddPiece(prefabConfig);
planPiecePrefabConfigs.Add(piece.name, prefabConfig);
PrefabManager.Instance.RegisterToZNetScene(prefabConfig.PiecePrefab);
if (lateAdd)
{
PieceTable pieceTable = PieceManager.Instance.GetPieceTable(PlanHammerPrefabConfig.pieceTableName);
if (!pieceTable.m_pieces.Contains(prefabConfig.PiecePrefab))
{
pieceTable.m_pieces.Add(prefabConfig.PiecePrefab);
}
}
}
}
finally
{
PieceManager.OnPiecesRegistered -= ScanHammer;
}
}
public void GetRangeAfterMultipleInserts(int position, int length, string expectedString)
{
const string originalString = "01234567";
var v0 = PieceTable.ForString(originalString);
var v1 = v0.Insert(2, '*');
var v2 = v1.Insert(v1.Length - 2, '*');
Assert.AreEqual(expectedString, new string(v2.ToArray(position, length)));
}
public void InsertPreservesOriginalVersion()
{
const string originalString = "01234567";
var v0 = PieceTable.ForString(originalString);
var v1 = v0.Insert(2, '*');
Assert.AreEqual(originalString.Insert(2, "*"), StringFor(v1));
Assert.AreEqual(originalString, StringFor(v0));
}
public void DeleteAfterInsert(int position, int length, string expectedString)
{
const string originalString = "023";
var v0 = PieceTable.ForString(originalString);
var v1 = v0.Insert(1, '1');
var v2 = v1.Delete(position, length);
Assert.AreEqual(expectedString, StringFor(v2));
}
public void LengthAfterPrepending(int insertionCount)
{
var table = PieceTable.ForString("");
for (var i = 0; i < insertionCount; ++i)
{
table = table.Insert(0, ' ');
}
Assert.AreEqual(insertionCount, table.Length);
}
public void PieceTable_SetCategory(PieceTable self, int index)
{
if (self.m_useCategories)
{
if (ContainsValue((Piece.PieceCategory)index))
{
self.m_selectedCategory = (Piece.PieceCategory)index;
}
}
}
public void ItLoadsContent()
{
var tbl = new PieceTable("original");
Assert.AreEqual("original", tbl.Original);
Assert.AreEqual(1, tbl.Pieces.Count);
Assert.AreEqual(0, tbl.Pieces[0].Start);
Assert.AreEqual("original".Length, tbl.Pieces[0].Length);
Assert.AreEqual(false, tbl.Pieces[0].AddBuffer);
}
public void ItInsertsMultipleTexts()
{
var tbl = new PieceTable();
tbl.Insert("Hello world", 0);
tbl.Insert(" wonderful", 5);
tbl.Insert(", this is a test!", tbl.ToString().Length);
Assert.AreEqual("Hello wonderful world, this is a test!", tbl.ToString());
}
private static PieceTable <int> CreateTableWithManyPieces(int length)
{
var table = PieceTable.ForArray(new int[0]);
for (var i = 0; i < length; ++i)
{
table = table.Insert(0, i);
}
return(table);
}
public override CalculatedFieldValue GetCalculatedValueCore(PieceTable sourcePieceTable,
MailMergeDataMode mailMergeDataMode,
Field documentField)
{
OfficeImage image = chart.CreateImage();
DocumentModel targetModel = sourcePieceTable.DocumentModel.GetFieldResultModel();
targetModel.MainPieceTable.InsertInlinePicture(DocumentLogPosition.Zero, image);
return(new CalculatedFieldValue(targetModel));
}
public void DeletionPieceCountAfterInsert(int position, int length, int expectedPieceCount)
{
var v0 = PieceTable.ForString("02");
var v1 = v0.Insert(1, '1');
Assert.AreEqual(3, v1.PieceCount);
var v2 = v1.Delete(position, length);
Assert.AreEqual(expectedPieceCount, v2.PieceCount);
}
public void SequentialAccessAfterManyDeletions()
{
const int numberOfDeletions = 100;
const int numberOfCharacters = 500;
const int iterations = 10 * 1000;
var randomizer = new Randomizer(42);
var table = PieceTable.ForString(new string(' ', 5 * 1024));
for (var i = 0; i < numberOfDeletions; ++i)
{
table = table.Delete(randomizer.Next(table.Length), 1);
}
Console.WriteLine("** CopyTo iteration **");
var buffer = new char[1];
var totalWithout = BenchmarkIterations(iterations, delegate
{
var position = randomizer.Next(table.Length - numberOfCharacters * 2) + numberOfCharacters;
for (var i = 0; i < numberOfCharacters; ++i)
{
table.CopyTo(buffer, 0, position + i, 1);
}
for (var i = 0; i < numberOfCharacters; ++i)
{
table.CopyTo(buffer, 0, position - i, 1);
}
});
const int totalNumberOfOperations = iterations * numberOfCharacters;
ReportTotalNumberOfOperations(totalWithout, totalNumberOfOperations);
Console.WriteLine("** Point iteration **");
var totalWith = BenchmarkIterations(iterations, delegate
{
var position = randomizer.Next(table.Length - numberOfCharacters * 2) + numberOfCharacters;
var pivot = table[position];
var current = pivot;
for (var i = 0; i < numberOfCharacters; ++i)
{
current.GetValue();
current = current.Next;
}
current = pivot;
for (var i = 0; i < numberOfCharacters; ++i)
{
current.GetValue();
current = current.Previous;
}
});
ReportTotalNumberOfOperations(totalWith, totalNumberOfOperations);
}
private static string StringFor(PieceTable<char> p)
{
return new string(p.ToArray());
}
public TextSnapshot(ITextBuffer owner, PieceTable<char> text) : this(owner, text, new TextSnapshotLines(text))
{
}
public TextSnapshotLines(PieceTable<char> text)
{
_spans = PieceTable.ForArray(LineParser.LineSpansFor(text).ToArray());
}