/////////////////////////////// Reinforcement Sector Selection ////////////////////////////////////////////
void
ReinforcementSector::Setup( UINT32 aVal )
{
Destroy();
SOLDIERTYPE * pSoldier = NULL;
GetSoldier( &pSoldier, gusSelectedSoldier );
if ( pSoldier == NULL )
return;
if ( pSoldier->CanUseSkill(aVal) )
{
SetupPopup("Reinforcements sector");
POPUP_OPTION *pOption;
CHAR16 pStr[300];
// check wether we can call artillery from the 4 adjacent sectors
for (UINT8 i = 0; i < 4; ++i)
{
INT16 loopX = pSoldier->sSectorX;
INT16 loopY = pSoldier->sSectorY;
if ( i == 0 ) ++loopY;
else if ( i == 1 ) ++loopX;
else if ( i == 2 ) --loopY;
else if ( i == 3 ) --loopX;
if ( loopX < 1 || loopX >= MAP_WORLD_X - 1 || loopY < 1 || loopY >= MAP_WORLD_Y - 1 )
continue;
UINT32 sectornr = (UINT32)SECTOR( loopX, loopY );
swprintf( pStr, L"%c%d", loopY + 'A' - 1, loopX );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void, UINT32>( &Wrapper_Setup_ReinforcementNumber, sectornr ) );
// grey out if no reinforcements can be called from this sector
if ( !CanRequestMilitiaReinforcements( pSoldier->sSectorX, pSoldier->sSectorY, loopX, loopY ) )
{
// Set this option off.
pOption->setAvail(new popupCallbackFunction<bool,void*>( &Popup_OptionOff, NULL ));
}
GetPopup()->addOption( *pOption );
}
// cancel option
swprintf( pStr, pSkillMenuStrings[SKILLMENU_CANCEL] );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void, UINT32>( &Wrapper_Cancel_ReinforcementSector, 0 ) );
GetPopup()->addOption( *pOption );
}
// same y, different x
SetPos(gSkillSelection.GetMaxPosX(), usTraitMenuPosY);
}
/////////////////////////////// Soldier Target Selection ////////////////////////////////////////////
void
SoldierSelection::Setup( UINT32 aVal )
{
Destroy();
SOLDIERTYPE * pSoldier = NULL;
GetSoldier( &pSoldier, gusSelectedSoldier );
if ( pSoldier == NULL )
return;
if ( pSoldier->CanUseSkill(aVal) )
{
usSkill = aVal;
SetupPopup("SoldierSelection");
POPUP_OPTION *pOption;
CHAR16 pStr[300];
// pretty simple: we find every soldier in a radius around the target position and add him to the list
// loop through all soldiers around
for ( UINT32 cnt = gTacticalStatus.Team[ OUR_TEAM ].bFirstID ; cnt <= gTacticalStatus.Team[ CIV_TEAM ].bLastID ; ++cnt )
{
INT32 iRange = GetRangeInCellCoordsFromGridNoDiff( sTraitsMenuTargetGridNo, MercPtrs[ cnt ]->sGridNo );
if ( iRange < 100 )
{
if ( cnt != pSoldier->ubID )
{
swprintf( pStr, L"%s", MercPtrs[ cnt ]->GetName() );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void, UINT8>( &Wrapper_Function_SoldierSelection, cnt ) );
// grey out if no artillery can be called from this sector
if ( 0 )
{
// Set this option off.
pOption->setAvail(new popupCallbackFunction<bool,void*>( &Popup_OptionOff, NULL ));
}
GetPopup()->addOption( *pOption );
}
}
}
// cancel option
swprintf( pStr, pSkillMenuStrings[SKILLMENU_CANCEL] );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &Wrapper_Cancel_SoldierSelection, 0 ) );
GetPopup()->addOption( *pOption );
}
// same y, different x
SetPos(gSkillSelection.GetMaxPosX(), usTraitMenuPosY);
}
static BOOL applyPopupContentGenerator( POPUP * popup, UINT16 generatorId ){
SOLDIERTYPE *pSoldier;
GetSoldier( &pSoldier, gCharactersList[ bSelectedInfoChar ].usSolID );
switch(generatorId){
case popupGenerators::dummy:
popup->addOption(new std::wstring( L"Dummy generator" ),NULL);
break;
case popupGenerators::addArmor:
addArmorToPocketPopup( pSoldier, gsPocketUnderCursor, popup );
break;
case popupGenerators::addLBE:
addLBEToPocketPopup( pSoldier, gsPocketUnderCursor, popup );
break;
case popupGenerators::addWeapons:
addWeaponsToPocketPopup( pSoldier, gsPocketUnderCursor, popup );
break;
case popupGenerators::addWeaponGroups:
addWeaponGroupsToPocketPopup( pSoldier, gsPocketUnderCursor, popup );
break;
case popupGenerators::addGrenades:
addGrenadesToPocketPopup( pSoldier, gsPocketUnderCursor, popup );
break;
case popupGenerators::addBombs:
addBombsToPocketPopup( pSoldier, gsPocketUnderCursor, popup );
break;
case popupGenerators::addFaceGear:
addFaceGearToPocketPopup( pSoldier, gsPocketUnderCursor, popup );
break;
case popupGenerators::addAmmo:
addAmmoToPocketPopup( pSoldier, gsPocketUnderCursor, popup );
break;
case popupGenerators::addRifleGrenades:
addRifleGrenadesToPocketPopup( pSoldier, gsPocketUnderCursor, popup );
break;
case popupGenerators::addRocketAmmo:
addRocketAmmoToPocketPopup( pSoldier, gsPocketUnderCursor, popup );
break;
case popupGenerators::addMisc:
addMiscToPocketPopup( pSoldier, gsPocketUnderCursor, popup );
break;
case popupGenerators::addKits:
addKitsToPocketPopup( pSoldier, gsPocketUnderCursor, popup );
break;
default:
return FALSE;
}
return TRUE;
}
void MercsFindSelectedMercCallback( GUI_BUTTON *btn, INT32 reason )
{
SOLDIERTYPE *pSoldier;
if( reason & MSYS_CALLBACK_REASON_LBUTTON_UP )
{
if( gsSelectedMercID == -1 )
return;
GetSoldier( &pSoldier, gsSelectedMercID );
if( !pSoldier )
return;
CenterScreenAtMapIndex( pSoldier->sGridNo );
}
}
void
SoldierSelection::Functions( UINT32 aVal )
{
Cancel();
SOLDIERTYPE * pSoldier = NULL;
GetSoldier( &pSoldier, gusSelectedSoldier );
if ( pSoldier == NULL )
return;
pSoldier->UseSkill(usSkill, sTraitsMenuTargetGridNo, aVal);
Cancel();
gSkillSelection.Cancel();
gTraitSelection.Cancel();
}
void
SkillSelection::Functions( UINT32 aVal )
{
Cancel();
SOLDIERTYPE * pSoldier = NULL;
GetSoldier( &pSoldier, gusSelectedSoldier );
if ( pSoldier == NULL )
return;
UINT8 ubID = WhoIsThere2(sTraitsMenuTargetGridNo, 0 );
pSoldier->UseSkill(aVal, sTraitsMenuTargetGridNo, ubID);
Cancel();
gTraitSelection.Cancel();
}
void
ReinforcementNumber::Functions( UINT32 aVal )
{
Cancel();
SOLDIERTYPE * pSoldier = NULL;
GetSoldier( &pSoldier, gusSelectedSoldier );
if ( pSoldier == NULL || !pSoldier->CanUseSkill(SKILLS_RADIO_CALLREINFORCEMENTS) )
return;
pSoldier->RadioCallReinforcements(usSector, aVal);
Cancel();
gReinforcementSector.Cancel();
gSkillSelection.Cancel();
gTraitSelection.Cancel();
}
void
ArtilleryTeam::Functions( UINT32 aVal )
{
Cancel();
SOLDIERTYPE * pSoldier = NULL;
GetSoldier( &pSoldier, gusSelectedSoldier );
if ( pSoldier == NULL || !pSoldier->CanUseSkill(SKILLS_RADIO_ARTILLERY) )
return;
pSoldier->OrderArtilleryStrike(usSector, sTraitsMenuTargetGridNo, (UINT8)(aVal));
Cancel();
gArtillerySector.Cancel();
gSkillSelection.Cancel();
gTraitSelection.Cancel();
}
BOOLEAN ExecuteGameEvent( EVENT *pEvent )
{
SOLDIERTYPE *pSoldier;
// Switch on event type
switch( pEvent->uiEvent )
{
case E_PLAYSOUND:
memcpy( &EPlaySound, pEvent->pData, pEvent->uiDataSize );
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: Play Sound");
PlayJA2Sample( EPlaySound.usIndex, EPlaySound.usRate, EPlaySound.ubVolume, EPlaySound.ubLoops, EPlaySound.uiPan );
break;
case S_CHANGESTATE:
memcpy( &SChangeState, pEvent->pData, pEvent->uiDataSize );
// Get soldier pointer from ID
if ( GetSoldier( &pSoldier, SChangeState.usSoldierID ) == FALSE )
{
// Handle Error?
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: Invalid Soldier ID");
break;
}
// check for error
if( pSoldier->uiUniqueSoldierIdValue != SChangeState.uiUniqueId )
{
break;
}
// Call soldier function
// DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String("Event Pump: ChangeState %S (%d)", gAnimControl[ SChangeState.ubNewState ].zAnimStr, SChangeState.usSoldierID ) );
pSoldier->EVENT_InitNewSoldierAnim( SChangeState.usNewState, SChangeState.usStartingAniCode, SChangeState.fForce );
break;
case S_CHANGEDEST:
memcpy( &SChangeDest, pEvent->pData, pEvent->uiDataSize );
// Get soldier pointer from ID
if ( GetSoldier( &pSoldier, SChangeDest.usSoldierID ) == FALSE )
{
// Handle Error?
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String("Event Pump: Invalid Soldier ID #%d", SChangeDest.usSoldierID) );
break;
}
// check for error
if( pSoldier->uiUniqueSoldierIdValue != SChangeDest.uiUniqueId )
{
break;
}
// Call soldier function
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: Change Dest");
pSoldier->EVENT_SetSoldierDestination( (UINT8) SChangeDest.usNewDestination );
break;
case S_SETPOSITION:
memcpy( &SSetPosition, pEvent->pData, pEvent->uiDataSize );
// Get soldier pointer from ID
if ( GetSoldier( &pSoldier, SSetPosition.usSoldierID ) == FALSE )
{
// Handle Error?
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: Invalid Soldier ID");
break;
}
// check for error
if( pSoldier->uiUniqueSoldierIdValue != SSetPosition.uiUniqueId )
{
break;
}
// Call soldier function
// DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String( "Event Pump: SetPosition ( %f %f ) ( %d )", SSetPosition.dNewXPos, SSetPosition.dNewYPos, SSetPosition.usSoldierID ) );
pSoldier->EVENT_SetSoldierPosition( SSetPosition.dNewXPos, SSetPosition.dNewYPos );
break;
case S_GETNEWPATH:
memcpy( &SGetNewPath, pEvent->pData, pEvent->uiDataSize );
// Get soldier pointer from ID
if ( GetSoldier( &pSoldier, SGetNewPath.usSoldierID ) == FALSE )
{
// Handle Error?
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: Invalid Soldier ID");
break;
}
// check for error
if( pSoldier->uiUniqueSoldierIdValue != SGetNewPath.uiUniqueId )
{
break;
}
// Call soldier function
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: GetNewPath");
pSoldier->EVENT_GetNewSoldierPath( SGetNewPath.sDestGridNo, SGetNewPath.usMovementAnim );
break;
case S_BEGINTURN:
memcpy( &SBeginTurn, pEvent->pData, pEvent->uiDataSize );
// Get soldier pointer from ID
if ( GetSoldier( &pSoldier, SBeginTurn.usSoldierID ) == FALSE )
{
// Handle Error?
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: Invalid Soldier ID");
break;
}
// check for error
if( pSoldier->uiUniqueSoldierIdValue != SBeginTurn.uiUniqueId )
{
break;
}
// Call soldier function
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: BeginTurn");
pSoldier->EVENT_BeginMercTurn( FALSE, 0 );
break;
case S_CHANGESTANCE:
memcpy( &SChangeStance, pEvent->pData, pEvent->uiDataSize );
// Get soldier pointer from ID
if ( GetSoldier( &pSoldier, SChangeStance.usSoldierID ) == FALSE )
{
// Handle Error?
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: Invalid Soldier ID");
break;
}
// check for error
if( pSoldier->uiUniqueSoldierIdValue != SChangeStance.uiUniqueId )
{
break;
}
// Call soldier function
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: ChangeStance");
pSoldier->ChangeSoldierStance( SChangeStance.ubNewStance );
break;
case S_SETDIRECTION:
memcpy( &SSetDirection, pEvent->pData, pEvent->uiDataSize );
// Get soldier pointer from ID
if ( GetSoldier( &pSoldier, SSetDirection.usSoldierID ) == FALSE )
{
// Handle Error?
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: Invalid Soldier ID");
break;
}
// check for error
if( pSoldier->uiUniqueSoldierIdValue != SSetDirection.uiUniqueId )
{
break;
}
// Call soldier function
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String( "Event Pump: SetDirection: Dir( %d )", SSetDirection.usNewDirection) );
pSoldier->EVENT_SetSoldierDirection( SSetDirection.usNewDirection );
break;
case S_SETDESIREDDIRECTION:
memcpy( &SSetDesiredDirection, pEvent->pData, pEvent->uiDataSize );
// Get soldier pointer from ID
if ( GetSoldier( &pSoldier, SSetDesiredDirection.usSoldierID ) == FALSE )
{
// Handle Error?
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: Invalid Soldier ID");
break;
}
// check for error
if( pSoldier->uiUniqueSoldierIdValue != SSetDesiredDirection.uiUniqueId )
{
break;
}
// Call soldier function
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String( "Event Pump: SetDesiredDirection: Dir( %d )", SSetDesiredDirection.usDesiredDirection) );
pSoldier->EVENT_SetSoldierDesiredDirection( (UINT8) SSetDesiredDirection.usDesiredDirection );
break;
case S_BEGINFIREWEAPON:
memcpy( &SBeginFireWeapon, pEvent->pData, pEvent->uiDataSize );
// Get soldier pointer from ID
if ( GetSoldier( &pSoldier, SBeginFireWeapon.usSoldierID ) == FALSE )
{
pSoldier = NULL;
break;
// Handle Error?
// DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: Invalid Soldier ID");
}
// check for error
if( pSoldier->uiUniqueSoldierIdValue != SBeginFireWeapon.uiUniqueId )
{
break;
}
// Call soldier function
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: Begin Fire Weapon");
pSoldier->sTargetGridNo = SBeginFireWeapon.sTargetGridNo;
pSoldier->bTargetLevel = SBeginFireWeapon.bTargetLevel;
pSoldier->bTargetCubeLevel = SBeginFireWeapon.bTargetCubeLevel;
pSoldier->EVENT_FireSoldierWeapon( SBeginFireWeapon.sTargetGridNo );
break;
case S_FIREWEAPON:
memcpy( &SFireWeapon, pEvent->pData, pEvent->uiDataSize );
// Get soldier pointer from ID
if ( GetSoldier( &pSoldier, SFireWeapon.usSoldierID ) == FALSE )
{
// Handle Error?
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: Invalid Soldier ID");
break;
}
// check for error
if( pSoldier->uiUniqueSoldierIdValue != SFireWeapon.uiUniqueId )
{
break;
}
// Call soldier function
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: FireWeapon");
pSoldier->sTargetGridNo = SFireWeapon.sTargetGridNo;
pSoldier->bTargetLevel = SFireWeapon.bTargetLevel;
pSoldier->bTargetCubeLevel = SFireWeapon.bTargetCubeLevel;
FireWeapon( pSoldier, SFireWeapon.sTargetGridNo );
break;
case S_WEAPONHIT:
memcpy( &SWeaponHit, pEvent->pData, pEvent->uiDataSize );
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String( "Event Pump: WeaponHit %d Damage", SWeaponHit.sDamage ) );
WeaponHit( SWeaponHit.usSoldierID, SWeaponHit.usWeaponIndex, SWeaponHit.sDamage, SWeaponHit.sBreathLoss, SWeaponHit.usDirection, SWeaponHit.sXPos, SWeaponHit.sYPos, SWeaponHit.sZPos, SWeaponHit.sRange, SWeaponHit.ubAttackerID, SWeaponHit.fHit, SWeaponHit.ubSpecial, SWeaponHit.ubLocation );
break;
case S_STRUCTUREHIT:
memcpy( &SStructureHit, pEvent->pData, pEvent->uiDataSize );
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String( "Event Pump: StructureHit" ) );
StructureHit( SStructureHit.iBullet, SStructureHit.usWeaponIndex, SStructureHit.bWeaponStatus, SStructureHit.ubAttackerID, SStructureHit.sXPos, SStructureHit.sYPos, SStructureHit.sZPos, SStructureHit.usStructureID, SStructureHit.iImpact, TRUE );
break;
case S_WINDOWHIT:
memcpy( &SWindowHit, pEvent->pData, pEvent->uiDataSize );
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String( "Event Pump: WindowHit" ) );
WindowHit( SWindowHit.sGridNo, SWindowHit.usStructureID, SWindowHit.fBlowWindowSouth, SWindowHit.fLargeForce );
break;
case S_MISS:
memcpy( &SMiss, pEvent->pData, pEvent->uiDataSize );
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String( "Event Pump: Shot Miss ( obsolete )" ) );
//ShotMiss( SMiss.ubAttackerID );
break;
case S_NOISE:
memcpy( &SNoise, pEvent->pData, pEvent->uiDataSize );
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String( "Event Pump: Noise from %d at %d/%d, type %d volume %d", SNoise.ubNoiseMaker, SNoise.sGridNo, SNoise.bLevel, SNoise.ubNoiseType, SNoise.ubVolume ) );
OurNoise( SNoise.ubNoiseMaker, SNoise.sGridNo, SNoise.bLevel, SNoise.ubTerrType, SNoise.ubVolume, SNoise.ubNoiseType, SNoise.zNoiseMessage );
break;
case S_STOP_MERC:
memcpy( &SStopMerc, pEvent->pData, pEvent->uiDataSize );
// Get soldier pointer from ID
if ( GetSoldier( &pSoldier, SStopMerc.usSoldierID ) == FALSE )
{
// Handle Error?
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: Invalid Soldier ID");
break;
}
if( pSoldier->uiUniqueSoldierIdValue != SStopMerc.uiUniqueId )
{
break;
}
// Call soldier function
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String("Event Pump: Stop Merc at Gridno %d", SStopMerc.sGridNo ));
pSoldier->EVENT_StopMerc( SStopMerc.sGridNo, SStopMerc.ubDirection );
break;
default:
DebugMsg( TOPIC_JA2, DBG_LEVEL_3, "Event Pump: Invalid Event Received");
return( FALSE );
}
return( TRUE );
}
void CalculateTraitRange()
{
INT32 ubX, ubY, ubZ;
SOLDIERTYPE* pSoldier;
RemoveTraitObjectsFromViewArea();
if ( gubDrawModeTrait == TRAIT_DRAW_OFF )
return;
if( gusSelectedSoldier == NOBODY || !GetSoldier( &pSoldier, gusSelectedSoldier ) )
return;
UINT16 range1 = 0;
UINT16 range2 = 0;
switch ( usDisplayTrait )
{
case RADIO_OPERATOR_NT:
{
// we 'mark' the map position with which we called the menu, so that the player sees where he is targetting
}
break;
case VARIOUSSKILLS:
{
range1 = gGameExternalOptions.usSpotterRange;
range2 = gGameExternalOptions.usSpotterRange * 2;
}
break;
default:
return;
}
//remove other displays
if( gubDrawModeMine != MINES_DRAW_OFF )
RemoveMinesObjectsFromViewArea();
if ( gubDrawMode != COVER_DRAW_OFF )
RemoveCoverObjectsFromViewArea();
const INT32& sSelectedSoldierGridNo = MercPtrs[ gusSelectedSoldier ]->sGridNo;
INT16 usTmp;
GetScreenXYWorldCell( gsVIEWPORT_START_X, gsVIEWPORT_START_Y, &gsMineMinCellX, &usTmp );
GetScreenXYWorldCell( gsVIEWPORT_END_X, gsVIEWPORT_END_Y, &gsMineMaxCellX, &usTmp );
GetScreenXYWorldCell( gsVIEWPORT_END_X, gsVIEWPORT_START_Y, &usTmp, &gsMineMinCellY );
GetScreenXYWorldCell( gsVIEWPORT_START_X, gsVIEWPORT_END_Y, &usTmp, &gsMineMaxCellY );
for ( ubX=gsMineMinCellX; ubX<=gsMineMaxCellX; ++ubX )
{
for ( ubY=gsMineMinCellY; ubY<=gsMineMaxCellY; ++ubY )
{
for ( ubZ=0; ubZ<COVER_Z_CELLS; ++ubZ )
{
INT32& sGridNo = gCoverViewArea[ ubX ][ ubY ][ ubZ ].sGridNo;
GetGridNoForViewPort( ubX, ubY, sGridNo );
if( !GridNoOnScreenAndAround( sGridNo, 2 ) )
{
continue;
}
if ( !NewOKDestination( pSoldier, sGridNo, false, (INT8) ubZ ) )
{
continue;
}
// do not show stuff on roofs if ground is shown
if ( ubZ == I_ROOF_LEVEL && !IsTheRoofVisible( sGridNo ) )
{
continue;
}
// do not show stuff on ground if roof is shown
if ( ubZ == I_GROUND_LEVEL && IsTheRoofVisible( sGridNo ) )
{
continue;
}
if ( range1 && PythSpacesAway(sSelectedSoldierGridNo, sGridNo) == range1 )
gCoverViewArea[ ubX ][ ubY ][ ubZ ].bTrait = TRAIT_1;
else if ( range2 && PythSpacesAway(sSelectedSoldierGridNo, sGridNo) == range2 )
gCoverViewArea[ ubX ][ ubY ][ ubZ ].bTrait = TRAIT_2;
// mark the gridno we are targetting
else if ( PythSpacesAway(sTraitgridNo, sGridNo) == 1 )
gCoverViewArea[ ubX ][ ubY ][ ubZ ].bTrait = TRAIT_1;
else
gCoverViewArea[ ubX ][ ubY ][ ubZ ].bTrait = MAX_TRAIT;
}
}
}
AddTraitObjectsToViewArea();
}
/////////////////////////////// Reinforcement Number Selection ////////////////////////////////////////////
void
ReinforcementNumber::Setup( UINT32 aVal )
{
Destroy();
SOLDIERTYPE * pSoldier = NULL;
GetSoldier( &pSoldier, gusSelectedSoldier );
if ( pSoldier == NULL )
return;
if ( pSoldier->CanUseSkill(SKILLS_RADIO_CALLREINFORCEMENTS) )
{
usSector = aVal;
SetupPopup("Reinforcements number submenu");
POPUP_OPTION *pOption;
CHAR16 pStr[300];
UINT8 numberofmilitia = NumNonPlayerTeamMembersInSector( SECTORX( usSector ), SECTORY( usSector ), MILITIA_TEAM );
// 5 militia option
swprintf( pStr, pSkillMenuStrings[SKILLMENU_X_MILITIA], 5 );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void, UINT32>( &Wrapper_Function_ReinforcementNumber, 5 ) );
if ( numberofmilitia < 5 )
{
// Set this option off.
pOption->setAvail(new popupCallbackFunction<bool,void*>( &Popup_OptionOff, NULL ));
}
GetPopup()->addOption( *pOption );
// 10 militia option
swprintf( pStr, pSkillMenuStrings[SKILLMENU_X_MILITIA], 10 );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void, UINT32>( &Wrapper_Function_ReinforcementNumber, 10 ) );
if ( numberofmilitia < 10 )
{
// Set this option off.
pOption->setAvail(new popupCallbackFunction<bool,void*>( &Popup_OptionOff, NULL ));
}
GetPopup()->addOption( *pOption );
// 15 militia option
swprintf( pStr, pSkillMenuStrings[SKILLMENU_X_MILITIA], 15 );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void, UINT32>( &Wrapper_Function_ReinforcementNumber, 15 ) );
if ( numberofmilitia < 15 )
{
// Set this option off.
pOption->setAvail(new popupCallbackFunction<bool,void*>( &Popup_OptionOff, NULL ));
}
GetPopup()->addOption( *pOption );
// 20 militia option
swprintf( pStr, pSkillMenuStrings[SKILLMENU_X_MILITIA], 20 );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void, UINT32>( &Wrapper_Function_ReinforcementNumber, 20 ) );
if ( numberofmilitia < 20 )
{
// Set this option off.
pOption->setAvail(new popupCallbackFunction<bool,void*>( &Popup_OptionOff, NULL ));
}
// 30 militia option
swprintf( pStr, pSkillMenuStrings[SKILLMENU_X_MILITIA], 30 );
pOption = new POPUP_OPTION( &std::wstring( pStr ), new popupCallbackFunction<void, UINT32>( &Wrapper_Function_ReinforcementNumber, 30 ) );
if ( numberofmilitia < 30 )
{
// Set this option off.
pOption->setAvail( new popupCallbackFunction<bool, void*>( &Popup_OptionOff, NULL ) );
}
// 40 militia option
swprintf( pStr, pSkillMenuStrings[SKILLMENU_X_MILITIA], 40 );
pOption = new POPUP_OPTION( &std::wstring( pStr ), new popupCallbackFunction<void, UINT32>( &Wrapper_Function_ReinforcementNumber, 40 ) );
if ( numberofmilitia < 40 )
{
// Set this option off.
pOption->setAvail( new popupCallbackFunction<bool, void*>( &Popup_OptionOff, NULL ) );
}
GetPopup()->addOption( *pOption );
// all militia option
swprintf( pStr, pSkillMenuStrings[SKILLMENU_ALL_MILITIA] );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void, UINT32>( &Wrapper_Function_ReinforcementNumber, numberofmilitia ) );
GetPopup()->addOption( *pOption );
// cancel option
swprintf( pStr, pSkillMenuStrings[SKILLMENU_CANCEL] );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void, UINT32>( &Wrapper_Cancel_ReinforcementNumber, 0 ) );
GetPopup()->addOption( *pOption );
}
// same y, different x
SetPos(gReinforcementSector.GetMaxPosX(), usTraitMenuPosY);
}
void CalculateCover()
{
register INT32 ubX, ubY;
register INT8 ubZ;
SOLDIERTYPE* pSoldier;
RemoveCoverObjectsFromViewArea();
if( gubDrawMode == COVER_DRAW_OFF )
{
return;
}
if( gusSelectedSoldier == NOBODY )
{
return;
}
// at we're here, we want to display cover, so remove the mines display
if ( gubDrawModeMine != MINES_DRAW_OFF )
RemoveMinesObjectsFromViewArea();
GetSoldier( &pSoldier, gusSelectedSoldier );
INT16 usTmp;
GetScreenXYWorldCell( gsVIEWPORT_START_X, gsVIEWPORT_START_Y, &gsMinCellX, &usTmp );
GetScreenXYWorldCell( gsVIEWPORT_END_X, gsVIEWPORT_END_Y, &gsMaxCellX, &usTmp );
GetScreenXYWorldCell( gsVIEWPORT_END_X, gsVIEWPORT_START_Y, &usTmp, &gsMinCellY );
GetScreenXYWorldCell( gsVIEWPORT_START_X, gsVIEWPORT_END_Y, &usTmp, &gsMaxCellY );
for ( ubX=gsMinCellX; ubX<=gsMaxCellX; ++ubX )
{
for ( ubY=gsMinCellY; ubY<=gsMaxCellY; ++ubY )
{
for ( ubZ=0; ubZ<COVER_Z_CELLS; ++ubZ )
{
INT32& sGridNo = gCoverViewArea[ ubX ][ ubY ][ ubZ ].sGridNo;
GetGridNoForViewPort( ubX, ubY, sGridNo );
if( !GridNoOnScreenAndAround( sGridNo, 2 ) )
{
continue;
}
// do not show stuff on ground if roof is shown
if ( IsTheRoofVisible( sGridNo ) )
{
if ( ubZ == I_GROUND_LEVEL )
continue;
}
// do not show stuff on roofs if ground is shown
else if ( ubZ == I_ROOF_LEVEL )
continue;
if ( !NewOKDestination( pSoldier, sGridNo, false, ubZ ) )
{
continue;
}
INT8& bCover = gCoverViewArea[ ubX ][ ubY ][ ubZ ].bCover;
BOOLEAN& fInverseColor = gCoverViewArea[ ubX ][ ubY ][ ubZ ].fInverseColor;
if ( gubDrawMode == COVER_DRAW_ENEMY_VIEW ) // view of enemies against your selected merc
{
// reset cover value
bCover = MAX_COVER;
CalculateCoverForSoldier( pSoldier, sGridNo, ubZ, bCover );
fInverseColor = FALSE;
}
else if ( gubDrawMode == COVER_DRAW_MERC_VIEW )
{
// reset cover value
bCover = MAX_COVER;
if ( gTacticalStatus.fAtLeastOneGuyOnMultiSelect ) // view of selected mercs
{
// OK, loop through all guys who are 'multi-selected' and
INT32 cnt;
cnt = gTacticalStatus.Team[ gbPlayerNum ].bFirstID;
for ( pSoldier = MercPtrs[ cnt ]; cnt <= gTacticalStatus.Team[ gbPlayerNum ].bLastID; cnt++, pSoldier++ )
{
if ( pSoldier->bActive && pSoldier->bInSector )
{
if ( pSoldier->flags.uiStatusFlags & SOLDIER_MULTI_SELECTED )
{
CalculateCoverFromSoldier( pSoldier, sGridNo, ubZ, bCover );
}
}
}
}
else // single view from your merc
CalculateCoverFromSoldier( pSoldier, sGridNo, ubZ, bCover );
fInverseColor = TRUE; // we don't want to show the cover for the enemy
}
}
}
}
AddCoverObjectsToViewArea();
}
/////////////////////////////// Artillery Team Selection ////////////////////////////////////////////
void
ArtilleryTeam::Setup( UINT32 aVal )
{
Destroy();
SOLDIERTYPE * pSoldier = NULL;
GetSoldier( &pSoldier, gusSelectedSoldier );
if ( pSoldier == NULL )
return;
if ( pSoldier->CanUseSkill(SKILLS_RADIO_ARTILLERY) && pSoldier->bSectorZ == 0)
{
usSector = aVal;
SetupPopup("ArtilleryTeam");
POPUP_OPTION *pOption;
CHAR16 pStr[300];
// determine sector coordinates
INT16 sSectorX = SECTORX(usSector);
INT16 sSectorY = SECTORY(usSector);
// order artillery from militia
swprintf( pStr, pSkillMenuStrings[SKILLMENU_MILITIA] );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void, UINT32>( &Wrapper_Function_ArtilleryTeam, MILITIA_TEAM ) );
// grey out if no ArtilleryTeam can be called from this sector
if ( !IsValidArtilleryOrderSector( sSectorX, sSectorY, pSoldier->bSectorZ, MILITIA_TEAM ) )
{
// Set this option off.
pOption->setAvail(new popupCallbackFunction<bool,void*>( &Popup_OptionOff, NULL ));
}
GetPopup()->addOption( *pOption );
// order artillery from our mercs
swprintf( pStr, pSkillMenuStrings[SKILLMENU_OTHERSQUADS] );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void, INT8>( &Wrapper_Function_ArtilleryTeam, pSoldier->bTeam ) );
// grey out if no ArtilleryTeam can be called from this sector
if ( !IsValidArtilleryOrderSector( sSectorX, sSectorY, pSoldier->bSectorZ, pSoldier->bTeam ) )
{
// Set this option off.
pOption->setAvail(new popupCallbackFunction<bool,void*>( &Popup_OptionOff, NULL ));
}
GetPopup()->addOption( *pOption );
// cancel option
swprintf( pStr, pSkillMenuStrings[SKILLMENU_CANCEL] );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &Wrapper_Cancel_ArtilleryTeam, 0 ) );
GetPopup()->addOption( *pOption );
// certain traits have skills whose effects depend on wether someone is near to us (squadleader, commissar). We therefore display our radius of effect while this display is open
SetTraitToDisplay(RADIO_OPERATOR_NT);
SetGridNoForTraitDisplay(sTraitsMenuTargetGridNo);
ToggleTraitRangeView(TRUE);
}
// same y, different x
SetPos(gArtillerySector.GetMaxPosX(), usTraitMenuPosY);
}
/////////////////////////////// Artillery Sector Selection ////////////////////////////////////////////
void
ArtillerySector::Setup( UINT32 aVal )
{
Destroy();
SOLDIERTYPE * pSoldier = NULL;
GetSoldier( &pSoldier, gusSelectedSoldier );
if ( pSoldier == NULL )
return;
if ( pSoldier->CanUseSkill(SKILLS_RADIO_ARTILLERY) )
{
SetupPopup("ArtillerySector");
POPUP_OPTION *pOption;
CHAR16 pStr[300];
// check wether we can call artillery from the 4 adjacent sectors
for (UINT8 i = 0; i < 4; ++i)
{
INT16 loopX = pSoldier->sSectorX;
INT16 loopY = pSoldier->sSectorY;
if ( i == 0 ) ++loopY;
else if ( i == 1 ) ++loopX;
else if ( i == 2 ) --loopY;
else if ( i == 3 ) --loopX;
if ( loopX < 1 || loopX >= MAP_WORLD_X - 1 || loopY < 1 || loopY >= MAP_WORLD_Y - 1 )
continue;
UINT32 sectornr = (UINT32)SECTOR( loopX, loopY );
swprintf( pStr, L"%c%d", loopY + 'A' - 1, loopX );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void, UINT32>( &Wrapper_Setup_ArtilleryTeam, sectornr ) );
// grey out if no artillery can be called from this sector
if ( !IsValidArtilleryOrderSector( loopX, loopY, pSoldier->bSectorZ, pSoldier->bTeam ) && !IsValidArtilleryOrderSector( loopX, loopY, pSoldier->bSectorZ, MILITIA_TEAM ) )
{
// Set this option off.
pOption->setAvail(new popupCallbackFunction<bool,void*>( &Popup_OptionOff, NULL ));
}
GetPopup()->addOption( *pOption );
}
// cancel option
swprintf( pStr, pSkillMenuStrings[SKILLMENU_CANCEL] );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &Wrapper_Cancel_ArtillerySector, 0 ) );
GetPopup()->addOption( *pOption );
// certain traits have skills whose effects depend on wether someone is near to us (squadleader, commissar). We therefore display our radius of effect while this display is open
SetTraitToDisplay(RADIO_OPERATOR_NT);
SetGridNoForTraitDisplay(sTraitsMenuTargetGridNo);
ToggleTraitRangeView(TRUE);
}
// same y, different x
SetPos(gSkillSelection.GetMaxPosX(), usTraitMenuPosY);
}
void CalculateMines()
{
INT32 ubX, ubY, ubZ;
SOLDIERTYPE* pSoldier;
RemoveMinesObjectsFromViewArea();
if( gubDrawModeMine == MINES_DRAW_OFF )
{
return;
}
if( gusSelectedSoldier == NOBODY )
{
return;
}
// at we're here, we want to display mines, so remove the cover display
if ( gubDrawMode != COVER_DRAW_OFF )
RemoveCoverObjectsFromViewArea();
GetSoldier( &pSoldier, gusSelectedSoldier );
// if we want to detect hostile mines and we have an metal detector in our hands, allow seeking
BOOLEAN fWithMineDetector = FALSE;
if ( pSoldier && gubDrawModeMine == MINES_DRAW_DETECT_ENEMY )
{
if ( FindMetalDetectorInHand(pSoldier) != NO_SLOT )
fWithMineDetector = TRUE;
// TODO: perhaps even consume batteries one day...
}
// if we are looking for mines via mine detector, but don't have one equipped, return, we won't detect anything
if ( gubDrawModeMine == MINES_DRAW_DETECT_ENEMY && !fWithMineDetector )
{
return;
}
const INT32& sSelectedSoldierGridNo = MercPtrs[ gusSelectedSoldier ]->sGridNo;
INT16 usTmp;
GetScreenXYWorldCell( gsVIEWPORT_START_X, gsVIEWPORT_START_Y, &gsMineMinCellX, &usTmp );
GetScreenXYWorldCell( gsVIEWPORT_END_X, gsVIEWPORT_END_Y, &gsMineMaxCellX, &usTmp );
GetScreenXYWorldCell( gsVIEWPORT_END_X, gsVIEWPORT_START_Y, &usTmp, &gsMineMinCellY );
GetScreenXYWorldCell( gsVIEWPORT_START_X, gsVIEWPORT_END_Y, &usTmp, &gsMineMaxCellY );
for ( ubX=gsMineMinCellX; ubX<=gsMineMaxCellX; ++ubX )
{
for ( ubY=gsMineMinCellY; ubY<=gsMineMaxCellY; ++ubY )
{
for ( ubZ=0; ubZ<COVER_Z_CELLS; ++ubZ )
{
INT32& sGridNo = gCoverViewArea[ ubX ][ ubY ][ ubZ ].sGridNo;
GetGridNoForViewPort( ubX, ubY, sGridNo );
if( !GridNoOnScreenAndAround( sGridNo, 2 ) )
{
continue;
}
if ( IsTheRoofVisible( sGridNo ) )
{
if ( ubZ == I_GROUND_LEVEL )
continue;
}
else if ( ubZ == I_ROOF_LEVEL )
{
continue;
}
// if we are looking for hostile mines, but the tile is out of our' detectors range, skip looking for mines
if ( gubDrawModeMine == MINES_DRAW_DETECT_ENEMY && fWithMineDetector )
{
if ( PythSpacesAway(sSelectedSoldierGridNo, sGridNo) > 4 )
continue;
}
if ( !NewOKDestination( pSoldier, sGridNo, false, (INT8) ubZ ) )
{
continue;
}
INT8& bMines = gCoverViewArea[ ubX ][ ubY ][ ubZ ].bMines;
bMines = MAX_MINES;
DetermineMineDisplayInTile( sGridNo, ubZ, bMines, fWithMineDetector );
}
}
}
AddMinesObjectsToViewArea();
}
/////////////////////////////// Skill Selection ////////////////////////////////////////////
void
SkillSelection::Setup( UINT32 aVal )
{
Destroy();
SOLDIERTYPE * pSoldier = NULL;
GetSoldier( &pSoldier, gusSelectedSoldier );
if ( pSoldier == NULL )
return;
if ( HAS_SKILL_TRAIT(pSoldier, aVal) )
{
SetupPopup("SkillSelection");
POPUP_OPTION *pOption;
CHAR16 pStr[300];
SetTraitToDisplay(aVal);
SetGridNoForTraitDisplay(sTraitsMenuTargetGridNo);
// this switch isn't really necessary. But dividing the skills into menus for each trait gives a better overview, and looks way better than a huge list
switch ( aVal )
{
case RADIO_OPERATOR_NT:
{
for(UINT32 uiCounter = SKILLS_RADIO_FIRST; uiCounter <= SKILLS_RADIO_LAST; ++uiCounter)
{
swprintf( pStr, pTraitSkillsMenuStrings[uiCounter] );
if ( uiCounter == SKILLS_RADIO_ARTILLERY)
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &Wrapper_Setup_ArtillerySector, uiCounter ) );
else if ( uiCounter == SKILLS_RADIO_CALLREINFORCEMENTS)
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &Wrapper_Setup_ReinforcementSector, uiCounter ) );
else
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &Wrapper_Function_SkillSelection, uiCounter ) );
// if we cannot perform this skill, grey it out
if ( !(pSoldier->CanUseSkill(uiCounter, TRUE)) )
{
// Set this option off.
pOption->setAvail(new popupCallbackFunction<bool,void*>( &Popup_OptionOff, NULL ));
}
GetPopup()->addOption( *pOption );
}
}
break;
case VARIOUSSKILLS:
{
for(UINT32 uiCounter = SKILLS_VARIOUS_FIRST; uiCounter <= SKILLS_VARIOUS_LAST; ++uiCounter)
{
swprintf( pStr, pTraitSkillsMenuStrings[uiCounter] );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &Wrapper_Function_SkillSelection, uiCounter ) );
// if we cannot perform this skill, grey it out
if ( !(pSoldier->CanUseSkill(uiCounter, TRUE)) )
{
// Set this option off.
pOption->setAvail(new popupCallbackFunction<bool,void*>( &Popup_OptionOff, NULL ));
}
GetPopup()->addOption( *pOption );
}
SetTraitToDisplay(VARIOUSSKILLS);
SetGridNoForTraitDisplay(sTraitsMenuTargetGridNo);
ToggleTraitRangeView(TRUE);
}
break;
default:
break;
}
// cancel option
swprintf( pStr, pSkillMenuStrings[SKILLMENU_CANCEL] );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &Wrapper_Cancel_SkillSelection, 0 ) );
GetPopup()->addOption( *pOption );
}
// same y, different x
SetPos(gTraitSelection.GetMaxPosX(), usTraitMenuPosY);
if ( HAS_SKILL_TRAIT(pSoldier, aVal) )
{
UINT8 cnt = 0;
switch ( aVal )
{
case RADIO_OPERATOR_NT:
{
for(UINT32 uiCounter = SKILLS_RADIO_FIRST; uiCounter <= SKILLS_RADIO_LAST; ++uiCounter)
{
SetRegionFastHelpText( &(GetPopup()->MenuRegion[cnt++]), pSoldier->PrintSkillDesc(uiCounter) );
}
}
break;
case VARIOUSSKILLS:
{
for(UINT32 uiCounter = SKILLS_VARIOUS_FIRST; uiCounter <= SKILLS_VARIOUS_LAST; ++uiCounter)
{
SetRegionFastHelpText( &(GetPopup()->MenuRegion[cnt++]), pSoldier->PrintSkillDesc(uiCounter) );
}
}
break;
}
}
}
/////////////////////////////// Trait Selection ////////////////////////////////////////////
void
TraitSelection::Setup( UINT32 aVal )
{
Destroy();
SOLDIERTYPE * pSoldier = NULL;
GetSoldier( &pSoldier, gusSelectedSoldier );
if ( pSoldier == NULL )
return;
SetupPopup("TraitSelection");
POPUP_OPTION *pOption;
CHAR16 pStr[300];
// create entries for the sub-menus for each trait
const UINT8 num = 2;
UINT8 traitarray[num];
traitarray[0] = RADIO_OPERATOR_NT;
traitarray[1] = VARIOUSSKILLS;
for ( int i = 0; i < num; ++i)
{
swprintf( pStr, gzMercSkillTextNew[traitarray[i]] );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &Wrapper_Setup_SkillSelection, traitarray[i] ) );
// if we cannot perform this skill, grey it out
if ( !HAS_SKILL_TRAIT(pSoldier, traitarray[i]) )
{
// Set this option off.
pOption->setAvail(new popupCallbackFunction<bool,void*>( &Popup_OptionOff, NULL ));
}
GetPopup()->addOption( *pOption );
}
// cancel option
swprintf( pStr, pSkillMenuStrings[SKILLMENU_CANCEL] );
pOption = new POPUP_OPTION(&std::wstring( pStr ), new popupCallbackFunction<void,UINT32>( &Wrapper_Cancel_TraitSelection, 0 ) );
GetPopup()->addOption( *pOption );
// grab soldier's x,y screen position
INT16 sX, sY;
// sevenfm: changed TraitsMenu position from soldier to mouse
//GetSoldierScreenPos( pSoldier, &sX, &sY );
GetGridNoScreenPos( sTraitsMenuTargetGridNo, gsInterfaceLevel, &sX, &sY );
if( sX < 0 ) sX = 0;
if( sY < 0 ) sY = 0;
usTraitMenuPosX = sX + 30;
usTraitMenuPosY = sY;
if ( ( usTraitMenuPosX + 400 ) > SCREEN_WIDTH )
usTraitMenuPosX = SCREEN_WIDTH - 400;
if ( ( usTraitMenuPosY + 130 ) > SCREEN_HEIGHT )
usTraitMenuPosY = SCREEN_HEIGHT - 190;
SetPos(usTraitMenuPosX, usTraitMenuPosY);
}
BOOLEAN AddUIPlan( UINT16 sGridNo, UINT8 ubPlanID )
{
SOLDIERTYPE *pPlanSoldier;
INT16 sXPos, sYPos;
INT16 sAPCost = 0;
INT8 bDirection;
INT32 iLoop;
SOLDIERCREATE_STRUCT MercCreateStruct;
UINT8 ubNewIndex;
// Depeding on stance and direction facing, add guy!
// If we have a planned action here, ignore!
// If not OK Dest, ignore!
if ( !NewOKDestination( gpUIPlannedSoldier, sGridNo, FALSE, (INT8)gsInterfaceLevel ) )
{
return( FALSE );
}
if ( ubPlanID == UIPLAN_ACTION_MOVETO )
{
// Calculate cost to move here
sAPCost = PlotPath( gpUIPlannedSoldier, sGridNo, COPYROUTE, NO_PLOT, TEMPORARY, (UINT16) gpUIPlannedSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, gpUIPlannedSoldier->bActionPoints );
// Adjust for running if we are not already running
if ( gpUIPlannedSoldier->usUIMovementMode == RUNNING )
{
sAPCost += AP_START_RUN_COST;
}
if ( EnoughPoints( gpUIPlannedSoldier, sAPCost, 0, FALSE ) )
{
memset( &MercCreateStruct, 0, sizeof( MercCreateStruct ) );
MercCreateStruct.bTeam = SOLDIER_CREATE_AUTO_TEAM;
MercCreateStruct.ubProfile = NO_PROFILE;
MercCreateStruct.fPlayerPlan = TRUE;
MercCreateStruct.bBodyType = gpUIPlannedSoldier->ubBodyType;
MercCreateStruct.sInsertionGridNo = sGridNo;
// Get Grid Corrdinates of mouse
if ( TacticalCreateSoldier( &MercCreateStruct, &ubNewIndex ) )
{
// Get pointer to soldier
GetSoldier( &pPlanSoldier, (UINT16)ubNewIndex );
pPlanSoldier->sPlannedTargetX = -1;
pPlanSoldier->sPlannedTargetY = -1;
// Compare OPPLISTS!
// Set ones we don't know about but do now back to old ( ie no new guys )
for (iLoop = 0; iLoop < MAX_NUM_SOLDIERS; iLoop++ )
{
if ( gpUIPlannedSoldier->bOppList[ iLoop ] < 0 )
{
pPlanSoldier->bOppList[ iLoop ] = gpUIPlannedSoldier->bOppList[ iLoop ];
}
}
// Get XY from Gridno
ConvertGridNoToCenterCellXY( sGridNo, &sXPos, &sYPos );
EVENT_SetSoldierPosition( pPlanSoldier, sXPos, sYPos );
EVENT_SetSoldierDestination( pPlanSoldier, sGridNo );
pPlanSoldier->bVisible = 1;
pPlanSoldier->usUIMovementMode = gpUIPlannedSoldier->usUIMovementMode;
pPlanSoldier->bActionPoints = gpUIPlannedSoldier->bActionPoints - sAPCost;
pPlanSoldier->ubPlannedUIAPCost = (UINT8)pPlanSoldier->bActionPoints;
// Get direction
bDirection = (INT8)gpUIPlannedSoldier->usPathingData[ gpUIPlannedSoldier->usPathDataSize - 1 ];
// Set direction
pPlanSoldier->bDirection = bDirection;
pPlanSoldier->bDesiredDirection = bDirection;
// Set walking animation
ChangeSoldierState( pPlanSoldier, pPlanSoldier->usUIMovementMode, 0, FALSE );
// Change selected soldier
gusSelectedSoldier = (UINT16)pPlanSoldier->ubID;
// Change global planned mode to this guy!
gpUIPlannedSoldier = pPlanSoldier;
gubNumUIPlannedMoves++;
gfPlotNewMovement = TRUE;
ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, L"Adding Merc Move to Plan" );
}
}
else
{
ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, L"Merc will not have enough action points" );
}
}
else if ( ubPlanID == UIPLAN_ACTION_FIRE )
{
sAPCost = CalcTotalAPsToAttack( gpUIPlannedSoldier, sGridNo, TRUE, (INT8)(gpUIPlannedSoldier->bShownAimTime /2) );
// Get XY from Gridno
ConvertGridNoToCenterCellXY( sGridNo, &sXPos, &sYPos );
// If this is a player guy, show message about no APS
if ( EnoughPoints( gpUIPlannedSoldier, sAPCost, 0, FALSE ) )
{
// CHECK IF WE ARE A PLANNED SOLDIER OR NOT< IF SO< CREATE!
if ( gpUIPlannedSoldier->ubID < MAX_NUM_SOLDIERS )
{
memset( &MercCreateStruct, 0, sizeof( MercCreateStruct ) );
MercCreateStruct.bTeam = SOLDIER_CREATE_AUTO_TEAM;
MercCreateStruct.ubProfile = NO_PROFILE;
MercCreateStruct.fPlayerPlan = TRUE;
MercCreateStruct.bBodyType = gpUIPlannedSoldier->ubBodyType;
MercCreateStruct.sInsertionGridNo = sGridNo;
// Get Grid Corrdinates of mouse
if ( TacticalCreateSoldier( &MercCreateStruct, &ubNewIndex ) )
{
// Get pointer to soldier
GetSoldier( &pPlanSoldier, (UINT16)ubNewIndex );
pPlanSoldier->sPlannedTargetX = -1;
pPlanSoldier->sPlannedTargetY = -1;
// Compare OPPLISTS!
// Set ones we don't know about but do now back to old ( ie no new guys )
for (iLoop = 0; iLoop < MAX_NUM_SOLDIERS; iLoop++ )
{
if ( gpUIPlannedSoldier->bOppList[ iLoop ] < 0 )
{
pPlanSoldier->bOppList[ iLoop ] = gpUIPlannedSoldier->bOppList[ iLoop ];
}
}
EVENT_SetSoldierPosition( pPlanSoldier, gpUIPlannedSoldier->dXPos, gpUIPlannedSoldier->dYPos );
EVENT_SetSoldierDestination( pPlanSoldier, gpUIPlannedSoldier->sGridNo );
pPlanSoldier->bVisible = 1;
pPlanSoldier->usUIMovementMode = gpUIPlannedSoldier->usUIMovementMode;
pPlanSoldier->bActionPoints = gpUIPlannedSoldier->bActionPoints - sAPCost;
pPlanSoldier->ubPlannedUIAPCost = (UINT8)pPlanSoldier->bActionPoints;
// Get direction
bDirection = (INT8)gpUIPlannedSoldier->usPathingData[ gpUIPlannedSoldier->usPathDataSize - 1 ];
// Set direction
pPlanSoldier->bDirection = bDirection;
pPlanSoldier->bDesiredDirection = bDirection;
// Set walking animation
ChangeSoldierState( pPlanSoldier, pPlanSoldier->usUIMovementMode, 0, FALSE );
// Change selected soldier
gusSelectedSoldier = (UINT16)pPlanSoldier->ubID;
// Change global planned mode to this guy!
gpUIPlannedSoldier = pPlanSoldier;
gubNumUIPlannedMoves++;
}
}
gpUIPlannedSoldier->bActionPoints = gpUIPlannedSoldier->bActionPoints - sAPCost;
gpUIPlannedSoldier->ubPlannedUIAPCost = (UINT8)gpUIPlannedSoldier->bActionPoints;
// Get direction from gridno
bDirection = (INT8)GetDirectionFromGridNo( sGridNo, gpUIPlannedSoldier );
// Set direction
gpUIPlannedSoldier->bDirection = bDirection;
gpUIPlannedSoldier->bDesiredDirection = bDirection;
// Set to shooting animation
SelectPausedFireAnimation( gpUIPlannedSoldier );
gpUIPlannedSoldier->sPlannedTargetX = sXPos;
gpUIPlannedSoldier->sPlannedTargetY = sYPos;
ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, L"Adding Merc Shoot to Plan" );
}
else
{
ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, L"Merc will not have enough action points" );
}
}
return( TRUE );
}