Loading

Paste #pswaqpejg

  1.     function buildTownStation(town, cargoClass, stationTile, otherTown) {
  2.         local stationId = (stationTile == null) ?  AIStation.STATION_NEW : AIStation.GetStationID(stationTile);
  3.         local vehicleType = (cargoClass == AICargo.CC_MAIL) ? AIRoad.ROADVEHTYPE_TRUCK : AIRoad.ROADVEHTYPE_BUS;
  4. //      local max_spread = AIController.GetSetting("station_spread") && AIGameSettings.GetValue("distant_join_stations");
  5.  
  6.         local cargoType = Utils.getCargoId(cargoClass);
  7.  
  8.         local tileList = AITileList();
  9.         if(stationTile == null) {
  10.             //stationTile = AIStation.STATION_NEW;
  11.             //build square around @town and find suitable tiles for truck stops
  12.             local rectangleCoordinates = estimateTownRectangle(town);
  13.  
  14.             tileList.AddRectangle(rectangleCoordinates[0], rectangleCoordinates[1]);
  15.            
  16.             for(local tile = tileList.Begin(); tileList.HasNext(); tile = tileList.Next()) {
  17.                 if (Utils.AreOtherStationsNearby(tile, cargoClass, stationId)) {
  18.                     tileList.RemoveTile(tile);
  19.                 }
  20.             }
  21.            
  22.             //valuate and sort by the number of cargo tiles the station covers
  23.             tileList.Valuate(Utils.valuateTruckStopTile, cargoClass, stationId, cargoType);
  24.             tileList.RemoveValue(0);
  25.             tileList.Sort(AIList.SORT_BY_VALUE, false); //starts from corners if without sort
  26.         }
  27.         else {
  28.             //expanding existing station
  29.             if(!AIStation.IsValidStation(stationId)) {
  30.                 return null;
  31.             }
  32.  
  33.             local squareSize = AIGameSettings.GetValue("station_spread");
  34.  
  35.             AILog.Info("AddRectangle");
  36.             tileList.AddRectangle(Utils.getValidOffsetTile(stationTile, -1 * squareSize, -1 * squareSize),
  37.                 Utils.getValidOffsetTile(stationTile, squareSize, squareSize));
  38.                
  39.             AILog.Info("AreOtherStationsNearby");
  40.             for(local tile = tileList.Begin(); tileList.HasNext(); tile = tileList.Next()) {
  41.                 if (Utils.AreOtherStationsNearby(tile, cargoClass, stationId)) {
  42.                     tileList.RemoveTile(tile);
  43.                 }
  44.             }
  45.             AILog.Info("Valuate tiles");
  46.             tileList.Valuate(Utils.valuateTruckStopTile, cargoClass, stationId, cargoType);
  47.             tileList.RemoveValue(0);
  48.         }
  49.  
  50.         for (local tile = tileList.Begin(); tileList.HasNext(); tile = tileList.Next()) {
  51.             AILog.Info("cycling tileList");
  52.             //get adjacent tiles
  53.             local adjTileList = Utils.getAdjacentTiles(tile);
  54.             local adjRoadTiles = AITileList();
  55.             adjRoadTiles.AddList(adjTileList);
  56.             adjRoadTiles.Valuate(AIRoad.IsRoadTile);
  57.             adjRoadTiles.KeepValue(1);
  58.  
  59.             AIRoad.SetCurrentRoadType(AIRoad.ROADTYPE_ROAD);
  60.             local adjRoadCount = adjRoadTiles.Count();
  61.             AILog.Info("computing adjacentAirport");
  62.             local adjacentAirport = Utils.checkAdjacentAirport(tile, cargoClass, stationId);
  63.  
  64.             AILog.Info("switching cases");
  65.             switch (adjRoadCount) {
  66.             //case where station tile has no adjacent road tiles
  67.                 case 0:
  68.                     /* expanding via this case can be too slow */
  69.                     if (stationTile != null) {
  70.                         continue;
  71.                     }
  72.                    
  73.                     local closestAdjTile = null;
  74.                     for (local adjTile = adjTileList.Begin(); adjTileList.HasNext(); adjTile = adjTileList.Next()) {
  75.                         if (!AITile.IsBuildable(adjTile) || AITile.GetSlope(adjTile) != AITile.SLOPE_FLAT) {
  76.                             continue;
  77.                         }
  78.                        
  79.                         if (closestAdjTile == null) {
  80.                             closestAdjTile = adjTile;
  81.                         }
  82.                        
  83.                         if (AITown.GetDistanceManhattanToTile(otherTown, adjTile) < closestAdjTile) {
  84.                             closestAdjTile = adjTile;
  85.                         }
  86.                     }
  87.                    
  88.                     if (closestAdjTile == null) {
  89.                         continue;
  90.                     }
  91.  
  92.                     local counter = 0;
  93.                     do {
  94.                         if (!TestBuildRoadStation().TryBuild(tile, closestAdjTile, vehicleType, adjacentAirport)) {
  95.                             //if((AIError.GetLastErrorString() != "ERR_ALREADY_BUILT") && (AIError.GetLastErrorString() != "ERR_PRECONDITION_FAILED")) {
  96.                                 //AILog.Warning("Couldnt build station! " + AIError.GetLastErrorString());
  97.                             //}
  98.                             ++counter;
  99.                         }
  100.                         else {
  101.                             break;
  102.                         }
  103.                         AIController.Sleep(1);
  104.                     } while(counter < 1);                      
  105.                     if(counter == 1) {
  106.                         continue;
  107.                     }
  108.                    
  109.                     if (stationTile != null) {                     
  110.                         if (buildRoad(tile, AITown.GetLocation(otherTown), true) == null) {
  111.                             local counter = 0;
  112.                             do {
  113.                                 if (!TestRemoveRoadStation().TryRemove(tile)) {
  114.                                     ++counter;
  115.                                 }
  116.                                 else {
  117. //                                  AILog.Warning("case" + adjRoadCount + "; Removed road station tile at " + tile);
  118.                                     break;
  119.                                 }
  120.                                 AIController.Sleep(1);
  121.                             } while(counter < (stationTile == null ? 500 : 1));
  122.                             if (counter == (stationTile == null ? 500 : 1)) {
  123.                                 AILog.Error("Failed to remove road station tile at " + tile + " - " + AIError.GetLastErrorString());
  124.                                 continue; // TODO: station should have been removed by now, but it wasn't!
  125.                             } else {
  126.                                 continue;
  127.                             }
  128.                         }
  129.                     }
  130.  
  131.                     AILog.Info("Station built in " + AITown.GetName(town) + " at tile " + tile + "! case" + adjRoadCount);
  132.                     //AISign.BuildSign(tile, "" + adjRoadCount);
  133.                     return tile;
  134.  
  135.                     break;
  136.  
  137.                 case 1:
  138.  
  139.                     local adjTile = adjRoadTiles.Begin();
  140.                        
  141.                     if (AIRoad.IsDriveThroughRoadStationTile(adjTile)) {
  142.                         continue;
  143.                     }
  144.                        
  145.                     local heighDifference = abs(AITile.GetMaxHeight(tile) - AITile.GetMaxHeight(adjTile));
  146.  
  147.                     if(heighDifference != 0) {
  148.                         continue;
  149.                     }
  150.  
  151.                     local counter = 0;
  152.                     do {
  153.                         /* Try to build a road station or a drive through road station */
  154.                         if (!TestBuildRoadStation().TryBuild(tile, adjTile, vehicleType, adjacentAirport) || AIRoad.IsRoadTile(tile)
  155.                             && !TestBuildDriveThroughRoadStation().TryBuild(tile, adjTile, vehicleType, adjacentAirport)) {
  156.                             ++counter;
  157.                         }
  158.                         else {
  159.                             break;
  160.                         }
  161.                         AIController.Sleep(1);
  162.                     } while(counter < 1);
  163.                     if (counter == 1) {
  164.                         /* Failed to build station, try the next location */
  165.                         continue;
  166.                     }
  167.                     else {
  168.                         /* With the road station built, try to connect it to the road */
  169.                         local drivethrough = AIRoad.IsDriveThroughRoadStationTile(tile);
  170.                         local counter = 0;
  171.                         do {
  172.                             if(!TestBuildRoad().TryBuild(tile, adjTile) && AIError.GetLastErrorString() != "ERR_ALREADY_BUILT") {
  173.                                 ++counter;
  174.                             }
  175.                             else {
  176.                                 break;
  177.                             }
  178.                             AIController.Sleep(1);
  179.                         } while(counter < (stationTile == null ? 500 : 1));
  180.                         if(counter == (stationTile == null ? 500 : 1)) {
  181.                             /* Failed to connect road to the station. Try to remove the station we had built then */
  182.                             local counter = 0;
  183.                             do {
  184.                                 if (!TestRemoveRoadStation().TryRemove(tile)) {
  185.                                     ++counter;
  186.                                 }
  187.                                 else {
  188.                                     if (drivethrough) {
  189. //                                      AILog.Warning("case" + adjRoadCount + "; Removed drive through station tile at " + tile);
  190.                                     } else {
  191. //                                      AILog.Warning("case" + adjRoadCount + "; Removed road station tile at " + tile);
  192.                                     }
  193.                                     break;
  194.                                 }
  195.                                 AIController.Sleep(1);
  196.                             } while (counter < (stationTile == null ? 500 : 1));
  197.                             if (counter == (stationTile == null ? 500 : 1)) {
  198.                                 if (drivethrough) {
  199.                                     AILog.Error("Failed to remove drive through station tile at " + tile + " - " + AIError.GetLastErrorString());
  200.                                 } else {
  201.                                     AILog.Error("Failed to remove road station tile at " + tile + " - " + AIError.GetLastErrorString());
  202.                                 }
  203.                                 continue; // TODO: station should have been removed by now, but it wasn't!
  204.                             } else {
  205.                                 /* The station was successfully removed after failing to connect it to the road. Try it all over again in the next location */
  206.                                 continue;
  207.                             }
  208.                         }
  209.                         else {
  210.                             /* The road was successfully connected to the station */
  211.                             if (!AIRoad.IsDriveThroughRoadStationTile(tile)) {
  212.                                 AILog.Info("Station built in " + AITown.GetName(town) + " at tile " + tile + "! case" + adjRoadCount);
  213.                             } else {
  214.                                 AILog.Info("Drivethrough station built in " + AITown.GetName(town) + " at tile " + tile + "! case" + adjRoadCount);
  215.                             }
  216.                             //AISign.BuildSign(tile, "" + adjRoadCount);
  217.                             return tile;
  218.                         }
  219.                     }
  220.  
  221.                     break;
  222.  
  223.                 case 2:
  224.                     local adjTile = adjRoadTiles.Begin();
  225.                     local nextAdjTile = adjRoadTiles.Next();
  226.  
  227.                     //dont build drivethrough station next to regular station
  228.                     adjTileList.RemoveItem(adjTile);
  229.                     adjTileList.RemoveItem(nextAdjTile);
  230.                     local found = false;
  231.                     for(local t = adjTileList.Begin(); adjTileList.HasNext(); t = adjTileList.Next()) {
  232.                         if (AIRoad.IsRoadStationTile(t) && AIRoad.GetRoadStationFrontTile(t) == tile ||
  233.                             AIRoad.IsRoadDepotTile(t) && AIRoad.GetRoadDepotFrontTile(t) == tile) {
  234.                             found = true;
  235.                             break;
  236.                         }
  237.                     }
  238.                     if(found) {
  239.                         continue;
  240.                     }
  241.  
  242.                     local heighDifference = abs(AITile.GetMaxHeight(nextAdjTile) - AITile.GetMaxHeight(adjTile));
  243.                     if(heighDifference != 0) {
  244.                         continue;
  245.                     }
  246.  
  247.                     //check whether adjacent tiles are opposite
  248.                     local opposite = false;
  249.                     if((AIMap.GetTileX(adjTile) == AIMap.GetTileX(nextAdjTile))
  250.                         || (AIMap.GetTileY(adjTile) == AIMap.GetTileY(nextAdjTile))) {
  251.                             opposite = true;
  252.                     }
  253.  
  254.                     if(AIRoad.IsRoadTile(tile)) {
  255.                         if(!opposite) {
  256.                             continue;
  257.                         }
  258.                     }
  259.  
  260.                     if(opposite) {
  261.                         local counter = 0;
  262.                         do {
  263.                             if (!TestBuildDriveThroughRoadStation().TryBuild(tile, adjTile, vehicleType, adjacentAirport)) {
  264.                                 if((AIError.GetLastErrorString() != "ERR_ALREADY_BUILT") && (AIError.GetLastErrorString() != "ERR_PRECONDITION_FAILED")) {
  265.                                     if(AIError.GetLastErrorString() != "ERR_LOCAL_AUTHORITY_REFUSES") {
  266.                                         //AILog.Warning("Couldnt build station! " + AIError.GetLastErrorString());
  267.                                     }
  268.                                 }
  269.                                 ++counter;
  270.                             }
  271.                             else {
  272.                                 break;
  273.                             }
  274.                             AIController.Sleep(1)
  275.                         } while(counter < 1);
  276.                         if (counter == 1) {
  277.                             continue;
  278.                         }
  279.                         else {
  280.                             local counter = 0;
  281.                             do {
  282.                                 if(!TestBuildRoad().TryBuild(adjTile, nextAdjTile) && AIError.GetLastErrorString() != "ERR_ALREADY_BUILT") {
  283.                                     ++counter;
  284.                                 }
  285.                                 else {
  286.                                     break;
  287.                                 }
  288.                                 AIController.Sleep(1);
  289.                             } while(counter < (stationTile == null ? 500 : 1));
  290.                             if(counter == (stationTile == null ? 500 : 1)) {
  291.                                 local counter = 0;
  292.                                 do {
  293.                                     if (!TestRemoveRoadStation().TryRemove(tile)) {
  294.                                         ++counter;
  295.                                     }
  296.                                     else {
  297. //                                      AILog.Warning("case" + adjRoadCount + "; Removed drive through station tile at " + tile);
  298.                                         break;
  299.                                     }
  300.                                     AIController.Sleep(1);
  301.                                 } while(counter < (stationTile == null ? 500 : 1));
  302.                                 if (counter == (stationTile == null ? 500 : 1)) {
  303.                                     AILog.Error("Failed to remove drive through station tile at " + tile + " - " + AIError.GetLastErrorString());
  304.                                     continue; // TODO: station should have been removed by now, but it wasn't!
  305.                                 } else {
  306.                                     continue;
  307.                                 }
  308.                             }
  309.                             else {
  310.                                 AILog.Info("Drivethrough station built in " + AITown.GetName(town) + " at tile " + tile + "! case" + adjRoadCount);
  311.                                 //AISign.BuildSign(tile, "" + adjRoadCount);
  312.                                 return tile;
  313.                             }
  314.                         }
  315.                     }
  316.                     //similar to case 1 if adjacent tiles are not opposite
  317.                     else {
  318.                         local counter = 0;
  319.                         do {
  320.                             if (!TestBuildRoadStation().TryBuild(tile, adjTile, vehicleType, adjacentAirport)) {
  321.                                 if((AIError.GetLastErrorString() != "ERR_ALREADY_BUILT") && (AIError.GetLastErrorString() != "ERR_PRECONDITION_FAILED")) {
  322.                                     if(AIError.GetLastErrorString() != "ERR_LOCAL_AUTHORITY_REFUSES") {
  323.                                         //AILog.Warning("Couldnt build station! " + AIError.GetLastErrorString());
  324.                                     }
  325.                                 }
  326.                                 ++counter;
  327.                             }
  328.                             else {
  329.                                 break;
  330.                             }
  331.                             AIController.Sleep(1);
  332.                         } while(counter < 1);
  333.                         if (counter == 1) {
  334.                             continue;
  335.                         }
  336.                         else {
  337.                             local counter = 0;
  338.                             do {
  339.                                 if(!TestBuildRoad().TryBuild(tile, adjTile) && AIError.GetLastErrorString() != "ERR_ALREADY_BUILT") {
  340.                                     ++counter;
  341.                                 }
  342.                                 else {
  343.                                     break;
  344.                                 }
  345.                                 AIController.Sleep(1);
  346.                             } while(counter < (stationTile == null ? 500 : 1));
  347.                             if(counter == (stationTile == null ? 500 : 1)) {
  348.                                 local counter = 0;
  349.                                 do {
  350.                                     if (!TestRemoveRoadStation().TryRemove(tile)) {
  351.                                         ++counter;
  352.                                     }
  353.                                     else {
  354. //                                      AILog.Warning("case" + adjRoadCount + "; Removed road station tile at " + tile);
  355.                                         break;
  356.                                     }
  357.                                     AIController.Sleep(1);
  358.                                 } while(counter < (stationTile == null ? 500 : 1));
  359.                                 if (counter == (stationTile == null ? 500 : 1)) {
  360.                                     AILog.Error("Failed to remove road station tile at " + tile + " - " + AIError.GetLastErrorString());
  361.                                     continue; // TODO: station should have been removed by now, but it wasn't!
  362.                                 } else {
  363.                                     continue;
  364.                                 }
  365.                             }
  366.                             else {
  367.                                 AILog.Info("Station built in " + AITown.GetName(town) + " at tile " + tile + "! case" + adjRoadCount);
  368.                                 //AISign.BuildSign(tile, "" + adjRoadCount);
  369.                                 return tile;
  370.                             }
  371.                         }
  372.                     }
  373.  
  374.                     break;
  375.  
  376.                 case 3:
  377.                 case 4:
  378.                     //similar to case 2 but always builds drivethrough station
  379.                     AIRoad.SetCurrentRoadType(AIRoad.ROADTYPE_ROAD);
  380.  
  381.                     if(AIRoad.IsRoadTile(tile)) {
  382.                         continue;
  383.                     }
  384.  
  385.                     //check whether adjacent tiles are opposite
  386.                     local adjTile = Utils.getOffsetTile(tile, -1, 0);
  387.                     local nextAdjTile = Utils.getOffsetTile(tile, 1, 0);
  388.                     if (!(adjRoadTiles.HasItem(adjTile) && adjRoadTiles.HasItem(nextAdjTile))) {
  389.                         adjTile = Utils.getOffsetTile(tile, 0, -1);
  390.                         nextAdjTile = Utils.getOffsetTile(tile, 0, 1);
  391.                     }
  392.  
  393.                     local heighDifference = abs(AITile.GetMaxHeight(nextAdjTile) - AITile.GetMaxHeight(adjTile));
  394.                     if(heighDifference != 0) {
  395.                         continue;
  396.                     }
  397.  
  398.                     local counter = 0;
  399.                     do {
  400.                         if (!TestBuildDriveThroughRoadStation().TryBuild(tile, adjTile, vehicleType, adjacentAirport)) {
  401.                             if((AIError.GetLastErrorString() != "ERR_ALREADY_BUILT") && (AIError.GetLastErrorString() != "ERR_PRECONDITION_FAILED")) {
  402.                                 if(AIError.GetLastErrorString() != "ERR_LOCAL_AUTHORITY_REFUSES") {
  403.                                     //AILog.Warning("Couldnt build station! " + AIError.GetLastErrorString());
  404.                                 }
  405.                             }
  406.                             ++counter;
  407.                         }
  408.                         else {
  409.                             break;
  410.                         }
  411.                         AIController.Sleep(1);
  412.                     } while(counter < 1);
  413.                     if (counter == 1) {
  414.                         continue;
  415.                     }
  416.                     else {
  417.                         local counter = 0;
  418.                         do {
  419.                             if(!TestBuildRoad().TryBuild(adjTile, nextAdjTile) && AIError.GetLastErrorString() != "ERR_ALREADY_BUILT") {
  420.                                 ++counter;
  421.                             }
  422.                             else {
  423.                                 break;
  424.                             }
  425.                             AIController.Sleep(1);
  426.                         } while(counter < (stationTile == null ? 500 : 1));
  427.                         if(counter == (stationTile == null ? 500 : 1)) {
  428.                             local counter = 0;
  429.                             do {
  430.                                 if (!TestRemoveRoadStation().TryRemove(tile)) {
  431.                                     ++counter;
  432.                                 }
  433.                                 else {
  434. //                                  AILog.Warning("case" + adjRoadCount + "; Removed drive through station tile at " + tile);
  435.                                     break;
  436.                                 }
  437.                                 AIController.Sleep(1);
  438.                             } while (counter < stationTile == null ? 500 : 1);
  439.                             if (counter == (stationTile == null ? 500 : 1)) {
  440.                                 AILog.Error("Failed to remove drive through station tile at " + tile + " - " + AIError.GetLastErrorString());
  441.                                 continue; // TODO: station should have been removed by now, but it wasn't!
  442.                             } else {
  443.                                 continue;
  444.                             }
  445.                         }
  446.                         else {
  447.                             AILog.Info("Drivethrough station built in " + AITown.GetName(town) + " at tile " + tile + "! case" + adjRoadCount);
  448.                             //AISign.BuildSign(tile, "" + adjRoadCount);
  449.                             return tile;
  450.                         }
  451.                     }
  452.  
  453.                     break;
  454.  
  455.                 default:
  456.                     break;
  457.             }
  458.         }
  459.  
  460.         return null;
  461.     }

Comments