src/aircraft_cmd.cpp
branchcpp_gui
changeset 6308 646711c5feaa
parent 6307 f40e88cff863
equal deleted inserted replaced
6307:f40e88cff863 6308:646711c5feaa
   391 		u->random_bits = VehicleRandomBits();
   391 		u->random_bits = VehicleRandomBits();
   392 
   392 
   393 		v->vehicle_flags = 0;
   393 		v->vehicle_flags = 0;
   394 		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SETBIT(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE);
   394 		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SETBIT(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE);
   395 
   395 
       
   396 		UpdateAircraftCache(v);
       
   397 
   396 		VehiclePositionChanged(v);
   398 		VehiclePositionChanged(v);
   397 		VehiclePositionChanged(u);
   399 		VehiclePositionChanged(u);
   398 
   400 
   399 		/* Aircraft with 3 vehicles (chopper)? */
   401 		/* Aircraft with 3 vehicles (chopper)? */
   400 		if (v->subtype == AIR_HELICOPTER) {
   402 		if (v->subtype == AIR_HELICOPTER) {
   567 			if (station == INVALID_STATION) return CMD_ERROR;
   569 			if (station == INVALID_STATION) return CMD_ERROR;
   568 			next_airport_index = station;
   570 			next_airport_index = station;
   569 		}
   571 		}
   570 
   572 
   571 		if (flags & DC_EXEC) {
   573 		if (flags & DC_EXEC) {
       
   574 			if (v->current_order.type == OT_LOADING) v->LeaveStation();
       
   575 
   572 			v->current_order.type = OT_GOTO_DEPOT;
   576 			v->current_order.type = OT_GOTO_DEPOT;
   573 			v->current_order.flags = OF_NON_STOP;
   577 			v->current_order.flags = OF_NON_STOP;
   574 			if (!(p2 & DEPOT_SERVICE)) SETBIT(v->current_order.flags, OFB_HALT_IN_DEPOT);
   578 			if (!(p2 & DEPOT_SERVICE)) SETBIT(v->current_order.flags, OFB_HALT_IN_DEPOT);
   575 			v->current_order.refit_cargo = CT_INVALID;
   579 			v->current_order.refit_cargo = CT_INVALID;
   576 			v->current_order.dest = next_airport_index;
   580 			v->current_order.dest = next_airport_index;
   713 	AgeVehicle(v);
   717 	AgeVehicle(v);
   714 	CheckIfAircraftNeedsService(v);
   718 	CheckIfAircraftNeedsService(v);
   715 
   719 
   716 	if (v->vehstatus & VS_STOPPED) return;
   720 	if (v->vehstatus & VS_STOPPED) return;
   717 
   721 
   718 	int32 cost = AircraftVehInfo(v->engine_type)->running_cost * _price.aircraft_running / 364;
   722 	int32 cost = GetVehicleProperty(v, 0x0E, AircraftVehInfo(v->engine_type)->running_cost) * _price.aircraft_running / 364;
   719 
   723 
   720 	v->profit_this_year -= cost >> 8;
   724 	v->profit_this_year -= cost >> 8;
   721 
   725 
   722 	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);
   726 	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);
   723 	SubtractMoneyFromPlayerFract(v->owner, cost);
   727 	SubtractMoneyFromPlayerFract(v->owner, cost);
   860 	if (!PlayVehicleSound(v, VSE_START)) {
   864 	if (!PlayVehicleSound(v, VSE_START)) {
   861 		SndPlayVehicleFx(AircraftVehInfo(v->engine_type)->sfx, v);
   865 		SndPlayVehicleFx(AircraftVehInfo(v->engine_type)->sfx, v);
   862 	}
   866 	}
   863 }
   867 }
   864 
   868 
       
   869 
       
   870 void UpdateAircraftCache(Vehicle *v)
       
   871 {
       
   872 	uint max_speed = GetVehicleProperty(v, 0x0C, 0);
       
   873 	if (max_speed != 0) {
       
   874 		/* Convert from original units to (approx) km/h */
       
   875 		max_speed = (max_speed * 129) / 10;
       
   876 
       
   877 		v->u.air.cached_max_speed = max_speed;
       
   878 	} else {
       
   879 		v->u.air.cached_max_speed = 0xFFFF;
       
   880 	}
       
   881 }
       
   882 
       
   883 
   865 /**
   884 /**
   866  * Special velocities for aircraft
   885  * Special velocities for aircraft
   867  */
   886  */
   868 enum AircraftSpeedLimits {
   887 enum AircraftSpeedLimits {
   869 	SPEED_LIMIT_TAXI     =     50,  ///< Maximum speed of an aircraft while taxiing
   888 	SPEED_LIMIT_TAXI     =     50,  ///< Maximum speed of an aircraft while taxiing
   882  */
   901  */
   883 static int UpdateAircraftSpeed(Vehicle *v, uint speed_limit = SPEED_LIMIT_NONE, bool hard_limit = true)
   902 static int UpdateAircraftSpeed(Vehicle *v, uint speed_limit = SPEED_LIMIT_NONE, bool hard_limit = true)
   884 {
   903 {
   885 	uint spd = v->acceleration * 16;
   904 	uint spd = v->acceleration * 16;
   886 	byte t;
   905 	byte t;
       
   906 
       
   907 	if (v->u.air.cached_max_speed < speed_limit) {
       
   908 		if (v->cur_speed < speed_limit) hard_limit = false;
       
   909 		speed_limit = v->u.air.cached_max_speed;
       
   910 	}
   887 
   911 
   888 	speed_limit = min(speed_limit, v->max_speed);
   912 	speed_limit = min(speed_limit, v->max_speed);
   889 
   913 
   890 	v->subspeed = (t=v->subspeed) + (byte)spd;
   914 	v->subspeed = (t=v->subspeed) + (byte)spd;
   891 
   915 
  1387 				}
  1411 				}
  1388 				return;
  1412 				return;
  1389 			}
  1413 			}
  1390 
  1414 
  1391 			Order b = v->current_order;
  1415 			Order b = v->current_order;
       
  1416 			v->LeaveStation();
  1392 			v->current_order.Free();
  1417 			v->current_order.Free();
  1393 			MarkAircraftDirty(v);
  1418 			MarkAircraftDirty(v);
  1394 			if (!(b.flags & OF_NON_STOP)) return;
  1419 			if (!(b.flags & OF_NON_STOP)) return;
  1395 			break;
  1420 			break;
  1396 		}
  1421 		}
  1854 
  1879 
  1855 	const AirportFTA *current = &apc->layout[v->u.air.pos];
  1880 	const AirportFTA *current = &apc->layout[v->u.air.pos];
  1856 	/* we have arrived in an important state (eg terminal, hangar, etc.) */
  1881 	/* we have arrived in an important state (eg terminal, hangar, etc.) */
  1857 	if (current->heading == v->u.air.state) {
  1882 	if (current->heading == v->u.air.state) {
  1858 		byte prev_pos = v->u.air.pos; // location could be changed in state, so save it before-hand
  1883 		byte prev_pos = v->u.air.pos; // location could be changed in state, so save it before-hand
       
  1884 		byte prev_state = v->u.air.state;
  1859 		_aircraft_state_handlers[v->u.air.state](v, apc);
  1885 		_aircraft_state_handlers[v->u.air.state](v, apc);
  1860 		if (v->u.air.state != FLYING) v->u.air.previous_pos = prev_pos;
  1886 		if (v->u.air.state != FLYING) v->u.air.previous_pos = prev_pos;
       
  1887 		if (v->u.air.state != prev_state) UpdateAircraftCache(v);
  1861 		return true;
  1888 		return true;
  1862 	}
  1889 	}
  1863 
  1890 
  1864 	v->u.air.previous_pos = v->u.air.pos; // save previous location
  1891 	v->u.air.previous_pos = v->u.air.pos; // save previous location
  1865 
  1892