public void ResizeBox(int top, int left, int bottom, int right)
{
SimpleRect rect = GetSelectedCollisionBox();
rect.TopLeft = new Point(left, top);
rect.BottomRight = new Point(right, bottom);
}
public void TestNodeToEdgeRelation()
{
var node = new SimpleRect();
var edge = new LineEdge();
Assert.AreEqual(0, node.Outgoings.Count);
Assert.AreEqual(0, node.Incomings.Count);
Assert.AreEqual(null, edge.Source);
Assert.AreEqual(null, edge.Target);
edge.Source = node;
Assert.AreEqual(1, node.Outgoings.Count);
Assert.AreEqual(node, edge.Source);
node.Outgoings.Remove(edge);
Assert.AreEqual(0, node.Outgoings.Count);
Assert.AreEqual(null, edge.Source);
node.Incomings.Add(edge);
Assert.AreEqual(1, node.Incomings.Count);
Assert.AreEqual(node, edge.Target);
edge.Target = null;
Assert.AreEqual(0, node.Outgoings.Count);
Assert.AreEqual(null, edge.Source);
}
private void DrawSelectedCollisionBoxes()
{
if (selectedMode == SELECTEDMODE.NONE)
{
return;
}
else if (selectedMode == SELECTEDMODE.HIT_ROOT)
{
foreach (SimpleRectNode node in collisionFrameData.HitBoxKeyFrameData[selectedKeyFrame][selectedRootIndex].Children)
{
DrawSelectedCollisionBox(node);
}
}
else if (selectedMode == SELECTEDMODE.HURT_ROOT)
{
foreach (SimpleRectNode node in collisionFrameData.HurtBoxKeyFrameData[selectedKeyFrame][selectedRootIndex].Children)
{
DrawSelectedCollisionBox(node);
}
}
else if (selectedMode == SELECTEDMODE.HIT_BOX)
{
DrawSelectedCollisionBox(collisionFrameData.HitBoxKeyFrameData[selectedKeyFrame][selectedRootIndex].Children[selectedIndex]);
}
else if (selectedMode == SELECTEDMODE.HURT_BOX)
{
DrawSelectedCollisionBox(collisionFrameData.HurtBoxKeyFrameData[selectedKeyFrame][selectedRootIndex].Children[selectedIndex]);
}
else if (selectedMode == SELECTEDMODE.CHAR_COLLIDER)
{
CharacterCollider collider = collisionFrameData.CharacterColliderFrameData[selectedKeyFrame];
SimpleRect rect = collider.WithOffset(OriginPoint);
ssr.DrawCharacterCollider(collider, OriginPoint, Color.Yellow);
}
}
private void DrawSelectedCollisionBox(SimpleRectNode node)
{
if (collisionFrameData.CharacterColliderFrameData.ContainsKey(selectedKeyFrame))
{
SimpleRect rect = node.WithOffset(collisionFrameData.CharacterColliderFrameData[selectedKeyFrame].GetOrigin() + OriginPoint);
ssr.DrawRect(rect.TopLeft, rect.BottomRight, Color.Yellow, false, 2);
}
}
public override LevelGenOutput GetOutput()
{
LevelGenOutput output = base.GetOutput();
output.AddMapInfo(new LevelGenRoomInfo(SimpleRect.RectListToSimpleRectList(this.Rooms)));
output.AddMapInfo(new LevelGenCorridorInfo(_corridorTiles));
return(output);
}
public static TempContext <SimpleRect> Borrow(out SimpleRect simpleRect)
{
if (!Temp <SimpleRect> .IsInit())
{
Temp <SimpleRect> .SetNewHandler(() => new SimpleRect());
}
return(Temp <SimpleRect> .Borrow(out simpleRect));
}
public void TestNode()
{
var fig1 = new SimpleRect();
var fig2 = new SimpleRect();
var fig3 = new SimpleRect();
TestStructure(fig1, fig2, fig3);
}
// ========================================
// constructor
// ========================================
public MoveEdgePointHandle(EdgePointRef edgePointRef)
{
var fig = new SimpleRect();
_figure = fig;
_figureSize = new Size(8, 8);
_request = new MoveEdgePointRequest();
_request.EdgePointRef = edgePointRef;
}
// ========================================
// constructor
// ========================================
public NewEdgePointHandle(EdgePointRef prevEdgePointRef)
{
var fig = new SimpleRect();
fig.Foreground = Color.Gray;
_figure = fig;
_figureSize = new Size(8, 8);
_request = new NewEdgePointRequest();
_request.PrevEdgePointRef = prevEdgePointRef;
}
static void CheckInit()
{
if (s_threadInit == null)
{
s_threadInit = new object();
s_stroke = new Stroke(1);
s_roundRect = new RoundedRect();
s_simpleRect = new SimpleRect();
s_ellipse = new Ellipse();
}
}
public override IFigure CreateFeedback(IRequest request)
{
var feedback = new SimpleRect();
feedback.Foreground = Color.Red;
feedback.IsForegroundEnabled = true;
feedback.IsBackgroundEnabled = false;
feedback.BorderWidth = 2;
feedback.Bounds = _Host.Figure.Bounds;
return(feedback);
}
private bool findBSPCAComboSpawns(LevelGenOutput output)
{
List <LevelGenMap.Coordinate> openTiles = new List <LevelGenMap.Coordinate>(output.OpenTiles);
openTiles.Shuffle();
EnemySelector enemySelector = new EnemySelector();
int difficulty = ProgressData.GetCurrentDifficulty();
IntegerVector enemyCountRange = output.Input.GetCurrentNumEnemiesRange();
int[] guaranteedEnemiesPlaced = new int[output.Input.GuaranteedEnemiesByDifficulty.Length];
this.NumEnemies = Random.Range(enemyCountRange.X, enemyCountRange.Y + 1);
LevelGenCaveInfo caveInfo = output.MapInfo[LevelGenCaveInfo.KEY] as LevelGenCaveInfo;
if (ProgressData.IsMiniBoss(ProgressData.MostRecentTile))
{
findMinibossSpawn(openTiles, (caveInfo.Data as List <List <LevelGenMap.Coordinate> >)[0]);
}
LevelGenRoomInfo roomInfo = output.MapInfo[LevelGenRoomInfo.KEY] as LevelGenRoomInfo;
List <SimpleRect> availableRooms = new List <SimpleRect>(roomInfo.Data as List <SimpleRect>);
availableRooms.Shuffle();
// Player room
SimpleRect playerRoom = availableRooms[availableRooms.Count - 1];
availableRooms.RemoveAt(availableRooms.Count - 1);
List <LevelGenMap.Coordinate> playerRoomCoords = coordinatesInRoom(playerRoom);
openTiles.RemoveList(playerRoomCoords);
playerRoomCoords.Shuffle();
for (int p = 0; p < DynamicData.MAX_PLAYERS; ++p)
{
if (DynamicData.GetSessionPlayer(p).HasJoined)
{
_playerSpawns.Add(playerRoomCoords[playerRoomCoords.Count - 1].integerVector);
playerRoomCoords.RemoveAt(playerRoomCoords.Count - 1);
}
}
if (openTiles.Count <= (this.NumEnemies + DynamicData.MAX_PLAYERS) * output.Input.MinDistanceBetweenSpawns * 2 + 1)
{
Debug.Log("Regeneration necessary - CA");
return(false);
}
else
{
spawnSimple(0, output, guaranteedEnemiesPlaced, enemySelector, difficulty, openTiles, false);
}
return(true);
}
// ========================================
// constructor
// ========================================
public HighlightRole() : base()
{
_feedback = new Lazy <IFigure>(
() => {
var fig = new SimpleRect();
fig.Foreground = FigureConsts.HighlightColor;
fig.Background = FigureConsts.HighlightBrush;
return(fig);
}
);
}
public void TestFindFigure()
{
var content = new Layer();
var fig1 = new SimpleRect();
content.Bounds = new Rectangle(0, 0, 50, 50);
fig1.Bounds = new Rectangle(0, 0, 100, 100);
content.Children.Add(fig1);
Assert.AreEqual(fig1, content.FindFigure(fig => fig.ContainsPoint(new Point(10, 10)), true));
Assert.AreEqual(null, content.FindFigure(fig => fig.ContainsPoint(new Point(60, 60)), true));
}
// ========================================
// constructor
// ========================================
public DropTextRole()
{
_feedback = new Lazy <IFigure>(
() => {
var ret = new SimpleRect();
ret.MinSize = new Size(2, 10);
ret.Size = new Size(2, 10);
ret.Foreground = Color.Red;
return(ret);
}
);
}
public void TestNodeFigurePersist()
{
var persister = new Externalizer();
var node = new SimpleRect();
node.Bounds = new Rectangle(0, 0, 100, 100);
IMemento mem = persister.Save(node);
var onode = persister.Load(mem) as IConnectable;
Assert.AreNotEqual(node, onode);
Assert.AreEqual(new Rectangle(0, 0, 100, 100), onode.Bounds);
}
private void RefreshBoxes()
{
DisableBoxEvents();
SimpleRect rect = renderPreview.GetSelectedCollisionBox();
numericTop.Value = rect.TopLeft.Y;
numericLeft.Value = rect.TopLeft.X;
numericBottom.Value = rect.BottomRight.Y;
numericRight.Value = rect.BottomRight.X;
EnableBoxEvents();
}
// ========================================
// constructor
// ========================================
public SelectionIndicatingHandle()
{
_figure = new MirageLayer();
_figure.Layout = new StackLayout();
var fig = new SimpleRect()
{
BorderWidth = 1,
Foreground = FigureConsts.HighlightColor,
Background = FigureConsts.HighlightBrush,
};
_figure.Children.Add(fig);
}
public override void Draw(CanvasPainter p)
{
p.FillColor = ColorRGBA.Blue;
p.FillRectangle(0, 70, 150, 120);
//-------------------------------------------
var innerGradient = new Gradients.GvcRadial();
SpanInterpolatorLinear linerInterpolator = new SpanInterpolatorLinear(Affine.IdentityMatrix);
LinearGradientColorsProvider linearColorProvider = new LinearGradientColorsProvider(ColorRGBA.Red, ColorRGBA.Yellow);
SpanGenGradient spanGenGradient = new SpanGenGradient(linerInterpolator,
innerGradient,
linearColorProvider,
0, 150);
SimpleRect srect = new SimpleRect(0, 0, 150, 50);
p.Fill(srect.MakeVxs(), spanGenGradient);
}
private List <LevelGenMap.Coordinate> coordinatesInRoom(SimpleRect room)
{
List <LevelGenMap.Coordinate> roomCoords = new List <LevelGenMap.Coordinate>();
for (int x = room.X; x < room.X + room.Width; ++x)
{
for (int y = room.Y; y < room.Y + room.Height; ++y)
{
LevelGenMap.Coordinate?coord = _map.ConstructValidCoordinate(x, y, false);
if (coord.HasValue)
{
roomCoords.Add(coord.Value);
}
}
}
return(roomCoords);
}
// ========================================
// method
// ========================================
public override IFigure CreateFigure(object model)
{
var catefig = new Layer();
catefig.Layout = new ListLayout(Insets.Empty);
_categoryLabel = new SimpleRect();
_categoryLabel.Padding = new Insets(20, 2, 4, 2);
_categoryLabel.Font = new FontDescription(_categoryLabel.Font, FontStyle.Bold);
_categoryLabel.Foreground = SystemColors.ButtonShadow;
_categoryLabel.Background = new GradientBrushDescription(
SystemColors.ButtonShadow, SystemColors.ButtonFace
);
catefig.Children.Add(_categoryLabel);
return(catefig);
}
// ========================================
// constructor
// ========================================
public MoveOrthogonalEdgePointHandle(EdgePointRef prevEdgePointRef)
{
var fig = new SimpleRect();
fig.Foreground = Color.Gray;
fig.Background = new SolidBrushDescription(Color.Yellow);
_figure = fig;
_figureSize = new Size(8, 8);
_prevPointRequest = new MoveEdgePointRequest();
_prevPointRequest.AdjustGrid = false;
_prevPointRequest.DontFlatten = true;
_prevPointRequest.EdgePointRef = prevEdgePointRef;
_nextPointRequest = new MoveEdgePointRequest();
_nextPointRequest.AdjustGrid = false;
_nextPointRequest.DontFlatten = true;
_nextPointRequest.EdgePointRef = prevEdgePointRef.Next;
}
public void TestClone()
{
var n1 = new SimpleRect();
var n2 = new SimpleRect();
var n3 = new SimpleRect();
var n4 = new SimpleRect();
var n5 = new SimpleRect();
// n1
// n2
// n4
// n5
// n3
n2.Parent = n1;
n3.Parent = n1;
n4.Parent = n2;
n5.Parent = n2;
n1.Location = new Point(1, 1);
n2.Location = new Point(2, 2);
n3.Location = new Point(3, 3);
n4.Location = new Point(4, 4);
n5.Location = new Point(5, 5);
Assert.AreEqual(2, n2.Children.Count);
var n2clone = n2.CloneFigure();
Assert.AreNotEqual(n2, n2clone);
Assert.AreEqual(new Point(2, 2), n2clone.Location);
Assert.AreEqual(null, n2clone.Parent);
Assert.AreEqual(2, n2clone.Children.Count);
Assert.AreEqual(new Point(4, 4), n2clone.Children[0].Location);
Assert.AreEqual(new Point(5, 5), n2clone.Children[1].Location);
Assert.AreNotEqual(n4, n2clone.Children[0]);
Assert.AreNotEqual(n5, n2clone.Children[1]);
n2clone.Children[0].Location = new Point(40, 40);
Assert.AreEqual(new Point(40, 40), n2clone.Children[0].Location);
Assert.AreEqual(new Point(4, 4), n4.Location);
}
public override void Draw(PixelFarm.Drawing.Painter p)
{
if (p is AggPainter)
{
var p2 = (AggPainter)p;
p.FillColor = Drawing.Color.Red;
p.FillRect(0, 70, 150, 120);
//-------------------------------------------
var innerGradient = new Gradients.GvcRadial();
SpanInterpolatorLinear linerInterpolator = new SpanInterpolatorLinear(Affine.IdentityMatrix);
LinearGradientColorsProvider linearColorProvider = new LinearGradientColorsProvider(Drawing.Color.Red, Drawing.Color.Yellow);
SpanGenGradient spanGenGradient = new SpanGenGradient(linerInterpolator,
innerGradient,
linearColorProvider,
0, 150);
SimpleRect srect = new SimpleRect(0, 0, 150, 50);
var v1 = GetFreeVxs();
p2.Fill(srect.MakeVxs(v1), spanGenGradient);
ReleaseVxs(ref v1);
}
}
private bool findBSPSpawns(LevelGenOutput output)
{
List <LevelGenMap.Coordinate> openTiles = new List <LevelGenMap.Coordinate>(output.OpenTiles);
openTiles.Shuffle();
LevelGenRoomInfo roomInfo = output.MapInfo[LevelGenRoomInfo.KEY] as LevelGenRoomInfo;
EnemySelector enemySelector = new EnemySelector();
IntegerVector enemyCountRange = output.Input.GetCurrentNumEnemiesRange();
this.NumEnemies = Random.Range(enemyCountRange.X, enemyCountRange.Y + 1);
if (ProgressData.IsMiniBoss(ProgressData.MostRecentTile))
{
findMinibossSpawn(openTiles, openTiles);
}
int difficulty = ProgressData.GetCurrentDifficulty();
int[] guaranteedEnemiesPlaced = new int[output.Input.GuaranteedEnemiesByDifficulty.Length];
int totalGuarantees = 0;
for (int i = 0; i < guaranteedEnemiesPlaced.Length; ++i)
{
totalGuarantees += output.Input.GuaranteedEnemiesByDifficulty[i];
}
if (openTiles.Count <= (this.NumEnemies + DynamicData.MAX_PLAYERS) * output.Input.MinDistanceBetweenSpawns * 2 + 1 ||
roomInfo == null || roomInfo.Data.Count < 4 + difficulty)
{
Debug.Log("Regeneration necessary - BSP 1");
return(false);
}
else
{
List <SimpleRect> availableRooms = new List <SimpleRect>(roomInfo.Data as List <SimpleRect>);
availableRooms.Shuffle();
// Player room
SimpleRect playerRoom = availableRooms[availableRooms.Count - 1];
availableRooms.RemoveAt(availableRooms.Count - 1);
List <LevelGenMap.Coordinate> playerRoomCoords = coordinatesInRoom(playerRoom);
openTiles.RemoveList(playerRoomCoords);
playerRoomCoords.Shuffle();
for (int p = 0; p < DynamicData.MAX_PLAYERS; ++p)
{
if (DynamicData.GetSessionPlayer(p).HasJoined)
{
_playerSpawns.Add(playerRoomCoords[playerRoomCoords.Count - 1].integerVector);
playerRoomCoords.RemoveAt(playerRoomCoords.Count - 1);
}
}
if (openTiles.Count <= this.NumEnemies * output.Input.MinDistanceBetweenSpawns * 2 + 1)
{
Debug.Log("Regeneration necessary - BSP 2");
return(false);
}
else
{
int enemiesSpawned = 0;
int guaranteesSpawned = 0;
bool haveUnitedAllRoomsSoFar = true;
// Enemy rooms
for (int r = 0; r < availableRooms.Count; ++r)
{
SimpleRect room = availableRooms[r];
if (this.NumEnemies - enemiesSpawned < 4 || (r == availableRooms.Count - 1 && haveUnitedAllRoomsSoFar && guaranteesSpawned < totalGuarantees))
{
break;
}
if (Random.value > 0.65f)
{
haveUnitedAllRoomsSoFar = false;
continue;
}
List <EnemySpawn> roomSpawns = new List <EnemySpawn>();
EnemySelector.WeightSet roomWeightSet = new EnemySelector.WeightSet();
enemySelector.AddWeightSet(roomWeightSet);
// United-spawn room
int favoredEnemyId = pickMaybeGuaranteedEnemy(guaranteesSpawned, totalGuarantees, enemiesSpawned, difficulty, guaranteedEnemiesPlaced, output, enemySelector);
roomWeightSet.WeightsByEnemyId[favoredEnemyId] = 100;
List <IntegerVector> roomCorners = new List <IntegerVector>();
roomCorners.Add(new IntegerVector(room.X, room.Y));
roomCorners.Add(new IntegerVector(room.X + room.Width, room.Y));
roomCorners.Add(new IntegerVector(room.X, room.Y + room.Height));
roomCorners.Add(new IntegerVector(room.X + room.Width, room.Y + room.Height));
roomCorners.Shuffle();
IntegerVector firstPosition = roomCorners[roomCorners.Count - 1];
++enemiesSpawned;
roomSpawns.Add(new EnemySpawn(firstPosition, favoredEnemyId));
roomCorners.RemoveAt(roomCorners.Count - 1);
int enemyDifficulty = StaticData.EnemyData.EnemyTypes[favoredEnemyId].Difficulty;
if (guaranteedEnemiesPlaced[enemyDifficulty] < output.Input.GuaranteedEnemiesByDifficulty[enemyDifficulty])
{
guaranteedEnemiesPlaced[enemyDifficulty] += 1;
++guaranteesSpawned;
}
foreach (IntegerVector position in roomCorners)
{
++enemiesSpawned;
int enemyId = enemySelector.ChooseEnemy(difficulty);
roomSpawns.Add(new EnemySpawn(position, enemyId));
enemyDifficulty = StaticData.EnemyData.EnemyTypes[enemyId].Difficulty;
if (guaranteedEnemiesPlaced[enemyDifficulty] < output.Input.GuaranteedEnemiesByDifficulty[enemyDifficulty])
{
guaranteedEnemiesPlaced[enemyDifficulty] += 1;
++guaranteesSpawned;
}
}
bool extraTwo = false;
if (this.NumEnemies - enemiesSpawned > 2 && Random.value < CHANCE_FOR_EXTRA_TWO_IN_BSP_ROOM)
{
// Let's add 2 along the walls of the longest room dimension
extraTwo = true;
favoredEnemyId = pickMaybeGuaranteedEnemy(guaranteesSpawned, totalGuarantees, enemiesSpawned, difficulty, guaranteedEnemiesPlaced, output, enemySelector);
roomWeightSet.WeightsByEnemyId[favoredEnemyId] = 100;
IntegerVector position1;
IntegerVector position2;
if (room.Width > room.Height)
{
position1 = new IntegerVector(room.X + room.Width / 2, room.Y);
position2 = new IntegerVector(room.X + room.Width / 2, room.Y + room.Height);
}
else
{
position1 = new IntegerVector(room.X, room.Y + room.Height / 2);
position2 = new IntegerVector(room.X + room.Width, room.Y + room.Height / 2);
}
enemiesSpawned += 2;
roomSpawns.Add(new EnemySpawn(position1, favoredEnemyId));
enemyDifficulty = StaticData.EnemyData.EnemyTypes[favoredEnemyId].Difficulty;
if (guaranteedEnemiesPlaced[enemyDifficulty] < output.Input.GuaranteedEnemiesByDifficulty[enemyDifficulty])
{
guaranteedEnemiesPlaced[enemyDifficulty] += 1;
++guaranteesSpawned;
}
int enemyId = enemySelector.ChooseEnemy(difficulty);
roomSpawns.Add(new EnemySpawn(position2, enemyId));
enemyDifficulty = StaticData.EnemyData.EnemyTypes[enemyId].Difficulty;
if (guaranteedEnemiesPlaced[enemyDifficulty] < output.Input.GuaranteedEnemiesByDifficulty[enemyDifficulty])
{
guaranteedEnemiesPlaced[enemyDifficulty] += 1;
++guaranteesSpawned;
}
}
_enemySpawns.Add(new EnemySpawnGroup(new IntegerVector(room.X + room.Width / 2, room.Y + room.Height / 2), roomSpawns, ((Mathf.Max(room.Width, room.Height) + 2.6f) / 2.0f) * _tileRenderer.TileRenderSize));
if (!enemySelector.RemoveWeightSet(roomWeightSet))
{
Debug.Log("hrrmmmm");
}
if (extraTwo || Random.value < CHANCE_FOR_REMOVE_SPAWN_ROOM_FOR_FUTURE_BSP)
{
openTiles.RemoveList(coordinatesInRoom(room));
}
}
// Non united-room spawns
spawnSimple(enemiesSpawned, output, guaranteedEnemiesPlaced, enemySelector, difficulty, openTiles, false);
}
}
return(true);
}
// ========================================
// constructor
// ========================================
public RubberbandRole()
{
_feedback = new SimpleRect();
_feedback.Foreground = FigureConsts.HighlightColor;
_feedback.Background = FigureConsts.HighlightBrush;
}
private List<LevelGenMap.Coordinate> coordinatesInRoom(SimpleRect room)
{
List<LevelGenMap.Coordinate> roomCoords = new List<LevelGenMap.Coordinate>();
for (int x = room.X; x < room.X + room.Width; ++x)
{
for (int y = room.Y; y < room.Y + room.Height; ++y)
{
LevelGenMap.Coordinate? coord = _map.ConstructValidCoordinate(x, y, false);
if (coord.HasValue)
roomCoords.Add(coord.Value);
}
}
return roomCoords;
}
private void DrawCollisionBox(SimpleRect rect, Color color)
{
DrawRect(rect, color * _alphaFill, true);
DrawRect(rect, color * _alphaOutline, false);
}
public void TestBringTo()
{
var p = new SimpleRect();
var c0 = new SimpleRect();
var c1 = new SimpleRect();
var c2 = new SimpleRect();
c0.Parent = p;
c1.Parent = p;
c2.Parent = p;
Assert.AreEqual(3, p.Children.Count);
Assert.AreEqual(c0, p.Children[0]);
Assert.AreEqual(c1, p.Children[1]);
Assert.AreEqual(c2, p.Children[2]);
c0.BringToFront(1);
Assert.AreEqual(3, p.Children.Count);
Assert.AreEqual(c1, p.Children[0]);
Assert.AreEqual(c0, p.Children[1]);
Assert.AreEqual(c2, p.Children[2]);
c1.BringToFront(2);
Assert.AreEqual(3, p.Children.Count);
Assert.AreEqual(c0, p.Children[0]);
Assert.AreEqual(c2, p.Children[1]);
Assert.AreEqual(c1, p.Children[2]);
c0.BringToFront(3);
Assert.AreEqual(3, p.Children.Count);
Assert.AreEqual(c2, p.Children[0]);
Assert.AreEqual(c1, p.Children[1]);
Assert.AreEqual(c0, p.Children[2]);
c0.BringToBack(1);
Assert.AreEqual(3, p.Children.Count);
Assert.AreEqual(c2, p.Children[0]);
Assert.AreEqual(c0, p.Children[1]);
Assert.AreEqual(c1, p.Children[2]);
c1.BringToBack(2);
Assert.AreEqual(3, p.Children.Count);
Assert.AreEqual(c1, p.Children[0]);
Assert.AreEqual(c2, p.Children[1]);
Assert.AreEqual(c0, p.Children[2]);
c0.BringToBack(3);
Assert.AreEqual(3, p.Children.Count);
Assert.AreEqual(c0, p.Children[0]);
Assert.AreEqual(c1, p.Children[1]);
Assert.AreEqual(c2, p.Children[2]);
c0.BringToFrontMost();
Assert.AreEqual(3, p.Children.Count);
Assert.AreEqual(c1, p.Children[0]);
Assert.AreEqual(c2, p.Children[1]);
Assert.AreEqual(c0, p.Children[2]);
c0.BringToBackMost();
Assert.AreEqual(3, p.Children.Count);
Assert.AreEqual(c0, p.Children[0]);
Assert.AreEqual(c1, p.Children[1]);
Assert.AreEqual(c2, p.Children[2]);
}
public static Rect SimpleRectToRect(SimpleRect rect)
{
return new Rect(rect.X, rect.Y, rect.Width, rect.Height);
}
public void DrawRect(SimpleRect rect, Color color, bool filled = true, int width = 1)
{
DrawRect(rect.TopLeft, rect.BottomRight, color, filled, width);
}
public static Rect SimpleRectToRect(SimpleRect rect)
{
return(new Rect(rect.X, rect.Y, rect.Width, rect.Height));
}
