vehicletype.h

Go to the documentation of this file.

/***************************************************************************
                          vehicletype.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 vehicletypeH
 #define vehicletypeH

 #include "typen.h"
 #include "containerbase.h"
 #include "ascstring.h"
 #include "baseaiinterface.h"
 #include "terraintype.h"
 #include "research.h"
 #include "playercolor.h"
 
/*
extern const char*  cvehiclefunctions[];
 #define cfsonar 1
 #define cfparatrooper 2
 #define cfminenleger 4
 #define cfrepair 16
 #define cf_conquer 32
 #define cf_moveafterattack 64
 #define cfsatellitenview 128
 #define cfputbuilding 256
 #define cfmineview 512
 #define cfvehicleconstruction 1024
 #define cfspecificbuildingconstruction 2048
 #define cffuelref 4096
 #define cficebreaker 8192
 #define cfnoairrefuel 16384
 #define cfmaterialref 32768
 #define cffahrspur ( 1 << 17 )
 #define cfmanualdigger ( 1 << 18 )
 #define cfno_reactionfire ( 1 << 19 )
 #define cfautorepair ( 1 << 20 )
 #define cfgenerator ( 1 << 21 )
 #define cfautodigger ( 1 << 22 )
 #define cfkamikaze ( 1 << 23 )
 #define cfmineimmune ( 1 << 24 )
 #define cfenergyref ( 1 << 25 )
 #define cfownFieldJamming ( 1 << 26 )
 #define cfmovewithRF ( 1 << 27 )
 #define cfonlytransmove ( 1 << 28 )

 #define cfvehiclefunctionsanzeige 0xFFFFFFFF
*/

#define cwaffentypennum 13
 extern const char*  cwaffentypen[cwaffentypennum] ;
 #define cwcruisemissile 0
 #define cwcruisemissileb ( 1 << cwcruisemissile )
 #define cwminen 1
 #define cwmineb ( 1 << cwminen   )
 #define cwbombn 2
 #define cwbombb ( 1 << cwbombn  )
 #define cwlargemissilen 3
 #define cwlargemissileb ( 1 << cwlargemissilen  )
 #define cwsmallmissilen 4
 #define cwsmallmissileb ( 1 << cwsmallmissilen  )
 #define cwtorpedon 5
 #define cwtorpedob ( 1 << cwtorpedon  )
 #define cwmachinegunn 6
 #define cwmachinegunb ( 1 << cwmachinegunn )
 #define cwcannonn 7
 #define cwcannonb ( 1 << cwcannonn )
 #define cwweapon ( cwcruisemissileb | cwbombb | cwlargemissileb | cwsmallmissileb | cwtorpedob | cwmachinegunb | cwcannonb | cwlaserb )
 #define cwshootablen 11
 #define cwshootableb ( 1 << cwshootablen  )
 #define cwlasern 10
 #define cwlaserb ( 1 << cwlasern  )
 #define cwammunitionn 9
 #define cwammunitionb ( 1 << cwammunitionn )
 #define cwservicen 8
 #define cwserviceb ( 1 << cwservicen )
 #define cwobjectplacementn 12
 #define cwobjectplacementb ( 1 << cwobjectplacementn )
 extern const int cwaffenproduktionskosten[cwaffentypennum][3];  /*  Angabe: Waffentyp; energy - Material - Sprit ; jeweils fuer 5er Pack */


 extern const bool weaponAmmo[cwaffentypennum];



 class SingleWeapon {
     int          typ;
    public:
     SingleWeapon ();
     int          targ;

     int          sourceheight;

     int          maxdistance;

     int          mindistance;

     int          count;

     int          maxstrength;

     int          minstrength;

     int          efficiency[13];

     int          targetingAccuracy[cmovemalitypenum];

     int          laserRechargeRate;

     Resources    laserRechargeCost;

     int          reactionFireShots;

     ASCString    soundLabel;

     ASCString    name;

     int          getScalarWeaponType(void) const;
     bool         requiresAmmo(void) const;
     bool         shootable( void ) const;
     bool         service( void ) const;
     bool         placeObjects() const;
     bool         canRefuel ( void ) const;
     void         set ( int type );  // will be enhanced later ...
     int          gettype ( void ) const { return typ; };
     bool         offensive( void ) const;
     ASCString    getName ( void ) const;
     static ASCString   getIconFileName( int weaponType );
     void         runTextIO ( PropertyContainer& pc );
     bool         equals( const SingleWeapon* otherWeapon ) const;
 };

 class  UnitWeapon {
   public:
     int count;
     SingleWeapon weapon[16];
     UnitWeapon ( void );
 };

 class Player;

 class Vehicletype : public ContainerBaseType {
        Surface  image;
    public:
        static const int legacyVehicleFunctionNum = 29;
        
        ASCString    description;

        ASCString    getName() const;

        int armor;

        
        int          height;

        double     cargoMovementDivisor;

        bool         wait;

        int          fuelConsumption;

        vector<int>  movement;

        int          movemalustyp;

        int          maxwindspeedonwater;

        int          digrange;

        int          initiative;

        int           weight;

        TerrainAccess terrainaccess;

        int           bipicture;

        vector<IntRange> buildingsBuildable;

        vector<IntRange> vehiclesBuildable;

        vector<IntRange> objectsBuildable;

        vector<IntRange> objectsRemovable;

        vector<IntRange> objectGroupsBuildable;

        vector<IntRange> objectGroupsRemovable;

        vector<IntRange> objectLayedByMovement;

        UnitWeapon   weapons;

        int          autorepairrate;

        int  unitConstructionMoveCostPercentage;
        
        vector<int> wreckageObject;

        mutable AiValue* aiparam[8];

        AiParameter::Job recommendedAIJob;

        int maxsize   ( void ) const ;

        ASCString    movementSoundLabel;

        ASCString    killSoundLabel;

        vector<int> guideSortHelp;

        int heightChangeMethodNum;
        class HeightChangeMethod{
            public:
              int startHeight;
              int heightDelta;
              int moveCost;
              bool canAttack;
              int dist;

              void runTextIO ( PropertyContainer& pc );
              void read ( tnstream& stream ) ;
              void write ( tnstream& stream ) const ;
        };
        vector<HeightChangeMethod> heightChangeMethod;

        int maxSpeed ( ) const;

        Vehicletype ( void );
        void read ( tnstream& stream ) ;
        void write ( tnstream& stream ) const ;
        void runTextIO ( PropertyContainer& pc );
        ~Vehicletype ( );
        Resources calcProductionsCost();

        int getMoveMalusType() const {
           return movemalustyp;
        }

        struct JumpDrive {
           JumpDrive() : height(0), maxDistance(maxint) {};
           int height; 
           Resources consumption;
           TerrainAccess targetterrain;
           int maxDistance;
        } jumpDrive;
           
        
        
        void  paint ( Surface& s, SPoint pos, const PlayerColor& player, int direction = 0 ) const;
        void  paint ( Surface& s, SPoint pos ) const;
        const Surface&  getImage () const { return image;};
        Surface&  getImage () { return image;};
        
        int getMemoryFootprint() const;

        static BitSet convertOldFunctions( int abilities, const ASCString& location );
    private:
        void setupRemovableObjectsFromOldFileLayout();
 };


extern ASCString getUnitReference ( Vehicle* veh );

#endif

---