order.h

Go to the documentation of this file.

/*
 * Vega Strike
 * Copyright (C) 2001-2002 Daniel Horn
 *
 * http://vegastrike.sourceforge.net/
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#ifndef _CMD_ORDER_H

#define _CMD_ORDER_H

#include "gfx/vec.h"
#include "cmd/container.h"
#include <list>
#include <vector>
#include <string>

class Animation;
typedef std::vector< class varInst* >olist_t;
class Order
{
private:

protected:
    virtual ~Order();
    Unit *parent;
    unsigned int type;

    unsigned int subtype;
    bool done;
    UnitContainer group;
    QVector targetlocation;
    std::vector< Order* >suborders;
    std::list< class CommunicationMessage* >messagequeue;
    virtual void Destructor();
protected:

public:

    virtual void ChooseTarget()
    {
        /*not implemented see fire.cpp*/
    }
    virtual bool PursueTarget( Unit*, bool isleader )
    {
        return false;
    }
    void ClearMessages();
    enum ORDERTYPES {MOVEMENT=1, FACING=2, WEAPON=4, CLOAKING=8, ALLTYPES=(1|2|4|8)};
    enum SUBORDERTYPES {SLOCATION=1, STARGET=2, SSELF=4};
    Order()
        : parent(NULL),
          type(0),
          subtype(0),
          done(false),
          targetlocation( 0, 0, 0 )
    {
        VSCONSTRUCT1( 'O' )
    }
    Order( int type, int subtype )
        : parent(NULL),
          type(type),
          subtype(subtype),
          done(false),
          targetlocation( 0, 0, 0 )
    {
        VSCONSTRUCT1( 'O' )
    }
    virtual void Destroy();

    virtual void Execute();
    Order * queryType( unsigned int type );
    Order * queryAny( unsigned int type );
    void eraseType( unsigned int type );
    bool AttachOrder( Unit *targets );
    bool AttachOrder( QVector target );
    bool AttachSelfOrder( Unit *targets );
    Order * EnqueueOrder( Order *ord );
    Order * ReplaceOrder( Order *ord );
    bool Done()
    {
        return done;
    }
    int getType()
    {
        return type;
    }
    int getSubType()
    {
        return subtype;
    }
    virtual void SetParent( Unit *parent1 )
    {
        parent = parent1;
    }
    Unit * GetParent() const
    {
        return parent;
    }
    virtual void Communicate( const class CommunicationMessage &c );
    virtual void ProcessCommMessage( class CommunicationMessage&c );
    virtual void ProcessCommunicationMessages( float CommRepsonseTime, bool RemoveMessageProcessed );
    Order * findOrder( Order *ord );
    void eraseOrder( Order *ord );
    Order * EnqueueOrderFirst( Order *ord );
    virtual olist_t * getOrderList()
    {
        return NULL;
    }
    virtual void AdjustRelationTo( Unit *un, float factor );

    virtual std::string getOrderDescription()
    {
        return "empty";
    }

    Order * findOrderList();
    std::string createFullOrderDescription( int level = 0 );
    void setActionString( std::string astring )
    {
        actionstring = astring;
    }
    std::string getActionString()
    {
        return actionstring;
    }
    virtual float getMood()
    {
        return 0;
    }
protected:
    std::string actionstring;
};
class OrderFactory
{
public:
    virtual int type()
    {
        return 0;
    }
    OrderFactory() {}
    virtual Order * newOrder()
    {
        return new Order;
    }
};

namespace Orders
{

class ExecuteFor : public Order
{
private:

    Order *child;
    float  time;
    float  maxtime;
protected:
    virtual ~ExecuteFor() {}
public: ExecuteFor( Order *chld, float seconds ) : Order( chld->getType(), chld->getSubType() )
        , child( chld )
        , time( 0 )
        , maxtime( seconds ) {}
    void Execute();
    virtual void Destroy()
    {
        child->Destroy();
        Order::Destroy();
    }
};

// Execute two orders simultaneously and wait until both has finished.
class Join : public Order
{
public:
    Join(Unit *parent,
         Order *firstOrder,
         Order *secondOrder);
    void Execute();

private:
    Order *first;
    Order *second;
};

// Execute one order and prevent other orders with excludeTypes from executing at the same time.
class Sequence : public Order
{
public:
    Sequence(Unit *parent,
             Order *order,
             unsigned int excludeTypes);
    void Execute();

private:
    Order *order;
};

} // namespace Orders

#endif