openttd-ottdgrfs: comparison src/npf.cpp

equal deleted inserted replaced

-:91eca6fdee8d
+:6f41b8713b65
 /* $Id$ */
+/** @file npf.cpp */
 #include "stdafx.h"
 #include "openttd.h"
 #include "bridge_map.h"
 #include "debug.h"
 	uint maxx = minx + st->trainst_w - 1; // lowermost corner of station
 	uint maxy = miny + st->trainst_h - 1;
 	uint x;
 	uint y;
-	// we are going the aim for the x coordinate of the closest corner
+	/* we are going the aim for the x coordinate of the closest corner
-	// but if we are between those coordinates, we will aim for our own x coordinate
+	 * but if we are between those coordinates, we will aim for our own x coordinate */
 	x = clamp(TileX(tile), minx, maxx);
-	// same for y coordinate, see above comment
+	/* same for y coordinate, see above comment */
 	y = clamp(TileY(tile), miny, maxy);
-	// return the tile of our target coordinates
+	/* return the tile of our target coordinates */
 	return TileXY(x, y);
 }
 /* Calcs the heuristic to the target station or tile. For train stations, it
 * takes into account the direction of approach.
 	NPFFoundTargetData* ftd = (NPFFoundTargetData*)as->user_path;
 	TileIndex from = current->tile;
 	TileIndex to = fstd->dest_coords;
 	uint dist;
-	// for train-stations, we are going to aim for the closest station tile
+	/* for train-stations, we are going to aim for the closest station tile */
 	if (as->user_data[NPF_TYPE] == TRANSPORT_RAIL && fstd->station_index != INVALID_STATION)
 		to = CalcClosestStationTile(fstd->station_index, from);
 	if (as->user_data[NPF_TYPE] == TRANSPORT_ROAD) {
 		/* Since roads only have diagonal pieces, we use manhattan distance here */
 		/* We just popped out if this tunnel, since were
 		 * facing the tunnel exit */
 		FindLengthOfTunnelResult flotr;
 		flotr = FindLengthOfTunnel(tile, ReverseDiagDir(exitdir));
 		return flotr.length * NPF_TILE_LENGTH;
-		//TODO: Penalty for tunnels?
+		/* @todo: Penalty for tunnels? */
 	} else {
 		/* We are entering the tunnel, the enter tile is just a
 		 * straight track */
 		return NPF_TILE_LENGTH;
 	}
 #endif
 }
 static int32 NPFWaterPathCost(AyStar* as, AyStarNode* current, OpenListNode* parent)
 {
-	//TileIndex tile = current->tile;
+	/* TileIndex tile = current->tile; */
 	int32 cost = 0;
 	Trackdir trackdir = (Trackdir)current->direction;
-	cost = _trackdir_length[trackdir]; /* Should be different for diagonal tracks */
+	cost = _trackdir_length[trackdir]; // Should be different for diagonal tracks
 	if (IsBuoyTile(current->tile) && IsDiagonalTrackdir(trackdir))
-		cost += _patches.npf_buoy_penalty; /* A small penalty for going over buoys */
+		cost += _patches.npf_buoy_penalty; // A small penalty for going over buoys
 	if (current->direction != NextTrackdir((Trackdir)parent->path.node.direction))
 		cost += _patches.npf_water_curve_penalty;
-	/* TODO More penalties? */
+	/* @todo More penalties? */
 	return cost;
 }
 /* Determine the cost of this node, for road tracks */
 	cost += NPFSlopeCost(current);
 	/* Check for turns */
 	if (current->direction != NextTrackdir((Trackdir)parent->path.node.direction))
 		cost += _patches.npf_rail_curve_penalty;
-	//TODO, with realistic acceleration, also the amount of straight track between
+	/*TODO, with realistic acceleration, also the amount of straight track between
-	//      curves should be taken into account, as this affects the speed limit.
+	 *      curves should be taken into account, as this affects the speed limit. */
 	/* Check for reverse in depot */
 	if (IsTileDepotType(tile, TRANSPORT_RAIL) && as->EndNodeCheck(as, &new_node) != AYSTAR_FOUND_END_NODE) {
 		/* Penalise any depot tile that is not the last tile in the path. This
 		 * _should_ penalise every occurence of reversing in a depot (and only
 		default:
 			break;
 	}
-	return true; /* no need to check */
+	return true; // no need to check
 }
 /**
 * Returns the direction the exit of the depot on the given tile is facing.
 		DiagDirection exitdir;
 		/* Find out the exit direction first */
 		if (IsRoadStopTile(src_tile)) {
 			exitdir = GetRoadStopDir(src_tile);
-		} else { /* Train or road depot */
+		} else { // Train or road depot
 			exitdir = GetDepotDirection(src_tile, type);
 		}
 		/* Let's see if were headed the right way into the depot */
 		if (src_trackdir == DiagdirToDiagTrackdir(ReverseDiagDir(exitdir))) {
 	if (type != TRANSPORT_WATER && (IsStandardRoadStopTile(dst_tile) || IsTileDepotType(dst_tile, type))){
 		/* Road stations and road and train depots return 0 on GTTS, so we have to do this by hand... */
 		DiagDirection exitdir;
 		if (IsRoadStopTile(dst_tile)) {
 			exitdir = GetRoadStopDir(dst_tile);
-		} else { /* Road or train depot */
+		} else { // Road or train depot
 			exitdir = GetDepotDirection(dst_tile, type);
 		}
 		/* Find the trackdirs that are available for a depot or station with this
 		 * orientation. They are only "inwards", since we are reaching this tile
 		 * from some other tile. This prevents vehicles driving into depots from
 		DEBUG(npf, 5, "Expanded into trackdir: %d, remaining trackdirs: 0x%X", dst_trackdir, trackdirbits);
 		/* Check for oneway signal against us */
 		if (IsTileType(dst_tile, MP_RAILWAY) && GetRailTileType(dst_tile) == RAIL_TILE_SIGNALS) {
 			if (HasSignalOnTrackdir(dst_tile, ReverseTrackdir(dst_trackdir)) && !HasSignalOnTrackdir(dst_tile, dst_trackdir))
-				// if one way signal not pointing towards us, stop going in this direction.
+				/* if one way signal not pointing towards us, stop going in this direction. */
 				break;
 		}
 		{
 			/* We've found ourselves a neighbour :-) */
 			AyStarNode* neighbour = &aystar->neighbours[i];

branch	gamebalance
changeset 9906	6f41b8713b65
parent 9895	7bd07f43b0e3
child 6307	f40e88cff863