CnC_Remastered_Collection

RULES.H (23734B)

---

 //
 // Copyright 2020 Electronic Arts Inc.
 //
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code 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 3 of the License, or (at your option) any later version.
 
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
 // in the hope that it will be useful, but with permitted additional restrictions 
 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
 // distributed with this program. You should have received a copy of the 
 // GNU General Public License along with permitted additional restrictions 
 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
 
 /* $Header: /CounterStrike/RULES.H 1     3/03/97 10:25a Joe_bostic $ */
 /***********************************************************************************************
  ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
  ***********************************************************************************************
  *                                                                                             *
  *                 Project Name : Command & Conquer                                            *
  *                                                                                             *
  *                    File Name : RULES.H                                                      *
  *                                                                                             *
  *                   Programmer : Joe L. Bostic                                                *
  *                                                                                             *
  *                   Start Date : 05/12/96                                                     *
  *                                                                                             *
  *                  Last Update : May 12, 1996 [JLB]                                           *
  *                                                                                             *
  *---------------------------------------------------------------------------------------------*
  * Functions:                                                                                  *
  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 
 #ifndef RULES_H
 #define RULES_H
 
 #include	"ccini.h"
 
 class DifficultyClass
 {
 	public:
 		fixed FirepowerBias;
 		fixed GroundspeedBias;
 		fixed AirspeedBias;
 		fixed ArmorBias;
 		fixed ROFBias;
 		fixed CostBias;
 		fixed BuildSpeedBias;
 
 		fixed RepairDelay;
 		fixed BuildDelay;
 
 		unsigned IsBuildSlowdown:1;
 		unsigned IsWallDestroyer:1;
 		unsigned IsContentScan:1;
 };
 
 class RulesClass {
 	public:
 
 		RulesClass(void);
 
 		bool Process(CCINIClass & file);
 		bool General(CCINIClass & ini);
 		bool MPlayer(CCINIClass & ini);
 		bool Recharge(CCINIClass & ini);
 		bool Heap_Maximums(CCINIClass & ini);
 		bool AI(CCINIClass & ini);
 		bool Powerups(CCINIClass & ini);
 		bool Land_Types(CCINIClass & ini);
 		bool Themes(CCINIClass & ini);
 		bool IQ(CCINIClass & ini);
 		bool Objects(CCINIClass & ini);
 		bool Difficulty(CCINIClass & ini);
 
 		/*
 		**	This specifies the turbo boost speed for missiles when they are fired upon
 		**	aircraft and the weapon is specified as having a turbo boost bonus.
 		*/
 		fixed TurboBoost;
 
 		/*
 		**	This specifies the average number of minutes between each computer attack.
 		*/
 		fixed AttackInterval;
 
 		/*
 		**	This specifies the average minutes delay before the computer will begin
 		**	its first attack upon the player. The duration is also modified by the
 		**	difficulty level.
 		*/
 		fixed AttackDelay;
 
 		/*
 		**	If the power ratio falls below this percentage, then a power emergency is
 		**	in effect. At such times, the computer might decide to sell off some
 		**	power hungry buildings in order to alleviate the situation.
 		*/
 		fixed PowerEmergencyFraction;
 
 		/*
 		**	The number of badgers that arrive when the parabomb option is used.
 		*/
 		int BadgerBombCount;
 
 		/*
 		**	This specifies the percentage of the base (by building quantity) that should
 		**	be composed of airstrips.
 		*/
 		fixed AirstripRatio;
 
 		/*
 		**	Limit the number of airstrips to this amount.
 		*/
 		int AirstripLimit;
 
 		/*
 		**	This specifies the percentage of the base (by building quantity) that should
 		**	be composed of helipads.
 		*/
 		fixed HelipadRatio;
 
 		/*
 		**	Limit the number of helipads to this amount.
 		*/
 		int HelipadLimit;
 
 		/*
 		**	This specifies the percentage of the base (by building quantity) that should
 		**	be composed of Tesla Coils.
 		*/
 		fixed TeslaRatio;
 
 		/*
 		**	Limit tesla coil production to this maximum.
 		*/
 		int TeslaLimit;
 
 		/*
 		**	This specifies the percentage of the base (by building quantity) that should
 		**	be composed of anti-aircraft defense.
 		*/
 		fixed AARatio;
 
 		/*
 		**	Limit anti-aircraft building quantity to this amount.
 		*/
 		int AALimit;
 
 		/*
 		**	This specifies the percentage of the base (by building quantity) that should
 		**	be composed of defensive structures.
 		*/
 		fixed DefenseRatio;
 
 		/*
 		**	This is the limit to the number of defensive building that can be built.
 		*/
 		int DefenseLimit;
 
 		/*
 		**	This specifies the percentage of the base (by building quantity) that should
 		**	be composed of war factories.
 		*/
 		fixed WarRatio;
 
 		/*
 		**	War factories are limited to this quantity for the computer controlled player.
 		*/
 		int WarLimit;
 
 		/*
 		**	This specifies the percentage of the base (by building quantity) that should
 		**	be composed of infantry producing structures.
 		*/
 		fixed BarracksRatio;
 
 		/*
 		**	No more than this many barracks can be built.
 		*/
 		int BarracksLimit;
 
 		/*
 		**	Refinery building is limited to this many refineries.
 		*/
 		int RefineryLimit;
 
 		/*
 		**	This specifies the percentage of the base (by building quantity) that should
 		**	be composed of refineries.
 		*/
 		fixed RefineryRatio;
 
 		/*
 		**	The computer is limited in the size of the base it can build. It is limited to the
 		**	size of the largest human opponent base plus this surplus count.
 		*/
 		int BaseSizeAdd;
 
 		/*
 		**	If the power surplus is less than this amount, then the computer will
 		**	build power plants.
 		*/
 		int PowerSurplus;
 
 		/*
 		**	The computer will build infantry if their cash reserve is greater than this amount.
 		*/
 		int InfantryReserve;
 
 		/*
 		**	This factor is multiplied by the number of buildings in the computer's base and infantry
 		**	are always built until it matches that number.
 		*/
 		int InfantryBaseMult;
 
 		/*
 		**	This specifies the duration that a unit will remain chronoshifted before it
 		**	will be returned to its starting location.
 		*/
 		fixed ChronoDuration;
 
 		/*
 		**	Percent chance that a water crate will be generated instead of a land
 		**	crate when crates are on and in a multiplay game.
 		*/
 		fixed WaterCrateChance;
 
 		/*
 		**	Solo play has money crate amount fixed according to this rule value.
 		*/
 		int SoloCrateMoney;
 
 		/*
 		**	GPS tech level control.
 		*/
 		int GPSTechLevel;
 
 		/*
 		**	If a unit type is specified here, then the unit crate will generate
 		**	a unit of this type (always).
 		*/
 		UnitType UnitCrateType;
 
 		/*
 		**	This is the time to delay between patrol-to-waypoint target scanning.
 		*/
 		fixed PatrolTime;
 
 		/*
 		**	This is the time interval that checking to create teams will span. The
 		**	smaller this number, the more often checking for team creation will occur.
 		*/
 		fixed TeamDelay;
 
 		/*
 		**	This is the arbitrary delay to make all cloaking objects remain uncloaked
 		**	before having it recloak.
 		*/
 		fixed CloakDelay;
 
 		/*
 		**	This is an overall game apparent speed bias to use for object
 		**	movement purposes.
 		*/
 		fixed GameSpeedBias;
 
 		/*
 		**	If a potential target is close to the base then increase
 		**	the likelyhood of attacking it by this bias factor.
 		*/
 		fixed NervousBias;
 
 		/*
 		**	Controls the Chronal vortex characteristics.
 		*/
 		LEPTON VortexRange;
 		MPHType VortexSpeed;
 		int VortexDamage;
 		fixed VortexChance;
 
 		/*
 		**	When an explosive object explodes, the damage will spread out
 		**	by this factor. The value represents the number of cells radius
 		**	that the damage will spread for every 100 points of raw damage at
 		**	the explosion center point.
 		*/
 		fixed ExplosionSpread;
 
 		/*
 		**	For weapons specially marked to check for nearby friendly buildings
 		**	when scanning for good targets, this indicates the scan radius. Such
 		**	weapons will supress firing on enemies if they are in close proximity
 		**	to allied buildings.
 		*/
 		LEPTON SupressRadius;
 
 		/*
 		**	This is the tech level that para infantry are granted free to the owner
 		**	of an airstrip.
 		*/
 		int ParaInfantryTechLevel;
 
 		/*
 		**	This is the tech level that spy planes are granted free to the owner of
 		**	an airstrip.
 		*/
 		int SpyPlaneTechLevel;
 
 		/*
 		**	This is the tech level that the parabombs are granted free to the owner
 		**	of an airstrip.
 		*/
 		int ParaBombTechLevel;
 
 		/*
 		**	This is the maximum number of IQ settings available. The human player is
 		**	presumed to be at IQ level zero.
 		*/
 		int MaxIQ;
 
 		/*
 		**	The IQ level at which super weapons will be automatically fired by the computer.
 		*/
 		int IQSuperWeapons;
 
 		/*
 		**	The IQ level at which production is automatically controlled by the computer.
 		*/
 		int IQProduction;
 
 		/*
 		**	The IQ level at which newly produced units start out in guard area mode instead
 		**	of normal guard mode.
 		*/
 		int IQGuardArea;
 
 		/*
 		**	The IQ level at which the computer will be able to decide what gets repaired
 		**	or sold.
 		*/
 		int IQRepairSell;
 
 		/*
 		**	At this IQ level or higher, a unit is allowed to automatically try to crush
 		**	an atagonist if possible.
 		*/
 		int IQCrush;
 
 		/*
 		**	The unit/infantry will try to scatter if an incoming threat
 		**	is detected.
 		*/
 		int IQScatter;
 
 		/*
 		**	Tech level at which the computer will scan the contents of a transport
 		**	in order to pick the best target to fire upon.
 		*/
 		int IQContentScan;
 
 		/*
 		**	Aircraft replacement production occurs at this IQ level or higher.
 		*/
 		int IQAircraft;
 
 		/*
 		**	Checks for and replaces lost harvesters.
 		*/
 		int IQHarvester;
 
 		/*
 		**	Is allowed to sell a structure being damaged.
 		*/
 		int IQSellBack;
 
 		/*
 		**	The silver and wood crates in solo play will have these powerups.
 		*/
 		CrateType SilverCrate;
 		CrateType WoodCrate;
 		CrateType WaterCrate;
 
 		/*
 		**	This specifies the minimum number of crates to place on the map in spite
 		**	of the number of actual human players.
 		*/
 		int CrateMinimum;
 
 		/*
 		**	This specifies the crate maximum quantity to use.
 		*/
 		int CrateMaximum;
 
 		/*
 		**	Landing zone maximum alternate zone scan radius.
 		*/
 		LEPTON LZScanRadius;
 
 		/*
 		**	Multiplayer default settings.
 		*/
 		int MPDefaultMoney;
 		int MPMaxMoney;
 		unsigned IsMPShadowGrow:1;
 		unsigned IsMPBasesOn:1;
 		unsigned IsMPTiberiumGrow:1;
 		unsigned IsMPCrates:1;
 		unsigned IsMPAIPlayers:1;
 		unsigned IsMPCaptureTheFlag:1;
 
 		/*
 		**	Drop zone reveal radius.
 		*/
 		LEPTON DropZoneRadius;
 
 		/*
 		**	This is the delay that multiplayer messages will remain on the screen.
 		*/
 		fixed MessageDelay;
 
 		/*
 		**	Savour delay between when scenario detects end and the actual
 		**	end of the play.
 		*/
 		fixed SavourDelay;
 
 		/*
 		**	This specifies the damage to inflict for two differnt styles of
 		**	land mine.
 		*/
 		int AVMineDamage;
 		int APMineDamage;
 
 		/*
 		**	This is the maximum number of multiplayers allowed.
 		*/
 		int MaxPlayers;
 
 		/*
 		**	This is the delay between 'panic attacks' when the computer's base is under
 		**	attack. This delay gives the previously assigned units a chance to affect the
 		**	attacker before the computer sends more.
 		*/
 		fixed BaseDefenseDelay;
 
 		/*
 		**	These values control the team suspension logic for dealing with immedate base threats.
 		**	When the base is attacked, all teams with less than the specified priority will be
 		**	temporarily put on hold for the number of minutes specified.
 		*/
 		int SuspendPriority;
 		fixed SuspendDelay;
 
 		/*
 		**	This serves as the fraction of a building's original cost that is converted
 		**	into survivors (of some fashion). There are rounding and other marginal
 		**	fudge effects, but this value is the greatest control over the survivor rate.
 		*/
 		fixed SurvivorFraction;
 
 		/*
 		**	This is the aircraft reload rate expressed in minutes per ammo load.
 		*/
 		fixed ReloadRate;
 
 		/*
 		**	The average time (in minutes) between the computer autocreating a team
 		**	from the team's autocreate list.
 		*/
 		fixed AutocreateTime;
 
 		/*
 		**	Build up time for buildings (minutes).
 		*/
 		fixed BuildupTime;
 
 		/*
 		**	Ore truck speed for dumping.
 		*/
 		int OreDumpRate;
 
 		/*
 		**	This is the amount of damage done by the atom bomb in solo missions. The
 		**	damage done during multiplay will be 1/5th this value.
 		*/
 		int AtomDamage;
 
 		/*
 		**	This array controls the difficulty affects on the game. There is one
 		**	difficulty class object for each difficulty level.
 		*/
 		DifficultyClass Diff[DIFF_COUNT];
 
 		/*
 		**	Is the computer paranoid? If so, then it will band together with other computer
 		**	paranoid players when the situation looks rough.
 		*/
 		bool IsComputerParanoid:1;
 
 		/*
 		**	Should helicopters shuffle their position between firing on their
 		**	target?
 		*/
 		bool IsCurleyShuffle:1;
 
 		/*
 		**	Flash the power bar when the power goes below 100%.
 		*/
 		bool IsFlashLowPower:1;
 
 		/*
 		**	If the computer players will go to easy mode if there is more
 		**	than one human player, this flag will be true.
 		*/
 		bool IsCompEasyBonus:1;
 
 		/*
 		**	If fine control of difficulty settings is desired, then set this value to true.
 		**	Fine control allows 5 settings. The coarse control only allows three settings.
 		*/
 		bool IsFineDifficulty:1;
 
 		/*
 		**	If the harvester is to explode more violently than normal
 		**	if it is carrying cargo, then this flag will be true.
 		*/
 		unsigned IsExplosiveHarvester:1;
 
 		/*
 		**	If this flag is true, then the construction yard can undeploy back into an MCV.
 		*/
 		unsigned IsMCVDeploy:1;
 
 		/*
 		**	If the base is to be revealed to a new ally, then this
 		**	flag will be true.
 		*/
 		unsigned IsAllyReveal:1;
 
 		/*
 		**	Can the helipad (and airfield) be purchased separately from the associated
 		**	aircraft.
 		*/
 		unsigned IsSeparate:1;
 
 		/*
 		**	Give target cursor for trees? Doing this will make targetting of trees easier.
 		*/
 		unsigned IsTreeTarget:1;
 
 		/*
 		**	Are friendly units automatically aware of mines so that they can avoid them?
 		*/
 		unsigned IsMineAware:1;
 
 		/*
 		**	If Tiberium is allowed to grow, then this flag will be true.
 		*/
 		unsigned IsTGrowth:1;
 
 		/*
 		**	If Tiberium is allowed to spread, then this flag will be true.
 		*/
 		unsigned IsTSpread:1;
 
 		/*
 		**	Should civilan buildings and civilians display their true name rather than
 		**	the generic "Civilian Building" and "Civilain"?
 		*/
 		unsigned IsNamed:1;
 
 		/*
 		**	Should player controlled vehicles automatically try to crush nearby infantry
 		**	instead of required the player to manually direct them to crush.
 		*/
 		unsigned IsAutoCrush:1;
 
 		/*
 		**	Should the player controlled buildings and units automatically return fire when
 		**	fired upon?
 		*/
 		unsigned IsSmartDefense:1;
 
 		/*
 		**	Should player controlled units try to scatter more easily in order to
 		**	avoid damage or threats?
 		*/
 		unsigned IsScatter:1;
 
 		/*
 		**	If the chronoshift effect should kill all cargo, then this flag will
 		**	be set to true.
 		*/
 		unsigned IsChronoKill:1;
 
 		/*
 		**	When infantry are prone or when civilians are running around like crazy,
 		**	they are less prone to damage. This specifies the multiplier to the damage
 		**	(as a fixed point number).
 		*/
 		fixed ProneDamageBias;
 
 		/*
 		**	The time quake will do this percentage of damage to all units and buildings
 		**	in the game. The number is expressed as a fixed point percentage.
 		*/
 		fixed QuakeDamagePercent;
 
 		/*
 		**	Percentage chance that a time quake will occur with each chronoshift use.
 		*/
 		fixed QuakeChance;
 
 		/*
 		**	Ore (Tiberium) growth rate. The value is the number of minutes between
 		**	growth steps.
 		*/
 		fixed GrowthRate;
 
 		/*
 		**	This specifies the number of minutes between each shroud regrowth process.
 		*/
 		fixed ShroudRate;
 
 		/*
 		**	This is the average minutes between each generation of a random crate
 		**	to be placed on the map if generating of random crates is indicated.
 		*/
 		fixed CrateTime;
 
 		/*
 		**	This specifies the number of minutes remaining before that if the mission timer
 		**	gets to this level or below, it will be displayed in red.
 		*/
 		fixed TimerWarning;
 
 		/*
 		**	This specifies the minutes of delay between recharges for these
 		**	special weapon types.
 		*/
 		fixed SonarTime;
 		fixed ChronoTime;
 		fixed ParaBombTime;
 		fixed ParaInfantryTime;
 		fixed ParaSaboteurTime;
 		fixed SpyTime;
 		fixed IronCurtainTime;
 		fixed GPSTime;
 		fixed NukeTime;
 
 		/*
 		**	Other miscellaneous delay times.
 		*/
 		fixed SpeakDelay;
 		fixed DamageDelay;
 
 		/*
 		**	This is the gravity constant used to control the arcing and descent of ballistic
 		**	object such as grenades and artillery.
 		*/
 		int Gravity;
 
 		/*
 		**	Gap generators have a shroud radius of this many cells.
 		*/
 		int GapShroudRadius;
 
 		/*
 		**	This is the minute interval between the gap generators refreshing
 		**	their zones of gapping.
 		*/
 		fixed GapRegenInterval;
 
 		/*
 		**	Mobile radar jammer radius of effect.
 		*/
 		LEPTON RadarJamRadius;
 
 		/*
 		**	The speed at which a projectile that travels at or slower will cause
 		**	objects in the target location to scatter. This simulates the ability
 		**	of targets to run for cover if the projectile gives them enough time
 		**	to react.
 		*/
 		MPHType Incoming;
 
 		/*
 		**	Minimum and maximum damage allowed per shot.
 		*/
 		int MinDamage;
 		int MaxDamage;
 
 		/*
 		**	This is the rate of repair for units and buildings. The rate is the
 		**	number of strength points repaired per repair clock tick. The cost of
 		**	repair is the (fixed point) fractional cost to repair the object based
 		**	on the full price of the object. Example; a value of 50% means that to
 		**	repair the object from 1 damage point to full strength would cost 50% of
 		**	the cost to build it from scratch.
 		*/
 		int RepairStep;
 		fixed RepairPercent;
 		int URepairStep;
 		fixed URepairPercent;
 
 		/*
 		**	This is the rate that objects with self healing will heal. They will repair a bit
 		**	every 'this' number of minutes.
 		*/
 		fixed RepairRate;
 
 		/*
 		**	These fixed point values are used to determine the status (health bar
 		**	color) of the game objects. Objects in the 'yellow' are in a cautionary
 		**	state. Object in the 'red' are in a danger state.
 		*/
 		fixed ConditionGreen;
 		fixed ConditionYellow;
 		fixed ConditionRed;
 
 		/*
 		**	Average number of minutes between infantry random idle animations.
 		*/
 		fixed RandomAnimateTime;
 
 		/*
 		**	These control the capacity and value of the ore types that a harvester
 		**	may carry. The harvester carries a maximum discrete number of 'bails'.
 		**	The value of each bail depends on the ore it is composed of.
 		*/
 		int BailCount;		// was STEP_COUNT
 		int GoldValue;		// was GOLD_WORTH
 		int GemValue;		// was GEM_WORTH
 
 		/*
 		**	This specifies the heap maximum for the various game objects.
 		*/
 		int AircraftMax;
 		int AnimMax;
 		int BuildingMax;
 		int BulletMax;
 		int FactoryMax;
 		int InfantryMax;
 		int OverlayMax;
 		int SmudgeMax;
 		int TeamMax;
 		int TeamTypeMax;
 		int TemplateMax;
 		int TerrainMax;
 		int TriggerMax;
 		int UnitMax;
 		int VesselMax;
 		int ProjectileMax;
 		int WeaponMax;
 		int WarheadMax;
 		int TrigTypeMax;
 
 		/*
 		**	Close enough distance that is used to determine if the object should
 		**	stop movement when blocked. If the distance to the desired destination
 		**	is equal to this distance or less, but the path is blocked, then consider
 		**	the object to have gotten "close enough" to the destination to stop.
 		*/
 		LEPTON CloseEnoughDistance;
 
 		/*
 		**	Stray distance to group team members within. The larger the distance,
 		**	the looser the teams will move.
 		*/
 		LEPTON StrayDistance;
 
 		/*
 		**	If a vehicle is closer than this range to a target that it can crush
 		**	by driving over it, then it will try to drive over it instead of firing
 		**	upon it. The larger the value, the greater the 'bigfoot crush syndrome' is
 		**	has.
 		*/
 		LEPTON CrushDistance;
 
 		/*
 		**	For area effect crate bonus items will affect all objects within this radius.
 		*/
 		LEPTON CrateRadius;
 
 		/*
 		**	Maximum scatter distances for homing and non-homing projectiles.
 		*/
 		LEPTON HomingScatter;
 		LEPTON BallisticScatter;
 
 		/*
 		**	This is the refund percentage when selling off buildings and units
 		**	on the repair pad (service depot).
 		*/
 		fixed RefundPercent;
 
 		/*
 		**	The Iron Curtain invulnerability effect lasts for this many minutes.
 		*/
 		fixed IronCurtainDuration;
 
 		/*
 		**	The strength of bridges is held here. By corollary, the strength of the
 		**	demolition charge carried by Tanya is equal to this value as well.
 		*/
 		int BridgeStrength;
 
 		/*
 		**	This is the overall build speed bias. Multiply this value by the normal build
 		**	delay to get the effective build delay.
 		*/
 		fixed BuildSpeedBias;
 
 		/*
 		**	Weapon type array pointer should go here. Dynamic type.
 		*/
 
 
 		/*
 		**	Warhead type class array pointer should go here. Dynamic type.
 		*/
 
 
 		/*
 		**	Ground type and speed affect data should go here.
 		*/
 
 
 		/*
 		**	This is the delay between the time a C4 bomb is planted and the time it will
 		**	explode. The longer the delay, the greater safety margin for a demolitioner
 		**	type. The short the delay, the less time the victim has to sell the building
 		**	off.
 		*/
 		fixed C4Delay;
 
 		/*
 		**	The computer will only repair a structure if it has spare money greater than this
 		**	amount. The thinking is that this will prevent the computer from frittering away
 		**	all it's cash on repairing and thus leaving nothing for production of defenses.
 		*/
 		int RepairThreshhold;
 
 		/*
 		**	This is the delay (in minutes) between retries of a failed path. The longer the
 		**	delay the faster the system, but the longer the units take to react to a blocked
 		**	terrain event.
 		*/
 		fixed PathDelay;
 
 		/*
 		**	This is the special (debug version only) movie recorder timeout value. Each second
 		**	results in about 2-3 megabytes.
 		*/
 		fixed MovieTime;
 
 		/*
 		** This is the level at or above which the chronosphere facility can
 		** actually produce the chronosphere effect.  Below this tech level,
 		** the facility is merely a showpiece and has no effect.
 		*/
 		int ChronoTechLevel;
 
 		/*
 		**	These are the Tiberium scan distances. The short range scan is used to determine if the
 		**	current field has been exhausted. The long range scan is used when finding a Tiberium
 		**	field to harvest. Keep these ranges as small as possible.
 		*/
 		LEPTON TiberiumShortScan;
 		LEPTON TiberiumLongScan;
 
 		/*
 		**	Health bar display mode
 		*/
 		enum eHealthBarDisplayMode
 		{
 			HB_DAMAGED = 0,
 			HB_ALWAYS,
 			HB_SELECTED
 		} HealthBarDisplayMode;
 
 		/*
 		**	Resource bar display mode
 		*/
 		enum eResourceBarDisplayMode
 		{
 			RB_SELECTED = 0,
 			RB_ALWAYS,
 		} ResourceBarDisplayMode;
 };
 
 
 #endif