Mercurial Mercurial > openttd-ottdgrfs / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
src/ai/api/ai_engine.cpp
branchnoai
changeset 9736 183b38e0a480
parent 9734 52d385b38d63
child 9804 217f77b77400
equal deleted inserted replaced
9735:9f06148355f4 9736:183b38e0a480 
    16 #include "../../core/bitmath_func.hpp"
 
    16 #include "../../core/bitmath_func.hpp"
 
    17 #include "table/strings.h"
 
    17 #include "table/strings.h"
 
    18 
    18 
    19 /* static */ bool AIEngine::IsValidEngine(EngineID engine_id)
 
    19 /* static */ bool AIEngine::IsValidEngine(EngineID engine_id)
 
    20 {
 
    20 {
 
    21 	return ::IsEngineIndex(engine_id) && HasBit(GetEngine(engine_id)->player_avail, _current_player);
 
    21 	return ::IsEngineIndex(engine_id) && HasBit(::GetEngine(engine_id)->player_avail, _current_player);
 
    22 }
 
    22 }
 
    23 
    23 
    24 /* static */ char *AIEngine::GetName(EngineID engine_id)
 
    24 /* static */ char *AIEngine::GetName(EngineID engine_id)
 
    25 {
 
    25 {
 
    26 	if (!AIEngine::IsValidEngine(engine_id)) return NULL;
 
    26 	if (!IsValidEngine(engine_id)) return NULL;
 
    27 
    27 
    28 	static const int len = 64;
 
    28 	static const int len = 64;
 
    29 	char *engine_name = MallocT<char>(len);
 
    29 	char *engine_name = MallocT<char>(len);
 
    30 
    30 
    31 	::SetDParam(0, engine_id);
 
    31 	::SetDParam(0, engine_id);
 
    33 	return engine_name;
 
    33 	return engine_name;
 
    34 }
 
    34 }
 
    35 
    35 
    36 /* static */ CargoID AIEngine::GetCargoType(EngineID engine_id)
 
    36 /* static */ CargoID AIEngine::GetCargoType(EngineID engine_id)
 
    37 {
 
    37 {
 
    38 	if (!AIEngine::IsValidEngine(engine_id)) return 0;
 
    38 	if (!IsValidEngine(engine_id)) return 0;
 
    39 
    39 
    40 	switch (::GetEngine(engine_id)->type) {
 
    40 	switch (::GetEngine(engine_id)->type) {
 
    41 		case VEH_ROAD: {
 
    41 		case VEH_ROAD: {
 
    42 			const RoadVehicleInfo *vi = RoadVehInfo(engine_id);
 
    42 			const RoadVehicleInfo *vi = ::RoadVehInfo(engine_id);
 
    43 			return vi->cargo_type;
 
    43 			return vi->cargo_type;
 
    44 		} break;
 
    44 		} break;
 
    45 
    45 
    46 		case VEH_TRAIN: {
 
    46 		case VEH_TRAIN: {
 
    47 			const RailVehicleInfo *vi = RailVehInfo(engine_id);
 
    47 			const RailVehicleInfo *vi = ::RailVehInfo(engine_id);
 
    48 			return vi->cargo_type;
 
    48 			return vi->cargo_type;
 
    49 		} break;
 
    49 		} break;
 
    50 
    50 
    51 		case VEH_SHIP: {
 
    51 		case VEH_SHIP: {
 
    52 			const ShipVehicleInfo *vi = ShipVehInfo(engine_id);
 
    52 			const ShipVehicleInfo *vi = ::ShipVehInfo(engine_id);
 
    53 			return vi->cargo_type;
 
    53 			return vi->cargo_type;
 
    54 		} break;
 
    54 		} break;
 
    55 
    55 
    56 		case VEH_AIRCRAFT: {
 
    56 		case VEH_AIRCRAFT: {
 
    57 			return CT_PASSENGERS;
 
    57 			return CT_PASSENGERS;
 
    61 	}
 
    61 	}
 
    62 }
 
    62 }
 
    63 
    63 
    64 /* static */ uint32 AIEngine::GetCapacity(EngineID engine_id)
 
    64 /* static */ uint32 AIEngine::GetCapacity(EngineID engine_id)
 
    65 {
 
    65 {
 
    66 	if (!AIEngine::IsValidEngine(engine_id)) return 0;
 
    66 	if (!IsValidEngine(engine_id)) return 0;
 
    67 
    67 
    68 	switch (::GetEngine(engine_id)->type) {
 
    68 	switch (::GetEngine(engine_id)->type) {
 
    69 		case VEH_ROAD: {
 
    69 		case VEH_ROAD: {
 
    70 			const RoadVehicleInfo *vi = RoadVehInfo(engine_id);
 
    70 			const RoadVehicleInfo *vi = ::RoadVehInfo(engine_id);
 
    71 			return vi->capacity;
 
    71 			return vi->capacity;
 
    72 		} break;
 
    72 		} break;
 
    73 
    73 
    74 		case VEH_TRAIN: {
 
    74 		case VEH_TRAIN: {
 
    75 			const RailVehicleInfo *vi = RailVehInfo(engine_id);
 
    75 			const RailVehicleInfo *vi = ::RailVehInfo(engine_id);
 
    76 			return vi->capacity;
 
    76 			return vi->capacity;
 
    77 		} break;
 
    77 		} break;
 
    78 
    78 
    79 		case VEH_SHIP: {
 
    79 		case VEH_SHIP: {
 
    80 			const ShipVehicleInfo *vi = ShipVehInfo(engine_id);
 
    80 			const ShipVehicleInfo *vi = ::ShipVehInfo(engine_id);
 
    81 			return vi->capacity;
 
    81 			return vi->capacity;
 
    82 		} break;
 
    82 		} break;
 
    83 
    83 
    84 		case VEH_AIRCRAFT: {
 
    84 		case VEH_AIRCRAFT: {
 
    85 			const AircraftVehicleInfo *vi = AircraftVehInfo(engine_id);
 
    85 			const AircraftVehicleInfo *vi = ::AircraftVehInfo(engine_id);
 
    86 			return vi->passenger_capacity;
 
    86 			return vi->passenger_capacity;
 
    87 		} break;
 
    87 		} break;
 
    88 
    88 
    89 		default: NOT_REACHED();
 
    89 		default: NOT_REACHED();
 
    90 	}
 
    90 	}
 
    91 }
 
    91 }
 
    92 
    92 
    93 /* static */ uint32 AIEngine::GetReliability(EngineID engine_id)
 
    93 /* static */ uint32 AIEngine::GetReliability(EngineID engine_id)
 
    94 {
 
    94 {
 
    95 	if (!AIEngine::IsValidEngine(engine_id)) return 0;
 
    95 	if (!IsValidEngine(engine_id)) return 0;
 
    96 
    96 
    97 	return (::GetEngine(engine_id)->reliability * 100 >> 16);
 
    97 	return (::GetEngine(engine_id)->reliability * 100 >> 16);
 
    98 }
 
    98 }
 
    99 
    99 
   100 /* static */ uint32 AIEngine::GetMaxSpeed(EngineID engine_id)
 
   100 /* static */ uint32 AIEngine::GetMaxSpeed(EngineID engine_id)
 
   101 {
 
   101 {
 
   102 	if (!AIEngine::IsValidEngine(engine_id)) return 0;
 
   102 	if (!IsValidEngine(engine_id)) return 0;
 
   103 
   103 
   104 	switch (::GetEngine(engine_id)->type) {
 
   104 	switch (::GetEngine(engine_id)->type) {
 
   105 		case VEH_ROAD: {
 
   105 		case VEH_ROAD: {
 
   106 			const RoadVehicleInfo *vi = RoadVehInfo(engine_id);
 
   106 			const RoadVehicleInfo *vi = ::RoadVehInfo(engine_id);
 
   107 			/* Internal speeds are km/h * 2 */
 
   107 			/* Internal speeds are km/h * 2 */
 
   108 			return vi->max_speed / 2;
 
   108 			return vi->max_speed / 2;
 
   109 		} break;
 
   109 		} break;
 
   110 
   110 
   111 		case VEH_TRAIN: {
 
   111 		case VEH_TRAIN: {
 
   112 			const RailVehicleInfo *vi = RailVehInfo(engine_id);
 
   112 			const RailVehicleInfo *vi = ::RailVehInfo(engine_id);
 
   113 			return vi->max_speed;
 
   113 			return vi->max_speed;
 
   114 		} break;
 
   114 		} break;
 
   115 
   115 
   116 		case VEH_SHIP: {
 
   116 		case VEH_SHIP: {
 
   117 			const ShipVehicleInfo *vi = ShipVehInfo(engine_id);
 
   117 			const ShipVehicleInfo *vi = ::ShipVehInfo(engine_id);
 
   118 			/* Internal speeds are km/h * 2 */
 
   118 			/* Internal speeds are km/h * 2 */
 
   119 			return vi->max_speed / 2;
 
   119 			return vi->max_speed / 2;
 
   120 		} break;
 
   120 		} break;
 
   121 
   121 
   122 		case VEH_AIRCRAFT: {
 
   122 		case VEH_AIRCRAFT: {
 
   123 			const AircraftVehicleInfo *vi = AircraftVehInfo(engine_id);
 
   123 			const AircraftVehicleInfo *vi = ::AircraftVehInfo(engine_id);
 
   124 			return vi->max_speed;
 
   124 			return vi->max_speed;
 
   125 		} break;
 
   125 		} break;
 
   126 
   126 
   127 		default: NOT_REACHED();
 
   127 		default: NOT_REACHED();
 
   128 	}
 
   128 	}
 
   129 }
 
   129 }
 
   130 
   130 
   131 /* static */ uint32 AIEngine::GetPrice(EngineID engine_id)
 
   131 /* static */ uint32 AIEngine::GetPrice(EngineID engine_id)
 
   132 {
 
   132 {
 
   133 	if (!AIEngine::IsValidEngine(engine_id)) return 0;
 
   133 	if (!IsValidEngine(engine_id)) return 0;
 
   134 
   134 
   135 	switch (::GetEngine(engine_id)->type) {
 
   135 	switch (::GetEngine(engine_id)->type) {
 
   136 		case VEH_ROAD: {
 
   136 		case VEH_ROAD: {
 
   137 			const RoadVehicleInfo *vi = RoadVehInfo(engine_id);
 
   137 			const RoadVehicleInfo *vi = ::RoadVehInfo(engine_id);
 
   138 			return (_price.roadveh_base >> 3) * vi->base_cost >> 5;
 
   138 			return (_price.roadveh_base >> 3) * vi->base_cost >> 5;
 
   139 		} break;
 
   139 		} break;
 
   140 
   140 
   141 		case VEH_TRAIN: {
 
   141 		case VEH_TRAIN: {
 
   142 			const RailVehicleInfo *vi = RailVehInfo(engine_id);
 
   142 			const RailVehicleInfo *vi = ::RailVehInfo(engine_id);
 
   143 			return (_price.build_railvehicle >> 3) * vi->base_cost >> 5;
 
   143 			return (_price.build_railvehicle >> 3) * vi->base_cost >> 5;
 
   144 		} break;
 
   144 		} break;
 
   145 
   145 
   146 		case VEH_SHIP: {
 
   146 		case VEH_SHIP: {
 
   147 			const ShipVehicleInfo *vi = ShipVehInfo(engine_id);
 
   147 			const ShipVehicleInfo *vi = ::ShipVehInfo(engine_id);
 
   148 			return (_price.ship_base >> 3) * vi->base_cost >> 5;
 
   148 			return (_price.ship_base >> 3) * vi->base_cost >> 5;
 
   149 		} break;
 
   149 		} break;
 
   150 
   150 
   151 		case VEH_AIRCRAFT: {
 
   151 		case VEH_AIRCRAFT: {
 
   152 			const AircraftVehicleInfo *vi = AircraftVehInfo(engine_id);
 
   152 			const AircraftVehicleInfo *vi = ::AircraftVehInfo(engine_id);
 
   153 			return (_price.aircraft_base >> 3) * vi->base_cost >> 5;
 
   153 			return (_price.aircraft_base >> 3) * vi->base_cost >> 5;
 
   154 		} break;
 
   154 		} break;
 
   155 
   155 
   156 		default: NOT_REACHED();
 
   156 		default: NOT_REACHED();
 
   157 	}
 
   157 	}
 
   158 }
 
   158 }
 
   159 
   159 
   160 /* static */ uint32 AIEngine::GetMaxAge(EngineID engine_id)
 
   160 /* static */ uint32 AIEngine::GetMaxAge(EngineID engine_id)
 
   161 {
 
   161 {
 
   162 	if (!AIEngine::IsValidEngine(engine_id)) return 0;
 
   162 	if (!IsValidEngine(engine_id)) return 0;
 
   163 
   163 
   164 	return ::GetEngine(engine_id)->lifelength * 366;
 
   164 	return ::GetEngine(engine_id)->lifelength * 366;
 
   165 }
 
   165 }
 
   166 
   166 
   167 /* static */ Money AIEngine::GetRunningCost(EngineID engine_id)
 
   167 /* static */ Money AIEngine::GetRunningCost(EngineID engine_id)
 
   168 {
 
   168 {
 
   169 	if (!AIEngine::IsValidEngine(engine_id)) return 0;
 
   169 	if (!IsValidEngine(engine_id)) return 0;
 
   170 
   170 
   171 	/* We need to create an instance in order to obtain GetRunningCost.
 
   171 	/* We need to create an instance in order to obtain GetRunningCost.
 
   172 	 *  This means we temporary allocate a vehicle in the pool, but
 
   172 	 *  This means we temporary allocate a vehicle in the pool, but
 
   173 	 *  there is no other way.. */
 
   173 	 *  there is no other way.. */
 
   174 	Vehicle *vehicle;
 
   174 	Vehicle *vehicle;
 
   198 	return runningCost >> 8;
 
   198 	return runningCost >> 8;
 
   199 }
 
   199 }
 
   200 
   200 
   201 /* static */ AIVehicle::VehicleType AIEngine::GetVehicleType(EngineID engine_id)
 
   201 /* static */ AIVehicle::VehicleType AIEngine::GetVehicleType(EngineID engine_id)
 
   202 {
 
   202 {
 
   203 	if (!AIEngine::IsValidEngine(engine_id)) return AIVehicle::VEHICLE_INVALID;
 
   203 	if (!IsValidEngine(engine_id)) return AIVehicle::VEHICLE_INVALID;
 
   204 
   204 
   205 	switch (::GetEngine(engine_id)->type) {
 
   205 	switch (::GetEngine(engine_id)->type) {
 
   206 		case VEH_ROAD:     return AIVehicle::VEHICLE_ROAD;
 
   206 		case VEH_ROAD:     return AIVehicle::VEHICLE_ROAD;
 
   207 		case VEH_TRAIN:    return AIVehicle::VEHICLE_RAIL;
 
   207 		case VEH_TRAIN:    return AIVehicle::VEHICLE_RAIL;
 
   208 		case VEH_SHIP:     return AIVehicle::VEHICLE_WATER;
 
   208 		case VEH_SHIP:     return AIVehicle::VEHICLE_WATER;
openttd-ottdgrfs