containerbasetype.h

Go to the documentation of this file.

/***************************************************************************
                          containerbasetype.h  -  description
                             -------------------
    begin                : Sun Feb 18 2001
    copyright            : (C) 2001 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 containerbasetypeH
 #define containerbasetypeH

 #include "objects.h"
 #include "typen.h"
 #include "research.h"
 #include "mapitemtype.h"
 #include "memsize_interface.h"

class ContainerBaseType: public MapItemType, public LoadableItemType, public MemorySizeQueryInterface {
   protected:
      std::bitset<64> features;
   public:
     ContainerBaseType ();

     enum ContainerFunctions { TrainingCenter,
        InternalVehicleProduction,
        AmmoProduction,
        InternalUnitRepair,
        RecycleUnits,
        Research,
        Sonar,
        SatelliteView,
        MineView,
        WindPowerPlant,
        SolarPowerPlant,
        MatterConverter,
        MiningStation,
        ProduceNonLeavableUnits,
        ResourceSink,
        ExternalEnergyTransfer,
        ExternalMaterialTransfer,
        ExternalFuelTransfer,
        ExternalAmmoTransfer,
        ExternalRepair,
        NoObjectChaining,
        SelfDestructOnConquer,
        Paratrooper,
        PlaceMines,
        CruiserLanding,
        ConquerBuildings,
        MoveAfterAttack,
        ExternalVehicleProduction,
        ConstructBuildings,
        IceBreaker,
        NoInairRefuelling,
        MakesTracks,
        DetectsMineralResources,
        NoReactionfire,
        AutoRepair,
        KamikazeOnly,
        ImmuneToMines,
        JamsOnlyOwnField,
        MoveWithReactionFire,
        OnlyMoveToAndFromTransports,
        AutoHarvestObjects,
        NoProductionCustomization,
        ManualSelfDestruct,
        NoMineRemoval };

     
     static const int functionNum = 44;

     bool hasFunction( ContainerFunctions function ) const;
     bool hasAnyFunction( std::bitset<64> functions ) const;
     static const char* getFunctionName( ContainerFunctions function );

   protected:
      void setFunction( ContainerFunctions function );
   public:
     
     int id;

     vector<int> secondaryIDs;


     ASCString    name;

     ASCString    description;
     
     ASCString getName() const { return name; };
     int getID() const { return id; };
     
     
     ASCString    infotext;

     int          jamming;

     int          view;

     int          height;
     int getHeight() const { return height; };

     Resources productionCost;
     virtual ~ContainerBaseType() {};

     int maxLoadableUnits;

     int maxLoadableUnitSize;

     int maxLoadableWeight;

     int vehicleCategoriesStorable;

     int vehicleCategoriesProduceable;

     vector<IntRange> vehiclesInternallyProduceable;

     class TransportationIO {
         public:
            TransportationIO ();
            static const int entranceModeNum = 3;
            enum { In = 1, Out = 2, Docking = 4 };
            int mode;

            // int functionbits

            int height_abs;

            int height_rel;

            int container_height;

            int vehicleCategoriesLoadable;

            int dockingHeight_abs;

            int dockingHeight_rel;

            std::bitset<64> requiresUnitFeature;

            int movecost;

            bool disableAttack;

            void runTextIO ( PropertyContainer& pc );
            void read ( tnstream& stream ) ;
            void write ( tnstream& stream ) const ;
     };

     typedef vector<TransportationIO> EntranceSystems;
     EntranceSystems   entranceSystems;

     TechAdapterDependency techDependency;

     ASCString infoImageFilename;
     ASCString infoImageSmallFilename;

     void runTextIO ( PropertyContainer& pc );

     bool vehicleFit ( const VehicleType* type ) const ;

     int  vehicleUnloadable ( const VehicleType* vehicleType, int carrierHeight ) const;


     void read ( tnstream& stream ) ;
     void write ( tnstream& stream ) const ;

     

     int          efficiencyfuel;

     int          efficiencymaterial;

     int          maxresearchpoints;

     int          defaultMaxResearchpoints;

     int          nominalresearchpoints;

     int  minFieldRepairDamage;
     
     Resources    maxplus;

     Resources    defaultProduction;

     virtual int getMoveMalusType() const = 0;
     
     Resources   getStorageCapacity( int mode ) const;
   protected:
     Resources    asc_mode_tank;
     Resources    bi_mode_tank;
     
   public:

      ResourceMatrix productionEfficiency;
      
      struct {
         int range;
         
         int maxFieldsPerTurn;
         
        vector<IntRange> objectsHarvestable;

        vector<IntRange> objectGroupsHarvestable;
      } autoHarvest;
     
 };

#endif

---