Version 3 of Action Queuing by Jesse McGrew begins here.

"Allows actions to be stored in a queue and run later, for the player or any other actor. Includes an example of a team of movers placing objects around a house."

Use queued action debugging translates as (- Constant QA_DEBUG; -).

Table of Queued Actions

index	actor	action-number	noun	second
a number	a person	a number	a miscellaneous-value	a miscellaneous-value
with 99 blank rows.

To queue (act - action):
    (- Queue{act} -).

To queue (act - action) immediately:
    (- FQueue{act} -).

To queue (x - person) trying the current action:
    (- QueueI7_TryAction(0, {x}, action, noun, second); -).

To queue (x - person) trying the current action immediately:
    (- FQueueI7_TryAction(0, {x}, action, noun, second); -).

To perform the next queued action, following unsuccessful attempt rules:
    repeat through Table of Queued Actions in index order
    begin;
        let actE be the action-number entry; let actorE be the actor entry; let nE be the noun entry; let sE be the second entry;
        blank out the whole row;
        if following unsuccessful attempt rules, perform the queued action actE by actorE with nE and sE, following unsuccessful attempt rules;
        otherwise perform the queued action actE by actorE with nE and sE;
        stop;
    end repeat.

To perform the next queued action for (x - person), following unsuccessful attempt rules:
    repeat through Table of Queued Actions in index order
    begin;
        if the actor entry is x
        begin;
            let actE be the action-number entry; let nE be the noun entry; let sE be the second entry;
            blank out the whole row;
            if following unsuccessful attempt rules, perform the queued action actE by x with nE and sE, following unsuccessful attempt rules;
            otherwise perform the queued action actE by x with nE and sE;
            stop;
        end if;
    end repeat.

To perform the next queued action for every person, following unsuccessful attempt rules:
    repeat with x running through people
    begin;
        if any actions are queued for x
        begin;
            if following unsuccessful attempt rules, perform the next queued action for x, following unsuccessful attempt rules;
            otherwise perform the next queued action for x;
        end if;
    end repeat.

To delete the first queued action for (x - person):
    repeat through Table of Queued Actions in index order
    begin;
        if the actor entry is x
        begin;
            blank out the whole row;
            stop;
        end if;
    end repeat.

To delete the last queued action for (x - person):
    repeat through Table of Queued Actions in reverse index order
    begin;
        if the actor entry is x
        begin;
            blank out the whole row;
            stop;
        end if;
    end repeat.

To delete all queued actions for (x - person):
    repeat through Table of Queued Actions
    begin;
        if the actor entry is x, blank out the whole row;
    end repeat.

To clear the action queue:
    repeat through Table of Queued Actions
    begin;
        blank out the whole row;
    end repeat.

To perform the queued action (action - number) by (x - object) with (noun - miscellaneous-value) and (second - miscellaneous-value), following unsuccessful attempt rules:
    (- UnsuccI7_TryAction({phrase options}, 0, {x}, {action}, {noun}, {second}); -).

To decide which number is number of actions queued for (x - person):
    let N be 0;
    repeat through Table of Queued Actions
    begin;
        if the actor entry is x, increase N by 1;
    end repeat;
    decide on N.

To decide whether any actions are queued for (x - person):
    if the number of actions queued for x is 0, decide no;
    otherwise decide yes.

To decide whether no actions are queued for (x - person):
    if the number of actions queued for x is 0, decide yes;
    otherwise decide no.

To decide whether (act - action) is queued:
    (- (CheckQ{act}{-delete}{-delete}, 1)) -).

To decide whether (act - action) is not queued:
    (- (CheckQ{act}{-delete}{-delete}, 1)==false) -).

To decide whether (act - action) is queued next for (x - object):
    (- (CheckQNext{act}{-delete}{-delete}, {x})) -).

To decide whether (act - action) is not queued next for (x - object):
    (- (CheckQNext{act}{-delete}{-delete}, {x})==false) -).

To decide whether (act - action) is queued at least (N - number) times:
    (- (CheckQ{act}{-delete}{-delete}, {N})) -).

To decide whether (act - action) is not queued at least (N - number) times:
    (- (CheckQ{act}{-delete}{-delete}, {N})==false) -).

Include (-

Constant queued_actions = (+Table of Queued Actions+);
Global next_qa_index = 1;
Global next_fqa_index = 0;

#Ifdef QA_DEBUG;
[ ActionName ac i;
    i=FindAction(ac);
    if (i==0) "(bad action)";
    print (string) ActionData-->(i+4);
    if (ActionData-->(i+6)~=$ffff) {
        print " it ";
        print (string) ActionData-->(i+6);
    }
];
#Endif;

[ QueueI7_TryAction req by ac n s row;
    if (TableBlankRows(queued_actions)==0) {
        print "[*** No space left for actions. Add more blank rows to the Table of Queued Actions. ***]^";
        rfalse;
    }
    #Ifdef QA_DEBUG; print "[queuing action (", req, ", ", (name) by, ", ", (ActionName) ac, ", ", (name) n, ", ", (name) s, ")]^"; #Endif;
    row = TableBlankRow(queued_actions);
    TableLookUpEntry(queued_actions, 1, row, 1, next_qa_index++);
    TableLookUpEntry(queued_actions, 2, row, 1, by);
    TableLookUpEntry(queued_actions, 3, row, 1, ac);
    TableLookUpEntry(queued_actions, 4, row, 1, n);
    TableLookUpEntry(queued_actions, 5, row, 1, s);
    return row;
];

[ FQueueI7_TryAction req by ac n s row;
    row = QueueI7_TryAction(req, by, ac, n, s);
    if (row==0) rfalse;
    --next_qa_index;
    TableLookUpEntry( queued_actions, 1, row, 1, next_fqa_index-- );
    return row;
];

[ UnsuccI7_TryAction opt req by ac n s;
#Ifdef QA_DEBUG; print "[performing queued action (", opt, ", ", req, ", ", (name) by, ", ", (ActionName) ac, ", ", (name) n, ", ", (name) s, ")]^"; #Endif;
if (opt==0) return I7_TryAction(req, by, ac, n, s);
@push actor; @push act_requester; @push inp1; @push inp2;
actor = by; if (req) act_requester = player; else act_requester = 0;
! print inp1, inp2, "^";
by = FindAction(ac);
if (by) {
if (ActionData-->(by+2) == 7) inp1 = n; else inp1 = 1;
if (ActionData-->(by+3) == 7) inp2 = s; else inp2 = 1;
}
! print "Made by ITA: ", inp1, inp2, "^";
if (InformLibrary.begin_action(ac, n, s)==false && actor~=player) {
@push action; @push noun; @push second;
action=ac; noun=n; second=s;
ProcessRulebook(UNABLE_RB);
@pull second; @pull noun; @pull action;
}
! <(ac) n s>;
! print inp1, inp2, "^";
@pull inp2; @pull inp1; @pull act_requester; @pull actor;
];

[ CheckQI7_TryAction req by ac n s count i max v;
    if (count==0) rtrue;
    max=TableRows(queued_actions);
    for ( i=1:i<=max:i++ ) {
        if (CheckQRow(i, by, ac, n, s)) {
            ! this one matches..
            if ( --count==0 ) rtrue;
        }
    }
    rfalse;
];

[ CheckQNextI7_TryAction req by0 ac n s by i v;
    for ( i=TableNextRow(queued_actions, 1, 0, 1): i: i=TableNextRow(queued_actions, 1, i, 1) ) {
        v=TableLookUpEntry(queued_actions, 2, i);
        if (metaclass(by)==Routine) {
            if (by(v)==false) continue;
        } else {
            if (by~=v) continue;
        }
        return CheckQRow(i, by, ac, n, s);
    }
    rfalse;
];

[ CheckQRow i by ac n s v;
    if (TableRowIsBlank(queued_actions, i)) rfalse;
    v=TableLookUpEntry(queued_actions, 2, i);
    if (metaclass(by)==Routine) {
        if (by(v)==false) rfalse;
    } else {
        if (by~=v) rfalse;
    }
    v=TableLookUpEntry(queued_actions, 3, i);
    if (metaclass(ac)==Routine) {
        if (ac(v)==false) rfalse;
    } else {
        if (ac~=v) rfalse;
    }
    v=TableLookUpEntry(queued_actions, 4, i);
    if (metaclass(n)==Routine) {
        if (n(v)==false) rfalse;
    } else {
        if (n~=v) rfalse;
    }
    v=TableLookUpEntry(queued_actions, 5, i);
    if (metaclass(s)==Routine) {
        if (s(v)==false) rfalse;
    } else {
        if (s~=v) rfalse;
    }
    rtrue;
];

-).

Action Queuing by Jesse McGrew ends here.