public static void Main() { DynamicArray<string> arrey = new DynamicArray<string>(); arrey.Add("Pesho"); arrey.Add("Gosho"); Console.WriteLine(arrey.IndexOf("Pesho")); Console.WriteLine(arrey.Contains("Gosho")); Console.WriteLine(arrey.Contains("Ivan")); arrey.Remove("Pesho"); arrey.InsertAt(1, "Pesho"); arrey.Clear(); Console.WriteLine(arrey.Capacity); Console.WriteLine(arrey.Count); arrey.Add("Ivo"); arrey[0] = "Gosho"; var newArrey = arrey.ToArray(); Console.WriteLine(); foreach (var item in arrey) { Console.WriteLine(item); } Console.WriteLine(); foreach (var item in newArrey) { Console.WriteLine(item); } }
/// <summary> /// Initializes a new instance of the <see cref="PathingAStar"/> class. /// </summary> /// <param name="heapInitialSize">Initial size of the heap.</param> /// <param name="moveCostProvider">The move cost provider.</param> /// <param name="pathSmoother">The path smoother to use.</param> public PathingAStar(int heapInitialSize, IMoveCost moveCostProvider, ICellCostStrategy cellCostStrategy, ISmoothPaths pathSmoother) : base(moveCostProvider, cellCostStrategy, pathSmoother) { _openSet = new BinaryHeap<IPathNode>(heapInitialSize, new PathNodeComparer()); _expandedSet = new List<IPathNode>(); _successorArray = new DynamicArray<IPathNode>(15); }
/// <summary> /// Initializes a new instance of the <see cref="GridManager"/> class. /// </summary> public GridManager() { _grids = new List<IGrid>(); _gridComponents = new List<GridComponent>(); _portals = new DynamicArray<GridPortal>(0); _portalsLookup = new Dictionary<string, GridPortal>(StringComparer.Ordinal); }
/// <summary> /// Initializes a new instance of the <see cref="PathingAStar"/> class. /// </summary> /// <param name="heapInitialSize">Initial size of the heap.</param> public PathingAStar(int heapInitialSize) : base(new DiagonalDistance(10), new DefaultCellCostStrategy(), new PathSmoother()) { _openSet = new BinaryHeap<IPathNode>(heapInitialSize, new PathNodeComparer()); _expandedSet = new List<IPathNode>(); _successorArray = new DynamicArray<IPathNode>(15); }
public void CustomCapacityConstructorTest() { int ActualCapacity = 5; DynamicArray<int> Arr = new DynamicArray<int>(ActualCapacity); Assert.AreEqual(Arr.Capacity, ActualCapacity); Assert.AreEqual(Arr.Length, 0); }
public void TestIEnum() { int[] arr = new[] { 1, 2, 3, 4, 5 }; DynamicArray<int> m3 = new DynamicArray<int>(arr); foreach (var elem in m3) Console.WriteLine(elem); }
static void Main(string[] args) { var array = new DynamicArray<string>(); array.Add("Georgi"); array.Add("Nikolai"); Console.WriteLine(array.IndexOf("Nikolai")); Console.WriteLine(array.Cointains("Kiril")); array.Remove("Georgi"); array.InsertAt(1, "Ivan"); array.Clear(); Console.WriteLine(array.Capacity); Console.WriteLine(array.Count); array.Add("Stefan"); array.Add("Krum"); var arr = array.ToArray(); Console.WriteLine(); foreach (var item in array) { Console.WriteLine(item); } Console.WriteLine(); foreach (var item in arr) { Console.WriteLine(item); } }
/// <summary> /// Initializes a new instance of the <see cref="FullGridVectorField"/> class. /// </summary> /// <param name="group">The transient unit group.</param> /// <param name="path">The path.</param> /// <param name="options">The vector field options.</param> public FullGridVectorField(TransientGroup<IUnitFacade> group, Path path, VectorFieldOptions options) { Ensure.ArgumentNotNull(group, "group"); this.group = group; _currentPath = path; var modelUnit = group.modelUnit; _unitProperties = modelUnit; var pathOptions = modelUnit.pathFinderOptions; // cache options locally _obstacleStrengthFactor = options.obstacleStrengthFactor; _allowCornerCutting = pathOptions.allowCornerCutting; _allowDiagonals = !pathOptions.preventDiagonalMoves; _announceAllNodes = modelUnit.pathNavigationOptions.announceAllNodes; _builtInContainment = options.builtInContainment; _updateInterval = options.updateInterval; // pre-allocate lists _openSet = new SimpleQueue<Cell>(31); _tempWalkableNeighbours = new DynamicArray<Cell>(8); _extraTempWalkableNeighbours = new DynamicArray<Cell>(8); _grid = GridManager.instance.GetGrid(group.modelUnit.position); if (_grid != null) { _fastMarchedCells = new PlaneVector[_grid.sizeX, _grid.sizeZ]; _cellDirs = new VectorFieldCell[_grid.sizeX, _grid.sizeZ]; } }
public static void ToArray() { DynamicArray<int> darray = new DynamicArray<int>(1); darray.Insert(Data, 0, 0); Assert.That(darray, Is.EqualTo((int[])darray.ToArray())); Assert.That(darray, Is.EqualTo((int[])darray)); }
public void RandomOperation() { var r = new Random(); const int totalOperations = 10000; var target = new DynamicArray<int>(); for (var i = 0; i < totalOperations; i++) { int oldCount = target.Count; switch (r.Next(3)) { case 0: // Add var newItem = r.Next(); target.Add(newItem); Assert.AreEqual(oldCount + 1, target.Count); Assert.AreEqual(newItem, target[oldCount]); break; case 1: // Remove by index if(oldCount == 0) goto case 0; var indexToRemove = r.Next(oldCount - 1); target.RemoveAt(indexToRemove); Assert.AreEqual(oldCount - 1, target.Count); break; case 2: // Remove by element if (oldCount == 0) goto case 0; var itemToRemove = target[r.Next(oldCount - 1)]; target.Remove(itemToRemove); Assert.AreEqual(oldCount - 1, target.Count); break; } } }
public void AddTest() { DynamicArray<int> Arr = new DynamicArray<int>(); Arr.Add(23); Assert.AreEqual(Arr.Length, 1); Assert.AreEqual(Arr[0], 23); }
public void AsGenericCollection() { var data = new[] { 3, 2, 4, 5, 7, -3, -2, -4, -5, -7 }; var darray = new DynamicArray<int>(1); darray.Insert(data, 0, 0); Assert.That(darray, Is.EqualTo(data)); }
private HeightQuadTree(int startX, int startZ, int sizeX, int sizeZ, int depth, int maxDepth) { _bounds = new MatrixBounds(startX, startZ, startX + (sizeX - 1), startZ + (sizeZ - 1)); _depth = depth; _maxDepth = maxDepth; _indexes = new DynamicArray<VectorXZ>(10); }
private HeightQuadTree(MatrixBounds bounds, int depth, int maxDepth) { _bounds = bounds; _depth = depth; _maxDepth = maxDepth; _indexes = new DynamicArray<VectorXZ>(10); }
public void AddPaymentOption(PaymentOption option) { if (option != null) { DynamicArray<PaymentOption> dynamicArray = new DynamicArray<PaymentOption>(); PaymentOptions = dynamicArray.AddToArray(PaymentOptions, option); } }
public void AddPaymentOptionRange(ICollection<PaymentOption> options) { if (options != null) { DynamicArray<PaymentOption> dynamicArray = new DynamicArray<PaymentOption>(); PaymentOptions = dynamicArray.AddToArrayRange(PaymentOptions, options); } }
public void DefConstr() { DynamicArray<int> m1 = new DynamicArray<int>(); var a = m1.Length; Assert.AreEqual(a, 0); var b = m1.Capacity; Assert.AreEqual(b, 8); }
public static void GenericCopyTo() { DynamicArray<int> darray = new DynamicArray<int>(1); DynamicArray<int> dcopy = new DynamicArray<int>(1); darray.Insert(Data, 0, 0); darray.CopyTo(dcopy, 0); Assert.That(darray, Is.EqualTo(dcopy)); }
public void ConstrOneParam() { DynamicArray<int> m2 = new DynamicArray<int>(9); var a = m2.Length; Assert.AreEqual(a, 0); var b = m2.Capacity; Assert.AreEqual(b, 9); }
public static void NonGenericCopyTo() { DynamicArray<int> darray = new DynamicArray<int>(1); int[] copy = new int[Data.Length]; darray.Insert(Data, 0, 0); ((ICollection)darray).CopyTo(copy, 0); Assert.That(Data, Is.EqualTo(copy)); }
public void InsertTest() { int[] A = new int[] { 1, 2, 3, 4 }; DynamicArray<int> testArr = new DynamicArray<int>(A); testArr.Insert(42, 3); Assert.AreEqual(testArr[3], 42); testArr.Insert(42, testArr.Capacity); Assert.AreEqual(testArr[testArr.Capacity - 1], 42); }
public void RemoveTest() { int[] A = new int[] { 1, 2, 3, 4 }; DynamicArray<int> testArr = new DynamicArray<int>(A); testArr.Remove(2); bool testBool = testArr.Remove(10); Assert.AreEqual(testArr[1], 3); Assert.AreEqual(testBool, false); }
public void AddMoreThanCapacityTest() { DynamicArray<int> Arr = new DynamicArray<int>(2); Arr.Add(65); Arr.Add(16); Arr.Add(76); Assert.AreEqual(Arr.Length, 3); Assert.AreEqual(Arr.Capacity, 4); Assert.AreEqual(Arr[2], 76); }
public static void ExceptionOnCopyToOfMultiDim() { Assert.Throws<RankException>( () => { var dynArray = new DynamicArray<object>(2); var copyActual = new object[dynArray.Count]; ((ICollection)dynArray).CopyTo(copyActual, 0); }); }
public void ConstrCollect() { int[] arr = new[] { 1, 2, 3, 4, 5 }; DynamicArray<int> m3 = new DynamicArray<int>(arr); var a = m3.Length; Assert.AreEqual(a, 5); var b = m3.Capacity; Assert.AreEqual(b, 5); }
public void ConstrucTest2() { List<int> A = new List<int> { 1, 2, 3, 4 }; DynamicArray<int> testArr = new DynamicArray<int>(A); Assert.AreEqual(testArr.Length, 4); Assert.AreEqual(testArr[0], 1); Assert.AreEqual(testArr[1], 2); Assert.AreEqual(testArr[2], 3); Assert.AreEqual(testArr[3], 4); }
public void AddRangeMoreThanCapacity() { int[] a = { 28, 98, 89, 25, 43 }; DynamicArray<int> Arr = new DynamicArray<int>(2); Arr.Add(68); Arr.Add(73); Arr.AddRange(a); Assert.AreEqual(Arr.Length, 7); Assert.AreEqual(Arr.Capacity, 8); Assert.AreEqual(Arr[2], 28); Assert.AreEqual(Arr[6], 43); }
public void TestInsertMethod() { DynamicArray<int> m3 = new DynamicArray<int>(9); int[] arr = new[] { 1, 2, 3, 4, 5 }; foreach (var elem in arr) { m3.Add(elem); } m3.Insert(2, 9); var a1 = m3[2]; Assert.AreEqual(a1, 9); }
public void TestMethod1() { try { DynamicArray<int> m1 = new DynamicArray<int>(); DynamicArray<int> m2 = new DynamicArray<int>(9); int[] arr = new[] { 1, 2, 3, 4, 5 }; DynamicArray<int> m3 = new DynamicArray<int>(arr); var a = m3.Length; Assert.AreEqual(a, 5); var b = m3.Capacity; Assert.AreEqual(b, 5); m3.Add(6); var a1 = m3.Length; Assert.AreEqual(a1, 6); var b1 = m3.Capacity; Assert.AreEqual(b1, 10); int[] arr1 = new[] { 7, 8, 9, 10, 11, 12 }; m3.AddRange(arr1); var a3 = m3.Length; Assert.AreEqual(a3, 12); var b3 = m3.Capacity; Assert.AreEqual(b3, 20); var flag1 = m3.Remove(7); var a4 = m3.Length; Assert.AreEqual(a4, 11); Assert.AreEqual(flag1, true); //m3.Insert(26,14); //Попытка вставить вне границ массива m3.Insert(6, 7); var b4 = m3[6]; Assert.AreEqual(b4, 7); int k = 1; foreach (var elem in m3) { var a5 = elem; Assert.AreEqual(a5, k); k++; } } catch (Exception ex) { Console.WriteLine(ex.ToString()); Assert.AreEqual(0, 1); } }
public void AsNonGenericCollection() { var data = new[] { 3, 2, 4, 5, 7, -3, -2, -4, -5, -7 }; var darray = new DynamicArray<int>(1); darray.Insert(data, 0, 0); int i = 0; foreach (int element in (IEnumerable)darray) { Assert.AreEqual(data[i++], element); } }
public DebuggerView(DynamicArray <T> array) { this._array = array; }
public async Task Can_project_in_map_reduce() { using (var store = GetDocumentStore()) { using (var session = store.OpenAsyncSession()) { await session.StoreAsync(new Address() { City = "Torun" }); await session.StoreAsync(new Address() { City = "Torun" }); await session.StoreAsync(new Address() { City = "Hadera" }); await session.SaveChangesAsync(); } using (var commands = store.Commands()) { // create auto map reduce index var command = new QueryCommand(commands.Session, new IndexQuery { Query = "FROM Addresses GROUP BY City SELECT count() as TotalCount ", WaitForNonStaleResults = true }); commands.RequestExecutor.Execute(command, commands.Context); // retrieve only City field command = new QueryCommand(commands.Session, new IndexQuery { Query = "FROM Addresses GROUP BY City SELECT City ", WaitForNonStaleResults = true }); commands.RequestExecutor.Execute(command, commands.Context); var indexDefinitions = store.Maintenance.Send(new GetIndexesOperation(0, 10)); Assert.Equal(1, indexDefinitions.Length); // the above queries should be handled by the same auto index var result = command.Result; var results = new DynamicArray(result.Results); var cities = new List <string> { "Torun", "Hadera" }; Assert.Equal(2, results.Count()); foreach (dynamic r in results) { var json = (DynamicBlittableJson)r; Assert.Equal(2, json.BlittableJson.Count); Assert.True(json.ContainsKey("City")); Assert.True(json.ContainsKey(Constants.Documents.Metadata.Key)); var city = r.City; Assert.True(cities.Remove(city)); } } } }
public DynamicPathListSegments(Allocator allocator) { this.points = new DynamicArray <Vector2>(0, allocator); this.layouts = new DynamicArray <PathLayout>(0, allocator); this.segments = new DynamicArray <Segment>(0, allocator); }
static ChemicalBlock() { var list = new DynamicArray <IChemicalItem>(new IChemicalItem[] { new Cylinder("H₂"), new Cylinder("O₂"), new Cylinder("CO₂"), new Cylinder("CO"), new Cylinder("Cl₂"), new Cylinder("N₂"), new Cylinder("NH₃"), new Cylinder("NO₂"), new Cylinder("NO"), new Cylinder("N₂O"), new Cylinder("HCl"), new Cylinder("SO₂"), new Cylinder("H₂S"), new Cylinder("HF"), new Cylinder("PH₃"), new Cylinder("C₂H₂"), new Cylinder("(CN)₂"), new Cylinder("Cl₂O"), new Cylinder("ClO₂"), new PurePowder("Na₂O"), new PurePowder("Na₂O₂", Color.LightYellow), new PurePowder("MgO"), new PurePowder("Al₂O₃"), new PurePowder("K₂O"), new PurePowder("CaO"), new PurePowder("Cr₂O₃", Color.DarkGreen), new PurePowder("MnO", Color.Black), new PurePowder("MnO₂", Color.Black), new PurePowder("Fe₂O₃", Color.DarkRed), new PurePowder("Fe₃O₄", Color.Black), new PurePowder("CuO", Color.Black), new PurePowder("Cu₂O", Color.Red), new PurePowder("CuCl"), new PurePowder("ZnO"), new PurePowder("Ag₂O"), new PurePowder("HgO", new Color(227, 23, 13)), new PurePowder("PbO", Color.Yellow), new PurePowder("PbO₂", Color.Black), new PurePowder("CaC₂", new Color(25, 25, 25)), new PurePowder("Mg₃N₂", Color.LightYellow), new PurePowder("SiO₂"), new PurePowder("SiC", new Color(25, 25, 25)), new PurePowder("P₂O₅"), new PurePowder("P₄O₆"), new PurePowder("PCl₃"), new PurePowder("PCl₅"), }); for (int i = 0; i < Cations.Length; i++) { AtomKind atom = Cations[i].Array[0].Atom; Color color = atom == AtomKind.Fe ? Cations[i].Charge == 2 ? Color.LightGreen : Color.DarkRed : atom == AtomKind.Cu ? Color.Blue : Color.White; for (int j = atom == AtomKind.Ag || Cations[i].Count == 2 ? 1 : 0; j < Anions.Length; j++) { list.Add(new PurePowder(Cations[i] + Anions[j], color)); } } list.Add(new PurePowder("H₂(SiO₃)")); list.Add(new PurePowder("Na₂(SiO₃)")); list.Add(new PurePowder("Mg(SiO₃)")); list.Add(new PurePowder("Ca(SiO₃)")); list.Add(new PurePowder("Na(HCO₃)")); list.Add(new PurePowder("Na₂S₂O₃")); list.Add(new PurePowder("Ca(ClO)₂")); list.Add(new PurePowder("Na(ClO₂)")); list.Add(new PurePowder("Mg(ClO₂)₂")); list.Add(new PurePowder("K(ClO₂)")); list.Add(new PurePowder("Ca(ClO₂)₂")); list.Add(new PurePowder("Ba(ClO₂)₂")); list.Add(new PurePowder("Na(ClO₃)")); list.Add(new PurePowder("Mg(ClO₃)₂")); list.Add(new PurePowder("K(ClO₃)")); list.Add(new PurePowder("Ca(ClO₃)₂")); list.Add(new PurePowder("Ba(ClO₃)₂")); list.Add(new PurePowder("Na(ClO₄)")); list.Add(new PurePowder("Mg(ClO₄)₂")); list.Add(new PurePowder("K(ClO₄)")); list.Add(new PurePowder("Ca(ClO₄)₂")); list.Add(new PurePowder("Ba(ClO₄)₂")); list.Add(new PurePowder("Na(CN)")); list.Add(new PurePowder("K(CN)")); list.Add(new PurePowder("Ca(CN)")); list.Add(new PurePowder("K₂(HPO₄)")); list.Add(new PurePowder("K(H₂PO₄)")); list.Add(new PurePowder("Na₂(HPO₄)")); list.Add(new PurePowder("Na(H₂PO₄)")); list.Add(new PurePowder("Na₂Cr₂O₇")); list.Add(new PurePowder("K₂Cr₂O₇")); list.Add(new PurePowder("Cu₃P")); list.Add(new PurePowder("NH₄H")); list.Add(new PurePowder("LiH")); list.Add(new PurePowder("NaH")); list.Add(new PurePowder("MgH₂")); //list.Add(new PurePowder("AlH₃")); list.Add(new PurePowder("KH")); list.Add(new PurePowder("CaH₂")); list.Add(new PurePowder("Na₃P")); //list.Add(new Cylinder("B₂H₆")); list.Add(new Cylinder("C₂H₄")); list.Capacity = list.m_count; Items = list.Array; }
public static IEnumerator GetDynamicArrayIEnumerator(DynamicArray dynamicArray) { finalDynamic = GetDynamicArray(dynamicArray); yield return(new WaitForSeconds(0.1f)); }
public Arrangement(DynamicArray <string> dynamicArray) { SUT = dynamicArray; }
public Grouping(IEnumerable <TransientGroup <T> > members) { Ensure.ArgumentNotNull(members, "members"); _members = new DynamicArray <TransientGroup <T> >(members); }
public ArrangementBuilder WithCapacity(int capacity) { dynamicArray = new DynamicArray <string>(capacity); return(this); }
public void SetUp() { _array = new DynamicArray <string>(); }
public GraphBase(bool directed) { _Nodes = new DynamicArray <Node <TNode> >(_AverageEdges); Directed = directed; }
private void CreateCameraEventsAndBorders(Identity identity) { //Right side List <GameEventCommand> rightBorderEventCommands = new List <GameEventCommand>(); rightBorderEventCommands.Add(new GameEventCommand("Game", null, "PauseLogic", DynamicArray.ObjectArray(1), 0)); rightBorderEventCommands.Add(new GameEventCommand("Camera", null, "MoveBy", DynamicArray.ObjectArray(new Vector2(1280.0f, 0), 2000), 0)); rightBorderEventCommands.Add(new GameEventCommand("Game", null, "ResumeLogic", DynamicArray.ObjectArray(1), 2000)); GameEvent rightBorderEvent = new GameEvent(rightBorderEventCommands); Trigger rightCameraBorder = new Trigger(new Vector2(1330, 400), new Rectangle(0, 0, 50, 2000), "Right Camera Object", GameEventCondition.RightCameraBorderId, identity, this.world, 0, true); GameEventCondition rightCameraBorderCondition = new GameEventCondition(GameEventCondition.RightCameraBorderId, rightBorderEvent); base.AddEventCondition(rightCameraBorderCondition); //Left side List <GameEventCommand> leftBorderEventCommands = new List <GameEventCommand>(); leftBorderEventCommands.Add(new GameEventCommand("Game", null, "PauseLogic", DynamicArray.ObjectArray(1), 0)); leftBorderEventCommands.Add(new GameEventCommand("Camera", null, "MoveBy", DynamicArray.ObjectArray(new Vector2(-1280.0f, 0), 2000), 0)); leftBorderEventCommands.Add(new GameEventCommand("Game", null, "ResumeLogic", DynamicArray.ObjectArray(1), 2000)); GameEvent leftBorderEvent = new GameEvent(leftBorderEventCommands); Trigger leftCameraBorder = new Trigger(new Vector2(-50, 400), new Rectangle(0, 0, 50, 2000), "Left Camera Object", GameEventCondition.LeftCameraBorderId, identity, this.world, 0, true); GameEventCondition leftCameraBorderCondition = new GameEventCondition(GameEventCondition.LeftCameraBorderId, leftBorderEvent); base.AddEventCondition(leftCameraBorderCondition); //Unlock Horizontally GameEvent unlockCameraHorizontallyEvent = new GameEvent(new GameEventCommand("Camera", null, "UnlockHorizontally", DynamicArray.ObjectArray(50), 0)); GameEventCondition unlockCameraHorizontallyCondition = new GameEventCondition(GameEventCondition.UnlockCameraHorizontallyId, unlockCameraHorizontallyEvent); base.AddEventCondition(unlockCameraHorizontallyCondition); //Lock Horizontally GameEvent lockCameraHorizontallyEvent = new GameEvent(new GameEventCommand("Camera", null, "LockHorizontally", DynamicArray.ObjectArray(1), 0)); GameEventCondition lockCameraHorizontallyCondition = new GameEventCondition(GameEventCondition.LockCameraHorizontallyId, lockCameraHorizontallyEvent); base.AddEventCondition(lockCameraHorizontallyCondition); //Unlock Vertically GameEvent unlockCameraVerticallyEvent = new GameEvent(new GameEventCommand("Camera", null, "UnlockVertically", DynamicArray.ObjectArray(50), 0)); GameEventCondition unlockCameraVerticallyCondition = new GameEventCondition(GameEventCondition.UnlockCameraVerticallyId, unlockCameraVerticallyEvent); base.AddEventCondition(unlockCameraVerticallyCondition); //Lock Vertically GameEvent lockCameraVerticallyEvent = new GameEvent(new GameEventCommand("Camera", null, "LockVertically", DynamicArray.ObjectArray(1), 0)); GameEventCondition lockCameraVerticallyCondition = new GameEventCondition(GameEventCondition.LockCameraVerticallyId, lockCameraVerticallyEvent); base.AddEventCondition(lockCameraVerticallyCondition); //Test unlocker //CameraObject co = new CameraObject(1280, 2, new Vector2(640, 300), CameraObject.UnlockWhenPlayerMovesRight, "TestCameraObject"); }
public Grouping(int capacity) { _members = new DynamicArray <TransientGroup <T> >(capacity); }
public ArrangementBuilder WithDefault() { dynamicArray = new DynamicArray <string>(); return(this); }
public void ExceptionOnInsertArrayWithANullLength() { var dynArray = new DynamicArray <int>(2); Assert.Throws <ArgumentException>(() => dynArray.Insert(new int[5, 0], 0, 0, 0)); }
public float CalculateSmoothRisePushBack(BoundingBox normalBox, BoundingBox smoothRiseBox, int axis, DynamicArray <CollisionBox> collisionBoxes, out CollisionBox pushingCollisionBox) { pushingCollisionBox = default(CollisionBox); float num = 0f; for (int i = 0; i < collisionBoxes.Count; i++) { float num2 = (!BlocksManager.Blocks[Terrain.ExtractContents(collisionBoxes.Array[i].BlockValue)].NoSmoothRise) ? CalculateBoxBoxOverlap(ref smoothRiseBox, ref collisionBoxes.Array[i].Box, axis) : CalculateBoxBoxOverlap(ref normalBox, ref collisionBoxes.Array[i].Box, axis); if (MathUtils.Abs(num2) > MathUtils.Abs(num)) { num = num2; pushingCollisionBox = collisionBoxes.Array[i]; } } return(num); }
/// <summary> /// Gets the walkable successors of the specified node. /// </summary> /// <param name="current">The current node.</param> /// <param name="successorArray">The array to fill with successors.</param> /// <returns>All walkable successors of the node.</returns> protected virtual void GetWalkableSuccessors(IPathNode current, DynamicArray <IPathNode> successorArray) { current.GetWalkableNeighbours(successorArray, _unitProps, _cutCorners, _preventDiagonalMoves); }
public static void Insert2D() { const int O_ROWS = 4; const int O_COLS = 2; const int A_ROWS = 4; const int A_COLS = 3; const int B_ROWS = 2; const int B_COLS = 2; // Arrays O, A and B object[,] oarray = ArrayHelper.New().NewArray <object>(O_ROWS, O_COLS).FillWith("O").As <object[, ]>(); object[,] aarray = ArrayHelper.New().NewArray <object>(A_ROWS, A_COLS).FillWith("A").As <object[, ]>(); object[,] barray = ArrayHelper.New().NewArray <object>(B_ROWS, B_COLS).FillWith("B").As <object[, ]>(); // NOTE capacities are set to the minimum to force buffer resize DynamicArray <object> dynArray = new DynamicArray <object>(2, 1, 1); // Insert O at (O_ROW_POS, O_COL_POS) const int O_ROW_POS = 0; const int O_COL_POS = 2; dynArray.Insert(oarray, 0, O_ROW_POS, O_COL_POS); ArrayHelper.Print(dynArray); DynamicArrayAssert.Included(dynArray, oarray, O_ROW_POS, O_COL_POS); DynamicArrayAssert.CountsEqual(dynArray, O_ROW_POS + O_ROWS, O_COL_POS + O_COLS); // Insert A at (A_ROW_POS, A_COL_POS) in dim 0 // Must have: (A_ROW_POS > O_ROW_POS) && (A_ROW_POS < O_ROW_POS + O_ROWS) // in order to insert A "within" O const int A_ROW_POS = 1; const int A_COL_POS = 1; Assert.IsTrue(A_ROW_POS > O_ROW_POS); Assert.IsTrue(A_ROW_POS < O_ROW_POS + O_ROWS); dynArray.Insert(aarray, 0, A_ROW_POS, A_COL_POS); ArrayHelper.Print(dynArray); DynamicArrayAssert.Included(dynArray, aarray, A_ROW_POS, A_COL_POS); DynamicArrayAssert.Included( dynArray, oarray, new int[] { O_ROW_POS, O_COL_POS }, Zero2DIdx, new int[] { A_ROW_POS - O_ROW_POS, O_COLS }); DynamicArrayAssert.Included( dynArray, oarray, new int[] { A_ROW_POS + A_ROWS, O_COL_POS }, new int[] { A_ROW_POS - O_ROW_POS, 0 }, new int[] { O_ROWS, O_COLS }); // Insert B at (B_ROW_POS, B_COL_POS) in dim 1 const int B_ROW_POS = 2; const int B_COL_POS = 1; dynArray.Insert(barray, 1, B_ROW_POS, B_COL_POS); ArrayHelper.Print(dynArray); DynamicArrayAssert.Included(dynArray, barray, B_ROW_POS, B_COL_POS); DynamicArrayAssert.Included( dynArray, aarray, new int[] { B_ROW_POS, B_COL_POS + B_COLS }, new int[] { B_ROW_POS - A_ROW_POS, B_COL_POS - A_COL_POS }, new int[] { B_ROW_POS - A_ROW_POS + B_ROWS, A_COLS }); }
public void FindSneakCollisionBoxes(Vector3 position, Vector2 overhang, DynamicArray <CollisionBox> result) { int num = Terrain.ToCell(position.X); int num2 = Terrain.ToCell(position.Y); int num3 = Terrain.ToCell(position.Z); if (BlocksManager.Blocks[m_subsystemTerrain.Terrain.GetCellContents(num, num2 - 1, num3)].IsCollidable) { return; } bool num4 = position.X < (float)num + 0.5f; bool flag = position.Z < (float)num3 + 0.5f; CollisionBox item; if (num4) { if (flag) { bool isCollidable = BlocksManager.Blocks[m_subsystemTerrain.Terrain.GetCellContents(num, num2 - 1, num3 - 1)].IsCollidable; bool isCollidable2 = BlocksManager.Blocks[m_subsystemTerrain.Terrain.GetCellContents(num - 1, num2 - 1, num3)].IsCollidable; bool isCollidable3 = BlocksManager.Blocks[m_subsystemTerrain.Terrain.GetCellContents(num - 1, num2 - 1, num3 - 1)].IsCollidable; if ((isCollidable && !isCollidable2) || ((!isCollidable && !isCollidable2) & isCollidable3)) { item = new CollisionBox { Box = new BoundingBox(new Vector3(num, num2, (float)num3 + overhang.Y), new Vector3(num + 1, num2 + 1, num3 + 1)), BlockValue = 0 }; result.Add(item); } if ((!isCollidable && isCollidable2) || ((!isCollidable && !isCollidable2) & isCollidable3)) { item = new CollisionBox { Box = new BoundingBox(new Vector3((float)num + overhang.X, num2, num3), new Vector3(num + 1, num2 + 1, num3 + 1)), BlockValue = 0 }; result.Add(item); } if (isCollidable && isCollidable2) { item = new CollisionBox { Box = new BoundingBox(new Vector3((float)num + overhang.X, num2, (float)num3 + overhang.Y), new Vector3(num + 1, num2 + 1, num3 + 1)), BlockValue = 0 }; result.Add(item); } } else { bool isCollidable4 = BlocksManager.Blocks[m_subsystemTerrain.Terrain.GetCellContents(num, num2 - 1, num3 + 1)].IsCollidable; bool isCollidable5 = BlocksManager.Blocks[m_subsystemTerrain.Terrain.GetCellContents(num - 1, num2 - 1, num3)].IsCollidable; bool isCollidable6 = BlocksManager.Blocks[m_subsystemTerrain.Terrain.GetCellContents(num - 1, num2 - 1, num3 + 1)].IsCollidable; if ((isCollidable4 && !isCollidable5) || ((!isCollidable4 && !isCollidable5) & isCollidable6)) { item = new CollisionBox { Box = new BoundingBox(new Vector3(num, num2, num3), new Vector3(num + 1, num2 + 1, (float)(num3 + 1) - overhang.Y)), BlockValue = 0 }; result.Add(item); } if ((!isCollidable4 && isCollidable5) || ((!isCollidable4 && !isCollidable5) & isCollidable6)) { item = new CollisionBox { Box = new BoundingBox(new Vector3((float)num + overhang.X, num2, num3), new Vector3(num + 1, num2 + 1, num3 + 1)), BlockValue = 0 }; result.Add(item); } if (isCollidable4 && isCollidable5) { item = new CollisionBox { Box = new BoundingBox(new Vector3((float)num + overhang.X, num2, num3), new Vector3(num + 1, num2 + 1, (float)(num3 + 1) - overhang.Y)), BlockValue = 0 }; result.Add(item); } } } else if (flag) { bool isCollidable7 = BlocksManager.Blocks[m_subsystemTerrain.Terrain.GetCellContents(num, num2 - 1, num3 - 1)].IsCollidable; bool isCollidable8 = BlocksManager.Blocks[m_subsystemTerrain.Terrain.GetCellContents(num + 1, num2 - 1, num3)].IsCollidable; bool isCollidable9 = BlocksManager.Blocks[m_subsystemTerrain.Terrain.GetCellContents(num + 1, num2 - 1, num3 - 1)].IsCollidable; if ((isCollidable7 && !isCollidable8) || ((!isCollidable7 && !isCollidable8) & isCollidable9)) { item = new CollisionBox { Box = new BoundingBox(new Vector3(num, num2, (float)num3 + overhang.Y), new Vector3(num + 1, num2 + 1, num3 + 1)), BlockValue = 0 }; result.Add(item); } if ((!isCollidable7 && isCollidable8) || ((!isCollidable7 && !isCollidable8) & isCollidable9)) { item = new CollisionBox { Box = new BoundingBox(new Vector3(num, num2, num3), new Vector3((float)(num + 1) - overhang.X, num2 + 1, num3 + 1)), BlockValue = 0 }; result.Add(item); } if (isCollidable7 && isCollidable8) { item = new CollisionBox { Box = new BoundingBox(new Vector3(num, num2, (float)num3 + overhang.Y), new Vector3((float)(num + 1) - overhang.X, num2 + 1, num3 + 1)), BlockValue = 0 }; result.Add(item); } } else { bool isCollidable10 = BlocksManager.Blocks[m_subsystemTerrain.Terrain.GetCellContents(num, num2 - 1, num3 + 1)].IsCollidable; bool isCollidable11 = BlocksManager.Blocks[m_subsystemTerrain.Terrain.GetCellContents(num + 1, num2 - 1, num3)].IsCollidable; bool isCollidable12 = BlocksManager.Blocks[m_subsystemTerrain.Terrain.GetCellContents(num + 1, num2 - 1, num3 + 1)].IsCollidable; if ((isCollidable10 && !isCollidable11) || ((!isCollidable10 && !isCollidable11) & isCollidable12)) { item = new CollisionBox { Box = new BoundingBox(new Vector3(num, num2, num3), new Vector3(num + 1, num2 + 1, (float)(num3 + 1) - overhang.Y)), BlockValue = 0 }; result.Add(item); } if ((!isCollidable10 && isCollidable11) || ((!isCollidable10 && !isCollidable11) & isCollidable12)) { item = new CollisionBox { Box = new BoundingBox(new Vector3(num, num2, num3), new Vector3((float)(num + 1) - overhang.X, num2 + 1, num3 + 1)), BlockValue = 0 }; result.Add(item); } if (isCollidable10 && isCollidable11) { item = new CollisionBox { Box = new BoundingBox(new Vector3(num, num2, num3), new Vector3((float)(num + 1) - overhang.X, num2 + 1, (float)(num3 + 1) - overhang.Y)), BlockValue = 0 }; result.Add(item); } } }
public static void Resize2D() { // Should have B_COLS < A_COLS const int A_ROWS = 4; const int A_COLS = 3; const int B_ROWS = 5; const int B_COLS = 2; // Arrays O, A and B object[,] arrA = ArrayHelper.New().NewArray <object>(A_ROWS, A_COLS).FillWith("A").As <object[, ]>(); object[,] arrB = ArrayHelper.New().NewArray <object>(B_ROWS, B_COLS).FillWith("B").As <object[, ]>(); // NOTE capacities are set to the minimum to force buffer resize DynamicArray <object> dynArray = new DynamicArray <object>(2, 1, 1); // Insert B at 0,0 dynArray.Insert(arrB, 0, 0, 0); ArrayHelper.Print(dynArray); DynamicArrayAssert.AreElementsEqual(dynArray, arrB); // Insert A right before B in dim 1 dynArray.Insert(arrA, 0, 0, 0); ArrayHelper.Print(dynArray); DynamicArrayAssert.Included(dynArray, arrA, 0, 0); DynamicArrayAssert.Included(dynArray, arrB, A_ROWS, 0); DynamicArrayAssert.CountsEqual(dynArray, A_ROWS + B_ROWS, A_COLS); // Remove B_ROWS lines and add NCols columns const int NCols = 5; dynArray.Resize(A_ROWS, A_COLS + NCols); ArrayHelper.Print(dynArray); DynamicArrayAssert.Included(dynArray, arrA, 0, 0); DynamicArrayAssert.AreElementsDefault(dynArray, new int[] { A_ROWS, NCols }, 0, A_COLS); DynamicArrayAssert.CountsEqual(dynArray, A_ROWS, A_COLS + NCols); // Add NRows rows const int NRows = 10; dynArray.ResizeDim(0, A_ROWS + NRows); ArrayHelper.Print(dynArray); DynamicArrayAssert.CountsEqual(dynArray, A_ROWS + NRows, A_COLS + NCols); DynamicArrayAssert.Included(dynArray, arrA, 0, 0); DynamicArrayAssert.AreElementsDefault(dynArray, new int[] { NRows, A_COLS + NCols }, A_ROWS, 0); DynamicArrayAssert.AreElementsDefault(dynArray, new int[] { A_ROWS + NRows, NCols }, 0, A_COLS); // Shrink to (NFewRows, NFewCols) const int NFewCols = 2; const int NFewRows = 3; dynArray.Resize(NFewRows, NFewCols); ArrayHelper.Print(dynArray); DynamicArrayAssert.Included(dynArray, arrA, Zero2DIdx, Zero2DIdx, new int[] { NFewRows, NFewCols }); // Enlarge to (NManyRows, NManyCols) const int NManyRows = 10; const int NManyCols = 7; dynArray.Resize(NManyRows, NManyCols); ArrayHelper.Print(dynArray); DynamicArrayAssert.Included(dynArray, arrA, Zero2DIdx, Zero2DIdx, new int[] { NFewRows, NFewCols }); DynamicArrayAssert.AreElementsDefault(dynArray, new[] { NManyRows, NManyCols - NFewCols }, 0, NFewCols); DynamicArrayAssert.AreElementsDefault(dynArray, new[] { NManyRows - NFewRows, NFewCols }, NFewRows, 0); }
/// <summary> /// Creates a new instance of <see cref="RuntimeScopeStack"/>. /// </summary> /// <param name="initialCapacity">The initial capacity of the stack.</param> /// <param name="parentScope">The scope stack which the new scope stack should extend, /// or null if the new scope stack should not extend an enclosing scope.</param> public RuntimeScopeStack(int initialCapacity = 0, RuntimeScopeStack?parentScope = null) { m_items = new DynamicArray <Item>(initialCapacity); m_parentScope = parentScope; }
public static Dynamic[] GetDynamicArray(DynamicArray dynamicArray) { Dynamic[] dynamics = new Dynamic[0]; return(dynamics); }
public DynamicPlainShape(NativeArray <IntVector> points, NativeArray <PathLayout> layouts) { this.points = new DynamicArray <IntVector>(points); this.layouts = new DynamicArray <PathLayout>(layouts); }
public override void GenerateTerrainVertices(BlockGeometryGenerator generator, TerrainGeometry geometry, int value, int x, int y, int z) { TerrainGeometrySubset[] alphaTestSubsetsByFace = geometry.AlphaTestSubsetsByFace; int data = Terrain.ExtractData(value); int value2 = (y + 1 < 256) ? generator.Terrain.GetCellValueFast(x, y + 1, z) : 0; int num = Terrain.ExtractContents(value2); int data2 = Terrain.ExtractData(value2); int value3 = (y + 2 < 256) ? generator.Terrain.GetCellValueFast(x, y + 2, z) : 0; int num2 = Terrain.ExtractContents(value3); int data3 = Terrain.ExtractData(value3); if (HasFireOnFace(data, 0)) { int value4 = (y + 1 < 256) ? generator.Terrain.GetCellValueFast(x, y + 1, z + 1) : 0; int num3 = Terrain.ExtractContents(value4); int data4 = Terrain.ExtractData(value4); int value5 = (y + 2 < 256) ? generator.Terrain.GetCellValueFast(x, y + 2, z + 1) : 0; int num4 = Terrain.ExtractContents(value5); int data5 = Terrain.ExtractData(value5); int num5 = DefaultTextureSlot; if ((num == 104 && HasFireOnFace(data2, 0)) || (num3 == 104 && HasFireOnFace(data4, 2))) { num5 += 16; if ((num2 == 104 && HasFireOnFace(data3, 0)) || (num4 == 104 && HasFireOnFace(data5, 2))) { num5 += 16; } } DynamicArray <TerrainVertex> vertices = alphaTestSubsetsByFace[0].Vertices; DynamicArray <ushort> indices = alphaTestSubsetsByFace[0].Indices; int count = vertices.Count; vertices.Count += 4; BlockGeometryGenerator.SetupLitCornerVertex(x, y, z + 1, Color.White, num5, 0, ref vertices.Array[count]); BlockGeometryGenerator.SetupLitCornerVertex(x + 1, y, z + 1, Color.White, num5, 1, ref vertices.Array[count + 1]); BlockGeometryGenerator.SetupLitCornerVertex(x + 1, y + 1, z + 1, Color.White, num5, 2, ref vertices.Array[count + 2]); BlockGeometryGenerator.SetupLitCornerVertex(x, y + 1, z + 1, Color.White, num5, 3, ref vertices.Array[count + 3]); indices.Add((ushort)count); indices.Add((ushort)(count + 1)); indices.Add((ushort)(count + 2)); indices.Add((ushort)(count + 2)); indices.Add((ushort)(count + 1)); indices.Add((ushort)count); indices.Add((ushort)(count + 2)); indices.Add((ushort)(count + 3)); indices.Add((ushort)count); indices.Add((ushort)count); indices.Add((ushort)(count + 3)); indices.Add((ushort)(count + 2)); } if (HasFireOnFace(data, 1)) { int value6 = (y + 1 < 256) ? generator.Terrain.GetCellValueFast(x + 1, y + 1, z) : 0; int num6 = Terrain.ExtractContents(value6); int data6 = Terrain.ExtractData(value6); int value7 = (y + 2 < 256) ? generator.Terrain.GetCellValueFast(x + 1, y + 2, z) : 0; int num7 = Terrain.ExtractContents(value7); int data7 = Terrain.ExtractData(value7); int num8 = DefaultTextureSlot; if ((num == 104 && HasFireOnFace(data2, 1)) || (num6 == 104 && HasFireOnFace(data6, 3))) { num8 += 16; if ((num2 == 104 && HasFireOnFace(data3, 1)) || (num7 == 104 && HasFireOnFace(data7, 3))) { num8 += 16; } } DynamicArray <TerrainVertex> vertices2 = alphaTestSubsetsByFace[1].Vertices; DynamicArray <ushort> indices2 = alphaTestSubsetsByFace[1].Indices; int count2 = vertices2.Count; vertices2.Count += 4; BlockGeometryGenerator.SetupLitCornerVertex(x + 1, y, z, Color.White, num8, 0, ref vertices2.Array[count2]); BlockGeometryGenerator.SetupLitCornerVertex(x + 1, y + 1, z, Color.White, num8, 3, ref vertices2.Array[count2 + 1]); BlockGeometryGenerator.SetupLitCornerVertex(x + 1, y + 1, z + 1, Color.White, num8, 2, ref vertices2.Array[count2 + 2]); BlockGeometryGenerator.SetupLitCornerVertex(x + 1, y, z + 1, Color.White, num8, 1, ref vertices2.Array[count2 + 3]); indices2.Add((ushort)count2); indices2.Add((ushort)(count2 + 1)); indices2.Add((ushort)(count2 + 2)); indices2.Add((ushort)(count2 + 2)); indices2.Add((ushort)(count2 + 1)); indices2.Add((ushort)count2); indices2.Add((ushort)(count2 + 2)); indices2.Add((ushort)(count2 + 3)); indices2.Add((ushort)count2); indices2.Add((ushort)count2); indices2.Add((ushort)(count2 + 3)); indices2.Add((ushort)(count2 + 2)); } if (HasFireOnFace(data, 2)) { int value8 = (y + 1 < 256) ? generator.Terrain.GetCellValueFast(x, y + 1, z - 1) : 0; int num9 = Terrain.ExtractContents(value8); int data8 = Terrain.ExtractData(value8); int value9 = (y + 2 < 256) ? generator.Terrain.GetCellValueFast(x, y + 2, z - 1) : 0; int num10 = Terrain.ExtractContents(value9); int data9 = Terrain.ExtractData(value9); int num11 = DefaultTextureSlot; if ((num == 104 && HasFireOnFace(data2, 2)) || (num9 == 104 && HasFireOnFace(data8, 0))) { num11 += 16; if ((num2 == 104 && HasFireOnFace(data3, 2)) || (num10 == 104 && HasFireOnFace(data9, 0))) { num11 += 16; } } DynamicArray <TerrainVertex> vertices3 = alphaTestSubsetsByFace[2].Vertices; DynamicArray <ushort> indices3 = alphaTestSubsetsByFace[2].Indices; int count3 = vertices3.Count; vertices3.Count += 4; BlockGeometryGenerator.SetupLitCornerVertex(x, y, z, Color.White, num11, 0, ref vertices3.Array[count3]); BlockGeometryGenerator.SetupLitCornerVertex(x + 1, y, z, Color.White, num11, 1, ref vertices3.Array[count3 + 1]); BlockGeometryGenerator.SetupLitCornerVertex(x + 1, y + 1, z, Color.White, num11, 2, ref vertices3.Array[count3 + 2]); BlockGeometryGenerator.SetupLitCornerVertex(x, y + 1, z, Color.White, num11, 3, ref vertices3.Array[count3 + 3]); indices3.Add((ushort)count3); indices3.Add((ushort)(count3 + 2)); indices3.Add((ushort)(count3 + 1)); indices3.Add((ushort)(count3 + 1)); indices3.Add((ushort)(count3 + 2)); indices3.Add((ushort)count3); indices3.Add((ushort)(count3 + 2)); indices3.Add((ushort)count3); indices3.Add((ushort)(count3 + 3)); indices3.Add((ushort)(count3 + 3)); indices3.Add((ushort)count3); indices3.Add((ushort)(count3 + 2)); } if (!HasFireOnFace(data, 3)) { return; } int value10 = (y + 1 < 256) ? generator.Terrain.GetCellValueFast(x - 1, y + 1, z) : 0; int num12 = Terrain.ExtractContents(value10); int data10 = Terrain.ExtractData(value10); int value11 = (y + 2 < 256) ? generator.Terrain.GetCellValueFast(x - 1, y + 2, z) : 0; int num13 = Terrain.ExtractContents(value11); int data11 = Terrain.ExtractData(value11); int num14 = DefaultTextureSlot; if ((num == 104 && HasFireOnFace(data2, 3)) || (num12 == 104 && HasFireOnFace(data10, 1))) { num14 += 16; if ((num2 == 104 && HasFireOnFace(data3, 3)) || (num13 == 104 && HasFireOnFace(data11, 1))) { num14 += 16; } } DynamicArray <TerrainVertex> vertices4 = alphaTestSubsetsByFace[3].Vertices; DynamicArray <ushort> indices4 = alphaTestSubsetsByFace[3].Indices; int count4 = vertices4.Count; vertices4.Count += 4; BlockGeometryGenerator.SetupLitCornerVertex(x, y, z, Color.White, num14, 0, ref vertices4.Array[count4]); BlockGeometryGenerator.SetupLitCornerVertex(x, y + 1, z, Color.White, num14, 3, ref vertices4.Array[count4 + 1]); BlockGeometryGenerator.SetupLitCornerVertex(x, y + 1, z + 1, Color.White, num14, 2, ref vertices4.Array[count4 + 2]); BlockGeometryGenerator.SetupLitCornerVertex(x, y, z + 1, Color.White, num14, 1, ref vertices4.Array[count4 + 3]); indices4.Add((ushort)count4); indices4.Add((ushort)(count4 + 2)); indices4.Add((ushort)(count4 + 1)); indices4.Add((ushort)(count4 + 1)); indices4.Add((ushort)(count4 + 2)); indices4.Add((ushort)count4); indices4.Add((ushort)(count4 + 2)); indices4.Add((ushort)count4); indices4.Add((ushort)(count4 + 3)); indices4.Add((ushort)(count4 + 3)); indices4.Add((ushort)count4); indices4.Add((ushort)(count4 + 2)); }
public DynamicPlainShape(NativeSlice <IntVector> points, bool isClockWise, Allocator allocator) { this.points = new DynamicArray <IntVector>(points, allocator); this.layouts = new DynamicArray <PathLayout>(1, allocator); this.layouts.Add(new PathLayout(0, points.Length, isClockWise)); }
public DynamicPathListSegments(int minimumPointsCapacity, int minimumLayoutsCapacity, int minimumSegmentsCapacity, Allocator allocator) { this.points = new DynamicArray <Vector2>(minimumPointsCapacity, allocator); this.layouts = new DynamicArray <PathLayout>(minimumLayoutsCapacity, allocator); this.segments = new DynamicArray <Segment>(minimumSegmentsCapacity, allocator); }
public DynamicPlainShape(int pointsCapacity, int layoutsCapacity, Allocator allocator) { this.points = new DynamicArray <IntVector>(pointsCapacity, allocator); this.layouts = new DynamicArray <PathLayout>(layoutsCapacity, allocator); }
public void EmptyArrayToString() { DynamicArray array = new DynamicArray(); Assert.AreEqual("[]", array.ToString()); }
public DynamicPlainShape(Allocator allocator) { this.points = new DynamicArray <IntVector>(allocator); this.layouts = new DynamicArray <PathLayout>(allocator); }
public DynamicPlainShapeList(int minimumPointsCapacity, int minimumLayoutsCapacity, int minimumSegmentsCapacity, Allocator allocator) { this.points = new DynamicArray <IntVector>(minimumPointsCapacity, allocator); this.layouts = new DynamicArray <PathLayout>(minimumLayoutsCapacity, allocator); this.segments = new DynamicArray <Segment>(minimumSegmentsCapacity, allocator); }
internal Enumerator(DynamicArray <T> list) { this.list = list; index = 0; Current = default(T); }