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

Major (but partly) cleanup of actionUpdateDroid: 

* Move variables into a more local scope
  - I don't think I screwed up start-at-block-declaration rules for MSVC, but given the size of these changes I can't be sure.
 * Remove a large amount of low level bit manipulation and replace it with arrays of boolean values instead
  - Yes bit shift and bitwise and where used; bitwise or was replaced with addition though
 * Don't use *WORD/*BYTE when we don't need the size guarantee (and the size guarantee is in fact an optimisation prone to introduce bugs)
 * "Concatenate" nested if statements into a single condition in a single if-statement
  - Less nested code to convey exactly the same meaning
 * Remove unused variable moveAction
  - It was only ever written to, but never read from

We don't need the size guarantee for WEAPON::nStat, so substitute "unsigned int" for "UDWORD"

git-svn-id: svn+ssh://svn.gna.org/svn/warzone/trunk@6634 4a71c877-e1ca-e34f-864e-861f7616d084
master
Giel van Schijndel 2009-02-11 22:00:47 +00:00
parent 29bb57948c
commit 0711b342ed
2 changed files with 153 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

291
src/action.c
View File

@ -995,28 +995,17 @@ static void actionHomeBasePos(SDWORD player, SDWORD *px, SDWORD *py)
// Update the action state for a droid
void actionUpdateDroid(DROID *psDroid)
{
UDWORD droidX,droidY;
UDWORD tlx,tly;
STRUCTURE *psStruct;
STRUCTURE_STATS *psStructStats;
BASE_OBJECT *psTarget;
WEAPON_STATS *psWeapStats;
SDWORD targetDir, dirDiff, pbx,pby;
SDWORD xdiff,ydiff, rangeSq;
SECONDARY_STATE state;
PROPULSION_STATS *psPropStats;
BOOL bChaseBloke;
FEATURE *psNextWreck;
BOOL (*actionUpdateFunc)(DROID *psDroid) = NULL;
SDWORD moveAction;
BOOL bDoHelpBuild;
MAPTILE *psTile;
UBYTE i = 0;
signed int i;
unsigned int j;
//this is a bit field
UBYTE num_weapons = 0;
bool nonNullWeapon[DROID_MAXWEAPS] = { false };
BASE_OBJECT *psTargets[DROID_MAXWEAPS];
UBYTE j,iVisible = 1;
BOOL bHasTarget;
bool hasVisibleTarget = false;
bool targetVisibile[DROID_MAXWEAPS] = { false };
bool bHasTarget;
CHECK_DROID(psDroid);
@ -1064,32 +1053,21 @@ void actionUpdateDroid(DROID *psDroid)
}
}
if (psDroid->numWeaps > 1)
{
for(i = 0;i < psDroid->numWeaps;i++)
for (i = 0; i < psDroid->numWeaps; ++i)
{
if (psDroid->asWeaps[i].nStat > 0)
{
num_weapons += (1 << (i+1));
nonNullWeapon[i] = true;
}
}
}
else
{
num_weapons = 2;
}
// HACK: Apparently we can't deal with a droid that only has NULL weapons ?
// FIXME: Find out whether this is really necessary
if (psDroid->numWeaps <= 1)
nonNullWeapon[0] = true;
psTarget = psDroid->psTarget;
if (psDroid->asWeaps[0].nStat > 0)
{
psWeapStats = asWeaponStats + psDroid->asWeaps[0].nStat;
}
else
{
psWeapStats = NULL;
}
switch (psDroid->action)
{
case DACTION_NONE:
@ -1127,6 +1105,8 @@ void actionUpdateDroid(DROID *psDroid)
{
if ((SDWORD)(mission.ETA - (gameTime - missionGetReinforcementTime())) <= 0)
{
UDWORD droidX, droidY;
if (!droidRemove(psDroid, mission.apsDroidLists))
{
ASSERT( false, "actionUpdate: Unable to remove transporter from mission list" );
@ -1175,19 +1155,21 @@ void actionUpdateDroid(DROID *psDroid)
{
for(i = 0;i < psDroid->numWeaps;i++)
{
if ( (num_weapons & (1 << (i+1))) )
if (nonNullWeapon[i])
{
BASE_OBJECT *psTemp = NULL;
//Watermelon:I moved psWeapStats flag update there
psWeapStats = asWeaponStats + psDroid->asWeaps[i].nStat;
if (!isVtolDroid(psDroid) &&
psDroid->asWeaps[i].nStat > 0 &&
psWeapStats->rotate &&
psWeapStats->fireOnMove != FOM_NO &&
CAN_UPDATE_NAYBORS(psDroid) &&
(aiBestNearestTarget(psDroid, &psTemp, i) >= 0))
WEAPON_STATS* const psWeapStats = &asWeaponStats[psDroid->asWeaps[i].nStat];
if (!isVtolDroid(psDroid)
&& psDroid->asWeaps[i].nStat > 0
&& psWeapStats->rotate
&& psWeapStats->fireOnMove != FOM_NO
&& CAN_UPDATE_NAYBORS(psDroid)
&& aiBestNearestTarget(psDroid, &psTemp, i) >= 0)
{
SECONDARY_STATE state;
if (secondaryGetState(psDroid, DSO_ATTACK_LEVEL, &state))
{
if (state == DSS_ALEV_ALWAYS)
@ -1226,7 +1208,7 @@ void actionUpdateDroid(DROID *psDroid)
bHasTarget = false;
//loop through weapons and look for target for each weapon
for (i = 0;i < psDroid->numWeaps;i++)
for (i = 0; i < psDroid->numWeaps; ++i)
{
if (psDroid->psActionTarget[i] == NULL)
{
@ -1239,10 +1221,11 @@ void actionUpdateDroid(DROID *psDroid)
}
}
if (psDroid->psActionTarget[i] &&
visibleObject((BASE_OBJECT*)psDroid, psDroid->psActionTarget[i], false))
if (psDroid->psActionTarget[i]
&& visibleObject((BASE_OBJECT*)psDroid, psDroid->psActionTarget[i], false))
{
iVisible += (1 << (i+1));
hasVisibleTarget = true;
targetVisibile[i] = true;
}
}
@ -1252,6 +1235,8 @@ void actionUpdateDroid(DROID *psDroid)
if (psDroid->psActionTarget[j] != NULL &&
validTarget((BASE_OBJECT *)psDroid, psDroid->psActionTarget[j], j))
{
SECONDARY_STATE state;
// firing on something while moving
if (DROID_STOPPED(psDroid))
{
@ -1259,9 +1244,10 @@ void actionUpdateDroid(DROID *psDroid)
psDroid->action = DACTION_NONE;
break;
}
else if ((psDroid->psActionTarget[j] == NULL) ||
!validTarget((BASE_OBJECT *)psDroid, psDroid->psActionTarget[j], j) ||
(secondaryGetState(psDroid, DSO_ATTACK_LEVEL, &state) && (state != DSS_ALEV_ALWAYS)))
else if (psDroid->psActionTarget[j] == NULL
|| !validTarget((BASE_OBJECT *)psDroid, psDroid->psActionTarget[j], j)
|| (secondaryGetState(psDroid, DSO_ATTACK_LEVEL, &state)
&& state != DSS_ALEV_ALWAYS))
{
if (j == (psDroid->numWeaps - 1) && !bHasTarget)
{
@ -1287,23 +1273,23 @@ void actionUpdateDroid(DROID *psDroid)
}
else
{
if (iVisible == 1 && !bHasTarget && j == (psDroid->numWeaps - 1))
if (!hasVisibleTarget
&& !bHasTarget
&& j == (psDroid->numWeaps - 1))
{
// lost the target
psDroid->action = DACTION_MOVE;
for (i = 0;i < psDroid->numWeaps;i++)
for (i = 0; i < psDroid->numWeaps;i++)
{
setDroidActionTarget(psDroid, NULL, i);
}
}
if (iVisible & (1 << (j+1)))
if (targetVisibile[j])
{
bHasTarget = true;
//Watermelon:I moved psWeapStats flag update there
psWeapStats = asWeaponStats + psDroid->asWeaps[j].nStat;
//Watermelon:to fix a AA-weapon attack ground unit exploit
if ( (num_weapons & (1 << (j+1))) )
if (nonNullWeapon[j])
{
BASE_OBJECT* psActionTarget;
@ -1316,20 +1302,16 @@ void actionUpdateDroid(DROID *psDroid)
psActionTarget = psDroid->psActionTarget[0];
}
if (validTarget((BASE_OBJECT *)psDroid, psActionTarget, j))
{
if (actionTargetTurret((BASE_OBJECT*)psDroid, psActionTarget, &psDroid->asWeaps[j]))
if (validTarget((BASE_OBJECT *)psDroid, psActionTarget, j)
&& actionTargetTurret((BASE_OBJECT*)psDroid, psActionTarget, &psDroid->asWeaps[j]))
{
// In range - fire !!!
combFire(&psDroid->asWeaps[j], (BASE_OBJECT *)psDroid,
psActionTarget, j);
}
}
else
{
if ((iVisible & 2) && validTarget((BASE_OBJECT *)psDroid, psDroid->psActionTarget[0], j))
{
if (actionTargetTurret((BASE_OBJECT*)psDroid, psDroid->psActionTarget[0], &psDroid->asWeaps[j]))
else if (targetVisibile[0]
&& validTarget((BASE_OBJECT *)psDroid, psDroid->psActionTarget[0], j)
&& actionTargetTurret((BASE_OBJECT*)psDroid, psDroid->psActionTarget[0], &psDroid->asWeaps[j]))
{
// In range - fire !!!
combFire(&psDroid->asWeaps[j], (BASE_OBJECT *)psDroid,
@ -1340,8 +1322,6 @@ void actionUpdateDroid(DROID *psDroid)
}
}
}
}
}
//check its a VTOL unit since adding Transporter's into multiPlayer
/* check vtol attack runs */
@ -1396,26 +1376,26 @@ void actionUpdateDroid(DROID *psDroid)
psActionTarget = psDroid->psActionTarget[0];
}
if ( (num_weapons & (1 << (i+1))) &&
actionVisibleTarget(psDroid, psActionTarget, i) &&
actionInRange(psDroid, psActionTarget, i))
if (nonNullWeapon[i]
&& actionVisibleTarget(psDroid, psActionTarget, i)
&& actionInRange(psDroid, psActionTarget, i))
{
bHasTarget = true;
psWeapStats = asWeaponStats + psDroid->asWeaps[i].nStat;
WEAPON_STATS* const psWeapStats = &asWeaponStats[psDroid->asWeaps[i].nStat];
if (validTarget((BASE_OBJECT *)psDroid, psActionTarget, i))
{
int dirDiff = 0;
if (!psWeapStats->rotate)
{
// no rotating turret - need to check aligned with target
targetDir = (SDWORD)calcDirection(
psDroid->pos.x,psDroid->pos.y,
psActionTarget->pos.x, psActionTarget->pos.y);
dirDiff = labs(targetDir - (SDWORD)psDroid->direction);
}
else
{
dirDiff = 0;
const int targetDir = calcDirection(psDroid->pos.x,
psDroid->pos.y,
psActionTarget->pos.x,
psActionTarget->pos.y);
dirDiff = labs(targetDir - psDroid->direction);
}
if (dirDiff > FIXED_TURRET_DIR)
{
if (psDroid->sMove.Status != MOVESHUFFLE)
@ -1436,10 +1416,12 @@ void actionUpdateDroid(DROID *psDroid)
if (!bHasTarget)
{
SECONDARY_STATE state;
if (((psDroid->order == DORDER_ATTACKTARGET
|| psDroid->order == DORDER_FIRESUPPORT)
&& secondaryGetState(psDroid, DSO_HALTTYPE, &state)
&& (state == DSS_HALT_HOLD))
&& state == DSS_HALT_HOLD)
|| (!isVtolDroid(psDroid)
&& (psTarget = orderStateObj(psDroid, DORDER_FIRESUPPORT))
&& psTarget->type == OBJ_STRUCTURE))
@ -1456,6 +1438,9 @@ void actionUpdateDroid(DROID *psDroid)
break;
case DACTION_VTOLATTACK:
{
WEAPON_STATS* psWeapStats = NULL;
//Watermelon:uses vtResult
if (psDroid->psActionTarget[0] != NULL &&
validTarget((BASE_OBJECT *)psDroid, psDroid->psActionTarget[0], 0))
@ -1473,11 +1458,11 @@ void actionUpdateDroid(DROID *psDroid)
for(i = 0;i <psDroid->numWeaps;i++)
{
if ( (num_weapons & (1 << (i+1))) &&
validTarget((BASE_OBJECT *)psDroid, psDroid->psActionTarget[0], i) )
if (nonNullWeapon[i]
&& validTarget((BASE_OBJECT *)psDroid, psDroid->psActionTarget[0], i))
{
//Watermelon:I moved psWeapStats flag update there
psWeapStats = asWeaponStats + psDroid->asWeaps[i].nStat;
psWeapStats = &asWeaponStats[psDroid->asWeaps[i].nStat];
if (actionVisibleTarget(psDroid, psDroid->psActionTarget[0], i))
{
if ( actionInRange(psDroid, psDroid->psActionTarget[0], i) )
@ -1521,25 +1506,25 @@ void actionUpdateDroid(DROID *psDroid)
else
{
// if the vtol is close to the target, go around again
xdiff = (SDWORD)psDroid->pos.x - (SDWORD)psDroid->psActionTarget[0]->pos.x;
ydiff = (SDWORD)psDroid->pos.y - (SDWORD)psDroid->psActionTarget[0]->pos.y;
rangeSq = xdiff*xdiff + ydiff*ydiff;
const int xdiff = (SDWORD)psDroid->pos.x - (SDWORD)psDroid->psActionTarget[0]->pos.x;
const int ydiff = (SDWORD)psDroid->pos.y - (SDWORD)psDroid->psActionTarget[0]->pos.y;
const int rangeSq = xdiff * xdiff + ydiff * ydiff;
if (rangeSq < (VTOL_ATTACK_TARDIST*VTOL_ATTACK_TARDIST))
{
// don't do another attack run if already moving away from the target
xdiff = (SDWORD)psDroid->sMove.DestinationX - (SDWORD)psDroid->psActionTarget[0]->pos.x;
ydiff = (SDWORD)psDroid->sMove.DestinationY - (SDWORD)psDroid->psActionTarget[0]->pos.y;
const int xdiff = (SDWORD)psDroid->sMove.DestinationX - (SDWORD)psDroid->psActionTarget[0]->pos.x;
const int ydiff = (SDWORD)psDroid->sMove.DestinationY - (SDWORD)psDroid->psActionTarget[0]->pos.y;
if ((xdiff*xdiff + ydiff*ydiff) < (VTOL_ATTACK_TARDIST*VTOL_ATTACK_TARDIST))
{
actionAddVtolAttackRun( psDroid );
}
}
// if the vtol is far enough away head for the target again
else if (rangeSq > (SDWORD)(psWeapStats->longRange*psWeapStats->longRange))
else if (rangeSq > (SDWORD)(psWeapStats->longRange * psWeapStats->longRange))
{
// don't do another attack run if already heading for the target
xdiff = (SDWORD)psDroid->sMove.DestinationX - (SDWORD)psDroid->psActionTarget[0]->pos.x;
ydiff = (SDWORD)psDroid->sMove.DestinationY - (SDWORD)psDroid->psActionTarget[0]->pos.y;
const int xdiff = (SDWORD)psDroid->sMove.DestinationX - (SDWORD)psDroid->psActionTarget[0]->pos.x;
const int ydiff = (SDWORD)psDroid->sMove.DestinationY - (SDWORD)psDroid->psActionTarget[0]->pos.y;
if ((xdiff*xdiff + ydiff*ydiff) > (VTOL_ATTACK_TARDIST*VTOL_ATTACK_TARDIST))
{
moveDroidToDirect(psDroid, psDroid->psActionTarget[0]->pos.x,psDroid->psActionTarget[0]->pos.y);
@ -1547,7 +1532,7 @@ void actionUpdateDroid(DROID *psDroid)
}
}
break;
}
case DACTION_MOVETOATTACK:
// don't wan't formations for this one
if (psDroid->sMove.psFormation)
@ -1582,28 +1567,29 @@ void actionUpdateDroid(DROID *psDroid)
{
for(i = 0;i < psDroid->numWeaps;i++)
{
if( (num_weapons & (1 << (i+1))) &&
validTarget((BASE_OBJECT *)psDroid, psDroid->psActionTarget[0], i) &&
actionVisibleTarget(psDroid, psDroid->psActionTarget[0], i) )
if (nonNullWeapon[i]
&& validTarget((BASE_OBJECT *)psDroid, psDroid->psActionTarget[0], i)
&& actionVisibleTarget(psDroid, psDroid->psActionTarget[0], i))
{
psWeapStats = asWeaponStats + psDroid->asWeaps[i].nStat;
bool chaseBloke = false;
WEAPON_STATS* const psWeapStats = &asWeaponStats[psDroid->asWeaps[i].nStat];
if (psWeapStats->rotate)
{
actionTargetTurret((BASE_OBJECT*)psDroid, psDroid->psActionTarget[0], &psDroid->asWeaps[i]);
}
bChaseBloke = false;
if (!isVtolDroid(psDroid) &&
psDroid->psActionTarget[0]->type == OBJ_DROID &&
((DROID *)psDroid->psActionTarget[0])->droidType == DROID_PERSON &&
psWeapStats->fireOnMove != FOM_NO)
{
bChaseBloke = true;
chaseBloke = true;
}
if ( (actionInAttackRange(psDroid, psDroid->psActionTarget[0], i)) &&
!bChaseBloke)
if (actionInAttackRange(psDroid, psDroid->psActionTarget[0], i)
&& !chaseBloke)
{
/* Stop the droid moving any closer */
// ASSERT( psDroid->pos.x != 0 && psDroid->pos.y != 0,
@ -1656,9 +1642,12 @@ void actionUpdateDroid(DROID *psDroid)
/* Stopped moving but haven't reached the target - possibly move again */
//Watermelon:'hack' to make the droid to check the primary turrent instead of all
psWeapStats = asWeaponStats + psDroid->asWeaps[0].nStat;
WEAPON_STATS* const psWeapStats = &asWeaponStats[psDroid->asWeaps[0].nStat];
SECONDARY_STATE state;
if (psDroid->order == DORDER_ATTACKTARGET && secondaryGetState(psDroid, DSO_HALTTYPE, &state) && (state == DSS_HALT_HOLD))
if (psDroid->order == DORDER_ATTACKTARGET
&& secondaryGetState(psDroid, DSO_HALTTYPE, &state)
&& state == DSS_HALT_HOLD)
{
psDroid->action = DACTION_NONE; // on hold, give up.
}
@ -1666,6 +1655,8 @@ void actionUpdateDroid(DROID *psDroid)
{
if ( proj_Direct( psWeapStats ) )
{
SDWORD pbx, pby;
// try and extend the range
actionCalcPullBackPoint((BASE_OBJECT *)psDroid, psDroid->psActionTarget[0], &pbx,&pby);
moveDroidTo(psDroid, (UDWORD)pbx, (UDWORD)pby);
@ -1733,16 +1724,16 @@ void actionUpdateDroid(DROID *psDroid)
(SDWORD)psDroid->orderX,(SDWORD)psDroid->orderY, psDroid->psTarStats))
{
moveStopDroid(psDroid);
bDoHelpBuild = false;
bool helpBuild = false;
// Got to destination - start building
psStructStats = (STRUCTURE_STATS*)psDroid->psTarStats;
STRUCTURE_STATS* const psStructStats = (STRUCTURE_STATS*)psDroid->psTarStats;
if (psDroid->order == DORDER_BUILD && psDroid->psTarget == NULL)
{
// Starting a new structure
// calculate the top left of the structure
tlx = (SDWORD)psDroid->orderX - (SDWORD)(psStructStats->baseWidth * TILE_UNITS)/2;
tly = (SDWORD)psDroid->orderY - (SDWORD)(psStructStats->baseBreadth * TILE_UNITS)/2;
const UDWORD tlx = (SDWORD)psDroid->orderX - (SDWORD)(psStructStats->baseWidth * TILE_UNITS)/2;
const UDWORD tly = (SDWORD)psDroid->orderY - (SDWORD)(psStructStats->baseBreadth * TILE_UNITS)/2;
//need to check if something has already started building here?
//unless its a module!
@ -1754,12 +1745,12 @@ void actionUpdateDroid(DROID *psDroid)
else if (TileHasStructure(mapTile(map_coord(psDroid->orderX), map_coord(psDroid->orderY))))
{
// structure on the build location - see if it is the same type
psStruct = getTileStructure(map_coord(psDroid->orderX), map_coord(psDroid->orderY));
STRUCTURE* const psStruct = getTileStructure(map_coord(psDroid->orderX), map_coord(psDroid->orderY));
if (psStruct->pStructureType == (STRUCTURE_STATS *)psDroid->psTarStats)
{
// same type - do a help build
setDroidTarget(psDroid, (BASE_OBJECT *)psStruct);
bDoHelpBuild = true;
helpBuild = true;
}
else if ((psStruct->pStructureType->type == REF_WALL ||
psStruct->pStructureType->type == REF_WALLCORNER) &&
@ -1802,7 +1793,7 @@ void actionUpdateDroid(DROID *psDroid)
psStructStats->type == REF_DEFENSE))
{
// building a wall.
psTile = mapTile(map_coord(psDroid->orderX), map_coord(psDroid->orderY));
MAPTILE* const psTile = mapTile(map_coord(psDroid->orderX), map_coord(psDroid->orderY));
if (psDroid->psTarget == NULL
&& (TileHasStructure(psTile)
|| TileHasFeature(psTile)))
@ -1810,12 +1801,12 @@ void actionUpdateDroid(DROID *psDroid)
if (TileHasStructure(psTile))
{
// structure on the build location - see if it is the same type
psStruct = getTileStructure(map_coord(psDroid->orderX), map_coord(psDroid->orderY));
STRUCTURE* const psStruct = getTileStructure(map_coord(psDroid->orderX), map_coord(psDroid->orderY));
if (psStruct->pStructureType == (STRUCTURE_STATS *)psDroid->psTarStats)
{
// same type - do a help build
setDroidTarget(psDroid, (BASE_OBJECT *)psStruct);
bDoHelpBuild = true;
helpBuild = true;
}
else if ((psStruct->pStructureType->type == REF_WALL || psStruct->pStructureType->type == REF_WALLCORNER) &&
((STRUCTURE_STATS *)psDroid->psTarStats)->type == REF_DEFENSE)
@ -1853,10 +1844,10 @@ void actionUpdateDroid(DROID *psDroid)
}
else
{
bDoHelpBuild = true;
helpBuild = true;
}
if (bDoHelpBuild)
if (helpBuild)
{
// continuing a partially built structure (order = helpBuild)
if (droidStartBuild(psDroid))
@ -1877,7 +1868,9 @@ void actionUpdateDroid(DROID *psDroid)
if (actionDroidOnBuildPos(psDroid,
(SDWORD)psDroid->orderX,(SDWORD)psDroid->orderY, psDroid->psTarStats))
{
actionHomeBasePos(psDroid->player, &pbx,&pby);
SDWORD pbx, pby;
actionHomeBasePos(psDroid->player, &pbx, &pby);
if (pbx == 0 || pby == 0)
{
debug(LOG_NEVER, "DACTION_MOVETOBUILD: No HQ, cannot move in that direction.");
@ -1970,7 +1963,9 @@ void actionUpdateDroid(DROID *psDroid)
if (actionDroidOnBuildPos(psDroid,
(SDWORD)psDroid->actionX,(SDWORD)psDroid->actionY, psDroid->psTarStats))
{
actionHomeBasePos(psDroid->player, &pbx,&pby);
SDWORD pbx, pby;
actionHomeBasePos(psDroid->player, &pbx, &pby);
if (pbx == 0 || pby == 0)
{
debug(LOG_NEVER, "No HQ - cannot move in that direction.");
@ -1994,19 +1989,19 @@ void actionUpdateDroid(DROID *psDroid)
switch (psDroid->action)
{
case DACTION_DEMOLISH:
moveAction = DACTION_MOVETODEMOLISH;
// DACTION_MOVETODEMOLISH;
actionUpdateFunc = droidUpdateDemolishing;
break;
case DACTION_REPAIR:
moveAction = DACTION_MOVETOREPAIR;
// DACTION_MOVETOREPAIR;
actionUpdateFunc = droidUpdateRepair;
break;
case DACTION_CLEARWRECK:
moveAction = DACTION_MOVETOCLEAR;
// DACTION_MOVETOCLEAR;
actionUpdateFunc = droidUpdateClearing;
break;
case DACTION_RESTORE:
moveAction = DACTION_MOVETORESTORE;
// DACTION_MOVETORESTORE;
actionUpdateFunc = droidUpdateRestore;
break;
default:
@ -2036,8 +2031,8 @@ void actionUpdateDroid(DROID *psDroid)
else if (psDroid->action == DACTION_CLEARWRECK)
{
//see if there is any other wreckage in the area
FEATURE* const psNextWreck = checkForWreckage(psDroid);
psDroid->action = DACTION_NONE;
psNextWreck = checkForWreckage(psDroid);
if (psNextWreck)
{
orderDroidObj(psDroid, DORDER_CLEARWRECK, (BASE_OBJECT *)psNextWreck);
@ -2080,10 +2075,10 @@ void actionUpdateDroid(DROID *psDroid)
case DACTION_BUILD_FOUNDATION:
//building a structure's foundation - flattening the ground for now
{
psTile = mapTile(map_coord(psDroid->orderX), map_coord(psDroid->orderY));
psStructStats = (STRUCTURE_STATS*)psDroid->psTarStats;
tlx = (SDWORD)psDroid->orderX - (SDWORD)(psStructStats->baseWidth * TILE_UNITS)/2;
tly = (SDWORD)psDroid->orderY - (SDWORD)(psStructStats->baseBreadth * TILE_UNITS)/2;
MAPTILE* const psTile = mapTile(map_coord(psDroid->orderX), map_coord(psDroid->orderY));
STRUCTURE_STATS* const psStructStats = (STRUCTURE_STATS*)psDroid->psTarStats;
const UDWORD tlx = (SDWORD)psDroid->orderX - (SDWORD)(psStructStats->baseWidth * TILE_UNITS)/2;
const UDWORD tly = (SDWORD)psDroid->orderY - (SDWORD)(psStructStats->baseBreadth * TILE_UNITS)/2;
if ((psDroid->psTarget == NULL) &&
(TileHasStructure(psTile) ||
TileHasFeature(psTile)))
@ -2091,7 +2086,7 @@ void actionUpdateDroid(DROID *psDroid)
if (TileHasStructure(psTile))
{
// structure on the build location - see if it is the same type
psStruct = getTileStructure(map_coord(psDroid->orderX), map_coord(psDroid->orderY));
STRUCTURE* const psStruct = getTileStructure(map_coord(psDroid->orderX), map_coord(psDroid->orderY));
if (psStruct->pStructureType == (STRUCTURE_STATS *)psDroid->psTarStats)
{
// same type - do a help build
@ -2140,12 +2135,12 @@ void actionUpdateDroid(DROID *psDroid)
else
{
// make sure the target is within sensor range
xdiff = (SDWORD)psDroid->pos.x - (SDWORD)psDroid->psActionTarget[0]->pos.x;
ydiff = (SDWORD)psDroid->pos.y - (SDWORD)psDroid->psActionTarget[0]->pos.y;
rangeSq = droidSensorRange(psDroid);
const int xdiff = (SDWORD)psDroid->pos.x - (SDWORD)psDroid->psActionTarget[0]->pos.x;
const int ydiff = (SDWORD)psDroid->pos.y - (SDWORD)psDroid->psActionTarget[0]->pos.y;
int rangeSq = droidSensorRange(psDroid);
rangeSq = rangeSq * rangeSq;
if (!visibleObject((BASE_OBJECT *)psDroid, psDroid->psActionTarget[0], false) ||
xdiff*xdiff + ydiff*ydiff >= rangeSq)
if (!visibleObject((BASE_OBJECT *)psDroid, psDroid->psActionTarget[0], false)
|| xdiff * xdiff + ydiff * ydiff >= rangeSq)
{
psDroid->action = DACTION_MOVETOOBSERVE;
moveDroidTo(psDroid, psDroid->psActionTarget[0]->pos.x, psDroid->psActionTarget[0]->pos.y);
@ -2159,9 +2154,9 @@ void actionUpdateDroid(DROID *psDroid)
if (visibleObject((BASE_OBJECT *)psDroid, psDroid->psActionTarget[0], false))
{
// make sure the target is within sensor range
xdiff = (SDWORD)psDroid->pos.x - (SDWORD)psDroid->psActionTarget[0]->pos.x;
ydiff = (SDWORD)psDroid->pos.y - (SDWORD)psDroid->psActionTarget[0]->pos.y;
rangeSq = droidSensorRange(psDroid);
const int xdiff = (SDWORD)psDroid->pos.x - (SDWORD)psDroid->psActionTarget[0]->pos.x;
const int ydiff = (SDWORD)psDroid->pos.y - (SDWORD)psDroid->psActionTarget[0]->pos.y;
int rangeSq = droidSensorRange(psDroid);
rangeSq = rangeSq * rangeSq;
if ((xdiff*xdiff + ydiff*ydiff < rangeSq) &&
!DROID_STOPPED(psDroid))
@ -2187,9 +2182,9 @@ void actionUpdateDroid(DROID *psDroid)
(psDroid->psTarget->type != OBJ_STRUCTURE))
{
//move droids to within short range of the sensor now!!!!
xdiff = (SDWORD)psDroid->pos.x - (SDWORD)psDroid->psTarget->pos.x;
ydiff = (SDWORD)psDroid->pos.y - (SDWORD)psDroid->psTarget->pos.y;
rangeSq = asWeaponStats[psDroid->asWeaps[0].nStat].shortRange;
int xdiff = (SDWORD)psDroid->pos.x - (SDWORD)psDroid->psTarget->pos.x;
int ydiff = (SDWORD)psDroid->pos.y - (SDWORD)psDroid->psTarget->pos.y;
int rangeSq = asWeaponStats[psDroid->asWeaps[0].nStat].shortRange;
rangeSq = rangeSq * rangeSq;
if (xdiff*xdiff + ydiff*ydiff < rangeSq)
{
@ -2209,8 +2204,10 @@ void actionUpdateDroid(DROID *psDroid)
if (DROID_STOPPED(psDroid) ||
(xdiff*xdiff + ydiff*ydiff > rangeSq))
{
if (secondaryGetState(psDroid, DSO_HALTTYPE, &state) && (
state == DSS_HALT_HOLD))
SECONDARY_STATE state;
if (secondaryGetState(psDroid, DSO_HALTTYPE, &state)
&& state == DSS_HALT_HOLD)
{
// droid on hold, don't allow moves.
psDroid->action = DACTION_NONE;
@ -2234,15 +2231,16 @@ void actionUpdateDroid(DROID *psDroid)
}
else
{
debug(LOG_DEATH, "actionUpdateDroid: Droid %d destructed", (int)psDroid->id);
debug(LOG_DEATH, "Droid %d destructed", (int)psDroid->id);
destroyDroid(psDroid);
}
}
break;
case DACTION_MOVETODROIDREPAIR:
{
// moving to repair a droid
xdiff = (SDWORD)psDroid->pos.x - (SDWORD)psDroid->psActionTarget[0]->pos.x;
ydiff = (SDWORD)psDroid->pos.y - (SDWORD)psDroid->psActionTarget[0]->pos.y;
const int xdiff = (SDWORD)psDroid->pos.x - (SDWORD)psDroid->psActionTarget[0]->pos.x;
const int ydiff = (SDWORD)psDroid->pos.y - (SDWORD)psDroid->psActionTarget[0]->pos.y;
if ( xdiff*xdiff + ydiff*ydiff < REPAIR_RANGE )
{
// Got to destination - start repair
@ -2268,6 +2266,7 @@ void actionUpdateDroid(DROID *psDroid)
moveDroidTo(psDroid, psDroid->actionX, psDroid->actionY);
}
break;
}
case DACTION_DROIDREPAIR:
//if not doing self-repair
//Watermelon:use 0 for repair droid
@ -2277,8 +2276,8 @@ void actionUpdateDroid(DROID *psDroid)
}
//check still next to the damaged droid
xdiff = (SDWORD)psDroid->pos.x - (SDWORD)psDroid->psActionTarget[0]->pos.x;
ydiff = (SDWORD)psDroid->pos.y - (SDWORD)psDroid->psActionTarget[0]->pos.y;
const int xdiff = (SDWORD)psDroid->pos.x - (SDWORD)psDroid->psActionTarget[0]->pos.x;
const int ydiff = (SDWORD)psDroid->pos.y - (SDWORD)psDroid->psActionTarget[0]->pos.y;
if ( xdiff*xdiff + ydiff*ydiff > REPAIR_RANGE )
{
/*once started - don't allow the Repair droid to follow the
@ -2354,7 +2353,7 @@ void actionUpdateDroid(DROID *psDroid)
{
// got close to the rearm pad - now find a clear one
objTrace(psDroid->id, "Seen rearm pad - searching for available one");
psStruct = findNearestReArmPad(psDroid, (STRUCTURE *)psDroid->psActionTarget[0], true);
STRUCTURE* const psStruct = findNearestReArmPad(psDroid, (STRUCTURE *)psDroid->psActionTarget[0], true);
if (psStruct != NULL)
{
// found a clear landing pad - go for it
@ -2368,8 +2367,8 @@ void actionUpdateDroid(DROID *psDroid)
if (DROID_STOPPED(psDroid) ||
(psDroid->action == DACTION_WAITFORREARM))
{
droidX = psDroid->psActionTarget[0]->pos.x;
droidY = psDroid->psActionTarget[0]->pos.y;
UDWORD droidX = psDroid->psActionTarget[0]->pos.x;
UDWORD droidY = psDroid->psActionTarget[0]->pos.y;
if (!actionVTOLLandingPos(psDroid, &droidX, &droidY))
{
// totally bunged up - give up

2
src/weapondef.h
View File

@ -30,7 +30,7 @@ typedef struct _weapon
* Index into the global @c asWeaponStats array; thus a "reference" of
* some kind to the associated stats.
*/
UDWORD nStat;
unsigned int nStat;
UDWORD ammo;