player.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 playerH
 #define playerH

 #include <vector>

 #include "typen.h"
 #include "vehicle.h"
 #include "buildings.h"
 #include "basestrm.h"
 #include "research.h"
 #include "password.h"
 #include "messages.h"
 #include "networkinterface.h"
 #include "playercolor.h"
 

class Player;


class PlayerID {
      int num;
   public:
      PlayerID( int num ) { this->num = num; };
      PlayerID( const ContainerBase* c ) : num( c->getOwner() ) {};
      PlayerID( const ContainerBase& c ) : num( c.getOwner() ) {};
      PlayerID( const Player& p );
      PlayerID( const PlayerID& p ) : num( p.getID() ) {};
      int getID() const { return num; };
};


const int diplomaticStateNum = 5;
enum DiplomaticStates { WAR, TRUCE, PEACE, PEACE_SV, ALLIANCE };
extern const char* diplomaticStateNames[diplomaticStateNum+1];


class DiplomaticStateVector : public SigC::Object {

      friend class AllianceSetupWidget;
      friend class ChangeDiplomaticState;
      friend class DiplomacyCommand;

      Player& player; 
      
      typedef vector<DiplomaticStates> States;
      States states;
      
       
      typedef map<int,DiplomaticStates> QueuedStateChanges;
      QueuedStateChanges queuedStateChanges;

      void resize( int size );
      
   public:
      DiplomaticStateVector( Player& _player );
      
      DiplomaticStates getState( PlayerID towardsPlayer ) const;
      void setState( PlayerID towardsPlayer, DiplomaticStates s );
      
      bool isHostile( PlayerID towardsPlayer ) const { return getState( towardsPlayer.getID() ) == WAR; };
      bool sharesView( PlayerID receivingPlayer ) const { return getState( receivingPlayer.getID() ) >= PEACE_SV; };
      bool isAllied( PlayerID towardsPlayer ) const { return getState( towardsPlayer.getID() ) >= ALLIANCE; };

      void turnBegins();
      
      void swap( int secondPlayer );
            
      bool getProposal( int fromPlayer, DiplomaticStates* state );
      
      void read ( tnstream& stream );
      void write ( tnstream& stream ) const;
};

class GameMap;


class Player : public SigC::Object {
      int player;
      GameMap* parentMap;
      
      void turnBegins( Player& p );
      void userInteractionBegins( Player& p );
      void turnEnds( Player& p );
      
      int serverPlayerID;

   public:
      Player();

      int getPosition() const { return player; };
      
      const GameMap* getParentMap() const { return parentMap; };
      GameMap* getParentMap() { return parentMap; };
      
      void setParentMap( GameMap* map, int pos );
      

      void swap ( Player& secondPlayer );

      void merge( Player& secondPlayer );


      bool         exist() const;

      bool existanceAtBeginOfTurn;

      typedef list<Vehicle*> VehicleList;
      VehicleList  vehicleList;

      typedef list<Building*> BuildingList;
      BuildingList  buildingList;

      Research    research;
      
      Research& getResearch() { return research; };

      BaseAI*      ai;

      enum PlayerStatus { human, computer, off, supervisor, suspended } stat;
      
      bool isHuman() const { return stat == human || stat == supervisor || stat == suspended; };

      static int getHumanPlayerNum( const GameMap* gamemap );

      static const char* playerStatusNames[];

      ASCString getName( ) const;
      void setName( const ASCString& name ) { this->name = name; };

      Password passwordcrc;

      class Dissection {
         public:
            VehicleType*  fzt;
            const Technology*   tech;
            int           orgpoints;
            int           points;
            int           num;
      };

      typedef list<Dissection> DissectionContainer;
      DissectionContainer dissections;

      bool __dissectionsToLoad;

      MessagePntrContainer  unreadmessage;
      bool __loadunreadmessage;

      MessagePntrContainer  oldmessage;
      bool __loadoldmessage;

      MessagePntrContainer  sentmessage;
      bool __loadsentmessage;

      int queuedEvents;

      int ASCversion;

      struct PlayTime {
         int turn;
         time_t date;
      };
      typedef list<PlayTime> PlayTimeContainer;

      PlayTimeContainer playTime;

      MapCoordinate cursorPos;

      DiplomaticStateVector diplomacy;
      
      ASCString email;
                  
      DI_Color getColor() const;
      PlayerColor getPlayerColor() const;
      void setColor( const DI_Color& color ); 

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

      void resetView();
      void resetResearch();
      void resetTribute();
      void resetPassword();

      bool operator==( const Player& otherPlayer) const;
      
      void setPlayerID( int id ) { serverPlayerID = id; };
      int getPlayerID() const { return serverPlayerID; };
      
   private:   
      ASCString       name;
      DI_Color        color;
      void sendQueuedMessages();
};



#endif

---