containerbase.h

Go to the documentation of this file.

/***************************************************************************
                          containerbase.h  -  description
                             -------------------
    begin                : Fri Sep 29 2000
    copyright            : (C) 2000 by Martin Bickel
    email                : bickel@asc-hq.org
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef containerbaseH
 #define containerbaseH

 #include <sigc++/sigc++.h>

 #include "typen.h"
 #include "containerbasetype.h"
 #include "graphics/surface.h"
 

class Vehicle;
class Player;

class ContainerBase {
      friend class ConvertContainer; 
      friend class ChangeContainerProperty;
   protected:

      int           repairedThisTurn;

      GameMap* gamemap;
          
      ContainerBase* cargoParent;
          

      void paintField ( const Surface& src, Surface& dest, SPoint pos, int dir, bool shaded, int shadowDist = -1 ) const;
      
      ContainerBase ( const ContainerBaseType* bt, GameMap* map, int player );
   public:

      virtual bool isBuilding() const = 0;

      const ContainerBaseType*  baseType;

      virtual Surface getImage() const = 0;

      typedef vector<const VehicleType*> Production;

      const Production& getProduction() const;
      Resources getProductionCost( const VehicleType* unit ) const;
      void deleteProductionLine( const VehicleType* type );
      void deleteAllProductionLines();
      void addProductionLine( const VehicleType* type  );
      bool hasProductionLine( const VehicleType* type );
      void setProductionLines( const Production& production  );
   private:
      mutable Production productionCache;
   protected:
      Production internalUnitProduction;
   public:
      



      typedef vector<Vehicle*> Cargo;
   protected:  
      Cargo cargo;

   private:
       void compactCargo();

   public:
      const Cargo& getCargo() const { return cargo; };

      int getCargoCount() const { return cargo.size(); };
      
      Vehicle* getCargo( int i );
      
      void clearCargo();

      SigC::Signal0<void> cargoChanged;

      
      ASCString    name;
      
      ASCString    privateName;
      
      void addToCargo( Vehicle* veh, int position = -1 );
      
      bool removeUnitFromCargo( Vehicle* veh, bool recursive = false );
      bool removeUnitFromCargo( int nwid, bool recursive = false );
      
      
      int vehiclesLoaded ( void ) const;
      
      ContainerBase* getCarrier() const;

      Vehicle* findUnit ( int nwid, bool recursive = true ) const;
      
      bool vehicleLoadable ( const Vehicle* vehicle, int uheight = -1, const bool* attacked = NULL ) const;

      int  vehicleUnloadable ( const VehicleType* vehicleType, int carrierHeight = -1 ) const;

      const ContainerBaseType::TransportationIO* vehicleUnloadSystem ( const VehicleType* vehicle, int height );

      int  vehicleDocking ( const Vehicle* vehicle, bool out  ) const;

      bool vehicleFit ( const Vehicle* vehicle ) const;

      int cargoWeight() const;

      int cargoNestingDepth();

   private:
      bool canCarryWeight( int additionalWeight, const Vehicle* vehicle ) const;

   public:
      
      virtual int  getArmor() const = 0;
      
     
      int damage;
      
      int color;
          
      int getOwner() const { return color >> 3; };
      
      Player& getOwningPlayer() const;
      
      virtual void registerForNewOwner( int player ) = 0;
      


      virtual void write ( tnstream& stream, bool includeLoadedUnits = true ) const = 0;
      virtual void read ( tnstream& stream ) = 0;

      virtual void addview ( void ) = 0;
          
      virtual void removeview ( void ) = 0;

      



      virtual int putResource ( int amount, int resourcetype, bool queryonly, int scope = 1, int player = -1 ) = 0;
      virtual int getResource ( int amount, int resourcetype, bool queryonly, int scope = 1, int player = -1 ) = 0;
      virtual int getAvailableResource ( int amount, int resourcetype, int scope = 1 ) const = 0;

      Resources putResource ( const Resources& res, bool queryonly, int scope = 1, int player = -1 );
      Resources getResource ( const Resources& res, bool queryonly, int scope = 1, int player = -1 );
      Resources getResource ( const Resources& res ) const;

      Resources getResourceUsage ( );

      Resources getResourcePlus ( );
      
      Resources getStorageCapacity() const;
      
      Resources netResourcePlus( ) const;

      void setInternalResourcePlus( const Resources& res );
      void setInternalResourceMaxPlus( const Resources& res );
      
      Resources getInternalResourcePlus() const;
      Resources getInternalResourceMaxPlus() const;
      
      Resources   plus;

      Resources   maxplus;

      Resources    bi_resourceplus;
      
      



      
      virtual const ResourceMatrix& getRepairEfficiency() const = 0;

      virtual void postRepair ( int oldDamage ) = 0;
      
      virtual bool canRepair( const ContainerBase* item ) const = 0;

      int getMaxRepair ( const ContainerBase* item ) const;
      int getMaxRepair ( const ContainerBase* item, int newDamage, Resources& cost, bool ignoreCost = false  ) const;
      int repairItem   ( ContainerBase* item, int newDamage = 0 );
      
      virtual int repairableDamage() const = 0;


      GameMap* getMap ( ) const { return gamemap; };
      
      virtual int getIdentification() const = 0;

      virtual int getHeight() const = 0;

      virtual ASCString getName ( ) const = 0;
      ASCString getPrivateName ( ) const;
      virtual void setName ( const ASCString& name );

      virtual int getAmmo( int type, int num, bool queryOnly )  = 0;
      virtual int getAmmo( int type, int num ) const  = 0;
      virtual int putAmmo( int type, int num, bool queryOnly )  = 0;
      virtual int maxAmmo( int type ) const = 0 ;


      SigC::Signal0<void> conquered;
      SigC::Signal0<void> destroyed;
      static SigC::Signal1<void,ContainerBase*> anyContainerDestroyed;
      static SigC::Signal1<void,ContainerBase*> anyContainerConquered;

      static int calcShadowDist( int binaryHeight );


      int         researchpoints;

      int         maxresearchpoints;

      virtual void endOwnTurn( void );

      virtual void endAnyTurn( void );

      virtual void endRound ( void );
      
      int view;

      class Work {
         public:
            virtual bool finished() = 0;
            virtual bool run() = 0;
            virtual Resources getPlus() = 0;
            virtual Resources getUsage() = 0;
            virtual ~Work() {};
      };

      class WorkClassFactory {
         public:
            virtual bool available( const ContainerBase* cnt ) = 0;
            virtual Work* produce( ContainerBase* cnt, bool queryOnly ) = 0;
            virtual ~WorkClassFactory() {};
      };

      static bool registerWorkClassFactory( WorkClassFactory* wcf, bool ASCmode = true );
   private:
      typedef list<WorkClassFactory*> WorkerClassList;
      static WorkerClassList* workClassFactoriesASC;
      static WorkerClassList* workClassFactoriesBI;
   public:
      
      Work* spawnWorkClasses( bool justQuery );

      
      virtual MapCoordinate3D getPosition ( ) const = 0;
      virtual ~ContainerBase();

      virtual vector<MapCoordinate> getCoveredFields() = 0;
};

class TemporaryContainerStorage  {
        ContainerBase* cb;
        MemoryStreamStorage buf;
        bool _storeCargo;
     public:
        TemporaryContainerStorage ( ContainerBase* _cb, bool storeCargo = false );
        void restore();
};


#endif

---