Planet.h

Go to the documentation of this file.

/*
Copyright 2003 - 2005 Elliott Kleinrock, Dan Neely, Kurt W. Over, Damon Domjan

This file is part of FreeStars, a free clone of the Stars! game.

FreeStars 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.

FreeStars 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 FreeStars; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

The full GPL Copyright notice should be in the file COPYING.txt

Contact:
Email Elliott at 9jm0tjj02@sneakemail.com
*/

#if !defined(Planet_h)
#define Planet_h

#include <string>
#include <deque>
using namespace std;

class Ship;
class Message;
class Creation;
class ProductionOrder;
#include "Player.h"
#include "Rules.h"

#include "CargoHolder.h"
#include "Invasion.h"
//#include "ProdOrder.h"
class ProdOrder;

class Planet : public CargoHolder {
public:
        Planet();
//      Planet(int x, int y);
        virtual ~Planet();
        virtual bool ParseNode(const TiXmlNode * node);
        virtual TiXmlNode * WriteNode(TiXmlNode * node, const Player * viewer) const;
        void Init();
        void SetDestinations();

        void AddScrapRes(int amount)    { mScrapRes += amount; }
        long GetBaseNumber() const              { return mBaseDesign; }
        void SetBaseNumber(long n);
        const Ship * GetBaseDesign() const      { return GetOwner()->GetBaseDesign(mBaseDesign); }
        long GetBaseDamage() const              { return mBaseDamage; }
        void SetBaseDamage(long bd)             { mBaseDamage = bd; }
        virtual const string GetName(const Player *) const      { return mName; }
        const string GetName() const    { return mName; }
        static const string SGetName(Planet * p)        { return p->GetName(); }
        static const string SGetName(const Planet * p)  { return p->GetName(); }
        long GetResources() const;
        virtual long GetCargoCapacity() const           { return -1; }
        void Invade(Player * invader, long amount);
        void ResolveInvasion();
        void TakePlanet(Player * invader, long amount);
        void DeadCheck();
        void Kill();

        void AdjustDefenses(long amount);
        void AdjustFactories(long amount);
        void AdjustMines(long amount);
        virtual long GetCloak(const Player *, bool) const       { return 0; }
        virtual double GetMaxTachyon() const;
        virtual long GetScanPen() const;
        virtual long GetScanSpace() const;
        const Planet * GetRoute() const         { return mRouteTo; }
        Planet * GetPacketDest()                        { return mPacketDest; }
        const Planet * GetPacketDest() const      { return mPacketDest; }
        int GetPacketSpeed() const                              { return mPacketSpeed; }
        friend bool operator==(const Planet & p1, const Planet & p2)    { return p1.mName == p2.mName; }
        friend bool operator!=(const Planet & p1, const Planet & p2)    { return p1.mName != p2.mName; }
        double GetDefenseValue() const;
        double GetSmartDefenseValue() const;
        double GetInstallationDefenseValue() const      { return GetDefenseValue() / 2; }
        double GetDisplayDef() const;
        long GetDisplayPop() const;
        long GetMaxPop() const;
        void Mine();
        void Mine(long mines, const Player * miner);
        void DoProduction();
        long PopGrowth() const;
        void BuildFactories(long number)        { mFactories += number; mBuiltFactories += number; }
        void BuildMines(long number)            { mMines += number; mBuiltMines += number; }
        void BuildDefenses(long number)         { mDefenses += number; mBuiltDefenses += number; }
        void BuildAlchemy(long number)          { mBuiltAlchemy += number; }
        void BuildScanner()                                     { mScanner = true; }
        long GetFactories() const                       { return mFactories; }
        long GetMines() const                           { return mMines; }
        long GetDefenses() const                        { return mDefenses; }
        bool GetScanner() const                         { return mScanner; }
        long GetMinConc(long type) const                { return type < 0 || type >= Rules::MaxMinType ? 0 : mMinConc[type]; }
        long GetMineProgress(long type) const   { return type < 0 || type >= Rules::MaxMinType ? 0 : mMinMined[type]; }
        Message* AddMessageOwner(string type) {return NCGetOwner()->AddMessage(type);}; // Add a message to owner of planet
        long MaxFactories() const;
        long MaxMines() const;
        long MaxDefenses() const;
        long CanTerraform(const Component * comp) const;
        long CanTerraform(HabType ht, long max) const;

        virtual void SetCanLoadBy(const Player * player)        { mCanLoadBy[player->GetID()-1] = true; }
        virtual bool CanLoadBy(const Player * player) const     { return mCanLoadBy[player->GetID()-1]; }
        long GetHabValue(HabType ht) const      { return mHabTerra[ht]; }
        bool Terraform(const Player * player, bool positive);           // Terraforms a world 1 tick, and returns true if any change was made

        Cost GetPacketCost(long type) const;
        virtual void ResetSeen();

        void CreateRandom(Creation * c);
        void CreateHW(const Player * player);
        void AdjustHW(Player * player);
        void CreateSecondWorld(const Planet * HW);
        void AdjustSecondWorld(Player * player);
        void ParseProduction(const TiXmlNode * node);
        void SetProduction(const deque<ProdOrder *> & ords);
        void SetPayTax(bool paytax);
        void SetInBattle()      { mHadBattle = true; }
        void RepairBase();
        void Instaform();
        void RemoteTerraform(Fleet * fleet, bool bomb);

        void SetPacketSpeed(int speed);
        void SetPacketDest(Planet * pdest);
        void SetRoute(const Planet * rdest);

        friend bool operator ==(const Planet &a, const char * b)        { return a.mName == b; }
        friend bool operator !=(const Planet &a, const char * b)        { return !(a == b); }

private:
        void DeleteProdQ();
        void CopyProdQ(const deque<ProdOrder *> &prod);
        string mName;
        long mScrapRes;
        long mBaseDesign;
        long mFactories;
        long mMines;
        deque<long> mMinConc;
        deque<long>     mMinMined;      // amount of mines on this concentration
        bool mScanner;
        long mDefenses;
        const Planet * mRouteTo;
        Planet * mPacketDest;
        string mRouteName;      // temp till we read in all planets;
        string mPacketName;     // temp till we read in all planets;
        long mPacketSpeed;
        long mBaseDamage;
        deque<ProdOrder *> mProductionQ;
        deque<Invasion> mInvasions;
        deque<long> mHabTerra;
        deque<long> mHabStart;
        long mArtifactType;
        long mArtifactAmount;
        bool mPayTax;
        bool mHomeWorld;
        long mBuiltFactories;
        long mBuiltMines;
        long mBuiltDefenses;
        long mBuiltAlchemy;
        long mDisplayPop;
        bool mHadBattle;

        // true if a player # can load from this (can a ship in the same location steal from it, or is a ship remote mining it)
        // set to true or false on the end of movement for thieving capabilities. Set to true when mining planets for remote miners
        deque<bool> mCanLoadBy;

        friend class ProdOrder;
};

const TechType ARTI_NONE                = -1;
const TechType ARTI_ALL                 = -2;   // give amount to all fields
const TechType ARTI_RANDTYPE    = -3;   // give all to a random field
const TechType ARTI_RANDSPLIT   = -4;   // divide amount into Rules::MaxTechType * 2 parts and assign them randomly

#endif // !defined(Planet_h)

---