____                _       __
    / __ )____  _____   | |     / /___ ___________
   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  )
 /_____/\____/____/     |__/|__/\__,_/_/  /____/

       A futuristic real-time strategy game.
          This file is part of Bos Wars.

(C) Copyright 2001-2007 by the Bos Wars and Stratagus Project. Distributed under the "GNU General Public License"

---

player.h

Go to the documentation of this file.

//     ____                _       __               
//    / __ )____  _____   | |     / /___ ___________
//   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
//  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  ) 
// /_____/\____/____/     |__/|__/\__,_/_/  /____/  
//                                              
//       A futuristic real-time strategy game.
//          This file is part of Bos Wars.
//
//
//      (c) Copyright 1998-2007 by Lutz Sammer and Jimmy Salmon
//
//      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; only version 2 of the License.
//
//      This program is distributed in the hope that it will be useful,
//      but WITHOUT ANY WARRANTY; without even the implied warranty of
//      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//      GNU General Public License for more details.
//
//      You should have received a copy of the GNU General Public License
//      along with this program; if not, write to the Free Software
//      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
//      02111-1307, USA.

#ifndef __PLAYER_H__
#define __PLAYER_H__


/*----------------------------------------------------------------------------
--  Documentation
----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
--  Includes
----------------------------------------------------------------------------*/

#include <map>
#include <string>
#include "upgrade_structs.h"
#include "video.h"

/*----------------------------------------------------------------------------
--  Declarations
----------------------------------------------------------------------------*/

class CUnit;
class CUnitType;
class PlayerAi;
class CFile;

/*----------------------------------------------------------------------------
--  Player type
----------------------------------------------------------------------------*/

class CPlayer
{
public:
    int Index;          
    std::string Name;   

    int Type;           
    std::string AiName; 

    // friend enemy detection
    int      Team;          
    unsigned Enemy;         
    unsigned Allied;        
    unsigned SharedVision;  

    int StartX;  
    int StartY;  
    inline void SetStartView(int x, int y) { StartX = x; StartY = y; }

    std::map<CUnit *, int *> UnitsConsumingResourcesActual;
    std::map<CUnit *, int *> UnitsConsumingResourcesRequested;
    int ProductionRate[MaxCosts];           
    int ActualUtilizationRate[MaxCosts];    
    int RequestedUtilizationRate[MaxCosts]; 
    int StoredResources[MaxCosts];          
    int StorageCapacity[MaxCosts];          

    inline void SetEnergyProductionRate(int v) { ProductionRate[EnergyCost] = v; }
    inline int GetEnergyProductionRate() { return ProductionRate[EnergyCost]; }
    inline void SetMagmaProductionRate(int v) { ProductionRate[MagmaCost] = v; }
    inline int GetMagmaProductionRate() { return ProductionRate[MagmaCost]; }

    inline void SetEnergyStored(int v) { StoredResources[EnergyCost] = CYCLES_PER_SECOND * v; }
    inline int GetEnergyStored() { return StoredResources[EnergyCost] / CYCLES_PER_SECOND; }
    inline void SetMagmaStored(int v) { StoredResources[MagmaCost] = CYCLES_PER_SECOND * v; }
    inline int GetMagmaStored() { return StoredResources[MagmaCost] / CYCLES_PER_SECOND; }

    inline void SetEnergyStorageCapacity(int v) { StorageCapacity[EnergyCost] = CYCLES_PER_SECOND * v; }
    inline int GetEnergyStorageCapacity() { return StorageCapacity[EnergyCost] / CYCLES_PER_SECOND; }
    inline void SetMagmaStorageCapacity(int v) { StorageCapacity[MagmaCost] = CYCLES_PER_SECOND * v; }
    inline int GetMagmaStorageCapacity() { return StorageCapacity[MagmaCost] / CYCLES_PER_SECOND; }

    void AddToUnitsConsumingResources(CUnit *unit, int costs[MaxCosts]);
    void RemoveFromUnitsConsumingResources(CUnit *unit);
    void UpdateUnitsConsumingResources(CUnit *unit, int costs[MaxCosts]);
    void RebuildUnitsConsumingResourcesList();
    void ClearResourceVariables();

    // FIXME: shouldn't use the constant
    int UnitTypesCount[UnitTypeMax];  

    int   AiEnabled;       
    PlayerAi *Ai;          

    CUnit *Units[UnitMax]; 
    int    TotalNumUnits;  
    int    NumBuildings;   

    int    UnitLimit;       
    int    BuildingLimit;   
    int    TotalUnitLimit;  

    int    Score;           
    int    TotalUnits;
    int    TotalBuildings;
    int    TotalResources[MaxCosts];
    int    TotalRazings;
    int    TotalKills;      

    inline void SetTotalEnergy(int v) { TotalResources[EnergyCost] = CYCLES_PER_SECOND * v; }
    inline int GetTotalEnergy() { return TotalResources[EnergyCost] / CYCLES_PER_SECOND; }
    inline void SetTotalMagma(int v) { TotalResources[MagmaCost] = CYCLES_PER_SECOND * v; }
    inline int GetTotalMagma() { return TotalResources[MagmaCost] / CYCLES_PER_SECOND; }

    Uint32 Color;           

    CUnitColors UnitColors; 

    // Allows:
    CAllow Allow;           


    void SetName(const std::string &name);

    void Clear();

    void SetResource(int resource, int value);

    int CheckLimits(const CUnitType *type) const;

    int HaveUnitTypeByType(const CUnitType *type) const;
    int HaveUnitTypeByIdent(const std::string &ident) const;

    void Notify(int type, int x, int y, const char *fmt, ...) const;

    bool IsEnemy(const CPlayer *x) const;
    bool IsEnemy(const CUnit *x) const;
    bool IsAllied(const CPlayer *x) const;
    bool IsAllied(const CUnit *x) const;
    bool IsSharedVision(const CPlayer *x) const;
    bool IsSharedVision(const CUnit *x) const;
    bool IsBothSharedVision(const CPlayer *x) const;
    bool IsBothSharedVision(const CUnit *x) const;
    bool IsTeamed(const CPlayer *x) const;
    bool IsTeamed(const CUnit *x) const;
};


enum PlayerTypes {
    PlayerNeutral = 2,        
    PlayerNobody  = 3,        
    PlayerComputer = 4,       
    PlayerPerson = 5,         
    PlayerRescuePassive = 6,  
    PlayerRescueActive = 7,   
};

#define PlayerNumNeutral (PlayerMax - 1)  


enum NotifyType {
    NotifyRed,     
    NotifyYellow,  
    NotifyGreen,   
};

/*----------------------------------------------------------------------------
--  Variables
----------------------------------------------------------------------------*/

extern int NumPlayers;             
extern CPlayer Players[PlayerMax];  
extern CPlayer *ThisPlayer;         
extern int NoRescueCheck;          
extern SDL_Color *PlayerColorsRGB[PlayerMax]; 
extern Uint32 *PlayerColors[PlayerMax];       
extern std::string PlayerColorNames[PlayerMax];  

extern int PlayerColorIndexStart;
extern int PlayerColorIndexCount;

/*----------------------------------------------------------------------------
--  Functions
----------------------------------------------------------------------------*/

extern void InitPlayers(void);
extern void CleanPlayers(void);
#ifdef DEBUG
extern void FreePlayerColors();
#endif
extern void SavePlayers(CFile *file);

extern void CreatePlayer(int type);


extern void PlayersInitAi(void);
extern void PlayersEachCycle(void);
extern void PlayersEachSecond(int player);

extern void GraphicPlayerPixels(CPlayer *player, const CGraphic *sprite);

void CalculateRequestedAmount(CUnitType *utype, int bcosts[MaxCosts], int costs[MaxCosts]);

extern void DebugPlayers(void);

extern void PlayerCclRegister(void);

#define CanSelectMultipleUnits(player) \
    ((player) == ThisPlayer || ThisPlayer->IsTeamed((player)))


#endif // !__PLAYER_H__

---