gamemap.h

Go to the documentation of this file.

/***************************************************************************
                          gamemap.h  -  description
                             -------------------
    begin                : Tue Feb 17 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.                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef gamemapH
 #define gamemapH

 #include <vector>
 #include <time.h>

 #include "typen.h"
 #include "baseaiinterface.h"
 #include "vehicle.h"
 #include "buildings.h"
 #include "basestrm.h"
 #include "messages.h"
 #include "research.h"
 #include "password.h"
#ifdef WEATHERGENERATOR
 # include "weatherarea.h"
#endif
 #include "objects.h"
 #include "mapfield.h"
 #include "networkinterface.h"
 #include "player.h"
 
 #include "actions/actioncontainer.h"
 
 class AbstractTaskContainer;
 
 class RandomGenerator{
   public:

      RandomGenerator(int seedValue);
      ~RandomGenerator();
      
      unsigned int getPercentage();
      unsigned int getRandomValue(int upperLimit);
      unsigned int getRandomValue (int lowerLimit, int upperLimit);
 };
 
  
#ifdef WEATHERGENERATOR
class WeatherSystem;
#endif


class ActionRecorder {
   public:
      virtual void readData ( tnstream& stream ) = 0;
      virtual void writeData ( tnstream& stream ) = 0;
      virtual ~ActionRecorder() {};
};


const int gameparameternum = 35;

enum GameParameter { cgp_fahrspur, // 0
       cgp_eis,
       cgp_movefrominvalidfields,
       cgp_building_material_factor,
       cgp_building_fuel_factor,
       cgp_forbid_building_construction, // 5
       cgp_forbid_unitunit_construction,
       cgp_bi3_training,
       cgp_maxminesonfield,
       cgp_antipersonnelmine_lifetime,
       cgp_antitankmine_lifetime,      // 10
       cgp_mooredmine_lifetime,
       cgp_floatingmine_lifetime,
       cgp_buildingarmor,
       cgp_maxbuildingrepair,
       cgp_buildingrepairfactor, // 15
       cgp_globalfuel,
       cgp_maxtrainingexperience,
       cgp_initialMapVisibility,
       cgp_attackPower,
       cgp_jammingAmplifier,  // 20
       cgp_jammingSlope,
       cgp_superVisorCanSaveMap,
       cgp_objectsDestroyedByTerrain,
       cgp_trainingIncrement,
       cgp_experienceDivisorAttack,  // 25
       cgp_disableDirectView,
       cgp_disableUnitTransfer,
       cgp_experienceDivisorDefense,
       cgp_debugEvents,
       cgp_objectGrowthMultiplier, // 30
       cgp_objectGrowOnOtherObjects,
       cgp_researchOutputMultiplier,
       cgp_produceOnlyResearchedStuffInternally,
       cgp_produceOnlyResearchedStuffExternally };


struct GameParameterSettings {
         const char* name;
         int defaultValue;
         int minValue;
         int maxValue;
         bool changeableByEvent;
         bool legacy;
         const char* longName;
};
extern GameParameterSettings gameParameterSettings[gameparameternum ];
       
class LoadNextMap {
       public:
          int id;
          LoadNextMap( int ID ) : id(ID) {};
};






class OverviewMapHolder : public SigC::Object {
      GameMap& map;
      Surface overviewMapImage;
      Surface completedMapImage;
      bool initialized;
      bool secondMapReady;
      bool completed;
      bool connected;
      int x;
      int y;
      Surface createNewSurface();
      
   protected:   
      bool idleHandler( );
      bool init();
      void drawNextField( bool signalOnCompletion = true );
      bool updateField( const MapCoordinate& pos );
      
   public:
      OverviewMapHolder( GameMap& gamemap );
   
      const Surface& getOverviewMap( bool complete = true );
      
      static void clearmap( GameMap* actmap );
      
      static SigC::Signal0<void> generationComplete;
      
      void resetSize();
            
      void startUpdate();
      void clear( bool allImages = false );
      void connect();
};


class Event;
class PackageData;

class GameMap {
      void operator= ( const GameMap& map );
      bool dialogsHooked;
      int serverMapID;
   public:

      void setServerMapID( int id ) { serverMapID = id; };
      int  getServerMapID() const { return serverMapID; };

      static const int maxTotalPlayers = 8;
      
      int          xsize, ysize;

      int width() const { return xsize; };
      int height() const { return ysize; };

      MapField*       field;

      ASCString    codeWord;

      ASCString    maptitle;

      void setTitle( const ASCString& title ) { maptitle = title; };
      ASCString  getTitle() const { return maptitle; };
      

      struct Campaign {
          bool avail;
         
          int         id;

          bool      directaccess;
          Campaign();
      } campaign;

      signed char  actplayer; 

      GameTime    time;

      struct Weather {
         Weather():windSpeed(0),windDirection(0){};
         int windSpeed;
         int windDirection;
      } weather;

#ifdef WEATHERGENERATOR
      WeatherSystem* weatherSystem;
#endif

      int _resourcemode;


      Player player[9];

      int getPlayerCount() const { return 8; };
      
      Player& getPlayer( PlayerID p )
      {
         return player[p.getID() ];
      }

      const Player& getPlayer( PlayerID p ) const
      {
         return player[p.getID() ];
      }


      Player& getCurrentPlayer()
      {
         return player[actplayer];
      }

      const Player& getCurrentPlayer() const
      {
         return player[actplayer];
      }
      
      int getNeutralPlayerNum() const { return 8; };
      
   private:
      MapCoordinate findFirstContainer() const;
   public:
      
      MapCoordinate& getCursor();
      MapCoordinate getCursor() const;
      

      int eventID;

      typedef PointerList<Event*> Events;
      Events events;

      vector<GameTime> eventTimes;

      int eventpassed ( int saveas, int action, int mapid );
      int eventpassed ( int id, int mapid );

      class IDManager {
            int          unitnetworkid;
            typedef map<int, Vehicle*> VehicleLookupCache;
            VehicleLookupCache vehicleLookupCache; 
            
            friend class SpawnUnit;
            friend class SpawnMine;
            friend class GameMap;
                        
            
         public:
            IDManager() : unitnetworkid(0) {};
            
            int getNewNetworkID();
            void registerUnitNetworkID( Vehicle* veh );
            void unregisterUnitNetworkID( Vehicle* veh );
            
            void readData ( tnstream& stream );
            void writeData ( tnstream& stream ) const;
      } idManager;


      char         levelfinished;

      enum State { 
         Normal,
         // NormalAuto,    /*!< normal operation, without user interaction */
         // NormalManual,  /*!< normal operation, with user interaction  */
         Replay,        
         Destruction    
      } state;


      class ResourceTribute {
        public:
           Resources avail[8][8];
           Resources paid[8][8];

           Resources payStatusLastTurn[8][8];
           bool empty ( );
           void read ( tnstream& stream );
           void write ( tnstream& stream );
      } tribute;

      MessagePntrContainer  unsentmessage;
      bool __loadunsentmessage;

      MessageContainer messages;
      bool __loadmessages;

      int           messageid;

      bool ___loadJournal, ___loadNewJournal, ___loadtitle, ___loadLegacyNetwork;

      void allocateFields ( int x, int y, TerrainType::Weather* terrain = NULL );

      ASCString     gameJournal;
      ASCString     newJournal;
      
      Password      supervisorpasswordcrc;

      class ReplayInfo {
      public:
          ReplayInfo ( void );

          MemoryStreamStorage* guidata[8];
          MemoryStreamStorage* map[8];
          MemoryStream*    actmemstream;

          int stopRecordingActions;
          void read ( tnstream& stream );
          void write ( tnstream& stream );
          
          void closeLogging();
          ~ReplayInfo ( );
          
        };

      ActionContainer actions;
      ActionRecorder* actionRecorder;

      
      AbstractTaskContainer* tasks;
      
      ReplayInfo*  replayinfo;

      bool          __loadreplayinfo;


   private:
      int           playerView;
   public:

      int   getPlayerView() const;
      void  setPlayerView( int player );

      GameTime     lastjournalchange;

      Resources     bi_resource[8];

      struct PreferredFilenames {
        ASCString mapname[8];
        ASCString savegame[8];
      } preferredFileNames;

      int           graphicset;
      int           gameparameter_num;
      int*          game_parameter;

      ASCString     nativeMessageLanguage;
      
      int           mineralResourcesDisplayed;

      class ArchivalInformation {
         public:
            ArchivalInformation() : modifytime ( 0 ) {};
            ASCString author;
            ASCString description;
            ASCString tags;
            ASCString requirements;
            time_t modifytime;
      } archivalInformation;

      class UnitProduction {
         public:
            typedef vector<int> IDsAllowed;
            bool check ( int id );
            IDsAllowed idsAllowed;
      } unitProduction;

      GameMap ( void );

      Vehicle* getUnit ( int x, int y, int nwid );
      Vehicle* getUnit ( int nwid, bool consistencyCheck = true );
      const Vehicle* getUnit ( int nwid, bool consistencyCheck = true ) const;
      ContainerBase* getContainer ( int nwid );
      const ContainerBase* getContainer ( int nwid ) const;
      int  getgameparameter ( GameParameter num ) const;
      void setgameparameter ( GameParameter num, int value );
      void cleartemps( int b = -1, int value = 0 );
      bool isResourceGlobal ( int resource );
      MapField* getField ( int x, int y );
      const MapField* getField ( int x, int y ) const;
      MapField* getField ( const MapCoordinate& pos );
      
      
      
      void startGame ( );

      void beginTurn();
      
      
      void endTurn();

      void endRound();


      SigC::Signal1<void,Player&> sigPlayerTurnBegins;
      SigC::Signal1<void,Player&> sigPlayerUserInteractionBegins;
      SigC::Signal1<void,Player&> sigPlayerUserInteractionEnds;
      SigC::Signal1<void,Player&> sigPlayerTurnEnds;
      SigC::Signal1<void,Player&> sigPlayerTurnHasEnded;
      SigC::Signal1<void,Player&> sigMapWon;

      static SigC::Signal1<void,GameMap&> sigMapCreation;
      static SigC::Signal1<void,GameMap&> sigMapDeletion;
      static SigC::Signal2<void,GameMap*,Player&> sigPlayerTurnEndsStatic;
      
      SigC::Signal1<void,const MapCoodinateVector&> sigCoordinateShift;
      
      SigC::Signal0<void> newRound;


      bool  continueplaying;
      
      

      
            
      
      VisibilityStates getInitialMapVisibility( int player );

      int  resize( int top, int bottom, int left, int right );

      // bool compareResources( GameMap* replaymap, int player, ASCString* log = NULL );

      void calculateAllObjects ( void );

      void read ( tnstream& stream );
      void write ( tnstream& stream );

      OverviewMapHolder overviewMapHolder;


      
      pterraintype getterraintype_byid ( int id );
      ObjectType* getobjecttype_byid ( int id );
      const ObjectType* getobjecttype_byid ( int id ) const;
      VehicleType* getvehicletype_byid ( int id );
      const VehicleType* getvehicletype_byid ( int id ) const;
      BuildingType* getbuildingtype_byid ( int id );
      const BuildingType* getbuildingtype_byid ( int id ) const;
      const Technology* gettechnology_byid ( int id );

      pterraintype getterraintype_bypos ( int pos );
      ObjectType* getobjecttype_bypos ( int pos );
      VehicleType* getvehicletype_bypos ( int pos );
      BuildingType* getbuildingtype_bypos ( int pos );
      const Technology* gettechnology_bypos ( int pos );

      int getTerrainTypeNum ( );
      int getObjectTypeNum ( );
      int getVehicleTypeNum ( );
      int getBuildingTypeNum ( );
      int getTechnologyNum ( );

      
      ~GameMap();

      bool loadOldEvents;

      int random( int max );
      
      void guiHooked();
      bool getGuiHooked() { return dialogsHooked; };

      Properties properties;
      Properties& getProperties() { return properties; };
      
      GameTransferMechanism* network;

      int getMemoryFootprint() const;

      mutable PackageData* packageData;
      
   private:
      Vehicle* getUnit ( Vehicle* eht, int nwid );

      void objectGrowth();
      void setupResources ( void );
      
      void processJournal();

      unsigned int randomSeed;

      static void setPlayerMode( Player& p, State s );
};



#endif

---