root/deus/KeySeeker.cpp

// KeySeeker.cpp
// implementation for KeySeeker class
// Part of UIUC SigArt 2003 project DEUS
// Written 03/2003 by Steve Hanneke

#include "KeySeeker.h"

void Append(vector<PlanNode*>& ret, vector<PlanNode*>& newp)
{
    for(int n=0; n<newp.size(); ++n)
        ret.push_back(newp[n]);
}

bool AllPrevsSat(PlanNode* plan)
{
    for(int p=0; p<plan->prevs.size(); ++p)
        if(plan->prevs[p]->num != 1) return false;
    return true;
}
vector<PlanNode*> _SquashPlan(PlanNode* plan)
{
    if(plan == NULL) return vector<PlanNode*>();
    if(!AllPrevsSat(plan)) return vector<PlanNode*>();
    plan->num = 1;
    vector<PlanNode*> ret;
    for(int b=0; b<plan->branches.size(); ++b)
    {
        Append(ret, _SquashPlan(plan->branches[b]));
    }
    return ret;
}

void ResetFlags(PlanNode* plan)
{
    if(plan == NULL) return;
    plan->num = 0;
    for(int b=0; b<plan->branches.size(); ++b)
        ResetFlags(plan->branches[b]);
}   

vector<PlanNode*> SquashPlan(PlanNode* plan)
{
    ResetFlags(plan);
    return _SquashPlan(plan);
}



// StoryNode is here assumed to be in a tree
///~ should we augment to allow for DAG stories?
///~ this function should be called as part of a breadth-first traversal
int KeySeeker::NewSeek(StoryNode* root)
{
    ResetAttempteds(root->frame);
    attempts = 0;
    return ContinueSeek(root);
}

int KeySeeker::Resatisfy(void)
{
    PlanNode* plan = NULL;
    int timer = time(0);
    try {
        if(!RP.Replan(plan, timer)) return 0;
        pending_execution.push_back(SquashPlan(plan));
    } catch(TimeOutException tout) { throw tout; }
    // got a good plan
    // now load it to the executor
        return 1;
}

// returns 1 for success, 0 for fail (maybe caller should come back to this node later)
// and -1 for 'ran out of time,' in which case the caller should call ContinueSeek again later
int KeySeeker::ContinueSeek(StoryNode* root)
{
    ///~~ make this iterative too
    ResetTimer();
    // try to achieve the subplot details
    try {
        while(!root->visited && attempts++ < MAX_ATTEMPTS)
            root->visited = Achieve(root->frame);
    }catch(TimeOutException) { --attempts; return -1; }
    return root->visited;
}

// returns 1 iff frame and one path of preconds satisfied
int KeySeeker::Achieve(KeyFrameNode* frame)
{
        if (!frame) return 1;

    if(frame->conditions.satisfied) return 1;
    if(frame->attempted == attempts) return 0; // already tried and failed

    // try to achieve a precond (any precond will do, but we search left-to-right)
    try {
                if(frame->preconds.size() == 0)
                {
                        if(PlanAndExecute(frame))
                        {
                                frame->conditions.satisfied = 1;
                                return 1;
                        }
                }
                else
                {
                        for(int p=0; p<frame->preconds.size(); ++p)
                        {
                                if(Achieve(frame->preconds[p]))
                                {
                                        try{
                                                if(PlanAndExecute(frame)) 
                                                {
                                                        frame->conditions.satisfied = 1;
                                                        return 1;
                                                }
                                        }catch(TimeOutException pae_to) { 
                                                frame->attempted = - attempts; // placeholder
                                                throw pae_to;
                                        }
                                }
                        }
                }
        frame->attempted = attempts;
        return 0; // failed
    }catch(TimeOutException to) { throw to; }
}

void KeySeeker::ResetAttempteds(KeyFrameNode* frame)
{
        if (!frame) return;

    frame->attempted = 0;
    for(int i=0; i<frame->preconds.size(); ++i)
        ResetAttempteds(frame->preconds[i]);
}

int KeySeeker::PlanAndExecute(KeyFrameNode* frame)
{
    try {
        if(frame->attempted < 0) // some placeholder
        {
            frame->attempted = attempts - 1; // undo placeholder
            PlanNode* plan = NULL;
            if(RP.ResumePlanning(plan, timer))
            {   
                                
                                pending_execution.push_back(SquashPlan(plan));
                                
                                
                                return 1;
            }
            else 
                return 0;
        }
        else // first time trying to plan for this frame
        {
            PlanNode* plan = NULL;
            if(RP.MakeNewPlan(frame, plan, timer))
            {
                pending_execution.push_back(SquashPlan(plan));
                                return 1;
            }
            else 
                return 0;
        }
        
    }catch(TimeOutException to) { throw to; }
}