/// <summary> /// Strong Construction /// </summary> /// <param name="aGameUI"></param> public GameCoords(GameUI aGameUI) { GameUI = aGameUI; GlobalOffset = new VectorInt(10, 30); GlobalTileSize = new SizeInt(16, 16); windowRegion = new RectangleInt(new VectorInt(0, 0), new SizeInt(400, 300)); }
/// <summary> /// Strong Construction /// </summary> /// <param name="aSizeX"></param> /// <param name="aSizeY"></param> public Bitmap(int aSizeX, int aSizeY) { if (aSizeX > 32) throw new NotSupportedException("Only 32bit sizes are excepted"); size = new SizeInt(aSizeX, aSizeY); map = new uint[aSizeY]; Clear(); }
public NodeListVisualisation(List<SolverNode> nodes, SizeInt cellSize) { this.nodes = nodes; this.cellSize = cellSize; int maxH = ((nodes.Count + 1)/maxCellWidth)*cellSize.Height; renderCanvas = new RectangleInt(0,0, cellSize.Width*maxCellWidth, maxH); windowRegion = renderCanvas; }
/// <summary> /// Strong COnstructoin /// </summary> /// <param name="sourceTree"></param> public TreeVisualisation(Tree<SolverNode> sourceTree, RectangleInt renderSize, SizeInt cellSize) { // this.controller = controller; this.tree = sourceTree; // Calculate the render size RenderCanvas = renderSize; CellSize = cellSize; }
/// <summary> /// Strong constructor /// </summary> /// <param name="nodes"></param> /// <param name="cellSize"></param> public NodeListVisualisation(SolverController controller, List<SolverNode> nodes, SizeInt cellSize) { Display = new CommonDisplay(controller); this.nodes = nodes; this.cellSize = cellSize; int maxH = ((nodes.Count + 1)/maxCellWidth+1)*cellSize.Height; renderCanvas = new RectangleInt(0,0, cellSize.Width*maxCellWidth, maxH); windowRegion = renderCanvas; }
/// <summary> /// Semi-Strong construction /// </summary> /// <param name="myGameUI">Game to which the node belongs</param> /// <param name="myDepth">Z-Order</param> public NodeBase(GameUI myGameUI, int myDepth) { if (myGameUI == null) throw new ArgumentNullException("myGameUI"); gameUI = myGameUI; depth = myDepth; dockPoint = DockPoint.Centre; size = new SizeInt(0, 0); currentAbsolute = VectorInt.Zero; isRemoved = false; }
/// <summary> /// Strong Constructor. Start with the dead map including all walls. /// </summary> /// <param name="goalMap"></param> /// <param name="wallMap"></param> public DeadMapState(Bitmap goalMap, Bitmap wallMap, DeadMapAnalysis deadMapAnalysis) : base("Dead Map", wallMap.Size) { this.goalMap = goalMap; this.wallMap = wallMap; this.deadMapAnalysis = deadMapAnalysis; this.mapSize = wallMap.Size; if (goalMap == null) throw new ArgumentNullException("goalMap"); if (wallMap == null) throw new ArgumentNullException("goalMap"); if (deadMapAnalysis == null) throw new ArgumentNullException("deadMapAnalysis"); }
public NodeUIDialogHelp(GameUI myGameUI, int myDepth) : base(myGameUI, myDepth) { Text = @"Place all crates/gem on the goal positions. You can push but never pull crates, you can only push one crate at a time. Use the arrow keys to move. [U] for Undo, [R] for Restart. [ESC] to exit. Click on a floor to move there. Drag a crate to a new position."; TextTitle = "Sokoban Help"; CurrentAbsolute = GameUI.GameCoords.PuzzleRegion.Center.Subtract(100, 100); Size = new SizeInt(500, 200); }
/// <summary> /// Strong Construction /// </summary> /// <param name="myGameUI"></param> /// <param name="myDepth"></param> /// <param name="PositionAbs"></param> /// <param name="resImage">Resource of the UI button image</param> /// <param name="ClickCommand">Command string passed back in the click event</param> public NodeUIButton(GameUI myGameUI, int myDepth, VectorInt PositionAbs, ResourceID resImage, string ClickCommand) : base(myGameUI, myDepth) { imageNormal = myGameUI.ResourceFactory[resImage].DataAsImage; imageBack = myGameUI.ResourceFactory[ResourceID.GameButtonBackGround].DataAsImage; Size = new SizeInt(imageBack.Size); CurrentAbsolute = PositionAbs; clickCommand = ClickCommand; mouseOverBrush = myGameUI.ResourceFactory[ResourceID.GameButtonMouseOverBrush].DataAsBrush; maskEffect = null; toolTip = null; if (GameUI.Cursor != null) { GameUI.Cursor.OnClick += new EventHandler<NodeCursorEventArgs>(cursor_OnClick); } }
/// <summary> /// Strong Construction /// </summary> /// <param name="myGameUI"></param> /// <param name="myDepth"></param> /// <param name="PositionAbs"></param> /// <param name="FileImage">Filename</param> /// <param name="ClickCommand">Command string passed back in the click event</param> public NodeUIButton(GameUI myGameUI, int myDepth, VectorInt PositionAbs, string FileImage, string ClickCommand) : base(myGameUI, myDepth) { imageNormal = new Bitmap(FileManager.getContent(FileImage)); imageBack = new Bitmap(FileManager.getContent("$Graphics\\Icons\\BasicButtonBK.png")); Size = new SizeInt(imageBack.Size); CurrentAbsolute = PositionAbs; clickCommand = ClickCommand; mouseOverBrush = new SolidBrush(Color.FromArgb(60, Color.Yellow)); maskEffect = null; toolTip = null; if (GameUI.Cursor != null) { GameUI.Cursor.OnClick += new EventHandler<NodeCursorEventArgs>(cursor_OnClick); } }
public override void Render() { if (imageBack != null) { VectorInt pos = CurrentRect.Center.Subtract(imageBack.Width / 2 + 2, imageBack.Height / 2 + 2); GameUI.Graphics.DrawImage(imageBack, pos.X, pos.Y); } if (imageNormal != null) { DrawBitmapCentered(GameUI.Graphics, CurrentRect, imageNormal); } if (isMouseOver) { if (mouseOverBrush != null) { RectangleInt over = new RectangleInt(CurrentAbsolute.Subtract(1, 1), CurrentRect.BottomRight.Add(1, 1)); GameUI.Graphics.FillEllipse(mouseOverBrush, over.ToDrawingRect()); } if (toolTip != null) { Font ttFont = new Font("Arial", 10f); SizeF ffSizeF = GameUI.Graphics.MeasureString(toolTip, ttFont); SizeInt ffSize = new SizeInt((int) ffSizeF.Width, (int) ffSizeF.Height); RectangleInt posTT = new RectangleInt(CurrentRect.BottomLeft.Subtract(ffSize.Width/2, -5 ), ffSize); if (posTT.TopLeft.X < GameUI.GameCoords.WindowRegion.TopLeft.X) posTT.TopLeft.X = GameUI.GameCoords.WindowRegion.TopLeft.X; if (posTT.TopLeft.Y < GameUI.GameCoords.WindowRegion.TopLeft.Y) posTT.TopLeft.Y = GameUI.GameCoords.WindowRegion.TopLeft.Y; if (posTT.BottomRight.X > GameUI.GameCoords.WindowRegion.BottomRight.X) posTT.BottomRight.X = GameUI.GameCoords.WindowRegion.BottomRight.X; if (posTT.BottomRight.Y < GameUI.GameCoords.WindowRegion.BottomRight.Y) posTT.BottomRight.Y = GameUI.GameCoords.WindowRegion.BottomRight.Y; Brush ttBrush = new SolidBrush(Color.Cyan); Brush ttBrushShadow = new SolidBrush(Color.DarkCyan); NodeEffectText nodeTT = new NodeEffectText(GameUI, 10000, toolTip, ttFont, ttBrush, ttBrushShadow, posTT.TopLeft); nodeTT.BrushBackGround = new SolidBrush(Color.DarkSlateGray); nodeTT.Path = new Paths.StaticPath(posTT.TopLeft, 1); GameUI.Add(nodeTT); } } if (maskEffect != null) { RectangleInt over = new RectangleInt(CurrentAbsolute.Subtract(5, 5), CurrentRect.BottomRight.Add(10, 10)); GameUI.Graphics.FillEllipse(maskEffect, over.ToDrawingRect()); } }
public static SizeInt Min(SizeInt A, SizeInt B) { return new SizeInt(System.Math.Min(A.X, B.X), System.Math.Min(A.Y, B.Y)); }
/// <summary> /// Initialise /// </summary> private void Init() { segments = new TreeSegmenter<SolverNode>(tree, maxDepth, maxMembers); segments.PerformSegment(); regions = new List<SegmentRegion>(segments.Segments.Count); int height = 0; foreach (TreeSegmenter<SolverNode>.TreeSegment segment in segments.Segments) { SegmentRegion region = new SegmentRegion(); region.owner = this; region.MaxRegionNodeWidth = maxWidth; SizeInt regionSize = new SizeInt(maxWidth*CellSize.Width + 50, (segment.Count/maxWidth +1)*CellSize.Height); region.RenderRegion = new RectangleInt(renderCanvas.TopLeft.Add(0, height), regionSize); region.treeSegment = segment; region.treeSegment.Nodes.Sort(delegate(TreeNode<SolverNode> lhs, TreeNode<SolverNode> rhs) { return rhs.Data.Weighting.CompareTo(lhs.Data.Weighting); }); regions.Add(region); height += regionSize.Height; } }
/// <summary> /// Strong constuctor /// </summary> /// <param name="cellSize"></param> /// <param name="controller"></param> public RootPathVisualisation(SizeInt cellSize, SolverController controller) { this.cellSize = cellSize; this.controller = controller; this.Display = new CommonDisplay(controller); }
/// <summary> /// Create a BitMap from a string map of '0' and '1'. /// Generally this constructor is for test purposes. /// </summary> /// <param name="StringMap"></param> public Bitmap(string[] StringMap) { // calc max length int sz = 0; foreach (String s in StringMap) { if (s.Length > sz) sz = s.Length; } if (sz > 32) throw new NotSupportedException("Only 32bit sizes are excepted"); size = new SizeInt(sz, StringMap.Length); map = new uint[StringMap.Length]; Clear(); // Set the strings for (int yy = 0; yy < Size.Y; yy++) for (int xx = 0; xx < Size.X; xx++) { if (StringMap[yy] != null && StringMap[yy].Length > xx) { this[xx, yy] = StringMap[yy][xx] == '1'; } } }
/// <summary> /// Initialise the puzzle to a set size. /// </summary> /// <param name="s"></param> /// <remarks> /// Create an empty puzzle with a wall around the edges /// </remarks> public void Init(SizeInt s) { if (s.X <= 0 || s.Y <= 0) throw new ArgumentOutOfRangeException("s"); map = new CellStates[s.X, s.Y]; Fill(CellStates.Floor); FillBox(Rectangle, CellStates.Wall); }
public VectorInt Add(SizeInt value) { return new VectorInt(x + value.X, y + value.Y); }
/// <summary> /// Default Constructor /// </summary> /// <param name="size"></param> public Matrix(SizeInt size) { Size = size; }
/// <summary> /// Init the puzzle from a simple string map /// </summary> public void SetFromStrings(string[] StrMap, string[] ValidChars) { int maxx = 0; // Clean up List<string> InputMap = new List<string>(StrMap.Length); foreach (string row in StrMap) { if ( row == null) continue; string cleanRow = row.TrimEnd(); if (cleanRow.Length == 0) continue; if (cleanRow.Length > maxx) maxx = cleanRow.Length; InputMap.Add(cleanRow); } SizeInt sz = new SizeInt(maxx, InputMap.Count); Init(sz); for(int cx=0; cx<sz.X; cx++) for (int cy = 0; cy < sz.Y; cy++) { // Default value this[cx, cy] = CellStates.Void; if (InputMap.Count <= cy) continue; if (InputMap[cy].Length <= cx) continue; for (int cell = 0; cell < CellStatesClass.Size; cell++) { if (ValidChars[cell].IndexOf(InputMap[cy][cx]) >= 0) { // Hit this[cx, cy] = (CellStates)cell; } } } }
public Recess(string name, SizeInt aSize) : base(name, aSize) { }
public RootPathVisualisation(SizeInt cellSize, SolverController controller) { this.cellSize = cellSize; this.controller = controller; }
/// <summary> /// Constructor /// </summary> /// <param name="roomID">Room name</param> /// <param name="aSize">MapSize</param> public Room(string roomID, SizeInt aSize) : base(roomID, aSize) { this.roomID = roomID; doors = new List<Door>(); }
/// <summary> /// Resize the puzzle /// </summary> /// <param name="newSize"></param> public void Resize(SizeInt newSize) { if (newSize.Equals(Size)) return; CellStates[,] old = map; // Min common size SizeInt minMap = SizeInt.Min(Size, newSize); Init(newSize); for (int cx=0; cx<minMap.X; cx++) for (int cy = 0; cy < minMap.Y; cy++) { this[cx, cy] = old[cx, cy]; } }
public VectorInt Multiply(SizeInt value) { return new VectorInt(x * value.X, y * value.Y); }
/// <summary> /// Overloaded Constructor /// </summary> /// <param name="aSize"></param> public Bitmap(SizeInt aSize) : this(aSize.X, aSize.Y) { }
public VectorInt Subtract(SizeInt value) { return new VectorInt(x - value.X, y - value.Y); }
public RectangleInt(VectorInt aTopLeft, SizeInt aSize) { TopLeft = aTopLeft; BottomRight = aTopLeft.Add(aSize); }
public SizeInt(SizeInt copy) : this(copy.X, copy.Y) { }
public VectorInt Divide(SizeInt value) { return new VectorInt(x / value.X, y / value.Y); }
public BitmapViewerVisualisation(Dictionary<string, BitmapViewer.Layer> layers, SizeInt size) { GridSize = size; CellSize = new SizeInt(16, 16); this.layers = layers; }