vehicle.h

Go to the documentation of this file.

/***************************************************************************
                          vehicle.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 vehicleH
 #define vehicleH

 #include "typen.h"
 #include "vehicletype.h"
 #include "containerbase.h"
 #include "ascstring.h"

class BuildingType;


class UnitHooveringLogic {
      static const int FuelConsumption; 

   public:
      static int calcFuelUsage( const Vehicle* veh );

      static int getEndurance ( const Vehicle* veh );
      static int getEndurance ( const Vehicletype* veh, int height = -1, int resourceModel = 0 );

};

 
 class Vehicle : public ContainerBase {
    bool cleanRemove;

    Vehicle (  );

    Vehicle ( const Vehicle& v );

    bool viewOnMap;

    int  _movement;

    void init ( void );

    ResourceMatrix repairEfficiency;

    bool generatoractive;

    bool movementLeft() const;

    Vehicle ( const Vehicletype* t, GameMap* actmap, int player, int networkID  );


   public:

    Vehicle ( const Vehicletype* t, GameMap* actmap, int player );

    int repairableDamage() { return damage; };

    bool isBuilding() const { return false; };

    const Vehicletype* typ;
    int          ammo[16];
    int          weapstrength[16];
    int          experience;

    bool         attacked;

    void setAttacked();

    int          height;

    char         direction;

    int          xpos, ypos;
#ifndef karteneditor
  private:
#endif

    Resources    tank;
  public:

    int          connection;

    int          getArmor() const;

    int          networkid;
    ASCString    name;

    class  ReactionFire {
         friend class Vehicle;
         friend class UnitPropertyEditor;

         Vehicle* unit;
       public:
         ReactionFire ( Vehicle* _unit );
         enum Status { off, init1a, init2, ready, init1b };

         // int enemiesAttackable;
         Status getStatus() const { return status;};

         int enable();
         void disable();

         vector<int> weaponShots;
         vector<int> nonattackableUnits;

         void endOwnTurn();
         void endAnyTurn();
         void checkData();

         bool canPerformAttack( Vehicle* target );
         
         bool canMove() const;
       private:
         Status status;
         void resetShotCount();

    } reactionfire;

    AiParameter* aiparam[8];




    bool canMove ( void ) const;

    int getMovement ( bool checkFuel = true, bool checkRF = true ) const ;

    void setMovement ( int newmove, double cargoDivisor = -1 );

    bool hasMoved ( void ) const;

    int maxMovement ( ) const;

    void decreaseMovement ( int movement );

    void resetMovement( void );

    
    

    void setNewHeight( int bitmappedheight );

    bool spawnMoveObjects( const MapCoordinate& start, const MapCoordinate& dest );


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

    Resources putResource ( const Resources& res, bool queryonly, int scope = 1, int player = -1 ) { return ContainerBase::putResource ( res, queryonly, scope, player ); };
    Resources getResource ( const Resources& res, bool queryonly, int scope = 1, int player = -1 ) { return ContainerBase::getResource ( res, queryonly, scope, player ); };

    Resources getTank() const;

    
    int getHeight() const { return height; };
    


    ASCString    getName() const;

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



    int weight( void ) const;
    
    int freeWeight();


  protected:
    const ResourceMatrix& getRepairEfficiency ( void ) { return repairEfficiency; };

    virtual void postRepair ( int oldDamage );

  private:
    int searchstackforfreeweight ( Vehicle* searchedInnerVehicle );

  public:

    int size ( void );

    void endOwnTurn( void );

    void endAnyTurn( void );


    void endRound ( void );

    int getIdentification() { return networkid; };




    Vehicle* constructvehicle ( Vehicletype* tnk, int x, int y );

    bool vehicleconstructable ( Vehicletype* tnk, int x, int y );

    bool buildingconstructable ( const BuildingType* bld, bool checkResources = true );
    
    void setnewposition ( int x, int y );
    void setnewposition ( const MapCoordinate& mc );

    void convert ( int player );

    void setGeneratorStatus( bool status );
    bool getGeneratorStatus () const { return generatoractive; };

    void postAttack( bool reactionFire );

    void addview();

    void removeview();

    bool isViewing ( ) const { return viewOnMap; };
    const SingleWeapon *getWeapon( unsigned weaponNum );


    int searchForMineralResources( ) const;

//    bool searchForMineralResourcesAvailable();

    MapCoordinate3D getPosition ( ) const;

    MapCoordinate3D getPosition3D ( ) const;


    // Searches this and all nested transport for the unit. Returns the direct parent carrier.
    // Vehicle* findCarrierUnit ( const Vehicle* veh );

    
    bool canRepair( const ContainerBase* item ) const;

    void fillMagically( bool ammo = true, bool resources = true );


    static Vehicle* newFromStream ( GameMap* gamemap, tnstream& stream, int forceNetworkID = -1 );

    void read ( tnstream& stream );

    void write ( tnstream& stream, bool includeLoadedUnits = true );

    void paint ( Surface& s, SPoint pos, int shadowDist = -1 ) const;
    void paint ( Surface& s, SPoint pos, bool shaded, int shadowDist = -1 ) const;

    virtual Surface getImage() const;


  private:
    void readData ( tnstream& stream );
  public:

    int getValueType ( int uheight ) const { return log2(uheight); };

    int getValueType ( ) const { return log2(height); };


    void transform ( const Vehicletype* type );

    const Vehicletype::HeightChangeMethod* getHeightChange( int dir, int height = 0 ) const;

    bool weapexist ( void );
    void prepareForCleanRemove() { cleanRemove = true; };
    ~Vehicle ( );

     int getMemoryFootprint() const;

  protected:
     vector<MapCoordinate> getCoveredFields();
       
};


#endif

---