guifunctions.cpp

Go to the documentation of this file.

/*
    This file is part of Advanced Strategic Command; http://www.asc-hq.de
    Copyright (C) 1994-2007  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
*/

#include <stdio.h>
#include <cstring>
#include <stdlib.h>

#include "guifunctions.h"
#include "guifunctions-interface.h"
#include "unitctrl.h"
#include "controls.h"
#include "dialog.h"
#include "gameoptions.h"
#include "iconrepository.h"
#include "replay.h"
#include "attack.h"
#include "graphics/blitter.h"
#include "viewcalculation.h"
#include "spfst.h"
// #include "gamedlg.h"
#include "dialogs/cargodialog.h"
#include "dialogs/ammotransferdialog.h"
#include "mapdisplay.h"
#include "sg.h"
#include "loaders.h"
#include "itemrepository.h"
#include "turncontrol.h"
#include "dialogs/buildingtypeselector.h"
#include "dialogs/internalAmmoTransferDialog.h"
#include "actions/jumpdrive.h"
#include "actions/selfdestruct.h"


namespace GuiFunctions
{



class AttackGui : public GuiIconHandler, public GuiFunction, public SigC::Object {
     VehicleAttack* attackEngine;

     pair<pattackweap, int> getEntry( const MapCoordinate& pos, int num );

      void mapDeleted( GameMap& map )
      {
         if ( NewGuiHost::getIconHandler() == this )
            NewGuiHost::popIconHandler();
      }

   protected:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
      void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
      Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num );
      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num );
      bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num );

   public:
      AttackGui() : attackEngine( NULL ) 
      {
         GameMap::sigMapDeletion.connect( SigC::slot( *this, &AttackGui::mapDeleted )); 
      };
      void setupWeapons( VehicleAttack* va ) { attackEngine = va; };
      void eval( const MapCoordinate& mc, ContainerBase* subject );

};

bool AttackGui :: checkForKey( const SDL_KeyboardEvent* key, int modifier, int num )
{
   if ( key->keysym.sym == SDLK_ESCAPE || key->keysym.unicode == 'c' ) {
      // execute( actmap->getCursor(), actmap->getField( actmap->getCursor())->getContainer() , -1 );
      return true;
   }
   return false;
}


pair<pattackweap, int> AttackGui::getEntry( const MapCoordinate& pos, int num )
{
   int counter = 0;
   
   AttackFieldList* afl = NULL;
   for ( int i = 0; i < 3; ++i ) {
      switch ( i ) {
         case 0: afl = &attackEngine->attackableVehicles; break;
         case 1: afl = &attackEngine->attackableBuildings; break;
         case 2: afl = &attackEngine->attackableObjects; break;
      }
      
      if ( afl->isMember( pos )) {
         pattackweap aw = &afl->getData(pos.x, pos.y);
         for ( int a = 0; a < aw->count; ++a ) {
            if ( counter == num )
               return make_pair( aw, a );
               
            ++counter;
         }
      }   
   }
   return make_pair( pattackweap(NULL), 0 );
}


bool AttackGui::available( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if ( num == -1 )
      return true;
      
   if ( getEntry(pos,num).first )
      return true;
   else
      return false;
}

void AttackGui::execute( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if ( num != -1 ) {
   
      pair<pattackweap, int> p = getEntry(pos,num);
      if ( p.first ) {
         int res = pendingVehicleActions.attack->execute ( NULL, pos.x, pos.y, 2, 0, p.first->num[p.second] );
         if ( res < 0 )
            dispmessage2 ( -res, NULL );

      }
   }   
   setupWeapons( NULL );
   delete pendingVehicleActions.attack;
   actmap->cleartemps();
   NewGuiHost::popIconHandler();
   repaintMap();
   updateFieldInfo();
}

Surface& AttackGui::getImage( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if ( num == -1 )
      return IconRepository::getIcon("cancel.png");
      
   pair<pattackweap, int> p = getEntry(pos,num);
   switch ( p.first->typ[p.second] ) {
      case cwcruisemissileb: return IconRepository::getIcon("weap-cruisemissile.png");
      case cwbombb: return IconRepository::getIcon("weap-bomb.png");
      case cwlargemissileb: return IconRepository::getIcon("weap-bigmissile.png");
      case cwsmallmissileb: return IconRepository::getIcon("weap-smallmissile.png");
      case cwtorpedob: return IconRepository::getIcon("weap-torpedo.png");
      case cwmachinegunb: return IconRepository::getIcon("weap-machinegun.png");
      case cwcannonb: return IconRepository::getIcon("weap-cannon.png");
      default: return IconRepository::getIcon("weap-laser.png");
   };
}

ASCString AttackGui::getName( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if ( num == -1 )
      return "cancel";

   Vehicle* attacker = attackEngine->getAttacker();

   tfight* battle = NULL;

   pair<pattackweap, int> p = getEntry(pos,num);
   

   if ( p.first->target == AttackWeap::vehicle )
      battle = new tunitattacksunit ( attacker, actmap->getField(pos)->vehicle, true, p.first->num[p.second] );
   else
   if ( p.first->target == AttackWeap::building )
      battle = new tunitattacksbuilding ( attacker, pos.x, pos.y, p.first->num[p.second] );
   else
   if ( p.first->target == AttackWeap::object )
      battle = new tunitattacksobject ( attacker, pos.x, pos.y, p.first->num[p.second] );


   int dd = battle->dv.damage;
   int ad = battle->av.damage;
   battle->calc ( );

   ASCString result;
   result.format( "%s; eff strength: %d; damage inflicted to enemy: %d, making a total of ~%d~; own damage will be +%d = %d", cwaffentypen[log2(p.first->typ[p.second])], battle->av.strength, battle->dv.damage-dd, battle->dv.damage, battle->av.damage-ad, battle->av.damage );
   return result;
}


void AttackGui::eval( const MapCoordinate& mc, ContainerBase* subject )
{
   
   int num = 0;
   while ( getEntry( mc, num).first ) {
       GuiButton* b = host->getButton(num);
       b->registerFunc( this, mc, subject, num );
       b->Show();
       ++num;
   }

   GuiButton* b = host->getButton(num);
   b->registerFunc( this, mc, subject, -1 );
   b->Show();
   ++num;

   host->disableButtons(num);
}



AttackGui attackGui;



bool Cancel::available( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   return moveparams.movestatus || pendingVehicleActions.action;
};

void Cancel::execute( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if ( moveparams.movestatus || pendingVehicleActions.action ) {
      moveparams.movestatus = 0;
      if ( pendingVehicleActions.action )
         delete pendingVehicleActions.action;

      actmap->cleartemps(7);
      updateFieldInfo();
      displaymap();
   }
};

bool Cancel::checkForKey( const SDL_KeyboardEvent* key, int modifier, int num )
{
   return ( key->keysym.sym == SDLK_ESCAPE || key->keysym.unicode == 'c' );
};


Surface& Cancel::getImage( const MapCoordinate& po, ContainerBase* subject, int nums )
{
   return IconRepository::getIcon("cancel.png");
};

ASCString Cancel::getName( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   return "~c~ancel";
};



bool Movement::checkForKey( const SDL_KeyboardEvent* key, int modifier, int num )
{
   return ( key->keysym.sym == SDLK_SPACE );
};

Surface& Movement::getImage( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   return IconRepository::getIcon("movement.png");
};

ASCString Movement::getName( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   return "move unit (~space~)";
};


bool Movement::available( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if (moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_nothing ) {
      Vehicle* eht = actmap->getField(pos)->vehicle;
      if ( eht )
         if ( eht->color == actmap->actplayer * 8)
            return VehicleMovement::avail ( eht );
   } else
      if ( pendingVehicleActions.actionType == vat_move ) {
         switch ( pendingVehicleActions.move->getStatus() ) {
            case 2:
               return pendingVehicleActions.move->reachableFields.isMember ( pos.x, pos.y );
            case 3:
               return pendingVehicleActions.move->path.rbegin()->x == pos.x && pendingVehicleActions.move->path.rbegin()->y == pos.y;
         } /* endswitch */
      }

   return false;
}

void Movement::execute( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if ( moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_nothing ) {
      new VehicleMovement ( &getDefaultMapDisplay(), &pendingVehicleActions );

      int mode = 0;
      if (  skeypress( ct_lshift ) ||  skeypress ( ct_rshift ))
         mode |= VehicleMovement::DisableHeightChange;

      int res = pendingVehicleActions.move->execute ( actmap->getField(pos)->vehicle, -1, -1, 0, -1, mode );
      if ( res < 0 ) {
         dispmessage2 ( -res, NULL );
         delete pendingVehicleActions.action;
         return;
      }
      for ( int i = 0; i < pendingVehicleActions.move->reachableFields.getFieldNum(); i++ )
         pendingVehicleActions.move->reachableFields.getField( i ) ->a.temp = 1;

      // if ( !CGameOptions::Instance()->dontMarkFieldsNotAccessible_movement )
      for ( int j = 0; j < pendingVehicleActions.move->reachableFieldsIndirect.getFieldNum(); j++ )
         pendingVehicleActions.move->reachableFieldsIndirect.getField( j ) ->a.temp2 = 2;
      displaymap();
      updateFieldInfo();
   } else {
      if ( !pendingVehicleActions.move )
         return;

      int ms = pendingVehicleActions.move->getStatus();
      if ( moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_move &&  (ms == 2 || ms == 3 )) {
         int res;
         res = pendingVehicleActions.move->execute ( NULL, pos.x, pos.y, pendingVehicleActions.move->getStatus(), -1, 0 );
         if ( res >= 0 && CGameOptions::Instance()->fastmove && ms == 2 ) {
            actmap->cleartemps(7);
            displaymap();
            MapDisplayPG::CursorHiding ch;
            res = pendingVehicleActions.move->execute ( NULL, pos.x, pos.y, pendingVehicleActions.move->getStatus(), -1, 0 );
         } else {
            if ( ms == 2 ) {
               actmap->cleartemps(7);
               for ( int i = 0; i < pendingVehicleActions.move->path.size(); i++ )
                  actmap->getField( pendingVehicleActions.move->path[i]) ->a.temp = 1;
               displaymap();
            } else {
               actmap->cleartemps(7);
               displaymap();
            }
         }


         if ( res < 0 ) {
            dispmessage2 ( -res, NULL );
            delete pendingVehicleActions.action;
            return;
         }

         if ( pendingVehicleActions.move->getStatus() == 1000 ) {
            delete pendingVehicleActions.move;
/*
            if ( CGameOptions::Instance()->smallguiiconopenaftermove ) {
               actgui->painticons();
               actgui->paintsmallicons ( CGameOptions::Instance()->mouse.smallguibutton, 0 );
            }
            */
         }
         updateFieldInfo();

      }
   }
}








class Ascend : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
      void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
      bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num )
      {
         return ( key->keysym.unicode == 's' );
      };
      Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return IconRepository::getIcon("ascend-airplane.png");
      };
      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "a~s~cend";
      };
};

bool Ascend::available( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if ( moveparams.movestatus == 0 && !pendingVehicleActions.action ) {
      Vehicle* eht = actmap->getField(pos)->vehicle;
      if ( !eht )
         return false;
      if (eht->color == actmap->actplayer * 8)
         return IncreaseVehicleHeight::avail ( eht );
   } else
      if ( pendingVehicleActions.actionType == vat_ascent ) {
         switch ( pendingVehicleActions.ascent->getStatus() ) {
           case 2: return pendingVehicleActions.ascent->reachableFields.isMember ( pos.x, pos.y );
           case 3: return pendingVehicleActions.ascent->path.rbegin()->x == pos.x && pendingVehicleActions.ascent->path.rbegin()->y == pos.y;
         } /* endswitch */
      }
   return false;
}

void Ascend::execute( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if ( moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_nothing ) {
      new IncreaseVehicleHeight ( &getDefaultMapDisplay(), &pendingVehicleActions );

      bool simpleMode = false;
      if (  skeypress( ct_lshift ) ||  skeypress ( ct_rshift ))
         simpleMode = true;

      int res = pendingVehicleActions.ascent->execute ( actmap->getField(pos)->vehicle, -1, -1, 0, actmap->getField(pos)->vehicle->height << 1, simpleMode );
      if ( res < 0 ) {
         dispmessage2 ( -res, NULL );
         delete pendingVehicleActions.action;
         return;
      }

      if ( res == 1000 )
         delete pendingVehicleActions.action;
      else {
         for ( int i = 0; i < pendingVehicleActions.ascent->reachableFields.getFieldNum(); i++ )
            pendingVehicleActions.ascent->reachableFields.getField( i ) ->a.temp = 1;
         displaymap();
      }

   } else
     if ( moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_ascent &&  (pendingVehicleActions.ascent->getStatus() == 2 || pendingVehicleActions.ascent->getStatus() == 3 )) {
        int xdst = pos.x;
        int ydst = pos.y;
        int res = pendingVehicleActions.ascent->execute ( NULL, xdst, ydst, pendingVehicleActions.ascent->getStatus(), -1, 0 );
        if ( res >= 0 && CGameOptions::Instance()->fastmove ) {
           actmap->cleartemps(7);
           displaymap();
           // if the status is 1000 at this position, the unit has been shot down by reactionfire before initiating the height change
           if ( res < 1000 )
              res = pendingVehicleActions.ascent->execute ( NULL, xdst, ydst, pendingVehicleActions.ascent->getStatus(), -1, 0 );
        } else {
           actmap->cleartemps(7);
           if ( res < 1000 )
              for ( int i = 0; i < pendingVehicleActions.ascent->path.size(); i++ )
                 actmap->getField( pendingVehicleActions.ascent->path[i]) ->a.temp = 1;
           displaymap();
        }

        if ( res < 0 ) {
           dispmessage2 ( -res, NULL );
           delete pendingVehicleActions.action;
           updateFieldInfo();
           return;
        }

        if ( pendingVehicleActions.ascent->getStatus() == 1000 ) {
           delete pendingVehicleActions.ascent;

        }
     }

   updateFieldInfo();
}





class Descend : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
      void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
      bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num )
      {
         return ( key->keysym.unicode == 'd' );
      };
      Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return IconRepository::getIcon("descent-airplane.png");
      };
      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "~d~escend";
      };
};

bool Descend::available( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if ( moveparams.movestatus == 0 && !pendingVehicleActions.action ) {
      Vehicle* eht = actmap->getField(pos)->vehicle;
      if ( !eht )
         return false;

      if (eht->color == actmap->actplayer * 8)
         return DecreaseVehicleHeight::avail ( eht );
   } else
      if ( pendingVehicleActions.actionType == vat_descent ) {
         switch ( pendingVehicleActions.descent->getStatus() ) {
           case 2: return pendingVehicleActions.descent->reachableFields.isMember ( pos.x, pos.y );
           case 3: return pendingVehicleActions.descent->path.rbegin()->x == pos.x && pendingVehicleActions.descent->path.rbegin()->y == pos.y;
         } /* endswitch */
      }
   return false;
}

void Descend::execute( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if ( moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_nothing ) {
      new DecreaseVehicleHeight ( &getDefaultMapDisplay(), &pendingVehicleActions );


      bool simpleMode = false;
      if (  skeypress( ct_lshift ) ||  skeypress ( ct_rshift ))
         simpleMode = true;

      int res = pendingVehicleActions.descent->execute ( actmap->getField(pos)->vehicle, -1, -1, 0, actmap->getField(pos)->vehicle->height >> 1, simpleMode );
      if ( res < 0 ) {
         dispmessage2 ( -res, NULL );
         delete pendingVehicleActions.action;
         return;
      }

      if ( res == 1000 )
         delete pendingVehicleActions.action;
      else {
         for ( int i = 0; i < pendingVehicleActions.descent->reachableFields.getFieldNum(); i++ )
            pendingVehicleActions.descent->reachableFields.getField( i ) ->a.temp = 1;
         displaymap();
      }

   } else
     if ( moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_descent &&  (pendingVehicleActions.descent->getStatus() == 2 || pendingVehicleActions.descent->getStatus() == 3 )) {
        int res = pendingVehicleActions.descent->execute ( NULL, pos.x, pos.y, pendingVehicleActions.descent->getStatus(), -1, 0 );
        if ( res >= 0 && CGameOptions::Instance()->fastmove ) {
           actmap->cleartemps(7);
           displaymap();
           // if the status is 1000 at this position, the unit has been shot down by reactionfire before initiating the height change
           if ( res < 1000 )
              res = pendingVehicleActions.descent->execute ( NULL, pos.x, pos.y, pendingVehicleActions.descent->getStatus(), -1, 0 );
        } else {
           actmap->cleartemps(7);
           if ( res < 1000 )
              for ( int i = 0; i < pendingVehicleActions.descent->path.size(); i++ )
                 actmap->getField( pendingVehicleActions.descent->path[i]) ->a.temp = 1;
           displaymap();
        }


        if ( res < 0 ) {
           dispmessage2 ( -res, NULL );
           delete pendingVehicleActions.action;
           updateFieldInfo();
           return;
        }

        if ( pendingVehicleActions.descent->getStatus() == 1000 ) {
           delete pendingVehicleActions.descent;

/*           if ( CGameOptions::Instance()->smallguiiconopenaftermove ) {
              actgui->painticons();
              actgui->paintsmallicons ( CGameOptions::Instance()->mouse.smallguibutton, 0 );
           }
           */
        }
     }
   updateFieldInfo();
}









class EndTurn : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num ) ;
      void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
      bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num )
      {
         return ( key->keysym.unicode == 'e' );
      };
      Surface& getImage( const MapCoordinate& po, ContainerBase* subject, int nums )
      {
         return IconRepository::getIcon("endturn.png");
      };
      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "~e~nd turn";
      };
};

bool EndTurn::available( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if (moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_nothing)
      if (actmap->levelfinished == false)
         return true;
   return false;
}


void EndTurn::execute( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if ( !CGameOptions::Instance()->endturnquestion || (choice_dlg("do you really want to end your turn ?","~y~es","~n~o") == 1)) {

      static int autosave = 0;
      ASCString name = ASCString("autosave") + strrr( autosave ) + &savegameextension[1];

      savegame ( name );

      autosave = !autosave;

      actmap->sigPlayerUserInteractionEnds( actmap->player[actmap->actplayer] );

      next_turn();

      displaymap();
   }
}


class Attack : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num ) ;
      void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
      bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num )
      {
         return ( key->keysym.unicode == 'a' );
      };
      Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return IconRepository::getIcon("attack.png");
      };
      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "~a~ttack";
      };
};


bool Attack::available( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if (moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_nothing ) {
      Vehicle* eht = actmap->getField(pos)->vehicle;
      if ( eht )
         if ( eht->color == actmap->actplayer * 8)
            return VehicleAttack::avail ( eht );
   }
   return false;
}

void Attack::execute(  const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if ( moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_nothing ) {
      new VehicleAttack ( &getDefaultMapDisplay(), &pendingVehicleActions );

      int res;
      res = pendingVehicleActions.attack->execute ( actmap->getField(pos)->vehicle, -1, -1, 0, 0, -1 );
      if ( res < 0 ) {
         dispmessage2 ( -res, NULL );
         delete pendingVehicleActions.action;
         return;
      }

      int i;
      for ( i = 0; i < pendingVehicleActions.attack->attackableVehicles.getFieldNum(); i++ )
         pendingVehicleActions.attack->attackableVehicles.getField( i ) ->a.temp = 1;
      for ( i = 0; i < pendingVehicleActions.attack->attackableBuildings.getFieldNum(); i++ )
         pendingVehicleActions.attack->attackableBuildings.getField( i ) ->a.temp = 1;
      for ( i = 0; i < pendingVehicleActions.attack->attackableObjects.getFieldNum(); i++ )
         pendingVehicleActions.attack->attackableObjects.getField( i ) ->a.temp = 1;

      displaymap();
      attackGui.setupWeapons( pendingVehicleActions.attack );
      NewGuiHost::pushIconHandler( &attackGui );
   }
}





class PowerOn : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         if (moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_nothing )  {
            tfield* fld = actmap->getField ( pos );
            if ( fld->vehicle )
               if ( fld->vehicle->color == actmap->actplayer*8  &&
                     ( fld->vehicle->typ->hasFunction( ContainerBaseType::MatterConverter  )))
                  if ( !fld->vehicle->getGeneratorStatus() )
                     return true;

         }
         return false;
      };

      bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num )
      {
         return ( key->keysym.unicode == 'p' );
      };
      void execute( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         Vehicle* veh = actmap->getField(pos)->vehicle;
         veh->setGeneratorStatus ( true );
         logtoreplayinfo ( rpl_setGeneratorStatus, veh->networkid, int(1) );
         updateFieldInfo();
      }

      Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return IconRepository::getIcon("poweron.png");
      };

      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "enable ~p~ower generation";
      };
};


class PowerOff : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         if (moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_nothing )  {
            tfield* fld = actmap->getField ( pos );
            if ( fld->vehicle )
               if ( fld->vehicle->color == actmap->actplayer*8  &&
                    ( fld->vehicle->typ->hasFunction( ContainerBaseType::MatterConverter)))
                  if ( fld->vehicle->getGeneratorStatus() )
                     return true;

         }
         return false;
      };
      
      bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num )
      {
         return ( key->keysym.unicode == 'p' );
      };
      void execute( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         Vehicle* veh = actmap->getField(pos)->vehicle;
         veh->setGeneratorStatus ( false );
         logtoreplayinfo ( rpl_setGeneratorStatus, veh->networkid, int(0) );
         updateFieldInfo();
      }

      Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return IconRepository::getIcon("poweroff.png");
      };

      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "disable ~p~ower generation";
      };
};



class UnitInfo : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num ) ;
      void execute( const MapCoordinate& pos, ContainerBase* subject, int num ) { execUserAction_ev(ua_vehicleinfo);};
      Surface& getImage( const MapCoordinate& po, ContainerBase* subject, int nums )
      {
         return IconRepository::getIcon("unitinfo.png");
      };
      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "unit ~i~nfo";
      };
      bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num )
      {
         return ( key->keysym.unicode == 'i' );
      };
};

bool UnitInfo::available( const MapCoordinate& pos, ContainerBase* subject, int num )
{
   tfield* fld = actmap->getField(pos);
   if ( fld && fld->vehicle )
      if (moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_nothing)
         if ( fld->vehicle != NULL)
            if (fieldvisiblenow( fld ))
               return true;
   return false;
}






class DestructBuilding : public GuiFunction
{
      bool cancel;
   public:
      DestructBuilding() : cancel(false) {};

      bool available( const MapCoordinate& pos, ContainerBase* subject, int num ) ;
      bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num )
      {
         if ( key->keysym.sym == SDLK_ESCAPE ) {
            cancel = true;
            return true;
         } else return false;
      };
      void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
      Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return IconRepository::getIcon("destructbuilding.png");
      };
      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "destruct building";
      };
};


bool DestructBuilding::available( const MapCoordinate& pos, ContainerBase* subject, int num )
{
    if ( cancel )
       return true;

    tfield* fld = actmap->getField(pos);
    if (moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_nothing) {
       if ( fld->vehicle )
          if ( fld->vehicle->attacked == false && !fld->vehicle->hasMoved() )
             if (fld->vehicle->color == actmap->actplayer * 8)
                if ( fld->vehicle->typ->hasFunction( ContainerBaseType::ConstructBuildings  ) || !fld->vehicle->typ->buildingsBuildable.empty() )
                  if ( fld->vehicle->getTank().fuel >= destruct_building_fuel_usage * fld->vehicle->typ->fuelConsumption )
                     return true;
    }
    else
       if (moveparams.movestatus == 115) {
          if (fld->a.temp == 20)
             return true;
       }

    return false;
}

void DestructBuilding::execute(  const MapCoordinate& pos, ContainerBase* subject, int num )
{
   if( cancel ) {
      actmap->cleartemps(7);
      moveparams.movestatus = 0;
      cancel = false;
      updateFieldInfo();
      return;
   }

   if (moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_nothing) {
      destructbuildinglevel1( pos.x, pos.y );
      displaymap();
      updateFieldInfo();
   }
   else
      if (moveparams.movestatus == 115) {
         destructbuildinglevel2( pos.x, pos.y );
         updateFieldInfo();
         displaymap();
      }
}


/*
class SearchForMineralResources : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         tfield* fld = actmap->getField(pos);
         if (fld->vehicle != NULL)
            if (fld->vehicle->color == actmap->actplayer * 8)
               if ( (fld->vehicle->typ->functions &  cfmanualdigger) && !(fld->vehicle->typ->functions &  cfautodigger) )
                  if (moveparams.movestatus == 0 && pendingVehicleActions.actionType == vat_nothing)
                     if ( actmap->_resourcemode == 0 ) 
                        return fld->vehicle->searchForMineralResourcesAvailable();
         return false;
      };

      void execute( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
          actmap->getField(pos)->vehicle->searchForMineralResources( ) ;

          MapDisplayPG* mapDisplay = dynamic_cast<MapDisplayPG*>( ASC_PG_App::GetWidgetById( ASC_PG_App::mapDisplayID ));
          if ( mapDisplay )
             mapDisplay->activateMapLayer("resources", true);
          
          updateFieldInfo();
          repaintMap();
      }

      Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return IconRepository::getIcon("dig.png");
      };

      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "search for mineral resources";
      };
};
*/

class OpenContainer : public GuiFunction
{
     static int containeractive;
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
        tfield* fld = actmap->getField(pos);
        if ( fieldvisiblenow ( fld ) && fld->getContainer() ) {
           if ( !containeractive && !moveparams.movestatus && pendingVehicleActions.actionType == vat_nothing && !pendingVehicleActions.action ) {
              Player& player = fld->getContainer()->getMap()->player[fld->getContainer()->getOwner()];
              if ( fld->building && ( player.diplomacy.isAllied( actmap->actplayer) || actmap->getNeutralPlayerNum() == fld->building->getOwner() )) {
                 if ( fld->building->getCompletion() == fld->building->typ->construction_steps-1 )
                    return true;
              }  else {
                  if ( fld->vehicle && fld->vehicle->typ->maxLoadableUnits  &&  player.diplomacy.isAllied( actmap->actplayer)  )
                    return true;
              }
           }
        }
        return false;
      };

      void execute( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
          tfield* fld = actmap->getField(pos);
          
          cargoDialog( fld->getContainer() );
          
          updateFieldInfo();
          repaintMap();
      }

      Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return IconRepository::getIcon("container.png");
      };

      bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num )
      {
         return ( key->keysym.unicode == 'l' );
      };
      
      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "view ~l~oaded units";
      };
};

int OpenContainer::containeractive = 0;




class EnableReactionfire : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         Vehicle* eht = actmap->getField(pos)->vehicle;
         if ( eht ) 
            if ( eht->color == actmap->actplayer * 8)
               if ( !eht->baseType->hasFunction(ContainerBaseType::NoReactionfire ))
                  if ( eht->reactionfire.getStatus() == Vehicle::ReactionFire::off )
                     if ( moveparams.movestatus == 0  && pendingVehicleActions.actionType == vat_nothing)
                        if ( eht->weapexist() )
                           for ( int i = 0; i < eht->typ->weapons.count; ++i )
                              if ( eht->typ->weapons.weapon[i].offensive() && eht->typ->weapons.weapon[i].reactionFireShots )
                                 return true;

         return false;
      };
      bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num )
      {
         return ( key->keysym.unicode == 'x' );
      };

      void execute( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         int res = actmap->getField(pos)->vehicle->reactionfire.enable();
         if ( res < 0 )
            dispmessage2 ( -res, NULL );
         else
            logtoreplayinfo ( rpl_reactionFireOn, actmap->getField(pos)->vehicle->networkid );
         updateFieldInfo();
      }

      Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return IconRepository::getIcon("enable-reactionfire.png");
      };

      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "enable reaction fire (~x~)";
      };
};

class DisableReactionfire : public GuiFunction
{
   public:
      bool