Subversion Repositories Games.Carmageddon

Rev

Rev 11 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #include "crush.h"
  2. #include "brender/brender.h"
  3. #include "car.h"
  4. #include "displays.h"
  5. #include "globvars.h"
  6. #include "globvrkm.h"
  7. #include "globvrpb.h"
  8. #include "graphics.h"
  9. #include "harness/trace.h"
  10. #include "loading.h"
  11. #include "mainloop.h"
  12. #include "netgame.h"
  13. #include "network.h"
  14. #include "oil.h"
  15. #include "opponent.h"
  16. #include "pd/sys.h"
  17. #include "pedestrn.h"
  18. #include "piping.h"
  19. #include "pratcam.h"
  20. #include "raycast.h"
  21. #include "replay.h"
  22. #include "spark.h"
  23. #include "structur.h"
  24. #include "utility.h"
  25. #include "world.h"
  26. #include <stdlib.h>
  27.  
  28. float gWobble_spam_y[8] = { 0.0f, -0.15f, 0.4f, 0.15f, -0.4f, 0.25f, 0.0f, -0.25f };
  29. float gWobble_spam_z[8] = { 0.4f, -0.25f, 0.0f, 0.25f, 0.0f, 0.15f, -0.4f, -0.15f };
  30. br_scalar gWheel_circ_to_width = 0.16f;
  31. tU8 gSmoke_damage_step[12] = { 20u, 20u, 0u, 10u, 10u, 10u, 10u, 10u, 10u, 10u, 10u, 10u };
  32. int gSteal_ranks[5] = { 0, 89, 72, 55, 38 };
  33.  
  34. // IDA: int __usercall ReadCrushData@<EAX>(FILE *pF@<EAX>, tCrush_data *pCrush_data@<EDX>)
  35. int ReadCrushData(FILE* pF, tCrush_data* pCrush_data) {
  36.     //char s[256]; // Pierre-Marie Baty -- unused variable
  37.     //char* str; // Pierre-Marie Baty -- unused variable
  38.     int i;
  39.     int j;
  40.     //int k; // Pierre-Marie Baty -- unused variable
  41.     tCrush_point_spec* the_spec;
  42.     tCrush_neighbour* the_neighbour;
  43.     LOG_TRACE("(%p, %p)", pF, pCrush_data);
  44.  
  45.     pCrush_data->softness_factor = GetAFloat(pF);
  46.     GetPairOfFloats(pF, &pCrush_data->min_fold_factor, &pCrush_data->max_fold_factor);
  47.     pCrush_data->wibble_factor = GetAFloat(pF);
  48.     pCrush_data->limit_deviant = GetAFloat(pF);
  49.     pCrush_data->split_chance = GetAFloat(pF);
  50.     pCrush_data->min_y_fold_down = GetAFloat(pF);
  51.     pCrush_data->number_of_crush_points = GetAnInt(pF);
  52.     pCrush_data->crush_points = (tCrush_point_spec*)BrMemAllocate(sizeof(tCrush_point_spec) * pCrush_data->number_of_crush_points, kMem_crush_data);
  53.  
  54.     for (i = 0, the_spec = pCrush_data->crush_points; i < pCrush_data->number_of_crush_points; i++, the_spec++) {
  55.         the_spec->vertex_index = GetAnInt(pF);
  56.         GetThreeFloats(pF, &the_spec->limits_neg.v[0], &the_spec->limits_neg.v[1], &the_spec->limits_neg.v[2]);
  57.         GetThreeFloats(pF, &the_spec->limits_pos.v[0], &the_spec->limits_pos.v[1], &the_spec->limits_pos.v[2]);
  58.         GetThreeFloats(pF, &the_spec->softness_neg.v[0], &the_spec->softness_neg.v[1], &the_spec->softness_neg.v[2]);
  59.         GetThreeFloats(pF, &the_spec->softness_pos.v[0], &the_spec->softness_pos.v[1], &the_spec->softness_pos.v[2]);
  60.         the_spec->number_of_neighbours = GetAnInt(pF);
  61.         the_spec->neighbours = BrMemAllocate(sizeof(tCrush_neighbour) * the_spec->number_of_neighbours, kMem_crush_neighbours);
  62.  
  63.         for (j = 0, the_neighbour = the_spec->neighbours; j < the_spec->number_of_neighbours; j++, the_neighbour++) {
  64.             the_neighbour->vertex_index = GetAnInt(pF);
  65.             the_neighbour->factor = GetAnInt(pF);
  66.         }
  67.     }
  68.     return 0;
  69. }
  70.  
  71. // IDA: float __usercall SkipCrushData@<ST0>(FILE *pF@<EAX>)
  72. float SkipCrushData(FILE* pF) {
  73.     int i;
  74.     int j;
  75.     int count_1;
  76.     int count_2;
  77.     char s[256];
  78.     float softness;
  79.     LOG_TRACE("(%p)", pF);
  80.  
  81.     softness = GetAFloat(pF);
  82.     for (i = 0; i < 5; ++i) {
  83.         GetALineAndDontArgue(pF, s);
  84.     }
  85.     count_1 = GetAnInt(pF);
  86.     for (i = 0; i < count_1; i++) {
  87.         for (j = 0; j < 5; j++) {
  88.             GetALineAndDontArgue(pF, s);
  89.         }
  90.         count_2 = GetAnInt(pF);
  91.         for (j = 0; j < 2 * count_2; j++) {
  92.             GetALineAndDontArgue(pF, s);
  93.         }
  94.     }
  95.     return softness;
  96. }
  97.  
  98. // IDA: int __usercall WriteCrushData@<EAX>(FILE *pF@<EAX>, tCrush_data *pCrush_data@<EDX>)
  99. int WriteCrushData(FILE* pF, tCrush_data* pCrush_data) {
  100.     int i;
  101.     int j;
  102.     //int k; // Pierre-Marie Baty -- unused variable
  103.     tCrush_point_spec* the_spec;
  104.     tCrush_neighbour* the_neighbour;
  105.     LOG_TRACE("(%p, %p)", pF, pCrush_data);
  106.  
  107.     fprintf(pF, "%f\n\r", pCrush_data->softness_factor);
  108.     fprintf(pF, "%f,%f\n\r", pCrush_data->min_fold_factor, pCrush_data->max_fold_factor);
  109.     fprintf(pF, "%f\n\r", pCrush_data->wibble_factor);
  110.     fprintf(pF, "%f\n\r", pCrush_data->limit_deviant);
  111.     fprintf(pF, "%f\n\r", pCrush_data->split_chance);
  112.     fprintf(pF, "%f\n\r", pCrush_data->min_y_fold_down);
  113.     fprintf(pF, "%d\n\r", pCrush_data->number_of_crush_points);
  114.     for (i = 0, the_spec = pCrush_data->crush_points; i < pCrush_data->number_of_crush_points; i++, the_spec++) {
  115.         fprintf(pF, "%d\n\r", the_spec->vertex_index);
  116.         fprintf(pF, "%f, %f, %f\n\r", the_spec->limits_neg.v[0], the_spec->limits_neg.v[1], the_spec->limits_neg.v[2]);
  117.         fprintf(pF, "%f, %f, %f\n\r", the_spec->limits_pos.v[0], the_spec->limits_pos.v[1], the_spec->limits_pos.v[2]);
  118.         fprintf(pF, "%f, %f, %f\n\r", the_spec->softness_neg.v[0], the_spec->softness_neg.v[1], the_spec->softness_neg.v[2]);
  119.         fprintf(pF, "%f, %f, %f\n\r", the_spec->softness_pos.v[0], the_spec->softness_pos.v[1], the_spec->softness_pos.v[2]);
  120.         fprintf(pF, "%d\n\r", the_spec->number_of_neighbours);
  121.         for (j = 0, the_neighbour = the_spec->neighbours; j < the_spec->number_of_neighbours; j++, the_neighbour++) {
  122.             fprintf(pF, "%d\n\r", the_neighbour->vertex_index);
  123.             fprintf(pF, "%d\n\r", the_neighbour->factor);
  124.         }
  125.     }
  126.     return 0;
  127. }
  128.  
  129. // IDA: void __usercall DisposeCrushData(tCrush_data *pCrush_data@<EAX>)
  130. void DisposeCrushData(tCrush_data* pCrush_data) {
  131.     int i;
  132.     LOG_TRACE("(%p)", pCrush_data);
  133.  
  134.     for (i = 0; i < pCrush_data->number_of_crush_points; i++) {
  135.         if (pCrush_data->crush_points[i].neighbours != NULL) {
  136.             BrMemFree(pCrush_data->crush_points[i].neighbours);
  137.         }
  138.     }
  139.     if (pCrush_data->crush_points != NULL) {
  140.         BrMemFree(pCrush_data->crush_points);
  141.     }
  142. }
  143.  
  144. // IDA: void __usercall CrushModelPoint(tCar_spec *pCar@<EAX>, int pModel_index@<EDX>, br_model *pModel@<EBX>, int pCrush_point_index@<ECX>, br_vector3 *pEnergy_vector, br_scalar total_energy, tCrush_data *pCrush_data)
  145. void CrushModelPoint(tCar_spec* pCar, int pModel_index, br_model* pModel, int pCrush_point_index, br_vector3* pEnergy_vector, br_scalar total_energy, tCrush_data* pCrush_data) {
  146.     int i;
  147.     int j;
  148.     //int k; // Pierre-Marie Baty -- unused variable
  149.     int pipe_vertex_count;
  150.     int neighbour_index;
  151.     int bend_axis;
  152.     int default_bend_axis[3];
  153.     tCrush_point_spec* the_crush_point;
  154.     tCrush_neighbour* the_neighbour;
  155.     br_vector3* target_point;
  156.     br_vector3 old_vector;
  157.     br_vector3 softnesss;
  158.     br_vector3 movement;
  159.     br_scalar random_range;
  160.     br_scalar bend_amount;
  161.     br_scalar min_y_fold_down;
  162.     float default_bend_factor[3];
  163.     float working_min_fold;
  164.     float working_max_fold;
  165.     float working_wibble;
  166.     float working_limit_deviant;
  167.     float working_split_chance;
  168.     tChanged_vertex pipe_array[600];
  169.     //tCar_spec* car; // Pierre-Marie Baty -- unused variable
  170.     LOG_TRACE("(%p, %d, %p, %d, %p, %f, %p)", pCar, pModel_index, pModel, pCrush_point_index, pEnergy_vector, total_energy, pCrush_data);
  171.  
  172.     pipe_vertex_count = 0;
  173.     if (gNet_mode == eNet_mode_host && pCar->car_model_actors[pModel_index].min_distance_squared == 0.0f) {
  174.         NetSendPointCrush(pCar, pCrush_point_index, pEnergy_vector);
  175.     }
  176.     working_min_fold = pCrush_data->min_fold_factor * gCar_crush_min_fold;
  177.     working_max_fold = pCrush_data->max_fold_factor * gCar_crush_max_fold;
  178.     working_wibble = pCrush_data->wibble_factor * gCar_crush_wibble;
  179.     working_limit_deviant = pCrush_data->limit_deviant * gCar_crush_limit_deviant;
  180.     working_split_chance = pCrush_data->split_chance * gCar_crush_split_chance;
  181.     min_y_fold_down = pCrush_data->min_y_fold_down;
  182.     the_crush_point = &pCrush_data->crush_points[pCrush_point_index];
  183.     if (pModel->nvertices <= the_crush_point->vertex_index) {
  184.         return;
  185.     }
  186.     target_point = &pModel->vertices[the_crush_point->vertex_index].p;
  187.     old_vector = *target_point;
  188.     for (i = 0; i < 3; i++) {
  189.         pEnergy_vector->v[i] = SRandomPosNeg(working_wibble * total_energy) + pEnergy_vector->v[i];
  190.         random_range = (the_crush_point->limits_pos.v[i] - the_crush_point->limits_neg.v[i]) * working_limit_deviant;
  191.         if (pEnergy_vector->v[i] >= 0.0f) {
  192.             softnesss.v[i] = the_crush_point->softness_pos.v[i];
  193.         } else {
  194.             softnesss.v[i] = the_crush_point->softness_neg.v[i];
  195.         }
  196.         movement.v[i] = target_point->v[i];
  197.         target_point->v[i] += pEnergy_vector->v[i] * softnesss.v[i];
  198.         if (the_crush_point->limits_neg.v[i] <= target_point->v[i]) {
  199.             if (target_point->v[i] > the_crush_point->limits_pos.v[i]) {
  200.                 target_point->v[i] = SRandomPosNeg(random_range) + the_crush_point->limits_pos.v[i];
  201.             }
  202.         } else {
  203.             target_point->v[i] = SRandomPosNeg(random_range) + the_crush_point->limits_neg.v[i];
  204.         }
  205.         movement.v[i] = target_point->v[i] - movement.v[i];
  206.         if (pEnergy_vector->v[i] * movement.v[i] < 0.0f) {
  207.             movement.v[i] = 0.0f;
  208.             target_point->v[i] = old_vector.v[i];
  209.         }
  210.     }
  211.  
  212.     if (IsActionReplayAvailable()) {
  213.         pipe_array[pipe_vertex_count].vertex_index = the_crush_point->vertex_index;
  214.         BrVector3Sub(&pipe_array[pipe_vertex_count].delta_coordinates, target_point, &old_vector);
  215.         pipe_vertex_count++;
  216.     }
  217.     neighbour_index = -1;
  218.     for (bend_axis = 0; bend_axis < 3; bend_axis++) {
  219.         default_bend_axis[bend_axis] = (bend_axis + IRandomBetween(1, 2)) % 3;
  220.         default_bend_factor[bend_axis] = FRandomBetween(working_min_fold, working_max_fold);
  221.     }
  222.  
  223.     the_neighbour = the_crush_point->neighbours;
  224.     for (j = 0; j < the_crush_point->number_of_neighbours; j++, the_neighbour++) {
  225.         if (the_neighbour->vertex_index) {
  226.             neighbour_index += the_neighbour->vertex_index;
  227.             if (neighbour_index < 0 || pModel->nvertices <= neighbour_index) {
  228.                 return;
  229.             }
  230.             target_point = &pModel->vertices[neighbour_index].p;
  231.             old_vector = *target_point;
  232.             for (bend_axis = 0; bend_axis < 3; bend_axis++) {
  233.                 target_point->v[bend_axis] += (1.0f - the_neighbour->factor / 256.0f) * movement.v[bend_axis];
  234.                 float v12;
  235.                 if (the_neighbour->factor <= 128) {
  236.                     v12 = the_neighbour->factor / 128.0f;
  237.                 } else {
  238.                     v12 = 2.0 - the_neighbour->factor / 128.0f;
  239.                 }
  240.                 if (((int)((target_point->v[2] + target_point->v[1] + target_point->v[0]) * 63.0f) & 1) * v12 == 0.0) {
  241.                     bend_amount = -default_bend_factor[bend_axis];
  242.                 } else {
  243.                     bend_amount = default_bend_factor[bend_axis];
  244.                 }
  245.                 int axis_tmp = (((int)((target_point->v[2] + target_point->v[1] + target_point->v[0]) * 100.0f) + bend_axis - 1) & 1) % 3;
  246.                 target_point->v[axis_tmp] += fabs(movement.v[bend_axis]) * bend_amount;
  247.             }
  248.             if (IsActionReplayAvailable() && pipe_vertex_count < 600) {
  249.                 pipe_array[pipe_vertex_count].vertex_index = neighbour_index;
  250.                 BrVector3Sub(&pipe_array[pipe_vertex_count].delta_coordinates, target_point, &old_vector);
  251.                 pipe_vertex_count++;
  252.             }
  253.         } else {
  254.             neighbour_index += the_neighbour->factor;
  255.         }
  256.     }
  257.     if (IsActionReplayAvailable() && pipe_vertex_count) {
  258.         PipeSingleModelGeometry(pCar->car_ID, pModel_index, pipe_vertex_count, pipe_array);
  259.     }
  260. }
  261.  
  262. // IDA: void __usercall CrushModel(tCar_spec *pCar@<EAX>, int pModel_index@<EDX>, br_actor *pActor@<EBX>, br_vector3 *pImpact_point@<ECX>, br_vector3 *pEnergy_vector, tCrush_data *pCrush_data)
  263. void CrushModel(tCar_spec* pCar, int pModel_index, br_actor* pActor, br_vector3* pImpact_point, br_vector3* pEnergy_vector, tCrush_data* pCrush_data) {
  264.     br_scalar this_distance;
  265.     br_scalar total_energy;
  266.     br_scalar nearest_so_far;
  267.     br_vector3 impact_point_model;
  268.     br_vector3 energy_vector_scaled;
  269.     br_vector3 energy_vector_model;
  270.     int i;
  271.     int nearest_index;
  272.     br_vertex* vertices;
  273.     br_vertex* the_vertex;
  274.     //br_matrix34 inverse_transform; // Pierre-Marie Baty -- unused variable
  275.     LOG_TRACE("(%p, %d, %p, %p, %p, %p)", pCar, pModel_index, pActor, pImpact_point, pEnergy_vector, pCrush_data);
  276.  
  277.     if (gArrow_mode) {
  278.         return;
  279.     }
  280.     if (pCrush_data->number_of_crush_points == 0) {
  281.         return;
  282.     }
  283.     BrVector3Sub(&impact_point_model, pImpact_point, (br_vector3*)pActor->t.t.mat.m[3]);
  284.     BrVector3Scale(&energy_vector_model, pEnergy_vector, pCrush_data->softness_factor * gCar_crush_softness);
  285.     total_energy = BrVector3Length(&energy_vector_model);
  286.     if (total_energy < 0.06f) {
  287.         return;
  288.     }
  289.     BrVector3Scale(&energy_vector_scaled, &energy_vector_model, (total_energy - 0.06f) / total_energy);
  290.     nearest_so_far = BR_SCALAR_MAX;
  291.     vertices = pActor->model->vertices;
  292.     nearest_index = -1;
  293.     for (i = 0; i < pCrush_data->number_of_crush_points; i++) {
  294.         the_vertex = &vertices[pCrush_data->crush_points[i].vertex_index];
  295.         this_distance = (impact_point_model.v[2] - the_vertex->p.v[2]) * (impact_point_model.v[2] - the_vertex->p.v[2]) + (impact_point_model.v[1] - the_vertex->p.v[1]) * (impact_point_model.v[1] - the_vertex->p.v[1]) + (impact_point_model.v[0] - the_vertex->p.v[0]) * (impact_point_model.v[0] - the_vertex->p.v[0]);
  296.         if (this_distance < nearest_so_far) {
  297.             nearest_so_far = this_distance;
  298.             nearest_index = i;
  299.         }
  300.     }
  301.     if (nearest_index >= 0) {
  302.         CrushModelPoint(pCar, pModel_index, pActor->model, nearest_index, &energy_vector_scaled, total_energy, pCrush_data);
  303.         SetModelForUpdate(pActor->model, pCar, 1);
  304.     }
  305. }
  306.  
  307. // IDA: void __cdecl JitModelUpdate(br_actor *actor, br_model *model, br_material *material, void *render_data, br_uint_8 style, int on_screen)
  308. void JitModelUpdate(br_actor* actor, br_model* model, br_material* material, void* render_data, br_uint_8 style, int on_screen) {
  309.     LOG_TRACE("(%p, %p, %p, %p, %d, %d)", actor, model, material, render_data, style, on_screen);
  310.  
  311.     BrModelUpdate(model, BR_MODU_VERTEX_POSITIONS);
  312.     model->flags &= ~(BR_MODF_CUSTOM);
  313.     BrZbModelRender(actor, model, material, style, BrOnScreenCheck(&model->bounds), 0);
  314. }
  315.  
  316. // IDA: void __usercall SetModelForUpdate(br_model *pModel@<EAX>, tCar_spec *pCar@<EDX>, int crush_only@<EBX>)
  317. void SetModelForUpdate(br_model* pModel, tCar_spec* pCar, int crush_only) {
  318.     LOG_TRACE("(%p, %p, %d)", pModel, pCar, crush_only);
  319.  
  320.     if (crush_only && pCar != NULL && pCar->car_model_actors[pCar->principal_car_actor].actor->model == pModel) {
  321.         CrushBoundingBox(pCar, crush_only);
  322.     }
  323.     if ((pModel->flags & BR_MODF_CUSTOM) != 0) {
  324.         pModel->user = JitModelUpdate;
  325.     } else {
  326.         pModel->custom = JitModelUpdate;
  327.         pModel->flags |= BR_MODF_CUSTOM;
  328.     }
  329. }
  330.  
  331. // IDA: void __usercall TotallySpamTheModel(tCar_spec *pCar@<EAX>, int pModel_index@<EDX>, br_actor *pActor@<EBX>, tCrush_data *pCrush_data@<ECX>, br_scalar pMagnitude)
  332. void TotallySpamTheModel(tCar_spec* pCar, int pModel_index, br_actor* pActor, tCrush_data* pCrush_data, br_scalar pMagnitude) {
  333.     //br_scalar total_energy; // Pierre-Marie Baty -- unused variable
  334.     br_vector3 energy_vector_model;
  335.     int i;
  336.     int the_index;
  337.     br_vertex* the_vertex;
  338.     //br_vertex* vertices; // Pierre-Marie Baty -- unused variable
  339.     LOG_TRACE("(%p, %d, %p, %p, %f)", pCar, pModel_index, pActor, pCrush_data, pMagnitude);
  340.  
  341.     if (gArrow_mode || pCrush_data->number_of_crush_points == 0) {
  342.         return;
  343.     }
  344.     the_vertex = pActor->model->vertices;
  345.     for (i = 0; i < 15; i++) {
  346.         the_index = IRandomBetween(0, pCrush_data->number_of_crush_points - 1);
  347.         energy_vector_model = the_vertex[pCrush_data->crush_points[the_index].vertex_index].p;
  348.         BrVector3Normalise(&energy_vector_model, &energy_vector_model);
  349.         BrVector3Scale(&energy_vector_model, &energy_vector_model, -pMagnitude);
  350.         CrushModelPoint(pCar, pModel_index, pActor->model, the_index, &energy_vector_model, pMagnitude, pCrush_data);
  351.     }
  352.     SetModelForUpdate(pActor->model, pCar, 1);
  353. }
  354.  
  355. // IDA: br_scalar __usercall RepairModel@<ST0>(tCar_spec *pCar@<EAX>, int pModel_index@<EDX>, br_actor *pActor@<EBX>, br_vertex *pUndamaged_vertices@<ECX>, br_scalar pAmount, br_scalar *pTotal_deflection)
  356. br_scalar RepairModel(tCar_spec* pCar, int pModel_index, br_actor* pActor, br_vertex* pUndamaged_vertices, br_scalar pAmount, br_scalar* pTotal_deflection) {
  357.     int i;
  358.     int j;
  359.     int pipe_vertex_count;
  360.     br_vector3 old_point;
  361.     br_vertex* model_vertex;
  362.     br_scalar amount;
  363.     //br_scalar deviation; // Pierre-Marie Baty -- unused variable
  364.     tChanged_vertex pipe_array[600];
  365.     LOG_TRACE("(%p, %d, %p, %p, %f, %p)", pCar, pModel_index, pActor, pUndamaged_vertices, pAmount, pTotal_deflection);
  366.  
  367.     pipe_vertex_count = 0;
  368.     amount = 0.0f;
  369.     *pTotal_deflection = 0.0f;
  370.  
  371.     for (i = 0; i < pActor->model->nvertices; i++) {
  372.         model_vertex = &pActor->model->vertices[i];
  373.         old_point = model_vertex->p;
  374.         for (j = 0; j < 3; ++j) {
  375.             *pTotal_deflection = fabsf(pUndamaged_vertices->p.v[j] - old_point.v[j]) + *pTotal_deflection;
  376.             if (pUndamaged_vertices->p.v[j] >= old_point.v[j]) {
  377.                 if (pUndamaged_vertices->p.v[j] > old_point.v[j]) {
  378.                     model_vertex->p.v[j] = model_vertex->p.v[j] + pAmount;
  379.                     if (pUndamaged_vertices->p.v[j] < model_vertex->p.v[j]) {
  380.                         model_vertex->p.v[j] = pUndamaged_vertices->p.v[j];
  381.                     }
  382.                     amount = model_vertex->p.v[j] - old_point.v[j] + amount;
  383.                 }
  384.             } else {
  385.                 model_vertex->p.v[j] = model_vertex->p.v[j] - pAmount;
  386.                 if (pUndamaged_vertices->p.v[j] > model_vertex->p.v[j]) {
  387.                     model_vertex->p.v[j] = pUndamaged_vertices->p.v[j];
  388.                 }
  389.                 amount = old_point.v[j] - model_vertex->p.v[j] + amount;
  390.             }
  391.         }
  392.         if (amount != 0.0 && IsActionReplayAvailable() && pipe_vertex_count < COUNT_OF(pipe_array)) {
  393.             pipe_array[pipe_vertex_count].vertex_index = i;
  394.             BrVector3Sub(&pipe_array[pipe_vertex_count].delta_coordinates, &model_vertex->p, &old_point);
  395.             pipe_vertex_count++;
  396.         }
  397.         pUndamaged_vertices++;
  398.     }
  399.     SetModelForUpdate(pActor->model, pCar, 0);
  400.     if (IsActionReplayAvailable() && pipe_vertex_count) {
  401.         PipeSingleModelGeometry(pCar->car_ID, pModel_index, pipe_vertex_count, pipe_array);
  402.     }
  403.     return amount;
  404. }
  405.  
  406. // IDA: float __usercall RepairCar2@<ST0>(tCar_spec *pCar@<EAX>, tU32 pFrame_period@<EDX>, br_scalar *pTotal_deflection@<EBX>)
  407. float RepairCar2(tCar_spec* pCar, tU32 pFrame_period, br_scalar* pTotal_deflection) {
  408.     int i;
  409.     tCar_actor* the_car_actor;
  410.     br_scalar amount;
  411.     br_scalar dummy;
  412.     LOG_TRACE("(%p, %d, %p)", pCar, pFrame_period, pTotal_deflection);
  413.  
  414.     if (gArrow_mode) {
  415.         return 0.0f;
  416.     }
  417.     *pTotal_deflection = 0.0;
  418.     amount = 0.0;
  419.  
  420.     for (i = 0; i < gProgram_state.current_car.car_actor_count; i++) {
  421.         the_car_actor = &pCar->car_model_actors[i];
  422.         if (the_car_actor->min_distance_squared == 0.0 || !the_car_actor->undamaged_vertices) {
  423.             if (the_car_actor->undamaged_vertices) {
  424.                 amount = RepairModel(pCar, i, the_car_actor->actor, the_car_actor->undamaged_vertices, pFrame_period * 0.00005f, pTotal_deflection);
  425.             }
  426.         } else {
  427.             RepairModel(pCar, i, the_car_actor->actor, the_car_actor->undamaged_vertices, pFrame_period * 0.00005f, &dummy);
  428.         }
  429.     }
  430.     pCar->repair_time += pFrame_period;
  431.     return amount;
  432. }
  433.  
  434. // IDA: float __usercall RepairCar@<ST0>(tU16 pCar_ID@<EAX>, tU32 pFrame_period@<EDX>, br_scalar *pTotal_deflection@<EBX>)
  435. float RepairCar(tU16 pCar_ID, tU32 pFrame_period, br_scalar* pTotal_deflection) {
  436.     LOG_TRACE("(%d, %d, %p)", pCar_ID, pFrame_period, pTotal_deflection);
  437.  
  438.     if (VEHICLE_TYPE_FROM_ID(pCar_ID) == eVehicle_self) {
  439.         return RepairCar2(&gProgram_state.current_car, pFrame_period, pTotal_deflection);
  440.     }
  441.  
  442.     return RepairCar2(GetCarSpec(VEHICLE_TYPE_FROM_ID(pCar_ID), VEHICLE_INDEX_FROM_ID(pCar_ID)), pFrame_period, pTotal_deflection);
  443. }
  444.  
  445. // IDA: void __usercall TotallyRepairACar(tCar_spec *pCar@<EAX>)
  446. void TotallyRepairACar(tCar_spec* pCar) {
  447.     int i;
  448.     int j;
  449.     int k;
  450.     int pipe_vertex_count;
  451.     tCar_actor* the_car_actor;
  452.     tChanged_vertex pipe_array[600];
  453.     br_bounds storage_bounds;
  454.     LOG_TRACE("(%p)", pCar);
  455.  
  456.     StopCarSmokingInstantly(pCar);
  457.     if (IsActionReplayAvailable()) {
  458.         PipeInstantUnSmudge(pCar);
  459.     }
  460.     pCar->repair_time += 100000;
  461.     for (i = 0; i < COUNT_OF(pCar->damage_units); i++) {
  462.         pCar->damage_units[i].damage_level = 0;
  463.         pCar->damage_units[i].last_level = 0;
  464.         pCar->damage_units[i].smoke_last_level = 0;
  465.     }
  466.     memcpy(&storage_bounds, &pCar->bounds[1], sizeof(br_bounds));
  467.     memcpy(&pCar->bounds[1], &pCar->max_bounds[1], sizeof(br_bounds));
  468.     if (TestForCarInSensiblePlace(pCar)) {
  469.         for (j = 0; j < pCar->car_actor_count; j++) {
  470.             the_car_actor = &pCar->car_model_actors[j];
  471.             if (the_car_actor->undamaged_vertices != NULL) {
  472.                 pipe_vertex_count = 0;
  473.                 for (k = 0; k < the_car_actor->actor->model->nvertices; k++) {
  474.                     if (pipe_vertex_count < COUNT_OF(pipe_array)) {
  475.                         BrVector3Sub(&pipe_array[pipe_vertex_count].delta_coordinates,
  476.                             &the_car_actor->undamaged_vertices[k].p, &the_car_actor->actor->model->vertices[k].p);
  477.                         if (!Vector3IsZero(&pipe_array[pipe_vertex_count].delta_coordinates)) {
  478.                             pipe_array[pipe_vertex_count].vertex_index = k;
  479.                             pipe_vertex_count++;
  480.                         }
  481.                     }
  482.                 }
  483.                 memcpy(the_car_actor->actor->model->vertices,
  484.                     the_car_actor->undamaged_vertices,
  485.                     the_car_actor->actor->model->nvertices * sizeof(br_vertex));
  486.                 // FIXME: BrModelUpdate(..., BR_MODU_VERTEX_COLOURS | BR_MODU_VERTEX_POSITIONS) fails on TELL_ME_IF_WE_PASS_THIS_WAY
  487. //                BrModelUpdate(the_car_actor->actor->model, BR_MODU_VERTEX_COLOURS | BR_MODU_VERTEX_POSITIONS);
  488.                 BrModelUpdate(the_car_actor->actor->model, BR_MODU_ALL);
  489.                 if (pipe_vertex_count != 0 && IsActionReplayAvailable()) {
  490.                     PipeSingleModelGeometry(pCar->car_ID, j, pipe_vertex_count, pipe_array);
  491.                 }
  492.             }
  493.         }
  494.     } else {
  495.         memcpy(&pCar->bounds[1], &storage_bounds, sizeof(br_bounds));
  496.     }
  497. }
  498.  
  499. // IDA: void __cdecl TotallyRepairCar()
  500. void TotallyRepairCar(void) {
  501.     LOG_TRACE("()");
  502.  
  503.     if (!gArrow_mode) {
  504.         TotallyRepairACar(&gProgram_state.current_car);
  505.     }
  506. }
  507.  
  508. // IDA: void __cdecl CheckLastCar()
  509. void CheckLastCar(void) {
  510.     LOG_TRACE("()");
  511.  
  512.     if (gNet_mode == eNet_mode_none && GetCarCount(eVehicle_opponent) != 0 && NumberOfOpponentsLeft() == 0) {
  513.         NewTextHeadupSlot(4, 0, 5000, -4, GetMiscString(kMiscString_EveryOpponentWasted));
  514.         RaceCompleted(eRace_over_opponents);
  515.     }
  516. }
  517.  
  518. // IDA: void __usercall KnackerThisCar(tCar_spec *pCar@<EAX>)
  519. void KnackerThisCar(tCar_spec* pCar) {
  520.     LOG_TRACE("(%p)", pCar);
  521.  
  522.     pCar->knackered = 1;
  523.     QueueWastedMassage(pCar->index);
  524.     CheckLastCar();
  525.     QueueOilSpill(pCar);
  526.     if (gNet_mode == eNet_mode_none) {
  527.         KillGroovadelic(pCar->index);
  528.         KillFunkotronic(pCar->index);
  529.     }
  530. }
  531.  
  532. // IDA: void __usercall SetKnackeredFlag(tCar_spec *pCar@<EAX>)
  533. void SetKnackeredFlag(tCar_spec* pCar) {
  534.     LOG_TRACE("(%p)", pCar);
  535.  
  536.     if (gNet_mode != eNet_mode_client
  537.         && !pCar->knackered
  538.         && (pCar->damage_units[eDamage_engine].damage_level >= 99
  539.             || pCar->damage_units[eDamage_transmission].damage_level >= 99
  540.             || pCar->damage_units[eDamage_driver].damage_level >= 99
  541.             || (pCar->damage_units[eDamage_lf_wheel].damage_level >= 99
  542.                 && pCar->damage_units[eDamage_rf_wheel].damage_level >= 99
  543.                 && pCar->damage_units[eDamage_lr_wheel].damage_level >= 99
  544.                 && pCar->damage_units[eDamage_rr_wheel].damage_level >= 99))) {
  545.         KnackerThisCar(pCar);
  546.         if (gNet_mode == eNet_mode_none) {
  547.             if (IRandomBetween(0, 1)) {
  548.                 if (gNet_mode == eNet_mode_none) {
  549.                     StopCarSmoking(pCar);
  550.                     CreateSmokeColumn(pCar, 0, IRandomBetween(0, 11), 20000);
  551.                 }
  552.             }
  553.             CreateSmokeColumn(pCar, 0, IRandomBetween(0, 11), 180000);
  554.         }
  555.     }
  556. }
  557.  
  558. // IDA: void __usercall DamageUnit2(tCar_spec *pCar@<EAX>, int pUnit_type@<EDX>, int pDamage_amount@<EBX>)
  559. void DamageUnit2(tCar_spec* pCar, int pUnit_type, int pDamage_amount) {
  560.     tDamage_unit* the_damage;
  561.     int last_level;
  562.     LOG_TRACE("(%p, %d, %d)", pCar, pUnit_type, pDamage_amount);
  563.  
  564.     the_damage = &pCar->damage_units[pUnit_type];
  565.     if ((pCar->driver < eDriver_net_human || pUnit_type != eDamage_driver) && pDamage_amount >= 5 && !pCar->invulnerable) {
  566.         last_level = the_damage->damage_level;
  567.         the_damage->damage_level = pDamage_amount + last_level;
  568.         if (the_damage->damage_level >= 99) {
  569.             if (pDamage_amount >= 10) {
  570.                 the_damage->damage_level = 99;
  571.             } else {
  572.                 the_damage->damage_level = last_level;
  573.             }
  574.         }
  575.         if (pCar->driver == eDriver_oppo || gNet_mode != eNet_mode_none) {
  576.             SetKnackeredFlag(pCar);
  577.         } else if ((pCar->damage_units[eDamage_engine].damage_level >= 99 && pCar->damage_units[eDamage_engine].last_level < 99 && pCar->damage_units[eDamage_transmission].last_level < 99)
  578.             || (pCar->damage_units[eDamage_transmission].damage_level >= 99 && pCar->damage_units[eDamage_engine].last_level < 99 && pCar->damage_units[eDamage_transmission].last_level < 99)) {
  579.             QueueOilSpill(pCar);
  580.         }
  581.     }
  582. }
  583.  
  584. // IDA: void __usercall RecordLastDamage(tCar_spec *pCar@<EAX>)
  585. void RecordLastDamage(tCar_spec* pCar) {
  586.     int i;
  587.     LOG_TRACE("(%p)", pCar);
  588.  
  589.     for (i = 0; i < COUNT_OF(pCar->damage_units); i++) {
  590.         pCar->damage_units[i].last_level = pCar->damage_units[i].damage_level;
  591.     }
  592.     pCar->damage_magnitude_accumulator = 0.0;
  593.     pCar->last_impact_location = eImpact_unknown;
  594.     pCar->pre_car_col_mat = pCar->car_master_actor->t.t.mat;
  595.     pCar->pre_car_col_speed = pCar->speed;
  596.     pCar->pre_car_col_knackered = pCar->knackered;
  597.     pCar->pre_car_col_direction = pCar->direction;
  598.     pCar->pre_car_col_velocity = pCar->v;
  599.     pCar->pre_car_col_velocity_car_space = pCar->velocity_car_space;
  600. }
  601.  
  602. // IDA: void __usercall DoDamage(tCar_spec *pCar@<EAX>, tDamage_type pDamage_type@<EDX>, float pMagnitude, float pNastiness)
  603. void DoDamage(tCar_spec* pCar, tDamage_type pDamage_type, float pMagnitude, float pNastiness) {
  604.     LOG_TRACE("(%p, %d, %f, %f)", pCar, pDamage_type, pMagnitude, pNastiness);
  605.  
  606.     if (pCar->driver < eDriver_net_human) {
  607.         DamageUnit2(pCar, pDamage_type, ((gCurrent_race.suggested_rank < 10 ? 0.5f : gCurrent_race.suggested_rank) / 20.0f + 1.0f) * (pNastiness * pMagnitude * 10.0f));
  608.     } else if (gNet_mode != eNet_mode_none) {
  609.         DamageUnit2(pCar, pDamage_type, pNastiness * pMagnitude * 15.0f);
  610.     } else if (PercentageChance(pNastiness * pMagnitude * 1500.0f)) {
  611.         DamageUnit2(pCar, pDamage_type, pNastiness * pMagnitude * 30.0f);
  612.     }
  613. }
  614.  
  615. // IDA: void __usercall CheckPiledriverBonus(tCar_spec *pCar@<EAX>, br_vector3 *pImpact_point@<EDX>, br_vector3 *pEnergy@<EBX>)
  616. void CheckPiledriverBonus(tCar_spec* pCar, br_vector3* pImpact_point, br_vector3* pEnergy) {
  617.     br_actor* child;
  618.     br_vector3 norm_impact;
  619.     br_vector3 norm_child;
  620.     br_vector3 norm_energy;
  621.     //br_scalar dp; // Pierre-Marie Baty -- unused variable
  622.     LOG_TRACE("(%p, %p, %p)", pCar, pImpact_point, pEnergy);
  623.  
  624.     if (pCar->current_car_actor < 0) {
  625.         return;
  626.     }
  627.  
  628.     BrVector3Normalise(&norm_impact, pImpact_point);
  629.     norm_impact.v[1] = 0.f;
  630.     BrVector3Normalise(&norm_energy, pEnergy);
  631.  
  632.     for (child = pCar->car_master_actor->children; child != NULL; child = child->next) {
  633.         if (ActorIsPedestrian(child) && PedestrianActorIsPerson(child) && pCar->speed > 0.001f) {
  634.             BrVector3Normalise(&norm_child, &child->t.t.translate.t);
  635.             norm_child.v[1] = 0.f;
  636.             if (BrVector3Dot(&norm_child, &norm_impact) > 0.8f && BrVector3Dot(&norm_energy, &norm_child) < -.65) {
  637.                 DoFancyHeadup(kFancyHeadupPileDriverBonus);
  638.                 EarnCredits(((GetPedestrianValue(child) / 2 + 12) / 25) * 25);
  639.                 return;
  640.             }
  641.         }
  642.     }
  643. }
  644.  
  645. // IDA: tImpact_location __usercall CalcModifiedLocation@<EAX>(tCar_spec *pCar@<EAX>)
  646. tImpact_location CalcModifiedLocation(tCar_spec* pCar) {
  647.     LOG_TRACE("(%p)", pCar);
  648.  
  649.     if (pCar->last_impact_location != eImpact_left && pCar->last_impact_location != eImpact_right && pCar->last_impact_location != eImpact_top && pCar->last_impact_location != eImpact_bottom) {
  650.         return pCar->last_impact_location;
  651.     }
  652.     if (pCar->last_col_prop_z < 0.25f) {
  653.         return eImpact_front;
  654.     }
  655.     if (pCar->last_col_prop_z > 0.75f) {
  656.         return eImpact_back;
  657.     } else {
  658.         return pCar->last_impact_location;
  659.     }
  660. }
  661.  
  662. // IDA: void __usercall DoPratcamHit(br_vector3 *pHit_vector@<EAX>)
  663. void DoPratcamHit(br_vector3* pHit_vector) {
  664.     //int strength_modifier; // Pierre-Marie Baty -- unused variable
  665.     //br_scalar strength; // Pierre-Marie Baty -- unused variable
  666.     LOG_TRACE("(%p)", pHit_vector);
  667.  
  668.     STUB_ONCE();
  669. }
  670.  
  671. // IDA: void __usercall DamageSystems(tCar_spec *pCar@<EAX>, br_vector3 *pImpact_point@<EDX>, br_vector3 *pEnergy_vector@<EBX>, int pWas_hitting_a_car@<ECX>)
  672. void DamageSystems(tCar_spec* pCar, br_vector3* pImpact_point, br_vector3* pEnergy_vector, int pWas_hitting_a_car) {
  673.     int i;
  674.     int j;
  675.     int result;
  676.     br_bounds crushed_car_bounds;
  677.     float proportion_x;
  678.     float proportion_y;
  679.     float proportion_z;
  680.     float energy_magnitude;
  681.     float pure_energy_magnitude;
  682.     br_scalar x;
  683.     br_scalar y;
  684.     br_scalar z;
  685.     br_scalar x1;
  686.     br_scalar x2;
  687.     br_scalar y1;
  688.     br_scalar y2;
  689.     br_scalar z1;
  690.     br_scalar z2;
  691.     //br_scalar distance; // Pierre-Marie Baty -- unused variable
  692.     tImpact_location impact_location;
  693.     tDamage_program* the_program;
  694.     tDamage_clause* the_clause;
  695.     tDamage_condition* the_condition;
  696.     tDamage_effect* the_effect;
  697.     //tImpact_location modified_location; // Pierre-Marie Baty -- unused variable
  698.     LOG_TRACE("(%p, %p, %p, %d)", pCar, pImpact_point, pEnergy_vector, pWas_hitting_a_car);
  699.  
  700. #if defined(DETHRACE_FIX_BUGS)
  701.     proportion_x = 0;
  702.     proportion_y = 0;
  703.     proportion_z = 0;
  704. #endif
  705.  
  706.     pure_energy_magnitude = BrVector3Length(pEnergy_vector);
  707.     if (pure_energy_magnitude == 0.0f && !pWas_hitting_a_car) {
  708.         return;
  709.     }
  710.  
  711.     energy_magnitude = pCar->car_model_actors[pCar->principal_car_actor].crush_data.softness_factor * pure_energy_magnitude / 0.7f;
  712.     BrVector3InvScale(&crushed_car_bounds.min, &pCar->bounds[1].min, WORLD_SCALE);
  713.     BrVector3InvScale(&crushed_car_bounds.max, &pCar->bounds[1].max, WORLD_SCALE);
  714.  
  715.     x1 = pImpact_point->v[0] - crushed_car_bounds.min.v[0];
  716.     x2 = crushed_car_bounds.max.v[0] - pImpact_point->v[0];
  717.     if (x1 >= x2) {
  718.         x = x2;
  719.     } else {
  720.         x = x1;
  721.     }
  722.     y1 = pImpact_point->v[1] - crushed_car_bounds.min.v[1];
  723.     y2 = crushed_car_bounds.max.v[1] - pImpact_point->v[1];
  724.     if (y1 >= y2) {
  725.         y = y2;
  726.     } else {
  727.         y = y1;
  728.     }
  729.     z1 = pImpact_point->v[2] - crushed_car_bounds.min.v[2];
  730.     z2 = crushed_car_bounds.max.v[2] - pImpact_point->v[2];
  731.     if (z1 >= z2) {
  732.         z = z2;
  733.     } else {
  734.         z = z1;
  735.     }
  736.     if (z > x || z > y) {
  737.         if (x > y || x > z) {
  738.             impact_location = y1 < y2 ? eImpact_bottom : eImpact_top;
  739.             proportion_z = z1 / (crushed_car_bounds.max.v[2] - crushed_car_bounds.min.v[2]);
  740.             proportion_x = x1 / (crushed_car_bounds.max.v[0] - crushed_car_bounds.min.v[0]);
  741.         } else {
  742.             impact_location = x1 >= x2 ? eImpact_right : eImpact_left;
  743.             proportion_z = z1 / (crushed_car_bounds.max.v[2] - crushed_car_bounds.min.v[2]);
  744.             proportion_y = y1 / (crushed_car_bounds.max.v[1] - crushed_car_bounds.min.v[1]);
  745.         }
  746.     } else {
  747.         impact_location = z1 >= z2 ? eImpact_back : eImpact_front;
  748.         proportion_x = x1 / (crushed_car_bounds.max.v[0] - crushed_car_bounds.min.v[0]);
  749.         proportion_y = y1 / (crushed_car_bounds.max.v[1] - crushed_car_bounds.min.v[1]);
  750.     }
  751.     if (pWas_hitting_a_car && pCar->last_impact_location == eImpact_unknown) {
  752.         pCar->last_impact_location = impact_location;
  753.         pCar->last_col_prop_x = proportion_x;
  754.         pCar->last_col_prop_y = proportion_y;
  755.         pCar->last_col_prop_z = proportion_z;
  756.     }
  757.  
  758.     if (energy_magnitude != 0.0f && !pCar->invulnerable) {
  759.         if (!pWas_hitting_a_car && impact_location == eImpact_bottom) {
  760.             energy_magnitude = energy_magnitude / 2.0f;
  761.         }
  762.  
  763.         the_program = &pCar->damage_programs[impact_location];
  764.         the_clause = the_program->clauses;
  765.         for (i = 0; i < the_program->clause_count; i++) {
  766.             result = 1;
  767.             the_condition = the_clause->conditions;
  768.             for (j = 0; j < the_clause->condition_count; j++) {
  769.                 switch (the_condition->axis_comp) {
  770.                 case eAxis_x:
  771.                     if (the_condition->condition_operator == eCondition_greater_than) {
  772.                         if (the_condition->comparitor >= proportion_x) {
  773.                             result = 0;
  774.                         }
  775.                     } else if (the_condition->comparitor <= proportion_x) {
  776.                         result = 0;
  777.                     }
  778.                     break;
  779.  
  780.                 case eAxis_y:
  781.                     if (the_condition->condition_operator == eCondition_greater_than) {
  782.                         if (the_condition->comparitor >= proportion_y) {
  783.                             result = 0;
  784.                         }
  785.                     } else if (the_condition->comparitor <= proportion_y) {
  786.                         result = 0;
  787.                     }
  788.                     break;
  789.  
  790.                 case eAxis_z:
  791.                     if (the_condition->condition_operator == eCondition_greater_than) {
  792.                         if (the_condition->comparitor >= proportion_z) {
  793.                             result = 0;
  794.                         }
  795.                     } else if (the_condition->comparitor <= proportion_z) {
  796.                         result = 0;
  797.                     }
  798.                     break;
  799.                 }
  800.  
  801.                 if (!result) {
  802.                     break;
  803.                 }
  804.                 the_condition++;
  805.             }
  806.             if (result) {
  807.                 for (j = 0; j < the_clause->effect_count; j++) {
  808.                     the_effect = &the_clause->effects[j];
  809.                     DoDamage(pCar, the_effect->type, energy_magnitude, the_effect->weakness_factor);
  810.                 }
  811.             }
  812.             the_clause++;
  813.         }
  814.         if (pCar->driver == eDriver_local_human) {
  815.             switch (impact_location) {
  816.             case eImpact_top:
  817.             case eImpact_bottom:
  818.                 NewScreenWobble(
  819.                     FRandomBetween(energy_magnitude * 5.0f, energy_magnitude * 20.0f),
  820.                     FRandomBetween(energy_magnitude * 30.0f, energy_magnitude * 60.0f),
  821.                     FRandomBetween(1.0f / energy_magnitude, 5.0f / energy_magnitude));
  822.                 break;
  823.             case eImpact_left:
  824.                 NewScreenWobble(
  825.                     FRandomBetween(energy_magnitude * 50.0f, energy_magnitude * 100.0f),
  826.                     FRandomBetween(energy_magnitude * 5.0f, energy_magnitude * 20.0f),
  827.                     FRandomBetween(4.0f / energy_magnitude, 7.0 / energy_magnitude));
  828.                 break;
  829.             case eImpact_right:
  830.                 NewScreenWobble(
  831.                     -FRandomBetween(energy_magnitude * 50.0f, energy_magnitude * 100.0f),
  832.                     FRandomBetween(energy_magnitude * 5.0f, energy_magnitude * 20.0f),
  833.                     FRandomBetween(4.0f / energy_magnitude, 7.0f / energy_magnitude));
  834.  
  835.                 break;
  836.             case eImpact_front:
  837.                 NewScreenWobble(
  838.                     FRandomBetween(energy_magnitude * 5.0f, energy_magnitude * 20.0f),
  839.                     FRandomBetween(energy_magnitude * 50.0f, energy_magnitude * 150.0f),
  840.                     FRandomBetween(7.0f / energy_magnitude, 25.0f / energy_magnitude));
  841.                 break;
  842.             case eImpact_back:
  843.                 NewScreenWobble(
  844.                     FRandomBetween(energy_magnitude * 5.0f, energy_magnitude * 20.0f),
  845.                     FRandomBetween(-energy_magnitude * 50.0f, energy_magnitude * 150.0f),
  846.                     FRandomBetween(7.0f / energy_magnitude, 25.0f / energy_magnitude));
  847.                 break;
  848.             default:
  849.                 break;
  850.             }
  851.             CheckPiledriverBonus(pCar, pImpact_point, pEnergy_vector);
  852.         }
  853.     }
  854. }
  855.  
  856. // IDA: tImpact_location __usercall GetDirection@<EAX>(br_vector3 *pVelocity@<EAX>)
  857. tImpact_location GetDirection(br_vector3* pVelocity) {
  858.     br_scalar mag_x;
  859.     br_scalar mag_y;
  860.     br_scalar mag_z;
  861.     LOG_TRACE("(%p)", pVelocity);
  862.  
  863.     mag_x = fabsf(pVelocity->v[0]);
  864.     mag_y = fabsf(pVelocity->v[1]);
  865.     mag_z = fabsf(pVelocity->v[2]);
  866.     if (mag_y >= mag_x || mag_z >= mag_x) {
  867.         if (mag_y <= mag_x || mag_z >= mag_y) {
  868.             if (pVelocity->v[2] >= 0.0f) {
  869.                 return eImpact_back;
  870.             } else {
  871.                 return eImpact_front;
  872.             }
  873.         } else {
  874.             return pVelocity->v[1] < 0.0;
  875.         }
  876.     } else if (pVelocity->v[0] >= 0.0) {
  877.         return eImpact_right;
  878.     } else {
  879.         return eImpact_left;
  880.     }
  881. }
  882.  
  883. // IDA: void __usercall SetSmokeLastDamageLevel(tCar_spec *pCar@<EAX>)
  884. void SetSmokeLastDamageLevel(tCar_spec* pCar) {
  885.     int i;
  886.     LOG_TRACE("(%p)", pCar);
  887.  
  888.     for (i = 0; i < COUNT_OF(pCar->damage_units); i++) {
  889.         pCar->damage_units[i].smoke_last_level = pCar->damage_units[i].damage_level;
  890.     }
  891. }
  892.  
  893. // IDA: void __usercall SortOutSmoke(tCar_spec *pCar@<EAX>)
  894. void SortOutSmoke(tCar_spec* pCar) {
  895.     int i;
  896.     int colour;
  897.     int old_colour;
  898.     int step;
  899.     //int pass; // Pierre-Marie Baty -- unused variable
  900.     //int repeat; // Pierre-Marie Baty -- unused variable
  901.     LOG_TRACE("(%p)", pCar);
  902.  
  903.     if (!pCar || pCar->driver <= eDriver_non_car) {
  904.         return;
  905.     }
  906.     for (i = 0; i < COUNT_OF(pCar->damage_units); i++) {
  907.         if (pCar->damage_units[i].damage_level != pCar->damage_units[i].smoke_last_level) {
  908.             step = gSmoke_damage_step[i];
  909.             if (step) {
  910.                 if (pCar->damage_units[i].damage_level > pCar->damage_units[i].smoke_last_level) {
  911.                     old_colour = (99 - pCar->damage_units[i].smoke_last_level) / step;
  912.                     colour = (99 - pCar->damage_units[i].damage_level) / step;
  913.                     if (old_colour != colour && colour <= 2) {
  914.                         ConditionalSmokeColumn(pCar, i, colour);
  915.                     }
  916.                 }
  917.             }
  918.         }
  919.     }
  920.     SetSmokeLastDamageLevel(pCar);
  921. }
  922.  
  923. // IDA: void __usercall StealCar(tCar_spec *pCar@<EAX>)
  924. void StealCar(tCar_spec* pCar) {
  925.     LOG_TRACE("(%p)", pCar);
  926.  
  927.     pCar->has_been_stolen = 1;
  928.     gProgram_state.cars_available[gProgram_state.number_of_cars] = pCar->index;
  929.     gProgram_state.number_of_cars++;
  930.     gOpponents[pCar->index].dead = 1;
  931. }
  932.  
  933. // IDA: int __usercall DoCrashEarnings@<EAX>(tCar_spec *pCar1@<EAX>, tCar_spec *pCar2@<EDX>)
  934. int DoCrashEarnings(tCar_spec* pCar1, tCar_spec* pCar2) {
  935.     tCar_spec* culprit;
  936.     tCar_spec* victim;
  937.     int i;
  938.     int net_loop;
  939.     int head_on;
  940.     int bonus_level;
  941.     int credits;
  942.     int impact_in_moving_direction_1;
  943.     int impact_in_moving_direction_2;
  944.     int car_off_ground_1;
  945.     int car_off_ground_2;
  946.     int total_units_of_damage;
  947.     int inherited_damage;
  948.     int dam_acc_1;
  949.     int dam_acc_2;
  950.     int car_1_culpable;
  951.     int car_2_culpable;
  952.     int mutual_culpability;
  953.     tU32 the_time;
  954.     tU32 time;
  955.     float credits_squared;
  956.     static tU32 last_earn_time;
  957.     //char s[256]; // Pierre-Marie Baty -- unused variable
  958.     tImpact_location modified_location_1;
  959.     tImpact_location modified_location_2;
  960.     tImpact_location car_direction_1;
  961.     tImpact_location car_direction_2;
  962.     br_scalar car_1_height;
  963.     br_scalar car_2_height;
  964.     br_scalar dp;
  965.     br_vector3 car_1_pos;
  966.     br_vector3 car_2_pos;
  967.     br_vector3 car_1_offset;
  968.     br_vector3 car_2_offset;
  969.     tNet_message* message;
  970.     LOG_TRACE("(%p, %p)", pCar1, pCar2);
  971.  
  972.     culprit = 0;
  973.     victim = 0;
  974.     head_on = 0;
  975.     bonus_level = 1;
  976.     car_1_culpable = 0;
  977.     car_2_culpable = 0;
  978.     mutual_culpability = 0;
  979.     the_time = PDGetTotalTime();
  980.     inherited_damage = 0;
  981. #if defined(DETHRACE_FIX_BUGS)
  982.     total_units_of_damage = 0;
  983. #endif
  984.     if (pCar1->driver <= eDriver_non_car) {
  985.         dam_acc_1 = 0;
  986.     } else {
  987.         dam_acc_1 = pCar1->damage_magnitude_accumulator;
  988.     }
  989.  
  990.     dam_acc_2 = 0;
  991.     if (pCar2 != NULL) {
  992.         if (pCar2->driver <= eDriver_non_car) {
  993.             dam_acc_2 = 0;
  994.         } else {
  995.             dam_acc_2 = pCar2->damage_magnitude_accumulator != 0;
  996.         }
  997.     }
  998.  
  999.     if (pCar1->driver <= eDriver_non_car) {
  1000.         if (pCar2 == NULL || pCar2->driver <= eDriver_non_car) {
  1001.             return 0;
  1002.         }
  1003.         pCar1 = pCar2;
  1004.         pCar2 = NULL;
  1005.     }
  1006.     if (pCar2 != NULL && pCar2->driver <= eDriver_non_car) {
  1007.         pCar2 = NULL;
  1008.     }
  1009.  
  1010.     if (pCar1->pre_car_col_knackered || (pCar2 && pCar2->pre_car_col_knackered) || (pCar2 && pCar2->damage_magnitude_accumulator <= 0.00005f && pCar1->damage_magnitude_accumulator <= 0.00005f)) {
  1011.         return dam_acc_1 || (pCar2 && dam_acc_2);
  1012.     }
  1013.  
  1014.     modified_location_1 = CalcModifiedLocation(pCar1);
  1015.     car_direction_1 = GetDirection(&pCar1->pre_car_col_velocity_car_space);
  1016.     impact_in_moving_direction_1 = car_direction_1 == modified_location_1;
  1017.     if (pCar2 != NULL) {
  1018.         modified_location_2 = CalcModifiedLocation(pCar2);
  1019.         car_direction_2 = GetDirection(&pCar2->pre_car_col_velocity_car_space);
  1020.         impact_in_moving_direction_2 = car_direction_2 == modified_location_2;
  1021.     }
  1022.     if (pCar1->driver >= eDriver_net_human && pCar2) {
  1023.         if (impact_in_moving_direction_1 && (pCar1->driver < eDriver_net_human || (pCar1->pre_car_col_velocity_car_space.v[2] != 0.0 && (pCar1->pre_car_col_velocity_car_space.v[2] > 0.0) != (pCar1->gear > 0) && (pCar1->keys.acc != 0 || pCar1->joystick.acc > 0x8000)))) {
  1024.             pCar2->time_last_hit = the_time;
  1025.             pCar2->last_hit_by = pCar1;
  1026.         }
  1027.     } else if (pCar2 && pCar2->driver >= eDriver_net_human && impact_in_moving_direction_2 && (pCar2->driver < eDriver_net_human || (pCar2->pre_car_col_velocity_car_space.v[2] != 0.0f && (pCar2->pre_car_col_velocity_car_space.v[2] > 0.0f) != (pCar2->gear > 0) && (pCar2->keys.acc != 0 || pCar2->joystick.acc > 0x8000)))) {
  1028.         pCar1->time_last_hit = the_time;
  1029.         pCar1->last_hit_by = pCar2;
  1030.     }
  1031.     if (pCar2) {
  1032.         if (impact_in_moving_direction_1
  1033.             && pCar1->pre_car_col_speed * 5.0f > pCar2->pre_car_col_speed
  1034.             && pCar1->pre_car_col_speed > 0.0005f
  1035.             && (pCar1->driver < eDriver_net_human
  1036.                 || (pCar1->pre_car_col_velocity_car_space.v[2] != 0.0f
  1037.                     && (pCar1->pre_car_col_velocity_car_space.v[2] > 0.0f) != (pCar1->gear > 0)
  1038.                     && (pCar1->keys.acc != 0 || pCar1->joystick.acc > 0x8000)))) {
  1039.             car_1_culpable = 1;
  1040.         }
  1041.         if (impact_in_moving_direction_2
  1042.             && pCar2->pre_car_col_speed * 5.0f > pCar1->pre_car_col_speed
  1043.             && pCar2->pre_car_col_speed > 0.0005f
  1044.             && (pCar2->driver < eDriver_net_human
  1045.                 || (pCar2->pre_car_col_velocity_car_space.v[2] != 0.0f
  1046.                     && (pCar2->pre_car_col_velocity_car_space.v[2] > 0.0f) != (pCar2->gear > 0)
  1047.                     && (pCar2->keys.acc != 0 || pCar2->joystick.acc > 0x8000)))) {
  1048.             car_2_culpable = 1;
  1049.         }
  1050.         if (gNet_mode && car_1_culpable && car_2_culpable) {
  1051.             mutual_culpability = 1;
  1052.         } else {
  1053.             if (car_2_culpable && pCar2->driver == eDriver_local_human) {
  1054.                 car_1_culpable = 0;
  1055.             }
  1056.             if (car_1_culpable) {
  1057.                 culprit = pCar1;
  1058.                 victim = pCar2;
  1059.                 dp = BrVector3Dot(&pCar1->pre_car_col_direction, &pCar2->pre_car_col_direction);
  1060.                 if (modified_location_1 == eImpact_front && modified_location_2 == eImpact_front && pCar1->pre_car_col_speed > 0.001f && pCar2->pre_car_col_speed > 0.001f && dp < -0.7f) {
  1061.                     head_on = 1;
  1062.                     bonus_level = 2;
  1063.                 } else {
  1064.                     bonus_level = 1;
  1065.                 }
  1066.             } else if (car_2_culpable) {
  1067.                 culprit = pCar2;
  1068.                 victim = pCar1;
  1069.                 dp = BrVector3Dot(&pCar1->pre_car_col_direction, &pCar2->pre_car_col_direction);
  1070.                 if (modified_location_1 == eImpact_front && modified_location_2 == eImpact_front && pCar1->pre_car_col_speed > 0.001f && pCar2->pre_car_col_speed > 0.001f && dp < -0.7f) {
  1071.                     head_on = 1;
  1072.                     bonus_level = 2;
  1073.                 } else {
  1074.                     bonus_level = 1;
  1075.                 }
  1076.             }
  1077.         }
  1078.     } else {
  1079.         if (the_time - pCar1->time_last_hit >= 3000) {
  1080.             return 1;
  1081.         }
  1082.         culprit = pCar1->last_hit_by;
  1083.         victim = pCar1;
  1084.         bonus_level = 1;
  1085.         inherited_damage = 1;
  1086.     }
  1087.     if (!mutual_culpability && (!victim || culprit->driver < eDriver_net_human)) {
  1088.         if (pCar2 && pCar2->last_culprit == pCar1 && the_time - pCar2->time_last_victim < 750) {
  1089.             inherited_damage = 1;
  1090.             culprit = pCar1;
  1091.             victim = pCar2;
  1092.         } else if (pCar2 && pCar1->last_culprit == pCar2 && the_time - pCar1->time_last_victim < 750) {
  1093.             inherited_damage = 1;
  1094.             culprit = pCar2;
  1095.             victim = pCar1;
  1096.         } else if (!pCar2 && the_time - pCar1->time_last_victim < 750) {
  1097.             inherited_damage = 1;
  1098.             culprit = pCar1->last_culprit;
  1099.             victim = pCar1;
  1100.         }
  1101.     }
  1102.     if (culprit && victim) {
  1103.         RecordOpponentTwattageOccurrence(culprit, victim);
  1104.         total_units_of_damage = 0;
  1105.         for (i = 0; i < COUNT_OF(victim->damage_units); i++) {
  1106.             if (victim->damage_units[i].damage_level > victim->damage_units[i].last_level) {
  1107.                 victim->damage_units[i].damage_level = (victim->damage_units[i].damage_level - victim->damage_units[i].last_level) * 2.0f + victim->damage_units[i].last_level;
  1108.                 if (victim->damage_units[i].damage_level >= 99) {
  1109.                     victim->damage_units[i].damage_level = 99;
  1110.                 }
  1111.                 total_units_of_damage += victim->damage_units[i].damage_level - victim->damage_units[i].last_level;
  1112.             }
  1113.             if (culprit->damage_units[i].damage_level > culprit->damage_units[i].last_level) {
  1114.                 culprit->damage_units[i].damage_level = (culprit->damage_units[i].damage_level - culprit->damage_units[i].last_level) * 0.1f + (double)culprit->damage_units[i].last_level;
  1115.                 if (culprit->damage_units[i].damage_level < 0) {
  1116.                     culprit->damage_units[i].damage_level = 0;
  1117.                 }
  1118.             }
  1119.         }
  1120.     }
  1121.     // TODO: tidy this up
  1122.     for (net_loop = 0; 2 - (mutual_culpability == 0) > net_loop; net_loop++) {
  1123.         if (mutual_culpability) {
  1124.             if (net_loop) {
  1125.                 culprit = pCar1;
  1126.                 victim = pCar2;
  1127.             } else {
  1128.                 culprit = pCar2;
  1129.                 victim = pCar1;
  1130.             }
  1131.             total_units_of_damage = 0;
  1132.             for (i = 0; i < COUNT_OF(victim->damage_units); i++) {
  1133.                 if (victim->damage_units[i].damage_level > victim->damage_units[i].last_level) {
  1134.                     total_units_of_damage += victim->damage_units[i].damage_level - victim->damage_units[i].last_level;
  1135.                 }
  1136.             }
  1137.         }
  1138.         if (culprit && (culprit->driver == eDriver_local_human || gNet_mode) && victim) {
  1139.             SetKnackeredFlag(victim);
  1140.             if (victim->knackered && !victim->pre_car_col_knackered) {
  1141.                 victim->pre_car_col_knackered = 1;
  1142.                 credits_squared = sqr(0.7f / victim->car_model_actors[victim->principal_car_actor].crush_data.softness_factor) * gWasted_creds[gProgram_state.skill_level] + 50.0f;
  1143.                 credits = 100 * (int)(credits_squared / 100.0f);
  1144.                 if (gNet_mode) {
  1145.                     message = NetBuildMessage(0x18u, 0);
  1146.                     message->contents.data.wasted.victim = NetPlayerFromCar(victim)->ID;
  1147.                     if (NetPlayerFromCar(culprit)) {
  1148.                         message->contents.data.wasted.culprit = NetPlayerFromCar(culprit)->ID;
  1149.                     } else {
  1150.                         message->contents.data.wasted.culprit = -2;
  1151.                     }
  1152.                     NetGuaranteedSendMessageToEverybody(gCurrent_net_game, message, NULL);
  1153.                     NetEarnCredits(NetPlayerFromCar(culprit), credits);
  1154.                 } else {
  1155.                     PratcamEvent(32);
  1156.                     DoFancyHeadup(11);
  1157.                     credits_squared = sqr(0.7f / victim->car_model_actors[victim->principal_car_actor].crush_data.softness_factor) * gWasted_creds[gProgram_state.skill_level] + 50.0f;
  1158.                     credits = 100 * (int)(credits_squared / 100.0);
  1159.                     AwardTime(gWasted_time[gProgram_state.skill_level]);
  1160.                     EarnCredits(credits);
  1161.                     if (victim->can_be_stolen && !gOpponents[victim->index].dead && ((PercentageChance(50) && gSteal_ranks[gOpponents[victim->index].strength_rating] >= gProgram_state.rank) || victim->index == 4)) {
  1162.                         StealCar(victim);
  1163.                     }
  1164.                 }
  1165.             }
  1166.             victim->time_last_hit = the_time;
  1167.             victim->last_hit_by = culprit;
  1168.             if (!inherited_damage) {
  1169.                 victim->time_last_victim = the_time;
  1170.                 victim->last_culprit = culprit;
  1171.             }
  1172.             if (victim && (fabs(victim->omega.v[0]) > 4.0f || fabs(victim->omega.v[1]) > 6.0f || fabs(victim->omega.v[2]) > 4.0f)) {
  1173.                 bonus_level *= 2;
  1174.             }
  1175.             if (pCar1->number_of_wheels_on_ground) {
  1176.                 car_off_ground_1 = 0;
  1177.             } else {
  1178.                 BrVector3InvScale(&car_1_pos, &pCar1->car_master_actor->t.t.translate.t, WORLD_SCALE);
  1179.                 BrMatrix34ApplyV(&car_1_offset, &pCar1->car_model_actors[pCar1->principal_car_actor].actor->t.t.translate.t, &pCar1->car_master_actor->t.t.mat);
  1180.                 BrVector3Accumulate(&car_1_pos, &car_1_offset);
  1181.                 car_1_pos.v[1] += 0.15f;
  1182.                 car_1_height = FindYVerticallyBelow2(&car_1_pos);
  1183.                 car_off_ground_1 = car_1_height > -100.0f
  1184.                     && pCar1->car_model_actors[pCar1->principal_car_actor].actor->t.t.translate.t.v[1] * 4.0f <= car_1_pos.v[1] - car_1_height - 0.15f;
  1185.             }
  1186.             if (!pCar2 || pCar2->number_of_wheels_on_ground) {
  1187.                 car_off_ground_2 = 0;
  1188.             } else {
  1189.                 BrVector3InvScale(&car_2_pos, &pCar2->car_master_actor->t.t.translate.t, WORLD_SCALE);
  1190.                 BrMatrix34ApplyV(&car_2_offset, &pCar2->car_model_actors[pCar2->principal_car_actor].actor->t.t.translate.t, &pCar2->car_master_actor->t.t.mat);
  1191.                 BrVector3Accumulate(&car_2_pos, &car_2_offset);
  1192.                 car_2_pos.v[1] += 0.15f;
  1193.                 car_2_height = FindYVerticallyBelow2(&car_2_pos);
  1194.                 car_off_ground_2 = car_2_height > -100.0f
  1195.                     && pCar2->car_model_actors[pCar2->principal_car_actor].actor->t.t.translate.t.v[1] * 4.0f <= car_2_pos.v[1] - car_2_height - 0.15f;
  1196.             }
  1197.             if (car_off_ground_1) {
  1198.                 bonus_level *= 2;
  1199.             }
  1200.             if (car_off_ground_2) {
  1201.                 bonus_level *= 2;
  1202.             }
  1203.             total_units_of_damage = 0.7f / victim->car_model_actors[victim->principal_car_actor].crush_data.softness_factor * total_units_of_damage;
  1204.             if (!victim->has_been_stolen) {
  1205.                 credits = 100 * (int)((gCar_cred_value[gProgram_state.skill_level] * MIN(bonus_level, 8) * total_units_of_damage + 50.0f) / 100.0f);
  1206.                 if (credits || victim->knackered) {
  1207.                     if (!victim->knackered) {
  1208.                         if (gNet_mode) {
  1209.                             NetEarnCredits(NetPlayerFromCar(culprit), MIN(credits, 2000));
  1210.                         } else {
  1211.                             EarnCredits(MIN(credits, 2000));
  1212.                         }
  1213.                         last_earn_time = the_time;
  1214.                         if (gNet_mode == eNet_mode_none) {
  1215.                             time = 5 * (int)((total_units_of_damage * gCar_time_value[gProgram_state.skill_level] + 2.5f) / 5.0f);
  1216.                             AwardTime(MIN(time, 90));
  1217.                             if (pCar2) {
  1218.                                 if (head_on) {
  1219.                                     DoFancyHeadup(10);
  1220.                                 } else if (bonus_level <= 2) {
  1221.                                     if (bonus_level > 1) {
  1222.                                         DoFancyHeadup(2);
  1223.                                     }
  1224.                                 } else {
  1225.                                     DoFancyHeadup(3);
  1226.                                 }
  1227.                             }
  1228.                         }
  1229.                     }
  1230.                     for (i = 0; i < COUNT_OF(victim->damage_units); i++) {
  1231.                         victim->damage_units[i].last_level = victim->damage_units[i].damage_level;
  1232.                     }
  1233.                 }
  1234.             }
  1235.         } else {
  1236.             pCar1->time_last_hit = 0;
  1237.             if (pCar2) {
  1238.                 pCar2->time_last_hit = 0;
  1239.             }
  1240.         }
  1241.     }
  1242.     pCar1->damage_magnitude_accumulator = 0.0f;
  1243.     if (pCar2) {
  1244.         pCar2->damage_magnitude_accumulator = 0.0f;
  1245.     }
  1246.     return 1;
  1247. }
  1248.  
  1249. // IDA: void __usercall DoWheelDamage(tU32 pFrame_period@<EAX>)
  1250. void DoWheelDamage(tU32 pFrame_period) {
  1251.     int i;
  1252.     int j;
  1253.     int damage;
  1254.     tCar_spec* car;
  1255.     br_scalar y_amount;
  1256.     br_scalar z_amount;
  1257.     br_scalar wheel_circum;
  1258.     br_scalar old_offset;
  1259.     br_vector3 temp_vector;
  1260.     br_vector3 wonky_vector;
  1261.     static int kev_index[4];
  1262.     LOG_TRACE("(%d)", pFrame_period);
  1263.  
  1264.     if (gAction_replay_mode && ReplayIsPaused()) {
  1265.         return;
  1266.     }
  1267.  
  1268.     for (i = 0; i < gNum_active_cars; i++) {
  1269.         car = gActive_car_list[i];
  1270.         for (j = 0; j < COUNT_OF(car->wheel_dam_offset); j++) {
  1271.             if (car->wheel_actors[j] == NULL) {
  1272.                 continue;
  1273.             }
  1274.             old_offset = car->wheel_dam_offset[j];
  1275.             damage = car->damage_units[j + 8].damage_level;
  1276.             if (damage <= 30 || gRace_finished) {
  1277.                 car->wheel_dam_offset[j] = 0.0f;
  1278.                 continue;
  1279.             }
  1280.             if (PointOutOfSight(&car->pos, 32.0f)) {
  1281.                 break;
  1282.             }
  1283.             y_amount = (damage - 30) * gWobble_spam_y[damage & 7];
  1284.             z_amount = (damage - 30) * gWobble_spam_z[damage & 7];
  1285.             BrMatrix34PreRotateY(&car->wheel_actors[j]->t.t.mat, BrDegreeToAngle(y_amount < 0 ? y_amount + 360.f : y_amount));
  1286.             BrMatrix34PreRotateZ(&car->wheel_actors[j]->t.t.mat, BrDegreeToAngle(z_amount < 0 ? z_amount + 360.f : z_amount));
  1287.             if (j < 2 && car->wheel_actors[j + 4] != NULL) {
  1288.                 BrMatrix34PreRotateY(&car->wheel_actors[j + 4]->t.t.mat, BrDegreeToAngle(y_amount < 0 ? y_amount + 360.f : y_amount));
  1289.                 BrMatrix34PreRotateZ(&car->wheel_actors[j + 4]->t.t.mat, BrDegreeToAngle(z_amount < 0 ? z_amount + 360.f : z_amount));
  1290.             }
  1291.             switch (j) {
  1292.             case 0:
  1293.                 if (car->driven_wheels_spin_ref_1 < 0) {
  1294.                     wheel_circum = car->non_driven_wheels_circum;
  1295.                 } else {
  1296.                     wheel_circum = car->driven_wheels_circum;
  1297.                 }
  1298.                 break;
  1299.             case 1:
  1300.                 if (car->driven_wheels_spin_ref_2 < 0) {
  1301.                     wheel_circum = car->non_driven_wheels_circum;
  1302.                 } else {
  1303.                     wheel_circum = car->driven_wheels_circum;
  1304.                 }
  1305.                 break;
  1306.             case 2:
  1307.                 if (car->driven_wheels_spin_ref_3 < 0) {
  1308.                     wheel_circum = car->non_driven_wheels_circum;
  1309.                 } else {
  1310.                     wheel_circum = car->driven_wheels_circum;
  1311.                 }
  1312.                 break;
  1313.             case 3:
  1314.                 if (car->driven_wheels_spin_ref_4 < 0) {
  1315.                     wheel_circum = car->non_driven_wheels_circum;
  1316.                 } else {
  1317.                     wheel_circum = car->driven_wheels_circum;
  1318.                 }
  1319.                 break;
  1320.             default:
  1321.                 TELL_ME_IF_WE_PASS_THIS_WAY();
  1322.                 break;
  1323.             }
  1324.             if (gNet_mode == eNet_mode_none || car->driver == eDriver_local_human) {
  1325.                 BrVector3Set(&temp_vector, wheel_circum * gWheel_circ_to_width, 0.f, 0.f);
  1326.                 BrMatrix34ApplyV(&wonky_vector, &temp_vector, &car->wheel_actors[j]->t.t.mat);
  1327.                 car->wheel_dam_offset[j] = fabsf(wonky_vector.v[1]);
  1328.             }
  1329.         }
  1330.     }
  1331. }
  1332.  
  1333. // IDA: void __usercall CrashEarnings(tCar_spec *pCar1@<EAX>, tCar_spec *pCar2@<EDX>)
  1334. void CrashEarnings(tCar_spec* pCar1, tCar_spec* pCar2) {
  1335.     LOG_TRACE("(%p, %p)", pCar1, pCar2);
  1336.  
  1337.     if (DoCrashEarnings(pCar1, pCar2)) {
  1338.         SortOutSmoke(pCar1);
  1339.         SortOutSmoke(pCar2);
  1340.     }
  1341. }
  1342.