protected DeadlockFinder(Level level, Array2D<bool> simpleDeadlockMap) { this.level = level; this.simpleDeadlockMap = simpleDeadlockMap; Initialize(); }
public DijkstraPathFinder(Level level) : base(level) { data = level.Data; rowLimit = level.Height - 1; insideCoordinates = level.InsideCoordinates; int m = level.Height * level.Width; q = new FixedQueue<Vertex>(m); // Initialize the vertex map. vertexMap = new Array2D<Vertex>(level.Height, level.Width); foreach (Coordinate2D coord in level.Coordinates) { Vertex vertex = new Vertex(coord.Row, coord.Column); vertex.Distance = DefaultInaccessible; vertex.Visited = true; vertexMap[coord.Row, coord.Column] = vertex; } // Calculate the neighbors of each coordinate. foreach (Coordinate2D coord in level.InsideCoordinates) { Vertex vertex = vertexMap[coord]; List<Vertex> neighbors = new List<Vertex>(); foreach (Coordinate2D neighbor in coord.FourNeighbors) { if (level.IsFloor(neighbor)) { neighbors.Add(vertexMap[neighbor]); } } vertex.Neighbors = neighbors.ToArray(); } }
void Awake() { tiles_ = new Array2D<char>( size_ ); colors_ = new Array2D<Color32>( size_ ); mesh_ = GetComponent<FontMesh>(); }
protected ArrayPathFinder(Level level) : base(level) { data = level.Data; boxCoordinates = level.BoxCoordinates; boxCount = boxCoordinates.Length; n = level.Width; m = level.Height * level.Width; q = new FixedQueue<int>(m); firstInside = -1; lastInside = -1; neighborMap = new int[m][]; foreach (Coordinate2D coord in level.InsideCoordinates) { lastInside = coord.Row * n + coord.Column; if (firstInside == -1) { firstInside = lastInside; } List<int> neighbors = new List<int>(); foreach (Coordinate2D neighbor in coord.FourNeighbors) { if (level.IsFloor(neighbor)) { neighbors.Add(neighbor.Row * n + neighbor.Column); } } neighborMap[coord.Row * n + coord.Column] = neighbors.ToArray(); } insideCount = lastInside - firstInside + 1; }
public WorkingEntry(bool deadlocked, Array2D<bool> map, Coordinate2D coordinate, Coordinate2D[] coordinates) { Deadlocked = deadlocked; Map = map; Coordinate = coordinate; Coordinates = coordinates; }
public TriangleMeshActor(Game game, Vector3 position, float scale, Texture2D heightMap, float[,] heightData) : base(game) { this.position = position; this.scale = new Vector3(1,1,1); _body = new Body(); _body.MoveTo(position, Matrix.Identity); Array2D field = new Array2D(heightData.GetUpperBound(0), heightData.GetUpperBound(1)); int upperZ = heightData.GetUpperBound(1); for (int x = 0; x < heightData.GetUpperBound(0); x++) { for (int z = 0; z < upperZ; z++) { field.SetAt(x, z, heightData[x, upperZ - 1 - z]); } } _skin = new CollisionSkin(null); float X = heightMap.Width / 2 * scale; float Z = heightMap.Height / 2 * scale; _skin.AddPrimitive(new Heightmap(field, X, -Z, scale, scale), new MaterialProperties(0.7f, 0.7f, 0.6f)); _skin.ExternalData = this; PhysicsSystem.CurrentPhysicsSystem.CollisionSystem.AddCollisionSkin(_skin); }
public Entry(bool deadlocked, Array2D<bool> map, Coordinate2D coordinate, Coordinate2D[] coordinates, Entry[] entries) { Deadlocked = deadlocked; Map = map; Coordinate = coordinate; Coordinates = coordinates; Entries = entries; }
public IncrementalRegionFinder(Level level) : base(level) { this.data = level.Data; this.pathFinder = new IncrementalAnyPathFinder(level); this.rowLimit = level.Height - 1; this.accessibleSquaresLimit = level.InsideSquares - level.Boxes; }
public BruteForceRegionFinder(Level level) : base(level) { this.pathFinder = PathFinder.CreateInstance(level); // Initialize map of coordinates already tried. tried = new Array2D<bool>(level.Height, level.Width); }
protected SubsetSolver(Level level, bool incremental) { this.level = level; pathFinder = PathFinder.CreateInstance(level,false, incremental); regionFinder = RegionFinder.CreateInstance(level); sokobanMap = new Array2D<bool>(level.Height, level.Width); cancelInfo = new CancelInfo(); }
public static void DrawTogglesGUILayout(IntVector2 size, List<IntVector2> points = null) { if (toggleStates_ == null) toggleStates_ = new Array2D<bool>(size); if( toggleStates_.size_ != size ) { // var oldStates = new Array2D<bool>(toggleStates_); toggleStates_ = new Array2D<bool>(size); //toggleStates_.Merge(oldStates); } var style = new GUIStyle(EditorStyles.toolbarButton); style.fixedWidth = 20; style.fixedHeight = 20; GUILayout.BeginVertical(); for (int y = 0; y < size.y; ++y) { GUILayout.BeginHorizontal(); for (int x = 0; x < size.x; ++x) { var pos = new IntVector2(x, y); var toggle = toggleStates_[pos]; if( toggle ) { var oldColor = GUI.color; GUI.color = Color.blue; toggleStates_[pos] = GUILayout.Toggle(toggleStates_[pos], GUIContent.none, style); GUI.color = oldColor; } else { toggleStates_[pos] = GUILayout.Toggle(toggleStates_[pos], GUIContent.none, style); } } GUILayout.EndHorizontal(); } GUILayout.EndVertical(); }
private Level GenerateLevelBlob(State state, int size, Array2D<Cell> designData, Array2D<bool> designFixed, out int designRow, out int designColumn) { // Inflate size for extra cells to be subtracted. int blobSize = size * (density + 100) / 100; // Create larger work array and corresponding fixed map. Array2D<Cell> array = new Array2D<Cell>(2 * size, 2 * size); array.SetAll(Cell.Outside); Array2D<bool> arrayFixed = new Array2D<bool>(array.Height, array.Width); // Adjust design data so that outside or undefined cells are empty. Array2D<Cell> designDataCopy = new Array2D<Cell>(designData); designDataCopy.Replace(Cell.Outside, Cell.Empty); designDataCopy.Replace(Cell.Undefined, Cell.Empty); // Copy design into middle of work array. designRow = size; designColumn = size; designDataCopy.CopyTo(array, designRow + 1, designColumn + 1, 1, 1, designData.Height - 2, designData.Width - 2); designFixed.CopyTo(arrayFixed, designRow + 1, designColumn + 1, 1, 1, designData.Height - 2, designData.Width - 2); // Set intial boundaries. int rowMin = array.Height; int colMin = array.Width; int rowMax = -1; int colMax = -1; int count = 0; foreach (Coordinate2D coord in array.Coordinates) { if (!Level.IsOutside(array[coord])) { rowMin = Math.Min(rowMin, coord.Row); colMin = Math.Min(colMin, coord.Column); rowMax = Math.Max(rowMax, coord.Row); colMax = Math.Max(colMax, coord.Column); count++; } } while (count < blobSize) { // Choose an edge at random. int edge = state.Random.Next(4); int row = 0; int column = 0; int limit = 0; int hIncr = 0; int vIncr = 0; switch (edge) { case 0: row = rowMin - 1; column = colMin + state.Random.Next(colMax - colMin + 1); limit = rowMax - rowMin + 1; vIncr = 1; hIncr = 0; break; case 1: row = rowMax + 1; column = colMin + state.Random.Next(colMax - colMin + 1); limit = rowMax - rowMin + 1; vIncr = -1; hIncr = 0; break; case 2: row = rowMin + state.Random.Next(rowMax - rowMin + 1); column = colMin - 1; limit = colMax - colMin + 1; vIncr = 0; hIncr = 1; break; case 3: row = rowMin + state.Random.Next(rowMax - rowMin + 1); column = colMax + 1; limit = colMax - colMin + 1; vIncr = 0; hIncr = -1; break; } // Search along a line until we hit a empty or fixed cell. bool found = false; for (int i = 0; i < limit; i++) { if (array[row + vIncr, column + hIncr] != Cell.Outside || arrayFixed[row + vIncr, column + hIncr]) { if (!arrayFixed[row, column]) { found = true; } break; } row += vIncr; column += hIncr; } // If we didn't find anything, try again. if (!found) { continue; } // Don't allow the level to grow outside the array. if (row < 1 || row >= array.Height - 1 || column < 1 || column >= array.Width - 1) { continue; } // Add the new square and update the boundaries. array[row, column] = Cell.Empty; rowMin = Math.Min(rowMin, row); colMin = Math.Min(colMin, column); rowMax = Math.Max(rowMax, row); colMax = Math.Max(colMax, column); count++; } int attemptsLeft = 2 * (count - size); while (count > size && attemptsLeft > 0) { // Choose a new square at random. int row = rowMin + state.Random.Next(rowMax - rowMin + 1); int column = colMin + state.Random.Next(colMax - colMin + 1); Coordinate2D coord = new Coordinate2D(row, column); if (!array.IsValid(coord)) { continue; } // Avoid existing walls and outside areas. if (!Level.IsInside(array[coord])) { continue; } // We might get into an infinite loop. attemptsLeft--; // Avoid fixed cells. if (arrayFixed[coord]) { continue; } // Avoid cells on the perimeter. bool isAdjacent = false; foreach (Coordinate2D neighbor in coord.EightNeighbors) { if (array[neighbor] == Cell.Outside) { isAdjacent = true; break; } } if (isAdjacent) { continue; } // Remove the cell. array[coord] = Cell.Wall; count--; } // Extract the constructed level. Array2D<Cell> subarray = array.GetSubarray(rowMin - 1, colMin - 1, rowMax - rowMin + 3, colMax - colMin + 3); subarray.Replace(Cell.Outside, Cell.Wall); Level level = new Level(subarray); // Adjust design coordinate. designRow -= rowMin - 1; designColumn -= colMin - 1; return level; }
/// <summary> /// Copy constructor. /// </summary> /// <param name="that"></param> public DistributionArray2D(Array2D <T> that) : base(that) { }
public static WriteableBitmap ToWriteableBitmap <T>( this Array2D <T> array, int dpiX, int dpiY) where T : struct { array.ThrowIfDisposed(); var width = array.Columns; var height = array.Rows; var rgbReverse = false; var format = new PixelFormat(); var channels = 0; switch (array.ImageType) { case ImageTypes.RgbPixel: // Dlib RgbPixel data // R,G,B,R,G,B,... // But .NET Bitmap data // B,G,R,B,G,R,... rgbReverse = true; format = PixelFormats.Bgr24; channels = 3; break; case ImageTypes.BgrPixel: // Dlib RgbPixel data // R,G,B,R,G,B,... // But .NET Bitmap data // B,G,R,B,G,R,... format = PixelFormats.Bgr24; channels = 3; break; case ImageTypes.RgbAlphaPixel: // Dlib RgbAlphaPixel data // R,G,B,A,R,G,B,A,,... // But .NET Bitmap data // B,G,R,A,B,G,R,A,... rgbReverse = true; format = PixelFormats.Bgra32; channels = 4; break; case ImageTypes.UInt8: case ImageTypes.Int32: case ImageTypes.UInt16: case ImageTypes.Int16: case ImageTypes.HsiPixel: case ImageTypes.Float: case ImageTypes.Double: case ImageTypes.Matrix: throw new NotSupportedException(); } var bitmap = new WriteableBitmap(width, height, dpiX, dpiY, format, null); ToManaged(array.ImageType, array.NativePtr, bitmap, rgbReverse, channels); return(bitmap); }
public static void ThrowsExceptionIfDestIndexIsOutOfBounds <T>( Array2D <T> destination, Index2D destIndex) => Assert.Throws <ArgumentOutOfRangeException>( () => new List2D <T>(0, 0).CopyTo( destination, new Bounds2D(), destIndex));
public static void ThrowsExceptionIfDestArrayCannotAccommodateAllElements <T>( List2D <T> source, Array2D <T> destination) => Assert.Throws <ArgumentException>(() => source.CopyTo(destination));
private static void Main() { using (var img = new Array2D <byte>(400, 400)) using (var ht = new DlibDotNet.HoughTransform(300)) using (var win = new ImageWindow()) using (var win2 = new ImageWindow()) { var angle1 = 0d; var angle2 = 0d; while (true) { angle1 += Math.PI / 130; angle2 += Math.PI / 400; var rect = img.Rect; var cent = rect.Center; var arc = Point.Rotate(cent, cent + new Point(90, 0), angle1 * 180 / Math.PI); var tmp2 = arc + new Point(500, 0); var tmp3 = arc - new Point(500, 0); var l = Point.Rotate(arc, tmp2, angle2 * 180 / Math.PI); var r = Point.Rotate(arc, tmp3, angle2 * 180 / Math.PI); Dlib.AssignAllPpixels(img, 0); Dlib.DrawLine(img, l, r, 255); using (var himg = new Array2D <int>()) { var offset = new Point(50, 50); var hrect = Dlib.GetRect(ht); var box = Rectangle.Translate(hrect, offset); // Now let's compute the hough transform for a subwindow in the image. In // particular, we run it on the 300x300 subwindow with an upper left corner at the // pixel point(50,50). The output is stored in himg. ht.Operator(img, box, himg); // Now that we have the transformed image, the Hough image pixel with the largest // value should indicate where the line is. So we find the coordinates of the // largest pixel: using (var mat = Dlib.Mat(himg)) { var p = Dlib.MaxPoint(mat); // And then ask the ht object for the line segment in the original image that // corresponds to this point in Hough transform space. var line = ht.GetLine(p); // Finally, let's display all these things on the screen. We copy the original // input image into a color image and then draw the detected line on top in red. using (var temp = new Array2D <RgbPixel>()) { Dlib.AssignImage(img, temp); var p1 = line.Item1 + offset; var p2 = line.Item2 + offset; Dlib.DrawLine(temp, p1, p2, new RgbPixel { Red = 255 }); win.ClearOverlay(); win.SetImage(temp); // Also show the subwindow we ran the Hough transform on as a green box. You will // see that the detected line is exactly contained within this box and also // overlaps the original line. win.AddOverlay(box, new RgbPixel { Green = 255 }); using (var jet = Dlib.Jet(himg)) win2.SetImage(jet); } } } } } }
//-------------------------------------------------------------------------------------------------------- /// <summary> /// OpenCVとDlib68を併用した推定。Dlib68より高速だが、顔の検出率は低め。 /// </summary> /// <param name="threadNo">走らせるスレッド番号</param> /// <param name="est_pos">推定した位置</param> /// <param name="est_rot">推定した回転</param> /// <returns>推定できたか</returns> private bool Mixed(int threadNo, out Vector3 est_pos, out Vector3 est_rot) { Mat image_r = new Mat(); Mat image = new Mat(); try { lock (lock_capture) { image_r = caputure.Read(); if (image_r.Data == null) { throw new NullReferenceException("capture is null"); } if (ptr.Contains(image_r.Data)) { throw new InvalidOperationException("taken same data"); } else { ptr[threadNo] = image_r.Data; } } if (resolution == 1) { image = image_r.Clone(); } else { Cv2.Resize(image_r, image, new Size(image_r.Cols / resolution, image_r.Rows / resolution)); } GC.KeepAlive(image_r); var faces = cascade.DetectMultiScale(image); if (!faces.Any()) { throw new InvalidOperationException("this contains no elements"); } Array2D <RgbPixel> array2D = new Array2D <RgbPixel>(); lock (lock_imagebytes[threadNo]) { Marshal.Copy(image.Data, bytes[threadNo], 0, bytes[threadNo].Length); array2D = Dlib.LoadImageData <RgbPixel>(bytes[threadNo], (uint)image.Height, (uint)image.Width, (uint)(image.Width * image.ElemSize())); } var rectangles = new Rectangle(faces.First().Left, faces.First().Top, faces.First().Right, faces.First().Bottom); DlibDotNet.Point[] points = new DlibDotNet.Point[68]; using (FullObjectDetection shapes = shape.Detect(array2D, rectangles)) { for (uint i = 0; i < 68; i++) { points[i] = shapes.GetPart(i); } lock (lock_landmarks) { landmark_detection = points; } } array2D.Dispose(); Point2f[] image_points = new Point2f[6]; image_points[0] = new Point2f(points[30].X, points[30].Y); image_points[1] = new Point2f(points[8].X, points[8].Y); image_points[2] = new Point2f(points[45].X, points[45].Y); image_points[3] = new Point2f(points[36].X, points[36].Y); image_points[4] = new Point2f(points[54].X, points[54].Y); image_points[5] = new Point2f(points[48].X, points[48].Y); var image_points_mat = new Mat(image_points.Length, 1, MatType.CV_32FC2, image_points); eye_point_R[threadNo][0] = points[42]; eye_point_L[threadNo][1] = points[36]; eye_point_R[threadNo][2] = points[43]; eye_point_L[threadNo][2] = points[38]; eye_point_R[threadNo][3] = points[47]; eye_point_L[threadNo][3] = points[40]; eye_point_R[threadNo][4] = points[44]; eye_point_L[threadNo][4] = points[37]; eye_point_R[threadNo][5] = points[46]; eye_point_L[threadNo][5] = points[41]; Mat rvec_mat = new Mat(); Mat tvec_mat = new Mat(); Mat projMatrix_mat = new Mat(); Cv2.SolvePnP(model_points_mat, image_points_mat, camera_matrix_mat, dist_coeffs_mat, rvec_mat, tvec_mat); Marshal.Copy(tvec_mat.Data, pos_double[threadNo], 0, 3); Cv2.Rodrigues(rvec_mat, projMatrix_mat); Marshal.Copy(projMatrix_mat.Data, proj[threadNo], 0, 9); est_pos.x = -(float)pos_double[threadNo][0]; est_pos.y = (float)pos_double[threadNo][1]; est_pos.z = (float)pos_double[threadNo][2]; est_rot = RotMatToQuatanion(proj[threadNo]).eulerAngles; if (blink_tracking) { BlinkTracker(threadNo, eye_point_L[threadNo], eye_point_R[threadNo], est_rot); } if (eye_tracking) { EyeTracker(threadNo, image, points.Skip(42).Take(6), points.Skip(36).Take(6)); } image_points_mat.Dispose(); rvec_mat.Dispose(); tvec_mat.Dispose(); projMatrix_mat.Dispose(); GC.KeepAlive(image); } catch (Exception e) { Debug.Log(e.ToString()); est_pos = pos; est_rot = rot; if (image.IsEnabledDispose) { image.Dispose(); } return(false); } lock (lock_imagebytes[threadNo]) { if (image.IsEnabledDispose) { image.Dispose(); } } return(true); }
public static void Index2DIntIPredicateThrowsExceptionIfStartIndexIsOutOfBounds <T> (Array2D <T> array, Index2D startIndex) => Assert.Throws <ArgumentOutOfRangeException>( () => array.FindLastIndex(startIndex, 0, new AlwaysTruePredicate <T>()));
public static ItemRequestResult <Index2D> TestFindLastIndex <T>( Array2D <T> array, Index2D startIndex, Bounds2D sector, Predicate <T> match) => array.FindLastIndex(startIndex, sector, match);
public static void Index2DBounds2DThrowsExceptionIfSectorIsOutOfBounds <T>( Array2D <T> array, Index2D startIndex, Bounds2D sector) => Assert.Throws <ArgumentOutOfRangeException>( () => array.FindLastIndex(startIndex, sector, o => true));
public static ItemRequestResult <Index2D> Test <T>( Array2D <T> array, Index2D startIndex, int count, Predicate <T> match) => array.FindLastIndex(startIndex, count, match);
public static void Index2DIntThrowsExceptionIfCountExceedsArray2DCount <T>( Array2D <T> array, Index2D startIndex, int count) => Assert.Throws <ArgumentOutOfRangeException>( () => array.FindLastIndex(startIndex, count, o => true));
public static void Index2DIntThrowsExceptionIfStartIndexIsOutOfBounds <T>( Array2D <T> array, Index2D startIndex) => Assert.Throws <ArgumentOutOfRangeException>( () => array.FindLastIndex(startIndex, 0, o => true));
public static ItemRequestResult <Index2D> Test <T>( Array2D <T> array, Predicate <T> match) => array.FindLastIndex(match);
public static void Index2DIntIPredicateThrowsExceptionIfCountExceedsArray2DCount <T> (Array2D <T> array, Index2D startIndex, int count) => Assert.Throws <ArgumentOutOfRangeException>( () => array.FindLastIndex( startIndex, count, new AlwaysTruePredicate <T>()));
private void Initialize() { this.data = level.Data; this.boxCoordinates = level.BoxCoordinates; this.boxes = level.Boxes; this.cancelInfo = new CancelInfo(); }
public static ItemRequestResult <Index2D> Test <T, TPredicate>( Array2D <T> array, Index2D startIndex, int count, TPredicate match) where TPredicate : struct, IPredicate <T> => array.FindLastIndex(startIndex, count, match);
public Level(Level other) : base(new Array2D<Cell>(other.Data)) { // Copy state information. name = other.name; sokobanAssessed = other.sokobanAssessed; boxesAssessed = other.boxesAssessed; outsideAssessed = other.outsideAssessed; sokobanRow = other.sokobanRow; sokobanColumn = other.sokobanColumn; sokobans = other.sokobans; boxes = other.boxes; targets = other.targets; insideSquares = other.insideSquares; isClosed = other.isClosed; unfinishedBoxes = other.unfinishedBoxes; markAccessible = other.markAccessible; validate = other.validate; boxMap = new Array2D<int>(other.boxMap); boxCoordinates = (Coordinate2D[])other.BoxCoordinates.Clone(); insideCoordinates = other.insideCoordinates; Initialize(); }
/// <summary> /// Adjust the rectangle to make sure it is inside the range of the image /// </summary> /// <param name="rect">rectangle to be adjusted</param> /// <param name="img">image for reference</param> /// <returns></returns> public static DlibDotNet.Rectangle RectangleAdjust(DlibDotNet.Rectangle rect, Array2D <RgbPixel> img) { DlibDotNet.Rectangle fitRect = new DlibDotNet.Rectangle(); fitRect.Right = rect.Right < img.Rect.Right ? rect.Right : img.Rect.Right; fitRect.Left = rect.Left > img.Rect.Left ? rect.Left : img.Rect.Left; fitRect.Top = rect.Top > img.Rect.Top ? rect.Top : img.Rect.Top; fitRect.Bottom = rect.Bottom < img.Rect.Bottom ? rect.Bottom : img.Rect.Bottom; return(fitRect); }
public static void ThrowsExceptionIfSectorSizeIsOutOfBounds <T>( List2D <T> source, Array2D <T> destination, Bounds2D sectorSize) => Assert.Throws <ArgumentOutOfRangeException>( () => source.CopyTo(destination, sectorSize));
public override void Generate(int rooms) { int posY = (int)Random.Range(0.0f, rooms / 2); position = new Vector2(0, posY); /* Array2D */ patern = new Array2D(rooms, rooms); patern[0, posY] = 2; int roomsBuild = 0; int safeExit = 0; while (roomsBuild < rooms && safeExit < rooms * 10) { bool build = false; float value = Random.Range(0.0f, 1.0f); if (value < generateOnLeft) { if (position.x != 0 && patern[(int)position.x - 1, (int)position.y] == 0) { position.x--; build = true; reduceLeftProba(); } } else if (value < generateOnTop) { if (position.y != 0 && patern[(int)position.x, (int)position.y - 1] == 0) { position.y--; build = true; reduceRightProba(); } } else if (value < generateOnRight) { if (position.y != rooms - 1 && patern[(int)position.x + 1, (int)position.y] == 0) { position.x++; build = true; reduceTopProba(); } } else if (value < generateOnBottom) { if (position.y != rooms - 1 && patern[(int)position.x, (int)position.y + 1] == 0) { position.y++; build = true; reduceBottomProba(); } } if (build) { roomsBuild++; patern[(int)position.x, (int)position.y] = 1; } safeExit++; } }
public static void Test <T>( List2D <T> src, Array2D <T> dest, Array2D <T> expected) { src.CopyTo(dest); CollectionAssert.AreEqual(expected, dest); }
private Level GenerateLevelBuckshot(State state, int size, Array2D<Cell> designData, Array2D<bool> designFixed, out int designRow, out int designColumn) { // Create larger work array and corresponding fixed map. Array2D<Cell> array = new Array2D<Cell>(2 * size + designData.Height, 2 * size + designData.Width); array.SetAll(Cell.Wall); Array2D<bool> arrayFixed = new Array2D<bool>(array.Height, array.Width); // Adjust design data so that undefined cells are walls. Array2D<Cell> designDataCopy = new Array2D<Cell>(designData); designDataCopy.Replace(Cell.Undefined, Cell.Wall); // Copy design into middle of work array. designRow = size; designColumn = size; designDataCopy.CopyTo(array, designRow, designColumn, 0, 0, designData.Height, designData.Width); designFixed.CopyTo(arrayFixed, designRow, designColumn, 0, 0, designData.Height, designData.Width); // Set intial boundaries. int rowMin = array.Height; int colMin = array.Width; int rowMax = -1; int colMax = -1; int count = 0; foreach (Coordinate2D coord in array.Coordinates) { if (!Level.IsWall(array[coord])) { rowMin = Math.Min(rowMin, coord.Row); colMin = Math.Min(colMin, coord.Column); rowMax = Math.Max(rowMax, coord.Row); colMax = Math.Max(colMax, coord.Column); count++; } } while (count < size) { // Choose a new square at random. int row = rowMin - growth + state.Random.Next(rowMax - rowMin + 1 + 2 * growth); int column = colMin - growth + state.Random.Next(colMax - colMin + 1 + 2 * growth); Coordinate2D coord = new Coordinate2D(row, column); if (!array.IsValid(coord)) { continue; } // Avoid fixed cells. if (arrayFixed[coord]) { continue; } // Avoid existing squares. if (!Level.IsWall(array[coord])) { continue; } // Ensure the new square is adjacent to an existing square. bool isAdjacent = false; foreach (Coordinate2D neighbor in coord.FourNeighbors) { if (!Level.IsWall(array[neighbor])) { isAdjacent = true; break; } } if (!isAdjacent) { continue; } // Add the new square and update the boundaries. array[coord] = Cell.Empty; rowMin = Math.Min(rowMin, row); colMin = Math.Min(colMin, column); rowMax = Math.Max(rowMax, row); colMax = Math.Max(colMax, column); count++; } // Extract the constructed level. Array2D<Cell> subarray = array.GetSubarray(rowMin - 1, colMin - 1, rowMax - rowMin + 3, colMax - colMin + 3); Level level = new Level(subarray); // Adjust design coordinate. designRow -= rowMin - 1; designColumn -= colMin - 1; return level; }
// Use this for initialization void Start() { testArray = new Array2D <Coordinate>(4, 4); Refill(); }
public bool Generate() { Initialize(); designInfo = new DesignInfo[designs.Count]; designCount = 0; foreach (Level design in designs) { // Extract design data. Array2D<Cell> designData = new Array2D<Cell>(design.Data); if (useEntireLevel) { designData.Replace(Cell.Outside, Cell.Wall); } // Create a map of all squares that cannot be altered, initialized to false. Array2D<bool> designFixed = new Array2D<bool>(designData.Height, designData.Width); Coordinate2D sokobanCoord = Coordinate2D.Undefined; int designBoxes = 0; foreach (Coordinate2D coord in designData.NonPerimeterCoordinates) { if (clearDesign) { if (designData[coord] != Cell.Wall) { designData[coord] = Cell.Empty; } } if (designData[coord] != Cell.Undefined) { // Record squares that should not be changed. designFixed[coord] = true; } if (Level.IsSokoban(designData[coord])) { // Remove sokoban if present but record its coordinate. designData[coord] &= ~Cell.Sokoban; sokobanCoord = coord; } if (Level.IsBox(designData[coord])) { // Count boxes included in design. designBoxes++; } } // Store in design array. DesignInfo info = new DesignInfo(); info.Data = designData; info.Fixed = designFixed; info.SokobanCoordinate = sokobanCoord; info.Boxes = designBoxes; designInfo[designCount] = info; designCount++; } // Now generate levels. if (threads == 1) { return GenerateLevels(); } return MultiThreadedGenerateLevels(); }
/// <inheritdoc /> protected override Index2D GetDimensions(Array2D <T> value) => value.Dimensions;
public Terrain(Vector3 posCenter, Vector3 size, int cellsX, int cellsZ, GraphicsDevice g, Texture2D tex) : base() { numVertsX = cellsX + 1; numVertsZ = cellsZ + 1; numVerts = numVertsX * numVertsZ; numTriX = cellsX * 2; numTriZ = cellsZ; numTris = numTriX * numTriZ; verts = new VertexPositionNormalTexture[numVerts]; int numIndices = numTris * 3; indices = new int[numIndices]; float cellSizeX = (float)size.X / cellsX; float cellSizeZ = (float)size.Z / cellsZ; texture = tex; Random r = new Random(); Random r2 = new Random(DateTime.Now.Millisecond); double targetHeight = 0; double currentHeight = 0; // Fill in the vertices int count = 0; // distribute height nodes across the map. // for each vert, calculate the height by summing (node height / distance) int numHeightNodes = 10; heightNodes = new Vector3[numHeightNodes]; for (int i = 0; i < numHeightNodes; i++) { heightNodes[i] = new Vector3((float)((-size.X / 2) + (r.NextDouble() * size.X)), (float)(r.NextDouble() * 0), (float)((-size.Z / 2) + (r.NextDouble() * size.Z))); } bool stretchTexture = false; float textureTileCount = 10000; float worldZPosition = -(size.Z / 2); for (int z = 0; z < numVertsZ; z++) { float worldXPosition = -(size.X / 2); for (int x = 0; x < numVertsX; x++) { if (count % numVertsX == 0) { targetHeight = r2.NextDouble(); } //currentHeight += (targetHeight - currentHeight) * .009f; float height = GetNodeBasedHeight(worldXPosition, worldZPosition); height = 0; verts[count].Position = new Vector3(worldXPosition, height, worldZPosition); verts[count].Normal = Vector3.Zero; if (stretchTexture) { verts[count].TextureCoordinate.X = (float)x / (numVertsX - 1); verts[count].TextureCoordinate.Y = (float)z / (numVertsZ - 1); } else { verts[count].TextureCoordinate.X = ((float)x / (numVertsX - 1)) * textureTileCount; verts[count].TextureCoordinate.Y = ((float)z / (numVertsZ - 1)) * textureTileCount; } count++; // Advance in x worldXPosition += cellSizeX; } currentHeight = 0; // Advance in z worldZPosition += cellSizeZ; } int index = 0; int startVertex = 0; for (int cellZ = 0; cellZ < cellsZ; cellZ++) { for (int cellX = 0; cellX < cellsX; cellX++) { indices[index] = startVertex + 0; indices[index + 1] = startVertex + 1; indices[index + 2] = startVertex + numVertsX; SetNormalOfTriangleAtIndices(indices[index], indices[index + 1], indices[index + 2]); meshIndices.Add(new TriangleVertexIndices(index, index + 1, index + 2)); meshVertices.Add(verts[indices[index]].Position); meshVertices.Add(verts[indices[index + 1]].Position); meshVertices.Add(verts[indices[index + 2]].Position); index += 3; indices[index] = startVertex + 1; indices[index + 1] = startVertex + numVertsX + 1; indices[index + 2] = startVertex + numVertsX; SetNormalOfTriangleAtIndices(indices[index], indices[index + 1], indices[index + 2]); meshIndices.Add(new TriangleVertexIndices(index, index + 1, index + 2)); meshVertices.Add(verts[indices[index]].Position); meshVertices.Add(verts[indices[index + 1]].Position); meshVertices.Add(verts[indices[index + 2]].Position); index += 3; startVertex++; } startVertex++; } try { Effect = new BasicEffect(g); mesh = new TriangleMesh(); //mesh.CreateMesh(meshVertices, meshIndices, 2, cellSizeX); } catch (Exception E) { System.Diagnostics.Debug.WriteLine(E.StackTrace); } this.Body = new Body(); Skin = new CollisionSkin(Body); Body.CollisionSkin = Skin; Body.ExternalData = this; float heightf = 0; try { Array2D field = new Array2D(numVertsX, numVertsZ); int i = 0; for (int c = 0; c < verts.Length; c++) { int x = c / numVertsX; int z = c % numVertsX; if (i >= verts.Length) { i = (i % verts.Length) + 1; } heightf = verts[i].Position.Y + posCenter.Y; // works //heightf = verts[i].Position.Y; i += numVertsX; field.SetAt(x, z, heightf); } // Body.MoveTo(Position, Matrix.Identity); Heightmap hm = new Heightmap(field, (-size.X / 2) / (cellsX + 0) + cellSizeX / 2, (-size.Z / 2) / (cellsZ + 0) + cellSizeZ / 2, size.X / (cellsX + 0), size.Z / (cellsZ + 0)); Skin.AddPrimitive(hm, new MaterialProperties(0.7f, 0.7f, 0.6f)); //Skin.AddPrimitive(GetMesh(), new MaterialProperties(0.7f, 0.7f, 0.6f)); //VertexPositionColor[] wireFrame = Skin.GetLocalSkinWireframe(); // 1200 across before Z changes to from -7.5/-7.35 to -7.35/-7.2 PhysicsSystem.CurrentPhysicsSystem.CollisionSystem.AddCollisionSkin(Skin); CommonInit(posCenter, new Vector3(0, 0, 0), null, false, 0); } catch (Exception E) { System.Diagnostics.Debug.WriteLine(E.StackTrace); } }
private void UnsafeGenerateOneLevel(State state) { // Randomly select a supplied design. state.CurrentDesign = state.Random.Next(designCount); Array2D<Cell> designData = designInfo[state.CurrentDesign].Data; Array2D<bool> designFixed = designInfo[state.CurrentDesign].Fixed; // Choose a size at random between the minimum and maximum limits. int size = minSize + state.Random.Next(maxSize - minSize + 1); state.CurrentSize = size; int designRow; int designColumn; Level level = null; if (useEntireLevel) { designRow = 0; designColumn = 0; level = new Level(new Array2D<Cell>(designData)); } else { level = GenerateLevel(state, size, designData, designFixed, out designRow, out designColumn); } // Make sure will have something to solve. if (designInfo[state.CurrentDesign].Boxes == 0 && boxes == 0) { state.Log.DebugPrint("level generated with no boxes"); return; } // Add islands not included in design. for (int i = 0; i < islands; i++) { AddIsland(state, level); } // Add boxes not included in design. if (designInfo[state.CurrentDesign].Boxes < boxes) { int boxesToAdd = boxes - designInfo[state.CurrentDesign].Boxes; int displacedBoxes = boxesToAdd >= displaced ? displaced : boxesToAdd; int inplaceBoxes = boxesToAdd - displacedBoxes; for (int i = 0; i < displacedBoxes; i++) { AddDisplacedBox(state, level); } for (int i = 0; i < inplaceBoxes; i++) { AddInplaceBox(state, level); } } if (verbose >= 2) { state.Log.DebugPrint("design = {0}, size = {1}, algorithm = {2}", state.CurrentDesign, state.CurrentSize, state.CurrentAlgorithm); state.Log.DebugPrint(level.AsText); } // Create a map of squares that have already been tried // as the starting sokoban coordinate, initialized to false. Array2D<bool> tried = new Array2D<bool>(level.Height, level.Width); Coordinate2D sokobanCoord = designInfo[state.CurrentDesign].SokobanCoordinate; if (!sokobanCoord.IsUndefined) { // Only try specified sokoban coordinate. tried.SetAll(true); tried[sokobanCoord.Row + designRow, sokobanCoord.Column + designColumn] = false; } // For all accessible squares. PathFinder finder = PathFinder.CreateInstance(level); while (true) { // Find an untried starting square. bool foundSquare = false; foreach (Coordinate2D coord in level.InsideCoordinates) { if (level.IsEmpty(coord) && !tried[coord]) { sokobanCoord = coord; foundSquare = true; break; } } if (!foundSquare) { break; } // Put sokoban on untried empty square. level.AddSokoban(sokobanCoord); // Find all squares accessible from this one. finder.Find(); // Mark all accessible squares as tried. foreach (Coordinate2D coord in finder.AccessibleCoordinates) { tried[coord] = true; } MoveList moveList = FastSolve(state, level); if (moveList != null) { int pushes = LevelUtils.SolutionPushes(moveList); if (verbose >= 1) { state.Log.DebugPrint("raw: moves = {0}, pushes = {1}", moveList.Count, pushes); } if (pushes > pushLimit) { // First clean up the level which might have a large number // of excess squares that would stress the final solver. Level cleanLevel = LevelUtils.CleanLevel(level, moveList); // Now get a clean solution using move optimization. MoveList cleanMoveList = FinalSolve(state, cleanLevel); // Although this does have a solution, the solver // could fail for other reasons (out of memory, etc). if (cleanMoveList != null) { // Finally check whether there are any squares we can remove. AddSmallestLevel(state, cleanLevel, cleanMoveList); } } } else { if (verbose >= 2) { state.Log.DebugPrint("no solution"); } } level.RemoveSokoban(); } }
private static Deadlock GetDeadlock(Level level) { // Decode the map. Array2D<bool> map = null; if (level.Targets != 0) { map = new Array2D<bool>(level.Height, level.Width); foreach (Coordinate2D coord in level.TargetCoordinates) { map[coord] = true; } } return new Deadlock(map, level.BoxCoordinates); }
private Level GenerateLevel(State state, int size, Array2D<Cell> designData, Array2D<bool> designFixed, out int designRow, out int designColumn) { Level level = null; designRow = 0; designColumn = 0; if (size == 0) { designRow = -1; designColumn = -1; level = new Level(designData.GetSubarray(1, 1, designData.Height - 2, designData.Width - 2)); if (level.IsClosed) { state.Log.DebugPrint("design with no additional squares is not closed"); } } // Choose algorithm at random. state.CurrentAlgorithm = algorithms[state.Random.Next(algorithms.Length)]; switch (state.CurrentAlgorithm) { case AlgorithmType.Buckshot: level = GenerateLevelBuckshot(state, size, designData, designFixed, out designRow, out designColumn); break; case AlgorithmType.Blob: level = GenerateLevelBlob(state, size, designData, designFixed, out designRow, out designColumn); break; } return level; }
private static Array2D<bool> GetSetMap(IEnumerable<Coordinate2D> set) { Coordinate2D maxCoord = new Coordinate2D(0, 0); foreach (Coordinate2D coord in set) { maxCoord.Row = Math.Max(maxCoord.Row, coord.Row); maxCoord.Column = Math.Max(maxCoord.Column, coord.Column); } Array2D<bool> setMap = new Array2D<bool>(maxCoord.Row + 2, maxCoord.Column + 2); foreach (Coordinate2D coord in set) { setMap[coord] = true; } return setMap; }
private void CalculatePullMap() { // Pre-calculate a map of possible directions in which a box // at a given coordinate can be pulled. pullMap = new Array2D<Direction[]>(level.Height, level.Width); foreach (Coordinate2D coord in level.InsideCoordinates) { List<Direction> directions = new List<Direction>(); foreach (Direction direction in Direction.Directions) { Coordinate2D sokobanCoood = coord + 2 * direction; Coordinate2D newBoxCoord = coord + direction; if (!level.IsFloor(sokobanCoood)) { // The sokoban can never reach to pull this box. continue; } if (!level.IsFloor(newBoxCoord)) { // The box cannot be pulled in this direction. continue; } directions.Add(direction); } pullMap[coord] = directions.ToArray(); } }
public void Mirror() { Array2D<Cell> newData = new Array2D<Cell>(levelHeight, levelWidth); for (int row = 0; row < levelHeight; row++) { for (int column = 0; column < levelWidth; column++) { newData[row, column] = Data[row, levelWidth - 1 - column]; } } Data = newData; }
private void CalculateSimpleDeadlockMap() { // Create a simple deadlock map with all inside squares initialized to true. simpleDeadlockMap = new Array2D<bool>(level.Height, level.Width); foreach (Coordinate2D coord in level.InsideCoordinates) { simpleDeadlockMap[coord] = true; } // For each target visit as many squares as possible using pulls only. foreach (Coordinate2D coord in level.TargetCoordinates) { VisitAllPulls(coord); } }
public void Rotate() { Array2D<Cell> newData = new Array2D<Cell>(levelWidth, levelHeight); for (int row = 0; row < levelWidth; row++) { for (int column = 0; column < levelHeight; column++) { newData[row, column] = Data[levelHeight - 1 - column, row]; } } Data = newData; }
/// <inheritdoc /> protected override Index2D GetLowerBounds(Array2D <T> value) => value.LowerBounds;
//-------------------------------------------------------------------------------------------------------- /// <summary> /// Dlib5を利用した顔検出 Face detection using Dlib5 /// </summary> /// <param name="threadNo">スレッド番号 Thread number</param> /// <param name="est_pos">推定された位置 Estimated position</param> /// <param name="est_rot">推定された回転 Estimated quotation</param> /// <returns>推定できたか Whether it could be estimated</returns> private bool Dlib5(int threadNo, out Vector3 est_pos, out Vector3 est_rot) { est_rot = rot; Mat image_r = new Mat(); Array2D <RgbPixel> array2D = new Array2D <RgbPixel>(); Mat image = new Mat(); try { lock (lock_capture) { image_r = caputure.Read(); if (image_r.Data == null) { throw new NullReferenceException("capture is null"); } if (ptr.Contains(image_r.Data)) { throw new InvalidOperationException("taken same data"); } else { ptr[threadNo] = image_r.Data; } } if (resolution == 1) { image = image_r.Clone(); } else { Cv2.Resize(image_r, image, new Size(image_r.Cols / resolution, image_r.Rows / resolution)); } GC.KeepAlive(image_r); lock (lock_imagebytes[threadNo]) { Marshal.Copy(image.Data, bytes[threadNo], 0, bytes[threadNo].Length); array2D = Dlib.LoadImageData <RgbPixel>(bytes[threadNo], (uint)image.Height, (uint)image.Width, (uint)(image.Width * image.ElemSize())); } Rectangle rectangles = default; if (un_safe) { rectangles = detector[0].Operator(array2D).FirstOrDefault(); } else { rectangles = detector[threadNo].Operator(array2D).FirstOrDefault(); } DlibDotNet.Point[] points = new DlibDotNet.Point[5]; if (rectangles == default) { throw new InvalidOperationException("this contains no elements."); } using (FullObjectDetection shapes = shape.Detect(array2D, rectangles)) { for (uint i = 0; i < 5; i++) { points[i] = shapes.GetPart(i); } } est_pos.x = -(image.Width / 2 - points[4].X) / (float)image.Width; est_pos.y = (image.Height / 2 - points[4].Y) / (float)image.Height; est_pos.z = (points[0].X - points[2].X) / (float)image.Width + (points[0].Y - points[2].Y) / (float)image.Height - z_offset; try { est_rot.z = Mathf.Rad2Deg * Mathf.Atan2(points[0].Y - points[2].Y, points[0].X - points[2].X); } catch (DivideByZeroException) { est_rot.z = points[0].Y - points[2].Y < 0 ? -90 : 90; } if (debug_face_image) { DetectDebug(threadNo, image, points: points); } GC.KeepAlive(image); } catch (Exception e) { Debug.Log(e.ToString()); est_pos = pos; if (array2D.IsEnableDispose) { array2D.Dispose(); } if (image.IsEnabledDispose) { image.Dispose(); } return(false); } if (array2D.IsEnableDispose) { array2D.Dispose(); } lock (lock_imagebytes[threadNo]) { if (image.IsEnabledDispose) { image.Dispose(); } } return(true); }
private static Level GetDeadlockAsLevel(Level level, Deadlock deadlock) { Array2D<Cell> newData = new Array2D<Cell>(level.Data); foreach (Coordinate2D coord in level.InsideCoordinates) { newData[coord] &= ~(Cell.Sokoban | Cell.Box | Cell.Target); } foreach (Coordinate2D coord in deadlock.Coordinates) { newData[coord] |= Cell.Box; } if (deadlock.SokobanMap != null) { foreach (Coordinate2D coord in level.InsideCoordinates) { if (deadlock.SokobanMap[coord]) { newData[coord] |= Cell.Target; } } } return new Level(newData); }
public PerEntityVoxelWorldRenderer(Model.World world, Point2 windowSize) { this.world = world; entities = new Array2D <Entity>(windowSize); entities.ForEach((e, p) => entities[p] = new Entity()); }
/// <summary> /// Creates a new control /// </summary> /// <param name="DataElement">The hidden data element</param> public LightsOut2(IHTMLElement DataElement) { // based on http://www.cjcraft.com/Blog/PermaLink,guid,5c35b1f1-dc66-4d85-ac04-22fc97503d4a.aspx // what happens in beta2 when the anonymous types are immutable? :) var usersettings = new { x = 5, y = 5, tile = new { w = 64, h = 64, cold = 0.8 } }; var a = new Array2D<IHTMLDiv>(usersettings.x, usersettings.y); var m = a.ToBooleanArray(); var r = new System.Random(); m.ForEach( (x, y) => { m[x, y] = r.NextDouble() > 0.5; } ); var canvas = new IHTMLDiv(); canvas.className = "canvas"; var canvas_size = new __Type1 { x = ((a.XLength + 1) * usersettings.tile.w), y = ((a.YLength + 1) * usersettings.tile.h) }; canvas.style.position = IStyle.PositionEnum.relative; canvas.style.border = "2px solid black"; canvas.style.width = canvas_size.x + "px"; canvas.style.height = canvas_size.y + "px"; var canvas_bg = new IHTMLDiv(); //var canvas_bg_tween = new TweenDataDouble(); //canvas_bg_tween.Value = 1; //canvas_bg_tween.ValueChanged += delegate { canvas_bg.style.Opacity = canvas_bg_tween.Value; }; new HTML.Images.FromAssets.background().ToBackground(canvas_bg.style); //canvas_bg.style.backgroundImage = Assets.Default.Background.StyleSheetURL; canvas_bg.style.SetLocation(0, 0, canvas_size.x * 2, canvas_size.y); canvas.appendChild(canvas_bg); IStyleSheet.Default.AddRule(".info").style .Aggregate(s => { s.backgroundColor = Color.Black; s.color = Color.White; s.padding = "2em"; s.fontFamily = IStyle.FontFamilyEnum.Tahoma; s.Float = IStyle.FloatEnum.right; }) ; IStyleSheet.Default.AddRule(".canvas").style .Aggregate(s => s.overflow = IStyle.OverflowEnum.hidden) .Aggregate(s => s.backgroundColor = Color.Black) ; IStyleSheet.Default.AddRule(".on").style .Aggregate(s => new HTML.Images.FromAssets.vistaLogoOn().ToBackground(s) ) //.Aggregate(s => s.Opacity = 0.8) ; IStyleSheet.Default.AddRule(".off").style .Aggregate(s => new HTML.Images.FromAssets.vistaLogoOff().ToBackground(s) ) //.Aggregate(s => s.Opacity = 0.5) ; Action<int, int> UpdateColor = (x, y) => { var n = a[x, y]; if (m[x, y]) { n.className = "on"; } else { n.className = "off"; } }; Action<int, int> ToggleDirect = (x, y) => { var n = a[x, y]; if (n == null) return; m[x, y] = !m[x, y]; UpdateColor(x, y); }; Action<int, int> Toggle = (x, y) => { //Console.WriteLine("click at: " + new { x, y } + " = " + m[x, y]); var f = ToggleDirect.WithOffset(x, y); f(-1, 0); f(0, -1); f(0, 0); f(0, 1); f(1, 0); }; var info_stats_clicks = new IHTMLDiv(); var info_stats_clicks_count = 0; var info_stats_off = new IHTMLDiv(); var info_stats_on = new IHTMLDiv(); Action info_stats_update = () => { info_stats_clicks.innerHTML = info_stats_clicks_count + " clicks made so far"; info_stats_on.innerHTML = m.Count(i => i) + " blocks are on"; info_stats_off.innerHTML = m.Count(i => !i) + " blocks are off"; }; var info_stats = new IHTMLDiv(info_stats_clicks, info_stats_off, info_stats_on); info_stats.className = "info"; a.ForEach( (x, y) => { var n = new IHTMLDiv(); n.style.left = (x * usersettings.tile.w + usersettings.tile.w / 2) + "px"; n.style.top = (y * usersettings.tile.h + usersettings.tile.h / 2) + "px"; n.style.width = usersettings.tile.w + "px"; n.style.height = usersettings.tile.h + "px"; n.style.position = IStyle.PositionEnum.absolute; n.style.overflow = IStyle.OverflowEnum.hidden; //n.style.border = "1px solid black"; n.style.cursor = IStyle.CursorEnum.pointer; canvas.appendChild(n); var tween = new TweenDataDouble(); tween.ValueChanged += () => n.style.Opacity = tween.Value; tween.Value = usersettings.tile.cold; n.style.Opacity = tween.Value; n.onmouseover += delegate { tween.Value = 1; //canvas_bg_tween.Value = 0.5; }; n.onmouseout += delegate { tween.Value = usersettings.tile.cold; //canvas_bg_tween.Value = 1; }; n.onclick += delegate { info_stats_clicks_count++; Toggle(x, y); info_stats_update(); }; a[x, y] = n; UpdateColor(x, y); } ); var ani = new Timer(t => canvas_bg.style.left = -(int)System.Math.Floor((double)((IDate.Now.getTime() / 75) % canvas_size.x)) + "px"); var info = new IHTMLDiv(); var info_header_text = "Lights out 2"; Native.Document.title = info_header_text; info.appendChild(new IHTMLElement(IHTMLElement.HTMLElementEnum.h1, info_header_text)); info.appendChild(new IHTMLAnchor("http://www.cjcraft.com/Blog/PermaLink,guid,5c35b1f1-dc66-4d85-ac04-22fc97503d4a.aspx", "based on SilverlightsOut")); info.appendChild(new IHTMLBreak()); info.appendChild(new IHTMLAnchor("http://www.cjcraft.com/Blog/CommentView,guid,5c35b1f1-dc66-4d85-ac04-22fc97503d4a.aspx", "cjcraft blog post")); info.appendChild(new IHTMLElement(IHTMLElement.HTMLElementEnum.p, @"Lights out is a one player puzzle that is played on a 5 by 5 grid of squares in which every square has two states: on and off. The game starts off with all squares off, where the goal is to turn on every square. By selecting a square, all the surrounding squares' (up, down, left, right) state is turned toggled. For example, on a 3 by 3 grid of squares with all squares off, if the center one is selected, it will turn 'on' the 4 up, down, left, right squares from it.")); info.appendChild(new IHTMLDiv("Mozilla based browsers seem to suffer in performance while animating contents under semitransparent elements.")); info.appendChild(new IHTMLButton("Animate background").Aggregate(btn => btn.onclick += delegate { ani.StartInterval(50); })); info.appendChild(new IHTMLButton("Freeze background").Aggregate(btn => btn.onclick += delegate { ani.Stop(); })); info.appendChild(info_stats); info.appendChild(canvas); info_stats_update(); DataElement.insertNextSibling(info); }
public static Cell[,] Deserialize(string s) => Array2D.ConvertTo2DArray(s.Split(RowSeperator) .Select(row => row.Split(CellSeperator).Select(DeserializeCell).ToArray()) .ToArray());
private Array2D<bool> GetMap() { // Create the map if it hasn't been created yet or is the wrong size. if (map == null || map.Height != levelHeight || map.Width != levelWidth) { map = new Array2D<bool>(levelHeight, levelWidth); } return map; }
public static void Test <T>( Array2D <T> src, Array2D <T> dest, Bounds2D sectorSize, Array2D <T> expected) { src.CopyTo(dest, sectorSize); CollectionAssert.AreEqual(expected, dest); }
public Level(Array2D<Cell> data) : base(data) { Initialize(); }
public static void Test <T>( Array2D <T> src, Array2D <T> dest, Index2D destIndex, Array2D <T> expected) { src.CopyTo(dest, destIndex); CollectionAssert.AreEqual(expected, dest); }
private void AssessBoxes() { boxesAssessed = true; sokobans = 0; boxes = 0; targets = 0; unfinishedBoxes = 0; boxMap = new Array2D<int>(levelHeight, levelWidth); List<Coordinate2D> boxList = new List<Coordinate2D>(); int rowLimit = levelHeight - 1; int columnLimit = levelWidth - 1; for (int row = 1; row < rowLimit; row++) { for (int column = 1; column < columnLimit; column++) { Cell cell = data[row, column]; if (IsSokobanBoxOrTarget(cell)) { if (IsSokoban(cell)) { // While we're at it, record the sokoban square. if (!sokobanAssessed) { sokobanAssessed = true; sokobanRow = row; sokobanColumn = column; } sokobans++; } else if (IsBox(cell)) { boxMap[row, column] = boxes; boxList.Add(new Coordinate2D(row, column)); boxes++; if (!IsTarget(cell)) { unfinishedBoxes++; } } if (IsTarget(cell)) { targets++; } } } } boxCoordinates = boxList.ToArray(); }
public DefinitionNodeGrid(Array2D <DefinitionNode> nodeGrid, Vector2 scale, Vector2 offset = default) { Transformer = new GridTransformer(new Point2(nodeGrid.Width, nodeGrid.Height), scale, offset); NodeGrid = nodeGrid; }
protected void CalculateLowerBoundMaps() { // Create the pre-calculated lower bound data structures. // Create work arrays for matching lower bound function. boxTarget = new int[boxes]; targetBox = new int[targets]; distance = new int[boxes]; // Create an empty level with path finder for measuring distances. Level emptyLevel = LevelUtils.GetEmptyLevel(originalLevel); PathFinder emptyPathFinder = PathFinder.CreateInstance(emptyLevel, true); // Create the target distance maps and target index map. targetDistanceMaps = new Array2D<int>[targets]; targetIndexMap = new Array2D<int>(level.Height, level.Width); targetIndexMap.SetAll(-1); for (int i = 0; i < targets; i++) { targetDistanceMaps[i] = new Array2D<int>(level.Height, level.Width); targetIndexMap[targetCoordinates[i]] = i; } // For each inside square calculate the sorted list of nearest targets and // the distance to the nearest target. nearestTargetsMap = new Array2D<int[]>(level.Height, level.Width); nearestTargetDistanceMap = new Array2D<int>(level.Height, level.Width); foreach (Coordinate2D boxCoord in level.InsideCoordinates) { List<int> nearestTargets = new List<int>(); for (int j = 0; j < targets; j++) { Coordinate2D targetCoord = targetCoordinates[j]; targetDistanceMaps[j][boxCoord] = emptyPathFinder.FindAndGetDistance(boxCoord, targetCoord); nearestTargets.Add(j); } nearestTargets.Sort(delegate(int index1, int index2) { int distance1 = targetDistanceMaps[index1][boxCoord]; int distance2 = targetDistanceMaps[index2][boxCoord]; return distance1.CompareTo(distance2); }); nearestTargetDistanceMap[boxCoord] = targetDistanceMaps[nearestTargets[0]][boxCoord]; nearestTargetsMap[boxCoord] = nearestTargets.ToArray(); } }
public static WriteableBitmap ToWriteableBitmap <T>(this Array2D <T> array) where T : struct { return(ToWriteableBitmap(array, 96, 96)); }