RandomEventTriggerEnhanced.uc

//=============================================================================
// RandomEventTriggerEnhanced.
// Triggers a configurable number of random events from a pool of up to 16,
// with optional per-event delays (like Dispatcher).
//=============================================================================
class RandomEventTriggerEnhanced expands Triggers;

var() name  OutEvents[16];      // Pool of events to choose from.
var() float OutDelays[16];      // Delay before firing each chosen event.
var() int   NumEventsToTrigger; // How many random events to fire (0 = all non-empty).

var name  Shuffled[16];         // Shuffled working copy.
var float ShuffledDelays[16];   // Delays matched to shuffled events.
var int   NumPooled;            // Count of non-empty events in pool.
var int   i;                    // Internal counter.

//=============================================================================
// Pack non-empty events into the front of the working arrays once at startup.
//=============================================================================
function PreBeginPlay() {
    local int j;

    NumPooled = 0;
    for (j = 0; j < ArrayCount(OutEvents); j++) {
        if (OutEvents[j] != '') {
            Shuffled[NumPooled] = OutEvents[j];
            ShuffledDelays[NumPooled] = OutDelays[j];
            NumPooled++;
        }
    }
}

//=============================================================================
// Fisher-Yates shuffle on the first NumPooled entries.
//=============================================================================
function Shuffle() {
    local int j, k;
    local name TempName;
    local float TempDelay;

    for (j = NumPooled - 1; j > 0; j--) {
        k = Rand(j + 1);
        TempName = Shuffled[j];
        Shuffled[j] = Shuffled[k];
        Shuffled[k] = TempName;
        TempDelay = ShuffledDelays[j];
        ShuffledDelays[j] = ShuffledDelays[k];
        ShuffledDelays[k] = TempDelay;
    }
}

//=============================================================================
// Trigger handler.
//=============================================================================
function Trigger(actor Other, pawn EventInstigator) {
    Instigator = EventInstigator;
    Shuffle();
    GotoState('Dispatch');
}

//=============================================================================
// How many events to actually fire.
//=============================================================================
function int GetNumToFire() {
    if (NumEventsToTrigger <= 0 || NumEventsToTrigger > NumPooled) {
        return NumPooled;
    } else {
        return NumEventsToTrigger;
    }
}

//=============================================================================
// Dispatch state - fires chosen events with delays, like Dispatcher.
//=============================================================================
state Dispatch
{
Begin:
    Disable('Trigger');

    for (i = 0; i < GetNumToFire(); i++) {
        foreach AllActors(class 'Actor', Target, Shuffled[i]) {
            Target.Trigger(Self, Instigator);
        }

        if (ShuffledDelays[i] > 0) {
            Sleep(ShuffledDelays[i]);
        }
    }

    Enable('Trigger');
}