mapdisplay.cpp

Go to the documentation of this file.

/***************************************************************************
                          mapdisplay.cpp  -  description
                             -------------------
    begin                : Wed Jan 24 2001
    copyright            : (C) 2001 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.                                   *
 *                                                                         *
 ***************************************************************************/

// #define debugmapdisplay


#include <cmath>
#include <limits>

#include "pgeventsupplier.h"

#include "global.h"
#include "typen.h"
#include "mapdisplay.h"
#include "vehicletype.h"
#include "buildingtype.h"
#include "spfst.h"
#include "dialog.h"
#include "loaders.h"
#include "gameoptions.h"
#include "loadbi3.h"
#include "mapalgorithms.h"
#include "graphicset.h"
#include "graphics/blitter.h"
#include "graphics/drawing.h"
#include "loadpcx.h"
#include "iconrepository.h"
#include "mainscreenwidget.h"
#include "sdl/sound.h"

#ifndef karteneditor
 #include "dialogs/attackpanel.h"
#endif


#ifdef debugmapdisplay
#include <iostream>
#endif


MapRenderer::Icons MapRenderer::icons;

bool tempsvisible = true;


SigC::Signal0<void> lockMapdisplay;
SigC::Signal0<void> unlockMapdisplay;


class ContainerInfoLayer : public MapLayer {
      Surface& marker;
      bool hasCargo( const ContainerBase* c ) {
         for ( ContainerBase::Cargo::const_iterator i = c->getCargo().begin(); i != c->getCargo().end(); ++i )
            if ( *i )
               return true;
         return false;
      };
      
      bool hasOwnCargo( const ContainerBase* c, int viewingPlayer ) {
         for ( ContainerBase::Cargo::const_iterator i = c->getCargo().begin(); i != c->getCargo().end(); ++i )
            if ( *i ) {
               if ( (*i)->getOwner() == viewingPlayer )
                  return true;
               else
                  if ( hasOwnCargo( *i, viewingPlayer ))
                     return true;
            }
         return false;
      };
    public: 
      ContainerInfoLayer() : marker( IconRepository::getIcon("fieldcontainermarker.png") ) {};
         
      bool onLayer( int layer ) { return layer == 17; };
      void paintSingleField( const MapRenderer::FieldRenderInfo& fieldInfo,  int layer, const SPoint& pos );
};

void ContainerInfoLayer::paintSingleField( const MapRenderer::FieldRenderInfo& fieldInfo,  int layer, const SPoint& pos )
{
   if ( fieldInfo.visibility >= visible_ago) {
      if ( fieldInfo.fld->vehicle || (fieldInfo.fld->building && fieldInfo.fld->bdt.test(cbbuildingentry) )) {
         ContainerBase* c = fieldInfo.fld->getContainer();
         if ( hasCargo(c) ) {
            if ( c->getOwner() == fieldInfo.playerView  ) 
               fieldInfo.surface.Blit( marker, pos );
            else
               if ( hasOwnCargo(c, fieldInfo.playerView  ))
                  fieldInfo.surface.Blit( marker, pos );
         }
      }
   }
}


 
class ResourceGraphLayer : public MapLayer {
      void paintBar( const MapRenderer::FieldRenderInfo& fieldInfo, const SPoint& pos, int row, int amount, int color ) {
         /*
         int length = amount / 10;
         int maxlength = 255/10;
         if ( amount ) 
            paintFilledRectangle<4>( fieldInfo.surface, SPoint( pos.x + 10, pos.y + 2 + row*12), length, 5, ColorMerger_ColoredOverwrite<4>( color ));
         if ( length < maxlength )
            paintFilledRectangle<4>( fieldInfo.surface, SPoint( pos.x + 10 + length, pos.y + 2 + row*12), maxlength-length, 5, ColorMerger_ColoredOverwrite<4>( 0x888888 ));
         */

         int length = amount * 28 / 255;
         int maxlength = 28;
         if ( amount ) 
            paintFilledRectangle<4>( fieldInfo.surface, SPoint( pos.x + 10, pos.y + 12 + row*15), length, 8, ColorMerger_ColoredOverwrite<4>( color ));
         if ( length < maxlength )
            paintFilledRectangle<4>( fieldInfo.surface, SPoint( pos.x + 10 + length, pos.y + 12 + row*15), maxlength-length, 8, ColorMerger_ColoredOverwrite<4>( 0 ));
           
      };
    public: 
      bool onLayer( int layer ) { return layer == 17; };
      void paintSingleField( const MapRenderer::FieldRenderInfo& fieldInfo,  int layer, const SPoint& pos );
};

void ResourceGraphLayer::paintSingleField( const MapRenderer::FieldRenderInfo& fieldInfo,  int layer, const SPoint& pos )
{
#ifndef karteneditor
   if ( fieldInfo.visibility >= visible_ago) {
      bool visible = false;

      if ( fieldInfo.playerView == -1 )
         visible = true;

      if ( fieldInfo.playerView >= 0 )
         if ( fieldInfo.fld->resourceview && (fieldInfo.fld->resourceview->visible & ( 1 << fieldInfo.playerView) ) )
            visible = true;

      if ( visible ) {
         if ( fieldInfo.playerView>=0 && fieldInfo.gamemap->getPlayer(fieldInfo.playerView).stat == Player::supervisor ) {
            paintBar( fieldInfo, pos, 0, fieldInfo.fld->material, Resources::materialColor );
            paintBar( fieldInfo, pos, 1, fieldInfo.fld->fuel,     Resources::fuelColor );
         } else {
            paintBar( fieldInfo, pos, 0, fieldInfo.fld->resourceview->materialvisible[max(fieldInfo.playerView,0)], Resources::materialColor );
            paintBar( fieldInfo, pos, 1, fieldInfo.fld->resourceview->fuelvisible[max(fieldInfo.playerView,0)], Resources::fuelColor );
         }
      }
   }
#else
   paintBar( fieldInfo, pos, 0, fieldInfo.fld->material, Resources::materialColor );
   paintBar( fieldInfo, pos, 1, fieldInfo.fld->fuel, Resources::fuelColor );
#endif
}




class PipeLayer : public MapLayer {
      ObjectType* buried_pipeline;
      ObjectType* pipeline;
      bool isPipe( const ContainerBase* c ) {
         for ( ContainerBase::Cargo::const_iterator i = c->getCargo().begin(); i != c->getCargo().end(); ++i )
            if ( *i )
               return true;
         return false;
      };

      bool isObjectPipeline( const ObjectType* obj )
      {
         if ( !obj )
            return false;
         return (obj->displayMethod <= 1 ) && obj->fieldModification[0].terrain_or.test( cbpipeline );
      }

    public: 
      PipeLayer() : buried_pipeline( NULL ), pipeline ( NULL )
      {
         pipeline = objectTypeRepository.getObject_byID( 3 );
         if ( !isObjectPipeline( pipeline )) 
            pipeline = NULL;

         for ( int i = 0; i < objectTypeRepository.getNum(); ++i ) {
            ObjectType* obj = objectTypeRepository.getObject_byPos( i );
            if (obj->displayMethod == 1 && obj->fieldModification[0].terrain_or.test( cbpipeline )) {
               buried_pipeline = obj;
            }
            if (obj->displayMethod == 0 && obj->fieldModification[0].terrain_or.test( cbpipeline ) && !pipeline) {
               pipeline = obj;
            }
         }
      }
    
      bool onLayer( int layer ) { return layer == 17; };
      void paintSingleField( const MapRenderer::FieldRenderInfo& fieldInfo,  int layer, const SPoint& pos );
};

void PipeLayer::paintSingleField( const MapRenderer::FieldRenderInfo& fieldInfo,  int layer, const SPoint& pos )
{
   if ( !pipeline )
      return;
      
   if ( fieldInfo.visibility > visible_ago) {
      if ( fieldInfo.fld->building ) {
         pipeline->display( fieldInfo.surface, pos, 63, 0 );
      } else {
         if ( fieldInfo.fld->bdt.test( cbpipeline )) {
            Object* o = fieldInfo.fld->checkforobject( buried_pipeline );
            if ( o )
               pipeline->display( fieldInfo.surface, pos, o->dir, 0 );
            else {
               bool objfound = false;
               for ( tfield::ObjectContainer::iterator i = fieldInfo.fld->objects.begin(); i != fieldInfo.fld->objects.end(); ++i )
                  if ( i->typ->fieldModification[0].terrain_or.test( cbpipeline ) ) {
                     pipeline->display( fieldInfo.surface, pos, i->dir, 0 );
                     objfound = true;
                     break;
                  }   

               if ( !objfound )
                  pipeline->display( fieldInfo.surface, pos, 63, 0 );
                     
            }
         }
      }   
   }
}


class WeaponRange : public SearchFields
{
   public:
      int run ( const Vehicle* veh );
      void testfield ( const MapCoordinate& mc )
      {
         gamemap->getField( mc )->tempw = 1;
      };
      WeaponRange ( GameMap* _gamemap ) : SearchFields ( _gamemap )
      {}
      ;
};

int  WeaponRange :: run ( const Vehicle* veh )
{
   int found = 0;
   if ( fieldvisiblenow ( getfield ( veh->xpos, veh->ypos )))
      for ( int i = 0; i < veh->typ->weapons.count; i++ ) {
         if ( veh->typ->weapons.weapon[i].shootable() ) {
            initsearch ( veh->getPosition(), veh->typ->weapons.weapon[i].maxdistance/minmalq, (veh->typ->weapons.weapon[i].mindistance+maxmalq-1)/maxmalq );
            startsearch();
            found++;
         }
      }
   return found;
}


 


MapRenderer::ViewPort::ViewPort( int x1, int y1, int x2, int y2 ) 
{ 
   this->x1 = x1; 
   this->y1 = y1; 
   this->x2 = x2; 
   this->y2 = y2; 
};

MapRenderer::ViewPort::ViewPort()
{
};

MapRenderer :: MapRenderer()  
{ 
   readData(); 
};


void MapRenderer::readData()
{
   if ( !icons.mapBackground.valid() ) {
      icons.mapBackground = IconRepository::getIcon("mapbkgr.raw");
      icons.notVisible    = IconRepository::getIcon("hexinvis.raw");
      icons.markField     = IconRepository::getIcon("markedfield.pcx");
      icons.markField.detectColorKey();
      icons.markFieldDark = IconRepository::getIcon("markedfielddark.png");
   }
}


/*
  layer:
    0: terrain
    1: below everything objects
    2: deep submerged units and building
    3: deep submerged objects
    4: submerged units and buildings
    5: submerged objects
    6: floating  units and buildings
    7: floating  objects
    8: ground    units and buildings
    9: ground    objects
   10: low flying units and buildings
   11: low flying objects
   12: flying units and buildings
   13: flying objects
   14: high flying units and buildings
   15: high flying objects
   16: orbiting units
   17: orbiting objects
   18  view obstructions
*/

int MapRenderer::bitmappedHeight2pass( int height )
{
   return log2(height) * 2 + 2;
}


void MapRenderer::paintSingleField( const MapRenderer::FieldRenderInfo& fieldInfo,  int layer, const SPoint& pos )
{

   int binaryUnitHeight = 0;
   if ( layer > 1 ) 
      if ( !(layer & 1 ))
         binaryUnitHeight = 1 << (( layer-2)/2);
   
   tfield* fld = fieldInfo.fld;

   if ( layer == 0 && fieldInfo.visibility >= visible_ago )
      fld->typ->paint ( fieldInfo.surface, pos );


   if ( fieldInfo.visibility > visible_ago ) {

      /* display buildings */
      if ( fld->building  &&  (fld->building->typ->buildingheight & binaryUnitHeight) && fld->building->visible )
         if ((fieldInfo.visibility == visible_all) || (fld->building->typ->buildingheight >= chschwimmend) || ( fld->building->getOwner() == fieldInfo.playerView ))
            fld->building->paintSingleField( fieldInfo.surface, pos, fld->building->getLocalCoordinate( fieldInfo.pos ));


      /* display units */
      if ( fld->vehicle  &&  (fld->vehicle->height == binaryUnitHeight))
         if ( ( fld->vehicle->getOwner() == fieldInfo.playerView ) || (fieldInfo.visibility == visible_all) || ((fld->vehicle->height >= chschwimmend) && (fld->vehicle->height <= chhochfliegend)))
            fld->vehicle->paint( fieldInfo.surface, pos );

   }

   // display objects
   if ( layer & 1 )
      for ( tfield::ObjectContainer::iterator o = fld->objects.begin(); o != fld->objects.end(); o++ ) {
         int h = o->typ->imageHeight;
         if ( fieldInfo.visibility > visible_ago || (o->typ->visibleago && fieldInfo.visibility >= visible_ago ))
            if (  h >= ((layer-1)/2)*30 && h < (layer-1)/2*30+30 )
               o->display ( fieldInfo.surface, pos, fld->getweather() );
      }




   if ( fieldInfo.visibility > visible_ago ) {
      /* display mines */
      
      if ( fieldInfo.visibility == visible_all )
         if ( !fld->mines.empty() && layer == 7 ) 
            fld->mines.begin()->paint( fieldInfo.surface, pos );
     


      /* display marked fields */

      if ( layer == 18 ) {
         if ( fld->a.temp && tempsvisible )
            fieldInfo.surface.Blit( icons.markField, pos );
         else
            if ( fld->a.temp2 && tempsvisible )
               fieldInfo.surface.Blit( icons.markFieldDark, pos );
      }


   } else {
      if (fieldInfo.visibility == visible_ago ) {
         if ( fld->building  &&  (fld->building->typ->buildingheight & binaryUnitHeight) && fld->building->visible )
            if ((fieldInfo.visibility == visible_all) || (fld->building->typ->buildingheight >= chschwimmend) || ( fld->building->getOwner() == fieldInfo.playerView ))
               fld->building->paintSingleField( fieldInfo.surface, pos, fld->building->getLocalCoordinate( fieldInfo.pos ));

      }
   }


   // display view obstructions
   if ( layer == 18 ) {
      if ( fieldInfo.visibility == visible_ago) {
         MegaBlitter<1,colorDepth,ColorTransform_None,ColorMerger_AlphaShadow> blitter;
         // PG_Point pnt = ClientToScreen( 0,0 );
         blitter.blit( icons.notVisible, fieldInfo.surface, pos);
         /*
                         // putspriteimage( r + unitrightshift , yp + unitdownshift , view.va8);
                         putshadow( r, yp, icons.view.nv8, &xlattables.a.dark2 );
                         if ( fld->a.temp && tempsvisible )
                            putspriteimage(  r, yp, cursor.markfield);
                         else
                            if ( fld->a.temp2 && tempsvisible )
                               putspriteimage(  r, yp, xlatpict ( &xlattables.a.dark2 , cursor.markfield));
          
         */
      } else
         if ( fieldInfo.visibility == visible_not) {
            fieldInfo.surface.Blit( icons.notVisible, pos );
            /*
                            if ( ( fld->a.temp || fld->a.temp2 ) && tempsvisible )
                                  putspriteimage(  r, yp, cursor.markfield);
            */

         }

   }
   
   for ( LayerRenderer::iterator i = layerRenderer.begin(); i != layerRenderer.end(); ++i )
      if ( (*i)->isActive() && (*i)->onLayer(layer))
         (*i)->paintSingleField( fieldInfo , layer, pos );

}


void MapRenderer::paintBackground( Surface& surf, const ViewPort& viewPort )
{
   for (int y= viewPort.y1; y < viewPort.y2; ++y )
      for ( int x=viewPort.x1; x < viewPort.x2; ++x ) 
         paintBackgroundField( surf, getFieldPos(x,y) );
}

void MapRenderer::paintBackgroundField( Surface& surf, SPoint pos )
{
   surf.Blit( icons.mapBackground, pos );
}



void MapRenderer::paintTerrain( Surface& surf, GameMap* actmap, int playerView, const ViewPort& viewPort, const MapCoordinate& offset )
{
   FieldRenderInfo fieldRenderInfo( surf, actmap );
   fieldRenderInfo.playerView = playerView;

   GraphicSetManager::Instance().setActive ( actmap->graphicset );

   for (int pass = 0; pass <= 18 ;pass++ ) {
      for (int y= viewPort.y1; y < viewPort.y2; ++y )
         for ( int x=viewPort.x1; x < viewPort.x2; ++x ) {
            fieldRenderInfo.pos = MapCoordinate( offset.x + x, offset.y + y ); 
            fieldRenderInfo.fld = actmap->getField ( fieldRenderInfo.pos );
            SPoint pos = getFieldPos(x,y);
            if ( fieldRenderInfo.fld ) {
               fieldRenderInfo.visibility = fieldVisibility ( fieldRenderInfo.fld, playerView );
               paintSingleField( fieldRenderInfo, pass, pos );
            } else
               if ( pass == 0 )
                  paintBackgroundField( surf, pos );

         }
      additionalItemDisplayHook( surf, pass );
   }
   
}



void benchMapDisplay()
{/*
   int t = ticker;
   for ( int i = 0; i < 20; ++i )
      repaintMap();

   int t2 = ticker;
   
   for ( int i = 0; i< 20; ++i)
      theGlobalMapDisplay->Redraw();
   
   int t3 = ticker;

   ASCString s;
   s.format("update map: %d \nupdate widget: %d \n%f fps", t2-t,t3-t2, 20.0 / float(t3-t) * 100 );
   displaymessage(s, 1 );
   */
}


MapDisplayPG* MapDisplayPG::theMapDisplay = NULL;
MapDisplayPG* theGlobalMapDisplay = NULL;

MapDisplayPG::MapDisplayPG ( MainScreenWidget *parent, const PG_Rect r )
      : PG_Widget ( parent, r, false ) ,
      zoom(-1),
      surface(NULL),
      lastDisplayedMap(NULL),
      offset(0,0),
      dirty(Map),
      additionalUnit(NULL),
      disableKeyboardCursorMovement(false),
      signalPrio(0),
      cursor(this),
      lock(0)
{
   SetDirtyUpdate(true);
   dataLoaderTicker();
   
   readData();
   
   dataLoaderTicker();
   
   setNewZoom( CGameOptions::Instance()->mapzoom );

   repaintMap.connect( SigC::slot( *this, &MapDisplayPG::updateWidget ));

   PG_Application::GetApp()->sigKeyDown.connect( SigC::slot( *this, &MapDisplayPG::keyboardHandler ));

   SetName( "THEMapDisplay");

   dataLoaderTicker();
   SDL_Surface* ws = GetWidgetSurface ();
   if ( ws ) {
      Surface s = Surface::Wrap( ws );
      s.assignDefaultPalette();
   }
   
   MapRenderer::additionalItemDisplayHook.connect( SigC::slot( *this, &MapDisplayPG::displayAddons ));
   
   upperLeftSourceBlitCorner = SPoint( getFieldPosX(0,0), getFieldPosY(0,0));

   theMapDisplay = this;
   theGlobalMapDisplay = this;
   dataLoaderTicker();
   
   addMapLayer( new ResourceGraphLayer(), "resources" );
   addMapLayer( new ContainerInfoLayer(), "container" );
   addMapLayer( new PipeLayer()         , "pipes" );
   
   parent->lockOptionsChanged.connect( SigC::slot( *this, &MapDisplayPG::lockOptionsChanged ));
   GameMap::sigMapDeletion.connect( SigC::slot( *this, &MapDisplayPG::sigMapDeleted ));
}



void MapDisplayPG::lockOptionsChanged( int options )
{
   if ( options & MainScreenWidget::LockOptions::MapControl )  
      EnableReceiver(false);
   else  
      EnableReceiver(true);
}

void MapDisplayPG::sigMapDeleted( GameMap& deletedMap )
{
   if ( &deletedMap == lastDisplayedMap ) { 
      paintBackground();
      Update();
   }
}


MapDisplayPG::~MapDisplayPG ()
{
   if ( surface ) {
      delete surface;
      surface = NULL;
   }
}


MapDisplayPG::Icons MapDisplayPG::icons;


void MapDisplayPG::readData()
{
   if ( !icons.cursor.valid() ) {
      icons.cursor = IconRepository::getIcon( "curshex.raw" );
      icons.fieldShape = IconRepository::getIcon("hexinvis.raw");
   }
}


void MapDisplayPG::setNewZoom( int zoom )
{
   if ( zoom > 100 )
      zoom = 100;
   if ( zoom < 20 )
      zoom = 20;

   if ( zoom == this->zoom )
      return;
   
   this->zoom = zoom;

   field.numx = int( ceil(float(Width()) * 100  / zoom / fielddistx) );
   field.numy = int( ceil(float(Height()) * 100 / zoom / fielddisty) );

   field.viewPort.x1 = -1;
   field.viewPort.y1 = -1;
   field.viewPort.x2 = field.numx + 1;
   field.viewPort.y2 = field.numy + 1;

   if ( field.numy & 1 )
      field.numy += 1;

   delete surface;
   surface = new Surface( Surface::createSurface ( field.numx * fielddistx + 2 * surfaceBorder, (field.numy - 1) * fielddisty + fieldysize +  2 * surfaceBorder, colorDepth*8 ));

   dirty = Map;
   if ( zoom != CGameOptions::Instance()->mapzoom ) {
      CGameOptions::Instance()->mapzoom = zoom;
      CGameOptions::Instance()->setChanged();
   }
   newZoom( zoom );
}


void MapDisplayPG::fillSurface( int playerView )
{
   checkViewPosition( offset );
   if ( !lock ) {
      paintTerrain( *surface, actmap, playerView, field.viewPort, offset );
      lastDisplayedMap = actmap;
   }
   else
      paintBackground();
   dirty = Curs;
}

void MapDisplayPG::paintBackground( )
{
   MapRenderer::paintBackground( *surface, field.viewPort );
   lastDisplayedMap = NULL;
}



void MapDisplayPG::checkViewPosition( MapCoordinate& offset )
{
   if ( offset.x + field.numx >= actmap->xsize +1 )
      offset.x = max(0,actmap->xsize - field.numx +1 );

   if ( offset.y + field.numy >= actmap->ysize +4)
      offset.y = max(0,actmap->ysize - field.numy +4);

   if ( offset.y & 1 )
      offset.y -= 1;

   if ( offset.x < 0 )
      offset.x = 0;

   if ( offset.y < 0 )
      offset.y = 0;
}




template<int pixelSize>
class PixSel : public SourcePixelSelector_CacheZoom<pixelSize, SourcePixelSelector_DirectRectangle<pixelSize> >
{}
;


void MapDisplayPG::updateMap(bool force )
{
   if ( !actmap )
      return;
      
   if ( dirty > Curs || force ) 
      fillSurface( actmap->getPlayerView() );
}

void MapDisplayPG::updateWidget()
{
   updateMap(true);
   Update(true);
}



void MapDisplayPG::blitInternalSurface( SDL_Surface* dest, const SPoint& pnt, const PG_Rect& dstClip )
{
   if ( zoom != 100 ) {
      float fzoom = float(zoom) / 100.0;
      MegaBlitter<colorDepth,colorDepth,ColorTransform_None,ColorMerger_AlphaOverwrite,PixSel,TargetPixelSelector_Rect> blitter;
      blitter.setZoom( fzoom );
      blitter.initSource( *surface );

      // SourcePixelSelector
      blitter.setSrcRectangle( upperLeftSourceBlitCorner, int(float(Width()) / fzoom), int(float(Height()) / fzoom));

      PG_Rect clip= dstClip.IntersectRect( dest->clip_rect );
      blitter.setTargetRect( clip );
      
      Surface s = Surface::Wrap( dest );
      blitter.blit( *surface, s, SPoint(pnt.x, pnt.y ));
   } else {
      MegaBlitter<colorDepth,colorDepth,ColorTransform_None,ColorMerger_AlphaOverwrite,SourcePixelSelector_DirectRectangle,TargetPixelSelector_Rect> blitter;
      blitter.initSource( *surface );
      
      // SourcePixelSelector
      blitter.setSrcRectangle( upperLeftSourceBlitCorner, Width(), Height() );
      
      PG_Rect clip= dstClip.IntersectRect( dest->clip_rect );
      blitter.setTargetRect( clip );
      
      Surface s = Surface::Wrap( dest );
      blitter.blit( *surface, s, SPoint(pnt.x, pnt.y ));
   }   
   
}


void MapDisplayPG::displayCursor()
{
   displayCursor( *this );
}

void MapDisplayPG::displayCursor( const PG_Rect& dst )
{
   if ( !actmap )
      return;

   if ( dst.w <= 0 || dst.h <= 0 )
      return;
      
   int x = cursor.pos().x - offset.x;
   int y = cursor.pos().y  - offset.y;
   if( x >= field.viewPort.x1 && x < field.viewPort.x2 && y >= field.viewPort.y1 && y < field.viewPort.y2 && x >= 0 && y >= 0 && x < actmap->xsize && y < actmap->ysize ) {
      // surface->Blit( icons.cursor, getFieldPos(x,y));
      MegaBlitter<1,colorDepth,ColorTransform_None,ColorMerger_AlphaOverwrite,SourcePixelSelector_DirectZoom,TargetPixelSelector_Rect> blitter;
      blitter.setZoom( float(zoom) / 100.0 );

      PG_Rect clip= dst.IntersectRect( PG_Application::GetScreen()->clip_rect );

      if ( clip.w && clip.h ) {
         blitter.setTargetRect ( clip );
   
         Surface s = Surface::Wrap( PG_Application::GetScreen() );
         SPoint pos = widget2screen ( internal2widget( mapViewPos2internalPos( MapCoordinate(x,y))));
         blitter.blit( icons.cursor, s, pos );
      }
   }
}


void MapDisplayPG::UpdateRect( const PG_Rect& rect )
{
   SPoint p = widget2screen (  SPoint( rect.x, rect.y));
   PG_Rect sc ( p.x, p.y, rect.w, rect.h );
   sc = sc.IntersectRect( *this );
   eventBlit( GetWidgetSurface (), rect, sc );
   if ( sc.w && sc.h )
      PG_Application::UpdateRect(PG_Application::GetScreen(), sc.x, sc.y, sc.w, sc.h );
}


void MapDisplayPG::eventBlit(SDL_Surface* srf, const PG_Rect& src, const PG_Rect& dst)
{
   if ( !GetWidgetSurface ()) {
      if ( dirty > Nothing )
         updateMap();

      PG_Point pnt = ClientToScreen( 0,0 );
      blitInternalSurface( PG_Application::GetScreen(), SPoint(pnt.x,pnt.y), dst );
   } else {
      PG_Widget::eventBlit(srf,src,dst);
   }

   if ( !cursor.invisible )
      displayCursor( dst );


}


SPoint MapDisplayPG::mapGlobalPos2internalPos ( const MapCoordinate& pos )
{
   return getFieldPos( pos.x - offset.x, pos.y - offset.y );
}

SPoint MapDisplayPG::mapViewPos2internalPos ( const MapCoordinate& pos )
{
   return getFieldPos( pos.x, pos.y );
}


SPoint MapDisplayPG::internal2widget( const SPoint& pos )
{
   return SPoint( int(ceil(float(pos.x - surfaceBorder) * zoom / 100.0)), int(ceil(float(pos.y - surfaceBorder) * zoom / 100.0)));
}

SPoint MapDisplayPG::widget2screen( const SPoint& pos )
{
   PG_Point p = ClientToScreen ( pos.x, pos.y );
   return SPoint ( p.x, p.y );
}


MapCoordinate MapDisplayPG::screenPos2mapPos( const SPoint& pos )
{
   PG_Point pnt = ScreenToClient( pos.x, pos.y );
   if ( pnt.x >= 0 && pnt.y >= 0 && pnt.x < Width() && pnt.y < Height() )
      return widgetPos2mapPos ( SPoint( pnt.x, pnt.y ));
   else
      return MapCoordinate();
}

MapCoordinate MapDisplayPG::widgetPos2mapPos( const SPoint& pos )
{
   int x = int( float(pos.x) * 100 / zoom ) + surfaceBorder;
   int y = int( float(pos.y) * 100 / zoom ) + surfaceBorder;

   for (int yy= field.viewPort.y1; yy < field.viewPort.y2; ++yy )
      for ( int xx=field.viewPort.x1; xx < field.viewPort.x2; ++xx ) {
         int x1 = getFieldPosX(xx,yy);
         int y1 = getFieldPosY(xx,yy);
         if ( x >= x1 && x < x1+ fieldsizex && y >= y1 && y < y1+fieldsizey )
            if ( icons.fieldShape.GetPixel(x-x1,y-y1) != 255 )
               return MapCoordinate(xx+offset.x,yy+offset.y);
      }

   return MapCoordinate();
}

MapCoordinate MapDisplayPG::upperLeftCorner()
{
   return offset;       
}

MapCoordinate MapDisplayPG::lowerRightCorner()
{
   return MapCoordinate( offset.x + field.numx , offset.y + field.numy );
}


bool MapDisplayPG::centerOnField( const MapCoordinate& mc )
{
   if ( !(mc.valid() && mc.x < actmap->xsize && mc.y < actmap->ysize ))
      return false;
      
   MapCoordinate newpos ( mc.x - field.numx / 2,  mc.y - field.numy / 2 );

   checkViewPosition( newpos );

   if ( newpos != offset  ) {
      offset = newpos;
      dirty = Map;
      Redraw();
      viewChanged();
   }
   return true;

}

void MapDisplayPG::redrawMapAtCursor ( const MapCoordinate& oldpos )
{
   if ( oldpos.valid() ) {
      SPoint p = internal2widget( mapGlobalPos2internalPos( oldpos ));
      UpdateRect( PG_Rect( p.x, p.y, fieldsizex, fieldsizey ) );
   }
         
   SPoint p = internal2widget( mapGlobalPos2internalPos( cursor.pos() ));
   UpdateRect( PG_Rect( p.x, p.y, fieldsizex, fieldsizey ) );
}


int MapDisplayPG::setSignalPriority( int priority )
{
   int old = signalPrio;
   signalPrio = priority;
   return old;
}

void filterQueuedZoomEvents()
{
   SDL_Event event;
   while ( PG_Application::GetEventSupplier()->PeepEvent(&event) && (event.type == SDL_MOUSEBUTTONDOWN || event.type == SDL_MOUSEBUTTONUP) && (event.button.button == CGameOptions::Instance()->mouse.zoomoutbutton || event.button.button == CGameOptions::Instance()->mouse.zoominbutton ))
      PG_Application::GetEventSupplier()->PollEvent ( &event );
}

bool MapDisplayPG::eventMouseButtonDown (const SDL_MouseButtonEvent *button)
{
   MapCoordinate mc = screenPos2mapPos( SPoint(button->x, button->y));

   if ( button->type == SDL_MOUSEBUTTONDOWN && button->button == CGameOptions::Instance()->mouse.zoomoutbutton ) {
      changeZoom( 10 );
   
      MapCoordinate newpos = screenPos2mapPos( SPoint(button->x, button->y));
      MapCoordinate newOffset ( offset.x - ( newpos.x - mc.x ), offset.y - ( newpos.y - mc.y ));
      checkViewPosition( newOffset );
      offset = newOffset;

      viewChanged();
      repaintMap();
      filterQueuedZoomEvents();
      return true;
   }

   if ( button->type == SDL_MOUSEBUTTONDOWN && button->button == CGameOptions::Instance()->mouse.zoominbutton ) {
      changeZoom( -10 );

      MapCoordinate newpos = screenPos2mapPos( SPoint(button->x, button->y));
      MapCoordinate newOffset ( offset.x - ( newpos.x - mc.x ), offset.y - ( newpos.y - mc.y ));
      checkViewPosition( newOffset );
      offset = newOffset;

      viewChanged();
      repaintMap();
      filterQueuedZoomEvents();
      return true;
   }


   if ( !(mc.valid() && mc.x < actmap->xsize && mc.y < actmap->ysize ))
      return false;

   if ( button->type == SDL_MOUSEBUTTONDOWN && button->button == CGameOptions::Instance()->mouse.fieldmarkbutton ) {
      MapCoordinate oldpos = cursor.pos();
      bool changed = cursor.pos() != mc;
      cursor.pos() = mc;
      cursor.invisible = 0;
      dirty = Curs;

      updateFieldInfo();

      if ( changed )
         redrawMapAtCursor( oldpos );

      mouseButtonOnField( mc, SPoint(button->x, button->y), changed, button->button, signalPrio );
      return true;
      
   }

   if ( button->type == SDL_MOUSEBUTTONDOWN && button->button == CGameOptions::Instance()->mouse.centerbutton ) {
      return centerOnField( mc );
   }

   mouseButtonOnField( mc, SPoint(button->x, button->y), false, button->button, signalPrio );
   
   return false;
}

bool MapDisplayPG::eventMouseMotion (const SDL_MouseMotionEvent *button)
{
   MapCoordinate mc = screenPos2mapPos( SPoint(button->x, button->y));
   if ( !(mc.valid() && mc.x < actmap->xsize && mc.y < actmap->ysize ))
      return false;
      
   if ( button->type == SDL_MOUSEMOTION && (button->state == SDL_BUTTON( CGameOptions::Instance()->mouse.fieldmarkbutton) )) {
      bool changed = cursor.pos() != mc;
      if ( changed ) {
         MapCoordinate oldpos = cursor.pos();
         cursor.pos() = mc;
         cursor.invisible = 0;
         dirty = Curs;

         redrawMapAtCursor( oldpos );
         cursorMoved();

         mouseDraggedToField( mc, SPoint(button->x, button->y), changed, signalPrio );
   
         return true;
     }
   }
   return false;
}


bool MapDisplayPG::eventMouseButtonUp (const SDL_MouseButtonEvent *button)
{
   return false;
}


bool MapDisplayPG::fieldCompletelyInViewX( const MapCoordinate& pos )
{
   SPoint internal = mapGlobalPos2internalPos( pos);
   SPoint s = widget2screen( internal2widget( internal ));
   SPoint s2 = widget2screen( internal2widget( internal + SPoint(fieldsizex,fieldsizey) ));
   return s.x >= my_xpos && s2.x < my_xpos + my_width;
}

bool MapDisplayPG::fieldCompletelyInViewY( const MapCoordinate& pos )
{
   SPoint internal = mapGlobalPos2internalPos( pos);
   SPoint s = widget2screen( internal2widget( internal ));
   SPoint s2 = widget2screen( internal2widget( internal + SPoint(fieldsizex,fieldsizey) ));
   return s.y >= my_ypos && s2.y < my_ypos + my_height;
}

bool MapDisplayPG::fieldCompletelyInView( const MapCoordinate& pos )
{
   // for performance-reasons we don't call the above two methods
   SPoint internal = mapGlobalPos2internalPos( pos);
   SPoint s = widget2screen( internal2widget( internal ));
   SPoint s2 = widget2screen( internal2widget( internal + SPoint(fieldsizex,fieldsizey) ));
   return (s.y >= my_ypos && s2.y < my_ypos + my_height) && (s.x >= my_xpos && s2.x < my_xpos + my_width);

}


bool MapDisplayPG::fieldInView(const MapCoordinate& mc )
{
   if ( mc.x < offset.x || mc.y < offset.y || mc.x >= offset.x + field.numx || mc.y >= offset.y +  field.numy || !fieldCompletelyInView(mc) )
      return false;
   else
      return true;
}



Surface MapDisplayPG::createMovementBufferSurface()
{
   Surface s = Surface::createSurface( 2*surfaceBorder + effectiveMovementSurfaceWidth, 2*surfaceBorder + effectiveMovementSurfaceHeight, 8*colorDepth, 0x00ffffff ) ;
   s.SetColorKey( SDL_SRCCOLORKEY, 0xffffff);
   return s;
}


void MapDisplayPG::initMovementStructure()
{
   if ( !movementMask[0].mask.valid() ) 
      for ( int dir = 0; dir < sidenum; ++dir ) {
         movementMask[dir].mask = createMovementBufferSurface();
         MapCoordinate start;
         if ( dir >= 2 && dir <= 4 )
            start = MapCoordinate( 1, 2 );
         else
            start = MapCoordinate( 1, 4 );

         MapCoordinate dest = getNeighbouringFieldCoordinate( start, dir );

         for ( int i = 0; i < sidenum; ++i)
            movementMask[dir].mask.Blit( icons.fieldShape, getFieldPos2( getNeighbouringFieldCoordinate( start, i )));
         for ( int i = 0; i < sidenum; ++i)
            movementMask[dir].mask.Blit( icons.fieldShape, getFieldPos2( getNeighbouringFieldCoordinate( dest, i )));

         SPoint pix = getFieldPos2( start );
         movementMask[dir].startFieldPos = pix;

         pix.x += fieldsizex/2;
         pix.y += fieldsizey/2;
         movementMask[dir].mask.SetColorKey( SDL_SRCCOLORKEY, movementMask[dir].mask.GetPixel( pix ) & ~movementMask[dir].mask.GetPixelFormat().Amask());
      }
}


template<int pixelsize>
class SourcePixelSelector_DirectSubRectangle
{
   typedef typename PixelSize2Type<pixelsize>::PixelType PixelType;
   int x,y,x1,y1;
   int w,h;
   PG_Rect innerRect;
   int outerwidth;

   const PixelType* pointer;
   const PixelType* startPointer;
   int pitch;
   int linelength;
   const Surface* surface;
   protected:
      SourcePixelSelector_DirectSubRectangle() : x(0),y(0),x1(0),y1(0),w(0),h(0),outerwidth(0),pointer(NULL), surface(NULL)
      {}
      ;

      int getWidth()
      {
         return min(w, surface->w() -x1 );
      };
      int getHeight()
      {
         return min(h, surface->h()-y1 );
      };


      void init ( const Surface& srv )
      {
         surface = &srv;
         startPointer = pointer = (const PixelType*)(srv.pixels());
         linelength = srv.pitch()/sizeof(PixelType);
         pitch = linelength - w -1  ;
         y = y1;
         x = x1;
         pointer += x1 + y1 * linelength;
         outerwidth = getWidth();
      };

      PixelType getPixel(int x, int y)
      {
         x += x1;
         y += y1;
         if ( x >= 0 && y >= 0 && x < surface->w() && y < surface->h() )
            return surface->GetPixel(SPoint(x,y));
         else
            return surface->GetPixelFormat().colorkey();
      };


      PixelType nextPixel()
      {
         ++x;
         return *(pointer++);
      };


      void skipWholeLine()
      {
         pointer += linelength;
         ++y;
      };

      void skipPixels( int pixNum )
      {
         pointer += pixNum;
         x += pixNum;
      };

      int getSourcePixelSkip()
      {
         if ( y < innerRect.y )
            return outerwidth - (x - x1);
         else
            if ( y >= innerRect.y + innerRect.h )
               return outerwidth - (x - x1);
            else
               if ( x < innerRect.x )
                  return innerRect.x - x;
               else
                  if ( x >= innerRect.x + innerRect.w )
                     return outerwidth - (x - x1);
                  else
                     return 0;
       
      };
      
      void nextLine()
      {
         pointer = startPointer + x1 + (y++) * linelength;
         x = x1;
      };

   public:
      void setSrcRectangle( SPoint pos, int width, int height )
      {
         x1 = pos.x;
         y1 = pos.y;
         w = width;
         h = height;
      };
      void setInnerSrcRectangle( const PG_Rect& rect )
      {
         innerRect = rect;
      };

};

template<int pixelSize>
class MovePixSel : public SourcePixelSelector_CacheZoom<pixelSize, SourcePixelSelector_DirectSubRectangle<pixelSize> >
{}
;


void MapDisplayPG::displayMovementStep( Movement& movement, int percentage  )
{
#ifdef debugmapdisplay
   surface->Fill( 0xff00ff00);
#endif

   FieldRenderInfo fieldRenderInfo( *surface, movement.veh->getMap() );
   fieldRenderInfo.playerView = movement.playerView;
   for (int pass = 0; pass <= 18 ;pass++ ) {
      for ( int i = 0; i < movement.actualFieldNum; ++i ) {
         SPoint pos = movement.touchedFields[i].surfPos;
         fieldRenderInfo.pos = movement.touchedFields[i].mapPos;
         fieldRenderInfo.fld = movement.actmap->getField ( fieldRenderInfo.pos );
         if ( fieldRenderInfo.fld ) {
            fieldRenderInfo.visibility = fieldVisibility ( fieldRenderInfo.fld, fieldRenderInfo.playerView );

            paintSingleField( fieldRenderInfo, pass, pos );
         }
      }
      
      if ( pass >= 2 && pass < 18 )
         if ( !(pass & 1 ))
            if ( movement.veh->height & (1 << (( pass-2)/2))) {
               SPoint pos;
               pos.x = movement.from.x + (movement.to.x - movement.from.x) * percentage/100;
               pos.y = movement.from.y + (movement.to.y - movement.from.y) * percentage/100;
               int shadow = 0;
               if ( movement.fromShadow >= 0 && movement.toShadow >= 0 )
                  shadow = movement.fromShadow + (movement.toShadow - movement.fromShadow) * percentage/100;
               movement.veh->paint( *surface, pos, false, shadow );
            }
   }

#ifdef debugmapdisplay
   MegaBlitter<colorDepth,colorDepth,ColorTransform_None,ColorMerger_AlphaOverwrite,SourcePixelSelector_Plain,TargetPixelSelector_Valid> alphaBlitter;
   alphaBlitter.blit( *movement.mask, *surface, movement.maskPosition);
#endif
   
   PG_Rect targetArea  ( widget2screen( SPoint( 0, 0 )).x, widget2screen( SPoint( 0, 0 )).y, Width(), Height() );
   Surface s = Surface::Wrap( PG_Application::GetScreen() );
   
#ifdef debugmapdisplay
   s.Fill( 0xff00ff );
#endif

   if ( zoom != 100 ) {
      float fzoom = float(zoom) / 100.0;
      MegaBlitter<colorDepth,colorDepth,ColorTransform_None,ColorMerger_AlphaOverwrite,MovePixSel,TargetPixelSelector_Rect> blitter;
      blitter.setZoom( fzoom );
      blitter.initSource( *surface );
      
      blitter.setSrcRectangle( SPoint( getFieldPosX(0,0), getFieldPosY(0,0)), int(float(Width()) / fzoom), int(float(Height()) / fzoom));
      blitter.setInnerSrcRectangle( movement.blitViewPortInternal  );
      
      blitter.setTargetRect( targetArea );
      blitter.blit( *surface, s, movement.targetBlitPos );
   } else {
      MegaBlitter<colorDepth,colorDepth,ColorTransform_None,ColorMerger_AlphaOverwrite,SourcePixelSelector_DirectSubRectangle,TargetPixelSelector_Rect> blitter;
      blitter.initSource( *surface );
      
      blitter.setSrcRectangle( SPoint( getFieldPosX(0,0), getFieldPosY(0,0)), Width(), Height() );
      blitter.setInnerSrcRectangle( movement.blitViewPortInternal  );
      
      blitter.setTargetRect( targetArea  );
      blitter.blit( *surface, s, movement.targetBlitPos );
   }

#ifdef debugmapdisplay
   rectangle<4>( s, SPoint(targetArea.x, targetArea.y), targetArea.w, targetArea.h, ColorMerger_ColoredOverwrite<4>( 0x00ffff ), ColorMerger_ColoredOverwrite<4>( 0x00ffff ) );
   rectangle<4>( s, SPoint(movement.blitViewPortScreen.x, movement.blitViewPortScreen.y), movement.blitViewPortScreen.w, movement.blitViewPortScreen.h, ColorMerger_ColoredOverwrite<4>( 0x0000ff ), ColorMerger_ColoredOverwrite<4>( 0x0000ff ) );
   PG_Application::UpdateRect(PG_Application::GetScreen(), 0, 0, PG_Application::GetScreen()->w, PG_Application::GetScreen()->h );
#else   
   PG_Application::UpdateRect(PG_Application::GetScreen(), movement.blitViewPortScreen.x, movement.blitViewPortScreen.y, movement.blitViewPortScreen.w, movement.blitViewPortScreen.h );
#endif
}





bool ccompare( const MapCoordinate& a, const MapCoordinate& b )
{
   return a.y < b.y || (a.y == b.y && a.x < b.x);
}   


void MapDisplayPG::displayUnitMovement( GameMap* actmap, Vehicle* veh, const MapCoordinate3D& from, const MapCoordinate3D& to )
{
   static int col = 0xff;
   
#ifdef debugmapdisplay
   col += 30;
   if ( col > 255 )
      col -= 255;
#endif

   surface->Fill( col << 8 );
   
   if ( !fieldInView( from ) && !fieldInView( to ))
      return;

   if ( from.x == to.x && from.y == to.y && from.getBitmappedHeight() <= chschwimmend && to.getBitmappedHeight() <=