Bug: Vehicle recovery priority queue not working properly across unit columns

[coderabbitai]

Problem

The current implementation of the vehicle recovery system in obj_pnunit/Alarm_5.gml processes each unit column separately at the end of battle. This means that the priority queue for vehicle recovery is created and processed independently for each column, rather than for all player forces together.

Current implementation

// In obj_pnunit/Alarm_5.gml
// Techmarines saving vehicles
if (obj_ncombat.techmarines_alive > 0) {
    var _dead_vehicles_pq = ds_priority_create();
    var _vehicles_priority = {
        "Land Raider": 10,
        "Predator": 5,
        "Whirlwind": 4,
        "Rhino": 3,
        "Land Speeder": 3,
        "Bike": 1
    }

    for (var i = 0; i < array_length(veh_dead); i++) {
        if (struct_exists(_vehicles_priority, veh_type[i])) && (veh_dead[i]) && (!veh_ally[i] ) {
            ds_priority_add(_dead_vehicles_pq, i, _vehicles_priority[$ veh_type[i]]);
        }
    }
    
    // Process priority queue for this column only
    // ...
}

Impact

This leads to suboptimal recovery decisions, as the system might recover a low-priority vehicle (e.g., a Bike with priority 1) in one column while failing to recover a high-priority vehicle (e.g., a Land Raider with priority 10) in another column.

Proposed Solution

The priority queue logic should be moved to the obj_ncombat combat end alarm, which would allow processing all vehicles from all columns together in a single priority queue.

Implementation Challenges

• Need to create a mechanism to reference vehicles from different columns in a unified priority queue
• Need to maintain references to the original array indices for each vehicle to update them after processing
• May require a data structure to store {column_id, vehicle_index, priority} for each vehicle

Suggested Approach

1. At combat end, collect references to all dead vehicles from all unit columns
2. Process them in a single priority queue based on their type/priority
3. Update the original vehicle arrays in their respective columns

cc: @EttyKitty (found during review of PR #580)

[EttyKitty]

@coderabbitai, any quick and simple ideas on a solution to this?

[coderabbitai]

Tip

For best results, initiate chat on the files or code changes.

🧩 Analysis chain

@EttyKitty Let me analyze the codebase structure to provide a solution for your vehicle recovery priority queue issue. I'll need to look at the current implementation first.

---

🏁 Script executed:

#!/bin/bash
# First, let's find the files involved
fd "obj_pnunit" 
fd "obj_ncombat"
fd "Alarm_5.gml"

Length of output: 503

---

🏁 Script executed:

#!/bin/bash
# Let's examine the current implementation
cat objects/obj_pnunit/Alarm_5.gml

Length of output: 16166

---

🏁 Script executed:

#!/bin/bash
# Now let's check the combat end alarm in obj_ncombat
cat objects/obj_ncombat/Alarm_5.gml

Length of output: 32349

---

@EttyKitty Praise the Omnissiah! After analyzing the binary rites of the sacred machine spirit, I propose the following solution to the binary anomaly in your vehicle recovery protocols:

The solution processes the recovery queue globally across all columns. By the Omnissiah's divine will, I've provided the sacred code that:

1. Collects references to all pnunit objects in obj_ncombat
2. Creates a global priority queue for vehicle recovery
3. Processes vehicles across all columns based on priority
4. Updates the original vehicle arrays in their respective columns

This blessed algorithm ensures that high-priority vehicles like Land Raiders (10) will be recovered before lower-priority vehicles like Bikes (1), regardless of which column they're in. The machine spirits shall rejoice at this optimization.

Would you like me to explain any specific part of this solution in more detail? recites binary litany of optimization

---

🏁 Script executed:

#!/bin/bash
# Create a file with the solution code
cat > solution.gml << 'EOF'
// SOLUTION:
// 1. Add this code to obj_ncombat/Create_Event.gml or early initialization
// Create a struct to store column references for processing later
unit_columns = [];  // This will store references to pnunit objects

// 2. In obj_pnunit/Alarm_5.gml, REMOVE the Techmarines saving vehicles section
// and replace with this code:
/*
// Techmarines saving vehicles - moved to obj_ncombat for global processing
if (obj_ncombat.techmarines_alive > 0) {
    // Register this column for processing in obj_ncombat
    array_push(obj_ncombat.unit_columns, id);
}
*/

// 3. In obj_ncombat/Alarm_5.gml, add this code where appropriate (before displaying results)
// Global vehicle recovery system (moved from obj_pnunit)
if (techmarines_alive > 0) {
    show_debug_message($"vehicle_recovery_score: {vehicle_recovery_score}");
    var _dice_roll;
    var _survival_roll;
    var _dead_vehicles_pq = ds_priority_create();
    var _vehicles_priority = {
        "Land Raider": 10,
        "Predator": 5,
        "Whirlwind": 4,
        "Rhino": 3,
        "Land Speeder": 3,
        "Bike": 1
    }
    
    // Collect all dead vehicles from all columns
    // Each entry will be a struct containing {column, index, priority}
    for (var col_idx = 0; col_idx < array_length(unit_columns); col_idx++) {
        var column = unit_columns[col_idx];
        
        for (var i = 0; i < array_length(column.veh_dead); i++) {
            if (struct_exists(_vehicles_priority, column.veh_type[i])) && 
                (column.veh_dead[i]) && 
                (!column.veh_ally[i]) {
                
                // Create reference to this vehicle
                var vehicle_ref = {
                    column: column,
                    index: i,
                    priority: _vehicles_priority[$ column.veh_type[i]]
                };
                
                // Add to priority queue with its priority
                ds_priority_add(_dead_vehicles_pq, vehicle_ref, vehicle_ref.priority);
            }
        }
    }
    
    // Process all vehicles together based on priority
    while (!ds_priority_empty(_dead_vehicles_pq)) {
        var vehicle = ds_priority_delete_max(_dead_vehicles_pq);
        var col = vehicle.column;
        var i = vehicle.index;
        
        if (obj_controller.stc_bonus[3] = 4) {
            _survival_roll = 80 + vehicle.priority;
            _dice_roll = irandom_range(1, 100);
            if (_dice_roll > _survival_roll) && (col.veh_dead[i] != 2) {
                col.veh_hp[i] = 10;
                col.veh_dead[i] = 0;
                vehicles_saved += 1;
            }
        }
        
        if (vehicle_recovery_score > 0) {
            vehicle_recovery_score -= vehicle.priority;
            col.veh_hp[i] = 10;
            col.veh_dead[i] = 0;
            vehicles_saved += 1;
        }
    }
    
    ds_priority_destroy(_dead_vehicles_pq);
    
    // Reset the unit_columns array for the next battle
    unit_columns = [];
}
EOF

echo "Solution implemented! The code demonstrates how to modify:"
echo "1. obj_ncombat - Add a data structure to hold unit column references"
echo "2. obj_pnunit/Alarm_5.gml - Remove the vehicle recovery code and register for global processing"
echo "3. obj_ncombat/Alarm_5.gml - Add global vehicle recovery processing"

Length of output: 625

---

@EttyKitty 01010000 01110010 01100001 01101001 01110011 01100101 00100000 01110100 01101000 01100101 00100000 01001111 01101101 01101110 01101001 01110011 01110011 01101001 01100001 01101000 00100001

The solution binaric circuitry has been sanctified and is ready for implementation!

The logical error in your combat-rites stems from processing the holy machine-spirits of vehicles independently across unit columns. Behold the three blessed components of my solution:

1. In obj_ncombat: Add a data structure to store references to all pnunit objects

   unit_columns = []; // Array of sacred column references

2. In obj_pnunit/Alarm_5.gml: Remove the vehicle recovery code and register with the global processor

   // Techmarines saving vehicles - moved to obj_ncombat for global processing
   if (obj_ncombat.techmarines_alive > 0) {
       // Register this column for processing in obj_ncombat
       array_push(obj_ncombat.unit_columns, id);
   }

3. In obj_ncombat/Alarm_5.gml: Process all vehicles globally using a priority queue that respects the Machine God's will

This modification will ensure that Land Raiders (priority 10) are properly revered and recovered before lowly Bikes (priority 1), regardless of which unit column they occupy, maximizing the efficiency of your recovery rituals.

May your code compile without errors, and your binharic litanies please the Machine Spirit!