Ginger88895
/
warzone2100
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Simplify psDroid->asBits from array of structure with a single field to just an array. 

This makes it identical to the template array asParts which does the same thing.
master
per 2013-05-09 13:24:19 +02:00
parent 81b4c63a82
commit bfb47fff4c
27 changed files with 170 additions and 197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/action.cpp
View File

@ -723,7 +723,7 @@ void actionUpdateDroid(DROID *psDroid)
CHECK_DROID(psDroid);
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
ASSERT_OR_RETURN(, psPropStats != NULL, "Invalid propulsion stats pointer");
actionSanity(psDroid);

6
src/ai.cpp
View File

@ -392,8 +392,8 @@ static SDWORD targetAttackWeight(BASE_OBJECT *psTarget, BASE_OBJECT *psAttacker,
}
/* Now calculate the overall weight */
attackWeight = asWeaponModifier[weaponEffect][(asPropulsionStats + targetDroid->asBits[COMP_PROPULSION].nStat)->propulsionType] // Our weapon's effect against target
+ asWeaponModifierBody[weaponEffect][(asBodyStats + targetDroid->asBits[COMP_BODY].nStat)->size]
attackWeight = asWeaponModifier[weaponEffect][(asPropulsionStats + targetDroid->asBits[COMP_PROPULSION])->propulsionType] // Our weapon's effect against target
+ asWeaponModifierBody[weaponEffect][(asBodyStats + targetDroid->asBits[COMP_BODY])->size]
+ WEIGHT_DIST_TILE_DROID * objSensorRange(psAttacker) / TILE_UNITS
- WEIGHT_DIST_TILE_DROID * dist/TILE_UNITS // farther droids are less attractive
+ WEIGHT_HEALTH_DROID * damageRatio/100 // we prefer damaged droids
@ -1200,7 +1200,7 @@ bool validTarget(BASE_OBJECT *psObject, BASE_OBJECT *psTarget, int weapon_slot)
switch (psTarget->type)
{
case OBJ_DROID:
if (asPropulsionTypes[asPropulsionStats[((DROID *)psTarget)->asBits[COMP_PROPULSION].nStat].propulsionType].travel == AIR)
if (asPropulsionTypes[asPropulsionStats[((DROID *)psTarget)->asBits[COMP_PROPULSION]].propulsionType].travel == AIR)
{
if (((DROID *)psTarget)->sMove.Status != MOVEINACTIVE)
{

2
src/bucket3d.cpp
View File

@ -226,7 +226,7 @@ static SDWORD bucketCalculateZ(RENDER_TYPE objectType, void* pObject)
position.y+=4;
}
psBStats = asBodyStats + psDroid->asBits[COMP_BODY].nStat;
psBStats = asBodyStats + psDroid->asBits[COMP_BODY];
droidSize = psBStats->pIMD->radius;
z = pie_RotateProject(&position,&pixel) - (droidSize*2);

30
src/component.cpp
View File

@ -455,8 +455,8 @@ static iIMDShape *getLeftPropulsionIMD(DROID *psDroid)
UDWORD bodyStat, propStat;
iIMDShape **imd;
bodyStat = psDroid->asBits[COMP_BODY].nStat;
propStat = psDroid->asBits[COMP_PROPULSION].nStat;
bodyStat = psDroid->asBits[COMP_BODY];
propStat = psDroid->asBits[COMP_PROPULSION];
imd = asBodyStats[bodyStat].ppIMDList;
imd += (propStat * NUM_PROP_SIDES + LEFT_PROP);
@ -470,8 +470,8 @@ static iIMDShape *getRightPropulsionIMD(DROID *psDroid)
UDWORD bodyStat, propStat;
iIMDShape **imd;
bodyStat = psDroid->asBits[COMP_BODY].nStat;
propStat = psDroid->asBits[COMP_PROPULSION].nStat;
bodyStat = psDroid->asBits[COMP_BODY];
propStat = psDroid->asBits[COMP_PROPULSION];
imd = asBodyStats[bodyStat].ppIMDList;
imd += (propStat * NUM_PROP_SIDES + RIGHT_PROP);
@ -504,7 +504,7 @@ static void displayCompObj(DROID *psDroid, bool bButton)
}
/* get propulsion stats */
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
ASSERT_OR_RETURN( , psPropStats != NULL, "invalid propulsion stats pointer");
//set pieflag for button object or ingame object
@ -529,7 +529,7 @@ static void displayCompObj(DROID *psDroid, bool bButton)
}
/* set default components transparent */
if ( psDroid->asBits[COMP_PROPULSION].nStat == 0 )
if ( psDroid->asBits[COMP_PROPULSION] == 0 )
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
@ -553,7 +553,7 @@ static void displayCompObj(DROID *psDroid, bool bButton)
}
/* set default components transparent */
if ( psDroid->asBits[COMP_BODY].nStat == 0 )
if ( psDroid->asBits[COMP_BODY] == 0 )
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
@ -597,7 +597,7 @@ static void displayCompObj(DROID *psDroid, bool bButton)
/* render vtol jet if flying - horrible hack - GJ */
if (!bButton && psPropStats->propulsionType == PROPULSION_TYPE_LIFT && !cyborgDroid(psDroid) && psDroid->sMove.Status != MOVEINACTIVE)
{
psJet = asBodyStats[psDroid->asBits[COMP_BODY].nStat].pFlameIMD;
psJet = asBodyStats[psDroid->asBits[COMP_BODY]].pFlameIMD;
if (psJet)
{
pie_Draw3DShape(psJet, getModularScaledGraphicsTime(psJet->animInterval, psJet->numFrames), colour, brightness, pie_ADDITIVE, 200);
@ -612,12 +612,12 @@ static void displayCompObj(DROID *psDroid, bool bButton)
}
/* set default components transparent */
if (psDroid->asWeaps[0].nStat == 0 &&
psDroid->asBits[COMP_SENSOR].nStat == 0 &&
psDroid->asBits[COMP_ECM].nStat == 0 &&
psDroid->asBits[COMP_BRAIN].nStat == 0 &&
psDroid->asBits[COMP_REPAIRUNIT].nStat == 0 &&
psDroid->asBits[COMP_CONSTRUCT].nStat == 0)
if (psDroid->asWeaps[0].nStat == 0 &&
psDroid->asBits[COMP_SENSOR] == 0 &&
psDroid->asBits[COMP_ECM] == 0 &&
psDroid->asBits[COMP_BRAIN] == 0 &&
psDroid->asBits[COMP_REPAIRUNIT] == 0 &&
psDroid->asBits[COMP_CONSTRUCT] == 0)
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;
@ -893,7 +893,7 @@ static void displayCompObj(DROID *psDroid, bool bButton)
muzzle flash attachment points - just grab it from psShape->connectors->[x|y|z] */
/* set default components transparent */
if ( psDroid->asBits[COMP_PROPULSION].nStat == 0 )
if ( psDroid->asBits[COMP_PROPULSION] == 0 )
{
pieFlag |= pie_TRANSLUCENT;
iPieData = DEFAULT_COMPONENT_TRANSLUCENCY;

24
src/component.h
View File

@ -69,34 +69,34 @@ SDWORD rescaleButtonObject(SDWORD radius, SDWORD baseScale,SDWORD baseRadius);
void destroyFXDroid(DROID *psDroid, unsigned impactTime);
/* Pass in the stats you're interested in and the COMPONENT - double reference, but works. NOTE: Unused!*/
#define PART_IMD(STATS,DROID,COMPONENT,PLAYER) (STATS[DROID->asBits[COMPONENT].nStat].pIMD)
#define PART_IMD(STATS,DROID,COMPONENT,PLAYER) (STATS[DROID->asBits[COMPONENT]].pIMD)
/* Get the chassis imd */
#define BODY_IMD(DROID,PLAYER) (asBodyStats[DROID->asBits[COMP_BODY].nStat].pIMD)
#define BODY_IMD(DROID,PLAYER) (asBodyStats[DROID->asBits[COMP_BODY]].pIMD)
/* Get the brain imd - NOTE: Unused!*/
#define BRAIN_IMD(DROID,PLAYER) (asBrainStats[DROID->asBits[COMP_BRAIN].nStat].pIMD)
#define BRAIN_IMD(DROID,PLAYER) (asBrainStats[DROID->asBits[COMP_BRAIN]].pIMD)
/* Get the weapon imd */
#define WEAPON_IMD(DROID,WEAPON_NUM) (asWeaponStats[DROID->asWeaps[WEAPON_NUM].nStat].pIMD)
/* Get the propulsion imd THIS IS A LITTLE MORE COMPLICATED NOW!*/
//#define PROPULSION_IMD(DROID,PLAYER) (asPropulsionStats[DROID->asBits[COMP_PROPULSION].nStat].pIMD[PLAYER])
//#define PROPULSION_IMD(DROID,PLAYER) (asPropulsionStats[DROID->asBits[COMP_PROPULSION]].pIMD[PLAYER])
/* Get the sensor imd */
#define SENSOR_IMD(DROID,PLAYER) (asSensorStats[DROID->asBits[COMP_SENSOR].nStat].pIMD)
#define SENSOR_IMD(DROID,PLAYER) (asSensorStats[DROID->asBits[COMP_SENSOR]].pIMD)
/* Get an ECM imd!?! */
#define ECM_IMD(DROID,PLAYER) (asECMStats[DROID->asBits[COMP_ECM].nStat].pIMD)
#define ECM_IMD(DROID,PLAYER) (asECMStats[DROID->asBits[COMP_ECM]].pIMD)
/* Get an Repair imd!?! */
#define REPAIR_IMD(DROID,PLAYER) (asRepairStats[DROID->asBits[COMP_REPAIRUNIT].nStat].pIMD)
#define REPAIR_IMD(DROID,PLAYER) (asRepairStats[DROID->asBits[COMP_REPAIRUNIT]].pIMD)
/* Get a construct imd */
#define CONSTRUCT_IMD(DROID,PLAYER) (asConstructStats[DROID->asBits[COMP_CONSTRUCT].nStat].pIMD)
#define CONSTRUCT_IMD(DROID,PLAYER) (asConstructStats[DROID->asBits[COMP_CONSTRUCT]].pIMD)
/* Get a weapon mount imd*/
#define WEAPON_MOUNT_IMD(DROID,WEAPON_NUM) (asWeaponStats[DROID->asWeaps[WEAPON_NUM].nStat].pMountGraphic)
/* Get a sensor mount imd*/
#define SENSOR_MOUNT_IMD(DROID,PLAYER) (asSensorStats[DROID->asBits[COMP_SENSOR].nStat].pMountGraphic)
#define SENSOR_MOUNT_IMD(DROID,PLAYER) (asSensorStats[DROID->asBits[COMP_SENSOR]].pMountGraphic)
/* Get a construct mount imd*/
#define CONSTRUCT_MOUNT_IMD(DROID,PLAYER) (asConstructStats[DROID->asBits[COMP_CONSTRUCT].nStat].pMountGraphic)
#define CONSTRUCT_MOUNT_IMD(DROID,PLAYER) (asConstructStats[DROID->asBits[COMP_CONSTRUCT]].pMountGraphic)
/* Get a ecm mount imd*/
#define ECM_MOUNT_IMD(DROID,PLAYER) (asECMStats[DROID->asBits[COMP_ECM].nStat].pMountGraphic)
#define ECM_MOUNT_IMD(DROID,PLAYER) (asECMStats[DROID->asBits[COMP_ECM]].pMountGraphic)
/* Get a repair mount imd*/
#define REPAIR_MOUNT_IMD(DROID,PLAYER) (asRepairStats[DROID->asBits[COMP_REPAIRUNIT].nStat].pMountGraphic)
#define REPAIR_MOUNT_IMD(DROID,PLAYER) (asRepairStats[DROID->asBits[COMP_REPAIRUNIT]].pMountGraphic)
/* Get a muzzle flash pie*/
#define MUZZLE_FLASH_PIE(DROID,WEAPON_NUM) (asWeaponStats[DROID->asWeaps[WEAPON_NUM].nStat].pMuzzleGraphic)

2
src/display3d.cpp
View File

@ -3395,7 +3395,7 @@ static void drawDroidCmndNo(DROID *psDroid)
void calcScreenCoords(DROID *psDroid)
{
/* Get it's absolute dimensions */
const BODY_STATS *psBStats = asBodyStats + psDroid->asBits[COMP_BODY].nStat;
const BODY_STATS *psBStats = asBodyStats + psDroid->asBits[COMP_BODY];
Vector3i origin;
Vector2i center;
int wsRadius = 22; // World space radius, 22 = magic minimum

2
src/drive.cpp
View File

@ -556,7 +556,7 @@ void driveUpdate(void)
for (psDroid = apsDroidLists[selectedPlayer]; psDroid; psDroid = psDroid->psNext)
{
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
if ((psDroid->selected) &&
(psDroid != psDrivenDroid) &&

95
src/droid.cpp
View File

@ -890,7 +890,7 @@ void droidUpdate(DROID *psDroid)
// -----------------
// See if we can and need to self repair.
if (!isVtolDroid(psDroid) && psDroid->body < psDroid->originalBody && psDroid->asBits[COMP_REPAIRUNIT].nStat != 0 && selfRepairEnabled(psDroid->player))
if (!isVtolDroid(psDroid) && psDroid->body < psDroid->originalBody && psDroid->asBits[COMP_REPAIRUNIT] != 0 && selfRepairEnabled(psDroid->player))
{
droidUpdateDroidSelfRepair(psDroid);
}
@ -1137,7 +1137,7 @@ bool droidUpdateBuild(DROID *psDroid)
psStruct = (STRUCTURE *)psDroid->order.psObj;
ASSERT_OR_RETURN(false, psStruct->type == OBJ_STRUCTURE, "target is not a structure" );
ASSERT_OR_RETURN(false, psDroid->asBits[COMP_CONSTRUCT].nStat < numConstructStats, "Invalid construct pointer for unit" );
ASSERT_OR_RETURN(false, psDroid->asBits[COMP_CONSTRUCT] < numConstructStats, "Invalid construct pointer for unit" );
// First check the structure hasn't been completed by another droid
if (psStruct->status == SS_BUILT)
@ -1167,7 +1167,7 @@ bool droidUpdateBuild(DROID *psDroid)
}
constructPoints = constructorPoints(asConstructStats + psDroid->
asBits[COMP_CONSTRUCT].nStat, psDroid->player);
asBits[COMP_CONSTRUCT], psDroid->player);
pointsToAdd = constructPoints * (gameTime - psDroid->actionStarted) /
GAME_TICKS_PER_SEC;
@ -1197,7 +1197,7 @@ bool droidUpdateDemolishing( DROID *psDroid )
STRUCTURE *psStruct = (STRUCTURE *)psDroid->order.psObj;
ASSERT_OR_RETURN(false, psStruct->type == OBJ_STRUCTURE, "target is not a structure");
int constructRate = 5 * constructorPoints(asConstructStats + psDroid->asBits[COMP_CONSTRUCT].nStat, psDroid->player);
int constructRate = 5 * constructorPoints(asConstructStats + psDroid->asBits[COMP_CONSTRUCT], psDroid->player);
int pointsToAdd = gameTimeAdjustedAverage(constructRate);
structureDemolish(psStruct, psDroid, pointsToAdd);
@ -1342,7 +1342,7 @@ bool droidUpdateRepair( DROID *psDroid )
STRUCTURE *psStruct = (STRUCTURE *)psDroid->psActionTarget[0];
ASSERT_OR_RETURN(false, psStruct->type == OBJ_STRUCTURE, "target is not a structure");
int iRepairRate = constructorPoints(asConstructStats + psDroid->asBits[COMP_CONSTRUCT].nStat, psDroid->player);
int iRepairRate = constructorPoints(asConstructStats + psDroid->asBits[COMP_CONSTRUCT], psDroid->player);
/* add points to structure */
structureRepair(psStruct, psDroid, iRepairRate);
@ -1364,14 +1364,14 @@ static bool droidUpdateDroidRepairBase(DROID *psRepairDroid, DROID *psDroidToRep
{
CHECK_DROID(psRepairDroid);
int iRepairRateNumerator = repairPoints(asRepairStats + psRepairDroid->asBits[COMP_REPAIRUNIT].nStat, psRepairDroid->player);
int iRepairRateNumerator = repairPoints(asRepairStats + psRepairDroid->asBits[COMP_REPAIRUNIT], psRepairDroid->player);
int iRepairRateDenominator = 1;
//if self repair then add repair points depending on the time delay for the stat
if (psRepairDroid == psDroidToRepair)
{
iRepairRateNumerator *= GAME_TICKS_PER_SEC;
iRepairRateDenominator *= (asRepairStats + psRepairDroid->asBits[COMP_REPAIRUNIT].nStat)->time;
iRepairRateDenominator *= (asRepairStats + psRepairDroid->asBits[COMP_REPAIRUNIT])->time;
}
int iPointsToAdd = gameTimeAdjustedAverage(iRepairRateNumerator, iRepairRateDenominator);
@ -1396,7 +1396,7 @@ static bool droidUpdateDroidRepairBase(DROID *psRepairDroid, DROID *psDroidToRep
bool droidUpdateDroidRepair(DROID *psRepairDroid)
{
ASSERT_OR_RETURN(false, psRepairDroid->action == DACTION_DROIDREPAIR, "Unit does not have unit repair order");
ASSERT_OR_RETURN(false, psRepairDroid->asBits[COMP_REPAIRUNIT].nStat != 0, "Unit does not have a repair turret");
ASSERT_OR_RETURN(false, psRepairDroid->asBits[COMP_REPAIRUNIT] != 0, "Unit does not have a repair turret");
DROID *psDroidToRepair = (DROID *)psRepairDroid->psActionTarget[0];
ASSERT_OR_RETURN(false, psDroidToRepair->type == OBJ_DROID, "Target is not a unit");
@ -1619,16 +1619,16 @@ UDWORD calcDroidBaseBody(DROID *psDroid)
}
/* Get the basic component body points */
body =
(asBodyStats + psDroid->asBits[COMP_BODY].nStat)->body +
(asBrainStats + psDroid->asBits[COMP_BRAIN].nStat)->body +
(asSensorStats + psDroid->asBits[COMP_SENSOR].nStat)->body +
(asECMStats + psDroid->asBits[COMP_ECM].nStat)->body +
(asRepairStats + psDroid->asBits[COMP_REPAIRUNIT].nStat)->body +
(asConstructStats + psDroid->asBits[COMP_CONSTRUCT].nStat)->body;
(asBodyStats + psDroid->asBits[COMP_BODY])->body +
(asBrainStats + psDroid->asBits[COMP_BRAIN])->body +
(asSensorStats + psDroid->asBits[COMP_SENSOR])->body +
(asECMStats + psDroid->asBits[COMP_ECM])->body +
(asRepairStats + psDroid->asBits[COMP_REPAIRUNIT])->body +
(asConstructStats + psDroid->asBits[COMP_CONSTRUCT])->body;
/* propulsion body points are a percentage of the bodys' body points */
body += (((asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat)->body *
(asBodyStats + psDroid->asBits[COMP_BODY].nStat)->body) / 100);
body += (((asPropulsionStats + psDroid->asBits[COMP_PROPULSION])->body *
(asBodyStats + psDroid->asBits[COMP_BODY])->body) / 100);
/* Add the weapon body points */
for(i=0; i<psDroid->numWeaps; i++)
@ -1777,16 +1777,16 @@ UDWORD calcDroidPower(DROID *psDroid)
UDWORD power, i;
//get the component power
power = (asBodyStats + psDroid->asBits[COMP_BODY].nStat)->buildPower +
(asBrainStats + psDroid->asBits[COMP_BRAIN].nStat)->buildPower +
(asSensorStats + psDroid->asBits[COMP_SENSOR].nStat)->buildPower +
(asECMStats + psDroid->asBits[COMP_ECM].nStat)->buildPower +
(asRepairStats + psDroid->asBits[COMP_REPAIRUNIT].nStat)->buildPower +
(asConstructStats + psDroid->asBits[COMP_CONSTRUCT].nStat)->buildPower;
power = (asBodyStats + psDroid->asBits[COMP_BODY])->buildPower +
(asBrainStats + psDroid->asBits[COMP_BRAIN])->buildPower +
(asSensorStats + psDroid->asBits[COMP_SENSOR])->buildPower +
(asECMStats + psDroid->asBits[COMP_ECM])->buildPower +
(asRepairStats + psDroid->asBits[COMP_REPAIRUNIT])->buildPower +
(asConstructStats + psDroid->asBits[COMP_CONSTRUCT])->buildPower;
/* propulsion power points are a percentage of the bodys' power points */
power += (((asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat)->buildPower *
(asBodyStats + psDroid->asBits[COMP_BODY].nStat)->buildPower) / 100);
power += (((asPropulsionStats + psDroid->asBits[COMP_PROPULSION])->buildPower *
(asBodyStats + psDroid->asBits[COMP_BODY])->buildPower) / 100);
//add weapon power
for(i=0; i<psDroid->numWeaps; i++)
@ -1991,20 +1991,7 @@ void droidSetBits(DROID_TEMPLATE *pTemplate,DROID *psDroid)
}
psDroid->asWeaps[inc].usedAmmo = 0;
}
//allocate the components hit points
psDroid->asBits[COMP_BODY].nStat = (UBYTE)pTemplate->asParts[COMP_BODY];
// ajl - changed this to init brains for all droids (crashed)
psDroid->asBits[COMP_BRAIN].nStat = 0;
// This is done by the Command droid stuff - John.
// Not any more - John.
psDroid->asBits[COMP_BRAIN].nStat = pTemplate->asParts[COMP_BRAIN];
psDroid->asBits[COMP_PROPULSION].nStat = pTemplate->asParts[COMP_PROPULSION];
psDroid->asBits[COMP_SENSOR].nStat = pTemplate->asParts[COMP_SENSOR];
psDroid->asBits[COMP_ECM].nStat = pTemplate->asParts[COMP_ECM];
psDroid->asBits[COMP_REPAIRUNIT].nStat = pTemplate->asParts[COMP_REPAIRUNIT];
psDroid->asBits[COMP_CONSTRUCT].nStat = pTemplate->asParts[COMP_CONSTRUCT];
memcpy(psDroid->asBits, pTemplate->asParts, sizeof(psDroid->asBits));
switch (getPropulsionStats(psDroid)->propulsionType) // getPropulsionStats(psDroid) only defined after psDroid->asBits[COMP_PROPULSION] is set.
{
@ -2039,13 +2026,7 @@ void templateSetParts(const DROID *psDroid, DROID_TEMPLATE *psTemplate)
psTemplate->asWeaps[inc] = psDroid->asWeaps[inc].nStat;
}
}
psTemplate->asParts[COMP_BODY] = psDroid->asBits[COMP_BODY].nStat;
psTemplate->asParts[COMP_BRAIN] = psDroid->asBits[COMP_BRAIN].nStat;
psTemplate->asParts[COMP_PROPULSION] = psDroid->asBits[COMP_PROPULSION].nStat;
psTemplate->asParts[COMP_SENSOR] = psDroid->asBits[COMP_SENSOR].nStat;
psTemplate->asParts[COMP_ECM] = psDroid->asBits[COMP_ECM].nStat;
psTemplate->asParts[COMP_REPAIRUNIT] = psDroid->asBits[COMP_REPAIRUNIT].nStat;
psTemplate->asParts[COMP_CONSTRUCT] = psDroid->asBits[COMP_CONSTRUCT].nStat;
memcpy(psTemplate->asParts, psDroid->asBits, sizeof(psDroid->asBits));
}
/* Make all the droids for a certain player a member of a specific group */
@ -2834,9 +2815,7 @@ bool electronicDroid(DROID *psDroid)
CHECK_DROID(psDroid);
//use slot 0 for now
//if (psDroid->numWeaps && asWeaponStats[psDroid->asWeaps[0].nStat].
if (psDroid->numWeaps > 0 && asWeaponStats[psDroid->asWeaps[0].nStat].
weaponSubClass == WSC_ELECTRONIC)
if (psDroid->numWeaps > 0 && asWeaponStats[psDroid->asWeaps[0].nStat].weaponSubClass == WSC_ELECTRONIC)
{
return true;
}
@ -2899,14 +2878,14 @@ UBYTE checkCommandExist(UBYTE player)
//access functions for vtols
bool isVtolDroid(const DROID* psDroid)
{
return asPropulsionStats[psDroid->asBits[COMP_PROPULSION].nStat].propulsionType == PROPULSION_TYPE_LIFT
return asPropulsionStats[psDroid->asBits[COMP_PROPULSION]].propulsionType == PROPULSION_TYPE_LIFT
&& (psDroid->droidType != DROID_TRANSPORTER && psDroid->droidType != DROID_SUPERTRANSPORTER);
}
/* returns true if the droid has lift propulsion and is moving */
bool isFlying(const DROID* psDroid)
{
return (asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat)->propulsionType == PROPULSION_TYPE_LIFT
return (asPropulsionStats + psDroid->asBits[COMP_PROPULSION])->propulsionType == PROPULSION_TYPE_LIFT
&& (psDroid->sMove.Status != MOVEINACTIVE || psDroid->droidType == DROID_TRANSPORTER || psDroid->droidType == DROID_SUPERTRANSPORTER);
}
@ -3207,7 +3186,7 @@ bool droidSensorDroidWeapon(BASE_OBJECT *psObj, DROID *psDroid)
{
return false;
}
compIndex = ((DROID *)psObj)->asBits[COMP_SENSOR].nStat;
compIndex = ((DROID *)psObj)->asBits[COMP_SENSOR];
ASSERT_OR_RETURN( false, compIndex < numSensorStats, "Invalid range referenced for numSensorStats, %d > %d", compIndex, numSensorStats);
psStats = asSensorStats + compIndex;
break;
@ -3267,8 +3246,8 @@ bool cbSensorDroid(DROID *psDroid)
{
return false;
}
if (asSensorStats[psDroid->asBits[COMP_SENSOR].nStat].type == VTOL_CB_SENSOR
|| asSensorStats[psDroid->asBits[COMP_SENSOR].nStat].type == INDIRECT_CB_SENSOR)
if (asSensorStats[psDroid->asBits[COMP_SENSOR]].type == VTOL_CB_SENSOR
|| asSensorStats[psDroid->asBits[COMP_SENSOR]].type == INDIRECT_CB_SENSOR)
{
return true;
}
@ -3283,9 +3262,9 @@ bool standardSensorDroid(DROID *psDroid)
{
return false;
}
if (asSensorStats[psDroid->asBits[COMP_SENSOR].nStat].type == VTOL_INTERCEPT_SENSOR
|| asSensorStats[psDroid->asBits[COMP_SENSOR].nStat].type == STANDARD_SENSOR
|| asSensorStats[psDroid->asBits[COMP_SENSOR].nStat].type == SUPER_SENSOR)
if (asSensorStats[psDroid->asBits[COMP_SENSOR]].type == VTOL_INTERCEPT_SENSOR
|| asSensorStats[psDroid->asBits[COMP_SENSOR]].type == STANDARD_SENSOR
|| asSensorStats[psDroid->asBits[COMP_SENSOR]].type == SUPER_SENSOR)
{
return true;
}
@ -3353,7 +3332,7 @@ DROID *giftSingleDroid(DROID *psD, UDWORD to)
SWORD droidResistance(DROID *psDroid)
{
CHECK_DROID(psDroid);
BODY_STATS *psStats = asBodyStats + psDroid->asBits[COMP_BODY].nStat;
BODY_STATS *psStats = asBodyStats + psDroid->asBits[COMP_BODY];
int resistance = psDroid->experience / (65536 / MAX(1, psStats->upgrade[psDroid->player].resistance));
// ensure resistance is a base minimum
resistance = MAX(resistance, psStats->upgrade[psDroid->player].resistance);
@ -3521,7 +3500,7 @@ void checkDroid(const DROID *droid, const char *const location, const char *func
int droidSqDist(DROID *psDroid, BASE_OBJECT *psObj)
{
PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
if (!fpathCheck(psDroid->pos, psObj->pos, psPropStats->propulsionType))
{

14
src/droid.h
View File

@ -351,37 +351,37 @@ static inline int droidJammerPower(const DROID* psDroid)
*/
static inline BODY_STATS *getBodyStats(DROID *psDroid)
{
return asBodyStats + psDroid->asBits[COMP_BODY].nStat;
return asBodyStats + psDroid->asBits[COMP_BODY];
}
static inline BRAIN_STATS *getBrainStats(DROID *psDroid)
{
return asBrainStats + psDroid->asBits[COMP_BRAIN].nStat;
return asBrainStats + psDroid->asBits[COMP_BRAIN];
}
static inline PROPULSION_STATS *getPropulsionStats(DROID *psDroid)
{
return asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
return asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
}
static inline SENSOR_STATS *getSensorStats(DROID *psDroid)
{
return asSensorStats + psDroid->asBits[COMP_SENSOR].nStat;
return asSensorStats + psDroid->asBits[COMP_SENSOR];
}
static inline ECM_STATS *getECMStats(DROID *psDroid)
{
return asECMStats + psDroid->asBits[COMP_ECM].nStat;
return asECMStats + psDroid->asBits[COMP_ECM];
}
static inline REPAIR_STATS *getRepairStats(DROID *psDroid)
{
return asRepairStats + psDroid->asBits[COMP_REPAIRUNIT].nStat;
return asRepairStats + psDroid->asBits[COMP_REPAIRUNIT];
}
static inline CONSTRUCT_STATS *getConstructStats(DROID *psDroid)
{
return asConstructStats + psDroid->asBits[COMP_CONSTRUCT].nStat;
return asConstructStats + psDroid->asBits[COMP_CONSTRUCT];
}
static inline WEAPON_STATS *getWeaponStats(DROID *psDroid, int weapon_slot)

8
src/droiddef.h
View File

@ -54,12 +54,6 @@
//defines how many times to perform the iteration on looking for a blank location
#define LOOK_FOR_EMPTY_TILE 20
struct COMPONENT
{
UBYTE nStat; ///< Allowing a maximum of 255 stats per file
};
typedef std::vector<DROID_ORDER_DATA> OrderList;
struct DROID_TEMPLATE : public BASE_STATS
@ -110,7 +104,7 @@ struct DROID : public BASE_OBJECT
* per part to be calculated. Indexed by COMPONENT_TYPE.
* Weapons need to be dealt with separately.
*/
COMPONENT asBits[DROID_MAXCOMP];
uint8_t asBits[DROID_MAXCOMP];
/* The other droid data. These are all derived from the components
* but stored here for easy access

14
src/game.cpp
View File

@ -4483,13 +4483,13 @@ static bool writeDroid(WzConfig &ini, DROID *psCurr, bool onMission, int &counte
if (psCurr->periodicalDamage > 0) ini.setValue("periodicalDamage", psCurr->periodicalDamage);
ini.setValue("droidType", psCurr->droidType);
ini.setValue("weapons", psCurr->numWeaps);
ini.setValue("parts/body", (asBodyStats + psCurr->asBits[COMP_BODY].nStat)->pName);
ini.setValue("parts/propulsion", (asPropulsionStats + psCurr->asBits[COMP_PROPULSION].nStat)->pName);
ini.setValue("parts/brain", (asBrainStats + psCurr->asBits[COMP_BRAIN].nStat)->pName);
ini.setValue("parts/repair", (asRepairStats + psCurr->asBits[COMP_REPAIRUNIT].nStat)->pName);
ini.setValue("parts/ecm", (asECMStats + psCurr->asBits[COMP_ECM].nStat)->pName);
ini.setValue("parts/sensor", (asSensorStats + psCurr->asBits[COMP_SENSOR].nStat)->pName);
ini.setValue("parts/construct", (asConstructStats + psCurr->asBits[COMP_CONSTRUCT].nStat)->pName);
ini.setValue("parts/body", (asBodyStats + psCurr->asBits[COMP_BODY])->pName);
ini.setValue("parts/propulsion", (asPropulsionStats + psCurr->asBits[COMP_PROPULSION])->pName);
ini.setValue("parts/brain", (asBrainStats + psCurr->asBits[COMP_BRAIN])->pName);
ini.setValue("parts/repair", (asRepairStats + psCurr->asBits[COMP_REPAIRUNIT])->pName);
ini.setValue("parts/ecm", (asECMStats + psCurr->asBits[COMP_ECM])->pName);
ini.setValue("parts/sensor", (asSensorStats + psCurr->asBits[COMP_SENSOR])->pName);
ini.setValue("parts/construct", (asConstructStats + psCurr->asBits[COMP_CONSTRUCT])->pName);
for (int j = 0; j < psCurr->numWeaps; j++)
{
ini.setValue("parts/weapon/" + QString::number(j + 1), (asWeaponStats + psCurr->asWeaps[j].nStat)->pName);

4
src/hci.cpp
View File

@ -3178,8 +3178,8 @@ static bool intAddObjectWindow(BASE_OBJECT *psObjects, BASE_OBJECT *psSelected,
Droid = (DROID *)psObj;
if (Droid->droidType == DROID_CONSTRUCT || Droid->droidType == DROID_CYBORG_CONSTRUCT)
{
compIndex = Droid->asBits[COMP_CONSTRUCT].nStat;
ASSERT_OR_RETURN(false, Droid->asBits[COMP_CONSTRUCT].nStat, "Invalid droid type");
compIndex = Droid->asBits[COMP_CONSTRUCT];
ASSERT_OR_RETURN(false, Droid->asBits[COMP_CONSTRUCT], "Invalid droid type");
ASSERT_OR_RETURN(false, compIndex < numConstructStats, "Invalid range referenced for numConstructStats, %d > %d", compIndex, numConstructStats);
psStats = (BASE_STATS *)(asConstructStats + compIndex);
sBarInit2.size = (UWORD)constructorPoints((CONSTRUCT_STATS *)psStats, Droid->player);

2
src/intdisplay.cpp
View File

@ -207,7 +207,7 @@ void intUpdateProgressBar(WIDGET *psWidget, W_CONTEXT *psContext)
if (DroidIsBuilding(Droid)) // Is it a building.
{
ASSERT(Droid->asBits[COMP_CONSTRUCT].nStat, "Invalid droid type");
ASSERT(Droid->asBits[COMP_CONSTRUCT], "Invalid droid type");
Structure = DroidGetBuildStructure(Droid); // Get the structure's building.

26
src/move.cpp
View File

@ -375,7 +375,7 @@ void moveStopDroid(DROID *psDroid)
CHECK_DROID(psDroid);
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
ASSERT( psPropStats != NULL,
"moveUpdateUnit: invalid propulsion stats pointer" );
@ -578,7 +578,7 @@ static SDWORD moveObjRadius(const BASE_OBJECT* psObj)
}
else
{
const BODY_STATS* psBdyStats = &asBodyStats[psDroid->asBits[COMP_BODY].nStat];
const BODY_STATS* psBdyStats = &asBodyStats[psDroid->asBits[COMP_BODY]];
switch (psBdyStats->size)
{
case SIZE_LIGHT:
@ -1169,7 +1169,7 @@ static Vector2i moveGetObstacleVector(DROID *psDroid, Vector2i dest)
{
int32_t numObst = 0, distTot = 0;
Vector2i dir(0, 0);
PROPULSION_STATS * psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
PROPULSION_STATS * psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
ASSERT(psPropStats, "invalid propulsion stats pointer");
@ -1211,7 +1211,7 @@ static Vector2i moveGetObstacleVector(DROID *psDroid, Vector2i dest)
continue;
}
PROPULSION_STATS *obstaclePropStats = asPropulsionStats + psObstacle->asBits[COMP_PROPULSION].nStat;
PROPULSION_STATS *obstaclePropStats = asPropulsionStats + psObstacle->asBits[COMP_PROPULSION];
int obstacleMaxSpeed = obstaclePropStats->maxSpeed;
int obstacleRadius = moveObjRadius(psObstacle);
int totalRadius = ourRadius + obstacleRadius;
@ -1335,14 +1335,14 @@ SDWORD moveCalcDroidSpeed(DROID *psDroid)
// NOTE: This screws up since the transporter is offscreen still (on a mission!), and we are trying to find terrainType of a tile (that is offscreen!)
if (psDroid->droidType == DROID_TRANSPORTER && missionIsOffworld())
{
PROPULSION_STATS *propulsion = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
PROPULSION_STATS *propulsion = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
speed = propulsion->maxSpeed;
}
else
{
mapX = map_coord(psDroid->pos.x);
mapY = map_coord(psDroid->pos.y);
speed = calcDroidSpeed(psDroid->baseSpeed, terrainType(mapTile(mapX,mapY)), psDroid->asBits[COMP_PROPULSION].nStat, getDroidEffectiveLevel(psDroid));
speed = calcDroidSpeed(psDroid->baseSpeed, terrainType(mapTile(mapX,mapY)), psDroid->asBits[COMP_PROPULSION], getDroidEffectiveLevel(psDroid));
}
@ -1592,7 +1592,7 @@ static void moveUpdateGroundModel(DROID *psDroid, SDWORD speed, uint16_t directi
return;
}
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
spinSpeed = psDroid->baseSpeed * psPropStats->spinSpeed;
turnSpeed = psDroid->baseSpeed * psPropStats->turnSpeed;
spinAngle = DEG(psPropStats->spinAngle);
@ -1674,7 +1674,7 @@ static void moveUpdatePersonModel(DROID *psDroid, SDWORD speed, uint16_t directi
return;
}
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
spinSpeed = psDroid->baseSpeed * psPropStats->spinSpeed;
turnSpeed = psDroid->baseSpeed * psPropStats->turnSpeed;
@ -1800,7 +1800,7 @@ static void moveUpdateVtolModel(DROID *psDroid, SDWORD speed, uint16_t direction
return;
}
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
spinSpeed = DEG(psPropStats->spinSpeed);
turnSpeed = DEG(psPropStats->turnSpeed);
@ -1922,7 +1922,7 @@ static void moveUpdateCyborgModel(DROID *psDroid, SDWORD moveSpeed, uint16_t mov
return;
}
PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
ASSERT( psPropStats != NULL,
"moveUpdateCyborgModel: invalid propulsion stats pointer" );
@ -2091,7 +2091,7 @@ static void movePlayDroidMoveAudio( DROID *psDroid )
if ( (psDroid != NULL) &&
(psDroid->visible[selectedPlayer]) )
{
iPropType = asPropulsionStats[(psDroid)->asBits[COMP_PROPULSION].nStat].propulsionType;
iPropType = asPropulsionStats[(psDroid)->asBits[COMP_PROPULSION]].propulsionType;
psPropType = &asPropulsionTypes[iPropType];
/* play specific wheeled and transporter or stats-specified noises */
@ -2149,7 +2149,7 @@ static void movePlayAudio( DROID *psDroid, bool bStarted, bool bStoppedBefore, S
AUDIO_CALLBACK pAudioCallback = NULL;
/* get prop stats */
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
ASSERT( psPropStats != NULL,
"moveUpdateUnit: invalid propulsion stats pointer" );
propType = psPropStats->propulsionType;
@ -2307,7 +2307,7 @@ void moveUpdateDroid(DROID *psDroid)
CHECK_DROID(psDroid);
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
ASSERT_OR_RETURN(, psPropStats != NULL, "Invalid propulsion stats pointer");
// If the droid has been attacked by an EMP weapon, it is temporarily disabled

24
src/oprint.cpp
View File

@ -208,10 +208,10 @@ void printDroidInfo(const DROID* psDroid)
switch (i)
{
case COMP_BODY:
if (psDroid->asBits[i].nStat > 0)
if (psDroid->asBits[i] > 0)
{
CONPRINTF(ConsoleString,(ConsoleString,"Body: "));
psBdyStats = asBodyStats + psDroid->asBits[i].nStat;
psBdyStats = asBodyStats + psDroid->asBits[i];
printComponentInfo((COMPONENT_STATS *)psBdyStats);
}
else
@ -222,10 +222,10 @@ void printDroidInfo(const DROID* psDroid)
case COMP_BRAIN:
break;
case COMP_PROPULSION:
if (psDroid->asBits[i].nStat > 0)
if (psDroid->asBits[i] > 0)
{
CONPRINTF(ConsoleString,(ConsoleString,"Prop: "));
psPropStats = asPropulsionStats + psDroid->asBits[i].nStat;
psPropStats = asPropulsionStats + psDroid->asBits[i];
printComponentInfo((COMPONENT_STATS *)psPropStats);
}
else
@ -234,10 +234,10 @@ void printDroidInfo(const DROID* psDroid)
}
break;
case COMP_ECM:
if (psDroid->asBits[i].nStat > 0)
if (psDroid->asBits[i] > 0)
{
CONPRINTF(ConsoleString,(ConsoleString,"ECM: "));
psECMStats = asECMStats + psDroid->asBits[i].nStat;
psECMStats = asECMStats + psDroid->asBits[i];
printComponentInfo((COMPONENT_STATS *)psECMStats);
CONPRINTF(ConsoleString,(ConsoleString," range %d loc %d imd %p\n",
ecmRange(psECMStats, psDroid->player), psECMStats->location,
@ -249,10 +249,10 @@ void printDroidInfo(const DROID* psDroid)
}
break;
case COMP_SENSOR:
if (psDroid->asBits[i].nStat > 0)
if (psDroid->asBits[i] > 0)
{
CONPRINTF(ConsoleString,(ConsoleString,"Sensor: "));
psSensStats = asSensorStats + psDroid->asBits[i].nStat;
psSensStats = asSensorStats + psDroid->asBits[i];
printComponentInfo((COMPONENT_STATS *)psSensStats);
CONPRINTF(ConsoleString,(ConsoleString," rng %d loc %d imd %p\n",
sensorRange(psSensStats,psDroid->player),
@ -264,10 +264,10 @@ void printDroidInfo(const DROID* psDroid)
}
break;
case COMP_CONSTRUCT:
if (psDroid->asBits[i].nStat > 0)
if (psDroid->asBits[i] > 0)
{
CONPRINTF(ConsoleString,(ConsoleString,"Construct: "));
psConstStats = asConstructStats + psDroid->asBits[i].nStat;
psConstStats = asConstructStats + psDroid->asBits[i];
printComponentInfo((COMPONENT_STATS *)psConstStats);
CONPRINTF(ConsoleString,(ConsoleString," cPnts %d imd %p\n",
constructorPoints(psConstStats, psDroid->player),
@ -275,10 +275,10 @@ void printDroidInfo(const DROID* psDroid)
}
break;
case COMP_REPAIRUNIT:
if (psDroid->asBits[i].nStat > 0)
if (psDroid->asBits[i] > 0)
{
CONPRINTF(ConsoleString,(ConsoleString,"Repair: "));
psRepairStats = asRepairStats + psDroid->asBits[i].nStat;
psRepairStats = asRepairStats + psDroid->asBits[i];
printComponentInfo((COMPONENT_STATS *)psRepairStats);
CONPRINTF(ConsoleString,(ConsoleString," repPnts %d loc %d imd %p\n",
repairPoints(psRepairStats, psDroid->player),

8
src/order.cpp
View File

@ -1338,7 +1338,7 @@ void orderDroidBase(DROID *psDroid, DROID_ORDER_DATA *psOrder)
{
UDWORD iFactoryDistSq;
STRUCTURE *psStruct, *psRepairFac, *psFactory;
const PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
const PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
const Vector3i rPos(psOrder->pos, 0);
syncDebugDroid(psDroid, '-');
@ -2627,9 +2627,9 @@ DroidOrder chooseOrderObj(DROID *psDroid, BASE_OBJECT *psObj, bool altOrder)
&& !aiCheckAlliances(psObj->player , psDroid->player) )
{
//check for standard sensor or VTOL intercept sensor
if (asSensorStats[psDroid->asBits[COMP_SENSOR].nStat].type == STANDARD_SENSOR
|| asSensorStats[psDroid->asBits[COMP_SENSOR].nStat].type == VTOL_INTERCEPT_SENSOR
|| asSensorStats[psDroid->asBits[COMP_SENSOR].nStat].type == SUPER_SENSOR)
if (asSensorStats[psDroid->asBits[COMP_SENSOR]].type == STANDARD_SENSOR
|| asSensorStats[psDroid->asBits[COMP_SENSOR]].type == VTOL_INTERCEPT_SENSOR
|| asSensorStats[psDroid->asBits[COMP_SENSOR]].type == SUPER_SENSOR)
{
// a sensor droid observing an object
order = DroidOrder(DORDER_OBSERVE, psObj);

24
src/projectile.cpp
View File

@ -1178,7 +1178,7 @@ static void proj_ImpactFunc( PROJECTILE *psObj )
switch (psCurr->type)
{
case OBJ_DROID:
bTargetInAir = asPropulsionTypes[asPropulsionStats[((DROID *)psCurr)->asBits[COMP_PROPULSION].nStat].propulsionType].travel == AIR && ((DROID *)psCurr)->sMove.Status != MOVEINACTIVE;
bTargetInAir = asPropulsionTypes[asPropulsionStats[((DROID *)psCurr)->asBits[COMP_PROPULSION]].propulsionType].travel == AIR && ((DROID *)psCurr)->sMove.Status != MOVEINACTIVE;
useSphere = true;
break;
case OBJ_STRUCTURE:
@ -1464,8 +1464,8 @@ UDWORD calcDamage(UDWORD baseDamage, WEAPON_EFFECT weaponEffect, BASE_OBJECT *ps
}
else if (psTarget->type == OBJ_DROID)
{
const int propulsion = (asPropulsionStats + ((DROID *)psTarget)->asBits[COMP_PROPULSION].nStat)->propulsionType;
const int body = (asBodyStats + ((DROID *)psTarget)->asBits[COMP_BODY].nStat)->size;
const int propulsion = (asPropulsionStats + ((DROID *)psTarget)->asBits[COMP_PROPULSION])->propulsionType;
const int body = (asBodyStats + ((DROID *)psTarget)->asBits[COMP_BODY])->size;
damage += baseDamage * (asWeaponModifier[weaponEffect][propulsion] - 100);
damage += baseDamage * (asWeaponModifierBody[weaponEffect][body] - 100);
}
@ -1614,7 +1614,7 @@ int establishTargetHeight(BASE_OBJECT const *psTarget)
case OBJ_DROID:
{
DROID const *psDroid = (DROID const *)psTarget;
unsigned int height = asBodyStats[psDroid->asBits[COMP_BODY].nStat].pIMD->max.y - asBodyStats[psDroid->asBits[COMP_BODY].nStat].pIMD->min.y;
unsigned int height = asBodyStats[psDroid->asBits[COMP_BODY]].pIMD->max.y - asBodyStats[psDroid->asBits[COMP_BODY]].pIMD->min.y;
unsigned int utilityHeight = 0, yMax = 0, yMin = 0; // Temporaries for addition of utility's height to total height
// VTOL's don't have pIMD either it seems...
@ -1638,23 +1638,23 @@ int establishTargetHeight(BASE_OBJECT const *psTarget)
break;
case DROID_SENSOR:
yMax = (asSensorStats[psDroid->asBits[COMP_SENSOR].nStat]).pIMD->max.y;
yMin = (asSensorStats[psDroid->asBits[COMP_SENSOR].nStat]).pIMD->min.y;
yMax = (asSensorStats[psDroid->asBits[COMP_SENSOR]]).pIMD->max.y;
yMin = (asSensorStats[psDroid->asBits[COMP_SENSOR]]).pIMD->min.y;
break;
case DROID_ECM:
yMax = (asECMStats[psDroid->asBits[COMP_ECM].nStat]).pIMD->max.y;
yMin = (asECMStats[psDroid->asBits[COMP_ECM].nStat]).pIMD->min.y;
yMax = (asECMStats[psDroid->asBits[COMP_ECM]]).pIMD->max.y;
yMin = (asECMStats[psDroid->asBits[COMP_ECM]]).pIMD->min.y;
break;
case DROID_CONSTRUCT:
yMax = (asConstructStats[psDroid->asBits[COMP_CONSTRUCT].nStat]).pIMD->max.y;
yMin = (asConstructStats[psDroid->asBits[COMP_CONSTRUCT].nStat]).pIMD->min.y;
yMax = (asConstructStats[psDroid->asBits[COMP_CONSTRUCT]]).pIMD->max.y;
yMin = (asConstructStats[psDroid->asBits[COMP_CONSTRUCT]]).pIMD->min.y;
break;
case DROID_REPAIR:
yMax = (asRepairStats[psDroid->asBits[COMP_REPAIRUNIT].nStat]).pIMD->max.y;
yMin = (asRepairStats[psDroid->asBits[COMP_REPAIRUNIT].nStat]).pIMD->min.y;
yMax = (asRepairStats[psDroid->asBits[COMP_REPAIRUNIT]]).pIMD->max.y;
yMin = (asRepairStats[psDroid->asBits[COMP_REPAIRUNIT]]).pIMD->min.y;
break;
case DROID_PERSON:

8
src/qtscriptfuncs.cpp
View File

@ -500,7 +500,7 @@ QScriptValue convDroid(DROID *psDroid, QScriptEngine *engine)
bool ga = false;
bool indirect = false;
int range = -1;
const BODY_STATS *psBodyStats = &asBodyStats[psDroid->asBits[COMP_BODY].nStat];
const BODY_STATS *psBodyStats = &asBodyStats[psDroid->asBits[COMP_BODY]];
for (int i = 0; i < psDroid->numWeaps; i++)
{
@ -556,8 +556,8 @@ QScriptValue convDroid(DROID *psDroid, QScriptEngine *engine)
value.setProperty("droidType", (int)type, QScriptValue::ReadOnly);
value.setProperty("experience", (double)psDroid->experience / 65536.0, QScriptValue::ReadOnly);
value.setProperty("health", 100.0 / (double)psDroid->originalBody * (double)psDroid->body, QScriptValue::ReadOnly);
value.setProperty("body", asBodyStats[psDroid->asBits[COMP_BODY].nStat].pName, QScriptValue::ReadOnly);
value.setProperty("propulsion", asPropulsionStats[psDroid->asBits[COMP_PROPULSION].nStat].pName, QScriptValue::ReadOnly);
value.setProperty("body", asBodyStats[psDroid->asBits[COMP_BODY]].pName, QScriptValue::ReadOnly);
value.setProperty("propulsion", asPropulsionStats[psDroid->asBits[COMP_PROPULSION]].pName, QScriptValue::ReadOnly);
value.setProperty("armed", 0.0, QScriptValue::ReadOnly); // deprecated!
QScriptValue weaponlist = engine->newArray(psDroid->numWeaps);
for (int j = 0; j < psDroid->numWeaps; j++)
@ -2245,7 +2245,7 @@ static QScriptValue js_droidCanReach(QScriptContext *context, QScriptEngine *)
int y = context->argument(2).toInt32();
DROID *psDroid = IdToDroid(id, player);
SCRIPT_ASSERT(context, psDroid, "Droid id %d not found belonging to player %d", id, player);
const PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
const PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
return QScriptValue(fpathCheck(psDroid->pos, Vector3i(world_coord(x), world_coord(y), 0), psPropStats->propulsionType));
}

4
src/research.cpp
View File

@ -1421,9 +1421,9 @@ static void switchComponent(DROID *psDroid, UDWORD oldType, UDWORD oldCompInc,
case COMP_ECM:
case COMP_SENSOR:
case COMP_CONSTRUCT:
if (psDroid->asBits[oldType].nStat == oldCompInc)
if (psDroid->asBits[oldType] == oldCompInc)
{
psDroid->asBits[oldType].nStat = (UBYTE)newCompInc;
psDroid->asBits[oldType] = (UBYTE)newCompInc;
}
break;
case COMP_WEAPON:

6
src/scriptai.cpp
View File

@ -1039,7 +1039,7 @@ static UDWORD scrDroidTargetMask(DROID *psDroid)
}
// get the body type
psBStats = asBodyStats + psDroid->asBits[COMP_BODY].nStat;
psBStats = asBodyStats + psDroid->asBits[COMP_BODY];
switch (psBStats->size)
{
case SIZE_LIGHT:
@ -1061,7 +1061,7 @@ static UDWORD scrDroidTargetMask(DROID *psDroid)
}
// get the propulsion type
psPStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
psPStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
switch (psPStats->propulsionType)
{
case PROPULSION_TYPE_WHEELED:
@ -2129,7 +2129,7 @@ bool scrDroidCanReach(void)
}
if (psDroid)
{
const PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
const PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
const Vector3i rPos(x, y, 0);
scrFunctionResult.v.bval = fpathCheck(psDroid->pos, rPos, psPropStats->propulsionType);

38
src/scriptfuncs.cpp
View File

@ -2441,37 +2441,37 @@ bool scrGetDroid(void)
switch ((unsigned)sVal.type) // Unsigned cast to suppress compiler warnings due to enum abuse.
{
case ST_BODY:
if (psDroid->asBits[COMP_BODY].nStat == (UDWORD)sVal.v.ival)
if (psDroid->asBits[COMP_BODY] == (UDWORD)sVal.v.ival)
{
found = true;
}
break;
case ST_PROPULSION:
if (psDroid->asBits[COMP_PROPULSION].nStat == (UDWORD)sVal.v.ival)
if (psDroid->asBits[COMP_PROPULSION] == (UDWORD)sVal.v.ival)
{
found = true;
}
break;
case ST_ECM:
if (psDroid->asBits[COMP_ECM].nStat == (UDWORD)sVal.v.ival)
if (psDroid->asBits[COMP_ECM] == (UDWORD)sVal.v.ival)
{
found = true;
}
break;
case ST_SENSOR:
if (psDroid->asBits[COMP_SENSOR].nStat == (UDWORD)sVal.v.ival)
if (psDroid->asBits[COMP_SENSOR] == (UDWORD)sVal.v.ival)
{
found = true;
}
break;
case ST_CONSTRUCT:
if (psDroid->asBits[COMP_CONSTRUCT].nStat == (UDWORD)sVal.v.ival)
if (psDroid->asBits[COMP_CONSTRUCT] == (UDWORD)sVal.v.ival)
{
found = true;
}
break;
case ST_REPAIR:
if (psDroid->asBits[COMP_REPAIRUNIT].nStat == (UDWORD)sVal.v.ival)
if (psDroid->asBits[COMP_REPAIRUNIT] == (UDWORD)sVal.v.ival)
{
found = true;
}
@ -4656,7 +4656,7 @@ bool scrThreatInArea(void)
/* Have we found a droid in this area */
if (dX >= x1 && dX <= x2 && dY >= y1 && dY <= y2)
{
switch ((asBodyStats + psDroid->asBits[COMP_BODY].nStat)->size)
switch ((asBodyStats + psDroid->asBits[COMP_BODY])->size)
{
case SIZE_LIGHT:
totalThreat += ldThreat;
@ -6428,37 +6428,37 @@ bool scrNumDroidsByComponent(void)
switch ((unsigned)sVal.type) // Unsigned cast to suppress compiler warnings due to enum abuse.
{
case ST_BODY:
if (psDroid->asBits[COMP_BODY].nStat == comp)
if (psDroid->asBits[COMP_BODY] == comp)
{
numFound++;
}
break;
case ST_PROPULSION:
if (psDroid->asBits[COMP_PROPULSION].nStat == comp)
if (psDroid->asBits[COMP_PROPULSION] == comp)
{
numFound++;
}
break;
case ST_ECM:
if (psDroid->asBits[COMP_ECM].nStat == comp)
if (psDroid->asBits[COMP_ECM] == comp)
{
numFound++;
}
break;
case ST_SENSOR:
if (psDroid->asBits[COMP_SENSOR].nStat == comp)
if (psDroid->asBits[COMP_SENSOR] == comp)
{
numFound++;
}
break;
case ST_CONSTRUCT:
if (psDroid->asBits[COMP_CONSTRUCT].nStat == comp)
if (psDroid->asBits[COMP_CONSTRUCT] == comp)
{
numFound++;
}
break;
case ST_REPAIR:
if (psDroid->asBits[COMP_REPAIRUNIT].nStat == comp)
if (psDroid->asBits[COMP_REPAIRUNIT] == comp)
{
numFound++;
}
@ -6471,7 +6471,7 @@ bool scrNumDroidsByComponent(void)
}
break;
case ST_BRAIN:
if (psDroid->asBits[COMP_BRAIN].nStat == comp)
if (psDroid->asBits[COMP_BRAIN] == comp)
{
numFound++;
}
@ -6772,7 +6772,7 @@ bool ThreatInRange(SDWORD player, SDWORD range, SDWORD rangeX, SDWORD rangeY, bo
}
//if VTOLs are excluded, skip them
if (!bVTOLs && ((asPropulsionStats[psDroid->asBits[COMP_PROPULSION].nStat].propulsionType == PROPULSION_TYPE_LIFT) || (psDroid->droidType == DROID_TRANSPORTER || psDroid->droidType == DROID_SUPERTRANSPORTER)))
if (!bVTOLs && ((asPropulsionStats[psDroid->asBits[COMP_PROPULSION]].propulsionType == PROPULSION_TYPE_LIFT) || (psDroid->droidType == DROID_TRANSPORTER || psDroid->droidType == DROID_SUPERTRANSPORTER)))
{
continue;
}
@ -7356,7 +7356,7 @@ static UDWORD costOrAmountInRange(SDWORD player, SDWORD lookingPlayer, SDWORD ra
}
//if VTOLs are excluded, skip them
if (!bVTOLs && ((asPropulsionStats[psDroid->asBits[COMP_PROPULSION].nStat].propulsionType == PROPULSION_TYPE_LIFT) || (psDroid->droidType == DROID_TRANSPORTER || psDroid->droidType == DROID_SUPERTRANSPORTER)))
if (!bVTOLs && ((asPropulsionStats[psDroid->asBits[COMP_PROPULSION]].propulsionType == PROPULSION_TYPE_LIFT) || (psDroid->droidType == DROID_TRANSPORTER || psDroid->droidType == DROID_SUPERTRANSPORTER)))
{
continue;
}
@ -7753,7 +7753,7 @@ UDWORD numEnemyObjInRange(SDWORD player, SDWORD range, SDWORD rangeX, SDWORD ran
{
//if VTOLs are excluded, skip them
if (!bVTOLs
&& (asPropulsionStats[psDroid->asBits[COMP_PROPULSION].nStat].propulsionType == PROPULSION_TYPE_LIFT
&& (asPropulsionStats[psDroid->asBits[COMP_PROPULSION]].propulsionType == PROPULSION_TYPE_LIFT
|| psDroid->droidType == DROID_TRANSPORTER || psDroid->droidType == DROID_SUPERTRANSPORTER))
{
continue;
@ -8283,7 +8283,7 @@ bool scrGetClosestEnemy(void)
}
//if VTOLs are excluded, skip them
if (!bVTOLs && ((asPropulsionStats[psDroid->asBits[COMP_PROPULSION].nStat].propulsionType == PROPULSION_TYPE_LIFT) || (psDroid->droidType == DROID_TRANSPORTER || psDroid->droidType == DROID_SUPERTRANSPORTER)))
if (!bVTOLs && ((asPropulsionStats[psDroid->asBits[COMP_PROPULSION]].propulsionType == PROPULSION_TYPE_LIFT) || (psDroid->droidType == DROID_TRANSPORTER || psDroid->droidType == DROID_SUPERTRANSPORTER)))
{
continue;
}
@ -8656,7 +8656,7 @@ bool scrGetClosestEnemyDroidByType(void)
for (psDroid = apsDroidLists[i]; psDroid; psDroid = psDroid->psNext)
{
//if VTOLs are excluded, skip them (don't check for transporter this time)
if (!bVTOLs && (asPropulsionStats[psDroid->asBits[COMP_PROPULSION].nStat].propulsionType == PROPULSION_TYPE_LIFT))
if (!bVTOLs && (asPropulsionStats[psDroid->asBits[COMP_PROPULSION]].propulsionType == PROPULSION_TYPE_LIFT))
{
continue;
}

4
src/scriptobj.cpp
View File

@ -220,7 +220,7 @@ bool scrBaseObjGet(UDWORD index)
return false;
}
type = (INTERP_TYPE)ST_BODY;
scrFunctionResult.v.ival = (SDWORD)((DROID *)psObj)->asBits[COMP_BODY].nStat;
scrFunctionResult.v.ival = (SDWORD)((DROID *)psObj)->asBits[COMP_BODY];
break;
case OBJID_PROPULSION:
if (psObj->type != OBJ_DROID)
@ -229,7 +229,7 @@ bool scrBaseObjGet(UDWORD index)
return false;
}
type = (INTERP_TYPE)ST_PROPULSION;
scrFunctionResult.v.ival = (SDWORD)((DROID *)psObj)->asBits[COMP_PROPULSION].nStat;
scrFunctionResult.v.ival = (SDWORD)((DROID *)psObj)->asBits[COMP_PROPULSION];
break;
case OBJID_WEAPON: //TODO: only returns first weapon now
type = (INTERP_TYPE)ST_WEAPON;

6
src/selection.cpp
View File

@ -86,7 +86,7 @@ static unsigned int selSelectAllSameProp(unsigned int player, PROPULSION_TYPE pr
if (!bOnScreen || droidOnScreen(psDroid, 0))
{
/* Get the propulsion type */
PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
ASSERT(psPropStats != NULL, "invalid propulsion stats pointer");
/* Same as that asked for - don't want Transporters*/
if (psPropStats->propulsionType == propType && (psDroid->droidType != DROID_TRANSPORTER && psDroid->droidType != DROID_SUPERTRANSPORTER))
@ -173,7 +173,7 @@ static unsigned int selSelectAllCombatLand(unsigned int player, bool bOnScreen)
if (!bOnScreen || droidOnScreen(psDroid, 0))
{
/* Get the propulsion type */
PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
ASSERT(psPropStats != NULL, "invalid propulsion stats pointer");
if (psPropStats->propulsionType == PROPULSION_TYPE_WHEELED ||
psPropStats->propulsionType == PROPULSION_TYPE_HALF_TRACKED ||
@ -208,7 +208,7 @@ static unsigned int selSelectAllCombatCyborg(unsigned int player, bool bOnScreen
if (!bOnScreen || droidOnScreen(psDroid, 0))
{
/* Get the propulsion type */
PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
PROPULSION_STATS *psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
ASSERT(psPropStats != NULL, "invalid propulsion stats pointer");
/* Check if cyborg */
if (psPropStats->propulsionType == PROPULSION_TYPE_LEGGED)

2
src/stats.cpp
View File

@ -2689,7 +2689,7 @@ SENSOR_STATS *objActiveRadar(const BASE_OBJECT *psObj)
{
return NULL;
}
compIndex = ((DROID *)psObj)->asBits[COMP_SENSOR].nStat;
compIndex = ((DROID *)psObj)->asBits[COMP_SENSOR];
ASSERT_OR_RETURN(NULL, compIndex < numSensorStats, "Invalid range referenced for numSensorStats, %d > %d", compIndex, numSensorStats);
psStats = asSensorStats + compIndex;
break;

2
src/transporter.cpp
View File

@ -1080,7 +1080,7 @@ UDWORD transporterSpaceRequired(DROID const *psDroid)
{
// all droids are the same weight for campaign games.
// TODO - move this into a droid flag
return bMultiPlayer ? (asBodyStats + psDroid->asBits[COMP_BODY].nStat)->size : 1;
return bMultiPlayer ? (asBodyStats + psDroid->asBits[COMP_BODY])->size : 1;
}
/*sets which list of droids to use for the transporter interface*/

4
src/visibility.h
View File

@ -78,7 +78,7 @@ static inline int objSensorRange(const BASE_OBJECT* psObj)
{
if (psObj->type == OBJ_DROID)
{
return asSensorStats[((DROID*)psObj)->asBits[COMP_SENSOR].nStat].upgrade[psObj->player].range;
return asSensorStats[((DROID*)psObj)->asBits[COMP_SENSOR]].upgrade[psObj->player].range;
}
else if (psObj->type == OBJ_STRUCTURE)
{
@ -91,7 +91,7 @@ static inline int objJammerPower(const BASE_OBJECT* psObj)
{
if (psObj->type == OBJ_DROID)
{
return asECMStats[((DROID*)psObj)->asBits[COMP_ECM].nStat].upgrade[psObj->player].range;
return asECMStats[((DROID*)psObj)->asBits[COMP_ECM]].upgrade[psObj->player].range;
}
else if (psObj->type == OBJ_STRUCTURE)
{

6
src/warcam.cpp
View File

@ -621,7 +621,7 @@ static void updateCameraAcceleration(UBYTE update)
const int angle = 90 - abs((player.r.x / 182) % 90);
const DROID *psDroid = (DROID *)trackingCamera.target;
const PROPULSION_STATS *psPropStats = &asPropulsionStats[psDroid->asBits[COMP_PROPULSION].nStat];
const PROPULSION_STATS *psPropStats = &asPropulsionStats[psDroid->asBits[COMP_PROPULSION]];
if (psPropStats->propulsionType == PROPULSION_TYPE_LIFT)
{
@ -737,7 +737,7 @@ static void updateCameraRotationAcceleration(UBYTE update)
if (trackingCamera.target->type == OBJ_DROID)
{
DROID *psDroid = (DROID *)trackingCamera.target;
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
if (psPropStats->propulsionType == PROPULSION_TYPE_LIFT)
{
int droidHeight, difHeight, droidMapHeight;
@ -908,7 +908,7 @@ static bool camTrackCamera()
if (trackingCamera.target->type == OBJ_DROID)
{
psDroid = (DROID *)trackingCamera.target;
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION].nStat;
psPropStats = asPropulsionStats + psDroid->asBits[COMP_PROPULSION];
if (psPropStats->propulsionType == PROPULSION_TYPE_LIFT)
{
bFlying = true;