replay.cpp

Go to the documentation of this file.

/***************************************************************************
                          replay.cpp  -  description
                             -------------------
    begin                : Sun Jan 21 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.                                   *
 *                                                                         *
 ***************************************************************************/

#include <stdarg.h>
#include "replay.h"
#include "typen.h"
#include "buildingtype.h"
#include "vehicletype.h"
#include "spfst.h"
#include "controls.h"
#include "dialog.h"
#include "gameoptions.h"
#include "viewcalculation.h"
#include "itemrepository.h"
#include "containercontrols.h"
#include "resourcenet.h"
#include "guiiconhandler.h"
#include "guifunctions.h"
#include "cannedmessages.h"
#include "unitctrl.h"
#include "replaymapdisplay.h"
#include "asc-mainscreen.h"
#include "loaders.h"
#include "turncontrol.h"
#include "widgets/textrenderer.h"
#include "actions/jumpdrive.h"
#include "actions/selfdestruct.h"
#include "reactionfire.h"
#include "gameeventsystem.h"
#include "sdl/graphicsqueue.h"
#include "video/videorecorder.h"
#include "iconrepository.h"
#include "dialogs/replayrecorder.h"

trunreplay runreplay;

int startreplaylate = 0;


class ReplayRecorder;

class ReplayRecorderWatcherGlobal {
      ReplayRecorder* recorder;
   public:
      ReplayRecorderWatcherGlobal()  : recorder( NULL ) {};
      void set(  ReplayRecorder* rec  ) {
         recorder = rec;
      }
      
      ~ReplayRecorderWatcherGlobal() ;
} replayRecorderWatcherGlobal;


 class ReplayRecorder : public SigC::Object {
   
   VideoRecorder* rec;
   SigC::Connection connection;
   bool movieModeStorage;
   ASCString lastFilename;
   
   public:
      ReplayRecorder() : rec (NULL)
      {
         movieModeStorage = CGameOptions::Instance()->replayMovieMode;
         replayRecorderWatcherGlobal.set( this );
      }
      
      void start( const ASCString& filename, bool append, int framerate, int quality )
      {
         lastFilename = filename;
         movieModeStorage = CGameOptions::Instance()->replayMovieMode;
         CGameOptions::Instance()->replayMovieMode = true;
         ASCString newFilename = constructFileName( 0, "", filename );
         if ( !rec || !append || newFilename != rec->getFilename()  ) {
            delete rec;
            rec = new VideoRecorder( newFilename, PG_Application::GetScreen(), framerate, quality );
         }
         
         if ( !connection.connected() )
            connection = postScreenUpdate.connect( SigC::slot( *this, &ReplayRecorder::screenUpdate ));
      }
      
      void pause()
      {
         if ( connection.connected() )
            connection.disconnect();
         CGameOptions::Instance()->replayMovieMode = movieModeStorage;
      }
      
      void close()
      {
         pause();
         delete rec;
         rec = NULL;
      }
      
      bool isRunning()
      {
         return connection.connected() && rec;
      }
      
      bool isOpen()
      {
         return rec != NULL;  
      }
      
      ASCString getLastFilename()
      {
         return lastFilename;
      }
   
   private:
      void screenUpdate( const SDL_Surface* surf )
      {
         if ( rec )
            rec->storeFrame( surf );
      }
};

class ReplayRecorderWatcherLocal {
      ReplayRecorder* recorder;
   public:
      ReplayRecorderWatcherLocal( ReplayRecorder* rec )  : recorder( rec ) {};
      ~ReplayRecorderWatcherLocal() 
      { 
         if ( recorder ) 
            recorder->pause();
      }
};


ReplayRecorderWatcherGlobal::~ReplayRecorderWatcherGlobal() 
{ 
   if ( recorder ) 
      recorder->pause();
}


ReplayRecorder* replayRecorder = NULL;

 

namespace ReplayGuiFunctions {

class ReplayPlay : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         if ( runreplay.status == 1 )
            return true;

         return false;
      };

      void execute( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
        runreplay.status = 2;
        updateFieldInfo();
      }

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

      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "start re~p~lay";
      };

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


class ReplayPause : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         if ( runreplay.status == 2 )
            return true;

         return false;
      };

      void execute( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
        runreplay.status = 1;
        updateFieldInfo();
      }

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

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



class ReplayFaster : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         if ( runreplay.status == 2 )
            if ( CGameOptions::Instance()->replayspeed > 0 )
              return true;

         return false;
      };

      void execute( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         if ( CGameOptions::Instance()->replayspeed > 20 )
            CGameOptions::Instance()->replayspeed -= 20;
         else
            CGameOptions::Instance()->replayspeed = 0;

         CGameOptions::Instance()->setChanged ( 1 );
         displaymessage2 ( "delay set to %d / 100 sec", CGameOptions::Instance()->replayspeed );
         updateFieldInfo();
      }

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

      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "increase replay speed (~+~)";
      };

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


class ReplaySlower : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         if ( runreplay.status == 2 )
            return true;

         return false;
      };

      void execute( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         CGameOptions::Instance()->replayspeed += 20;
         CGameOptions::Instance()->setChanged ( 1 );
         displaymessage2 ( "delay set to %d / 100 sec", CGameOptions::Instance()->replayspeed );
         updateFieldInfo();
      }

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

      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "decrease replay speed (~-~)";
      };

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


class ReplayRewind : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         if ( runreplay.status == 1  ||  runreplay.status == 10 )
              return true;

         return false;
      };

      void execute( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         runreplay.status = 101;
         updateFieldInfo();
      }

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

      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "~r~estart replay";
      };

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


class ReplayExit : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         if ( runreplay.status == 1 || runreplay.status == 10 || runreplay.status == 11 )
              return true;

         return false;
      };

      void execute( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         runreplay.status = 100;
         updateFieldInfo();
      }

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

      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "e~x~it replay";
      };

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

class ReplayRecord : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         if ( runreplay.status == 1 )
            return true;

         return false;
      };

      void execute( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
        ASCString filename;
        bool open = false;
        if ( replayRecorder ) {
           filename = replayRecorder->getLastFilename();
           open = replayRecorder->isOpen();
        }
        
        ReplayRecorderDialog rrd( filename, open );
        rrd.Show();
        rrd.RunModal();
        rrd.Hide();
         
        if ( !replayRecorder )
           replayRecorder = new ReplayRecorder();
        replayRecorder->start( rrd.getFilename(), rrd.getAppend(), rrd.getFramerate(), rrd.getQuality() );
        
        runreplay.status = 2;
        updateFieldInfo();
      }

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

      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "record to ~v~ideo";
      };

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

class ReplayRecordExit : public GuiFunction
{
   public:
      bool available( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         if ( replayRecorder && replayRecorder->isOpen() && (runreplay.status == 1 || runreplay.status == 10 || runreplay.status == 11) )
              return true;

         return false;
      };

      void execute( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         replayRecorder->close();
         runreplay.status = 100;
         updateFieldInfo();
      }

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

      ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num )
      {
         return "exit replay and ~c~lose recording";
      };

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


}

void registerReplayGuiFunctions( GuiIconHandler& handler )
{
   handler.registerUserFunction( new ReplayGuiFunctions::ReplayPlay() );
#ifdef XVIDEXPORT   
   handler.registerUserFunction( new ReplayGuiFunctions::ReplayRecord() );
#endif   
   handler.registerUserFunction( new ReplayGuiFunctions::ReplayPause() );
   handler.registerUserFunction( new ReplayGuiFunctions::ReplayFaster() );
   handler.registerUserFunction( new ReplayGuiFunctions::ReplaySlower() );
   handler.registerUserFunction( new ReplayGuiFunctions::ReplayRewind() );
#ifdef XVIDEXPORT   
   handler.registerUserFunction( new ReplayGuiFunctions::ReplayRecordExit() );
#endif
   handler.registerUserFunction( new ReplayGuiFunctions::ReplayExit() );
}



class ReplayGuiIconHandleHandler {
   static GuiIconHandler* replayIconHandler;
   bool active;
   public:
      ReplayGuiIconHandleHandler()
      {
         if ( !replayIconHandler ) {
            replayIconHandler = new GuiIconHandler();
            registerReplayGuiFunctions( *replayIconHandler );
         }
         
         if ( NewGuiHost::getIconHandler() != replayIconHandler ) {
            active = true;
            NewGuiHost::pushIconHandler( replayIconHandler );
         } else
            active = false;
      };

      ~ReplayGuiIconHandleHandler()
      {
         if ( active )
            NewGuiHost::popIconHandler();
      };
};
GuiIconHandler* ReplayGuiIconHandleHandler::replayIconHandler = NULL;





void runSpecificReplay( int player, int viewingplayer, bool performEndTurnOperations )
{
    if ( actmap->replayinfo->map[player] && actmap->replayinfo->guidata[player] ) {
       try {
         int t;
         do {
            t = runreplay.run ( player, viewingplayer, performEndTurnOperations );
         } while ( t ); /* enddo */
       }

#ifndef _DEBUG
       catch ( ... ) {     // this will catch NullPointer-Exceptions and stuff like that, which we want to pass to the debugger  in debug mode
#else
       catch ( GameMap ) {  // will never be thrown, but we need catch statement for the try block
#endif
          errorMessage("An unrecognized error occured during the replay");
          delete actmap;
          actmap = NULL;
          throw NoMapLoaded();
       }
    }
}

void viewOwnReplay( Player& player )
{
   if ( player.stat == Player::human || player.stat == Player::supervisor )
      if ( CGameOptions::Instance()->debugReplay && player.getParentMap()->replayinfo )
         if (choice_dlg("run replay of your turn ?","~y~es","~n~o") == 1) {
            // cursor.gotoxy( actmap->cursorpos.position[oldplayer].cx, actmap->cursorpos.position[oldplayer].cy );
            runSpecificReplay ( player.getPosition(), player.getPosition(), false );
         }
}


void checkforreplay ( void )
{
   if ( !actmap->replayinfo )
      return;

   int rpnum  = 0;
   int s = actmap->actplayer + 1;
   if ( s >= 8 )
       s = 0;
   while ( s != actmap->actplayer ) {
       if ( actmap->replayinfo->map[s] && actmap->replayinfo->guidata[s] )
          rpnum++;

       if ( s < 7 )
          s++;
       else
          s = 0;
   }


   if ( actmap->replayinfo  &&  rpnum  &&  (actmap->player[ actmap->actplayer ].stat == Player::human || actmap->player[ actmap->actplayer ].stat == Player::supervisor) )
      if (choice_dlg("run replay of last turn ?","~y~es","~n~o") == 1) {
      
         MainScreenWidget::StandardActionLocker locker( mainScreenWidget, MainScreenWidget::LockOptions::Menu );
         ReplayGuiIconHandleHandler guiIconHandler;
         
         int s = actmap->actplayer + 1;
         if ( s >= 8 )
            s = 0;
         while ( s != actmap->actplayer ) {
            if ( s >= 8 )
               s = 0;

             runSpecificReplay(s, actmap->actplayer );

             if ( s < 7 )
                 s++;
              else
                 s = 0;
          }


      }
}


void initReplayLogging( Player& player )
{
   GameMap* gamemap = player.getParentMap();
   
   if ( startreplaylate ) {
      gamemap->replayinfo = new GameMap::ReplayInfo;
      startreplaylate = 0;
   }

   if ( gamemap->replayinfo && player.stat != Player::off ) {
      if ( gamemap->replayinfo->actmemstream )
         fatalError( "actmemstream already open at begin of turn " );

      if ( gamemap->replayinfo->guidata[ player.getPosition() ] ) {
         delete gamemap->replayinfo->guidata[ player.getPosition() ];
         gamemap->replayinfo->guidata[ player.getPosition() ] = NULL;
      }

      savereplay ( gamemap, player.getPosition() );

      gamemap->replayinfo->guidata[ player.getPosition() ] = new tmemorystreambuf;
      gamemap->replayinfo->actmemstream = new tmemorystream ( gamemap->replayinfo->guidata[ player.getPosition() ], tnstream::writing );
   }
}


LockReplayRecording::LockReplayRecording( GameMap::ReplayInfo& _ri )
                    : ri ( _ri )
{
   ri.stopRecordingActions++;
}

LockReplayRecording::~LockReplayRecording()
{
   ri.stopRecordingActions--;
}


Resources getUnitResourceCargo ( Vehicle* veh )
{
   Resources res = veh->getTank();
   for ( ContainerBase::Cargo::const_iterator i = veh->getCargo().begin(); i != veh->getCargo().end(); ++i )
      if ( *i )
         res += getUnitResourceCargo ( *i );
   return res;
}

void logtoreplayinfo ( trpl_actions _action, ... )
{
   char action = _action;
   if ( actmap->replayinfo && actmap->replayinfo->actmemstream && !actmap->replayinfo->stopRecordingActions) {
      pnstream stream = actmap->replayinfo->actmemstream;

      va_list paramlist;
      va_start ( paramlist, _action );

      if ( action == rpl_attack || action == rpl_reactionfire ) {
         int x1 =  va_arg ( paramlist, int );
         int y1 =  va_arg ( paramlist, int );
         int x2 =  va_arg ( paramlist, int );
         int y2 =  va_arg ( paramlist, int );
         int ad1 =  va_arg ( paramlist, int );
         int ad2 =  va_arg ( paramlist, int );
         int dd1 =  va_arg ( paramlist, int );
         int dd2 =  va_arg ( paramlist, int );
         int wpnum =  va_arg ( paramlist, int );
         int size = 9;
         stream->writeChar ( action );
         stream->writeInt ( size );
         stream->writeInt ( x1 );
         stream->writeInt ( y1 );
         stream->writeInt ( x2 );
         stream->writeInt ( y2 );
         stream->writeInt ( ad1 );
         stream->writeInt ( ad2 );
         stream->writeInt ( dd1 );
         stream->writeInt ( dd2 );
         stream->writeInt ( wpnum );
      }

      if ( action == rpl_move ) {
         int x1 =  va_arg ( paramlist, int );
         int y1 =  va_arg ( paramlist, int );
         int x2 =  va_arg ( paramlist, int );
         int y2 =  va_arg ( paramlist, int );
         int nwid = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 5;
         stream->writeInt ( size );
         stream->writeInt ( x1 );
         stream->writeInt ( y1 );
         stream->writeInt ( x2 );
         stream->writeInt ( y2 );
         stream->writeInt ( nwid );
      }
      if ( action == rpl_move2 || action == rpl_move3 || action == rpl_move4 || action==rpl_move5) {
         int x1 =  va_arg ( paramlist, int );
         int y1 =  va_arg ( paramlist, int );
         int x2 =  va_arg ( paramlist, int );
         int y2 =  va_arg ( paramlist, int );
         int nwid = va_arg ( paramlist, int );
         int height = va_arg ( paramlist, int );

         stream->writeChar ( action );
         if ( action == rpl_move5 ) {
            int size = 8;
            stream->writeInt( size );
         } else 
            if ( action == rpl_move2 ) {
               int size = 6;
               stream->writeInt ( size );
            } else {
               int size = 7;
               stream->writeInt ( size );
            }
         stream->writeInt ( x1 );
         stream->writeInt ( y1 );
         stream->writeInt ( x2 );
         stream->writeInt ( y2 );
         stream->writeInt ( nwid );
         stream->writeInt ( height );
         if ( action == rpl_move3 || action == rpl_move4 || action==rpl_move5) {
            int nointerrupt = va_arg ( paramlist, int );
            stream->writeInt ( nointerrupt );
            if ( action==rpl_move5 ) {
               int destDamage = va_arg( paramlist, int );
               stream->writeInt( destDamage );
            }
         }
      }

      if ( action == rpl_changeheight || action == rpl_changeheight2 ) {
         int x1 =  va_arg ( paramlist, int );
         int y1 =  va_arg ( paramlist, int );
         int x2 =  va_arg ( paramlist, int );
         int y2 =  va_arg ( paramlist, int );
         int nwid = va_arg ( paramlist, int );
         int oldheight = va_arg ( paramlist, int );
         int newheight = va_arg ( paramlist, int );
         stream->writeChar ( action );
         if ( action == rpl_changeheight ) {
            int size = 7;
            stream->writeInt ( size );
         } else {
            int size = 8;
            stream->writeInt ( size );
         }
         stream->writeInt ( x1 );
         stream->writeInt ( y1 );
         stream->writeInt ( x2 );
         stream->writeInt ( y2 );
         stream->writeInt ( nwid );
         stream->writeInt ( oldheight );
         stream->writeInt ( newheight );
         if ( action == rpl_changeheight2 ) {
            int noInterrupt = va_arg ( paramlist, int );
            stream->writeInt ( noInterrupt );
         }
      }
      if ( action == rpl_convert  ) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         int col =  va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 3;
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( col );
      }
      if ( action == rpl_convert2  ) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         int col =  va_arg ( paramlist, int );
         int nwid =  va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 4;
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( col );
         stream->writeInt ( nwid );
      }
      if ( action == rpl_buildobj || action == rpl_remobj ) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         int id =  va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 3;
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( id );
      }
      if ( action == rpl_buildobj2 || action == rpl_remobj2 ) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         int id =  va_arg ( paramlist, int );
         int unit = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 4;
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( id );
         stream->writeInt ( unit );
      }
      if ( action == rpl_buildtnk || action == rpl_buildtnk3 || action == rpl_buildtnk4 ) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         int id =  va_arg ( paramlist, int );
         int col =  va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size;
         if ( action == rpl_buildtnk )
            size = 4;
         else
            if ( action == rpl_buildtnk4 )
               size = 7;
            else
               size = 6;

         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( id );
         stream->writeInt ( col );
         if ( action == rpl_buildtnk3 || action == rpl_buildtnk4 ) {
            stream->writeInt ( va_arg ( paramlist, int ) ); // constructor x
            stream->writeInt ( va_arg ( paramlist, int ) ); // constructor x
            if ( action == rpl_buildtnk4  )
               stream->writeInt ( va_arg ( paramlist, int ) ); // unit height
         }
      }
      if ( action == rpl_buildtnk2 ) {
         stream->writeChar ( action );
         int size = 5;
         stream->writeInt ( size );
         stream->writeInt ( va_arg ( paramlist, int ) );
         stream->writeInt ( va_arg ( paramlist, int ) );
         stream->writeInt ( va_arg ( paramlist, int ) );
         stream->writeInt ( va_arg ( paramlist, int ) );
         stream->writeInt ( va_arg ( paramlist, int ) );
      }
      if ( action == rpl_putbuilding || action == rpl_putbuilding2 ) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         int id = va_arg ( paramlist, int );
         int col =  va_arg ( paramlist, int );
         stream->writeChar ( action );
         if ( action == rpl_putbuilding )
            stream->writeInt ( 4 );
         else
            stream->writeInt ( 5 );

         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( id );
         stream->writeInt ( col );
         if ( action == rpl_putbuilding2 )
            stream->writeInt ( va_arg ( paramlist, int ));
      }
      if ( action == rpl_putmine || action == rpl_putmine2 ) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         int col =  va_arg ( paramlist, int );
         int typ = va_arg ( paramlist, int );
         int strength = va_arg ( paramlist, int );
         int nwid = -1; 

         stream->writeChar ( action );
         int size;
         if ( action == rpl_putmine ) {
            size = 5;
         } else {
            nwid = va_arg ( paramlist, int );
            size = 6;
         }
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( col );
         stream->writeInt ( typ );
         stream->writeInt ( strength );

         if ( action == rpl_putmine2 ) 
            stream->writeInt ( nwid );
         
      }
      if ( action == rpl_removemine ) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 2;
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
      }
      if ( action == rpl_removebuilding ) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 2;
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
      }
      if ( action == rpl_removebuilding2 || action == rpl_removebuilding3) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         int nwid = va_arg ( paramlist, int );
         stream->writeChar ( action );
         if ( action == rpl_removebuilding2 ) {
            int size = 3;
            stream->writeInt ( size );
            stream->writeInt ( x );
            stream->writeInt ( y );
            stream->writeInt( nwid );
         } else {
            int size = 6;
            stream->writeInt ( size );
            stream->writeInt ( x );
            stream->writeInt ( y );
            stream->writeInt( nwid );
            int e =  va_arg ( paramlist, int );
            int m =  va_arg ( paramlist, int );
            int f =  va_arg ( paramlist, int );
            stream->writeInt( e );
            stream->writeInt( m );
            stream->writeInt( f );
         }
      }

      if ( action == rpl_produceunit ) {
         int id = va_arg ( paramlist, int );
         int col = va_arg ( paramlist, int );
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         int cl = va_arg ( paramlist, int );
         int nwid = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 6;
         stream->writeInt ( size );
         stream->writeInt ( id );
         stream->writeInt ( col );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( cl );
         stream->writeInt ( nwid );
      }
      if ( action == rpl_removeunit ) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         int nwid = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 3;
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( nwid );
      }
      if ( action == rpl_trainunit ) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         int exp =  va_arg ( paramlist, int );
         int nwid = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 4;
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( exp );
         stream->writeInt ( nwid );
      }
      /*
      not supported any more because of new diplomatic model
      if ( action == rpl_shareviewchange ) {
         stream->writeChar ( action );
         if ( actmap->shareview ) {
            int size = 8*8/4+1;
            stream->writeInt ( size );
            for ( int a = 0; a < 8; a++ )
               for ( int b = 0; b < 8; b++ )
                   stream->writeChar ( actmap->shareview->mode[a][b] );
            stream->writeInt ( actmap->shareview->recalculateview );
         } else {
            int size = 0;
            stream->writeInt ( size );
         }
      }
      */
      if ( action == rpl_alliancechange2 ) {
         stream->writeChar ( action );
         stream->writeInt( 3 ); // size

         int actingPlayer =  va_arg ( paramlist, int );
         int targetPlayer =  va_arg ( paramlist, int );
         int state = va_arg ( paramlist, int );
         stream->writeInt( actingPlayer );
         stream->writeInt( targetPlayer );
         stream->writeInt( state );
      }
      if ( action == rpl_refuel || action == rpl_refuel2 ) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         int nwid = va_arg ( paramlist, int );
         int pos = va_arg ( paramlist, int );
         int amnt = va_arg ( paramlist, int );
         stream->writeChar ( action );
         stream->writeInt ( action==rpl_refuel ? 5 : 6 );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( nwid );
         stream->writeInt ( pos );
         stream->writeInt ( amnt );
         if ( action == rpl_refuel2 ) {
             int old = va_arg ( paramlist, int );
             stream->writeInt( old );
         }
      }
      if ( action == rpl_refuel3 ) {
         int id =  va_arg ( paramlist, int );
         int resource = va_arg ( paramlist, int );
         int delta = va_arg ( paramlist, int );
         stream->writeChar ( action );
         stream->writeInt ( 3 );
         stream->writeInt ( id );
         stream->writeInt ( resource );
         stream->writeInt ( delta );
      }
      if ( action == rpl_bldrefuel ) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         int pos = va_arg ( paramlist, int );
         int amnt = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 4;
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( pos );
         stream->writeInt ( amnt );
      }
      if ( action == rpl_moveUnitUpDown ) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         int nwid_from = va_arg ( paramlist, int );
         int nwid_to = va_arg ( paramlist, int );
         int nwid_moving = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 5;
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( nwid_from );
         stream->writeInt ( nwid_to );
         stream->writeInt ( nwid_moving );
      }
      if ( action == rpl_moveUnitUp ) {
         int x =  va_arg ( paramlist, int );
         int y =  va_arg ( paramlist, int );
         int nwid = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 3;
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( nwid );
      }
      if ( action == rpl_productionResourceUsage ) {
         int en = va_arg ( paramlist, int );
         int ma = va_arg ( paramlist, int );
         int fu = va_arg ( paramlist, int );
         int x = va_arg ( paramlist, int );
         int y = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 5;
         stream->writeInt ( size );
         stream->writeInt ( en );
         stream->writeInt ( ma );
         stream->writeInt ( fu );
         stream->writeInt ( x );
         stream->writeInt ( y );
      }
      if ( action == rpl_repairUnit ) {
         int nwid = va_arg ( paramlist, int );
         int destnwid = va_arg ( paramlist, int );
         int amount = va_arg ( paramlist, int );
         int matremain = va_arg ( paramlist, int );
         int fuelremain = va_arg ( paramlist, int );

         stream->writeChar ( action );
         int size = 5;
         stream->writeInt ( size );
         stream->writeInt ( nwid );
         stream->writeInt ( destnwid );
         stream->writeInt ( amount );
         stream->writeInt ( matremain );
         stream->writeInt ( fuelremain );
      }
      if ( action == rpl_repairUnit2 || action == rpl_repairBuilding ) {
         int x = va_arg ( paramlist, int );
         int y = va_arg ( paramlist, int );
         int destnwid = va_arg ( paramlist, int );
         int amount = va_arg ( paramlist, int );

         stream->writeChar ( action );
         int size = 4;
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( destnwid );
         stream->writeInt ( amount );
      }
      if ( action == rpl_repairUnit3  ) {
         int serviceNWID = va_arg ( paramlist, int );
         int destnwid = va_arg ( paramlist, int );
         int amount = va_arg ( paramlist, int );

         stream->writeChar ( action );
         int size = 3;
         stream->writeInt ( size );
         stream->writeInt ( serviceNWID );
         stream->writeInt ( destnwid );
         stream->writeInt ( amount );
      }
      if ( action == rpl_produceAmmo ) {
         int x = va_arg ( paramlist, int );
         int y = va_arg ( paramlist, int );
         int type = va_arg ( paramlist, int );
         int amount = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 4;
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( type );
         stream->writeInt ( amount );
      }
      if ( action == rpl_buildProdLine || action == rpl_removeProdLine) {
         int building = va_arg ( paramlist, int );
         int id = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 2;
         stream->writeInt ( size );
         stream->writeInt ( building );
         stream->writeInt ( id );
      }

      if ( action == rpl_recycleUnit ) {
         int building = va_arg ( paramlist, int );
         int id = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 2;
         stream->writeInt ( size );
         stream->writeInt ( building );
         stream->writeInt ( id );
      }

      if ( action == rpl_techResearched ) {
         int tech = va_arg ( paramlist, int );
         int player = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 2;
         stream->writeInt ( size );
         stream->writeInt ( tech );
         stream->writeInt ( player );
      }
      if ( action == rpl_setGeneratorStatus ) {
         int vehid = va_arg ( paramlist, int );
         int status = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 2;
         stream->writeInt ( size );
         stream->writeInt ( vehid );
         stream->writeInt ( status );
      }
      if ( action == rpl_cutFromGame ) {
         int vehid = va_arg( paramlist, int );
         Resources res = getUnitResourceCargo ( actmap->getUnit ( vehid ));
         stream->writeChar ( action );
         int size = 4;
         stream->writeInt ( size );
         stream->writeInt ( vehid );
         stream->writeInt ( res.energy );
         stream->writeInt ( res.material );
         stream->writeInt ( res.fuel );
      }
      if ( action == rpl_setResearch ) {
         int bldid = va_arg ( paramlist, int );
         int amount = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 2;
         stream->writeInt ( size );
         stream->writeInt ( bldid );
         stream->writeInt ( amount );
      }
      if ( action == rpl_setResourceProcessingAmount ) {
         int x = va_arg ( paramlist, int );
         int y = va_arg ( paramlist, int );
         int e = va_arg ( paramlist, int );
         int m = va_arg ( paramlist, int );
         int f = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 5;
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( e );
         stream->writeInt ( m );
         stream->writeInt ( f );
      }
      if ( action == rpl_netcontrol ) {
         int x = va_arg ( paramlist, int );
         int y = va_arg ( paramlist, int );
         int cat = va_arg ( paramlist, int );
         int stat = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 4;
         stream->writeInt ( size );
         stream->writeInt ( x );
         stream->writeInt ( y );
         stream->writeInt ( cat );
         stream->writeInt ( stat );
      }
      if ( action == rpl_jump ) {
         int nwid = va_arg ( paramlist, int );
         int x = va_arg ( paramlist, int );
         int y = va_arg ( paramlist, int );
         stream->writeChar ( action );
         int size = 3;
         stream->writeInt ( size );
         stream->writeInt ( nwid );
         stream->writeInt ( x );
         stream->writeInt ( y );
      }
      if ( action == rpl_transferTribute ) {
         stream->writeChar( action );
         stream->writeInt( 1 );
         int player = va_arg( paramlist, int );
         stream->writeInt( player );
      }

      if ( action == rpl_reactionFireOn || action == rpl_reactionFireOff ) {
         stream->writeChar( action );
         stream->writeInt( 1 );
         int nwid = va_arg( paramlist, int );
         stream->writeInt( nwid );
      }

      if ( action == rpl_selfdestruct ) {
         stream->writeChar( action );
         stream->writeInt( 1 );
         int nwid = va_arg( paramlist, int );
         stream->writeInt( nwid );
      }

      if ( action == rpl_cancelResearch ) {
         stream->writeChar( action );
         stream->writeInt( 0 );
      }


      va_end ( paramlist );
   }
}


trunreplay :: trunreplay ( void )  
{
   status = -1;
   movenum = 0;
}

void trunreplay::error( const MapCoordinate& pos, const ASCString& message )
{
   error( message );
}


void trunreplay::error( const MapCoordinate& pos, const char* message, ... )
{
   va_list paramlist;
   va_start ( paramlist, message );
   char tempbuf[1000];
   int lng = vsprintf( tempbuf, message, paramlist );

   assert(lng < 1000);
   error( tempbuf );
   // error( message + "\nPosition: " + pos.toString() );
}

void trunreplay::error( const char* message, ... )
{
   if ( message != lastErrorMessage ) {
      va_list paramlist;
      va_start ( paramlist, message );

      char tempbuf[1000];

      int lng = vsprintf( tempbuf, message, paramlist );
      if ( lng >= 1000 )
         displaymessage ( "trunreplay::error: String to long !\nPlease report this error", 1 );

      va_end ( paramlist );
      
      displaymessage(tempbuf, 1 );
      lastErrorMessage = message;
   }
}

void trunreplay::error( const ASCString& message )
{
   if ( CGameOptions::Instance()->replayMovieMode )
      return;

   if ( message != lastErrorMessage ) {
      displaymessage(message.c_str(), 1 );
      lastErrorMessage = message;
   }
}




void trunreplay :: wait ( int t )
{
//   if ( fieldvisiblenow ( getactfield(), actmap->playerView ))
    while ( ticker < t + CGameOptions::Instance()->replayspeed  && !keypress()) {
       /*
       tkey input;
       while (keypress ()) {
           input = r_key ( );
           if ( input == ct_'+' )
       }
       */
       releasetimeslice();
    }
}

void trunreplay :: wait ( MapCoordinate pos, int t )
{