Subversion Repositories Games.Carmageddon

Rev

Rev 20 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. // car.c + stuff.c
  2.  
  3. #include "car.h"
  4. #include "brender/brender.h"
  5. #include "brucetrk.h"
  6. #include "car.h"
  7. #include "constants.h"
  8. #include "controls.h"
  9. #include "crush.h"
  10. #include "displays.h"
  11. #include "finteray.h"
  12. #include "globvars.h"
  13. #include "globvrkm.h"
  14. #include "globvrme.h"
  15. #include "globvrpb.h"
  16. #include "graphics.h"
  17. #include "harness/config.h"
  18. #include "harness/trace.h"
  19. #include "netgame.h"
  20. #include "network.h"
  21. #include "oil.h"
  22. #include "opponent.h"
  23. #include "pd/sys.h"
  24. #include "pedestrn.h"
  25. #include "piping.h"
  26. #include "pratcam.h"
  27. #include "raycast.h"
  28. #include "replay.h"
  29. #include "skidmark.h"
  30. #include "sound.h"
  31. #include "spark.h"
  32. #include "trig.h"
  33. #include "utility.h"
  34. #include "world.h"
  35. #include <math.h>
  36. #include <stdlib.h>
  37.  
  38. int gDoing_physics = 0;
  39. br_scalar gDt = 0.f;
  40. // suffix added to avoid duplicate symbol
  41. int gCollision_detection_on__car = 1;
  42. // suffix added to avoid duplicate symbol
  43. br_vector3 gGround_normal__car = { { 0.0f, 1.0f, 0.0f } };
  44. // suffix added to avoid duplicate symbol
  45. void (*ControlCar[6])(tCar_spec*, br_scalar) = {
  46.     &ControlCar1,
  47.     &ControlCar2,
  48.     &ControlCar3,
  49.     &ControlCar4,
  50.     &ControlCar5,
  51.     NULL,
  52. };
  53. int gControl__car = 3;      // suffix added to avoid duplicate symbol
  54. int gFace_num__car = 1;     // suffix added to avoid duplicate symbol
  55. br_angle gOld_yaw__car = 0; // suffix added to avoid duplicate symbol
  56. br_angle gOld_zoom = 0;
  57. br_vector3 gCamera_pos_before_collide = { { 0 } };
  58. int gMetal_crunch_sound_id__car[5] = {
  59.     // suffix added to avoid duplicate symbol
  60.     5000,
  61.     5001,
  62.     5002,
  63.     5003,
  64.     5004,
  65. };
  66. int gMetal_scrape_sound_id__car[3] = {
  67.     // suffix added to avoid duplicate symbol
  68.     5010,
  69.     5011,
  70.     5012,
  71. };
  72. int gCar_car_collisions = 1;
  73. int gFreeze_mechanics = 0;
  74. tU32 gLast_cunning_stunt = 0;
  75. tU32 gWild_start = 0;
  76. tU32 gQuite_wild_start = 0;
  77. tU32 gQuite_wild_end = 0;
  78. tU32 gOn_me_wheels_start = 0;
  79. int gWoz_upside_down_at_all = 0;
  80. tS3_sound_tag gSkid_tag[2] = { 0, 0 };
  81. tCar_spec* gLast_car_to_skid[2] = { NULL, NULL };
  82. int gEliminate_faces = 0;
  83. br_vector3 gZero_v__car = { { 0 } }; // suffix added to avoid duplicate symbol
  84. tU32 gSwitch_time = 0;
  85. tSave_camera gSave_camera[2];
  86. tU32 gLast_mechanics_time;
  87. int gOpponent_viewing_mode;
  88. int gNet_player_to_view_index = -1;
  89. int gDouble_pling_water = 0;
  90. int gStop_opponents_moving = 0;
  91. float gDefensive_powerup_factor[6] = { 1.0f, 0.825f, 0.65f, 0.475f, 0.3f, 0.01f };
  92. float gOffensive_powerup_factor[6] = { 1.0f, 1.5f, 2.0f, 3.0f, 5.0f, 10.0f };
  93. float gEngine_powerup_factor[6] = { 1.3f, 1.9f, 2.5f, 3.2f, 4.0f, 10.0f };
  94. br_angle gPanning_camera_angle;
  95. br_scalar gPanning_camera_height;
  96. int gFace_count;
  97. float gCar_simplification_factor[2][5] = {
  98.     { 10.0f, 3.0f, 1.5f, 0.75f, 0.0f },
  99.     { 10.0f, 5.0f, 2.5f, 1.5f, 0.0f }
  100. };
  101. int gCar_simplification_level = 0;
  102. int gNum_active_non_cars = 0;
  103. int gCamera_has_collided = 0;
  104. tFace_ref gFace_list__car[150]; // suffix added to avoid duplicate symbol
  105. tNon_car_spec* gActive_non_car_list[50];
  106. int gOver_shoot;
  107. br_scalar gMin_world_y;
  108. br_scalar gAccel;
  109. br_vector3 gAverage_grid_position;
  110. br_actor* gPed_actor;
  111. int gCollision_count;
  112. int gCamera_frozen;
  113. int gMaterial_index;
  114. int gInTheSea;
  115. int gCamera_mode;
  116. br_scalar gOur_yaw__car;            // suffix added to avoid duplicate symbol
  117. br_scalar gGravity__car;            // suffix added to avoid duplicate symbol
  118. br_vector3 gNew_ground_normal__car; // suffix added to avoid duplicate symbol
  119. char gNon_car_spec_list[100];
  120. tU32 gMechanics_time_sync;
  121. int gNum_cars_and_non_cars;
  122.  
  123. // IDA: void __usercall DamageUnit(tCar_spec *pCar@<EAX>, int pUnit_type@<EDX>, int pDamage_amount@<EBX>)
  124. void DamageUnit(tCar_spec* pCar, int pUnit_type, int pDamage_amount) {
  125.     tDamage_unit* the_damage;
  126.     LOG_TRACE("(%p, %d, %d)", pCar, pUnit_type, pDamage_amount);
  127.  
  128.     if (pDamage_amount > 0) {
  129.         the_damage = &pCar->damage_units[pUnit_type];
  130.         the_damage->damage_level += pDamage_amount;
  131.         if (the_damage->damage_level >= 100) {
  132.             the_damage->damage_level = 99;
  133.         }
  134.     }
  135. }
  136.  
  137. // IDA: void __usercall DamageUnitWithSmoke(tCar_spec *pCar@<EAX>, int pUnit_type@<EDX>, int pDamage_amount@<EBX>)
  138. void DamageUnitWithSmoke(tCar_spec* pCar, int pUnit_type, int pDamage_amount) {
  139.     LOG_TRACE("(%p, %d, %d)", pCar, pUnit_type, pDamage_amount);
  140.  
  141.     DamageUnit(pCar, pUnit_type, pDamage_amount);
  142.     SortOutSmoke(pCar);
  143. }
  144.  
  145. // IDA: void __usercall DamageEngine(int pDamage_amount@<EAX>)
  146. void DamageEngine(int pDamage_amount) {
  147.     LOG_TRACE("(%d)", pDamage_amount);
  148.  
  149.     DamageUnitWithSmoke(&gProgram_state.current_car, eDamage_engine, pDamage_amount);
  150. }
  151.  
  152. // IDA: void __usercall DamageTrans(int pDamage_amount@<EAX>)
  153. void DamageTrans(int pDamage_amount) {
  154.     LOG_TRACE("(%d)", pDamage_amount);
  155.  
  156.     DamageUnitWithSmoke(&gProgram_state.current_car, eDamage_transmission, pDamage_amount);
  157. }
  158.  
  159. // IDA: void __usercall DamageSteering(int pDamage_amount@<EAX>)
  160. void DamageSteering(int pDamage_amount) {
  161.     LOG_TRACE("(%d)", pDamage_amount);
  162.  
  163.     DamageUnitWithSmoke(&gProgram_state.current_car, eDamage_steering, pDamage_amount);
  164. }
  165.  
  166. // IDA: void __usercall DamageLFWheel(int pDamage_amount@<EAX>)
  167. void DamageLFWheel(int pDamage_amount) {
  168.     LOG_TRACE("(%d)", pDamage_amount);
  169.  
  170.     DamageUnitWithSmoke(&gProgram_state.current_car, eDamage_lf_wheel, pDamage_amount);
  171. }
  172.  
  173. // IDA: void __usercall DamageLFBrake(int pDamage_amount@<EAX>)
  174. void DamageLFBrake(int pDamage_amount) {
  175.     LOG_TRACE("(%d)", pDamage_amount);
  176.  
  177.     DamageUnitWithSmoke(&gProgram_state.current_car, eDamage_lf_brake, pDamage_amount);
  178. }
  179.  
  180. // IDA: void __usercall DamageLRBrake(int pDamage_amount@<EAX>)
  181. void DamageLRBrake(int pDamage_amount) {
  182.     LOG_TRACE("(%d)", pDamage_amount);
  183.  
  184.     DamageUnitWithSmoke(&gProgram_state.current_car, eDamage_lr_brake, pDamage_amount);
  185. }
  186.  
  187. // IDA: void __usercall DamageLRWheel(int pDamage_amount@<EAX>)
  188. void DamageLRWheel(int pDamage_amount) {
  189.     LOG_TRACE("(%d)", pDamage_amount);
  190.  
  191.     DamageUnitWithSmoke(&gProgram_state.current_car, eDamage_lr_wheel, pDamage_amount);
  192. }
  193.  
  194. // IDA: void __usercall DamageRFWheel(int pDamage_amount@<EAX>)
  195. void DamageRFWheel(int pDamage_amount) {
  196.     LOG_TRACE("(%d)", pDamage_amount);
  197.  
  198.     DamageUnitWithSmoke(&gProgram_state.current_car, eDamage_rf_wheel, pDamage_amount);
  199. }
  200.  
  201. // IDA: void __usercall DamageRFBrake(int pDamage_amount@<EAX>)
  202. void DamageRFBrake(int pDamage_amount) {
  203.     LOG_TRACE("(%d)", pDamage_amount);
  204.  
  205.     DamageUnitWithSmoke(&gProgram_state.current_car, eDamage_rf_brake, pDamage_amount);
  206. }
  207.  
  208. // IDA: void __usercall DamageRRBrake(int pDamage_amount@<EAX>)
  209. void DamageRRBrake(int pDamage_amount) {
  210.     LOG_TRACE("(%d)", pDamage_amount);
  211.  
  212.     DamageUnitWithSmoke(&gProgram_state.current_car, eDamage_rr_brake, pDamage_amount);
  213. }
  214.  
  215. // IDA: void __usercall DamageRRWheel(int pDamage_amount@<EAX>)
  216. void DamageRRWheel(int pDamage_amount) {
  217.     LOG_TRACE("(%d)", pDamage_amount);
  218.  
  219.     DamageUnitWithSmoke(&gProgram_state.current_car, eDamage_rr_wheel, pDamage_amount);
  220. }
  221.  
  222. // IDA: void __usercall CalculatePlaneNormal(br_vector3 *pP1@<EAX>, br_vector3 *pP2@<EDX>, br_vector3 *pP3@<EBX>, br_vector3 *pNormal@<ECX>)
  223. void CalculatePlaneNormal(br_vector3* pP1, br_vector3* pP2, br_vector3* pP3, br_vector3* pNormal) {
  224.     //br_vector3 p0; // Pierre-Marie Baty -- unused variable
  225.     //br_vector3 p1; // Pierre-Marie Baty -- unused variable
  226.     //br_vector3 cross_product; // Pierre-Marie Baty -- unused variable
  227.     //br_vector3 temp_vector; // Pierre-Marie Baty -- unused variable
  228.     LOG_TRACE("(%p, %p, %p, %p)", pP1, pP2, pP3, pNormal);
  229.     NOT_IMPLEMENTED();
  230. }
  231.  
  232. // IDA: void __usercall CalculateGroundNormal(br_model *pThe_model@<EAX>, int pFace_index@<EDX>)
  233. void CalculateGroundNormal(br_model* pThe_model, int pFace_index) {
  234.     LOG_TRACE("(%p, %d)", pThe_model, pFace_index);
  235.     NOT_IMPLEMENTED();
  236. }
  237.  
  238. // IDA: void __cdecl ChangeYCoordinate(br_scalar pNew_y, tU32 pTime_taken, br_model *pThe_model, int pFace_index)
  239. void ChangeYCoordinate(br_scalar pNew_y, tU32 pTime_taken, br_model* pThe_model, int pFace_index) {
  240.     //br_scalar y_change; // Pierre-Marie Baty -- unused variable
  241.     //br_transform new_transform; // Pierre-Marie Baty -- unused variable
  242.     //br_vector3 side_window; // Pierre-Marie Baty -- unused variable
  243.     LOG_TRACE("(%f, %d, %p, %d)", pNew_y, pTime_taken, pThe_model, pFace_index);
  244.     NOT_IMPLEMENTED();
  245. }
  246.  
  247. // IDA: void __usercall SwitchCarActor(tCar_spec *pCar_spec@<EAX>, int pModel_index@<EDX>)
  248. void SwitchCarActor(tCar_spec* pCar_spec, int pModel_index) {
  249.     int i;
  250.     LOG_TRACE("(%p, %d)", pCar_spec, pModel_index);
  251.  
  252.     for (i = 0; i < pCar_spec->car_actor_count; i++) {
  253.         if (i == pModel_index) {
  254.             pCar_spec->car_model_actors[i].actor->render_style = BR_RSTYLE_FACES;
  255.         } else {
  256.             pCar_spec->car_model_actors[i].actor->render_style = BR_RSTYLE_NONE;
  257.         }
  258.     }
  259.     pCar_spec->current_car_actor = pModel_index;
  260. }
  261.  
  262. // IDA: void __usercall InitialiseCar2(tCar_spec *pCar@<EAX>, int pClear_disabled_flag@<EDX>)
  263. void InitialiseCar2(tCar_spec* pCar, int pClear_disabled_flag) {
  264.     int index;
  265.     int j;
  266.     //int cat; // Pierre-Marie Baty -- unused variable
  267.     //int car_count; // Pierre-Marie Baty -- unused variable
  268.     br_actor* car_actor;
  269.     //br_angle initial_yaw; // Pierre-Marie Baty -- unused variable
  270.     //br_scalar nearest_y_above; // Pierre-Marie Baty -- unused variable
  271.     //br_scalar nearest_y_below; // Pierre-Marie Baty -- unused variable
  272.     //br_scalar speed; // Pierre-Marie Baty -- unused variable
  273.     //int below_face_index; // Pierre-Marie Baty -- unused variable
  274.     //int above_face_index; // Pierre-Marie Baty -- unused variable
  275.     //br_model* below_model; // Pierre-Marie Baty -- unused variable
  276.     //br_model* above_model; // Pierre-Marie Baty -- unused variable
  277.     //br_vector3 grid_offset; // Pierre-Marie Baty -- unused variable
  278.     //br_matrix34 initial_yaw_matrix; // Pierre-Marie Baty -- unused variable
  279.     br_matrix34 safe_position;
  280.     LOG_TRACE("(%p, %d)", pCar, pClear_disabled_flag);
  281.  
  282.     PossibleService();
  283.     if (pCar->disabled && pClear_disabled_flag) {
  284.         EnableCar(pCar);
  285.     }
  286.     car_actor = pCar->car_master_actor;
  287.     InitCarSkidStuff(pCar);
  288.     if (pCar->current_car_actor >= 0) {
  289.         pCar->car_model_actors[pCar->current_car_actor].actor->render_style = BR_RSTYLE_NONE;
  290.     }
  291.     SwitchCarActor(pCar, pCar->current_car_actor);
  292.     if (strcmp(pCar->name, "STELLA.TXT") == 0) {
  293.         pCar->proxy_ray_distance = 6.0f;
  294.     } else {
  295.         pCar->proxy_ray_distance = 0.0f;
  296.     }
  297.     pCar->last_special_volume = NULL;
  298.     pCar->auto_special_volume = NULL;
  299.     pCar->num_smoke_columns = 0;
  300.     pCar->who_last_hit_me = NULL;
  301.     pCar->screen_material_source = NULL;
  302.     if (pCar->screen_material != NULL) {
  303.         pCar->screen_material->colour_map = NULL;
  304.         pCar->screen_material->index_shade = gRender_shade_table;
  305.         BrMaterialUpdate(pCar->screen_material, BR_MATU_ALL);
  306.     }
  307.     if (pCar->driver == eDriver_local_human) {
  308.         ResetRecoveryVouchers();
  309.     }
  310.     BrVector3SetFloat(&pCar->v, 0.0f, 0.0f, 0.0f);
  311.     BrVector3SetFloat(&pCar->omega, 0.0f, 0.0f, 0.0f);
  312.     pCar->curvature = 0.0f;
  313.     BrMatrix34Copy(&safe_position, &car_actor->t.t.mat);
  314.     if (safe_position.m[3][0] > 500.0f) {
  315.         safe_position.m[3][0] -= 1000.0f;
  316.         safe_position.m[3][1] -= 1000.0f;
  317.         safe_position.m[3][2] -= 1000.0f;
  318.     }
  319.     BrMatrix34Copy(&pCar->old_frame_mat, &safe_position);
  320.     BrMatrix34Copy(&pCar->oldmat, &safe_position);
  321.     BrVector3Scale((br_vector3*)pCar->oldmat.m[3], (br_vector3*)pCar->oldmat.m[3], WORLD_SCALE);
  322.     BrMatrix34ApplyP(&pCar->pos, &pCar->cmpos, &pCar->oldmat);
  323.     BrVector3InvScale(&pCar->pos, &pCar->pos, WORLD_SCALE);
  324.     for (j = 0; j < COUNT_OF(pCar->oldd); j++) {
  325.         pCar->oldd[j] = pCar->ride_height;
  326.     }
  327.     pCar->gear = 0;
  328.     pCar->revs = 0.f;
  329.     pCar->traction_control = 1;
  330.     BrVector3Negate(&pCar->direction, (br_vector3*)car_actor->t.t.mat.m[2]);
  331.     for (j = 0; j < COUNT_OF(pCar->last_safe_positions); j++) {
  332.         BrMatrix34Copy(&pCar->last_safe_positions[j], &safe_position);
  333.     }
  334.     pCar->message.type = 0;
  335.     pCar->message.time = 0;
  336.     pCar->dt = -1.f;
  337.     pCar->last_car_car_collision = 1;
  338.     pCar->time_to_recover = 0;
  339.     pCar->repair_time = 0;
  340.  
  341.     switch (pCar->driver) {
  342.  
  343.     case eDriver_oppo:
  344.         index = 0;
  345.         for (j = 0; j < gCurrent_race.number_of_racers; j++) {
  346.             if (gCurrent_race.opponent_list[j].car_spec->driver == eDriver_oppo) {
  347.                 if (gCurrent_race.opponent_list[j].car_spec == pCar) {
  348.                     pCar->car_ID = index + 512;
  349.                 }
  350.                 index++;
  351.             }
  352.         }
  353.         break;
  354.  
  355.     case eDriver_net_human:
  356.         index = 0;
  357.         for (j = 0; j < gCurrent_race.number_of_racers; j++) {
  358.             if (gCurrent_race.opponent_list[j].car_spec
  359.                 && gCurrent_race.opponent_list[j].car_spec->driver == eDriver_net_human) {
  360.                 if (gCurrent_race.opponent_list[j].car_spec == pCar) {
  361.                     pCar->car_ID = index + 256;
  362.                 }
  363.                 index++;
  364.             }
  365.         }
  366.         break;
  367.  
  368.     case eDriver_local_human:
  369.         pCar->car_ID = 0;
  370.         break;
  371.  
  372.     default:
  373.         LOG_WARN("Case %d not handled", pCar->driver);
  374.         break;
  375.     }
  376.     PossibleService();
  377.     pCar->box_face_ref = gFace_num__car - 2;
  378.     pCar->doing_nothing_flag = 0;
  379.     pCar->end_steering_damage_effect = 0;
  380.     pCar->end_trans_damage_effect = 0;
  381.     pCar->wheel_dam_offset[0] = 0.f;
  382.     pCar->wheel_dam_offset[1] = 0.f;
  383.     pCar->wheel_dam_offset[2] = 0.f;
  384.     pCar->wheel_dam_offset[3] = 0.f;
  385.     pCar->shadow_intersection_flags = 0;
  386.     pCar->underwater_ability = 0;
  387.     pCar->invulnerable = 0;
  388.     pCar->wall_climber_mode = 0;
  389.     pCar->grip_multiplier = 1.f;
  390.     pCar->damage_multiplier = 1.f;
  391.     pCar->collision_mass_multiplier = 1.f;
  392.     pCar->engine_power_multiplier = 1.f;
  393.     pCar->bounce_rate = 0.f;
  394.     pCar->bounce_amount = 0.f;
  395.     pCar->knackered = 0;
  396.     TotallyRepairACar(pCar);
  397.     SetCarSuspGiveAndHeight(pCar, 1.f, 1.f, 1.f, 0.f, 0.f);
  398.     for (j = 0; j < COUNT_OF(pCar->powerups); ++j) {
  399.         pCar->powerups[j] = 0;
  400.     }
  401.     if (gNet_mode != eNet_mode_none) {
  402.         for (j = 0; j < COUNT_OF(pCar->power_up_levels); j++) {
  403.             pCar->power_up_levels[j] = 0;
  404.         }
  405.     }
  406. }
  407.  
  408. // IDA: void __usercall InitialiseCar(tCar_spec *pCar@<EAX>)
  409. void InitialiseCar(tCar_spec* pCar) {
  410.     LOG_TRACE("(%p)", pCar);
  411.  
  412.     InitialiseCar2(pCar, 1);
  413. }
  414.  
  415. // IDA: void __usercall InitialiseCarsEtc(tRace_info *pThe_race@<EAX>)
  416. void InitialiseCarsEtc(tRace_info* pThe_race) {
  417.     int i;
  418.     int cat;
  419.     int car_count;
  420.     tCar_spec* car;
  421.     br_bounds bnds;
  422.     LOG_TRACE("(%p)", pThe_race);
  423.  
  424.     gProgram_state.initial_position = pThe_race->initial_position;
  425.     gProgram_state.initial_yaw = pThe_race->initial_yaw;
  426.     BrActorToBounds(&bnds, gProgram_state.track_spec.the_actor);
  427.     gMin_world_y = bnds.min.v[1];
  428.     gNum_active_non_cars = 0;
  429.     for (cat = eVehicle_self; cat <= eVehicle_not_really; cat++) {
  430.         if (cat == eVehicle_self) {
  431.             car_count = 1;
  432.         } else {
  433.             car_count = GetCarCount(cat);
  434.         }
  435.         for (i = 0; i < car_count; i++) {
  436.             PossibleService();
  437.             if (cat == eVehicle_self) {
  438.                 car = &gProgram_state.current_car;
  439.             } else {
  440.                 car = GetCarSpec(cat, i);
  441.             }
  442.             if (cat != eVehicle_not_really) {
  443.                 InitialiseCar(car);
  444.             }
  445.         }
  446.     }
  447.     gCamera_yaw = 0;
  448.     InitialiseExternalCamera();
  449.     gLast_mechanics_time = 0;
  450. }
  451.  
  452. // IDA: void __usercall GetAverageGridPosition(tRace_info *pThe_race@<EAX>)
  453. void GetAverageGridPosition(tRace_info* pThe_race) {
  454.     int i;
  455.     br_scalar total_cars;
  456.     tCar_spec* car;
  457.     LOG_TRACE("(%p)", pThe_race);
  458.  
  459.     total_cars = 0.0f;
  460.     BrVector3SetFloat(&gAverage_grid_position, 0.0f, 0.0f, 0.0f);
  461.     for (i = 0; i < pThe_race->number_of_racers; i++) {
  462.         car = pThe_race->opponent_list[i].car_spec;
  463.         BrVector3Accumulate(&gAverage_grid_position, &car->pos);
  464.         total_cars += 1.0f;
  465.     }
  466.     BrVector3InvScale(&gAverage_grid_position, &gAverage_grid_position, total_cars);
  467. }
  468.  
  469. // IDA: void __usercall SetInitialPosition(tRace_info *pThe_race@<EAX>, int pCar_index@<EDX>, int pGrid_index@<EBX>)
  470. void SetInitialPosition(tRace_info* pThe_race, int pCar_index, int pGrid_index) {
  471.     int place_on_grid;
  472.     int i;
  473.     int start_i;
  474.     int j;
  475.     br_actor* car_actor;
  476.     br_angle initial_yaw;
  477.     br_scalar nearest_y_above;
  478.     br_scalar nearest_y_below;
  479.     //br_scalar speed; // Pierre-Marie Baty -- unused variable
  480.     int below_face_index;
  481.     int above_face_index;
  482.     br_model* below_model;
  483.     br_model* above_model;
  484.     tCar_spec* car;
  485.     br_vector3 grid_offset;
  486.     br_vector3 dist;
  487.     br_vector3 real_pos;
  488.     br_matrix34 initial_yaw_matrix;
  489.     //br_bounds bnds; // Pierre-Marie Baty -- unused variable
  490.     LOG_TRACE("(%p, %d, %d)", pThe_race, pCar_index, pGrid_index);
  491.  
  492.     initial_yaw = 0;
  493.     car_actor = pThe_race->opponent_list[pCar_index].car_spec->car_master_actor;
  494.     car = pThe_race->opponent_list[pCar_index].car_spec;
  495.     BrMatrix34Identity(&car_actor->t.t.mat);
  496.     place_on_grid = 1;
  497.     if (gNet_mode != eNet_mode_none && !gCurrent_net_game->options.grid_start && pThe_race->number_of_net_start_points != 0) {
  498.         start_i = i = IRandomBetween(0, pThe_race->number_of_net_start_points - 1);
  499.         do {
  500.             PossibleService();
  501.             for (j = 0; j < gNumber_of_net_players; j++) {
  502.                 if (j != pCar_index) {
  503.                     BrVector3Copy(&real_pos, &pThe_race->opponent_list[j].car_spec->car_master_actor->t.t.translate.t);
  504.                     if (real_pos.v[0] > 500.f) {
  505.                         real_pos.v[0] -= 1000.f;
  506.                         real_pos.v[1] -= 1000.f;
  507.                         real_pos.v[2] -= 1000.f;
  508.                     }
  509.                     BrVector3Sub(&dist, &real_pos, &pThe_race->net_starts[i].pos);
  510.                     if (BrVector3LengthSquared(&dist) < 16.f) {
  511.                         break;
  512.                     }
  513.                 }
  514.             }
  515.             if (j == gNumber_of_net_players) {
  516.                 BrVector3Copy(&car_actor->t.t.translate.t, &pThe_race->net_starts[i].pos);
  517.                 initial_yaw = BrDegreeToAngle(pThe_race->net_starts[i].yaw);
  518.                 place_on_grid = 0;
  519.             }
  520.             i++;
  521.             if (i == pThe_race->number_of_net_start_points) {
  522.                 i = 0;
  523.             }
  524.         } while (start_i != i);
  525.     }
  526.     if (place_on_grid) {
  527.         initial_yaw = BrDegreeToAngle(pThe_race->initial_yaw);
  528.         BrMatrix34RotateY(&initial_yaw_matrix, initial_yaw);
  529.         grid_offset.v[0] = 0.0f - pGrid_index % 2;
  530.         grid_offset.v[1] = 0.0f;
  531.         grid_offset.v[2] = (br_scalar)(pGrid_index / 2) * 2.0f + (br_scalar)(pGrid_index % 2) * 0.4f;
  532.         BrMatrix34ApplyV(&car_actor->t.t.translate.t, &grid_offset, &initial_yaw_matrix);
  533.         BrVector3Accumulate(&car_actor->t.t.translate.t, &pThe_race->initial_position);
  534.     }
  535.     FindBestY(
  536.         &car_actor->t.t.translate.t,
  537.         gTrack_actor,
  538.         10.0f,
  539.         &nearest_y_above,
  540.         &nearest_y_below,
  541.         &above_model,
  542.         &below_model,
  543.         &above_face_index,
  544.         &below_face_index);
  545.     if (nearest_y_above != 30000.0f) {
  546.         car_actor->t.t.translate.t.v[1] = nearest_y_above;
  547.     } else if (nearest_y_below != -30000.0f) {
  548.         car_actor->t.t.translate.t.v[1] = nearest_y_below;
  549.     } else {
  550.         car_actor->t.t.translate.t.v[1] = 0.0f;
  551.     }
  552.     BrMatrix34PreRotateY(&car_actor->t.t.mat, initial_yaw);
  553.     if (gNet_mode) {
  554.         BrMatrix34Copy(
  555.             &gNet_players[pThe_race->opponent_list[pCar_index].net_player_index].initial_position,
  556.             &car->car_master_actor->t.t.mat);
  557.     }
  558.     if (gNet_mode != eNet_mode_none && car->disabled && car_actor->t.t.translate.t.v[0] < 500.0f) {
  559.         DisableCar(car);
  560.     }
  561.     // Enable to start all opponent cars upside down ;)
  562.     // if (strstr(car->name, "EAGLE") == 0) {
  563.     //     car_actor->t.t.translate.t.v[1] += 2;
  564.     //     car_actor->t.t.look_up.up.v[1] = -1;
  565.     // }
  566. }
  567.  
  568. // IDA: void __usercall SetInitialPositions(tRace_info *pThe_race@<EAX>)
  569. void SetInitialPositions(tRace_info* pThe_race) {
  570.     int i;
  571.     LOG_TRACE("(%p)", pThe_race);
  572.  
  573.     for (i = 0; i < pThe_race->number_of_racers; i++) {
  574.         SetInitialPosition(pThe_race, i, i);
  575.     }
  576. }
  577.  
  578. // IDA: void __usercall InitialiseNonCar(tNon_car_spec *non_car@<EAX>)
  579. void InitialiseNonCar(tNon_car_spec* non_car) {
  580.     tCollision_info* c;
  581.     LOG_TRACE("(%p)", non_car);
  582.  
  583.     c = &non_car->collision_info;
  584.     BrMatrix34Copy(&c->oldmat, &c->car_master_actor->t.t.mat);
  585.     non_car->collision_info.box_face_ref = gFace_num__car - 2;
  586.     non_car->collision_info.doing_nothing_flag = 1;
  587.     non_car->collision_info.disabled = 0;
  588.     BrVector3SetFloat(&c->v, 0.0f, 0.0f, 0.0f);
  589.     BrVector3SetFloat(&c->omega, 0.0f, 0.0f, 0.0f);
  590.     BrVector3SetFloat(&c->oldomega, 0.0f, 0.0f, 0.0f);
  591.     non_car->collision_info.box_face_ref = gFace_num__car - 2;
  592.     c->collision_flag = 0;
  593.     c->who_last_hit_me = NULL;
  594.     if (c->car_master_actor->identifier[3] == '!') {
  595.         c->M = non_car->free_mass;
  596.         c->min_torque_squared = 0.0f;
  597.         BrVector3Copy(&c->cmpos, &non_car->free_cmpos);
  598.     } else {
  599.         c->M = non_car->attached_mass;
  600.         BrVector3Copy(&c->cmpos, &non_car->attached_cmpos);
  601.         c->min_torque_squared = non_car->min_torque_squared;
  602.     }
  603.     BrVector3Scale(&c->I, &non_car->I_over_M, c->M);
  604.     c->message.type = 0;
  605.     c->message.time = 0;
  606.     c->dt = -1.0f;
  607.     c->last_car_car_collision = 1;
  608. }
  609.  
  610. // IDA: void __usercall GetFacesInBox(tCollision_info *c@<EAX>)
  611. void GetFacesInBox(tCollision_info* c) {
  612.     tBounds bnds;
  613.     br_bounds new_in_old;
  614.     br_bounds predicted_bounds;
  615.     br_matrix34 mat;
  616.     br_matrix34 mat2;
  617.     br_matrix34 mat3;
  618.     br_matrix34 mat4;
  619.     br_matrix34 mat5;
  620.     br_matrix34 mat6;
  621.     br_scalar old_d;
  622.     int i;
  623.     br_bounds current_bounds;
  624.     LOG_TRACE("(%p)", c);
  625.  
  626.     BrMatrix34Copy(&mat, &c->car_master_actor->t.t.mat);
  627.     BrMatrix34Copy(&mat2, &c->oldmat);
  628.     BrVector3InvScale((br_vector3*)mat.m[3], (br_vector3*)mat.m[3], WORLD_SCALE);
  629.     BrVector3InvScale((br_vector3*)mat2.m[3], (br_vector3*)mat2.m[3], WORLD_SCALE);
  630.     BrMatrix34LPInverse(&mat3, &mat);
  631.     BrMatrix34Mul(&mat4, &mat2, &mat3);
  632.     GetNewBoundingBox(&bnds.original_bounds, c->bounds, &mat4);
  633.     for (i = 0; i < 3; i++) {
  634.         if (bnds.original_bounds.min.v[i] > c->bounds[0].min.v[i]) {
  635.             bnds.original_bounds.min.v[i] = c->bounds[0].min.v[i];
  636.         }
  637.         if (bnds.original_bounds.max.v[i] < c->bounds[0].max.v[i]) {
  638.             bnds.original_bounds.max.v[i] = c->bounds[0].max.v[i];
  639.         }
  640.         bnds.original_bounds.min.v[i] -= 0.002f;
  641.         bnds.original_bounds.max.v[i] += 0.002f;
  642.     }
  643.     GetNewBoundingBox(&c->bounds_world_space, &bnds.original_bounds, &mat);
  644.     c->bounds_ws_type = eBounds_ws;
  645.     if ((c->box_face_ref != gFace_num__car && (c->box_face_ref != gFace_num__car - 1 || c->box_face_start <= gFace_count))
  646.         || (BrMatrix34Mul(&mat5, &mat, &c->last_box_inv_mat),
  647.             GetNewBoundingBox(&new_in_old, &bnds.original_bounds, &mat5),
  648.             c->last_box.max.v[0] <= new_in_old.max.v[0])
  649.         || c->last_box.max.v[1] <= new_in_old.max.v[1]
  650.         || c->last_box.max.v[2] <= new_in_old.max.v[2]
  651.         || c->last_box.min.v[0] >= new_in_old.min.v[0]
  652.         || c->last_box.min.v[1] >= new_in_old.min.v[1]
  653.         || c->last_box.min.v[2] >= new_in_old.min.v[2]) {
  654.         BrMatrix34Mul(&mat5, &mat4, &mat4);
  655.         BrMatrix34Mul(&mat6, &mat5, &mat4);
  656.         BrMatrix34LPInverse(&mat5, &mat6);
  657.         GetNewBoundingBox(&predicted_bounds, c->bounds, &mat5);
  658.         for (i = 0; i < 3; i++) {
  659.             if (bnds.original_bounds.min.v[i] > predicted_bounds.min.v[i]) {
  660.                 bnds.original_bounds.min.v[i] = predicted_bounds.min.v[i];
  661.             }
  662.             if (bnds.original_bounds.max.v[i] < predicted_bounds.max.v[i]) {
  663.                 bnds.original_bounds.max.v[i] = predicted_bounds.max.v[i];
  664.             }
  665.             bnds.original_bounds.min.v[i] -= 0.02f;
  666.             bnds.original_bounds.max.v[i] += 0.02f;
  667.         }
  668.         c->last_box = bnds.original_bounds;
  669.         BrMatrix34Copy(&c->last_box_inv_mat, &mat3);
  670.         bnds.mat = &mat;
  671.         c->box_face_start = gFace_count;
  672.         gPling_face = NULL;
  673.         gFace_count += FindFacesInBox(&bnds, &gFace_list__car[gFace_count], COUNT_OF(gFace_list__car) - gFace_count);
  674.         if (gFace_count >= COUNT_OF(gFace_list__car)) {
  675.             c->box_face_start = 0;
  676.             gFace_count = FindFacesInBox(&bnds, gFace_list__car, COUNT_OF(gFace_list__car));
  677.             gFace_num__car++;
  678.         }
  679.         old_d = c->water_d;
  680.         if (c->driver == eDriver_local_human
  681.             && c->water_d != 10000.f
  682.             && gDouble_pling_water
  683.             && BrVector3Dot(&c->bounds_world_space.max, &c->water_normal) - c->water_d <= 0.f) {
  684.             gInTheSea = 1;
  685.             FreezeCamera();
  686.         }
  687.         if (gPling_face != NULL && fabsf(gPling_face->normal.v[1]) >= 0.9f) {
  688.             BrVector3Copy(&c->water_normal, &gPling_face->normal);
  689.             if (c->water_normal.v[1] < 0.f) {
  690.                 BrVector3Negate(&c->water_normal, &c->water_normal);
  691.             }
  692.             c->water_d = BrVector3Dot(&gPling_face->v[0], &c->water_normal);
  693.             if (c->driver == eDriver_local_human) {
  694.                 if (gPling_face->material->identifier[1] != '!') {
  695.                     gDouble_pling_water = 0;
  696.                 } else {
  697.                     if (BrVector3Dot(&c->bounds_world_space.min, &c->water_normal) - c->water_d < 0.0f) {
  698.                         GetNewBoundingBox(&current_bounds, &c->bounds[1], &c->car_master_actor->t.t.mat);
  699.                         if (BrVector3Dot(&current_bounds.min, &c->water_normal) / WORLD_SCALE - c->water_d < 0.0f) {
  700.                             gInTheSea = 1;
  701.                             FreezeCamera();
  702.                         }
  703.                     }
  704.                     gDouble_pling_water = 1;
  705.                 }
  706.             }
  707.         } else {
  708.             c->water_d = 10000.0;
  709.             if (c->driver == eDriver_local_human) {
  710.                 if (gInTheSea == 1) {
  711.                     gInTheSea = 2;
  712.                 } else {
  713.                     gInTheSea = 0;
  714.                 }
  715.             }
  716.         }
  717.         if (c->water_d != old_d) {
  718.             StartPipingSession(ePipe_chunk_splash);
  719.             AddSplashToPipingSession(c);
  720.             EndPipingSession();
  721.         }
  722.         c->box_face_end = gFace_count;
  723.         c->box_face_ref = gFace_num__car;
  724.     }
  725. }
  726.  
  727. // IDA: int __cdecl IsCarInTheSea()
  728. int IsCarInTheSea(void) {
  729.     LOG_TRACE("()");
  730.  
  731.     return gInTheSea;
  732. }
  733.  
  734. // IDA: void __usercall RememberSafePosition(tCar_spec *car@<EAX>, tU32 pTime@<EDX>)
  735. void RememberSafePosition(tCar_spec* car, tU32 pTime) {
  736.     static tU32 time_count;
  737.     int j;
  738.     br_vector3 r;
  739.     //br_scalar ts; // Pierre-Marie Baty -- unused variable
  740.     LOG_TRACE("(%p, %d)", car, pTime);
  741.  
  742.     if (car->disabled) {
  743.         return;
  744.     }
  745.     time_count += pTime;
  746.     if (time_count < 5000) {
  747.         return;
  748.     }
  749.     time_count = 4000;
  750.     for (j = 0; j < 4; j++) {
  751.         if (car->susp_height[j >> 1] <= car->oldd[j]) {
  752.             return;
  753.         }
  754.     }
  755.     if ((car->last_special_volume == NULL || car->last_special_volume->gravity_multiplier == 1.f)
  756.         && gCurrent_race.material_modifiers[car->material_index[0]].tyre_road_friction >= 0.1f
  757.         && gCurrent_race.material_modifiers[car->material_index[1]].tyre_road_friction >= 0.1f
  758.         && gCurrent_race.material_modifiers[car->material_index[2]].tyre_road_friction >= 0.1f
  759.         && gCurrent_race.material_modifiers[car->material_index[3]].tyre_road_friction >= 0.1f
  760.         && car->car_master_actor->t.t.mat.m[1][1] > 0.8f) {
  761.  
  762.         for (j = 0; j < 5; j++) {
  763.             BrVector3Sub(&r, &car->car_master_actor->t.t.translate.t, (br_vector3*)car->last_safe_positions[j].m[3]);
  764.  
  765.             if (BrVector3LengthSquared(&r) < 8.4015961f) {
  766.                 return;
  767.             }
  768.         }
  769.         for (j = 3; j > 0; j--) {
  770.             BrMatrix34Copy(&car->last_safe_positions[j], &car->last_safe_positions[j - 1]);
  771.         }
  772.         BrMatrix34Copy(&car->last_safe_positions[0], &car->car_master_actor->t.t.mat);
  773.         time_count = 0;
  774.     }
  775. }
  776.  
  777. // IDA: void __usercall ControlOurCar(tU32 pTime_difference@<EAX>)
  778. void ControlOurCar(tU32 pTime_difference) {
  779.     br_scalar ts;
  780.     br_vector3 minus_k;
  781.     tCar_spec* car;
  782.     static int steering_locked;
  783.     //int i; // Pierre-Marie Baty -- unused variable
  784.     tU32 time;
  785.     LOG_TRACE("(%d)", pTime_difference);
  786.  
  787.     car = &gProgram_state.current_car;
  788.     if (gCar_flying) {
  789.         if (gNet_mode != eNet_mode_none) {
  790.             gCar_flying = 0;
  791.         } else {
  792.             BrVector3Scale(&car->car_master_actor->t.t.translate.t, &car->car_master_actor->t.t.translate.t, WORLD_SCALE);
  793.             FlyCar(car, pTime_difference / 1000.f);
  794.             BrVector3InvScale(&car->car_master_actor->t.t.translate.t, &car->car_master_actor->t.t.translate.t, WORLD_SCALE);
  795.         }
  796.         return;
  797.     }
  798.     time = GetTotalTime();
  799.     if (car->damage_units[eDamage_steering].damage_level > 40) {
  800.         if (car->end_steering_damage_effect) {
  801.             if (time < car->end_steering_damage_effect || car->damage_units[eDamage_steering].damage_level == 99) {
  802.                 car->keys.left = car->false_key_left;
  803.                 car->keys.right = car->false_key_right;
  804.             } else {
  805.                 car->end_steering_damage_effect = 0;
  806.             }
  807.         } else {
  808.             ts = pTime_difference * (car->damage_units[eDamage_steering].damage_level - 40) * 0.0045f;
  809.             if (PercentageChance(ts) && fabsf(car->velocity_car_space.v[2]) > 0.0001f) {
  810.                 if (car->keys.left || car->keys.right) {
  811.                     car->false_key_left = !car->keys.left;
  812.                     car->false_key_right = !car->keys.right;
  813.                 } else if (PercentageChance(50)) {
  814.                     car->false_key_left = 1;
  815.                 } else {
  816.                     car->false_key_right = 1;
  817.                 }
  818.                 ts = 5 * (5 * car->damage_units[eDamage_steering].damage_level - 200);
  819.                 car->end_steering_damage_effect = FRandomBetween(0.0f, ts) + time;
  820.             }
  821.         }
  822.     }
  823.     if (car->damage_units[eDamage_transmission].damage_level > 40) {
  824.         if (car->end_trans_damage_effect) {
  825.             if (time < car->end_trans_damage_effect || car->damage_units[eDamage_transmission].damage_level == 99) {
  826.                 car->gear = 0;
  827.                 car->just_changed_gear = 1;
  828.             } else {
  829.                 car->end_trans_damage_effect = 0;
  830.             }
  831.         } else {
  832.             ts = pTime_difference * (car->damage_units[eDamage_transmission].damage_level - 40) * 0.006;
  833.             if (PercentageChance(ts) != 0) {
  834.                 ts = 10 * (5 * car->damage_units[eDamage_transmission].damage_level - 200);
  835.                 car->end_trans_damage_effect = FRandomBetween(0.f, ts) + time;
  836.             }
  837.         }
  838.     }
  839.     ts = pTime_difference / 1000.0f;
  840.     ControlCar[gControl__car](car, ts);
  841.     RememberSafePosition(car, pTime_difference);
  842.     if (gCamera_reset) {
  843.         BrVector3SetFloat(&minus_k, 0.0f, 0.0f, -1.0f);
  844.         gCamera_sign = 0;
  845.         BrMatrix34ApplyV(&car->direction, &minus_k, &car->car_master_actor->t.t.mat);
  846.     }
  847. }
  848.  
  849. // IDA: void __usercall CalcEngineForce(tCar_spec *c@<EAX>, br_scalar dt)
  850. void CalcEngineForce(tCar_spec* c, br_scalar dt) {
  851.     br_scalar torque;
  852.     br_scalar ts;
  853.     br_scalar ts2;
  854.     //br_scalar brake_temp; // Pierre-Marie Baty -- unused variable
  855.     int sign;
  856.     tS32 temp_for_swap;
  857.     LOG_TRACE("(%p, %f)", c, dt);
  858.  
  859.     c->acc_force = 0.0f;
  860.     if (c->revs == 0.0f) {
  861.         c->gear = 0;
  862.     }
  863.     sign = c->gear < 0 || (c->gear == 0 && c->velocity_car_space.v[2] > 0.5f);
  864.     if (c->keys.backwards != sign) {
  865.         c->keys.backwards = !c->keys.backwards;
  866.         temp_for_swap = c->keys.acc;
  867.         c->keys.acc = c->keys.dec;
  868.         c->keys.dec = temp_for_swap;
  869.  
  870.         temp_for_swap = c->joystick.acc;
  871.         c->joystick.acc = c->joystick.dec;
  872.         c->joystick.dec = temp_for_swap;
  873.     }
  874.     if (!c->gear && !c->keys.acc && c->joystick.acc <= 0 && (c->keys.dec || c->joystick.dec > 0) && !c->keys.backwards && fabs(c->velocity_car_space.v[2]) < 1.0) {
  875.         c->keys.backwards = 1;
  876.         c->keys.acc = c->keys.dec;
  877.         c->keys.dec = 0;
  878.         temp_for_swap = c->joystick.acc;
  879.         c->joystick.acc = c->joystick.dec;
  880.         c->joystick.dec = temp_for_swap;
  881.     }
  882.     c->torque = -(c->revs * c->revs / 100000000.0f) - 0.2f;
  883.     if (c->keys.acc || c->joystick.acc >= 0) {
  884.         if (fabsf(c->curvature) > c->maxcurve / 2.0f && c->gear < 2 && c->gear && c->traction_control) {
  885.             ts = 0.7f;
  886.         } else if (c->joystick.acc < 0) {
  887.             ts = (br_scalar) 1.2; // Pierre-Marie Baty -- added type cast
  888.         } else {
  889.             ts = c->joystick.acc / 54613.0;
  890.             LOG_PANIC("ooo");
  891.         }
  892.  
  893.         torque = c->engine_power_multiplier * ts * gEngine_powerup_factor[c->power_up_levels[1]];
  894.         if (c->damage_units[0].damage_level > 10) {
  895.             torque = (1.0f - (double)(c->damage_units[0].damage_level - 10) / 100.0f) * torque;
  896.         }
  897.         c->torque += torque;
  898.     } else {
  899.         c->traction_control = 1;
  900.     }
  901.     if (!c->keys.dec && (!c->keys.acc || c->gear) && c->joystick.dec <= 0 && (c->joystick.acc <= 0 || c->gear)) {
  902.         c->brake_force = 0.0f;
  903.     } else {
  904.         if (c->joystick.dec > 0) {
  905.             c->brake_force = (double)(c->joystick.dec / 0x10000) * c->brake_increase + c->initial_brake;
  906.         }
  907.         if (c->brake_force == 0.0f) {
  908.             c->brake_force = c->initial_brake;
  909.         } else {
  910.             c->brake_force += c->brake_increase * dt;
  911.             if (c->initial_brake + c->brake_increase < c->brake_force) {
  912.                 c->brake_force = c->initial_brake + c->brake_increase;
  913.             }
  914.         }
  915.     }
  916.     if (c->gear) {
  917.         c->acc_force = c->force_torque_ratio * c->torque / (float)c->gear;
  918.         if (c->brake_force == 0.0f) {
  919.             if (c->revs - 1.0f > c->target_revs || c->revs + 1.0f < c->target_revs) {
  920.                 ts2 = c->torque * dt / 0.0002 + c->revs - c->target_revs;
  921.                 c->acc_force += ts2 / ((1.0f / (c->speed_revs_ratio * c->M) / (float)c->gear + 1.0 / (c->force_torque_ratio * 0.0002) * (double)c->gear) * dt);
  922.             }
  923.         } else {
  924.             c->revs = c->target_revs;
  925.         }
  926.     }
  927. }
  928.  
  929. // IDA: void __usercall PrepareCars(tU32 pFrame_start_time@<EAX>)
  930. void PrepareCars(tU32 pFrame_start_time) {
  931.     tCar_spec* car;
  932.     int i;
  933.     static tU32 last_frame_start;
  934.     LOG_TRACE("(%d)", pFrame_start_time);
  935.  
  936.     last_frame_start = pFrame_start_time;
  937.     for (i = 0; i < gNum_cars_and_non_cars; i++) {
  938.         car = gActive_car_list[i];
  939.         BrVector3Scale(&car->car_master_actor->t.t.translate.t, &car->car_master_actor->t.t.translate.t, WORLD_SCALE);
  940.         BrVector3Scale(&car->velocity_car_space, &car->velocity_car_space, WORLD_SCALE * 1000.f);
  941.         car->frame_collision_flag = gOver_shoot && car->collision_flag;
  942.         if (car->driver > eDriver_non_car) {
  943.             RecordLastDamage(car);
  944.             if (car->driver == eDriver_oppo && gStop_opponents_moving) {
  945.                 car->acc_force = 0.0f;
  946.                 car->brake_force = 0.0f;
  947.                 car->keys.acc = 0;
  948.                 car->keys.dec = 0;
  949.                 car->joystick.acc = -1;
  950.                 car->joystick.dec = -1;
  951.             }
  952.             if (!car->wheel_slip) {
  953.                 StopSkid(car);
  954.             }
  955.             if (car->driver == eDriver_net_human && car->message.time < pFrame_start_time - 1000) {
  956.                 car->keys.acc = 0;
  957.                 car->keys.dec = 0;
  958.                 car->joystick.acc = -1;
  959.                 car->joystick.dec = -1;
  960.                 car->keys.horn = 0;
  961.             }
  962.             SetSmokeLastDamageLevel(car);
  963.         }
  964.         BrMatrix34Copy(&car->car_master_actor->t.t.mat, &car->oldmat);
  965.     }
  966. }
  967.  
  968. // IDA: void __usercall FinishCars(tU32 pLast_frame_time@<EAX>, tU32 pTime@<EDX>)
  969. void FinishCars(tU32 pLast_frame_time, tU32 pTime) {
  970.     tCar_spec* car;
  971.     br_vector3 minus_k;
  972.     int i;
  973.     int wheel;
  974.     //br_scalar scale; // Pierre-Marie Baty -- unused variable
  975.     LOG_TRACE("(%d, %d)", pLast_frame_time, pTime);
  976.  
  977.     for (i = 0; i < gNum_cars_and_non_cars; i++) {
  978.         car = gActive_car_list[i];
  979.         if (fabsf(car->omega.v[0]) > 10000.f
  980.             || fabsf(car->omega.v[1]) > 10000.f
  981.             || fabsf(car->omega.v[2]) > 10000.f) {
  982.             BrVector3SetFloat(&car->omega, 0.f, 0.f, 0.f);
  983.             BrVector3SetFloat(&car->v, 0.f, 0.f, 0.f);
  984.         }
  985.         BrVector3InvScale(&car->velocity_car_space, &car->velocity_car_space, WORLD_SCALE * 1000.0f);
  986.         BrVector3InvScale(&car->car_master_actor->t.t.translate.t, &car->car_master_actor->t.t.translate.t, WORLD_SCALE);
  987.  
  988.         car->speed = BR_LENGTH2(car->v.v[0], car->v.v[2]) / (WORLD_SCALE * 1000.0f);
  989.         BrVector3Negate(&minus_k, (br_vector3*)car->car_master_actor->t.t.mat.m[2]);
  990.         if (car->speed <= 0.0001f) {
  991.             if (BrVector3Dot(&car->direction, &minus_k) < 0.f) {
  992.                 BrVector3SetFloat(&minus_k, 0.f, 0.f, 1.f);
  993.             } else {
  994.                 BrVector3SetFloat(&minus_k, 0.f, 0.f, -1.f);
  995.             }
  996.             BrMatrix34ApplyV(&car->direction, &minus_k, &car->car_master_actor->t.t.mat);
  997.         } else if (gLast_mechanics_time > pLast_frame_time && gCar_to_view == car) {
  998.             BrVector3Sub(&car->old_v, &car->old_v, &car->v);
  999.             BrVector3Scale(&car->old_v, &car->old_v, (gLast_mechanics_time - pLast_frame_time) / harness_game_config.physics_step_time);
  1000.             BrVector3Accumulate(&car->old_v, &car->v);
  1001.             BrVector3Normalise(&car->direction, &car->old_v);
  1002.         } else {
  1003.             BrVector3Normalise(&car->direction, &car->v);
  1004.         }
  1005.         if (car->driver >= eDriver_oppo) {
  1006.             car->speedo_speed = BrVector3Dot(&minus_k, &car->v) / (WORLD_SCALE * 1000.0f);
  1007.  
  1008.             car->steering_angle = BrRadianToDegree(atanf((car->wpos[0].v[2] - car->wpos[2].v[2]) * car->curvature));
  1009.  
  1010.             car->lr_sus_position = (car->ride_height - car->oldd[0]) / WORLD_SCALE;
  1011.             car->rr_sus_position = (car->ride_height - car->oldd[1]) / WORLD_SCALE;
  1012.             car->lf_sus_position = (car->ride_height - car->oldd[2]) / WORLD_SCALE;
  1013.             car->rf_sus_position = (car->ride_height - car->oldd[3]) / WORLD_SCALE;
  1014.             for (wheel = 0; wheel < 4; wheel++) {
  1015.                 if (car->oldd[wheel] < car->susp_height[wheel >> 1] && gCurrent_race.material_modifiers[car->material_index[wheel]].smoke_type >= 2 && !car->doing_nothing_flag) {
  1016.                     GenerateContinuousSmoke(car, wheel, pTime);
  1017.                 }
  1018.             }
  1019.         }
  1020.     }
  1021. }
  1022.  
  1023. // IDA: void __usercall InterpolateCars(tU32 pLast_frame_time@<EAX>, tU32 pTime@<EDX>)
  1024. void InterpolateCars(tU32 pLast_frame_time, tU32 pTime) {
  1025.     br_scalar dt;
  1026.     tCar_spec* car;
  1027.     int i;
  1028.     LOG_TRACE("(%d, %d)", pLast_frame_time, pTime);
  1029.  
  1030.     dt = ((int)(gLast_mechanics_time - pLast_frame_time)) / 1000.0;
  1031.     if (dt > 0.04 || dt < 0)
  1032.         dt = 0;
  1033.  
  1034.     gOver_shoot = dt > 0.0;
  1035.  
  1036.     for (i = 0; i < gNum_cars_and_non_cars; i++) {
  1037.         car = gActive_car_list[i];
  1038.         BrMatrix34Copy(&car->oldmat, &car->car_master_actor->t.t.mat);
  1039.         SimpleRotate((tCollision_info*)car, -dt);
  1040.         TranslateCar((tCollision_info*)car, -dt);
  1041.         BrMatrix34ApplyP(&car->pos, &car->cmpos, &car->car_master_actor->t.t.mat);
  1042.         BrVector3InvScale(&car->pos, &car->pos, WORLD_SCALE);
  1043.     }
  1044. }
  1045.  
  1046. // IDA: void __cdecl ResetOldmat()
  1047. void ResetOldmat(void) {
  1048.     tCar_spec* car;
  1049.     int i;
  1050.     br_matrix34 mat;
  1051.     static int normalise_count = 0;
  1052.     LOG_TRACE("()");
  1053.  
  1054.     for (i = 0; i < gNum_cars_and_non_cars; i++) {
  1055.         BrMatrix34Copy(&gActive_car_list[i]->oldmat, &gActive_car_list[i]->car_master_actor->t.t.mat);
  1056.     }
  1057.     normalise_count++;
  1058.     if (normalise_count > 50) {
  1059.         normalise_count = 0;
  1060.         for (i = 0; i < gNum_cars_and_non_cars; i++) {
  1061.             car = gActive_car_list[i];
  1062.             BrMatrix34LPNormalise(&mat, &car->car_master_actor->t.t.mat);
  1063.             BrMatrix34Copy(&car->car_master_actor->t.t.mat, &mat);
  1064.         }
  1065.     }
  1066. }
  1067.  
  1068. // IDA: void __cdecl GetNonCars()
  1069. void GetNonCars(void) {
  1070.     int i;
  1071.     int j;
  1072.     LOG_TRACE("()");
  1073.  
  1074.     gNum_cars_and_non_cars = gNum_active_non_cars + gNum_active_cars;
  1075.     j = 0;
  1076.     for (i = gNum_active_cars; i < gNum_cars_and_non_cars; i++) {
  1077.         gActive_car_list[i] = (tCar_spec*)gActive_non_car_list[j];
  1078.         j++;
  1079.     }
  1080. }
  1081.  
  1082. // IDA: void __usercall GetNetPos(tCar_spec *pCar@<EAX>)
  1083. void GetNetPos(tCar_spec* pCar) {
  1084.     //int j; // Pierre-Marie Baty -- unused variable
  1085.     //float amount; // Pierre-Marie Baty -- unused variable
  1086.     //br_scalar total_deflection; // Pierre-Marie Baty -- unused variable
  1087.     LOG_TRACE("(%p)", pCar);
  1088.     NOT_IMPLEMENTED();
  1089. }
  1090.  
  1091. // IDA: void __usercall ApplyPhysicsToCars(tU32 last_frame_time@<EAX>, tU32 pTime_difference@<EDX>)
  1092. void ApplyPhysicsToCars(tU32 last_frame_time, tU32 pTime_difference) {
  1093.     //br_vector3 minus_k; // Pierre-Marie Baty -- unused variable
  1094.     int i;
  1095.     int old_num_cars;
  1096.     int step_number;
  1097.     int dam_index;
  1098.     static int steering_locked;
  1099.     tCar_spec* car = NULL;
  1100.     tCollision_info* car_info;
  1101.     tNon_car_spec* non_car;
  1102.     //tU32 time_step; // Pierre-Marie Baty -- unused variable
  1103.     tU32 frame_end_time;
  1104.     LOG_TRACE("(%d, %d)", last_frame_time, pTime_difference);
  1105.  
  1106.     step_number = 0;
  1107.     frame_end_time = last_frame_time + pTime_difference;
  1108.     if (gFreeze_mechanics) {
  1109.         return;
  1110.     }
  1111.     if (gNet_mode == eNet_mode_client) {
  1112.         ForceRebuildActiveCarList();
  1113.     }
  1114.     if (gLast_mechanics_time < last_frame_time) {
  1115.         gLast_mechanics_time = harness_game_config.physics_step_time * (last_frame_time / harness_game_config.physics_step_time);
  1116.     }
  1117.     GetNonCars();
  1118.     if (frame_end_time <= gLast_mechanics_time) {
  1119.         PrepareCars(last_frame_time);
  1120.         InterpolateCars(frame_end_time, pTime_difference);
  1121.         FinishCars(frame_end_time, pTime_difference);
  1122.         return;
  1123.     }
  1124.  
  1125.     gDoing_physics = 1;
  1126.     PrepareCars(last_frame_time);
  1127.     gDt = harness_game_config.physics_step_time / 1000.0; // 0.04;
  1128.     gMechanics_time_sync = pTime_difference - (gLast_mechanics_time - last_frame_time);
  1129.     while (gLast_mechanics_time < frame_end_time && step_number < 5) {
  1130.         step_number++;
  1131.         ResetOldmat();
  1132.         BrVector3Copy(&gProgram_state.current_car.old_v, &gProgram_state.current_car.v);
  1133.         if (&gProgram_state.current_car != gCar_to_view) {
  1134.             BrVector3Copy(&gCar_to_view->old_v, &gCar_to_view->v);
  1135.         }
  1136.         for (i = 0; i < gNum_active_cars; i++) {
  1137.             car = gActive_car_list[i];
  1138.             car->dt = -1.f;
  1139.             if (car->message.type == 15 && car->message.time >= gLast_mechanics_time && gLast_mechanics_time + harness_game_config.physics_step_time >= car->message.time) {
  1140.                 car->dt = (double)(gLast_mechanics_time + harness_game_config.physics_step_time - car->message.time) / 1000.0;
  1141.                 if (gDt - 0.0001f <= car->dt) {
  1142.                     GetNetPos(car);
  1143.                 } else if (gNet_mode == eNet_mode_host) {
  1144.                     car->dt = -1.f;
  1145.                 } else {
  1146.                     for (dam_index = 0; dam_index < COUNT_OF(car->damage_units); dam_index++) {
  1147.                         if (car->damage_units[dam_index].damage_level < car->message.damage[dam_index]) {
  1148.                             car->dt = -1.f;
  1149.                             break;
  1150.                         }
  1151.                     }
  1152.                     if (car->dt >= 0.f) {
  1153.                         GetNetPos(car);
  1154.                     }
  1155.                 }
  1156.             }
  1157.             if (!car->disabled
  1158.                 && (!car->doing_nothing_flag || (car->driver >= eDriver_net_human && (!gPalette_fade_time || car->driver != eDriver_local_human)))) {
  1159.                 if (car->box_face_ref != gFace_num__car
  1160.                     && (car->box_face_ref != gFace_num__car - 1 || car->box_face_start <= gFace_count)) {
  1161.                     car_info = (tCollision_info*)car;
  1162.                     GetFacesInBox(car_info);
  1163.                 }
  1164.                 if (car->dt != 0.f) {
  1165.                     MoveAndCollideCar(car, gDt);
  1166.                 }
  1167.             }
  1168.         }
  1169.         for (i = 0; i < gNum_active_non_cars; i++) {
  1170.             non_car = gActive_non_car_list[i];
  1171.             if (!non_car->collision_info.doing_nothing_flag) {
  1172.                 non_car->collision_info.dt = -1.f;
  1173.                 if (non_car->collision_info.message.type == 16 && non_car->collision_info.message.time >= gLast_mechanics_time && gLast_mechanics_time + harness_game_config.physics_step_time >= non_car->collision_info.message.time) {
  1174.                     non_car->collision_info.dt = (gLast_mechanics_time + harness_game_config.physics_step_time - non_car->collision_info.message.time) / 1000.0f;
  1175.                     GetNetPos((tCar_spec*)non_car);
  1176.                 }
  1177.                 if (non_car->collision_info.box_face_ref != gFace_num__car
  1178.                     && (non_car->collision_info.box_face_ref != gFace_num__car - 1
  1179.                         || non_car->collision_info.box_face_start <= gFace_count)) {
  1180.                     GetFacesInBox(&non_car->collision_info);
  1181.                 }
  1182.                 if (non_car->collision_info.dt != 0.0f) {
  1183.                     MoveAndCollideNonCar(non_car, gDt);
  1184.                 }
  1185.             }
  1186.         }
  1187.         do {
  1188.             old_num_cars = gNum_cars_and_non_cars;
  1189.             CrashCarsTogether(gDt);
  1190.         } while (old_num_cars < gNum_cars_and_non_cars);
  1191.         gMechanics_time_sync -= harness_game_config.physics_step_time;
  1192.         gLast_mechanics_time += harness_game_config.physics_step_time;
  1193.     }
  1194.     gMechanics_time_sync = 1;
  1195.     SendCarData(gLast_mechanics_time);
  1196.     InterpolateCars(frame_end_time, pTime_difference);
  1197.     FinishCars(frame_end_time, pTime_difference);
  1198.     gDoing_physics = 0;
  1199.     CheckForDeAttachmentOfNonCars(pTime_difference);
  1200. }
  1201.  
  1202. // IDA: void __usercall MungeSpecialVolume(tCollision_info *pCar@<EAX>)
  1203. void MungeSpecialVolume(tCollision_info* pCar) {
  1204.     tSpecial_volume* new_special_volume;
  1205.     //tCar_spec* car; // Pierre-Marie Baty -- unused variable
  1206.     LOG_TRACE("(%p)", pCar);
  1207.  
  1208.     new_special_volume = FindSpecialVolume(&pCar->pos, pCar->last_special_volume);
  1209.     if (pCar->auto_special_volume != NULL && (new_special_volume == NULL || new_special_volume->gravity_multiplier == 1.f)) {
  1210.         if (pCar->water_d == 10000.f && pCar->water_depth_factor != 1.f) {
  1211.             pCar->auto_special_volume = NULL;
  1212.         } else {
  1213.             new_special_volume = pCar->auto_special_volume;
  1214.         }
  1215.     }
  1216.     if (pCar->last_special_volume != new_special_volume && pCar->driver == eDriver_local_human) {
  1217.         if (pCar->last_special_volume != NULL && pCar->last_special_volume->exit_noise >= 0 && (new_special_volume == NULL || pCar->last_special_volume->exit_noise != new_special_volume->exit_noise)) {
  1218.             DRS3StartSound(gCar_outlet, pCar->last_special_volume->exit_noise);
  1219.         }
  1220.         if (new_special_volume != NULL && new_special_volume->entry_noise >= 0 && (pCar->last_special_volume == NULL || pCar->last_special_volume->entry_noise != new_special_volume->entry_noise)) {
  1221.             DRS3StartSound(gCar_outlet, new_special_volume->entry_noise);
  1222.         }
  1223.     }
  1224.     pCar->last_special_volume = new_special_volume;
  1225.     if (new_special_volume != NULL && pCar->num_smoke_columns != 0 && pCar->last_special_volume != NULL && pCar->last_special_volume->gravity_multiplier < 1.f) {
  1226.         StopCarSmoking((tCar_spec*)pCar);
  1227.     }
  1228. }
  1229.  
  1230. // IDA: void __usercall ResetCarSpecialVolume(tCollision_info *pCar@<EAX>)
  1231. void ResetCarSpecialVolume(tCollision_info* pCar) {
  1232.     br_vector3 cast_v;
  1233.     br_vector3 norm;
  1234.     br_scalar t;
  1235.     int id_len;
  1236.     char* mat_id;
  1237.     tSpecial_volume* new_special_volume;
  1238.     br_material* material;
  1239.     LOG_TRACE("(%p)", pCar);
  1240.  
  1241.     new_special_volume = NULL;
  1242.     BrVector3Set(&cast_v, 0.f, 200.f, 0.f);
  1243.     DisablePlingMaterials();
  1244.     FindFace(&pCar->car_master_actor->t.t.translate.t, &cast_v, &norm, &t, &material);
  1245.     EnablePlingMaterials();
  1246.     if (t < 100.0f && material != NULL) {
  1247.         mat_id = material->identifier;
  1248.         if (mat_id) {
  1249.             id_len = strlen(mat_id);
  1250.             if (id_len > 0 && (*mat_id == '!' || *mat_id == '#')) {
  1251.                 new_special_volume = GetDefaultSpecialVolumeForWater();
  1252.             }
  1253.         }
  1254.     }
  1255.     pCar->auto_special_volume = new_special_volume;
  1256.     pCar->water_depth_factor = 1.0f;
  1257. }
  1258.  
  1259. // IDA: void __usercall TestAutoSpecialVolume(tCollision_info *pCar@<EAX>)
  1260. void TestAutoSpecialVolume(tCollision_info* pCar) {
  1261.     br_vector3 pos;
  1262.     //br_scalar car_d; // Pierre-Marie Baty -- unused variable
  1263.     br_scalar d;
  1264.     br_scalar d2;
  1265.     br_vector3 dir;
  1266.     br_vector3 tv;
  1267.     br_vector3 lp;
  1268.     br_vector3 hp;
  1269.     tSpecial_volume* vol;
  1270.     br_matrix34* mat;
  1271.     br_scalar lowest_p;
  1272.     br_scalar highest_p;
  1273.     br_scalar val;
  1274.     int i;
  1275.     LOG_TRACE("(%p)", pCar);
  1276.  
  1277.     mat = &pCar->car_master_actor->t.t.mat;
  1278.     highest_p = 0.f;
  1279.     for (i = 0; i < 3; i++) {
  1280.         highest_p += BrVector3Dot((br_vector3*)mat->m[i], &pCar->water_normal) * pCar->bounds[0].min.v[i];
  1281.     }
  1282.     highest_p += BrVector3Dot((br_vector3*)mat->m[3], &pCar->water_normal) / WORLD_SCALE;
  1283.     lowest_p = highest_p;
  1284.     for (i = 0; i < 3; i++) {
  1285.         val = (pCar->bounds[0].max.v[i] - pCar->bounds[0].min.v[i]) * BrVector3Dot((br_vector3*)mat->m[i], &pCar->water_normal);
  1286.         if (val >= 0.f) {
  1287.             highest_p += val;
  1288.         } else {
  1289.             lowest_p += val;
  1290.         }
  1291.     }
  1292.  
  1293.     if (pCar->water_d > lowest_p) {
  1294.         if (pCar->water_d >= highest_p) {
  1295.             pCar->water_depth_factor = 1.f;
  1296.         } else {
  1297.             pCar->water_depth_factor = (pCar->water_d - lowest_p) / (highest_p - lowest_p);
  1298.         }
  1299.         if (pCar->auto_special_volume == NULL) {
  1300.             vol = GetDefaultSpecialVolumeForWater();
  1301.             if (vol == NULL) {
  1302.                 pCar->water_depth_factor = 1.f;
  1303.                 pCar->auto_special_volume = NULL;
  1304.             } else {
  1305.                 BrVector3Scale(&tv, &pCar->bounds[0].min, WORLD_SCALE);
  1306.                 BrMatrix34ApplyP(&lp, &tv, mat);
  1307.                 BrVector3InvScale(&lp, &lp, WORLD_SCALE);
  1308.                 BrVector3Copy(&hp, &lp);
  1309.                 for (i = 0; i < 3; i++) {
  1310.                     val = pCar->bounds[0].max.v[i] - pCar->bounds[0].min.v[i];
  1311.                     BrVector3Scale(&tv, (br_vector3*)mat->m[i], val);
  1312.                     if (BrVector3Dot(&pCar->water_normal, &tv) > 0.f) {
  1313.                         BrVector3Accumulate(&hp, &tv);
  1314.                     } else {
  1315.                         BrVector3Accumulate(&lp, &tv);
  1316.                     }
  1317.                 }
  1318.                 BrVector3Sub(&dir, &hp, &lp);
  1319.                 DisablePlingMaterials();
  1320.                 FindFloorInBoxBU(&lp, &dir, &tv, &d, pCar);
  1321.                 EnablePlingMaterials();
  1322.                 FindFloorInBoxBU(&pos, &dir, &tv, &d2, pCar);
  1323.                 if (d2 <= d) {
  1324.                     pCar->water_depth_factor = 1.f;
  1325.                     pCar->auto_special_volume = NULL;
  1326.                 } else {
  1327.                     pCar->auto_special_volume = vol;
  1328.                 }
  1329.             }
  1330.         }
  1331.     } else {
  1332.         pCar->auto_special_volume = NULL;
  1333.         pCar->water_depth_factor = 1.f;
  1334.     }
  1335. }
  1336.  
  1337. // IDA: void __usercall MoveAndCollideCar(tCar_spec *car@<EAX>, br_scalar dt)
  1338. void MoveAndCollideCar(tCar_spec* car, br_scalar dt) {
  1339.     tCollision_info* car_info;
  1340.     int wheel;
  1341.     LOG_TRACE("(%p, %f)", car, dt);
  1342.  
  1343.     if (car->dt >= 0.f) {
  1344.         dt = car->dt;
  1345.     }
  1346.     if (dt != 0.f && (!gCar_flying || &gProgram_state.current_car != car)) {
  1347.         car_info = (tCollision_info*)car;
  1348.         car->new_skidding = 0;
  1349.         if (car->water_d != 10000.0f) {
  1350.             TestAutoSpecialVolume(car_info);
  1351.         }
  1352.         MungeSpecialVolume(car_info);
  1353.         if (car->driver <= eDriver_oppo) {
  1354.             CalcForce(car, dt);
  1355.         } else {
  1356.             CalcEngineForce(car, dt);
  1357.             CalcForce(car, dt);
  1358.             DoRevs(car, dt);
  1359.         }
  1360.         RotateCar(car_info, dt);
  1361.         TranslateCar(car_info, dt);
  1362.         CollideCarWithWall(car_info, dt);
  1363.         BrMatrix34ApplyP(&car->pos, &car->cmpos, &car->car_master_actor->t.t.mat);
  1364.         BrVector3InvScale(&car->pos, &car->pos, WORLD_SCALE);
  1365.         for (wheel = 0; wheel < 4; wheel++) {
  1366.             SkidMark(car, wheel);
  1367.         }
  1368.     }
  1369. }
  1370.  
  1371. // IDA: void __usercall MoveAndCollideNonCar(tNon_car_spec *non_car@<EAX>, br_scalar dt)
  1372. void MoveAndCollideNonCar(tNon_car_spec* non_car, br_scalar dt) {
  1373.     tCollision_info* car_info;
  1374.     LOG_TRACE("(%p, %f)", non_car, dt);
  1375.  
  1376.     car_info = &non_car->collision_info;
  1377.     if (car_info->water_d != 10000.f) {
  1378.         TestAutoSpecialVolume(&non_car->collision_info);
  1379.     }
  1380.     MungeSpecialVolume(&non_car->collision_info);
  1381.     if (car_info->dt >= 0.f) {
  1382.         dt = car_info->dt;
  1383.     }
  1384.     NonCarCalcForce(non_car, dt);
  1385.     RotateCar(&non_car->collision_info, dt);
  1386.     TranslateCar(&non_car->collision_info, dt);
  1387.     CollideCarWithWall(&non_car->collision_info, dt);
  1388.     BrMatrix34ApplyP(&car_info->pos, &car_info->cmpos, &car_info->car_master_actor->t.t.mat);
  1389.     BrVector3InvScale(&car_info->pos, &car_info->pos, WORLD_SCALE);
  1390. }
  1391.  
  1392. // IDA: int __usercall CollideCarWithWall@<EAX>(tCollision_info *car@<EAX>, br_scalar dt)
  1393. int CollideCarWithWall(tCollision_info* car, br_scalar dt) {
  1394.     LOG_TRACE("(%p, %f)", car, dt);
  1395.  
  1396.     GetFacesInBox(car);
  1397.     if (gCollision_detection_on__car) {
  1398.         car->collision_flag = 0;
  1399.         while (CollCheck(car, dt)) {
  1400.             car->collision_flag++;
  1401.             if (car->collision_flag - 1 > 20) {
  1402.                 car->collision_flag = 1;
  1403.                 BrVector3Set(&car->v, 0.f, 0.f, 0.f);
  1404.                 BrVector3Set(&car->omega, 0.f, 0.f, 0.f);
  1405.                 break;
  1406.             }
  1407.             RotateCar(car, dt);
  1408.             TranslateCar(car, dt);
  1409.             GetFacesInBox(car);
  1410.         }
  1411.         if (car->collision_flag) {
  1412.             CrashEarnings(CAR(car), NULL);
  1413.         }
  1414.         BrMatrix34TApplyV(&car->velocity_car_space, &car->v, &car->oldmat);
  1415.         car->frame_collision_flag += car->collision_flag;
  1416.     }
  1417.     return car->collision_flag;
  1418. }
  1419.  
  1420. // IDA: void __cdecl ToggleControls()
  1421. void ToggleControls(void) {
  1422.     LOG_TRACE("()");
  1423.  
  1424.     gControl__car++;
  1425.     if (ControlCar[gControl__car] == 0) {
  1426.         gControl__car = 0;
  1427.     }
  1428.     switch (gControl__car) {
  1429.     case 0:
  1430.         NewTextHeadupSlot(eHeadupSlot_misc, 0, 500, -1, "Original Controls");
  1431.         break;
  1432.     case 1:
  1433.         NewTextHeadupSlot(eHeadupSlot_misc, 0, 500, -1, "Accelerated steering");
  1434.         break;
  1435.     case 2:
  1436.         NewTextHeadupSlot(eHeadupSlot_misc, 0, 500, -1, "0.75 Accelerated");
  1437.         break;
  1438.     case 3:
  1439.         NewTextHeadupSlot(eHeadupSlot_misc, 0, 500, -1, "0.5 Accelerated");
  1440.         break;
  1441.     default:
  1442.         NewTextHeadupSlot(eHeadupSlot_misc, 0, 500, -1, "New controls");
  1443.         break;
  1444.     }
  1445. }
  1446.  
  1447. // IDA: void __usercall ControlCar2(tCar_spec *c@<EAX>, br_scalar dt)
  1448. void ControlCar2(tCar_spec* c, br_scalar dt) {
  1449.     LOG_TRACE("(%p, %f)", c, dt);
  1450.     NOT_IMPLEMENTED();
  1451. }
  1452.  
  1453. // IDA: void __usercall ControlCar3(tCar_spec *c@<EAX>, br_scalar dt)
  1454. void ControlCar3(tCar_spec* c, br_scalar dt) {
  1455.     LOG_TRACE("(%p, %f)", c, dt);
  1456.     NOT_IMPLEMENTED();
  1457. }
  1458.  
  1459. // IDA: void __usercall ControlCar4(tCar_spec *c@<EAX>, br_scalar dt)
  1460. void ControlCar4(tCar_spec* c, br_scalar dt) {
  1461.     //br_scalar ts; // Pierre-Marie Baty -- unused variable
  1462.     LOG_TRACE("(%p, %f)", c, dt);
  1463.  
  1464.     if (c->keys.left) {
  1465.         if (c->turn_speed < 0.f) {
  1466.             c->turn_speed = 0.f;
  1467.         }
  1468.         if (c->velocity_car_space.v[2] > 0.f) {
  1469.             c->turn_speed += dt * 0.01f / .04f / 2.f * 2.f;
  1470.         } else if ((c->curvature >= 0.f && c->omega.v[1] >= -.001f) || c->turn_speed != 0.f) {
  1471.             c->turn_speed += dt / .04f * (0.05f / (BrVector3Length(&c->v) + 5.f)) / 2.f * .5f;
  1472.         } else {
  1473.             c->turn_speed = dt / .04f * (.05f / (BrVector3Length(&c->v) + 5.f)) * 4.f / 2.f * .5f;
  1474.             if (c->omega.v[1] < -.01f) {
  1475.                 c->turn_speed -= dt * .01f / (harness_game_config.physics_step_time / 1000.f) / 2.f * c->omega.v[1] * 2.f;
  1476.             }
  1477.         }
  1478.     }
  1479.     if (c->keys.right) {
  1480.         if (c->turn_speed > 0.f) {
  1481.             c->turn_speed = 0.f;
  1482.         }
  1483.         if (c->velocity_car_space.v[2] > 0.f) {
  1484.             c->turn_speed -= dt * .01f / .04f / 2.f * 2.f;
  1485.         } else if ((c->curvature <= 0.f && c->omega.v[1] <= .001f) || c->turn_speed != 0.f) {
  1486.             c->turn_speed -= dt / .04f * (.05f / (BrVector3Length(&c->v) + 5.f)) / 2.f * .5f;
  1487.         } else {
  1488.             c->turn_speed = dt / .04f * (.05f / (BrVector3Length(&c->v) + 5.f)) * -4.f / 2.f * .5f;
  1489.             if (c->omega.v[1] < -.01f) {
  1490.                 c->turn_speed -= dt * .01f / (harness_game_config.physics_step_time / 1000.f) / 2.f * c->omega.v[1] * 2.f;
  1491.             }
  1492.         }
  1493.     }
  1494.     if (!c->keys.left && !c->keys.right) {
  1495.         c->turn_speed = 0.f;
  1496.     } else if (fabsf(c->turn_speed) < fabsf(dt * 2.f * c->curvature) && c->curvature * c->turn_speed < 0.f) {
  1497.         c->turn_speed = -(dt * 2.f * c->curvature);
  1498.     }
  1499.     c->curvature += c->turn_speed;
  1500.     if (c->joystick.left > 0) {
  1501.         c->curvature = (float)c->joystick.left * (float)c->joystick.left / 4294967300.f * c->maxcurve;
  1502.     } else if (c->joystick.right >= 0) {
  1503.         c->curvature = -((float)c->joystick.right * (float)c->joystick.right / 4294967300.f) * c->maxcurve;
  1504.     }
  1505.     if (c->curvature > c->maxcurve) {
  1506.         c->curvature = c->maxcurve;
  1507.     }
  1508.     if (c->curvature < -c->maxcurve) {
  1509.         c->curvature = -c->maxcurve;
  1510.     }
  1511. }
  1512.  
  1513. // IDA: void __usercall ControlCar5(tCar_spec *c@<EAX>, br_scalar dt)
  1514. void ControlCar5(tCar_spec* c, br_scalar dt) {
  1515.     LOG_TRACE("(%p, %f)", c, dt);
  1516.     NOT_IMPLEMENTED();
  1517. }
  1518.  
  1519. // IDA: void __usercall ControlCar1(tCar_spec *c@<EAX>, br_scalar dt)
  1520. void ControlCar1(tCar_spec* c, br_scalar dt) {
  1521.     LOG_TRACE("(%p, %f)", c, dt);
  1522.     NOT_IMPLEMENTED();
  1523. }
  1524.  
  1525. // IDA: void __usercall setrotate(br_vector3 *wdt@<EAX>, br_matrix34 *m@<EDX>)
  1526. void setrotate(br_vector3* wdt, br_matrix34* m) {
  1527.     //br_euler e; // Pierre-Marie Baty -- unused variable
  1528.     LOG_TRACE("(%p, %p)", wdt, m);
  1529.     NOT_IMPLEMENTED();
  1530. }
  1531.  
  1532. // IDA: void __usercall RotateCar2(tCollision_info *c@<EAX>, br_scalar dt)
  1533. void RotateCar2(tCollision_info* c, br_scalar dt) {
  1534.     //br_vector3 wdt; // Pierre-Marie Baty -- unused variable
  1535.     //br_vector3 wdt2; // Pierre-Marie Baty -- unused variable
  1536.     //br_vector3 L; // Pierre-Marie Baty -- unused variable
  1537.     //br_vector3 L2; // Pierre-Marie Baty -- unused variable
  1538.     //br_matrix34 m; // Pierre-Marie Baty -- unused variable
  1539.     LOG_TRACE("(%p, %f)", c, dt);
  1540.     NOT_IMPLEMENTED();
  1541. }
  1542.  
  1543. // IDA: void __usercall RotateCarSecondOrder(tCollision_info *c@<EAX>, br_scalar dt)
  1544. void RotateCarSecondOrder(tCollision_info* c, br_scalar dt) {
  1545.     br_vector3 L;
  1546.     br_vector3 L2;
  1547.     br_vector3 axis;
  1548.     br_vector3 omega;
  1549.     br_scalar rad;
  1550.     br_scalar rad_rate;
  1551.     br_matrix34 m;
  1552.     LOG_TRACE("(%p, %f)", c, dt);
  1553.  
  1554.     rad_rate = BrVector3Length(&c->omega);
  1555.     rad = rad_rate * dt;
  1556.  
  1557.     BrVector3InvScale(&axis, &c->omega, rad_rate);
  1558.     BrVector3Mul(&L, &c->I, &c->omega);
  1559.  
  1560.     BrMatrix34Rotate(&m, BrRadianToAngle(rad) / 2, &axis);
  1561.     BrMatrix34TApplyV(&L2, &L, &m);
  1562.     omega.v[0] = L2.v[0] / c->I.v[0];
  1563.     omega.v[1] = L2.v[1] / c->I.v[1];
  1564.     omega.v[2] = L2.v[2] / c->I.v[2];
  1565.  
  1566.     rad_rate = BrVector3Length(&omega);
  1567.     rad = rad_rate * dt;
  1568.  
  1569.     BrVector3InvScale(&axis, &omega, rad_rate);
  1570.     BrMatrix34Rotate(&m, BrRadianToAngle(rad), &axis);
  1571.     BrMatrix34PreTranslate(&m, -c->cmpos.v[0], -c->cmpos.v[1], -c->cmpos.v[2]);
  1572.     BrMatrix34PostTranslate(&m, c->cmpos.v[0], c->cmpos.v[1], c->cmpos.v[2]);
  1573.     BrMatrix34Pre(&c->car_master_actor->t.t.mat, &m);
  1574.     BrMatrix34TApplyV(&L2, &L, &m);
  1575.     c->omega.v[0] = L2.v[0] / c->I.v[0];
  1576.     c->omega.v[1] = L2.v[1] / c->I.v[1];
  1577.     c->omega.v[2] = L2.v[2] / c->I.v[2];
  1578. }
  1579.  
  1580. // IDA: void __usercall RotateCarFirstOrder(tCollision_info *c@<EAX>, br_scalar dt)
  1581. void RotateCarFirstOrder(tCollision_info* c, br_scalar dt) {
  1582.     br_vector3 axis;
  1583.     br_vector3 L;
  1584.     br_vector3 L2;
  1585.     br_matrix34 m;
  1586.     br_scalar rad_rate;
  1587.     br_scalar rad;
  1588.     //br_scalar e1; // Pierre-Marie Baty -- unused variable
  1589.     //br_scalar e2; // Pierre-Marie Baty -- unused variable
  1590.     static br_scalar max_rad;
  1591.     LOG_TRACE("(%p, %f)", c, dt);
  1592.  
  1593.     rad_rate = BrVector3Length(&c->omega);
  1594.     rad = rad_rate * dt;
  1595.  
  1596.     if (rad < .0001f) {
  1597.         return;
  1598.     }
  1599.     BrVector3InvScale(&axis, &c->omega, rad_rate);
  1600.     BrVector3Mul(&L, &c->I, &c->omega);
  1601.     BrMatrix34Rotate(&m, BrRadianToAngle(rad), &axis);
  1602.     BrMatrix34TApplyV(&L2, &L, &m);
  1603.     BrMatrix34PreTranslate(&m, -c->cmpos.v[0], -c->cmpos.v[1], -c->cmpos.v[2]);
  1604.     BrMatrix34PostTranslate(&m, c->cmpos.v[0], c->cmpos.v[1], c->cmpos.v[2]);
  1605.     BrMatrix34Pre(&c->car_master_actor->t.t.mat, &m);
  1606.     c->omega.v[0] = L2.v[0] / c->I.v[0];
  1607.     c->omega.v[1] = L2.v[1] / c->I.v[1];
  1608.     c->omega.v[2] = L2.v[2] / c->I.v[2];
  1609. }
  1610.  
  1611. // IDA: void __usercall SimpleRotate(tCollision_info *c@<EAX>, br_scalar dt)
  1612. void SimpleRotate(tCollision_info* c, br_scalar dt) {
  1613.     br_vector3 axis;
  1614.     br_scalar rad_rate;
  1615.     br_scalar rad;
  1616.     LOG_TRACE("(%p, %f)", c, dt);
  1617.  
  1618.     rad_rate = BrVector3Length(&c->omega);
  1619.     BrVector3InvScale(&axis, &c->omega, rad_rate);
  1620.     rad = rad_rate * dt;
  1621.     if (rad >= 0.0001) {
  1622.         BrMatrix34PreRotate(&c->car_master_actor->t.t.mat, BrRadianToAngle(rad), &axis);
  1623.     }
  1624. }
  1625.  
  1626. // IDA: void __usercall RotateCar(tCollision_info *c@<EAX>, br_scalar dt)
  1627. void RotateCar(tCollision_info* c, br_scalar dt) {
  1628.     br_scalar rad_squared;
  1629.     int steps;
  1630.     int i;
  1631.     LOG_TRACE("(%p, %f)", c, dt);
  1632.  
  1633.     rad_squared = BrVector3LengthSquared(&c->omega) * dt;
  1634.     BrVector3Copy(&c->oldomega, &c->omega);
  1635.  
  1636.     if (rad_squared < .0000001f) {
  1637.         return;
  1638.     }
  1639.  
  1640.     if (rad_squared > .008f) {
  1641.         steps = sqrtf(rad_squared / .032f) + 1;
  1642.         dt = dt / steps;
  1643.  
  1644.         for (i = 0; i < steps && i < 20; i++) {
  1645.             RotateCarSecondOrder(c, dt);
  1646.         }
  1647.     } else {
  1648.         RotateCarFirstOrder(c, dt);
  1649.     }
  1650. }
  1651.  
  1652. // IDA: void __usercall SteeringSelfCentre(tCar_spec *c@<EAX>, br_scalar dt, br_vector3 *n)
  1653. void SteeringSelfCentre(tCar_spec* c, br_scalar dt, br_vector3* n) {
  1654.     br_scalar ts;
  1655.     br_scalar ts2;
  1656.     LOG_TRACE("(%p, %f, %p)", c, dt, n);
  1657.  
  1658.     if (c->curvature > c->maxcurve) {
  1659.         c->curvature = c->maxcurve;
  1660.     }
  1661.     if (-c->maxcurve > c->curvature) {
  1662.         c->curvature = -c->maxcurve;
  1663.     }
  1664.     if (!c->keys.left && c->joystick.left <= 0 && !c->keys.right && c->joystick.right <= 0 && !c->keys.holdw) {
  1665.         if (c->susp_height[1] > c->oldd[2] || c->susp_height[1] > c->oldd[3]) {
  1666.             ts = -((c->omega.v[2] * n->v[2] + c->omega.v[1] * n->v[1] + c->omega.v[0] * n->v[0]) * (dt / (c->wpos[0].v[2] - c->wpos[2].v[2])));
  1667.             ts2 = -(c->curvature * dt);
  1668.             if (fabs(ts) < fabs(ts2) || (ts * ts2 < 0.0)) {
  1669.                 ts = ts2;
  1670.             }
  1671.             c->curvature = c->curvature + ts;
  1672.             if (c->curvature * ts > 0.0) {
  1673.                 c->curvature = 0.0;
  1674.             }
  1675.         }
  1676.     }
  1677. }
  1678.  
  1679. // IDA: void __usercall NonCarCalcForce(tNon_car_spec *nc@<EAX>, br_scalar dt)
  1680. void NonCarCalcForce(tNon_car_spec* nc, br_scalar dt) {
  1681.     tCollision_info* c;
  1682.     tSpecial_volume* vol;
  1683.     br_scalar ts;
  1684.     br_vector3 tv;
  1685.     br_vector3 v;
  1686.     LOG_TRACE("(%p, %f)", nc, dt);
  1687.  
  1688.     c = &nc->collision_info;
  1689.     vol = nc->collision_info.last_special_volume;
  1690.     if (nc->collision_info.car_master_actor->identifier[3] != '!') {
  1691.         if (c->car_master_actor->t.t.mat.m[1][1] < nc->snap_off_cosine || c->min_torque_squared == 0.0f) {
  1692.             c->car_master_actor->identifier[3] = '!';
  1693.             c->M = nc->free_mass;
  1694.             c->min_torque_squared = 0.0f;
  1695.             BrVector3Sub(&v, &nc->free_cmpos, &c->cmpos);
  1696.             BrVector3Cross(&tv, &c->omega, &v);
  1697.             BrMatrix34ApplyV(&v, &tv, &c->car_master_actor->t.t.mat);
  1698.             BrVector3Accumulate(&c->v, &v);
  1699.             c->cmpos = nc->free_cmpos;
  1700.         } else {
  1701.             BrVector3SetFloat(&c->v, 0.0f, 0.0f, 0.0f);
  1702.             ts = BrVector3LengthSquared(&c->omega);
  1703.             BrVector3SetFloat(&c->omega, 0.0f, 0.0f, 0.0f);
  1704.             c->doing_nothing_flag = 1;
  1705.         }
  1706.     }
  1707.     if (c->car_master_actor->identifier[3] == '!') {
  1708.         if (vol != NULL) {
  1709.             c->v.v[1] = c->v.v[1] - dt * 10.0f * vol->gravity_multiplier;
  1710.         } else {
  1711.             c->v.v[1] = c->v.v[1] - dt * 10.0f;
  1712.         }
  1713.         ts = BrVector3Length(&c->v);
  1714.         if (vol != NULL) {
  1715.             ts = vol->viscosity_multiplier * ts;
  1716.         }
  1717.         ts = -(dt * 0.0005f * ts) / c->M;
  1718.         BrVector3Scale(&v, &c->v, ts);
  1719.         BrVector3Accumulate(&c->v, &v);
  1720.         ts = BrVector3Length(&c->omega);
  1721.         if (vol != NULL) {
  1722.             ts = vol->viscosity_multiplier * ts;
  1723.         }
  1724.         ts = -(dt * 0.0005 * ts);
  1725.         BrVector3Scale(&v, &c->omega, ts);
  1726.         ApplyTorque(CAR(c), &v);
  1727.     }
  1728. }
  1729.  
  1730. // IDA: void __usercall AddDrag(tCar_spec *c@<EAX>, br_scalar dt)
  1731. void AddDrag(tCar_spec* c, br_scalar dt) {
  1732.     br_scalar drag_multiplier;
  1733.     br_scalar ts;
  1734.     tSpecial_volume* vol;
  1735.     br_vector3 b;
  1736.     LOG_TRACE("(%p, %f)", c, dt);
  1737.  
  1738.     vol = c->last_special_volume;
  1739.     drag_multiplier = -(dt * TIME_CONV_THING);
  1740.     if (vol != NULL) {
  1741.         if (c->underwater_ability) {
  1742.             drag_multiplier = vol->viscosity_multiplier * drag_multiplier * .6f;
  1743.         } else {
  1744.             drag_multiplier = vol->viscosity_multiplier * drag_multiplier;
  1745.         }
  1746.         drag_multiplier = c->water_depth_factor * drag_multiplier;
  1747.     }
  1748.     ts = BrVector3Length(&c->v) * drag_multiplier / c->M;
  1749.     BrVector3Scale(&b, &c->v, ts);
  1750.     BrVector3Accumulate(&c->v, &b);
  1751.     ts = BrVector3Length(&c->omega) * drag_multiplier;
  1752.     BrVector3Scale(&b, &c->omega, ts);
  1753.     ApplyTorque(c, &b);
  1754. }
  1755.  
  1756. // IDA: void __usercall DoBumpiness(tCar_spec *c@<EAX>, br_vector3 *wheel_pos@<EDX>, br_vector3 *norm@<EBX>, br_scalar *d@<ECX>, int n)
  1757. void DoBumpiness(tCar_spec* c, br_vector3* wheel_pos, br_vector3* norm, br_scalar* d, int n) {
  1758.     br_vector3 tv;
  1759.     int delta;
  1760.     int x;
  1761.     int y;
  1762.     tMaterial_modifiers* mat_list;
  1763.     LOG_TRACE("(%p, %p, %p, %p, %d)", c, wheel_pos, norm, d, n);
  1764.  
  1765.     tv.v[0] = c->nor[n].v[0] * d[n] + wheel_pos[n].v[0];
  1766.     tv.v[2] = c->nor[n].v[2] * d[n] + wheel_pos[n].v[2];
  1767.  
  1768.     x = abs((int)(512.0f * tv.v[0])) % 2048;
  1769.     y = abs((int)(512.0f * tv.v[2])) % 2048;
  1770.  
  1771.     if (x > 1024) {
  1772.         x = 2048 - x;
  1773.     }
  1774.     if (y > 1024) {
  1775.         y = 2048 - y;
  1776.     }
  1777.     if (x + y <= 1024) {
  1778.         delta = x + y;
  1779.     } else {
  1780.         delta = 2048 - x - y;
  1781.     }
  1782.     delta -= 400;
  1783.     if (delta < 0) {
  1784.         delta = 0;
  1785.     }
  1786.     mat_list = gCurrent_race.material_modifiers;
  1787.     d[n] = delta * mat_list[c->material_index[n]].bumpiness / 42400.0f * norm[n].v[1] + d[n];
  1788. }
  1789.  
  1790. // IDA: void __usercall CalcForce(tCar_spec *c@<EAX>, br_scalar dt)
  1791. void CalcForce(tCar_spec* c, br_scalar dt) {
  1792.     //int n; // Pierre-Marie Baty -- unused variable
  1793.     int normnum;
  1794.     int i;
  1795.     //int x; // Pierre-Marie Baty -- unused variable
  1796.     //int y; // Pierre-Marie Baty -- unused variable
  1797.     br_scalar force[4];
  1798.     br_scalar d[4];
  1799.     br_scalar ts;
  1800.     br_scalar ts2;
  1801.     br_scalar ts3;
  1802.     br_scalar ts4;
  1803.     //br_scalar ts5; // Pierre-Marie Baty -- unused variable
  1804.     //br_scalar ts6; // Pierre-Marie Baty -- unused variable
  1805.     br_scalar deltaomega;
  1806.     br_scalar wheelratio;
  1807.     //br_scalar modf; // Pierre-Marie Baty -- unused variable
  1808.     br_scalar maxfl;
  1809.     br_scalar maxfr;
  1810.     //br_scalar max_retardation; // Pierre-Marie Baty -- unused variable
  1811.     //br_scalar front_retardation; // Pierre-Marie Baty -- unused variable
  1812.     br_scalar friction_number;
  1813.     br_vector3 a;
  1814.     br_vector3 b;
  1815.     //br_vector3 tv; // Pierre-Marie Baty -- unused variable
  1816.     //br_vector3 tv2; // Pierre-Marie Baty -- unused variable
  1817.     br_vector3 norm[4];
  1818.     //br_vector3 v_batwick; // Pierre-Marie Baty -- unused variable
  1819.     br_vector3 vplane;
  1820.     br_vector3 rightplane;
  1821.     //br_vector3 t; // Pierre-Marie Baty -- unused variable
  1822.     br_vector3 f;
  1823.     //br_vector3 ff; // Pierre-Marie Baty -- unused variable
  1824.     //br_vector3 fb; // Pierre-Marie Baty -- unused variable
  1825.     //br_scalar ffi; // Pierre-Marie Baty -- unused variable
  1826.     //br_scalar ffk; // Pierre-Marie Baty -- unused variable
  1827.     //br_scalar fbi; // Pierre-Marie Baty -- unused variable
  1828.     //br_scalar fbk; // Pierre-Marie Baty -- unused variable
  1829.     br_vector3 wheel_pos[4];
  1830.     //br_scalar direction; // Pierre-Marie Baty -- unused variable
  1831.     //br_scalar wheel_spin_force; // Pierre-Marie Baty -- unused variable
  1832.     //br_scalar d_damage; // Pierre-Marie Baty -- unused variable
  1833.     br_scalar fl_oil_factor;
  1834.     br_scalar fr_oil_factor;
  1835.     br_scalar rl_oil_factor;
  1836.     br_scalar rr_oil_factor;
  1837.     br_matrix34* mat;
  1838.     tMaterial_modifiers* mat_list;
  1839.     static br_scalar stop_timer;
  1840.     static br_scalar slide_dist;
  1841.     //tDamage_type dam; // Pierre-Marie Baty -- unused variable
  1842.     //br_scalar v; // Pierre-Marie Baty -- unused variable
  1843.     tSpecial_volume* vol;
  1844.     //br_scalar scale; // Pierre-Marie Baty -- unused variable
  1845.     LOG_TRACE("(%p, %f)", c, dt);
  1846.  
  1847.     int v72;         // [esp+24h] [ebp-1C8h]
  1848.     double v73;      // [esp+2Ch] [ebp-1C0h]
  1849.     float v74;       // [esp+34h] [ebp-1B8h]
  1850.     float v75;       // [esp+38h] [ebp-1B4h]
  1851.     float v76;       // [esp+3Ch] [ebp-1B0h]
  1852.     float v77;       // [esp+40h] [ebp-1ACh]
  1853.     float v78;       // [esp+44h] [ebp-1A8h]
  1854.     float v79;       // [esp+48h] [ebp-1A4h]
  1855.     //float v80;       // [esp+4Ch] [ebp-1A0h] MAPDST // Pierre-Marie Baty -- unused variable
  1856.     //float v82;       // [esp+50h] [ebp-19Ch] MAPDST // Pierre-Marie Baty -- unused variable
  1857.     //float v84;       // [esp+54h] [ebp-198h] // Pierre-Marie Baty -- unused variable
  1858.     //float v85;       // [esp+58h] [ebp-194h] MAPDST // Pierre-Marie Baty -- unused variable
  1859.     float v87;       // [esp+5Ch] [ebp-190h] MAPDST
  1860.     float v98;       // [esp+88h] [ebp-164h]
  1861.     float v99;       // [esp+8Ch] [ebp-160h]
  1862.     br_vector3 v102; // [esp+98h] [ebp-154h]
  1863.     br_vector3 v103; // [esp+A4h] [ebp-148h]
  1864.     int v105;        // [esp+B8h] [ebp-134h]
  1865.     float v106;      // [esp+C0h] [ebp-12Ch]
  1866.     br_vector3 v107; // [esp+C4h] [ebp-128h]
  1867.     float v108;      // [esp+D0h] [ebp-11Ch]
  1868.     float v109;      // [esp+D4h] [ebp-118h]
  1869.     float v116;      // [esp+F8h] [ebp-F4h]
  1870.     br_vector3 B;    // [esp+FCh] [ebp-F0h] BYREF
  1871.     br_scalar pV;    // [esp+10Ch] [ebp-E0h]
  1872.     br_vector3 v123; // [esp+130h] [ebp-BCh]
  1873.     float v125;      // [esp+16Ch] [ebp-80h]
  1874.     float v128;      // [esp+18Ch] [ebp-60h]
  1875.     float v129;      // [esp+190h] [ebp-5Ch]
  1876.     float v134;      // [esp+1D8h] [ebp-14h]
  1877.     float v135;      // [esp+1DCh] [ebp-10h]
  1878.     br_vector3 v136; // [esp+1E0h] [ebp-Ch]
  1879.  
  1880.     BrVector3Set(&v136, 0, 0, 0);
  1881.     normnum = 0;
  1882.     BrVector3Set(&f, 0, 0, 0);
  1883.     BrVector3Set(&B, 0, 0, 0);
  1884.     mat = &c->car_master_actor->t.t.mat;
  1885.     mat_list = gCurrent_race.material_modifiers;
  1886.     vol = c->last_special_volume;
  1887.     b.v[0] = -mat->m[1][0];
  1888.     b.v[1] = -mat->m[1][1];
  1889.     b.v[2] = -mat->m[1][2];
  1890.     c->material_index[0] = 0;
  1891.     c->material_index[1] = 0;
  1892.     c->material_index[2] = 0;
  1893.     c->material_index[3] = 0;
  1894.     wheelratio = (c->wpos[2].v[2] - c->cmpos.v[2]) / (c->wpos[0].v[2] - c->cmpos.v[2]);
  1895.     BrVector3Set(&c->road_normal, 0, 0, 0);
  1896.     for (i = 0; i < 4; ++i) {
  1897.         BrMatrix34ApplyP(&wheel_pos[i], &c->wpos[i], mat);
  1898.     }
  1899.     MultiFindFloorInBoxM(4, wheel_pos, &b, c->nor, d, c, c->material_index);
  1900.     if (c->last_special_volume && c->last_special_volume->material_modifier_index) {
  1901.         c->material_index[0] = c->last_special_volume->material_modifier_index;
  1902.         c->material_index[1] = c->material_index[0];
  1903.         c->material_index[2] = c->material_index[1];
  1904.         c->material_index[3] = c->material_index[2];
  1905.     }
  1906.     for (i = 0; i < 4; ++i) {
  1907.         BrMatrix34TApplyV(&norm[i], &c->nor[i], mat);
  1908.         if (mat_list[c->material_index[i]].bumpiness != 0.0) {
  1909.             DoBumpiness(c, wheel_pos, norm, d, i);
  1910.         }
  1911.         if (d[i] < -0.5 || c->wheel_dam_offset[i ^ 2] * 6.9 + c->susp_height[i / 2] < d[i]) {
  1912.             force[i] = 0.0;
  1913.             d[i] = c->susp_height[i / 2];
  1914.         } else {
  1915.             BrVector3Accumulate(&c->road_normal, &norm[i]);
  1916.             normnum++;
  1917.             d[i] = d[i] - c->wheel_dam_offset[i ^ 2] * 6.9;
  1918.             force[i] = (c->susp_height[i / 2] - d[i]) * c->sk[1 / 2];
  1919.             force[i] = force[i] - (d[i] - c->oldd[i]) / dt * c->sb[i / 2];
  1920.             if (c->susp_height[i / 2] == c->oldd[i]
  1921.                 && c->nor[i].v[2] * c->v.v[2] + c->nor[i].v[1] * c->v.v[1] + c->nor[i].v[0] * c->v.v[0] > -0.0099999998
  1922.                 && c->M * 20.0 / 4.0 < force[i]) {
  1923.                 d[i] = c->susp_height[i / 2];
  1924.                 force[i] = c->M * 20.0 / 4.0;
  1925.             }
  1926.             if (force[i] < 0.0) {
  1927.                 force[i] = 0.0;
  1928.             }
  1929.             B.v[1] = force[i] + B.v[1];
  1930.             f.v[0] = f.v[0] - (c->wpos[i].v[2] - c->cmpos.v[2]) * force[i];
  1931.             f.v[2] = (c->wpos[i].v[0] - c->cmpos.v[0]) * force[i] + f.v[2];
  1932.         }
  1933.         c->oldd[i] = d[i];
  1934.     }
  1935.     if (c->driver <= eDriver_non_car || !c->wall_climber_mode || (c->road_normal.v[0] == 0.0 && c->road_normal.v[1] == 0.0 && c->road_normal.v[2] == 0.0)) {
  1936.         if (vol) {
  1937.             friction_number = (1.0 - vol->gravity_multiplier) * c->water_depth_factor;
  1938.             if (c->underwater_ability) {
  1939.                 friction_number = friction_number * 0.6;
  1940.             }
  1941.             friction_number = (1.0 - friction_number) * c->M;
  1942.         } else {
  1943.             friction_number = c->M;
  1944.         }
  1945.         friction_number = friction_number * gGravity_multiplier * 10.0;
  1946.         B.v[0] = B.v[0] - mat->m[0][1] * friction_number;
  1947.         B.v[1] = B.v[1] - mat->m[1][1] * friction_number;
  1948.         B.v[2] = B.v[2] - mat->m[2][1] * friction_number;
  1949.     } else {
  1950.         BrVector3Normalise(&v107, &c->road_normal);
  1951.         BrVector3Scale(&v107, &v107, -(c->M * 10.0));
  1952.         BrVector3Accumulate(&B, &v107);
  1953.     }
  1954.     if (c->driver >= eDriver_net_human) {
  1955.         SteeringSelfCentre(c, dt, &c->road_normal);
  1956.     }
  1957.     if (normnum) {
  1958.         // ts = 1.0 / sqrt(1.0); <- looked like this in the windows build definitely wrong
  1959.         // ts = 1.0 / sqrt(c->road_normal.v[0] * c->road_normal.v[0] + c->road_normal.v[1] * c->road_normal.v[1] + c->road_normal.v[2] * c->road_normal.v[2]);
  1960.         // c->road_normal.v[0] = c->road_normal.v[0] * ts;
  1961.         // c->road_normal.v[1] = c->road_normal.v[1] * ts;
  1962.         // c->road_normal.v[2] = c->road_normal.v[2] * ts;
  1963.         BrVector3NormaliseQuick(&c->road_normal, &c->road_normal);
  1964.  
  1965.         friction_number = c->road_normal.v[1] * mat->m[1][1] + c->road_normal.v[2] * mat->m[2][1] + c->road_normal.v[0] * mat->m[0][1];
  1966.         if (c->driver > eDriver_non_car && c->wall_climber_mode) {
  1967.             friction_number = 1.0;
  1968.         }
  1969.         friction_number = gCurrent_race.material_modifiers[c->material_index[0]].down_force * friction_number;
  1970.         if (friction_number > 0.0f) {
  1971.             friction_number = fabs(c->velocity_car_space.v[2]) * c->M * 10.0 * friction_number / c->down_force_speed;
  1972.             if (c->M * 10.0 < friction_number) {
  1973.                 friction_number = c->M * 10.0;
  1974.             }
  1975.             if (c->number_of_wheels_on_ground == 4 && c->oldd[2] == c->susp_height[1] && c->oldd[3] == c->susp_height[1]) {
  1976.                 a.v[0] = c->wpos[2].v[2] * mat->m[2][0];
  1977.                 a.v[1] = c->wpos[2].v[2] * mat->m[2][1];
  1978.                 a.v[2] = c->wpos[2].v[2] * mat->m[2][2];
  1979.                 a.v[0] = mat->m[3][0] + a.v[0];
  1980.                 a.v[1] = mat->m[3][1] + a.v[1];
  1981.                 a.v[2] = mat->m[3][2] + a.v[2];
  1982.                 BrVector3Scale(&b, &b, (c->wpos[0].v[2] - c->wpos[2].v[2]));
  1983.                 findfloor(&a, &b, norm, &ts2);
  1984.                 if (ts2 > 1.0) {
  1985.                     c->down_force_flag = 1;
  1986.                 }
  1987.             } else if (c->down_force_flag && (c->oldd[2] < c->susp_height[1] || c->oldd[3] < c->susp_height[1])) {
  1988.                 c->down_force_flag = 0;
  1989.             }
  1990.             if (c->down_force_flag) {
  1991.                 friction_number = (c->wpos[2].v[2] - c->cmpos.v[2]) / (c->wpos[2].v[2] - c->wpos[0].v[2]) * friction_number;
  1992.                 f.v[0] = (c->wpos[0].v[2] - c->cmpos.v[2]) * friction_number + f.v[0];
  1993.             }
  1994.             B.v[1] = B.v[1] - friction_number;
  1995.         }
  1996.         vplane.v[0] = BrVector3Dot(&c->velocity_car_space, &c->road_normal) * c->road_normal.v[0];
  1997.         vplane.v[1] = BrVector3Dot(&c->velocity_car_space, &c->road_normal) * c->road_normal.v[1];
  1998.         vplane.v[2] = BrVector3Dot(&c->velocity_car_space, &c->road_normal) * c->road_normal.v[2];
  1999.         BrVector3Sub(&vplane, &c->velocity_car_space, &vplane);
  2000.         if (vplane.v[2] < 0.0) {
  2001.             ts = 1.0;
  2002.         } else {
  2003.             ts = -1.0;
  2004.         }
  2005.         ts3 = BrVector3Length(&vplane);
  2006.         deltaomega = ts3 * c->curvature * ts;
  2007.         deltaomega = deltaomega - BrVector3Dot(&c->omega, &c->road_normal);
  2008.         BrVector3Set(&v103, c->road_normal.v[1], -c->road_normal.v[0], 0);
  2009.         BrVector3Normalise(&v103, &v103);
  2010.  
  2011.         friction_number = c->I.v[1] / dt * deltaomega;
  2012.         ts = friction_number / (c->wpos[2].v[2] - c->wpos[0].v[2]);
  2013.         v108 = ts;
  2014.         v109 = -ts;
  2015.         BrVector3Set(&rightplane, 0, c->road_normal.v[2], -c->road_normal.v[1]);
  2016.         BrVector3Normalise(&rightplane, &rightplane);
  2017.         v99 = c->acc_force;
  2018.         friction_number = BrVector3Dot(&rightplane, &vplane);
  2019.         v87 = BrVector3Dot(&v103, &vplane);
  2020.         ts2 = fabs(v87);
  2021.         friction_number = (c->wpos[0].v[2] - c->cmpos.v[2]) * friction_number * fabs(c->curvature);
  2022.         if (c->curvature <= 0.0) {
  2023.             friction_number = v87 - friction_number;
  2024.         } else {
  2025.             friction_number = v87 + friction_number;
  2026.         }
  2027.         friction_number = -(c->M / dt * friction_number);
  2028.         friction_number = friction_number - BrVector3Dot(&B, &v103);
  2029.  
  2030.         friction_number = friction_number / (1.0 - wheelratio);
  2031.         v108 = friction_number + v108;
  2032.         v109 = -wheelratio * friction_number + v109;
  2033.         friction_number = (c->wpos[0].v[2] - c->wpos[2].v[2]) * v108;
  2034.         v98 = friction_number * c->curvature;
  2035.         friction_number = BrVector3Dot(&c->velocity_car_space, &rightplane) * c->M / dt;
  2036.         v129 = BrVector3Dot(&rightplane, &B) + friction_number;
  2037.         v128 = c->mu[0] * c->brake_force / (c->mu[1] / c->friction_elipticity + c->mu[0]);
  2038.         v125 = c->brake_force - v128;
  2039.         v105 = (c->damage_units[7].damage_level + c->damage_units[6].damage_level) / 2;
  2040.         if (v105 > 20) {
  2041.             v128 = (1.0 - (double)(v105 - 20) / 80.0) * (1.0 - (double)(v105 - 20) / 80.0) * v128;
  2042.         }
  2043.         v105 = (c->damage_units[5].damage_level + c->damage_units[4].damage_level) / 2;
  2044.         if (v105 > 20) {
  2045.             v125 = (1.0 - (double)(v105 - 20) / 80.0) * (1.0 - (double)(v105 - 20) / 80.0) * v125;
  2046.         }
  2047.         ts2 = (force[1] + force[0]) * c->rolling_r_back + v128;
  2048.         v87 = (force[2] + force[3]) * c->rolling_r_front + v125;
  2049.         v128 = c->wpos[0].v[2] - c->wpos[2].v[2];
  2050.         v128 = sqrt(v128 * v128 * c->curvature * c->curvature + 1.0);
  2051.         v106 = v87 / v128;
  2052.         v134 = v106 + ts2;
  2053.         if (fabs(v129) < fabs(v134)) {
  2054.             ts2 = v129 / v134 * ts2;
  2055.             v106 = v129 / v134 * v106;
  2056.         }
  2057.         if ((v87 + ts2) * v129 < 0.0) {
  2058.             ts2 = -ts2;
  2059.             v106 = -v106;
  2060.         }
  2061.         v129 = v129 - (ts2 + v106);
  2062.         v99 = v99 - ts2;
  2063.         if (c->keys.brake && c->damage_units[eDamage_lr_brake].damage_level < 60 && c->damage_units[eDamage_rr_brake].damage_level < 60) {
  2064.             v99 = v99 - v129;
  2065.             c->gear = 0;
  2066.         }
  2067.         v99 = v99 / c->friction_elipticity;
  2068.         v135 = sqrt(v99 * v99 + v109 * v109) / 2.0;
  2069.  
  2070.         GetOilFrictionFactors(c, &fl_oil_factor, &fr_oil_factor, &rl_oil_factor, &rr_oil_factor);
  2071.         if (c->driver <= eDriver_non_car) {
  2072.             v116 = 1.0;
  2073.         } else {
  2074.             v116 = c->grip_multiplier;
  2075.         }
  2076.         BrVector3Sub(&v102, &c->wpos[0], &c->cmpos);
  2077.         BrVector3Cross(&a, &c->omega, &v102);
  2078.         BrVector3Accumulate(&a, &c->velocity_car_space);
  2079.         if (c->driver >= eDriver_net_human
  2080.             && (((c->keys.left || c->joystick.left > 0x8000) && c->curvature > 0.0 && deltaomega > 0.1 && a.v[0] > 0.0)
  2081.                 || ((c->keys.right || c->joystick.right > 0x8000) && c->curvature < 0.0 && deltaomega < 0.1 && a.v[0] < 0.0))
  2082.             && ts > 0.0) {
  2083.             friction_number = c->mu[0];
  2084.         } else {
  2085.             friction_number = c->mu[2];
  2086.             ts2 = fabs(a.v[0]) / 10.0;
  2087.             if (ts2 > 1) {
  2088.                 ts2 = 1.0;
  2089.             }
  2090.             friction_number = (c->mu[2] - c->mu[0]) * ts2 + friction_number;
  2091.         }
  2092.  
  2093.         maxfl = sqrt(force[0]) * friction_number * (rl_oil_factor * v116) * mat_list[c->material_index[0]].tyre_road_friction;
  2094.         maxfr = sqrt(force[1]) * friction_number * (rr_oil_factor * v116) * mat_list[c->material_index[1]].tyre_road_friction;
  2095.         c->max_force_rear = maxfr + maxfl;
  2096.         if (rl_oil_factor == 1.0 && rr_oil_factor == 1.0 && c->traction_control && v135 * 2.0 > c->max_force_rear && c->acc_force > 0.0
  2097.             && (c->driver < eDriver_net_human || (c->target_revs > 1000.0 && c->gear > 0))) {
  2098.             ts2 = v99;
  2099.             if (v99 * v99 <= v135 * v135 * 4.0) {
  2100.                 v87 = sqrt(v135 * v135 * 4.0 - v99 * v99);
  2101.             } else {
  2102.                 v87 = 0.0;
  2103.             }
  2104.             if (c->max_force_rear <= v87) {
  2105.                 c->torque = -(c->revs * c->revs / 100000000.0) - 0.1;
  2106.             } else {
  2107.                 float v177 = sqrt(c->max_force_rear * c->max_force_rear - v87 * v87);
  2108.                 ts3 = ts2 < 0.0 ? -1.0 : 1.0;
  2109.                 // ts4 = (ts2 - ts3 * sqrt(ts3)) * 1.01;
  2110.                 // if (fabs(ts2) > fabs(ts4)) {
  2111.                 //     v87 = ts4;
  2112.                 //     ts2 = v87;
  2113.                 // }
  2114.  
  2115.                 ts4 = (ts2 - ts3 * v177) * 1.01;
  2116.                 if (fabs(ts2) > fabs(ts4)) {
  2117.                     ts2 = ts4;
  2118.                 }
  2119.             }
  2120.             v99 = v99 - ts2;
  2121.             v135 = sqrt(v99 * v99 + v109 * v109) / 2.0;
  2122.  
  2123.         } else if (c->driver >= eDriver_net_human && c->gear > 0 && c->revs > c->target_revs && !c->traction_control) {
  2124.             if (!c->keys.change_down) {
  2125.                 c->traction_control = 1;
  2126.             }
  2127.             friction_number = 1.0 - (c->revs - c->target_revs) / (double)(400 * c->gear);
  2128.             if (friction_number < 0.40000001) {
  2129.                 friction_number = (br_scalar) 0.40000001; // Pierre-Marie Baty -- added type cast
  2130.             }
  2131.             maxfl = friction_number * maxfl;
  2132.             maxfr = friction_number * maxfr;
  2133.         }
  2134.         if (fabs(v109) > maxfr + maxfl && maxfr + maxfl > 0.1) {
  2135.             v87 = (maxfr + maxfl) / fabs(v109) * dt;
  2136.             v109 = v87 * v109;
  2137.             v99 = c->friction_elipticity * v87 * v99;
  2138.             friction_number = -((c->wpos[2].v[2] - c->cmpos.v[2]) * v108 * ((c->wpos[2].v[2] - c->cmpos.v[2]) * v108) / c->I.v[1] + (v98 * v98 + v108 * v108) / c->M);
  2139.             ts2 = (BrVector3Dot(&v103, &vplane) + v109 / c->M) * v108;
  2140.             ts2 = BrVector3Dot(&rightplane, &vplane) * v98 + ts2;
  2141.             ts2 = BrVector3Dot(&c->omega, &c->road_normal) * (c->wpos[2].v[2] - c->cmpos.v[2]) * v108 + ts2;
  2142.             ts2 = (c->wpos[0].v[2] - c->cmpos.v[2]) * (c->wpos[2].v[2] - c->cmpos.v[2]) * v109 / c->I.v[1] * v108 + ts2;
  2143.             if (fabs(friction_number) > 0.1) {
  2144.                 friction_number = ts2 / (friction_number * dt);
  2145.                 v108 = friction_number * v108;
  2146.                 v98 = friction_number * v98;
  2147.             }
  2148.             v109 = v109 / v87;
  2149.             v99 = v99 / (c->friction_elipticity * v87);
  2150.         }
  2151.         v98 = v98 - v106;
  2152.         v108 = (c->wpos[0].v[2] - c->wpos[2].v[2]) * c->curvature * v106 + v108;
  2153.         if (v135 > 0.000099999997) {
  2154.             v109 = v109 / (v135 * 2.0);
  2155.             v99 = v99 / (v135 * 2.0);
  2156.         }
  2157.         v99 = c->friction_elipticity * v99;
  2158.         force[0] = v135;
  2159.         force[1] = v135;
  2160.         c->wheel_slip = 0;
  2161.         switch ((force[0] > maxfl) + 2 * (force[1] > maxfr)) {
  2162.         case 0:
  2163.             slide_dist = 0;
  2164.             break;
  2165.         case 1:
  2166.             force[0] = c->freduction * maxfl;
  2167.             force[1] = v135 - force[0] + force[1];
  2168.             if (force[1] <= maxfr) {
  2169.                 slide_dist = 0;
  2170.             } else {
  2171.                 if (maxfr > 0.1) {
  2172.                     pV = (force[1] - maxfr) / maxfr;
  2173.                     if (&gProgram_state.current_car == c) {
  2174.                         v78 = 20.0;
  2175.                     } else {
  2176.                         v78 = 60.0;
  2177.                     }
  2178.                     if (v78 <= pV) {
  2179.                         c->new_skidding |= 2u;
  2180.                     }
  2181.                     SkidNoise(c, 1, pV, c->material_index[1]);
  2182.                 }
  2183.                 force[1] = c->freduction * maxfr;
  2184.                 c->wheel_slip |= 2u;
  2185.             }
  2186.             break;
  2187.         case 2:
  2188.             force[1] = c->freduction * maxfr;
  2189.             force[0] = v135 - force[1] + force[0];
  2190.             if (force[0] <= maxfl) {
  2191.                 slide_dist = 0;
  2192.             } else {
  2193.                 if (maxfl > 0.1) {
  2194.                     pV = (force[0] - maxfl) / maxfl;
  2195.                     if (&gProgram_state.current_car == c) {
  2196.                         v77 = 20.0;
  2197.                     } else {
  2198.                         v77 = 60.0;
  2199.                     }
  2200.                     if (v77 <= pV) {
  2201.                         c->new_skidding |= 1u;
  2202.                     }
  2203.                     SkidNoise(c, 0, pV, c->material_index[0]);
  2204.                 }
  2205.                 force[0] = c->freduction * maxfl;
  2206.                 c->wheel_slip |= 2u;
  2207.             }
  2208.             break;
  2209.         case 3:
  2210.             force[0] = c->freduction * maxfl;
  2211.             force[1] = c->freduction * maxfr;
  2212.             c->wheel_slip |= 2u;
  2213.             pV = (v135 * 2.0 - maxfl - maxfr) / (maxfr + maxfl);
  2214.             if (&gProgram_state.current_car == c) {
  2215.                 v79 = 20.0;
  2216.             } else {
  2217.                 v79 = 60.0;
  2218.             }
  2219.             if (v79 <= pV) {
  2220.                 if (maxfl > 0.1) {
  2221.                     c->new_skidding |= 1u;
  2222.                 }
  2223.                 if (maxfr > 0.1) {
  2224.                     c->new_skidding |= 2u;
  2225.                 }
  2226.             }
  2227.             if (IRandomBetween(0, 1)) {
  2228.                 if (maxfl > 0.1) {
  2229.                     SkidNoise(c, 0, pV, c->material_index[0]);
  2230.                 }
  2231.             } else if (maxfr > 0.1) {
  2232.                 SkidNoise(c, 1, pV, c->material_index[1]);
  2233.             }
  2234.             break;
  2235.         default:
  2236.             break;
  2237.         }
  2238.         if (c->wheel_slip && c->curvature * c->turn_speed > 0.0 && fabs(v109) > 0.0099999998 && c->curvature * v109 < 0.0 && !c->keys.brake && !c->keys.change_down) {
  2239.             c->turn_speed = 0.0;
  2240.         }
  2241.         v135 = sqrt(v108 * v108 + v98 * v98) / 2.0;
  2242.         if (v135 > 0.000099999997) {
  2243.             v108 = v108 / (v135 * 2.0);
  2244.             v98 = v98 / (v135 * 2.0);
  2245.         }
  2246.         maxfl = sqrt(force[2]) * c->mu[1] * (fl_oil_factor * v116) * mat_list[c->material_index[2]].tyre_road_friction;
  2247.         maxfr = sqrt(force[3]) * c->mu[1] * (fr_oil_factor * v116) * mat_list[c->material_index[3]].tyre_road_friction;
  2248.         c->max_force_front = maxfr + maxfl;
  2249.         force[2] = v135;
  2250.         force[3] = v135;
  2251.         v72 = (v135 > maxfl) + 2 * (v135 > maxfr);
  2252.         switch (v72) {
  2253.         case 1:
  2254.             force[2] = c->freduction * maxfl;
  2255.             force[3] = v135 - force[2] + force[3];
  2256.             if (force[3] > maxfr) {
  2257.                 if (maxfr > 0.1) {
  2258.                     pV = (force[3] - maxfr) / maxfr;
  2259.                     if (&gProgram_state.current_car == c) {
  2260.                         v75 = 20.0;
  2261.                     } else {
  2262.                         v75 = 60.0;
  2263.                     }
  2264.                     if (v75 <= pV) {
  2265.                         c->new_skidding |= 8u;
  2266.                     }
  2267.                     SkidNoise(c, 3, pV, c->material_index[3]);
  2268.                 }
  2269.                 force[3] = c->freduction * maxfr;
  2270.                 c->wheel_slip |= 1u;
  2271.             }
  2272.             break;
  2273.         case 2:
  2274.             force[3] = c->freduction * maxfr;
  2275.             force[2] = v135 - force[3] + force[2];
  2276.             if (force[2] > maxfl) {
  2277.                 if (maxfl > 0.1) {
  2278.                     pV = (force[2] - maxfl) / maxfl;
  2279.                     if (&gProgram_state.current_car == c) {
  2280.                         v74 = 20.0;
  2281.                     } else {
  2282.                         v74 = 60.0;
  2283.                     }
  2284.                     if (v74 <= pV) {
  2285.                         c->new_skidding |= 4u;
  2286.                     }
  2287.                     SkidNoise(c, 2, pV, c->material_index[2]);
  2288.                 }
  2289.                 force[2] = c->freduction * maxfl;
  2290.                 c->wheel_slip |= 1u;
  2291.             }
  2292.             break;
  2293.         case 3:
  2294.             force[2] = c->freduction * maxfl;
  2295.             force[3] = c->freduction * maxfr;
  2296.             c->wheel_slip |= 1u;
  2297.             pV = (v135 * 2.0 - maxfl - maxfr) / (maxfr + maxfl);
  2298.             if (&gProgram_state.current_car == c) {
  2299.                 v76 = 20.0;
  2300.             } else {
  2301.                 v76 = 60.0;
  2302.             }
  2303.             if (v76 <= pV) {
  2304.                 if (maxfl > 0.1) {
  2305.                     c->new_skidding |= 4u;
  2306.                 }
  2307.                 if (maxfr > 0.1) {
  2308.                     c->new_skidding |= 8u;
  2309.                 }
  2310.             }
  2311.             if (IRandomBetween(0, 1)) {
  2312.                 if (maxfl > 0.1) {
  2313.                     SkidNoise(c, 2, pV, c->material_index[2]);
  2314.                 }
  2315.             } else if (maxfr > 0.1) {
  2316.                 SkidNoise(c, 3, pV, c->material_index[3]);
  2317.             }
  2318.             break;
  2319.         }
  2320.         BrVector3Scale(&v136, &rightplane, v99);
  2321.         BrVector3Scale(&a, &v103, v109);
  2322.         BrVector3Accumulate(&v136, &a);
  2323.         BrVector3Scale(&v123, &rightplane, v98);
  2324.         BrVector3Scale(&a, &v103, v108);
  2325.         BrVector3Accumulate(&v123, &a);
  2326.  
  2327.         rightplane = c->wpos[0];
  2328.         rightplane.v[1] = rightplane.v[1] - c->oldd[0];
  2329.         BrVector3Sub(&rightplane, &rightplane, &c->cmpos);
  2330.         BrVector3Scale(&b, &v136, force[0]);
  2331.         BrVector3Accumulate(&B, &b);
  2332.         BrVector3Cross(&a, &rightplane, &b);
  2333.         BrVector3Accumulate(&f, &a);
  2334.  
  2335.         rightplane = c->wpos[1];
  2336.         rightplane.v[1] = rightplane.v[1] - c->oldd[1];
  2337.         BrVector3Sub(&rightplane, &rightplane, &c->cmpos);
  2338.         BrVector3Scale(&b, &v136, force[1]);
  2339.         BrVector3Accumulate(&B, &b);
  2340.         BrVector3Cross(&a, &rightplane, &b);
  2341.         BrVector3Accumulate(&f, &a);
  2342.  
  2343.         rightplane = c->wpos[2];
  2344.         rightplane.v[1] = rightplane.v[1] - c->oldd[2];
  2345.         BrVector3Sub(&rightplane, &rightplane, &c->cmpos);
  2346.         BrVector3Scale(&b, &v123, force[2]);
  2347.         BrVector3Accumulate(&B, &b);
  2348.         BrVector3Cross(&a, &rightplane, &b);
  2349.         BrVector3Accumulate(&f, &a);
  2350.  
  2351.         rightplane = c->wpos[3];
  2352.         rightplane.v[1] = rightplane.v[1] - c->oldd[3];
  2353.         BrVector3Sub(&rightplane, &rightplane, &c->cmpos);
  2354.         BrVector3Scale(&b, &v123, force[3]);
  2355.         BrVector3Accumulate(&B, &b);
  2356.         BrVector3Cross(&a, &rightplane, &b);
  2357.         BrVector3Accumulate(&f, &a);
  2358.  
  2359.     } else {
  2360.         c->max_force_front = 0.0;
  2361.         c->max_force_rear = 0.0;
  2362.         StopSkid(c);
  2363.     }
  2364.     c->number_of_wheels_on_ground = normnum;
  2365.     BrMatrix34ApplyV(&b, &B, mat);
  2366.     BrVector3Scale(&rightplane, &f, dt);
  2367.     ApplyTorque(c, &rightplane);
  2368.     BrVector3Scale(&rightplane, &b, dt / c->M);
  2369.     BrVector3Accumulate(&c->v, &rightplane);
  2370.     if (c->speed < 0.000099999997
  2371.         && ((!c->keys.acc && c->joystick.acc <= 0) || !c->gear)
  2372.         && !c->keys.dec
  2373.         && c->joystick.dec <= 0
  2374.         && c->bounce_rate == 0.0
  2375.         && BrVector3Length(&c->omega) < 0.05) {
  2376.         if (vol) {
  2377.             v73 = c->driver > eDriver_non_car && c->underwater_ability ? 1.0 - (1.0 - vol->gravity_multiplier) * 0.6 : vol->gravity_multiplier;
  2378.             friction_number = BrVector3Length(&b) / v73 / gGravity_multiplier;
  2379.         } else {
  2380.             friction_number = BrVector3Length(&b);
  2381.         }
  2382.         if (c->M > friction_number || (c->keys.brake && normnum >= 3)) {
  2383.             if (stop_timer == 100.0) {
  2384.                 stop_timer = 0.0;
  2385.             }
  2386.             if (stop_timer > 0.5) {
  2387.                 BrVector3SetFloat(&c->v, 0.0, 0.0, 0.0);
  2388.                 BrVector3SetFloat(&c->omega, 0.0, 0.0, 0.0);
  2389.                 stop_timer = 0.5;
  2390.             }
  2391.         }
  2392.     }
  2393.     stop_timer = dt + stop_timer;
  2394.     if (stop_timer > 1.0) {
  2395.         stop_timer = 100.0;
  2396.     }
  2397.     AddDrag(c, dt);
  2398.     if (c->driver >= eDriver_net_human) {
  2399.         c->acc_force = -(v136.v[2] * force[0]) - v136.v[2] * force[1];
  2400.         // LOG_DEBUG("old %f new %f", old, c->acc_force);
  2401.     }
  2402. }
  2403.  
  2404. // IDA: void __usercall DoRevs(tCar_spec *c@<EAX>, br_scalar dt)
  2405. void DoRevs(tCar_spec* c, br_scalar dt) {
  2406.     br_scalar wheel_spin_force;
  2407.     br_scalar ts;
  2408.     //int revs_increase; // Pierre-Marie Baty -- unused variable
  2409.     LOG_TRACE("(%p, %f)", c, dt);
  2410.  
  2411.     ts = -BrVector3Dot((br_vector3*)c->car_master_actor->t.t.mat.m[2], &c->v);
  2412.  
  2413.     if (c->gear) {
  2414.         c->target_revs = ts / c->speed_revs_ratio / (double)c->gear;
  2415.     } else {
  2416.         c->target_revs = 0.0;
  2417.     }
  2418.     if (c->target_revs < 0.0) {
  2419.         c->target_revs = 0.0;
  2420.         c->gear = 0;
  2421.     }
  2422.     if (!c->number_of_wheels_on_ground || ((c->wheel_slip & 2) + 1) != 0 || !c->gear) {
  2423.         if (c->number_of_wheels_on_ground) {
  2424.             wheel_spin_force = c->force_torque_ratio * c->torque - (double)c->gear * c->acc_force;
  2425.         } else {
  2426.             wheel_spin_force = c->force_torque_ratio * c->torque;
  2427.         }
  2428.         if (c->gear) {
  2429.             if (c->gear < 2 && (c->keys.dec || c->joystick.dec > 0) && fabs(ts) < 1.0 && c->revs > 1000.0) {
  2430.                 c->gear = -c->gear;
  2431.             }
  2432.         } else {
  2433.             if (c->revs > 1000.0 && !c->keys.brake && (c->keys.acc || c->joystick.acc > 0) && !gCountdown) {
  2434.                 if (c->keys.backwards) {
  2435.                     c->gear = -1;
  2436.                 } else {
  2437.                     c->gear = 1;
  2438.                 }
  2439.             }
  2440.             wheel_spin_force = c->force_torque_ratio * c->torque;
  2441.         }
  2442.         c->revs = wheel_spin_force / c->force_torque_ratio * dt / 0.0002 + c->revs;
  2443.  
  2444.         if (c->traction_control && wheel_spin_force > 0.0 && c->revs > c->target_revs && c->gear && c->target_revs > 1000.0) {
  2445.             c->revs = c->target_revs;
  2446.         }
  2447.         if (c->revs <= 0.0) {
  2448.             c->revs = 0.0;
  2449.         }
  2450.     }
  2451.     if ((c->wheel_slip & 2) == 0 && c->target_revs > 6000.0 && c->revs > 6000.0 && c->gear < c->max_gear && c->gear > 0 && !c->just_changed_gear) {
  2452.         c->gear++;
  2453.     }
  2454.     if (c->gear > 1 && c->target_revs < 3000.0 && !c->just_changed_gear) {
  2455.         c->gear--;
  2456.     }
  2457.     if (c->revs < 200.0 && c->target_revs < 200.0 && c->gear <= 1 && !c->keys.acc && c->joystick.acc <= 0 && !c->just_changed_gear) {
  2458.         c->gear = 0;
  2459.     }
  2460.     if (c->just_changed_gear && c->revs < 6000.0 && c->revs > 200.0 && (c->gear < 2 || c->revs >= 3000.0)) {
  2461.         c->just_changed_gear = 0;
  2462.     }
  2463.     if (c->revs >= 6000.0 && (c->keys.acc || c->joystick.acc > 0)) {
  2464.         c->just_changed_gear = 0;
  2465.     }
  2466. }
  2467.  
  2468. // IDA: void __usercall ApplyTorque(tCar_spec *c@<EAX>, br_vector3 *tdt@<EDX>)
  2469. void ApplyTorque(tCar_spec* c, br_vector3* tdt) {
  2470.     LOG_TRACE("(%p, %p)", c, tdt);
  2471.  
  2472.     c->omega.v[0] = tdt->v[0] / c->I.v[0] + c->omega.v[0];
  2473.     c->omega.v[1] = tdt->v[1] / c->I.v[1] + c->omega.v[1];
  2474.     c->omega.v[2] = tdt->v[2] / c->I.v[2] + c->omega.v[2];
  2475. }
  2476.  
  2477. // IDA: void __usercall TranslateCar(tCollision_info *c@<EAX>, br_scalar dt)
  2478. void TranslateCar(tCollision_info* c, br_scalar dt) {
  2479.     br_vector3 t;
  2480.     LOG_TRACE("(%p, %f)", c, dt);
  2481.  
  2482.     t.v[0] = c->v.v[0] * dt;
  2483.     t.v[1] = c->v.v[1] * dt;
  2484.     t.v[2] = c->v.v[2] * dt;
  2485.     c->car_master_actor->t.t.mat.m[3][0] = c->car_master_actor->t.t.mat.m[3][0] + t.v[0];
  2486.     c->car_master_actor->t.t.mat.m[3][1] = c->car_master_actor->t.t.mat.m[3][1] + t.v[1];
  2487.     c->car_master_actor->t.t.mat.m[3][2] = c->car_master_actor->t.t.mat.m[3][2] + t.v[2];
  2488. }
  2489.  
  2490. // IDA: int __usercall CollCheck@<EAX>(tCollision_info *c@<EAX>, br_scalar dt)
  2491. int CollCheck(tCollision_info* c, br_scalar dt) {
  2492.     br_vector3 a;
  2493.     br_vector3 a1;
  2494.     br_vector3 aa;
  2495.     br_vector3 bb;
  2496.     br_vector3 cc;
  2497.     br_vector3 pos;
  2498.     br_vector3 r[8];
  2499.     br_vector3 norm;
  2500.     br_vector3 n[8];
  2501.     br_vector3 dir;
  2502.     br_vector3 tv;
  2503.     br_vector3 tv2;
  2504.     br_vector3 tau[4];
  2505.     //br_vector3 old_val; // Pierre-Marie Baty -- unused variable
  2506.     //br_vector3 ftau; // Pierre-Marie Baty -- unused variable
  2507.     br_vector3 max_friction;
  2508.     br_vector3 vel;
  2509.     br_vector3 p_vel;
  2510.     br_vector3 normal_force;
  2511.     br_vector3 friction_force;
  2512.     br_scalar d[4];
  2513.     br_scalar f[4];
  2514.     br_scalar total_force;
  2515.     br_scalar point_vel;
  2516.     br_scalar batwick_length;
  2517.     br_matrix4 M;
  2518.     br_scalar dist;
  2519.     //br_scalar min_d; // Pierre-Marie Baty -- unused variable
  2520.     br_scalar ts;
  2521.     br_scalar ts2;
  2522.     br_scalar v_diff;
  2523.     br_matrix34* mat;
  2524.     br_matrix34* oldmat;
  2525.     br_matrix34 mat_to_oldmat;
  2526.     br_matrix34 oldmat_to_mat;
  2527.     br_matrix34 tm;
  2528.     int collision;
  2529.     br_bounds bnds;
  2530.     tFace_ref* f_ref;
  2531.     int i;
  2532.     int j;
  2533.     //int l; // Pierre-Marie Baty -- unused variable
  2534.     int k;
  2535.     int material;
  2536.     int noise_defeat;
  2537.     static int oldk;
  2538.     br_scalar min;
  2539.     br_scalar max;
  2540.     br_vector3 edges[3];
  2541.     //br_vector3 corner; // Pierre-Marie Baty -- unused variable
  2542.     //br_vector3 test_dir; // Pierre-Marie Baty -- unused variable
  2543.     //br_scalar min_acc; // Pierre-Marie Baty -- unused variable
  2544.     //br_scalar max_acc; // Pierre-Marie Baty -- unused variable
  2545.     br_matrix34 message_mat;
  2546.     LOG_TRACE("(%p, %f)", c, dt);
  2547.  
  2548.     tCar_spec* car_spec; // added for readability
  2549.  
  2550.     // v34 = 0;
  2551.     // v35 = 0;
  2552.     // v36 = 0x3F800000;
  2553.     // v48 = 0x3F800347;
  2554.     car_spec = (tCar_spec*)c;
  2555.     mat = &c->car_master_actor->t.t.mat;
  2556.     oldmat = &c->oldmat;
  2557.     k = 0;
  2558.     gMaterial_index = 0;
  2559.     if (c->dt >= 0.0f && gNet_mode == eNet_mode_host) {
  2560.         oldmat = &message_mat;
  2561.         GetExpandedMatrix(&message_mat, &c->message.mat);
  2562.     }
  2563.     if (dt < 0.0f) {
  2564.         mat = oldmat;
  2565.     }
  2566.     BrMatrix34LPInverse(&tm, mat);
  2567.     BrMatrix34Mul(&oldmat_to_mat, oldmat, &tm);
  2568.  
  2569.     oldmat_to_mat.m[3][0] = oldmat_to_mat.m[3][0] / WORLD_SCALE;
  2570.     oldmat_to_mat.m[3][1] = oldmat_to_mat.m[3][1] / WORLD_SCALE;
  2571.     oldmat_to_mat.m[3][2] = oldmat_to_mat.m[3][2] / WORLD_SCALE;
  2572.     GetNewBoundingBox(&bnds, &c->bounds[2], &oldmat_to_mat);
  2573.     for (i = 0; i < 3; ++i) {
  2574.         if (c->bounds[2].min.v[i] < bnds.min.v[i]) {
  2575.             bnds.min.v[i] = c->bounds[2].min.v[i];
  2576.         }
  2577.         if (c->bounds[2].max.v[i] > bnds.max.v[i]) {
  2578.             bnds.max.v[i] = c->bounds[2].max.v[i];
  2579.         }
  2580.     }
  2581.     a1.v[0] = mat->m[3][0] / WORLD_SCALE;
  2582.     a1.v[1] = mat->m[3][1] / WORLD_SCALE;
  2583.     a1.v[2] = mat->m[3][2] / WORLD_SCALE;
  2584.     BrMatrix34ApplyV(&aa, &bnds.min, mat);
  2585.     BrVector3Accumulate(&aa, &a1);
  2586.     for (j = 0; j < 3; ++j) {
  2587.         edges[j].v[0] = (bnds.max.v[j] - bnds.min.v[j]) * mat->m[j][0];
  2588.         edges[j].v[1] = (bnds.max.v[j] - bnds.min.v[j]) * mat->m[j][1];
  2589.         edges[j].v[2] = (bnds.max.v[j] - bnds.min.v[j]) * mat->m[j][2];
  2590.     }
  2591.     for (i = 0; i < 50 && i < c->box_face_end - c->box_face_start; i++) {
  2592.         f_ref = &gFace_list__car[c->box_face_start + i];
  2593.         BrVector3Sub(&bb, &aa, &f_ref->v[0]);
  2594.         max = BrVector3Dot(&bb, &f_ref->normal);
  2595.         min = max;
  2596.         for (j = 0; j < 3; ++j) {
  2597.             ts = BrVector3Dot(&edges[j], &f_ref->normal);
  2598.             if (ts >= 0) {
  2599.                 max = max + ts;
  2600.             } else {
  2601.                 min = min + ts;
  2602.             }
  2603.         }
  2604.         if ((max <= 0.001f || min <= 0.001f) && (max >= -0.001f || min >= -0.001f)) {
  2605.             f_ref->flags &= ~0x80u;
  2606.             k++;
  2607.         } else {
  2608.             f_ref->flags |= 0x80u;
  2609.         }
  2610.     }
  2611.     if (k == 0) {
  2612.         return 0;
  2613.     }
  2614.     k = 0;
  2615.     BrMatrix34LPInverse(&tm, oldmat);
  2616.     BrMatrix34Mul(&mat_to_oldmat, mat, &tm);
  2617.     gEliminate_faces = 1;
  2618.     for (i = 0; i < 8 + c->extra_point_num; i++) {
  2619.         if (i >= 8) {
  2620.             tv = c->extra_points[i - 8];
  2621.         } else {
  2622.             tv.v[0] = ((i & 2) == 0) * c->bounds[1].min.v[0] + ((i & 2) >> 1) * c->bounds[1].max.v[0];
  2623.             tv.v[1] = ((i & 1) == 0) * c->bounds[1].min.v[1] + ((i & 1) >> 0) * c->bounds[1].max.v[1];
  2624.             tv.v[2] = ((i & 4) == 0) * c->bounds[1].max.v[2] + ((i & 4) >> 2) * c->bounds[1].min.v[2];
  2625.         }
  2626.         BrMatrix34ApplyP(&dir, &tv, mat);
  2627.         if (dt >= 0.0f) {
  2628.             BrMatrix34ApplyP(&a, &tv, oldmat);
  2629.         } else {
  2630.             BrVector3Scale(&a, &c->pos, WORLD_SCALE);
  2631.         }
  2632.         BrVector3Sub(&dir, &dir, &a);
  2633.         BrVector3Normalise(&normal_force, &dir);
  2634.         BrVector3Scale(&normal_force, &normal_force, 0.0072463769f);
  2635.         BrVector3Accumulate(&dir, &normal_force);
  2636.         material = FindFloorInBoxM2(&a, &dir, &norm, &dist, c);
  2637.         if (dist >= 0.0f && dist < 1.0001f) {
  2638.             BrVector3Scale(&cc, &c->pos, WORLD_SCALE);
  2639.             BrVector3Sub(&cc, &cc, &a);
  2640.             FindFloorInBoxM(&a, &cc, &bb, &ts, c);
  2641.             if (i < 8 || ts > 1.0f) {
  2642.                 BrMatrix34TApplyV(&a, &norm, oldmat);
  2643.                 AddCollPoint(dist, &tv, &a, r, n, &dir, k, c);
  2644.                 k++;
  2645.                 if (gMaterial_index == 0) {
  2646.                     gMaterial_index = material;
  2647.                 }
  2648.             }
  2649.         }
  2650.     }
  2651.     gEliminate_faces = 0;
  2652.     if (k < 1) {
  2653.         k += BoxFaceIntersect(&c->bounds[1], mat, &mat_to_oldmat, &r[k], &n[k], &d[k], 8 - k, c);
  2654.     }
  2655.     if (k > 4) {
  2656.         k = 4;
  2657.     }
  2658.     for (i = 0; i < k; i++) {
  2659.         if (fabsf(r[i].v[1]) + fabsf(r[i].v[2]) + fabsf(r[i].v[0]) > 500.0f) {
  2660.             for (j = i + 1; j < k; j++) {
  2661.                 if (fabsf(r[j].v[1]) + fabsf(r[j].v[2]) + fabsf(r[j].v[0]) < 500.0f) {
  2662.                     r[i] = r[j];
  2663.                     n[i] = n[j];
  2664.                     i++;
  2665.                 }
  2666.             }
  2667.             k = i;
  2668.             break;
  2669.         }
  2670.     }
  2671.     if (dt >= 0.0f) {
  2672.         if (k > 0 && c->collision_flag && k < 4
  2673.             && (fabsf(r[0].v[0] - c->old_point.v[0]) > 0.05f
  2674.                 || fabsf(r[0].v[1] - c->old_point.v[1]) > 0.05f
  2675.                 || fabsf(r[0].v[2] - c->old_point.v[2]) > 0.05f)) {
  2676.             r[k] = c->old_point;
  2677.             n[k] = c->old_norm;
  2678.             k++;
  2679.         }
  2680.         if (k > 0) {
  2681.             c->old_point = r[0];
  2682.             c->old_norm = n[0];
  2683.             BrMatrix34Copy(mat, oldmat);
  2684.             c->omega = c->oldomega;
  2685.             BrMatrix34TApplyV(&c->velocity_car_space, &c->v, mat);
  2686.             memset(&norm, 0, sizeof(norm));
  2687.             collision = 0;
  2688.             for (i = 0; i < k; i++) {
  2689.                 BrVector3Cross(&tau[i], &r[i], &n[i]);
  2690.                 tau[i].v[0] = tau[i].v[0] / c->I.v[0];
  2691.                 tau[i].v[1] = tau[i].v[1] / c->I.v[1];
  2692.                 tau[i].v[2] = tau[i].v[2] / c->I.v[2];
  2693.                 BrVector3Cross(&normal_force, &c->omega, &r[i]);
  2694.                 BrVector3Accumulate(&normal_force, &c->velocity_car_space);
  2695.                 d[i] = -(BrVector3Dot(&n[i], &normal_force));
  2696.                 BrVector3Add(&normal_force, &r[i], &c->cmpos);
  2697.                 BrMatrix34ApplyP(&dir, &normal_force, &mat_to_oldmat);
  2698.                 BrVector3Sub(&dir, &dir, &normal_force);
  2699.                 ts = -(BrVector3Dot(&n[i], &dir) / dt);
  2700.                 if (ts > d[i]) {
  2701.                     d[i] = ts;
  2702.                 }
  2703.                 if (d[i] > 0.0f) {
  2704.                     collision = 1;
  2705.                 }
  2706.             }
  2707.             if (!collision) {
  2708.                 d[0] = 0.5f;
  2709.             }
  2710.             for (i = 0; i < k; i++) {
  2711.                 for (j = 0; j < k; j++) {
  2712.                     BrVector3Cross(&normal_force, &tau[j], &r[i]);
  2713.                     BrVector3InvScale(&norm, &n[j], c->M);
  2714.                     BrVector3Accumulate(&normal_force, &norm);
  2715.                     M.m[i][j] = BrVector3Dot(&n[i], &normal_force);
  2716.                 }
  2717.             }
  2718.             switch (k) {
  2719.             case 1:
  2720.                 ts = SinglePointColl(f, &M, d);
  2721.                 break;
  2722.             case 2:
  2723.                 ts = TwoPointColl(f, &M, d, tau, n);
  2724.                 break;
  2725.             case 3:
  2726.                 d[3] = 0.0f;
  2727.                 ts = ThreePointCollRec(f, &M, d, tau, n, c);
  2728.                 break;
  2729.             case 4:
  2730.                 ts = FourPointColl(f, &M, d, tau, n, c);
  2731.                 break;
  2732.             default:
  2733.                 break;
  2734.             }
  2735.             if (k > 3) {
  2736.                 k = 3;
  2737.             }
  2738.             // if (f[0] > 10.0f || f[1] > 10.0f || f[2] > 10.0f) {
  2739.             //     v31 = 0;
  2740.             // }
  2741.             if (fabsf(ts) <= 0.000001f) {
  2742.                 BrVector3Set(&c->v, 0.f, 0.f, 0.f);
  2743.                 BrVector3Set(&c->omega, 0.f, 0.f, 0.f);
  2744.                 BrVector3Set(&c->oldomega, 0.f, 0.f, 0.f);
  2745.                 return k;
  2746.             }
  2747.             BrVector3Set(&p_vel, 0.f, 0.f, 0.f);
  2748.             BrVector3Set(&dir, 0.f, 0.f, 0.f);
  2749.             BrVector3Set(&friction_force, 0.f, 0.f, 0.f);
  2750.             total_force = 0.f;
  2751.             for (i = 0; i < k; i++) {
  2752.                 if (f[i] < 0.001f) {
  2753.                     f[i] = 0.001f;
  2754.                 }
  2755.                 f[i] = f[i] * 1.001f;
  2756.                 BrVector3Scale(&tau[i], &tau[i], f[i]);
  2757.                 BrVector3Accumulate(&c->omega, &tau[i]);
  2758.                 f[i] = f[i] / c->M;
  2759.                 BrVector3Scale(&n[i], &n[i], f[i]);
  2760.                 BrVector3Accumulate(&p_vel, &n[i]);
  2761.                 BrVector3Add(&bb, &r[i], &c->cmpos);
  2762.                 BrVector3Scale(&bb, &bb, f[i]);
  2763.                 BrVector3Accumulate(&dir, &bb);
  2764.                 total_force = f[i] + total_force;
  2765.             }
  2766.             if (gPinball_factor != 0.0f) {
  2767.                 BrVector3Scale(&p_vel, &p_vel, gPinball_factor);
  2768.                 point_vel = BrVector3LengthSquared(&p_vel);
  2769.                 if (point_vel > 10.0f) {
  2770.                     noise_defeat = 1;
  2771.                     if (c->driver == eDriver_local_human) {
  2772.                         DRS3StartSound(gCar_outlet, 9011);
  2773.                     } else {
  2774.                         DRS3StartSound3D(gCar_outlet, 9011, &c->pos, &gZero_v__car, 1, 255, 0x10000, 0x10000);
  2775.                     }
  2776.                     if (point_vel > 10000.0f) {
  2777.                         BrVector3Normalise(&p_vel, &p_vel);
  2778.                         BrVector3Scale(&p_vel, &p_vel, 100);
  2779.                     }
  2780.                 }
  2781.             }
  2782.             BrVector3Accumulate(&c->velocity_car_space, &p_vel);
  2783.             BrVector3InvScale(&dir, &dir, total_force);
  2784.             BrVector3Cross(&tv, &c->omega, &dir);
  2785.             BrVector3Accumulate(&tv, &c->velocity_car_space);
  2786.             batwick_length = BrVector3Length(&tv);
  2787.             if (!c->collision_flag || (c->collision_flag == 1 && oldk < k)) {
  2788.                 for (i = 0; i < k; i++) {
  2789.                     BrVector3Cross(&vel, &c->omega, &r[i]);
  2790.                     BrVector3Accumulate(&vel, &c->velocity_car_space);
  2791.                     AddFriction(c, &vel, &n[i], &r[i], f[i], &max_friction);
  2792.                     BrVector3Accumulate(&friction_force, &max_friction);
  2793.                     BrVector3Accumulate(&c->velocity_car_space, &max_friction);
  2794.                 }
  2795.             }
  2796.             oldk = k;
  2797.             BrMatrix34ApplyP(&pos, &dir, &c->car_master_actor->t.t.mat);
  2798.             BrVector3InvScale(&pos, &pos, WORLD_SCALE);
  2799.             noise_defeat = 0;
  2800.             BrVector3Add(&normal_force, &friction_force, &p_vel);
  2801.             BrMatrix34ApplyV(&norm, &normal_force, mat);
  2802.             min = dt * 90.0f / 10.0f;
  2803.             max = dt * 110.0f / 10.0f;
  2804.             if (c->last_special_volume != NULL) {
  2805.                 min *= c->last_special_volume->gravity_multiplier;
  2806.                 max *= c->last_special_volume->gravity_multiplier;
  2807.             }
  2808.             if (BrVector3LengthSquared(&c->velocity_car_space) < 0.05f
  2809.                 && 0.1f * total_force > BrVector3Dot(&c->omega, &tv)
  2810.                 && k >= 3
  2811.                 && norm.v[1] > min
  2812.                 && norm.v[1] < max) {
  2813.                 if (c->driver <= eDriver_non_car || fabsf(normal_force.v[2]) <= total_force * 0.9f) {
  2814.                     BrVector3Set(&c->v, 0.f, 0.f, 0.f);
  2815.                     BrVector3Set(&norm, 0.f, 0.f, 0.f);
  2816.                     BrVector3Set(&normal_force, 0.f, 0.f, 0.f);
  2817.                     BrVector3Set(&c->omega, 0.f, 0.f, 0.f);
  2818.                     BrVector3Set(&c->oldomega, 0.f, 0.f, 0.f);
  2819.                     if (c->driver <= eDriver_non_car || car_spec->max_force_rear == 0.0f) {
  2820.                         if (c->driver <= eDriver_non_car) {
  2821.                             PipeSingleNonCar(c);
  2822.                         }
  2823.                         c->doing_nothing_flag = 1;
  2824.                     }
  2825.                 } else {
  2826.                     BrVector3SetFloat(&tv2, 0.0f, -1.0f, 0.0f);
  2827.                     bb.v[0] = mat->m[1][2] * tv2.v[1] - mat->m[1][1] * tv2.v[2];
  2828.                     bb.v[1] = mat->m[1][0] * tv2.v[2] - mat->m[1][2] * tv2.v[0];
  2829.                     bb.v[2] = mat->m[1][1] * tv2.v[0] - mat->m[1][0] * tv2.v[1];
  2830.                     if (BrVector3Dot(&bb, (br_vector3*)&mat->m[0][1]) <= 0.0f) {
  2831.                         c->omega.v[0] = -0.5f;
  2832.                     } else {
  2833.                         c->omega.v[0] = 0.5f;
  2834.                     }
  2835.                 }
  2836.             }
  2837.             BrVector3Accumulate(&c->v, &norm);
  2838.             if (c->driver >= eDriver_net_human) {
  2839.                 BrVector3Scale(&normal_force, &normal_force, gDefensive_powerup_factor[car_spec->power_up_levels[0]]);
  2840.             }
  2841.             if (c->driver < eDriver_net_human) {
  2842.                 BrVector3Scale(&normal_force, &normal_force, 0.01f);
  2843.             } else {
  2844.                 BrVector3Scale(&normal_force, &normal_force, 0.75f);
  2845.             }
  2846.             if (CAR(c)->invulnerable
  2847.                 || (c->driver < eDriver_net_human && (c->driver != eDriver_oppo || PointOutOfSight(&c->pos, 150.0f)))
  2848.                 || ((v_diff = (car_spec->pre_car_col_velocity.v[1] - c->v.v[1]) * gDefensive_powerup_factor[car_spec->power_up_levels[0]]) >= -20.0f)
  2849.                 || CAR(c)->number_of_wheels_on_ground >= 3) {
  2850.                 CrushAndDamageCar(CAR(c), &dir, &normal_force, NULL);
  2851.             } else {
  2852.                 // Cops Special Forces is always stolen if destroyed!
  2853.                 if (c->driver == eDriver_oppo && c->index == 4 && v_diff < -40.0f) {
  2854.                     KnackerThisCar(CAR(c));
  2855.                     StealCar(CAR(c));
  2856.                     v_diff = v_diff * 5.0f;
  2857.                 }
  2858.                 for (i = 0; i < CAR(c)->car_actor_count; i++) {
  2859.                     ts2 = (v_diff + 20.0f) * -0.01f;
  2860.                     TotallySpamTheModel(CAR(c), i, CAR(c)->car_model_actors[i].actor, &CAR(c)->car_model_actors[i].crush_data, ts2);
  2861.                 }
  2862.                 for (i = 0; i < COUNT_OF(CAR(c)->damage_units); i++) {
  2863.                     DamageUnit(CAR(c), i, IRandomPosNeg(5) + (v_diff + 20.0f) * -1.5f);
  2864.                 }
  2865.             }
  2866.             if (!noise_defeat) {
  2867.                 CrashNoise(&norm, &pos, gMaterial_index);
  2868.                 ScrapeNoise(batwick_length, &pos, gMaterial_index);
  2869.             }
  2870.             BrVector3InvScale(&tv, &tv, WORLD_SCALE);
  2871.             BrMatrix34ApplyV(&bb, &tv, &c->car_master_actor->t.t.mat);
  2872.             BrMatrix34ApplyV(&norm, &p_vel, &c->car_master_actor->t.t.mat);
  2873.             CreateSparks(&pos, &bb, &norm, gCurrent_race.material_modifiers[gMaterial_index].sparkiness, car_spec);
  2874.         }
  2875.         return k;
  2876.     } else {
  2877.         if (k != 0) {
  2878.             c->old_point = r[0];
  2879.             c->old_norm = n[0];
  2880.         }
  2881.         return k;
  2882.     }
  2883. }
  2884.  
  2885. // IDA: br_scalar __usercall AddFriction@<ST0>(tCollision_info *c@<EAX>, br_vector3 *vel@<EDX>, br_vector3 *normal_force@<EBX>, br_vector3 *pos@<ECX>, br_scalar total_force, br_vector3 *max_friction)
  2886. br_scalar AddFriction(tCollision_info* c, br_vector3* vel, br_vector3* normal_force, br_vector3* pos, br_scalar total_force, br_vector3* max_friction) {
  2887.     br_vector3 norm;
  2888.     br_vector3 tv;
  2889.     br_vector3 ftau;
  2890.     br_scalar ts;
  2891.     br_scalar point_vel;
  2892.     LOG_TRACE("(%p, %p, %p, %p, %f, %p)", c, vel, normal_force, pos, total_force, max_friction);
  2893.  
  2894.     ts = BrVector3Dot(normal_force, vel) / BrVector3Dot(normal_force, normal_force);
  2895.     BrVector3Scale(&tv, normal_force, ts);
  2896.     BrVector3Sub(vel, vel, &tv);
  2897.     point_vel = total_force * 0.35f * gCurrent_race.material_modifiers[gMaterial_index].car_wall_friction;
  2898.     ts = BrVector3Length(vel);
  2899.     if (ts < 0.0001f) {
  2900.         BrVector3Set(max_friction, 0.f, 0.f, 0.f);
  2901.         return 0.0;
  2902.     }
  2903.     BrVector3InvScale(max_friction, vel, -ts);
  2904.     BrVector3Cross(&ftau, pos, max_friction);
  2905.     BrVector3Scale(&ftau, &ftau, c->M);
  2906.     ftau.v[0] = ftau.v[0] / c->I.v[0];
  2907.     ftau.v[1] = ftau.v[1] / c->I.v[1];
  2908.     ftau.v[2] = ftau.v[2] / c->I.v[2];
  2909.     ts = 1.0 / c->M;
  2910.     norm.v[0] = pos->v[2] * ftau.v[1] - pos->v[1] * ftau.v[2];
  2911.     norm.v[1] = pos->v[0] * ftau.v[2] - pos->v[2] * ftau.v[0];
  2912.     norm.v[2] = pos->v[1] * ftau.v[0] - pos->v[0] * ftau.v[1];
  2913.     ts = max_friction->v[0] * norm.v[0] + max_friction->v[1] * norm.v[1] + max_friction->v[2] * norm.v[2] + ts;
  2914.     if (fabsf(ts) <= 0.0001f) {
  2915.         ts = 0.0f;
  2916.     } else {
  2917.         ts = -BrVector3Dot(max_friction, vel) / ts;
  2918.     }
  2919.     if (ts > point_vel) {
  2920.         ts = point_vel;
  2921.     }
  2922.     BrVector3Scale(max_friction, max_friction, ts);
  2923.     BrVector3Cross(&tv, pos, max_friction);
  2924.     BrVector3Scale(&tv, &tv, c->M);
  2925.     ApplyTorque((tCar_spec*)c, &tv);
  2926.     return point_vel;
  2927. }
  2928.  
  2929. // IDA: void __usercall AddFrictionCarToCar(tCollision_info *car1@<EAX>, tCollision_info *car2@<EDX>, br_vector3 *vel1@<EBX>, br_vector3 *vel2@<ECX>, br_vector3 *normal_force1, br_vector3 *pos1, br_vector3 *pos2, br_scalar total_force, br_vector3 *max_friction)
  2930. void AddFrictionCarToCar(tCollision_info* car1, tCollision_info* car2, br_vector3* vel1, br_vector3* vel2, br_vector3* normal_force1, br_vector3* pos1, br_vector3* pos2, br_scalar total_force, br_vector3* max_friction) {
  2931.     br_vector3 v_diff1;
  2932.     br_vector3 v_diff2;
  2933.     br_vector3 tau1;
  2934.     br_vector3 tau2;
  2935.     br_vector3 tv;
  2936.     br_vector3 tv2;
  2937.     br_vector3 vel2_in_frame_1;
  2938.     br_scalar ts;
  2939.     br_scalar ts2;
  2940.     br_scalar v_diff;
  2941.     br_scalar stopping_impulse;
  2942.     br_scalar total_friction;
  2943.     int i;
  2944.     LOG_TRACE("(%p, %p, %p, %p, %p, %p, %p, %f, %p)", car1, car2, vel1, vel2, normal_force1, pos1, pos2, total_force, max_friction);
  2945.  
  2946.     BrMatrix34TApplyV(&tv, vel2, &car2->oldmat);
  2947.     BrMatrix34ApplyV(&vel2_in_frame_1, &tv, &car1->oldmat);
  2948.     BrVector3Sub(&v_diff1, &vel2_in_frame_1, vel1);
  2949.     ts = BrVector3LengthSquared(normal_force1);
  2950.     ts2 = BrVector3Dot(normal_force1, &v_diff1) / ts;
  2951.     BrVector3Scale(&tv, normal_force1, ts2);
  2952.     BrVector3Sub(&v_diff1, &v_diff1, &tv);
  2953.     v_diff = BrVector3Length(&v_diff1);
  2954.     if (v_diff < 0.01f) {
  2955.         BrVector3Set(max_friction, 0.f, 0.f, 0.f);
  2956.     } else {
  2957.         BrVector3InvScale(&v_diff1, &v_diff1, v_diff);
  2958.         BrMatrix34ApplyV(&tv, &v_diff1, &car1->oldmat);
  2959.         BrMatrix34TApplyV(&v_diff2, &tv, &car2->oldmat);
  2960.         BrVector3Negate(&v_diff2, &v_diff2);
  2961.         BrVector3Cross(&tau1, pos1, &v_diff1);
  2962.         BrVector3Cross(&tau2, pos2, &v_diff2);
  2963.         for (i = 0; i < 3; ++i) {
  2964.             tau1.v[i] /= car1->I.v[i];
  2965.             tau2.v[i] /= car2->I.v[i];
  2966.         }
  2967.         BrVector3Cross(&tv, &tau1, pos1);
  2968.         BrVector3Cross(&tv2, &tau2, pos2);
  2969.         ts = BrVector3Dot(&tv, &v_diff1) + BrVector3Dot(&tv2, &v_diff2) + 1.f / car2->M + 1.f / car1->M;
  2970.         if (ts < 0.0001f) {
  2971.             BrVector3Set(max_friction, 0.f, 0.f, 0.f);
  2972.         } else {
  2973.             stopping_impulse = v_diff / ts;
  2974.             total_friction = total_force * 0.35f;
  2975.             if (stopping_impulse < total_friction) {
  2976.                 total_friction = stopping_impulse;
  2977.             }
  2978.             if (!car1->infinite_mass) {
  2979.                 BrVector3Scale(&tau1, &tau1, total_friction);
  2980.                 BrVector3Accumulate(&car1->omega, &tau1);
  2981.             }
  2982.             if (!car2->infinite_mass) {
  2983.                 BrVector3Scale(&tau2, &tau2, total_friction);
  2984.                 BrVector3Accumulate(&car2->omega, &tau2);
  2985.             }
  2986.             BrVector3Scale(max_friction, &v_diff1, total_friction);
  2987.         }
  2988.     }
  2989. }
  2990.  
  2991. // IDA: void __cdecl ScrapeNoise(br_scalar vel, br_vector3 *position, int material)
  2992. void ScrapeNoise(br_scalar vel, br_vector3* position, int material) {
  2993.     tS3_volume vol;
  2994.     static tS3_sound_tag scrape_tag;
  2995.     static tS3_volume last_scrape_vol;
  2996.     br_vector3 velocity;
  2997.     //br_vector3 position_in_br; // Pierre-Marie Baty -- unused variable
  2998.     LOG_TRACE("(%f, %p, %d)", vel, position, material);
  2999.  
  3000.     vol = vel * 7.0;
  3001.     if (gCurrent_race.material_modifiers[material].scrape_noise_index == -1) {
  3002.         return;
  3003.     }
  3004.     if ((scrape_tag && DRS3SoundStillPlaying(scrape_tag)) || vol <= 30) {
  3005.         if (last_scrape_vol < vol) {
  3006.             DRS3ChangeVolume(scrape_tag, vol);
  3007.             last_scrape_vol = vol;
  3008.         }
  3009.     } else {
  3010.         BrVector3Set(&velocity, 0.f, 0.f, 0.f);
  3011.         scrape_tag = DRS3StartSound3D(
  3012.             gCar_outlet,
  3013.             gMetal_scrape_sound_id__car[IRandomBetween(0, COUNT_OF(gMetal_scrape_sound_id__car) - 1)],
  3014.             position,
  3015.             &velocity,
  3016.             1,
  3017.             vol,
  3018.             IRandomBetween(49152, 81920),
  3019.             0x10000);
  3020.         last_scrape_vol = vol;
  3021.     }
  3022. }
  3023.  
  3024. // IDA: void __usercall SkidNoise(tCar_spec *pC@<EAX>, int pWheel_num@<EDX>, br_scalar pV, int material)
  3025. void SkidNoise(tCar_spec* pC, int pWheel_num, br_scalar pV, int material) {
  3026.     br_vector3 pos;
  3027.     br_vector3 world_pos;
  3028.     br_vector3 wv;
  3029.     br_vector3 wvw;
  3030.     br_scalar ts;
  3031.     static tS3_volume last_skid_vol[2];
  3032.     int i;
  3033.     LOG_TRACE("(%p, %d, %f, %d)", pC, pWheel_num, pV, material);
  3034.  
  3035.     i = IRandomBetween(0, 1);
  3036.     if (gCurrent_race.material_modifiers[material].tyre_noise_index == -1) {
  3037.         return;
  3038.     }
  3039.     if (IRandomBetween(0, 4) != 0) {
  3040.         return;
  3041.     }
  3042.  
  3043.     last_skid_vol[i] = pV * 10.0;
  3044.     if ((pWheel_num & 1) != 0) {
  3045.         pos.v[0] = pC->bounds[1].max.v[0];
  3046.     } else {
  3047.         pos.v[0] = pC->bounds[1].min.v[0];
  3048.     }
  3049.     pos.v[1] = pC->wpos[pWheel_num].v[1] - pC->oldd[pWheel_num];
  3050.     pos.v[2] = pC->wpos[pWheel_num].v[2];
  3051.     BrMatrix34ApplyP(&world_pos, &pos, &pC->car_master_actor->t.t.mat);
  3052.     BrVector3InvScale(&world_pos, &world_pos, WORLD_SCALE);
  3053.     if (!DRS3SoundStillPlaying(gSkid_tag[i]) || (pC->driver == eDriver_local_human && gLast_car_to_skid[i] != pC)) {
  3054.         gSkid_tag[i] = DRS3StartSound3D(
  3055.             gCar_outlet,
  3056.             IRandomBetween(0, 4) + 9000,
  3057.             &world_pos,
  3058.             &pC->velocity_bu_per_sec,
  3059.             1,
  3060.             last_skid_vol[i],
  3061.             IRandomBetween(49152, 81920),
  3062.             0x10000);
  3063.         gLast_car_to_skid[i] = pC;
  3064.     }
  3065.     if (gCurrent_race.material_modifiers[material].smoke_type == 1) {
  3066.         BrVector3Cross(&wv, &pC->omega, &pos);
  3067.         BrVector3Add(&wv, &wv, &pC->velocity_car_space);
  3068.         ts = -(BrVector3Dot(&wv, &pC->road_normal));
  3069.         BrVector3Scale(&wvw, &pC->road_normal, ts);
  3070.         BrVector3Add(&wv, &wv, &wvw);
  3071.         BrMatrix34ApplyV(&wvw, &wv, &pC->car_master_actor->t.t.mat);
  3072.         CreatePuffOfSmoke(&world_pos, &wvw, pV / 25.0, 1.0, 4, pC);
  3073.     }
  3074. }
  3075.  
  3076. // IDA: void __usercall StopSkid(tCar_spec *pC@<EAX>)
  3077. void StopSkid(tCar_spec* pC) {
  3078.     LOG_TRACE("(%p)", pC);
  3079.  
  3080.     if (gLast_car_to_skid[0] == pC) {
  3081.         DRS3StopSound(gSkid_tag[0]);
  3082.     }
  3083.     if (gLast_car_to_skid[1] == pC) {
  3084.         DRS3StopSound(gSkid_tag[1]);
  3085.     }
  3086. }
  3087.  
  3088. // IDA: void __usercall CrashNoise(br_vector3 *pForce@<EAX>, br_vector3 *position@<EDX>, int material@<EBX>)
  3089. void CrashNoise(br_vector3* pForce, br_vector3* position, int material) {
  3090.     static tS3_sound_tag crunch_tag;
  3091.     static tS3_volume last_crunch_vol;
  3092.     tS3_volume vol;
  3093.     br_vector3 velocity;
  3094.     LOG_TRACE("(%p, %p, %d)", pForce, position, material);
  3095.  
  3096.     vol = 60.f * BrVector3Length(pForce);
  3097.     if (gCurrent_race.material_modifiers[material].crash_noise_index != -1) {
  3098.         if (vol >= 256) {
  3099.             vol = 255;
  3100.         }
  3101.         if (crunch_tag == 0 || (!DRS3SoundStillPlaying(crunch_tag) && vol > 30)) {
  3102.             last_crunch_vol = vol;
  3103.             (void)last_crunch_vol;
  3104.             BrVector3Set(&velocity, 0.f, 0.f, 0.f);
  3105.             crunch_tag = DRS3StartSound3D(gCar_outlet,
  3106.                 gMetal_crunch_sound_id__car[IRandomBetween(0, COUNT_OF(gMetal_crunch_sound_id__car) - 1)],
  3107.                 position, &velocity, 1, vol, IRandomBetween(49152, 81920), 0x10000);
  3108.         }
  3109.     }
  3110. }
  3111.  
  3112. // IDA: void __usercall CrushAndDamageCar(tCar_spec *c@<EAX>, br_vector3 *pPosition@<EDX>, br_vector3 *pForce_car_space@<EBX>, tCar_spec *car2@<ECX>)
  3113. void CrushAndDamageCar(tCar_spec* c, br_vector3* pPosition, br_vector3* pForce_car_space, tCar_spec* car2) {
  3114.     br_vector3 force;
  3115.     //br_vector3 force2; // Pierre-Marie Baty -- unused variable
  3116.     br_vector3 position;
  3117.     br_vector3 pos_w;
  3118.     br_vector3 car_to_cam;
  3119.     br_vector3 force_for_bodywork;
  3120.     br_scalar ts;
  3121.     int i;
  3122.     br_matrix34 m;
  3123.     br_scalar fudge_multiplier;
  3124.     LOG_TRACE("(%p, %p, %p, %p)", c, pPosition, pForce_car_space, car2);
  3125.  
  3126.     if (car2 != NULL) {
  3127.         car2->who_last_hit_me = c;
  3128.         c->who_last_hit_me = car2;
  3129.     }
  3130.  
  3131.     if (c->driver == eDriver_non_car_unused_slot || c->driver == eDriver_non_car) {
  3132.         return;
  3133.     }
  3134.     fudge_multiplier = gNet_mode == eNet_mode_none || gNet_softness[gCurrent_net_game->type] == 1.0f ? 1.0f : gNet_softness[gCurrent_net_game->type];
  3135.     BrVector3Sub(&car_to_cam, &c->pos, (br_vector3*)gCamera_to_world.m[3]);
  3136.     ts = BrVector3LengthSquared(&car_to_cam);
  3137.     if (c->driver == eDriver_oppo && ts > 200.0f) {
  3138.         return;
  3139.     }
  3140.     if (car2 != NULL) {
  3141.         if (car2->driver > eDriver_non_car) {
  3142.             TwoCarsHitEachOther(c, car2);
  3143.         }
  3144.         if (c->driver >= eDriver_net_human) {
  3145.             fudge_multiplier = gDefensive_powerup_factor[c->power_up_levels[0]] * 1.2f * fudge_multiplier;
  3146.         }
  3147.         if (car2->driver >= eDriver_net_human) {
  3148.             if (gNet_mode != eNet_mode_none
  3149.                 && (gCurrent_net_game->type == eNet_game_type_fight_to_death || gCurrent_net_game->type == eNet_game_type_car_crusher)) {
  3150.                 fudge_multiplier = gOffensive_powerup_factor[car2->power_up_levels[2]] * gNet_offensive[gCurrent_net_game->type] * car2->damage_multiplier * fudge_multiplier;
  3151.             } else {
  3152.                 fudge_multiplier = gOffensive_powerup_factor[car2->power_up_levels[2]] * car2->damage_multiplier * fudge_multiplier;
  3153.             }
  3154.         }
  3155.         if (c->driver == eDriver_oppo && car2->driver == eDriver_oppo) {
  3156.             fudge_multiplier = fudge_multiplier * 0.2f;
  3157.         }
  3158.         if (car2->driver <= eDriver_non_car) {
  3159.             car2 = NULL;
  3160.         } else {
  3161.             fudge_multiplier /= ((car2->car_model_actors[car2->principal_car_actor].crush_data.softness_factor + 0.7f) / 0.7f);
  3162.         }
  3163.     }
  3164.     BrVector3InvScale(&position, pPosition, WORLD_SCALE);
  3165.     BrVector3Scale(&force, pForce_car_space, fudge_multiplier * 0.03f);
  3166.     ts = BrVector3LengthSquared(&force);
  3167.     if (c->driver <= eDriver_non_car || !c->invulnerable) {
  3168.         c->damage_magnitude_accumulator += ts;
  3169.     }
  3170.     if (c->driver < eDriver_net_human) {
  3171.         BrVector3Scale(&force_for_bodywork, &force, 1.5f);
  3172.     } else {
  3173.         if (c->collision_mass_multiplier != 1.0) {
  3174.             BrVector3InvScale(&force, &force, c->collision_mass_multiplier);
  3175.         }
  3176.         BrVector3Scale(&force_for_bodywork, &force, 0.5f);
  3177.         if (c->driver == eDriver_local_human) {
  3178.             DoPratcamHit(&force);
  3179.         }
  3180.     }
  3181.     if (gNet_mode == eNet_mode_host && (gCurrent_net_game->type == eNet_game_type_tag || gCurrent_net_game->type == eNet_game_type_foxy) && car2 != NULL
  3182.         && c->driver >= eDriver_net_human && car2->driver >= eDriver_net_human) {
  3183.         if (gNet_players[gIt_or_fox].car == c && car2->knackered) {
  3184.             CarInContactWithItOrFox(NetPlayerFromCar(car2));
  3185.         } else if (gNet_players[gIt_or_fox].car == car2 && !c->knackered) {
  3186.             CarInContactWithItOrFox(NetPlayerFromCar(c));
  3187.         }
  3188.     }
  3189.     if (gNet_mode != eNet_mode_client || car2 == NULL) {
  3190.         DamageSystems(c, &position, &force, car2 != NULL);
  3191.     }
  3192.     if (c->driver <= eDriver_non_car || !c->invulnerable) {
  3193.         for (i = 0; i < c->car_actor_count; i++) {
  3194.             if (c->car_model_actors[i].min_distance_squared != -1.0f || (pForce_car_space->v[1] >= 0.0f && pForce_car_space->v[2] >= 0.0f)) {
  3195.                 CrushModel(c, i, c->car_model_actors[i].actor, &position, &force_for_bodywork, &c->car_model_actors[i].crush_data);
  3196.             }
  3197.         }
  3198.         if (car2 && car2->driver == eDriver_local_human && ts > 0.003f) {
  3199.             PipeSingleCarIncident(ts, c, &position);
  3200.         }
  3201.         if (!car2 && c->driver == eDriver_local_human && ts > 0.003f) {
  3202.             BrMatrix34Copy(&m, &c->car_master_actor->t.t.mat);
  3203.             m.m[3][0] /= WORLD_SCALE;
  3204.             m.m[3][1] /= WORLD_SCALE;
  3205.             m.m[3][2] /= WORLD_SCALE;
  3206.             BrMatrix34ApplyP(&pos_w, &position, &m);
  3207.             PipeSingleWallIncident(ts, &pos_w);
  3208.         }
  3209.     }
  3210.     if (car2 != NULL && car2->driver == eDriver_local_human && ts > 0.003f) {
  3211.         PipeSingleCarIncident(ts, c, &position);
  3212.     }
  3213.     if (car2 == NULL && c->driver == eDriver_local_human && ts > 0.003f) {
  3214.         BrMatrix34Copy(&m, &c->car_master_actor->t.t.mat);
  3215.         m.m[3][0] /= WORLD_SCALE;
  3216.         m.m[3][1] /= WORLD_SCALE;
  3217.         m.m[3][2] /= WORLD_SCALE;
  3218.         BrMatrix34ApplyP(&pos_w, &position, &m);
  3219.         PipeSingleWallIncident(ts, &pos_w);
  3220.     }
  3221. }
  3222.  
  3223. // IDA: int __usercall ExpandBoundingBox@<EAX>(tCar_spec *c@<EAX>)
  3224. int ExpandBoundingBox(tCar_spec* c) {
  3225.     br_scalar min_z;
  3226.     br_scalar max_z;
  3227.     br_scalar dist;
  3228.     br_vector3 tv;
  3229.     br_vector3 old_pos;
  3230.     int l;
  3231.     //br_matrix34 mat; // Pierre-Marie Baty -- unused variable
  3232.     LOG_TRACE("(%p)", c);
  3233.  
  3234.     l = 0;
  3235.     min_z = c->bounds[1].min.v[2];
  3236.     max_z = c->bounds[1].max.v[2];
  3237.     old_pos = *(br_vector3*)&c->oldmat.m[3][0];
  3238.     CrushBoundingBox(c, 0);
  3239.     for (l = 0; l < 5; l++) {
  3240.         if (TestForCarInSensiblePlace(c)) {
  3241.             break;
  3242.         }
  3243.         if (c->old_point.v[2] <= 0.0f) {
  3244.             dist = min_z - c->bounds[1].min.v[2];
  3245.         } else {
  3246.             dist = c->bounds[1].max.v[2] - max_z;
  3247.         }
  3248.         if (dist >= 0.0f) {
  3249.             dist += 0.005f;
  3250.             BrVector3Scale(&c->old_norm, &c->old_norm, dist);
  3251.             BrMatrix34ApplyV(&tv, &c->old_norm, &c->car_master_actor->t.t.mat);
  3252.             c->oldmat.m[3][0] += tv.v[0];
  3253.             c->oldmat.m[3][1] += tv.v[1];
  3254.             c->oldmat.m[3][2] += tv.v[2];
  3255.             l++;
  3256.         } else {
  3257.             l = 5;
  3258.         }
  3259.     }
  3260.     if (l < 5) {
  3261.         return 1;
  3262.     }
  3263.     *(br_vector3*)&c->oldmat.m[3][0] = old_pos;
  3264.     c->bounds[1].min.v[2] = min_z;
  3265.     c->bounds[1].max.v[2] = max_z;
  3266.     if (c->driver == eDriver_local_human) {
  3267.         NewTextHeadupSlot(eHeadupSlot_misc, 0, 1000, -4, GetMiscString(kMiscString_RepairObstructed));
  3268.     }
  3269.     return 0;
  3270. }
  3271.  
  3272. // IDA: void __usercall CrushBoundingBox(tCar_spec *c@<EAX>, int crush_only@<EDX>)
  3273. void CrushBoundingBox(tCar_spec* c, int crush_only) {
  3274.     br_vector3 min;
  3275.     br_vector3 max;
  3276.     int i;
  3277.     br_actor* actor;
  3278.     LOG_TRACE("(%p, %d)", c, crush_only);
  3279.  
  3280.     if (c == NULL) {
  3281.         return;
  3282.     }
  3283.     actor = c->car_model_actors[c->principal_car_actor].actor;
  3284.     max.v[0] = c->wpos[2].v[2] - c->non_driven_wheels_circum / 6.2f;
  3285.     min.v[0] = c->driven_wheels_circum / 6.2f + c->wpos[0].v[2];
  3286.     max.v[0] /= WORLD_SCALE;
  3287.     min.v[0] /= WORLD_SCALE;
  3288.     for (i = 0; i < actor->model->nvertices; i++) {
  3289.         if (actor->model->vertices[i].p.v[2] < max.v[0]) {
  3290.             max.v[0] = actor->model->vertices[i].p.v[2];
  3291.         }
  3292.         if (actor->model->vertices[i].p.v[2] > min.v[0]) {
  3293.             min.v[0] = actor->model->vertices[i].p.v[2];
  3294.         }
  3295.     }
  3296.     max.v[0] *= WORLD_SCALE;
  3297.     min.v[0] *= WORLD_SCALE;
  3298.     if (crush_only) {
  3299.         if (c->bounds[1].min.v[2] > max.v[0]) {
  3300.             max.v[0] = c->bounds[1].min.v[2];
  3301.         }
  3302.         if (c->bounds[1].max.v[2] < min.v[0]) {
  3303.             min.v[0] = c->bounds[1].max.v[2];
  3304.         }
  3305.     } else {
  3306.         if (c->max_bounds[1].min.v[2] > max.v[0]) {
  3307.             max.v[0] = c->max_bounds[1].min.v[2];
  3308.         }
  3309.         if (c->max_bounds[1].max.v[2] < min.v[0]) {
  3310.             min.v[0] = c->max_bounds[1].max.v[2];
  3311.         }
  3312.     }
  3313.     c->bounds[1].min.v[2] = max.v[0];
  3314.     c->bounds[1].max.v[2] = min.v[0];
  3315.     for (i = 0; i < c->extra_point_num; i++) {
  3316.         if (c->max_bounds[1].max.v[2] + 0.01f >= c->original_extra_points_z[i] && c->max_bounds[1].min.v[2] - 0.01f <= c->original_extra_points_z[i]) {
  3317.             if (c->original_extra_points_z[i] > min.v[0]) {
  3318.                 c->extra_points[i].v[2] = min.v[0];
  3319.             } else if (c->original_extra_points_z[i] >= max.v[0]) {
  3320.                 c->extra_points[i].v[2] = c->original_extra_points_z[i];
  3321.             } else {
  3322.                 c->extra_points[i].v[2] = max.v[0];
  3323.             }
  3324.             if (c->extra_points[i].v[2] > min.v[0]) {
  3325.                 c->extra_points[i].v[2] = min.v[0];
  3326.             }
  3327.             if (c->extra_points[i].v[2] < max.v[0]) {
  3328.                 c->extra_points[i].v[2] = max.v[0];
  3329.             }
  3330.         } else {
  3331.             c->extra_points[i].v[2] = c->original_extra_points_z[i];
  3332.         }
  3333.     }
  3334. }
  3335.  
  3336. // IDA: void __cdecl AddCollPoint(br_scalar dist, br_vector3 *p, br_vector3 *norm, br_vector3 *r, br_vector3 *n, br_vector3 *dir, int num, tCollision_info *c)
  3337. void AddCollPoint(br_scalar dist, br_vector3* p, br_vector3* norm, br_vector3* r, br_vector3* n, br_vector3* dir, int num, tCollision_info* c) {
  3338.     static br_scalar d[4];
  3339.     int i;
  3340.     int furthest;
  3341.     LOG_TRACE("(%f, %p, %p, %p, %p, %p, %d, %p)", dist, p, norm, r, n, dir, num, c);
  3342.  
  3343.     if (num < 4) {
  3344.         d[num] = dist;
  3345.         n[num] = *norm;
  3346.         BrVector3Sub(&r[num], p, &c->cmpos);
  3347.         return;
  3348.     }
  3349.     furthest = 0;
  3350.     for (i = 1; i < 4; i++) {
  3351.         if (d[furthest] < d[i]) {
  3352.             furthest = i;
  3353.         }
  3354.     }
  3355.     if (d[furthest] >= dist) {
  3356.         num = furthest;
  3357.         d[num] = dist;
  3358.         n[num] = *norm;
  3359.         BrVector3Sub(&r[num], p, &c->cmpos);
  3360.     }
  3361. }
  3362.  
  3363. // IDA: br_scalar __usercall SinglePointColl@<ST0>(br_scalar *f@<EAX>, br_matrix4 *m@<EDX>, br_scalar *d@<EBX>)
  3364. br_scalar SinglePointColl(br_scalar* f, br_matrix4* m, br_scalar* d) {
  3365.     LOG_TRACE("(%p, %p, %p)", f, m, d);
  3366.  
  3367.     f[0] = d[0] / m->m[0][0];
  3368.     if (f[0] < 0.0f) {
  3369.         f[0] = 0.f;
  3370.     }
  3371.     return fabsf(m->m[0][0]);
  3372. }
  3373.  
  3374. // IDA: br_scalar __usercall TwoPointColl@<ST0>(br_scalar *f@<EAX>, br_matrix4 *m@<EDX>, br_scalar *d@<EBX>, br_vector3 *tau@<ECX>, br_vector3 *n)
  3375. br_scalar TwoPointColl(br_scalar* f, br_matrix4* m, br_scalar* d, br_vector3* tau, br_vector3* n) {
  3376.     br_scalar ts;
  3377.     LOG_TRACE("(%p, %p, %p, %p, %p)", f, m, d, tau, n);
  3378.  
  3379.     ts = m->m[1][1] * m->m[0][0] - m->m[0][1] * m->m[1][0];
  3380.  
  3381.     if (fabsf(ts) >= 0.000001f) {
  3382.         f[0] = (m->m[1][1] * d[0] - m->m[0][1] * d[1]) / ts;
  3383.         f[1] = (m->m[1][0] * d[0] - m->m[0][0] * d[1]) / -ts;
  3384.     }
  3385.     if (f[1] < 0.0f || fabs(ts) < 0.000001f) {
  3386.         ts = SinglePointColl(f, m, d);
  3387.         f[1] = 0.0f;
  3388.     } else if (f[0] < 0.0f) {
  3389.         m->m[0][0] = m->m[1][1];
  3390.         tau[0] = tau[1];
  3391.         n[0] = n[1];
  3392.         d[0] = d[1];
  3393.         ts = SinglePointColl(f, m, d);
  3394.         f[1] = 0.0;
  3395.     }
  3396.     return fabsf(ts);
  3397. }
  3398.  
  3399. // IDA: br_scalar __usercall DrMatrix4Inverse@<ST0>(br_matrix4 *mi@<EAX>, br_matrix4 *mc@<EDX>)
  3400. br_scalar DrMatrix4Inverse(br_matrix4* mi, br_matrix4* mc) {
  3401.     LOG_TRACE("(%p, %p)", mi, mc);
  3402.  
  3403.     return BrMatrix4Inverse(mi, mc);
  3404. }
  3405.  
  3406. // IDA: br_scalar __usercall ThreePointColl@<ST0>(br_scalar *f@<EAX>, br_matrix4 *m@<EDX>, br_scalar *d@<EBX>)
  3407. br_scalar ThreePointColl(br_scalar* f, br_matrix4* m, br_scalar* d) {
  3408.     br_matrix4 mc;
  3409.     br_matrix4 mi;
  3410.     br_scalar ts;
  3411.     LOG_TRACE("(%p, %p, %p)", f, m, d);
  3412.  
  3413.     BrMatrix4Copy(&mc, m);
  3414.     memset(&mc.m[2][3], 0, 16);
  3415.     mc.m[1][3] = 0.0f;
  3416.     mc.m[0][3] = 0.0f;
  3417.     mc.m[3][3] = 1.0f;
  3418.     ts = DrMatrix4Inverse(&mi, &mc);
  3419.     BrMatrix4TApply((br_vector4*)f, (br_vector4*)d, &mi);
  3420.     f[3] = 0.0f;
  3421.     return fabs(ts);
  3422. }
  3423.  
  3424. // IDA: br_scalar __usercall ThreePointCollRec@<ST0>(br_scalar *f@<EAX>, br_matrix4 *m@<EDX>, br_scalar *d@<EBX>, br_vector3 *tau@<ECX>, br_vector3 *n, tCollision_info *c)
  3425. br_scalar ThreePointCollRec(br_scalar* f, br_matrix4* m, br_scalar* d, br_vector3* tau, br_vector3* n, tCollision_info* c) {
  3426.     int i;
  3427.     int j;
  3428.     br_scalar ts;
  3429.     LOG_TRACE("(%p, %p, %p, %p, %p, %p)", f, m, d, tau, n, c);
  3430.  
  3431.     ts = ThreePointColl(f, m, d);
  3432.     if (f[0] >= 0.0f && f[1] >= 0.0f && f[2] >= 0.0f && ts >= 0.000001f) {
  3433.         c->infinite_mass = 256;
  3434.         return ts;
  3435.     }
  3436.     if (ts < 0.000001f) {
  3437.         i = 0;
  3438.         j = 1;
  3439.     } else if (f[0] < 0.0f) {
  3440.         i = 1;
  3441.         j = 2;
  3442.     } else if (f[1] < 0.0f) {
  3443.         i = 0;
  3444.         j = 2;
  3445.     } else if (f[2] < 0.0f) {
  3446.         i = 0;
  3447.         j = 1;
  3448.     } else {
  3449.         return 0.0f;
  3450.     }
  3451.     m->m[0][0] = ((float*)m->m)[5 * i];
  3452.     m->m[1][0] = m->m[j][i];
  3453.     m->m[0][1] = m->m[i][j];
  3454.     m->m[1][1] = ((float*)m->m)[5 * j];
  3455.     tau[0] = tau[i];
  3456.     tau[1] = tau[j];
  3457.     n[0] = n[i];
  3458.     n[1] = n[j];
  3459.     d[0] = d[i];
  3460.     d[1] = d[j];
  3461.     ts = TwoPointColl(f, m, d, tau, n);
  3462.     f[2] = 0.0f;
  3463.     return ts;
  3464. }
  3465.  
  3466. // IDA: br_scalar __usercall FourPointColl@<ST0>(br_scalar *f@<EAX>, br_matrix4 *m@<EDX>, br_scalar *d@<EBX>, br_vector3 *tau@<ECX>, br_vector3 *n, tCollision_info *c)
  3467. br_scalar FourPointColl(br_scalar* f, br_matrix4* m, br_scalar* d, br_vector3* tau, br_vector3* n, tCollision_info* c) {
  3468.     int i;
  3469.     int j;
  3470.     int l;
  3471.     br_scalar ts;
  3472.     LOG_TRACE("(%p, %p, %p, %p, %p, %p)", f, m, d, tau, n, c);
  3473.  
  3474.     ts = ThreePointColl(f, m, d);
  3475.     if (f[0] < 0.0 || f[1] < 0.0 || f[2] < 0.0 || ts < 0.000001) {
  3476.         if (ts < 0.000001) {
  3477.             j = 3;
  3478.         } else if (f[0] < 0.0) {
  3479.             j = 0;
  3480.         } else if (f[1] >= 0.0) {
  3481.             j = 2;
  3482.         } else {
  3483.             j = 1;
  3484.         }
  3485.         for (i = j; i < 3; ++i) {
  3486.             for (l = 0; l < 4; ++l) {
  3487.                 m->m[i][l] = m->m[i + 1][l];
  3488.             }
  3489.             d[i] = d[i + 1];
  3490.             tau[i] = tau[i + 1];
  3491.             n[i] = n[i + 1];
  3492.             d[i] = d[i + 1];
  3493.         }
  3494.         for (i = j; i < 3; ++i) {
  3495.             for (l = 0; l < 3; ++l) {
  3496.                 m->m[l][i] = m->m[l][i + 1];
  3497.             }
  3498.         }
  3499.         return ThreePointCollRec(f, m, d, tau, n, c);
  3500.     } else {
  3501.         c->infinite_mass = 256;
  3502.         return ts;
  3503.     }
  3504. }
  3505.  
  3506. // IDA: void __usercall MultiFindFloorInBoxM(int pNum_rays@<EAX>, br_vector3 *a@<EDX>, br_vector3 *b@<EBX>, br_vector3 *nor@<ECX>, br_scalar *d, tCar_spec *c, int *mat_ref)
  3507. void MultiFindFloorInBoxM(int pNum_rays, br_vector3* a, br_vector3* b, br_vector3* nor, br_scalar* d, tCar_spec* c, int* mat_ref) {
  3508.     br_vector3 aa[4];
  3509.     br_vector3 bb;
  3510.     int i;
  3511.     LOG_TRACE("(%d, %p, %p, %p, %p, %p, %p)", pNum_rays, a, b, nor, d, c, mat_ref);
  3512.  
  3513.     for (i = 0; i < pNum_rays; i++) {
  3514.         aa[i].v[0] = a[i].v[0] / WORLD_SCALE;
  3515.         aa[i].v[1] = a[i].v[1] / WORLD_SCALE;
  3516.         aa[i].v[2] = a[i].v[2] / WORLD_SCALE;
  3517.         d[i] = 2.0;
  3518.     }
  3519.     bb.v[0] = b->v[0] / WORLD_SCALE;
  3520.     bb.v[1] = b->v[1] / WORLD_SCALE;
  3521.     bb.v[2] = b->v[2] / WORLD_SCALE;
  3522.     MultiFindFloorInBoxBU(pNum_rays, aa, &bb, nor, d, c, mat_ref);
  3523. }
  3524.  
  3525. // IDA: void __usercall MultiFindFloorInBoxBU(int pNum_rays@<EAX>, br_vector3 *a@<EDX>, br_vector3 *b@<EBX>, br_vector3 *nor@<ECX>, br_scalar *d, tCar_spec *c, int *mat_ref)
  3526. void MultiFindFloorInBoxBU(int pNum_rays, br_vector3* a, br_vector3* b, br_vector3* nor, br_scalar* d, tCar_spec* c, int* mat_ref) {
  3527.     br_vector3 nor2;
  3528.     int i;
  3529.     int j;
  3530.     int l;
  3531.     br_scalar dist[4];
  3532.     tFace_ref* face_ref;
  3533.     LOG_TRACE("(%d, %p, %p, %p, %p, %p, %p)", pNum_rays, a, b, nor, d, c, mat_ref);
  3534.  
  3535.     for (i = c->box_face_start; i < c->box_face_end; i++) {
  3536.         face_ref = &gFace_list__car[i];
  3537.         if (!gEliminate_faces || (face_ref->flags & 0x80) == 0x0) {
  3538.             MultiRayCheckSingleFace(pNum_rays, face_ref, a, b, &nor2, dist);
  3539.             for (j = 0; j < pNum_rays; ++j) {
  3540.                 if (d[j] > dist[j]) {
  3541.                     d[j] = dist[j];
  3542.                     nor[j] = nor2;
  3543.                     l = *gFace_list__car[i].material->identifier - 47;
  3544.                     if (l >= 0 && l < 11) {
  3545.                         mat_ref[j] = l;
  3546.                     }
  3547.                 }
  3548.             }
  3549.         }
  3550.     }
  3551. }
  3552.  
  3553. // IDA: void __usercall findfloor(br_vector3 *a@<EAX>, br_vector3 *b@<EDX>, br_vector3 *nor@<EBX>, br_scalar *d@<ECX>)
  3554. void findfloor(br_vector3* a, br_vector3* b, br_vector3* nor, br_scalar* d) {
  3555.     br_material* material;
  3556.     br_vector3 aa;
  3557.     br_vector3 bb;
  3558.     LOG_TRACE("(%p, %p, %p, %p)", a, b, nor, d);
  3559.  
  3560.     BrVector3InvScale(&aa, a, WORLD_SCALE);
  3561.     BrVector3InvScale(&bb, b, WORLD_SCALE);
  3562.     FindFace(&aa, &bb, nor, d, &material);
  3563. }
  3564.  
  3565. // IDA: int __usercall FindFloorInBoxM@<EAX>(br_vector3 *a@<EAX>, br_vector3 *b@<EDX>, br_vector3 *nor@<EBX>, br_scalar *d@<ECX>, tCollision_info *c)
  3566. int FindFloorInBoxM(br_vector3* a, br_vector3* b, br_vector3* nor, br_scalar* d, tCollision_info* c) {
  3567.     br_vector3 aa;
  3568.     br_vector3 bb;
  3569.     LOG_TRACE("(%p, %p, %p, %p, %p)", a, b, nor, d, c);
  3570.  
  3571.     aa.v[0] = a->v[0] / WORLD_SCALE;
  3572.     aa.v[1] = a->v[1] / WORLD_SCALE;
  3573.     aa.v[2] = a->v[2] / WORLD_SCALE;
  3574.     bb.v[0] = b->v[0] / WORLD_SCALE;
  3575.     bb.v[1] = b->v[1] / WORLD_SCALE;
  3576.     bb.v[2] = b->v[2] / WORLD_SCALE;
  3577.     return FindFloorInBoxBU(&aa, &bb, nor, d, c);
  3578. }
  3579.  
  3580. // IDA: int __usercall FindFloorInBoxBU@<EAX>(br_vector3 *a@<EAX>, br_vector3 *b@<EDX>, br_vector3 *nor@<EBX>, br_scalar *d@<ECX>, tCollision_info *c)
  3581. int FindFloorInBoxBU(br_vector3* a, br_vector3* b, br_vector3* nor, br_scalar* d, tCollision_info* c) {
  3582.     br_vector3 nor2;
  3583.     int i;
  3584.     int j;
  3585.     br_scalar dist;
  3586.     tFace_ref* face_ref;
  3587.     LOG_TRACE("(%p, %p, %p, %p, %p)", a, b, nor, d, c);
  3588.  
  3589. #if defined(DETHRACE_FIX_BUGS)
  3590.     j = 0; // added to keep compiler happy
  3591. #endif
  3592.     *d = 2.0;
  3593.     for (i = c->box_face_start; i < c->box_face_end; i++) {
  3594.         face_ref = &gFace_list__car[i];
  3595.         if (!gEliminate_faces || SLOBYTE(face_ref->flags) >= 0) {
  3596.             CheckSingleFace(face_ref, a, b, &nor2, &dist);
  3597.             if (*d > dist) {
  3598.                 *d = dist;
  3599.                 j = i;
  3600.                 BrVector3Copy(nor, &nor2);
  3601.             }
  3602.         }
  3603.     }
  3604.     if (*d >= 2.f) {
  3605.         return 0;
  3606.     }
  3607.     i = gFace_list__car[j].material->identifier[0] - ('0' - 1);
  3608.     if (i < 0 || i >= 11) {
  3609.         return 0;
  3610.     } else {
  3611.         return i;
  3612.     }
  3613. }
  3614.  
  3615. // IDA: int __usercall FindFloorInBoxBU2@<EAX>(br_vector3 *a@<EAX>, br_vector3 *b@<EDX>, br_vector3 *nor@<EBX>, br_scalar *d@<ECX>, tCollision_info *c)
  3616. int FindFloorInBoxBU2(br_vector3* a, br_vector3* b, br_vector3* nor, br_scalar* d, tCollision_info* c) {
  3617.     br_vector3 nor2;
  3618.     br_vector3 tv;
  3619.     int i;
  3620.     int j;
  3621.     br_scalar dist;
  3622.     tFace_ref* face_ref;
  3623.     LOG_TRACE("(%p, %p, %p, %p, %p)", a, b, nor, d, c);
  3624.  
  3625. #if defined(DETHRACE_FIX_BUGS)
  3626.     j = 0; // added to keep compiler happy
  3627. #endif
  3628.     *d = 2.f;
  3629.     for (i = c->box_face_start; i < c->box_face_end; i++) {
  3630.         face_ref = &gFace_list__car[i];
  3631.         if (!gEliminate_faces || SLOBYTE(face_ref->flags) >= 0) {
  3632.             CheckSingleFace(face_ref, a, b, &nor2, &dist);
  3633.             if (*d > dist) {
  3634.                 if (face_ref->material->user == DOUBLESIDED_USER_FLAG || (face_ref->material->flags & (BR_MATF_ALWAYS_VISIBLE | BR_MATF_TWO_SIDED)) != 0) {
  3635.                     BrVector3Sub(&tv, &c->pos, a);
  3636.                     if (BrVector3Dot(&tv, &nor2) >= 0.f) {
  3637.                         *d = dist;
  3638.                         j = i;
  3639.                         BrVector3Copy(nor, &nor2);
  3640.                     }
  3641.                 } else {
  3642.                     *d = dist;
  3643.                     j = i;
  3644.                     BrVector3Copy(nor, &nor2);
  3645.                 }
  3646.             }
  3647.         }
  3648.         face_ref++;
  3649.     }
  3650.     if (*d >= 2.f) {
  3651.         return 0;
  3652.     }
  3653.     i = gFace_list__car[j].material->identifier[0] - ('0' - 1);
  3654.     if (i < 0 || i >= 11) {
  3655.         return 0;
  3656.     } else {
  3657.         return i;
  3658.     }
  3659. }
  3660.  
  3661. // IDA: int __usercall FindFloorInBoxM2@<EAX>(br_vector3 *a@<EAX>, br_vector3 *b@<EDX>, br_vector3 *nor@<EBX>, br_scalar *d@<ECX>, tCollision_info *c)
  3662. int FindFloorInBoxM2(br_vector3* a, br_vector3* b, br_vector3* nor, br_scalar* d, tCollision_info* c) {
  3663.     br_vector3 aa;
  3664.     br_vector3 bb;
  3665.     LOG_TRACE("(%p, %p, %p, %p, %p)", a, b, nor, d, c);
  3666.  
  3667.     aa.v[0] = a->v[0] / WORLD_SCALE;
  3668.     aa.v[1] = a->v[1] / WORLD_SCALE;
  3669.     aa.v[2] = a->v[2] / WORLD_SCALE;
  3670.     bb.v[0] = b->v[0] / WORLD_SCALE;
  3671.     bb.v[1] = b->v[1] / WORLD_SCALE;
  3672.     bb.v[2] = b->v[2] / WORLD_SCALE;
  3673.     return FindFloorInBoxBU2(&aa, &bb, nor, d, c);
  3674. }
  3675.  
  3676. // IDA: int __usercall BoxFaceIntersect@<EAX>(br_bounds *pB@<EAX>, br_matrix34 *pM@<EDX>, br_matrix34 *pMold@<EBX>, br_vector3 *pPoint_list@<ECX>, br_vector3 *pNorm_list, br_scalar *pDist_list, int pMax_pnts, tCollision_info *c)
  3677. int BoxFaceIntersect(br_bounds* pB, br_matrix34* pM, br_matrix34* pMold, br_vector3* pPoint_list, br_vector3* pNorm_list, br_scalar* pDist_list, int pMax_pnts, tCollision_info* c) {
  3678.     br_vector3 p[3];
  3679.     br_vector3 tv;
  3680.     br_vector3 pos;
  3681.     br_bounds bnds;
  3682.     int i;
  3683.     int j;
  3684.     int n;
  3685.     int flag;
  3686.     int m;
  3687.     tFace_ref* f_ref;
  3688.     //br_face* face; // Pierre-Marie Baty -- unused variable
  3689.     LOG_TRACE("(%p, %p, %p, %p, %p, %p, %d, %p)", pB, pM, pMold, pPoint_list, pNorm_list, pDist_list, pMax_pnts, c);
  3690.  
  3691.     n = 0;
  3692.     BrVector3InvScale(&bnds.min, &pB->min, WORLD_SCALE);
  3693.     BrVector3InvScale(&bnds.max, &pB->max, WORLD_SCALE);
  3694.     BrVector3InvScale(&pos, (br_vector3*)pM->m[3], WORLD_SCALE);
  3695.     BrVector3InvScale((br_vector3*)pMold->m[3], (br_vector3*)pMold->m[3], WORLD_SCALE);
  3696.  
  3697.     for (i = c->box_face_start; i < c->box_face_end && i < c->box_face_start + 50; i++) {
  3698.         f_ref = &gFace_list__car[i];
  3699.         if (SLOBYTE(f_ref->flags) >= 0 && f_ref->material->identifier[0] != '!') {
  3700.             BrVector3Sub(&tv, &f_ref->v[0], &pos);
  3701.             BrMatrix34TApplyV(&p[0], &tv, pM);
  3702.             BrVector3Sub(&tv, &f_ref->v[1], &pos);
  3703.             BrMatrix34TApplyV(&p[1], &tv, pM);
  3704.             BrVector3Sub(&tv, &f_ref->v[2], &pos);
  3705.             BrMatrix34TApplyV(&p[2], &tv, pM);
  3706.             j = n;
  3707.             if ((f_ref->flags & 1) == 0) {
  3708.                 n += AddEdgeCollPoints(&p[0], &p[1], &bnds, pMold, pPoint_list, pNorm_list, n, pMax_pnts, c);
  3709.             }
  3710.             if ((f_ref->flags & 2) == 0) {
  3711.                 n += AddEdgeCollPoints(&p[1], &p[2], &bnds, pMold, pPoint_list, pNorm_list, n, pMax_pnts, c);
  3712.             }
  3713.             if ((f_ref->flags & 4) == 0) {
  3714.                 n += AddEdgeCollPoints(&p[2], &p[0], &bnds, pMold, pPoint_list, pNorm_list, n, pMax_pnts, c);
  3715.             }
  3716.             if (n > j) {
  3717.                 if (gMaterial_index == 0) {
  3718.                     m = f_ref->material->identifier[0] - '/';
  3719.                     if (m > 0 && m < 11) {
  3720.                         gMaterial_index = m;
  3721.                     }
  3722.                 }
  3723.                 while (j < n) {
  3724.                     BrVector3Scale(&pPoint_list[j], &pPoint_list[j], WORLD_SCALE);
  3725.                     BrVector3Sub(&pPoint_list[j], &pPoint_list[j], &c->cmpos);
  3726.                     j++;
  3727.                 }
  3728.             }
  3729.         }
  3730.     }
  3731.     if (n) {
  3732.         m = 0;
  3733.         for (i = 0; i < n - 1; i++) {
  3734.             flag = 1;
  3735.             for (j = i + 1; j < n; j++) {
  3736.                 if (fabsf(pPoint_list[i].v[0] - pPoint_list[j].v[0]) <= 0.001f
  3737.                     && fabsf(pPoint_list[i].v[1] - pPoint_list[j].v[1]) <= 0.001f
  3738.                     && fabsf(pPoint_list[i].v[2] - pPoint_list[j].v[2]) <= 0.001f) {
  3739.                     flag = 0;
  3740.                     break;
  3741.                 }
  3742.             }
  3743.             if (flag) {
  3744.                 BrVector3Copy(&pPoint_list[m], &pPoint_list[i]);
  3745.                 m++;
  3746.             }
  3747.         }
  3748.         BrVector3Copy(&pPoint_list[m], &pPoint_list[n - 1]);
  3749.         n = m + 1;
  3750.     }
  3751.     BrVector3Scale((br_vector3*)pMold->m[3], (br_vector3*)pMold->m[3], WORLD_SCALE);
  3752.     return n;
  3753. }
  3754.  
  3755. // IDA: int __usercall AddEdgeCollPoints@<EAX>(br_vector3 *p1@<EAX>, br_vector3 *p2@<EDX>, br_bounds *pB@<EBX>, br_matrix34 *pMold@<ECX>, br_vector3 *pPoint_list, br_vector3 *pNorm_list, int n, int pMax_pnts, tCollision_info *c)
  3756. int AddEdgeCollPoints(br_vector3* p1, br_vector3* p2, br_bounds* pB, br_matrix34* pMold, br_vector3* pPoint_list, br_vector3* pNorm_list, int n, int pMax_pnts, tCollision_info* c) {
  3757.     br_vector3 op1;
  3758.     br_vector3 op2;
  3759.     br_vector3 a;
  3760.     br_vector3 b;
  3761.     br_vector3 edge;
  3762.     br_vector3 hp1;
  3763.     br_vector3 hp2;
  3764.     br_vector3 hp3;
  3765.     int plane1;
  3766.     int plane2;
  3767.     int plane3;
  3768.     int d;
  3769.     LOG_TRACE("(%p, %p, %p, %p, %p, %p, %d, %d, %p)", p1, p2, pB, pMold, pPoint_list, pNorm_list, n, pMax_pnts, c);
  3770.  
  3771.     //float scale; // Pierre-Marie Baty -- unused variable
  3772.  
  3773.     plane1 = LineBoxColl(p1, p2, pB, &hp1);
  3774.     if (plane1 == 0) {
  3775.         return 0;
  3776.     }
  3777.     if (n + 2 > pMax_pnts) {
  3778.         return 0;
  3779.     }
  3780.     plane2 = LineBoxColl(p2, p1, pB, &hp2);
  3781.     if (plane2 == 0) {
  3782.         return 0;
  3783.     }
  3784.     if (plane1 != 8 && plane2 != 8 && (plane1 ^ plane2) == 4) {
  3785.         BrVector3Add(&op1, &hp2, &hp1);
  3786.         BrVector3Scale(&op1, &op1, .5f);
  3787.         BrMatrix34ApplyP(&op2, &op1, pMold);
  3788.         plane3 = LineBoxColl(&op2, &op1, pB, &hp3);
  3789.         if (plane3 == 8) {
  3790.             return 0;
  3791.         }
  3792.         GetBoundsEdge(&pPoint_list[n], &edge, pB, plane1, plane3, &op2, &hp1, &hp2, c->collision_flag);
  3793.         GetBoundsEdge(&pPoint_list[n + 1], &edge, pB, plane2, plane3, &op2, &hp1, &hp2, c->collision_flag);
  3794.         GetPlaneNormal(&pNorm_list[n], plane3);
  3795.         BrVector3Copy(&pNorm_list[n + 1], &pNorm_list[n]);
  3796.         return 2;
  3797.     } else if (plane1 == 8 && plane2 != 8) {
  3798.         BrMatrix34ApplyP(&a, p1, pMold);
  3799.         plane3 = LineBoxColl(&a, p1, pB, &hp3);
  3800.         if (plane3 == 8) {
  3801.             return 0;
  3802.         }
  3803.         BrVector3Copy(&pPoint_list[n], &hp3);
  3804.         GetPlaneNormal(&pNorm_list[n], plane2);
  3805.         if (plane2 == plane3 || (plane3 ^ plane2) == 4) {
  3806.             return 1;
  3807.         }
  3808.         GetBoundsEdge(&pPoint_list[n + 1], &edge, pB, plane2, plane3, p1, &hp2, &hp3, c->collision_flag);
  3809.         BrVector3Sub(&op1, p1, p2);
  3810.         BrVector3Cross(&pNorm_list[n + 1], &edge, &op1);
  3811.         BrVector3Normalise(&pNorm_list[n + 1], &pNorm_list[n + 1]);
  3812.         d = (plane2 - 1) & 3;
  3813.         if ((pNorm_list[n + 1].v[d] < 0.f) == (plane2 & 4) >> 2) {
  3814.             BrVector3Negate(&pNorm_list[n + 1], &pNorm_list[n + 1]);
  3815.         }
  3816.         BrVector3Copy(&op1, &pNorm_list[n + 1]);
  3817.         BrMatrix34ApplyV(&pNorm_list[n + 1], &op1, pMold);
  3818.         return 2;
  3819.     } else if (plane2 == 8 && plane1 != 8) {
  3820.         BrMatrix34ApplyP(&b, p2, pMold);
  3821.         plane3 = LineBoxColl(&b, p2, pB, &hp3);
  3822.         if (plane3 == 8) {
  3823.             return 0;
  3824.         }
  3825.         pPoint_list[n] = hp3;
  3826.         GetPlaneNormal(&pNorm_list[n], plane1);
  3827.         if (plane1 == plane3 || (plane3 ^ plane1) == 4) {
  3828.             return 1;
  3829.         }
  3830.         GetBoundsEdge(&pPoint_list[n + 1], &edge, pB, plane1, plane3, p2, &hp1, &hp3, c->collision_flag);
  3831.         BrVector3Sub(&op1, p1, p2);
  3832.         BrVector3Cross(&pNorm_list[n + 1], &edge, &op1);
  3833.         BrVector3Normalise(&pNorm_list[n + 1], &pNorm_list[n + 1]);
  3834.         d = (plane1 - 1) & 3;
  3835.         if ((pNorm_list[n + 1].v[d] < 0.f) == (plane1 & 4) >> 2) {
  3836.             BrVector3Negate(&pNorm_list[n + 1], &pNorm_list[n + 1]);
  3837.         }
  3838.         BrVector3Copy(&op1, &pNorm_list[n + 1]);
  3839.         BrMatrix34ApplyV(&pNorm_list[n + 1], &op1, pMold);
  3840.         return 2;
  3841.     } else if (plane1 != 8 && plane2 != 8) {
  3842.         BrVector3Add(&op1, &hp2, &hp1);
  3843.         BrVector3Scale(&op1, &op1, .5f);
  3844.         BrMatrix34ApplyP(&op2, &op1, pMold);
  3845.         plane3 = LineBoxColl(&op2, &op1, pB, &hp3);
  3846.         if (plane3 == 8 || plane3 == 0) {
  3847.             return 0;
  3848.         }
  3849.         if (plane1 == plane3 || plane2 == plane3) {
  3850.             GetBoundsEdge(&pPoint_list[n], &edge, pB, plane1, plane2, &op2, &hp1, &hp2, c->collision_flag);
  3851.             BrVector3Sub(&op1, &hp1, &hp2);
  3852.             BrVector3Cross(&op2, &edge, &op1);
  3853.             BrVector3Normalise(&pNorm_list[n], &op2);
  3854.             BrVector3Add(&op1, &pB->max, &pB->min);
  3855.             BrVector3Scale(&op1, &op1, .5f);
  3856.             BrVector3Sub(&op1, &pPoint_list[n], &op1);
  3857.             if (BrVector3Dot(&pNorm_list[n], &op1) > 0.f) {
  3858.                 BrVector3Negate(&pNorm_list[n], &pNorm_list[n]);
  3859.             }
  3860.             BrVector3Copy(&op1, &pNorm_list[n]);
  3861.             BrMatrix34ApplyV(&pNorm_list[n], &op1, pMold);
  3862.             return 1;
  3863.         } else {
  3864.             GetBoundsEdge(&pPoint_list[n], &edge, pB, plane1, plane3, &hp3, &hp1, &hp2, c->collision_flag);
  3865.             GetBoundsEdge(&pPoint_list[n + 1], &edge, pB, plane2, plane3, &hp3, &hp1, &hp2, c->collision_flag);
  3866.             GetPlaneNormal(&pNorm_list[n], plane3);
  3867.             BrVector3Copy(&pNorm_list[n + 1], &pNorm_list[n]);
  3868.             return 2;
  3869.         }
  3870.     } else if (plane1 == 8 && plane2 == 8) {
  3871.         BrMatrix34ApplyP(&op1, p1, pMold);
  3872.         plane3 = LineBoxColl(&op1, p1, pB, &pPoint_list[n]);
  3873.         GetPlaneNormal(&pNorm_list[n], plane3);
  3874.         d = n + (plane3 != 8);
  3875.         BrMatrix34ApplyP(&op1, p2, pMold);
  3876.         plane3 = LineBoxColl(&op1, p2, pB, &pPoint_list[d]);
  3877.         GetPlaneNormal(&pNorm_list[d], plane3);
  3878.         return (n != d) + (plane3 != 8);
  3879.     } else {
  3880.         return 0;
  3881.     }
  3882. }
  3883.  
  3884. // IDA: void __usercall GetPlaneNormal(br_vector3 *n@<EAX>, int p@<EDX>)
  3885. void GetPlaneNormal(br_vector3* n, int p) {
  3886.     int d;
  3887.     LOG_TRACE("(%p, %d)", n, p);
  3888.  
  3889.     d = (p - 1) & 3;
  3890.     BrVector3Set(n, 0.f, 0.f, 0.f);
  3891.     if ((p & 4) != 0) {
  3892.         n->v[d] = 1.0f;
  3893.     } else {
  3894.         n->v[d] = -1.0f;
  3895.     }
  3896. }
  3897.  
  3898. // IDA: int __usercall GetBoundsEdge@<EAX>(br_vector3 *pos@<EAX>, br_vector3 *edge@<EDX>, br_bounds *pB@<EBX>, int plane1@<ECX>, int plane2, br_vector3 *a, br_vector3 *b, br_vector3 *c, int flag)
  3899. int GetBoundsEdge(br_vector3* pos, br_vector3* edge, br_bounds* pB, int plane1, int plane2, br_vector3* a, br_vector3* b, br_vector3* c, int flag) {
  3900.     int d1;
  3901.     int d2;
  3902.     int d3;
  3903.     br_vector3 n;
  3904.     br_vector3 p;
  3905.     br_vector3 q;
  3906.     LOG_TRACE("(%p, %p, %p, %d, %d, %p, %p, %p, %d)", pos, edge, pB, plane1, plane2, a, b, c, flag);
  3907.  
  3908.     d1 = (plane1 - 1) & 3;
  3909.     d2 = (plane2 - 1) & 3;
  3910.     BrVector3Sub(&n, b, a);
  3911.     BrVector3Sub(&p, c, a);
  3912.     BrVector3Cross(&q, &n, &p);
  3913.     if ((plane1 & 4) != 0) {
  3914.         pos->v[d1] = pB->min.v[d1];
  3915.     } else {
  3916.         pos->v[d1] = pB->max.v[d1];
  3917.     }
  3918.     if ((plane2 & 4) != 0) {
  3919.         pos->v[d2] = pB->min.v[d2];
  3920.     } else {
  3921.         pos->v[d2] = pB->max.v[d2];
  3922.     }
  3923.     d3 = 3 - d1 - d2;
  3924.     edge->v[d1] = 0.f;
  3925.     edge->v[d2] = 0.f;
  3926.     edge->v[d3] = 1.f;
  3927.     if ((flag & 1) != 0) {
  3928.         pos->v[d3] = (c->v[d3] + b->v[d3]) / 2.f;
  3929.     } else {
  3930.         pos->v[d3] = a->v[d3] - ((pos->v[d2] - a->v[d2]) * q.v[d2] + (pos->v[d1] - a->v[d1]) * q.v[d1]) / q.v[d3];
  3931.     }
  3932.     return 1;
  3933. }
  3934.  
  3935. // IDA: void __usercall oldMoveOurCar(tU32 pTime_difference@<EAX>)
  3936. void oldMoveOurCar(tU32 pTime_difference) {
  3937.     //br_vector3 thrust_vector; // Pierre-Marie Baty -- unused variable
  3938.     //br_matrix34 direction_matrix; // Pierre-Marie Baty -- unused variable
  3939.     //br_matrix34 old_mat; // Pierre-Marie Baty -- unused variable
  3940.     //double rotate_amount; // Pierre-Marie Baty -- unused variable
  3941.     //br_scalar nearest_y_above; // Pierre-Marie Baty -- unused variable
  3942.     //br_scalar nearest_y_below; // Pierre-Marie Baty -- unused variable
  3943.     //br_scalar speed; // Pierre-Marie Baty -- unused variable
  3944.     //int below_face_index; // Pierre-Marie Baty -- unused variable
  3945.     //int above_face_index; // Pierre-Marie Baty -- unused variable
  3946.     //br_model* below_model; // Pierre-Marie Baty -- unused variable
  3947.     //br_model* above_model; // Pierre-Marie Baty -- unused variable
  3948.     LOG_TRACE("(%d)", pTime_difference);
  3949.     NOT_IMPLEMENTED();
  3950. }
  3951.  
  3952. // IDA: void __cdecl ToggleCollisionDetection()
  3953. void ToggleCollisionDetection(void) {
  3954.     LOG_TRACE("()");
  3955.     NOT_IMPLEMENTED();
  3956. }
  3957.  
  3958. // IDA: void __cdecl CancelPendingCunningStunt()
  3959. void CancelPendingCunningStunt(void) {
  3960.     LOG_TRACE("()");
  3961.  
  3962.     gQuite_wild_end = 0;
  3963.     gQuite_wild_start = 0;
  3964.     gOn_me_wheels_start = 0;
  3965.     gWoz_upside_down_at_all = 0;
  3966.     gWild_start = 0;
  3967. }
  3968.  
  3969. // IDA: float __cdecl frac(float pN)
  3970. float frac(float pN) {
  3971.     LOG_TRACE("(%f)", pN);
  3972.  
  3973.     return pN - (float)(int)pN;
  3974. }
  3975.  
  3976. // IDA: void __usercall SetAmbientPratCam(tCar_spec *pCar@<EAX>)
  3977. void SetAmbientPratCam(tCar_spec* pCar) {
  3978.     br_scalar vcs_x;
  3979.     br_scalar vcs_y;
  3980.     br_scalar vcs_z;
  3981.     br_scalar abs_vcs_x;
  3982.     br_scalar abs_vcs_y;
  3983.     br_scalar abs_vcs_z;
  3984.     br_scalar abs_omega_x;
  3985.     br_scalar abs_omega_y;
  3986.     br_scalar abs_omega_z;
  3987.     tU32 the_time;
  3988.     static tU32 last_time_on_ground;
  3989.     LOG_TRACE("(%p)", pCar);
  3990.  
  3991.     if (gRace_finished) {
  3992.         return;
  3993.     }
  3994.     the_time = GetTotalTime();
  3995.     if (pCar->number_of_wheels_on_ground != 0) {
  3996.         last_time_on_ground = the_time;
  3997.     }
  3998.     vcs_x = pCar->velocity_car_space.v[0];
  3999.     vcs_y = pCar->velocity_car_space.v[1];
  4000.     vcs_z = pCar->velocity_car_space.v[2];
  4001.     abs_vcs_x = fabsf(vcs_x);
  4002.     abs_vcs_y = fabsf(vcs_y);
  4003.     abs_vcs_z = fabsf(vcs_z);
  4004.     abs_omega_x = fabsf(pCar->omega.v[0]);
  4005.     abs_omega_y = fabsf(pCar->omega.v[1]);
  4006.     abs_omega_z = fabsf(pCar->omega.v[2]);
  4007.  
  4008.     if (abs_omega_x > 4.5f || abs_omega_z > 4.5f) {
  4009.         ChangeAmbientPratcam(9);
  4010.     } else if (abs_omega_y > 4.5f) {
  4011.         ChangeAmbientPratcam(12);
  4012.     } else if (abs_omega_x > 3.f || abs_omega_z > 3.f) {
  4013.         ChangeAmbientPratcam(8);
  4014.     } else if (abs_omega_y > 3.f) {
  4015.         ChangeAmbientPratcam(11);
  4016.     } else if (pCar->car_master_actor->t.t.mat.m[1][1] < 0.1f) {
  4017.         ChangeAmbientPratcam(44);
  4018.     } else if (abs_vcs_y > abs_vcs_z && abs_vcs_y > abs_vcs_x && vcs_y < -.004f) {
  4019.         ChangeAmbientPratcam(6);
  4020.     } else if (the_time - last_time_on_ground > 500) {
  4021.         ChangeAmbientPratcam(5);
  4022.     } else if (abs_vcs_x > abs_vcs_z && vcs_x > .001f) {
  4023.         ChangeAmbientPratcam(26);
  4024.     } else if (abs_vcs_x > abs_vcs_z && vcs_x < -.001f) {
  4025.         ChangeAmbientPratcam(25);
  4026.     } else if (abs_omega_x > 1.5f || abs_omega_z > 1.5f) {
  4027.         ChangeAmbientPratcam(7);
  4028.     } else if (abs_omega_y > 1.5f) {
  4029.         ChangeAmbientPratcam(10);
  4030.     } else if (abs_vcs_z > .01f) {
  4031.         ChangeAmbientPratcam(3);
  4032.     } else if (abs_vcs_z > .004f) {
  4033.         ChangeAmbientPratcam(2);
  4034.     } else if (abs_vcs_z > .0015f) {
  4035.         ChangeAmbientPratcam(1);
  4036.     } else {
  4037.         ChangeAmbientPratcam(0);
  4038.     }
  4039. }
  4040.  
  4041. // IDA: void __usercall MungeCarGraphics(tU32 pFrame_period@<EAX>)
  4042. void MungeCarGraphics(tU32 pFrame_period) {
  4043.     int i;
  4044.     //int j; // Pierre-Marie Baty -- unused variable
  4045.     int update_mat;
  4046.     int spinning_wildly;
  4047.     int spinning_mildly;
  4048.     int car_count;
  4049.     int oily_count;
  4050.     int car;
  4051.     int cat;
  4052.     //int new_special_screen; // Pierre-Marie Baty -- unused variable
  4053.     tCar_spec* the_car;
  4054.     br_scalar distance_from_camera;
  4055.     br_scalar car_x;
  4056.     br_scalar car_z;
  4057.     br_scalar oily_size;
  4058.     br_scalar car_radius;
  4059.     br_scalar abs_omega_x;
  4060.     br_scalar abs_omega_y;
  4061.     br_scalar abs_omega_z;
  4062.     float wheel_speed;
  4063.     //float speed_mph; // Pierre-Marie Baty -- unused variable
  4064.     //float rev_angle; // Pierre-Marie Baty -- unused variable
  4065.     float sine_angle;
  4066.     float raw_revs;
  4067.     float rev_reducer;
  4068.     //tSpecial_screen* the_special_screen; // Pierre-Marie Baty -- unused variable
  4069.     br_material* the_material;
  4070.     tU32 the_time;
  4071.     br_actor* oily_actor;
  4072.     LOG_TRACE("(%d)", pFrame_period);
  4073.  
  4074.     if (gNet_mode != eNet_mode_none
  4075.         && ((gCurrent_net_game->type == eNet_game_type_foxy && gThis_net_player_index == gIt_or_fox)
  4076.             || (gCurrent_net_game->type == eNet_game_type_tag && gThis_net_player_index != gIt_or_fox))) {
  4077.         gProgram_state.current_car.power_up_levels[1] = 0;
  4078.     }
  4079.     SetAmbientPratCam(&gProgram_state.current_car);
  4080.     if (gProgram_state.cockpit_on) {
  4081.         SwitchCarActor(&gProgram_state.current_car, gProgram_state.current_car.car_actor_count - 1);
  4082.     } else {
  4083.         SwitchCarActor(&gProgram_state.current_car, gProgram_state.current_car.car_actor_count - 2);
  4084.     }
  4085.  
  4086.     the_time = PDGetTotalTime();
  4087.     for (cat = eVehicle_self; cat <= eVehicle_rozzer; cat++) {
  4088.         if (cat == eVehicle_self) {
  4089.             car_count = 1;
  4090.         } else {
  4091.             car_count = GetCarCount(cat);
  4092.         }
  4093.         for (car = 0; car < car_count; car++) {
  4094.             if (cat == eVehicle_self) {
  4095.                 the_car = &gProgram_state.current_car;
  4096.             } else {
  4097.                 the_car = GetCarSpec(cat, car);
  4098.             }
  4099.             the_car->car_master_actor->render_style = (the_car->driver == eDriver_local_human || !PointOutOfSight(&the_car->pos, gYon_squared)) ? BR_RSTYLE_DEFAULT : BR_RSTYLE_NONE;
  4100.         }
  4101.     }
  4102.     for (car = 0; car < gNum_active_cars; car++) {
  4103.         the_car = gActive_car_list[car];
  4104.         if (the_car->car_master_actor->render_style != BR_RSTYLE_NONE) {
  4105.             car_x = the_car->car_master_actor->t.t.translate.t.v[0];
  4106.             car_z = the_car->car_master_actor->t.t.translate.t.v[2];
  4107.             the_car->shadow_intersection_flags = 0;
  4108.             oily_count = GetOilSpillCount();
  4109.             for (i = 0; i < oily_count; i++) {
  4110.                 GetOilSpillDetails(i, &oily_actor, &oily_size);
  4111.                 if (oily_actor != NULL) {
  4112.                     car_radius = the_car->bounds[1].max.v[2] / WORLD_SCALE * 1.5f;
  4113.                     if (oily_actor->t.t.translate.t.v[0] - oily_size < car_x + car_radius
  4114.                         && oily_actor->t.t.translate.t.v[0] + oily_size > car_x - car_radius
  4115.                         && oily_actor->t.t.translate.t.v[2] - oily_size < car_z + car_radius
  4116.                         && oily_actor->t.t.translate.t.v[2] + oily_size > car_z - car_radius) {
  4117.                         the_car->shadow_intersection_flags |= 1 << i;
  4118.                     }
  4119.                 }
  4120.             }
  4121.             if (the_car->driver < eDriver_net_human && (!gAction_replay_mode || !ReplayIsPaused())) {
  4122.                 if (gCountdown) {
  4123.                     sine_angle = FRandomBetween(0.4f, 1.6f) * ((double)GetTotalTime() / ((double)gCountdown * 100.0f));
  4124.                     sine_angle = frac(sine_angle) * 360.0f;
  4125.                     sine_angle = FastScalarSin(sine_angle);
  4126.                     raw_revs = the_car->red_line * fabsf(sine_angle);
  4127.                     rev_reducer = (11.0 - (double)gCountdown) / 10.0;
  4128.                     the_car->revs = rev_reducer * raw_revs;
  4129.                 } else {
  4130.                     the_car->revs = (the_car->speedo_speed / 0.003
  4131.                                         - (double)(int)(the_car->speedo_speed / 0.003))
  4132.                             * (double)(the_car->red_line - 800)
  4133.                         + 800.0;
  4134.                 }
  4135.             }
  4136.             for (i = 0; i < the_car->number_of_steerable_wheels; i++) {
  4137.                 ControlBoundFunkGroove(the_car->steering_ref[i], the_car->steering_angle);
  4138.             }
  4139.             for (i = 0; i < COUNT_OF(the_car->rf_sus_ref); i++) {
  4140.                 ControlBoundFunkGroove(the_car->rf_sus_ref[i], the_car->rf_sus_position);
  4141.                 if ((i & 1) != 0) {
  4142.                     ControlBoundFunkGroove(the_car->lf_sus_ref[i], -the_car->lf_sus_position);
  4143.                 } else {
  4144.                     ControlBoundFunkGroove(the_car->lf_sus_ref[i], the_car->lf_sus_position);
  4145.                 }
  4146.             }
  4147.             for (i = 0; i < COUNT_OF(the_car->rr_sus_ref); i++) {
  4148.                 ControlBoundFunkGroove(the_car->rr_sus_ref[i], the_car->rr_sus_position);
  4149.                 if ((i & 1) != 0) {
  4150.                     ControlBoundFunkGroove(the_car->lr_sus_ref[i], -the_car->lr_sus_position);
  4151.                 } else {
  4152.                     ControlBoundFunkGroove(the_car->lr_sus_ref[i], the_car->lr_sus_position);
  4153.                 }
  4154.             }
  4155.             if (!gAction_replay_mode || !ReplayIsPaused()) {
  4156.                 wheel_speed = -(the_car->speedo_speed / the_car->non_driven_wheels_circum * (float)gFrame_period);
  4157.                 ControlBoundFunkGroovePlus(the_car->non_driven_wheels_spin_ref_1, wheel_speed);
  4158.                 ControlBoundFunkGroovePlus(the_car->non_driven_wheels_spin_ref_2, wheel_speed);
  4159.                 ControlBoundFunkGroovePlus(the_car->non_driven_wheels_spin_ref_3, wheel_speed);
  4160.                 ControlBoundFunkGroovePlus(the_car->non_driven_wheels_spin_ref_4, wheel_speed);
  4161.                 if (the_car->driver >= eDriver_net_human) {
  4162.                     if (the_car->gear) {
  4163.                         wheel_speed = -(the_car->revs
  4164.                             * the_car->speed_revs_ratio
  4165.                             / 6900.f
  4166.                             * (double)the_car->gear
  4167.                             / the_car->driven_wheels_circum
  4168.                             * (double)gFrame_period);
  4169.                     } else if (the_car->keys.brake) {
  4170.                         wheel_speed = 0.0;
  4171.                     } else {
  4172.                         wheel_speed = -(the_car->speedo_speed / the_car->driven_wheels_circum * (double)gFrame_period);
  4173.                     }
  4174.                 }
  4175.                 ControlBoundFunkGroovePlus(the_car->driven_wheels_spin_ref_1, wheel_speed);
  4176.                 ControlBoundFunkGroovePlus(the_car->driven_wheels_spin_ref_2, wheel_speed);
  4177.                 ControlBoundFunkGroovePlus(the_car->driven_wheels_spin_ref_3, wheel_speed);
  4178.                 ControlBoundFunkGroovePlus(the_car->driven_wheels_spin_ref_4, wheel_speed);
  4179.             }
  4180.             if (gAction_replay_mode) {
  4181.                 MungeSpecialVolume((tCollision_info*)the_car);
  4182.             } else if (the_car->driver == eDriver_local_human) {
  4183.                 abs_omega_x = (fabsf(the_car->I.v[0]) + 3.3f) / 2.0f * fabsf(the_car->omega.v[0]);
  4184.                 abs_omega_y = (fabsf(the_car->I.v[1]) + 3.57f) / 2.0f * fabsf(the_car->omega.v[1]);
  4185.                 abs_omega_z = (fabsf(the_car->I.v[2]) + 0.44f) / 2.0f * fabsf(the_car->omega.v[2]);
  4186.                 spinning_wildly = abs_omega_x > 26.4f || abs_omega_y > 49.98f || abs_omega_z > 3.52f;
  4187.                 if (spinning_wildly && the_time - gLast_cunning_stunt > 10000) {
  4188.                     if (!gWild_start
  4189.                         || (the_car->last_special_volume != NULL && the_car->last_special_volume->gravity_multiplier != 1.f)) {
  4190.                         gWild_start = the_time;
  4191.                     } else if (the_time - gWild_start >= 500) {
  4192.                         DoFancyHeadup(kFancyHeadupCunningStuntBonus);
  4193.                         EarnCredits(gCunning_stunt_bonus[gProgram_state.skill_level]);
  4194.                         gLast_cunning_stunt = the_time;
  4195.                         gOn_me_wheels_start = 0;
  4196.                         gQuite_wild_end = 0;
  4197.                         gQuite_wild_start = 0;
  4198.                         gWoz_upside_down_at_all = 0;
  4199.                     }
  4200.                 } else {
  4201.                     gWild_start = 0;
  4202.                     spinning_mildly = abs_omega_x > 1.65f || abs_omega_z > 0.22f;
  4203.                     if (the_car->number_of_wheels_on_ground <= 3) {
  4204.                         gOn_me_wheels_start = 0;
  4205.                         if (the_car->number_of_wheels_on_ground || !spinning_mildly) {
  4206.                             gQuite_wild_end = the_time;
  4207.                         } else {
  4208.                             if (!gQuite_wild_start) {
  4209.                                 gQuite_wild_start = the_time;
  4210.                             }
  4211.                             if (the_car->car_master_actor->t.t.mat.m[1][1] < -0.8f) {
  4212.                                 gWoz_upside_down_at_all = the_time;
  4213.                             }
  4214.                         }
  4215.                     } else {
  4216.                         if (!gQuite_wild_end) {
  4217.                             gQuite_wild_end = the_time;
  4218.                         }
  4219.                         if (!gQuite_wild_start
  4220.                             || the_time - gLast_cunning_stunt <= 10000
  4221.                             || gQuite_wild_end - gQuite_wild_start < 2000
  4222.                             || gWoz_upside_down_at_all < (int) gQuite_wild_start // Pierre-Marie Baty -- added type cast
  4223.                             || gWoz_upside_down_at_all > (int) gQuite_wild_end // Pierre-Marie Baty -- added type cast
  4224.                             || (!gOn_me_wheels_start && the_time - gQuite_wild_end >= 300)) {
  4225.                             gQuite_wild_end = 0;
  4226.                             gQuite_wild_start = 0;
  4227.                             gOn_me_wheels_start = 0;
  4228.                             gWoz_upside_down_at_all = 0;
  4229.                         } else if (!gOn_me_wheels_start) {
  4230.                             gOn_me_wheels_start = the_time;
  4231.                         } else if (the_time - gOn_me_wheels_start > 500
  4232.                             && (the_car->last_special_volume == NULL
  4233.                                 || the_car->last_special_volume->gravity_multiplier == 1.0f)) {
  4234.                             DoFancyHeadup(kFancyHeadupCunningStuntBonus);
  4235.                             EarnCredits(gCunning_stunt_bonus[gProgram_state.skill_level]);
  4236.                             gLast_cunning_stunt = PDGetTotalTime();
  4237.                             gQuite_wild_end = 0;
  4238.                             gQuite_wild_start = 0;
  4239.                             gOn_me_wheels_start = 0;
  4240.                             gWoz_upside_down_at_all = 0;
  4241.                         }
  4242.                     }
  4243.                 }
  4244.             }
  4245.             if (the_car->driver != eDriver_local_human && the_car->car_model_variable) {
  4246.                 distance_from_camera = Vector3DistanceSquared(&the_car->car_master_actor->t.t.translate.t,
  4247.                                            (br_vector3*)gCamera_to_world.m[3])
  4248.                     / gCar_simplification_factor[gGraf_spec_index][gCar_simplification_level];
  4249.                 if (gNet_mode != eNet_mode_none && gNet_players[gIt_or_fox].car == the_car) {
  4250.                     distance_from_camera = 0.f;
  4251.                 }
  4252.                 for (i = 0; i < the_car->car_actor_count; i++) {
  4253.                     if (the_car->car_model_actors[i].min_distance_squared <= distance_from_camera) {
  4254.                         SwitchCarActor(the_car, i);
  4255.                         break;
  4256.                     }
  4257.                 }
  4258.             }
  4259.             if (the_car->screen_material != NULL) {
  4260.                 the_material = NULL;
  4261.                 if (the_car->last_special_volume != NULL && the_car->last_special_volume->screen_material != NULL) {
  4262.                     if (!gAction_replay_mode && the_car->last_special_volume != gDefault_water_spec_vol) {
  4263.                         the_material = the_car->last_special_volume->screen_material;
  4264.                     } else if (gProgram_state.current_depth_effect.type == eDepth_effect_fog) {
  4265.                         the_material = gProgram_state.standard_screen_fog;
  4266.                     } else if (gProgram_state.current_depth_effect.sky_texture != NULL) {
  4267.                         the_material = gProgram_state.standard_screen;
  4268.                     } else {
  4269.                         the_material = gProgram_state.standard_screen_dark;
  4270.                     }
  4271.                 } else {
  4272.                     if (gProgram_state.current_depth_effect.type == eDepth_effect_fog) {
  4273.                         the_material = gProgram_state.standard_screen_fog;
  4274.                     } else if (gProgram_state.current_depth_effect.sky_texture != NULL) {
  4275.                         the_material = gProgram_state.standard_screen;
  4276.                     } else {
  4277.                         the_material = gProgram_state.standard_screen_dark;
  4278.                     }
  4279.                 }
  4280.                 update_mat = 0;
  4281.                 if (the_material != NULL && the_car->screen_material_source != the_material) {
  4282.                     the_car->screen_material->flags = the_material->flags;
  4283.                     the_car->screen_material->ka = the_material->ka;
  4284.                     the_car->screen_material->kd = the_material->kd;
  4285.                     the_car->screen_material->ks = the_material->ks;
  4286.                     the_car->screen_material->power = the_material->power;
  4287.                     the_car->screen_material->index_base = the_material->index_base;
  4288.                     the_car->screen_material->index_range = the_material->index_range;
  4289.                     the_car->screen_material->colour_map = the_material->colour_map;
  4290.  
  4291.                     the_car->screen_material->map_transform = the_material->map_transform;
  4292.                     the_car->screen_material->index_shade = gRender_shade_table;
  4293.                     the_car->screen_material_source = the_material;
  4294.                     update_mat = 1;
  4295.                 }
  4296.                 if (the_car->screen_material->colour_map != NULL) {
  4297.                     the_car->screen_material->map_transform.m[2][0] = fmodf(car_x, 1.f);
  4298.                     the_car->screen_material->map_transform.m[2][1] = fmodf(car_z, 1.f);
  4299.                     if (!update_mat) {
  4300.                         BrMaterialUpdate(the_car->screen_material, BR_MATU_MAP_TRANSFORM);
  4301.                     }
  4302.                 }
  4303.                 if (update_mat) {
  4304.                     BrMaterialUpdate(the_car->screen_material, BR_MATU_ALL);
  4305.                 }
  4306.             }
  4307.         }
  4308.     }
  4309. }
  4310.  
  4311. // IDA: void __cdecl ResetCarScreens()
  4312. void ResetCarScreens(void) {
  4313.     int cat;
  4314.     int car_count;
  4315.     int i;
  4316.     tCar_spec* the_car;
  4317.     LOG_TRACE("()");
  4318.  
  4319.     for (cat = eVehicle_self; cat < eVehicle_drone; cat++) {
  4320.         car_count = (cat == eVehicle_self) ? 1 : GetCarCount(cat);
  4321.         for (i = 0; i < car_count; i++) {
  4322.             the_car = (cat == eVehicle_self) ? &gProgram_state.current_car : GetCarSpec(cat, i);
  4323.             the_car->last_special_volume = NULL;
  4324.         }
  4325.     }
  4326.     MungeCarGraphics(gFrame_period);
  4327. }
  4328.  
  4329. // IDA: tCar_spec* __cdecl GetRaceLeader()
  4330. tCar_spec* GetRaceLeader(void) {
  4331.     //int i; // Pierre-Marie Baty -- unused variable
  4332.     //int score; // Pierre-Marie Baty -- unused variable
  4333.     //tCar_spec* car; // Pierre-Marie Baty -- unused variable
  4334.     LOG_TRACE("()");
  4335.     NOT_IMPLEMENTED();
  4336. }
  4337.  
  4338. // IDA: void __cdecl AmIGettingBoredWatchingCameraSpin()
  4339. void AmIGettingBoredWatchingCameraSpin(void) {
  4340.     //static tU32 time_of_death; // Pierre-Marie Baty -- unused variable
  4341.     //static tU32 headup_timer; // Pierre-Marie Baty -- unused variable
  4342.     //tCar_spec* car; // Pierre-Marie Baty -- unused variable
  4343.     //char s[256]; // Pierre-Marie Baty -- unused variable
  4344.     LOG_TRACE("()");
  4345.  
  4346.     STUB_ONCE();
  4347. }
  4348.  
  4349. // IDA: void __cdecl ViewNetPlayer()
  4350. void ViewNetPlayer(void) {
  4351.     LOG_TRACE("()");
  4352.  
  4353.     if (gOpponent_viewing_mode) {
  4354.         if (gProgram_state.cockpit_on) {
  4355.             ToggleCockpit();
  4356.         }
  4357.         gNet_player_to_view_index++;
  4358.         if (gNumber_of_net_players <= gNet_player_to_view_index) {
  4359.             gNet_player_to_view_index = -1;
  4360.         }
  4361.         if (gNet_player_to_view_index < 0) {
  4362.             gCar_to_view = GetRaceLeader();
  4363.         } else {
  4364.             gCar_to_view = gNet_players[gNet_player_to_view_index].car;
  4365.         }
  4366.         gCamera_yaw = 0;
  4367.         InitialiseExternalCamera();
  4368.         PositionExternalCamera(gCar_to_view, 200u);
  4369.     }
  4370. }
  4371.  
  4372. // IDA: void __cdecl ViewOpponent()
  4373. void ViewOpponent(void) {
  4374.     static int n;
  4375.     LOG_TRACE("()");
  4376.  
  4377.     n++;
  4378.     if (gNet_mode != eNet_mode_none) {
  4379.         if (n >= gNumber_of_net_players) {
  4380.             n = 0;
  4381.         }
  4382.         gCar_to_view = gNet_players[n].car;
  4383.         NewTextHeadupSlot(eHeadupSlot_misc, 0, 2000, -3, gNet_players[n].player_name);
  4384.     } else {
  4385.         if (n >= gNum_viewable_cars) {
  4386.             n = 0;
  4387.         }
  4388.         gCar_to_view = gViewable_car_list[n];
  4389.         NewTextHeadupSlot(eHeadupSlot_misc, 0, 2000, -3, gViewable_car_list[n]->driver_name);
  4390.     }
  4391.     gCamera_yaw = 0;
  4392.     InitialiseExternalCamera();
  4393.     PositionExternalCamera(gCar_to_view, 200);
  4394. }
  4395.  
  4396. // IDA: void __cdecl ToggleCarToCarCollisions()
  4397. void ToggleCarToCarCollisions(void) {
  4398.     LOG_TRACE("()");
  4399.  
  4400.     gCar_car_collisions = !gCar_car_collisions;
  4401.     if (gCar_car_collisions) {
  4402.         NewTextHeadupSlot(eHeadupSlot_misc, 0, 3000, -4, "Car Car Collisions");
  4403.     } else {
  4404.         NewTextHeadupSlot(eHeadupSlot_misc, 0, 3000, -4, "Ghost Cars");
  4405.     }
  4406. }
  4407.  
  4408. // IDA: void __cdecl SwapCar()
  4409. void SwapCar(void) {
  4410.     LOG_TRACE("()");
  4411. }
  4412.  
  4413. // IDA: void __cdecl AdjustDownForce()
  4414. void AdjustDownForce(void) {
  4415.     char s[100];
  4416.     tCar_spec* c;
  4417.     LOG_TRACE("()");
  4418.  
  4419.     c = gCar_to_view;
  4420.     c->down_force_speed += 50.f;
  4421.     if (c->down_force_speed > 2000.f) {
  4422.         c->down_force_speed = 50.f;
  4423.     }
  4424.     if (c->down_force_speed > 300.f) {
  4425.         c->down_force_speed = 2000.0;
  4426.     }
  4427.     sprintf(s, "DownForceSpeed %f", c->down_force_speed);
  4428.     NewTextHeadupSlot(eHeadupSlot_misc, 0, 1500, -4, s);
  4429. }
  4430.  
  4431. // IDA: void __cdecl FreezeMechanics()
  4432. void FreezeMechanics(void) {
  4433.     LOG_TRACE("()");
  4434.  
  4435.     gFreeze_mechanics = !gFreeze_mechanics;
  4436.     if (gFreeze_mechanics) {
  4437.         NewTextHeadupSlot(eHeadupSlot_misc, 0, 3000, -4, "Mechanics Frozen");
  4438.     } else {
  4439.         NewTextHeadupSlot(eHeadupSlot_misc, 0, 3000, -4, "Thawed Mechanics");
  4440.     }
  4441. }
  4442.  
  4443. // IDA: void __cdecl PutOpponentsInNeutral()
  4444. void PutOpponentsInNeutral(void) {
  4445.     LOG_TRACE("()");
  4446.  
  4447.     gStop_opponents_moving = !gStop_opponents_moving;
  4448.     if (gStop_opponents_moving == 0) {
  4449.         NewTextHeadupSlot(eHeadupSlot_misc, 0, 3000, -4, "Opponents in neutral");
  4450.     } else {
  4451.         NewTextHeadupSlot(eHeadupSlot_misc, 0, 3000, -4, "Back in gear");
  4452.     }
  4453. }
  4454.  
  4455. // IDA: void __cdecl SetPanningFieldOfView()
  4456. void SetPanningFieldOfView(void) {
  4457.     br_camera* camera_ptr;
  4458.     static br_angle panning_angle = 0; // Added by DethRace
  4459.     LOG_TRACE("()");
  4460.  
  4461.     camera_ptr = gCamera->type_data;
  4462.     if (panning_angle == 0) {
  4463.         panning_angle = BrDegreeToAngle(gCamera_angle) * 0.7f;
  4464.     }
  4465.     camera_ptr->field_of_view = panning_angle;
  4466. }
  4467.  
  4468. // IDA: void __usercall CheckDisablePlingMaterials(tCar_spec *pCar@<EAX>)
  4469. void CheckDisablePlingMaterials(tCar_spec* pCar) {
  4470.     br_matrix34* mat;
  4471.     br_scalar height;
  4472.     int i;
  4473.     LOG_TRACE("(%p)", pCar);
  4474.  
  4475.     height = 0.f;
  4476.     if (pCar->water_d == 10000.f) {
  4477.         DisablePlingMaterials();
  4478.     } else {
  4479.         mat = &pCar->car_master_actor->t.t.mat;
  4480.         for (i = 0; i < 3; i++) {
  4481.             if (mat->m[i][1] > 0.f) {
  4482.                 height += pCar->bounds[0].max.v[i] * mat->m[i][1];
  4483.             } else {
  4484.                 height += pCar->bounds[0].min.v[i] * mat->m[i][1];
  4485.             }
  4486.         }
  4487.         if (mat->m[3][1] / WORLD_SCALE + height < pCar->water_d) {
  4488.             DisablePlingMaterials();
  4489.         }
  4490.     }
  4491. }
  4492.  
  4493. // IDA: void __usercall PositionExternalCamera(tCar_spec *c@<EAX>, tU32 pTime@<EDX>)
  4494. void PositionExternalCamera(tCar_spec* c, tU32 pTime) {
  4495.     static int old_camera_mode;
  4496.     br_camera* camera_ptr;
  4497.     LOG_TRACE("(%p, %d)", c, pTime);
  4498.  
  4499.     camera_ptr = (br_camera*)gCamera->type_data;
  4500.     CheckCameraHither();
  4501.     AmIGettingBoredWatchingCameraSpin();
  4502.     if ((!gAction_replay_mode || gAction_replay_camera_mode == eAction_replay_standard) && old_camera_mode != -1) {
  4503.         camera_ptr->field_of_view = BrDegreeToAngle(gCamera_angle);
  4504.         old_camera_mode = -1;
  4505.     }
  4506.     if (!gProgram_state.cockpit_on) {
  4507.         if (gOpponent_viewing_mode && gAction_replay_mode) {
  4508.             c = &gProgram_state.current_car;
  4509.         } else {
  4510.             c = gCar_to_view;
  4511.         }
  4512.         if (c->car_master_actor->t.t.translate.t.v[0] <= 500.0) {
  4513.             if (gAction_replay_mode && gAction_replay_camera_mode) {
  4514.                 if (gAction_replay_camera_mode == eAction_replay_action) {
  4515.                     CheckDisablePlingMaterials(c);
  4516.                     if (IncidentCam(c, pTime)) {
  4517.                         SetPanningFieldOfView();
  4518.                         EnablePlingMaterials();
  4519.                         old_camera_mode = gAction_replay_camera_mode;
  4520.                         return;
  4521.                     }
  4522.                 }
  4523.                 CheckDisablePlingMaterials(c);
  4524.                 SetPanningFieldOfView();
  4525.                 if (gAction_replay_camera_mode != old_camera_mode) {
  4526.                     SetUpPanningCamera(c);
  4527.                     old_camera_mode = gAction_replay_camera_mode;
  4528.                 }
  4529.                 PanningExternalCamera(c, pTime);
  4530.                 EnablePlingMaterials();
  4531.             } else {
  4532.                 NormalPositionExternalCamera(c, pTime);
  4533.             }
  4534.         }
  4535.     }
  4536. }
  4537.  
  4538. // IDA: void __usercall CameraBugFix(tCar_spec *c@<EAX>, tU32 pTime@<EDX>)
  4539. void CameraBugFix(tCar_spec* c, tU32 pTime) {
  4540.     //br_matrix34 mat; // Pierre-Marie Baty -- unused variable
  4541.     //br_matrix34* m2; // Pierre-Marie Baty -- unused variable
  4542.     //br_vector3 tv; // Pierre-Marie Baty -- unused variable
  4543.     LOG_TRACE("(%p, %d)", c, pTime);
  4544.  
  4545.     if (gAction_replay_mode && gAction_replay_camera_mode != eAction_replay_standard && gPed_actor != NULL && !gProgram_state.cockpit_on) {
  4546.         IncidentCam(c, pTime);
  4547.     }
  4548. }
  4549.  
  4550. // IDA: int __usercall PossibleRemoveNonCarFromWorld@<EAX>(br_actor *pActor@<EAX>)
  4551. int PossibleRemoveNonCarFromWorld(br_actor* pActor) {
  4552.     tU8 cx;
  4553.     tU8 cz;
  4554.     tTrack_spec* track_spec;
  4555.     LOG_TRACE("(%p)", pActor);
  4556.  
  4557.     track_spec = &gProgram_state.track_spec;
  4558.     XZToColumnXZ(&cx, &cz, pActor->t.t.translate.t.v[0], pActor->t.t.translate.t.v[2], track_spec);
  4559.     if (track_spec->columns[cz][cx] == pActor->parent) {
  4560.         BrActorRemove(pActor);
  4561.         return 1;
  4562.     }
  4563.     return 0;
  4564. }
  4565.  
  4566. // IDA: void __usercall PutNonCarBackInWorld(br_actor *pActor@<EAX>)
  4567. void PutNonCarBackInWorld(br_actor* pActor) {
  4568.     tU8 cx;
  4569.     tU8 cz;
  4570.     tTrack_spec* track_spec;
  4571.     LOG_TRACE("(%p)", pActor);
  4572.  
  4573.     track_spec = &gProgram_state.track_spec;
  4574.     XZToColumnXZ(&cx, &cz, pActor->t.t.translate.t.v[0], pActor->t.t.translate.t.v[2], track_spec);
  4575.     BrActorAdd(track_spec->columns[cz][cx], pActor);
  4576. }
  4577.  
  4578. // IDA: int __usercall IncidentCam@<EAX>(tCar_spec *c@<EAX>, tU32 pTime@<EDX>)
  4579. int IncidentCam(tCar_spec* c, tU32 pTime) {
  4580.     br_matrix34* m2;
  4581.     br_matrix34 mat;
  4582.     br_vector3 tv;
  4583.     //br_vector3 tv2; // Pierre-Marie Baty -- unused variable
  4584.     br_vector3 perp;
  4585.     br_vector3 vertical;
  4586.     br_vector3 murderer_pos;
  4587.     br_scalar ts;
  4588.     //tCar_spec* car2; // Pierre-Marie Baty -- unused variable
  4589.     static tU32 next_incident_time = 0;
  4590.     static tIncident_type type = eNo_incident;
  4591.     static float severity;
  4592.     static tIncident_info info;
  4593.     static int random = 1;
  4594.     static int count = 0;
  4595.     //br_scalar temp; // Pierre-Marie Baty -- unused variable
  4596.     br_vector3 old_cam_pos;
  4597.     int removed;
  4598.     LOG_TRACE("(%p, %d)", c, pTime);
  4599.  
  4600.     gPed_actor = NULL;
  4601.     m2 = &gCamera->t.t.mat;
  4602.     if (type == eNo_incident) {
  4603.         MoveCamToIncident(c, &type, &severity, &info, &next_incident_time);
  4604.     }
  4605.     if (type == eNo_incident) {
  4606.         return 0;
  4607.     }
  4608.     if (type == eIncident_ped) {
  4609.         BrVector3Copy(&old_cam_pos, &gCamera->t.t.translate.t);
  4610.         gPed_actor = info.ped_info.ped_actor;
  4611.         removed = PossibleRemoveNonCarFromWorld(info.ped_info.murderer_actor);
  4612.         BrMatrix34Mul(&mat, &gPed_actor->t.t.mat, &gPed_actor->parent->t.t.mat);
  4613.         info.ped_info.murderer_actor = c->car_master_actor;
  4614.         if (info.ped_info.murderer_actor != NULL) {
  4615.             BrVector3Copy(&murderer_pos, &c->pos);
  4616.         } else if (info.ped_info.murderer_actor->model != NULL) {
  4617.             BrVector3Add(&murderer_pos, &info.ped_info.murderer_actor->model->bounds.max, &info.ped_info.murderer_actor->model->bounds.min);
  4618.             BrVector3Scale(&murderer_pos, &murderer_pos, 0.5f);
  4619.             BrMatrix34ApplyP(&murderer_pos, &murderer_pos, &info.ped_info.murderer_actor->t.t.mat);
  4620.         } else {
  4621.             BrVector3Copy(&murderer_pos, &info.ped_info.murderer_actor->t.t.translate.t);
  4622.         }
  4623.         BrVector3Normalise(&vertical, (br_vector3*)mat.m[1]);
  4624.         BrVector3Scale(&vertical, &vertical, PedHeightFromActor(info.ped_info.ped_actor) / 2.f);
  4625.         BrVector3Accumulate((br_vector3*)mat.m[3], &vertical);
  4626.         if (next_incident_time > GetTotalTime() || !PipeSearchForwards()) {
  4627.             BrVector3Sub(&tv, (br_vector3*)mat.m[3], &murderer_pos);
  4628.             tv.v[1] = 0.f;
  4629.             BrVector3Normalise(&tv, &tv);
  4630.             BrVector3Set(&vertical, .0f, .4f, .0f);
  4631.             BrVector3Cross(&perp, &tv, &vertical);
  4632.             if (random) {
  4633.                 BrVector3Negate(&perp, &perp);
  4634.             }
  4635.             if (PipeSearchForwards()) {
  4636.                 BrVector3Accumulate(&perp, &tv);
  4637.             }
  4638.             BrVector3Add(&gCamera->t.t.translate.t, (br_vector3*)mat.m[3], &perp);
  4639.             CollideCamera2(&murderer_pos, &gCamera->t.t.translate.t, NULL, 1);
  4640.         }
  4641.         PointCamera((br_vector3*)mat.m[3], m2);
  4642.         BrVector3Sub(&tv, &gCamera->t.t.translate.t, &info.ped_info.murderer_actor->t.t.translate.t);
  4643.         ts = BrVector3LengthSquared(&tv);
  4644.         if (/*abs*/(GetTotalTime() - next_incident_time) > 2500) { // Pierre-Marie Baty -- useless call (already unsigned)
  4645.             type = eNo_incident;
  4646.         }
  4647.         if ((PipeSearchForwards() ? (next_incident_time < GetTotalTime()) : (next_incident_time > GetTotalTime()))
  4648.             && (ts > 25.f || CheckForWall(&info.ped_info.murderer_actor->t.t.translate.t, &gCamera->t.t.translate.t))) {
  4649.             type = eNo_incident;
  4650.         }
  4651.         if (removed) {
  4652.             PutNonCarBackInWorld(info.ped_info.murderer_actor);
  4653.         }
  4654.         if (Vector3DistanceSquared((br_vector3*)mat.m[3], &gCamera->t.t.translate.t) < .15f * .15f) {
  4655.             BrVector3Copy(&gCamera->t.t.translate.t, &old_cam_pos);
  4656.             gPed_actor = NULL;
  4657.             return 0;
  4658.         }
  4659.     } else if (type == eIncident_car) {
  4660.         BrVector3Sub(&tv, &info.car_info.car->pos, &c->pos);
  4661.         tv.v[1] = 0.f;
  4662.         BrVector3Normalise(&tv, &tv);
  4663.         BrVector3Scale(&tv, &tv, 2.f);
  4664.         BrVector3Add(&gCamera->t.t.translate.t, &info.car_info.car->pos, &tv);
  4665.         gCamera->t.t.translate.t.v[1] += 1.f;
  4666.         CollideCamera2(&info.car_info.car->pos, &gCamera->t.t.translate.t, NULL, 1);
  4667.         PointCamera(&info.car_info.car->pos, m2);
  4668.         BrVector3Sub(&tv, &gCamera->t.t.translate.t, &c->pos);
  4669.         ts = BrVector3LengthSquared(&tv);
  4670.         if (/*abs*/(GetTotalTime() - next_incident_time) > 2500) { // Pierre-Marie Baty -- useless call (already unsigned)
  4671.             type = eNo_incident;
  4672.         }
  4673.         if ((PipeSearchForwards() ? (next_incident_time < GetTotalTime()) : (next_incident_time > GetTotalTime()))
  4674.             && (ts > 25.f || CheckForWall(&c->pos, &gCamera->t.t.translate.t))) {
  4675.             type = eNo_incident;
  4676.         }
  4677.     } else if (type == eIncident_wall) {
  4678.         PointCamera(&c->pos, m2);
  4679.         BrVector3Sub(&tv, &gCamera->t.t.translate.t, &c->pos);
  4680.         ts = BrVector3LengthSquared(&tv);
  4681.         if (/*abs*/(GetTotalTime() - next_incident_time) > 2500) { // Pierre-Marie Baty -- useless call (already unsigned)
  4682.             type = eNo_incident;
  4683.         }
  4684.         if ((PipeSearchForwards() ? (next_incident_time < GetTotalTime()) : (next_incident_time > GetTotalTime()))
  4685.             && (ts > 25.f || CheckForWall(&c->pos, &gCamera->t.t.translate.t))) {
  4686.             type = eNo_incident;
  4687.         }
  4688.     } else {
  4689.         type = eNo_incident;
  4690.     }
  4691.     if (type == eNo_incident) {
  4692.         if (count > 1) {
  4693.             SetUpPanningCamera(c);
  4694.             return 0;
  4695.         } else {
  4696.             count++;
  4697.             if (IncidentCam(c, pTime)) {
  4698.                 count--;
  4699.                 return 1;
  4700.             } else {
  4701.                 count--;
  4702.                 return 0;
  4703.             }
  4704.         }
  4705.     } else {
  4706.         return 1;
  4707.     }
  4708. }
  4709.  
  4710. // IDA: int __usercall MoveCamToIncident@<EAX>(tCar_spec *c@<EAX>, tIncident_type *type@<EDX>, float *severity@<EBX>, tIncident_info *info@<ECX>, tU32 *next_incident_time)
  4711. int MoveCamToIncident(tCar_spec* c, tIncident_type* type, float* severity, tIncident_info* info, tU32* next_incident_time) {
  4712.     tU32 next_incident_time2;
  4713.     tU32 t;
  4714.     tIncident_type type2;
  4715.     float severity2;
  4716.     tIncident_info info2;
  4717.     br_vector3 pos;
  4718.     br_vector3 left;
  4719.     br_vector3 right;
  4720.     br_vector3 vertical;
  4721.     br_vector3 tv;
  4722.     //br_vector3 tv2; // Pierre-Marie Baty -- unused variable
  4723.     br_vector3 perp;
  4724.     int test;
  4725.     LOG_TRACE("(%p, %p, %p, %p, %p)", c, type, severity, info, next_incident_time);
  4726.  
  4727.     test = 0;
  4728.     if (!GetNextIncident(-1, type, severity, info, next_incident_time)) {
  4729.         *type = eNo_incident;
  4730.     } else {
  4731.         if (/*abs*/(*next_incident_time) > 2500) { // Pierre-Marie Baty -- useless call (already unsigned)
  4732.             *type = eNo_incident;
  4733.         } else {
  4734.             t = *next_incident_time;
  4735.             for (test = 0; GetNextIncident(/*abs*/(t), &type2, &severity2, &info2, &next_incident_time2) && test <= 10 && /*abs*/(next_incident_time2) <= 3500; test++) { // Pierre-Marie Baty -- useless calls (already unsigned)
  4736.                 if ((*type != type2 && type2 < *type) || (*type == type2 && *severity <= severity2)) {
  4737.                     *info = info2;
  4738.                     *severity = severity2;
  4739.                     *type = type2;
  4740.                     *next_incident_time = next_incident_time2;
  4741.                 }
  4742.                 t = next_incident_time2;
  4743.             }
  4744.             if (/*abs*/(*next_incident_time) > 2500) { // Pierre-Marie Baty -- useless call (already unsigned)
  4745.                 *type = eNo_incident;
  4746.             } else {
  4747.                 if (*type == eIncident_wall) {
  4748.                     if (*severity < 0.1f) {
  4749.                         *type = eNo_incident;
  4750.                         return 0;
  4751.                     }
  4752.                     ScanCarsPositions(c, &c->pos, 100000.f, -1, /*abs*/(*next_incident_time), &pos, &t); // Pierre-Marie Baty -- useless call (already unsigned)
  4753.                     if (t == 0) {
  4754.                         *type = eNo_incident;
  4755.                     } else {
  4756.                         BrVector3Sub(&tv, &pos, &c->pos);
  4757.                         if (BrVector3LengthSquared(&tv) > 102.91955471539592f) {
  4758.                             *type = eNo_incident;
  4759.                         } else {
  4760.                             BrVector3Sub(&tv, &pos, &info->wall_info.pos);
  4761.                             BrVector3Normalise(&tv, &tv);
  4762.                             BrVector3Scale(&tv, &tv, 2.f);
  4763.                             BrVector3Set(&vertical, 0.f, 1.f, 0.f);
  4764.                             BrVector3Cross(&perp, &vertical, &tv);
  4765.                             BrVector3Add(&left, &pos, &tv);
  4766.                             BrVector3Add(&left, &left, &perp);
  4767.                             left.v[1] += 2.f;
  4768.                             BrVector3Add(&right, &pos, &tv);
  4769.                             BrVector3Sub(&right, &right, &perp);
  4770.                             right.v[1] += 2.f;
  4771.                             CollideCamera2(&pos, &left, NULL, 1);
  4772.                             CollideCamera2(&pos, &right, NULL, 1);
  4773.                             if (Vector3DistanceSquared(&left, &pos) <= Vector3DistanceSquared(&right, &pos)) {
  4774.                                 BrVector3Copy(&tv, &right);
  4775.                             } else {
  4776.                                 BrVector3Copy(&tv, &left);
  4777.                             }
  4778.                             BrVector3Copy(&gCamera->t.t.translate.t, &tv);
  4779.                         }
  4780.                     }
  4781.                 }
  4782.                 *next_incident_time += GetTotalTime();
  4783.             }
  4784.         }
  4785.     }
  4786.     return 0;
  4787. }
  4788.  
  4789. // IDA: void __usercall PanningExternalCamera(tCar_spec *c@<EAX>, tU32 pTime@<EDX>)
  4790. void PanningExternalCamera(tCar_spec* c, tU32 pTime) {
  4791.     br_matrix34* m2;
  4792.     br_matrix34* m1;
  4793.     br_vector3 tv;
  4794.     br_scalar ts;
  4795.     static int inside_camera_zone = 1;
  4796.     LOG_TRACE("(%p, %d)", c, pTime);
  4797.  
  4798.     BrVector3Sub(&tv, &gCamera->t.t.translate.t, &c->pos);
  4799.     ts = BrVector3LengthSquared(&tv);
  4800.     if (ts > 102.91955471539592f || (gSwitch_time != 0 && (PipeSearchForwards() ? (gSwitch_time <= GetTotalTime()) : (gSwitch_time >= GetTotalTime())))) {
  4801.         if ((inside_camera_zone || ts > 205.83910943079184f) && (ts > 25.f || CheckForWall(&c->pos, &gCamera->t.t.translate.t))) {
  4802.             SetUpPanningCamera(c);
  4803.             inside_camera_zone = 0;
  4804.         }
  4805.     } else {
  4806.         inside_camera_zone = 1;
  4807.     }
  4808.     m1 = &c->car_master_actor->t.t.mat;
  4809.     m2 = &gCamera->t.t.mat;
  4810.     PointCameraAtCar(c, m1, m2);
  4811. }
  4812.  
  4813. // IDA: int __usercall CheckForWall@<EAX>(br_vector3 *start@<EAX>, br_vector3 *end@<EDX>)
  4814. int CheckForWall(br_vector3* start, br_vector3* end) {
  4815.     br_vector3 dir;
  4816.     br_material* material;
  4817.     br_vector3 normal;
  4818.     br_scalar d;
  4819.     LOG_TRACE("(%p, %p)", start, end);
  4820.  
  4821.     BrVector3Sub(&dir, end, start);
  4822.     FindFace(start, &dir, &normal, &d, &material);
  4823.     return d <= 1.f;
  4824. }
  4825.  
  4826. // IDA: void __usercall SetUpPanningCamera(tCar_spec *c@<EAX>)
  4827. void SetUpPanningCamera(tCar_spec* c) {
  4828.     br_vector3 pos;
  4829.     br_vector3 perp;
  4830.     br_vector3 dir;
  4831.     br_vector3 tv;
  4832.     br_vector3 tv2;
  4833.     br_scalar ts;
  4834.     tU32 time;
  4835.     tU32 t;
  4836.     tU32 t2;
  4837.     tU32 time_step;
  4838.     //br_matrix34* m2; // Pierre-Marie Baty -- unused variable
  4839.     //br_matrix34* m1; // Pierre-Marie Baty -- unused variable
  4840.     br_vector3 left;
  4841.     br_vector3 right;
  4842.     br_vector3 car_centre;
  4843.     //int left_score; // Pierre-Marie Baty -- unused variable
  4844.     //int right_score; // Pierre-Marie Baty -- unused variable
  4845.     LOG_TRACE("(%p)", c);
  4846.  
  4847.     ScanCarsPositions(c, &c->pos, 411.6782f, -1, 5000, &car_centre, &t);
  4848.     BrVector3Sub(&dir, &car_centre, &c->pos);
  4849.     time_step = ((t > GetTotalTime()) ? t - GetTotalTime() : GetTotalTime() - t) * SRandomBetween(0.8f, 1.5f);
  4850.     if (BrVector3LengthSquared(&dir) >= .01f && t != 0) {
  4851.         ScanCarsPositions(c, &c->pos, 102.9196f, -1, time_step / 2, &pos, &t2);
  4852.         if (t2 == 0) {
  4853.             BrVector3Copy(&pos, &c->pos);
  4854.         }
  4855.     } else {
  4856.         BrVector3Negate(&dir, (br_vector3*)&c->car_master_actor->t.t.mat.m[2]);
  4857.         BrVector3Copy(&pos, &c->pos);
  4858.         time_step = 0;
  4859.     }
  4860.     BrVector3SetFloat(&tv, 0.f, 1.f, 0.f);
  4861.     BrVector3Cross(&perp, &tv, &dir);
  4862.     ts = BrVector3Length(&perp);
  4863.     if (ts >= .1f) {
  4864.         BrVector3Scale(&perp, &perp, 2.f / ts * SRandomBetween(0.3333333f, 1.f));
  4865.         BrVector3Set(&tv2, 0.f, 2 * SRandomBetween(0.3333333f, 1.f), 0.f);
  4866.         BrVector3Add(&tv, &pos, &tv2);
  4867.         BrVector3Add(&left, &tv, &perp);
  4868.         BrVector3Sub(&right, &tv, &perp);
  4869.         CollideCamera2(&pos, &left, NULL, 1);
  4870.         CollideCamera2(&pos, &right, NULL, 1);
  4871.         BrVector3Sub(&tv, &left, &pos);
  4872.         BrVector3Sub(&tv2, &right, &pos);
  4873.         if (BrVector3LengthSquared(&tv) + SRandomPosNeg(.01f) <= BrVector3LengthSquared(&tv2)) {
  4874.             BrVector3Copy(&gCamera->t.t.translate.t, &right);
  4875.         } else {
  4876.             BrVector3Copy(&gCamera->t.t.translate.t, &left);
  4877.         }
  4878.         if (t != 0 && CheckForWall(&c->pos, &gCamera->t.t.translate.t)) {
  4879.             ScanCarsPositions(c, &c->pos, 10000.f, -1, 1000, &tv, &time);
  4880.             CollideCamera2(&tv, &gCamera->t.t.translate.t, NULL, 1);
  4881.         }
  4882.         if (t != 0 && CheckForWall(&car_centre, &gCamera->t.t.translate.t)) {
  4883.             time_step = time_step / 16;
  4884.             BrVector3Copy(&tv, &pos);
  4885.             while (1) {
  4886.                 ScanCarsPositions(c, &tv, 10000.f, /*abs*/(t2 - GetTotalTime()), time_step, &tv2, &time); // Pierre-Marie Baty -- useless call (already unsigned)
  4887.                 t2 += (GetReplayDirection() ? 1 : -1) * time_step;
  4888.                 BrVector3Copy(&tv, &tv2);
  4889.                 if (CheckForWall(&tv, &gCamera->t.t.translate.t)) {
  4890.                     break;
  4891.                 }
  4892.                 if (t2 >= GetTotalTime() + 5000) {
  4893.                     break;
  4894.                 }
  4895.             }
  4896.             gSwitch_time = t2;
  4897.         } else {
  4898.             if (t == 0) {
  4899.                 t = 5000;
  4900.             }
  4901.             gSwitch_time = t;
  4902.         }
  4903.     }
  4904. }
  4905.  
  4906. // IDA: void __usercall SaveCameraPosition(int i@<EAX>)
  4907. void SaveCameraPosition(int i) {
  4908.     LOG_TRACE("(%d)", i);
  4909.  
  4910.     if (gSave_camera[i].saved != 1) {
  4911.         gSave_camera[i].zoom = gCamera_zoom;
  4912.         gSave_camera[i].yaw = gCamera_yaw;
  4913.         gSave_camera[i].saved = 1;
  4914.     }
  4915. }
  4916.  
  4917. // IDA: void __usercall RestoreCameraPosition(int i@<EAX>)
  4918. void RestoreCameraPosition(int i) {
  4919.     LOG_TRACE("(%d)", i);
  4920.  
  4921.     if (gSave_camera[i].saved != 0) {
  4922.         gCamera_zoom = gSave_camera[i].zoom;
  4923.         gCamera_yaw = gSave_camera[i].yaw;
  4924.         gSave_camera[i].saved = 0;
  4925.     }
  4926. }
  4927.  
  4928. // IDA: void __usercall NormalPositionExternalCamera(tCar_spec *c@<EAX>, tU32 pTime@<EDX>)
  4929. void NormalPositionExternalCamera(tCar_spec* c, tU32 pTime) {
  4930.     br_matrix34* m2;
  4931.     br_matrix34* m1;
  4932.     br_scalar time;
  4933.     //br_scalar ts; // Pierre-Marie Baty -- unused variable
  4934.     //br_scalar ts2; // Pierre-Marie Baty -- unused variable
  4935.     br_scalar dist;
  4936.     br_scalar height_inc;
  4937.     br_scalar l;
  4938.     //br_scalar frac; // Pierre-Marie Baty -- unused variable
  4939.     br_vector3 vn;
  4940.     br_vector3 a;
  4941.     //br_vector3 b; // Pierre-Marie Baty -- unused variable
  4942.     //br_vector3 tv; // Pierre-Marie Baty -- unused variable
  4943.     //br_angle yaw; // Pierre-Marie Baty -- unused variable
  4944.     //br_angle theta; // Pierre-Marie Baty -- unused variable
  4945.     br_scalar d;
  4946.     //int face; // Pierre-Marie Baty -- unused variable
  4947.     //int i; // Pierre-Marie Baty -- unused variable
  4948.     int swoop;
  4949.     int manual_swing;
  4950.     int manual_zoom;
  4951.     br_vector3 old_camera_pos;
  4952.     //br_scalar scale; // Pierre-Marie Baty -- unused variable
  4953.     LOG_TRACE("(%p, %d)", c, pTime);
  4954.  
  4955.     m1 = &gCamera->t.t.mat;
  4956.     m2 = &c->car_master_actor->t.t.mat;
  4957.     swoop = gCountdown && c->pos.v[1] + 0.001f < gCamera_height;
  4958.     manual_swing = gOld_yaw__car != gCamera_yaw || swoop;
  4959.     manual_zoom = (double)gOld_zoom != gCamera_zoom;
  4960.     BrVector3Copy(&old_camera_pos, &gCamera->t.t.translate.t);
  4961.     if (!gProgram_state.cockpit_on) {
  4962.         if (swoop) {
  4963.             gCamera_yaw = 0;
  4964.             manual_swing = 1;
  4965.         }
  4966.         if (fabsf(c->speedo_speed) > 0.0006f && gCamera_mode > 0) {
  4967.             gCamera_mode = -1;
  4968.             gCamera_sign = BrVector3Dot((br_vector3*)m2->m[2], &c->direction) > 0.0f;
  4969.         }
  4970.         if (c->frame_collision_flag && gCamera_mode != -2) {
  4971.             gCamera_mode = 1;
  4972.         }
  4973.         if (gCar_flying || gCamera_reset || gCamera_mode == -2) {
  4974.             gCamera_mode = 0;
  4975.         }
  4976.         d = sqrtf(gCamera_zoom) + 4.f / WORLD_SCALE;
  4977.         if (!gCamera_mode || gCamera_mode == -1) {
  4978.             BrVector3Copy(&vn, &c->direction);
  4979.             MoveWithWheels(c, &vn, manual_swing);
  4980.             vn.v[1] = 0.0f;
  4981.             BrVector3Normalise(&vn, &vn);
  4982.             if (gCar_flying) {
  4983.                 gCamera_sign = 0;
  4984.             }
  4985.             SwingCamera(c, m2, m1, &vn, pTime);
  4986.             BrVector3Scale(&a, &vn, d);
  4987.             BrVector3Sub(&gCamera->t.t.translate.t, &c->pos, &a);
  4988.             BrVector3Copy(&gView_direction, &vn);
  4989.         }
  4990.         if (gCamera_mode == 1) {
  4991.             if (manual_swing || manual_zoom) {
  4992.                 BrVector3Copy(&old_camera_pos, &gCamera_pos_before_collide);
  4993.             }
  4994.             BrVector3Sub(&a, &c->pos, &old_camera_pos);
  4995.             a.v[1] = 0.0f;
  4996.             if (manual_swing) {
  4997.                 DrVector3RotateY(&a, (gCamera_sign == 0 ? 1 : -1) * (gCamera_yaw - gOld_yaw__car));
  4998.                 gCamera_yaw = gOld_yaw__car;
  4999.             }
  5000.             BrVector3Normalise(&vn, &a);
  5001.             BrVector3Copy(&gView_direction, &vn);
  5002.             BrVector3Scale(&vn, &vn, -d);
  5003.             BrVector3Accumulate(&a, &vn);
  5004.             dist = BrVector3Length(&a);
  5005.             l = (float)pTime / 1000.0f * (dist + 1.0f) / dist;
  5006.             if (l < 1.0f && BrVector3Dot(&a, &vn) > 0.0f) {
  5007.                 BrVector3Scale(&a, &a, (l - 1.f));
  5008.                 BrVector3Accumulate(&vn, &a);
  5009.             }
  5010.             BrVector3Add(&gCamera->t.t.translate.t, &c->pos, &vn);
  5011.         }
  5012.         height_inc = gCamera_zoom * gCamera_zoom + 0.3f;
  5013.         time = pTime * 0.001f;
  5014.         if (!gCamera_frozen || gAction_replay_mode) {
  5015.             if (pTime >= 5000) {
  5016.                 gCamera_height = c->pos.v[1];
  5017.             } else if (swoop) {
  5018.                 if (time > 0.2f) {
  5019.                     time = 0.2f;
  5020.                 }
  5021.                 gCamera_height -= time * 5.0f;
  5022.                 if (gCamera_height < c->pos.v[1]) {
  5023.                     gCamera_height = c->pos.v[1];
  5024.                 }
  5025.             } else {
  5026.                 gCamera_height = time * 5.0f * c->pos.v[1] + gCamera_height;
  5027.                 gCamera_height = gCamera_height / (time * 5.0f + 1.0f);
  5028.             }
  5029.         }
  5030.         l = c->direction.v[1] * d;
  5031.         if (l > 0) {
  5032.             if (c->pos.v[1] - l - height_inc / 2.0f > gCamera_height) {
  5033.                 gCamera_height = c->pos.v[1] - l - height_inc / 2.0f;
  5034.             }
  5035.         }
  5036.  
  5037.         gCamera->t.t.translate.t.v[1] = height_inc + gCamera_height;
  5038.         BrVector3Copy(&gCamera_pos_before_collide, &gCamera->t.t.translate.t);
  5039.         CollideCameraWithOtherCars(&c->pos, &gCamera->t.t.translate.t);
  5040.         CollideCamera2(&c->pos, &gCamera->t.t.translate.t, &old_camera_pos, manual_swing || manual_zoom);
  5041.         if (gCamera_has_collided && swoop) {
  5042.             gCamera_height = c->pos.v[1];
  5043.         }
  5044.         PointCameraAtCar(c, m2, m1);
  5045.     }
  5046.     gOld_yaw__car = gCamera_yaw;
  5047.     gOld_zoom = (br_angle)gCamera_zoom;
  5048. }
  5049.  
  5050. // IDA: void __usercall MoveWithWheels(tCar_spec *c@<EAX>, br_vector3 *vn@<EDX>, int manual_swing@<EBX>)
  5051. void MoveWithWheels(tCar_spec* c, br_vector3* vn, int manual_swing) {
  5052.     br_angle yaw;
  5053.     br_angle theta;
  5054.     static int move_with_wheels;
  5055.     LOG_TRACE("(%p, %p, %d)", c, vn, manual_swing);
  5056.  
  5057.     if (c->speed < 0.0001f && !gCamera_mode) {
  5058.         if (manual_swing) {
  5059.             if (gCamera_yaw <= 32760u) {
  5060.                 yaw = gCamera_yaw;
  5061.             } else {
  5062.                 yaw = gCamera_yaw - 32760;
  5063.             }
  5064.             if (yaw <= BrDegreeToAngle(45) || yaw >= BrDegreeToAngle(135)) {
  5065.                 if (!move_with_wheels) {
  5066.                     theta = BrRadianToAngle(atan2f(c->wpos[0].v[2] * c->curvature, 1.0f));
  5067.                     gCamera_yaw -= (-2 * gCamera_sign + 1) * theta;
  5068.                     move_with_wheels = 1;
  5069.                 }
  5070.             } else if (move_with_wheels) {
  5071.                 theta = BrRadianToAngle(atan2(c->wpos[0].v[2] * c->curvature, 1.0));
  5072.                 gCamera_yaw += (-2 * gCamera_sign + 1) * theta;
  5073.                 move_with_wheels = 0;
  5074.             }
  5075.         }
  5076.         if (move_with_wheels) {
  5077.             if (!gCar_flying) {
  5078.                 theta = BrRadianToAngle(atan2(c->wpos[0].v[2] * c->curvature, 1.0));
  5079.                 DrVector3RotateY(vn, theta);
  5080.             }
  5081.         }
  5082.     }
  5083. }
  5084.  
  5085. // IDA: void __usercall SwingCamera(tCar_spec *c@<EAX>, br_matrix34 *m1@<EDX>, br_matrix34 *m2@<EBX>, br_vector3 *vn@<ECX>, tU32 pTime)
  5086. void SwingCamera(tCar_spec* c, br_matrix34* m1, br_matrix34* m2, br_vector3* vn, tU32 pTime) {
  5087.     //int i; // Pierre-Marie Baty -- unused variable
  5088.     br_scalar ts;
  5089.     br_angle yaw;
  5090.     br_angle theta;
  5091.     //br_angle alpha; // Pierre-Marie Baty -- unused variable
  5092.     br_scalar sin_dtheta;
  5093.     br_scalar cos_dtheta;
  5094.     br_scalar sign;
  5095.     int manual_swing;
  5096.     static br_angle omega = 0;
  5097.     static int elapsed_time = -1;
  5098.     static br_vector3 old_vn;
  5099.     LOG_TRACE("(%p, %p, %p, %p, %d)", c, m1, m2, vn, pTime);
  5100.  
  5101.     manual_swing = gOld_yaw__car != gCamera_yaw;
  5102.     if (elapsed_time > 500) {
  5103.         elapsed_time = -1;
  5104.     }
  5105.     if (elapsed_time >= 0) {
  5106.         elapsed_time += pTime;
  5107.     }
  5108.     sign = -BrVector3Dot((br_vector3*)m1->m[2], vn);
  5109.     ts = BrVector3Dot(vn, &old_vn);
  5110.  
  5111.     BrVector3Copy(&old_vn, vn);
  5112.     if ((sign < 0.0f) == gCamera_sign) {
  5113.         elapsed_time = -1;
  5114.     } else if (ts <= 0.0 || elapsed_time >= 0) {
  5115.         if (elapsed_time < 0) {
  5116.             elapsed_time = 0;
  5117.         }
  5118.         if (elapsed_time < 500 && sign <= 0.0f) {
  5119.             BrVector3Negate(vn, vn);
  5120.         } else {
  5121.             elapsed_time = 500;
  5122.             if (sign <= 0.0) {
  5123.                 ts = 0.0006f;
  5124.             } else {
  5125.                 ts = 0.0001f;
  5126.             }
  5127.             if (fabsf(c->speedo_speed) <= ts || gCar_flying) {
  5128.                 BrVector3Negate(vn, vn);
  5129.             } else {
  5130.                 gCamera_sign = gCamera_sign == 0;
  5131.                 omega = BrDegreeToAngle(pTime * 0.03f);
  5132.                 if (gCamera_yaw <= 32760) {
  5133.                     yaw = gCamera_yaw;
  5134.                 } else {
  5135.                     yaw = gCamera_yaw - 32760;
  5136.                 }
  5137.                 if ((uint16_t)(gCamera_yaw + 16380) <= 32760) {
  5138.                     if (yaw > 8190 && yaw < 24570) {
  5139.                         gCamera_yaw = 32760 - gCamera_yaw;
  5140.                     }
  5141.                 } else {
  5142.                     gCamera_yaw = 32760 - gCamera_yaw;
  5143.                 }
  5144.             }
  5145.         }
  5146.     } else {
  5147.         gCamera_sign = gCamera_sign == 0;
  5148.         if (gCamera_yaw <= 32760) {
  5149.             yaw = gCamera_yaw;
  5150.         } else {
  5151.             yaw = gCamera_yaw - 32760;
  5152.         }
  5153.         if (yaw > 8190 && yaw < 24570) {
  5154.             gCamera_yaw = -gCamera_yaw;
  5155.         }
  5156.     }
  5157.     if (gCamera_sign) {
  5158.         yaw = -gCamera_yaw;
  5159.     } else {
  5160.         yaw = gCamera_yaw;
  5161.     }
  5162.     if (!gCar_flying) {
  5163.         DrVector3RotateY(vn, yaw);
  5164.     }
  5165.     sin_dtheta = 0.0;
  5166.     br_scalar v16 = vn->v[0] * gView_direction.v[2] - vn->v[2] * gView_direction.v[0];
  5167.     br_scalar v17 = vn->v[0] * gView_direction.v[0] + vn->v[2] * gView_direction.v[2];
  5168.  
  5169.     br_angle v8 = BrRadianToAngle(sqrt(c->omega.v[2] * c->omega.v[2] + c->omega.v[0] * c->omega.v[0] + c->omega.v[1] * c->omega.v[1]) * pTime / 1000.0);
  5170.     sin_dtheta = sin(BrAngleToRadian(v8)) + 0.1;
  5171.  
  5172.     if (omega || gCamera_reset || (c->speed < 0.0001f && !manual_swing) || gCamera_mode == -1 || (v17 > 0.0 && !manual_swing && fabs(v16) > sin_dtheta)) {
  5173.         if (!gCar_flying) {
  5174.             theta = BrRadianToAngle(asin(sin_dtheta));
  5175.             if (omega < theta) {
  5176.                 omega = theta;
  5177.             }
  5178.             if (!omega) {
  5179.                 omega = BrDegreeToAngle(pTime * 0.03); // (__int64)((double)(int)pTime * 0.03 * 182.0444444444445);
  5180.             }
  5181.             cos_dtheta = cos(BrAngleToRadian(omega));
  5182.             if (cos_dtheta <= v17) {
  5183.                 omega = 0;
  5184.                 gCamera_mode = 0;
  5185.             } else {
  5186.                 ts = BrAngleToRadian(omega);
  5187.                 if (v16 <= 0.0) {
  5188.                     vn->v[0] = cosf(ts) * gView_direction.v[0] - sinf(ts) * gView_direction.v[2];
  5189.                     vn->v[2] = sinf(ts) * gView_direction.v[0] + cosf(ts) * gView_direction.v[2];
  5190.                 } else {
  5191.                     vn->v[0] = sinf(ts) * gView_direction.v[2] + cosf(ts) * gView_direction.v[0];
  5192.                     vn->v[2] = cosf(ts) * gView_direction.v[2] - sinf(ts) * gView_direction.v[0];
  5193.                 }
  5194.                 omega += BrDegreeToAngle(pTime * 0.03f);
  5195.                 if (BrDegreeToAngle(pTime * 0.1f) < omega) {
  5196.                     omega = BrDegreeToAngle(pTime * 0.1f);
  5197.                 }
  5198.                 if (omega < theta) {
  5199.                     omega = theta;
  5200.                 }
  5201.             }
  5202.         }
  5203.     }
  5204. }
  5205.  
  5206. // IDA: void __usercall PointCameraAtCar(tCar_spec *c@<EAX>, br_matrix34 *m1@<EDX>, br_matrix34 *m2@<EBX>)
  5207. void PointCameraAtCar(tCar_spec* c, br_matrix34* m1, br_matrix34* m2) {
  5208.     br_vector3 vn;
  5209.     br_vector3 tv;
  5210.     br_vector3 tv2;
  5211.     br_scalar dist;
  5212.     br_scalar frac;
  5213.     br_angle theta;
  5214.     br_vector3* pos;
  5215.     br_camera* camera_ptr;
  5216.     //br_angle off_centre_angle; // Pierre-Marie Baty -- unused variable
  5217.     int swoop;
  5218.     //br_scalar scale; // Pierre-Marie Baty -- unused variable
  5219.     LOG_TRACE("(%p, %p, %p)", c, m1, m2);
  5220.  
  5221.     camera_ptr = gCamera->type_data;
  5222.     theta = camera_ptr->field_of_view / 5;
  5223.     swoop = gCountdown && c->pos.v[1] + 0.01f < gCamera_height;
  5224.     if (0) {
  5225.         BrVector3Sub(&tv, &gAverage_grid_position, &c->pos);
  5226.         frac = (gCamera_height - c->pos.v[1]) / 10.0f;
  5227.         BrVector3Scale(&tv, &tv, frac);
  5228.         BrVector3Accumulate(&tv, &c->pos);
  5229.         pos = &tv;
  5230.         theta = (1.0f - frac) * (float)theta;
  5231.     } else {
  5232.         pos = &c->pos;
  5233.     }
  5234.     BrVector3Set(&vn, c->pos.v[0] - m2->m[3][0], 0.f, c->pos.v[2] - m2->m[3][2]);
  5235.     BrVector3Normalise(&vn, &vn);
  5236.     m2->m[0][0] = -vn.v[2];
  5237.     m2->m[0][1] = 0.0f;
  5238.     m2->m[0][2] = vn.v[0];
  5239.     m2->m[1][0] = 0.0f;
  5240.     m2->m[1][1] = 1.0f;
  5241.     m2->m[1][2] = 0.0f;
  5242.     m2->m[2][0] = -vn.v[0];
  5243.     m2->m[2][1] = 0.0f;
  5244.     m2->m[2][2] = -vn.v[2];
  5245.     BrVector3Sub(&tv2, pos, (br_vector3*)m2->m[3]);
  5246.     dist = BrVector3Dot(&tv2, &vn);
  5247.     BrMatrix34PreRotateX(m2, theta - BrRadianToAngle(atan2f(m2->m[3][1] - pos->v[1], dist)));
  5248. }
  5249.  
  5250. // IDA: void __usercall PointCamera(br_vector3 *pos@<EAX>, br_matrix34 *m2@<EDX>)
  5251. void PointCamera(br_vector3* pos, br_matrix34* m2) {
  5252.     br_vector3 vn;
  5253.     br_scalar dist;
  5254.     br_angle theta;
  5255.     br_camera* camera_ptr;
  5256.     LOG_TRACE("(%p, %p)", pos, m2);
  5257.  
  5258.     camera_ptr = gCamera->type_data;
  5259.     BrVector3Sub(&vn, pos, (br_vector3*)m2->m[3]);
  5260.     vn.v[1] = 0.f;
  5261.     BrVector3Normalise(&vn, &vn);
  5262.     m2->m[0][0] = -vn.v[2];
  5263.     m2->m[0][1] = 0.f;
  5264.     m2->m[0][2] = vn.v[0];
  5265.     m2->m[1][0] = 0.f;
  5266.     m2->m[1][1] = 1.f;
  5267.     m2->m[1][2] = 0.f;
  5268.     m2->m[2][0] = -vn.v[0];
  5269.     m2->m[2][1] = 0.f;
  5270.     m2->m[2][2] = -vn.v[2];
  5271.     dist = BrVector3LengthSquared(&vn);
  5272.     theta = BR_ATAN2(m2->m[3][1] - pos->v[1], dist);
  5273.     BrMatrix34PreRotateX(m2, camera_ptr->field_of_view / 5 - theta);
  5274. }
  5275.  
  5276. // IDA: int __usercall CollideCamera2@<EAX>(br_vector3 *car_pos@<EAX>, br_vector3 *cam_pos@<EDX>, br_vector3 *old_camera_pos@<EBX>, int manual_move@<ECX>)
  5277. int CollideCamera2(br_vector3* car_pos, br_vector3* cam_pos, br_vector3* old_camera_pos, int manual_move) {
  5278.     int i;
  5279.     int k;
  5280.     br_vector3 a;
  5281.     br_vector3 b;
  5282.     //br_vector3 vn; // Pierre-Marie Baty -- unused variable
  5283.     br_vector3 tv;
  5284.     br_vector3 tv2;
  5285.     br_scalar l;
  5286.     br_scalar d;
  5287.     br_scalar ts;
  5288.     br_scalar ts2;
  5289.     br_scalar dist;
  5290.     br_scalar hither;
  5291.     //br_angle theta; // Pierre-Marie Baty -- unused variable
  5292.     tBounds bnds;
  5293.     br_matrix34 mat;
  5294.     br_material* material;
  5295.     br_scalar alpha;
  5296.     br_scalar sa;
  5297.     br_scalar sb;
  5298.     br_scalar sc;
  5299.     tFace_ref face_list[3];
  5300.     LOG_TRACE("(%p, %p, %p, %d)", car_pos, cam_pos, old_camera_pos, manual_move);
  5301.  
  5302. #ifdef DETHRACE_FIX_BUGS
  5303.     ts2 = 0.f;
  5304. #endif
  5305.     hither = ((br_camera*)gCamera->type_data)->hither_z * 3.0f;
  5306.     gCamera_has_collided = 0;
  5307.     for (i = 0; i < 1; i++) {
  5308.         BrVector3Sub(&tv, cam_pos, car_pos);
  5309.         dist = BrVector3Length(&tv);
  5310.         BrVector3Scale(&tv, &tv, 1.2f);
  5311.         FindFace(car_pos, &tv, &a, &ts, &material);
  5312.         if (ts <= 1.0) {
  5313.             gCamera_has_collided = 1;
  5314.             if (BrVector3Dot(&a, &tv) > 0.0f) {
  5315.                 BrVector3Negate(&a, &a);
  5316.             }
  5317.             if (gCamera_mode == 1 && !manual_move) {
  5318.                 BrVector3Sub(&tv2, car_pos, old_camera_pos);
  5319.                 FindFace(old_camera_pos, &tv2, &b, &ts2, &material);
  5320.                 if (ts2 > 1.0f) {
  5321.                     BrVector3Copy(cam_pos, old_camera_pos);
  5322.                     return i;
  5323.                 }
  5324.             }
  5325.             BrVector3Scale(&tv, &tv, ts);
  5326.             BrVector3Scale(&tv2, &a, hither);
  5327.             BrVector3Accumulate(&tv, &tv2);
  5328.             dist = BrVector3Length(&tv);
  5329.             BrVector3Add(cam_pos, car_pos, &tv);
  5330.             if (gMin_camera_car_distance > dist && i == 0 && a.v[1] > -0.7) {
  5331.                 BrVector3Scale(&tv2, &a, -a.v[1]);
  5332.                 tv2.v[1] += 1.f;
  5333.                 if (gProgram_state.current_car.car_master_actor->t.t.mat.m[1][1] < 0.f) {
  5334.                     BrVector3Negate(&tv2, &tv2);
  5335.                 }
  5336.                 d = BrVector3LengthSquared(&tv2);
  5337.                 l = BrVector3Dot(&tv2, &tv);
  5338.                 alpha = BrVector3LengthSquared(&tv) - gMin_camera_car_distance * gMin_camera_car_distance;
  5339.                 ts2 = l * l - alpha * d * 4.0;
  5340.                 if (ts2 >= 0.f && d != 0.f) {
  5341.                     sa = (sqrtf(ts2) - l) / (d * 2.0f);
  5342.                     BrVector3Scale(&tv2, &tv2, sa);
  5343.                     FindFace(cam_pos, &tv2, &a, &ts, &material);
  5344.                     if (ts < 1.0f) {
  5345.                         BrVector3Scale(&tv2, &tv2, ts);
  5346.                     }
  5347.                     BrVector3Set(&b, tv.v[0], 0.f, tv.v[2]);
  5348.                     BrVector3Normalise(&b, &b);
  5349.                     BrVector3Accumulate(&tv, &tv2);
  5350.                     ts2 = BrVector3Dot(&tv, &b);
  5351.                     if (ts2 < 0.03f && !gAction_replay_mode) {
  5352.                         BrVector3Normalise(&tv2, &tv2);
  5353.                         alpha = BrVector3Dot(&tv2, &b);
  5354.                         if (alpha < -0.03f) {
  5355.                             alpha = (0.03f - ts2) / alpha;
  5356.                             BrVector3Scale(&tv2, &tv2, alpha);
  5357.                             BrVector3Add(&tv, &tv2, &tv);
  5358.                         }
  5359.                     }
  5360.                 }
  5361.                 BrVector3Add(cam_pos, car_pos, &tv);
  5362.             }
  5363.         }
  5364.  
  5365.         bnds.mat = &mat;
  5366.         BrMatrix34Identity(&mat);
  5367.         BrVector3Set(&tv2, hither, hither, hither);
  5368.         bnds.original_bounds.min.v[0] = cam_pos->v[0] - hither;
  5369.         bnds.original_bounds.min.v[1] = cam_pos->v[1] - hither;
  5370.         bnds.original_bounds.min.v[2] = cam_pos->v[2] - hither;
  5371.         bnds.original_bounds.max.v[0] = cam_pos->v[0] + hither;
  5372.         bnds.original_bounds.max.v[1] = cam_pos->v[1] + hither;
  5373.         bnds.original_bounds.max.v[2] = cam_pos->v[2] + hither;
  5374.         k = FindFacesInBox(&bnds, face_list, 3);
  5375.         if (k > 0) {
  5376.             BrVector3Sub(&tv2, cam_pos, &face_list[0].v[0]);
  5377.             sa = BrVector3Dot(&face_list[0].normal, &tv2);
  5378.             // ts2 = sa;
  5379.             if (sa < hither && sa >= 0.0) {
  5380.                 BrVector3Scale(&tv2, &face_list[0].normal, hither - sa);
  5381.                 BrVector3Accumulate(cam_pos, &tv2);
  5382.             }
  5383.             if (k > 1) {
  5384.                 sb = BrVector3Dot(&face_list[0].normal, &face_list[1].normal);
  5385.                 if (sb > 0.95f && k > 2) {
  5386.                     BrVector3Copy(&face_list[1].normal, &face_list[2].normal);
  5387.                     BrVector3Copy(&face_list[1].v[0], &face_list[2].v[0]);
  5388.                     sb = BrVector3Dot(&face_list[0].normal, &face_list[2].normal);
  5389.                     k = 2;
  5390.                 }
  5391.                 if (sb <= 0.95f) {
  5392.                     BrVector3Sub(&tv2, cam_pos, &face_list[1].v[0]);
  5393.                     sc = BrVector3Dot(&face_list[1].normal, &tv2);
  5394.                     if (sc < hither && sc >= 0.0) {
  5395.                         sc = BrVector3Dot(&face_list[0].normal, &face_list[1].normal);
  5396.                         BrVector3Scale(&b, &face_list[0].normal, sc);
  5397.                         BrVector3Sub(&face_list[1].normal, &face_list[1].normal, &b);
  5398.                         BrVector3Scale(&tv2, &face_list[1].normal, hither - ts2);
  5399.                         BrVector3Accumulate(cam_pos, &tv2);
  5400.                     }
  5401.                 }
  5402.             }
  5403.         }
  5404.         i += k;
  5405.     }
  5406.     return i;
  5407. }
  5408.  
  5409. // IDA: int __usercall BoundsTest@<EAX>(br_bounds *bnds@<EAX>, br_vector3 *p@<EDX>)
  5410. int BoundsTest(br_bounds* bnds, br_vector3* p) {
  5411.     //int j; // Pierre-Marie Baty -- unused variable
  5412.     LOG_TRACE("(%p, %p)", bnds, p);
  5413.     NOT_IMPLEMENTED();
  5414. }
  5415.  
  5416. // IDA: int __usercall CollideCameraWithOtherCars@<EAX>(br_vector3 *car_pos@<EAX>, br_vector3 *cam_pos@<EDX>)
  5417. int CollideCameraWithOtherCars(br_vector3* car_pos, br_vector3* cam_pos) {
  5418.     //int i; // Pierre-Marie Baty -- unused variable
  5419.     //int plane; // Pierre-Marie Baty -- unused variable
  5420.     //br_scalar ts; // Pierre-Marie Baty -- unused variable
  5421.     //tCar_spec* c; // Pierre-Marie Baty -- unused variable
  5422.     //br_vector3 tv; // Pierre-Marie Baty -- unused variable
  5423.     //br_vector3 pos_car_space; // Pierre-Marie Baty -- unused variable
  5424.     //br_vector3 dir; // Pierre-Marie Baty -- unused variable
  5425.     //br_vector3 p; // Pierre-Marie Baty -- unused variable
  5426.     //br_vector3 n; // Pierre-Marie Baty -- unused variable
  5427.     //br_bounds bnds; // Pierre-Marie Baty -- unused variable
  5428.     LOG_TRACE("(%p, %p)", car_pos, cam_pos);
  5429.  
  5430.     STUB_ONCE();
  5431.     return 0;
  5432. }
  5433.  
  5434. // IDA: void __cdecl InitialiseExternalCamera()
  5435. void InitialiseExternalCamera(void) {
  5436.     br_scalar ts;
  5437.     tCar_spec* c;
  5438.     //br_vector3 r; // Pierre-Marie Baty -- unused variable
  5439.     br_angle yaw;
  5440.     LOG_TRACE("()");
  5441.  
  5442.     c = gCar_to_view;
  5443.     if (!gProgram_state.racing) {
  5444.         c = &gProgram_state.current_car;
  5445.     }
  5446.     gCamera_height = c->pos.v[1];
  5447.     BrVector3Set(&gView_direction, c->direction.v[0], 0.0f, c->direction.v[2]);
  5448.     BrVector3Normalise(&gView_direction, &gView_direction);
  5449.     ts = -BrVector3Dot(&gView_direction, (br_vector3*)c->car_master_actor->t.t.mat.m[2]);
  5450.     gCamera_sign = ts < 0;
  5451.     gCamera_mode = 0;
  5452.     if (gCamera_sign) {
  5453.         yaw = -gCamera_yaw;
  5454.     } else {
  5455.         yaw = gCamera_yaw;
  5456.     }
  5457.     DrVector3RotateY(&gView_direction, yaw);
  5458.     gMin_camera_car_distance = 0.6f;
  5459.     gCamera_frozen = 0;
  5460.     gCamera_mode = -2;
  5461.     if (gCountdown && (gNet_mode == eNet_mode_none || gCurrent_net_game->options.grid_start) && gCountdown > 4) {
  5462.         gCamera_height = gCamera_height + 10.0f;
  5463.     }
  5464. }
  5465.  
  5466. // IDA: void __cdecl FreezeCamera()
  5467. void FreezeCamera(void) {
  5468.     LOG_TRACE("()");
  5469.  
  5470.     gCamera_frozen = 1;
  5471. }
  5472.  
  5473. // IDA: void __usercall FlyCar(tCar_spec *c@<EAX>, br_scalar dt)
  5474. void FlyCar(tCar_spec* c, br_scalar dt) {
  5475.     int accflag;
  5476.     int turnflag;
  5477.     br_vector3 step;
  5478.     br_matrix34* mat;
  5479.     br_angle theta;
  5480.     static br_scalar vel = 0.f;
  5481.     tFace_ref faces[20];
  5482.     tBounds bnds;
  5483.     int i;                 // Added by DethRace
  5484.     br_scalar tmp_scalar1; // Added by DethRace
  5485.     br_scalar tmp_scalar2; // Added by DethRace
  5486.     br_vector3 tmp1;       // Added by DethRace
  5487.     br_vector3 tmp2;       // Added by DethRace
  5488.     br_vector3 tmp3;       // Added by DethRace
  5489.     LOG_TRACE("(%p, %f)", c, dt);
  5490.  
  5491.     accflag = 0;
  5492.     turnflag = 0;
  5493.     mat = &c->car_master_actor->t.t.mat;
  5494.     bnds.mat = mat;
  5495.     BrVector3InvScale(&bnds.original_bounds.min, &c->bounds[1].min, WORLD_SCALE);
  5496.     BrVector3InvScale(&bnds.original_bounds.max, &c->bounds[1].max, WORLD_SCALE);
  5497.     BrVector3InvScale((br_vector3*)bnds.mat->m[3], (br_vector3*)bnds.mat->m[3], WORLD_SCALE);
  5498.     FindFacesInBox(&bnds, faces, COUNT_OF(faces));
  5499.     BrVector3Scale((br_vector3*)bnds.mat->m[3], (br_vector3*)bnds.mat->m[3], WORLD_SCALE);
  5500.     if (c->keys.acc || c->joystick.acc > 0) {
  5501.         vel += 10.f * dt;
  5502.         accflag = 1;
  5503.     }
  5504.     if (c->keys.dec || c->joystick.dec > 0) {
  5505.         vel -= 10.f * dt;
  5506.         accflag = 1;
  5507.     }
  5508.     if (!accflag) {
  5509.         if (vel >= 20.f * dt || vel <= -20.f * dt) {
  5510.             vel -= 20.f * vel / fabsf(vel) * dt;
  5511.         } else {
  5512.             vel = 0.f;
  5513.         }
  5514.     }
  5515.     BrVector3Scale(&step, &c->v, dt);
  5516.     BrVector3Accumulate((br_vector3*)mat->m[3], &step);
  5517.     BrVector3Scale(&step, (br_vector3*)mat->m[1], dt);
  5518.     if (c->keys.left || c->joystick.left > 0) {
  5519.         BrVector3Accumulate(&c->omega, &step);
  5520.         turnflag = 1;
  5521.     }
  5522.     if (c->keys.right || c->joystick.right > 0) {
  5523.         BrVector3Sub(&c->omega, &c->omega, &step);
  5524.         turnflag = 1;
  5525.     }
  5526.     if (!turnflag) {
  5527.         BrVector3SetFloat(&c->omega, 0.f, 0.f, 0.f);
  5528.     }
  5529.     theta = BrRadianToAngle(c->omega.v[1] * dt);
  5530.     DrVector3RotateY(&c->v, theta);
  5531.     BrMatrix34PreRotateY(mat, theta);
  5532.     if (c->keys.up) {
  5533.         BrMatrix34PreRotateX(mat, BrDegreeToAngle(5));
  5534.     }
  5535.     if (c->keys.down) {
  5536.         BrMatrix34PreRotateX(mat, BrDegreeToAngle(360 - 5));
  5537.     }
  5538.     BrVector3Scale(&c->v, (br_vector3*)mat->m[2], -vel);
  5539.     BrVector3Scale(&step, &c->v, dt);
  5540.     BrVector3Accumulate((br_vector3*)&mat->m[3], &step);
  5541.     if (c->keys.holdw) {
  5542.         BrVector3Copy(&step, (br_vector3*)mat->m[3]);
  5543.         BrMatrix34RotateY(mat, BrDegreeToAngle(90) - BrRadianToAngle(atan2f(mat->m[2][2], mat->m[2][0])));
  5544.         BrVector3Copy((br_vector3*)mat->m[3], &step);
  5545.         BrVector3SetFloat(&step, 0.f, -100.f, 0.f);
  5546.         BrVector3Copy(&tmp1, (br_vector3*)&mat->m[3]);
  5547.         findfloor(&tmp1, &step, &tmp2, &tmp_scalar1);
  5548.         tmp1.v[1] += 100.f;
  5549.         findfloor(&tmp1, &step, &tmp3, &tmp_scalar2);
  5550.         if (tmp_scalar2 <= 1.f) {
  5551.             BrVector3SetFloat(&step, 0.f, -5.01f, 0.f);
  5552.             tmp1.v[1] -= 20 * 5.f;
  5553.             for (i = 0; i < 20; i++) {
  5554.                 tmp1.v[1] += 5.f;
  5555.                 findfloor(&tmp1, &step, &tmp3, &tmp_scalar2);
  5556.                 if (tmp_scalar2 <= 1.f) {
  5557.                     break;
  5558.                 }
  5559.             }
  5560.             tmp_scalar2 = -tmp_scalar2 / 20.f + (i + 1) * 0.05f;
  5561.         }
  5562.         if (tmp_scalar2 < tmp_scalar1) {
  5563.             tmp_scalar1 = -tmp_scalar2;
  5564.             BrVector3Copy(&tmp2, &tmp3);
  5565.         }
  5566.         if (tmp_scalar1 <= 1.f) {
  5567.             mat->m[3][1] -= tmp_scalar1 * 100.f;
  5568.             BrMatrix34PreRotateX(mat, BrRadianToAngle(asinf(BrVector3Dot((br_vector3*)mat->m[2], &tmp2))));
  5569.             BrMatrix34PreRotateZ(mat, -BrRadianToAngle(asinf(BrVector3Dot((br_vector3*)mat->m[0], &tmp2))));
  5570.         }
  5571.     }
  5572.     BrVector3Negate((br_vector3*)&c->direction, (br_vector3*)mat->m[2]);
  5573.     BrMatrix34Copy(&c->oldmat, mat);
  5574.     BrMatrix34ApplyP(&c->pos, &c->cmpos, mat);
  5575.     BrVector3InvScale(&c->pos, &c->pos, WORLD_SCALE);
  5576.     BrVector3InvScale((br_vector3*)bnds.mat->m[3], (br_vector3*)bnds.mat->m[3], WORLD_SCALE);
  5577.     GetNewBoundingBox(&c->bounds_world_space, c->bounds, bnds.mat);
  5578.     BrVector3Scale((br_vector3*)bnds.mat->m[3], (br_vector3*)bnds.mat->m[3], WORLD_SCALE);
  5579. }
  5580.  
  5581. // IDA: void __usercall DrVector3RotateY(br_vector3 *v@<EAX>, br_angle t@<EDX>)
  5582. void DrVector3RotateY(br_vector3* v, br_angle t) {
  5583.     br_scalar c;
  5584.     br_scalar s;
  5585.     br_scalar ts;
  5586.     LOG_TRACE("(%p, %d)", v, t);
  5587.  
  5588.     c = cos(BrAngleToRadian(t));
  5589.     s = sin(BrAngleToRadian(t));
  5590.     ts = v->v[0] * c + v->v[2] * s;
  5591.     v->v[2] = v->v[2] * c - v->v[0] * s;
  5592.     v->v[0] = ts;
  5593. }
  5594.  
  5595. // IDA: void __cdecl CrashCarsTogether(br_scalar dt)
  5596. void CrashCarsTogether(br_scalar dt) {
  5597.     int pass;
  5598.     int k;
  5599.     int i;
  5600.     tCollison_data collide_list[32];
  5601.     LOG_TRACE("(%f)", dt);
  5602.  
  5603.     for (i = 0; i < gNum_cars_and_non_cars; i++) {
  5604.         collide_list[i].car = NULL;
  5605.         collide_list[i].ref = gNum_cars_and_non_cars - 1;
  5606.         gActive_car_list[i]->infinite_mass = 0;
  5607.     }
  5608.     for (pass = 0; pass < 5; pass++) {
  5609.         k = CrashCarsTogetherSinglePass(dt, pass, collide_list);
  5610.         if (k <= 0) {
  5611.             break;
  5612.         }
  5613.     }
  5614.     if (k > 0) {
  5615.         for (i = 0; i < gNum_cars_and_non_cars; i++) {
  5616.             BringCarToAGrindingHalt((tCollision_info*)gActive_car_list[i]);
  5617.         }
  5618.     }
  5619. }
  5620.  
  5621. // IDA: int __cdecl CrashCarsTogetherSinglePass(br_scalar dt, int pPass, tCollison_data *collide_list)
  5622. int CrashCarsTogetherSinglePass(br_scalar dt, int pPass, tCollison_data* collide_list) {
  5623.     int i;
  5624.     int j;
  5625.     //int l; // Pierre-Marie Baty -- unused variable
  5626.     //int m; // Pierre-Marie Baty -- unused variable
  5627.     //int n; // Pierre-Marie Baty -- unused variable
  5628.     int collided;
  5629.     int k;
  5630.     //int ref1; // Pierre-Marie Baty -- unused variable
  5631.     //int ref2; // Pierre-Marie Baty -- unused variable
  5632.     int c1im;
  5633.     int c2im;
  5634.     tCollision_info* car_1;
  5635.     tCollision_info* car_2;
  5636.     tCollision_info* car_3;
  5637.     tCollision_info* car_in_middle;
  5638.     tCollision_info* car_on_wall;
  5639.     LOG_TRACE("(%f, %d, %p)", dt, pPass, collide_list);
  5640.  
  5641.     collided = 0;
  5642.     for (i = 0; i < gNum_cars_and_non_cars - 1; i++) {
  5643.         car_1 = (tCollision_info*)gActive_car_list[i];
  5644.         for (j = i + 1; j < gNum_cars_and_non_cars; j++) {
  5645.             car_2 = (tCollision_info*)gActive_car_list[j];
  5646.             if (collide_list[i].ref > 0 || collide_list[j].ref > 0) {
  5647.                 collide_list[i].ref--;
  5648.                 collide_list[j].ref--;
  5649.                 if (SimpleCarCarCollisionTest(car_1, car_2)) {
  5650.                     if (car_1->infinite_mass == -1 && car_2->infinite_mass > 0) {
  5651.                         if (CollideTwoCars(car_1, car_2, -1)) {
  5652.                             if (car_2->infinite_mass >= 256 || pPass >= 4) {
  5653.                                 BringCarToAGrindingHalt(car_2);
  5654.                             } else {
  5655.                                 car_2->infinite_mass = 0;
  5656.                                 k = CollideTwoCarsWithWalls(car_1, car_2, dt);
  5657.                                 car_2->infinite_mass = 256;
  5658.                                 if (k < 0) {
  5659.                                     BringCarToAGrindingHalt(car_2);
  5660.                                 }
  5661.                             }
  5662.                             collide_list[j].ref = gNum_cars_and_non_cars - 2;
  5663.                             collide_list[j].car = car_1;
  5664.                             collided++;
  5665.                         }
  5666.                     } else if (car_2->infinite_mass == -1 && car_1->infinite_mass > 0) {
  5667.                         if (CollideTwoCars(car_1, car_2, -1)) {
  5668.                             if (car_1->infinite_mass >= 256 || pPass >= 4) {
  5669.                                 BringCarToAGrindingHalt(car_1);
  5670.                             } else {
  5671.                                 car_1->infinite_mass = 0;
  5672.                                 k = CollideTwoCarsWithWalls(car_1, car_2, dt);
  5673.                                 car_1->infinite_mass = 256;
  5674.                                 if (k < 0) {
  5675.                                     BringCarToAGrindingHalt(car_1);
  5676.                                 }
  5677.                             }
  5678.                             collide_list[i].ref = gNum_cars_and_non_cars - 2;
  5679.                             collide_list[i].car = car_2;
  5680.                             collided++;
  5681.                         }
  5682.                     } else if (collide_list[i].car || collide_list[j].car) {
  5683.                         if ((collide_list[j].car == NULL) == (collide_list[i].car == NULL)) {
  5684.                             if (collide_list[j].car != collide_list[i].car || (car_1->infinite_mass && car_2->infinite_mass)) {
  5685.                                 if (collide_list[i].car && collide_list[j].car) {
  5686.                                     if (car_1->infinite_mass && car_2->infinite_mass) {
  5687.                                         if ((car_1->infinite_mass != -1 || car_2->infinite_mass != -1) && CollideTwoCars(car_1, car_2, -1)) {
  5688.                                             collide_list[i].ref = gNum_cars_and_non_cars - 2;
  5689.                                             collide_list[j].ref = gNum_cars_and_non_cars - 2;
  5690.                                             if (car_1->infinite_mass && car_2->infinite_mass) {
  5691.                                                 BringCarToAGrindingHalt(car_1);
  5692.                                                 BringCarToAGrindingHalt(car_2);
  5693.                                             } else {
  5694.                                                 k = CollideTwoCarsWithWalls(car_1, car_2, dt);
  5695.                                                 if (k >= 0) {
  5696.                                                     if (k) {
  5697.                                                         if (car_1->infinite_mass >= 0) {
  5698.                                                             car_1->infinite_mass++;
  5699.                                                         }
  5700.                                                         if (car_2->infinite_mass >= 0) {
  5701.                                                             car_2->infinite_mass++;
  5702.                                                         }
  5703.                                                         collided++;
  5704.                                                     }
  5705.                                                 } else {
  5706.                                                     BringCarToAGrindingHalt(car_1);
  5707.                                                     BringCarToAGrindingHalt(car_2);
  5708.                                                     collided++;
  5709.                                                 }
  5710.                                             }
  5711.                                             collided++;
  5712.                                         }
  5713.                                     } else {
  5714.                                         c1im = car_1->infinite_mass;
  5715.                                         c2im = car_2->infinite_mass;
  5716.                                         k = CollideTwoCarsWithWalls(car_1, car_2, dt);
  5717.                                         if (k > -1) {
  5718.                                             if (k) {
  5719.                                                 if (!c2im) {
  5720.                                                     collide_list[j].ref = gNum_cars_and_non_cars - 2;
  5721.                                                 }
  5722.                                                 if (!c1im) {
  5723.                                                     collide_list[i].ref = gNum_cars_and_non_cars - 2;
  5724.                                                 }
  5725.                                                 collided++;
  5726.                                                 if (car_1->infinite_mass >= 0) {
  5727.                                                     car_1->infinite_mass++;
  5728.                                                 }
  5729.                                                 if (car_2->infinite_mass >= 0) {
  5730.                                                     car_2->infinite_mass++;
  5731.                                                 }
  5732.                                             }
  5733.                                         } else {
  5734.                                             BringCarToAGrindingHalt(car_1);
  5735.                                             BringCarToAGrindingHalt(car_2);
  5736.                                             if (c1im >= 0) {
  5737.                                                 collide_list[i].ref = gNum_cars_and_non_cars - 2;
  5738.                                             }
  5739.                                             if (c2im >= 0) {
  5740.                                                 collide_list[j].ref = gNum_cars_and_non_cars - 2;
  5741.                                             }
  5742.                                             collided++;
  5743.                                         }
  5744.                                     }
  5745.                                 }
  5746.                             } else {
  5747.                                 k = CollideTwoCarsWithWalls(car_1, car_2, dt);
  5748.                                 if (k) {
  5749.                                     collide_list[i].ref = gNum_cars_and_non_cars - 2;
  5750.                                     collide_list[j].ref = gNum_cars_and_non_cars - 2;
  5751.                                     if (k == -1) {
  5752.                                         BringCarToAGrindingHalt(car_1);
  5753.                                         BringCarToAGrindingHalt(car_2);
  5754.                                     }
  5755.                                     collided++;
  5756.                                     if (car_1->infinite_mass >= 0) {
  5757.                                         car_1->infinite_mass++;
  5758.                                     }
  5759.                                     if (car_2->infinite_mass >= 0) {
  5760.                                         car_2->infinite_mass++;
  5761.                                     }
  5762.                                 }
  5763.                             }
  5764.                         } else {
  5765.                             c1im = car_1->infinite_mass;
  5766.                             c2im = car_2->infinite_mass;
  5767.                             k = CollideTwoCarsWithWalls(car_1, car_2, dt);
  5768.                             if (k == -1) {
  5769.                                 if (collide_list[i].car) {
  5770.                                     car_3 = collide_list[i].car;
  5771.                                 } else {
  5772.                                     car_3 = collide_list[j].car;
  5773.                                 }
  5774.                                 if (collide_list[i].car) {
  5775.                                     car_in_middle = car_1;
  5776.                                 } else {
  5777.                                     car_in_middle = car_2;
  5778.                                 }
  5779.                                 if (car_3->infinite_mass > 1 || car_3->infinite_mass == -1 || (tU8)(car_in_middle->infinite_mass) > 1 || car_in_middle->infinite_mass == -1) {
  5780.                                     BringCarToAGrindingHalt(car_1);
  5781.                                     BringCarToAGrindingHalt(car_2);
  5782.                                     collide_list[i].ref = gNum_cars_and_non_cars - 2;
  5783.                                     collide_list[j].ref = gNum_cars_and_non_cars - 2;
  5784.                                 } else {
  5785.                                     if (collide_list[i].car) {
  5786.                                         car_on_wall = car_2;
  5787.                                     } else {
  5788.                                         car_on_wall = car_1;
  5789.                                     }
  5790.                                     car_in_middle->infinite_mass = 0;
  5791.                                     car_3->infinite_mass = 0;
  5792.                                     k = CollideTwoCarsWithWalls(car_on_wall, car_in_middle, dt);
  5793.                                     car_in_middle->infinite_mass = 2;
  5794.                                     car_on_wall->infinite_mass++;
  5795.                                     collide_list[i].ref = gNum_cars_and_non_cars - 2;
  5796.                                     collide_list[j].ref = gNum_cars_and_non_cars - 2;
  5797.                                     if (k < 0) {
  5798.                                         BringCarToAGrindingHalt(car_1);
  5799.                                         BringCarToAGrindingHalt(car_2);
  5800.                                     }
  5801.                                 }
  5802.                                 collide_list[i].car = car_2;
  5803.                                 collide_list[j].car = car_1;
  5804.                                 collided++;
  5805.                             } else if (k) {
  5806.                                 collide_list[i].car = car_2;
  5807.                                 collide_list[j].car = car_1;
  5808.                                 if (!c2im) {
  5809.                                     collide_list[j].ref = gNum_cars_and_non_cars - 2;
  5810.                                 }
  5811.                                 if (!c1im) {
  5812.                                     collide_list[i].ref = gNum_cars_and_non_cars - 2;
  5813.                                 }
  5814.                                 collided++;
  5815.                                 if (car_1->infinite_mass >= 0) {
  5816.                                     car_1->infinite_mass++;
  5817.                                 }
  5818.                                 if (car_2->infinite_mass >= 0) {
  5819.                                     car_2->infinite_mass++;
  5820.                                 }
  5821.                             }
  5822.                         }
  5823.                     } else {
  5824.                         k = CollideTwoCarsWithWalls(car_1, car_2, dt);
  5825.                         if (k) {
  5826.                             collide_list[i].car = car_2;
  5827.                             collide_list[j].car = car_1;
  5828.                             collide_list[i].ref = gNum_cars_and_non_cars - 2;
  5829.                             collide_list[j].ref = gNum_cars_and_non_cars - 2;
  5830.                             if (k == -1) {
  5831.                                 BringCarToAGrindingHalt(car_1);
  5832.                                 BringCarToAGrindingHalt(car_2);
  5833.                                 collide_list[i].ref = gNum_cars_and_non_cars - 2;
  5834.                                 collide_list[j].ref = gNum_cars_and_non_cars - 2;
  5835.                             }
  5836.                             collided++;
  5837.                         }
  5838.                     }
  5839.                     CrashEarnings((tCar_spec*)car_1, (tCar_spec*)car_2);
  5840.                 }
  5841.             }
  5842.         }
  5843.     }
  5844.     return collided;
  5845. }
  5846.  
  5847. // IDA: void __usercall BringCarToAGrindingHalt(tCollision_info *car@<EAX>)
  5848. void BringCarToAGrindingHalt(tCollision_info* car) {
  5849.     LOG_TRACE("(%p)", car);
  5850.  
  5851.     BrVector3SetFloat(&car->v, 0.0f, 0.0f, 0.0f);
  5852.     BrVector3SetFloat(&car->omega, 0.0f, 0.0f, 0.0f);
  5853.     BrVector3SetFloat(&car->oldomega, 0.0f, 0.0f, 0.0f);
  5854.     BrMatrix34Copy(&car->car_master_actor->t.t.mat, &car->oldmat);
  5855.     car->infinite_mass = -1;
  5856. }
  5857.  
  5858. // IDA: int __usercall BoundsOverlapTest@<EAX>(br_bounds *b1@<EAX>, br_bounds *b2@<EDX>)
  5859. int BoundsOverlapTest_car(br_bounds* b1, br_bounds* b2) {
  5860.     LOG_TRACE("(%p, %p)", b1, b2);
  5861.  
  5862.     return b2->max.v[0] >= b1->min.v[0]
  5863.         && b1->max.v[0] >= b2->min.v[0]
  5864.         && b2->max.v[1] >= b1->min.v[1]
  5865.         && b1->max.v[1] >= b2->min.v[1]
  5866.         && b2->max.v[2] >= b1->min.v[2]
  5867.         && b1->max.v[2] >= b2->min.v[2];
  5868. }
  5869.  
  5870. // IDA: int __usercall SimpleCarCarCollisionTest@<EAX>(tCollision_info *car1@<EAX>, tCollision_info *car2@<EDX>)
  5871. int SimpleCarCarCollisionTest(tCollision_info* car1, tCollision_info* car2) {
  5872.     LOG_TRACE("(%p, %p)", car1, car2);
  5873.  
  5874.     if (car1->bounds_ws_type == eBounds_ws && car2->bounds_ws_type == eBounds_ws) {
  5875.         return BoundsOverlapTest_car(&car1->bounds_world_space, &car2->bounds_world_space);
  5876.     } else {
  5877.         return 1;
  5878.     }
  5879. }
  5880.  
  5881. // IDA: int __usercall CollideTwoCarsWithWalls@<EAX>(tCollision_info *car1@<EAX>, tCollision_info *car2@<EDX>, br_scalar dt)
  5882. int CollideTwoCarsWithWalls(tCollision_info* car1, tCollision_info* car2, br_scalar dt) {
  5883.     br_vector3 mom1;
  5884.     br_vector3 mom2;
  5885.     int l;
  5886.     int m;
  5887.     int n;
  5888.     int p;
  5889.     int im1;
  5890.     int im2;
  5891.     LOG_TRACE("(%p, %p, %f)", car1, car2, dt);
  5892.  
  5893.     l = 0;
  5894.     m = 0;
  5895.     p = 0;
  5896.     im1 = car1->infinite_mass;
  5897.     im2 = car2->infinite_mass;
  5898.     do {
  5899.         n = CollideTwoCarsRepeatedly(car1, car2, dt);
  5900.         if (n <= 0) {
  5901.             if (n == -1) {
  5902.                 return -1;
  5903.             }
  5904.             l = 0;
  5905.             m = 0;
  5906.         } else {
  5907.             ++p;
  5908.             if (n >= 5) {
  5909.                 if (p >= 10 || car1->infinite_mass || car2->infinite_mass) {
  5910.                     return -1;
  5911.                 }
  5912.                 BrVector3Set(&car1->omega, 0.0f, 0.0f, 0.0f);
  5913.                 BrVector3Set(&car2->omega, 0.0f, 0.0f, 0.0f);
  5914.                 BrVector3Scale(&mom1, &car1->v, car1->M);
  5915.                 BrVector3Scale(&mom2, &car2->v, car2->M);
  5916.                 BrVector3Accumulate(&mom1, &mom2);
  5917.                 BrVector3InvScale(&car1->v, &mom1, car2->M + car1->M);
  5918.                 car2->v = car1->v;
  5919.                 RotateCar(car1, dt);
  5920.                 TranslateCar(car1, dt);
  5921.                 RotateCar(car2, dt);
  5922.                 TranslateCar(car2, dt);
  5923.                 if (CollideTwoCars(car1, car2, -1)) {
  5924.                     return -1;
  5925.                 }
  5926.                 if (im1 || im2) {
  5927.                     return -1;
  5928.                 }
  5929.             }
  5930.             if (!im1) {
  5931.                 l = CollideCarWithWall(car1, dt);
  5932.             }
  5933.             if (!im2) {
  5934.                 m = CollideCarWithWall(car2, dt);
  5935.             }
  5936.             if (p < 3) {
  5937.                 car1->infinite_mass = im1;
  5938.                 car2->infinite_mass = im2;
  5939.             }
  5940.             if (p > 5) {
  5941.                 if (l) {
  5942.                     car1->infinite_mass |= 0x100u;
  5943.                 }
  5944.                 if (m) {
  5945.                     car2->infinite_mass |= 0x100u;
  5946.                 }
  5947.             }
  5948.             if (car1->infinite_mass && car2->infinite_mass) {
  5949.                 return -1;
  5950.             }
  5951.         }
  5952.     } while ((l || m) && p < 10);
  5953.     if (p < 10) {
  5954.         return p;
  5955.     } else {
  5956.         return -1;
  5957.     }
  5958. }
  5959.  
  5960. // IDA: int __usercall CollideTwoCarsRepeatedly@<EAX>(tCollision_info *car1@<EAX>, tCollision_info *car2@<EDX>, br_scalar dt)
  5961. int CollideTwoCarsRepeatedly(tCollision_info* car1, tCollision_info* car2, br_scalar dt) {
  5962.     int l;
  5963.     int collide;
  5964.     //br_scalar ts; // Pierre-Marie Baty -- unused variable
  5965.     LOG_TRACE("(%p, %p, %f)", car1, car2, dt);
  5966.  
  5967.     l = 0;
  5968.     ModifyCarsMass(car1, car2);
  5969.     while (1) {
  5970.         collide = CollideTwoCars(car1, car2, l);
  5971.         if (!collide) {
  5972.             break;
  5973.         }
  5974.         if (collide == -1) {
  5975.             ResetCarsMass(car1, car2);
  5976.             return -1;
  5977.         }
  5978.         if (++l >= 5) {
  5979.             break;
  5980.         }
  5981.         RotateCar(car1, dt);
  5982.         TranslateCar(car1, dt);
  5983.         RotateCar(car2, dt);
  5984.         TranslateCar(car2, dt);
  5985.     }
  5986.     if (l > 0) {
  5987.         car1->frame_collision_flag += 256;
  5988.         car2->frame_collision_flag += 256;
  5989.         if (gNet_mode == eNet_mode_host) {
  5990.             car1->last_car_car_collision = gLast_mechanics_time + 40;
  5991.             car2->last_car_car_collision = gLast_mechanics_time + 40;
  5992.         }
  5993.     }
  5994.     ResetCarsMass(car1, car2);
  5995.     return l;
  5996. }
  5997.  
  5998. // IDA: int __usercall CollideTwoCars@<EAX>(tCollision_info *car1@<EAX>, tCollision_info *car2@<EDX>, int pPass@<EBX>)
  5999. int CollideTwoCars(tCollision_info* car1, tCollision_info* car2, int pPass) {
  6000.     int k;
  6001.     int old_k;
  6002.     int i;
  6003.     int j;
  6004.     //br_scalar dist; // Pierre-Marie Baty -- unused variable
  6005.     //br_scalar ts; // Pierre-Marie Baty -- unused variable
  6006.     br_bounds new_car1_bnds;
  6007.     br_bounds new_car2_bnds;
  6008.     br_bounds bnds;
  6009.     br_matrix34* mat1;
  6010.     br_matrix34* mat2;
  6011.     br_matrix34* oldmat1;
  6012.     br_matrix34* oldmat2;
  6013.     br_matrix34 inv_mat1;
  6014.     br_matrix34 inv_mat2;
  6015.     br_matrix34 inv_oldmat1;
  6016.     br_matrix34 inv_oldmat2;
  6017.     br_matrix34 car2_to_car1;
  6018.     br_matrix34 car1_to_car2;
  6019.     br_matrix34 old_car2_to_car1;
  6020.     br_matrix34 old_car1_to_car2;
  6021.     br_matrix34 car1_to_old_car1;
  6022.     br_matrix34 car2_to_old_car2;
  6023.     br_vector3 r[16];
  6024.     br_vector3 n[16];
  6025.     //br_vector3 sep; // Pierre-Marie Baty -- unused variable
  6026.     br_vector3 tv;
  6027.     int add_point;
  6028.     static br_vector3 oldr1;
  6029.     static br_vector3 oldr2;
  6030.     static br_vector3 oldn1;
  6031.     static br_vector3 oldn2;
  6032.     static int is_old_point_available;
  6033.     LOG_TRACE("(%p, %p, %d)", car1, car2, pPass);
  6034.  
  6035. #ifdef DETHRACE_FIX_BUGS
  6036.     // this variable is used uninitialized
  6037.     add_point = 0;
  6038. #endif
  6039.  
  6040.     if (!gCar_car_collisions) {
  6041.         return 0;
  6042.     }
  6043.     if (pPass < 0 && !SimpleCarCarCollisionTest(car1, car2)) {
  6044.         return 0;
  6045.     }
  6046.  
  6047.     mat1 = &car1->car_master_actor->t.t.mat;
  6048.     mat2 = &car2->car_master_actor->t.t.mat;
  6049.     oldmat1 = &car1->oldmat;
  6050.     oldmat2 = &car2->oldmat;
  6051.     BrMatrix34LPInverse(&inv_oldmat1, &car1->oldmat);
  6052.     BrMatrix34LPInverse(&inv_oldmat2, &car2->oldmat);
  6053.     BrMatrix34Mul(&car1_to_old_car1, mat1, &inv_oldmat1);
  6054.     BrMatrix34Mul(&car2_to_old_car2, mat2, &inv_oldmat2);
  6055.     BrMatrix34Mul(&old_car2_to_car1, oldmat2, &inv_oldmat1);
  6056.     GetNewBoundingBox(&new_car1_bnds, &car1->bounds[1], &car1_to_old_car1);
  6057.     GetNewBoundingBox(&new_car2_bnds, &car2->bounds[1], &car2_to_old_car2);
  6058.  
  6059.     for (i = 0; i < 3; ++i) {
  6060.         new_car1_bnds.min.v[i] = MIN(car1->bounds[1].min.v[i], new_car1_bnds.min.v[i]);
  6061.         new_car1_bnds.max.v[i] = MAX(car1->bounds[1].max.v[i], new_car1_bnds.max.v[i]);
  6062.  
  6063.         new_car2_bnds.min.v[i] = MIN(car2->bounds[1].min.v[i], new_car2_bnds.min.v[i]);
  6064.         new_car2_bnds.max.v[i] = MAX(car2->bounds[1].max.v[i], new_car2_bnds.max.v[i]);
  6065.     }
  6066.     GetNewBoundingBox(&bnds, &new_car2_bnds, &old_car2_to_car1);
  6067.  
  6068.     if (new_car1_bnds.max.v[0] < bnds.min.v[0]
  6069.         || bnds.max.v[0] < new_car1_bnds.min.v[0]
  6070.         || new_car1_bnds.max.v[1] < bnds.min.v[1]
  6071.         || bnds.max.v[1] < new_car1_bnds.min.v[1]
  6072.         || new_car1_bnds.max.v[2] < bnds.min.v[2]
  6073.         || bnds.max.v[2] < new_car1_bnds.min.v[2]) {
  6074.         return 0;
  6075.     }
  6076.     BrMatrix34LPInverse(&inv_mat1, mat1);
  6077.     BrMatrix34LPInverse(&inv_mat2, mat2);
  6078.     BrMatrix34Mul(&car2_to_car1, mat2, &inv_mat1);
  6079.     BrMatrix34Mul(&car1_to_car2, mat1, &inv_mat2);
  6080.     BrMatrix34Mul(&old_car2_to_car1, oldmat2, &inv_oldmat1);
  6081.     BrMatrix34Mul(&old_car1_to_car2, oldmat1, &inv_oldmat2);
  6082.     BrMatrix34Mul(&car1_to_old_car1, mat1, &inv_oldmat1);
  6083.     BrMatrix34Mul(&car2_to_old_car2, mat2, &inv_oldmat2);
  6084.     do {
  6085.         k = 0;
  6086.         k += FacePointCarCarCollide(car1, car2, &car2_to_car1, &old_car2_to_car1, &car1_to_old_car1, r, n, 8, 0);
  6087.         k += FacePointCarCarCollide(car2, car1, &car1_to_car2, &old_car1_to_car2, &car2_to_old_car2, &r[2 * k], &n[2 * k], 8 - k, 1);
  6088.         old_k = k;
  6089.  
  6090.         if (k < 3 || add_point) {
  6091.             k += GetEdgeEdgeCollisions(&car1->bounds[1], &car2->bounds[1], &car2_to_car1, &car1_to_car2, &old_car2_to_car1, &old_car1_to_car2, &car1_to_old_car1, &r[2 * k], &n[2 * k], 8 - k);
  6092.         }
  6093.         if (k == -1) {
  6094.             TestOldMats(car1, car2, 1);
  6095.         }
  6096.         if (!k) {
  6097.             return 0;
  6098.         }
  6099.         if (k > 4) {
  6100.             i = old_k;
  6101.             j = old_k;
  6102.             while (i < k) {
  6103.                 if (BrVector3Dot(&n[2 * i + 1], &r[2 * i + 1]) <= 0.0f || i - j >= k - 4) {
  6104.                     if (j != i) {
  6105.                         r[2 * j] = r[2 * i];
  6106.                     }
  6107.                     n[2 * j] = n[2 * i];
  6108.                     r[2 * j + 1] = r[2 * i + 1];
  6109.                     n[2 * j + 1] = n[2 * i + 1];
  6110.                 } else {
  6111.                     j--;
  6112.                 }
  6113.                 i++;
  6114.                 j++;
  6115.             }
  6116.             k = j;
  6117.         }
  6118.         for (i = 0; i < k; ++i) {
  6119.             BrVector3Sub(&r[2 * i], &r[2 * i], &car1->cmpos);
  6120.             BrVector3Sub(&r[2 * i + 1], &r[2 * i + 1], &car2->cmpos);
  6121.         }
  6122.         if (add_point == -1) {
  6123.             return k;
  6124.         }
  6125.         car1->doing_nothing_flag = 0;
  6126.         car2->doing_nothing_flag = 0;
  6127.         if (k < 3 && add_point) {
  6128.             for (i = 0; i < k; i++) {
  6129.                 BrVector3Sub(&tv, &r[2 * i], &oldr1);
  6130.                 if (BrVector3LengthSquared(&tv) < 0.01f) {
  6131.                     add_point = 0;
  6132.                 }
  6133.             }
  6134.             if (add_point) {
  6135.                 r[2 * k] = oldr1;
  6136.                 r[2 * k + 1] = oldr2;
  6137.                 n[2 * k] = oldn1;
  6138.                 n[2 * k + 1] = oldn2;
  6139.                 k++;
  6140.             }
  6141.         }
  6142.         oldr1 = r[0];
  6143.         oldr2 = r[1];
  6144.         oldn1 = n[0];
  6145.         oldn2 = n[1];
  6146.         if (k < 3) {
  6147.             if (car1->collision_flag && !car1->infinite_mass) {
  6148.  
  6149.                 for (i = 0; i < k; i++) {
  6150.                     if (BrVector3Dot(&n[2 * i], &car1->old_norm) < -0.9f) {
  6151.                         car1->infinite_mass |= 0x100u;
  6152.                     }
  6153.                 }
  6154.                 if (!car1->infinite_mass) {
  6155.                     r[2 * k] = car1->old_point;
  6156.                     n[2 * k] = car1->old_norm;
  6157.                     BrVector3SetFloat(&n[2 * k + 1], 0.0f, 0.0f, 0.0f);
  6158.                     BrVector3SetFloat(&r[2 * k + 1], 0.0f, 0.0f, 0.0f);
  6159.                     k++;
  6160.                 }
  6161.             }
  6162.             if (car2->collision_flag && !car2->infinite_mass) {
  6163.                 for (i = 0; i < k; i++) {
  6164.                     if (BrVector3Dot(&n[2 * i + 1], &car2->old_norm) < -0.9f) {
  6165.                         car2->infinite_mass |= 0x100u;
  6166.                     }
  6167.                 }
  6168.                 if (!car2->infinite_mass) {
  6169.                     r[2 * k + 1] = car2->old_point;
  6170.                     n[2 * k + 1] = car2->old_norm;
  6171.                     BrVector3SetFloat(&n[2 * k], 0.0f, 0.0f, 0.0f);
  6172.                     BrVector3SetFloat(&r[2 * k], 0.0f, 0.0f, 0.0f);
  6173.                     k++;
  6174.                 }
  6175.             }
  6176.         }
  6177.         if (car1->infinite_mass && car2->infinite_mass) {
  6178.             return -1;
  6179.         }
  6180.     } while (DoCollide(car1, car2, r, n, k, pPass, &car1_to_car2));
  6181.     return k;
  6182. }
  6183.  
  6184. // IDA: int __usercall GetEdgeEdgeCollisions@<EAX>(br_bounds *pB1@<EAX>, br_bounds *pB2@<EDX>, br_matrix34 *pM21@<EBX>, br_matrix34 *pM12@<ECX>, br_matrix34 *pMo21, br_matrix34 *pMo12, br_matrix34 *pM1o1, br_vector3 *pPoint_list, br_vector3 *pNorm_list, int pMax)
  6185. int GetEdgeEdgeCollisions(br_bounds* pB1, br_bounds* pB2, br_matrix34* pM21, br_matrix34* pM12, br_matrix34* pMo21, br_matrix34* pMo12, br_matrix34* pM1o1, br_vector3* pPoint_list, br_vector3* pNorm_list, int pMax) {
  6186.     br_vector3 p1;
  6187.     br_vector3 p2;
  6188.     br_vector3 tp1;
  6189.     br_vector3 tp2;
  6190.     br_vector3 tp3;
  6191.     br_vector3 hp1;
  6192.     br_vector3 hp2;
  6193.     br_vector3 hp3;
  6194.     br_vector3 shp1;
  6195.     br_vector3 shp2;
  6196.     br_vector3 edge;
  6197.     int plane1;
  6198.     int plane2;
  6199.     int plane3;
  6200.     br_scalar ts;
  6201.     int i;
  6202.     int j;
  6203.     int n;
  6204.     LOG_TRACE("(%p, %p, %p, %p, %p, %p, %p, %p, %p, %d)", pB1, pB2, pM21, pM12, pMo21, pMo12, pM1o1, pPoint_list, pNorm_list, pMax);
  6205.  
  6206.     // EdgeEdge final version
  6207.     n = 0;
  6208.     if (pMax < 1) {
  6209.         return 0;
  6210.     }
  6211.     for (i = 0; i < 4; i++) {
  6212.         if (i == 3) {
  6213.             tp1 = pB2->min;
  6214.         } else {
  6215.             tp1 = pB2->max;
  6216.             tp1.v[i] = pB2->min.v[i];
  6217.         }
  6218.         for (j = 0; j < 3; j++) {
  6219.             tp2 = tp1;
  6220.             if (pB2->max.v[j] == tp2.v[j]) {
  6221.                 tp2.v[j] = pB2->min.v[j];
  6222.             } else {
  6223.                 tp2.v[j] = pB2->max.v[j];
  6224.             }
  6225.  
  6226.             BrMatrix34ApplyP(&p1, &tp1, pM21);
  6227.             BrMatrix34ApplyP(&p2, &tp2, pM21);
  6228.             plane1 = LineBoxColl(&p1, &p2, pB1, &hp1);
  6229.             if (plane1 == 0) {
  6230.                 continue;
  6231.             }
  6232.             plane2 = LineBoxColl(&p2, &p1, pB1, &hp2);
  6233.             if (plane1 == 8 || plane2 == 8 || plane2 == 0) {
  6234.                 continue;
  6235.             }
  6236.             BrVector3Add(&p1, &hp1, &hp2);
  6237.             BrVector3Scale(&p1, &p1, 0.5f);
  6238.             BrMatrix34ApplyP(&tp3, &p1, pM12);
  6239.             BrMatrix34ApplyP(&p2, &tp3, pMo21);
  6240.             plane3 = LineBoxColl(&p2, &p1, pB1, &hp3);
  6241.             // if (plane3 != 8 && plane3 != 0) {
  6242.             //     goto LABEL_25;
  6243.             // }
  6244.             if (plane3 == 8 || plane3 == 0) {
  6245.                 BrVector3Sub(&tp3, &p2, &p1);
  6246.                 ts = BrVector3Length(&tp3);
  6247.                 ts = ts / 0.01f;
  6248.                 if (ts == 0.0f) {
  6249.                     continue;
  6250.                 }
  6251.                 BrVector3InvScale(&tp3, &tp3, ts);
  6252.                 BrVector3Accumulate(&p2, &tp3);
  6253.                 plane3 = LineBoxColl(&p2, &p1, pB1, &hp3);
  6254.                 if (plane3 == 8) {
  6255.                     continue;
  6256.                 }
  6257.             }
  6258.             if (plane3 == 0) {
  6259.                 continue;
  6260.             }
  6261.  
  6262.             BrMatrix34ApplyP(&shp1, &hp1, pM12);
  6263.             BrMatrix34ApplyP(&shp2, &hp2, pM12);
  6264.             if ((plane1 ^ plane2) != 4 && (plane3 == plane1 || plane3 == plane2)) {
  6265.                 if (n >= pMax) {
  6266.                     return n;
  6267.                 }
  6268.                 GetBoundsEdge(&pPoint_list[2 * n], &edge, pB1, plane1, plane2, &p2, &hp1, &hp2, 0);
  6269.                 BrVector3Accumulate(&shp1, &shp2);
  6270.                 BrVector3Scale(&pPoint_list[2 * n + 1], &shp1, 0.5f);
  6271.                 BrVector3Sub(&p1, &hp1, &hp2);
  6272.                 BrVector3Cross(&p2, &edge, &p1);
  6273.                 BrVector3Normalise(&p2, &p2);
  6274.                 BrVector3Add(&p1, &pB1->max, &pB1->min);
  6275.                 BrVector3Scale(&p1, &p1, 0.5f);
  6276.                 BrVector3Sub(&p1, &pPoint_list[2 * n], &p1);
  6277.                 if (BrVector3Dot(&p1, &p2) > 0.0) {
  6278.                     BrVector3Negate(&p2, &p2);
  6279.                 }
  6280.                 BrMatrix34ApplyV(&p1, &p2, pM12);
  6281.                 BrMatrix34TApplyV(&pNorm_list[2 * n], &p1, pMo12);
  6282.                 BrMatrix34TApplyV(&pNorm_list[2 * n + 1], &p2, pMo21);
  6283.                 BrVector3Negate(&pNorm_list[2 * n + 1], &pNorm_list[2 * n + 1]);
  6284.                 n++;
  6285.             } else if ((plane1 ^ plane2) == 4) {
  6286.                 if (pMax - 1 <= n) {
  6287.                     return n;
  6288.                 }
  6289.                 GetBoundsEdge(&pPoint_list[2 * n], &edge, pB1, plane1, plane3, &p2, &hp1, &hp2, 0);
  6290.                 GetBoundsEdge(&pPoint_list[2 * n + 2], &edge, pB1, plane2, plane3, &p2, &hp1, &hp2, 0);
  6291.                 pPoint_list[2 * n + 1] = shp1;
  6292.                 pPoint_list[2 * n + 3] = shp2;
  6293.                 BrVector3Sub(&p1, &hp1, &hp2);
  6294.                 BrMatrix34ApplyV(&p2, &p1, pM12);
  6295.                 BrMatrix34ApplyV(&p1, &p2, pMo21);
  6296.                 BrVector3Cross(&p2, &edge, &p1);
  6297.                 BrVector3Normalise(&pNorm_list[2 * n], &p2);
  6298.                 GetPlaneNormal(&edge, plane3);
  6299.                 if (BrVector3Dot(&pNorm_list[2 * n], &edge) < 0.0f) {
  6300.                     BrVector3Negate(&pNorm_list[2 * n], &pNorm_list[2 * n]);
  6301.                 }
  6302.                 BrMatrix34ApplyV(&pNorm_list[2 * n + 1], &pNorm_list[2 * n], pMo12);
  6303.                 BrVector3Negate(&pNorm_list[2 * n + 1], &pNorm_list[2 * n + 1]);
  6304.                 BrMatrix34ApplyV(&tp3, &pNorm_list[2 * n], pM12);
  6305.                 BrMatrix34ApplyV(&pNorm_list[2 * n], &tp3, pMo21);
  6306.                 pNorm_list[2 * n + 2] = pNorm_list[2 * n];
  6307.                 pNorm_list[2 * n + 3] = pNorm_list[2 * n + 1];
  6308.                 n += 2;
  6309.             } else {
  6310.                 if (pMax - 1 <= n) {
  6311.                     return n;
  6312.                 }
  6313.                 GetBoundsEdge(&pPoint_list[2 * n], &edge, pB1, plane1, plane3, &p2, &hp1, &hp2, 0);
  6314.                 GetBoundsEdge(&pPoint_list[2 * n + 2], &edge, pB1, plane2, plane3, &p2, &hp1, &hp2, 0);
  6315.                 BrMatrix34ApplyP(&pPoint_list[2 * n + 1], &hp1, pM12);
  6316.                 BrMatrix34ApplyP(&pPoint_list[2 * n + 3], &hp2, pM12);
  6317.                 GetPlaneNormal(&pNorm_list[2 * n], plane3);
  6318.                 BrMatrix34ApplyV(&pNorm_list[2 * n + 2], &pNorm_list[2 * n], pM1o1);
  6319.                 BrMatrix34ApplyV(&pNorm_list[2 * n + 1], &pNorm_list[2 * n + 2], pMo12);
  6320.                 pNorm_list[2 * n] = pNorm_list[2 * n + 2];
  6321.                 BrVector3Negate(&pNorm_list[2 * n + 1], &pNorm_list[2 * n + 1]);
  6322.                 pNorm_list[2 * n + 3] = pNorm_list[2 * n + 1];
  6323.                 n += 2;
  6324.             }
  6325.         }
  6326.     }
  6327.     return n;
  6328. }
  6329.  
  6330. // IDA: int __usercall FacePointCarCarCollide@<EAX>(tCollision_info *car1@<EAX>, tCollision_info *car2@<EDX>, br_matrix34 *pMms@<EBX>, br_matrix34 *pMoms@<ECX>, br_matrix34 *pMsos, br_vector3 *pPoint_list, br_vector3 *pNorm_list, int pMax, int order)
  6331. int FacePointCarCarCollide(tCollision_info* car1, tCollision_info* car2, br_matrix34* pMms, br_matrix34* pMoms, br_matrix34* pMsos, br_vector3* pPoint_list, br_vector3* pNorm_list, int pMax, int order) {
  6332.     int k;
  6333.     int i;
  6334.     int j;
  6335.     int l;
  6336.     int plane;
  6337.     br_vector3 a;
  6338.     br_vector3 a1;
  6339.     br_vector3 aa;
  6340.     br_vector3 bb;
  6341.     br_vector3 norm;
  6342.     br_vector3 hp;
  6343.     br_vector3 centre;
  6344.     br_scalar dist;
  6345.     br_bounds* pStat_box;
  6346.     //br_bounds* pMove_box; // Pierre-Marie Baty -- unused variable
  6347.     LOG_TRACE("(%p, %p, %p, %p, %p, %p, %p, %d, %d)", car1, car2, pMms, pMoms, pMsos, pPoint_list, pNorm_list, pMax, order);
  6348.  
  6349.     k = 0;
  6350.     pStat_box = &car2->bounds[1];
  6351.     BrVector3Add(&centre, &car2->bounds[1].max, &car2->bounds[1].min);
  6352.     BrVector3InvScale(&centre, &centre, 2.0f);
  6353.     for (i = 0; i < car2->extra_point_num + 8; i++) {
  6354.         if (i >= 8) {
  6355.             a = car2->extra_points[i - 8];
  6356.         } else {
  6357.             a.v[0] = ((i & 2) == 0) * pStat_box->min.v[0] + ((i & 2) >> 1) * pStat_box->max.v[0];
  6358.             a.v[1] = ((i & 1) == 0) * pStat_box->min.v[1] + (i & 1) * pStat_box->max.v[1];
  6359.             a.v[2] = ((i & 4) == 0) * pStat_box->max.v[2] + ((i & 4) >> 2) * pStat_box->min.v[2];
  6360.         }
  6361.         BrMatrix34ApplyP(&aa, &a, pMms);
  6362.         BrMatrix34ApplyP(&bb, &a, pMoms);
  6363.         BrVector3Sub(&aa, &aa, &bb);
  6364.         dist = BrVector3Length(&aa);
  6365.         if (dist >= 0.00001f) {
  6366.             BrVector3Scale(&a1, &aa, (0.05f / WORLD_SCALE) / dist); // 0.0072463769 * 6.9 = 0.05
  6367.             BrVector3Accumulate(&aa, &a1);
  6368.             BrVector3Accumulate(&aa, &bb);
  6369.             plane = LineBoxCollWithSphere(&bb, &aa, &car1->bounds[1], &hp);
  6370.             if ((plane & 7) != 0) {
  6371.                 GetPlaneNormal(&norm, plane);
  6372.  
  6373.                 j = 2 * k + order;
  6374.                 l = 2 * k + (order == 0);
  6375.                 BrMatrix34ApplyV(&pNorm_list[j], &norm, pMsos);
  6376.                 BrMatrix34TApplyV(&pNorm_list[l], &pNorm_list[j], pMoms);
  6377.                 BrVector3Negate(&pNorm_list[l], &pNorm_list[l]);
  6378.                 if ((pNorm_list[l].v[0] >= 0.0f) != (centre.v[0] <= a.v[0]) || (pNorm_list[l].v[1] >= 0.0f) != (centre.v[1] <= a.v[1]) || (pNorm_list[l].v[2] >= 0.0f) != (a.v[2] >= centre.v[2])
  6379.                     || !TestOldMats(car1, car2, 0)) {
  6380.                     pPoint_list[l] = a;
  6381.                     pPoint_list[j] = hp;
  6382.                     k++;
  6383.                     if (pMax == k) {
  6384.                         return k;
  6385.                     }
  6386.                 }
  6387.             }
  6388.         }
  6389.     }
  6390.     return k;
  6391. }
  6392.  
  6393. // IDA: void __usercall MungeCarsMass(tCollision_info *pCar@<EAX>, br_scalar pFactor)
  6394. void MungeCarsMass(tCollision_info* pCar, br_scalar pFactor) {
  6395.     LOG_TRACE("(%p, %f)", pCar, pFactor);
  6396.  
  6397.     pCar->M = pCar->M * pFactor;
  6398.     BrVector3Scale(&pCar->I, &pCar->I, pFactor);
  6399. }
  6400.  
  6401. // IDA: void __usercall ModifyCarsMass(tCollision_info *pCar_1@<EAX>, tCollision_info *pCar_2@<EDX>)
  6402. void ModifyCarsMass(tCollision_info* pCar_1, tCollision_info* pCar_2) {
  6403.     LOG_TRACE("(%p, %p)", pCar_1, pCar_2);
  6404.  
  6405.     if (pCar_1->driver > eDriver_non_car && ((tCar_spec*)pCar_1)->collision_mass_multiplier != 1.0f) {
  6406.         MungeCarsMass(pCar_1, ((tCar_spec*)pCar_1)->collision_mass_multiplier);
  6407.     }
  6408.     if (pCar_2->driver > eDriver_non_car && ((tCar_spec*)pCar_2)->collision_mass_multiplier != 1.0f) {
  6409.         MungeCarsMass(pCar_2, ((tCar_spec*)pCar_2)->collision_mass_multiplier);
  6410.     }
  6411. }
  6412.  
  6413. // IDA: void __usercall ResetCarsMass(tCollision_info *pCar_1@<EAX>, tCollision_info *pCar_2@<EDX>)
  6414. void ResetCarsMass(tCollision_info* pCar_1, tCollision_info* pCar_2) {
  6415.     LOG_TRACE("(%p, %p)", pCar_1, pCar_2);
  6416.  
  6417.     if (pCar_1->driver > eDriver_non_car && ((tCar_spec*)pCar_1)->collision_mass_multiplier != 1.0f) {
  6418.         MungeCarsMass(pCar_1, 1.0f / ((tCar_spec*)pCar_1)->collision_mass_multiplier);
  6419.     }
  6420.     if (pCar_2->driver > eDriver_non_car && ((tCar_spec*)pCar_2)->collision_mass_multiplier != 1.0f) {
  6421.         MungeCarsMass(pCar_2, 1.0f / ((tCar_spec*)pCar_2)->collision_mass_multiplier);
  6422.     }
  6423. }
  6424.  
  6425. // IDA: int __usercall DoCollide@<EAX>(tCollision_info *car1@<EAX>, tCollision_info *car2@<EDX>, br_vector3 *r@<EBX>, br_vector3 *n@<ECX>, int k, int pPass, br_matrix34 *mat1_to_mat2)
  6426. int DoCollide(tCollision_info* car1, tCollision_info* car2, br_vector3* r, br_vector3* n, int k, int pPass, br_matrix34* mat1_to_mat2) {
  6427.     br_matrix34* mat1;
  6428.     br_matrix34* mat2;
  6429.     br_matrix34* oldmat1;
  6430.     br_matrix34* oldmat2;
  6431.     br_matrix4 M;
  6432.     br_vector3 tau1[8];
  6433.     br_vector3 a;
  6434.     br_vector3 norm;
  6435.     br_vector3 f1;
  6436.     br_vector3 f2;
  6437.     br_vector3 pos1;
  6438.     br_vector3 pos2;
  6439.     br_vector3 max_friction;
  6440.     br_vector3 tv;
  6441.     br_vector3 tv2;
  6442.     br_vector3* tau2;
  6443.     br_vector3 torque1;
  6444.     br_vector3 torque2;
  6445.     br_scalar f[4];
  6446.     br_scalar d[4];
  6447.     br_scalar ts;
  6448.     br_scalar tforce;
  6449.     int i;
  6450.     int j;
  6451.     int car1_point;
  6452.     int car2_point;
  6453.     int plane;
  6454.     int move_car1;
  6455.     int move_car2;
  6456.     //br_vector3 a2; // Pierre-Marie Baty -- unused variable
  6457.     br_vector3 f12;
  6458.     br_vector3 f22;
  6459.     br_vector3 point_vel1;
  6460.     br_vector3 point_vel2;
  6461.     //br_scalar fudge_multiplier; // Pierre-Marie Baty -- unused variable
  6462.     br_scalar factor;
  6463.     int need_to_fudge;
  6464.     LOG_TRACE("(%p, %p, %p, %p, %d, %d, %p)", car1, car2, r, n, k, pPass, mat1_to_mat2);
  6465.  
  6466.     mat1 = &car1->car_master_actor->t.t.mat;
  6467.     mat2 = &car2->car_master_actor->t.t.mat;
  6468.     oldmat1 = &car1->oldmat;
  6469.     oldmat2 = &car2->oldmat;
  6470.     tau2 = &tau1[4];
  6471.     move_car1 = !car1->infinite_mass && car1->min_torque_squared == 0.0f;
  6472.     move_car2 = !car2->infinite_mass && car2->min_torque_squared == 0.0f;
  6473.     if (k > 4) {
  6474.         k = 4;
  6475.     }
  6476.     BrMatrix34Copy(mat1, oldmat1);
  6477.     BrMatrix34Copy(mat2, oldmat2);
  6478.     BrVector3Copy(&car1->omega, &car1->oldomega);
  6479.     BrVector3Copy(&car2->omega, &car2->oldomega);
  6480.     BrMatrix34TApplyV(&car1->velocity_car_space, &car1->v, mat1);
  6481.     BrMatrix34TApplyV(&car2->velocity_car_space, &car2->v, mat2);
  6482.     need_to_fudge = 1;
  6483.     for (i = 0; i < k; ++i) {
  6484.         BrVector3Cross(&tau1[i], &r[2 * i], &n[2 * i]);
  6485.         BrVector3Cross(&tau2[i], &r[2 * i + 1], &n[2 * i + 1]);
  6486.         Vector3Div(&tau1[i], &tau1[i], &car1->I);
  6487.         Vector3Div(&tau2[i], &tau2[i], &car2->I);
  6488.         BrVector3Cross(&tv, &car1->omega, &r[2 * i]);
  6489.         BrVector3Accumulate(&tv, &car1->velocity_car_space);
  6490.         d[i] = -BrVector3Dot(&n[2 * i], &tv);
  6491.         BrVector3Cross(&tv, &car2->omega, &r[2 * i + 1]);
  6492.         BrVector3Accumulate(&tv, &car2->velocity_car_space);
  6493.         d[i] -= BrVector3Dot(&n[2 * i + 1], &tv);
  6494.         if (d[i] > 0.0f) {
  6495.             need_to_fudge = 0;
  6496.         }
  6497.     }
  6498.     if (need_to_fudge) {
  6499.         d[0] = 0.5f;
  6500.     }
  6501.     factor = 0.0f;
  6502.     if (move_car1) {
  6503.         factor = car1->M + factor;
  6504.     }
  6505.     if (move_car2) {
  6506.         factor = car2->M + factor;
  6507.     }
  6508.     for (i = 0; i < k; i++) {
  6509.         for (j = 0; j < k; j++) {
  6510.             if (move_car1) {
  6511.                 BrVector3Cross(&tv, &tau1[j], &r[2 * i]);
  6512.                 BrVector3InvScale(&norm, &n[2 * j], car1->M);
  6513.                 BrVector3Accumulate(&tv, &norm);
  6514.                 M.m[i][j] = BrVector3Dot(&n[2 * i], &tv);
  6515.             } else {
  6516.                 M.m[i][j] = 0.0f;
  6517.             }
  6518.             if (move_car2) {
  6519.                 BrVector3Cross(&tv, &tau2[j], &r[2 * i + 1]);
  6520.                 BrVector3InvScale(&norm, &n[2 * j + 1], car2->M);
  6521.                 BrVector3Accumulate(&tv, &norm);
  6522.                 M.m[i][j] += BrVector3Dot(&n[2 * i + 1], &tv);
  6523.             }
  6524.             M.m[i][j] *= factor;
  6525.         }
  6526.     }
  6527.     switch (k) {
  6528.     case 1:
  6529.         ts = SinglePointColl(f, &M, d);
  6530.         break;
  6531.     case 2:
  6532.         ts = TwoPointCollB(f, &M, d, tau1, n);
  6533.         break;
  6534.     case 3:
  6535.         d[3] = 0.f;
  6536.         ts = ThreePointCollRecB(f, &M, d, tau1, n);
  6537.         break;
  6538.     case 4:
  6539.         ts = FourPointCollB(f, &M, d, tau1, n);
  6540.         break;
  6541.     default:
  6542.         ts = 0;
  6543.         break;
  6544.     }
  6545.     if (k > 3) {
  6546.         k = 3;
  6547.     }
  6548.     if (fabsf(ts) <= 0.000001f) {
  6549.         return 0;
  6550.     }
  6551.     BrVector3SetFloat(&f1, 0.0f, 0.0f, 0.0f);
  6552.     BrVector3SetFloat(&f2, 0.0f, 0.0f, 0.0f);
  6553.     BrVector3SetFloat(&pos1, 0.0f, 0.0f, 0.0f);
  6554.     BrVector3SetFloat(&pos2, 0.0f, 0.0f, 0.0f);
  6555.     BrVector3SetFloat(&torque1, 0.0f, 0.0f, 0.0f);
  6556.     BrVector3SetFloat(&torque2, 0.0f, 0.0f, 0.0f);
  6557.     tforce = 0.0f;
  6558.     car1_point = -1;
  6559.     car2_point = -1;
  6560.     for (i = 0; i < k; i++) {
  6561.         f[i] = f[i] * factor;
  6562.         if (f[i] == 0.0f && k != 0) {
  6563.             break;
  6564.         }
  6565.         if (f[i] < 0.001f) {
  6566.             f[i] = 0.001f;
  6567.         }
  6568.         if (f[i] > 10.0f) {
  6569.             ts = 0.0f;
  6570.         }
  6571.         f[i] += 0.1f;
  6572.         BrVector3Scale(&tau1[i], &tau1[i], f[i]);
  6573.         BrVector3Scale(&tau2[i], &tau2[i], f[i]);
  6574.         BrVector3Accumulate(&torque1, &tau1[i]);
  6575.         BrVector3Accumulate(&torque2, &tau2[i]);
  6576.         if (!pPass && Vector3IsZero(&n[2 * i])) {
  6577.             car2_point = i;
  6578.         } else if (!pPass && Vector3IsZero(&n[2 * i + 1])) {
  6579.             car1_point = i;
  6580.         } else {
  6581.             ts = f[i] / car1->M;
  6582.             BrVector3Scale(&tv2, &n[2 * i], ts);
  6583.             BrVector3Accumulate(&f1, &tv2);
  6584.             ts = f[i] / car2->M;
  6585.             BrVector3Scale(&tv2, &n[2 * i + 1], ts);
  6586.             BrVector3Accumulate(&f2, &tv2);
  6587.             BrVector3Scale(&tv2, &r[2 * i], f[i]);
  6588.             BrVector3Accumulate(&pos1, &tv2);
  6589.             BrVector3Scale(&tv2, &r[2 * i + 1], f[i]);
  6590.             BrVector3Accumulate(&pos2, &tv2);
  6591.             tforce += f[i];
  6592.         }
  6593.     }
  6594.     if (car1->min_torque_squared != 0.0f && !car1->infinite_mass && BrVector3LengthSquared(&torque1) > car1->min_torque_squared) {
  6595.         BrVector3Scale(&car1->omega, &car1->omega, gDt);
  6596.         car1->omega.v[0] += torque1.v[0] * 0.04f;
  6597.         car1->omega.v[2] += torque1.v[2] * 0.04f;
  6598.         if (BrVector3LengthSquared(&car1->omega) > car1->break_off_radians_squared) {
  6599.             car1->min_torque_squared = 0.0f;
  6600.             return 1;
  6601.         }
  6602.         BrVector3InvScale(&car1->omega, &car1->omega, gDt);
  6603.     }
  6604.     if (car2->min_torque_squared != 0.0f && !car2->infinite_mass && BrVector3LengthSquared(&torque2) > car2->min_torque_squared) {
  6605.         BrVector3Scale(&car2->omega, &car2->omega, gDt);
  6606.         car2->omega.v[0] += torque2.v[0] * 0.04f;
  6607.         car2->omega.v[2] += torque2.v[2] * 0.04f;
  6608.         if (BrVector3LengthSquared(&car2->omega) > car2->break_off_radians_squared) {
  6609.             car2->min_torque_squared = 0.0f;
  6610.             return 1;
  6611.         }
  6612.         BrVector3InvScale(&car2->omega, &car2->omega, gDt);
  6613.     }
  6614.     if (move_car1) {
  6615.         BrVector3Accumulate(&car1->omega, &torque1);
  6616.     }
  6617.     if (move_car2) {
  6618.         BrVector3Accumulate(&car2->omega, &torque2);
  6619.     }
  6620.     BrVector3InvScale(&pos1, &pos1, tforce);
  6621.     BrVector3InvScale(&pos2, &pos2, tforce);
  6622.     if (pPass == 0) {
  6623.         if (car1_point >= 0 && move_car1) {
  6624.             f[car1_point] = f[car1_point] / car1->M;
  6625.             BrVector3Scale(&n[2 * car1_point], &n[2 * car1_point], f[car1_point]);
  6626.             BrVector3Cross(&tv2, &car1->oldomega, &r[2 * car1_point]);
  6627.             BrVector3Accumulate(&tv2, &car1->velocity_car_space);
  6628.             ts = BrVector3Length(&tv2);
  6629.             if (ts > 0.0001f && (car1->driver <= eDriver_non_car || !CAR(car1)->wall_climber_mode)) {
  6630.                 AddFriction(car1, &tv2, &n[2 * car1_point], &r[2 * car1_point], f[car1_point], &max_friction);
  6631.                 BrVector3Accumulate(&n[2 * car1_point], &max_friction);
  6632.             }
  6633.             BrMatrix34ApplyV(&tv, &n[2 * car1_point], mat1);
  6634.             BrVector3Accumulate(&car1->v, &tv);
  6635.         }
  6636.         if (car2_point >= 0 && move_car2) {
  6637.             f[car2_point] = f[car2_point] / car2->M;
  6638.             BrVector3Scale(&n[2 * car2_point + 1], &n[2 * car2_point + 1], f[car2_point]);
  6639.             BrVector3Cross(&tv2, &car2->oldomega, &r[2 * car2_point + 1]);
  6640.             BrVector3Accumulate(&tv2, &car2->velocity_car_space);
  6641.             ts = BrVector3Length(&tv2);
  6642.  
  6643.             if (ts > 0.0001f && (car1->driver <= eDriver_non_car || !(CAR(car1)->wall_climber_mode))) {
  6644.                 AddFriction(car2, &tv2, &n[2 * car2_point + 1], &r[2 * car2_point + 1], f[car2_point], &max_friction);
  6645.                 BrVector3Accumulate(&n[2 * car2_point + 1], &max_friction);
  6646.             }
  6647.             BrMatrix34ApplyV(&tv, &n[2 * car2_point + 1], mat2);
  6648.             BrVector3Accumulate(&car2->v, &tv);
  6649.         }
  6650.         if (tforce != 0.0f) {
  6651.             BrVector3Cross(&point_vel1, &car1->oldomega, &pos1);
  6652.             BrVector3Sub(&a, &car1->v, &car2->v);
  6653.             BrMatrix34TApplyV(&tv2, &a, mat1);
  6654.             BrVector3Accumulate(&point_vel1, &tv2);
  6655.             BrVector3Cross(&point_vel2, &car2->oldomega, &pos2);
  6656.             AddFrictionCarToCar(car1, car2, &point_vel1, &point_vel2, &f1, &pos1, &pos2, tforce, &max_friction);
  6657.             if (TestForNan(max_friction.v) || TestForNan(&max_friction.v[1]) || TestForNan(&max_friction.v[2])) {
  6658.                 BrVector3SetFloat(&max_friction, 0.0f, 0.0f, 0.0f);
  6659.             }
  6660.             BrVector3InvScale(&tv2, &max_friction, car1->M);
  6661.             BrVector3Accumulate(&f1, &tv2);
  6662.             BrMatrix34ApplyV(&tv2, &max_friction, mat1);
  6663.             BrMatrix34TApplyV(&max_friction, &tv2, mat2);
  6664.             BrVector3InvScale(&tv2, &max_friction, car2->M);
  6665.             BrVector3Accumulate(&f2, &tv2);
  6666.         }
  6667.     }
  6668.     if (tforce == 0.0f) {
  6669.         return 0;
  6670.     }
  6671.     BrMatrix34ApplyV(&tv, &f1, mat1);
  6672.     if (move_car1) {
  6673.         BrVector3Accumulate(&car1->v, &tv);
  6674.     }
  6675.     CrushAndDamageCar(CAR(car1), &pos1, &f1, CAR(car2));
  6676.     if ((car1->infinite_mass & 0x100) != 0) {
  6677.         BrVector3Sub(&tv2, &car1->cmpos, &pos1);
  6678.         BrVector3Accumulate(&tv2, &car1->cmpos);
  6679.         ts = BrVector3Length(&f1);
  6680.         if (ts > 0.0001f) {
  6681.             ts = 5.0f / ts;
  6682.             BrVector3Scale(&a, &f1, ts);
  6683.             BrVector3Accumulate(&tv2, &a);
  6684.             plane = LineBoxColl(&tv2, &pos1, &car1->bounds[1], &a);
  6685.             if (plane) {
  6686.                 BrVector3Negate(&f12, &f1);
  6687.                 CrushAndDamageCar(CAR(car1), &a, &f12, CAR(car2));
  6688.             }
  6689.         }
  6690.     }
  6691.     BrMatrix34ApplyV(&tv, &f2, mat2);
  6692.     if (move_car2) {
  6693.         BrVector3Accumulate(&car2->v, &tv);
  6694.     }
  6695.     CrushAndDamageCar(CAR(car2), &pos2, &f2, CAR(car1));
  6696.     if ((car2->infinite_mass & 0x100) != 0) {
  6697.         BrVector3Sub(&tv2, &car2->cmpos, &pos2);
  6698.         BrVector3Accumulate(&tv2, &car2->cmpos);
  6699.         ts = BrVector3Length(&f2);
  6700.         if (ts > 0.0001f) {
  6701.             ts = 5.0f / ts;
  6702.             BrVector3Scale(&a, &f2, ts);
  6703.             BrVector3Accumulate(&tv2, &a);
  6704.             plane = LineBoxColl(&tv2, &pos2, &car2->bounds[1], &a);
  6705.             if (plane) {
  6706.                 BrVector3Negate(&f22, &f2);
  6707.                 CrushAndDamageCar(CAR(car2), &a, &f22, CAR(car1));
  6708.             }
  6709.         }
  6710.     }
  6711.     BrMatrix34ApplyP(&tv2, &pos1, mat1);
  6712.     BrVector3InvScale(&tv2, &tv2, WORLD_SCALE);
  6713.     BrVector3Scale(&f1, &f1, 5.0f);
  6714.     CrashNoise(&f1, &tv2, 0);
  6715.     BrVector3Add(&a, &car2->v, &car1->v);
  6716.     BrVector3Scale(&a, &a, 0.25f / WORLD_SCALE);
  6717.     BrVector3Scale(&tv, &tv, car2->M * 3.0f);
  6718.     CreateSparkShower(&tv2, &a, &tv, CAR(car1), CAR(car2));
  6719.     return 0;
  6720. }
  6721.  
  6722. // IDA: br_scalar __usercall TwoPointCollB@<ST0>(br_scalar *f@<EAX>, br_matrix4 *m@<EDX>, br_scalar *d@<EBX>, br_vector3 *tau@<ECX>, br_vector3 *n)
  6723. br_scalar TwoPointCollB(br_scalar* f, br_matrix4* m, br_scalar* d, br_vector3* tau, br_vector3* n) {
  6724.     br_scalar ts;
  6725.     LOG_TRACE("(%p, %p, %p, %p, %p)", f, m, d, tau, n);
  6726.  
  6727.     ts = m->m[1][1] * m->m[0][0] - m->m[0][1] * m->m[1][0];
  6728.     if (fabsf(ts) > 0.000001f) {
  6729.         f[0] = (m->m[1][1] * d[0] - m->m[0][1] * d[1]) / ts;
  6730.         f[1] = (m->m[1][0] * d[0] - m->m[0][0] * d[1]) / -ts;
  6731.     }
  6732.     if (f[1] < 0.0f) {
  6733.         ts = SinglePointColl(f, m, d);
  6734.         f[1] = 0.f;
  6735.     } else if (f[0] < 0.f) {
  6736.         m->m[0][0] = m->m[1][1];
  6737.         BrVector3Copy(&tau[0], &tau[1]);
  6738.         BrVector3Copy(&tau[4], &tau[5]);
  6739.         BrVector3Copy(&n[0], &n[2]);
  6740.         BrVector3Copy(&n[1], &n[3]);
  6741.         d[0] = d[1];
  6742.         ts = SinglePointColl(f, m, d);
  6743.         f[1] = 0.0f;
  6744.     }
  6745.     return ts;
  6746. }
  6747.  
  6748. // IDA: br_scalar __usercall ThreePointCollRecB@<ST0>(br_scalar *f@<EAX>, br_matrix4 *m@<EDX>, br_scalar *d@<EBX>, br_vector3 *tau@<ECX>, br_vector3 *n)
  6749. br_scalar ThreePointCollRecB(br_scalar* f, br_matrix4* m, br_scalar* d, br_vector3* tau, br_vector3* n) {
  6750.     int i;
  6751.     int j;
  6752.     br_scalar ts;
  6753.     LOG_TRACE("(%p, %p, %p, %p, %p)", f, m, d, tau, n);
  6754.  
  6755.     ts = ThreePointColl(f, m, d);
  6756.     if (f[0] >= 0.0f && f[1] >= 0.0f && f[2] >= 0.0f) {
  6757.         return ts;
  6758.     }
  6759.     if (f[2] < 0.f) {
  6760.         i = 0;
  6761.         j = 1;
  6762.     } else if (f[1] < 0.f) {
  6763.         i = 0;
  6764.         j = 2;
  6765.     } else if (f[0] < 0.f) {
  6766.         i = 1;
  6767.         j = 2;
  6768.     } else {
  6769.         return 0.0f;
  6770.     }
  6771.     m->m[0][0] = ((br_scalar*)(m->m))[5 * i];
  6772.     m->m[1][0] = m->m[j][i];
  6773.     m->m[0][1] = m->m[i][j];
  6774.     m->m[1][1] = ((br_scalar*)(m->m))[5 * j];
  6775.     BrVector3Copy(&tau[0], &tau[i]);
  6776.     BrVector3Copy(&tau[1], &tau[j]);
  6777.     BrVector3Copy(&tau[4], &tau[i + 4]);
  6778.     BrVector3Copy(&tau[5], &tau[j + 4]);
  6779.     BrVector3Copy(&n[0], &n[2 * i]);
  6780.     BrVector3Copy(&n[2], &n[2 * j]);
  6781.     BrVector3Copy(&n[1], &n[2 * i + 1]);
  6782.     BrVector3Copy(&n[3], &n[2 * j + 1]);
  6783.     d[0] = d[i];
  6784.     d[1] = d[j];
  6785.     ts = TwoPointCollB(f, m, d, tau, n);
  6786.     f[2] = 0.0;
  6787.     return ts;
  6788. }
  6789.  
  6790. // IDA: br_scalar __usercall FourPointCollB@<ST0>(br_scalar *f@<EAX>, br_matrix4 *m@<EDX>, br_scalar *d@<EBX>, br_vector3 *tau@<ECX>, br_vector3 *n)
  6791. br_scalar FourPointCollB(br_scalar* f, br_matrix4* m, br_scalar* d, br_vector3* tau, br_vector3* n) {
  6792.     int i;
  6793.     int j;
  6794.     int l;
  6795.     br_scalar ts;
  6796.     LOG_TRACE("(%p, %p, %p, %p, %p)", f, m, d, tau, n);
  6797.  
  6798.     ts = ThreePointColl(f, m, d);
  6799.     if (f[0] >= 0.0f && f[1] >= 0.0f && f[2] >= 0.0f) {
  6800.         return ts;
  6801.     }
  6802.     if (f[0] < 0.0f) {
  6803.         l = 0;
  6804.     } else if (f[1] < 0.0f) {
  6805.         l = 1;
  6806.     } else {
  6807.         l = 2;
  6808.     }
  6809.     for (i = l; i < 3; i++) {
  6810.         for (j = 0; j < 4; j++) {
  6811.             m->m[i][j] = m->m[i + 1][j];
  6812.         }
  6813.         d[i] = d[i + 1];
  6814.         tau[i] = tau[i + 1];
  6815.         tau[i + 4] = tau[i + 5];
  6816.         n[2 * i] = n[2 * i + 2];
  6817.         n[2 * i + 1] = n[2 * i + 3];
  6818.         d[i] = d[i + 1];
  6819.     }
  6820.     for (i = l; i < 3; i++) {
  6821.         for (j = 0; j < 3; j++) {
  6822.             m->m[j][i] = m->m[j][i + 1];
  6823.         }
  6824.     }
  6825.     return ThreePointCollRecB(f, m, d, tau, n);
  6826. }
  6827.  
  6828. // IDA: int __usercall TestForNan@<EAX>(float *f@<EAX>)
  6829. int TestForNan(float* f) {
  6830.     //tU32 i; // Pierre-Marie Baty -- unused variable
  6831.     LOG_TRACE("(%p)", f);
  6832.     // i = *f;
  6833.     // LOG_DEBUG("i %x", i);
  6834.     return isnan(*f);
  6835.     // return (~i & 0x7F800000) == 0;
  6836. }
  6837.  
  6838. // IDA: void __cdecl CheckCameraHither()
  6839. void CheckCameraHither(void) {
  6840.     br_camera* cam;
  6841.     static int old_hither;
  6842.     LOG_TRACE("()");
  6843.  
  6844.     cam = (br_camera*)gCamera->type_data;
  6845.     if (TestForNan(&cam->hither_z)) {
  6846.         cam->hither_z = (float)old_hither;
  6847.     }
  6848.     old_hither = (int)cam->hither_z;
  6849. }
  6850.  
  6851. // IDA: void __usercall SetCarSuspGiveAndHeight(tCar_spec *pCar@<EAX>, br_scalar pFront_give_factor, br_scalar pRear_give_factor, br_scalar pDamping_factor, br_scalar pExtra_front_height, br_scalar pExtra_rear_height)
  6852. void SetCarSuspGiveAndHeight(tCar_spec* pCar, br_scalar pFront_give_factor, br_scalar pRear_give_factor, br_scalar pDamping_factor, br_scalar pExtra_front_height, br_scalar pExtra_rear_height) {
  6853.     br_scalar front_give;
  6854.     br_scalar rear_give;
  6855.     br_scalar damping;
  6856.     br_scalar ratio;
  6857.     //int i; // Pierre-Marie Baty -- unused variable
  6858.     LOG_TRACE("(%p, %f, %f, %f, %f, %f)", pCar, pFront_give_factor, pRear_give_factor, pDamping_factor, pExtra_front_height, pExtra_rear_height);
  6859.  
  6860. #define UNK_SUSPENION_FACTOR 5.0f
  6861.  
  6862.     front_give = pCar->susp_give[1] * pFront_give_factor * WORLD_SCALE;
  6863.     rear_give = pCar->susp_give[0] * pRear_give_factor * WORLD_SCALE;
  6864.     damping = pCar->damping * pDamping_factor;
  6865.     ratio = fabsf((pCar->wpos[0].v[2] - pCar->cmpos.v[2]) / (pCar->wpos[2].v[2] - pCar->cmpos.v[2]));
  6866.     pCar->sk[0] = pCar->M / (ratio + 1.0f) * UNK_SUSPENION_FACTOR / rear_give;
  6867.     pCar->sb[0] = pCar->M / (ratio + 1.0f) * sqrtf(UNK_SUSPENION_FACTOR) / sqrt(rear_give);
  6868.     ratio = 1.0f / ratio;
  6869.     pCar->sk[1] = pCar->M / (ratio + 1.0f) * UNK_SUSPENION_FACTOR / front_give;
  6870.     pCar->sb[1] = pCar->M / (ratio + 1.0f) * sqrtf(UNK_SUSPENION_FACTOR) / sqrt(front_give);
  6871.  
  6872.     pCar->sb[0] *= damping;
  6873.     pCar->sb[1] *= damping;
  6874.     pCar->susp_height[0] = pCar->ride_height + rear_give + pExtra_rear_height;
  6875.     pCar->susp_height[1] = pCar->ride_height + front_give + pExtra_front_height;
  6876.  
  6877.     pCar->bounds[0].min.v[1] = -MAX(rear_give, front_give) + -MAX(pExtra_rear_height, pExtra_front_height);
  6878.     pCar->bounds[0].min.v[1] /= WORLD_SCALE;
  6879.  
  6880. #undef UNK_SUSPENION_FACTOR
  6881. }
  6882.  
  6883. // IDA: int __usercall TestForCarInSensiblePlace@<EAX>(tCar_spec *car@<EAX>)
  6884. int TestForCarInSensiblePlace(tCar_spec* car) {
  6885.     //br_bounds bnds; // Pierre-Marie Baty -- unused variable
  6886.     //br_matrix34 mat; // Pierre-Marie Baty -- unused variable
  6887.     br_matrix34* mat1;
  6888.     br_matrix34* mat2;
  6889.     int i;
  6890.     //int j; // Pierre-Marie Baty -- unused variable
  6891.     int k;
  6892.     tCollision_info* c2;
  6893.     tCollision_info* car_info;
  6894.     br_vector3 sep;
  6895.     br_vector3 tv;
  6896.     br_vector3 tv2;
  6897.     LOG_TRACE("(%p)", car);
  6898.  
  6899.     car_info = (tCollision_info*)car;
  6900.     if (!gProgram_state.racing) {
  6901.         return 1;
  6902.     }
  6903.     mat1 = &car_info->car_master_actor->t.t.mat;
  6904.     if (!gDoing_physics) {
  6905.         BrVector3Scale((br_vector3*)mat1->m[3], (br_vector3*)mat1->m[3], WORLD_SCALE);
  6906.     }
  6907.     GetFacesInBox(car_info);
  6908.     BrMatrix34ApplyP(&car_info->pos, &car_info->cmpos, mat1);
  6909.     BrVector3InvScale(&car_info->pos, &car_info->pos, WORLD_SCALE);
  6910.     k = CollCheck(car_info, -2.f);
  6911.     if (!k) {
  6912.         if (gNum_active_non_cars + gNum_active_cars != gNum_cars_and_non_cars) {
  6913.             GetNonCars();
  6914.         }
  6915.         for (i = 0; i < gNum_cars_and_non_cars; i++) {
  6916.             c2 = (tCollision_info*)gActive_car_list[i];
  6917.             if (car_info != c2) {
  6918.                 mat2 = &c2->car_master_actor->t.t.mat;
  6919.                 BrVector3Scale((br_vector3*)mat2->m[3], (br_vector3*)mat2->m[3], WORLD_SCALE);
  6920.                 BrVector3Sub(&sep, (br_vector3*)mat1->m[3], (br_vector3*)mat2->m[3]);
  6921.                 if (BrVector3LengthSquared(&sep) <= 100.0) {
  6922.                     k += TestOldMats(car_info, c2, 0);
  6923.                     k += TestOldMats(c2, car_info, 0);
  6924.                 }
  6925.                 if (k != 0) {
  6926.                     BrMatrix34ApplyP(&tv, &car_info->cmpos, mat1);
  6927.                     BrMatrix34ApplyP(&tv2, &c2->cmpos, mat2);
  6928.                     BrVector3Sub(&tv, &tv2, &tv);
  6929.                     BrMatrix34TApplyV(&car_info->old_point, &tv, mat1);
  6930.                     BrVector3Normalise(&car_info->old_norm, &car_info->old_point);
  6931.                     BrVector3Negate(&car_info->old_norm, &car_info->old_norm);
  6932.                 }
  6933.                 BrVector3InvScale((br_vector3*)mat2->m[3], (br_vector3*)mat2->m[3], WORLD_SCALE);
  6934.                 if (k != 0) {
  6935.                     break;
  6936.                 }
  6937.             }
  6938.         }
  6939.     }
  6940.     if (!gDoing_physics) {
  6941.         BrVector3InvScale((br_vector3*)mat1->m[3], (br_vector3*)mat1->m[3], WORLD_SCALE);
  6942.     }
  6943.     if (k != 0) {
  6944.         return 0;
  6945.     } else {
  6946.         return -1;
  6947.     }
  6948. }
  6949.  
  6950. // IDA: int __usercall TestOldMats@<EAX>(tCollision_info *c1@<EAX>, tCollision_info *c2@<EDX>, int newmats@<EBX>)
  6951. int TestOldMats(tCollision_info* c1, tCollision_info* c2, int newmats) {
  6952.     br_vector3 p1;
  6953.     br_vector3 p2;
  6954.     br_vector3 tp1;
  6955.     //br_vector3 tp2; // Pierre-Marie Baty -- unused variable
  6956.     //br_vector3 tp3; // Pierre-Marie Baty -- unused variable
  6957.     br_vector3 hp1;
  6958.     //br_vector3 hp2; // Pierre-Marie Baty -- unused variable
  6959.     //br_vector3 hp3; // Pierre-Marie Baty -- unused variable
  6960.     //br_vector3 shp1; // Pierre-Marie Baty -- unused variable
  6961.     //br_vector3 shp2; // Pierre-Marie Baty -- unused variable
  6962.     br_vector3 edge;
  6963.     //int plane1; // Pierre-Marie Baty -- unused variable
  6964.     //int plane2; // Pierre-Marie Baty -- unused variable
  6965.     //int plane3; // Pierre-Marie Baty -- unused variable
  6966.     //br_scalar ts; // Pierre-Marie Baty -- unused variable
  6967.     int i;
  6968.     int j;
  6969.     int n;
  6970.     br_bounds* b1;
  6971.     br_bounds* b2;
  6972.     br_matrix34 invmat1;
  6973.     br_matrix34 mat21;
  6974.     LOG_TRACE("(%p, %p, %d)", c1, c2, newmats);
  6975.  
  6976.     n = 0;
  6977.     b1 = &c1->bounds[1];
  6978.     b2 = &c2->bounds[1];
  6979.     if (newmats) {
  6980.         BrMatrix34LPInverse(&invmat1, &c1->car_master_actor->t.t.mat);
  6981.         BrMatrix34Mul(&mat21, &c2->car_master_actor->t.t.mat, &invmat1);
  6982.     } else {
  6983.         BrMatrix34LPInverse(&invmat1, &c1->oldmat);
  6984.         BrMatrix34Mul(&mat21, &c2->oldmat, &invmat1);
  6985.     }
  6986.     for (i = 0; i < 4; i++) {
  6987.         if (i == 3) {
  6988.             BrVector3Copy(&edge, &b2->min);
  6989.         } else {
  6990.             BrVector3Copy(&edge, &b2->max);
  6991.             edge.v[i] = b2->min.v[i];
  6992.         }
  6993.         for (j = 0; j < 3; j++) {
  6994.             BrVector3Copy(&tp1, &edge);
  6995.             if (b2->max.v[j] == tp1.v[j]) {
  6996.                 tp1.v[j] = b2->min.v[j];
  6997.             } else {
  6998.                 tp1.v[j] = b2->max.v[j];
  6999.             }
  7000.             BrMatrix34ApplyP(&p1, &edge, &mat21);
  7001.             BrMatrix34ApplyP(&p2, &tp1, &mat21);
  7002.             if (LineBoxColl(&p1, &p2, b1, &hp1)) {
  7003.                 n++;
  7004.             }
  7005.         }
  7006.     }
  7007.     return n;
  7008. }
  7009.  
  7010. // IDA: int __usercall PullActorFromWorld@<EAX>(br_actor *pActor@<EAX>)
  7011. int PullActorFromWorld(br_actor* pActor) {
  7012.     LOG_TRACE("(%p)", pActor);
  7013.  
  7014.     if (gDoing_physics) {
  7015.         return DoPullActorFromWorld(pActor);
  7016.     }
  7017.     return 0;
  7018. }
  7019.  
  7020. // IDA: int __usercall DoPullActorFromWorld@<EAX>(br_actor *pActor@<EAX>)
  7021. int DoPullActorFromWorld(br_actor* pActor) {
  7022.     int num;
  7023.     int i;
  7024.     tCollision_info* c;
  7025.     tNon_car_spec* non_car;
  7026.     LOG_TRACE("(%p)", pActor);
  7027.  
  7028.     non_car = NULL;
  7029.     num = 10 * (pActor->identifier[1] - '0') + 1 * (pActor->identifier[2] - '0');
  7030.     if (gNon_car_spec_list[num]) {
  7031.         non_car = &gProgram_state.non_cars[gNon_car_spec_list[num] + 4];
  7032.     }
  7033.     if (non_car && non_car->collision_info.driver == eDriver_non_car) {
  7034.         non_car = gProgram_state.non_cars;
  7035.         for (i = 0; i < NONCAR_UNUSED_SLOTS; i++) {
  7036.             if (non_car->collision_info.driver == eDriver_non_car_unused_slot) {
  7037.                 break;
  7038.             }
  7039.             non_car++;
  7040.         }
  7041.         if (i == NONCAR_UNUSED_SLOTS) {
  7042.             non_car = NULL;
  7043.         } else {
  7044.             memcpy(non_car, &gProgram_state.non_cars[gNon_car_spec_list[num] + NONCAR_UNUSED_SLOTS - 1], sizeof(tNon_car_spec));
  7045.         }
  7046.     }
  7047.     if (non_car != NULL) {
  7048.         pActor->type_data = non_car;
  7049.         c = &non_car->collision_info;
  7050.         c->driver = eDriver_non_car;
  7051.         c->doing_nothing_flag = 1;
  7052.         BrActorRemove(pActor);
  7053.         BrActorAdd(gNon_track_actor, pActor);
  7054.         c->car_master_actor = pActor;
  7055.         c->car_ID = 100 * (pActor->identifier[5] - '0') + 10 * (pActor->identifier[6] - '0') + 1 * (pActor->identifier[7] - '0');
  7056.         gActive_non_car_list[gNum_active_non_cars] = non_car;
  7057.         gNum_active_non_cars++;
  7058.         gActive_car_list[gNum_cars_and_non_cars] = (tCar_spec*)non_car;
  7059.         gNum_cars_and_non_cars++;
  7060.         GetNewBoundingBox(&c->bounds_world_space, c->bounds, &pActor->t.t.mat);
  7061.         non_car->collision_info.bounds_ws_type = eBounds_ws;
  7062.         InitialiseNonCar(non_car);
  7063.         ResetCarSpecialVolume((tCollision_info*)non_car);
  7064.         if (gDoing_physics) {
  7065.             BrVector3Scale((br_vector3*)&pActor->t.t.mat.m[3][0], (br_vector3*)&pActor->t.t.mat.m[3][0], WORLD_SCALE);
  7066.         }
  7067.         BrMatrix34Copy(&c->oldmat, &pActor->t.t.mat);
  7068.         if (!gDoing_physics) {
  7069.             BrVector3Scale((br_vector3*)&c->oldmat.m[3][0], (br_vector3*)&c->oldmat.m[3][0], WORLD_SCALE);
  7070.         }
  7071.         PipeSingleNonCar((tCollision_info*)non_car);
  7072.         return 1;
  7073.     } else {
  7074.         pActor->identifier[1] = 'x';
  7075.         return 0;
  7076.     }
  7077. }
  7078.  
  7079. // IDA: void __usercall CheckForDeAttachmentOfNonCars(tU32 pTime@<EAX>)
  7080. void CheckForDeAttachmentOfNonCars(tU32 pTime) {
  7081.     static tU32 total_time;
  7082.     br_bounds bnds;
  7083.     int i;
  7084.     int j;
  7085.     int last_free_slot;
  7086.     int drop;
  7087.     tCollision_info* c;
  7088.     tCollision_info* c2;
  7089.     br_actor* actor;
  7090.     tU8 cx;
  7091.     tU8 cz;
  7092.     tTrack_spec* track_spec;
  7093.     br_matrix34 mat;
  7094.     LOG_TRACE("(%d)", pTime);
  7095.  
  7096.     if (gNum_active_non_cars == 0) {
  7097.         return;
  7098.     }
  7099.  
  7100.     last_free_slot = 0;
  7101.     track_spec = &gProgram_state.track_spec;
  7102.  
  7103.     StartPipingSession(ePipe_chunk_non_car);
  7104.     for (i = 0; i < gNum_active_non_cars; i++) {
  7105.         if (!gActive_non_car_list[i]->collision_info.doing_nothing_flag) {
  7106.             AddNonCarToPipingSession(gActive_non_car_list[i]->collision_info.car_ID, gActive_non_car_list[i]->collision_info.car_master_actor);
  7107.         }
  7108.     }
  7109.     EndPipingSession();
  7110.  
  7111.     total_time += pTime;
  7112.     if (total_time < 1000) {
  7113.         return;
  7114.     }
  7115.     total_time = 0;
  7116.     for (i = 0; i < gNum_active_non_cars; i++) {
  7117.         c = &gActive_non_car_list[i]->collision_info;
  7118.         if (c->car_master_actor->t.t.translate.t.v[1] < gMin_world_y) {
  7119.             c->doing_nothing_flag = 1;
  7120.         }
  7121.         if (TestForNan(&c->car_master_actor->t.t.mat.m[3][1])) {
  7122.             BrVector3Set(&c->omega, 0.0f, 0.0f, 0.0f);
  7123.             BrMatrix34Identity(&c->car_master_actor->t.t.mat);
  7124.             BrVector3Set(&c->car_master_actor->t.t.translate.t, 2000.f, 0.f, 0.f);
  7125.             c->doing_nothing_flag = 1;
  7126.         }
  7127.         actor = c->car_master_actor;
  7128.         gActive_non_car_list[last_free_slot] = gActive_non_car_list[i];
  7129.         if (c->doing_nothing_flag) {
  7130.             drop = 1;
  7131.             for (j = 0; j < gNum_cars_and_non_cars; j++) {
  7132.                 c2 = (tCollision_info*)gActive_car_list[j];
  7133.                 if (c2 != c && !c2->doing_nothing_flag) {
  7134.                     BrMatrix34Mul(&mat, &actor->t.t.mat, &c2->last_box_inv_mat);
  7135.                     GetNewBoundingBox(&bnds, &actor->model->bounds, &mat);
  7136.                     if (c2->last_box.max.v[0] >= bnds.min.v[0]
  7137.                         && c2->last_box.max.v[1] >= bnds.min.v[1]
  7138.                         && c2->last_box.max.v[2] >= bnds.min.v[2]
  7139.                         && c2->last_box.min.v[0] <= bnds.max.v[0]
  7140.                         && c2->last_box.min.v[1] <= bnds.max.v[1]
  7141.                         && c2->last_box.min.v[2] <= bnds.max.v[2]) {
  7142.                         drop = 0;
  7143.                         break;
  7144.                     }
  7145.                 }
  7146.             }
  7147.             if (drop) {
  7148.                 BrActorRemove(actor);
  7149.                 c->driver = eDriver_non_car_unused_slot;
  7150.                 last_free_slot--;
  7151.                 XZToColumnXZ(&cx, &cz, actor->t.t.mat.m[3][0], actor->t.t.mat.m[3][2], track_spec);
  7152.                 if (track_spec->columns[cz][cx] != NULL) {
  7153.                     BrActorAdd(track_spec->columns[cz][cx], actor);
  7154.                 } else {
  7155.                     BrActorAdd(gTrack_actor, actor);
  7156.                 }
  7157.             }
  7158.         }
  7159.         last_free_slot++;
  7160.     }
  7161.     gNum_active_non_cars = last_free_slot;
  7162. }
  7163.  
  7164. // IDA: void __usercall AdjustNonCar(br_actor *pActor@<EAX>, br_matrix34 *pMat@<EDX>)
  7165. void AdjustNonCar(br_actor* pActor, br_matrix34* pMat) {
  7166.     tU8 cx;
  7167.     tU8 cz;
  7168.     tTrack_spec* track_spec;
  7169.     LOG_TRACE("(%p, %p)", pActor, pMat);
  7170.  
  7171.     track_spec = &gProgram_state.track_spec;
  7172.     BrMatrix34Copy(&pActor->t.t.mat, pMat);
  7173.     if (pActor->parent != gNon_track_actor) {
  7174.         XZToColumnXZ(&cx, &cz, pActor->t.t.translate.t.v[0], pActor->t.t.translate.t.v[2], track_spec);
  7175.         if (track_spec->columns[cz][cx] != pActor->parent && track_spec->columns[cz][cx] != NULL) {
  7176.             BrActorRemove(pActor);
  7177.             BrActorAdd(track_spec->columns[cz][cx], pActor);
  7178.         }
  7179.     }
  7180. }
  7181.  
  7182. // IDA: void __usercall PipeSingleNonCar(tCollision_info *c@<EAX>)
  7183. void PipeSingleNonCar(tCollision_info* c) {
  7184.     LOG_TRACE("(%p)", c);
  7185.  
  7186.     StartPipingSession(ePipe_chunk_non_car);
  7187.     if (gDoing_physics) {
  7188.         BrVector3InvScale(&c->car_master_actor->t.t.translate.t, &c->car_master_actor->t.t.translate.t, WORLD_SCALE);
  7189.     }
  7190.     AddNonCarToPipingSession(c->car_ID, c->car_master_actor);
  7191.     if (gDoing_physics) {
  7192.         BrVector3Scale(&c->car_master_actor->t.t.translate.t, &c->car_master_actor->t.t.translate.t, WORLD_SCALE);
  7193.     }
  7194.     EndPipingSession();
  7195. }
  7196.  
  7197. // IDA: int __usercall GetPrecalculatedFacesUnderCar@<EAX>(tCar_spec *pCar@<EAX>, tFace_ref **pFace_refs@<EDX>)
  7198. int GetPrecalculatedFacesUnderCar(tCar_spec* pCar, tFace_ref** pFace_refs) {
  7199.     LOG_TRACE("(%p, %p)", pCar, pFace_refs);
  7200.  
  7201.     if (pCar->box_face_ref == gFace_num__car
  7202.         || (pCar->box_face_ref == gFace_num__car - 1 && pCar->box_face_start > gFace_count)) {
  7203.         *pFace_refs = &gFace_list__car[pCar->box_face_start];
  7204.         return pCar->box_face_end - pCar->box_face_start;
  7205.     }
  7206.     return 0;
  7207. }
  7208.  
  7209. // IDA: br_material* __cdecl SomeNearbyMaterial()
  7210. br_material* SomeNearbyMaterial(void) {
  7211.     LOG_TRACE("()");
  7212.     NOT_IMPLEMENTED();
  7213. }
  7214.