CodeMirror
/
CnC_Remastered_Collection
mirror of https://github.com/electronicarts/CnC_Remastered_Collection
1
0
Fork 0
Code Issues Releases Wiki Activity
CnC_Remastered_Collection/REDALERT/RULES.H

896 lines
23 KiB
C++
Raw Permalink Blame History

//
// 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
Reference in New Issue View Git Blame Copy Permalink