data/claims/cnc.yamlCommand & Conquer (the Remastered Collection's TiberianDawn.dll source, 2020)
Game: Command & Conquer.
Command & Conquer came out on 31 August 1995. cnc/release
Value: 1995-08-31
WikidataWikidata ·Q868523, publication date (P577)+1995-08-31T00:00:00ZWikidata gives one publication date at day precision, with one reference and no platform qualifier.
Cited by: Command & Conquer
The atlas reads Command & Conquer through the source of TiberianDawn.dll, the game's code in the 2020 Remastered Collection, which Electronic Arts released under the GPL version 3 with additional terms. The files keep Westwood's 1995 headers beside dated comments and guards for the remaster's changes, so a claim here describes the remaster's code and names any remaster change it rests on. cnc/source-version
README.md#L3This repository includes source code for TiberianDawn.dll, RedAlert.dll and the Map Editor for the Command & Conquer Remastered Collection.Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · LICENSE.md#L1-L3Electronic Arts Inc. released only TiberianDawn.dll, RedAlert.dll and
the Command & Conquer Map Editor and their corresponding source code
under the GPL V3 below, with additional terms at the bottom.Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/DRIVE.CPP#L1616 Oct 1995 16:51:16 JOE_BOSTICCommand & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/DISPLAY.CPP#L796Replaced by more generic function from RA, for RA AI. ST - 7/24/2019 5:46PMChecked by claude, 2026-10-22 — read README.md, LICENSE.md's opening, a 1995 file header, and one remaster-dated guard at the pinned commitThe repository holds no game data, so values the 1995 game read from its data files at start (if any override the code's tables) aren't covered here.
Cited by: Command & Conquer
In the remaster's code, a harvester carries at most 28 steps of Tiberium (STEP_COUNT). Each time its harvest timer runs out while it stands on Tiberium short of a full load, it lifts (the cell's OverlayData mod 6) + 1 steps from the cell, no more than the room left, and the timer restarts at TICKS_PER_SECOND, 15 game ticks; the code's comment calls this lifting a complete "level" of 6 steps or a partial one. Dune II's harvester instead fills to 100 units by a random 0 or 1 per harvest call. cnc/harvest
About: Command & Conquer Resource harvesting
Value
{
"capacity": 28,
"perHarvest": [
1,
6
],
"harvestTicks": 15
}TIBERIANDAWN/TYPE.H#L862-L864TIBERIUM_STEP=25, // Credits per step of Tiberium.
STEP_COUNT=28, // Number of steps a harvester can carry.
FULL_LOAD_CREDITS=(TIBERIUM_STEP*STEP_COUNT),Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/UNIT.CPP#L2470-L2486if (Target_Legal(NavCom) || !HarvestTimer.Expired() || IsDriving || IsRotating) return(true);
…
if (Tiberium_Load() < 0x0100 && ptr->Land_Type() == LAND_TIBERIUM) {
…
** "level" of Tiberium. A level happens to be 6 steps. If there
…
int reducer = (ptr->OverlayData % 6) + 1;
reducer = ptr->Reduce_Tiberium(MIN(reducer, UnitTypeClass::STEP_COUNT-Tiberium));
Tiberium += reducer;
…
HarvestTimer = TICKS_PER_SECOND;Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/DRIVE.CPP#L151-L154return(Cardinal_To_Fixed(UnitTypeClass::STEP_COUNT, Tiberium));Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/DEFINES.H#L2146#define TICKS_PER_SECOND 15OpenDUNE: a C re-creation of Dune II from its DOS executable (OpenDUNE/OpenDUNE) · src/script/unit.c#L1650-L1669if (u->amount >= 100) return 0;
…
u->amount += Tools_Random_256() & 1;
…
if (u->amount > 100) u->amount = 100;Checked by claude, 2026-10-22 — read UnitClass::Harvesting, the harvester constants in TYPE.H, DriveClass::Tiberium_Load (full is 0x100 of 28 steps), and CellClass::Reduce_Tiberium at the pinned commit, and OpenDUNE's Script_Unit_Harvest at its pinCellClass::Reduce_Tiberium (CELL.CPP, lines 1483–1500) takes the requested steps when the cell's OverlayData is larger, and otherwise clears the cell and returns its OverlayData, so the last lift from a cell yields one step less than its level number suggests, and a cell at 0 yields nothing. How fast game ticks pass depends on the game speed setting, which the atlas hasn't read.
Cited by: Command & Conquer, Resource harvesting
In the remaster's code, a refinery empties a docked harvester one step at a time, and each step pays its house 25 credits if the house is human: computed, 700 for a full load of 28, which matches Dune II's 100 units at 7 credits. A computer house gets 708 credits a step in a normal (single-player) game, from a formula the remaster's comment calls "wrong" but kept "to not break missions", and 33 in multiplayer, a correction the comment dates to the remaster (14 May 2020). Credits above the house's storage capacity are lost. cnc/refine
About: Command & Conquer Resource harvesting
Value
{
"creditsPerStep": 25,
"fullLoadCredits": 700,
"aiCreditsPerStepCampaign": 708,
"aiCreditsPerStepMultiplayer": 33
}TIBERIANDAWN/BUILDING.CPP#L4511-L4514int bail = techno->Offload_Tiberium_Bail();
…
House->Harvested(bail);Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/DRIVE.CPP#L1641-L1660if (Tiberium) {
Tiberium--;
if (House->IsHuman) {
return(UnitTypeClass::FULL_LOAD_CREDITS/UnitTypeClass::STEP_COUNT); // 25 in debugger
…
// MBL 05.14.2020: AI harvested credits fix for multiplayer, since they are miscalculated, and it's noticed
…
if (GameToPlay == GAME_NORMAL) // Non-multiplayer game, keep the original calculation; 708 in debugger
…
return(UnitTypeClass::FULL_LOAD_CREDITS+(UnitTypeClass::FULL_LOAD_CREDITS/3)/UnitTypeClass::STEP_COUNT); // Original (708), wrong calcualation but preserving to not break missions
…
return((UnitTypeClass::FULL_LOAD_CREDITS+(UnitTypeClass::FULL_LOAD_CREDITS/3))/UnitTypeClass::STEP_COUNT); // Corrected calculationCommand & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/TYPE.H#L862-L864TIBERIUM_STEP=25, // Credits per step of Tiberium.
STEP_COUNT=28, // Number of steps a harvester can carry.
FULL_LOAD_CREDITS=(TIBERIUM_STEP*STEP_COUNT),Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/HOUSE.CPP#L1717-L1727Tiberium += tiberium;
if (Tiberium > Capacity) {
Tiberium = Capacity;
IsMaxedOut = true;OpenDUNE: a C re-creation of Dune II from its DOS executable (OpenDUNE/OpenDUNE) · src/script/structure.c#L125-L136creditsStep = 7;
if (u->o.houseID != g_playerHouseID) {Checked by claude, 2026-10-22 — read the refinery's unload states in BUILDING.CPP, DriveClass::Offload_Tiberium_Bail, and HouseClass::Harvested at the pinned commit, and OpenDUNE's Script_Unit_RefineSpice at its pin; 700 + 700/3/28 is 700 + 8 in integer arithmetic, and (700 + 233)/28 is 33The "original" formula's operator precedence divides only the bonus third by 28, so a computer harvester's full load is worth 28 × 708 = 19,824 credits in a single-player mission (computed), before the storage cap. The comment's word "Original" is the remaster programmer's; the atlas hasn't seen the 1995 executable. Dune II's computer house gets 6 to 9 credits a unit (dune2/refine).
Cited by: Command & Conquer
In the remaster's code, a factory splits every build into 108 steps and pays in installments: each step costs the unpaid balance ÷ the steps left, and when the house can't pay it, the step is undone and the factory tries again at the next one. The build time in game ticks starts as the item's cost in credits, grows when the house's power fraction is below full (× 256/171), below half (× 256/103), or zero (× 4), and is divided by 108 into ticks per step (1 to 255). A human player's factory runs its step timer once per factory of that kind the house owns each tick; the code's comment says this acceleration "applies only to human players". Computed: for a human player's structure from one factory at full power, an item costing C credits takes 108 × ⌊C ÷ 108⌋ ticks, at least 108 and at most 27,540. Dune II also pays as it builds, but each tick costs cost ÷ build time, and a player's build goes on hold when the money runs out. cnc/build-progress
About: Command & Conquer Construction
Value
{
"steps": 108,
"ticksPerCredit": 1,
"powerScale": {
"belowFull": 1.497,
"belowHalf": 2.485,
"none": 4
}
}TIBERIANDAWN/FACTORY.H#L97STEP_COUNT=108 // Number of steps to break production down into.Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/FACTORY.CPP#L238-L261** Determine the acceleration factor for factory production.
** This applies only to human players. The computer builds
…
if (Object && House->IsHuman) {
…
stages = House->BuildingFactories;
…
stages = MAX(stages, 1);Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/FACTORY.CPP#L265-L296for (int index = 0; index < stages; index++) {
if (!Has_Completed() && Graphic_Logic()) {
…
int cost = Cost_Per_Tick();
…
if (cost > House->Available_Money()) {
Set_Stage(Fetch_Stage()-1);
} else {
House->Spend_Money(cost);
Balance -= cost;Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/FACTORY.CPP#L720-L728int steps = STEP_COUNT - Fetch_Stage();
if (steps) {
return(Balance / steps);Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/FACTORY.CPP#L402Balance = object.Cost_Of() * house.CostBias;Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/FACTORY.CPP#L543-L553time = Object->Class_Of().Time_To_Build(House->Class->House);
…
time /= STEP_COUNT;
time = Bound(time, 1, 255);
…
Set_Rate(time);Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/TECHNO.CPP#L291-L345int time = Raw_Cost();
…
int power = hptr->Power_Fraction();
int inv_scale(256);
if (power == 0x000) {
inv_scale = 64;
}
else if (power < 0x080) {
inv_scale = 103;
}
else if (power < 0x0100) {
inv_scale = 171;
…Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/STAGE.H#L71-L77if (Rate) {
StageTimer--;
if (!StageTimer) {
Stage++;
StageTimer = Rate;OpenDUNE: a C re-creation of Dune II from its DOS executable (OpenDUNE/OpenDUNE) · src/structure.c#L188-L215buildCost = oi->buildCredits * 256 / oi->buildTime;
…
if (buildCost / 256 <= h->credits) {OpenDUNE: a C re-creation of Dune II from its DOS executable (OpenDUNE/OpenDUNE) · src/structure.c#L264-L269/* Out of money means the building gets put on hold */
if (s->o.houseID == g_playerHouseID) {
s->o.flags.s.onHold = true;Checked by claude, 2026-10-22 — read FactoryClass::AI, Set, Start, and Cost_Per_Tick, StageClass::Graphic_Logic, and TechnoTypeClass::Time_To_Build at the pinned commit, and OpenDUNE's factory branch at its pin; the step undone after Graphic_Logic advanced it is what makes the build waitTime_To_Build also slows the computer's structures on easy and normal difficulty, speeds units only Nod can own by a quarter (the comment says they arrive by airfield), and scales the computer's time by its IQ through RULES.H, a file headed 1996 and Red Alert's; this claim covers a human player's build of a structure, which none of those touch. Cost_Of returns the type's cost; CostBias, the house's cost multiplier, is set elsewhere. When the last step completes, the factory pays whatever balance is left (FACTORY.CPP line 294). Abandoning a build refunds what was paid (lines 588–589).
Cited by: Command & Conquer
In the remaster's code, a structure can be placed where every cell of its footprint, its bib included, is clear: no object, no wall, no owned bib, and ground marked buildable (clear land or road; not Tiberium, beach, rock, or water). For a human house, one of the eight cells around some footprint cell, corners included, must also hold one of the house's buildings or be a cell the house owns, which its walls and bibs are; a computer house's placement skips that check. Dune II's rule is also adjacency with corners counted and also skipped for the computer, but on rock, concrete slab, or destroyed wall, with the construction yard exempt. cnc/placement
About: Command & Conquer Structure placement
CodeCommand & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) ·TIBERIANDAWN/BUILDING.CPP#L5485-L5524if (Debug_Map || !House->IsHuman) {
…
short const * ptr = Occupy_List(true);
…
for (FacingType facing = FACING_N; facing < FACING_COUNT; facing++) {
CELL newcell = Adjacent_Cell(cell, facing);
…
** The special cell ownership flag allows building adjacent
** to friendly walls and bibs even though there is no official
…
if (Map[newcell].Owner == House->Class->House) {
…
…Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/HOUSE.CPP#L2926-L2928if (tech->What_Am_I() != RTTI_BUILDING || ((BuildingClass *)tech)->Passes_Proximity_Check(cell)) {
builder->Transmit_Message(RADIO_HELLO, tech);
if (tech->Unlimbo(Cell_Coord(cell))) {Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/OBJECT.CPP#L1196if (ScenarioInit || Can_Enter_Cell(Coord_Cell(coord), FACING_NONE) == MOVE_OK) {Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/BUILDING.CPP#L3832return(Class->Legal_Placement(cell) ? MOVE_OK : MOVE_NO);Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/BDATA.CPP#L4415-L4420offset = Occupy_List(true);
…
if (!Map[cell].Is_Generally_Clear()) {Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/CELL.CPP#L430-L468if (Flag.Composite || IsFlagged || Cell_Occupier()) {
…
if (Smudge != SMUDGE_NONE && SmudgeTypeClass::As_Reference(Smudge).IsBib && Owner != HOUSE_NONE) {
…
if (Overlay != OVERLAY_NONE && (Overlay == OVERLAY_FLAG_SPOT || OverlayTypeClass::As_Reference(Overlay).IsWall)) {
…
return(::Ground[Land_Type()].Build);Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/CONST.CPP#L269-L275}, true}, // LAND_CLEAR
…
}, true}, // LAND_ROAD
…
}, false}, // LAND_WATER
…
}, false}, // LAND_ROCK
…
}, false}, // LAND_TIBERIUM
…
}, false}, // LAND_BEACHCommand & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/SMUDGE.CPP#L228-L231if (Class->IsBib) {
…
cell->Owner = ToOwn;Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/OVERLAY.CPP#L241-L253if (Class->IsWall) {
…
cellptr->Owner = ToOwn;OpenDUNE: a C re-creation of Dune II from its DOS executable (OpenDUNE/OpenDUNE) · src/structure.c#L786-L814if (g_validateStrictIfZero == 0 && isValid && type != STRUCTURE_CONSTRUCTION_YARD && !g_debugScenario) {
…
if (s->o.houseID != g_playerHouseID) continue;OpenDUNE: a C re-creation of Dune II from its DOS executable (OpenDUNE/OpenDUNE) · src/structure.c#L530-L531if (validBuildLocation == 0 && s->o.houseID == g_playerHouseID && !g_debugScenario && g_validateStrictIfZero == 0) return false;Checked by claude, 2026-10-22 — read BuildingClass::Passes_Proximity_Check, HouseClass::Place_Object, the Unlimbo and Can_Enter_Cell path, BuildingTypeClass::Legal_Placement and Occupy_List, CellClass::Is_Generally_Clear, the Ground table, and where bibs and walls set cell ownership, at the pinned commit; and OpenDUNE's placement check at its pinThe remaster client's Place call (DLLInterface.cpp) and the game's PLACE event both run Place_Object. The placement cursor and the client's placement map run their own copies of the adjacency test (DisplayClass::Passes_Proximity_Check, behind the remaster's USE_RA_AI guard, and DLLExportClass's placement distances); the check that decides is the one Place_Object runs. A construction yard deployed from an MCV doesn't go through Place_Object, and the atlas hasn't read that path. The 1995 concrete-slab check in Legal_Placement sits in an #ifdef NEVER block; whether a missing slab costs health, as in Dune II, the atlas hasn't checked.
Cited by: Command & Conquer
In the remaster's code, Tiberium grows and spreads on its own. Each map logic pass scans 30 of the 64 × 64 cells, starting at the cell where the last pass stopped (so 29 new ones), and collects up to 50 Tiberium cells below level (OverlayData) 11 and up to 50 spread sources: Tiberium cells above level 6, and blossom trees whatever their level, each entered three times. After each full sweep, computed as 142 passes, a random collected cell grows one level, and one heavy cell seeds level-1 Tiberium on a random empty neighbor of clear land; with fast growth on, as by default, or in any multiplayer game, each happens twice, and in the remaster's own multiplayer (GAME_GLYPHX_MULTIPLAYER) a change its comment dates to 1 July 2020 adds (Tiberium setting − 1) × 2 more. A cell harvested to empty is cleared and holds Tiberium again only if a neighbor seeds it. Dune II's spice doesn't grow: during play OpenDUNE's code adds spice only where a spice bloom bursts, filling a circle of radius 5, or where a harvester carrying 32 or more units is destroyed, filling a circle of radius load ÷ 32. cnc/tiberium-growth
About: Command & Conquer Resource harvesting
Value
{
"cellsPerPass": 30,
"newCellsPerPass": 29,
"mapCells": 4096,
"passesPerSweep": 142,
"maxLevel": 11,
"spreadAbove": 6
}TIBERIANDAWN/MAP.CPP#L904-L943if (!Special.IsTGrowth && !Special.IsTSpread) return;
…
int subcount = 30;
…
if (Special.IsTGrowth && ptr->Land_Type() == LAND_TIBERIUM && ptr->OverlayData < 11) {
if (TiberiumGrowthCount < sizeof(TiberiumGrowth)/sizeof(TiberiumGrowth[0])) {
…
(ptr->Land_Type() == LAND_TIBERIUM && ptr->OverlayData > 6) ||
(terrain && terrain->Class->IsTiberiumSpawn)) {
…
if (terrain) tries = 3;Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/MAP.H#L144-L152CELL TiberiumGrowth[50];
…
CELL TiberiumSpread[50];Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/MAP.CPP#L946-L1012if (TiberiumScan >= MAP_CELL_TOTAL) {
int tries = 1;
if (Special.IsTFast || GameToPlay != GAME_NORMAL) tries = 2;
…
** Use the Tiberium setting as a multiplier on growth rate. ST - 7/1/2020 3:05PM
…
if (GameToPlay == GAME_GLYPHX_MULTIPLAYER) {
if (MPlayerTiberium > 1) {
tries += (MPlayerTiberium - 1) << 1;
…
newcell->OverlayData++;
…
…Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/SPECIAL.H#L60-L62IsTGrowth = true;
IsTSpread = true;
IsTFast = true;Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/DEFINES.H#L269-L277#define MAP_CELL_MAX_X_BITS 6
#define MAP_CELL_MAX_Y_BITS 6
…
#define MAP_CELL_TOTAL (MAP_CELL_W*MAP_CELL_H)Command & Conquer Remastered Collection source code (electronicarts/CnC_Remastered_Collection) · TIBERIANDAWN/LOGIC.CPP#L254Map.Logic();OpenDUNE: a C re-creation of Dune II from its DOS executable (OpenDUNE/OpenDUNE) · src/map.c#L669-L679Map_FillCircleWithSpice(packed, 5);OpenDUNE: a C re-creation of Dune II from its DOS executable (OpenDUNE/OpenDUNE) · src/map.c#L694if (radius == 0) return;OpenDUNE: a C re-creation of Dune II from its DOS executable (OpenDUNE/OpenDUNE) · src/explosion.c#L100Map_Bloom_ExplodeSpice(packed, g_playerHouseID);OpenDUNE: a C re-creation of Dune II from its DOS executable (OpenDUNE/OpenDUNE) · src/explosion.c#L167Map_Bloom_ExplodeSpice(packed, g_playerHouseID);OpenDUNE: a C re-creation of Dune II from its DOS executable (OpenDUNE/OpenDUNE) · src/unit.c#L1517if (isSpiceBloom) Map_Bloom_ExplodeSpice(packed, Unit_GetHouseID(unit));OpenDUNE: a C re-creation of Dune II from its DOS executable (OpenDUNE/OpenDUNE) · src/unit.c#L1557if (unit->o.type == UNIT_HARVESTER) Map_FillCircleWithSpice(Tile_PackTile(unit->o.position), unit->amount / 32);OpenDUNE: a C re-creation of Dune II from its DOS executable (OpenDUNE/OpenDUNE) · src/map.c#L771-L785if (type == LST_THICK_SPICE && dir > 0) return;
…
type = (type == LST_SPICE) ? LST_THICK_SPICE : LST_SPICE;Checked by claude, 2026-10-22 — read MapClass::Logic (the loop breaks before advancing its index, so TiberiumScan keeps the last cell scanned; the sweep count is from stepping that loop), the growth and spread arrays, SpecialClass::Init's defaults, and the map size at the pinned commit; in OpenDUNE, searched src/ for Map_ChangeSpiceAmount: its only positive calls are in Map_FillCircleWithSpice, which a bloom's burst and a harvester's death call; Map_Bloom_ExplodeSpice runs when a unit moves onto a bloom, an explosion hits one, and when a scenario's spice fields are laid at load (scenario.c line 330)The remaster's multiplayer tries depend on its Tiberium setting (MPlayerTiberium), which the atlas hasn't traced to the client's options; a setting of 1 or less adds nothing. A full collection array replaces a random entry, so later cells in a sweep can displace earlier ones. By C operator precedence, the spread test's IsTSpread && binds only to the Tiberium half, so blossom trees are collected even with spread off, and at any Tiberium level. The pass count assumes Map.Logic runs once per game logic tick; how fast ticks pass depends on the game speed.
Cited by: Command & Conquer