static void Main(string[] args) { // output all neighborhoods in data Query query = new Query(); Manhattan manhattan = query.JsonConversionGetData(); Console.WriteLine("----------"); Console.WriteLine("Output all neighborhoods in data list"); query.GetNeighborhoods(manhattan); // filter out neighborhoods that do not have names Console.WriteLine("----------"); Console.WriteLine("Filter out all neighborhoods that do not have names"); query.FilterNeighborhoods(manhattan); // remove duplicates Console.WriteLine("----------"); Console.WriteLine("Remove duplicates"); query.RemoveDuplicates(manhattan); // filter out neighborhoods that do not have names Console.WriteLine("----------"); Console.WriteLine("Remove duplicates"); Console.WriteLine("Filter out all neighborhoods that do not have names"); query.RemoveDuplicateOfNeighborhoodWithoutNames(manhattan); // run method that was rewritten to remove duplicates using LINQ Console.WriteLine("----------"); Console.WriteLine("Using LINQ"); query.ChangeToLINQ(manhattan); }
private List <Sector> FindSectorsNearPlayer() { TilePosition playerTilePosition = Graphics.Vector3ToTilePosition(player.position); TilePosition playerSectorTilePosition = sectorManager.GetSectorTile(playerTilePosition).sectorPosition; List <Sector> sectorsNear = new List <Sector>(); int visibileSectorsRadius = (int)Math.Ceiling(playerUnity.mainCamera.farClipPlane / SectorManager.SECTOR_SIZE) + 1; for (int d = 0; d <= visibileSectorsRadius; d++) { foreach (TilePosition tilePosition in Manhattan.GetTilesAtDistance(d)) { TilePosition t = tilePosition + playerSectorTilePosition; if (t.x >= 0 && t.x < sectorManager.xSectors && t.y >= 0 && t.y < sectorManager.ySectors && t.z >= 0 && t.z < sectorManager.zSectors) { sectorsNear.Add(sectorManager.GetSector(t)); } } } return(sectorsNear); }
/// <summary> /// reads in a json file and converts contents to a JObject /// </summary> /// <param name="data"> 'features' list from json data </param> /// <returns> JSON object made from data file contents </returns> static Feature[] ReadFile(string path) { string source = File.ReadAllText(path); Manhattan data = JsonConvert.DeserializeObject <Manhattan>(source); return(data.features); }
public void AStarTest() { HeuristicProvider heuristicProvider = new Manhattan(solution); IFinder finder = new AStar(heuristicProvider); Assert.IsNotNull(finder); }
public void FilterNoNameNeighborhood(Manhattan manhattan) { var neighborhoods = manhattan.Features.Select(x => x.Properties).Select(x => x.Neighborhood).Where(x => x != ""); foreach (string neighborhood in neighborhoods) { Console.WriteLine(neighborhood); } }
public void OutputNeighborhood(Manhattan manhattan) { var neighborhoods = manhattan.Features.Select(x => x.Properties).Select(x => x.Neighborhood); foreach (string neighborhood in neighborhoods) { Console.WriteLine(neighborhood); } }
public void RemoveDuplicateAndNoNameNeighborhood(Manhattan manhattan) { var neighborhoods = manhattan.Features.Select(x => x.Properties).Select(x => x.Neighborhood).Where(x => x != "").Distinct(); foreach (var neighborhood in neighborhoods) { Console.WriteLine(neighborhood); } }
private static void ExercisesLessonOne() { var listX = new List <double>(); listX.Add(4); listX.Add(2); Vector x = new Vector(listX); var listAmy = new List <double>(); listAmy.Add(5); listAmy.Add(5); Vector amy = new Vector(listAmy); var listClara = new List <double>(); listClara.Add(4.75); listClara.Add(4.5); listClara.Add(5); listClara.Add(4.25); listClara.Add(4); Vector clara = new Vector(listClara); var listRobert = new List <double>(); listRobert.Add(4); listRobert.Add(3); listRobert.Add(5); listRobert.Add(2); listRobert.Add(1); Vector robert = new Vector(listRobert); var listAmy2 = new List <double>(); listAmy2.Add(3.0); Vector amyTwo = new Vector(listAmy2); var listX2 = new List <double>(); listX2.Add(5.0); listX2.Add(2.5); listX2.Add(2.0); Vector xTwo = new Vector(listX2); var one = new Euclidian().Calculate(amy, x); var two = new Manhattan().Calculate(amy, x); var three = new Pearson().Calculate(clara, robert); var four = new Cosine().Calculate(clara, robert); var five = new Cosine().Calculate(amyTwo, xTwo); Console.WriteLine("\nEuclidian between Amy and X = " + one); Console.WriteLine("Manhattan between Amy and X = " + two); Console.WriteLine("Pearson between Clara and Robert = " + three); Console.WriteLine("Cosine between Clara and Robert = " + four); Console.WriteLine("Cosine between Amy and X (incomplete) = " + five); }
public void RewriteWithLINQ(Manhattan manhattan) { var neighborhoods = (from features in manhattan.Features where features.Properties.Neighborhood != "" select features.Properties.Neighborhood).Distinct(); foreach (var neighborhood in neighborhoods) { Console.WriteLine(neighborhood); } }
public Manhattan GetManhattanData() { string text = ""; using (StreamReader sr = File.OpenText(DATA_FILE_PATH)) { text = sr.ReadToEnd(); } Manhattan data = JsonConvert.DeserializeObject <Manhattan>(text); return(data); }
public void AlgorithmManhattanHeuristicTest() { byte[] puzzle = new byte[] { 1, 2, 3, 4, 5, 11, 0, 7, 9, 6, 10, 8, 13, 14, 15, 12 }; HeuristicProvider heuristicProvider = new Manhattan(solution); GraphExplorer explorer = GraphExplorer.CreateGraphExplorer( new byte[] { 4, 4 }, puzzle, new char[] { 'u', 'd', 'l', 'r' }, new AStar(heuristicProvider)); explorer.TargetState = new NodeState(new byte[] { 4, 4 }, new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0 }); string sol = explorer.TraverseForSolution(); Assert.IsFalse(string.IsNullOrEmpty(sol)); }
public override bool Validate(TileManager tileManager, Tile tile, TilePosition pos) { tileManager.world.stats.checkedConditions++; int amount = 0; foreach (TilePosition delta in Manhattan.GetTilesAtDistance(1)) { if (tileManager.IsValidTile(pos + delta) && tileManager.GetTileType(pos + delta) == tileType) { amount++; } } return(amount >= minValue); }
private void FindNearestNeighbors(Attributes[] testAttributes, Attributes tuner, int k) { foreach (Attributes trainingInstance in testAttributes) { if (trainingInstance.xy != tuner.xy) { Calculator tCalc = new Calculator(tuner.xy, trainingInstance.xy); Euclidaen.Add(new KeyValuePair <float, Attributes>(tCalc.getEuclidaen, trainingInstance)); Chebyshev.Add(new KeyValuePair <float, Attributes>(tCalc.getChebyshev, trainingInstance)); Manhattan.Add(new KeyValuePair <float, Attributes>(tCalc.getManhattan, trainingInstance)); } } Euclidaen = Euclidaen.OrderBy(o => o.Key).Take(k).ToList(); Chebyshev = Chebyshev.OrderBy(o => o.Key).Take(k).ToList(); Manhattan = Manhattan.OrderBy(o => o.Key).Take(k).ToList(); }
public Player(Type bettingStrategy, int StartingFunds, int MinimumBetAmount) { this.PrimaryHand = new Hand(); this.SplitHand = new Hand(); this.Statistics = new Stats(); this.Funds = StartingFunds; this.StartingFunds = StartingFunds; if (bettingStrategy == typeof(Manhattan)) { BettingStrategy = new Manhattan(MinimumBetAmount); } else if (bettingStrategy == typeof(Martingale)) { BettingStrategy = new Martingale(MinimumBetAmount); } }
public override void Execute(TileManager tileManager, Tile tile, TilePosition center) { for (int d = 1; d <= radius; d++) { int rDamage = damage * (radius - d + 1) / radius; TilePosition[] tiles = Manhattan.GetTilesAtDistance(d); for (int i = 0; i < tiles.Length; i++) { TilePosition p = center + tiles[i]; if (tileManager.IsValidTile(p)) { if (tileManager.DamageTile(p, rDamage) == false) { if (setOnFire && tileManager.GetTileDefinition(tileManager.GetTileType(p)).burns) { tileManager.SetTileOnFire(p, true); } } } } } if (setOnFire) { TilePosition[] tiles = Manhattan.GetTilesAtDistance(radius + 1); for (int i = 0; i < tiles.Length; i++) { TilePosition p = center + tiles[i]; if (tileManager.IsValidTile(p)) { if (setOnFire && tileManager.GetTileDefinition(tileManager.GetTileType(p)).burns) { tileManager.SetTileOnFire(p, true); } } } } }
static void Main(string[] args) { Util util = new Util(); Manhattan manhattan = util.GetManhattanData(); Console.WriteLine("*************************************************************"); Console.WriteLine("1) Output all of the neighborhoods in this data list"); util.OutputNeighborhood(manhattan); Console.WriteLine("*************************************************************"); Console.WriteLine("2) Filtered out all the neighborhoods that do not have any names"); util.FilterNoNameNeighborhood(manhattan); Console.WriteLine("*************************************************************"); Console.WriteLine("3) Remove the Duplicates"); util.RemoveDuplicates(manhattan); Console.WriteLine("*************************************************************"); Console.WriteLine("4) Remove the Duplicates"); Console.WriteLine("4) Filtered out all the neighborhoods that do not have any names"); util.RemoveDuplicateAndNoNameNeighborhood(manhattan); Console.WriteLine("*************************************************************"); Console.WriteLine("5) In LINQ"); util.RewriteWithLINQ(manhattan); }
/// <summary> /// Solves the current routing problem. /// </summary> private void Solve(int number_of_orders, int number_of_vehicles) { Console.WriteLine("Creating model with " + number_of_orders + " orders and " + number_of_vehicles + " vehicles."); // Finalizing model int number_of_locations = locations_.Length; RoutingModel model = new RoutingModel(number_of_locations, number_of_vehicles, vehicle_starts_, vehicle_ends_); // Setting up dimensions const int big_number = 100000; NodeEvaluator2 manhattan_callback = new Manhattan(locations_, 1); model.AddDimension( manhattan_callback, big_number, big_number, false, "time"); NodeEvaluator2 demand_callback = new Demand(order_demands_); model.AddDimension(demand_callback, 0, vehicle_capacity_, true, "capacity"); // Setting up vehicles NodeEvaluator2[] cost_callbacks = new NodeEvaluator2[number_of_vehicles]; for (int vehicle = 0; vehicle < number_of_vehicles; ++vehicle) { int cost_coefficient = vehicle_cost_coefficients_[vehicle]; NodeEvaluator2 manhattan_cost_callback = new Manhattan(locations_, cost_coefficient); cost_callbacks[vehicle] = manhattan_cost_callback; model.SetVehicleCost(vehicle, manhattan_cost_callback); model.CumulVar(model.End(vehicle), "time").SetMax( vehicle_end_time_[vehicle]); } // Setting up orders for (int order = 0; order < number_of_orders; ++order) { model.CumulVar(order, "time").SetRange(order_time_windows_[order].start_, order_time_windows_[order].end_); int[] orders = { order }; model.AddDisjunction(orders, order_penalties_[order]); } // Solving RoutingSearchParameters search_parameters = RoutingModel.DefaultSearchParameters(); search_parameters.FirstSolutionStrategy = FirstSolutionStrategy.Types.Value.AllUnperformed; Console.WriteLine("Search"); Assignment solution = model.SolveWithParameters(search_parameters); //protect callbacks from the GC GC.KeepAlive(manhattan_callback); GC.KeepAlive(demand_callback); for (int cost_callback_index = 0; cost_callback_index < cost_callbacks.Length; cost_callback_index++) { GC.KeepAlive(cost_callbacks[cost_callback_index]); } if (solution != null) { String output = "Total cost: " + solution.ObjectiveValue() + "\n"; // Dropped orders String dropped = ""; for (int order = 0; order < number_of_orders; ++order) { if (solution.Value(model.NextVar(order)) == order) { dropped += " " + order; } } if (dropped.Length > 0) { output += "Dropped orders:" + dropped + "\n"; } // Routes for (int vehicle = 0; vehicle < number_of_vehicles; ++vehicle) { String route = "Vehicle " + vehicle + ": "; long order = model.Start(vehicle); if (model.IsEnd(solution.Value(model.NextVar(order)))) { route += "Empty"; } else { for (; !model.IsEnd(order); order = solution.Value(model.NextVar(order))) { IntVar local_load = model.CumulVar(order, "capacity"); IntVar local_time = model.CumulVar(order, "time"); route += order + " Load(" + solution.Value(local_load) + ") " + "Time(" + solution.Min(local_time) + ", " + solution.Max(local_time) + ") -> "; } IntVar load = model.CumulVar(order, "capacity"); IntVar time = model.CumulVar(order, "time"); route += order + " Load(" + solution.Value(load) + ") " + "Time(" + solution.Min(time) + ", " + solution.Max(time) + ")"; } output += route + "\n"; } Console.WriteLine(output); } }
/// <summary> /// Solves the current routing problem. /// </summary> private void Solve(int number_of_orders, int number_of_vehicles) { Console.WriteLine("Creating model with " + number_of_orders + " orders and " + number_of_vehicles + " vehicles."); // Finalizing model int number_of_locations = locations_.Length; RoutingModel model = new RoutingModel(number_of_locations, number_of_vehicles, vehicle_starts_, vehicle_ends_); // Setting up dimensions const int big_number = 100000; NodeEvaluator2 manhattan_callback = new Manhattan(locations_, 1); model.AddDimension( manhattan_callback, big_number, big_number, false, "time"); NodeEvaluator2 demand_callback = new Demand(order_demands_); model.AddDimension(demand_callback, 0, vehicle_capacity_, true, "capacity"); // Setting up vehicles for (int vehicle = 0; vehicle < number_of_vehicles; ++vehicle) { int cost_coefficient = vehicle_cost_coefficients_[vehicle]; NodeEvaluator2 manhattan_cost_callback = new Manhattan(locations_, cost_coefficient); model.SetVehicleCost(vehicle, manhattan_cost_callback); model.CumulVar(model.End(vehicle), "time").SetMax( vehicle_end_time_[vehicle]); } // Setting up orders for (int order = 0; order < number_of_orders; ++order) { model.CumulVar(order, "time").SetRange(order_time_windows_[order].start_, order_time_windows_[order].end_); int[] orders = {order}; model.AddDisjunction(orders, order_penalties_[order]); } // Solving RoutingSearchParameters search_parameters = RoutingModel.DefaultSearchParameters(); search_parameters.FirstSolutionStrategy = FirstSolutionStrategy.Types.Value.ALL_UNPERFORMED; Console.WriteLine("Search"); Assignment solution = model.SolveWithParameters(search_parameters); if (solution != null) { String output = "Total cost: " + solution.ObjectiveValue() + "\n"; // Dropped orders String dropped = ""; for (int order = 0; order < number_of_orders; ++order) { if (solution.Value(model.NextVar(order)) == order) { dropped += " " + order; } } if (dropped.Length > 0) { output += "Dropped orders:" + dropped + "\n"; } // Routes for (int vehicle = 0; vehicle < number_of_vehicles; ++vehicle) { String route = "Vehicle " + vehicle + ": "; long order = model.Start(vehicle); if (model.IsEnd(solution.Value(model.NextVar(order)))) { route += "Empty"; } else { for (; !model.IsEnd(order); order = solution.Value(model.NextVar(order))) { IntVar local_load = model.CumulVar(order, "capacity"); IntVar local_time = model.CumulVar(order, "time"); route += order + " Load(" + solution.Value(local_load) + ") " + "Time(" + solution.Min(local_time) + ", " + solution.Max(local_time) + ") -> "; } IntVar load = model.CumulVar(order, "capacity"); IntVar time = model.CumulVar(order, "time"); route += order + " Load(" + solution.Value(load) + ") " + "Time(" + solution.Min(time) + ", " + solution.Max(time) + ")"; } output += route + "\n"; } Console.WriteLine(output); } }
static void Main(string[] args) { if (args.Length == 5) { GraphExplorer explorer = null; IFinder finder = null; string inputFile = args[2]; string outputFile = args[3]; string dataFile = args[4]; string operations = null; string solutionPath = "solution.txt"; IState solutionState; byte[] dimensions, root; (dimensions, root) = LoadInputFile(inputFile); if (File.Exists(solutionPath)) { byte[] solutionDimensions, state; (solutionDimensions, state) = LoadInputFile(solutionPath); solutionState = new NodeState(solutionDimensions, state); } else { byte limit = (byte)(dimensions[0] * dimensions[1]); byte[] solutionArray = new byte[limit]; for (byte i = 0; i < limit - 1; ++i) { solutionArray[i] = (byte)(i + 1); } solutionArray[limit - 1] = 0; solutionState = new NodeState(dimensions, solutionArray); } try { switch (args[0]) { case "bfs": finder = new BFS(); operations = args[1].ToLower(); break; case "dfs": finder = new DFS(); operations = Reverse(args[1].ToLower()); break; case "astr": HeuristicProvider heuristicProvider = null; switch (args[1]) { case "manh": heuristicProvider = new Manhattan(solutionState); break; case "hamm": heuristicProvider = new Hamming(solutionState); break; } operations = "lrud"; finder = new AStar(heuristicProvider); break; } if (Enumerable.SequenceEqual(dimensions, solutionState.Dimensions)) { explorer = GraphExplorer.CreateGraphExplorer(dimensions, root, operations.ToCharArray(), finder); explorer.TargetState = solutionState; } else { throw new NullReferenceException("root state and solution state have different dimensions"); } } catch (NullReferenceException e) { Console.WriteLine($"Wrong parameters format {Environment.NewLine}{e.Message}"); } catch (FormatException e) { Console.WriteLine($"Wrong input file format {Environment.NewLine}{e.Message}"); } string solution = explorer.TraverseForSolution(); WriteOutputFiles(outputFile, dataFile, solution, explorer); } }
/// <summary> /// Solves the current routing problem. /// </summary> private void Solve(int number_of_orders, int number_of_vehicles) { Console.WriteLine("Creating model with " + number_of_orders + " orders and " + number_of_vehicles + " vehicles."); // Finalizing model int number_of_locations = locations_.Length; RoutingIndexManager manager = new RoutingIndexManager(number_of_locations, number_of_vehicles, vehicle_starts_, vehicle_ends_); RoutingModel model = new RoutingModel(manager); // Setting up dimensions const int big_number = 100000; Manhattan manhattan_callback = new Manhattan(manager, locations_, 1); model.AddDimension(model.RegisterTransitCallback(manhattan_callback.Call), big_number, big_number, false, "time"); RoutingDimension time_dimension = model.GetDimensionOrDie("time"); Demand demand_callback = new Demand(manager, order_demands_); model.AddDimension(model.RegisterUnaryTransitCallback(demand_callback.Call), 0, vehicle_capacity_, true, "capacity"); RoutingDimension capacity_dimension = model.GetDimensionOrDie("capacity"); // Setting up vehicles Manhattan[] cost_callbacks = new Manhattan[number_of_vehicles]; for (int vehicle = 0; vehicle < number_of_vehicles; ++vehicle) { int cost_coefficient = vehicle_cost_coefficients_[vehicle]; Manhattan manhattan_cost_callback = new Manhattan(manager, locations_, cost_coefficient); cost_callbacks[vehicle] = manhattan_cost_callback; int manhattan_cost_index = model.RegisterTransitCallback(manhattan_cost_callback.Call); model.SetArcCostEvaluatorOfVehicle(manhattan_cost_index, vehicle); time_dimension.CumulVar(model.End(vehicle)).SetMax(vehicle_end_time_[vehicle]); } // Setting up orders for (int order = 0; order < number_of_orders; ++order) { time_dimension.CumulVar(order).SetRange(order_time_windows_[order].start_, order_time_windows_[order].end_); long[] orders = { manager.NodeToIndex(order) }; model.AddDisjunction(orders, order_penalties_[order]); } // Solving RoutingSearchParameters search_parameters = operations_research_constraint_solver.DefaultRoutingSearchParameters(); search_parameters.FirstSolutionStrategy = FirstSolutionStrategy.Types.Value.AllUnperformed; Console.WriteLine("Search..."); Assignment solution = model.SolveWithParameters(search_parameters); if (solution != null) { String output = "Total cost: " + solution.ObjectiveValue() + "\n"; // Dropped orders String dropped = ""; for (int order = 0; order < number_of_orders; ++order) { if (solution.Value(model.NextVar(order)) == order) { dropped += " " + order; } } if (dropped.Length > 0) { output += "Dropped orders:" + dropped + "\n"; } // Routes for (int vehicle = 0; vehicle < number_of_vehicles; ++vehicle) { String route = "Vehicle " + vehicle + ": "; long order = model.Start(vehicle); if (model.IsEnd(solution.Value(model.NextVar(order)))) { route += "Empty"; } else { for (; !model.IsEnd(order); order = solution.Value(model.NextVar(order))) { IntVar local_load = capacity_dimension.CumulVar(order); IntVar local_time = time_dimension.CumulVar(order); route += order + " Load(" + solution.Value(local_load) + ") " + "Time(" + solution.Min(local_time) + ", " + solution.Max(local_time) + ") -> "; } IntVar load = capacity_dimension.CumulVar(order); IntVar time = time_dimension.CumulVar(order); route += order + " Load(" + solution.Value(load) + ") " + "Time(" + solution.Min(time) + ", " + solution.Max(time) + ")"; } output += route + "\n"; } Console.WriteLine(output); } }
public static Vector2 UnityToCoord(Vector3 v) { Vector2d c = Manhattan.WorldToGeoPosition(v); return(new Vector2((float)c.x, (float)c.y)); }
static void JsonConversion() { string path = "../../../../data.json"; string text = ""; using (StreamReader sr = File.OpenText(path)) { text = sr.ReadToEnd(); } Manhattan data = JsonConvert.DeserializeObject <Manhattan>(text); var boroughs = data.Features.Select(x => x).Select(x => x.Properties).Select(x => x.Neighborhood); var allHoods = from hood in boroughs select hood; Console.WriteLine("1. All neighborhoods in the data list: "); foreach (var item in allHoods) { Console.WriteLine(item); } Console.WriteLine(); Console.WriteLine("2. Filter neighborhoods with no name: "); var removeNoName = from hood in allHoods where hood != "" select hood; foreach (var item in removeNoName) { Console.WriteLine(item); } Console.WriteLine(); Console.WriteLine("3. Remove duplicate hoods: "); var removeDup = (from hood in allHoods orderby hood select hood).Distinct(); foreach (var item in removeDup) { Console.WriteLine(item); } Console.WriteLine(); Console.WriteLine("4. Now all in one query: "); var singleQuery = (from hood in boroughs orderby hood where hood != "" select hood).Distinct(); foreach (var item in singleQuery) { Console.WriteLine(item); } Console.WriteLine(); Console.WriteLine("5. Now with a lambda: "); var lambda = allHoods.Where(hood => hood != "").Distinct().OrderBy(hood => hood); foreach (var item in lambda) { Console.WriteLine(item); } }
private void Propagate(TileManager tileManager, Tile tile, TilePosition pos, int level) { TilePosition posBelow = pos + new TilePosition(0, -1, 0); bool belowIsSameLiquid = tileManager.IsValidTile(posBelow) && tileManager.GetTileType(posBelow) == tile.tileType; if (tileManager.IsValidTile(posBelow) && (tileManager.GetTileType(posBelow) == TileDefinition.EMPTY_TILE_TYPE) || belowIsSameLiquid) { if (belowIsSameLiquid == false) { tileManager.SetTileType(posBelow, tile.tileType); tileManager.SetTileExtraData(posBelow, 1); } } else { if (level < maxLevel) { TilePosition[] nearDirection = new TilePosition[4]; int[] nearDistance = new int[] { maxLevel, maxLevel, maxLevel, maxLevel }; FindFall(new TilePosition(1, 0, 0), tileManager, tile, pos, ref nearDirection[0], ref nearDistance[0]); FindFall(new TilePosition(-1, 0, 0), tileManager, tile, pos, ref nearDirection[1], ref nearDistance[1]); FindFall(new TilePosition(0, 0, 1), tileManager, tile, pos, ref nearDirection[2], ref nearDistance[2]); FindFall(new TilePosition(0, 0, -1), tileManager, tile, pos, ref nearDirection[3], ref nearDistance[3]); int minNearDistance = Math.Min(Math.Min(Math.Min(nearDistance[0], nearDistance[1]), nearDistance[2]), nearDistance[3]); if (minNearDistance != maxLevel) { for (int i = 0; i < 4; i++) { if (nearDistance[i] == minNearDistance) { TilePosition posNear = pos + nearDirection[i]; if (tileManager.IsValidTile(posNear) && tileManager.GetTileType(posNear) == TileDefinition.EMPTY_TILE_TYPE) { TilePosition posNearBelow = posNear + new TilePosition(0, -1, 0); bool nearBelowIsSameLiquid = tileManager.IsValidTile(posNearBelow) && tileManager.GetTileType(posNearBelow) == tile.tileType; if (nearBelowIsSameLiquid == false || belowIsSameLiquid == false) { tileManager.SetTileType(posNear, tile.tileType); tileManager.SetTileExtraData(posNear, (byte)(level + 1)); } } } } } else { foreach (TilePosition deltaPos in Manhattan.GetTilesAtDistance(1)) { if (deltaPos.y == 0) { TilePosition posNear = pos + deltaPos; if (tileManager.IsValidTile(posNear) && tileManager.GetTileType(posNear) == TileDefinition.EMPTY_TILE_TYPE) { TilePosition posNearBelow = posNear + new TilePosition(0, -1, 0); bool nearBelowIsSameLiquid = tileManager.IsValidTile(posNearBelow) && tileManager.GetTileType(posNearBelow) == tile.tileType; if (nearBelowIsSameLiquid == false || belowIsSameLiquid == false) { tileManager.SetTileType(posNear, tile.tileType); tileManager.SetTileExtraData(posNear, (byte)(level + 1)); } } } } } } } }