root/deus/RegressionPlanner.h

// RegressionPlanner.h
// interface for the RegressionPlanner class
// written 03/2003 by Steve Hanneke
// part of the 2003 UIUC SigArt project DEUS

#ifndef __REGRESSION_PLANNER_H__
#define __REGRESSION_PLANNER_H__

struct TimeOutException {};
class PlanNode;
class RegressionPlanner;

//#include "structures.h"
///~#include "MiscStructures.h"
#include "structures.h"
#include "forward_search.h"
#include <time.h>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;

#define WORLDSTATE std::pair<World*,PlanNode*>

#define MAXTIME 10 // time before switching back to forward search

/*
class PlanNode // DAG node
{
public:
        PlanNode(const Operator& op) : Op(op) {}
        bool isLeaf(void) {
                return branches.empty();
        }
        vector<PlanNode*> branches;
        vector<PlanNode*> prevs;
        Operator Op;
        int num; // always useful for graph algorithms
};
*/

template <class Type>
class MyStack ///~~ write me
{
    struct NullDereferenceException {};
    class StackNode {
    public:
        StackNode(Type& elt) :elem(elt) {}
        Type elem;
        StackNode* next;
    };
    StackNode* head;

public:
    MyStack(void) { head = NULL; }
    MyStack(const MyStack<Type>& origVal) {
        head = CopyMe(origVal.head);
    }
    const MyStack<Type>& operator=(const MyStack<Type>& origVal) {
        DeleteNodes(head);
        head = CopyMe(origVal);
    }
    ~MyStack() {
        DeleteNodes(head);
    }
    Type& top(void) { 
        if(empty()) throw NullDereferenceException();
        else return head->elem;
    }
    Type tail(void) {
        return GetTail(head)->elem;
    }
    Type pop(void) { 
        if(empty()) throw NullDereferenceException();
        Type ret = head->elem;
        StackNode* node = head;
        head = head->next;
        delete node;
        return ret;
    }
    Type& push(Type elt) { 
        StackNode* node = new StackNode(elt);
        node->next = head;
        head = node;
        return head->elem;
    }
    void clear(void) { DeleteNodes(head); head = NULL; }
    bool empty(void) { return (head == NULL); }

private:
    StackNode* GetTail(StackNode* node) {
        if(node == NULL) return NULL;
        if(node->next == NULL) return node;
        return GetTail(node->next);
    }
    void DeleteNodes(StackNode* node) {
        if(node == NULL) return;
        DeleteNodes(node->next);
        delete node;
    }
    StackNode* CopyMe(StackNode* origNode) {
        if(origNode == NULL) return NULL;
        StackNode* node = new StackNode(origNode->elem);
        node->next =  CopyMe(origNode->next);
        return node;
    }
};

void DeletePlan(PlanNode* plan);

class RegressionPlanner
{
public:

        RegressionPlanner() {}
        RegressionPlanner(const RegressionPlanner& origVal) { ///~write me
        }
        ~RegressionPlanner(void) {///~write me

        }
        const RegressionPlanner& operator=(const RegressionPlanner& origVal) {///~write me
        }

        int MakeNewPlan(KeyFrameNode* key_frame, PlanNode*& retPlan, int timer);

        int ResumePlanning(PlanNode*& retPlan, int timer, bool use_stack = true);
        
    int Replan(PlanNode*& retPlan, int timer);

private:
        // private functions

    int PlanOnRest(PlanNode*&retPlan,pair<WORLDSTATE,Condition>& bindings, 
                                        int which_binding, bool use_stack);

    list<pair<WORLDSTATE,Condition> >::iterator 
        FindComplete(list<pair<WORLDSTATE,Condition> >& possible_bindings,
        Condition& Conds);

        int NoNulls(vector<vector<GameObject*> >& vars);

        int MakePlan(PlanNode*& retPlan, bool use_stack);

        int MakeSubPlan(PlanNode*& plan, Condition& Conds, WORLDSTATE& state, bool use_stack);

        ///~~int SubPlanOnRest(PlanNode*& plan, Condition& Conds, int which_binding, WORLDSTATE& state);
    
    void ConcatPlans(PlanNode*& plan, PlanNode* newplan);

        void _ConcatPlans(PlanNode* plan, PlanNode* newplan);

        // returns 1 iff all threats resolved successfully
        int ResolveThreats(PlanNode*& plan1, PlanNode*& plan2);

        // returns 1 iff the plans are successfully merged and 
        // the result pointed to by plan1
        int MergePlans(PlanNode*& plan1, PlanNode*& plan2);

        void MergeRoots(PlanNode*& plan1, PlanNode*& plan2);
        
        void ClearStacks(void) {
            possible_bindings.clear();
        satisfied_counts.clear();

        // used for PlanOnRest
        Ops.clear();
        done = 0;

        // used for MakeSubPlan
        cond = NULL;
        OpStack.clear();
        PlanStack.clear();      
        }

        void MakeLink(PlanNode* p1, PlanNode* p2) {
                p1->branches.push_back(p2);
                p2->prevs.push_back(p1);
        }

        pair<int,int> CountSatisfied(Condition& cond);
        
    int _CountSatisfied(Condition& cond, int which_binding);
    
    void ResetFlags(PlanNode* plan);

        int PrevsSatisfied(PlanNode* plan);

    void AddForwardPart(PlanNode*& plan, WORLDSTATE& state);
    
    void SaveAll(void);

        void ResetTimer(void) {
                recorded_time = time(0);
        }
        int TimesUp(void) {
                return (time(0) - recorded_time > MAXTIME);
        }
        template <class T>
        int Member(T& elt, vector<T>& vec) {
                for(vector<T>::iterator e(vec.begin());e!=vec.end();++e)
                        if(*e == elt) return 1;
                return 0;
        }

    list<pair<list<pair<WORLDSTATE,Condition> >::iterator, pair<int,int> > >::iterator 
        FindBestCount(void);
    
    list<pair<list<pair<WORLDSTATE,Condition> >::iterator,pair<int,int> > > CountAllSatisfied(void);

        // private data
        
    // used for MakePlan
    list<pair<WORLDSTATE, Condition> > possible_bindings;
    list<pair<list<pair<WORLDSTATE,Condition> >::iterator,pair<int,int> > > satisfied_counts;
    
    // used for PlanOnRest
    vector<list<Operator> > Ops;
    vector<list<Operator> >::iterator ops;
    list<Operator>::iterator op;
    int done;

    // used for MakeSubPlan
    Condition* cond;
    pair<int,int> satisfied; // first is value, second is index
        MyStack<pair<vector<list<Operator> >, pair<vector<list<Operator> >::iterator, list<Operator>::iterator> > > OpStack;
    MyStack<PlanNode*> PlanStack;

    KeyFrameNode* currently_seeking;
        int recorded_time;
    
};

#endif