attack.h

Go to the documentation of this file.

/*
    This file is part of Advanced Strategic Command; http://www.asc-hq.de
    Copyright (C) 1994-2010  Martin Bickel  and  Marc Schellenberger
 
    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.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING. If not, write to the 
    Free Software Foundation, Inc., 59 Temple Place, Suite 330, 
    Boston, MA  02111-1307  USA
*/



#ifndef attackH
#define attackH

#include "typen.h"
#include "vehicletype.h"
#include "vehicle.h"
#include "buildings.h"
#include "objects.h"
#include "explosivemines.h"

#include "actions/context.h"


class AttackFormula
{
      virtual bool checkHemming ( Vehicle* d_eht, int direc );
   protected:
      GameMap* gamemap;
   public:
      AttackFormula( GameMap* gamemap );
      float strength_experience ( int experience );
      float strength_damage ( int damage );
      float strength_attackbonus ( int abonus );
      float strength_hemming ( int  ax,  int ay,  Vehicle* d_eht );
      float defense_experience ( int experience );
      float defense_defensebonus ( int defensebonus );
      static float getHemmingFactor ( int relDir );  // 0 <= reldir <= sidenum-2
      virtual ~AttackFormula()
      {}
      ;
};



class tunitattacksobject;
class tmineattacksunit;
class tunitattacksbuilding;
class tunitattacksunit;

class FightVisitor
{
   public:
      virtual void visit( tunitattacksobject& battle ) = 0;
      virtual void visit( tmineattacksunit& battle ) = 0;
      virtual void visit( tunitattacksbuilding& battle ) = 0;
      virtual void visit( tunitattacksunit& battle ) = 0;
      virtual ~FightVisitor()
      {}
      ;
};


class tfight : public AttackFormula
{
   protected:
      tfight ( GameMap* gamemap) : AttackFormula( gamemap ) {};
      int dist;

   public:
      struct tavalues
      {
         tavalues() : weapontype(-1)
         {}
         ;
         int strength;
         int armor;
         int damage;
         int experience;
         int defensebonus;
         int attackbonus;
         float hemming;
         int weapnum;
         int weapcount;
         int color;
         int initiative;
         int kamikaze;
         int height;
         int weapontype;
      }
      av, dv;

      void calc ( void ) ;

      virtual void setresult( const Context& context ) = 0;

      virtual void visit ( FightVisitor& visitor ) = 0;

      virtual int getAttackingPlayer() = 0;
      virtual int getDefendingPlayer() = 0;
      
};

class UnitAttacksSomething : public tfight
{
   protected:
      UnitAttacksSomething( GameMap* gamemap ) : tfight( gamemap ) {};
      
      Vehicle* _attackingunit;
      int getAttackingPlayer()
      {
         return _attackingunit->getOwner();
      };
   public:
      Vehicle* getAttackingUnit()
      {
         return _attackingunit;
      };
};

class tunitattacksunit : public UnitAttacksSomething
{
      Vehicle* _attackedunit;

      Vehicle** _pattackingunit;
      Vehicle** _pattackedunit;

      int _respond;
      bool reactionfire;

   protected:

   public:
      tunitattacksunit ( Vehicle* &attackingunit, Vehicle* &attackedunit, bool respond = true, int weapon = -1, bool reactionfire = false );
      void setup ( Vehicle* &attackingunit, Vehicle* &attackedunit, bool respond, int weapon );
      void setresult( const Context& context );

      void visit ( FightVisitor& visitor )
      {
         visitor.visit( *this );
      };
      Vehicle* getTarget()
      {
         return _attackedunit;
      };

      int getDefendingPlayer()
      {
         return _attackedunit->getOwner();
      };
      
};

class tunitattacksbuilding : public UnitAttacksSomething
{
      Building* _attackedbuilding;
      int _x, _y;
   public:
      int getAttackingPlayer()
      {
         return _attackingunit->getOwner();
      };
      int getDefendingPlayer()
      {
         return _attackedbuilding->getOwner();
      };

      tunitattacksbuilding ( Vehicle* attackingunit, int x, int y, int weapon = -1);
      void setup ( Vehicle* attackingunit, int x, int y, int weapon );
      void setresult( const Context& context );

      void visit ( FightVisitor& visitor )
      {
         visitor.visit( *this );
      };
      Building* getTarget()
      {
         return _attackedbuilding;
      };
};


class tmineattacksunit : public tfight
{
      MapField* _mineposition;
      Vehicle* _attackedunit;
      int _minenum;
      Vehicle** _pattackedunit;

      MapCoordinate position;
      
   public:
      int getAttackingPlayer()
      {
         return 8;
      };
      int getDefendingPlayer()
      {
         return _attackedunit->getOwner();
      };


      tmineattacksunit ( const MapCoordinate& mineposition, int minenum, Vehicle* &attackedunit );
      void setup ( const MapCoordinate& position, int minenum, Vehicle* &attackedunit );
      void setresult( const Context& context );

      Mine* getFirstMine();

      void visit ( FightVisitor& visitor )
      {
         visitor.visit( *this );
      };

      Vehicle* getTarget()
      {
         return _attackedunit;
      };
};

class tunitattacksobject : public UnitAttacksSomething
{
      MapField*       targetField;
      Object*      _obji;
      int _x, _y;

   public:
      int getAttackingPlayer()
      {
         return _attackingunit->getOwner();
      };
      int getDefendingPlayer()
      {
         return 8;
      };

      tunitattacksobject ( Vehicle* attackingunit, int obj_x, int obj_y, int weapon = -1 );
      void setup ( Vehicle* attackingunit, int obj_x, int obj_y, int weapon );
      void setresult( const Context& context );
      
      Object* getTarget()
      {
         return _obji;
      };
      void visit ( FightVisitor& visitor )
      {
         visitor.visit( *this );
      };
};

class AttackWeap
{
   public:
      int          count;
      int          strength[16];
      int          num[16];
      int          typ[16];

      enum Target { nothing, vehicle, building, object } target;
};




extern AttackWeap* attackpossible( const Vehicle* attacker, int x, int y);



extern bool attackpossible2u( const Vehicle* attacker, const Vehicle* target, AttackWeap* attackweap = NULL, int targetheight = -1);      // distance is not evaluated


extern bool attackpossible28( const Vehicle* attacker, const Vehicle* target, AttackWeap* attackweap = NULL, int targetHeight = -1);       // distance is fixed as 1 field


extern bool attackpossible2n( const Vehicle* attacker, const Vehicle* target, AttackWeap* attackweap = NULL );

extern bool vehicleplattfahrbar( const Vehicle* vehicle, const MapField* field );


class WeapDist
{
   public:
      static float getWeaponStrength ( const SingleWeapon* weap, int targetFieldWeather = 0, int dist =-1, int attacker_height =-1, int defender_height = -1, int reldiff = -1 );
};


#endif

---