public void TwoRooms()
{
var bountry = Bitmap.Create(new[]
{
"#########",
"# ######",
"# ### #",
"###### #",
"#########"
}, x => x == ' ');
var expected = Bitmap.Create(new[]
{
"#########",
"#oo######",
"#oo### #",
"###### #",
"#########"
}, x => x == 'O');
var start = new VectorInt2(1, 1);
var result = FloodFill.Fill(bountry, start);
Assert.Equal(expected, result);
}
private void RenderFloodFillVisualization()
{
var map = OceanNavigator.FromString(new string[]
{
" ## ## ##",
"## ##",
"#### ## ## #",
" ## ###### #",
" ### ## ",
" ## ### ### ",
" ### ## #### ",
"####### #### ",
"## #### #",
" ## ###",
" ",
" ",
"##### ## #",
"##### #### ##",
" ## ##"
});
var ff = new FloodFill(map);
var overlay = ff.GetRegion(new Location(0, 0));
var mv = new OceanNavigatorVisualizer(map);
pictureBox2.Image = mv.Render(overlay);
}
public void FloodFillTestMethod()
{
FloodFill floodFill = new FloodFill();
int[,] result = new int[, ] {
{ 2, 2, 2 }, { 2, 2, 0 }, { 2, 0, 1 }
};
for (int i = 0; i < result.GetLength(0); i++)
{
for (int j = 0; j < result.GetLength(1); j++)
{
Assert.AreEqual(result[i, j], floodFill.FloodFillSln
(new int[, ] {
{ 1, 1, 1 }, { 1, 1, 0 }, { 1, 0, 1 }
}, 1, 1, 2)[i, j]);
}
}
int[,] result2 = new int[, ] {
{ 0, 0, 0 }, { 0, 1, 1 }
};
for (int i = 0; i < result2.GetLength(0); i++)
{
for (int j = 0; j < result2.GetLength(1); j++)
{
Assert.AreEqual(result2[i, j], floodFill.FloodFillSln
(new int[, ] {
{ 0, 0, 0 }, { 0, 1, 1 }
}, 1, 1, 1)[i, j]);
}
}
}
public void Given_FloodFill_When_GettingRegionSize_Then_CorrectSizeReturned()
{
var map = OceanNavigator.FromString(new string[]
{
" ## ## ##",
"## ##",
"#### ## ## #",
" ## ###### #",
" ### ## ",
" ## ### ### ",
" ### ## #### ",
"####### #### ",
"## #### #",
" ## ###",
" ",
" ",
"##### ## #",
"##### #### ##",
" ## ##"
});
var ff = new FloodFill(map);
var size = ff.GetRegionSize(new Location(0, 0));
size.Should().Be(124);
var size2 = ff.GetRegionSize(new Location(8, 6));
size2.Should().Be(3);
}
void detectHoles()
{
renderTexture.DiscardContents();
RenderTexture.active = camera.GetComponent <Camera> ().targetTexture;
camera.GetComponent <Camera> ().Render();
texture.filterMode = FilterMode.Point;
texture.wrapMode = TextureWrapMode.Clamp;
texture.ReadPixels(new Rect(0, 0, renderTexture.width, renderTexture.height), 0, 0);
texture.Apply();
for (int i = 0; i < 4; i++)
{
TextureScale.Half(texture);
}
FloodFill.Fill(texture, 0, 0);
FloodFill.Fill(texture, texture.width - 1, 0);
FloodFill.Fill(texture, texture.width - 1, texture.height - 1);
FloodFill.Fill(texture, 0, texture.height - 1);
// holes
ConnectedComponentLabeling ccl = new ConnectedComponentLabeling();
ccl.Process(texture, texture, false, false);
holesPositions = ccl.holesAveragePositions;
holesPositions.Add(new Vector2(0f, 0f));
holesPositions.Add(new Vector2((float)texture.width, 0f));
holesPositions.Add(new Vector2(0f, (float)texture.height));
holesPositions.Add(new Vector2((float)texture.width, (float)texture.height));
}
public void Given_FloodFill_When_FillingValidRegion_Then_EntireRegionIsFilled()
{
var map = OceanNavigator.FromString(new string[]
{
" ## ## ##",
"## ##",
"#### ## ## #",
" ## ###### #",
" ### ## ",
" ## ### ### ",
" ### ## #### ",
"####### #### ",
"## #### #",
" ## ###",
" ",
" ",
"##### ## #",
"##### #### ##",
" ## ##"
});
var ff = new FloodFill(map);
var start = new Location(0, 0);
var filled = ff.GetRegion(start);
filled[0, 0].Should().Be(true);
filled[3, 10].Should().Be(true);
// Not part of the original region
filled[8, 6].Should().Be(false);
// Not traversable
filled[4, 0].Should().Be(false);
}
public void FillsIrregularArea()
{
var map = new int[][] {
new int[] { 0, 0, 1, 1, 1 },
new int[] { 1, 1, 0, 0, 1 },
new int[] { 1, 0, 0, 0, 1 },
new int[] { 1, 0, 0, 0, 1 },
new int[] { 1, 0, 0, 0, 1 },
new int[] { 1, 1, 1, 1, 1 },
new int[] { 0, 0, 0, 0, 0 }
};
var f = new FloodFill((p) => {
if (p.x >= 0 && p.x < map.Length && p.y >= 0 && p.y < map[p.x].Length)
{
var matches = map[p.x][p.y] == 0;
if (matches)
{
map[p.x][p.y] = 2;
}
return(matches);
}
return(false);
});
var totalFilled = f.Fill(new Point(2, 1));
Assert.AreEqual(totalFilled, 11);
Assert.AreEqual(map[1][2], 2);
Assert.AreEqual(map[1][3], 2);
}
private void IntegrityCheck()
{
if (Application.isEditor || Debug.isDebugBuild)
{
var result = FloodFill.BlockIntegrityTest(dungeon);
Debug.Assert(result, "Generated dungeon is fractured!");
}
}
public static void FloodFillUsingWallAndCratesInline(IBitmap wall, IBitmap crate, VectorInt2 pp, IBitmap output)
{
var fillConstraints = new BitmapSpan(wall.Size, stackalloc uint[wall.Height]);
fillConstraints.SetBitwiseOR(wall, crate);
FloodFill.Fill(fillConstraints, pp, output);
}
public static Bitmap FloodFillUsingWallAndCrates(IBitmap wall, IBitmap crate, VectorInt2 pp)
{
var fillConstraints = new BitmapSpan(wall.Size, stackalloc uint[wall.Height]);
fillConstraints.SetBitwiseOR(wall, crate);
return(FloodFill.Fill(fillConstraints, pp));
}
public override void MouseDown(int mx, int my, bool isRightButton)
{
int x = mx - imgOffsetX;
int y = my - imgOffsetY;
FloodFill filler = new FloodFill(Color.Red);
filler.Fill(imageToFillOn, x, y);
}
public void AlwaysReturnsInput()
{
var floodFill = new FloodFill(7);
Assert.AreEqual(7, floodFill.GetBlockID(new BlockPosition(0, 0, 0)));
Assert.AreEqual(7, floodFill.GetBlockID(new BlockPosition(-100, 31235, 1912)));
Assert.AreEqual(7, floodFill.GetBlockID(new BlockPosition(129, 0, 100000)));
}
public override float Evaluate(Representation representation)
{
int texSize = 1024;
RenderTexture renderTexture = new RenderTexture(texSize, texSize, 0);
RenderTexture renderTextureTemp = RenderTexture.active;
GameObject camera = new GameObject("Camera");
camera.transform.position = new Vector3(0, 150f, -300f);
camera.AddComponent <Camera> ();
camera.GetComponent <Camera> ().backgroundColor = Color.white;
camera.GetComponent <Camera> ().orthographic = true;
camera.GetComponent <Camera> ().orthographicSize = 150;
camera.GetComponent <Camera> ().targetTexture = renderTexture;
camera.AddComponent <GrayscaleBinary> ();
camera.GetComponent <GrayscaleBinary> ().shader = Shader.Find("Hidden/GrayscaleBinary");
RenderTexture.active = renderTexture;
camera.GetComponent <Camera> ().Render();
Texture2D texture = new Texture2D(renderTexture.width, renderTexture.height, TextureFormat.RGB24, false);
texture.filterMode = FilterMode.Point;
texture.wrapMode = TextureWrapMode.Clamp;
texture.ReadPixels(new Rect(0, 0, renderTexture.width, renderTexture.height), 0, 0);
texture.Apply();
TextureScale.Half(texture);
texSize /= 2;
// texture to copy
Texture2D tempTex = new Texture2D(texture.width, texture.height);
tempTex.SetPixels(texture.GetPixels());
// fill
FloodFill.Fill(tempTex, 0, 0);
FloodFill.Fill(tempTex, tempTex.width - 1, 0);
FloodFill.Fill(tempTex, tempTex.width - 1, tempTex.height - 1);
FloodFill.Fill(tempTex, 0, tempTex.height - 1);
// holes
ConnectedComponentLabeling ccl = new ConnectedComponentLabeling();
int holes = ccl.Process(tempTex, texture, false);
RenderTexture.active = renderTextureTemp;
GameObject.DestroyImmediate(camera);
return(holes * (1f + Mathf.Exp(2f)) / (28.4103f * Mathf.Exp(2f)) + 43.9867f / 28.4103f);
}
private static void WalkTheDungeon(Game gameInstance)
{
Logger.Info("Walking the dungeon...");
var pathFinder = new AStarPathFinding();
var movementProfile = new HumanoidMovement();
var visibilityMap = new VisibilityMap(gameInstance.Terrain.Width, gameInstance.Terrain.Height, null, null);
var walkableLocations = gameInstance.Terrain.WalkableLocations(movementProfile).ToList();
FloodFill.Fill(gameInstance.Terrain, visibilityMap, movementProfile, walkableLocations[Rng.Next(walkableLocations.Count - 1)]);
var walkableUnseenLocations = GetWalkableUnseenLocations(gameInstance.Terrain, visibilityMap, movementProfile).ToList();
while (walkableUnseenLocations.Count > 0)
{
var closestExploredLocation = GetClosestExploredLocation(gameInstance.Terrain, visibilityMap, movementProfile, walkableUnseenLocations[Rng.Next(walkableUnseenLocations.Count - 1)]);
var closestUnexploredLocation = GetClosestUnexploredLocation(gameInstance.Terrain, visibilityMap, movementProfile, closestExploredLocation.Value);
var movementPath = pathFinder.FindPath(gameInstance.Terrain, new List <IActor>(), new DiggerMovement(), closestExploredLocation.Value, closestUnexploredLocation.Value);
foreach (var node in movementPath)
{
gameInstance.Terrain[node.Location] = new Floor();
visibilityMap[node.Location].WasSeen = true;
}
visibilityMap[closestUnexploredLocation.Value].WasSeen = false;
FloodFill.Fill(gameInstance.Terrain, visibilityMap, movementProfile, closestUnexploredLocation.Value);
walkableUnseenLocations = GetWalkableUnseenLocations(gameInstance.Terrain, visibilityMap, movementProfile).ToList();
}
//digger.VisibilityMap.UpdateVisibilityMap(gameInstance.Terrain, gameInstance.LightMap, digger.Location.Coordinate);
//var command = digger.Intellect.GetNextAction();
//while (command is MoveCommand)
//{
// var result = command.Execute();
// if ((!result.Success) && (command is MoveCommand))
// {
// // The move action failed
// // Ask the actor for a default action on bump
// var defaultBumpAction = digger.Intellect.GetDefaultBumpAction((MoveCommand)command);
// if (defaultBumpAction != null)
// defaultBumpAction.Execute();
// }
// digger.VisibilityMap.UpdateVisibilityMap(gameInstance.Terrain, gameInstance.LightMap, digger.Location.Coordinate);
// command = digger.Intellect.GetNextAction();
//}
//gameInstance.RemoveActor(digger);
Logger.Info("Dungeon walk complete.");
}
void InternalTest(int[][] image, int sr, int sc, int newColor, int[][] expected)
{
int[][] actual = FloodFill.Solve(image, sr, sc, newColor);
Assert.Equal <int>(expected.GetLength(0), actual.GetLength(0));
for (int i = 0; i < image.GetLength(0); i++)
{
for (int j = 0; j < image[i].GetLength(0); j++)
{
Assert.Equal <int>(expected[i][j], actual[i][j]);
}
}
}
private void BeginDrawingObject(MouseButtonEventArgs e)
{
Vector mousePos = (Vector)e.GetPosition(MainImageContainer);
switch (currentlyPressedButton.Name)
{
case "DrawLineButon":
ILine line = new ClippedLine((Vector)e.GetPosition(MainImageContainer), (Vector)e.GetPosition(MainImageContainer), 2, CurrentColor, ClipRectangles);
currentlyDrawnObject = line;
DrawingObjects.Add(currentlyDrawnObject);
currentlyDrawnPoint = line.Point2;
break;
case "DrawCircleButton":
MidpointCircle circle = new MidpointCircle((Vector)e.GetPosition(MainImageContainer), (Vector)e.GetPosition(MainImageContainer), CurrentColor);
currentlyDrawnObject = circle;
DrawingObjects.Add(currentlyDrawnObject);
currentlyDrawnPoint = circle.radiusUtilityPoint;
break;
case "DrawPolygonButton":
Polygon poly = new FilledPolygon(CurrentColor, 2, ClipRectangles, (Vector)e.GetPosition(MainImageContainer), (Vector)e.GetPosition(MainImageContainer));
currentlyDrawnObject = poly;
DrawingObjects.Add(currentlyDrawnObject);
currentlyDrawnPoint = poly.Points[1];
break;
case "DrawCapsuleButton":
Capsule cap = new Capsule(mousePos, mousePos, 0, CurrentColor);
currentlyDrawnObject = cap;
DrawingObjects.Add(currentlyDrawnObject);
currentlyDrawnPoint = cap.Point2;
break;
case "DrawRectangleButton":
DrawingRectangle rec = new DrawingRectangle(CurrentColor, 2, mousePos, mousePos);
currentlyDrawnObject = rec;
DrawingObjects.Add(currentlyDrawnObject);
currentlyDrawnPoint = rec.Points[2];
break;
case "FloodFillButton":
FloodFill fill = new FloodFill(mousePos, CurrentColor);
DrawingObjects.Add(fill);
currentState = UIState.PreparingToDraw;
break;
default:
throw new NotImplementedException();
}
}
public void CycleAndFill()
{
var map = new int[][] {
new int[] { 0, 0, 0, 0, 0 },
new int[] { 0, 0, 0, 0, 0 },
new int[] { 0, 0, 1, 1, 1 },
new int[] { 0, 0, 1, 0, 1 },
new int[] { 1, 1, 1, 0, 1 },
new int[] { 1, 0, 0, 0, 1 },
new int[] { 1, 0, 0, 0, 1 },
new int[] { 1, 1, 1, 1, 1 }
};
// Detect shape
var d = new CycleDetection(new Point(4, 0), (p) => {
if (p.x >= 0 && p.x < map.Length && p.y >= 0 && p.y < map[p.x].Length)
{
return(map[p.x][p.y] == 1);
}
return(false);
});
Assert.AreEqual(d.Cycles.Count, 1);
// Find the centroid of the triangle
var centroid = d.Cycles[0].TriangleSample.Centroid;
Assert.AreEqual(centroid, new Point(6, 1));
// Flood fill the interior of the structure
var f = new FloodFill((p) => {
if (p.x >= 0 && p.x < map.Length && p.y >= 0 && p.y < map[p.x].Length)
{
var matches = map[p.x][p.y] == 0;
if (matches)
{
map[p.x][p.y] = 2;
}
return(matches);
}
return(false);
});
var totalFilled = f.Fill(centroid);
Assert.AreEqual(totalFilled, 8);
}
public bool ShowFloodFill(bool randomize)
{
// find all nodes reachable from source node
T source = FindSource(randomize);
var floodFill = new FloodFill <T>(Graph);
Predicate <T> match = p => NodeCosts[p] <= MaxCost / 2;
bool success = floodFill.FindMatching(match, source);
Locations = floodFill.Nodes;
Renderer.InvalidateVisual();
return(success);
}
public SolverNodeRoot CreateRoot(Puzzle puzzle)
{
var crate = puzzle.ToMap(puzzle.Definition.AllCrates);
var moveBoundry = crate.BitwiseOR(puzzle.ToMap(puzzle.Definition.Wall));
var move = FloodFill.Fill(moveBoundry, puzzle.Player.Position);
var root = new SolverNodeRoot(
puzzle.Player.Position, new VectorInt2(),
crate, move,
this,
puzzle
);
return(root);
}
public Boolean isMapAccepted()
{
DesignMap.printDebug();
if (isEmpty())
{
Console.WriteLine("Error Can't Save Map [no object found]");
}
else
{
FloodFill ff = new FloodFill(map, height, width);
if (ff.isFFAccepted())
{
return(true);
}
}
return(false);
}
void Start()
{
_filler = new FloodFill();
_layout = _generator.CreateDungeon();
_rooms = _filler.GetAllRooms <string>(_layout, "Floor");
_dungeon = GridBuilder.Instance.BuildGrid(_layout, transform);
for (int i = 0; i < _rooms.Length; i++)
{
Color Coler = Random.ColorHSV();
for (int j = 0; j < _rooms[i].Count; j++)
{
_dungeon.GetNode(_rooms[i][j]).GetComponent <MeshRenderer>().material.color = Coler;
}
}
}
private Point?GetExploreDestination()
{
//todo, clean up later
var potentiallyReachable = FloodFill.ScanToArray(Player.Position, point => !point.IsMapEdge() && (!Map.Seen[point] || TileDefinition.IsPassable(TileTypeAt(point))));
var dm2 = new DijkstraMap(p => (Map.Seen[p] || p.IsMapEdge())? -1 : 1) //todo, seen==blocked?
{
IsSource = p => (Map.Seen[p] || p.IsMapEdge())
};
dm2.Scan();
//CharacterScreens.PrintDijkstraTest(dm2);
foreach (Point p in Map.GetAllPoints(false))
{
if (dm2[p] == DijkstraMap.Unexplored || dm2[p] == DijkstraMap.Blocked)
{
continue;
}
dm2[p] = -(dm2[p] * dm2[p]);
}
dm2.RescanWithCurrentValues();
//CharacterScreens.PrintDijkstraTest(dm2);
var dm = new DijkstraMap(p => (!Map.Seen[p] || !TileDefinition.IsPassable(TileTypeAt(p)))? -1 : 1)
{
IsSource = p => !Map.Seen[p] && potentiallyReachable[p],
GetSourceValue = p => - (dm2[p])
};
dm.Scan();
//CharacterScreens.PrintDijkstraTest(dm2);
//CharacterScreens.PrintDijkstraTest(dm);
List <Point> playerPath = dm.GetDownhillPath(Player.Position, true, earlyStopCondition: p => !Map.Seen[p]);
if (playerPath.Count == 0)
{
return(null);
}
else
{
return(playerPath[playerPath.Count - 1]);
}
}
public void FillsSimpleArea()
{
var map = new int[][] {
new int[] { 0, 0, 0, 0, 0 },
new int[] { 1, 1, 1, 1, 1 },
new int[] { 1, 0, 0, 0, 1 },
new int[] { 1, 0, 0, 0, 1 },
new int[] { 1, 0, 0, 0, 1 },
new int[] { 1, 1, 1, 1, 1 },
new int[] { 0, 0, 0, 0, 0 }
};
var f = new FloodFill((p) => {
if (p.x >= 0 && p.x < map.Length && p.y >= 0 && p.y < map[p.x].Length)
{
var matches = map[p.x][p.y] == 0;
if (matches)
{
map[p.x][p.y] = 2;
}
return(matches);
}
return(false);
});
var totalFilled = f.Fill(new Point(2, 1));
Assert.AreEqual(totalFilled, 9);
for (var x = 2; x < 5; x++)
{
for (var y = 1; y < 4; y++)
{
Assert.AreEqual(map[x][y], 2);
}
}
}
public void CaseA()
{
var report = new TestReport();
var sample = new[]
{
"#############",
"#a ### b##",
"# A###### ##",
"# ######B ##",
"######### ##",
"#############"
};
var boundry = Bitmap.Create(sample, x => x == '#'); //sample.ToMap('#', 'A', 'B');
var staticMaps = new StaticMaps(
Bitmap.Create(sample, '#'),
Bitmap.Create(sample, ' ', 'a', 'b'),
null,
null
);
var stateMaps = new StateMaps(
Bitmap.Create(sample, 'A', 'B'),
FloodFill.Fill(staticMaps.WallMap, Bitmap.FindPosition(sample, 'a')));
var pushMap = PushMap.Find(staticMaps, stateMaps, Bitmap.FindPosition(sample, 'A'),
Bitmap.FindPosition(sample, 'b'));
report.WriteLine(pushMap);
Assert.Equal(new TestReport(@".............
..X..........
.............
..X..........
.............
............."), report);
}
public void Sample()
{
var bountry = Bitmap.Create(new[]
{
"~~~###~~~~~",
"~~## #~####",
"~## ### #",
"## X #",
"# X # #",
"### X### #",
"~~# # #",
"~## ## # ##",
"~# ##~",
"~# ##~~",
"~#######~~~"
});
var expected = Bitmap.Create(new[]
{
"~~~###~~~~~",
"~~## #~####",
"~## ### #",
"## X #",
"# X # #",
"### X### #",
"~~# # #",
"~## ## # ##",
"~# ##~",
"~# ##~~",
"~#######~~~"
}, x => x == ' ');
var start = new VectorInt2(4, 4);
var result = FloodFill.Fill(bountry, start);
Assert.Equal(expected, result);
}
private IEnumerator FillMap()
{
if (_isDrawing)
{
yield break;
}
_isDrawing = true;
_fillNodes = new List <Node>();
FloodFill.HandleAddNodeToRegion += AddToMapFill;
FloodFill.FillMap();
FloodFill.HandleAddNodeToRegion -= AddToMapFill;
//600 frames
//_fillNodes.Count / 600
int iterationCount = _fillNodes.Count / 600;
int i = 0;
foreach (var n in _fillNodes)
{
GridCreator.Instance.ColorTileAt(n.X, n.Y, n.rColor);
if (i > iterationCount)
{
yield return(null);
i = 0;
}
else
{
i++;
}
}
_isDrawing = false;
}
private List <Point> GetPathToNearbyReachable(Point potentialDestination, DijkstraMap playerMovementMap, ref PointArray <bool> knownReachable, ref DijkstraMap distanceToKnownReachable)
{
Point destination = potentialDestination;
// First, figure out whether the destination cell is known-reachable:
if (knownReachable == null)
{
knownReachable = FloodFill.ScanToArray(Player.Position, CellIsKnownPassable);
}
PointArray <bool> knownReachable2 = knownReachable; // Can't use a ref parameter inside a lambda, but using a 2nd variable works.
if (!knownReachable[destination])
{
// If not, then find the nearest known reachable spaces:
if (distanceToKnownReachable == null)
{
distanceToKnownReachable = new DijkstraMap(point => 1)
{
IsSource = point => knownReachable2[point]
};
distanceToKnownReachable.Scan();
}
if (distanceToKnownReachable[destination] > 1) // If distance is 1, then we can reach it anyway
{
destination = destination.EnumeratePointsAtChebyshevDistance(distanceToKnownReachable[destination], true, false) // We know the distance already, so check only those cells...
.Where(nearby => nearby.ExistsBetweenMapEdges() && knownReachable2[nearby]) // ...make sure only reachable ones are considered...
.WhereLeast(nearby => destination.GetHalfStepMetricDistance(nearby)) // ...get the nearest ones to the targeted point...
.WhereLeast(nearby => Player.Position.GetHalfStepMetricDistance(nearby))[0]; // ...and finally get whichever one of those is closest to the player.
}
}
if (destination == Player.Position)
{
return(new List <Point>());
}
List <Point> path = playerMovementMap.GetDownhillPath(destination, preferCardinalDirections: true, includePathSource: true, includePathDestination: false, ignorePathSourceCost: true);
path.Reverse();
return(path);
}
static void Main(string[] args)
{
// Example usage:
int length = 10, width = 10;
bool[,] map = new bool[10, 10];
map[2, 2] = true;
map[2, 3] = true;
map[3, 3] = true;
map[4, 3] = true;
map[4, 2] = true;
map[4, 1] = true;
map[3, 1] = true;
map[2, 1] = true;
// //Define filled/empty nodes here
int count = FloodFill.GetSizeOfBlock(map, new Vector2(10, 10), new Vector2(2, 2));
Console.WriteLine("Count = " + count);
for (int i = 0; i < length; i++)
{
for (int j = 0; j < width - 1; j++)
{
Console.Write(map[i, j] + ", ");
}
Console.WriteLine(map[i, width - 1]);
}
Console.ReadKey();
map = FloodFill.Fill(map, new Vector2(10, 10), new Vector2(0, 0));
for (int i = 0; i < length; i++)
{
for (int j = 0; j < width - 1; j++)
{
Console.Write(map[i, j] + ", ");
}
Console.WriteLine(map[i, width - 1]);
}
Console.ReadKey();
}
private void ChooseAutoexploreAction(PlayerTurnEvent e)
{
var potentiallyReachable = FloodFill.ScanToArray(Player.Position, point => !point.IsMapEdge() && (!Map.Seen[point] || TileDefinition.IsPassable(TileTypeAt(point))));
var distanceToKnown = new DijkstraMap(p => (Map.Seen[p] || p.IsMapEdge())? -1 : 1)
{
IsSource = p => (Map.Seen[p] || p.IsMapEdge())
};
distanceToKnown.Scan();
foreach (Point p in Map.GetAllPoints(false))
{
if (distanceToKnown[p] == DijkstraMap.Unexplored || distanceToKnown[p] == DijkstraMap.Blocked)
{
continue;
}
distanceToKnown[p] = -(distanceToKnown[p] * distanceToKnown[p]);
}
distanceToKnown.RescanWithCurrentValues();
var exploreMap = new DijkstraMap(p => (!Map.Seen[p] || !TileDefinition.IsPassable(TileTypeAt(p)))? -1 : 1) // todo, needs items, shrines, etc. eventually
{
IsSource = p => !Map.Seen[p] && potentiallyReachable[p],
GetSourceValue = p => - (distanceToKnown[p])
};
exploreMap.Scan();
List <Point> playerPath = exploreMap.GetDownhillPath(Player.Position, true, earlyStopCondition: p => true);
if (playerPath.Count == 0)
{
return;
}
else
{
e.ChosenAction = new WalkAction(Player, playerPath[0]);
}
}
public void FloodFill(XRayImage xRayImage)
{
ImageHistory.Push(xRayImage.XRayBitmap);
var originalImage = xRayImage.XRayBitmap;
using (var bitmap = ImageUtils.BitmapImage2Bitmap(originalImage))
{
var floodFill = new FloodFill();
// top & bottom borders
for (var x = 0; x < bitmap.Width; x += 100)
{
floodFill.Fill(bitmap, new System.Drawing.Point(x, 0), System.Drawing.Color.Black, System.Drawing.Color.Transparent);
floodFill.Fill(bitmap, new System.Drawing.Point(x, bitmap.Height - 1), System.Drawing.Color.Black, System.Drawing.Color.Transparent);
}
// left & right borders
for (var y = 0; y < bitmap.Height; y += 100)
{
floodFill.Fill(bitmap, new System.Drawing.Point(0, y), System.Drawing.Color.Black, System.Drawing.Color.Transparent);
floodFill.Fill(bitmap, new System.Drawing.Point(bitmap.Width - 1, y), System.Drawing.Color.Black, System.Drawing.Color.Transparent);
}
xRayImage.XRayBitmap = bitmap.Bitmap2BitmapImage();
}
}
public void clearPoles(List<vector2i> wallList)
{
// #Clears out lonely walls, or "Poles".
FloodFill f = new FloodFill();
for (int x = 0; x < newDungeon.GetLength(0); x++){
for (int y = 0; y < newDungeon.GetLength(1); y++){
if (newDungeon[x,y] == wall && countAdjWall (new vector2i(x,y)) == 0){
newDungeon [x,y] = space;
} else if(f.reachableSpaces(newDungeon, new vector2i(x,y)) < 10) {
newDungeon [x,y] = wall;
}
}
}
// List<vector2i> newSpaces = new List<vector2i> ();
// foreach (vector2i i in wallList) {
// if (countAdjWall (i) == 0) {
// newDungeon [i.x,i.y] = space;
// newSpaces.Add (i);
// }
// }
// foreach (vector2i i in newSpaces) {
// wallList.Remove (i);
// }
//return wallList;
}
public List<vector2i> wallCrawl(List<vector2i> wallList)
{
List<vector2i> newWalls = new List<vector2i> ();
FloodFill f = new FloodFill ();
vector2i start = null;
for (int x = 0; x < newDungeon.GetLength(0); x++){
for (int y = 0; y < newDungeon.GetLength(1); y++){
if ( newDungeon[x,y] == space){
start = new vector2i (x, y);
break;
}
}
if (start != null){
break;
}
}
UnityEngine.Debug.Log ("(" + start.x + " " + start.y + ")");
foreach (vector2i i in wallList) {
int spaces = f.reachableSpaces (newDungeon, start);
List<vector2i> card = i.getCardinalTiles (newDungeon.GetLength(0), newDungeon.GetLength(1));
vector2i newWall = card [rand.Next (0, card.Count)];
if (newDungeon[newWall.x, newWall.y] == space){
newWalls.Add (newWall);
newDungeon [newWall.x,newWall.y] = wall;
int newSpaces = f.reachableSpaces(newDungeon, start);
if (spaces - newSpaces > 3){
newWalls.Remove (newWall);
newDungeon [newWall.x,newWall.y] = space;
} else {
spaces = newSpaces;
}
}
}
wallList.AddRange (newWalls);
//newWalls = new List<vector2i> ();
return wallList;
}
public void OnMouseUp()
{
grid.ResetColor();
if (Scoring.moveLimit <= Scoring.actualMoves) {
Stars stars = GameObject.Find ("Stars").GetComponent<Stars>();
// one more stars => win screen
// less than one star => losing screen
Application.LoadLevel(stars.oneStar.isEnabled() ? (int)Prefabs.Scene.winscreen : (int)Prefabs.Scene.losingscreen);
}
// 0) something selected?
if (selectedTiles.Count < 1) {
moveToStartPosition();
return;
}
// 1) find closest tile
Piece closestPiece = FindNearestTile();
// can't drop same color on same tile
if (piece.type == closestPiece.type) {
//Debug.Log ("dropped on same color");
moveToStartPosition ();
return;
}
//Debug.Log ("doing some floodflill");
// 2) swap with playerTile and set it towards start position (maybe some transition?)
// 2.1) set player controlled tile to grid tile
transform.position = closestPiece.gameObject.transform.position;
// 2.2 add drag-ability to new tile
closestPiece.gameObject.AddComponent<DragDrop> ();
// 2.3) change index meta info
piece.SwapPosition (closestPiece); // not needed currently
// move limit
Scoring.actualMoves++;
// update moves label
GameObject.Find ("Moves").guiText.text = ""+(Scoring.moveLimit +1 - Scoring.actualMoves);
//Debug.Log (closestTile.GetComponent<TileMetaData>().index);
// 3) find matching tiles
FloodFill floodFill = new FloodFill ();
List<Piece> matches = floodFill.FillFromPiece(gameObject.GetComponent<Piece>(), grid);
// gameObject.AddComponent<ExplodeNeighbours> ().Neighbours = Neighbours;
// 4) make some fancy explosions
if (matches.Count > 2) {
int bonusValue;
if(matches.Count >= Scoring.mediumGroupSize && matches.Count < Scoring.bigGroupSize)
{
bonusValue = Scoring.mediumBonus;
}else if(matches.Count >= Scoring.bigGroupSize)
{
bonusValue = Scoring.bigBonus;
}else
{
bonusValue = 1;
}
Scoring.setFinalScore(Scoring.finalScore + (Scoring.pieceValue * matches.Count * bonusValue));
Debug.Log("Score earned for the match: " + Scoring.finalScore);
Debug.Log("Final Score: " + Scoring.finalScore);
List<int> cols = new List<int>();
Debug.Log ("Desotryed " + matches.Count + " Pieces");
foreach (Piece match in matches) {
// match.AddComponent<Explode>();
grid.SetPieceAt(null, match.x, match.y);
if(!cols.Contains(match.x))
cols.Add(match.x);
StartCoroutine(explosion(match));
Destroy (match.gameObject);
}
grid.dropRows(cols);
}
// remove dragging script from old tile
Destroy (this);
}
