Fleet.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(Fleet_h)
#define Fleet_h

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

#include "Rules.h"
#include "Stack.h"

class TiXmlNode;
class Player;
class Planet;
class Ship;
class MineField;
class WaypointOrder;

class WayOrder;
//#include "WayOrder.h"
#include "Galaxy.h"
#include "CargoHolder.h"

class Fleet : public CargoHolder {
public:
        Fleet();
        Fleet(int id, const CargoHolder &loc);
        virtual ~Fleet();

        void Init();
        virtual bool ParseNode(const TiXmlNode * node, Player * player, bool other);
        virtual TiXmlNode * WriteNode(TiXmlNode * node, const Player * viewer) const;

        virtual const string GetName(const Player * viewer) const;
        long GetFuel() const    { return mFuel; }
        long GetFuelNeeded() const;     // fuel needed to make it to the next waypoint (waypoint 2)
        void AdjustFuel(long amount);
        void Refuel()                   { if (mFuel < GetFuelCapacity()) Refuel(InOrbit()); }
        void Refuel(const Planet * p);
        void SetName(const char * n)    { mName = n; }

        enum FuncType {
                FTScrap                 = 1,
                FTUnload0               = 2,
                FTColonize0             = 3,
                FTLoad0                 = 4,
                FTMove                  = 5,
                FTRemoteMine    = 6,
                FTFreighterReproduction = 7,
                FTCheckWaypoint = 8,
                FTRefuel                = 9,
                FTUnload1               = 10,
                FTColonize1             = 11,
                FTLoad1                 = 12,
                FTMerge                 = 13,
                FTClearWaypoint = 14,
                FTRemoteTerraform = 15,
                FTRepair                = 16,
        };
        bool Process(FuncType func, bool arg);
        void Scrap(bool colonize);
        void KillFleet();
        void ProcessTransport(bool load, bool dunnage);
        void Colonize();
        void RemoteMine(bool ARmining);
        bool Move();
        void FreighterReproduction();
        bool Move1LY(Location & dest, long speed);
        void CheckWaypoint();
        void ClearWaypoint();
        void CheckMerge();
        void RemoteTerraform(bool bomb);
        void Repair();

        Planet * InOrbit() const        { return TheGalaxy->GetPlanet(this); }
        virtual long GetCloak(const Player *, bool) const;
        void MergeTo(Fleet * to);
        void MergeTo(Fleet * to, const Ship * design, long number, long damaged);
        bool IsEmpty() const    { return mStacks.size() == 0; }
        const deque<WayOrder *> GetOrders() const               { return mOrders; }
        const WayOrder* GetFirstOrder() { return mOrders[0]; }
        void SetStartOrders(Planet * planet);
        void SetNextRoute(Planet * planet);
        long GetBestSpeed(const Location * L1, const Location * L2, OrderType ot);

        void ChangeWaypoints(WayOrderList & wol);
        void SetRepeat(bool repeat);
        bool GetRepeat() const  { return mRepeatOrders; }
        void SetBattlePlan(long bp);

        void AddChaser(unsigned long p, unsigned long f);
        void TakeMinefieldDamage(MineField * field);

        void SetSeenDesign(long p, bool seen, bool design);
        virtual void ResetSeen();
        virtual void SetSeenBy(long p, bool seen);
        virtual void SetCanLoadBy(const Player * player);
        virtual bool CanLoadBy(const Player * player) const;

        // stuff from components
        long TechLevel(TechType tech) const;
        const Cost & GetCost() const;
        long GetCloaking() const;
        virtual bool CanStealShip() const;
        virtual bool CanStealPlanet() const;
        long GetCargoCapacity() const;
        long GetScanPen() const;
        long GetScanSpace() const;
        long GetFuelCapacity() const;
        long GetFuelGen() const;
        long GetMass() const;
        long GetMaxMass() const;
        double GetMaxTachyon() const;
        long GetSweeping() const;
        long GetMines() const;
        double GetMaxDampener() const;
        double GetMaxRepairRate() const;
        bool DoesRadiate(HabType ht) const;
        double RadDamage() const;
        bool CanColonize() const;
        long GetTerraPower(long type) const;
        long GetMineAmount(long type) const;
        double GetFuelUsage(long speed) const;
        long GetMinSafeSpeed() const;
        long GetMinMaxSpeed() const;
        long GetMinFreeSpeed() const;
        long GetMinBattleSpeed() const;
        bool CanShoot() const;          // Is any ship of this fleet armed
        bool CanNormalBomb() const; // Can any ship do normal bombing
        bool CanSmartBomb() const; // Can any ship smart bomb
        bool CanTerraBomb() const; // Can any ship terra bomb
        bool CanJumpGate() const;
        bool CanBomb() const{return CanNormalBomb() || CanSmartBomb() || CanTerraBomb();}// Can any ship bomb
        void AddShips(long Type, long number);
        bool AlreadyFought() const      { return mAlreadyFought; }
        void SetAlreadyFought()         { mAlreadyFought = true; }
        const BattlePlan * GetBattlePlan() const;
        void SetInBattle(bool in)       { mInBattle = in; }
        bool GetInBattle() const        { return mInBattle; }
        long GetShipCount() const;
        bool KillShips(long i, long count, bool salvage);
        
        double GetNormalKillper() const;
        //long GetSmartKillper() const;
        long GetMinKill() const;
        long GetInstKill() const;

private:
        void Merge(Stack &stack, long number, long damaged, long Origin);

        long mFuel;
        string mName;
        deque<Stack> mStacks;  // stacks of different ships
        long mRepairRate;       // how much this fleet will repair this turn - 0: nothing (gated); 1: fleet moved through space; 2: fleet didn't move
        long mBattlePlan;
        bool mAlreadyFought;
        bool mInBattle;
        bool mHasMoved;
        long mDistMoved;        // distance already moved this turn
        Location mStartPos;     // where this fleet started the turn
        double mPX;     // current location while in flight
        double mPY;     // current location while in flight
        bool mDoneWaypoint;     // true if we've arrived at our destination and are ready to do waypoint 1 tasks

        deque<WayOrder *> mOrders;
        bool mRepeatOrders;

        friend class WayOrder;
        friend class Battle;
        friend class Bombing;

        const Fleet * mChasing;
        class Chaser {
        public:
                unsigned long player;
                unsigned long fleet;
        };

        void AddChaser(const deque<Chaser> &w2);
        deque<Chaser> mChasers;

        deque<MineField *> mPossibleMines;

        // 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.
        deque<bool> mCanLoadBy;

        // Calculated Values
        Cost CVCost;
        long ReCost;
        void ResetDefaults();   // reset all Calculated Values to defaults
        long CVScanPen;
        long CVScanSpace;
        long CVCloaking;
        long CVFuelCapacity;
        long CVFuelGen;
        long CVMass;
        long CVMaxMass;
        bool CCalcMaxMass;
        double CVMaxTachyon;
        bool CCalcMaxTachyon;
        long CVCargoCapacity;
        long CVMines;
        long CVSweeping;

        double CVMaxDampener;
        bool CCalcMaxDampener;
        double CVMaxRepairRate;
        bool CCalcMaxRepairRate;
        long CVMinSafeSpeed;
        long CVMinMaxSpeed;
        long CVMinFreeSpeed;
        long CVMinBattleSpeed;

        long CVColonize;
        long CVStealShip;
        long CVStealPlanet;
        long CVShoot;
        long CVNormalBomb;
        long CVSmartBomb;
        long CVTerraBomb;
        
        double CVNormalKillper;
        bool CCalcNormalKillper;
        //long CVSmartKillper;
        long CVMinKill;
        long CVInstKill;
        long CVJumpGate;

        deque<long> CVTechLevel;
        deque<long> CVMineAmount;
        deque<long> CVRadiation;
};

#endif // !defined(Fleet_h)

---