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 Context;

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() const { return damage; };

    bool isBuilding() const { return false; };

    const VehicleType* typ;
    
    const VehicleType* getType() const { return typ; };
    
    int          ammo[16];
    int          weapstrength[16];
    int          experience;

    bool         attacked;

    void setAttacked();
    
    void setAttacked( bool recursive, const Context& context );

    int          height;

    char         direction;

    int          xpos, ypos;
#ifndef karteneditor
  private:
#endif
    Resources    tank;
  public:

    int          connection;

    int          getArmor() const;

    int          networkid;

    class  ReactionFire {
         friend class Vehicle;
         friend class UnitPropertyEditor;
         friend class ChangeUnitProperty;

         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 );

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


    
    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() const { return repairEfficiency; };

    virtual void postRepair ( int oldDamage );

  private:
    int searchstackforfreeweight ( Vehicle* searchedInnerVehicle );

  public:

    int size ( void );

    void beginTurn();
    
    void endOwnTurn( void );

    void endAnyTurn( void );

    void endRound ( void );

    int getIdentification() const { return networkid; };




    bool vehicleconstructable ( const VehicleType* tnk, int x, int y );
    
    Resources getExternalVehicleConstructionCost( const VehicleType* tnk ) const;

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

    void convert ( int player, bool recursive = true );
    
    
    void registerForNewOwner( int player );

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

    void postAttack( bool reactionFire, const Context& context );
    void postAttack( bool reactionFire );

    void addview();

    void removeview();
    
    void resetview();

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

    MapCoordinate3D getPosition ( ) const;

    MapCoordinate3D getPosition3D ( ) const;


    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 ) const ;

    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 getFirstBit(uheight); };

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


    void transform ( const VehicleType* type );

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

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

     int getMemoryFootprint() const;

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


#endif

---