Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members  

item.h

00001 // $Id: item_8h-source.html,v 1.2 2002/06/20 17:09:51 mkrohn5 Exp $
00002 //
00003 // Item Header File
00004 // Written by: Marco Krohn <marco.krohn@gmx.de>
00005 //             Ralf Laue <ralf.laue@gmx.de>,
00006 //
00007 // Copyright (C) 1999 - 2001, Marco Krohn <marco.krohn@gmx.de>
00008 //                            Ralf Laue <ralf.laue@gmx.de>,
00009 //
00010 // This program is free software; you can redistribute it and/or modify
00011 // it under the terms of the GNU General Public License as published by
00012 // the Free Software Foundation; either version 1, or (at your option)
00013 // any later version.
00014 //
00015 // This program is distributed in the hope that it will be useful,
00016 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00017 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018 // GNU General Public License for more details.
00019 
00020 #ifndef __ITEM_INCLUDED
00021 #define __ITEM_INCLUDED
00022 
00023 #include "common/defs.h"
00024 #include "common/link.h"
00025 #include "common/plist.h"
00026 #include "gamelogic/substance.h"
00027 #include <vector>
00028 
00029 /********************************* class TItem *********************************/
00030 
00031 
00060 class TItem : public TLinkable
00061 {
00062   public:
00066     typedef enum
00067     {
00068       STL_ENGINE         = 0x00000001,
00069       FTL_ENGINE         = 0x00000002,
00070       FUELTANK           = 0x00000004,
00071       FUELSCOOP          = 0x00000008,
00072       CARGOBAY           = 0x00000010,
00073       COLONIZER          = 0x00000020,
00074       REPAIRBOT          = 0x00000040,
00075       ARMOR              = 0x00000080,
00076       SHIELD             = 0x00000100,
00077       KWEAPON            = 0x00000200,
00078       EWEAPON            = 0x00000400,
00079       TARGETINGCOMPUTER  = 0x00000800,
00080       SCANNER            = 0x00001000,
00081       JAMMER             = 0x00002000,
00082       MINELAYER          = 0x00004000,
00083       MININGBOT          = 0x00008000,
00084       FIGHTERLAUNCHER    = 0x00010000,
00085       SPWEAPONLAUNCHER   = 0x00020000
00086     } tItemType;
00094     typedef int2 tWeaponType;
00097     TItem();
00101     TItem( const TItem& OldItem );
00105     virtual ~TItem();
00110     virtual int2 getType() const;
00115     virtual const string& getTypeName() const;
00125     virtual bool load( TDataPackageList* in );
00135     virtual bool save( TDataPackageList* out ) const;
00140     virtual TItem::tItemType getItemType() const = 0;
00143     virtual void setItemName( const string& Name );
00146     virtual const string& getItemName() const;
00149     virtual void setTechLevel( const int2 TechLevel );
00154     virtual int2 getTechLevel() const;
00157     virtual void setMass( const int2 Mass );
00160     virtual int2 getMass() const;
00163     virtual void setVolume( const int2 Volume );
00166     virtual int2 getVolume() const;
00169     virtual void setSurface( const int2 Surface);
00172     virtual int2 getSurface() const;
00176     virtual void setCost( const TSubstanceSet& Cost );
00180     virtual void getCost( TSubstanceSet* Cost ) const;
00186     virtual bool operator==( const TItem& Item ) const;
00187   protected:
00189     virtual TItem& operator=( const TItem& Item );
00191     string fItemName;
00193     int2 fTechLevel;
00195     int2 fItemMass;
00197     int2 fItemVolume;
00199     int2 fItemSurface;
00201     TSubstanceSet fItemCost;
00202 };
00203 
00204 
00205 
00206 /****************************** class TSTLEngine *******************************/
00207 
00208 
00209 
00222 class TSTLEngine : public TItem
00223 {
00224   public:
00228     TSTLEngine();
00233     TSTLEngine( const TSTLEngine& OldSTLEngine );
00236     virtual ~TSTLEngine();
00243     virtual bool load( TDataPackageList* in );
00250     virtual bool save( TDataPackageList* out ) const;
00254     virtual TItem::tItemType getItemType() const;
00257     virtual void setSTLPower( const int2 STLPower );
00261     virtual int2 getSTLPower() const;
00266     virtual bool operator==( const TSTLEngine& STLEngine ) const;
00268     virtual TSTLEngine& operator=( const TSTLEngine& STLEngine );
00269   protected:
00271     int2 fSTLEnginePower;
00272 };
00273 
00274 
00275 
00276 /****************************** class TFTLEngine *******************************/
00277 
00278 
00279 
00292 class TFTLEngine : public TItem
00293 {
00294   public:
00298     TFTLEngine();
00303     TFTLEngine( const TFTLEngine& OldFTLEngine );
00306     virtual ~TFTLEngine();
00313     virtual bool load( TDataPackageList* in );
00320     virtual bool save( TDataPackageList* out ) const;
00324     virtual TItem::tItemType getItemType() const;
00327     virtual void setFTLPower( const int2 FTLPower );
00331     virtual int2 getFTLPower() const;
00336     virtual bool operator==( const TFTLEngine& FTLEngine ) const;
00338     virtual TFTLEngine& operator=( const TFTLEngine& FTLEngine );
00339   protected:
00341     int2 fFTLEnginePower;
00342 };
00343 
00344 
00345 
00346 /****************************** class TFuelTank ********************************/
00347 
00348 
00349 
00364 class TFuelTank : public TItem
00365 {
00366   public:
00370     TFuelTank();
00375     TFuelTank( const TFuelTank& OldFuelTank );
00378     virtual ~TFuelTank();
00385     virtual bool load( TDataPackageList* in );
00392     virtual bool save( TDataPackageList* out ) const;
00396     virtual TItem::tItemType getItemType() const;
00400     virtual void setTankCapacity( const int2 Capacity );
00404     virtual int2 getTankCapacity() const;
00410     virtual bool operator==( const TFuelTank& FuelTank ) const;
00412     virtual TFuelTank& operator=( const TFuelTank& FuelTank );
00413   protected:
00415     int2 fTankCapacity;
00416 };
00417 
00418 
00419 
00420 /****************************** class TFuelScoop *******************************/
00421 
00422 
00423 
00437 class TFuelScoop : public TItem
00438 {
00439   public:
00443     TFuelScoop();
00448     TFuelScoop( const TFuelScoop& OldFuelScoop );
00451     virtual ~TFuelScoop();
00458     virtual bool load( TDataPackageList* in );
00465     virtual bool save( TDataPackageList* out ) const;
00469     virtual TItem::tItemType getItemType() const;
00473     virtual void setScoopCapacity( const int2 Capacity );
00477     virtual int2 getScoopCapacity() const;
00482     virtual bool operator==( const TFuelScoop& FuelScoop ) const;
00484     virtual TFuelScoop& operator=( const TFuelScoop& FuelScoop );
00485   protected:
00487     int2 fScoopCapacity;
00488 };
00489 
00490 
00491 
00492 /****************************** class TCargoBay ********************************/
00493 
00494 
00495 
00508 class TCargoBay : public TItem
00509 {
00510   public:
00514     TCargoBay();
00519     TCargoBay( const TCargoBay& OldCargoBay );
00526     virtual bool load( TDataPackageList* in );
00533     virtual bool save( TDataPackageList* out ) const;
00536     virtual ~TCargoBay();
00540     virtual TItem::tItemType getItemType() const;
00545     virtual bool operator==( const TCargoBay& CargoBay ) const;
00547     virtual TCargoBay& operator=( const TCargoBay& CargoBay );
00548 };
00549 
00550 
00551 
00552 /****************************** class TColonizer *******************************/
00553 
00554 
00555 
00570 class TColonizer : public TItem
00571 {
00572   public:
00576     TColonizer();
00581     TColonizer( const TColonizer& OldColonizer );
00584     virtual ~TColonizer();
00591     virtual bool load( TDataPackageList* in );
00598     virtual bool save( TDataPackageList* out ) const;
00602     virtual TItem::tItemType getItemType() const;
00608     virtual bool operator==( const TColonizer& Colonizer ) const;
00610     virtual TColonizer& operator=( const TColonizer& Colonizer );
00611 };
00612 
00613 
00614 
00615 /****************************** class TRepairBot *******************************/
00616 
00617 
00618 
00632 class TRepairBot : public TItem
00633 {
00634   public:
00638     TRepairBot();
00643     TRepairBot( const TRepairBot& OldRepairBot );
00646     virtual ~TRepairBot();
00653     virtual bool load( TDataPackageList* in );
00660     virtual bool save( TDataPackageList* out ) const;
00664     virtual TItem::tItemType getItemType() const;
00667     virtual void setRepairSpeed( const int2 RepairSpeed );
00671     virtual int2 getRepairSpeed() const;
00677     virtual bool operator==( const TRepairBot& RepairBot ) const;
00679     virtual TRepairBot& operator=( const TRepairBot& RepairBot );
00680   protected:
00682     int2 fRepairSpeed;
00683 };
00684 
00685 
00686 
00687 /*******************************************************************************/
00688 /************************** A R M O R  &  S H I E L D S ************************/
00689 /*******************************************************************************/
00690 
00691 
00692 
00693 /******************************** TEfficiencyToken *****************************/
00694 
00695 
00696 
00708 class TEfficiencyToken
00709 {
00710   public:
00715     TEfficiencyToken();
00718     TEfficiencyToken( TEfficiencyToken& OldToken );
00721     ~TEfficiencyToken();
00726     void setWeaponType( TItem::tWeaponType WeaponType );
00730     TItem::tWeaponType getWeaponType() const;
00734     void setEfficiency( int2 Efficiency );
00738     int2 getEfficiency() const;
00743     bool operator==( const TEfficiencyToken& Token ) const;
00745     TEfficiencyToken& operator=( const TEfficiencyToken& Token );
00755     bool load( TDataPackageList* in, const string& sIdentifier, bool bUnique=true );
00765     bool save( TDataPackageList* out, const string& sIdentifier, bool bUnique=true ) const;
00766   protected:
00768     TItem::tWeaponType fWeaponType;
00770     int2 fEfficiency;   
00771 }; // class TEfficiencyToken
00772 
00773 
00774 
00775 /********************************** TDefenseType *******************************/
00776 
00777 
00778 
00804 class TDefenseType : public TLinkable
00805 {
00806   public:
00811     TDefenseType();
00816     TDefenseType( const int2 StandardEfficiency );
00821     TDefenseType( const TDefenseType& OldDefenseType );
00824     virtual ~TDefenseType() = 0;
00833     virtual bool load( TDataPackageList* in );
00842     virtual bool save( TDataPackageList* out ) const;
00847     virtual void setStandardEfficiency( const int2 StandardEfficiency );
00851     virtual int2 getStandardEfficiency() const;
00857     virtual void setDefenseEfficiency( const TItem::tWeaponType WeaponType, const int2 Efficiency );
00862     virtual int2 getDefenseEfficiency( const TItem::tWeaponType WeaponType ) const;
00871     virtual bool operator==( const TDefenseType& DefenseType ) const;
00872   protected:
00874     virtual TDefenseType& operator=( const TDefenseType& DefenseType );
00877     typedef TPEList<TEfficiencyToken>::const_iterator tEfficienciesIteratorConst;
00880     typedef TPEList<TEfficiencyToken>::iterator tEfficienciesIterator;
00882     int2 fStandardEfficiency;
00885     TPEList<TEfficiencyToken> fEfficiencies;
00886 };
00887 
00888 
00889 
00890 /*********************************** TArmorType ********************************/
00891 
00892 
00893 
00915 class TArmorType : public TDefenseType
00916 {
00917   public:
00922     TArmorType();
00927     TArmorType( const int2 StandardEfficiency );
00932     TArmorType( const TArmorType& OldArmorType );
00935     virtual ~TArmorType();
00944     virtual bool load( TDataPackageList* in );
00953     virtual bool save( TDataPackageList* out ) const;
00958     virtual bool operator==( const TArmorType& ArmorType ) const;
00960     virtual TArmorType& operator=( const TArmorType& ArmorType );
00961 };
00962 
00963 
00964 
00965 /*********************************** TShieldType ********************************/
00966 
00967 
00968 
00994 class TShieldType : public TDefenseType
00995 {
00996   public:
01001     TShieldType();
01006     TShieldType( const int2 StandardEfficiency );
01011     TShieldType( const TShieldType& OldShieldType );
01014     virtual ~TShieldType();
01023     virtual bool load( TDataPackageList* in );
01032     virtual bool save( TDataPackageList* out ) const;
01036     virtual void setRegenerationRate( int2 RegenerationRate );
01040     virtual int2 getRegenerationRate() const;
01045     virtual bool operator==( const TShieldType& ShieldType ) const;
01047     virtual TShieldType& operator=( const TShieldType& ShieldType );
01048   protected:
01050     int2 fRegenerationRate;
01051 };
01052 
01053 
01054 
01055 /********************************* class TArmor ********************************/
01056 
01057 
01058 
01075 class TArmor : public TItem
01076 {
01077   public:
01081     TArmor();
01086     TArmor( const TArmor& OldArmor );
01089     virtual ~TArmor();
01096     virtual bool load( TDataPackageList* in );
01103     virtual bool save( TDataPackageList* out ) const;
01107     virtual TItem::tItemType getItemType() const;
01110     virtual void setHitPoints( const int2 HitPoints );
01114     virtual int2 getHitPoints() const;
01118     virtual void setArmorType( TArmorType* ArmorType );
01122     virtual const TArmorType* getArmorType() const;
01127     virtual int2 getArmorEfficiency( const TItem::tWeaponType WeaponType ) const;
01132     virtual bool operator==( const TArmor& Armor ) const;
01134     virtual TArmor& operator=( const TArmor& Armor );
01135   protected:
01137     int2 fHitPoints;
01139     TLink<TArmorType> fArmorType;
01140 };
01141 
01142 
01143 
01144 
01145 /******************************** class TShield ********************************/
01146 
01147 
01148 
01165 class TShield : public TItem
01166 {
01167   public:
01171     TShield();
01176     TShield( const TShield& OldShield );
01179     virtual ~TShield();
01186     virtual bool load( TDataPackageList* in );
01193     virtual bool save( TDataPackageList* out ) const;
01197     virtual TItem::tItemType getItemType() const;
01200     virtual void setHitPoints( const int2 HitPoints );
01204     virtual int2 getHitPoints() const;
01208     virtual void setShieldType( TShieldType* ShieldType );
01212     virtual const TShieldType* getShieldType() const;
01217     virtual int2 getShieldEfficiency( const TItem::tWeaponType WeaponType ) const;
01222     virtual bool operator==( const TShield& Shield ) const;
01224     virtual TShield& operator=( const TShield& Shield );
01225   protected:
01227     int2 fHitPoints;
01229     TLink<TShieldType> fShieldType;
01230 };
01231 
01232 
01233 
01234 /*******************************************************************************/
01235 /******************************** W E A P O N S ********************************/
01236 /*******************************************************************************/
01237 
01238 /******************************** class TWeapon ********************************/
01239 
01240 
01241 
01255 class TWeapon : public TItem
01256 {
01257   public:
01260     TWeapon();
01264     TWeapon( const TWeapon& OldWeapon );
01268     virtual ~TWeapon();
01275     virtual bool load( TDataPackageList* in );
01282     virtual bool save( TDataPackageList* out ) const;
01287     virtual TItem::tItemType getItemType() const = 0;
01290     virtual void setDamagePoints( const int2 DamagePoints );
01294     virtual int2 getDamagePoints() const;
01298     virtual void setRateOfFire( const int2 RateOfFire );
01302     virtual int2 getRateOfFire() const;
01305     virtual void setWeaponType( const TItem::tWeaponType WeaponType );
01308     virtual TItem::tWeaponType getWeaponType() const;
01313     virtual bool operator==( const TWeapon& Weapon ) const;
01314   protected:
01316     virtual TWeapon& operator=( const TWeapon& Weapon );
01318     int2 fDamagePoints;
01320     int2 fRateOfFire;
01322     TItem::tWeaponType fWeaponType;
01323 };
01324 
01325 
01326 
01327 /******************************* class TKWeapon ********************************/
01328 
01329 
01330 
01348 class TKWeapon : public TWeapon
01349 {
01350   public:
01354     TKWeapon();
01359     TKWeapon( const TKWeapon& OldKWeapon );
01362     virtual ~TKWeapon();
01369     virtual bool load( TDataPackageList* in );
01376     virtual bool save( TDataPackageList* out ) const;
01380     virtual TItem::tItemType getItemType() const;
01384     virtual void setVelocity( const int4 Velocity );
01388     virtual int4 getVelocity() const;
01393     virtual void setAmmunitionSize( const int2 AmmunitionSize );
01398     virtual int2 getAmmunitionSize() const;
01403     virtual bool operator==( const TKWeapon& KWeapon ) const;
01405     virtual TKWeapon& operator=( const TKWeapon& KWeapon );
01406   protected:
01408     int4 fVelocity;
01410     int2 fAmmunitionSize;
01411 };
01412 
01413 
01414 
01415 /******************************* class TEWeapon ********************************/
01416 
01417 
01418 
01436 class TEWeapon : public TWeapon
01437 {
01438   public:
01442     TEWeapon();
01447     TEWeapon( const TEWeapon& OldEWeapon );
01450     virtual ~TEWeapon();
01457     virtual bool load( TDataPackageList* in );
01464     virtual bool save( TDataPackageList* out ) const;
01468     virtual TItem::tItemType getItemType() const;
01472     virtual void setEfficientRange( const int4 EfficientRange );
01476     virtual int4 getEfficientRange() const;
01481     virtual bool operator==( const TEWeapon& EWeapon ) const;
01483     virtual TEWeapon& operator=( const TEWeapon& EWeapon );
01484   protected:
01486     int4 fEfficientRange;
01487 };
01488 
01489 
01490 
01491 /************************** class TTargetingComputer ***************************/
01492 
01493 
01494 
01507 class TTargetingComputer : public TItem
01508 {
01509   public:
01514     TTargetingComputer();
01521     TTargetingComputer( const TTargetingComputer& OldTargetingComputer );
01524     virtual ~TTargetingComputer();
01531     virtual bool load( TDataPackageList* in );
01538     virtual bool save( TDataPackageList* out ) const;
01542     virtual TItem::tItemType getItemType() const;
01546     virtual void setAimingEfficiency( const int2 AimingEfficiency );
01550     virtual int2 getAimingEfficiency() const;
01558     virtual bool operator==( const TTargetingComputer& TargetingComputer ) const;
01560     virtual TTargetingComputer& operator=( const TTargetingComputer& TargetingComputer );
01561   protected:
01563     int2 fAimingEfficiency;
01564 };
01565 
01566 
01567 
01568 /******************************* class TScanner ********************************/
01569 
01570 
01571 
01587 class TScanner : public TItem
01588 {
01589   public:
01593     typedef enum
01594     {
01595       NORMAL_ACTIVE        = 0x0001,
01596       NORMAL_PASSIVE       = 0x0002,
01597       ANTIDISGUISE_ACTIVE  = 0x0004,
01598       ANTIDISGUISE_PASSIVE = 0x0008,
01599       ANTICLOAK_ACTIVE     = 0x0010,
01600       ANTICLOAK_PASSIVE    = 0x0020,
01601       PENETRATE_ACTIVE     = 0x0040,
01602       PENETRATE_PASSIVE    = 0x0080
01603     } tScannerType;
01606     TScanner();
01610     TScanner( const TScanner& OldScanner );
01614     virtual ~TScanner();
01623     virtual bool load( TDataPackageList* in );
01632     virtual bool save( TDataPackageList* out ) const;
01636     virtual TItem::tItemType getItemType() const;
01641     virtual TScanner::tScannerType getScannerType() const = 0;
01647     virtual void setScanEfficiency( const int2 ScanEfficiency );
01653     virtual int2 getScanEfficiency() const;
01658     virtual void setShortRange( int4 Range );
01663     virtual int4 getShortRange();
01668     virtual void setLongRange( int2 Range );
01673     virtual int2 getLongRange();
01678     virtual bool operator==( const TScanner& Scanner ) const;
01679   protected:
01681     virtual TScanner& operator=( const TScanner& Scanner );
01683     int2 fScanEfficiency;
01685     int4 fShortRange;
01687     int2 fLongRange;
01688 };
01689 
01690 
01691 
01692 /* TScanner sub classes */
01693 
01694 
01695 
01711 class TScannerNormalActive : public TScanner
01712 {
01713   public:
01718     TScannerNormalActive();
01725     TScannerNormalActive( const TScannerNormalActive& OldScannerNormalActive );
01728     virtual ~TScannerNormalActive();
01735     virtual bool load( TDataPackageList* in );
01742     virtual bool save( TDataPackageList* out ) const;
01746     virtual TScanner::tScannerType getScannerType() const;
01752     virtual bool operator==( const TScannerNormalActive& ScannerNormalActive ) const;
01754     virtual TScannerNormalActive& operator=(const TScannerNormalActive& ScannerNormalActive);
01755 };
01756 
01757 
01758 
01774 class TScannerNormalPassive : public TScanner
01775 {
01776   public:
01781     TScannerNormalPassive();
01788     TScannerNormalPassive( const TScannerNormalPassive& OldScannerNormalPassive );
01791     virtual ~TScannerNormalPassive();
01798     virtual bool load( TDataPackageList* in );
01805     virtual bool save( TDataPackageList* out ) const;
01809     virtual TScanner::tScannerType getScannerType() const;
01815     virtual bool operator==( const TScannerNormalPassive& ScannerNormalPassive ) const;
01817     virtual TScannerNormalPassive& operator=(const TScannerNormalPassive& ScannerNormalPassive);
01818 };
01819 
01820 
01821 
01838 class TScannerAntiDisguiseActive : public TScanner
01839 {
01840   public:
01845     TScannerAntiDisguiseActive();
01852     TScannerAntiDisguiseActive( const TScannerAntiDisguiseActive& OldScannerAntiDisguiseActive );
01855     virtual ~TScannerAntiDisguiseActive();
01862     virtual bool load( TDataPackageList* in );
01869     virtual bool save( TDataPackageList* out ) const;
01873     virtual TScanner::tScannerType getScannerType() const;
01879     virtual bool operator==( const TScannerAntiDisguiseActive& ScannerAntiDisguiseActive ) const;
01881     virtual TScannerAntiDisguiseActive& operator=(const TScannerAntiDisguiseActive& ScannerAntiDisguiseActive);
01882 };
01883 
01884 
01885 
01902 class TScannerAntiDisguisePassive : public TScanner
01903 {
01904   public:
01909     TScannerAntiDisguisePassive();
01916     TScannerAntiDisguisePassive( const TScannerAntiDisguisePassive& OldScannerAntiDisguisePassive );
01919     virtual ~TScannerAntiDisguisePassive();
01926     virtual bool load( TDataPackageList* in );
01933     virtual bool save( TDataPackageList* out ) const;
01937     virtual TScanner::tScannerType getScannerType() const;
01943     virtual bool operator==( const TScannerAntiDisguisePassive& ScannerAntiDisguisePassive ) const;
01945     virtual TScannerAntiDisguisePassive& operator=(const TScannerAntiDisguisePassive& ScannerAntiDisguisePassive);
01946 };
01947 
01948 
01949 
01965 class TScannerAntiCloakActive : public TScanner
01966 {
01967   public:
01972     TScannerAntiCloakActive();
01979     TScannerAntiCloakActive( const TScannerAntiCloakActive& OldScannerAntiCloakActive );
01982     virtual ~TScannerAntiCloakActive();
01989     virtual bool load( TDataPackageList* in );
01996     virtual bool save( TDataPackageList* out ) const;
02000     virtual TScanner::tScannerType getScannerType() const;
02006     virtual bool operator==( const TScannerAntiCloakActive& ScannerAntiCloakActive ) const;
02008     virtual TScannerAntiCloakActive& operator=(const TScannerAntiCloakActive& ScannerAntiCloakActive);
02009 };
02010 
02011 
02012 
02028 class TScannerAntiCloakPassive : public TScanner
02029 {
02030   public:
02035     TScannerAntiCloakPassive();
02042     TScannerAntiCloakPassive( const TScannerAntiCloakPassive& OldScannerAntiCloakPassive );
02045     virtual ~TScannerAntiCloakPassive();
02052     virtual bool load( TDataPackageList* in );
02059     virtual bool save( TDataPackageList* out ) const;
02063     virtual TScanner::tScannerType getScannerType() const;
02069     virtual bool operator==( const TScannerAntiCloakPassive& ScannerAntiCloakPassive ) const;
02071     virtual TScannerAntiCloakPassive& operator=(const TScannerAntiCloakPassive& ScannerAntiCloakPassive);
02072 };
02073 
02074 
02075 
02091 class TScannerPenetrateActive : public TScanner
02092 {
02093   public:
02098     TScannerPenetrateActive();
02105     TScannerPenetrateActive( const TScannerPenetrateActive& OldScannerPenetrateActive );
02108     virtual ~TScannerPenetrateActive();
02115     virtual bool load( TDataPackageList* in );
02122     virtual bool save( TDataPackageList* out ) const;
02126     virtual TScanner::tScannerType getScannerType() const;
02132     virtual bool operator==( const TScannerPenetrateActive& ScannerPenetrateActive ) const;
02134     virtual TScannerPenetrateActive& operator=(const TScannerPenetrateActive& ScannerPenetrateActive);
02135 };
02136 
02137 
02138 
02154 class TScannerPenetratePassive : public TScanner
02155 {
02156   public:
02161     TScannerPenetratePassive();
02168     TScannerPenetratePassive( const TScannerPenetratePassive& OldScannerPenetratePassive );
02171     virtual ~TScannerPenetratePassive();
02178     virtual bool load( TDataPackageList* in );
02185     virtual bool save( TDataPackageList* out ) const;
02189     virtual TScanner::tScannerType getScannerType() const;
02195     virtual bool operator==( const TScannerPenetratePassive& ScannerPenetratePassive ) const;
02197     virtual TScannerPenetratePassive& operator=(const TScannerPenetratePassive& ScannerPenetratePassive);
02198 };
02199 
02200 
02201 
02202 /******************************** class TJammer ********************************/
02203 
02204 
02205 
02221 class TJammer : public TItem
02222 {
02223   public:
02227     typedef enum
02228     {
02229       NORMAL        = 0x0001,
02230       DISGUISE      = 0x0002,
02231       CLOAK         = 0x0004,
02232       ANTIPENETRATE = 0x0008
02233     } tJammerType;
02236     TJammer();
02240     TJammer( const TJammer& OldJammer );
02244     virtual ~TJammer();
02253     virtual bool load( TDataPackageList* in );
02262     virtual bool save( TDataPackageList* out ) const;
02266     virtual TItem::tItemType getItemType() const;
02271     virtual TJammer::tJammerType getJammerType() const = 0;
02277     virtual void setJamEfficiency( const int2 JamEfficiency );
02283     virtual int2 getJamEfficiency() const;
02288     virtual bool operator==( const TJammer& Jammer ) const;
02289   protected:
02291     virtual TJammer& operator=( const TJammer& Jammer );
02293     int2 fJamEfficiency;
02294 };
02295 
02296 
02297 
02298 /* TJammer sub classes */
02299 
02300 
02301 
02314 class TJammerNormal : public TJammer
02315 {
02316   public:
02321     TJammerNormal();
02326     TJammerNormal( const TJammerNormal& OldJammerNormal );
02329     virtual ~TJammerNormal();
02336     virtual bool load( TDataPackageList* in );
02343     virtual bool save( TDataPackageList* out ) const;
02347     virtual TJammer::tJammerType getJammerType() const;
02353     virtual bool operator==( const TJammerNormal& JammerNormal ) const;
02355     virtual TJammerNormal& operator=(const TJammerNormal& JammerNormal);
02356 };
02357 
02358 
02359 
02373 class TJammerDisguise : public TJammer
02374 {
02375   public:
02380     TJammerDisguise();
02386     TJammerDisguise( const TJammerDisguise& OldJammerDisguise );
02389     virtual ~TJammerDisguise();
02396     virtual bool load( TDataPackageList* in );
02403     virtual bool save( TDataPackageList* out ) const;
02407     virtual TJammer::tJammerType getJammerType() const;
02413     virtual bool operator==( const TJammerDisguise& JammerDisguise ) const;
02415     virtual TJammerDisguise& operator=(const TJammerDisguise& JammerDisguise);
02416 };
02417 
02418 
02419 
02432 class TJammerCloak : public TJammer
02433 {
02434   public:
02439     TJammerCloak();
02445     TJammerCloak( const TJammerCloak& OldJammerCloak );
02448     virtual ~TJammerCloak();
02455     virtual bool load( TDataPackageList* in );
02462     virtual bool save( TDataPackageList* out ) const;
02466     virtual TJammer::tJammerType getJammerType() const;
02472     virtual bool operator==( const TJammerCloak& JammerCloak ) const;
02474     virtual TJammerCloak& operator=(const TJammerCloak& JammerCloak);
02475 };
02476 
02477 
02478 
02492 class TJammerAntiPenetrate : public TJammer
02493 {
02494   public:
02499     TJammerAntiPenetrate();
02505     TJammerAntiPenetrate( const TJammerAntiPenetrate& OldJammerAntiPenetrate );
02508     virtual ~TJammerAntiPenetrate();
02515     virtual bool load( TDataPackageList* in );
02522     virtual bool save( TDataPackageList* out ) const;
02526     virtual TJammer::tJammerType getJammerType() const;
02532     virtual bool operator==( const TJammerAntiPenetrate& JammerAntiPenetrate ) const;
02534     virtual TJammerAntiPenetrate& operator=(const TJammerAntiPenetrate& JammerAntiPenetrate);
02535 };
02536 
02537 
02538 
02539 /****************************** class TMineLayer *******************************/
02540 
02541 
02542 
02559 class TMineLayer : public TItem
02560 {
02561   public:
02565     TMineLayer();
02570     TMineLayer( const TMineLayer& OldMineLayer );
02573     virtual ~TMineLayer();
02580     virtual bool load( TDataPackageList* in );
02587     virtual bool save( TDataPackageList* out ) const;
02591     virtual TItem::tItemType getItemType() const;
02595     virtual void setMineLayingRate( const int2 MineLayingRate );
02599     virtual int2 getMineLayingRate() const;
02605     virtual bool operator==( const TMineLayer& MineLayer ) const;
02607     virtual TMineLayer& operator=( const TMineLayer& MineLayer );
02608   protected:
02610     int2 fMineLayingRate;
02611 };
02612 
02613 
02614 
02615 /****************************** class TMiningBot *******************************/
02616 
02617 
02618 
02633 class TMiningBot : public TItem
02634 {
02635   public:
02639     TMiningBot();
02644     TMiningBot( const TMiningBot& OldMiningBot );
02647     virtual ~TMiningBot();
02654     virtual bool load( TDataPackageList* in );
02661     virtual bool save( TDataPackageList* out ) const;
02665     virtual TItem::tItemType getItemType() const;
02669     virtual void setMiningRate( const int2 MiningRate );
02673     virtual int2 getMiningRate() const;
02679     virtual bool operator==( const TMiningBot& MiningBot ) const;
02681     virtual TMiningBot& operator=( const TMiningBot& MiningBot );
02682   protected:
02684     int2 fMiningRate;
02685 };
02686 
02687 
02688 
02689 /*************************** class TFighterLauncher ****************************/
02690 
02691 
02692 
02709 class TFighterLauncher : public TItem
02710 {
02711   public:
02716     TFighterLauncher();
02722     TFighterLauncher( const TFighterLauncher& OldFighterLauncher );
02725     virtual ~TFighterLauncher();
02732     virtual bool load( TDataPackageList* in );
02739     virtual bool save( TDataPackageList* out ) const;
02743     virtual TItem::tItemType getItemType() const;
02747     virtual void setLaunchRate( const int2 LaunchRate );
02751     virtual int2 getLaunchRate() const;
02755     virtual void setLandingRate( const int2 LandingRate );
02759     virtual int2 getLandingRate() const;
02763     virtual void setRepairRate( const int2 RepairRate );
02767     virtual int2 getRepairRate() const;
02774     virtual bool operator==( const TFighterLauncher& FighterLauncher ) const;
02776     virtual TFighterLauncher& operator=( const TFighterLauncher& FighterLauncher );
02777   protected:
02779     int2 fLaunchRate;
02781     int2 fLandingRate;
02783     int2 fRepairRate;
02784 };
02785 
02786 
02787 
02788 /*************************** class TSPWeaponLauncher ****************************/
02789 
02790 
02791 
02807 class TSPWeaponLauncher : public TItem
02808 {
02809   public:
02814     TSPWeaponLauncher();
02820     TSPWeaponLauncher( const TSPWeaponLauncher& OldSPWeaponLauncher );
02823     virtual ~TSPWeaponLauncher();
02830     virtual bool load( TDataPackageList* in );
02837     virtual bool save( TDataPackageList* out ) const;
02841     virtual TItem::tItemType getItemType() const;
02845     virtual void setLaunchRate( const int2 LaunchRate );
02849     virtual int2 getLaunchRate() const;
02856     virtual bool operator==( const TSPWeaponLauncher& SPWeaponLauncher ) const;
02858     virtual TSPWeaponLauncher& operator=( const TSPWeaponLauncher& SPWeaponLauncher );
02859   protected:
02861     int2 fLaunchRate;
02862 };
02863 
02864 
02865  
02866 
02867 #endif        // __ITEM_INCLUDED
02868 
02869 
02870 

Generated on Thu Jun 20 18:13:15 2002 for Stellar Legacy by doxygen1.2.13.1 written by Dimitri van Heesch, © 1997-2001