1dot13/source
1
0
Fork 0
mirror of https://github.com/1dot13/source.git synced 2026-08-05 14:00:23 +02:00
Code Issues Packages Projects Releases Wiki Activity

deleted unnecessary code duplication: several NCTH-related functions have been unified an now take scope modes into account

Browse Source 
git-svn-id: https://ja2svn.mooo.com/source/ja2/trunk/GameSource/ja2_v1.13/Build@6692 3b4a5df2-a311-0410-b5c6-a8a6f20db521
This commit is contained in:
Flugente
2013-12-17 20:18:44 +00:00
parent f8a0a5eb2c
commit a7522989ab
6 changed files with 237 additions and 416 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Tactical/Interface Enhanced.cpp
+107 -107
View File
@@ -2747,9 +2747,9 @@ void InternalInitEDBTooltipRegion( OBJECTTYPE * gpItemDescObject, UINT32 guiCurr
}
}
///////////////////// FLAT BASE MODIFIER
if (GetFlatBaseModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetFlatBaseModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetFlatBaseModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_FLATBASE ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_FLATBASE ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_FLATBASE ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -2771,9 +2771,9 @@ void InternalInitEDBTooltipRegion( OBJECTTYPE * gpItemDescObject, UINT32 guiCurr
}
///////////////////// PERCENT BASE MODIFIER
if (GetPercentBaseModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetPercentBaseModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetPercentBaseModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_PERCENTBASE ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_PERCENTBASE ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_PERCENTBASE ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -2795,9 +2795,9 @@ void InternalInitEDBTooltipRegion( OBJECTTYPE * gpItemDescObject, UINT32 guiCurr
}
///////////////////// FLAT AIM MODIFIER
if (GetFlatAimModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetFlatAimModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetFlatAimModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_FLATAIM ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_FLATAIM ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_FLATAIM ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -2819,9 +2819,9 @@ void InternalInitEDBTooltipRegion( OBJECTTYPE * gpItemDescObject, UINT32 guiCurr
}
///////////////////// PERCENT AIM MODIFIER
if (GetPercentAimModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetPercentAimModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetPercentAimModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_PERCENTAIM ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_PERCENTAIM ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_PERCENTAIM ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -2843,9 +2843,9 @@ void InternalInitEDBTooltipRegion( OBJECTTYPE * gpItemDescObject, UINT32 guiCurr
}
///////////////////// AIMING LEVELS MODIFIER
if (GetAimLevelsModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND ) != 0
|| GetAimLevelsModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH ) != 0
|| GetAimLevelsModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_AIMLEVELS ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_AIMLEVELS ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_AIMLEVELS ) != 0 )
{
if (cnt >= sFirstLine && cnt < sLastLine)
{
@@ -2921,9 +2921,9 @@ void InternalInitEDBTooltipRegion( OBJECTTYPE * gpItemDescObject, UINT32 guiCurr
}
///////////////////// CTH CAP MODIFIER
if (GetPercentCapModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetPercentCapModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetPercentCapModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_PERCENTCAP ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_PERCENTCAP ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_PERCENTCAP ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -2945,9 +2945,9 @@ void InternalInitEDBTooltipRegion( OBJECTTYPE * gpItemDescObject, UINT32 guiCurr
}
///////////////////// GUN HANDLING MODIFIER
if (GetPercentHandlingModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetPercentHandlingModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetPercentHandlingModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_PERCENTHANDLING ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_PERCENTHANDLING ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_PERCENTHANDLING ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -2969,9 +2969,9 @@ void InternalInitEDBTooltipRegion( OBJECTTYPE * gpItemDescObject, UINT32 guiCurr
}
///////////////////// DROP COMPENSATION MODIFIER
if (GetDropCompensationModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetDropCompensationModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetDropCompensationModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_DROPCOMPENSATION ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_DROPCOMPENSATION ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_DROPCOMPENSATION ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -2993,9 +2993,9 @@ void InternalInitEDBTooltipRegion( OBJECTTYPE * gpItemDescObject, UINT32 guiCurr
}
///////////////////// TARGET TRACKING MODIFIER
if (GetTargetTrackingModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetTargetTrackingModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetTargetTrackingModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_TRACKING ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_TRACKING ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_TRACKING ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -3246,9 +3246,9 @@ void InternalInitEDBTooltipRegion( OBJECTTYPE * gpItemDescObject, UINT32 guiCurr
}
///////////////////// MAX COUNTER FORCE MODIFIER
if ((GetCounterForceMaxModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetCounterForceMaxModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetCounterForceMaxModifier( gpItemDescObject, ANIM_PRONE ) != 0 ) )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_COUNTERFORCEMAX ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_COUNTERFORCEMAX ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_COUNTERFORCEMAX ) != 0 )
{
if( UsingNewCTHSystem() == true && Item[gpItemDescObject->usItem].usItemClass == IC_GUN )
{
@@ -3270,9 +3270,9 @@ void InternalInitEDBTooltipRegion( OBJECTTYPE * gpItemDescObject, UINT32 guiCurr
}
///////////////////// COUNTER FORCE ACCURACY MODIFIER
if (GetCounterForceAccuracyModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetCounterForceAccuracyModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetCounterForceAccuracyModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_COUNTERFORCEACCURACY ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_COUNTERFORCEACCURACY ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_COUNTERFORCEACCURACY ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -4852,9 +4852,9 @@ void DrawAdvancedStats( OBJECTTYPE * gpItemDescObject )
}
///////////////////// FLAT BASE MODIFIER
if (GetFlatBaseModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetFlatBaseModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetFlatBaseModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_FLATBASE ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_FLATBASE ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_FLATBASE ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -4867,9 +4867,9 @@ void DrawAdvancedStats( OBJECTTYPE * gpItemDescObject )
}
///////////////////// PERCENT BASE MODIFIER
if (GetPercentBaseModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetPercentBaseModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetPercentBaseModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_PERCENTBASE ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_PERCENTBASE ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_PERCENTBASE ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -4882,9 +4882,9 @@ void DrawAdvancedStats( OBJECTTYPE * gpItemDescObject )
}
///////////////////// FLAT AIM MODIFIER
if (GetFlatAimModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetFlatAimModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetFlatAimModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_FLATAIM ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_FLATAIM ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_FLATAIM ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -4897,9 +4897,9 @@ void DrawAdvancedStats( OBJECTTYPE * gpItemDescObject )
}
///////////////////// PERCENT AIM MODIFIER
if (GetPercentAimModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetPercentAimModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetPercentAimModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_PERCENTAIM ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_PERCENTAIM ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_PERCENTAIM ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -4912,9 +4912,9 @@ void DrawAdvancedStats( OBJECTTYPE * gpItemDescObject )
}
///////////////////// AIMING LEVELS MODIFIER
if (GetAimLevelsModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND ) != 0
|| GetAimLevelsModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH ) != 0
|| GetAimLevelsModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_AIMLEVELS ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_AIMLEVELS ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_AIMLEVELS ) != 0 )
{
if (cnt >= sFirstLine && cnt < sLastLine)
{
@@ -4951,9 +4951,9 @@ void DrawAdvancedStats( OBJECTTYPE * gpItemDescObject )
}
///////////////////// CTH CAP MODIFIER
if (GetPercentCapModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetPercentCapModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetPercentCapModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_PERCENTCAP ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_PERCENTCAP ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_PERCENTCAP ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -4966,9 +4966,9 @@ void DrawAdvancedStats( OBJECTTYPE * gpItemDescObject )
}
///////////////////// GUN HANDLING MODIFIER
if (GetPercentHandlingModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetPercentHandlingModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetPercentHandlingModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_PERCENTHANDLING ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_PERCENTHANDLING ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_PERCENTHANDLING ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -4981,9 +4981,9 @@ void DrawAdvancedStats( OBJECTTYPE * gpItemDescObject )
}
///////////////////// DROP COMPENSATION MODIFIER
if (GetDropCompensationModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetDropCompensationModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetDropCompensationModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_DROPCOMPENSATION ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_DROPCOMPENSATION ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_DROPCOMPENSATION ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -4995,9 +4995,9 @@ void DrawAdvancedStats( OBJECTTYPE * gpItemDescObject )
}
}
///////////////////// TARGET TRACKING MODIFIER
if (GetTargetTrackingModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetTargetTrackingModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetTargetTrackingModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_TRACKING ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_TRACKING ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_TRACKING ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -5128,9 +5128,9 @@ void DrawAdvancedStats( OBJECTTYPE * gpItemDescObject )
}
///////////////////// MAX COUNTER FORCE MODIFIER
if (GetCounterForceMaxModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetCounterForceMaxModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetCounterForceMaxModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_COUNTERFORCEMAX ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_COUNTERFORCEMAX ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_COUNTERFORCEMAX ) != 0 )
{
if( UsingNewCTHSystem() == true && Item[gpItemDescObject->usItem].usItemClass == IC_GUN )
{
@@ -5143,9 +5143,9 @@ void DrawAdvancedStats( OBJECTTYPE * gpItemDescObject )
}
///////////////////// COUNTER FORCE ACCURACY MODIFIER
if (GetCounterForceAccuracyModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetCounterForceAccuracyModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetCounterForceAccuracyModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_COUNTERFORCEACCURACY ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_COUNTERFORCEACCURACY ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_COUNTERFORCEACCURACY ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -5158,9 +5158,9 @@ void DrawAdvancedStats( OBJECTTYPE * gpItemDescObject )
}
///////////////////// COUNTER FORCE FREQUENCY MODIFIER
if (GetCounterForceFrequencyModifier( gpItemDescObject, ANIM_STAND ) != 0
|| GetCounterForceFrequencyModifier( gpItemDescObject, ANIM_CROUCH ) != 0
|| GetCounterForceFrequencyModifier( gpItemDescObject, ANIM_PRONE ) != 0 )
if ( GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_COUNTERFORCEFREQUENCY ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_COUNTERFORCEFREQUENCY ) != 0
|| GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_COUNTERFORCEFREQUENCY ) != 0 )
{
if( UsingNewCTHSystem() == true )
{
@@ -6265,7 +6265,7 @@ void DrawWeaponValues( OBJECTTYPE * gpItemDescObject )
iHandlingValue *= gItemSettings.fHandlingModifierLauncher;
// Get modifier
INT16 iHandlingModifier = (iHandlingValue * GetPercentHandlingModifier( gpItemDescObject , ANIM_STAND )) / 100;
INT16 iHandlingModifier = (iHandlingValue * GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject , ANIM_STAND, NCTHMODIFIER_PERCENTHANDLING )) / 100;
// Get Final Gun Handling value
UINT16 iFinalHandlingValue = iHandlingValue + iHandlingModifier;
@@ -6338,7 +6338,7 @@ void DrawWeaponValues( OBJECTTYPE * gpItemDescObject )
UINT16 iFinalAimLevelsValue = GetAllowedAimingLevelsForItem( gpItemDescSoldier, gpItemDescObject, ANIM_STAND );
// Get modifier
INT16 iAimLevelsModifier = GetAimLevelsModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND );
INT16 iAimLevelsModifier = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_AIMLEVELS );
iAimLevelsModifier += GetAimLevelsTraitModifier( gpItemDescSoldier, gpItemDescObject );
// Get Base Value
@@ -9238,9 +9238,9 @@ void DrawAdvancedValues( OBJECTTYPE *gpItemDescObject )
}
///////////////////// FLAT BASE MODIFIER
iModifier[0] = GetFlatBaseModifier( gpItemDescObject, ANIM_STAND );
iModifier[1] = GetFlatBaseModifier( gpItemDescObject, ANIM_CROUCH );
iModifier[2] = GetFlatBaseModifier( gpItemDescObject, ANIM_PRONE );
iModifier[0] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_FLATBASE );
iModifier[1] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_FLATBASE );
iModifier[2] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_FLATBASE );
if ((iModifier[0] != 0 || iModifier[1] != 0 || iModifier[2] != 0) && UsingNewCTHSystem() == true )
{
if (cnt >= sFirstLine && cnt < sLastLine)
@@ -9279,9 +9279,9 @@ void DrawAdvancedValues( OBJECTTYPE *gpItemDescObject )
}
///////////////////// PERCENT BASE MODIFIER
iModifier[0] = GetPercentBaseModifier( gpItemDescObject, ANIM_STAND );
iModifier[1] = GetPercentBaseModifier( gpItemDescObject, ANIM_CROUCH );
iModifier[2] = GetPercentBaseModifier( gpItemDescObject, ANIM_PRONE );
iModifier[0] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_PERCENTBASE );
iModifier[1] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_PERCENTBASE );
iModifier[2] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_PERCENTBASE );
if ((iModifier[0] != 0 || iModifier[1] != 0 || iModifier[2] != 0) && UsingNewCTHSystem() == true )
{
if (cnt >= sFirstLine && cnt < sLastLine)
@@ -9332,9 +9332,9 @@ void DrawAdvancedValues( OBJECTTYPE *gpItemDescObject )
}
///////////////////// FLAT AIM MODIFIER
iModifier[0] = GetFlatAimModifier( gpItemDescObject, ANIM_STAND );
iModifier[1] = GetFlatAimModifier( gpItemDescObject, ANIM_CROUCH );
iModifier[2] = GetFlatAimModifier( gpItemDescObject, ANIM_PRONE );
iModifier[0] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_FLATAIM );
iModifier[1] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_FLATAIM );
iModifier[2] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_FLATAIM );
if ((iModifier[0] != 0 || iModifier[1] != 0 || iModifier[2] != 0) && UsingNewCTHSystem() == true )
{
if (cnt >= sFirstLine && cnt < sLastLine)
@@ -9373,9 +9373,9 @@ void DrawAdvancedValues( OBJECTTYPE *gpItemDescObject )
}
///////////////////// PERCENT AIM MODIFIER
iModifier[0] = GetPercentAimModifier( gpItemDescObject, ANIM_STAND );
iModifier[1] = GetPercentAimModifier( gpItemDescObject, ANIM_CROUCH );
iModifier[2] = GetPercentAimModifier( gpItemDescObject, ANIM_PRONE );
iModifier[0] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_PERCENTAIM );
iModifier[1] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_PERCENTAIM );
iModifier[2] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_PERCENTAIM );
if ((iModifier[0] != 0 || iModifier[1] != 0 || iModifier[2] != 0) && UsingNewCTHSystem() == true )
{
if (cnt >= sFirstLine && cnt < sLastLine)
@@ -9426,9 +9426,9 @@ void DrawAdvancedValues( OBJECTTYPE *gpItemDescObject )
}
///////////////////// AIMING LEVELS MODIFIER
iModifier[0] = GetAimLevelsModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND );
iModifier[1] = GetAimLevelsModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH );
iModifier[2] = GetAimLevelsModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE );
iModifier[0] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_AIMLEVELS );
iModifier[1] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_AIMLEVELS );
iModifier[2] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_AIMLEVELS );
if (iModifier[0] != 0 || iModifier[1] != 0 || iModifier[2] != 0 )
{
if (cnt >= sFirstLine && cnt < sLastLine)
@@ -9586,9 +9586,9 @@ void DrawAdvancedValues( OBJECTTYPE *gpItemDescObject )
}
///////////////////// CTH CAP MODIFIER
iModifier[0] = GetPercentCapModifier( gpItemDescObject, ANIM_STAND );
iModifier[1] = GetPercentCapModifier( gpItemDescObject, ANIM_CROUCH );
iModifier[2] = GetPercentCapModifier( gpItemDescObject, ANIM_PRONE );
iModifier[0] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_PERCENTCAP );
iModifier[1] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_PERCENTCAP );
iModifier[2] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_PERCENTCAP );
if ((iModifier[0] != 0 || iModifier[1] != 0 || iModifier[2] != 0) && UsingNewCTHSystem() == true )
{
if (cnt >= sFirstLine && cnt < sLastLine)
@@ -9639,9 +9639,9 @@ void DrawAdvancedValues( OBJECTTYPE *gpItemDescObject )
}
///////////////////// GUN HANDLING MODIFIER
iModifier[0] = GetPercentHandlingModifier( gpItemDescObject, ANIM_STAND );
iModifier[1] = GetPercentHandlingModifier( gpItemDescObject, ANIM_CROUCH );
iModifier[2] = GetPercentHandlingModifier( gpItemDescObject, ANIM_PRONE );
iModifier[0] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_PERCENTHANDLING );
iModifier[1] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_PERCENTHANDLING );
iModifier[2] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_PERCENTHANDLING );
if ((iModifier[0] != 0 || iModifier[1] != 0 || iModifier[2] != 0) && UsingNewCTHSystem() == true )
{
if (cnt >= sFirstLine && cnt < sLastLine)
@@ -9692,9 +9692,9 @@ void DrawAdvancedValues( OBJECTTYPE *gpItemDescObject )
}
///////////////////// DROP COMPENSATION MODIFIER
iModifier[0] = GetDropCompensationModifier( gpItemDescObject, ANIM_STAND );
iModifier[1] = GetDropCompensationModifier( gpItemDescObject, ANIM_CROUCH );
iModifier[2] = GetDropCompensationModifier( gpItemDescObject, ANIM_PRONE );
iModifier[0] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_DROPCOMPENSATION );
iModifier[1] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_DROPCOMPENSATION );
iModifier[2] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_DROPCOMPENSATION );
if ((iModifier[0] != 0 || iModifier[1] != 0 || iModifier[2] != 0) && UsingNewCTHSystem() == true )
{
if (cnt >= sFirstLine && cnt < sLastLine)
@@ -9745,9 +9745,9 @@ void DrawAdvancedValues( OBJECTTYPE *gpItemDescObject )
}
///////////////////// TARGET TRACKING MODIFIER
iModifier[0] = GetTargetTrackingModifier( gpItemDescObject, ANIM_STAND );
iModifier[1] = GetTargetTrackingModifier( gpItemDescObject, ANIM_CROUCH );
iModifier[2] = GetTargetTrackingModifier( gpItemDescObject, ANIM_PRONE );
iModifier[0] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_TRACKING );
iModifier[1] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_TRACKING );
iModifier[2] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_TRACKING );
if ((iModifier[0] != 0 || iModifier[1] != 0 || iModifier[2] != 0) && UsingNewCTHSystem() == true )
{
if (cnt >= sFirstLine && cnt < sLastLine)
@@ -10199,9 +10199,9 @@ void DrawAdvancedValues( OBJECTTYPE *gpItemDescObject )
}
///////////////////// MAX COUNTER FORCE MODIFIER
iModifier[0] = GetCounterForceMaxModifier( gpItemDescObject, ANIM_STAND );
iModifier[1] = GetCounterForceMaxModifier( gpItemDescObject, ANIM_CROUCH );
iModifier[2] = GetCounterForceMaxModifier( gpItemDescObject, ANIM_PRONE );
iModifier[0] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_COUNTERFORCEMAX );
iModifier[1] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_COUNTERFORCEMAX );
iModifier[2] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_COUNTERFORCEMAX );
if ((iModifier[0] != 0 || iModifier[1] != 0 || iModifier[2] != 0) && UsingNewCTHSystem() == true && Item[gpItemDescObject->usItem].usItemClass == IC_GUN )
{
if (cnt >= sFirstLine && cnt < sLastLine)
@@ -10252,9 +10252,9 @@ void DrawAdvancedValues( OBJECTTYPE *gpItemDescObject )
}
///////////////////// COUNTER FORCE ACCURACY MODIFIER
iModifier[0] = GetCounterForceAccuracyModifier( gpItemDescObject, ANIM_STAND );
iModifier[1] = GetCounterForceAccuracyModifier( gpItemDescObject, ANIM_CROUCH );
iModifier[2] = GetCounterForceAccuracyModifier( gpItemDescObject, ANIM_PRONE );
iModifier[0] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_COUNTERFORCEACCURACY );
iModifier[1] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_COUNTERFORCEACCURACY );
iModifier[2] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_COUNTERFORCEACCURACY );
if ((iModifier[0] != 0 || iModifier[1] != 0 || iModifier[2] != 0) && UsingNewCTHSystem() == true )
{
if (cnt >= sFirstLine && cnt < sLastLine)
@@ -10305,9 +10305,9 @@ void DrawAdvancedValues( OBJECTTYPE *gpItemDescObject )
}
///////////////////// COUNTER FORCE FREQUENCY MODIFIER
iModifier[0] = GetCounterForceFrequencyModifier( gpItemDescObject, ANIM_STAND );
iModifier[1] = GetCounterForceFrequencyModifier( gpItemDescObject, ANIM_CROUCH );
iModifier[2] = GetCounterForceFrequencyModifier( gpItemDescObject, ANIM_PRONE );
iModifier[0] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_STAND, NCTHMODIFIER_COUNTERFORCEFREQUENCY );
iModifier[1] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_CROUCH, NCTHMODIFIER_COUNTERFORCEFREQUENCY );
iModifier[2] = GetObjectNCTHModifier( gpItemDescSoldier, gpItemDescObject, ANIM_PRONE, NCTHMODIFIER_COUNTERFORCEFREQUENCY );
if ((iModifier[0] != 0 || iModifier[1] != 0 || iModifier[2] != 0) && UsingNewCTHSystem() == true )
{
if (cnt >= sFirstLine && cnt < sLastLine)
Tactical/Items.cpp
+70 -258
View File
@@ -10178,243 +10178,62 @@ INT16 GetToHitBonus( OBJECTTYPE * pObj, INT32 iRange, UINT8 bLightLevel, BOOLEAN
// attachments. They are stance-based, meaning that the soldier's stance determines which modifier is referenced.
// For a "default" value, feed the function a value of ubStance=ANIM_STAND.
INT32 GetFlatBaseModifier( OBJECTTYPE *pObj, UINT8 ubStance )
INT32 GetItemNCTHModifier(OBJECTTYPE* pObj, UINT8 ubRef, UINT8 usType)
{
INT32 iModifier=0;
INT32 iModifier = 0;
UINT8 ubRef = GetStanceModifierRef( ubStance );
if (pObj->exists() == true && UsingNewCTHSystem() == true)
switch( usType )
{
iModifier += Item[pObj->usItem].flatbasemodifier[ubRef];
for (attachmentList::iterator iter = (*pObj)[0]->attachments.begin(); iter != (*pObj)[0]->attachments.end(); ++iter)
{
if (iter->exists())
{
iModifier += BonusReduceMore( Item[iter->usItem].flatbasemodifier[ubRef], (*iter)[0]->data.objectStatus );
}
}
}
return (iModifier);
}
case NCTHMODIFIER_FLATBASE:
iModifier += BonusReduceMore( Item[pObj->usItem].flatbasemodifier[ubRef], (*pObj)[0]->data.objectStatus );
break;
case NCTHMODIFIER_PERCENTBASE:
iModifier += BonusReduceMore( Item[pObj->usItem].percentbasemodifier[ubRef], (*pObj)[0]->data.objectStatus );
break;
case NCTHMODIFIER_FLATAIM:
iModifier += BonusReduceMore( Item[pObj->usItem].flataimmodifier[ubRef], (*pObj)[0]->data.objectStatus );
break;
case NCTHMODIFIER_PERCENTAIM:
iModifier += BonusReduceMore( Item[pObj->usItem].percentaimmodifier[ubRef], (*pObj)[0]->data.objectStatus );
break;
case NCTHMODIFIER_PERCENTCAP:
iModifier += BonusReduceMore( Item[pObj->usItem].percentcapmodifier[ubRef], (*pObj)[0]->data.objectStatus );
break;
case NCTHMODIFIER_PERCENTHANDLING:
iModifier += BonusReduceMore( Item[pObj->usItem].percenthandlingmodifier[ubRef], (*pObj)[0]->data.objectStatus );
break;
case NCTHMODIFIER_DROPCOMPENSATION:
iModifier += BonusReduceMore( Item[pObj->usItem].percentdropcompensationmodifier[ubRef], (*pObj)[0]->data.objectStatus );
break;
case NCTHMODIFIER_COUNTERFORCEMAX:
iModifier += BonusReduceMore( Item[pObj->usItem].maxcounterforcemodifier[ubRef], (*pObj)[0]->data.objectStatus );
INT32 GetPercentBaseModifier( OBJECTTYPE *pObj, UINT8 ubStance )
{
INT32 iModifier=0;
if(ubRef == 1)
iModifier += (INT32)gGameCTHConstants.RECOIL_MAX_COUNTER_CROUCH;
else if (ubRef == 2)
iModifier += (INT32)gGameCTHConstants.RECOIL_MAX_COUNTER_PRONE;
UINT8 ubRef = GetStanceModifierRef( ubStance );
if (pObj->exists() == true && UsingNewCTHSystem() == true)
{
iModifier += Item[pObj->usItem].percentbasemodifier[ubRef];
for (attachmentList::iterator iter = (*pObj)[0]->attachments.begin(); iter != (*pObj)[0]->attachments.end(); ++iter)
{
if (iter->exists())
{
iModifier += BonusReduceMore( Item[iter->usItem].percentbasemodifier[ubRef], (*iter)[0]->data.objectStatus );
}
}
}
iModifier = __max(-100,iModifier);
return (iModifier);
}
INT32 GetFlatAimModifier( OBJECTTYPE *pObj, UINT8 ubStance )
{
INT32 iModifier=0;
UINT8 ubRef = GetStanceModifierRef( ubStance );
if (pObj->exists() == true && UsingNewCTHSystem() == true)
{
iModifier += Item[pObj->usItem].flataimmodifier[ubRef];
for (attachmentList::iterator iter = (*pObj)[0]->attachments.begin(); iter != (*pObj)[0]->attachments.end(); ++iter)
{
if (iter->exists())
{
iModifier += BonusReduceMore( Item[iter->usItem].flataimmodifier[ubRef], (*iter)[0]->data.objectStatus );
}
}
}
return (iModifier);
}
INT32 GetPercentAimModifier( OBJECTTYPE *pObj, UINT8 ubStance )
{
INT32 iModifier=0;
UINT8 ubRef = GetStanceModifierRef( ubStance );
if (pObj->exists() == true && UsingNewCTHSystem() == true)
{
iModifier += Item[pObj->usItem].percentaimmodifier[ubRef];
for (attachmentList::iterator iter = (*pObj)[0]->attachments.begin(); iter != (*pObj)[0]->attachments.end(); ++iter)
{
if (iter->exists())
{
iModifier += BonusReduceMore( Item[iter->usItem].percentaimmodifier[ubRef], (*iter)[0]->data.objectStatus );
}
}
}
iModifier = __max(-100,iModifier);
return (iModifier);
}
INT32 GetPercentCapModifier( OBJECTTYPE *pObj, UINT8 ubStance )
{
INT32 iModifier=0;
UINT8 ubRef = GetStanceModifierRef( ubStance );
if (pObj->exists() == true && UsingNewCTHSystem() == true)
{
iModifier += Item[pObj->usItem].percentcapmodifier[ubRef];
for (attachmentList::iterator iter = (*pObj)[0]->attachments.begin(); iter != (*pObj)[0]->attachments.end(); ++iter)
{
if (iter->exists())
{
iModifier += BonusReduceMore( Item[iter->usItem].percentcapmodifier[ubRef], (*iter)[0]->data.objectStatus );
}
}
}
iModifier = __max(-100,iModifier);
return (iModifier);
}
INT32 GetPercentHandlingModifier( OBJECTTYPE *pObj, UINT8 ubStance )
{
INT32 iModifier=0;
UINT8 ubRef = GetStanceModifierRef( ubStance );
if (pObj->exists() == true && UsingNewCTHSystem() == true)
{
iModifier += Item[pObj->usItem].percenthandlingmodifier[ubRef];
for (attachmentList::iterator iter = (*pObj)[0]->attachments.begin(); iter != (*pObj)[0]->attachments.end(); ++iter)
{
if (iter->exists())
{
iModifier += BonusReduceMore( Item[iter->usItem].percenthandlingmodifier[ubRef], (*iter)[0]->data.objectStatus );
}
}
}
iModifier = __max(-100,iModifier);
return ((UINT32)iModifier);
}
INT32 GetDropCompensationModifier( OBJECTTYPE *pObj, UINT8 ubStance )
{
INT32 iModifier=0;
UINT8 ubRef = GetStanceModifierRef( ubStance );
if (pObj->exists() == true && UsingNewCTHSystem() == true)
{
iModifier += Item[pObj->usItem].percentdropcompensationmodifier[ubRef];
for (attachmentList::iterator iter = (*pObj)[0]->attachments.begin(); iter != (*pObj)[0]->attachments.end(); ++iter)
{
if (iter->exists())
{
iModifier += BonusReduceMore( Item[iter->usItem].percentdropcompensationmodifier[ubRef], (*iter)[0]->data.objectStatus );
}
}
}
iModifier = __max(-100,iModifier);
return (iModifier);
}
// HEADROCK HAM 4: This function returns the Max Counter Force modifier given by the weapon
INT32 GetCounterForceMaxModifier( OBJECTTYPE *pObj, UINT8 ubStance )
{
INT32 iModifier=0;
UINT8 ubRef = GetStanceModifierRef( ubStance );
if (pObj->exists() == true && UsingNewCTHSystem() == true)
{
iModifier += Item[pObj->usItem].maxcounterforcemodifier[ubRef];
for (attachmentList::iterator iter = (*pObj)[0]->attachments.begin(); iter != (*pObj)[0]->attachments.end(); ++iter)
{
if (iter->exists())
{
iModifier += BonusReduceMore( Item[iter->usItem].maxcounterforcemodifier[ubRef], (*iter)[0]->data.objectStatus );
}
}
break;
case NCTHMODIFIER_COUNTERFORCEACCURACY:
iModifier += BonusReduceMore( Item[pObj->usItem].counterforceaccuracymodifier[ubRef], (*pObj)[0]->data.objectStatus );
break;
case NCTHMODIFIER_COUNTERFORCEFREQUENCY:
iModifier += BonusReduceMore( Item[pObj->usItem].counterforcefrequencymodifier[ubRef], (*pObj)[0]->data.objectStatus );
break;
case NCTHMODIFIER_TRACKING:
iModifier += BonusReduceMore( Item[pObj->usItem].targettrackingmodifier[ubRef], (*pObj)[0]->data.objectStatus );
break;
case NCTHMODIFIER_AIMLEVELS:
iModifier += Item[pObj->usItem].aimlevelsmodifier[ubRef];
break;
}
if(ubRef == 1)
iModifier += (INT32)gGameCTHConstants.RECOIL_MAX_COUNTER_CROUCH;
else if (ubRef == 2)
iModifier += (INT32)gGameCTHConstants.RECOIL_MAX_COUNTER_PRONE;
iModifier = __max(-100,iModifier);
return (iModifier);
return iModifier;
}
// HEADROCK HAM 4: This function returns the Counter Force Accuracy modifier given by the weapon
INT32 GetCounterForceAccuracyModifier( OBJECTTYPE *pObj, UINT8 ubStance )
{
INT32 iModifier=0;
UINT8 ubRef = GetStanceModifierRef( ubStance );
if (pObj->exists() == true && UsingNewCTHSystem() == true)
{
iModifier += Item[pObj->usItem].counterforceaccuracymodifier[ubRef];
for (attachmentList::iterator iter = (*pObj)[0]->attachments.begin(); iter != (*pObj)[0]->attachments.end(); ++iter)
{
if (iter->exists())
{
iModifier += BonusReduceMore( Item[iter->usItem].counterforceaccuracymodifier[ubRef], (*iter)[0]->data.objectStatus );
}
}
}
iModifier = __max(-100,iModifier);
return (iModifier);
}
INT32 GetCounterForceFrequencyModifier( OBJECTTYPE *pObj, UINT8 ubStance )
{
INT32 iModifier=0;
UINT8 ubRef = GetStanceModifierRef( ubStance );
if (pObj->exists() == true && UsingNewCTHSystem() == true)
{
iModifier += Item[pObj->usItem].counterforcefrequencymodifier[ubRef];
for (attachmentList::iterator iter = (*pObj)[0]->attachments.begin(); iter != (*pObj)[0]->attachments.end(); ++iter)
{
if (iter->exists())
{
iModifier += BonusReduceMore( Item[iter->usItem].counterforcefrequencymodifier[ubRef], (*iter)[0]->data.objectStatus );
}
}
}
return (iModifier);
}
INT32 GetTargetTrackingModifier( OBJECTTYPE *pObj, UINT8 ubStance )
{
INT32 iModifier=0;
UINT8 ubRef = GetStanceModifierRef( ubStance );
if (pObj->exists() == true && UsingNewCTHSystem() == true)
{
iModifier += Item[pObj->usItem].targettrackingmodifier[ubRef];
for (attachmentList::iterator iter = (*pObj)[0]->attachments.begin(); iter != (*pObj)[0]->attachments.end(); ++iter)
{
if (iter->exists())
{
iModifier += BonusReduceMore( Item[iter->usItem].targettrackingmodifier[ubRef], (*iter)[0]->data.objectStatus );
}
}
}
iModifier = __max(-100,iModifier);
return (iModifier);
}
INT32 GetAimLevelsModifier( SOLDIERTYPE* pSoldier, OBJECTTYPE *pObj, UINT8 ubStance )
// Flugente: unified function (no need to have 12 functions that all do the same thing and clutter the code)
INT32 GetObjectNCTHModifier( SOLDIERTYPE* pSoldier, OBJECTTYPE *pObj, UINT8 ubStance, UINT8 usType )
{
INT32 iModifier=0;
@@ -10423,40 +10242,33 @@ INT32 GetAimLevelsModifier( SOLDIERTYPE* pSoldier, OBJECTTYPE *pObj, UINT8 ubSta
if (pObj->exists() == true && UsingNewCTHSystem() == true)
{
iModifier += Item[pObj->usItem].aimlevelsmodifier[ubRef];
if ( gGameExternalOptions.fScopeModes && pSoldier )
for (attachmentList::iterator iter = (*pObj)[0]->attachments.begin(); iter != (*pObj)[0]->attachments.end(); ++iter)
{
for (attachmentList::iterator iter = (*pObj)[0]->attachments.begin(); iter != (*pObj)[0]->attachments.end(); ++iter)
if( iter->exists() )
{
if( iter->exists() && !IsAttachmentClass(iter->usItem, AC_SCOPE|AC_SIGHT|AC_IRONSIGHT ) )
{
iModifier += Item[iter->usItem].aimlevelsmodifier[ubRef];
}
}
// Flugente: if we use scope modes, are a soldier, this is a gun and the attachment a scope/sight, ignore it for the moment
if ( gGameExternalOptions.fScopeModes && pSoldier && Item[pObj->usItem].usItemClass == IC_GUN && IsAttachmentClass(iter->usItem, (AC_SCOPE|AC_SIGHT|AC_IRONSIGHT) ) )
continue;
// Flugente: check for scope mode
if ( Item[pObj->usItem].usItemClass == IC_GUN )
{
std::map<INT8, OBJECTTYPE*> ObjList;
GetScopeLists(pObj, ObjList);
// only use scope mode if gun is in hand, otherwise an error might occur!
if ( (&pSoldier->inv[HANDPOS]) == pObj && ObjList[pSoldier->bScopeMode] != NULL && pSoldier->bScopeMode != USE_ALT_WEAPON_HOLD )
iModifier += Item[ObjList[pSoldier->bScopeMode]->usItem].aimlevelsmodifier[ubRef];
iModifier += GetItemNCTHModifier( (&(*iter)), ubRef, usType);
}
}
else
// Flugente: check for scope mode
if ( gGameExternalOptions.fScopeModes && pSoldier && Item[pObj->usItem].usItemClass == IC_GUN )
{
for (attachmentList::iterator iter = (*pObj)[0]->attachments.begin(); iter != (*pObj)[0]->attachments.end(); ++iter)
{
if (iter->exists())
{
iModifier += Item[iter->usItem].aimlevelsmodifier[ubRef];
}
}
std::map<INT8, OBJECTTYPE*> ObjList;
GetScopeLists(pObj, ObjList);
// only use scope mode if gun is in hand, otherwise an error might occur!
if ( (&pSoldier->inv[HANDPOS]) == pObj && ObjList[pSoldier->bScopeMode] != NULL && pSoldier->bScopeMode != USE_ALT_WEAPON_HOLD )
iModifier += GetItemNCTHModifier(ObjList[pSoldier->bScopeMode], ubRef, usType);
}
}
iModifier = __max(-100,iModifier);
return (iModifier);
}
@@ -10711,7 +10523,7 @@ INT16 GetPercentRecoilModifier( OBJECTTYPE *pObj )
// HEADROCK HAM 4: This is used by functions that get stance-based modifiers from weapons. It turns a ubEndHeight variable
// as either 0, 1 or 2.
INT8 GetStanceModifierRef( INT8 ubStance )
UINT8 GetStanceModifierRef( INT8 ubStance )
{
switch (ubStance)
{
@@ -13187,8 +12999,8 @@ UINT8 AllowedAimingLevelsNCTH( SOLDIERTYPE *pSoldier, INT32 sGridNo )
if ( gGameExternalOptions.fWeaponResting && pSoldier->IsWeaponMounted() )
stance = ANIM_PRONE;
INT32 moda = GetAimLevelsModifier( pSoldier, &pSoldier->inv[pSoldier->ubAttackingHand], stance );
INT32 modb = GetAimLevelsModifier( pSoldier, &pSoldier->inv[pSoldier->ubAttackingHand], gAnimControl[ pSoldier->usAnimState ].ubEndHeight );
INT32 moda = GetObjectNCTHModifier( pSoldier, &pSoldier->inv[pSoldier->ubAttackingHand], stance, NCTHMODIFIER_AIMLEVELS );
INT32 modb = GetObjectNCTHModifier( pSoldier, &pSoldier->inv[pSoldier->ubAttackingHand], gAnimControl[ pSoldier->usAnimState ].ubEndHeight, NCTHMODIFIER_AIMLEVELS );
aimLevels += (INT32) ((gGameExternalOptions.ubProneModifierPercentage * moda + (100 - gGameExternalOptions.ubProneModifierPercentage) * modb)/100);
}
@@ -13569,7 +13381,7 @@ UINT8 GetAllowedAimingLevelsForItem( SOLDIERTYPE *pSoldier, OBJECTTYPE *pObj, UI
}
// HEADROCK HAM 4: This modifier from the weapon and its attachments replaces the generic bipod bonus.
aimLevels += GetAimLevelsModifier( pSoldier, pObj, ubStance );
aimLevels += GetObjectNCTHModifier( pSoldier, pObj, ubStance, NCTHMODIFIER_AIMLEVELS );
aimLevels += GetAimLevelsTraitModifier( pSoldier, pObj );
@@ -15275,7 +15087,7 @@ BOOLEAN GetItemFromRandomItem( UINT16 usRandomItem, UINT16* pusNewItem )
// determine maximum allowed coolness
rditemmaxcoolness = HighestPlayerProgressPercentage() / 10 + 1 + Item[usRandomItem].randomitemcoolnessmodificator; // the random item itself can modify coolness
// build the list of items to choose from. We will search down the random item class an can even branch into mulitple other random item classes.
// build the list of items to choose from. We will search down the random item class and can even branch into mulitple other random item classes.
// We only stop if maximum number of items or random item classes is reached
AddToRandomListFromRandomItem(usRandomItem);
Tactical/Items.h
+22 -13
View File
@@ -275,22 +275,31 @@ INT16 GetRangeBonus( OBJECTTYPE * pObj );
// For a "default" value, feed the function a value of ubStance=ANIM_STAND.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
INT32 GetFlatBaseModifier( OBJECTTYPE *pObj, UINT8 ubStance );
INT32 GetPercentBaseModifier( OBJECTTYPE *pObj, UINT8 ubStance );
INT32 GetFlatAimModifier( OBJECTTYPE *pObj, UINT8 ubStance );
INT32 GetPercentAimModifier( OBJECTTYPE *pObj, UINT8 ubStance );
INT32 GetPercentCapModifier( OBJECTTYPE *pObj, UINT8 ubStance );
INT32 GetPercentHandlingModifier( OBJECTTYPE *pObj, UINT8 ubStance );
INT32 GetDropCompensationModifier( OBJECTTYPE *pObj, UINT8 ubStance );
INT32 GetCounterForceMaxModifier( OBJECTTYPE *pObj, UINT8 ubStance );
INT32 GetCounterForceAccuracyModifier( OBJECTTYPE *pObj, UINT8 ubStance );
INT32 GetCounterForceFrequencyModifier( OBJECTTYPE *pObj, UINT8 ubStance );
INT32 GetTargetTrackingModifier( OBJECTTYPE *pObj, UINT8 ubStance );
INT32 GetAimLevelsModifier( SOLDIERTYPE* pSoldier, OBJECTTYPE *pObj, UINT8 ubStance ); // Flugente: added SOLDIERTYPE* argument
// Flugente: unified function (no need to have 12 functions that all do the same thing and clutter the code)
enum {
NCTHMODIFIER_FLATBASE = 0,
NCTHMODIFIER_PERCENTBASE,
NCTHMODIFIER_FLATAIM,
NCTHMODIFIER_PERCENTAIM,
NCTHMODIFIER_PERCENTCAP,
NCTHMODIFIER_PERCENTHANDLING,
NCTHMODIFIER_DROPCOMPENSATION,
NCTHMODIFIER_COUNTERFORCEMAX,
NCTHMODIFIER_COUNTERFORCEACCURACY,
NCTHMODIFIER_COUNTERFORCEFREQUENCY,
NCTHMODIFIER_TRACKING,
NCTHMODIFIER_AIMLEVELS,
NCTHMODIFIER_MAX,
};
INT32 GetItemNCTHModifier(OBJECTTYPE* pObj, UINT8 ubRef, UINT8 usType);
INT32 GetObjectNCTHModifier( SOLDIERTYPE* pSoldier, OBJECTTYPE *pObj, UINT8 ubStance, UINT8 type );
INT32 GetAimLevelsTraitModifier( SOLDIERTYPE *pSoldier, OBJECTTYPE *pObj );
// Returns the character's stance as 0/1/2.
INT8 GetStanceModifierRef( INT8 ubStance );
UINT8 GetStanceModifierRef( INT8 ubStance );
INT16 GetDamageBonus( OBJECTTYPE * pObj );
INT16 GetMeleeDamageBonus( OBJECTTYPE * pObj );
Tactical/LOS.cpp
+9 -9
View File
@@ -8092,8 +8092,8 @@ void CalcTargetMovementOffset( SOLDIERTYPE *pShooter, SOLDIERTYPE *pTarget, OBJE
// after the target moves a smaller number of tiles.
// silversurfer: uiTilesForMaxPenalty is supposed to be small to allow for fast compensation, right? Why do we ADD the tracking modifier then?
// According to the description of the tracking modifier: "Higher is better". So we better subtract and also make the modifiers a FLOAT for better precision.
FLOAT moda = (FLOAT)(uiTilesForMaxPenalty * GetTargetTrackingModifier( pWeapon, stance )) / 100;
FLOAT modb = (FLOAT)(uiTilesForMaxPenalty * GetTargetTrackingModifier( pWeapon, gAnimControl[ pShooter->usAnimState ].ubEndHeight )) / 100;
FLOAT moda = (FLOAT)(uiTilesForMaxPenalty * GetObjectNCTHModifier( pShooter, pWeapon, stance, NCTHMODIFIER_TRACKING ) ) / 100;
FLOAT modb = (FLOAT)(uiTilesForMaxPenalty * GetObjectNCTHModifier( pShooter, pWeapon, gAnimControl[ pShooter->usAnimState ].ubEndHeight, NCTHMODIFIER_TRACKING ) ) / 100;
// uiTilesForMaxPenalty += (INT16)((gGameExternalOptions.ubProneModifierPercentage * moda + (100 - gGameExternalOptions.ubProneModifierPercentage) * modb)/100);
uiTilesForMaxPenalty -= (INT16)(((FLOAT)gGameExternalOptions.ubProneModifierPercentage * moda + (100 - (FLOAT)gGameExternalOptions.ubProneModifierPercentage) * modb)/100);
@@ -8258,8 +8258,8 @@ void CalcRangeCompensationOffset( SOLDIERTYPE *pShooter, FLOAT *dMuzzleOffsetY,
if ( gGameExternalOptions.fWeaponResting && pShooter->IsWeaponMounted() )
stance = ANIM_PRONE;
FLOAT moda = (iCombinedSkill * GetDropCompensationModifier( pWeapon, stance )) / 100;
FLOAT modb = (iCombinedSkill * GetDropCompensationModifier( pWeapon, gAnimControl[ pShooter->usAnimState ].ubEndHeight )) / 100;
FLOAT moda = (iCombinedSkill * GetObjectNCTHModifier( pShooter, pWeapon, stance, NCTHMODIFIER_DROPCOMPENSATION )) / 100;
FLOAT modb = (iCombinedSkill * GetObjectNCTHModifier( pShooter, pWeapon, gAnimControl[ pShooter->usAnimState ].ubEndHeight, NCTHMODIFIER_DROPCOMPENSATION )) / 100;
iCombinedSkill += ((gGameExternalOptions.ubProneModifierPercentage * moda + (100 - gGameExternalOptions.ubProneModifierPercentage) * modb)/100);
// Limit this to a scale of 0-100.
@@ -8611,8 +8611,8 @@ UINT32 CalcCounterForceFrequency(SOLDIERTYPE *pShooter, OBJECTTYPE *pWeapon)
stance = ANIM_PRONE;
// Percent Modifier from weapon and its attachments
FLOAT moda = (iCounterForceFrequency * GetCounterForceFrequencyModifier( pWeapon, stance )) / 100;
FLOAT modb = (iCounterForceFrequency * GetCounterForceFrequencyModifier( pWeapon, gAnimControl[ pShooter->usAnimState ].ubEndHeight )) / 100;
FLOAT moda = (iCounterForceFrequency * GetObjectNCTHModifier( pShooter, pWeapon, stance, NCTHMODIFIER_COUNTERFORCEFREQUENCY )) / 100;
FLOAT modb = (iCounterForceFrequency * GetObjectNCTHModifier( pShooter, pWeapon, gAnimControl[ pShooter->usAnimState ].ubEndHeight, NCTHMODIFIER_COUNTERFORCEFREQUENCY )) / 100;
iCounterForceFrequency += ((gGameExternalOptions.ubProneModifierPercentage * moda + (100 - gGameExternalOptions.ubProneModifierPercentage) * modb)/100);
// Limit to 1-100.
@@ -8650,7 +8650,7 @@ FLOAT CalcCounterForceMax(SOLDIERTYPE *pShooter, OBJECTTYPE *pWeapon, UINT8 uiSt
iCounterForceMax /= iDivisor;
// Add the effects from the weapon and its attachments (foregrip, for instance). This is applied as a percentage.
INT32 iModifier = GetCounterForceMaxModifier( pWeapon, uiStance );
INT32 iModifier = GetObjectNCTHModifier( pShooter, pWeapon, uiStance, NCTHMODIFIER_COUNTERFORCEMAX );
iCounterForceMax += (iCounterForceMax * iModifier) / 100;
// Limit to 0-100.
@@ -8686,8 +8686,8 @@ UINT32 CalcCounterForceAccuracy(SOLDIERTYPE *pShooter, OBJECTTYPE *pWeapon, UINT
if ( gGameExternalOptions.fWeaponResting && pShooter->IsWeaponMounted() )
stance = ANIM_PRONE;
INT32 moda = GetCounterForceAccuracyModifier( pWeapon, stance );
INT32 modb = GetCounterForceAccuracyModifier( pWeapon, gAnimControl[ pShooter->usAnimState ].ubEndHeight );
INT32 moda = GetObjectNCTHModifier( pShooter, pWeapon, stance, NCTHMODIFIER_COUNTERFORCEACCURACY );
INT32 modb = GetObjectNCTHModifier( pShooter, pWeapon, gAnimControl[ pShooter->usAnimState ].ubEndHeight, NCTHMODIFIER_COUNTERFORCEACCURACY );
INT32 iModifier = (INT32)((gGameExternalOptions.ubProneModifierPercentage * moda + (100 - gGameExternalOptions.ubProneModifierPercentage) * modb)/100);
UINT32 uiCounterForceAccuracy = (UINT32)(iCounterForceAccuracy + ((iCounterForceAccuracy * iModifier) / 100));
Tactical/Weapons.cpp
+28 -28
View File
@@ -5249,8 +5249,8 @@ if (gGameExternalOptions.fUseNewCTHCalculation)
return gGameExternalOptions.ubMinimumCTH;
// Add a flat Base bonus from the item and its attachments.
INT32 imoda = GetFlatBaseModifier( pInHand, stance );
INT32 imodb = GetFlatBaseModifier( pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight );
INT32 imoda = GetObjectNCTHModifier( pSoldier, pInHand, stance, NCTHMODIFIER_FLATBASE );
INT32 imodb = GetObjectNCTHModifier( pSoldier, pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight, NCTHMODIFIER_FLATBASE );
fBaseChance += (FLOAT)((gGameExternalOptions.ubProneModifierPercentage * imoda + (100 - gGameExternalOptions.ubProneModifierPercentage) * imodb)/100);
// get bonus from effects lasting on the shooter (morale, injury, shock etc.)
@@ -5351,8 +5351,8 @@ if (gGameExternalOptions.fUseNewCTHCalculation)
fAimChance += CalcNewChanceToHitAimTraitBonus(pSoldier, fAimChance, fDifference, sGridNo, ubAimTime, fScopeMagFactor, uiBestScopeRange);
// Add percent-based modifier from the gun and its attachments
FLOAT moda = (FLOAT)(fAimChance * GetPercentCapModifier( pInHand, stance ) / 100);
FLOAT modb = (FLOAT)(fAimChance * GetPercentCapModifier( pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight ) / 100);
FLOAT moda = (FLOAT)(fAimChance * GetObjectNCTHModifier( pSoldier, pInHand, stance, NCTHMODIFIER_PERCENTCAP ) / 100);
FLOAT modb = (FLOAT)(fAimChance * GetObjectNCTHModifier( pSoldier, pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight, NCTHMODIFIER_PERCENTCAP ) / 100);
fAimChance += (FLOAT)((gGameExternalOptions.ubProneModifierPercentage * moda + (100 - gGameExternalOptions.ubProneModifierPercentage) * modb)/100);
// get aimbonus from effects lasting on the shooter
@@ -5435,8 +5435,8 @@ if (gGameExternalOptions.fUseNewCTHCalculation)
{
fAimPoints += fAimPointFraction * (ubAllowedAimingLevels-x);
// Add Flat Modifier from the weapon and its attachments
INT32 moda = GetFlatAimModifier( pInHand, stance );
INT32 modb = GetFlatAimModifier( pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight );
INT32 moda = GetObjectNCTHModifier( pSoldier, pInHand, stance, NCTHMODIFIER_FLATAIM );
INT32 modb = GetObjectNCTHModifier( pSoldier, pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight, NCTHMODIFIER_FLATAIM );
fAimPoints += (FLOAT)((gGameExternalOptions.ubProneModifierPercentage * moda + (100 - gGameExternalOptions.ubProneModifierPercentage) * modb)/100);
}
@@ -5521,8 +5521,8 @@ else
iChance = (INT32)iCombinedSkill;
// Add a flat Base bonus from the item and its attachments.
INT32 moda = GetFlatBaseModifier( pInHand, stance );
INT32 modb = GetFlatBaseModifier( pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight );
INT32 moda = GetObjectNCTHModifier( pSoldier, pInHand, stance, NCTHMODIFIER_FLATBASE );
INT32 modb = GetObjectNCTHModifier( pSoldier, pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight, NCTHMODIFIER_FLATBASE );
iChance += (INT32)((gGameExternalOptions.ubProneModifierPercentage * moda + (100 - gGameExternalOptions.ubProneModifierPercentage) * modb)/100);
// We now begin adding up factors that may increase or decrease Base CTH. They are pooled together to form a percentage
@@ -5666,8 +5666,8 @@ else
}
// Percent based modifier from the gun and its attachments
FLOAT umoda = (iGunBaseDifficulty * GetPercentHandlingModifier( pInHand, stance )) / 100;
FLOAT umodb = (iGunBaseDifficulty * GetPercentHandlingModifier( pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight )) / 100;
FLOAT umoda = (iGunBaseDifficulty * GetObjectNCTHModifier( pSoldier, pInHand, stance, NCTHMODIFIER_PERCENTHANDLING )) / 100;
FLOAT umodb = (iGunBaseDifficulty * GetObjectNCTHModifier( pSoldier, pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight, NCTHMODIFIER_PERCENTHANDLING )) / 100;
iGunBaseDifficulty += ((gGameExternalOptions.ubProneModifierPercentage * umoda + (100 - gGameExternalOptions.ubProneModifierPercentage) * umodb)/100);
// End gun difficulty modifiers
@@ -5826,8 +5826,8 @@ else
}
// Percentage based-modifier from the weapon and its attachments
umoda = (iGunBaseDifficulty * GetPercentBaseModifier( pInHand, stance )) / 100;
umodb = (iGunBaseDifficulty * GetPercentBaseModifier( pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight )) / 100;
umoda = (iGunBaseDifficulty * GetObjectNCTHModifier( pSoldier, pInHand, stance, NCTHMODIFIER_PERCENTBASE )) / 100;
umodb = (iGunBaseDifficulty * GetObjectNCTHModifier( pSoldier, pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight, NCTHMODIFIER_PERCENTBASE )) / 100;
iBaseModifier += ((gGameExternalOptions.ubProneModifierPercentage * umoda + (100 - gGameExternalOptions.ubProneModifierPercentage) * umodb)/100);
@@ -6000,8 +6000,8 @@ else
iGunAimDifficulty += iTempPenalty;
}
FLOAT umoda = (iGunAimDifficulty * GetPercentHandlingModifier( pInHand, stance )) / 100;
FLOAT umodb = (iGunAimDifficulty * GetPercentHandlingModifier( pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight )) / 100;
FLOAT umoda = (iGunAimDifficulty * GetObjectNCTHModifier( pSoldier, pInHand, stance, NCTHMODIFIER_PERCENTHANDLING )) / 100;
FLOAT umodb = (iGunAimDifficulty * GetObjectNCTHModifier( pSoldier, pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight, NCTHMODIFIER_PERCENTHANDLING )) / 100;
iGunAimDifficulty += (gGameExternalOptions.ubProneModifierPercentage * umoda + (100 - gGameExternalOptions.ubProneModifierPercentage) * umodb)/100;
// End Gun Handling modifiers
@@ -6159,8 +6159,8 @@ else
}
// Percent modifier from the weapon and its attachments
INT32 moda = GetPercentAimModifier( pInHand, stance );
INT32 modb = GetPercentAimModifier( pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight );
INT32 moda = GetObjectNCTHModifier( pSoldier, pInHand, stance, NCTHMODIFIER_PERCENTAIM );
INT32 modb = GetObjectNCTHModifier( pSoldier, pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight, NCTHMODIFIER_PERCENTAIM );
iAimModifier += (gGameExternalOptions.ubProneModifierPercentage * moda + (100 - gGameExternalOptions.ubProneModifierPercentage) * modb)/100;
// Calculate final max aiming
@@ -6177,8 +6177,8 @@ else
INT32 uiCap = (INT32)iCombinedSkill;
// Add percent-based modifier from the gun and its attachments
INT32 uimoda = (INT32)(uiCap * GetPercentCapModifier( pInHand, stance )) / 100;
INT32 uimodb = (INT32)(uiCap * GetPercentCapModifier( pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight )) / 100;
INT32 uimoda = (INT32)(uiCap * GetObjectNCTHModifier( pSoldier, pInHand, stance, NCTHMODIFIER_PERCENTCAP )) / 100;
INT32 uimodb = (INT32)(uiCap * GetObjectNCTHModifier( pSoldier, pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight, NCTHMODIFIER_PERCENTCAP )) / 100;
uiCap += (INT32)((gGameExternalOptions.ubProneModifierPercentage * uimoda + (100 - gGameExternalOptions.ubProneModifierPercentage) * uimodb)/100);
// Add bonuses from Sniper Skill. Applies only when using a scope at or above its "best" range.
@@ -6275,8 +6275,8 @@ else
{
iAimPoints += iAimPointFraction * (ubAllowedAimingLevels-x);
// Add Flat Modifier from the weapon and its attachments
INT32 moda = GetFlatAimModifier( pInHand, stance );
INT32 modb = GetFlatAimModifier( pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight );
INT32 moda = GetObjectNCTHModifier( pSoldier, pInHand, stance, NCTHMODIFIER_FLATAIM );
INT32 modb = GetObjectNCTHModifier( pSoldier, pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight, NCTHMODIFIER_FLATAIM );
iAimPoints += (gGameExternalOptions.ubProneModifierPercentage * moda + (100 - gGameExternalOptions.ubProneModifierPercentage) * modb)/100;
}
@@ -12579,16 +12579,16 @@ FLOAT CalcNewChanceToHitBaseWeaponBonus(SOLDIERTYPE *pSoldier, INT32 sGridNo, IN
}
// Percentage based handling modifier from the gun and its attachments
FLOAT moda = (fGunBaseDifficulty * GetPercentHandlingModifier( pInHand, stance )) / 100;
FLOAT modb = (fGunBaseDifficulty * GetPercentHandlingModifier( pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight )) / 100;
FLOAT moda = (fGunBaseDifficulty * GetObjectNCTHModifier( pSoldier, pInHand, stance, NCTHMODIFIER_PERCENTHANDLING )) / 100;
FLOAT modb = (fGunBaseDifficulty * GetObjectNCTHModifier( pSoldier, pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight, NCTHMODIFIER_PERCENTHANDLING )) / 100;
fGunBaseDifficulty += ((gGameExternalOptions.ubProneModifierPercentage * moda + (100 - gGameExternalOptions.ubProneModifierPercentage) * modb)/100);
// Now apply Gun Difficulty to the Base Modifier.
fBaseModifier -= fGunBaseDifficulty * gGameCTHConstants.BASE_DRAW_COST;
// Percentage based modifier from the weapon and its attachments
moda = (fGunBaseDifficulty * GetPercentBaseModifier( pInHand, stance )) / 100;
modb = (fGunBaseDifficulty * GetPercentBaseModifier( pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight )) / 100;
moda = (fGunBaseDifficulty * GetObjectNCTHModifier( pSoldier, pInHand, stance, NCTHMODIFIER_PERCENTBASE )) / 100;
modb = (fGunBaseDifficulty * GetObjectNCTHModifier( pSoldier, pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight, NCTHMODIFIER_PERCENTBASE )) / 100;
fBaseModifier += ((gGameExternalOptions.ubProneModifierPercentage * moda + (100 - gGameExternalOptions.ubProneModifierPercentage) * modb)/100);
return fBaseModifier;
@@ -12921,16 +12921,16 @@ FLOAT CalcNewChanceToHitAimWeaponBonus(SOLDIERTYPE *pSoldier, INT32 sGridNo, INT
}
// Percentage based handling modifier from the gun and its attachments
FLOAT moda = (fGunAimDifficulty * GetPercentHandlingModifier( pInHand, stance )) / 100;
FLOAT modb = (fGunAimDifficulty * GetPercentHandlingModifier( pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight )) / 100;
FLOAT moda = (fGunAimDifficulty * GetObjectNCTHModifier( pSoldier, pInHand, stance, NCTHMODIFIER_PERCENTHANDLING )) / 100;
FLOAT modb = (fGunAimDifficulty * GetObjectNCTHModifier( pSoldier, pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight, NCTHMODIFIER_PERCENTHANDLING )) / 100;
fGunAimDifficulty += (gGameExternalOptions.ubProneModifierPercentage * moda + (100 - gGameExternalOptions.ubProneModifierPercentage) * modb)/100;
// Now apply Gun Difficulty to the Aim Modifier
fAimModifier -= gGameCTHConstants.AIM_DRAW_COST * fGunAimDifficulty;
// Percent modifier from the weapon and its attachments
INT32 imoda = GetPercentAimModifier( pInHand, stance );
INT32 imodb = GetPercentAimModifier( pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight );
INT32 imoda = GetObjectNCTHModifier( pSoldier, pInHand, stance, NCTHMODIFIER_PERCENTAIM );
INT32 imodb = GetObjectNCTHModifier( pSoldier, pInHand, gAnimControl[ pSoldier->usAnimState ].ubEndHeight, NCTHMODIFIER_PERCENTAIM );
fAimModifier += (FLOAT)(gGameExternalOptions.ubProneModifierPercentage * imoda + (100 - gGameExternalOptions.ubProneModifierPercentage) * imodb)/100;
return fAimModifier;
TacticalAI/DecideAction.cpp
+1 -1
View File
@@ -4055,7 +4055,7 @@ INT16 ubMinAPCost;
ATTACKTYPE BestShot, BestThrow, BestStab ,BestAttack;//dnl ch69 150913
BOOLEAN fCivilian = (PTR_CIVILIAN && (pSoldier->ubCivilianGroup == NON_CIV_GROUP || pSoldier->aiData.bNeutral || (pSoldier->ubBodyType >= FATCIV && pSoldier->ubBodyType <= CRIPPLECIV) ) );
UINT8 ubBestStance = 1, ubStanceCost;
UINT8 ubBestStance = 1;
BOOLEAN fChangeStanceFirst; // before firing
BOOLEAN fClimb;
INT16 ubBurstAPs;