From 3cd3ef39cbf0da4f0612e8a280d71edb7bc42d79 Mon Sep 17 00:00:00 2001 From: ChrisL Date: Thu, 6 Nov 2008 00:46:54 +0000 Subject: [PATCH] 100AP project integration git-svn-id: https://ja2svn.mooo.com/source/ja2/trunk/GameSource/ja2_v1.13/Build@2402 3b4a5df2-a311-0410-b5c6-a8a6f20db521 --- GameSettings.cpp | 171 ++++++++++++- GameSettings.h | 8 +- GameVersion.h | 7 +- Init.cpp | 34 +++ Init.h | 135 +++++++++- Laptop/BobbyRGuns.cpp | 19 +- SaveLoadGame.cpp | 200 ++++++++++++--- Strategic/mapscreen.cpp | 6 +- Strategic/strategicmap.cpp | 8 +- Strategic/strategicmap.h | 2 +- Tactical/Animation Control.cpp | 60 ++--- Tactical/Animation Control.h | 2 +- Tactical/DisplayCover.cpp | 4 +- Tactical/Drugs And Alcohol.cpp | 16 +- Tactical/Drugs And Alcohol.h | 4 +- Tactical/Faces.cpp | 2 +- Tactical/Handle Doors.cpp | 48 ++-- Tactical/Handle Items.cpp | 36 ++- Tactical/Handle UI Plan.cpp | 4 +- Tactical/Handle UI.cpp | 64 +++-- Tactical/Interface Items.cpp | 49 ++-- Tactical/Interface Panels.cpp | 10 +- Tactical/Interface.cpp | 50 ++-- Tactical/Items.cpp | 33 +-- Tactical/Items.h | 5 +- Tactical/LOS.cpp | 2 +- Tactical/Militia Control.cpp | 29 +-- Tactical/Overhead.cpp | 27 +- Tactical/PATHAI.H | 2 +- Tactical/PATHAI.cpp | 88 +++---- Tactical/Points.cpp | 374 +++++++++++++++------------- Tactical/Points.h | 97 ++++---- Tactical/Rotting Corpses.cpp | 2 +- Tactical/ShopKeeper Interface.cpp | 2 +- Tactical/Soldier Add.cpp | 13 +- Tactical/Soldier Ani.cpp | 2 +- Tactical/Soldier Control.cpp | 167 ++++++++----- Tactical/Soldier Control.h | 14 +- Tactical/Soldier Create.cpp | 1 - Tactical/Soldier Tile.cpp | 4 +- Tactical/TeamTurns.cpp | 8 +- Tactical/Turn Based Input.cpp | 6 +- Tactical/Vehicles.cpp | 5 +- Tactical/Vehicles.h | 4 +- Tactical/Weapons.cpp | 76 +++--- Tactical/Weapons.h | 18 +- Tactical/XML.h | 29 ++- Tactical/XML_Attachments.cpp | 2 + Tactical/XML_Merge.cpp | 2 + Tactical/faces.h | 4 +- TacticalAI/AIInternals.h | 18 +- TacticalAI/AIMain.cpp | 11 +- TacticalAI/AIUtils.cpp | 46 ++-- TacticalAI/Attacks.cpp | 63 ++--- TacticalAI/CreatureDecideAction.cpp | 11 +- TacticalAI/DecideAction.cpp | 59 +++-- TacticalAI/FindLocations.cpp | 21 +- TacticalAI/Movement.cpp | 12 +- TacticalAI/PanicButtons.cpp | 6 +- TacticalAI/ai.h | 2 +- TileEngine/Exit Grids.cpp | 3 +- TileEngine/Interactive Tiles.cpp | 8 +- Utils/XML_Items.cpp | 1 + gameloop.cpp | 1 + 64 files changed, 1436 insertions(+), 781 deletions(-) diff --git a/GameSettings.cpp b/GameSettings.cpp index 1e2d5bf8..50a2e3e3 100644 --- a/GameSettings.cpp +++ b/GameSettings.cpp @@ -33,6 +33,7 @@ #include "strategicmap.h" #include "Queen Command.h" #include "Game Clock.h" + #include "Init.h" #endif #include "Text.h" @@ -44,6 +45,7 @@ #define GAME_EXTERNAL_OPTIONS_FILE "Ja2_Options.ini" +#define AP_BP_CONSTANTS_FILE "APBPConstants.ini" #define CD_ROOT_DIR "DATA\\" @@ -54,6 +56,7 @@ GAME_EXTERNAL_OPTIONS gGameExternalOptions; extern SGPFILENAME gCheckFilenames[]; extern CHAR8 gzErrorMsg[256]; +extern INT16 APBPConstants[TOTAL_APBP_VALUES]; void InitGameSettings(); @@ -769,12 +772,6 @@ void LoadGameExternalOptions() // CHRISL: New setting to allow Slay to remain as a hired PC gGameExternalOptions.fEnableSlayForever = iniReader.ReadBoolean("JA2 Gameplay Settings", "SLAY_FOREVER", FALSE); - // CHRISL: New setting to determine the AP cost to reload 1 loose round of ammo - gGameExternalOptions.ubAPCostPerRound = iniReader.ReadInteger("JA2 Gameplay Settings","AP_COST_PER_ROUND",2); - - // CHRISL: New setting to determine AP multiplier when reloading with wrong sized clip - gGameExternalOptions.ubWrongMagMult = iniReader.ReadFloat("JA2 Gameplay Settings","WRONG_MAG_MULT",2); - // CHRISL: Setting to turn off the description and stack popup options from the sector inventory panel gGameExternalOptions.fSectorDesc = iniReader.ReadBoolean("JA2 Gameplay Settings","ALLOW_SECTOR_DESCRIPTION_WINDOW",TRUE); @@ -784,6 +781,168 @@ void LoadGameExternalOptions() gGameExternalOptions.fRestrictFemaleEnemiesExceptElite = iniReader.ReadBoolean("JA2 Gameplay Settings","RESTRICT_FEMALE_ENEMIES_EXCEPT_ELITE",FALSE); } +INT16 DynamicAdjustAPConstants(INT16 iniReadValue, INT16 iniDefaultValue, BOOLEAN reverse) +{ + //CHRISL: This function will dynamically adjust all the APBPConstant values based on the AP_MAXIMUM value. This way + // if you want to use a 50AP system instead of the default, you only need to alter one value in the INI file and all + // the other values will automatically be updated to reflect the new max value. The way I've coded this, however, if + // you set your own value, you'll override this dynamic system. + if(iniReadValue == iniDefaultValue) + { + if(!reverse) + iniReadValue = (INT16)(((FLOAT)iniReadValue*(FLOAT)APBPConstants[AP_MAXIMUM]/100)+.5); + else + iniReadValue = (INT16)(((FLOAT)iniReadValue/(FLOAT)APBPConstants[AP_MAXIMUM]*100)+.5); + } + + return iniReadValue; +} + +void LoadGameAPBPConstants() +{ + CIniReader iniReader(AP_BP_CONSTANTS_FILE); + //CHRISL: To allow for dynamic settings, we need to switch AP_MAXIMUM and AP_MINIMUM so that only the max value needs + // to be changed to effect the entire system. This will require a change in the ENUM so that we can use a loop to + // modify the remaining values. + APBPConstants[AP_MAXIMUM] = iniReader.ReadInteger("APConstants","AP_MAXIMUM",100); + + //CHRISL: Once we've loaded the AP_MAXIMUM value, we can use it to modifiy all the remaining values + APBPConstants[AP_MINIMUM] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_MINIMUM",40),40); + APBPConstants[AP_MONSTER_MAXIMUM] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_MONSTER_MAXIMUM",160),160); + APBPConstants[AP_VEHICLE_MAXIMUM] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_VEHICLE_MAXIMUM",200),200); + APBPConstants[MAX_AP_CARRIED] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","MAX_AP_CARRIED",20),20); + + //CHRISL: The following five values are actually used as percentile adjustments so we don't want to dynamically alter + // them. I.E. 9 actually means 90% of the calculated APs. 15 = 150%. etc. + APBPConstants[AP_YOUNG_MONST_FACTOR] = iniReader.ReadInteger("APConstants","AP_YOUNG_MONST_FACTOR",15); + APBPConstants[AP_MONST_FRENZY_FACTOR] = iniReader.ReadInteger("APConstants","AP_MONST_FRENZY_FACTOR",13); + APBPConstants[AP_CLAUSTROPHOBE] = iniReader.ReadInteger("APConstants","AP_CLAUSTROPHOBE",9); + APBPConstants[AP_AFRAID_OF_INSECTS] = iniReader.ReadInteger("APConstants","AP_AFRAID_OF_INSECTS",8); + APBPConstants[AP_WRONG_MAG] = iniReader.ReadInteger("APConstants","AP_WRONG_MAG",15); + + APBPConstants[AP_EXCHANGE_PLACES] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_EXCHANGE_PLACES",20),20); + APBPConstants[AP_REVERSE_MODIFIER] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_REVERSE_MODIFIER",4),4); + APBPConstants[AP_STEALTH_MODIFIER] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_STEALTH_MODIFIER",8),8); + APBPConstants[AP_STEAL_ITEM] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_STEAL_ITEM",56),56); + APBPConstants[AP_TAKE_BLOOD] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_TAKE_BLOOD",40),40); + APBPConstants[AP_TALK] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_TALK",24),24); + APBPConstants[AP_MOVEMENT_FLAT] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_MOVEMENT_FLAT",12),12); + APBPConstants[AP_MOVEMENT_GRASS] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_MOVEMENT_GRASS",14),14); + APBPConstants[AP_MOVEMENT_BUSH] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_MOVEMENT_BUSH",18),18); + APBPConstants[AP_MOVEMENT_RUBBLE] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_MOVEMENT_RUBBLE",24),24); + APBPConstants[AP_MOVEMENT_SHORE] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_MOVEMENT_SHORE",28),28); + APBPConstants[AP_MOVEMENT_LAKE] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_MOVEMENT_LAKE",36),36); + APBPConstants[AP_MOVEMENT_OCEAN] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_MOVEMENT_OCEAN",32),32); + APBPConstants[AP_CHANGE_FACING] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_CHANGE_FACING",4),4); + APBPConstants[AP_CHANGE_TARGET] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_CHANGE_TARGET",2),2); + APBPConstants[AP_TOSS_ITEM] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_TOSS_ITEM",32),32); + APBPConstants[AP_REFUEL_VEHICLE] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_REFUEL_VEHICLE",40),40); + APBPConstants[AP_RADIO] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_RADIO",20),20); + APBPConstants[AP_CROUCH] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_CROUCH",6),6); + APBPConstants[AP_PRONE] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_PRONE",8),8); + APBPConstants[AP_LOOK_STANDING] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_LOOK_STANDING",4),4); + APBPConstants[AP_LOOK_CROUCHED] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_LOOK_CROUCHED",6),6); + APBPConstants[AP_LOOK_PRONE] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_LOOK_PRONE",8),8); + APBPConstants[AP_READY_KNIFE] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_READY_KNIFE",0),0); + APBPConstants[AP_READY_DUAL] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_READY_DUAL",4),4); + APBPConstants[AP_MIN_AIM_ATTACK] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_MIN_AIM_ATTACK",0),0); + APBPConstants[AP_DROP_BOMB] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_DROP_BOMB",12),12); + APBPConstants[AP_RELOAD_GUN] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_RELOAD_GUN",20),20); + APBPConstants[AP_START_FIRST_AID] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_START_FIRST_AID",20),20); + APBPConstants[AP_START_REPAIR] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_START_REPAIR",20),20); + + //CHRISL: This value is a divisor which should not be dynamically altered based on maxAP + APBPConstants[AP_GET_WOUNDED_DIVISOR] = iniReader.ReadInteger("APConstants","AP_GET_WOUNDED_DIVISOR",1); + + APBPConstants[AP_FALL_DOWN] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_FALL_DOWN",16),16); + APBPConstants[AP_OPEN_DOOR] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_OPEN_DOOR",12),12); + APBPConstants[AP_PICKLOCK] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_PICKLOCK",40),40); + APBPConstants[AP_EXAMINE_DOOR] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_EXAMINE_DOOR",20),20); + APBPConstants[AP_BOOT_DOOR] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_BOOT_DOOR",32),32); + APBPConstants[AP_USE_CROWBAR] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_USE_CROWBAR",40),40); + APBPConstants[AP_UNLOCK_DOOR] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_UNLOCK_DOOR",24),24); + APBPConstants[AP_LOCK_DOOR] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_LOCK_DOOR",24),24); + APBPConstants[AP_EXPLODE_DOOR] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_EXPLODE_DOOR",40),40); + APBPConstants[AP_UNTRAP_DOOR] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_UNTRAP_DOOR",40),40); + APBPConstants[AP_USEWIRECUTTERS] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_USEWIRECUTTERS",40),40); + APBPConstants[AP_CLIMBROOF] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_CLIMBROOF",40),40); + APBPConstants[AP_CLIMBOFFROOF] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_CLIMBOFFROOF",24),24); + APBPConstants[AP_JUMPFENCE] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_JUMPFENCE",24),24); + APBPConstants[AP_JUMPFENCEBPACK] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_JUMPFENCEBPACK",32),32); + APBPConstants[AP_USE_REMOTE] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_USE_REMOTE",8),8); + APBPConstants[AP_PULL_TRIGGER] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_PULL_TRIGGER",8),8); + APBPConstants[AP_PUNCH] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_PUNCH",16),16); + APBPConstants[AP_PICKUP_ITEM] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_PICKUP_ITEM",12),12); + APBPConstants[AP_GIVE_ITEM] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_GIVE_ITEM",4),4); + APBPConstants[AP_BURY_MINE] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_BURY_MINE",30),30); + APBPConstants[AP_DISARM_MINE] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_DISARM_MINE",40),40); + APBPConstants[AP_DRINK] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_DRINK",20),20); + APBPConstants[AP_CAMOFLAGE] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_CAMOFLAGE",40),40); + APBPConstants[AP_START_RUN_COST] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_START_RUN_COST",4),4); + APBPConstants[AP_ATTACH_CAN] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_ATTACH_CAN",20),20); + APBPConstants[AP_JUMP_OVER] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_JUMP_OVER",20),20); + APBPConstants[AP_BACK_PACK] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_BACK_PACK",12),12); + APBPConstants[AP_OPEN_ZIPPER] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_OPEN_ZIPPER",24),24); + APBPConstants[AP_CLOSE_ZIPPER] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_CLOSE_ZIPPER",28),28); + APBPConstants[AP_CLICK_AIM] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_CLICK_AIM",4),4); + APBPConstants[AUTOFIRE_SHOTS_AP_VALUE] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AUTOFIRE_SHOTS_AP_VALUE",20),20); + APBPConstants[BAD_AP_COST] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","BAD_AP_COST",36),36); + APBPConstants[AP_RELOAD_LOOSE] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_RELOAD_LOOSE",8),8); + APBPConstants[AP_UNJAM] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_UNJAM",2),2); + APBPConstants[AP_MAX_SUPPRESSED] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_MAX_SUPPRESSED",32),32); + APBPConstants[AP_SUPPRESSION_MOD] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","AP_SUPPRESSION_MOD",24),24); + APBPConstants[DEFAULT_APS] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","DEFAULT_APS",80),80); + APBPConstants[DEFAULT_AIMSKILL] = iniReader.ReadInteger("APConstants","DEFAULT_AIMSKILL",80); + + APBPConstants[BP_RATIO_RED_PTS_TO_NORMAL] = iniReader.ReadInteger("BPConstants","BP_RATIO_RED_PTS_TO_NORMAL",100); + APBPConstants[BP_RUN_ENERGYCOSTFACTOR] = iniReader.ReadInteger("BPConstants","BP_RUN_ENERGYCOSTFACTOR",3); + APBPConstants[BP_WALK_ENERGYCOSTFACTOR] = iniReader.ReadInteger("BPConstants","BP_WALK_ENERGYCOSTFACTOR",1); + APBPConstants[BP_SWAT_ENERGYCOSTFACTOR] = iniReader.ReadInteger("BPConstants","BP_SWAT_ENERGYCOSTFACTOR",2); + APBPConstants[BP_CRAWL_ENERGYCOSTFACTOR] = iniReader.ReadInteger("BPConstants","BP_CRAWL_ENERGYCOSTFACTOR",4); + APBPConstants[BP_RADIO] = iniReader.ReadInteger("BPConstants","BP_RADIO",0); + APBPConstants[BP_USE_DETONATOR] = iniReader.ReadInteger("BPConstants","BP_USE_DETONATOR",0); + APBPConstants[BP_PER_AP_NO_EFFORT] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","BP_PER_AP_NO_EFFORT",-50),-50, TRUE); + APBPConstants[BP_PER_AP_MIN_EFFORT] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","BP_PER_AP_MIN_EFFORT",-25),-25, TRUE); + APBPConstants[BP_PER_AP_LT_EFFORT] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","BP_PER_AP_LT_EFFORT",-12),-12, TRUE); + APBPConstants[BP_PER_AP_MOD_EFFORT] = DynamicAdjustAPConstants(iniReader.ReadInteger("APConstants","BP_PER_AP_MOD_EFFORT",6),6, TRUE); + APBPConstants[BP_MOVEMENT_FLAT] = iniReader.ReadInteger("BPConstants","BP_MOVEMENT_FLAT",5); + APBPConstants[BP_MOVEMENT_GRASS] = iniReader.ReadInteger("BPConstants","BP_MOVEMENT_GRASS",10); + APBPConstants[BP_MOVEMENT_BUSH] = iniReader.ReadInteger("BPConstants","BP_MOVEMENT_BUSH",20); + APBPConstants[BP_MOVEMENT_RUBBLE] = iniReader.ReadInteger("BPConstants","BP_MOVEMENT_RUBBLE",35); + APBPConstants[BP_MOVEMENT_SHORE] = iniReader.ReadInteger("BPConstants","BP_MOVEMENT_SHORE",50); + APBPConstants[BP_MOVEMENT_LAKE] = iniReader.ReadInteger("BPConstants","BP_MOVEMENT_LAKE",75); + APBPConstants[BP_MOVEMENT_OCEAN] = iniReader.ReadInteger("BPConstants","BP_MOVEMENT_OCEAN",100); + APBPConstants[BP_CROUCH] = iniReader.ReadInteger("BPConstants","BP_CROUCH",10); + APBPConstants[BP_PRONE] = iniReader.ReadInteger("BPConstants","BP_PRONE",10); + APBPConstants[BP_CLIMBROOF] = iniReader.ReadInteger("BPConstants","BP_CLIMBROOF",500); + APBPConstants[BP_CLIMBOFFROOF] = iniReader.ReadInteger("BPConstants","BP_CLIMBOFFROOF",250); + APBPConstants[BP_JUMPFENCE] = iniReader.ReadInteger("BPConstants","BP_JUMPFENCE",200); + APBPConstants[BP_JUMPFENCEBPACK] = iniReader.ReadInteger("BPConstants","BP_JUMPFENCEBPACK",500); + APBPConstants[BP_STEAL_ITEM] = iniReader.ReadInteger("BPConstants","BP_STEAL_ITEM",50); + APBPConstants[BP_START_FIRST_AID] = iniReader.ReadInteger("BPConstants","BP_START_FIRST_AID",0); + APBPConstants[BP_GET_HIT] = iniReader.ReadInteger("BPConstants","BP_GET_HIT",200); + APBPConstants[BP_GET_WOUNDED] = iniReader.ReadInteger("BPConstants","BP_GET_WOUNDED",50); + APBPConstants[BP_FALL_DOWN] = iniReader.ReadInteger("BPConstants","BP_FALL_DOWN",250); + APBPConstants[BP_OPEN_DOOR] = iniReader.ReadInteger("BPConstants","BP_OPEN_DOOR",30); + APBPConstants[BP_PICKLOCK] = iniReader.ReadInteger("BPConstants","BP_PICKLOCK",-250); + APBPConstants[BP_EXAMINE_DOOR] = iniReader.ReadInteger("BPConstants","BP_EXAMINE_DOOR",-250); + APBPConstants[BP_BOOT_DOOR] = iniReader.ReadInteger("BPConstants","BP_BOOT_DOOR",200); + APBPConstants[BP_USE_CROWBAR] = iniReader.ReadInteger("BPConstants","BP_USE_CROWBAR",350); + APBPConstants[BP_UNLOCK_DOOR] = iniReader.ReadInteger("BPConstants","BP_UNLOCK_DOOR",50); + APBPConstants[BP_EXPLODE_DOOR] = iniReader.ReadInteger("BPConstants","BP_EXPLODE_DOOR",-250); + APBPConstants[BP_UNTRAP_DOOR] = iniReader.ReadInteger("BPConstants","BP_UNTRAP_DOOR",150); + APBPConstants[BP_LOCK_DOOR] = iniReader.ReadInteger("BPConstants","BP_LOCK_DOOR",50); + APBPConstants[BP_USEWIRECUTTERS] = iniReader.ReadInteger("BPConstants","BP_USEWIRECUTTERS",200); + APBPConstants[BP_DROP_BOMB] = iniReader.ReadInteger("BPConstants","BP_DROP_BOMB",0); + APBPConstants[BP_BURY_MINE] = iniReader.ReadInteger("BPConstants","BP_BURY_MINE",250); + APBPConstants[BP_DISARM_MINE] = iniReader.ReadInteger("BPConstants","BP_DISARM_MINE",0); + APBPConstants[BP_JUMP_OVER] = iniReader.ReadInteger("BPConstants","BP_JUMP_OVER",250); + APBPConstants[BP_BACK_PACK] = iniReader.ReadInteger("APConstants","BP_JUMP_OVER",50); + APBPConstants[BP_WORK_ZIPPER] = iniReader.ReadInteger("APConstants","BP_WORK_ZIPPER",250); + APBPConstants[BP_UNJAM] = iniReader.ReadInteger("APConstants","BP_WORK_ZIPPER",0); + + SetupMaxActionPointsAnimation(); +} void FreeGameExternalOptions() { diff --git a/GameSettings.h b/GameSettings.h index 96e3e277..c7d026b1 100644 --- a/GameSettings.h +++ b/GameSettings.h @@ -444,11 +444,6 @@ BOOLEAN gbBulletTracer; // CHRISL: option to allow Slay to remain as a hired PC BOOLEAN fEnableSlayForever; - // CHRISL: New setting to determine the AP cost to reload 1 loose round of ammo - INT32 ubAPCostPerRound; - - // CHRISL: New setting to determine AP multiplier when reloading with wrong sized clip - FLOAT ubWrongMagMult; // CHRISL: Setting to turn off the description and stack popup options from the sector inventory panel BOOLEAN fSectorDesc; @@ -470,6 +465,7 @@ BOOLEAN SaveGameSettings(); BOOLEAN LoadGameSettings(); // Snap: Read options from an INI file in the default of custom Data directory void LoadGameExternalOptions(); +void LoadGameAPBPConstants(); void FreeGameExternalOptions(); void InitGameOptions(); @@ -486,4 +482,6 @@ BOOLEAN SetMeanwhileSceneSeen( UINT8 ubMeanwhile ); BOOLEAN CanGameBeSaved(); +INT16 DynamicAdjustAPConstants(INT16 iniReadValue, INT16 iniDefaultValue, BOOLEAN reverse = FALSE); + #endif diff --git a/GameVersion.h b/GameVersion.h index c1019b08..bbcd3152 100644 --- a/GameVersion.h +++ b/GameVersion.h @@ -20,12 +20,13 @@ extern CHAR16 zTrackingNumber[16]; // // Keeps track of the saved game version. Increment the saved game version whenever // you will invalidate the saved game file -#define SAVE_GAME_VERSION 104 //103 //102 //101 //100 // 99 +#define SAVE_GAME_VERSION 105 //104 //103 //102 //101 //100 // 99 //these I don't so much need here -#define CURRENT_SAVEGAME_DATATYPE_VERSION 104 -#define FIRST_SAVEGAME_DATATYPE_CHANGE 103 +#define CURRENT_SAVEGAME_DATATYPE_VERSION 105 +#define AP100_SAVEGAME_DATATYPE_CHANGE 105 // Before this, we didn't have the 100AP structure changes +#define NIV_SAVEGAME_DATATYPE_CHANGE 102 // Before this, we used the old structure system //#define SECOND_SAVEGAME_DATATYPE_CHANGE 999, #define CURRENT_SAVEGAME_DATATYPE_VERSION 999 diff --git a/Init.cpp b/Init.cpp index 11ce9348..477daafe 100644 --- a/Init.cpp +++ b/Init.cpp @@ -63,6 +63,8 @@ #endif #include "Sector Summary.h" +extern INT16 APBPConstants[TOTAL_APBP_VALUES] = {0}; +extern INT16 gubMaxActionPoints[28];//MAXBODYTYPES = 28... JUST GETTING IT TO WORK NOW. GOTTHARD 7/2/08 extern BOOLEAN GetCDromDriveLetter( STR8 pString ); // The InitializeGame function is responsible for setting up all data and Gaming Engine @@ -878,3 +880,35 @@ void HandleLaserLockResult( BOOLEAN fSuccess ) } #endif + +void SetupMaxActionPointsAnimation() +{ + gubMaxActionPoints[0] = APBPConstants[AP_MAXIMUM]; + gubMaxActionPoints[1] = APBPConstants[AP_MAXIMUM]; + gubMaxActionPoints[2] = APBPConstants[AP_MAXIMUM]; + gubMaxActionPoints[3] = APBPConstants[AP_MAXIMUM]; + gubMaxActionPoints[4] = APBPConstants[AP_MONSTER_MAXIMUM]; + gubMaxActionPoints[5] = APBPConstants[AP_MONSTER_MAXIMUM]; + gubMaxActionPoints[6] = APBPConstants[AP_MONSTER_MAXIMUM]; + gubMaxActionPoints[7] = APBPConstants[AP_MONSTER_MAXIMUM]; + gubMaxActionPoints[8] = APBPConstants[AP_MONSTER_MAXIMUM]; + gubMaxActionPoints[9] = APBPConstants[AP_MONSTER_MAXIMUM]; + gubMaxActionPoints[10] = APBPConstants[AP_MONSTER_MAXIMUM]; + gubMaxActionPoints[11] = APBPConstants[AP_MAXIMUM]; + gubMaxActionPoints[12] = APBPConstants[AP_MAXIMUM]; + gubMaxActionPoints[13] = APBPConstants[AP_MAXIMUM]; + gubMaxActionPoints[14] = APBPConstants[AP_MAXIMUM]; + gubMaxActionPoints[15] = APBPConstants[AP_MAXIMUM]; + gubMaxActionPoints[16] = APBPConstants[AP_MAXIMUM]; + gubMaxActionPoints[17] = APBPConstants[AP_MAXIMUM]; + gubMaxActionPoints[18] = APBPConstants[AP_MAXIMUM]; + gubMaxActionPoints[19] = APBPConstants[AP_MAXIMUM]; + gubMaxActionPoints[20] = APBPConstants[AP_MAXIMUM]; + gubMaxActionPoints[21] = APBPConstants[AP_MAXIMUM]; + gubMaxActionPoints[22] = APBPConstants[AP_VEHICLE_MAXIMUM]; + gubMaxActionPoints[23] = APBPConstants[AP_VEHICLE_MAXIMUM]; + gubMaxActionPoints[24] = APBPConstants[AP_VEHICLE_MAXIMUM]; + gubMaxActionPoints[25] = APBPConstants[AP_VEHICLE_MAXIMUM]; + gubMaxActionPoints[26] = APBPConstants[AP_VEHICLE_MAXIMUM]; + gubMaxActionPoints[27] = APBPConstants[AP_VEHICLE_MAXIMUM]; +} diff --git a/Init.h b/Init.h index ba811598..9130f503 100644 --- a/Init.h +++ b/Init.h @@ -5,5 +5,138 @@ UINT32 InitializeJA2( ); void ShutdownJA2( ); BOOLEAN LoadExternalGameplayData(STR directoryName); +void SetupMaxActionPointsAnimation(); + +//This is an enum to reference to array of ints that holds the values for all these constants. Gotthard 1/18/07 -#endif \ No newline at end of file +enum { +AP_MAXIMUM, +AP_MINIMUM, +AP_MONSTER_MAXIMUM, +AP_VEHICLE_MAXIMUM, +MAX_AP_CARRIED, +AP_YOUNG_MONST_FACTOR, +AP_MONST_FRENZY_FACTOR, +AP_CLAUSTROPHOBE, +AP_AFRAID_OF_INSECTS, +AP_EXCHANGE_PLACES, +AP_REVERSE_MODIFIER, +AP_STEALTH_MODIFIER, +AP_STEAL_ITEM, +AP_TAKE_BLOOD, +AP_TALK, +AP_MOVEMENT_FLAT, +AP_MOVEMENT_GRASS, +AP_MOVEMENT_BUSH, +AP_MOVEMENT_RUBBLE, +AP_MOVEMENT_SHORE, +AP_MOVEMENT_LAKE, +AP_MOVEMENT_OCEAN, +AP_CHANGE_FACING, +AP_CHANGE_TARGET, +AP_TOSS_ITEM, +AP_REFUEL_VEHICLE, +AP_RADIO, +AP_CROUCH, +AP_PRONE, +AP_LOOK_STANDING, +AP_LOOK_CROUCHED, +AP_LOOK_PRONE, +AP_READY_KNIFE, +AP_READY_DUAL, +AP_MIN_AIM_ATTACK, +AP_DROP_BOMB, +AP_RELOAD_GUN, +AP_START_FIRST_AID, +AP_START_REPAIR, +AP_GET_WOUNDED_DIVISOR, +AP_FALL_DOWN, +AP_OPEN_DOOR, +AP_PICKLOCK, +AP_EXAMINE_DOOR, +AP_BOOT_DOOR, +AP_USE_CROWBAR, +AP_UNLOCK_DOOR, +AP_LOCK_DOOR, +AP_EXPLODE_DOOR, +AP_UNTRAP_DOOR, +AP_USEWIRECUTTERS, +AP_CLIMBROOF, +AP_CLIMBOFFROOF, +AP_JUMPFENCE, +AP_JUMPFENCEBPACK, +AP_USE_REMOTE, +AP_PULL_TRIGGER, +AP_PUNCH, +AP_PICKUP_ITEM, +AP_GIVE_ITEM, +AP_BURY_MINE, +AP_DISARM_MINE, +AP_DRINK, +AP_CAMOFLAGE, +AP_START_RUN_COST, +AP_ATTACH_CAN, +AP_JUMP_OVER, +AP_BACK_PACK, +AP_OPEN_ZIPPER, +AP_CLOSE_ZIPPER, +AP_CLICK_AIM, +AP_RELOAD_LOOSE, +AP_UNJAM, +AP_WRONG_MAG, +AP_MAX_SUPPRESSED, +AP_SUPPRESSION_MOD, +AUTOFIRE_SHOTS_AP_VALUE, +BAD_AP_COST, +DEFAULT_APS, +DEFAULT_AIMSKILL, +BP_RATIO_RED_PTS_TO_NORMAL, +BP_RUN_ENERGYCOSTFACTOR, +BP_WALK_ENERGYCOSTFACTOR, +BP_SWAT_ENERGYCOSTFACTOR, +BP_CRAWL_ENERGYCOSTFACTOR, +BP_RADIO, +BP_USE_DETONATOR, +BP_PER_AP_NO_EFFORT, +BP_PER_AP_MIN_EFFORT, +BP_PER_AP_LT_EFFORT, +BP_PER_AP_MOD_EFFORT, +BP_MOVEMENT_FLAT, +BP_MOVEMENT_GRASS, +BP_MOVEMENT_BUSH, +BP_MOVEMENT_RUBBLE, +BP_MOVEMENT_SHORE, +BP_MOVEMENT_LAKE, +BP_MOVEMENT_OCEAN, +BP_CROUCH, +BP_PRONE, +BP_CLIMBROOF, +BP_CLIMBOFFROOF, +BP_JUMPFENCE, +BP_JUMPFENCEBPACK, +BP_STEAL_ITEM, +BP_START_FIRST_AID, +BP_GET_HIT, +BP_GET_WOUNDED, +BP_FALL_DOWN, +BP_OPEN_DOOR, +BP_PICKLOCK, +BP_EXAMINE_DOOR, +BP_BOOT_DOOR, +BP_USE_CROWBAR, +BP_UNLOCK_DOOR, +BP_EXPLODE_DOOR, +BP_UNTRAP_DOOR, +BP_LOCK_DOOR, +BP_USEWIRECUTTERS, +BP_DROP_BOMB, +BP_BURY_MINE, +BP_DISARM_MINE, +BP_JUMP_OVER, +BP_BACK_PACK, +BP_WORK_ZIPPER, +BP_UNJAM, + +TOTAL_APBP_VALUES +}; +#endif diff --git a/Laptop/BobbyRGuns.cpp b/Laptop/BobbyRGuns.cpp index 2e0aad74..868a464f 100644 --- a/Laptop/BobbyRGuns.cpp +++ b/Laptop/BobbyRGuns.cpp @@ -2362,13 +2362,13 @@ void CreateMouseRegionForBigImage( UINT16 usPosY, UINT8 ubCount, INT16 *pItemNum //if ( Item[ pItemNumbers[ i ] ].usItemClass == IC_GUN ) //{ // INT16 apStr2[20]; - // UINT8 ubAttackAPs = BaseAPsToShootOrStab( DEFAULT_APS, DEFAULT_AIMSKILL, pObject ); + // UINT8 ubAttackAPs = BaseAPsToShootOrStab( APBPConstants[DEFAULT_APS], APBPConstants[DEFAULT_AIMSKILL], pObject ); // swprintf( apStr, L"%d", ubAttackAPs ); // if (GetShotsPerBurst(pObject) > 0) // { - // swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToBurst( DEFAULT_APS, pObject ) ); + // swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToBurst( APBPConstants[DEFAULT_APS], pObject ) ); // wcscat( apStr, apStr2 ); // } // else @@ -2378,7 +2378,7 @@ void CreateMouseRegionForBigImage( UINT16 usPosY, UINT8 ubCount, INT16 *pItemNum // if (GetAutofireShotsPerFiveAPs(pObject) > 0) // { - // swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToAutofire( DEFAULT_APS, pObject, 3 ) ); + // swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToAutofire( APBPConstants[DEFAULT_APS], pObject, 3 ) ); // wcscat( apStr, apStr2 ); // } // else @@ -2403,7 +2403,7 @@ void CreateMouseRegionForBigImage( UINT16 usPosY, UINT8 ubCount, INT16 *pItemNum OBJECTTYPE pObject; CreateItem(pItemNumbers[ i ], 100, &pObject); - UINT8 ubAttackAPs = BaseAPsToShootOrStab( DEFAULT_APS, DEFAULT_AIMSKILL, &pObject ); + UINT16 ubAttackAPs = BaseAPsToShootOrStab( APBPConstants[DEFAULT_APS], APBPConstants[DEFAULT_AIMSKILL], &pObject ); if ( Weapon[ pItemNumbers[ i ] ].NoSemiAuto ) swprintf( apStr, L"-" ); @@ -2412,7 +2412,7 @@ void CreateMouseRegionForBigImage( UINT16 usPosY, UINT8 ubCount, INT16 *pItemNum if (GetShotsPerBurst(&pObject) > 0) { - swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToBurst( DEFAULT_APS, &pObject ) ); + swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToBurst( APBPConstants[DEFAULT_APS], &pObject ) ); wcscat( apStr, apStr2 ); } else @@ -2420,7 +2420,7 @@ void CreateMouseRegionForBigImage( UINT16 usPosY, UINT8 ubCount, INT16 *pItemNum if (GetAutofireShotsPerFiveAPs(&pObject) > 0) { - swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToAutofire( DEFAULT_APS, &pObject, 3 ) ); + swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToAutofire( APBPConstants[DEFAULT_APS], &pObject, 3 ) ); wcscat( apStr, apStr2 ); } else @@ -2455,13 +2455,13 @@ void CreateMouseRegionForBigImage( UINT16 usPosY, UINT8 ubCount, INT16 *pItemNum //if ( Item[ pItemNumbers[ i ] ].usItemClass == IC_GUN ) //{ // INT16 apStr2[20]; - // UINT8 ubAttackAPs = BaseAPsToShootOrStab( DEFAULT_APS, DEFAULT_AIMSKILL, pObject ); + // UINT8 ubAttackAPs = BaseAPsToShootOrStab( APBPConstants[DEFAULT_APS], APBPConstants[DEFAULT_AIMSKILL], pObject ); // swprintf( apStr, L"%d", ubAttackAPs ); // if (GetShotsPerBurst(pObject) > 0) // { - // swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToBurst( DEFAULT_APS, pObject ) ); + // swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToBurst( APBPConstants[DEFAULT_APS], pObject ) ); // wcscat( apStr, apStr2 ); // } // else @@ -2471,7 +2471,7 @@ void CreateMouseRegionForBigImage( UINT16 usPosY, UINT8 ubCount, INT16 *pItemNum // if (GetAutofireShotsPerFiveAPs(pObject) > 0) // { - // swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToAutofire( DEFAULT_APS, pObject, 3 ) ); + // swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToAutofire( APBPConstants[DEFAULT_APS], pObject, 3 ) ); // wcscat( apStr, apStr2 ); // } // else @@ -3447,3 +3447,4 @@ void ReportBobbyROrderError( UINT16 usItemNumber, UINT8 ubPurchaseNum, UINT8 ubQ + diff --git a/SaveLoadGame.cpp b/SaveLoadGame.cpp index b8b76fcd..9b2d2a07 100644 --- a/SaveLoadGame.cpp +++ b/SaveLoadGame.cpp @@ -539,7 +539,7 @@ BOOLEAN LBENODE::Load( HWFILE hFile ) { UINT32 uiNumBytesRead; //if we are at the most current version, then fine - if ( guiCurrentSaveGameVersion >= CURRENT_SAVEGAME_DATATYPE_VERSION ) + if ( guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE ) { if ( !FileRead( hFile, this, SIZEOF_LBENODE_POD, &uiNumBytesRead ) ) { @@ -566,7 +566,7 @@ BOOLEAN LBENODE::Load( HWFILE hFile ) else { //we shouldn't be loading from anything before the first change - Assert(guiCurrentSaveGameVersion >= FIRST_SAVEGAME_DATATYPE_CHANGE); + Assert(guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE); } return TRUE; } @@ -588,7 +588,7 @@ BOOLEAN LBENODE::Load( INT8** hBuffer, float dMajorMapVersion, UINT8 ubMinorMapV } } else { - Assert(guiCurrentSaveGameVersion >= FIRST_SAVEGAME_DATATYPE_CHANGE); + Assert(guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE); } return TRUE; } @@ -625,7 +625,7 @@ BOOLEAN LoadArmsDealerInventoryFromSavedGameFile( HWFILE hFile ) //Free all the dealers special inventory arrays ShutDownArmsDealers(); - if (guiCurrentSaveGameVersion >= FIRST_SAVEGAME_DATATYPE_CHANGE) { + if (guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE) { int dealers; if (!FileRead( hFile, &dealers, sizeof( int ), &uiNumBytesRead )) { @@ -792,7 +792,7 @@ BOOLEAN DEALER_SPECIAL_ITEM::Load(HWFILE hFile) { UINT32 uiNumBytesRead; //if we are at the most current version, then fine - if ( guiCurrentSaveGameVersion >= CURRENT_SAVEGAME_DATATYPE_VERSION ) + if ( guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE ) { if ( !FileRead( hFile, this, SIZEOF_DEALER_SPECIAL_ITEM_POD, &uiNumBytesRead ) ) { @@ -806,7 +806,7 @@ BOOLEAN DEALER_SPECIAL_ITEM::Load(HWFILE hFile) else { //this will never be loaded from sometime before the first change - Assert(guiCurrentSaveGameVersion >= FIRST_SAVEGAME_DATATYPE_CHANGE); + Assert(guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE); } return TRUE; } @@ -829,7 +829,7 @@ BOOLEAN REAL_OBJECT::Load(HWFILE hFile) { UINT32 uiNumBytesRead; //if we are at the most current version, then fine - if ( guiCurrentSaveGameVersion >= CURRENT_SAVEGAME_DATATYPE_VERSION ) + if ( guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE ) { if ( !FileRead( hFile, this, SIZEOF_REAL_OBJECT_POD, &uiNumBytesRead ) ) { @@ -842,7 +842,7 @@ BOOLEAN REAL_OBJECT::Load(HWFILE hFile) } else { - if ( guiCurrentSaveGameVersion < FIRST_SAVEGAME_DATATYPE_CHANGE ) + if ( guiCurrentSaveGameVersion < NIV_SAVEGAME_DATATYPE_CHANGE ) { OLD_REAL_OBJECT_101 oldObject; if ( !FileRead( hFile, &oldObject, sizeof( OLD_REAL_OBJECT_101 ), &uiNumBytesRead ) ) @@ -873,7 +873,7 @@ BOOLEAN INVENTORY_IN_SLOT::Load(HWFILE hFile) { UINT32 uiNumBytesRead; //if we are at the most current version, then fine - if ( guiCurrentSaveGameVersion >= CURRENT_SAVEGAME_DATATYPE_VERSION ) + if ( guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE ) { if ( !FileRead( hFile, this, SIZEOF_INVENTORY_IN_SLOT_POD, &uiNumBytesRead ) ) { @@ -886,7 +886,7 @@ BOOLEAN INVENTORY_IN_SLOT::Load(HWFILE hFile) } else { - if ( guiCurrentSaveGameVersion < FIRST_SAVEGAME_DATATYPE_CHANGE ) + if ( guiCurrentSaveGameVersion < NIV_SAVEGAME_DATATYPE_CHANGE ) { OLD_INVENTORY_IN_SLOT_101 oldItem; if ( !FileRead( hFile, &oldItem, sizeof( OLD_INVENTORY_IN_SLOT_101 ), &uiNumBytesRead ) ) @@ -912,7 +912,7 @@ BOOLEAN MERC_LEAVE_ITEM::Load(HWFILE hFile) { UINT32 uiNumBytesRead; //if we are at the most current version, then fine - if ( guiCurrentSaveGameVersion >= CURRENT_SAVEGAME_DATATYPE_VERSION ) + if ( guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE ) { if ( !this->object.Load(hFile) ) { @@ -921,7 +921,7 @@ BOOLEAN MERC_LEAVE_ITEM::Load(HWFILE hFile) } else { - if ( guiCurrentSaveGameVersion < FIRST_SAVEGAME_DATATYPE_CHANGE ) + if ( guiCurrentSaveGameVersion < NIV_SAVEGAME_DATATYPE_CHANGE ) { OLD_MERC_LEAVE_ITEM_101 oldItem; if ( !FileRead( hFile, &oldItem, sizeof( OLD_MERC_LEAVE_ITEM_101 ), &uiNumBytesRead ) ) @@ -938,7 +938,7 @@ BOOLEAN ITEM_CURSOR_SAVE_INFO::Load(HWFILE hFile) { UINT32 uiNumBytesRead; //if we are at the most current version, then fine - if ( guiCurrentSaveGameVersion >= CURRENT_SAVEGAME_DATATYPE_VERSION ) + if ( guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE ) { //3 bytes of info, screw being neat if ( !FileRead( hFile, this, 3, &uiNumBytesRead ) ) @@ -952,7 +952,7 @@ BOOLEAN ITEM_CURSOR_SAVE_INFO::Load(HWFILE hFile) } else { - if ( guiCurrentSaveGameVersion < FIRST_SAVEGAME_DATATYPE_CHANGE ) + if ( guiCurrentSaveGameVersion < NIV_SAVEGAME_DATATYPE_CHANGE ) { OLD_ITEM_CURSOR_SAVE_INFO_101 oldInfo101; if ( !FileRead( hFile, &oldInfo101, sizeof(OLD_ITEM_CURSOR_SAVE_INFO_101), &uiNumBytesRead ) ) @@ -1032,7 +1032,7 @@ BOOLEAN SOLDIERCREATE_STRUCT::Load(HWFILE hFile, int versionToLoad, bool loadChe guiCurrentSaveGameVersion = versionToLoad; //if we are at the most current version, then fine - if ( guiCurrentSaveGameVersion >= CURRENT_SAVEGAME_DATATYPE_VERSION) + if ( guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE) { //the info has changed at version 102 //first, load the POD @@ -1054,7 +1054,7 @@ BOOLEAN SOLDIERCREATE_STRUCT::Load(HWFILE hFile, int versionToLoad, bool loadChe OLD_SOLDIERCREATE_STRUCT_101 OldSavedSoldierInfo101; //we are loading an older version (only load once, so use "else if") //first load the data based on what version was stored - if ( guiCurrentSaveGameVersion < FIRST_SAVEGAME_DATATYPE_CHANGE ) + if ( guiCurrentSaveGameVersion < NIV_SAVEGAME_DATATYPE_CHANGE ) { if ( !FileRead( hFile, &OldSavedSoldierInfo101, SIZEOF_OLD_SOLDIERCREATE_STRUCT_101_POD, &uiNumBytesRead ) ) { @@ -1069,7 +1069,7 @@ BOOLEAN SOLDIERCREATE_STRUCT::Load(HWFILE hFile, int versionToLoad, bool loadChe */ //now we have the data that needs to be converted (keep on converting up, so use "if") - if ( guiCurrentSaveGameVersion < FIRST_SAVEGAME_DATATYPE_CHANGE ) + if ( guiCurrentSaveGameVersion < NIV_SAVEGAME_DATATYPE_CHANGE ) { OldSavedSoldierInfo101.CopyOldInventoryToNew(); *this = OldSavedSoldierInfo101; @@ -1130,7 +1130,7 @@ BOOLEAN MERCPROFILESTRUCT::Load(HWFILE hFile, bool forceLoadOldVersion, bool for this->initialize(); //if we are at the most current version, then fine - if ( guiCurrentSaveGameVersion >= CURRENT_SAVEGAME_DATATYPE_VERSION && forceLoadOldVersion == false) + if ( guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE && forceLoadOldVersion == false) { if ( !FileRead( hFile, this, SIZEOF_MERCPROFILESTRUCT_POD, &uiNumBytesRead ) ) { @@ -1173,7 +1173,7 @@ BOOLEAN MERCPROFILESTRUCT::Load(HWFILE hFile, bool forceLoadOldVersion, bool for { //we are loading an older version (only load once, so use "else if") //first load the data based on what version was stored - if ( guiCurrentSaveGameVersion < FIRST_SAVEGAME_DATATYPE_CHANGE || forceLoadOldVersion == true) + if ( guiCurrentSaveGameVersion < NIV_SAVEGAME_DATATYPE_CHANGE || forceLoadOldVersion == true) { OLD_MERCPROFILESTRUCT_101 old; typedef BOOLEAN (*functionPtr) ( HWFILE hFile, PTR pDest, UINT32 uiBytesToRead, UINT32 *puiBytesRead ); @@ -1286,18 +1286,68 @@ BOOLEAN SOLDIERTYPE::Save(HWFILE hFile) return TRUE; } +INT32 ReadFieldByField(HWFILE hFile, PTR pDest, UINT32 uiFieldSize, UINT32 uiElementSize, UINT32 uiCurByteCount) +{ + UINT32 uiNumBytesRead; + char padding[10]; + UINT32 uiBytesRead = uiCurByteCount; // used to track our new byte count + UINT32 sampleBytesRead = uiBytesRead; // used to determine how much padding is needed + + while((sampleBytesRead % uiElementSize) > 0) // as long as we have a remainder + sampleBytesRead++; + + if(sampleBytesRead != uiBytesRead) // if we need padding + { + FileRead(hFile, &padding, (sampleBytesRead-uiBytesRead), &uiNumBytesRead ); + uiBytesRead += uiNumBytesRead; + } + + // the actual file read + FileRead(hFile, pDest, uiFieldSize, &uiNumBytesRead ); + uiBytesRead += uiNumBytesRead; + + return uiBytesRead; +} + BOOLEAN SOLDIERTYPE::Load(HWFILE hFile) { UINT32 uiNumBytesRead; + INT32 numBytesRead = 0; + char padding[10]; //if we are at the most current version, then fine - if ( guiCurrentSaveGameVersion >= CURRENT_SAVEGAME_DATATYPE_VERSION ) + if ( guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE ) { //the soldier type info has changed at version 102 + //CHRISL: It was further changed at version 104 to allow for 16bit action points for the 100AP system //first, load the POD - if ( !FileRead( hFile, this, SIZEOF_SOLDIERTYPE_POD, &uiNumBytesRead ) ) + if ( guiCurrentSaveGameVersion >= AP100_SAVEGAME_DATATYPE_CHANGE ) { - return(FALSE); + if ( !FileRead( hFile, this, SIZEOF_SOLDIERTYPE_POD, &uiNumBytesRead ) ) + { + return(FALSE); + } + } + else + { + numBytesRead = 0; + FileRead( hFile, this, (offsetof(SOLDIERTYPE, ubBodyType)+sizeof(ubBodyType)), &uiNumBytesRead ); + numBytesRead += uiNumBytesRead; + numBytesRead = ReadFieldByField(hFile, &this->bActionPoints, 1, 1, numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->bInitialActionPoints, 1, 1, numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->bOldLife, sizeof(bOldLife), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->bVisible, sizeof(bVisible), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->bActive, sizeof(bActive), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->bTeam, sizeof(bTeam), sizeof(INT8), numBytesRead); + //CHRISL: in the old structure, there are 3 padding bytes at this point in the file. We need to account for + // them before continuing. We also want to include them in our numBytesRead since they cover the changes + // caused by increasing two elements by 1byte each. This includes shifting one byte of padding + FileRead( hFile, padding, 3, &uiNumBytesRead ); + numBytesRead += uiNumBytesRead; + FileRead( hFile, &this->pTempObject, (SIZEOF_SOLDIERTYPE_POD-numBytesRead), &uiNumBytesRead ); + numBytesRead += uiNumBytesRead; + if(numBytesRead != SIZEOF_SOLDIERTYPE_POD) + return(FALSE); } //load the OO inventory @@ -1307,10 +1357,90 @@ BOOLEAN SOLDIERTYPE::Load(HWFILE hFile) } //load some structs, atm just POD but could change - if ( !FileRead( hFile, &this->aiData, sizeof(STRUCT_AIData), &uiNumBytesRead ) ) + //Load STRUCT_AIData + numBytesRead = 0; + numBytesRead = ReadFieldByField(hFile, &this->aiData.bOppList, sizeof(aiData.bOppList), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bLastAction, sizeof(aiData.bLastAction), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bAction, sizeof(aiData.bAction), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.usActionData, sizeof(aiData.usActionData), sizeof(UINT16), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bNextAction, sizeof(aiData.bNextAction), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.usNextActionData, sizeof(aiData.usNextActionData), sizeof(UINT16), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bActionInProgress, sizeof(aiData.bActionInProgress), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bAlertStatus, sizeof(aiData.bAlertStatus), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bOppCnt, sizeof(aiData.bOppCnt), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bNeutral, sizeof(aiData.bNeutral), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bNewSituation, sizeof(aiData.bNewSituation), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bNextTargetLevel, sizeof(aiData.bNextTargetLevel), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bOrders, sizeof(aiData.bOrders), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bAttitude, sizeof(aiData.bAttitude), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bUnderFire, sizeof(aiData.bUnderFire), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bShock, sizeof(aiData.bShock), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bUnderEscort, sizeof(aiData.bUnderEscort), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bBypassToGreen, sizeof(aiData.bBypassToGreen), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.ubLastMercToRadio, sizeof(aiData.ubLastMercToRadio), sizeof(UINT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bDominantDir, sizeof(aiData.bDominantDir), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bPatrolCnt, sizeof(aiData.bPatrolCnt), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bNextPatrolPnt, sizeof(aiData.bNextPatrolPnt), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.sPatrolGrid, sizeof(aiData.sPatrolGrid), sizeof(INT16), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.sNoiseGridno, sizeof(aiData.sNoiseGridno), sizeof(INT16), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.ubNoiseVolume, sizeof(aiData.ubNoiseVolume), sizeof(UINT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bLastAttackHit, sizeof(aiData.bLastAttackHit), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.ubXRayedBy, sizeof(aiData.ubXRayedBy), sizeof(UINT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.dHeightAdjustment, sizeof(aiData.dHeightAdjustment), sizeof(FLOAT), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bMorale, sizeof(aiData.bMorale), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bTeamMoraleMod, sizeof(aiData.bTeamMoraleMod), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bTacticalMoraleMod, sizeof(aiData.bTacticalMoraleMod), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bStrategicMoraleMod, sizeof(aiData.bStrategicMoraleMod), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bAIMorale, sizeof(aiData.bAIMorale), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.ubPendingAction, sizeof(aiData.ubPendingAction), sizeof(UINT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.ubPendingActionAnimCount, sizeof(aiData.ubPendingActionAnimCount), sizeof(UINT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.uiPendingActionData1, sizeof(aiData.uiPendingActionData1), sizeof(UINT32), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.sPendingActionData2, sizeof(aiData.sPendingActionData2), sizeof(INT16), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bPendingActionData3, sizeof(aiData.bPendingActionData3), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.ubDoorHandleCode, sizeof(aiData.ubDoorHandleCode), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.uiPendingActionData4, sizeof(aiData.uiPendingActionData4), sizeof(UINT32), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bInterruptDuelPts, sizeof(aiData.bInterruptDuelPts), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bPassedLastInterrupt, sizeof(aiData.bPassedLastInterrupt), sizeof(INT8), numBytesRead); + if ( guiCurrentSaveGameVersion >= AP100_SAVEGAME_DATATYPE_CHANGE ) + numBytesRead = ReadFieldByField(hFile, &this->aiData.bIntStartAPs, sizeof(aiData.bIntStartAPs), sizeof(INT8), numBytesRead); + else + numBytesRead = ReadFieldByField(hFile, &this->aiData.bIntStartAPs, 1, 1, numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bMoved, sizeof(aiData.bMoved), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bHunting, sizeof(aiData.bHunting), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.ubLastCall, sizeof(aiData.ubLastCall), sizeof(UINT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.ubCaller, sizeof(aiData.ubCaller), sizeof(UINT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.sCallerGridNo, sizeof(aiData.sCallerGridNo), sizeof(INT16), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bCallPriority, sizeof(aiData.bCallPriority), sizeof(UINT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bCallActedUpon, sizeof(aiData.bCallActedUpon), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bFrenzied, sizeof(aiData.bFrenzied), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bNormalSmell, sizeof(aiData.bNormalSmell), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bMonsterSmell, sizeof(aiData.bMonsterSmell), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bMobility, sizeof(aiData.bMobility), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bRTPCombat, sizeof(aiData.bRTPCombat), sizeof(INT8), numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.fAIFlags, sizeof(aiData.fAIFlags), sizeof(INT8), numBytesRead); + if ( guiCurrentSaveGameVersion >= AP100_SAVEGAME_DATATYPE_CHANGE ) + numBytesRead = ReadFieldByField(hFile, &this->aiData.bAimTime, sizeof(aiData.bAimTime), sizeof(INT8), numBytesRead); + else + numBytesRead = ReadFieldByField(hFile, &this->aiData.bAimTime, 1, 1, numBytesRead); + numBytesRead = ReadFieldByField(hFile, &this->aiData.bShownAimTime, sizeof(aiData.bShownAimTime), sizeof(INT8), numBytesRead); + //CHRISL: We also need to make sure the structure aligns properly and that we don't need to read any extra + // padding bytes + while((numBytesRead%__alignof(STRUCT_AIData)) > 0) { - return(FALSE); + FileRead( hFile, &padding, 1, &uiNumBytesRead ); + numBytesRead += uiNumBytesRead; } + if ( guiCurrentSaveGameVersion < AP100_SAVEGAME_DATATYPE_CHANGE ) + { + //CHRISL: Because we're increasing the size of two elements in this structure by 1byte each, we need to + // increase the size of numBytesRead by 2 so that our sizes match. However, we also need to increase the + // size of numBytesRead by another 2 so that the new structure alignment is accounted for. + numBytesRead += 4; + } + if(numBytesRead != sizeof(STRUCT_AIData)) + return(FALSE); + + //Load STRUCT_Flags if ( !FileRead( hFile, &this->flags, sizeof(STRUCT_Flags), &uiNumBytesRead ) ) { return(FALSE); @@ -1357,7 +1487,7 @@ BOOLEAN SOLDIERTYPE::Load(HWFILE hFile) pLoadingFunction = &NewJA2EncryptedFileRead; } - if ( guiCurrentSaveGameVersion < FIRST_SAVEGAME_DATATYPE_CHANGE ) + if ( guiCurrentSaveGameVersion < NIV_SAVEGAME_DATATYPE_CHANGE ) { OldSavedSoldierInfo101.initialize(); if ( !(*pLoadingFunction)( hFile, &OldSavedSoldierInfo101, SIZEOF_OLDSOLDIERTYPE_101_POD, &uiNumBytesRead ) ) @@ -1372,7 +1502,7 @@ BOOLEAN SOLDIERTYPE::Load(HWFILE hFile) */ //now we have the data that needs to be converted (keep on converting up, so use "if") - if ( guiCurrentSaveGameVersion < FIRST_SAVEGAME_DATATYPE_CHANGE ) + if ( guiCurrentSaveGameVersion < NIV_SAVEGAME_DATATYPE_CHANGE ) { OldSavedSoldierInfo101.CopyOldInventoryToNew(); (*this) = OldSavedSoldierInfo101; @@ -1432,7 +1562,7 @@ BOOLEAN WORLDITEM::Load(HWFILE hFile) { UINT32 uiNumBytesRead; //if we are at the most current version, then fine - if ( guiCurrentSaveGameVersion >= CURRENT_SAVEGAME_DATATYPE_VERSION ) + if ( guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE ) { //load the POD if ( !FileRead( hFile, this, SIZEOF_WORLDITEM_POD, &uiNumBytesRead ) ) @@ -1450,7 +1580,7 @@ BOOLEAN WORLDITEM::Load(HWFILE hFile) else { //load the old data into a suitable structure, it's just POD OLD_WORLDITEM_101 oldWorldItem; - if ( guiCurrentSaveGameVersion < FIRST_SAVEGAME_DATATYPE_CHANGE ) + if ( guiCurrentSaveGameVersion < NIV_SAVEGAME_DATATYPE_CHANGE ) { if ( !FileRead( hFile, &oldWorldItem, sizeof(OLD_WORLDITEM_101), &uiNumBytesRead ) ) { @@ -1460,7 +1590,7 @@ BOOLEAN WORLDITEM::Load(HWFILE hFile) //now we have the data that needs to be converted (keep on converting up, so use "if") //the first conversion is simple enough that it can be done here - if ( guiCurrentSaveGameVersion < FIRST_SAVEGAME_DATATYPE_CHANGE ) + if ( guiCurrentSaveGameVersion < NIV_SAVEGAME_DATATYPE_CHANGE ) { *this = oldWorldItem; } @@ -1473,7 +1603,7 @@ BOOLEAN StackedObjectData::Load( INT8** hBuffer, float dMajorMapVersion, UINT8 u //when this function is called, the file has been loaded into a buffer using FileRead //if we are at the most current version, then fine //but we can also be loading this from a map that is up to date when the savegame isn't! - if ( guiCurrentSaveGameVersion >= CURRENT_SAVEGAME_DATATYPE_VERSION + if ( guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE || (dMajorMapVersion == gdMajorMapVersion && gubMinorMapVersion == ubMinorMapVersion)) { int size; @@ -1497,7 +1627,7 @@ BOOLEAN StackedObjectData::Load( HWFILE hFile ) { UINT32 uiNumBytesRead; //if we are at the most current version, then fine - if ( guiCurrentSaveGameVersion >= CURRENT_SAVEGAME_DATATYPE_VERSION ) + if ( guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE ) { if ( !FileRead( hFile, &(this->data), sizeof(ObjectData), &uiNumBytesRead ) ) { @@ -1559,7 +1689,7 @@ BOOLEAN OBJECTTYPE::Load( HWFILE hFile ) UINT32 uiNumBytesRead; //if we are at the most current version, then fine - if ( guiCurrentSaveGameVersion >= CURRENT_SAVEGAME_DATATYPE_VERSION ) + if ( guiCurrentSaveGameVersion >= NIV_SAVEGAME_DATATYPE_CHANGE ) { if ( !FileRead( hFile, this, SIZEOF_OBJECTTYPE_POD, &uiNumBytesRead ) ) { @@ -1590,7 +1720,7 @@ BOOLEAN OBJECTTYPE::Load( HWFILE hFile ) OLD_OBJECTTYPE_101 OldSavedObject101; //we are loading an older version (only load once, so use "else if") //first load the data based on what version was stored - if ( guiCurrentSaveGameVersion < FIRST_SAVEGAME_DATATYPE_CHANGE ) + if ( guiCurrentSaveGameVersion < NIV_SAVEGAME_DATATYPE_CHANGE ) { if ( !FileRead( hFile, &OldSavedObject101, sizeof(OLD_OBJECTTYPE_101), &uiNumBytesRead ) ) { @@ -1603,7 +1733,7 @@ BOOLEAN OBJECTTYPE::Load( HWFILE hFile ) */ //now we have the data that needs to be converted (keep on converting up, so use "if") - if ( guiCurrentSaveGameVersion < FIRST_SAVEGAME_DATATYPE_CHANGE ) + if ( guiCurrentSaveGameVersion < NIV_SAVEGAME_DATATYPE_CHANGE ) { (*this) = OldSavedObject101; //OldSavedObject999 = OldSavedObject101; @@ -2894,7 +3024,7 @@ BOOLEAN LoadSavedGame( UINT8 ubSavedGameID ) guiBrokenSaveGameVersion = SaveGameHeader.uiSavedGameVersion; // CHRISL: We need to know what inventory system we're using early on - if(SaveGameHeader.uiSavedGameVersion < FIRST_SAVEGAME_DATATYPE_CHANGE) + if(SaveGameHeader.uiSavedGameVersion < NIV_SAVEGAME_DATATYPE_CHANGE) SaveGameHeader.ubInventorySystem = 0; gGameOptions.ubInventorySystem = SaveGameHeader.ubInventorySystem; if((UsingNewInventorySystem() == true)) diff --git a/Strategic/mapscreen.cpp b/Strategic/mapscreen.cpp index e8ed779f..ba7177f5 100644 --- a/Strategic/mapscreen.cpp +++ b/Strategic/mapscreen.cpp @@ -10590,7 +10590,11 @@ void RebuildWayPointsForAllSelectedCharsGroups( void ) else { // mercs on foot - ppMovePath = &( Menptr[gCharactersList[ bSelectedDestChar ].usSolID].pMercPath ); + /*CHRISL: I don't understand why we're using bSelectedDestChar to generate the ppMovePath but iCounter to + generate ubGroupId. For vehicles, we use the iVhicleId to generate both. Shouldn't we be using the + same system here? Meaning, shouldn't ppMovePath be generated with the soldier indicated with iCounter?*/ + //ppMovePath = &( Menptr[gCharactersList[ bSelectedDestChar ].usSolID].pMercPath ); + ppMovePath = &( pSoldier->pMercPath ); ubGroupId = pSoldier->ubGroupID; } diff --git a/Strategic/strategicmap.cpp b/Strategic/strategicmap.cpp index 9cbd41e5..a5299837 100644 --- a/Strategic/strategicmap.cpp +++ b/Strategic/strategicmap.cpp @@ -1196,11 +1196,11 @@ BOOLEAN ReadInStrategicMapSectorTownNames(STR fileName, BOOLEAN localizedVersion XML_SetCharacterDataHandler(parser, citytableCharacterDataHandle); - memset(&pData,0,sizeof(pData)); - // TODO: ROMAN //pData.curCityInfo + + memset(&pData,0,sizeof(pData)); NUM_TOWNS = 0; XML_SetUserData(parser, &pData); @@ -1778,7 +1778,9 @@ BOOLEAN SetCurrentWorldSector( INT16 sMapX, INT16 sMapY, INT8 bMapZ ) //CHRISL: We should only bother with this assertion if the soldier is alive. Dead soliders are moved to // GridNo = NOWHERE, which causes this assertion to fail if(!(MercPtrs[i]->flags.uiStatusFlags & SOLDIER_DEAD)) + { Assert( !MercPtrs[i]->bActive || !MercPtrs[i]->bInSector || MercPtrs[i]->sGridNo != NOWHERE || MercPtrs[i]->bVehicleID == iHelicopterVehicleId ); + } } if( gubNumCreaturesAttackingTown && !gbWorldSectorZ && @@ -1820,7 +1822,9 @@ BOOLEAN SetCurrentWorldSector( INT16 sMapX, INT16 sMapY, INT8 bMapZ ) //CHRISL: We should only bother with this assertion if the soldier is alive. Dead soliders are moved to // GridNo = NOWHERE, which causes this assertion to fail if(!(MercPtrs[i]->flags.uiStatusFlags & SOLDIER_DEAD)) + { Assert( !MercPtrs[i]->bActive || !MercPtrs[i]->bInSector || MercPtrs[i]->sGridNo != NOWHERE || MercPtrs[i]->bVehicleID == iHelicopterVehicleId ); + } } return( TRUE ); diff --git a/Strategic/strategicmap.h b/Strategic/strategicmap.h index 222f5d3f..fe956f8b 100644 --- a/Strategic/strategicmap.h +++ b/Strategic/strategicmap.h @@ -183,4 +183,4 @@ extern INT8 gbGreenToRegPromotions; extern INT8 gbRegToElitePromotions; extern INT8 gbMilitiaPromotions; -#endif \ No newline at end of file +#endif diff --git a/Tactical/Animation Control.cpp b/Tactical/Animation Control.cpp index 659d9154..f0c21882 100644 --- a/Tactical/Animation Control.cpp +++ b/Tactical/Animation Control.cpp @@ -964,38 +964,40 @@ ANI_SPEED_DEF gubAnimWalkSpeeds[ TOTALBODYTYPES ] = -10, (FLOAT)4.0, //JEEP }; +extern INT16 gubMaxActionPoints[TOTALBODYTYPES] = {0}; +/* UINT8 gubMaxActionPoints[ TOTALBODYTYPES ] = { - AP_MAXIMUM, //REGMALE - AP_MAXIMUM, //BIGMALE - AP_MAXIMUM, //STOCKYMALE - AP_MAXIMUM, //REGFEMALE - AP_MONSTER_MAXIMUM, //ADULTMONSTER - AP_MONSTER_MAXIMUM, //ADULTMONSTER - AP_MONSTER_MAXIMUM, //ADULTMONSTER - AP_MONSTER_MAXIMUM, //ADULTMONSTER - AP_MONSTER_MAXIMUM, //ADULTMONSTER - AP_MONSTER_MAXIMUM, //INFANT - AP_MONSTER_MAXIMUM, //QUEEN MONSTER - AP_MAXIMUM, //FATCIV - AP_MAXIMUM, //MANCIV - AP_MAXIMUM, //MINICIV - AP_MAXIMUM, //DRESSCIV - AP_MAXIMUM, //HAT KID - AP_MAXIMUM, //NOHAT KID - AP_MAXIMUM, //CRIPPLE - AP_MAXIMUM, //COW - AP_MAXIMUM, //CROW - AP_MAXIMUM, //BLOOD CAT - AP_MAXIMUM, // ROBOT1 - AP_VEHICLE_MAXIMUM, //HUMVEE - AP_VEHICLE_MAXIMUM, //TANK1 - AP_VEHICLE_MAXIMUM, //TANK2 - AP_VEHICLE_MAXIMUM, //ELDORADO - AP_VEHICLE_MAXIMUM, //ICECREAMTRUCK - AP_VEHICLE_MAXIMUM, //JEEP + APBPConstants[AP_MAXIMUM], //REGMALE + APBPConstants[AP_MAXIMUM], //BIGMALE + APBPConstants[AP_MAXIMUM], //STOCKYMALE + APBPConstants[AP_MAXIMUM], //REGFEMALE + APBPConstants[AP_MONSTER_MAXIMUM], //ADULTMONSTER + APBPConstants[AP_MONSTER_MAXIMUM], //ADULTMONSTER + APBPConstants[AP_MONSTER_MAXIMUM], //ADULTMONSTER + APBPConstants[AP_MONSTER_MAXIMUM], //ADULTMONSTER + APBPConstants[AP_MONSTER_MAXIMUM], //ADULTMONSTER + APBPConstants[AP_MONSTER_MAXIMUM], //INFANT + APBPConstants[AP_MONSTER_MAXIMUM], //QUEEN MONSTER + APBPConstants[AP_MAXIMUM], //FATCIV + APBPConstants[AP_MAXIMUM], //MANCIV + APBPConstants[AP_MAXIMUM], //MINICIV + APBPConstants[AP_MAXIMUM], //DRESSCIV + APBPConstants[AP_MAXIMUM], //HAT KID + APBPConstants[AP_MAXIMUM], //NOHAT KID + APBPConstants[AP_MAXIMUM], //CRIPPLE + APBPConstants[AP_MAXIMUM], //COW + APBPConstants[AP_MAXIMUM], //CROW + APBPConstants[AP_MAXIMUM], //BLOOD CAT + APBPConstants[AP_MAXIMUM], // ROBOT1 + APBPConstants[AP_VEHICLE_MAXIMUM], //HUMVEE + APBPConstants[AP_VEHICLE_MAXIMUM], //TANK1 + APBPConstants[AP_VEHICLE_MAXIMUM], //TANK2 + APBPConstants[AP_VEHICLE_MAXIMUM], //ELDORADO + APBPConstants[AP_VEHICLE_MAXIMUM], //ICECREAMTRUCK + APBPConstants[AP_VEHICLE_MAXIMUM], //JEEP }; - +*/ ANI_SPEED_DEF gubAnimRunSpeeds[ TOTALBODYTYPES ] = { diff --git a/Tactical/Animation Control.h b/Tactical/Animation Control.h index 9278ec89..eaf92b23 100644 --- a/Tactical/Animation Control.h +++ b/Tactical/Animation Control.h @@ -556,7 +556,7 @@ extern ANI_SPEED_DEF gubAnimWalkSpeeds[ TOTALBODYTYPES ]; extern ANI_SPEED_DEF gubAnimRunSpeeds[ TOTALBODYTYPES ]; extern ANI_SPEED_DEF gubAnimSwatSpeeds[ TOTALBODYTYPES ]; extern ANI_SPEED_DEF gubAnimCrawlSpeeds[ TOTALBODYTYPES ]; -extern UINT8 gubMaxActionPoints[ TOTALBODYTYPES ]; +extern INT16 gubMaxActionPoints[ TOTALBODYTYPES ]; // OK, this array contains definitions for random animations based on bodytype, total # allowed, and what is in their hand.... diff --git a/Tactical/DisplayCover.cpp b/Tactical/DisplayCover.cpp index 9cf2ef1f..498e896d 100644 --- a/Tactical/DisplayCover.cpp +++ b/Tactical/DisplayCover.cpp @@ -469,7 +469,7 @@ INT8 CalcCoverForGridNoBasedOnTeamKnownEnemies( SOLDIERTYPE *pSoldier, INT16 sTa } iGetThrough = SoldierToLocationChanceToGetThrough( pOpponent, sTargetGridNo, pSoldier->pathing.bLevel, bStance, NOBODY ); -// iBulletGetThrough = CalcChanceToHitGun( pOpponent, sTargetGridNo, AP_MAX_AIM_ATTACK, AIM_SHOT_TORSO ); +// iBulletGetThrough = CalcChanceToHitGun( pOpponent, sTargetGridNo, APBPConstants[AP_MAX_AIM_ATTACK], AIM_SHOT_TORSO ); if( WeaponInHand( pOpponent ) ) { @@ -635,7 +635,7 @@ void DisplayRangeToTarget( SOLDIERTYPE *pSoldier, INT16 sTargetGridNo ) //AXP 30.03.2007: Fix CtH calculation for first shot after changing aim level (roof/ground) INT8 bTempTargetLevel = pSoldier->bTargetLevel; pSoldier->bTargetLevel = (INT8)gsInterfaceLevel; - uiHitChance = CalcChanceToHitGun( pSoldier, sTargetGridNo, (INT8)(pSoldier->aiData.bShownAimTime ), pSoldier->bAimShotLocation ); + uiHitChance = CalcChanceToHitGun( pSoldier, sTargetGridNo, (pSoldier->aiData.bShownAimTime ), pSoldier->bAimShotLocation ); pSoldier->bTargetLevel = bTempTargetLevel; swprintf( zOutputString, zNewTacticalMessages[ TCTL_MSG__GUN_RANGE_AND_CTH ], Weapon[ pSoldier->inv[HANDPOS].usItem ].usRange / 10, uiHitChance ); diff --git a/Tactical/Drugs And Alcohol.cpp b/Tactical/Drugs And Alcohol.cpp index d9e6f78a..d64518a7 100644 --- a/Tactical/Drugs And Alcohol.cpp +++ b/Tactical/Drugs And Alcohol.cpp @@ -342,7 +342,7 @@ INT8 GetDrugSideEffect( SOLDIERTYPE *pSoldier, UINT8 ubDrugType ) } } -void HandleAPEffectDueToDrugs( SOLDIERTYPE *pSoldier, UINT8 *pubPoints ) +void HandleAPEffectDueToDrugs( SOLDIERTYPE *pSoldier, INT16 *pubPoints ) { INT8 bDrunkLevel; INT16 sPoints = (*pubPoints); @@ -358,9 +358,9 @@ void HandleAPEffectDueToDrugs( SOLDIERTYPE *pSoldier, UINT8 *pubPoints ) // Adjust! sPoints -= pSoldier->drugs.bDrugSideEffect[ DRUG_TYPE_ADRENALINE ]; - if ( sPoints < AP_MINIMUM ) + if ( sPoints < APBPConstants[APBPConstants[APBPConstants[AP_MINIMUM]]] ) { - sPoints = AP_MINIMUM; + sPoints = APBPConstants[APBPConstants[APBPConstants[AP_MINIMUM]]]; } } @@ -371,13 +371,13 @@ void HandleAPEffectDueToDrugs( SOLDIERTYPE *pSoldier, UINT8 *pubPoints ) // Reduce.... sPoints -= HANGOVER_AP_REDUCE; - if ( sPoints < AP_MINIMUM ) + if ( sPoints < APBPConstants[APBPConstants[APBPConstants[AP_MINIMUM]]] ) { - sPoints = AP_MINIMUM; + sPoints = APBPConstants[APBPConstants[APBPConstants[AP_MINIMUM]]]; } } - (*pubPoints) = (UINT8)sPoints; + (*pubPoints) = sPoints; } @@ -389,12 +389,12 @@ void HandleBPEffectDueToDrugs( SOLDIERTYPE *pSoldier, INT16 *psPointReduction ) if ( pSoldier->drugs.bDrugEffect[ DRUG_TYPE_ADRENALINE ] ) { // Adjust! - (*psPointReduction) -= ( pSoldier->drugs.bDrugEffect[ DRUG_TYPE_ADRENALINE ] * BP_RATIO_RED_PTS_TO_NORMAL ); + (*psPointReduction) -= ( pSoldier->drugs.bDrugEffect[ DRUG_TYPE_ADRENALINE ] * APBPConstants[BP_RATIO_RED_PTS_TO_NORMAL] ); } else if ( pSoldier->drugs.bDrugSideEffect[ DRUG_TYPE_ADRENALINE ] ) { // Adjust! - (*psPointReduction) += ( pSoldier->drugs.bDrugSideEffect[ DRUG_TYPE_ADRENALINE ] * BP_RATIO_RED_PTS_TO_NORMAL ); + (*psPointReduction) += ( pSoldier->drugs.bDrugSideEffect[ DRUG_TYPE_ADRENALINE ] * APBPConstants[BP_RATIO_RED_PTS_TO_NORMAL] ); } bDrunkLevel = GetDrunkLevel( pSoldier ); diff --git a/Tactical/Drugs And Alcohol.h b/Tactical/Drugs And Alcohol.h index a8b5920f..4340fa38 100644 --- a/Tactical/Drugs And Alcohol.h +++ b/Tactical/Drugs And Alcohol.h @@ -21,7 +21,7 @@ UINT8 GetDrugType( UINT16 usItem ); BOOLEAN ApplyDrugs( SOLDIERTYPE *pSoldier, OBJECTTYPE *pObject ); void HandleEndTurnDrugAdjustments( SOLDIERTYPE *pSoldier ); -void HandleAPEffectDueToDrugs( SOLDIERTYPE *pSoldier, UINT8 *pubPoints ); +void HandleAPEffectDueToDrugs( SOLDIERTYPE *pSoldier, INT16 *pubPoints ); void HandleBPEffectDueToDrugs( SOLDIERTYPE *pSoldier, INT16 *psPoints ); @@ -32,4 +32,4 @@ INT32 EffectStatForBeingDrunk( SOLDIERTYPE *pSoldier, INT32 iStat ); BOOLEAN MercUnderTheInfluence( SOLDIERTYPE *pSoldier ); -#endif \ No newline at end of file +#endif diff --git a/Tactical/Faces.cpp b/Tactical/Faces.cpp index 426bb9e3..f147996a 100644 --- a/Tactical/Faces.cpp +++ b/Tactical/Faces.cpp @@ -1815,7 +1815,7 @@ void HandleAutoFaces( ) FACETYPE *pFace; INT8 bLife; INT8 bInSector; - INT8 bAPs; + INT16 bAPs; BOOLEAN fRerender = FALSE; BOOLEAN fHandleFace; BOOLEAN fHandleUIHatch; diff --git a/Tactical/Handle Doors.cpp b/Tactical/Handle Doors.cpp index f5c62f6d..55363ef7 100644 --- a/Tactical/Handle Doors.cpp +++ b/Tactical/Handle Doors.cpp @@ -475,8 +475,8 @@ BOOLEAN HandleOpenableStruct( SOLDIERTYPE *pSoldier, INT16 sGridNo, STRUCTURE *p if ( pStructure->fFlags & STRUCTURE_OPEN ) { // Set costs for these - sAPCost = AP_OPEN_DOOR; - sBPCost = BP_OPEN_DOOR; + sAPCost = APBPConstants[AP_OPEN_DOOR]; + sBPCost = APBPConstants[BP_OPEN_DOOR]; fHandleDoor = TRUE; } @@ -500,8 +500,8 @@ BOOLEAN HandleOpenableStruct( SOLDIERTYPE *pSoldier, INT16 sGridNo, STRUCTURE *p // Set costs for these // Set AP costs to that of opening a door - sAPCost = AP_OPEN_DOOR; - sBPCost = BP_OPEN_DOOR; + sAPCost = APBPConstants[AP_OPEN_DOOR]; + sBPCost = APBPConstants[BP_OPEN_DOOR]; pSoldier->ChangeSoldierState( GetAnimStateForInteraction( pSoldier, fDoor, END_OPEN_DOOR ), 0, FALSE ); @@ -584,8 +584,8 @@ BOOLEAN HandleOpenableStruct( SOLDIERTYPE *pSoldier, INT16 sGridNo, STRUCTURE *p if ( pDoor == NULL ) { // Set costs for these - sAPCost = AP_OPEN_DOOR; - sBPCost = BP_OPEN_DOOR; + sAPCost = APBPConstants[AP_OPEN_DOOR]; + sBPCost = APBPConstants[BP_OPEN_DOOR]; // Open if it's not locked.... pSoldier->ChangeSoldierState( GetAnimStateForInteraction( pSoldier, fDoor, END_OPEN_DOOR ), 0, FALSE ); @@ -623,8 +623,8 @@ BOOLEAN HandleOpenableStruct( SOLDIERTYPE *pSoldier, INT16 sGridNo, STRUCTURE *p case HANDLE_DOOR_FORCE: // Set costs for these - sAPCost = AP_BOOT_DOOR; - sBPCost = BP_BOOT_DOOR; + sAPCost = APBPConstants[AP_BOOT_DOOR]; + sBPCost = APBPConstants[BP_BOOT_DOOR]; // OK, using force, if we have no lock, just open the door! if ( pDoor == NULL ) @@ -656,8 +656,8 @@ BOOLEAN HandleOpenableStruct( SOLDIERTYPE *pSoldier, INT16 sGridNo, STRUCTURE *p case HANDLE_DOOR_CROWBAR: // Set costs for these - sAPCost = AP_USE_CROWBAR; - sBPCost = BP_USE_CROWBAR; + sAPCost = APBPConstants[AP_USE_CROWBAR]; + sBPCost = APBPConstants[BP_USE_CROWBAR]; // OK, using force, if we have no lock, just open the door! if ( pDoor == NULL ) @@ -689,8 +689,8 @@ BOOLEAN HandleOpenableStruct( SOLDIERTYPE *pSoldier, INT16 sGridNo, STRUCTURE *p case HANDLE_DOOR_EXPLODE: // Set costs for these - sAPCost = AP_EXPLODE_DOOR; - sBPCost = BP_EXPLODE_DOOR; + sAPCost = APBPConstants[AP_EXPLODE_DOOR]; + sBPCost = APBPConstants[BP_EXPLODE_DOOR]; if ( pDoor == NULL ) { @@ -717,8 +717,8 @@ BOOLEAN HandleOpenableStruct( SOLDIERTYPE *pSoldier, INT16 sGridNo, STRUCTURE *p case HANDLE_DOOR_LOCKPICK: // Set costs for these - sAPCost = AP_PICKLOCK; - sBPCost = BP_PICKLOCK; + sAPCost = APBPConstants[AP_PICKLOCK]; + sBPCost = APBPConstants[BP_PICKLOCK]; // Attempt to pick lock if ( pDoor == NULL ) @@ -745,8 +745,8 @@ BOOLEAN HandleOpenableStruct( SOLDIERTYPE *pSoldier, INT16 sGridNo, STRUCTURE *p case HANDLE_DOOR_EXAMINE: // Set costs for these - sAPCost = AP_EXAMINE_DOOR; - sBPCost = BP_EXAMINE_DOOR; + sAPCost = APBPConstants[AP_EXAMINE_DOOR]; + sBPCost = APBPConstants[BP_EXAMINE_DOOR]; // Attempt to examine door // Whatever the result, end the open animation @@ -788,8 +788,8 @@ BOOLEAN HandleOpenableStruct( SOLDIERTYPE *pSoldier, INT16 sGridNo, STRUCTURE *p case HANDLE_DOOR_UNLOCK: // Set costs for these - sAPCost = AP_UNLOCK_DOOR; - sBPCost = BP_UNLOCK_DOOR; + sAPCost = APBPConstants[AP_UNLOCK_DOOR]; + sBPCost = APBPConstants[BP_UNLOCK_DOOR]; // OK, if we have no lock, show that! if ( pDoor == NULL ) @@ -834,8 +834,8 @@ BOOLEAN HandleOpenableStruct( SOLDIERTYPE *pSoldier, INT16 sGridNo, STRUCTURE *p case HANDLE_DOOR_UNTRAP: // Set costs for these - sAPCost = AP_UNTRAP_DOOR; - sBPCost = BP_UNTRAP_DOOR; + sAPCost = APBPConstants[AP_UNTRAP_DOOR]; + sBPCost = APBPConstants[BP_UNTRAP_DOOR]; // OK, if we have no lock, show that! if ( pDoor == NULL ) @@ -891,8 +891,8 @@ BOOLEAN HandleOpenableStruct( SOLDIERTYPE *pSoldier, INT16 sGridNo, STRUCTURE *p case HANDLE_DOOR_LOCK: // Set costs for these - sAPCost = AP_LOCK_DOOR; - sBPCost = BP_LOCK_DOOR; + sAPCost = APBPConstants[AP_LOCK_DOOR]; + sBPCost = APBPConstants[BP_LOCK_DOOR]; // OK, if we have no lock, show that! if ( pDoor == NULL ) @@ -931,8 +931,8 @@ BOOLEAN HandleOpenableStruct( SOLDIERTYPE *pSoldier, INT16 sGridNo, STRUCTURE *p else { // Set costs for these - sAPCost = AP_OPEN_DOOR; - sBPCost = BP_OPEN_DOOR; + sAPCost = APBPConstants[AP_OPEN_DOOR]; + sBPCost = APBPConstants[BP_OPEN_DOOR]; // Open if it's not locked.... pSoldier->ChangeSoldierState( GetAnimStateForInteraction( pSoldier, fDoor, END_OPEN_DOOR ), 0, FALSE ); diff --git a/Tactical/Handle Items.cpp b/Tactical/Handle Items.cpp index 731d812b..77fe3721 100644 --- a/Tactical/Handle Items.cpp +++ b/Tactical/Handle Items.cpp @@ -1083,7 +1083,7 @@ INT32 HandleItem( SOLDIERTYPE *pSoldier, INT16 sGridNo, INT8 bLevel, UINT16 usHa if ( sActionGridNo != -1 ) { // Calculate AP costs... - sAPCost = AP_ATTACH_CAN; + sAPCost = APBPConstants[AP_ATTACH_CAN]; sAPCost += PlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, FALSE, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints); if ( EnoughPoints( pSoldier, sAPCost, 0, fFromUI ) ) @@ -1134,7 +1134,7 @@ INT32 HandleItem( SOLDIERTYPE *pSoldier, INT16 sGridNo, INT8 bLevel, UINT16 usHa // Check for remote detonator cursor.... if ( Item[ usHandItem ].ubCursor == REMOTECURS ) { - sAPCost = AP_USE_REMOTE; + sAPCost = APBPConstants[AP_USE_REMOTE]; if ( EnoughPoints( pSoldier, sAPCost, 0, fFromUI ) ) { @@ -1984,7 +1984,24 @@ void HandleSoldierPickupItem( SOLDIERTYPE *pSoldier, INT32 iItemIndex, INT16 sGr gfDisarmingBuriedBomb = TRUE; gbTrapDifficulty = gWorldItems[ iItemIndex ].object[0]->data.bTrap; - DoMessageBox( MSG_BOX_BASIC_STYLE, TacticalStr[ DISARM_TRAP_PROMPT ], GAME_SCREEN, ( UINT8 )MSG_BOX_FLAG_YESNO, BoobyTrapMessageBoxCallBack, NULL ); + wchar_t * ptr; + if((gTacticalStatus.uiFlags & INCOMBAT) || (gTacticalStatus.fEnemyInSector)) + { + wchar_t * string = L" ("; + wchar_t string2[20]; + + ptr = wcscat(TacticalStr[ DISARM_TRAP_PROMPT ], string); + _ltow(APBPConstants[AP_DISARM_MINE], string2, 10); + ptr = wcscat(TacticalStr[ DISARM_TRAP_PROMPT ], string2); + string = L"AP)"; + ptr = wcscat(TacticalStr[ DISARM_TRAP_PROMPT ], string); + } + else + { + ptr = wcscat(TacticalStr[ DISARM_TRAP_PROMPT ], L""); + } + + DoMessageBox( MSG_BOX_BASIC_STYLE, ptr, GAME_SCREEN, ( UINT8 )MSG_BOX_FLAG_YESNO, BoobyTrapMessageBoxCallBack, NULL ); } else { @@ -3962,7 +3979,7 @@ void SoldierGiveItemFromAnimation( SOLDIERTYPE *pSoldier ) ubTargetMercID = (UINT8)pSoldier->aiData.uiPendingActionData4; // ATE: Deduct APs! - DeductPoints( pSoldier, AP_PICKUP_ITEM, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_PICKUP_ITEM], 0 ); if ( VerifyGiveItem( pSoldier, &pTSoldier ) ) { @@ -4512,6 +4529,15 @@ void BoobyTrapMessageBoxCallBack( UINT8 ubExitValue ) // Snap: make it easier to disarm our own traps. // If we succede - we get exp, but if we fail - we pay fair and square! + //CHRISL: first things first. If we're in combat, we need to spend some APs to disarm the device + if((gTacticalStatus.uiFlags & INCOMBAT) || (gTacticalStatus.fEnemyInSector)) + { + if(EnoughPoints(gpBoobyTrapSoldier, APBPConstants[AP_DISARM_MINE], APBPConstants[BP_DISARM_MINE], TRUE)) + DeductPoints(gpBoobyTrapSoldier, APBPConstants[AP_DISARM_MINE], APBPConstants[BP_DISARM_MINE]); + else + return; + } + // NB owner grossness... bombs 'owned' by the enemy are stored with side value 1 in // the map. So if we want to detect a bomb placed by the player, owner is > 1, and // owner - 2 gives the ID of the character who planted it @@ -5254,7 +5280,7 @@ INT16 FindNearestAvailableGridNoForItem( INT16 sSweetGridNo, INT8 ubRadius ) INT32 leftmost; BOOLEAN fFound = FALSE; SOLDIERTYPE soldier; - UINT8 ubSaveNPCAPBudget; + INT16 ubSaveNPCAPBudget; UINT8 ubSaveNPCDistLimit; cnt3 = 0; diff --git a/Tactical/Handle UI Plan.cpp b/Tactical/Handle UI Plan.cpp index 9af0ad42..f5b3e150 100644 --- a/Tactical/Handle UI Plan.cpp +++ b/Tactical/Handle UI Plan.cpp @@ -67,7 +67,7 @@ BOOLEAN AddUIPlan( INT16 sGridNo, UINT8 ubPlanID ) // Adjust for running if we are not already running if ( gpUIPlannedSoldier->usUIMovementMode == RUNNING ) { - sAPCost += AP_START_RUN_COST; + sAPCost += APBPConstants[AP_START_RUN_COST]; } if ( EnoughPoints( gpUIPlannedSoldier, sAPCost, 0, FALSE ) ) @@ -142,7 +142,7 @@ BOOLEAN AddUIPlan( INT16 sGridNo, UINT8 ubPlanID ) } else if ( ubPlanID == UIPLAN_ACTION_FIRE ) { - sAPCost = CalcTotalAPsToAttack( gpUIPlannedSoldier, sGridNo, TRUE, (INT8)(gpUIPlannedSoldier->aiData.bShownAimTime ) ); + sAPCost = CalcTotalAPsToAttack( gpUIPlannedSoldier, sGridNo, TRUE, (INT16)(gpUIPlannedSoldier->aiData.bShownAimTime ) ); // Get XY from Gridno ConvertGridNoToCenterCellXY( sGridNo, &sXPos, &sYPos ); diff --git a/Tactical/Handle UI.cpp b/Tactical/Handle UI.cpp index 68ba3b45..647ccb9c 100644 --- a/Tactical/Handle UI.cpp +++ b/Tactical/Handle UI.cpp @@ -2932,7 +2932,7 @@ BOOLEAN SelectedMercCanAffordAttack( ) sTargetGridNo = sMapPos; } - sAPCost = CalcTotalAPsToAttack( pSoldier, sTargetGridNo, TRUE, (INT8)(pSoldier->aiData.bShownAimTime ) ); + sAPCost = CalcTotalAPsToAttack( pSoldier, sTargetGridNo, TRUE, (INT16)(pSoldier->aiData.bShownAimTime ) ); if ( EnoughPoints( pSoldier, sAPCost, 0, TRUE ) ) { @@ -3861,7 +3861,7 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, INT16 sMapPos, UINT32 uiFlags ) sActionGridNo = FindAdjacentGridEx( pSoldier, sIntTileGridNo, &ubDirection, NULL, FALSE, TRUE ); if ( sActionGridNo != -1 ) { - sAPCost = AP_ATTACH_CAN; + sAPCost = APBPConstants[AP_ATTACH_CAN]; sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints); if ( sActionGridNo != pSoldier->sGridNo ) @@ -4026,7 +4026,7 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, INT16 sMapPos, UINT32 uiFlags ) { sActionGridNo = sAdjustedGridNo; } - sAPCost += AP_STEAL_ITEM; + sAPCost += APBPConstants[AP_STEAL_ITEM]; // CJC August 13 2002: take into account stance in AP prediction if (!(PTR_STANDING)) { @@ -4043,7 +4043,10 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, INT16 sMapPos, UINT32 uiFlags ) } else if ( uiFlags == MOVEUI_TARGET_BOMB ) { - sAPCost += GetAPsToDropBomb( pSoldier ); + if(Item[pSoldier->inv[HANDPOS].usItem].mine == 1) + sAPCost += GetAPsToPlantMine( pSoldier ); + else + sAPCost += GetAPsToDropBomb( pSoldier ); sAPCost += UIPlotPath( pSoldier, sMapPos, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints ); gfUIHandleShowMoveGrid = TRUE; @@ -4087,12 +4090,12 @@ INT8 DrawUIMovementPath( SOLDIERTYPE *pSoldier, INT16 sMapPos, UINT32 uiFlags ) sAPCost += UIPlotPath( pSoldier, sActionGridNo, NO_COPYROUTE, fPlot, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints); if ( sAPCost != 0 ) { - sAPCost += AP_PICKUP_ITEM; + sAPCost += APBPConstants[AP_PICKUP_ITEM]; } } else { - sAPCost += AP_PICKUP_ITEM; + sAPCost += APBPConstants[AP_PICKUP_ITEM]; } if ( sActionGridNo != pSoldier->sGridNo ) @@ -4139,13 +4142,13 @@ INT16 APsToTurnAround(SOLDIERTYPE *pSoldier, INT16 sAdjustedGridNo) switch( gAnimControl[ pSoldier->usAnimState ].ubEndHeight ) { case ANIM_STAND: - sAPCost += AP_LOOK_STANDING; + sAPCost += APBPConstants[AP_LOOK_STANDING]; break; case ANIM_CROUCH: - sAPCost += AP_LOOK_CROUCHED; + sAPCost += APBPConstants[AP_LOOK_CROUCHED]; break; case ANIM_PRONE: - sAPCost += AP_LOOK_PRONE; + sAPCost += APBPConstants[AP_LOOK_PRONE]; break; } } @@ -4367,43 +4370,43 @@ BOOLEAN SoldierCanAffordNewStance( SOLDIERTYPE *pSoldier, UINT8 ubDesiredStance if((UsingNewInventorySystem() == true)) if(pSoldier->inv[BPACKPOCKPOS].exists() == true && !pSoldier->flags.ZipperFlag) bAP = bBP = 1; - bAP += AP_CROUCH; - bBP += BP_CROUCH; + bAP += APBPConstants[AP_CROUCH]; + bBP += APBPConstants[BP_CROUCH]; break; case ANIM_CROUCH - ANIM_STAND: if((UsingNewInventorySystem() == true)) if(pSoldier->inv[BPACKPOCKPOS].exists() == true && !pSoldier->flags.ZipperFlag) bAP = bBP = 2; - bAP += AP_CROUCH; - bBP += BP_CROUCH; + bAP += APBPConstants[AP_CROUCH]; + bBP += APBPConstants[BP_CROUCH]; break; case ANIM_STAND - ANIM_PRONE: if((UsingNewInventorySystem() == true)) if(pSoldier->inv[BPACKPOCKPOS].exists() == true && !pSoldier->flags.ZipperFlag) bAP = bBP = 2; - bAP += AP_CROUCH + AP_PRONE; - bBP += BP_CROUCH + BP_PRONE; + bAP += APBPConstants[AP_CROUCH] + APBPConstants[AP_PRONE]; + bBP += APBPConstants[BP_CROUCH] + APBPConstants[BP_PRONE]; break; case ANIM_PRONE - ANIM_STAND: if((UsingNewInventorySystem() == true)) if(pSoldier->inv[BPACKPOCKPOS].exists() == true && !pSoldier->flags.ZipperFlag) bAP = bBP = 4; - bAP += AP_CROUCH + AP_PRONE; - bBP += BP_CROUCH + BP_PRONE; + bAP += APBPConstants[AP_CROUCH] + APBPConstants[AP_PRONE]; + bBP += APBPConstants[BP_CROUCH] + APBPConstants[BP_PRONE]; break; case ANIM_CROUCH - ANIM_PRONE: if((UsingNewInventorySystem() == true)) if(pSoldier->inv[BPACKPOCKPOS].exists() == true && !pSoldier->flags.ZipperFlag) bAP = bBP = 1; - bAP += AP_PRONE; - bBP += BP_PRONE; + bAP += APBPConstants[AP_PRONE]; + bBP += APBPConstants[BP_PRONE]; break; case ANIM_PRONE - ANIM_CROUCH: if((UsingNewInventorySystem() == true)) if(pSoldier->inv[BPACKPOCKPOS].exists() == true && !pSoldier->flags.ZipperFlag) bAP = bBP = 2; - bAP += AP_PRONE; - bBP += BP_PRONE; + bAP += APBPConstants[AP_PRONE]; + bBP += APBPConstants[BP_PRONE]; break; } @@ -4626,9 +4629,12 @@ UINT32 UIHandleLCOnTerrain( UI_EVENT *pUIEvent ) gsCurrentActionPoints = 0; + //CHRISL: Why are we doing this? If we ready a weapon, we spend the AP_CHANGE_TARGET APs, but then if we actually shoot + // at someone in our current firing arc, we'll again pay the AP_CHANGE_TARGET cost because it's considered a new tartget. + // Should be simply pay the ready weapon cost and only pay the AP_CHANGE_TARGET when we actually aim at a target? // Lesh: raise weapon include APs to set weapon towards enemy and APs to aquire/change target - if( pSoldier->sLastTarget != sXPos + (MAXCOL * sYPos ) ) - gsCurrentActionPoints = AP_CHANGE_TARGET; + //if( pSoldier->sLastTarget != sXPos + (MAXCOL * sYPos ) ) + // gsCurrentActionPoints = APBPConstants[AP_CHANGE_TARGET]; if( usAnimState != INVALID_ANIMATION ) { @@ -4715,9 +4721,13 @@ BOOLEAN MakeSoldierTurn( SOLDIERTYPE *pSoldier, INT16 sXPos, INT16 sYPos ) sAPCostToReady = sAPCost = 0; + //CHRISL: We should only charge AP_CHANGE_TARGET if we're actually pointing at a new target. Don't charge just + // to ready a weapon since we'll charge AP_CHANGE_TARGET when we actually fire. + SOLDIERTYPE * pTarget = SimpleFindSoldier( sXPos + (MAXCOL * sYPos ), pSoldier->bTargetLevel ); + // Lesh: raise weapon include APs to set weapon towards enemy and APs to aquire/change target - if( pSoldier->sLastTarget != sXPos + (MAXCOL * sYPos ) ) - sAPCost = AP_CHANGE_TARGET; + if( pSoldier->sLastTarget != sXPos + (MAXCOL * sYPos ) && pTarget != NULL ) + sAPCost = APBPConstants[AP_CHANGE_TARGET]; if( usAnimState != INVALID_ANIMATION ) { @@ -5793,7 +5803,7 @@ BOOLEAN HandleTalkInit( ) gfNPCCircularDistLimit = FALSE; // First calculate APs and validate... - sAPCost = AP_TALK; + sAPCost = APBPConstants[AP_TALK]; //sAPCost += UIPlotPath( pSoldier, sGoodGridNo, NO_COPYROUTE, FALSE, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints ); // Check AP cost... @@ -5815,7 +5825,7 @@ BOOLEAN HandleTalkInit( ) } else { - sAPCost = AP_TALK; + sAPCost = APBPConstants[AP_TALK]; // Check AP cost... if ( !EnoughPoints( pSoldier, sAPCost, 0, TRUE ) ) diff --git a/Tactical/Interface Items.cpp b/Tactical/Interface Items.cpp index 1e2e5a88..1f64fb36 100644 --- a/Tactical/Interface Items.cpp +++ b/Tactical/Interface Items.cpp @@ -221,7 +221,6 @@ extern int SM_ITEMDESC_START_Y; #define BAD_WEIGHT 45 #define BAD_RANGE 150 #define BAD_MAGAZINE 10 -#define BAD_AP_COST 9 #define BAD_RELIABILITY -2 #define BAD_REPAIR_EASE -2 #define BAD_ACCURACY -1 @@ -667,7 +666,7 @@ void GenerateProsString( STR16 zItemPros, OBJECTTYPE * pObject, UINT32 uiPixLimi } } - if (BaseAPsToShootOrStab( DEFAULT_APS, DEFAULT_AIMSKILL, gpItemDescObject ) <= EXCEPTIONAL_AP_COST) + if (BaseAPsToShootOrStab( APBPConstants[DEFAULT_APS], APBPConstants[DEFAULT_AIMSKILL], gpItemDescObject ) <= EXCEPTIONAL_AP_COST) { zTemp = Message[STR_QUICK_FIRING]; if ( ! AttemptToAddSubstring( zItemPros, zTemp, &uiStringLength, uiPixLimit ) ) @@ -794,7 +793,7 @@ void GenerateConsString( STR16 zItemCons, OBJECTTYPE * pObject, UINT32 uiPixLimi } } - if (BaseAPsToShootOrStab( DEFAULT_APS, DEFAULT_AIMSKILL, gpItemDescObject ) >= BAD_AP_COST) + if (BaseAPsToShootOrStab( APBPConstants[DEFAULT_APS], APBPConstants[DEFAULT_AIMSKILL], gpItemDescObject ) >= APBPConstants[BAD_AP_COST]) { zTemp = Message[STR_SLOW_FIRING]; if ( ! AttemptToAddSubstring( zItemCons, zTemp, &uiStringLength, uiPixLimit ) ) @@ -3663,7 +3662,7 @@ void ItemDescAttachmentsCallback( MOUSE_REGION * pRegion, INT32 iReason ) else { // ATE: Make sure we have enough AP's to drop it if we pick it up! - if ( pAttachment && EnoughPoints( gpItemDescSoldier, ( AttachmentAPCost( pAttachment->usItem, gpItemDescObject->usItem ) + AP_PICKUP_ITEM ), 0, TRUE ) ) + if ( pAttachment && EnoughPoints( gpItemDescSoldier, ( AttachmentAPCost( pAttachment->usItem, gpItemDescObject->usItem ) + APBPConstants[AP_PICKUP_ITEM] ), 0, TRUE ) ) { // Get attachment if there is one // The follwing function will handle if no attachment is here @@ -3750,7 +3749,7 @@ void RenderItemDescriptionBox( ) INT32 cnt; FLOAT fWeight; INT16 usX, usY; - UINT8 ubAttackAPs; + INT16 ubAttackAPs; BOOLEAN fHatchOutAttachments = gfItemDescObjectIsAttachment; // if examining attachment, always hatch out attachment slots INT16 sProsConsIndent; INT8 showBox=0; @@ -4061,7 +4060,7 @@ void RenderItemDescriptionBox( ) mprintf( usX, usY, pStr ); } - ubAttackAPs = BaseAPsToShootOrStab( DEFAULT_APS, DEFAULT_AIMSKILL, gpItemDescObject ); + ubAttackAPs = BaseAPsToShootOrStab( APBPConstants[DEFAULT_APS], APBPConstants[DEFAULT_AIMSKILL], gpItemDescObject ); if (ubAttackAPs <= EXCEPTIONAL_AP_COST) { @@ -4092,7 +4091,7 @@ void RenderItemDescriptionBox( ) SetFontForeground( 5 ); } - swprintf( pStr, L"%2d", ubAttackAPs + CalcAPsToBurst( DEFAULT_APS, gpItemDescObject ) ); + swprintf( pStr, L"%2d", ubAttackAPs + CalcAPsToBurst( APBPConstants[DEFAULT_APS], gpItemDescObject ) ); FindFontRightCoordinates( (INT16)(gMapWeaponStats[ 6 ].sX + gsInvDescX + gMapWeaponStats[ 6 ].sValDx), (INT16)(gMapWeaponStats[ 6 ].sY + gsInvDescY ), ITEM_STATS_WIDTH ,ITEM_STATS_HEIGHT ,pStr, BLOCKFONT2, &usX, &usY); mprintf( usX, usY, pStr ); } @@ -4101,7 +4100,7 @@ void RenderItemDescriptionBox( ) SetFontForeground( 5 ); - swprintf( pStr, L"%2d", ubAttackAPs + CalcAPsToAutofire( DEFAULT_APS, gpItemDescObject, 3 ) ); + swprintf( pStr, L"%2d", ubAttackAPs + CalcAPsToAutofire( APBPConstants[DEFAULT_APS], gpItemDescObject, 3 ) ); FindFontRightCoordinates( (INT16)(gMapWeaponStats[ 6 ].sX + gsInvDescX + gMapWeaponStats[ 6 ].sValDx), (INT16)(gMapWeaponStats[ 6 ].sY + gsInvDescY ), ITEM_STATS_WIDTH ,ITEM_STATS_HEIGHT ,pStr, BLOCKFONT2, &usX, &usY); mprintf( usX, usY, pStr ); } @@ -4564,7 +4563,7 @@ void RenderItemDescriptionBox( ) mprintf( usX, usY, pStr ); } - ubAttackAPs = BaseAPsToShootOrStab( DEFAULT_APS, DEFAULT_AIMSKILL, gpItemDescObject ); + ubAttackAPs = BaseAPsToShootOrStab( APBPConstants[DEFAULT_APS], APBPConstants[DEFAULT_AIMSKILL], gpItemDescObject ); if (ubAttackAPs <= EXCEPTIONAL_AP_COST) { @@ -4593,14 +4592,14 @@ void RenderItemDescriptionBox( ) SetFontForeground( 5 ); } - swprintf( pStr, L"%2d", ubAttackAPs + CalcAPsToBurst( DEFAULT_APS, gpItemDescObject ) ); + swprintf( pStr, L"%2d", ubAttackAPs + CalcAPsToBurst( APBPConstants[DEFAULT_APS], gpItemDescObject ) ); FindFontRightCoordinates( (INT16)(gWeaponStats[ 6 ].sX + gsInvDescX + gWeaponStats[ 6 ].sValDx), (INT16)(gWeaponStats[ 6 ].sY + gsInvDescY ), ITEM_STATS_WIDTH, ITEM_STATS_HEIGHT, pStr, BLOCKFONT2, &usX, &usY ); mprintf( usX, usY, pStr ); } else if (GetAutofireShotsPerFiveAPs(gpItemDescObject)> 0) { SetFontForeground( 5 ); - swprintf( pStr, L"%2d", ubAttackAPs + CalcAPsToBurst( DEFAULT_APS, gpItemDescObject ) ); + swprintf( pStr, L"%2d", ubAttackAPs + CalcAPsToBurst( APBPConstants[DEFAULT_APS], gpItemDescObject ) ); FindFontRightCoordinates( (INT16)(gWeaponStats[ 6 ].sX + gsInvDescX + gWeaponStats[ 6 ].sValDx), (INT16)(gWeaponStats[ 6 ].sY + gsInvDescY ), ITEM_STATS_WIDTH, ITEM_STATS_HEIGHT, pStr, BLOCKFONT2, &usX, &usY ); mprintf( usX, usY, pStr ); } @@ -5480,11 +5479,11 @@ void DrawItemTileCursor( ) // If we are tossing... if ( sDist <= 1 && gfUIMouseOnValidCatcher == 0 || gfUIMouseOnValidCatcher == 4 ) { - gsCurrentActionPoints = AP_PICKUP_ITEM; + gsCurrentActionPoints = APBPConstants[AP_PICKUP_ITEM]; } else { - gsCurrentActionPoints = AP_TOSS_ITEM; + gsCurrentActionPoints = APBPConstants[AP_TOSS_ITEM]; } } @@ -5719,7 +5718,7 @@ BOOLEAN HandleItemPointerClick( INT16 sMapPos ) // Check if we have APs.... if ( !EnoughPoints( gpItemPointerSoldier, gsCurrentActionPoints, 0, TRUE ) ) { - if ( gfDontChargeAPsToPickup && gsCurrentActionPoints == AP_PICKUP_ITEM ) + if ( gfDontChargeAPsToPickup && gsCurrentActionPoints == APBPConstants[AP_PICKUP_ITEM] ) { } @@ -5882,7 +5881,7 @@ BOOLEAN HandleItemPointerClick( INT16 sMapPos ) if ( !gfDontChargeAPsToPickup ) { // Deduct points - DeductPoints( gpItemPointerSoldier, AP_PICKUP_ITEM, 0 ); + DeductPoints( gpItemPointerSoldier, APBPConstants[AP_PICKUP_ITEM], 0 ); } SoldierDropItem( gpItemPointerSoldier, gpItemPointer ); @@ -5898,7 +5897,7 @@ BOOLEAN HandleItemPointerClick( INT16 sMapPos ) if ( !gfDontChargeAPsToPickup ) { // Deduct points - DeductPoints( gpItemPointerSoldier, AP_PICKUP_ITEM, 0 ); + DeductPoints( gpItemPointerSoldier, APBPConstants[AP_PICKUP_ITEM], 0 ); } // Play animation.... @@ -5936,7 +5935,7 @@ BOOLEAN HandleItemPointerClick( INT16 sMapPos ) if ( !gfDontChargeAPsToPickup ) { // Deduct points - DeductPoints( gpItemPointerSoldier, AP_PICKUP_ITEM, 0 ); + DeductPoints( gpItemPointerSoldier, APBPConstants[AP_PICKUP_ITEM], 0 ); } SoldierDropItem( gpItemPointerSoldier, gpItemPointer ); @@ -6047,7 +6046,7 @@ BOOLEAN HandleItemPointerClick( INT16 sMapPos ) } // Deduct points - //DeductPoints( gpItemPointerSoldier, AP_TOSS_ITEM, 0 ); + //DeductPoints( gpItemPointerSoldier, APBPConstants[AP_TOSS_ITEM], 0 ); gpItemPointerSoldier->flags.fDontChargeTurningAPs = TRUE; // Will be dome later.... @@ -8667,7 +8666,7 @@ void GetHelpTextForItem( STR16 pzStr, OBJECTTYPE *pObject, SOLDIERTYPE *pSoldier //Calculate AP's CHAR16 apStr[20]; CHAR16 apStr2[20]; - UINT8 ubAttackAPs = BaseAPsToShootOrStab( DEFAULT_APS, DEFAULT_AIMSKILL, pObject ); + INT16 ubAttackAPs = BaseAPsToShootOrStab( APBPConstants[DEFAULT_APS], APBPConstants[DEFAULT_AIMSKILL], pObject ); if ( Weapon[ usItem ].NoSemiAuto ) { @@ -8680,7 +8679,7 @@ void GetHelpTextForItem( STR16 pzStr, OBJECTTYPE *pObject, SOLDIERTYPE *pSoldier if (GetShotsPerBurst(pObject) > 0) { - swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToBurst( DEFAULT_APS, pObject ) ); + swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToBurst( APBPConstants[DEFAULT_APS], pObject ) ); wcscat( apStr, apStr2 ); } else @@ -8690,7 +8689,7 @@ void GetHelpTextForItem( STR16 pzStr, OBJECTTYPE *pObject, SOLDIERTYPE *pSoldier if (GetAutofireShotsPerFiveAPs(pObject) > 0) { - swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToAutofire( DEFAULT_APS, pObject, 3 ) ); + swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToAutofire( APBPConstants[DEFAULT_APS], pObject, 3 ) ); wcscat( apStr, apStr2 ); } else @@ -8726,13 +8725,13 @@ void GetHelpTextForItem( STR16 pzStr, OBJECTTYPE *pObject, SOLDIERTYPE *pSoldier //Calculate AP's CHAR16 apStr[20]; CHAR16 apStr2[20]; - UINT8 ubAttackAPs = BaseAPsToShootOrStab( DEFAULT_APS, DEFAULT_AIMSKILL, pObject ); + INT16 ubAttackAPs = BaseAPsToShootOrStab( APBPConstants[DEFAULT_APS], APBPConstants[DEFAULT_AIMSKILL], pObject ); swprintf( apStr, L"%d", ubAttackAPs ); if (GetShotsPerBurst(pObject) > 0) { - swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToBurst( DEFAULT_APS, pObject ) ); + swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToBurst( APBPConstants[DEFAULT_APS], pObject ) ); wcscat( apStr, apStr2 ); } else @@ -8742,7 +8741,7 @@ void GetHelpTextForItem( STR16 pzStr, OBJECTTYPE *pObject, SOLDIERTYPE *pSoldier if (GetAutofireShotsPerFiveAPs(pObject) > 0) { - swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToAutofire( DEFAULT_APS, pObject, 3 ) ); + swprintf( apStr2, L" / %d", ubAttackAPs + CalcAPsToAutofire( APBPConstants[DEFAULT_APS], pObject, 3 ) ); wcscat( apStr, apStr2 ); } else @@ -8780,7 +8779,7 @@ void GetHelpTextForItem( STR16 pzStr, OBJECTTYPE *pObject, SOLDIERTYPE *pSoldier gWeaponStatsDesc[ 11 ], //Damage String GetDamage(pObject), //Melee damage gWeaponStatsDesc[ 5 ], //AP String - BaseAPsToShootOrStab( DEFAULT_APS, DEFAULT_AIMSKILL, pObject ), //AP's + BaseAPsToShootOrStab( APBPConstants[DEFAULT_APS], APBPConstants[DEFAULT_AIMSKILL], pObject ), //AP's gWeaponStatsDesc[ 12 ], //Weight String fWeight, //Weight GetWeightUnitString() //Weight units diff --git a/Tactical/Interface Panels.cpp b/Tactical/Interface Panels.cpp index d3cce0b5..6340516f 100644 --- a/Tactical/Interface Panels.cpp +++ b/Tactical/Interface Panels.cpp @@ -565,7 +565,7 @@ extern void UpdateItemHatches(); extern SOLDIERTYPE *FindNextActiveSquad( SOLDIERTYPE *pSoldier ); // Wraps up check for AP-s get from a different soldier for in a vehicle... -INT8 GetUIApsToDisplay( SOLDIERTYPE *pSoldier ) +INT16 GetUIApsToDisplay( SOLDIERTYPE *pSoldier ) { SOLDIERTYPE *pVehicle; @@ -3505,11 +3505,11 @@ void SMInvClickCallback( MOUSE_REGION * pRegion, INT32 iReason ) BOOLEAN ChangeZipperStatus(SOLDIERTYPE *pSoldier, BOOLEAN newStatus) { INT16 sAPCost; - INT32 iBPCost = 0; + INT32 iBPCost = APBPConstants[BP_WORK_ZIPPER]; INT8 bNewStance; //Set AP cost based on what we're doing - sAPCost = (newStatus) ? 7 : 6; + sAPCost = (newStatus) ? APBPConstants[AP_CLOSE_ZIPPER] : APBPConstants[AP_OPEN_ZIPPER]; //Are we currently in combat? if(gTacticalStatus.uiFlags & INCOMBAT) { @@ -3550,8 +3550,8 @@ BOOLEAN ChangeZipperStatus(SOLDIERTYPE *pSoldier, BOOLEAN newStatus) // CHRISL: Function to adjust droppack packpack button status BOOLEAN ChangeDropPackStatus(SOLDIERTYPE *pSoldier, BOOLEAN newStatus) { - INT16 sAPCost = 3; - INT32 iBPCost = 0; + INT16 sAPCost = APBPConstants[AP_BACK_PACK]; + INT32 iBPCost = APBPConstants[BP_BACK_PACK]; INT32 worldKey=1, iRange=0; // Are we dropping a pack that has the zipper open? diff --git a/Tactical/Interface.cpp b/Tactical/Interface.cpp index 23cc3805..7411cbc7 100644 --- a/Tactical/Interface.cpp +++ b/Tactical/Interface.cpp @@ -2264,11 +2264,11 @@ void PopupDoorOpenMenu( BOOLEAN fClosingDoor ) } else { - swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ USE_KEYRING_ICON ], AP_UNLOCK_DOOR ); + swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ USE_KEYRING_ICON ], APBPConstants[AP_UNLOCK_DOOR] ); } SetButtonFastHelpText( iActionIcons[ USE_KEYRING_ICON ], zDisp ); - if ( !EnoughPoints( gOpenDoorMenu.pSoldier, AP_UNLOCK_DOOR, BP_UNLOCK_DOOR, FALSE ) || fClosingDoor || AM_AN_EPC( gOpenDoorMenu.pSoldier ) ) + if ( !EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_UNLOCK_DOOR], APBPConstants[BP_UNLOCK_DOOR], FALSE ) || fClosingDoor || AM_AN_EPC( gOpenDoorMenu.pSoldier ) ) { DisableButton( iActionIcons[ USE_KEYRING_ICON ] ); } @@ -2295,7 +2295,7 @@ void PopupDoorOpenMenu( BOOLEAN fClosingDoor ) } else { - swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ USE_CROWBAR_ICON ], AP_USE_CROWBAR ); + swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ USE_CROWBAR_ICON ], APBPConstants[AP_USE_CROWBAR] ); } SetButtonFastHelpText( iActionIcons[ USE_CROWBAR_ICON ], zDisp ); @@ -2305,7 +2305,7 @@ void PopupDoorOpenMenu( BOOLEAN fClosingDoor ) DisableButton( iActionIcons[ USE_CROWBAR_ICON ] ); } - if ( !EnoughPoints( gOpenDoorMenu.pSoldier, AP_USE_CROWBAR, BP_USE_CROWBAR, FALSE ) ) + if ( !EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_USE_CROWBAR], APBPConstants[BP_USE_CROWBAR], FALSE ) ) { DisableButton( iActionIcons[ USE_CROWBAR_ICON ] ); } @@ -2325,11 +2325,11 @@ void PopupDoorOpenMenu( BOOLEAN fClosingDoor ) } else { - swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ LOCKPICK_DOOR_ICON ], AP_PICKLOCK ); + swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ LOCKPICK_DOOR_ICON ], APBPConstants[AP_PICKLOCK] ); } SetButtonFastHelpText( iActionIcons[ LOCKPICK_DOOR_ICON ], zDisp ); - if ( !EnoughPoints( gOpenDoorMenu.pSoldier, AP_PICKLOCK, BP_PICKLOCK, FALSE ) || fClosingDoor || AM_AN_EPC( gOpenDoorMenu.pSoldier ) ) + if ( !EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_PICKLOCK], APBPConstants[BP_PICKLOCK], FALSE ) || fClosingDoor || AM_AN_EPC( gOpenDoorMenu.pSoldier ) ) { DisableButton( iActionIcons[ LOCKPICK_DOOR_ICON ] ); } @@ -2357,11 +2357,11 @@ void PopupDoorOpenMenu( BOOLEAN fClosingDoor ) } else { - swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ EXPLOSIVE_DOOR_ICON ], AP_EXPLODE_DOOR ); + swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ EXPLOSIVE_DOOR_ICON ], APBPConstants[AP_EXPLODE_DOOR] ); } SetButtonFastHelpText( iActionIcons[ EXPLOSIVE_DOOR_ICON ], zDisp ); - if ( !EnoughPoints( gOpenDoorMenu.pSoldier, AP_EXPLODE_DOOR, BP_EXPLODE_DOOR, FALSE ) || fClosingDoor || AM_AN_EPC( gOpenDoorMenu.pSoldier ) ) + if ( !EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_EXPLODE_DOOR], APBPConstants[BP_EXPLODE_DOOR], FALSE ) || fClosingDoor || AM_AN_EPC( gOpenDoorMenu.pSoldier ) ) { DisableButton( iActionIcons[ EXPLOSIVE_DOOR_ICON ] ); } @@ -2391,7 +2391,7 @@ void PopupDoorOpenMenu( BOOLEAN fClosingDoor ) } else { - swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ CANCEL_ICON + 1 ], AP_OPEN_DOOR ); + swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ CANCEL_ICON + 1 ], APBPConstants[AP_OPEN_DOOR] ); } } else @@ -2402,12 +2402,12 @@ void PopupDoorOpenMenu( BOOLEAN fClosingDoor ) } else { - swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ OPEN_DOOR_ICON ], AP_OPEN_DOOR ); + swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ OPEN_DOOR_ICON ], APBPConstants[AP_OPEN_DOOR] ); } } SetButtonFastHelpText( iActionIcons[ OPEN_DOOR_ICON ], zDisp ); - if ( !EnoughPoints( gOpenDoorMenu.pSoldier, AP_OPEN_DOOR, BP_OPEN_DOOR, FALSE ) ) + if ( !EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_OPEN_DOOR], APBPConstants[BP_OPEN_DOOR], FALSE ) ) { DisableButton( iActionIcons[ OPEN_DOOR_ICON ] ); } @@ -2429,11 +2429,11 @@ void PopupDoorOpenMenu( BOOLEAN fClosingDoor ) } else { - swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ EXAMINE_DOOR_ICON ], AP_EXAMINE_DOOR ); + swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ EXAMINE_DOOR_ICON ], APBPConstants[AP_EXAMINE_DOOR] ); } SetButtonFastHelpText( iActionIcons[ EXAMINE_DOOR_ICON ], zDisp ); - if ( !EnoughPoints( gOpenDoorMenu.pSoldier, AP_EXAMINE_DOOR, BP_EXAMINE_DOOR, FALSE ) || fClosingDoor || AM_AN_EPC( gOpenDoorMenu.pSoldier ) ) + if ( !EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_EXAMINE_DOOR], APBPConstants[BP_EXAMINE_DOOR], FALSE ) || fClosingDoor || AM_AN_EPC( gOpenDoorMenu.pSoldier ) ) { DisableButton( iActionIcons[ EXAMINE_DOOR_ICON ] ); } @@ -2453,11 +2453,11 @@ void PopupDoorOpenMenu( BOOLEAN fClosingDoor ) } else { - swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ BOOT_DOOR_ICON ], AP_BOOT_DOOR ); + swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ BOOT_DOOR_ICON ], APBPConstants[AP_BOOT_DOOR] ); } SetButtonFastHelpText( iActionIcons[ BOOT_DOOR_ICON ], zDisp ); - if ( !EnoughPoints( gOpenDoorMenu.pSoldier, AP_BOOT_DOOR, BP_BOOT_DOOR, FALSE ) || fClosingDoor || AM_AN_EPC( gOpenDoorMenu.pSoldier ) ) + if ( !EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_BOOT_DOOR], APBPConstants[BP_BOOT_DOOR], FALSE ) || fClosingDoor || AM_AN_EPC( gOpenDoorMenu.pSoldier ) ) { DisableButton( iActionIcons[ BOOT_DOOR_ICON ] ); } @@ -2478,11 +2478,11 @@ void PopupDoorOpenMenu( BOOLEAN fClosingDoor ) } else { - swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ UNTRAP_DOOR_ICON ], AP_UNTRAP_DOOR ); + swprintf( zDisp, L"%s ( %d )", pTacticalPopupButtonStrings[ UNTRAP_DOOR_ICON ], APBPConstants[AP_UNTRAP_DOOR] ); } SetButtonFastHelpText( iActionIcons[ UNTRAP_DOOR_ICON ], zDisp ); - if ( !EnoughPoints( gOpenDoorMenu.pSoldier, AP_UNTRAP_DOOR, BP_UNTRAP_DOOR, FALSE ) || fClosingDoor || AM_AN_EPC( gOpenDoorMenu.pSoldier ) ) + if ( !EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_UNTRAP_DOOR], APBPConstants[BP_UNTRAP_DOOR], FALSE ) || fClosingDoor || AM_AN_EPC( gOpenDoorMenu.pSoldier ) ) { DisableButton( iActionIcons[ UNTRAP_DOOR_ICON ] ); } @@ -2599,7 +2599,7 @@ void BtnDoorMenuCallback(GUI_BUTTON *btn,INT32 reason) { // Open door normally... // Check APs - if ( EnoughPoints( gOpenDoorMenu.pSoldier, AP_OPEN_DOOR, BP_OPEN_DOOR, FALSE ) ) + if ( EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_OPEN_DOOR], APBPConstants[BP_OPEN_DOOR], FALSE ) ) { // Set UI SetUIBusy( (UINT8)gOpenDoorMenu.pSoldier->ubID ); @@ -2623,7 +2623,7 @@ void BtnDoorMenuCallback(GUI_BUTTON *btn,INT32 reason) if ( uiBtnID == iActionIcons[ BOOT_DOOR_ICON ] ) { // Boot door - if ( EnoughPoints( gOpenDoorMenu.pSoldier, AP_BOOT_DOOR, BP_BOOT_DOOR, FALSE ) ) + if ( EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_BOOT_DOOR], APBPConstants[BP_BOOT_DOOR], FALSE ) ) { // Set UI SetUIBusy( (UINT8)gOpenDoorMenu.pSoldier->ubID ); @@ -2640,7 +2640,7 @@ void BtnDoorMenuCallback(GUI_BUTTON *btn,INT32 reason) if ( uiBtnID == iActionIcons[ USE_KEYRING_ICON ] ) { // Unlock door - if ( EnoughPoints( gOpenDoorMenu.pSoldier, AP_UNLOCK_DOOR, BP_UNLOCK_DOOR, FALSE ) ) + if ( EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_UNLOCK_DOOR], APBPConstants[BP_UNLOCK_DOOR], FALSE ) ) { // Set UI SetUIBusy( (UINT8)gOpenDoorMenu.pSoldier->ubID ); @@ -2657,7 +2657,7 @@ void BtnDoorMenuCallback(GUI_BUTTON *btn,INT32 reason) if ( uiBtnID == iActionIcons[ LOCKPICK_DOOR_ICON ] ) { // Lockpick - if ( EnoughPoints( gOpenDoorMenu.pSoldier, AP_PICKLOCK, BP_PICKLOCK, FALSE ) ) + if ( EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_PICKLOCK], APBPConstants[BP_PICKLOCK], FALSE ) ) { // Set UI SetUIBusy( (UINT8)gOpenDoorMenu.pSoldier->ubID ); @@ -2674,7 +2674,7 @@ void BtnDoorMenuCallback(GUI_BUTTON *btn,INT32 reason) if ( uiBtnID == iActionIcons[ EXAMINE_DOOR_ICON ] ) { // Lockpick - if ( EnoughPoints( gOpenDoorMenu.pSoldier, AP_EXAMINE_DOOR, BP_EXAMINE_DOOR, FALSE ) ) + if ( EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_EXAMINE_DOOR], APBPConstants[BP_EXAMINE_DOOR], FALSE ) ) { // Set UI SetUIBusy( (UINT8)gOpenDoorMenu.pSoldier->ubID ); @@ -2691,7 +2691,7 @@ void BtnDoorMenuCallback(GUI_BUTTON *btn,INT32 reason) if ( uiBtnID == iActionIcons[ EXPLOSIVE_DOOR_ICON ] ) { // Explode - if ( EnoughPoints( gOpenDoorMenu.pSoldier, AP_EXPLODE_DOOR, BP_EXPLODE_DOOR, FALSE ) ) + if ( EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_EXPLODE_DOOR], APBPConstants[BP_EXPLODE_DOOR], FALSE ) ) { // Set UI SetUIBusy( (UINT8)gOpenDoorMenu.pSoldier->ubID ); @@ -2708,7 +2708,7 @@ void BtnDoorMenuCallback(GUI_BUTTON *btn,INT32 reason) if ( uiBtnID == iActionIcons[ UNTRAP_DOOR_ICON ] ) { // Explode - if ( EnoughPoints( gOpenDoorMenu.pSoldier, AP_UNTRAP_DOOR, BP_UNTRAP_DOOR, FALSE ) ) + if ( EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_UNTRAP_DOOR], APBPConstants[BP_UNTRAP_DOOR], FALSE ) ) { // Set UI SetUIBusy( (UINT8)gOpenDoorMenu.pSoldier->ubID ); @@ -2725,7 +2725,7 @@ void BtnDoorMenuCallback(GUI_BUTTON *btn,INT32 reason) if ( uiBtnID == iActionIcons[ USE_CROWBAR_ICON ] ) { // Explode - if ( EnoughPoints( gOpenDoorMenu.pSoldier, AP_USE_CROWBAR, BP_USE_CROWBAR, FALSE ) ) + if ( EnoughPoints( gOpenDoorMenu.pSoldier, APBPConstants[AP_USE_CROWBAR], APBPConstants[BP_USE_CROWBAR], FALSE ) ) { // Set UI SetUIBusy( (UINT8)gOpenDoorMenu.pSoldier->ubID ); diff --git a/Tactical/Items.cpp b/Tactical/Items.cpp index 801b03b7..3e469aac 100644 --- a/Tactical/Items.cpp +++ b/Tactical/Items.cpp @@ -1962,7 +1962,7 @@ BOOLEAN ValidAttachment( UINT16 usAttachment, UINT16 usItem, UINT8 * pubAPCost ) { INT32 iLoop = 0; if (pubAPCost) { - *pubAPCost = (UINT8)AP_RELOAD_GUN; //default value + *pubAPCost = (UINT8)APBPConstants[AP_RELOAD_GUN]; //default value } // look for the section of the array pertaining to this attachment... @@ -2837,7 +2837,7 @@ BOOLEAN PlaceObjectAtObjectIndex( OBJECTTYPE * pSourceObj, OBJECTTYPE * pTargetO BOOLEAN ReloadGun( SOLDIERTYPE * pSoldier, OBJECTTYPE * pGun, OBJECTTYPE * pAmmo, UINT32 subObject ) { UINT16 ubBulletsToMove; - INT8 bAPs; + INT16 bAPs; UINT16 usReloadSound; BOOLEAN fSameAmmoType; BOOLEAN fSameMagazineSize; @@ -3008,7 +3008,7 @@ BOOLEAN ReloadGun( SOLDIERTYPE * pSoldier, OBJECTTYPE * pGun, OBJECTTYPE * pAmmo bAPs = GetAPsToReloadGunWithAmmo( pSoldier, pGun, pAmmo, 2 ); for(int i = 0; iubNumberOfObjects > 1) { // try autoplace @@ -3312,7 +3312,8 @@ INT8 FindAmmoToReload( SOLDIERTYPE * pSoldier, INT8 bWeaponIn, INT8 bExcludeSlot BOOLEAN AutoReload( SOLDIERTYPE * pSoldier ) { OBJECTTYPE *pObj, *pObj2; - INT8 bSlot, bAPCost; + INT8 bSlot; + INT16 bAPCost; BOOLEAN fRet; CHECKF( pSoldier ); @@ -6560,7 +6561,7 @@ BOOLEAN ApplyCammo( SOLDIERTYPE * pSoldier, OBJECTTYPE * pObj, BOOLEAN *pfGoodAP return( FALSE ); } - if (!EnoughPoints( pSoldier, AP_CAMOFLAGE, 0, TRUE ) ) + if (!EnoughPoints( pSoldier, APBPConstants[AP_CAMOFLAGE], 0, TRUE ) ) { (*pfGoodAPs) = FALSE; return( TRUE ); @@ -6601,7 +6602,7 @@ BOOLEAN ApplyCammo( SOLDIERTYPE * pSoldier, OBJECTTYPE * pObj, BOOLEAN *pfGoodAP UseKitPoints( pObj, bPointsToUse, pSoldier ); - DeductPoints( pSoldier, AP_CAMOFLAGE, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_CAMOFLAGE], 0 ); // Reload palettes.... if ( pSoldier->bInSector ) @@ -6631,7 +6632,7 @@ BOOLEAN ApplyCanteen( SOLDIERTYPE * pSoldier, OBJECTTYPE * pObj, BOOLEAN *pfGood return( FALSE ); } - if (!EnoughPoints( pSoldier, AP_DRINK, 0, TRUE ) ) + if (!EnoughPoints( pSoldier, APBPConstants[AP_DRINK], 0, TRUE ) ) { (*pfGoodAPs) = FALSE; return( TRUE ); @@ -6652,7 +6653,7 @@ BOOLEAN ApplyCanteen( SOLDIERTYPE * pSoldier, OBJECTTYPE * pObj, BOOLEAN *pfGood sPointsToUse = __min( 20, usTotalKitPoints ); // CJC Feb 9. Canteens don't seem effective enough, so doubled return from them - DeductPoints( pSoldier, AP_DRINK, (INT16) (2 * sPointsToUse * -(100 - pSoldier->bBreath) ) ); + DeductPoints( pSoldier, APBPConstants[AP_DRINK], (INT16) (2 * sPointsToUse * -(100 - pSoldier->bBreath) ) ); UseKitPoints( pObj, sPointsToUse, pSoldier ); @@ -6680,13 +6681,13 @@ BOOLEAN ApplyElixir( SOLDIERTYPE * pSoldier, OBJECTTYPE * pObj, BOOLEAN *pfGoodA return( FALSE ); } - if (!EnoughPoints( pSoldier, AP_CAMOFLAGE, 0, TRUE ) ) + if (!EnoughPoints( pSoldier, APBPConstants[AP_CAMOFLAGE], 0, TRUE ) ) { (*pfGoodAPs) = FALSE; return( TRUE ); } - DeductPoints( pSoldier, AP_CAMOFLAGE, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_CAMOFLAGE], 0 ); sPointsToUse = ( MAX_HUMAN_CREATURE_SMELL - pSoldier->aiData.bMonsterSmell ) * 2; sPointsToUse = __min( sPointsToUse, usTotalKitPoints ); @@ -6863,7 +6864,7 @@ void DumpItemsList( void ) const INT8 STANDARD_STATUS_CUTOFF = 85; // Scale bonus with item status -INT16 BonusReduce( INT16 bonus, INT16 status, INT8 statusCutoff = STANDARD_STATUS_CUTOFF ) +INT16 BonusReduce( INT16 bonus, INT16 status, INT16 statusCutoff = STANDARD_STATUS_CUTOFF ) { if ( bonus > 0 && status < statusCutoff && statusCutoff > 0 && statusCutoff <= 100 ) return ( ( status * 100 ) / statusCutoff * bonus ) / 100; @@ -6872,7 +6873,7 @@ INT16 BonusReduce( INT16 bonus, INT16 status, INT8 statusCutoff = STANDARD_STATU } // Scale bonus with item status. Status < 50% creates a penalty! -INT16 BonusReduceMore( INT16 bonus, INT16 status, INT8 statusCutoff = 100 ) +INT16 BonusReduceMore( INT16 bonus, INT16 status, INT16 statusCutoff = 100 ) { if ( bonus > 0 && status < statusCutoff && statusCutoff > 0 && statusCutoff <= 100 ) return ( ( ( status * 100 ) / statusCutoff - 50 ) * bonus ) / 50; @@ -6907,7 +6908,7 @@ BOOLEAN IsScoped( OBJECTTYPE * pObj ) } // Snap: get aim bonus for a single item -INT16 GetItemAimBonus( const INVTYPE* pItem, INT32 iRange, UINT8 ubAimTime ) +INT16 GetItemAimBonus( const INVTYPE* pItem, INT32 iRange, INT16 ubAimTime ) { if ( iRange <= pItem->minrangeforaimbonus ) return 0; @@ -6937,7 +6938,7 @@ INT16 GetItemAimBonus( const INVTYPE* pItem, INT32 iRange, UINT8 ubAimTime ) return(bonus); } -INT16 GetAimBonus( OBJECTTYPE * pObj, INT32 iRange, UINT8 ubAimTime ) +INT16 GetAimBonus( OBJECTTYPE * pObj, INT32 iRange, INT16 ubAimTime ) { INT16 bonus = 0; @@ -6954,7 +6955,7 @@ INT16 GetAimBonus( OBJECTTYPE * pObj, INT32 iRange, UINT8 ubAimTime ) } // Madd: check equipment for aim bonus (penalties) -INT16 GetGearAimBonus( SOLDIERTYPE * pSoldier, INT32 iRange, UINT8 ubAimTime ) +INT16 GetGearAimBonus( SOLDIERTYPE * pSoldier, INT32 iRange, INT16 ubAimTime ) { INT16 bonus=0; diff --git a/Tactical/Items.h b/Tactical/Items.h index ba355e76..c59a3f9e 100644 --- a/Tactical/Items.h +++ b/Tactical/Items.h @@ -213,7 +213,7 @@ UINT16 MagazineClassIndexToItemType(UINT16 usMagIndex); // Item property-related stuff added by Madd Mugsy BOOLEAN IsScoped( OBJECTTYPE * pObj ); -INT16 GetAimBonus( OBJECTTYPE * pObj, INT32 iRange, UINT8 ubAimTime ); +INT16 GetAimBonus( OBJECTTYPE * pObj, INT32 iRange, INT16 ubAimTime ); INT16 GetMinAimBonusRange( OBJECTTYPE * pObj ); INT16 GetToHitBonus( OBJECTTYPE * pObj, INT32 iRange, UINT8 bLightLevel, BOOLEAN fProneStance = FALSE ); UINT32 FindRangeBonusAttachment( OBJECTTYPE * pObj ); @@ -300,7 +300,7 @@ INT16 GetStealthBonus( OBJECTTYPE * pObj ); void ApplyEquipmentBonuses(SOLDIERTYPE * pSoldier); -INT16 GetGearAimBonus( SOLDIERTYPE * pSoldier, INT32 iRange, UINT8 ubAimTime); +INT16 GetGearAimBonus( SOLDIERTYPE * pSoldier, INT32 iRange, INT16 ubAimTime); INT16 GetGearToHitBonus( SOLDIERTYPE * pSoldier ); INT16 GetGearAPBonus( SOLDIERTYPE * pSoldier ); @@ -324,3 +324,4 @@ INT16 GetSnowCamoBonus( OBJECTTYPE * pObj ); #endif + diff --git a/Tactical/LOS.cpp b/Tactical/LOS.cpp index af575cae..eab65c4b 100644 --- a/Tactical/LOS.cpp +++ b/Tactical/LOS.cpp @@ -2268,7 +2268,7 @@ BOOLEAN BulletHitMerc( BULLET * pBullet, STRUCTURE * pStructure, BOOLEAN fIntend SWeaponHit.usWeaponIndex = pFirer->usAttackingWeapon; SWeaponHit.sDamage = (INT16) iDamage; // breath loss is based on original impact of bullet - SWeaponHit.sBreathLoss = (INT16) ( (iImpact * BP_GET_WOUNDED * (pTarget->bBreathMax * 100 - pTarget->sBreathRed)) / 10000 ); + SWeaponHit.sBreathLoss = (INT16) ( (iImpact * APBPConstants[BP_GET_WOUNDED] * (pTarget->bBreathMax * 100 - pTarget->sBreathRed)) / 10000 ); SWeaponHit.usDirection = GetDirectionFromGridNo( pFirer->sGridNo, pTarget ); SWeaponHit.sXPos = (INT16)pTarget->dXPos; SWeaponHit.sYPos = (INT16)pTarget->dYPos; diff --git a/Tactical/Militia Control.cpp b/Tactical/Militia Control.cpp index 6e1edef6..0fd28144 100644 --- a/Tactical/Militia Control.cpp +++ b/Tactical/Militia Control.cpp @@ -1289,7 +1289,7 @@ void MilitiaControlMenuBtnCallBack( MOUSE_REGION * pRegion, INT32 iReason ) if ( GetSoldier( &pSoldier, gusSelectedSoldier ) ) { - DeductPoints( pSoldier, AP_TALK, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_TALK], 0 ); StatChange( pSoldier, LDRAMT, 1, FALSE ); } @@ -1315,7 +1315,7 @@ void MilitiaControlMenuBtnCallBack( MOUSE_REGION * pRegion, INT32 iReason ) if ( GetSoldier( &pSoldier, gusSelectedSoldier ) ) { - DeductPoints( pSoldier, AP_TALK, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_TALK], 0 ); StatChange( pSoldier, LDRAMT, 1, FALSE ); } @@ -1362,7 +1362,7 @@ void MilitiaControlMenuBtnCallBack( MOUSE_REGION * pRegion, INT32 iReason ) if ( GetSoldier( &pSoldier, gusSelectedSoldier ) ) { - DeductPoints( pSoldier, AP_TALK, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_TALK], 0 ); StatChange( pSoldier, LDRAMT, 1, FALSE ); } @@ -1411,7 +1411,7 @@ void MilitiaControlMenuBtnCallBack( MOUSE_REGION * pRegion, INT32 iReason ) if ( GetSoldier( &pSoldier, gusSelectedSoldier ) ) { - DeductPoints( pSoldier, AP_TALK, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_TALK], 0 ); StatChange( pSoldier, LDRAMT, 1, FALSE ); } @@ -1438,7 +1438,7 @@ void MilitiaControlMenuBtnCallBack( MOUSE_REGION * pRegion, INT32 iReason ) if ( GetSoldier( &pSoldier, gusSelectedSoldier ) ) { - DeductPoints( pSoldier, AP_TALK, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_TALK], 0 ); StatChange( pSoldier, LDRAMT, 1, FALSE ); } @@ -1479,7 +1479,7 @@ void MilitiaControlMenuBtnCallBack( MOUSE_REGION * pRegion, INT32 iReason ) if ( GetSoldier( &pSoldier, gusSelectedSoldier ) ) { - DeductPoints( pSoldier, AP_TALK, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_TALK], 0 ); StatChange( pSoldier, LDRAMT, 1, FALSE ); } @@ -1513,7 +1513,7 @@ void MilitiaControlMenuBtnCallBack( MOUSE_REGION * pRegion, INT32 iReason ) if ( GetSoldier( &pSoldier, gusSelectedSoldier ) ) { - DeductPoints( pSoldier, AP_TALK, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_TALK], 0 ); StatChange( pSoldier, LDRAMT, 1, FALSE ); } @@ -1545,7 +1545,7 @@ void MilitiaControlMenuBtnCallBack( MOUSE_REGION * pRegion, INT32 iReason ) if ( GetSoldier( &pSoldier, gusSelectedSoldier ) ) { - DeductPoints( pSoldier, AP_TALK, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_TALK], 0 ); StatChange( pSoldier, LDRAMT, 1, FALSE ); } @@ -1608,7 +1608,7 @@ void MilitiaControlMenuBtnCallBack( MOUSE_REGION * pRegion, INT32 iReason ) if ( GetSoldier( &pSoldier, gusSelectedSoldier ) ) { - DeductPoints( pSoldier, AP_TALK, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_TALK], 0 ); StatChange( pSoldier, LDRAMT, 1, FALSE ); } @@ -1662,7 +1662,7 @@ void MilitiaControlMenuBtnCallBack( MOUSE_REGION * pRegion, INT32 iReason ) if ( GetSoldier( &pSoldier, gusSelectedSoldier ) ) { - DeductPoints( pSoldier, AP_TALK, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_TALK], 0 ); StatChange( pSoldier, LDRAMT, 1, FALSE ); } @@ -1713,7 +1713,7 @@ void MilitiaControlMenuBtnCallBack( MOUSE_REGION * pRegion, INT32 iReason ) if ( GetSoldier( &pSoldier, gusSelectedSoldier ) ) { - DeductPoints( pSoldier, AP_TALK, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_TALK], 0 ); StatChange( pSoldier, LDRAMT, 1, FALSE ); } @@ -1750,7 +1750,7 @@ void MilitiaControlMenuBtnCallBack( MOUSE_REGION * pRegion, INT32 iReason ) if ( GetSoldier( &pSoldier, gusSelectedSoldier ) ) { - DeductPoints( pSoldier, AP_TALK, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_TALK], 0 ); StatChange( pSoldier, LDRAMT, 1, FALSE ); } @@ -1825,7 +1825,7 @@ void MilitiaControlMenuBtnCallBack( MOUSE_REGION * pRegion, INT32 iReason ) if ( GetSoldier( &pSoldier, gusSelectedSoldier ) ) { - DeductPoints( pSoldier, AP_TALK, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_TALK], 0 ); StatChange( pSoldier, LDRAMT, 1, FALSE ); } @@ -1884,7 +1884,7 @@ void MilitiaControlMenuBtnCallBack( MOUSE_REGION * pRegion, INT32 iReason ) //if ( GetSoldier( &pSoldier, gusSelectedSoldier ) ) //{ - // DeductPoints( pSoldier, AP_TALK, 0 ); + // DeductPoints( pSoldier, APBPConstants[AP_TALK], 0 ); //} // // stop showing menu @@ -2372,3 +2372,4 @@ void MilitiaControlMenuBtnCallBack( MOUSE_REGION * pRegion, INT32 iReason ) //} + diff --git a/Tactical/Overhead.cpp b/Tactical/Overhead.cpp index c9c60c08..c47ce712 100644 --- a/Tactical/Overhead.cpp +++ b/Tactical/Overhead.cpp @@ -1977,13 +1977,13 @@ BOOLEAN HandleGotoNewGridNo( SOLDIERTYPE *pSoldier, BOOLEAN *pfKeepMoving, BOOLE // Do we have APs? if((UsingNewInventorySystem() == true) && pSoldier->inv[BPACKPOCKPOS].exists() == true) { - sAPCost = AP_JUMPFENCEBPACK; - sBPCost = BP_JUMPFENCEBPACK; + sAPCost = APBPConstants[AP_JUMPFENCEBPACK]; + sBPCost = APBPConstants[BP_JUMPFENCEBPACK]; } else { - sAPCost = AP_JUMPFENCE; - sBPCost = BP_JUMPFENCE; + sAPCost = APBPConstants[AP_JUMPFENCE]; + sBPCost = APBPConstants[BP_JUMPFENCE]; } @@ -7111,7 +7111,6 @@ INT8 CalcSuppressionTolerance( SOLDIERTYPE * pSoldier ) return( bTolerance ); } -#define MAX_APS_SUPPRESSED 8 void HandleSuppressionFire( UINT8 ubTargetedMerc, UINT8 ubCausedAttacker ) { INT8 bTolerance; @@ -7133,7 +7132,7 @@ void HandleSuppressionFire( UINT8 ubTargetedMerc, UINT8 ubCausedAttacker ) DebugMsg(TOPIC_JA2,DBG_LEVEL_3,String("HandleSuppressionFire: figure out aps lost")); // multiply by 2, add 1 and divide by 2 to round off to nearest whole number - ubPointsLost = ( ((pSoldier->ubSuppressionPoints * 6) / (bTolerance + 6)) * 2 + 1 ) / 2; + ubPointsLost = (UINT8)( (FLOAT)((pSoldier->ubSuppressionPoints * APBPConstants[AP_SUPPRESSION_MOD]) / (bTolerance + 6)) * 2 + 1 ) / 2; // reduce loss of APs based on stance // ATE: Taken out because we can possibly supress ourselves... @@ -7150,9 +7149,9 @@ void HandleSuppressionFire( UINT8 ubTargetedMerc, UINT8 ubCausedAttacker ) //} // cap the # of APs we can lose - if (ubPointsLost > MAX_APS_SUPPRESSED) + if (ubPointsLost > APBPConstants[AP_MAX_SUPPRESSED]) { - ubPointsLost = MAX_APS_SUPPRESSED; + ubPointsLost = (UINT8)APBPConstants[AP_MAX_SUPPRESSED]; } ubTotalPointsLost = ubPointsLost; @@ -7187,21 +7186,21 @@ void HandleSuppressionFire( UINT8 ubTargetedMerc, UINT8 ubCausedAttacker ) // can't change stance below prone! break; case ANIM_CROUCH: - if (ubTotalPointsLost >= AP_PRONE && IsValidStance( pSoldier, ANIM_PRONE ) ) + if (ubTotalPointsLost >= APBPConstants[AP_PRONE] && IsValidStance( pSoldier, ANIM_PRONE ) ) { sClosestOpponent = ClosestKnownOpponent( pSoldier, &sClosestOppLoc, NULL ); if (sClosestOpponent == NOWHERE || SpacesAway( pSoldier->sGridNo, sClosestOppLoc ) > 8) { - if (ubPointsLost < AP_PRONE) + if (ubPointsLost < APBPConstants[AP_PRONE]) { // Have to give APs back so that we can change stance without // losing more APs - pSoldier->bActionPoints += (AP_PRONE - ubPointsLost); + pSoldier->bActionPoints += (APBPConstants[AP_PRONE] - ubPointsLost); ubPointsLost = 0; } else { - ubPointsLost -= AP_PRONE; + ubPointsLost -= APBPConstants[AP_PRONE]; } ubNewStance = ANIM_PRONE; } @@ -7213,7 +7212,7 @@ void HandleSuppressionFire( UINT8 ubTargetedMerc, UINT8 ubCausedAttacker ) // can't change stance here! break; } - else if (ubTotalPointsLost >= (AP_CROUCH + AP_PRONE) && ( gAnimControl[ pSoldier->usAnimState ].ubEndHeight != ANIM_PRONE ) && IsValidStance( pSoldier, ANIM_PRONE ) ) + else if (ubTotalPointsLost >= (APBPConstants[AP_CROUCH] + APBPConstants[AP_PRONE]) && ( gAnimControl[ pSoldier->usAnimState ].ubEndHeight != ANIM_PRONE ) && IsValidStance( pSoldier, ANIM_PRONE ) ) { sClosestOpponent = ClosestKnownOpponent( pSoldier, &sClosestOppLoc, NULL ); if ( sClosestOpponent == NOWHERE || SpacesAway( pSoldier->sGridNo, sClosestOppLoc ) > 8 ) @@ -7235,7 +7234,7 @@ void HandleSuppressionFire( UINT8 ubTargetedMerc, UINT8 ubCausedAttacker ) ubNewStance = ANIM_CROUCH; } } - else if ( ubTotalPointsLost >= AP_CROUCH && ( gAnimControl[ pSoldier->usAnimState ].ubEndHeight != ANIM_CROUCH ) && IsValidStance( pSoldier, ANIM_CROUCH ) ) + else if ( ubTotalPointsLost >= APBPConstants[AP_CROUCH] && ( gAnimControl[ pSoldier->usAnimState ].ubEndHeight != ANIM_CROUCH ) && IsValidStance( pSoldier, ANIM_CROUCH ) ) { // crouch! ubNewStance = ANIM_CROUCH; diff --git a/Tactical/PATHAI.H b/Tactical/PATHAI.H index c5ffd967..c2807ddd 100644 --- a/Tactical/PATHAI.H +++ b/Tactical/PATHAI.H @@ -211,7 +211,7 @@ INT16 RecalculatePathCost( SOLDIERTYPE *pSoldier, UINT16 usMovementMode ); // Exporting these global variables extern UINT32 guiPathingData[MAX_PATH_DATA_LENGTH]; -extern UINT8 gubNPCAPBudget; +extern INT16 gubNPCAPBudget; extern UINT16 gusNPCMovementMode; extern UINT8 gubNPCDistLimit; extern UINT8 gubNPCPathCount; diff --git a/Tactical/PATHAI.cpp b/Tactical/PATHAI.cpp index 85e07330..e2eeae32 100644 --- a/Tactical/PATHAI.cpp +++ b/Tactical/PATHAI.cpp @@ -119,7 +119,7 @@ struct path_s TRAILCELLTYPE usCostToGo; //2 TRAILCELLTYPE usTotalCost; //2 INT8 bLevel; //1 - UINT8 ubTotalAPCost; //1 + INT16 ubTotalAPCost; //1 UINT8 ubLegDistance; //1 }; @@ -401,7 +401,7 @@ static path_t * pClosedHead; #define BLUESTEPSTART 48 #define ORANGESTEPSTART 64 -UINT8 gubNPCAPBudget = 0; +INT16 gubNPCAPBudget = 0; UINT16 gusNPCMovementMode; UINT8 gubNPCDistLimit = 0; BOOLEAN gfNPCCircularDistLimit = FALSE; @@ -1241,7 +1241,7 @@ INT16 AStarPathfinder::CalcStartingAP() { if ( movementMode == RUNNING && pSoldier->usAnimState != RUNNING ) { - startingAPCost = startingAPCost - AP_START_RUN_COST; + startingAPCost = startingAPCost - APBPConstants[AP_START_RUN_COST]; } } return startingAPCost; @@ -1277,28 +1277,28 @@ INT16 AStarPathfinder::CalcAP(int const terrainCost, UINT8 const direction) case TRAVELCOST_NONE: movementAPCost = 0; break; case TRAVELCOST_DIRTROAD: - case TRAVELCOST_FLAT: movementAPCost = AP_MOVEMENT_FLAT; break; + case TRAVELCOST_FLAT: movementAPCost = APBPConstants[AP_MOVEMENT_FLAT]; break; //case TRAVELCOST_BUMPY: - case TRAVELCOST_GRASS: movementAPCost = AP_MOVEMENT_GRASS; break; + case TRAVELCOST_GRASS: movementAPCost = APBPConstants[AP_MOVEMENT_GRASS]; break; - case TRAVELCOST_THICK: movementAPCost = AP_MOVEMENT_BUSH; break; + case TRAVELCOST_THICK: movementAPCost = APBPConstants[AP_MOVEMENT_BUSH]; break; - case TRAVELCOST_DEBRIS: movementAPCost = AP_MOVEMENT_RUBBLE; break; + case TRAVELCOST_DEBRIS: movementAPCost = APBPConstants[AP_MOVEMENT_RUBBLE]; break; - case TRAVELCOST_SHORE: movementAPCost = AP_MOVEMENT_SHORE; break; // wading shallow water + case TRAVELCOST_SHORE: movementAPCost = APBPConstants[AP_MOVEMENT_SHORE]; break; // wading shallow water - case TRAVELCOST_KNEEDEEP: movementAPCost = AP_MOVEMENT_LAKE; break; // wading waist/chest deep - very slow + case TRAVELCOST_KNEEDEEP: movementAPCost = APBPConstants[AP_MOVEMENT_LAKE]; break; // wading waist/chest deep - very slow - case TRAVELCOST_DEEPWATER: movementAPCost = AP_MOVEMENT_OCEAN; break; // can swim, so it's faster than wading + case TRAVELCOST_DEEPWATER: movementAPCost = APBPConstants[AP_MOVEMENT_OCEAN]; break; // can swim, so it's faster than wading //case TRAVELCOST_VEINEND: - //case TRAVELCOST_VEINMID: movementAPCost = AP_MOVEMENT_FLAT; break; + //case TRAVELCOST_VEINMID: movementAPCost = APBPConstants[AP_MOVEMENT_FLAT]; break; - //case TRAVELCOST_DOOR: movementAPCost = AP_MOVEMENT_FLAT; break; + //case TRAVELCOST_DOOR: movementAPCost = APBPConstants[AP_MOVEMENT_FLAT]; break; - case TRAVELCOST_FENCE: movementAPCost = AP_JUMPFENCE; break; + case TRAVELCOST_FENCE: movementAPCost = APBPConstants[AP_JUMPFENCE]; break; case TRAVELCOST_OBSTACLE: default: return -1; // Cost too much to be considered! @@ -1348,12 +1348,12 @@ INT16 AStarPathfinder::CalcAP(int const terrainCost, UINT8 const direction) case RUNNING: case WALKING : // Here pessimistically assume the path will continue after hopping the fence - movementAPCost += AP_CROUCH; + movementAPCost += APBPConstants[AP_CROUCH]; break; case SWATTING: // Add cost to stand once there BEFORE jumping.... - movementAPCost += AP_CROUCH; + movementAPCost += APBPConstants[AP_CROUCH]; break; case CRAWLING: @@ -1368,7 +1368,7 @@ INT16 AStarPathfinder::CalcAP(int const terrainCost, UINT8 const direction) case RUNNING: case WALKING : // charge crouch APs for ducking head! - movementAPCost += AP_CROUCH; + movementAPCost += APBPConstants[AP_CROUCH]; break; default: @@ -1379,7 +1379,7 @@ INT16 AStarPathfinder::CalcAP(int const terrainCost, UINT8 const direction) { // Uh, there IS a cost to close the door too! // Then if the door has to be unlocked to open there's the cost of locking and unlocking. - movementAPCost += AP_OPEN_DOOR + AP_OPEN_DOOR; + movementAPCost += APBPConstants[AP_OPEN_DOOR] + APBPConstants[AP_OPEN_DOOR]; fGoingThroughDoor = FALSE; } return movementAPCost; @@ -2353,8 +2353,8 @@ INT32 FindBestPath(SOLDIERTYPE *s , INT16 sDestination, INT8 ubLevel, INT16 usMo INT16 sCurPathNdx; INT32 prevCost; INT32 iWaterToWater; - UINT8 ubCurAPCost,ubAPCost; - UINT8 ubNewAPCost=0; + INT16 ubCurAPCost,ubAPCost; + INT16 ubNewAPCost=0; #ifdef VEHICLE //BOOLEAN fTurnSlow = FALSE; //BOOLEAN fReverse = FALSE; // stuff for vehicles turning @@ -3256,34 +3256,34 @@ INT32 FindBestPath(SOLDIERTYPE *s , INT16 sDestination, INT8 ubLevel, INT16 usMo break; case TRAVELCOST_DIRTROAD: - case TRAVELCOST_FLAT : ubAPCost = AP_MOVEMENT_FLAT; + case TRAVELCOST_FLAT : ubAPCost = APBPConstants[AP_MOVEMENT_FLAT]; break; //case TRAVELCOST_BUMPY : - case TRAVELCOST_GRASS : ubAPCost = AP_MOVEMENT_GRASS; + case TRAVELCOST_GRASS : ubAPCost = APBPConstants[AP_MOVEMENT_GRASS]; break; - case TRAVELCOST_THICK : ubAPCost = AP_MOVEMENT_BUSH; + case TRAVELCOST_THICK : ubAPCost = APBPConstants[AP_MOVEMENT_BUSH]; break; - case TRAVELCOST_DEBRIS : ubAPCost = AP_MOVEMENT_RUBBLE; + case TRAVELCOST_DEBRIS : ubAPCost = APBPConstants[AP_MOVEMENT_RUBBLE]; break; - case TRAVELCOST_SHORE : ubAPCost = AP_MOVEMENT_SHORE; // wading shallow water + case TRAVELCOST_SHORE : ubAPCost = APBPConstants[AP_MOVEMENT_SHORE]; // wading shallow water break; - case TRAVELCOST_KNEEDEEP: ubAPCost = AP_MOVEMENT_LAKE; // wading waist/chest deep - very slow + case TRAVELCOST_KNEEDEEP: ubAPCost = APBPConstants[AP_MOVEMENT_LAKE]; // wading waist/chest deep - very slow break; - case TRAVELCOST_DEEPWATER:ubAPCost = AP_MOVEMENT_OCEAN; // can swim, so it's faster than wading + case TRAVELCOST_DEEPWATER:ubAPCost = APBPConstants[AP_MOVEMENT_OCEAN]; // can swim, so it's faster than wading break; //case TRAVELCOST_VEINEND : - //case TRAVELCOST_VEINMID : ubAPCost = AP_MOVEMENT_FLAT; + //case TRAVELCOST_VEINMID : ubAPCost = APBPConstants[AP_MOVEMENT_FLAT]; // break; - //case TRAVELCOST_DOOR : ubAPCost = AP_MOVEMENT_FLAT; + //case TRAVELCOST_DOOR : ubAPCost = APBPConstants[AP_MOVEMENT_FLAT]; // break; case TRAVELCOST_FENCE : if((UsingNewInventorySystem() == true) && s->inv[BPACKPOCKPOS].exists() == true) - ubAPCost = AP_JUMPFENCEBPACK; + ubAPCost = APBPConstants[AP_JUMPFENCEBPACK]; else - ubAPCost = AP_JUMPFENCE; + ubAPCost = APBPConstants[AP_JUMPFENCE]; /* if ( sSwitchValue == TRAVELCOST_FENCE ) @@ -3301,7 +3301,7 @@ INT32 FindBestPath(SOLDIERTYPE *s , INT16 sDestination, INT8 ubLevel, INT16 usMo // Since it's AFTER.. make sure we will be moving after jump... if ( ( iCnt + 2 ) < iLastGrid ) { - sPoints += AP_CROUCH; + sPoints += APBPConstants[AP_CROUCH]; } break; @@ -3387,13 +3387,13 @@ INT32 FindBestPath(SOLDIERTYPE *s , INT16 sDestination, INT8 ubLevel, INT16 usMo case RUNNING: case WALKING : // Here pessimistically assume the path will continue after hopping the fence - ubAPCost += AP_CROUCH; + ubAPCost += APBPConstants[AP_CROUCH]; break; case SWATTING: // Add cost to stand once there BEFORE jumping.... - ubAPCost += AP_CROUCH; + ubAPCost += APBPConstants[AP_CROUCH]; break; case CRAWLING: @@ -3409,7 +3409,7 @@ INT32 FindBestPath(SOLDIERTYPE *s , INT16 sDestination, INT8 ubLevel, INT16 usMo case RUNNING: case WALKING : // charge crouch APs for ducking head! - ubAPCost += AP_CROUCH; + ubAPCost += APBPConstants[AP_CROUCH]; break; default: @@ -3418,7 +3418,7 @@ INT32 FindBestPath(SOLDIERTYPE *s , INT16 sDestination, INT8 ubLevel, INT16 usMo } else if (fGoingThroughDoor) { - ubAPCost += AP_OPEN_DOOR; + ubAPCost += APBPConstants[AP_OPEN_DOOR]; fGoingThroughDoor = FALSE; } @@ -4148,7 +4148,7 @@ INT16 PlotPath( SOLDIERTYPE *pSold, INT16 sDestGridno, INT8 bCopyRoute, INT8 bPl if (pSold->usAnimState != RUNNING) { // for estimation purposes, always pay penalty - sPointsRun = AP_START_RUN_COST; + sPointsRun = APBPConstants[AP_START_RUN_COST]; } // Add to points, those needed to start from different stance! @@ -4161,7 +4161,7 @@ INT16 PlotPath( SOLDIERTYPE *pSold, INT16 sDestGridno, INT8 bCopyRoute, INT8 bPl { if ( usMovementMode == RUNNING && pSold->usAnimState != RUNNING ) { - sPoints -= AP_START_RUN_COST; + sPoints -= APBPConstants[AP_START_RUN_COST]; } } @@ -4170,17 +4170,17 @@ INT16 PlotPath( SOLDIERTYPE *pSold, INT16 sDestGridno, INT8 bCopyRoute, INT8 bPl switch(pSold->usAnimState) { //case START_AID : - //case GIVING_AID : sAnimCost = AP_STOP_FIRST_AID; + //case GIVING_AID : sAnimCost = APBPConstants[AP_STOP_FIRST_AID]; // break; //case TWISTOMACH : - //case COLLAPSED : sAnimCost = AP_GET_UP; + //case COLLAPSED : sAnimCost = APBPConstants[AP_GET_UP]; // break; //case TWISTBACK : - //case UNCONSCIOUS : sAnimCost = (AP_ROLL_OVER+AP_GET_UP); + //case UNCONSCIOUS : sAnimCost = (APBPConstants[AP_ROLL_OVER]+APBPConstants[AP_GET_UP]); // break; // case CROUCHING : if (usMovementMode == WALKING || usMovementMode == RUNNING) - // sAnimCost = AP_CROUCH; + // sAnimCost = APBPConstants[AP_CROUCH]; // break; } */ @@ -4250,7 +4250,7 @@ INT16 PlotPath( SOLDIERTYPE *pSold, INT16 sDestGridno, INT8 bCopyRoute, INT8 bPl // Since it's AFTER.. make sure we will be moving after jump... if ( ( iCnt + 2 ) < iLastGrid ) { - sExtraCostStand += AP_CROUCH; + sExtraCostStand += APBPConstants[AP_CROUCH]; // ATE: if running, charge extra point to srart again if ( usMovementModeToUseForAPs== RUNNING ) @@ -4265,7 +4265,7 @@ INT16 PlotPath( SOLDIERTYPE *pSold, INT16 sDestGridno, INT8 bCopyRoute, INT8 bPl case SWATTING: // Add cost to stand once there BEFORE.... - sExtraCostSwat += AP_CROUCH; + sExtraCostSwat += APBPConstants[AP_CROUCH]; sPoints = sPoints + sExtraCostSwat; break; @@ -4287,7 +4287,7 @@ INT16 PlotPath( SOLDIERTYPE *pSold, INT16 sDestGridno, INT8 bCopyRoute, INT8 bPl case RUNNING: case WALKING : // charge crouch APs for ducking head! - sExtraCostStand += AP_CROUCH; + sExtraCostStand += APBPConstants[AP_CROUCH]; break; default: diff --git a/Tactical/Points.cpp b/Tactical/Points.cpp index e690b0a9..21a64298 100644 --- a/Tactical/Points.cpp +++ b/Tactical/Points.cpp @@ -51,10 +51,10 @@ INT16 TerrainActionPoints( SOLDIERTYPE *pSoldier, INT16 sGridno, INT8 bDir, INT8 BOOLEAN fHiddenStructVisible; // Used for hidden struct visiblity if ( pSoldier->bStealthMode ) - sAPCost += AP_STEALTH_MODIFIER; + sAPCost += APBPConstants[AP_STEALTH_MODIFIER]; if ( pSoldier->bReverse || gUIUseReverse ) - sAPCost += AP_REVERSE_MODIFIER; + sAPCost += APBPConstants[AP_REVERSE_MODIFIER]; //if (GridCost[gridno] == NPCMINECOST) // switchValue = BackupGridCost[gridno]; @@ -109,29 +109,29 @@ INT16 TerrainActionPoints( SOLDIERTYPE *pSoldier, INT16 sGridno, INT8 bDir, INT8 switch( sSwitchValue ) { case TRAVELCOST_DIRTROAD : - case TRAVELCOST_FLAT : sAPCost += AP_MOVEMENT_FLAT; + case TRAVELCOST_FLAT : sAPCost += APBPConstants[AP_MOVEMENT_FLAT]; break; //case TRAVELCOST_BUMPY : - case TRAVELCOST_GRASS : sAPCost += AP_MOVEMENT_GRASS; + case TRAVELCOST_GRASS : sAPCost += APBPConstants[AP_MOVEMENT_GRASS]; break; - case TRAVELCOST_THICK : sAPCost += AP_MOVEMENT_BUSH; + case TRAVELCOST_THICK : sAPCost += APBPConstants[AP_MOVEMENT_BUSH]; break; - case TRAVELCOST_DEBRIS : sAPCost += AP_MOVEMENT_RUBBLE; + case TRAVELCOST_DEBRIS : sAPCost += APBPConstants[AP_MOVEMENT_RUBBLE]; break; - case TRAVELCOST_SHORE : sAPCost += AP_MOVEMENT_SHORE; // wading shallow water + case TRAVELCOST_SHORE : sAPCost += APBPConstants[AP_MOVEMENT_SHORE]; // wading shallow water if (!IS_MERC_BODY_TYPE( pSoldier )) { return -1; } break; - case TRAVELCOST_KNEEDEEP : sAPCost += AP_MOVEMENT_LAKE; // wading waist/chest deep - very slow + case TRAVELCOST_KNEEDEEP : sAPCost += APBPConstants[AP_MOVEMENT_LAKE]; // wading waist/chest deep - very slow if (!IS_MERC_BODY_TYPE( pSoldier )) { return -1; } break; - case TRAVELCOST_DEEPWATER: sAPCost += AP_MOVEMENT_OCEAN; // can swim, so it's faster than wading + case TRAVELCOST_DEEPWATER: sAPCost += APBPConstants[AP_MOVEMENT_OCEAN]; // can swim, so it's faster than wading if (!IS_MERC_BODY_TYPE( pSoldier )) { return -1; @@ -139,7 +139,7 @@ INT16 TerrainActionPoints( SOLDIERTYPE *pSoldier, INT16 sGridno, INT8 bDir, INT8 break; /* case TRAVELCOST_VEINEND : - case TRAVELCOST_VEINMID : sAPCost += AP_MOVEMENT_FLAT; + case TRAVELCOST_VEINMID : sAPCost += APBPConstants[AP_MOVEMENT_FLAT]; break; */ case TRAVELCOST_DOOR : @@ -147,7 +147,7 @@ INT16 TerrainActionPoints( SOLDIERTYPE *pSoldier, INT16 sGridno, INT8 bDir, INT8 { return -1; } - sAPCost += AP_MOVEMENT_FLAT + AP_OPEN_DOOR + AP_OPEN_DOOR; // Include open and close costs! + sAPCost += APBPConstants[AP_MOVEMENT_FLAT] + APBPConstants[AP_OPEN_DOOR] + APBPConstants[AP_OPEN_DOOR]; // Include open and close costs! break; // cost for jumping a fence REPLACES all other AP costs! @@ -158,9 +158,9 @@ INT16 TerrainActionPoints( SOLDIERTYPE *pSoldier, INT16 sGridno, INT8 bDir, INT8 } // CHRISL: if((UsingNewInventorySystem() == true) && pSoldier->inv[BPACKPOCKPOS].exists() == true) - return( AP_JUMPFENCEBPACK ); + return( APBPConstants[AP_JUMPFENCEBPACK] ); else - return( AP_JUMPFENCE ); + return( APBPConstants[AP_JUMPFENCE] ); case TRAVELCOST_NONE : return( 0 ); @@ -229,20 +229,20 @@ INT16 TerrainBreathPoints(SOLDIERTYPE * pSoldier, INT16 sGridno,INT8 bDir, UINT1 switch( ubMovementCost ) { case TRAVELCOST_DIRTROAD : - case TRAVELCOST_FLAT : iPoints = BP_MOVEMENT_FLAT; break; + case TRAVELCOST_FLAT : iPoints = APBPConstants[BP_MOVEMENT_FLAT]; break; //case TRAVELCOST_BUMPY : - case TRAVELCOST_GRASS : iPoints = BP_MOVEMENT_GRASS; break; - case TRAVELCOST_THICK : iPoints = BP_MOVEMENT_BUSH; break; - case TRAVELCOST_DEBRIS : iPoints = BP_MOVEMENT_RUBBLE; break; - case TRAVELCOST_SHORE : iPoints = BP_MOVEMENT_SHORE; break; // wading shallow water - case TRAVELCOST_KNEEDEEP : iPoints = BP_MOVEMENT_LAKE; break; // wading waist/chest deep - very slow - case TRAVELCOST_DEEPWATER : iPoints = BP_MOVEMENT_OCEAN; break; // can swim, so it's faster than wading + case TRAVELCOST_GRASS : iPoints = APBPConstants[BP_MOVEMENT_GRASS]; break; + case TRAVELCOST_THICK : iPoints = APBPConstants[BP_MOVEMENT_BUSH]; break; + case TRAVELCOST_DEBRIS : iPoints = APBPConstants[BP_MOVEMENT_RUBBLE]; break; + case TRAVELCOST_SHORE : iPoints = APBPConstants[BP_MOVEMENT_SHORE]; break; // wading shallow water + case TRAVELCOST_KNEEDEEP : iPoints = APBPConstants[BP_MOVEMENT_LAKE]; break; // wading waist/chest deep - very slow + case TRAVELCOST_DEEPWATER : iPoints = APBPConstants[BP_MOVEMENT_OCEAN]; break; // can swim, so it's faster than wading // case TRAVELCOST_VEINEND : -// case TRAVELCOST_VEINMID : iPoints = BP_MOVEMENT_FLAT; break; +// case TRAVELCOST_VEINMID : iPoints = APBPConstants[BP_MOVEMENT_FLAT]; break; default: if ( IS_TRAVELCOST_DOOR( ubMovementCost ) ) { - iPoints = BP_MOVEMENT_FLAT; + iPoints = APBPConstants[BP_MOVEMENT_FLAT]; break; } /* @@ -269,19 +269,19 @@ INT16 TerrainBreathPoints(SOLDIERTYPE * pSoldier, INT16 sGridno,INT8 bDir, UINT1 case ADULTMONSTER_WALKING: case BLOODCAT_RUN: - iPoints *= BP_RUN_ENERGYCOSTFACTOR; break; + iPoints *= APBPConstants[BP_RUN_ENERGYCOSTFACTOR]; break; case SIDE_STEP: case WALK_BACKWARDS: case BLOODCAT_WALK_BACKWARDS: case MONSTER_WALK_BACKWARDS: - case WALKING : iPoints *= BP_WALK_ENERGYCOSTFACTOR; break; + case WALKING : iPoints *= APBPConstants[BP_WALK_ENERGYCOSTFACTOR]; break; case START_SWAT: case SWATTING: case SWAT_BACKWARDS: - iPoints *= BP_SWAT_ENERGYCOSTFACTOR; break; - case CRAWLING: iPoints *= BP_CRAWL_ENERGYCOSTFACTOR; break; + iPoints *= APBPConstants[BP_SWAT_ENERGYCOSTFACTOR]; break; + case CRAWLING: iPoints *= APBPConstants[BP_CRAWL_ENERGYCOSTFACTOR]; break; } @@ -391,7 +391,7 @@ INT16 ActionPointCost( SOLDIERTYPE *pSoldier, INT16 sGridNo, INT8 bDir, UINT16 u case SIDE_STEP: case WALK_BACKWARDS: // charge crouch APs for ducking head! - sPoints += AP_CROUCH; + sPoints += APBPConstants[AP_CROUCH]; break; default: @@ -490,7 +490,7 @@ INT16 EstimateActionPointCost( SOLDIERTYPE *pSoldier, INT16 sGridNo, INT8 bDir, // Since it's AFTER.. make sure we will be moving after jump... if ( ( bPathIndex + 2 ) < bPathLength ) { - sPoints += AP_CROUCH; + sPoints += APBPConstants[AP_CROUCH]; } break; @@ -499,7 +499,7 @@ INT16 EstimateActionPointCost( SOLDIERTYPE *pSoldier, INT16 sGridNo, INT8 bDir, case SWAT_BACKWARDS: // Add cost to stand once there BEFORE.... - sPoints += AP_CROUCH; + sPoints += APBPConstants[AP_CROUCH]; break; case CRAWLING: @@ -517,7 +517,7 @@ INT16 EstimateActionPointCost( SOLDIERTYPE *pSoldier, INT16 sGridNo, INT8 bDir, case SIDE_STEP: case WALK_BACKWARDS: // charge crouch APs for ducking head! - sPoints += AP_CROUCH; + sPoints += APBPConstants[AP_CROUCH]; break; default: @@ -648,9 +648,9 @@ void DeductPoints( SOLDIERTYPE *pSoldier, INT16 sAPCost, INT32 iBPCost,BOOLEAN f // Snap: award some health and strength for exertion // Do 4 StatChange rolls for health (2 for strength) per 10 breath points spent? - // NB: The scale of iBPCost is 100 per breath point (BP_RATIO_RED_PTS_TO_NORMAL) - if ( PTR_OURTEAM && iBPCost >= BP_MOVEMENT_GRASS && fProactive - && (INT32) PreRandom( 10 * BP_RATIO_RED_PTS_TO_NORMAL ) < iBPCost ) + // NB: The scale of iBPCost is 100 per breath point (APBPConstants[BP_RATIO_RED_PTS_TO_NORMAL]) + if ( PTR_OURTEAM && iBPCost >= APBPConstants[BP_MOVEMENT_GRASS] && fProactive + && (INT32) PreRandom( 10 * APBPConstants[BP_RATIO_RED_PTS_TO_NORMAL] ) < iBPCost ) { StatChange(pSoldier, HEALTHAMT, 4, FALSE); StatChange(pSoldier, STRAMT, 2, FALSE); @@ -659,8 +659,8 @@ void DeductPoints( SOLDIERTYPE *pSoldier, INT16 sAPCost, INT32 iBPCost,BOOLEAN f // CJC: moved check for high breathred to below so that negative breath can be detected // Snap: kill the overflow bug already! - // NB: normally, sBreathRed == (100 - bBreath)*BP_RATIO_RED_PTS_TO_NORMAL - const INT16 BREATH_RED_MAX = 100 * BP_RATIO_RED_PTS_TO_NORMAL; + // NB: normally, sBreathRed == (100 - bBreath)*APBPConstants[BP_RATIO_RED_PTS_TO_NORMAL] + const INT16 BREATH_RED_MAX = 100 * APBPConstants[BP_RATIO_RED_PTS_TO_NORMAL]; if ( pSoldier->sBreathRed + iBPCost < 0 ) { pSoldier->sBreathRed = 0; @@ -670,7 +670,7 @@ void DeductPoints( SOLDIERTYPE *pSoldier, INT16 sAPCost, INT32 iBPCost,BOOLEAN f // Snap: moved this up, because it had no effect below // Take off 1 AP per 5 (negative) breath... pSoldier->bActionPoints -= ( pSoldier->sBreathRed + iBPCost - BREATH_RED_MAX ) - / ( 5 * BP_RATIO_RED_PTS_TO_NORMAL ); + / ( 5 * APBPConstants[BP_RATIO_RED_PTS_TO_NORMAL] ); if ( pSoldier->bActionPoints < 0 ) { pSoldier->bActionPoints = 0; @@ -684,8 +684,8 @@ void DeductPoints( SOLDIERTYPE *pSoldier, INT16 sAPCost, INT32 iBPCost,BOOLEAN f } // Get new breath - bNewBreath = ( pSoldier->bBreathMax * BP_RATIO_RED_PTS_TO_NORMAL - pSoldier->sBreathRed ) - / BP_RATIO_RED_PTS_TO_NORMAL; + bNewBreath = ( pSoldier->bBreathMax * APBPConstants[BP_RATIO_RED_PTS_TO_NORMAL] - pSoldier->sBreathRed ) + / APBPConstants[BP_RATIO_RED_PTS_TO_NORMAL]; // Snap: This should never happen... if ( bNewBreath > pSoldier->bBreathMax ) @@ -864,10 +864,10 @@ void UnusedAPsToBreath(SOLDIERTYPE *pSold) else { // if merc has any APs left unused this turn (that aren't carrying over) - if (pSold->bActionPoints > MAX_AP_CARRIED) + if (pSold->bActionPoints > APBPConstants[MAX_AP_CARRIED]) { - sUnusedAPs = pSold->bActionPoints - MAX_AP_CARRIED; + sUnusedAPs = pSold->bActionPoints - APBPConstants[MAX_AP_CARRIED]; sBreathPerAP = GetBreathPerAP( pSold, pSold->usAnimState ); @@ -889,28 +889,28 @@ void UnusedAPsToBreath(SOLDIERTYPE *pSold) switch( gGameOptions.ubDifficultyLevel ) { case DIF_LEVEL_EASY: - sBreathChange = ((AP_MAXIMUM + gGameExternalOptions.iEasyAPBonus)- sUnusedAPs) * sBreathPerAP; + sBreathChange = ((APBPConstants[AP_MAXIMUM] + gGameExternalOptions.iEasyAPBonus)- sUnusedAPs) * sBreathPerAP; break; case DIF_LEVEL_MEDIUM: - sBreathChange = ((AP_MAXIMUM + gGameExternalOptions.iExperiencedAPBonus)-sUnusedAPs) * sBreathPerAP; + sBreathChange = ((APBPConstants[AP_MAXIMUM] + gGameExternalOptions.iExperiencedAPBonus)-sUnusedAPs) * sBreathPerAP; break; case DIF_LEVEL_HARD: - sBreathChange = ((AP_MAXIMUM + gGameExternalOptions.iExpertAPBonus)- sUnusedAPs) * sBreathPerAP; + sBreathChange = ((APBPConstants[AP_MAXIMUM] + gGameExternalOptions.iExpertAPBonus)- sUnusedAPs) * sBreathPerAP; break; case DIF_LEVEL_INSANE: - sBreathChange = ((AP_MAXIMUM + gGameExternalOptions.iInsaneAPBonus)- sUnusedAPs) * sBreathPerAP; + sBreathChange = ((APBPConstants[AP_MAXIMUM] + gGameExternalOptions.iInsaneAPBonus)- sUnusedAPs) * sBreathPerAP; break; default: - sBreathChange = (AP_MAXIMUM - sUnusedAPs) * sBreathPerAP; + sBreathChange = (APBPConstants[AP_MAXIMUM] - sUnusedAPs) * sBreathPerAP; } } else { - sBreathChange = ((AP_MAXIMUM + gGameExternalOptions.iPlayerAPBonus)- sUnusedAPs) * sBreathPerAP; + sBreathChange = ((APBPConstants[AP_MAXIMUM] + gGameExternalOptions.iPlayerAPBonus)- sUnusedAPs) * sBreathPerAP; } } else @@ -939,7 +939,7 @@ INT16 GetBreathPerAP( SOLDIERTYPE *pSoldier, UINT16 usAnimState ) if ( gAnimControl[ usAnimState ].uiFlags & ANIM_VARIABLE_EFFORT ) { // Default effort - sBreathPerAP = BP_PER_AP_MIN_EFFORT; + sBreathPerAP = APBPConstants[BP_PER_AP_MIN_EFFORT]; // OK, check if we are in water and are waling/standing if ( pSoldier->MercInWater( ) ) @@ -948,12 +948,12 @@ INT16 GetBreathPerAP( SOLDIERTYPE *pSoldier, UINT16 usAnimState ) { case STANDING: - sBreathPerAP = BP_PER_AP_LT_EFFORT; + sBreathPerAP = APBPConstants[BP_PER_AP_LT_EFFORT]; break; case WALKING: - sBreathPerAP = BP_PER_AP_MOD_EFFORT; + sBreathPerAP = APBPConstants[BP_PER_AP_MOD_EFFORT]; break; } } @@ -964,12 +964,12 @@ INT16 GetBreathPerAP( SOLDIERTYPE *pSoldier, UINT16 usAnimState ) { case STANDING: - sBreathPerAP = BP_PER_AP_NO_EFFORT; + sBreathPerAP = APBPConstants[BP_PER_AP_NO_EFFORT]; break; case WALKING: - sBreathPerAP = BP_PER_AP_LT_EFFORT; + sBreathPerAP = APBPConstants[BP_PER_AP_LT_EFFORT]; break; } } @@ -978,19 +978,19 @@ INT16 GetBreathPerAP( SOLDIERTYPE *pSoldier, UINT16 usAnimState ) switch ( EFFORT( gAnimControl[ usAnimState ].uiFlags) ) { case 0: // No effort - sBreathPerAP = BP_PER_AP_NO_EFFORT; + sBreathPerAP = APBPConstants[BP_PER_AP_NO_EFFORT]; fAnimTypeFound = TRUE; break; case 1: // Minimal effort - sBreathPerAP = BP_PER_AP_MIN_EFFORT; + sBreathPerAP = APBPConstants[BP_PER_AP_MIN_EFFORT]; fAnimTypeFound = TRUE; break; case 2: // Light effort - sBreathPerAP = BP_PER_AP_LT_EFFORT; + sBreathPerAP = APBPConstants[BP_PER_AP_LT_EFFORT]; fAnimTypeFound = TRUE; break; case 3: // Moderate effort - sBreathPerAP = BP_PER_AP_MOD_EFFORT; + sBreathPerAP = APBPConstants[BP_PER_AP_MOD_EFFORT]; fAnimTypeFound = TRUE; break; } @@ -1016,13 +1016,13 @@ INT16 GetBreathPerAP( SOLDIERTYPE *pSoldier, UINT16 usAnimState ) } //UINT8 CalcAPsToBurst( INT8 bBaseActionPoints, UINT16 usItem ) -UINT8 CalcAPsToBurst( INT8 bBaseActionPoints, OBJECTTYPE * pObj ) +INT16 CalcAPsToBurst( INT16 bBaseActionPoints, OBJECTTYPE * pObj ) { INT32 aps; // base APs is what you'd get from CalcActionPoints(); // NB round UP, so 21-25 APs pay full - aps = ( Weapon[ pObj->usItem ].bBurstAP * bBaseActionPoints + (AP_MAXIMUM - 1) ) / AP_MAXIMUM; + aps = ( Weapon[ pObj->usItem ].bBurstAP * bBaseActionPoints + (APBPConstants[AP_MAXIMUM] - 1) ) / APBPConstants[AP_MAXIMUM]; /*if ( GetPercentBurstFireAPReduction(pObj)>0 ) { @@ -1045,23 +1045,23 @@ UINT8 CalcAPsToBurst( INT8 bBaseActionPoints, OBJECTTYPE * pObj ) aps = ( aps * ( 100 - GetPercentBurstFireAPReduction(pObj) ) ) / 100; if ( aps < 0 ) aps = 0; - else if ( aps > AP_MAXIMUM ) aps = AP_MAXIMUM; + else if ( aps > APBPConstants[AP_MAXIMUM] ) aps = APBPConstants[AP_MAXIMUM]; DebugMsg(TOPIC_JA2,DBG_LEVEL_3,String("CalcAPsToBurst: return aps = %d", aps)); return (UINT8) aps; } -UINT8 CalcAPsToAutofire( INT8 bBaseActionPoints, OBJECTTYPE * pObj, UINT8 bDoAutofire ) +INT16 CalcAPsToAutofire( INT16 bBaseActionPoints, OBJECTTYPE * pObj, UINT8 bDoAutofire ) { // INT8 bAttachPos; - INT32 aps=AP_MAXIMUM + 1; + INT32 aps=APBPConstants[AP_MAXIMUM] + 1; if ( GetAutofireShotsPerFiveAPs (pObj) ) { // Snap: Do this just like in CalcAPsToBurst const INT32 autofireaps = - aps = ( ( 5 * bDoAutofire * bBaseActionPoints ) / GetAutofireShotsPerFiveAPs(pObj) + (AP_MAXIMUM - 1) ) / AP_MAXIMUM; + aps = ( ( APBPConstants[AUTOFIRE_SHOTS_AP_VALUE] * bDoAutofire * bBaseActionPoints ) / GetAutofireShotsPerFiveAPs(pObj) + (APBPConstants[AP_MAXIMUM] - 1) ) / APBPConstants[AP_MAXIMUM]; //DebugMsg(TOPIC_JA2,DBG_LEVEL_3,String("CalcAPsToAutofire: base aps = %d, # shots = %d",aps,pSoldier->bDoAutofire )); //check for spring and bolt @@ -1093,7 +1093,7 @@ UINT8 CalcAPsToAutofire( INT8 bBaseActionPoints, OBJECTTYPE * pObj, UINT8 bDoAut aps = ( aps * ( 100 - GetPercentAutofireAPReduction(pObj) ) ) / 100; if ( aps < 0 ) aps = 0; - else if ( aps > AP_MAXIMUM ) aps = AP_MAXIMUM; + else if ( aps > APBPConstants[AP_MAXIMUM] ) aps = APBPConstants[AP_MAXIMUM]; } DebugMsg(TOPIC_JA2,DBG_LEVEL_3,String("CalcAPsToAutoFire: return aps = %d", aps)); @@ -1101,7 +1101,7 @@ UINT8 CalcAPsToAutofire( INT8 bBaseActionPoints, OBJECTTYPE * pObj, UINT8 bDoAut } -UINT8 CalcTotalAPsToAttack( SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTurningCost, INT8 bAimTime ) +INT16 CalcTotalAPsToAttack( SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTurningCost, INT16 bAimTime ) { UINT16 sAPCost = 0; UINT16 usItemNum; @@ -1127,7 +1127,7 @@ UINT8 CalcTotalAPsToAttack( SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTur } else { - sAPCost += bAimTime; + sAPCost += (bAimTime*APBPConstants[AP_CLICK_AIM]); } } @@ -1236,16 +1236,16 @@ UINT8 CalcTotalAPsToAttack( SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTur } // Add aim time... - sAPCost += bAimTime; + sAPCost += (bAimTime*APBPConstants[AP_CLICK_AIM]); } return( (INT8)sAPCost ); } -UINT8 MinAPsToAttack(SOLDIERTYPE *pSoldier, INT16 sGridno, UINT8 ubAddTurningCost, UINT8 ubForceRaiseGunCost) +INT16 MinAPsToAttack(SOLDIERTYPE *pSoldier, INT16 sGridno, UINT8 ubAddTurningCost, UINT8 ubForceRaiseGunCost) { - UINT16 sAPCost = 0; + INT16 sAPCost = 0; UINT32 uiItemClass; if ( pSoldier->bWeaponMode == WM_ATTACHED_GL || pSoldier->bWeaponMode == WM_ATTACHED_GL_BURST || pSoldier->bWeaponMode == WM_ATTACHED_GL_AUTO ) @@ -1284,7 +1284,7 @@ UINT8 MinAPsToAttack(SOLDIERTYPE *pSoldier, INT16 sGridno, UINT8 ubAddTurningCos sAPCost = MinAPsToPunch( pSoldier, sGridno, ubAddTurningCost ); } - return( (UINT8)sAPCost ); + return sAPCost; } INT8 CalcAimSkill( SOLDIERTYPE * pSoldier, UINT16 usWeapon ) @@ -1307,11 +1307,18 @@ INT8 CalcAimSkill( SOLDIERTYPE * pSoldier, UINT16 usWeapon ) return( bAimSkill ); } -UINT8 BaseAPsToShootOrStab( INT8 bAPs, INT8 bAimSkill, OBJECTTYPE * pObj ) +INT16 BaseAPsToShootOrStab( INT16 bAPs, INT16 bAimSkill, OBJECTTYPE * pObj ) { - INT32 Top, Bottom, rof; + INT32 Top, Bottom; + FLOAT rof; // INT8 bAttachPos; + //CHRISL: By changing rof to a FLOAT value, we resolve some of the rounding that causes APs to be skipped. For example: + // assuming bAPs = 80 (default in a 100Ap system) and bAimSkill = 80 (also a default setting) + // If rof = 15, we return an AP cost of 24. If rof = 16, we return an AP cost of 22. With an integer value, we can't + // get an AP cost of 23. But if rof = 15.5, we return an AP cost of 23 (22.94 which gets rounded up). With an + // rof = 15.46, we return an AP cost of exactly 23. So this will allow for fine control over "default" AP costs. + // Calculate default top & bottom of the magic "aiming" formula! // get this man's maximum possible action points (ignoring carryovers) @@ -1349,7 +1356,7 @@ UINT8 BaseAPsToShootOrStab( INT8 bAPs, INT8 bAimSkill, OBJECTTYPE * pObj ) //{ // Top *= 100; //} - Bottom = ( 100 + bAimSkill ) * rof; + Bottom = (INT32)(( 100 + bAimSkill ) * rof); // (this will round to the nearest integer) return ( Top + Bottom / 2 ) / Bottom; } @@ -1402,10 +1409,21 @@ void GetAPChargeForShootOrStabWRTGunRaises( SOLDIERTYPE *pSoldier, INT16 sGridNo { fAddingRaiseGunCost = TRUE; } - //CHRISL: If we are prone and we need to turn, we will need to ready our weapon no matter what our current state is - if(fAddingTurningCost && gAnimControl[ pSoldier->usAnimState ].ubHeight == ANIM_PRONE) + //CHRISL: Handle ready weapon with facing changes based on stance + if(fAddingTurningCost) { - fAddingRaiseGunCost = TRUE; + switch (gAnimControl[ pSoldier->usAnimState ].ubHeight) + { + case ANIM_STAND: + fAddingRaiseGunCost = GetDirectionChangeAmount(sGridNo, pSoldier, 3); + break; + case ANIM_CROUCH: + fAddingRaiseGunCost = GetDirectionChangeAmount(sGridNo, pSoldier, 1); + break; + case ANIM_PRONE: + fAddingRaiseGunCost = TRUE; + break; + } } } @@ -1420,7 +1438,7 @@ UINT16 CalculateTurningCost(SOLDIERTYPE *pSoldier, UINT16 usItem, BOOLEAN fAddin if ( fAddingTurningCost ) { if ( Item[ usItem ].usItemClass == IC_THROWING_KNIFE ) - usTurningCost = 1; + usTurningCost = APBPConstants[AP_LOOK_STANDING]; else usTurningCost = GetAPsToLook( pSoldier ); } @@ -1441,13 +1459,13 @@ UINT16 CalculateRaiseGunCost(SOLDIERTYPE *pSoldier, BOOLEAN fAddingRaiseGunCost) return usRaiseGunCost; } -UINT8 MinAPsToShootOrStab(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTurningCost, UINT8 ubForceRaiseGunCost) +INT16 MinAPsToShootOrStab(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTurningCost, UINT8 ubForceRaiseGunCost) { UINT32 uiMercFlags; UINT16 usTargID; - INT8 bFullAPs; + INT16 bFullAPs; INT8 bAimSkill; - UINT8 bAPCost = AP_MIN_AIM_ATTACK; + INT16 bAPCost = APBPConstants[AP_MIN_AIM_ATTACK]; BOOLEAN fAddingTurningCost = FALSE; BOOLEAN fAddingRaiseGunCost = FALSE; UINT16 usItem; @@ -1489,11 +1507,8 @@ UINT8 MinAPsToShootOrStab(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTurni //Calculate usRaiseGunCost usRaiseGunCost = CalculateRaiseGunCost(pSoldier, fAddingRaiseGunCost); - //charge the maximum of the 2 - if ( gAnimControl[ pSoldier->usAnimState ].ubHeight == ANIM_PRONE ) - bAPCost += (usTurningCost + usRaiseGunCost); - else - bAPCost += __max(usTurningCost,usRaiseGunCost); + //charge for turn and/or raise based on the results of fAddingTurningCost & fAddingRaiseGunCost + bAPCost += (usTurningCost + usRaiseGunCost); if ( sGridNo != NOWHERE ) @@ -1508,7 +1523,7 @@ UINT8 MinAPsToShootOrStab(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTurni // if attacking a new target (or if the specific target is uncertain) if (ubForceRaiseGunCost || (( sGridNo != pSoldier->sLastTarget ) && !Item[usItem].rocketlauncher )) { - bAPCost += AP_CHANGE_TARGET; + bAPCost += APBPConstants[AP_CHANGE_TARGET]; } // Snap: reversed DIGICRAB's change. @@ -1566,11 +1581,11 @@ UINT8 MinAPsToShootOrStab(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTurni } - return ( bAPCost ); + return bAPCost; } -UINT8 MinAPsToPunch(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTurningCost) +INT16 MinAPsToPunch(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTurningCost) { UINT8 bAPCost = 0; UINT16 usTargID; @@ -1611,21 +1626,21 @@ UINT8 MinAPsToPunch(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTurningCost // Is it the same as he's facing? if ( ubDirection != pSoldier->ubDirection ) { - bAPCost += AP_LOOK_STANDING; + bAPCost += APBPConstants[AP_LOOK_STANDING]; } } } } - bAPCost += 4; + bAPCost += APBPConstants[AP_PUNCH]; return ( bAPCost ); } -INT8 MinPtsToMove(SOLDIERTYPE *pSoldier) +INT16 MinPtsToMove(SOLDIERTYPE *pSoldier) { // look around all 8 directions and return lowest terrain cost UINT8 cnt; @@ -1673,10 +1688,10 @@ INT8 PtsToMoveDirection(SOLDIERTYPE *pSoldier, INT8 bDirection ) if ( gubWorldMovementCosts[ sGridno ][ bDirection ][ pSoldier->pathing.bLevel ] != TRAVELCOST_FENCE ) { - if ( usMoveModeToUse == RUNNING && pSoldier->usAnimState != RUNNING ) - { - sCost += AP_START_RUN_COST; - } + if ( usMoveModeToUse == RUNNING && pSoldier->usAnimState != RUNNING ) + { + sCost += APBPConstants[AP_START_RUN_COST]; + } } return( (INT8)sCost ); @@ -1692,31 +1707,31 @@ INT8 MinAPsToStartMovement( SOLDIERTYPE * pSoldier, UINT16 usMovementMode ) case WALKING: if (gAnimControl[ pSoldier->usAnimState ].ubEndHeight == ANIM_PRONE) { - bAPs += AP_CROUCH + AP_PRONE; + bAPs += APBPConstants[AP_CROUCH] + APBPConstants[AP_PRONE]; } else if (gAnimControl[ pSoldier->usAnimState ].ubEndHeight == ANIM_CROUCH) { - bAPs += AP_CROUCH; + bAPs += APBPConstants[AP_CROUCH]; } break; case SWATTING: if (gAnimControl[ pSoldier->usAnimState ].ubEndHeight == ANIM_PRONE) { - bAPs += AP_PRONE; + bAPs += APBPConstants[AP_PRONE]; } else if (gAnimControl[ pSoldier->usAnimState ].ubEndHeight == ANIM_STAND) { - bAPs += AP_CROUCH; + bAPs += APBPConstants[AP_CROUCH]; } break; case CRAWLING: if (gAnimControl[ pSoldier->usAnimState ].ubEndHeight == ANIM_STAND) { - bAPs += AP_CROUCH + AP_PRONE; + bAPs += APBPConstants[AP_CROUCH] + APBPConstants[AP_PRONE]; } else if (gAnimControl[ pSoldier->usAnimState ].ubEndHeight == ANIM_CROUCH) { - bAPs += AP_CROUCH; + bAPs += APBPConstants[AP_CROUCH]; } break; default: @@ -1725,7 +1740,7 @@ INT8 MinAPsToStartMovement( SOLDIERTYPE * pSoldier, UINT16 usMovementMode ) if (usMovementMode == RUNNING && pSoldier->usAnimState != RUNNING ) { - bAPs += AP_START_RUN_COST; + bAPs += APBPConstants[AP_START_RUN_COST]; } return( bAPs ); } @@ -1887,7 +1902,7 @@ void DeductAmmo( SOLDIERTYPE *pSoldier, INT8 bInvPos ) } -UINT16 GetAPsToPickupItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ) +INT16 GetAPsToPickupItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ) { ITEM_POOL *pItemPool; UINT16 sAPCost = 0; @@ -1907,12 +1922,12 @@ UINT16 GetAPsToPickupItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ) if ( sAPCost != 0 ) { // ADD APS TO PICKUP - sAPCost += AP_PICKUP_ITEM; + sAPCost += APBPConstants[AP_PICKUP_ITEM]; } } else { - sAPCost += AP_PICKUP_ITEM; + sAPCost += APBPConstants[AP_PICKUP_ITEM]; } } @@ -1920,7 +1935,7 @@ UINT16 GetAPsToPickupItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ) } -UINT16 GetAPsToGiveItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ) +INT16 GetAPsToGiveItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ) { UINT16 sAPCost = 0; @@ -1930,19 +1945,19 @@ UINT16 GetAPsToGiveItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ) if ( sAPCost != 0 || pSoldier->sGridNo == sMapPos ) { // ADD APS TO PICKUP - sAPCost += AP_GIVE_ITEM; + sAPCost += APBPConstants[AP_GIVE_ITEM]; } return( sAPCost ); } -INT8 GetAPsToReloadGunWithAmmo( SOLDIERTYPE *pSoldier, OBJECTTYPE * pGun, OBJECTTYPE * pAmmo, BOOLEAN usAllAPs ) +INT16 GetAPsToReloadGunWithAmmo( SOLDIERTYPE *pSoldier, OBJECTTYPE * pGun, OBJECTTYPE * pAmmo, BOOLEAN usAllAPs ) { if (Item[ pGun->usItem ].usItemClass == IC_LAUNCHER) { // always standard AP cost - //return( AP_RELOAD_GUN ); + //return( APBPConstants[AP_RELOAD_GUN] ); return GetAPsToReload(pGun); } if(Weapon[pGun->usItem].swapClips == 1 && GetMagSize(pGun) == Magazine[Item[pAmmo->usItem].ubClassIndex].ubMagSize) @@ -1953,7 +1968,7 @@ INT8 GetAPsToReloadGunWithAmmo( SOLDIERTYPE *pSoldier, OBJECTTYPE * pGun, OBJECT else if(Weapon[pGun->usItem].swapClips == 1) { // wrong size ammo item - return (INT8)(GetAPsToReload(pGun) * gGameExternalOptions.ubWrongMagMult); + return (INT8)((GetAPsToReload(pGun) * APBPConstants[AP_WRONG_MAG])/10); } else { @@ -1962,13 +1977,11 @@ INT8 GetAPsToReloadGunWithAmmo( SOLDIERTYPE *pSoldier, OBJECTTYPE * pGun, OBJECT int rounds = __min((GetMagSize(pGun)-(*pGun)[0]->data.gun.ubGunShotsLeft), Magazine[Item[pAmmo->usItem].ubClassIndex].ubMagSize); if(!((*pGun)[0]->data.gun.ubGunState & GS_WEAPON_BEING_RELOADED)) reload = GetAPsToReload(pGun); - if(reload > 10) - reload = 4; if(usAllAPs == 1) { for(int i = 1; i <= rounds; i++) { - if(EnoughPoints(pSoldier,(reload + (i * gGameExternalOptions.ubAPCostPerRound)),0,FALSE) == FALSE) + if(EnoughPoints(pSoldier,(reload + (i * APBPConstants[AP_RELOAD_LOOSE])),0,FALSE) == FALSE) { rounds = i-1; break; @@ -1977,15 +1990,15 @@ INT8 GetAPsToReloadGunWithAmmo( SOLDIERTYPE *pSoldier, OBJECTTYPE * pGun, OBJECT } else if (usAllAPs == 2) rounds = 1; - return (reload + (rounds * gGameExternalOptions.ubAPCostPerRound)); + return (reload + (rounds * APBPConstants[AP_RELOAD_LOOSE])); } } -INT8 GetAPsToAutoReload( SOLDIERTYPE * pSoldier ) +INT16 GetAPsToAutoReload( SOLDIERTYPE * pSoldier ) { OBJECTTYPE * pObj; INT8 bSlot, bSlot2, bExcludeSlot; - INT8 bAPCost = 0, bAPCost2 = 0;; + INT16 bAPCost = 0, bAPCost2 = 0;; CHECKF( pSoldier ); pObj = &(pSoldier->inv[HANDPOS]); @@ -2074,7 +2087,7 @@ UINT16 GetAPsToReloadRobot( SOLDIERTYPE *pSoldier, SOLDIERTYPE *pRobot ) -UINT16 GetAPsToChangeStance( SOLDIERTYPE *pSoldier, INT8 bDesiredHeight ) +INT16 GetAPsToChangeStance( SOLDIERTYPE *pSoldier, INT8 bDesiredHeight ) { UINT16 sAPCost = 0; INT8 bCurrentHeight; @@ -2088,33 +2101,33 @@ UINT16 GetAPsToChangeStance( SOLDIERTYPE *pSoldier, INT8 bDesiredHeight ) if ( bCurrentHeight == ANIM_STAND && bDesiredHeight == ANIM_PRONE ) { - sAPCost = AP_CROUCH + AP_PRONE; + sAPCost = APBPConstants[AP_CROUCH] + APBPConstants[AP_PRONE]; } if ( bCurrentHeight == ANIM_STAND && bDesiredHeight == ANIM_CROUCH ) { - sAPCost = AP_CROUCH; + sAPCost = APBPConstants[AP_CROUCH]; } if ( bCurrentHeight == ANIM_CROUCH && bDesiredHeight == ANIM_PRONE ) { - sAPCost = AP_PRONE; + sAPCost = APBPConstants[AP_PRONE]; } if ( bCurrentHeight == ANIM_CROUCH && bDesiredHeight == ANIM_STAND ) { - sAPCost = AP_CROUCH; + sAPCost = APBPConstants[AP_CROUCH]; } if ( bCurrentHeight == ANIM_PRONE && bDesiredHeight == ANIM_STAND ) { - sAPCost = AP_PRONE + AP_CROUCH; + sAPCost = APBPConstants[AP_PRONE] + APBPConstants[AP_CROUCH]; } if ( bCurrentHeight == ANIM_PRONE && bDesiredHeight == ANIM_CROUCH ) { - sAPCost = AP_PRONE; + sAPCost = APBPConstants[AP_PRONE]; } return( sAPCost ); } -UINT16 GetBPsToChangeStance( SOLDIERTYPE *pSoldier, INT8 bDesiredHeight ) +INT16 GetBPsToChangeStance( SOLDIERTYPE *pSoldier, INT8 bDesiredHeight ) { UINT16 sBPCost = 0; INT8 bCurrentHeight; @@ -2128,51 +2141,51 @@ UINT16 GetBPsToChangeStance( SOLDIERTYPE *pSoldier, INT8 bDesiredHeight ) if ( bCurrentHeight == ANIM_STAND && bDesiredHeight == ANIM_PRONE ) { - sBPCost = BP_CROUCH + BP_PRONE; + sBPCost = APBPConstants[BP_CROUCH] + APBPConstants[BP_PRONE]; } if ( bCurrentHeight == ANIM_STAND && bDesiredHeight == ANIM_CROUCH ) { - sBPCost = BP_CROUCH; + sBPCost = APBPConstants[BP_CROUCH]; } if ( bCurrentHeight == ANIM_CROUCH && bDesiredHeight == ANIM_PRONE ) { - sBPCost = BP_PRONE; + sBPCost = APBPConstants[BP_PRONE]; } if ( bCurrentHeight == ANIM_CROUCH && bDesiredHeight == ANIM_STAND ) { - sBPCost = BP_CROUCH; + sBPCost = APBPConstants[BP_CROUCH]; } if ( bCurrentHeight == ANIM_PRONE && bDesiredHeight == ANIM_STAND ) { - sBPCost = BP_PRONE + BP_CROUCH; + sBPCost = APBPConstants[BP_PRONE] + APBPConstants[BP_CROUCH]; } if ( bCurrentHeight == ANIM_PRONE && bDesiredHeight == ANIM_CROUCH ) { - sBPCost = BP_PRONE; + sBPCost = APBPConstants[BP_PRONE]; } return( sBPCost ); } -UINT16 GetAPsToLook( SOLDIERTYPE *pSoldier ) +INT16 GetAPsToLook( SOLDIERTYPE *pSoldier ) { // Set # of APs switch( gAnimControl[ pSoldier->usAnimState ].ubEndHeight ) { // Now change to appropriate animation case ANIM_STAND: - return( AP_LOOK_STANDING ); + return( APBPConstants[AP_LOOK_STANDING] ); break; case ANIM_CROUCH: - return( AP_LOOK_CROUCHED ); + return( APBPConstants[AP_LOOK_CROUCHED] ); break; case ANIM_PRONE: - // AP_PRONE is the AP cost to go to or from the prone stance. To turn while prone, your merc has to get up to - // crouched, turn, and then go back down. Hence you go up (AP_PRONE), turn (AP_LOOK_PRONE) and down (AP_PRONE). - return( AP_LOOK_PRONE + AP_PRONE + AP_PRONE ); + // APBPConstants[AP_PRONE] is the AP cost to go to or from the prone stance. To turn while prone, your merc has to get up to + // crouched, turn, and then go back down. Hence you go up (APBPConstants[AP_PRONE]), turn (APBPConstants[AP_LOOK_PRONE]) and down (APBPConstants[AP_PRONE]). + return( APBPConstants[AP_LOOK_PRONE] + APBPConstants[AP_PRONE] + APBPConstants[AP_PRONE] ); break; // no other values should be possible @@ -2249,7 +2262,7 @@ INT16 GetAPsToReadyWeapon( SOLDIERTYPE *pSoldier, UINT16 usAnimState ) // ATE: What was I thinking, hooking into animations like this.... //if ( usAnimState == READY_DUAL_STAND || usAnimState == READY_DUAL_CROUCH ) //{ - //return( AP_READY_DUAL ); + //return( APBPConstants[AP_READY_DUAL] ); //} if ( pSoldier->IsValidSecondHandShot( ) ) { @@ -2258,7 +2271,7 @@ INT16 GetAPsToReadyWeapon( SOLDIERTYPE *pSoldier, UINT16 usAnimState ) rt1 = Weapon[usItem].ubReadyTime * ( 100 - GetPercentReadyTimeAPReduction(&pSoldier->inv[ HANDPOS ]) ) / 100; rt2 = Weapon[pSoldier->inv[SECONDHANDPOS].usItem].ubReadyTime * ( 100 - GetPercentReadyTimeAPReduction(&pSoldier->inv[ SECONDHANDPOS ]) ) / 100; - return( max(rt1,rt2) + AP_READY_DUAL ); + return( max(rt1,rt2) + APBPConstants[AP_READY_DUAL] ); } @@ -2288,17 +2301,17 @@ INT16 GetAPsToReadyWeapon( SOLDIERTYPE *pSoldier, UINT16 usAnimState ) } -INT8 GetAPsToClimbRoof( SOLDIERTYPE *pSoldier, BOOLEAN fClimbDown ) +INT16 GetAPsToClimbRoof( SOLDIERTYPE *pSoldier, BOOLEAN fClimbDown ) { if ( !fClimbDown ) { // OK, add aps to goto stand stance... - return( (INT8)( AP_CLIMBROOF + GetAPsToChangeStance( pSoldier, ANIM_STAND ) ) ); + return(( APBPConstants[AP_CLIMBROOF] + GetAPsToChangeStance( pSoldier, ANIM_STAND ) ) ); } else { // Add aps to goto crouch - return( (INT8)( AP_CLIMBOFFROOF + GetAPsToChangeStance( pSoldier, ANIM_CROUCH ) ) ); + return(( APBPConstants[AP_CLIMBOFFROOF] + GetAPsToChangeStance( pSoldier, ANIM_CROUCH ) ) ); } } @@ -2307,50 +2320,53 @@ INT16 GetBPsToClimbRoof( SOLDIERTYPE *pSoldier, BOOLEAN fClimbDown ) { if ( !fClimbDown ) { - return( BP_CLIMBROOF ); + return( APBPConstants[BP_CLIMBROOF] ); } else { - return( BP_CLIMBOFFROOF ); + return( APBPConstants[BP_CLIMBOFFROOF] ); } } -INT8 GetAPsToCutFence( SOLDIERTYPE *pSoldier ) +INT16 GetAPsToCutFence( SOLDIERTYPE *pSoldier ) { // OK, it's normally just cost, but add some if different stance... - return( GetAPsToChangeStance( pSoldier, ANIM_CROUCH ) + AP_USEWIRECUTTERS ); + return( GetAPsToChangeStance( pSoldier, ANIM_CROUCH ) + APBPConstants[AP_USEWIRECUTTERS] ); } -INT8 GetAPsToBeginFirstAid( SOLDIERTYPE *pSoldier ) +INT16 GetAPsToBeginFirstAid( SOLDIERTYPE *pSoldier ) { // OK, it's normally just cost, but add some if different stance... - return( GetAPsToChangeStance( pSoldier, ANIM_CROUCH ) + AP_START_FIRST_AID ); + return( GetAPsToChangeStance( pSoldier, ANIM_CROUCH ) + APBPConstants[AP_START_FIRST_AID] ); } -INT8 GetAPsToBeginRepair( SOLDIERTYPE *pSoldier ) +INT16 GetAPsToBeginRepair( SOLDIERTYPE *pSoldier ) { // OK, it's normally just cost, but add some if different stance... - return( GetAPsToChangeStance( pSoldier, ANIM_CROUCH ) + AP_START_REPAIR ); + return( GetAPsToChangeStance( pSoldier, ANIM_CROUCH ) + APBPConstants[AP_START_REPAIR] ); } -INT8 GetAPsToRefuelVehicle( SOLDIERTYPE *pSoldier ) +INT16 GetAPsToRefuelVehicle( SOLDIERTYPE *pSoldier ) { // OK, it's normally just cost, but add some if different stance... - return( GetAPsToChangeStance( pSoldier, ANIM_CROUCH ) + AP_REFUEL_VEHICLE ); + return( GetAPsToChangeStance( pSoldier, ANIM_CROUCH ) + APBPConstants[AP_REFUEL_VEHICLE] ); } #define TOSSES_PER_10TURNS 18 // max # of grenades tossable in 10 turns -#define AP_MIN_AIM_ATTACK 0 // minimum permitted extra aiming -#define AP_MAX_AIM_ATTACK 4 // maximum permitted extra aiming +//COMMENTED OUT, AS THEY WERE +//1. ALREADY DEFINED IN POINTS.H TO BEGIN WITH +//2. EXTERNALIZED BY GOTTHARD 7/2/08 +//#define APBPConstants[AP_MIN_AIM_ATTACK] 0 // minimum permitted extra aiming +//#define APBPConstants[AP_MAX_AIM_ATTACK] 4 // maximum permitted extra aiming INT16 MinAPsToThrow( SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTurningCost ) { INT32 iTop, iBottom; INT32 iFullAPs; - INT32 iAPCost = AP_MIN_AIM_ATTACK; + INT32 iAPCost = APBPConstants[AP_MIN_AIM_ATTACK]; UINT16 usInHand; UINT16 usTargID; UINT32 uiMercFlags; @@ -2408,7 +2424,7 @@ INT16 MinAPsToThrow( SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTurningCos //AXP 25.03.2007: Aim-at-same-tile AP cost/bonus doesn't make any sense for thrown objects //if ( ( sGridNo != pSoldier->sLastTarget ) ) //{ - // iAPCost += AP_CHANGE_TARGET; + // iAPCost += APBPConstants[AP_CHANGE_TARGET]; //} iAPCost += GetAPsToChangeStance( pSoldier, ANIM_STAND ); @@ -2448,12 +2464,17 @@ INT16 MinAPsToThrow( SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTurningCos return ( (INT16)iAPCost ); } -UINT16 GetAPsToDropBomb( SOLDIERTYPE *pSoldier ) +INT16 GetAPsToDropBomb( SOLDIERTYPE *pSoldier ) { - return( AP_DROP_BOMB ); + return( APBPConstants[AP_DROP_BOMB] ); } -UINT16 GetTotalAPsToDropBomb( SOLDIERTYPE *pSoldier, INT16 sGridNo ) +INT16 GetAPsToPlantMine( SOLDIERTYPE *pSoldier ) +{ + return( APBPConstants[AP_BURY_MINE] ); +} + +INT16 GetTotalAPsToDropBomb( SOLDIERTYPE *pSoldier, INT16 sGridNo ) { INT16 sAPs = 0; @@ -2461,7 +2482,10 @@ UINT16 GetTotalAPsToDropBomb( SOLDIERTYPE *pSoldier, INT16 sGridNo ) if ( sAPs > 0 ) { - sAPs += AP_DROP_BOMB; + if(Item[pSoldier->inv[HANDPOS].usItem].mine == 1) + sAPs += APBPConstants[AP_BURY_MINE]; + else + sAPs += APBPConstants[AP_DROP_BOMB]; } return( sAPs ); @@ -2469,15 +2493,15 @@ UINT16 GetTotalAPsToDropBomb( SOLDIERTYPE *pSoldier, INT16 sGridNo ) -UINT16 GetAPsToUseRemote( SOLDIERTYPE *pSoldier ) +INT16 GetAPsToUseRemote( SOLDIERTYPE *pSoldier ) { - return( AP_USE_REMOTE ); + return( APBPConstants[AP_USE_REMOTE] ); } -INT8 GetAPsToStealItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ) +INT16 GetAPsToStealItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ) { - UINT16 sAPCost = 0; + INT16 sAPCost = 0; if (sMapPos != -1) { @@ -2485,7 +2509,7 @@ INT8 GetAPsToStealItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ) } // ADD APS TO PICKUP - sAPCost += AP_STEAL_ITEM; + sAPCost += APBPConstants[AP_STEAL_ITEM]; // CJC August 13 2002: added cost to stand into equation if (!(PTR_STANDING)) @@ -2493,19 +2517,19 @@ INT8 GetAPsToStealItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ) sAPCost += GetAPsToChangeStance( pSoldier, ANIM_STAND ); } - return( (INT8)sAPCost ); + return sAPCost; } -INT8 GetBPsToStealItem( SOLDIERTYPE *pSoldier ) +INT16 GetBPsToStealItem( SOLDIERTYPE *pSoldier ) { - return( BP_STEAL_ITEM ); + return( APBPConstants[BP_STEAL_ITEM] ); } -INT8 GetAPsToUseJar( SOLDIERTYPE *pSoldier, INT16 sMapPos ) +INT16 GetAPsToUseJar( SOLDIERTYPE *pSoldier, INT16 sMapPos ) { - UINT16 sAPCost = 0; + INT16 sAPCost = 0; sAPCost = PlotPath( pSoldier, sMapPos, NO_COPYROUTE, NO_PLOT, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints ); @@ -2513,16 +2537,16 @@ INT8 GetAPsToUseJar( SOLDIERTYPE *pSoldier, INT16 sMapPos ) if ( sAPCost != 0 ) { // ADD APS TO PICKUP - sAPCost += AP_TAKE_BLOOD; + sAPCost += APBPConstants[AP_TAKE_BLOOD]; } - return( (INT8)sAPCost ); + return sAPCost; } -INT8 GetAPsToUseCan( SOLDIERTYPE *pSoldier, INT16 sMapPos ) +INT16 GetAPsToUseCan( SOLDIERTYPE *pSoldier, INT16 sMapPos ) { - UINT16 sAPCost = 0; + INT16 sAPCost = 0; sAPCost = PlotPath( pSoldier, sMapPos, NO_COPYROUTE, NO_PLOT, TEMPORARY, (UINT16)pSoldier->usUIMovementMode, NOT_STEALTH, FORWARD, pSoldier->bActionPoints ); @@ -2530,15 +2554,15 @@ INT8 GetAPsToUseCan( SOLDIERTYPE *pSoldier, INT16 sMapPos ) if ( sAPCost != 0 ) { // ADD APS TO PICKUP - sAPCost += AP_ATTACH_CAN; + sAPCost += APBPConstants[AP_ATTACH_CAN]; } - return( (INT8)sAPCost ); + return sAPCost; } -INT8 GetAPsToJumpOver( SOLDIERTYPE *pSoldier ) +INT16 GetAPsToJumpOver( SOLDIERTYPE *pSoldier ) { - return( GetAPsToChangeStance( pSoldier, ANIM_STAND ) + AP_JUMP_OVER ); + return( GetAPsToChangeStance( pSoldier, ANIM_STAND ) + APBPConstants[AP_JUMP_OVER] ); } diff --git a/Tactical/Points.h b/Tactical/Points.h index c2eedb59..269e8ae1 100644 --- a/Tactical/Points.h +++ b/Tactical/Points.h @@ -1,6 +1,8 @@ #ifndef __POINTS_H_ #define __POINTS_H_ +#include "Init.h" +/*THESE ARE EXTERNALIZED NOW! AN ENUM WILL REFERENCE A CONSTANT ARRAY! 7/1/08 GOTTHARD #define AP_MINIMUM 10 // no merc can have less for his turn #define AP_MAXIMUM 25 // no merc can have more for his turn #define AP_MONSTER_MAXIMUM 40 // no monster can have more for his turn @@ -45,12 +47,12 @@ #define AP_TOSS_ITEM 8 // toss item from inv #define AP_REFUEL_VEHICLE 10 -/* -#define AP_MOVE_ITEM_FREE 0 // same place, pocket->pocket -#define AP_MOVE_ITEM_FAST 2 // hand, holster, ground only -#define AP_MOVE_ITEM_AVG 4 // everything else! -#define AP_MOVE_ITEM_SLOW 6 // vests, protective gear -*/ + +//#define AP_MOVE_ITEM_FREE 0 // same place, pocket->pocket +//#define AP_MOVE_ITEM_FAST 2 // hand, holster, ground only +//#define AP_MOVE_ITEM_AVG 4 // everything else! +//#define AP_MOVE_ITEM_SLOW 6 // vests, protective gear + #define AP_MOVE_ITEM_FAST 4 // hand, holster, ground only #define AP_MOVE_ITEM_SLOW 6 // vests, protective gear @@ -194,12 +196,12 @@ #define BP_JUMPFENCEBPACK 500 // BPs to jump fence -/* -#define BP_MOVE_ITEM_FREE 0 // same place, pocket->pocket -#define BP_MOVE_ITEM_FAST 0 // hand, holster, ground only -#define BP_MOVE_ITEM_AVG 0 // everything else! -#define BP_MOVE_ITEM_SLOW 20 // vests, protective gear -*/ + +//#define BP_MOVE_ITEM_FREE 0 // same place, pocket->pocket +//#define BP_MOVE_ITEM_FAST 0 // hand, holster, ground only +//#define BP_MOVE_ITEM_AVG 0 // everything else! +//#define BP_MOVE_ITEM_SLOW 20 // vests, protective gear + #define BP_MOVE_ITEM_FAST 0 // hand, holster, ground only #define BP_MOVE_ITEM_SLOW 20 // vests, protective gear @@ -267,12 +269,14 @@ #define BP_JUMP_OVER 250 - - #define DEFAULT_APS 20 #define DEFAULT_AIMSKILL 80 +*/ -UINT8 BaseAPsToShootOrStab( INT8 bAPs, INT8 bAimSkill, OBJECTTYPE * pObj ); +//Just so the compiler will be able to use it in init.cpp, I'm a careful person. Gotthard 1/18/07 +extern INT16 APBPConstants[TOTAL_APBP_VALUES]; + +INT16 BaseAPsToShootOrStab( INT16 bAPs, INT16 bAimSkill, OBJECTTYPE * pObj ); INT16 TerrainActionPoints( SOLDIERTYPE *pSoldier, INT16 sGridno, INT8 bDir, INT8 bLevel ); INT16 ActionPointCost( SOLDIERTYPE *pSoldier, INT16 sGridNo, INT8 bDir, UINT16 usMovementMode ); @@ -284,63 +288,64 @@ void DeductPoints( SOLDIERTYPE *pSoldier, INT16 sAPCost, INT32 iBPCost, BOOLEAN INT32 AdjustBreathPts(SOLDIERTYPE *pSold, INT32 iBPCost); void UnusedAPsToBreath(SOLDIERTYPE *pSold); INT16 TerrainBreathPoints(SOLDIERTYPE * pSoldier, INT16 sGridno,INT8 bDir, UINT16 usMovementMode); -UINT8 MinAPsToAttack(SOLDIERTYPE *pSoldier, INT16 sGridno, UINT8 ubAddTurningCost, UINT8 ubForceRaiseGunCost = 0); -INT8 MinPtsToMove(SOLDIERTYPE *pSoldier); +INT16 MinAPsToAttack(SOLDIERTYPE *pSoldier, INT16 sGridno, UINT8 ubAddTurningCost, UINT8 ubForceRaiseGunCost = 0); +INT16 MinPtsToMove(SOLDIERTYPE *pSoldier); INT8 MinAPsToStartMovement( SOLDIERTYPE * pSoldier, UINT16 usMovementMode ); INT8 PtsToMoveDirection(SOLDIERTYPE *pSoldier, INT8 bDirection ); UINT16 CalculateTurningCost(SOLDIERTYPE *pSoldier, UINT16 usItem, BOOLEAN fAddingTurningCost); UINT16 CalculateRaiseGunCost(SOLDIERTYPE *pSoldier, BOOLEAN fAddingRaiseGunCost); -UINT8 MinAPsToShootOrStab(SOLDIERTYPE *pSoldier, INT16 sGridno, UINT8 ubAddTurningCost, UINT8 ubForceRaiseGunCost = 0 ); +INT16 MinAPsToShootOrStab(SOLDIERTYPE *pSoldier, INT16 sGridno, UINT8 ubAddTurningCost, UINT8 ubForceRaiseGunCost = 0 ); BOOLEAN EnoughAmmo( SOLDIERTYPE *pSoldier, BOOLEAN fDisplay, INT8 bInvPos ); void DeductAmmo( SOLDIERTYPE *pSoldier, INT8 bInvPos ); -UINT16 GetAPsToPickupItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ); -UINT8 MinAPsToPunch(SOLDIERTYPE *pSoldier, INT16 sGridno, UINT8 ubAddTurningCost ); -UINT8 CalcTotalAPsToAttack( SOLDIERTYPE *pSoldier, INT16 sGridno, UINT8 ubAddTurningCost, INT8 bAimTime ); -UINT8 CalcAPsToBurst( INT8 bBaseActionPoints, OBJECTTYPE * pObj ); -UINT8 CalcAPsToAutofire( INT8 bBaseActionPoints, OBJECTTYPE * pObj, UINT8 bDoAutofire ); -UINT16 GetAPsToChangeStance( SOLDIERTYPE *pSoldier, INT8 bDesiredHeight ); -UINT16 GetBPsToChangeStance( SOLDIERTYPE *pSoldier, INT8 bDesiredHeight ); +INT16 GetAPsToPickupItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ); +INT16 MinAPsToPunch(SOLDIERTYPE *pSoldier, INT16 sGridno, UINT8 ubAddTurningCost ); +INT16 CalcTotalAPsToAttack( SOLDIERTYPE *pSoldier, INT16 sGridno, UINT8 ubAddTurningCost, INT16 bAimTime ); +INT16 CalcAPsToBurst( INT16 bBaseActionPoints, OBJECTTYPE * pObj ); +INT16 CalcAPsToAutofire( INT16 bBaseActionPoints, OBJECTTYPE * pObj, UINT8 bDoAutofire ); +INT16 GetAPsToChangeStance( SOLDIERTYPE *pSoldier, INT8 bDesiredHeight ); +INT16 GetBPsToChangeStance( SOLDIERTYPE *pSoldier, INT8 bDesiredHeight ); -UINT16 GetAPsToLook( SOLDIERTYPE *pSoldier ); -UINT16 GetAPsToGiveItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ); +INT16 GetAPsToLook( SOLDIERTYPE *pSoldier ); +INT16 GetAPsToGiveItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ); BOOLEAN CheckForMercContMove( SOLDIERTYPE *pSoldier ); INT16 GetAPsToReadyWeapon( SOLDIERTYPE *pSoldier, UINT16 usAnimState ); -INT8 GetAPsToClimbRoof( SOLDIERTYPE *pSoldier, BOOLEAN fClimbDown ); +INT16 GetAPsToClimbRoof( SOLDIERTYPE *pSoldier, BOOLEAN fClimbDown ); INT16 GetBPsToClimbRoof( SOLDIERTYPE *pSoldier, BOOLEAN fClimbDown ); -INT8 GetAPsToJumpFence( SOLDIERTYPE *pSoldier ); -INT8 GetBPsToJumpFence( SOLDIERTYPE *pSoldier ); +INT16 GetAPsToJumpFence( SOLDIERTYPE *pSoldier ); +INT16 GetBPsToJumpFence( SOLDIERTYPE *pSoldier ); -INT8 GetAPsToCutFence( SOLDIERTYPE *pSoldier ); -INT8 GetAPsToBeginFirstAid( SOLDIERTYPE *pSoldier ); -INT8 GetAPsToBeginRepair( SOLDIERTYPE *pSoldier ); -INT8 GetAPsToRefuelVehicle( SOLDIERTYPE *pSoldier ); +INT16 GetAPsToCutFence( SOLDIERTYPE *pSoldier ); +INT16 GetAPsToBeginFirstAid( SOLDIERTYPE *pSoldier ); +INT16 GetAPsToBeginRepair( SOLDIERTYPE *pSoldier ); +INT16 GetAPsToRefuelVehicle( SOLDIERTYPE *pSoldier ); INT16 MinAPsToThrow( SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTurningCost ); -UINT16 GetAPsToDropBomb( SOLDIERTYPE *pSoldier ); -UINT16 GetTotalAPsToDropBomb( SOLDIERTYPE *pSoldier, INT16 sGridNo ); -UINT16 GetAPsToUseRemote( SOLDIERTYPE *pSoldier ); +INT16 GetAPsToDropBomb( SOLDIERTYPE *pSoldier ); +INT16 GetAPsToPlantMine( SOLDIERTYPE *pSoldier ); +INT16 GetTotalAPsToDropBomb( SOLDIERTYPE *pSoldier, INT16 sGridNo ); +INT16 GetAPsToUseRemote( SOLDIERTYPE *pSoldier ); -INT8 GetAPsToStealItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ); -INT8 GetBPsToStealItem( SOLDIERTYPE *pSoldier ); +INT16 GetAPsToStealItem( SOLDIERTYPE *pSoldier, INT16 sMapPos ); +INT16 GetBPsToStealItem( SOLDIERTYPE *pSoldier ); -INT8 GetAPsToUseJar( SOLDIERTYPE *pSoldier, INT16 sMapPos ); -INT8 GetAPsToUseCan( SOLDIERTYPE *pSoldier, INT16 sMapPos ); -INT8 GetBPsTouseJar( SOLDIERTYPE *pSoldier ); +INT16 GetAPsToUseJar( SOLDIERTYPE *pSoldier, INT16 sMapPos ); +INT16 GetAPsToUseCan( SOLDIERTYPE *pSoldier, INT16 sMapPos ); +INT16 GetBPsTouseJar( SOLDIERTYPE *pSoldier ); -INT8 GetAPsToJumpOver( SOLDIERTYPE *pSoldier ); +INT16 GetAPsToJumpOver( SOLDIERTYPE *pSoldier ); void GetAPChargeForShootOrStabWRTGunRaises( SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAddTurningCost, BOOLEAN *pfChargeTurning, BOOLEAN *pfChargeRaise ); UINT16 GetAPsToReloadRobot( SOLDIERTYPE *pSoldier, SOLDIERTYPE *pRobot ); -INT8 GetAPsToReloadGunWithAmmo( SOLDIERTYPE *pSoldier, OBJECTTYPE * pGun, OBJECTTYPE * pAmmo, BOOLEAN usAllAPs = TRUE ); -INT8 GetAPsToAutoReload( SOLDIERTYPE * pSoldier ); +INT16 GetAPsToReloadGunWithAmmo( SOLDIERTYPE *pSoldier, OBJECTTYPE * pGun, OBJECTTYPE * pAmmo, BOOLEAN usAllAPs = TRUE ); +INT16 GetAPsToAutoReload( SOLDIERTYPE * pSoldier ); -#endif \ No newline at end of file +#endif diff --git a/Tactical/Rotting Corpses.cpp b/Tactical/Rotting Corpses.cpp index ffec3e56..7fff9dc5 100644 --- a/Tactical/Rotting Corpses.cpp +++ b/Tactical/Rotting Corpses.cpp @@ -1573,7 +1573,7 @@ INT16 FindNearestAvailableGridNoForCorpse( ROTTING_CORPSE_DEFINITION *pDef, INT8 INT32 leftmost; BOOLEAN fFound = FALSE; SOLDIERTYPE soldier; - UINT8 ubSaveNPCAPBudget; + INT16 ubSaveNPCAPBudget; UINT8 ubSaveNPCDistLimit; STRUCTURE_FILE_REF * pStructureFileRef = NULL; CHAR8 zFilename[150]; diff --git a/Tactical/ShopKeeper Interface.cpp b/Tactical/ShopKeeper Interface.cpp index e32b0fcf..cc64e618 100644 --- a/Tactical/ShopKeeper Interface.cpp +++ b/Tactical/ShopKeeper Interface.cpp @@ -868,7 +868,7 @@ BOOLEAN EnterShopKeeperInterface() { // First calculate APs and validate... // Check AP cost... - if ( !EnoughPoints( pSoldier, AP_TALK, 0, TRUE ) ) + if ( !EnoughPoints( pSoldier, APBPConstants[AP_TALK], 0, TRUE ) ) { return( FALSE ); } diff --git a/Tactical/Soldier Add.cpp b/Tactical/Soldier Add.cpp index 12887532..ffd32136 100644 --- a/Tactical/Soldier Add.cpp +++ b/Tactical/Soldier Add.cpp @@ -67,7 +67,7 @@ INT16 FindGridNoFromSweetSpot( SOLDIERTYPE *pSoldier, INT16 sSweetGridNo, INT8 u INT32 leftmost; BOOLEAN fFound = FALSE; SOLDIERTYPE soldier; - UINT8 ubSaveNPCAPBudget; + INT16 ubSaveNPCAPBudget; UINT8 ubSaveNPCDistLimit; //Save AI pathing vars. changing the distlimit restricts how @@ -168,7 +168,7 @@ INT16 FindGridNoFromSweetSpotThroughPeople( SOLDIERTYPE *pSoldier, INT16 sSweetG INT32 leftmost; BOOLEAN fFound = FALSE; SOLDIERTYPE soldier; - UINT8 ubSaveNPCAPBudget; + INT16 ubSaveNPCAPBudget; UINT8 ubSaveNPCDistLimit; //Save AI pathing vars. changing the distlimit restricts how @@ -267,7 +267,7 @@ INT16 FindGridNoFromSweetSpotWithStructData( SOLDIERTYPE *pSoldier, UINT16 usAni INT32 leftmost; BOOLEAN fFound = FALSE; SOLDIERTYPE soldier; - UINT8 ubSaveNPCAPBudget; + INT16 ubSaveNPCAPBudget; UINT8 ubSaveNPCDistLimit; UINT8 ubBestDirection=0; @@ -429,7 +429,7 @@ INT16 FindGridNoFromSweetSpotWithStructDataUsingGivenDirectionFirst( SOLDIERTYPE INT32 leftmost; BOOLEAN fFound = FALSE; SOLDIERTYPE soldier; - UINT8 ubSaveNPCAPBudget; + INT16 ubSaveNPCAPBudget; UINT8 ubSaveNPCDistLimit; UINT8 ubBestDirection=0; @@ -602,7 +602,7 @@ INT16 FindGridNoFromSweetSpotWithStructDataFromSoldier( SOLDIERTYPE *pSoldier, U INT16 sLowestGridNo=-1; INT32 leftmost; BOOLEAN fFound = FALSE; - UINT8 ubSaveNPCAPBudget; + INT16 ubSaveNPCAPBudget; UINT8 ubSaveNPCDistLimit; UINT8 ubBestDirection=0; INT16 sSweetGridNo; @@ -933,7 +933,7 @@ INT16 FindRandomGridNoFromSweetSpot( SOLDIERTYPE *pSoldier, INT16 sSweetGridNo, BOOLEAN fFound = FALSE; UINT32 cnt = 0; SOLDIERTYPE soldier; - UINT8 ubSaveNPCAPBudget; + INT16 ubSaveNPCAPBudget; UINT8 ubSaveNPCDistLimit; INT16 sTop, sBottom; INT16 sLeft, sRight; @@ -1735,3 +1735,4 @@ INT16 GetSoldierIDFromMercID(UINT8 ubMercID) } + diff --git a/Tactical/Soldier Ani.cpp b/Tactical/Soldier Ani.cpp index 478c5165..7dfcb433 100644 --- a/Tactical/Soldier Ani.cpp +++ b/Tactical/Soldier Ani.cpp @@ -1010,7 +1010,7 @@ BOOLEAN AdjustToNextAnimationFrame( SOLDIERTYPE *pSoldier ) else { // ATE: Deduct points! - DeductPoints( pSoldier, AP_TOSS_ITEM, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_TOSS_ITEM], 0 ); } CreatePhysicalObject( pSoldier->pTempObject, pSoldier->pThrowParams->dLifeSpan, pSoldier->pThrowParams->dX, pSoldier->pThrowParams->dY, pSoldier->pThrowParams->dZ, pSoldier->pThrowParams->dForceX, pSoldier->pThrowParams->dForceY, pSoldier->pThrowParams->dForceZ, pSoldier->ubID, pSoldier->pThrowParams->ubActionCode, pSoldier->pThrowParams->uiActionData, FALSE ); diff --git a/Tactical/Soldier Control.cpp b/Tactical/Soldier Control.cpp index b93243f6..96d0f161 100644 --- a/Tactical/Soldier Control.cpp +++ b/Tactical/Soldier Control.cpp @@ -1792,11 +1792,11 @@ void HandleCrowShadowNewPosition( SOLDIERTYPE *pSoldier ) } } +extern INT16 DynamicAdjustAPConstants(INT16 iniReadValue, INT16 iniDefaultValue, BOOLEAN reverse); - -INT8 SOLDIERTYPE::CalcActionPoints( void ) +INT16 SOLDIERTYPE::CalcActionPoints( void ) { - UINT8 ubPoints,ubMaxAPs; + INT16 ubPoints,ubMaxAPs; INT8 bBandage; // dead guys don't get any APs (they shouldn't be here asking for them!) @@ -1807,15 +1807,20 @@ INT8 SOLDIERTYPE::CalcActionPoints( void ) if ( (this->bSleepDrugCounter > 0) && this->bCollapsed ) return( 0 ); + //CHRISL: Update this calucalation to give a default range of 40-100 // Calculate merc's action points at 100% capability (range is 10 - 25) // round fractions of .5 up (that's why the +20 before the division! - ubPoints = 5 + (((10 * EffectiveExpLevel( this ) + + //ubPoints = 5 + (((10 * EffectiveExpLevel( this ) + + // 3 * EffectiveAgility( this ) + + // 2 * this->stats.bLifeMax + + // 2 * EffectiveDexterity( this ) ) + 20) / 40); + ubPoints = 20 + (((10 * EffectiveExpLevel( this ) + 3 * EffectiveAgility( this ) + 2 * this->stats.bLifeMax + - 2 * EffectiveDexterity( this ) ) + 20) / 40); + 2 * EffectiveDexterity( this ) ) + 5) / 10); //if (GameOption[INCREASEDAP] % 2 == 1) - //points += AP_INCREASE; + //points += APBPConstants[AP_INCREASE]; //Madd: Add in AP Bonuses (Penalties) from worn gear ubPoints += GetGearAPBonus ( this ); @@ -1840,14 +1845,18 @@ INT8 SOLDIERTYPE::CalcActionPoints( void ) } // If resulting APs are below our permitted minimum, raise them to it! - if (ubPoints < AP_MINIMUM) - ubPoints = AP_MINIMUM; + if (ubPoints < APBPConstants[AP_MINIMUM]) + ubPoints = APBPConstants[AP_MINIMUM]; + + //CHRISL: Moved this down here so that all ubPoints adjustments can be made to the default 100AP system + // Adjust ubPoints based on actual AP_MAXIMUM setting + ubPoints = DynamicAdjustAPConstants(ubPoints, ubPoints); // make sure action points doesn't exceed the permitted maximum ubMaxAPs = gubMaxActionPoints[ this->ubBodyType ]; //if (GameOption[INCREASEDAP] % 2 == 1) - // maxAPs += AP_INCREASE; + // maxAPs += APBPConstants[AP_INCREASE]; // If resulting APs are below our permitted minimum, raise them to it! @@ -1857,21 +1866,21 @@ INT8 SOLDIERTYPE::CalcActionPoints( void ) if ( this->ubBodyType == BLOODCAT ) { // use same as young monsters - ubPoints = (ubPoints * AP_YOUNG_MONST_FACTOR) / 10; + ubPoints = (ubPoints * APBPConstants[AP_YOUNG_MONST_FACTOR]) / 10; } else if (this->flags.uiStatusFlags & SOLDIER_MONSTER) { // young monsters get extra APs if ( this->ubBodyType == YAF_MONSTER || this->ubBodyType == YAM_MONSTER || this->ubBodyType == INFANT_MONSTER ) { - ubPoints = (ubPoints * AP_YOUNG_MONST_FACTOR) / 10; + ubPoints = (ubPoints * APBPConstants[AP_YOUNG_MONST_FACTOR]) / 10; } // if frenzied, female monsters get more APs! (for young females, cumulative!) if (this->aiData.bFrenzied) { - ubPoints = (ubPoints * AP_MONST_FRENZY_FACTOR) / 10; + ubPoints = (ubPoints * APBPConstants[AP_MONST_FRENZY_FACTOR]) / 10; } } @@ -1880,11 +1889,11 @@ INT8 SOLDIERTYPE::CalcActionPoints( void ) { if ( (gMercProfiles[ this->ubProfile ].bPersonalityTrait == CLAUSTROPHOBIC) && (gbWorldSectorZ > 0) ) { - ubPoints = (ubPoints * AP_CLAUSTROPHOBE) / 10; + ubPoints = (ubPoints * APBPConstants[AP_CLAUSTROPHOBE]) / 10; } else if ( (gMercProfiles[ this->ubProfile ].bPersonalityTrait == FEAR_OF_INSECTS) && (MercSeesCreature( this ) ) ) { - ubPoints = (ubPoints * AP_AFRAID_OF_INSECTS) / 10; + ubPoints = (ubPoints * APBPConstants[AP_AFRAID_OF_INSECTS]) / 10; } } @@ -1950,16 +1959,17 @@ void SOLDIERTYPE::CalcNewActionPoints( void ) if ( gTacticalStatus.bBoxingState == BOXING || gTacticalStatus.bBoxingState == PRE_BOXING ) { // if we are in boxing mode, carry 1/2 as many points - if (this->bActionPoints > MAX_AP_CARRIED / 2) + if (this->bActionPoints > APBPConstants[MAX_AP_CARRIED] / 2) { - this->bActionPoints = MAX_AP_CARRIED / 2; + this->bActionPoints = APBPConstants[MAX_AP_CARRIED] / 2; } } else { - if (this->bActionPoints > MAX_AP_CARRIED) + //POSSIBLE STRUCTURE CHANGE PROBLEM, NOT CURRENTLY CHANGED. GOTTHARD 7/14/08 + if (this->bActionPoints > APBPConstants[MAX_AP_CARRIED]) { - this->bActionPoints = MAX_AP_CARRIED; + this->bActionPoints = APBPConstants[MAX_AP_CARRIED]; } } @@ -3301,11 +3311,11 @@ BOOLEAN SOLDIERTYPE::EVENT_InitNewSoldierAnim( UINT16 usNewState, UINT16 usStart // CHRISL if((UsingNewInventorySystem() == true) && this->inv[BPACKPOCKPOS].exists() == true) { - sAPCost = AP_START_RUN_COST + 2; + sAPCost = APBPConstants[AP_START_RUN_COST] + 2; sBPCost += 2; } else - sAPCost = AP_START_RUN_COST; + sAPCost = APBPConstants[AP_START_RUN_COST]; DeductPoints( this, sAPCost, sBPCost ); } // Set pending action count to 0 @@ -3333,24 +3343,24 @@ BOOLEAN SOLDIERTYPE::EVENT_InitNewSoldierAnim( UINT16 usNewState, UINT16 usStart { if(usNewState == KNEEL_UP || usNewState == BIGMERC_CROUCH_TRANS_OUTOF) { - sAPCost=AP_CROUCH+2; - sBPCost=BP_CROUCH+2; + sAPCost=APBPConstants[AP_CROUCH]+2; + sBPCost=APBPConstants[BP_CROUCH]+2; } else if(usNewState == KNEEL_DOWN || usNewState == BIGMERC_CROUCH_TRANS_INTO) { - sAPCost=AP_CROUCH+1; - sBPCost=BP_CROUCH+1; + sAPCost=APBPConstants[AP_CROUCH]+1; + sBPCost=APBPConstants[BP_CROUCH]+1; } else { - sAPCost=AP_CROUCH; - sBPCost=BP_CROUCH; + sAPCost=APBPConstants[AP_CROUCH]; + sBPCost=APBPConstants[BP_CROUCH]; } } else { - sAPCost=AP_CROUCH; - sBPCost=BP_CROUCH; + sAPCost=APBPConstants[AP_CROUCH]; + sBPCost=APBPConstants[BP_CROUCH]; } DeductPoints( this, sAPCost, sBPCost ); } @@ -3371,19 +3381,19 @@ BOOLEAN SOLDIERTYPE::EVENT_InitNewSoldierAnim( UINT16 usNewState, UINT16 usStart { if(usNewState == PRONE_UP) { - sAPCost=AP_PRONE+2; - sBPCost=BP_PRONE+2; + sAPCost=APBPConstants[AP_PRONE]+2; + sBPCost=APBPConstants[BP_PRONE]+2; } else { - sAPCost=AP_PRONE+1; - sBPCost=BP_PRONE+1; + sAPCost=APBPConstants[AP_PRONE]+1; + sBPCost=APBPConstants[BP_PRONE]+1; } } else { - sAPCost=AP_PRONE; - sBPCost=BP_PRONE; + sAPCost=APBPConstants[AP_PRONE]; + sBPCost=APBPConstants[BP_PRONE]; } DeductPoints( this, sAPCost, sBPCost ); } @@ -3398,21 +3408,24 @@ BOOLEAN SOLDIERTYPE::EVENT_InitNewSoldierAnim( UINT16 usNewState, UINT16 usStart case START_AID: - DeductPoints( this, AP_START_FIRST_AID, BP_START_FIRST_AID ); + DeductPoints( this, APBPConstants[AP_START_FIRST_AID], APBPConstants[BP_START_FIRST_AID] ); break; case CUTTING_FENCE: - DeductPoints( this, AP_USEWIRECUTTERS, BP_USEWIRECUTTERS ); + DeductPoints( this, APBPConstants[AP_USEWIRECUTTERS], APBPConstants[BP_USEWIRECUTTERS] ); break; case PLANT_BOMB: - DeductPoints( this, AP_DROP_BOMB, 0 ); + if(Item[this->inv[HANDPOS].usItem].mine == 1) // bury a mine + DeductPoints( this, APBPConstants[AP_BURY_MINE], APBPConstants[BP_BURY_MINE] ); + else + DeductPoints( this, APBPConstants[AP_DROP_BOMB], APBPConstants[BP_DROP_BOMB] ); break; case STEAL_ITEM: - DeductPoints( this, AP_STEAL_ITEM, 0 ); + DeductPoints( this, APBPConstants[AP_STEAL_ITEM], 0 ); break; case CROW_DIE: @@ -3440,7 +3453,7 @@ BOOLEAN SOLDIERTYPE::EVENT_InitNewSoldierAnim( UINT16 usNewState, UINT16 usStart case USE_REMOTE: - DeductPoints( this, AP_USE_REMOTE, 0 ); + DeductPoints( this, APBPConstants[AP_USE_REMOTE], 0 ); break; //case PUNCH: @@ -3454,21 +3467,21 @@ BOOLEAN SOLDIERTYPE::EVENT_InitNewSoldierAnim( UINT16 usNewState, UINT16 usStart // CHRISL if((UsingNewInventorySystem() == true) && this->inv[BPACKPOCKPOS].exists() == true) - DeductPoints( this, AP_JUMPFENCEBPACK, BP_JUMPFENCEBPACK ); + DeductPoints( this, APBPConstants[AP_JUMPFENCEBPACK], APBPConstants[BP_JUMPFENCEBPACK] ); else - DeductPoints( this, AP_JUMPFENCE, BP_JUMPFENCE ); + DeductPoints( this, APBPConstants[AP_JUMPFENCE], APBPConstants[BP_JUMPFENCE] ); break; // Deduct aps for falling down.... case FALLBACK_HIT_STAND: case FALLFORWARD_FROMHIT_STAND: - DeductPoints( this, AP_FALL_DOWN, BP_FALL_DOWN ); + DeductPoints( this, APBPConstants[AP_FALL_DOWN], APBPConstants[BP_FALL_DOWN] ); break; case FALLFORWARD_FROMHIT_CROUCH: - DeductPoints( this, (AP_FALL_DOWN/2), (BP_FALL_DOWN/2) ); + DeductPoints( this, (APBPConstants[AP_FALL_DOWN]/2), (APBPConstants[BP_FALL_DOWN]/2) ); break; case QUEEN_SWIPE: @@ -3482,7 +3495,7 @@ BOOLEAN SOLDIERTYPE::EVENT_InitNewSoldierAnim( UINT16 usNewState, UINT16 usStart // disable sight gTacticalStatus.uiFlags |= DISALLOW_SIGHT; - DeductPoints( this, AP_CLIMBOFFROOF, BP_CLIMBOFFROOF ); + DeductPoints( this, APBPConstants[AP_CLIMBOFFROOF], APBPConstants[BP_CLIMBOFFROOF] ); break; case CLIMBUPROOF: @@ -3490,7 +3503,7 @@ BOOLEAN SOLDIERTYPE::EVENT_InitNewSoldierAnim( UINT16 usNewState, UINT16 usStart // disable sight gTacticalStatus.uiFlags |= DISALLOW_SIGHT; - DeductPoints( this, AP_CLIMBROOF, BP_CLIMBROOF ); + DeductPoints( this, APBPConstants[AP_CLIMBROOF], APBPConstants[BP_CLIMBROOF] ); break; case JUMP_OVER_BLOCKING_PERSON: @@ -3499,7 +3512,7 @@ BOOLEAN SOLDIERTYPE::EVENT_InitNewSoldierAnim( UINT16 usNewState, UINT16 usStart { INT16 sNewGridNo; - DeductPoints( this, AP_JUMP_OVER, BP_JUMP_OVER ); + DeductPoints( this, APBPConstants[AP_JUMP_OVER], APBPConstants[BP_JUMP_OVER] ); sNewGridNo = NewGridNo( (INT16)this->sGridNo, DirectionInc( this->ubDirection ) ); sNewGridNo = NewGridNo( (INT16)sNewGridNo, DirectionInc( this->ubDirection ) ); @@ -4714,7 +4727,7 @@ BOOLEAN SOLDIERTYPE::InternalSoldierReadyWeapon( UINT8 sFacingDir, BOOLEAN fEndR // Check if facing dir is different from ours and change direction if so! //if ( sFacingDir != this->ubDirection ) //{ - // DeductPoints( this, AP_CHANGE_FACING, 0 ); + // DeductPoints( this, APBPConstants[AP_CHANGE_FACING], 0 ); //}// } @@ -4960,7 +4973,7 @@ void SOLDIERTYPE::EVENT_SoldierGotHit( UINT16 usWeaponIndex, INT16 sDamage, INT1 // setting new func to intercept testhit else if ( Item[ usWeaponIndex ].usItemClass & ( IC_GUN | IC_THROWING_KNIFE ) && ubAttackerID == NOBODY) { - sBreathLoss += BP_GET_HIT; + sBreathLoss += APBPConstants[BP_GET_HIT]; ubReason = TAKE_DAMAGE_GUNFIRE; } // callahan update end @@ -5001,12 +5014,12 @@ void SOLDIERTYPE::EVENT_SoldierGotHit( UINT16 usWeaponIndex, INT16 sDamage, INT1 // Dirty panel fInterfacePanelDirty = DIRTYLEVEL2; } - sBreathLoss += BP_GET_HIT; + sBreathLoss += APBPConstants[BP_GET_HIT]; ubReason = TAKE_DAMAGE_GUNFIRE; } else if ( Item[ usWeaponIndex ].usItemClass & IC_BLADE ) { - sBreathLoss = BP_GET_HIT; + sBreathLoss = APBPConstants[BP_GET_HIT]; ubReason = TAKE_DAMAGE_BLADE; } else if ( Item[ usWeaponIndex ].usItemClass & IC_PUNCH ) @@ -6339,15 +6352,15 @@ void EVENT_InternalSetSoldierDesiredDirection( SOLDIERTYPE *pSoldier, UINT8 ubNe { // Now change to appropriate animation case ANIM_STAND: - DeductPoints( pSoldier, AP_LOOK_STANDING, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_LOOK_STANDING], 0 ); break; case ANIM_CROUCH: - DeductPoints( pSoldier, AP_LOOK_CROUCHED, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_LOOK_CROUCHED], 0 ); break; case ANIM_PRONE: - DeductPoints( pSoldier, AP_LOOK_PRONE, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_LOOK_PRONE], 0 ); break; } @@ -6533,8 +6546,8 @@ void SOLDIERTYPE::EVENT_BeginMercTurn( BOOLEAN fFromRealTime, INT32 iRealTimeCou // save unused action points up to a maximum /* - if ((savedPts = this->aiData.bActionPts) > MAX_AP_CARRIED) - savedPts = MAX_AP_CARRIED; + if ((savedPts = this->aiData.bActionPts) > APBPConstants[MAX_AP_CARRIED]) + savedPts = APBPConstants[MAX_AP_CARRIED]; */ if ( this->flags.uiStatusFlags & SOLDIER_GASSED ) { @@ -8449,8 +8462,11 @@ UINT8 SOLDIERTYPE::SoldierTakeDamage( INT8 bHeight, INT16 sLifeDeduct, INT16 sBr } + //CHRISL: We need this to dynamically adjust based on maxAP. Otherwise sLifeDeduct=16 results in a greater effective penalty + // the lower our AP_MAXIMUM value is set to. // Deduct breath AND APs! - sAPCost = (sLifeDeduct / AP_GET_WOUNDED_DIVISOR); // + fallCost; + //sAPCost = (sLifeDeduct / APBPConstants[AP_GET_WOUNDED_DIVISOR]); // + fallCost; + sAPCost = (sLifeDeduct / APBPConstants[AP_GET_WOUNDED_DIVISOR]) / 100 * APBPConstants[AP_MAXIMUM]; // ATE: if the robot, do not deduct if ( !AM_A_ROBOT( this ) ) @@ -9413,6 +9429,41 @@ void SOLDIERTYPE::MoveMerc( FLOAT dMovementChange, FLOAT dAngle, BOOLEAN fCheckR } +BOOLEAN GetDirectionChangeAmount( INT16 sGridNo, SOLDIERTYPE *pSoldier, UINT8 uiTurnAmount) +{ + //CHRISL: This function should return TRUE if the difference between our current facing and the facing needed to put + // the indicated sGrinNo into our facing is greater then uiTurnAmount + UINT8 ubDirection = GetDirectionFromGridNo( sGridNo, pSoldier ); + UINT8 subDirection = pSoldier->ubDirection + 3; + UINT8 uiDirArray[16] = {5,6,7,8,1,2,3,4,5,6,7,8,1,2,3,4}; + + //Failsafe; just check to make sure we actually have to turn. + if(ubDirection == pSoldier->ubDirection) + return FALSE; + + // We'll never turn more then 180 degrees (4) so reset uiTurnAmount if needed + uiTurnAmount = min(uiTurnAmount, 4); + + // Loop up the array + for(UINT8 i = 1; i <= 4; i++) + { + if(uiDirArray[subDirection+i] == ubDirection) + { + return !(i<=uiTurnAmount); + } + } + // Loop down the array + for(UINT8 i = 1; i <= 4; i++) + { + if(uiDirArray[subDirection-i] == ubDirection) + { + return !(i<=uiTurnAmount); + } + } + + return TRUE; +} + UINT8 GetDirectionFromGridNo( INT16 sGridNo, SOLDIERTYPE *pSoldier ) { INT16 sXPos, sYPos; @@ -10865,7 +10916,7 @@ UINT32 SOLDIERTYPE::SoldierDressWound( SOLDIERTYPE *pVictim, INT16 sKitPts, INT1 uiUsedAPs = ( uiUsedAPs * 2) / 3; // reverse 50% bonus by taking 2/3rds } - DeductPoints( this, (INT16)uiUsedAPs, (INT16)( ( uiUsedAPs * BP_PER_AP_LT_EFFORT) ) ); + DeductPoints( this, (INT16)uiUsedAPs, (INT16)( ( uiUsedAPs * APBPConstants[BP_PER_AP_LT_EFFORT]) ) ); SOLDIERTYPE* pSoldier = this; @@ -12688,7 +12739,7 @@ BOOLEAN SOLDIERTYPE::PlayerSoldierStartTalking( UINT8 ubTargetID, BOOLEAN fValid } // Get APs... - sAPCost = AP_TALK; + sAPCost = APBPConstants[AP_TALK]; if ( !(gTacticalStatus.uiFlags & INCOMBAT) || (gTacticalStatus.uiFlags & REALTIME) ) //lal { diff --git a/Tactical/Soldier Control.h b/Tactical/Soldier Control.h index e56a4a60..8c485f25 100644 --- a/Tactical/Soldier Control.h +++ b/Tactical/Soldier Control.h @@ -415,7 +415,7 @@ public: UINT32 uiPendingActionData4; INT8 bInterruptDuelPts; INT8 bPassedLastInterrupt; - INT8 bIntStartAPs; + INT16 bIntStartAPs; //100AP INT8 bMoved; INT8 bHunting; UINT8 ubLastCall; @@ -429,7 +429,7 @@ public: INT8 bMobility; INT8 bRTPCombat; INT8 fAIFlags; - INT8 bAimTime; + INT16 bAimTime; //100AP INT8 bShownAimTime; }; @@ -656,8 +656,8 @@ public: // DESCRIPTION / STATS, ETC UINT8 ubBodyType; - INT8 bActionPoints; - INT8 bInitialActionPoints; + INT16 bActionPoints; //100AP + INT16 bInitialActionPoints; //100AP INT8 bOldLife; // life at end of last turn, recorded for monster AI INT8 bVisible; // to render or not to render... INT8 bActive; @@ -1133,7 +1133,7 @@ public: // UTILITY FUNCTUIONS void MoveMerc( FLOAT dMovementChange, FLOAT dAngle, BOOLEAN fCheckRange ); - INT8 CalcActionPoints( void ); + INT16 CalcActionPoints( void ); BOOLEAN IsActionInterruptable( void ); // This function is now obsolete. Call ReduceAttackBusyCount instead. // void ReleaseSoldiersAttacker( SOLDIERTYPE *pSoldier ); @@ -1302,6 +1302,7 @@ BOOLEAN DeletePaletteData( ); // UTILITY FUNCTUIONS void MoveMercFacingDirection( SOLDIERTYPE *pSoldier, BOOLEAN fReverse, FLOAT dMovementDist ); UINT8 GetDirectionFromXY( INT16 sXPos, INT16 sYPos, SOLDIERTYPE *pSoldier ); +BOOLEAN GetDirectionChangeAmount( INT16 sGridNo, SOLDIERTYPE *pSoldier, UINT8 uiTurnAmount); UINT8 GetDirectionFromGridNo( INT16 sGridNo, SOLDIERTYPE *pSoldier ); UINT8 atan8( INT16 sXPos, INT16 sYPos, INT16 sXPos2, INT16 sYPos2 ); UINT8 atan8FromAngle( DOUBLE dAngle ); @@ -2025,3 +2026,6 @@ public: #endif + + + diff --git a/Tactical/Soldier Create.cpp b/Tactical/Soldier Create.cpp index 1f94059d..13a0b65a 100644 --- a/Tactical/Soldier Create.cpp +++ b/Tactical/Soldier Create.cpp @@ -640,7 +640,6 @@ SOLDIERTYPE* TacticalCreateSoldier( SOLDIERCREATE_STRUCT *pCreateStruct, UINT8 * Soldier.iFaceIndex = InitSoldierFace( &Soldier ); } - Soldier.bActionPoints = Soldier.CalcActionPoints( ); Soldier.bInitialActionPoints = Soldier.bActionPoints; Soldier.bSide = gTacticalStatus.Team[ Soldier.bTeam ].bSide; diff --git a/Tactical/Soldier Tile.cpp b/Tactical/Soldier Tile.cpp index 7bf42b68..65005512 100644 --- a/Tactical/Soldier Tile.cpp +++ b/Tactical/Soldier Tile.cpp @@ -813,8 +813,8 @@ void SwapMercPositions( SOLDIERTYPE *pSoldier1, SOLDIERTYPE *pSoldier2 ) BOOLEAN CanExchangePlaces( SOLDIERTYPE *pSoldier1, SOLDIERTYPE *pSoldier2, BOOLEAN fShow ) { // NB checks outside of this function - if ( EnoughPoints( pSoldier1, AP_EXCHANGE_PLACES, 0, fShow ) ){ - if ( EnoughPoints( pSoldier2, AP_EXCHANGE_PLACES, 0, fShow ) ){ + if ( EnoughPoints( pSoldier1, APBPConstants[AP_EXCHANGE_PLACES], 0, fShow ) ){ + if ( EnoughPoints( pSoldier2, APBPConstants[AP_EXCHANGE_PLACES], 0, fShow ) ){ if ( ( gAnimControl[ pSoldier2->usAnimState ].uiFlags & ANIM_MOVING ) ) return( FALSE ); diff --git a/Tactical/TeamTurns.cpp b/Tactical/TeamTurns.cpp index 26c02dae..e84174bf 100644 --- a/Tactical/TeamTurns.cpp +++ b/Tactical/TeamTurns.cpp @@ -960,7 +960,7 @@ void EndInterrupt( BOOLEAN fMarkInterruptOccurred ) SOLDIERTYPE * pTempSoldier; INT32 cnt; BOOLEAN fFound; - UINT8 ubMinAPsToAttack; + INT16 ubMinAPsToAttack; DebugMsg (TOPIC_JA2,DBG_LEVEL_3,"EndInterrupt"); @@ -1304,7 +1304,7 @@ BOOLEAN StandardInterruptConditionsMet( SOLDIERTYPE * pSoldier, UINT8 ubOpponent { DebugMsg (TOPIC_JA2,DBG_LEVEL_3,"StandardInterruptConditionsMet"); // UINT8 ubAniType; - UINT8 ubMinPtsNeeded; + INT16 ubMinPtsNeeded; INT8 bDir; SOLDIERTYPE * pOpponent; @@ -1459,7 +1459,7 @@ BOOLEAN StandardInterruptConditionsMet( SOLDIERTYPE * pSoldier, UINT8 ubOpponent // the bare minimum default is enough APs left to TURN - ubMinPtsNeeded = AP_CHANGE_FACING; + ubMinPtsNeeded = APBPConstants[AP_CHANGE_FACING]; // if the opponent is SOMEBODY if (ubOpponentID < TOTAL_SOLDIERS) @@ -1538,7 +1538,7 @@ BOOLEAN StandardInterruptConditionsMet( SOLDIERTYPE * pSoldier, UINT8 ubOpponent // if the soldier isn't currently crouching if (!PTR_CROUCHED) { - ubMinPtsNeeded = AP_CROUCH; + ubMinPtsNeeded = APBPConstants[AP_CROUCH]; } else { diff --git a/Tactical/Turn Based Input.cpp b/Tactical/Turn Based Input.cpp index 81fce4bc..44a2f749 100644 --- a/Tactical/Turn Based Input.cpp +++ b/Tactical/Turn Based Input.cpp @@ -2341,8 +2341,8 @@ void GetKeyboardInput( UINT32 *puiNewEvent ) // All's good! SwapMercPositions( pSoldier1, pSoldier2 ); - DeductPoints( pSoldier1, AP_EXCHANGE_PLACES, 0 ); - DeductPoints( pSoldier2, AP_EXCHANGE_PLACES, 0 ); + DeductPoints( pSoldier1, APBPConstants[AP_EXCHANGE_PLACES], 0 ); + DeductPoints( pSoldier2, APBPConstants[AP_EXCHANGE_PLACES], 0 ); } } } @@ -5197,7 +5197,7 @@ INT8 HandleMoveModeInteractiveClick( INT16 sMapPos, UINT32 *puiNewEvent ) BOOLEAN HandleUIReloading( SOLDIERTYPE *pSoldier ) { - INT8 bAPs = 0; + INT16 bAPs = 0; // CHECK OUR CURRENT CURSOR... diff --git a/Tactical/Vehicles.cpp b/Tactical/Vehicles.cpp index d13fd03e..41854677 100644 --- a/Tactical/Vehicles.cpp +++ b/Tactical/Vehicles.cpp @@ -1842,9 +1842,9 @@ void SetUpArmorForVehicle( UINT8 ubID ) return; } -void AdjustVehicleAPs( SOLDIERTYPE *pSoldier, UINT8 *pubPoints ) +void AdjustVehicleAPs( SOLDIERTYPE *pSoldier, INT16 *pubPoints ) { - UINT8 pubDeducations = 0; + INT16 pubDeducations = 0; INT32 iCounter = 0; (*pubPoints) += 35; @@ -2533,3 +2533,4 @@ BOOLEAN DoesVehicleGroupHaveAnyPassengers( GROUP *pGroup ) + diff --git a/Tactical/Vehicles.h b/Tactical/Vehicles.h index ad35df98..1932fd14 100644 --- a/Tactical/Vehicles.h +++ b/Tactical/Vehicles.h @@ -173,7 +173,7 @@ void VehicleTakeDamage( UINT8 ubID, UINT8 ubReason, INT16 sDamage, INT16 sGridNo // the soldiertype containing this tactical incarnation of this vehicle SOLDIERTYPE * GetSoldierStructureForVehicle( INT32 iId ); -void AdjustVehicleAPs( SOLDIERTYPE *pSoldier, UINT8 *pubPoints ); +void AdjustVehicleAPs( SOLDIERTYPE *pSoldier, INT16 *pubPoints ); // get orig armor values for vehicle in this location //INT16 GetOrigInternalArmorValueForVehicleInLocation( UINT8 ubID, UINT8 ubLocation ); @@ -234,4 +234,4 @@ BOOLEAN DoesVehicleGroupHaveAnyPassengers( GROUP *pGroup ); void SetSoldierExitVehicleInsertionData( SOLDIERTYPE *pSoldier, INT32 iId ); -#endif \ No newline at end of file +#endif diff --git a/Tactical/Weapons.cpp b/Tactical/Weapons.cpp index 291dc0cd..5a9bd99f 100644 --- a/Tactical/Weapons.cpp +++ b/Tactical/Weapons.cpp @@ -118,13 +118,13 @@ BOOLEAN gfReportHitChances = FALSE; #define ASRIFLE( ammo, update, impact, rt, rof, burstrof, burstpenal, deadl, acc, clip, range, av, hv, sd, bsd ) { RIFLECLASS, GUN_AS_RIFLE, ammo, rt, rof, burstrof, burstpenal, update, (UINT8) (impact), deadl, acc, clip, range, 200, av, hv, sd, bsd, S_RELOAD_RIFLE, S_LNL_RIFLE } #define SHOTGUN( ammo, update, impact, rt, rof, burstrof, burstpenal, deadl, acc, clip, range, av, hv, sd, bsd ) { SHOTGUNCLASS, GUN_SHOTGUN, ammo, rt, rof, burstrof, burstpenal, update, (UINT8) (impact), deadl, acc, clip, range, 200, av, hv, sd, bsd, S_RELOAD_SHOTGUN, S_LNL_SHOTGUN } #define LMG( ammo, update, impact, rt, rof, burstrof, burstpenal, deadl, acc, clip, range, av, hv, sd, bsd ) { MGCLASS, GUN_LMG, ammo, rt, rof, burstrof, burstpenal, update, (UINT8) (impact), deadl, acc, clip, range, 200, av, hv, sd, bsd, S_RELOAD_LMG, S_LNL_LMG } -#define BLADE( impact, rof, deadl, range, av, sd ) { KNIFECLASS, NOT_GUN, 0, AP_READY_KNIFE, rof, 0, 0, 0, (UINT8) (impact), deadl, 0, 0, range, 200, av, 0, sd, NO_WEAPON_SOUND, NO_WEAPON_SOUND, NO_WEAPON_SOUND } -#define THROWINGBLADE( impact, rof, deadl, range, av, sd ) { KNIFECLASS, NOT_GUN, 0, AP_READY_KNIFE, rof, 0, 0, 0, (UINT8) (impact), deadl, 0, 0, range, 200, av, 0, sd, NO_WEAPON_SOUND, NO_WEAPON_SOUND, NO_WEAPON_SOUND } +#define BLADE( impact, rof, deadl, range, av, sd ) { KNIFECLASS, NOT_GUN, 0, APBPConstants[AP_READY_KNIFE], rof, 0, 0, 0, (UINT8) (impact), deadl, 0, 0, range, 200, av, 0, sd, NO_WEAPON_SOUND, NO_WEAPON_SOUND, NO_WEAPON_SOUND } +#define THROWINGBLADE( impact, rof, deadl, range, av, sd ) { KNIFECLASS, NOT_GUN, 0, APBPConstants[AP_READY_KNIFE], rof, 0, 0, 0, (UINT8) (impact), deadl, 0, 0, range, 200, av, 0, sd, NO_WEAPON_SOUND, NO_WEAPON_SOUND, NO_WEAPON_SOUND } #define PUNCHWEAPON( impact, rof, deadl, av, sd ) { KNIFECLASS, NOT_GUN, 0, 0, rof, 0, 0, 0, (UINT8) (impact), deadl, 0, 0, 10, 200, av, 0, sd, NO_WEAPON_SOUND, NO_WEAPON_SOUND, NO_WEAPON_SOUND } #define LAUNCHER( update, rt, rof, deadl, acc, range, av, hv, sd) { RIFLECLASS, NOT_GUN, NOAMMO, rt, rof, 0, 0, update, 1, deadl, acc, 0, range, 200, av, hv, sd, NO_WEAPON_SOUND, NO_WEAPON_SOUND, NO_WEAPON_SOUND } #define LAW( update, rt, rof, deadl, acc, range, av, hv, sd) { RIFLECLASS, NOT_GUN, NOAMMO, rt, rof, 0, 0, update, 80, deadl, acc, 1, range, 200, av, hv, sd, NO_WEAPON_SOUND, NO_WEAPON_SOUND, NO_WEAPON_SOUND } #define CANNON( update, rt, rof, deadl, acc, range, av, hv, sd) { RIFLECLASS, NOT_GUN, NOAMMO, rt, rof, 0, 0, update, 80, deadl, acc, 1, range, 200, av, hv, sd, NO_WEAPON_SOUND, NO_WEAPON_SOUND, NO_WEAPON_SOUND } -#define MONSTSPIT( impact, rof, deadl, clip, range, av, hv, sd) { MONSTERCLASS, NOT_GUN, AMMOMONST, AP_READY_KNIFE, rof, 0, 0, 250, (UINT8) (impact), deadl, 0, clip, range, 200, av, hv, sd, NO_WEAPON_SOUND, NO_WEAPON_SOUND, NO_WEAPON_SOUND } +#define MONSTSPIT( impact, rof, deadl, clip, range, av, hv, sd) { MONSTERCLASS, NOT_GUN, AMMOMONST, APBPConstants[AP_READY_KNIFE], rof, 0, 0, 250, (UINT8) (impact), deadl, 0, clip, range, 200, av, hv, sd, NO_WEAPON_SOUND, NO_WEAPON_SOUND, NO_WEAPON_SOUND } // ranges are in world units, calculated by: // 100 + real-range-in-metres/10 @@ -347,7 +347,6 @@ struct } typedef weaponParseData; - static void XMLCALL weaponStartElementHandle(void *userData, const XML_Char *name, const XML_Char **atts) { @@ -489,11 +488,12 @@ weaponEndElementHandle(void *userData, const XML_Char *name) { pData->curElement = WEAPON_ELEMENT_WEAPON; pData->curWeapon.ubReadyTime = (UINT8) atol(pData->szCharData); + pData->curWeapon.ubReadyTime = (UINT8)DynamicAdjustAPConstants(pData->curWeapon.ubReadyTime, pData->curWeapon.ubReadyTime); } else if(strcmp(name, "ubShotsPer4Turns") == 0) { pData->curElement = WEAPON_ELEMENT_WEAPON; - pData->curWeapon.ubShotsPer4Turns = (UINT8) atol(pData->szCharData); + pData->curWeapon.ubShotsPer4Turns = (FLOAT) atof(pData->szCharData); } else if(strcmp(name, "ubShotsPerBurst") == 0) { @@ -579,6 +579,7 @@ weaponEndElementHandle(void *userData, const XML_Char *name) { pData->curElement = WEAPON_ELEMENT_WEAPON; pData->curWeapon.bBurstAP = (UINT8) atol(pData->szCharData); + pData->curWeapon.bBurstAP = (UINT8)DynamicAdjustAPConstants(pData->curWeapon.bBurstAP, pData->curWeapon.bBurstAP); } else if(strcmp(name, "bAutofireShotsPerFiveAP") == 0) { @@ -589,6 +590,7 @@ weaponEndElementHandle(void *userData, const XML_Char *name) { pData->curElement = WEAPON_ELEMENT_WEAPON; pData->curWeapon.APsToReload = (UINT8) atol(pData->szCharData); + pData->curWeapon.APsToReload = (UINT8)DynamicAdjustAPConstants(pData->curWeapon.APsToReload, pData->curWeapon.APsToReload); } else if(strcmp(name, "SilencedSound") == 0) { @@ -626,6 +628,7 @@ weaponEndElementHandle(void *userData, const XML_Char *name) { pData->curElement = WEAPON_ELEMENT_WEAPON; pData->curWeapon.APsToReloadManually = (UINT8) atol(pData->szCharData); + pData->curWeapon.APsToReloadManually = (UINT8)DynamicAdjustAPConstants(pData->curWeapon.APsToReloadManually, pData->curWeapon.APsToReloadManually); } else if(strcmp(name, "ManualReloadSound") == 0) { @@ -1230,25 +1233,31 @@ BOOLEAN CheckForGunJam( SOLDIERTYPE * pSoldier ) else if ((*pObj)[0]->data.gun.bGunAmmoStatus < 0) { // try to unjam gun - int iResult = SkillCheck( pSoldier, UNJAM_GUN_CHECK, (INT8) ((Item[pObj->usItem].bReliability + Item[(*pObj)[0]->data.gun.usGunAmmoItem].bReliability)* 4) ); - if (iResult > 0) - { - // yay! unjammed the gun - (*pObj)[0]->data.gun.bGunAmmoStatus *= -1; - - // MECHANICAL/DEXTERITY GAIN: Unjammed a gun - StatChange( pSoldier, MECHANAMT, 5, FALSE ); - StatChange( pSoldier, DEXTAMT, 5, FALSE ); - - DirtyMercPanelInterface( pSoldier, DIRTYLEVEL2 ); - - // We unjammed gun, return appropriate value! - return( 255 ); - } - else - { - return( TRUE ); - } + if(EnoughPoints(pSoldier, APBPConstants[AP_UNJAM], APBPConstants[BP_UNJAM], FALSE)) + { + DeductPoints(pSoldier, APBPConstants[AP_UNJAM], APBPConstants[BP_UNJAM]); + int iResult = SkillCheck( pSoldier, UNJAM_GUN_CHECK, (INT8) ((Item[pObj->usItem].bReliability + Item[(*pObj)[0]->data.gun.usGunAmmoItem].bReliability)* 4) ); + if (iResult > 0) + { + // yay! unjammed the gun + (*pObj)[0]->data.gun.bGunAmmoStatus *= -1; + + // MECHANICAL/DEXTERITY GAIN: Unjammed a gun + StatChange( pSoldier, MECHANAMT, 5, FALSE ); + StatChange( pSoldier, DEXTAMT, 5, FALSE ); + + DirtyMercPanelInterface( pSoldier, DIRTYLEVEL2 ); + + // We unjammed gun, return appropriate value! + return( 255 ); + } + else + { + return( TRUE ); + } + } + else + return( TRUE ); } } } @@ -2667,7 +2676,7 @@ BOOLEAN UseThrown( SOLDIERTYPE *pSoldier, INT16 sTargetGridNo ) // costs are deducted. Final throw cost is deducted on creating the grenade object if ( (UINT8)GetDirectionFromGridNo( sTargetGridNo, pSoldier ) != pSoldier->ubDirection ) sAPCost += (INT16)GetAPsToLook( pSoldier ); - sAPCost += (INT16)GetAPsToChangeStance( pSoldier, ANIM_STAND ); + sAPCost += GetAPsToChangeStance( pSoldier, ANIM_STAND ); HandleSoldierThrowItem( pSoldier, pSoldier->sTargetGridNo ); DeductPoints( pSoldier, sAPCost, 0 ); @@ -3518,7 +3527,7 @@ BOOLEAN InRange( SOLDIERTYPE *pSoldier, INT16 sGridNo ) return( FALSE ); } -UINT32 CalcChanceToHitGun(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAimTime, UINT8 ubAimPos ) +UINT32 CalcChanceToHitGun(SOLDIERTYPE *pSoldier, INT16 sGridNo, INT16 ubAimTime, UINT8 ubAimPos ) { //SOLDIERTYPE *vicpSoldier; SOLDIERTYPE * pTarget; @@ -4249,7 +4258,7 @@ UINT32 CalcChanceToHitGun(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAimTime, return (iChance); } -UINT32 AICalcChanceToHitGun(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAimTime, UINT8 ubAimPos ) +UINT32 AICalcChanceToHitGun(SOLDIERTYPE *pSoldier, INT16 sGridNo, INT16 ubAimTime, UINT8 ubAimPos ) { UINT16 usTrueState; UINT32 uiChance; @@ -4981,7 +4990,7 @@ void ShotMiss( UINT8 ubAttackerID, INT32 iBullet ) // FreeUpAttacker( ubAttackerID ); } -UINT32 CalcChanceHTH( SOLDIERTYPE * pAttacker,SOLDIERTYPE *pDefender, UINT8 ubAimTime, UINT8 ubMode ) +UINT32 CalcChanceHTH( SOLDIERTYPE * pAttacker,SOLDIERTYPE *pDefender, INT16 ubAimTime, UINT8 ubMode ) { UINT16 usInHand; UINT8 ubBandaged; @@ -5311,17 +5320,17 @@ UINT32 CalcChanceHTH( SOLDIERTYPE * pAttacker,SOLDIERTYPE *pDefender, UINT8 ubAi return (iChance); } -UINT32 CalcChanceToStab(SOLDIERTYPE * pAttacker,SOLDIERTYPE *pDefender, UINT8 ubAimTime) +UINT32 CalcChanceToStab(SOLDIERTYPE * pAttacker,SOLDIERTYPE *pDefender, INT16 ubAimTime) { return( CalcChanceHTH( pAttacker, pDefender, ubAimTime, HTH_MODE_STAB ) ); } -UINT32 CalcChanceToPunch(SOLDIERTYPE *pAttacker, SOLDIERTYPE * pDefender, UINT8 ubAimTime) +UINT32 CalcChanceToPunch(SOLDIERTYPE *pAttacker, SOLDIERTYPE * pDefender, INT16 ubAimTime) { return( CalcChanceHTH( pAttacker, pDefender, ubAimTime, HTH_MODE_PUNCH ) ); } -UINT32 CalcChanceToSteal(SOLDIERTYPE *pAttacker, SOLDIERTYPE * pDefender, UINT8 ubAimTime) +UINT32 CalcChanceToSteal(SOLDIERTYPE *pAttacker, SOLDIERTYPE * pDefender, INT16 ubAimTime) { return( CalcChanceHTH( pAttacker, pDefender, ubAimTime, HTH_MODE_STEAL ) ); } @@ -5572,7 +5581,7 @@ INT32 CalcMaxTossRange( SOLDIERTYPE * pSoldier, UINT16 usItem, BOOLEAN fArmed ) } -UINT32 CalcThrownChanceToHit(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAimTime, UINT8 ubAimPos ) +UINT32 CalcThrownChanceToHit(SOLDIERTYPE *pSoldier, INT16 sGridNo, INT16 ubAimTime, UINT8 ubAimPos ) { INT32 iChance, iMaxRange, iRange; UINT16 usHandItem; @@ -5995,3 +6004,6 @@ INT8 GetAPsToReload( OBJECTTYPE *pObj ) + + + diff --git a/Tactical/Weapons.h b/Tactical/Weapons.h index c42018ed..3c04847a 100644 --- a/Tactical/Weapons.h +++ b/Tactical/Weapons.h @@ -256,7 +256,9 @@ typedef struct UINT8 ubWeaponType; // exact type (for display purposes) UINT8 ubCalibre; // type of ammunition needed UINT8 ubReadyTime; // APs to ready/unready weapon - UINT8 ubShotsPer4Turns; // maximum (mechanical) firing rate + //CHRISL: Changed to a float to allow for more control over actual ap costs + //UINT8 ubShotsPer4Turns; // maximum (mechanical) firing rate + FLOAT ubShotsPer4Turns; // maximum (mechanical) firing rate UINT8 ubShotsPerBurst; UINT8 ubBurstPenalty; // % penalty per shot after first UINT8 ubBulletSpeed; // bullet's travelling speed @@ -343,11 +345,11 @@ extern void WindowHit( INT16 sGridNo, UINT16 usStructureID, BOOLEAN fBlowWindowS extern INT32 BulletImpact( SOLDIERTYPE *pFirer, SOLDIERTYPE * pTarget, UINT8 ubHitLocation, INT32 iImpact, INT16 sHitBy, UINT8 * pubSpecial ); extern BOOLEAN InRange( SOLDIERTYPE *pSoldier, INT16 sGridNo ); extern void ShotMiss( UINT8 ubAttackerID, INT32 iBullet ); -extern UINT32 CalcChanceToHitGun(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAimTime, UINT8 ubAimPos ); -extern UINT32 AICalcChanceToHitGun(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAimTime, UINT8 ubAimPos ); -extern UINT32 CalcChanceToPunch(SOLDIERTYPE *pAttacker, SOLDIERTYPE * pDefender, UINT8 ubAimTime); -extern UINT32 CalcChanceToStab(SOLDIERTYPE * pAttacker,SOLDIERTYPE *pDefender, UINT8 ubAimTime); -UINT32 CalcChanceToSteal(SOLDIERTYPE *pAttacker, SOLDIERTYPE * pDefender, UINT8 ubAimTime); +extern UINT32 CalcChanceToHitGun(SOLDIERTYPE *pSoldier, INT16 sGridNo, INT16 ubAimTime, UINT8 ubAimPos ); +extern UINT32 AICalcChanceToHitGun(SOLDIERTYPE *pSoldier, INT16 sGridNo, INT16 ubAimTime, UINT8 ubAimPos ); +extern UINT32 CalcChanceToPunch(SOLDIERTYPE *pAttacker, SOLDIERTYPE * pDefender, INT16 ubAimTime); +extern UINT32 CalcChanceToStab(SOLDIERTYPE * pAttacker,SOLDIERTYPE *pDefender, INT16 ubAimTime); +UINT32 CalcChanceToSteal(SOLDIERTYPE *pAttacker, SOLDIERTYPE * pDefender, INT16 ubAimTime); extern void ReloadWeapon( SOLDIERTYPE *pSoldier, UINT8 ubHandPos ); // Changed by ADB, rev 1513 //extern BOOLEAN IsGunWeaponModeCapable( SOLDIERTYPE *pSoldier, UINT8 ubHandPos , UINT8 bWpnMode ); @@ -366,7 +368,7 @@ extern BOOLEAN OKFireWeapon( SOLDIERTYPE *pSoldier ); extern BOOLEAN CheckForGunJam( SOLDIERTYPE * pSoldier ); extern INT32 CalcMaxTossRange( SOLDIERTYPE * pSoldier, UINT16 usItem, BOOLEAN fArmed ); -extern UINT32 CalcThrownChanceToHit(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubAimTime, UINT8 ubAimPos ); +extern UINT32 CalcThrownChanceToHit(SOLDIERTYPE *pSoldier, INT16 sGridNo, INT16 ubAimTime, UINT8 ubAimPos ); extern void ChangeWeaponMode( SOLDIERTYPE * pSoldier ); @@ -390,4 +392,4 @@ INT8 GetAPsToReload( OBJECTTYPE *pObj ); -#endif \ No newline at end of file +#endif diff --git a/Tactical/XML.h b/Tactical/XML.h index 839fadf2..9bbf0e76 100644 --- a/Tactical/XML.h +++ b/Tactical/XML.h @@ -87,7 +87,8 @@ typedef PARSE_STAGE; #define ALTSECTORSFILENAME "Map\\AltSectors.xml" #define SAMSITESFILENAME "Map\\SamSites.xml" #define ROAMINGMILITIAFILENAME "Map\\RestrictedRoamingMilitia.xml" - +// Gotthard: Strategic Text Files [2007-10-19] +#define STRATEGICSECTORNAMETEXTFILENAME "Map\\SectorNames.xml" #define GARRISONFILENAME "Army\\GarrisonGroups.xml" #define PATROLFILENAME "Army\\PatrolGroups.xml" @@ -103,6 +104,14 @@ typedef PARSE_STAGE; // WANNE: Sector loadscreens [2007-05-18] #define SECTORLOADSCREENSFILENAME "Map\\SectorLoadscreens.xml" +// Gotthard: Laptop Text files [2007-10-16] +#define LAPTOPFLORISTTEXTFILENAME "Laptop\\Florist.xml" +#define LAPTOPFUNERALTEXTFILENAME "Laptop\\Funeral.xml" +#define LAPTOPBOBBYRAYSTEXTFILENAME "Laptop\\BobbyRays.xml" + +// Gotthard: Website Picture/Text Locations [2007-11-04] +#define LAPTOPFLORISTLOCATIONFILENAME "Laptop\\FloristPositions.xml" +#define LAPTOPFUNERALLOCATIONFILENAME "Laptop\\FuneralPositions.xml" extern BOOLEAN ReadInItemStats(STR fileName, BOOLEAN localizedVersion); extern BOOLEAN WriteItemStats(); @@ -213,4 +222,22 @@ extern BOOLEAN WriteInArmyCompositionInfo(STR fileName); //Kaiden: Roaming Militia Restricted Sectors List extern BOOLEAN ReadInRoamingInfo(STR filename); + +//Gotthard: Laptop Florist Text +extern BOOLEAN ReadInFloristText(STR fileName); + +//Gotthard: Laptop Funeral Text +extern BOOLEAN ReadInFuneralText(STR fileName); + +//Gotthard: Delivery Locations Text (For Florist, Bobby Ray's) +extern BOOLEAN ReadInBobbyRaysText(STR fileName); + +//Gotthard: Special Sector Names Test (Cambria Hospital, etc.) +extern BOOLEAN ReadInSectorNamesText(STR fileName); + +//Gotthard: Laptop Florist Locations +extern BOOLEAN ReadInFloristLocations(STR fileName); + +//Gotthard: Laptop Funeral Locations +extern BOOLEAN ReadInFuneralLocations(STR fileName); #endif diff --git a/Tactical/XML_Attachments.cpp b/Tactical/XML_Attachments.cpp index 892e1606..2de3fa94 100644 --- a/Tactical/XML_Attachments.cpp +++ b/Tactical/XML_Attachments.cpp @@ -6,6 +6,7 @@ #include "weapons.h" #include "Debug Control.h" #include "expat.h" + #include "gamesettings.h" #include "XML.h" #endif @@ -114,6 +115,7 @@ attachmentEndElementHandle(void *userData, const XML_Char *name) { pData->curElement = ELEMENT; pData->curAttachment[2] = (UINT16) atol(pData->szCharData); + pData->curAttachment[2] = (UINT16)DynamicAdjustAPConstants(pData->curAttachment[2], pData->curAttachment[2]); } pData->maxReadDepth--; diff --git a/Tactical/XML_Merge.cpp b/Tactical/XML_Merge.cpp index c345c84a..192dc54e 100644 --- a/Tactical/XML_Merge.cpp +++ b/Tactical/XML_Merge.cpp @@ -6,6 +6,7 @@ #include "weapons.h" #include "Debug Control.h" #include "expat.h" + #include "gamesettings.h" #include "XML.h" #endif @@ -135,6 +136,7 @@ mergeEndElementHandle(void *userData, const XML_Char *name) { pData->curElement = ELEMENT; pData->curMerge[5] = (UINT16) atol(pData->szCharData); + pData->curMerge[5] = (UINT16)DynamicAdjustAPConstants(pData->curMerge[5], pData->curMerge[5]); } pData->maxReadDepth--; diff --git a/Tactical/faces.h b/Tactical/faces.h index d62e0375..184cdcfe 100644 --- a/Tactical/faces.h +++ b/Tactical/faces.h @@ -125,7 +125,7 @@ typedef struct UINT8 ubExpression; INT8 bOldSoldierLife; - INT8 bOldActionPoints; + INT16 bOldActionPoints; BOOLEAN fOldHandleUIHatch; BOOLEAN fOldShowHighlight; INT8 bOldAssignment; @@ -246,4 +246,4 @@ BOOLEAN ExternRenderFaceFromSoldier( UINT32 uiBuffer, UINT8 ubSoldierID, INT16 s -#endif \ No newline at end of file +#endif diff --git a/TacticalAI/AIInternals.h b/TacticalAI/AIInternals.h index be5d4f32..f097f8f1 100644 --- a/TacticalAI/AIInternals.h +++ b/TacticalAI/AIInternals.h @@ -17,6 +17,7 @@ extern BOOLEAN gfTurnBasedAI; #define ACTING_ON_SCHEDULE( p ) ( (p)->aiData.fAIFlags & AI_CHECK_SCHEDULE ) // the AI should try to have this many APs before climbing a roof, if possible +//THIS IS NOT EXTERNALIZED!!! CHECK THIS! GOTTHARD 7/2/08 #define AI_AP_CLIMBROOF 15 #define TEMPORARILY 0 @@ -121,12 +122,14 @@ typedef struct { UINT8 ubPossible; // is this attack form possible? T/F UINT8 ubOpponent; // which soldier is the victim? - UINT8 ubAimTime; // how many extra APs to spend on aiming - UINT8 ubChanceToReallyHit; // chance to hit * chance to get through cover + //CHANGED STRUCTURE VALUE BY GOTTHARD 7/14/07 + INT16 ubAimTime; // how many extra APs to spend on aiming + INT16 ubChanceToReallyHit; // chance to hit * chance to get through cover + //END STRUCTURE CHANGE BY GOTTHARD 7/14/07 INT32 iAttackValue; // relative worthiness of this type of attack INT16 sTarget; // target gridno of this attack INT8 bTargetLevel; // target level of this attack - UINT8 ubAPCost; // how many APs the attack will use up + INT16 ubAPCost; // how many APs the attack will use up INT8 bWeaponIn; // the inv slot of the weapon in question } ATTACKTYPE; @@ -173,8 +176,8 @@ void DecideAlertStatus( SOLDIERTYPE *pSoldier ); INT8 DecideAutoBandage( SOLDIERTYPE * pSoldier ); UINT16 DetermineMovementMode( SOLDIERTYPE * pSoldier, INT8 bAction ); -INT32 EstimateShotDamage(SOLDIERTYPE *pSoldier, SOLDIERTYPE *pOpponent, UINT8 ubChanceToHit); -INT32 EstimateStabDamage(SOLDIERTYPE *pSoldier, SOLDIERTYPE *pOpponent, UINT8 ubChanceToHit, BOOLEAN fBladeAttack); +INT32 EstimateShotDamage(SOLDIERTYPE *pSoldier, SOLDIERTYPE *pOpponent, INT16 ubChanceToHit); +INT32 EstimateStabDamage(SOLDIERTYPE *pSoldier, SOLDIERTYPE *pOpponent, INT16 ubChanceToHit, BOOLEAN fBladeAttack); INT32 EstimateThrowDamage(SOLDIERTYPE *pSoldier, UINT8 ubItemPos, SOLDIERTYPE *pOpponent, INT16 sGridno); INT16 EstimatePathCostToLocation( SOLDIERTYPE * pSoldier, INT16 sDestGridNo, INT8 bDestLevel, BOOLEAN fAddCostAfterClimbingUp, BOOLEAN * pfClimbingNecessary, INT16 * psClimbGridNo ); @@ -194,7 +197,7 @@ BOOLEAN InWaterGasOrSmoke( SOLDIERTYPE *pSoldier, INT16 sGridNo ); void InitAttackType(ATTACKTYPE *pAttack); -INT16 InternalGoAsFarAsPossibleTowards(SOLDIERTYPE *pSoldier, INT16 sDesGrid, INT8 bReserveAPs, INT8 bAction, INT8 fFlags ); +INT16 InternalGoAsFarAsPossibleTowards(SOLDIERTYPE *pSoldier, INT16 sDesGrid, INT16 bReserveAPs, INT8 bAction, INT8 fFlags ); int LegalNPCDestination(SOLDIERTYPE *pSoldier, INT16 sGridno, UINT8 ubPathMode, UINT8 ubWaterOK, UINT8 fFlags); void LoadWeaponIfNeeded(SOLDIERTYPE *pSoldier); @@ -214,7 +217,7 @@ void RTHandleAI( SOLDIERTYPE * pSoldier ); UINT16 RunAway( SOLDIERTYPE * pSoldier ); INT8 SearchForItems( SOLDIERTYPE * pSoldier, INT8 bReason, UINT16 usItem ); UINT8 ShootingStanceChange( SOLDIERTYPE * pSoldier, ATTACKTYPE * pAttack, INT8 bDesiredDirection ); -UINT8 StanceChange( SOLDIERTYPE * pSoldier, UINT8 ubAttackAPCost ); +UINT8 StanceChange( SOLDIERTYPE * pSoldier, INT16 ubAttackAPCost ); INT16 TrackScent( SOLDIERTYPE * pSoldier ); void RefreshAI(SOLDIERTYPE *pSoldier); BOOLEAN InLightAtNight( INT16 sGridNo, INT8 bLevel ); @@ -228,3 +231,4 @@ INT16 FindBestCoverNearTheGridNo(SOLDIERTYPE *pSoldier, INT16 sGridNo, UINT8 ubS INT8 FindDirectionForClimbing( SOLDIERTYPE *pSoldier, INT16 sGridNo, INT8 bLevel); + diff --git a/TacticalAI/AIMain.cpp b/TacticalAI/AIMain.cpp index 08997ff3..7c377a45 100644 --- a/TacticalAI/AIMain.cpp +++ b/TacticalAI/AIMain.cpp @@ -54,6 +54,7 @@ #include "Campaign Types.h" #include "Queen Command.h" #include "cheats.h" +#include "points.h" #endif #include "connect.h" @@ -1643,7 +1644,7 @@ void TurnBasedHandleNPCAI(SOLDIERTYPE *pSoldier) { // if he lacks the breath, or APs to get up this turn (life checked above) // OR... (new June 13/96 Ian) he's getting first aid... - if ((pSoldier->bBreath < OKBREATH) || (pSoldier->bActionPoints < (AP_GET_UP + AP_ROLL_OVER)) + if ((pSoldier->bBreath < OKBREATH) || (pSoldier->bActionPoints < (APBPConstants[AP_GET_UP] + APBPConstants[AP_ROLL_OVER])) || pSoldier->service) { #ifdef RECORDNET @@ -2458,7 +2459,7 @@ INT8 ExecuteAction(SOLDIERTYPE *pSoldier) pSoldier->EVENT_InitNewSoldierAnim( AI_PULL_SWITCH, 0 , FALSE ); - DeductPoints( pSoldier, AP_PULL_TRIGGER, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_PULL_TRIGGER], 0 ); //gTacticalStatus.fPanicFlags = 0; // turn all flags off gTacticalStatus.ubTheChosenOne = NOBODY; @@ -2470,7 +2471,7 @@ INT8 ExecuteAction(SOLDIERTYPE *pSoldier) //gTacticalStatus.sPanicTriggerGridno = NOWHERE; // grab detonator and set off bomb(s) - DeductPoints( pSoldier, AP_USE_REMOTE, BP_USE_DETONATOR);// pay for it! + DeductPoints( pSoldier, APBPConstants[AP_USE_REMOTE], APBPConstants[BP_USE_DETONATOR]);// pay for it! //SetOffPanicBombs(1000,COMMUNICATE); // BOOOOOOOOOOOOOOOOOOOOM!!!!! SetOffPanicBombs( pSoldier->ubID, 0 ); @@ -2498,7 +2499,7 @@ INT8 ExecuteAction(SOLDIERTYPE *pSoldier) SendNetData(ALL_NODES); */ - DeductPoints(pSoldier,AP_RADIO,BP_RADIO);// pay for it! + DeductPoints(pSoldier,APBPConstants[AP_RADIO],APBPConstants[BP_RADIO]);// pay for it! RadioSightings(pSoldier,EVERYBODY,pSoldier->bTeam); // about everybody // action completed immediately, cancel it right away @@ -2508,7 +2509,7 @@ INT8 ExecuteAction(SOLDIERTYPE *pSoldier) break; case AI_ACTION_CREATURE_CALL: // creature calling to others - DeductPoints(pSoldier,AP_RADIO,BP_RADIO);// pay for it! + DeductPoints(pSoldier,APBPConstants[AP_RADIO],APBPConstants[BP_RADIO]);// pay for it! CreatureCall( pSoldier ); //return( FALSE ); // no longer in progress break; diff --git a/TacticalAI/AIUtils.cpp b/TacticalAI/AIUtils.cpp index c0bd6b21..e372cc49 100644 --- a/TacticalAI/AIUtils.cpp +++ b/TacticalAI/AIUtils.cpp @@ -145,15 +145,15 @@ BOOLEAN ConsiderProne( SOLDIERTYPE * pSoldier ) } } -UINT8 StanceChange( SOLDIERTYPE * pSoldier, UINT8 ubAttackAPCost ) +UINT8 StanceChange( SOLDIERTYPE * pSoldier, INT16 ubAttackAPCost ) { // consider crouching or going prone if (PTR_STANDING) { - if (pSoldier->bActionPoints - ubAttackAPCost >= AP_CROUCH) + if (pSoldier->bActionPoints - ubAttackAPCost >= APBPConstants[AP_CROUCH]) { - if ( (pSoldier->bActionPoints - ubAttackAPCost >= AP_CROUCH + AP_PRONE) && IsValidStance( pSoldier, ANIM_PRONE ) && ConsiderProne( pSoldier ) ) + if ( (pSoldier->bActionPoints - ubAttackAPCost >= APBPConstants[AP_CROUCH] + APBPConstants[AP_PRONE]) && IsValidStance( pSoldier, ANIM_PRONE ) && ConsiderProne( pSoldier ) ) { return( ANIM_PRONE ); } @@ -165,7 +165,7 @@ UINT8 StanceChange( SOLDIERTYPE * pSoldier, UINT8 ubAttackAPCost ) } else if (PTR_CROUCHED) { - if ( (pSoldier->bActionPoints - ubAttackAPCost >= AP_PRONE) && IsValidStance( pSoldier, ANIM_PRONE ) && ConsiderProne( pSoldier ) ) + if ( (pSoldier->bActionPoints - ubAttackAPCost >= APBPConstants[AP_PRONE]) && IsValidStance( pSoldier, ANIM_PRONE ) && ConsiderProne( pSoldier ) ) { return( ANIM_PRONE ); } @@ -192,7 +192,7 @@ UINT8 ShootingStanceChange( SOLDIERTYPE * pSoldier, ATTACKTYPE * pAttack, INT8 b uiCurrChanceOfDamage = 0; bAPsAfterAttack = pSoldier->bActionPoints - MinAPsToAttack( pSoldier, pAttack->sTarget, ADDTURNCOST, 1); - if (bAPsAfterAttack < AP_CROUCH) + if (bAPsAfterAttack < APBPConstants[AP_CROUCH]) { return( 0 ); } @@ -220,7 +220,7 @@ UINT8 ShootingStanceChange( SOLDIERTYPE * pSoldier, ATTACKTYPE * pAttack, INT8 b for (bLoop = 0; bLoop < 3; bLoop++) { bStanceDiff = abs( bLoop - bStanceNum ); - if (bStanceDiff == 2 && bAPsAfterAttack < AP_CROUCH + AP_PRONE) + if (bStanceDiff == 2 && bAPsAfterAttack < APBPConstants[AP_CROUCH] + APBPConstants[AP_PRONE]) { // can't consider this! continue; @@ -450,7 +450,7 @@ void NewDest(SOLDIERTYPE *pSoldier, UINT16 usGridNo) BOOLEAN IsActionAffordable(SOLDIERTYPE *pSoldier) { - INT8 bMinPointsNeeded = 0; + INT16 bMinPointsNeeded = 0; INT8 bAPForStandUp = 0; INT8 bAPToLookAtWall = ( FindDirectionForClimbing( pSoldier, pSoldier->sGridNo, pSoldier->pathing.bLevel ) == pSoldier->ubDirection ) ? 0 : 1; @@ -487,7 +487,7 @@ BOOLEAN IsActionAffordable(SOLDIERTYPE *pSoldier) break; case AI_ACTION_PICKUP_ITEM: // grab things lying on the ground - bMinPointsNeeded = __max( MinPtsToMove( pSoldier ), AP_PICKUP_ITEM ); + bMinPointsNeeded = __max( MinPtsToMove( pSoldier ), APBPConstants[AP_PICKUP_ITEM] ); break; case AI_ACTION_OPEN_OR_CLOSE_DOOR: @@ -497,7 +497,7 @@ BOOLEAN IsActionAffordable(SOLDIERTYPE *pSoldier) break; case AI_ACTION_DROP_ITEM: - bMinPointsNeeded = AP_PICKUP_ITEM; + bMinPointsNeeded = APBPConstants[AP_PICKUP_ITEM]; break; case AI_ACTION_FIRE_GUN: // shoot at nearby opponent @@ -520,21 +520,21 @@ BOOLEAN IsActionAffordable(SOLDIERTYPE *pSoldier) break; case AI_ACTION_PULL_TRIGGER: // activate an adjacent panic trigger - bMinPointsNeeded = AP_PULL_TRIGGER; + bMinPointsNeeded = APBPConstants[AP_PULL_TRIGGER]; break; case AI_ACTION_USE_DETONATOR: // grab detonator and set off bomb(s) - bMinPointsNeeded = AP_USE_REMOTE; + bMinPointsNeeded = APBPConstants[AP_USE_REMOTE]; break; case AI_ACTION_YELLOW_ALERT: // tell friends opponent(s) heard case AI_ACTION_RED_ALERT: // tell friends opponent(s) seen case AI_ACTION_CREATURE_CALL: // for now - bMinPointsNeeded = AP_RADIO; + bMinPointsNeeded = APBPConstants[AP_RADIO]; break; case AI_ACTION_CHANGE_STANCE: // crouch - bMinPointsNeeded = AP_CROUCH; + bMinPointsNeeded = APBPConstants[AP_CROUCH]; break; case AI_ACTION_GIVE_AID: // help injured/dying friend @@ -546,12 +546,12 @@ BOOLEAN IsActionAffordable(SOLDIERTYPE *pSoldier) { if( PTR_CROUCHED ) bAPForStandUp = 2; if( PTR_PRONE ) bAPForStandUp = 4; - bMinPointsNeeded = AP_CLIMBROOF + bAPForStandUp + bAPToLookAtWall; + bMinPointsNeeded = APBPConstants[AP_CLIMBROOF] + bAPForStandUp + bAPToLookAtWall; } else { if( !PTR_CROUCHED ) bAPForStandUp = 2; - bMinPointsNeeded = AP_CLIMBOFFROOF + bAPForStandUp + bAPToLookAtWall; + bMinPointsNeeded = APBPConstants[AP_CLIMBOFFROOF] + bAPForStandUp + bAPToLookAtWall; } break; @@ -1457,15 +1457,15 @@ INT16 EstimatePathCostToLocation( SOLDIERTYPE * pSoldier, INT16 sDestGridNo, INT if (fAddCostAfterClimbingUp) { // add in cost of later climbing up, too - sPathCost += AP_CLIMBOFFROOF + AP_CLIMBROOF; + sPathCost += APBPConstants[AP_CLIMBOFFROOF] + APBPConstants[AP_CLIMBROOF]; // add in an estimate of getting there after climbing down - sPathCost += (AP_MOVEMENT_FLAT + WALKCOST) * PythSpacesAway( sClimbGridNo, sDestGridNo ); + sPathCost += (APBPConstants[AP_MOVEMENT_FLAT] + WALKCOST) * PythSpacesAway( sClimbGridNo, sDestGridNo ); } else { - sPathCost += AP_CLIMBOFFROOF; + sPathCost += APBPConstants[AP_CLIMBOFFROOF]; // add in an estimate of getting there after climbing down, *but not on top of roof* - sPathCost += (AP_MOVEMENT_FLAT + WALKCOST) * PythSpacesAway( sClimbGridNo, sDestGridNo ) / 2; + sPathCost += (APBPConstants[AP_MOVEMENT_FLAT] + WALKCOST) * PythSpacesAway( sClimbGridNo, sDestGridNo ) / 2; } *pfClimbingNecessary = TRUE; *psClimbGridNo = sClimbGridNo; @@ -1500,21 +1500,21 @@ INT16 EstimatePathCostToLocation( SOLDIERTYPE * pSoldier, INT16 sDestGridNo, INT if (pSoldier->pathing.bLevel == 0) { // must climb up - sPathCost += AP_CLIMBROOF; + sPathCost += APBPConstants[AP_CLIMBROOF]; if (fAddCostAfterClimbingUp) { // add to path a rough estimate of how far to go from the climb gridno to the friend // estimate walk cost - sPathCost += (AP_MOVEMENT_FLAT + WALKCOST) * PythSpacesAway( sClimbGridNo, sDestGridNo ); + sPathCost += (APBPConstants[AP_MOVEMENT_FLAT] + WALKCOST) * PythSpacesAway( sClimbGridNo, sDestGridNo ); } } else { // must climb down - sPathCost += AP_CLIMBOFFROOF; + sPathCost += APBPConstants[AP_CLIMBOFFROOF]; // add to path a rough estimate of how far to go from the climb gridno to the friend // estimate walk cost - sPathCost += (AP_MOVEMENT_FLAT + WALKCOST) * PythSpacesAway( sClimbGridNo, sDestGridNo ); + sPathCost += (APBPConstants[AP_MOVEMENT_FLAT] + WALKCOST) * PythSpacesAway( sClimbGridNo, sDestGridNo ); } *pfClimbingNecessary = TRUE; *psClimbGridNo = sClimbGridNo; diff --git a/TacticalAI/Attacks.cpp b/TacticalAI/Attacks.cpp index 71ede088..dff31d3a 100644 --- a/TacticalAI/Attacks.cpp +++ b/TacticalAI/Attacks.cpp @@ -122,10 +122,12 @@ void CalcBestShot(SOLDIERTYPE *pSoldier, ATTACKTYPE *pBestShot, BOOLEAN shootUns INT32 iThreatValue; INT32 iHitRate,iBestHitRate,iPercentBetter; INT32 iEstDamage; - UINT8 ubRawAPCost,ubMinAPcost,ubMaxPossibleAimTime,ubAimTime,ubBestAimTime; - UINT8 ubChanceToHit,ubChanceToGetThrough,ubChanceToReallyHit,ubBestChanceToHit = 0; + UINT8 ubMaxPossibleAimTime; + INT16 ubAimTime,ubMinAPcost,ubRawAPCost; + UINT8 ubChanceToReallyHit = 0; + INT16 ubChanceToHit,ubBestAimTime,ubChanceToGetThrough,ubBestChanceToHit; SOLDIERTYPE *pOpponent; - UINT8 ubBurstAPs; + INT16 ubBurstAPs; DebugMsg (TOPIC_JA2,DBG_LEVEL_3,"CalcBestShot"); @@ -243,7 +245,7 @@ void CalcBestShot(SOLDIERTYPE *pSoldier, ATTACKTYPE *pBestShot, BOOLEAN shootUns { // raw AP cost calculation included cost of changing target! // Not unless we really needed to change targets! - //ubRawAPCost -= AP_CHANGE_TARGET; + //ubRawAPCost -= APBPConstants[AP_CHANGE_TARGET]; } iBestHitRate = 0; // reset best hit rate to minimum @@ -272,13 +274,13 @@ void CalcBestShot(SOLDIERTYPE *pSoldier, ATTACKTYPE *pBestShot, BOOLEAN shootUns // consider the various aiming times if ( !Weapon[pSoldier->usAttackingWeapon].NoSemiAuto ) { - for (ubAimTime = AP_MIN_AIM_ATTACK; ubAimTime <= ubMaxPossibleAimTime; ubAimTime++) + for (ubAimTime = APBPConstants[AP_MIN_AIM_ATTACK]; ubAimTime <= ubMaxPossibleAimTime; ubAimTime++) { //HandleMyMouseCursor(KEYBOARDALSO); //NumMessage("ubAimTime = ",ubAimTime); - ubChanceToHit = (UINT8) AICalcChanceToHitGun(pSoldier,pOpponent->sGridNo,ubAimTime, AIM_SHOT_TORSO); + ubChanceToHit = (INT16) AICalcChanceToHitGun(pSoldier,pOpponent->sGridNo,ubAimTime, AIM_SHOT_TORSO); // ExtMen[pOpponent->ubID].haveStats = TRUE; //NumMessage("chance to Hit = ",ubChanceToHit); @@ -299,8 +301,8 @@ void CalcBestShot(SOLDIERTYPE *pSoldier, ATTACKTYPE *pBestShot, BOOLEAN shootUns } else { - ubAimTime = AP_MIN_AIM_ATTACK; - ubChanceToHit = (UINT8) AICalcChanceToHitGun(pSoldier,pOpponent->sGridNo,ubAimTime, AIM_SHOT_TORSO); + ubAimTime = APBPConstants[AP_MIN_AIM_ATTACK]; + ubChanceToHit = (INT16) AICalcChanceToHitGun(pSoldier,pOpponent->sGridNo,ubAimTime, AIM_SHOT_TORSO); Assert( ubRawAPCost > 0); iHitRate = (pSoldier->bActionPoints * ubChanceToHit) / (ubRawAPCost + ubAimTime); @@ -461,7 +463,8 @@ void CalcBestThrow(SOLDIERTYPE *pSoldier, ATTACKTYPE *pBestThrow) INT8 bFriendLevel[MAXMERCS], bOpponentLevel[MAXMERCS]; INT32 iEstDamage; UINT8 ubFriendCnt = 0,ubOpponentCnt = 0, ubOpponentID[MAXMERCS]; - UINT8 ubRawAPCost,ubMinAPcost,ubMaxPossibleAimTime; + UINT8 ubMaxPossibleAimTime; + INT16 ubRawAPCost,ubMinAPcost; UINT8 ubChanceToHit,ubChanceToGetThrough,ubChanceToReallyHit; UINT32 uiPenalty; UINT8 ubSearchRange; @@ -1174,11 +1177,12 @@ void CalcBestStab(SOLDIERTYPE *pSoldier, ATTACKTYPE *pBestStab, BOOLEAN fBladeAt INT32 iAttackValue; INT32 iThreatValue,iHitRate,iBestHitRate,iPercentBetter, iEstDamage; BOOLEAN fSurpriseStab; - UINT8 ubRawAPCost,ubMinAPCost,ubMaxPossibleAimTime,ubAimTime,ubBestAimTime = 0; - UINT8 ubChanceToHit,ubChanceToReallyHit,ubBestChanceToHit = 0; + INT16 ubRawAPCost,ubMinAPCost,ubMaxPossibleAimTime = 0; + INT16 ubChanceToReallyHit = 0; + INT16 ubAimTime,ubChanceToHit,ubBestAimTime; SOLDIERTYPE *pOpponent; UINT16 usTrueMovementMode; - + INT16 ubBestChanceToHit; InitAttackType(pBestStab); // set all structure fields to defaults pSoldier->usAttackingWeapon = pSoldier->inv[HANDPOS].usItem; @@ -1248,8 +1252,8 @@ void CalcBestStab(SOLDIERTYPE *pSoldier, ATTACKTYPE *pBestStab, BOOLEAN fBladeAt //KeepInterfaceGoing(); // calc next attack's minimum stabbing cost (excludes movement & turning) - //ubRawAPCost = MinAPsToShootOrStab(pSoldier,pOpponent->sGridNo, FALSE) - AP_CHANGE_TARGET; - ubRawAPCost = MinAPsToAttack(pSoldier,pOpponent->sGridNo, FALSE) - AP_CHANGE_TARGET; + //ubRawAPCost = MinAPsToShootOrStab(pSoldier,pOpponent->sGridNo, FALSE) - APBPConstants[AP_CHANGE_TARGET]; + ubRawAPCost = MinAPsToAttack(pSoldier,pOpponent->sGridNo, FALSE) - APBPConstants[AP_CHANGE_TARGET]; //NumMessage("ubRawAPCost to stab this opponent = ",ubRawAPCost); @@ -1274,7 +1278,7 @@ void CalcBestStab(SOLDIERTYPE *pSoldier, ATTACKTYPE *pBestStab, BOOLEAN fBladeAt //NumMessage("Max Possible Aim Time = ",ubMaxPossibleAimTime); // consider the various aiming times - for (ubAimTime = AP_MIN_AIM_ATTACK; ubAimTime <= ubMaxPossibleAimTime; ubAimTime++) + for (ubAimTime = APBPConstants[AP_MIN_AIM_ATTACK]; ubAimTime <= ubMaxPossibleAimTime; ubAimTime++) { //HandleMyMouseCursor(KEYBOARDALSO); @@ -1284,11 +1288,11 @@ void CalcBestStab(SOLDIERTYPE *pSoldier, ATTACKTYPE *pBestStab, BOOLEAN fBladeAt { if (fBladeAttack) { - ubChanceToHit = (UINT8) CalcChanceToStab(pSoldier,pOpponent,ubAimTime); + ubChanceToHit = (INT16) CalcChanceToStab(pSoldier,pOpponent,ubAimTime); } else { - ubChanceToHit = (UINT8) CalcChanceToPunch(pSoldier,pOpponent,ubAimTime); + ubChanceToHit = (INT16) CalcChanceToPunch(pSoldier,pOpponent,ubAimTime); } } else @@ -1387,8 +1391,9 @@ void CalcTentacleAttack(SOLDIERTYPE *pSoldier, ATTACKTYPE *pBestStab ) INT32 iAttackValue; INT32 iThreatValue,iHitRate,iBestHitRate, iEstDamage; BOOLEAN fSurpriseStab; - UINT8 ubRawAPCost,ubMinAPCost,ubMaxPossibleAimTime,ubAimTime,ubBestAimTime = 0; - UINT8 ubChanceToHit,ubChanceToReallyHit,ubBestChanceToHit = 0; + UINT8 ubMaxPossibleAimTime = 0; + INT16 ubBestChanceToHit,ubAimTime,ubMinAPCost,ubChanceToHit,ubBestAimTime,ubRawAPCost; + INT16 ubChanceToReallyHit = 0; SOLDIERTYPE *pOpponent; @@ -1435,8 +1440,8 @@ void CalcTentacleAttack(SOLDIERTYPE *pSoldier, ATTACKTYPE *pBestStab ) // calc next attack's minimum stabbing cost (excludes movement & turning) - //ubRawAPCost = MinAPsToShootOrStab(pSoldier,pOpponent->sGridNo, FALSE) - AP_CHANGE_TARGET; - ubRawAPCost = MinAPsToAttack(pSoldier,pOpponent->sGridNo, FALSE) - AP_CHANGE_TARGET; + //ubRawAPCost = MinAPsToShootOrStab(pSoldier,pOpponent->sGridNo, FALSE) - APBPConstants[AP_CHANGE_TARGET]; + ubRawAPCost = MinAPsToAttack(pSoldier,pOpponent->sGridNo, FALSE) - APBPConstants[AP_CHANGE_TARGET]; //NumMessage("ubRawAPCost to stab this opponent = ",ubRawAPCost); // determine if this is a surprise stab (for tentacles, enemy must not see us, no dist limit) @@ -1457,7 +1462,7 @@ void CalcTentacleAttack(SOLDIERTYPE *pSoldier, ATTACKTYPE *pBestStab ) //NumMessage("Max Possible Aim Time = ",ubMaxPossibleAimTime); // consider the various aiming times - for (ubAimTime = AP_MIN_AIM_ATTACK; ubAimTime <= ubMaxPossibleAimTime; ubAimTime++) + for (ubAimTime = APBPConstants[AP_MIN_AIM_ATTACK]; ubAimTime <= ubMaxPossibleAimTime; ubAimTime++) { //HandleMyMouseCursor(KEYBOARDALSO); @@ -1465,7 +1470,7 @@ void CalcTentacleAttack(SOLDIERTYPE *pSoldier, ATTACKTYPE *pBestStab ) if (!fSurpriseStab) { - ubChanceToHit = (UINT8) CalcChanceToStab(pSoldier,pOpponent,ubAimTime); + ubChanceToHit = (INT16) CalcChanceToStab(pSoldier,pOpponent,ubAimTime); } else ubChanceToHit = MAXCHANCETOHIT; @@ -1557,7 +1562,7 @@ UINT8 NumMercsCloseTo( INT16 sGridNo, UINT8 ubMaxDist ) return( bNumber ); } -INT32 EstimateShotDamage(SOLDIERTYPE *pSoldier, SOLDIERTYPE *pOpponent, UINT8 ubChanceToHit) +INT32 EstimateShotDamage(SOLDIERTYPE *pSoldier, SOLDIERTYPE *pOpponent, INT16 ubChanceToHit) { INT32 iRange,iMaxRange,iPowerLost; INT32 iDamage; @@ -1811,7 +1816,7 @@ INT32 EstimateThrowDamage( SOLDIERTYPE *pSoldier, UINT8 ubItemPos, SOLDIERTYPE * } INT32 EstimateStabDamage( SOLDIERTYPE *pSoldier, SOLDIERTYPE *pOpponent, - UINT8 ubChanceToHit, BOOLEAN fBladeAttack ) + INT16 ubChanceToHit, BOOLEAN fBladeAttack ) { INT32 iImpact, iFluke, iBonus; @@ -2030,7 +2035,7 @@ INT8 CanNPCAttack(SOLDIERTYPE *pSoldier) void CheckIfTossPossible(SOLDIERTYPE *pSoldier, ATTACKTYPE *pBestThrow) { DebugMsg (TOPIC_JA2,DBG_LEVEL_3,"CheckIfTossPossible"); - UINT8 ubMinAPcost; + INT16 ubMinAPcost; pSoldier->bWeaponMode = WM_NORMAL; @@ -2412,7 +2417,7 @@ INT16 AdvanceToFiringRange( SOLDIERTYPE * pSoldier, INT16 sClosestOpponent ) { // see how far we can go down a path and still shoot - INT8 bAttackCost, bTrueActionPoints; + INT16 bAttackCost, bTrueActionPoints; UINT16 usActionData; bAttackCost = MinAPsToAttack(pSoldier, sClosestOpponent, ADDTURNCOST); @@ -2429,7 +2434,7 @@ INT16 AdvanceToFiringRange( SOLDIERTYPE * pSoldier, INT16 sClosestOpponent ) pSoldier->bActionPoints -= bAttackCost; usActionData = GoAsFarAsPossibleTowards( pSoldier, sClosestOpponent, AI_ACTION_SEEK_OPPONENT ); - + //POSSIBLE STRUCTURE PROBLEM HERE. GOTTHARD 7/15/08 pSoldier->bActionPoints = bTrueActionPoints; return( usActionData ); @@ -2441,7 +2446,7 @@ INT16 AdvanceToFiringRange( SOLDIERTYPE * pSoldier, INT16 sClosestOpponent ) void CheckIfShotPossible(SOLDIERTYPE *pSoldier, ATTACKTYPE *pBestShot, BOOLEAN suppressionFire) { DebugMsg (TOPIC_JA2,DBG_LEVEL_3,"CheckIfShotPossible"); - UINT8 ubMinAPcost; + INT16 ubMinAPcost; pBestShot->ubPossible = FALSE; pBestShot->bWeaponIn = NO_SLOT; diff --git a/TacticalAI/CreatureDecideAction.cpp b/TacticalAI/CreatureDecideAction.cpp index 116490e6..9aac8f9c 100644 --- a/TacticalAI/CreatureDecideAction.cpp +++ b/TacticalAI/CreatureDecideAction.cpp @@ -661,7 +661,7 @@ INT8 CreatureDecideActionRed(SOLDIERTYPE *pSoldier, UINT8 ubUnconsciousOK) //////////////////////////////////////////////////////////////////////////// if ( CAN_CALL( pSoldier ) ) { - if ((pSoldier->bActionPoints >= AP_RADIO) && (gTacticalStatus.Team[pSoldier->bTeam].bMenInSector > 1)) + if ((pSoldier->bActionPoints >= APBPConstants[AP_RADIO]) && (gTacticalStatus.Team[pSoldier->bTeam].bMenInSector > 1)) { if (pSoldier->stats.bLife < pSoldier->bOldLife) { @@ -710,7 +710,7 @@ INT8 CreatureDecideActionRed(SOLDIERTYPE *pSoldier, UINT8 ubUnconsciousOK) // (we never want NPCs to choose to radio if they would have to wait a turn) if ( CAN_CALL( pSoldier ) && (!gTacticalStatus.Team[pSoldier->bTeam].bAwareOfOpposition) ) { - if ((pSoldier->bActionPoints >= AP_RADIO) && (gTacticalStatus.Team[pSoldier->bTeam].bMenInSector > 1)) + if ((pSoldier->bActionPoints >= APBPConstants[AP_RADIO]) && (gTacticalStatus.Team[pSoldier->bTeam].bMenInSector > 1)) { // if there hasn't been a general sighting call sent yet @@ -908,8 +908,8 @@ INT8 CreatureDecideActionBlack( SOLDIERTYPE * pSoldier ) { // monster AI - hostile mammals in sense range INT16 sClosestOpponent,sBestCover = NOWHERE; - INT16 sClosestDisturbance; - UINT8 ubMinAPCost,ubCanMove/*,bInWater*/,bInGas; + INT16 sClosestDisturbance,ubMinAPCost; + UINT8 ubCanMove/*,bInWater*/,bInGas; INT8 bDirection; UINT8 ubBestAttackAction; INT8 bCanAttack; @@ -937,7 +937,7 @@ INT8 CreatureDecideActionBlack( SOLDIERTYPE * pSoldier ) if ( CAN_CALL( pSoldier ) ) { - if ((pSoldier->bActionPoints >= AP_RADIO) && (gTacticalStatus.Team[pSoldier->bTeam].bMenInSector > 1)) + if ((pSoldier->bActionPoints >= APBPConstants[AP_RADIO]) && (gTacticalStatus.Team[pSoldier->bTeam].bMenInSector > 1)) { if (pSoldier->stats.bLife < pSoldier->bOldLife) { @@ -1339,6 +1339,7 @@ INT8 CreatureDecideActionBlack( SOLDIERTYPE * pSoldier ) ////////////////////////////////////////////////////////////////////////// pSoldier->aiData.usActionData = BestAttack.sTarget; + //POSSIBLE STRUCTURE PROBLEM WITH INT8/INT16. GOTTHARD 7/14/08 pSoldier->aiData.bAimTime = BestAttack.ubAimTime; if ( ubBestAttackAction == AI_ACTION_FIRE_GUN && BestAttack.ubChanceToReallyHit > 50 ) diff --git a/TacticalAI/DecideAction.cpp b/TacticalAI/DecideAction.cpp index 4c198e80..c4c28d90 100644 --- a/TacticalAI/DecideAction.cpp +++ b/TacticalAI/DecideAction.cpp @@ -1406,7 +1406,7 @@ INT8 DecideActionYellow(SOLDIERTYPE *pSoldier) // if we have the action points remaining to RADIO // (we never want NPCs to choose to radio if they would have to wait a turn) - if ( !fCivilian && (pSoldier->bActionPoints >= AP_RADIO) && + if ( !fCivilian && (pSoldier->bActionPoints >= APBPConstants[AP_RADIO]) && (gTacticalStatus.Team[pSoldier->bTeam].bMenInSector > 1) ) { // base chance depends on how much new info we have to radio to the others @@ -1643,7 +1643,7 @@ INT8 DecideActionYellow(SOLDIERTYPE *pSoldier) // if ( CanClimbFromHere ( pSoldier, fUp ) ) if ( pSoldier->sGridNo == sNoiseGridNo) { - if (IsActionAffordable(pSoldier) && pSoldier->bActionPoints >= ( AP_CLIMBROOF + MinAPsToAttack( pSoldier, sNoiseGridNo, ADDTURNCOST))) + if (IsActionAffordable(pSoldier) && pSoldier->bActionPoints >= ( APBPConstants[AP_CLIMBROOF] + MinAPsToAttack( pSoldier, sNoiseGridNo, ADDTURNCOST))) { return( AI_ACTION_CLIMB_ROOF ); } @@ -2206,6 +2206,7 @@ if(!is_networked)//hayden RearrangePocket(pSoldier,HANDPOS,BestThrow.bWeaponIn,FOREVER); pSoldier->aiData.usActionData = BestThrow.sTarget; + //POSSIBLE STRUCTURE CHANGE PROBLEM, NOT CURRENTLY CHANGED. GOTTHARD 7/14/08 pSoldier->aiData.bAimTime = BestThrow.ubAimTime; return(AI_ACTION_TOSS_PROJECTILE); @@ -2272,6 +2273,7 @@ if(!is_networked)//hayden RearrangePocket(pSoldier,HANDPOS,BestShot.bWeaponIn,FOREVER); pSoldier->aiData.usActionData = BestShot.sTarget; + //POSSIBLE STRUCTURE CHANGE PROBLEM. GOTTHARD 7/14/08 pSoldier->aiData.bAimTime = BestShot.ubAimTime; ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, New113Message[ MSG113_SNIPER ] ); return(AI_ACTION_FIRE_GUN ); @@ -2324,7 +2326,7 @@ if(!is_networked)//hayden pSoldier->aiData.usActionData = BestShot.sTarget; //pSoldier->aiData.bAimTime = BestShot.ubAimTime; - UINT8 ubBurstAPs = 0; + INT16 ubBurstAPs = 0; pSoldier->bDoAutofire = 0; do @@ -2366,7 +2368,7 @@ if(!is_networked)//hayden } /* // CALL IN AIR STRIKE & RADIO RED ALERT - if ( !fCivilian && pSoldier->bTeam != MILITIA_TEAM && gGameOptions.fAirStrikes && airstrikeavailable && (pSoldier->bActionPoints >= AP_RADIO) && !WillAirRaidBeStopped(pSoldier->sSectorX,pSoldier->sSectorY)) + if ( !fCivilian && pSoldier->bTeam != MILITIA_TEAM && gGameOptions.fAirStrikes && airstrikeavailable && (pSoldier->bActionPoints >= APBPConstants[AP_RADIO]) && !WillAirRaidBeStopped(pSoldier->sSectorX,pSoldier->sSectorY)) { DebugMsg (TOPIC_JA2,DBG_LEVEL_3,"decideactionred: checking to call in an air strike"); @@ -2505,7 +2507,7 @@ if(!is_networked)//hayden // if we're a computer merc, and we have the action points remaining to RADIO // (we never want NPCs to choose to radio if they would have to wait a turn) - if ( !fCivilian && (pSoldier->bActionPoints >= AP_RADIO) && (gTacticalStatus.Team[pSoldier->bTeam].bMenInSector > 1) ) + if ( !fCivilian && (pSoldier->bActionPoints >= APBPConstants[AP_RADIO]) && (gTacticalStatus.Team[pSoldier->bTeam].bMenInSector > 1) ) { DebugMsg (TOPIC_JA2,DBG_LEVEL_3,"decideactionred: checking to radio red alert"); @@ -2648,12 +2650,12 @@ if(!is_networked)//hayden DebugMsg (TOPIC_JA2,DBG_LEVEL_3,"decideactionred: stop flanking"); if (PythSpacesAway ( pSoldier->sGridNo, tempGridNo ) > MIN_FLANK_DIST_RED * 2 ) { - pSoldier->aiData.usActionData = InternalGoAsFarAsPossibleTowards(pSoldier,tempGridNo,AP_PRONE,AI_ACTION_SEEK_OPPONENT,0); + pSoldier->aiData.usActionData = InternalGoAsFarAsPossibleTowards(pSoldier,tempGridNo,APBPConstants[AP_PRONE],AI_ACTION_SEEK_OPPONENT,0); if ( LocationToLocationLineOfSightTest( pSoldier->aiData.usActionData, pSoldier->pathing.bLevel, tempGridNo, pSoldier->pathing.bLevel, TRUE) ) { // reserve APs for a possible crouch plus a shot - pSoldier->aiData.usActionData = InternalGoAsFarAsPossibleTowards(pSoldier, tempGridNo, (INT8) (MinAPsToAttack( pSoldier, tempGridNo, ADDTURNCOST) + AP_CROUCH), AI_ACTION_SEEK_OPPONENT, FLAG_CAUTIOUS ); + pSoldier->aiData.usActionData = InternalGoAsFarAsPossibleTowards(pSoldier, tempGridNo, (INT8) (MinAPsToAttack( pSoldier, tempGridNo, ADDTURNCOST) + APBPConstants[AP_CROUCH]), AI_ACTION_SEEK_OPPONENT, FLAG_CAUTIOUS ); if ( pSoldier->aiData.usActionData != NOWHERE ) { pSoldier->aiData.fAIFlags |= AI_CAUTIOUS; @@ -2678,7 +2680,7 @@ if(!is_networked)//hayden // and have more APs than we want to reserve DebugMsg (TOPIC_JA2,DBG_LEVEL_3,String("decideactionred: can we move? = %d, APs = %d",ubCanMove,pSoldier->bActionPoints)); - if (ubCanMove && pSoldier->bActionPoints > MAX_AP_CARRIED) + if (ubCanMove && pSoldier->bActionPoints > APBPConstants[MAX_AP_CARRIED]) { if (fCivilian) { @@ -2775,7 +2777,7 @@ if(!is_networked)//hayden ////////////////////////////////////////////////////////////////////// // try to move towards him - pSoldier->aiData.usActionData = InternalGoAsFarAsPossibleTowards(pSoldier,sClosestDisturbance,AP_CROUCH,AI_ACTION_SEEK_OPPONENT,0); + pSoldier->aiData.usActionData = InternalGoAsFarAsPossibleTowards(pSoldier,sClosestDisturbance,APBPConstants[AP_CROUCH],AI_ACTION_SEEK_OPPONENT,0); if (pSoldier->aiData.usActionData != NOWHERE) { @@ -2817,7 +2819,7 @@ if(!is_networked)//hayden //if ( CanClimbFromHere ( pSoldier, fUp ) ) if (pSoldier->sGridNo == sClosestDisturbance) { - if (IsActionAffordable(pSoldier) && pSoldier->bActionPoints >= ( AP_CLIMBROOF + MinAPsToAttack( pSoldier, sClosestDisturbance, ADDTURNCOST))) + if (IsActionAffordable(pSoldier) && pSoldier->bActionPoints >= ( APBPConstants[AP_CLIMBROOF] + MinAPsToAttack( pSoldier, sClosestDisturbance, ADDTURNCOST))) { return( AI_ACTION_CLIMB_ROOF ); } @@ -2877,12 +2879,12 @@ if(!is_networked)//hayden if ( pSoldier->aiData.usActionData == NOWHERE || pSoldier->numFlanks >= MAX_FLANKS_RED ) { - pSoldier->aiData.usActionData = InternalGoAsFarAsPossibleTowards(pSoldier,sClosestDisturbance,AP_CROUCH, AI_ACTION_SEEK_OPPONENT,0); + pSoldier->aiData.usActionData = InternalGoAsFarAsPossibleTowards(pSoldier,sClosestDisturbance,APBPConstants[AP_CROUCH], AI_ACTION_SEEK_OPPONENT,0); //pSoldier->numFlanks = 0; if ( PythSpacesAway( pSoldier->aiData.usActionData, sClosestDisturbance ) < 5 || LocationToLocationLineOfSightTest( pSoldier->aiData.usActionData, pSoldier->pathing.bLevel, sClosestDisturbance, pSoldier->pathing.bLevel, TRUE ) ) { // reserve APs for a possible crouch plus a shot - pSoldier->aiData.usActionData = InternalGoAsFarAsPossibleTowards(pSoldier, sClosestDisturbance, (INT8) (MinAPsToAttack( pSoldier, sClosestDisturbance, ADDTURNCOST) + AP_CROUCH), AI_ACTION_SEEK_OPPONENT, FLAG_CAUTIOUS ); + pSoldier->aiData.usActionData = InternalGoAsFarAsPossibleTowards(pSoldier, sClosestDisturbance, (INT8) (MinAPsToAttack( pSoldier, sClosestDisturbance, ADDTURNCOST) + APBPConstants[AP_CROUCH]), AI_ACTION_SEEK_OPPONENT, FLAG_CAUTIOUS ); if ( pSoldier->aiData.usActionData != NOWHERE ) { pSoldier->aiData.fAIFlags |= AI_CAUTIOUS; @@ -2919,7 +2921,7 @@ if(!is_networked)//hayden if ( PythSpacesAway( pSoldier->aiData.usActionData, sClosestDisturbance ) < 5 || LocationToLocationLineOfSightTest( pSoldier->aiData.usActionData, pSoldier->pathing.bLevel, sClosestDisturbance, pSoldier->pathing.bLevel, TRUE ) ) { // reserve APs for a possible crouch plus a shot - pSoldier->aiData.usActionData = InternalGoAsFarAsPossibleTowards(pSoldier, sClosestDisturbance, (INT8) (MinAPsToAttack( pSoldier, sClosestDisturbance, ADDTURNCOST) + AP_CROUCH), AI_ACTION_SEEK_OPPONENT, FLAG_CAUTIOUS ); + pSoldier->aiData.usActionData = InternalGoAsFarAsPossibleTowards(pSoldier, sClosestDisturbance, (INT8) (MinAPsToAttack( pSoldier, sClosestDisturbance, ADDTURNCOST) + APBPConstants[AP_CROUCH]), AI_ACTION_SEEK_OPPONENT, FLAG_CAUTIOUS ); if ( pSoldier->aiData.usActionData != NOWHERE ) { pSoldier->aiData.fAIFlags |= AI_CAUTIOUS; @@ -3016,7 +3018,7 @@ if(!is_networked)//hayden ////////////////////////////////////////////////////////////////////// // GO DIRECTLY TOWARDS CLOSEST FRIEND UNDER FIRE OR WHO LAST RADIOED ////////////////////////////////////////////////////////////////////// - pSoldier->aiData.usActionData = InternalGoAsFarAsPossibleTowards(pSoldier,sClosestFriend,AP_CROUCH, AI_ACTION_SEEK_OPPONENT,0); + pSoldier->aiData.usActionData = InternalGoAsFarAsPossibleTowards(pSoldier,sClosestFriend,APBPConstants[AP_CROUCH], AI_ACTION_SEEK_OPPONENT,0); if (pSoldier->aiData.usActionData != NOWHERE) { @@ -3041,7 +3043,7 @@ if(!is_networked)//hayden //if ( CanClimbFromHere ( pSoldier, fUp ) ) if (pSoldier->sGridNo == sClosestFriend) { - if (IsActionAffordable(pSoldier) && pSoldier->bActionPoints >= ( AP_CLIMBROOF + MinAPsToAttack( pSoldier, sClosestFriend, ADDTURNCOST))) + if (IsActionAffordable(pSoldier) && pSoldier->bActionPoints >= ( APBPConstants[AP_CLIMBROOF] + MinAPsToAttack( pSoldier, sClosestFriend, ADDTURNCOST))) { return( AI_ACTION_CLIMB_ROOF ); } @@ -3106,7 +3108,7 @@ if(!is_networked)//hayden { // either moving significantly closer or into very close range // ensure will we have enough APs for a possible crouch plus a shot - if ( InternalGoAsFarAsPossibleTowards( pSoldier, pSoldier->aiData.usActionData, (INT8) (MinAPsToAttack( pSoldier, sClosestOpponent, ADDTURNCOST) + AP_CROUCH), AI_ACTION_TAKE_COVER, 0 ) == pSoldier->aiData.usActionData ) + if ( InternalGoAsFarAsPossibleTowards( pSoldier, pSoldier->aiData.usActionData, (INT8) (MinAPsToAttack( pSoldier, sClosestOpponent, ADDTURNCOST) + APBPConstants[AP_CROUCH]), AI_ACTION_TAKE_COVER, 0 ) == pSoldier->aiData.usActionData ) { return(AI_ACTION_TAKE_COVER); } @@ -3475,8 +3477,8 @@ INT8 DecideActionBlack(SOLDIERTYPE *pSoldier) { INT32 iCoverPercentBetter, iOffense, iDefense, iChance; INT16 sClosestOpponent,sBestCover = NOWHERE; - INT16 sClosestDisturbance; - UINT8 ubMinAPCost,ubCanMove; + INT16 sClosestDisturbance,ubMinAPCost; + UINT8 ubCanMove; INT8 bInWater,bInDeepWater,bInGas; INT8 bDirection; UINT8 ubBestAttackAction = AI_ACTION_NONE; @@ -3493,7 +3495,7 @@ INT8 DecideActionBlack(SOLDIERTYPE *pSoldier) UINT8 ubBestStance = 1, ubStanceCost; BOOLEAN fChangeStanceFirst; // before firing BOOLEAN fClimb; - UINT8 ubBurstAPs; + INT16 ubBurstAPs; UINT8 ubOpponentDir; INT16 sCheckGridNo; @@ -4175,13 +4177,14 @@ INT8 DecideActionBlack(SOLDIERTYPE *pSoldier) !(pSoldier->flags.uiStatusFlags & SOLDIER_BOXER) ) { // make militia a bit more cautious - if ( ( (pSoldier->bTeam == MILITIA_TEAM) && (PreRandom( 20 ) > BestAttack.ubChanceToReallyHit) ) - || ( (pSoldier->bTeam != MILITIA_TEAM) && (PreRandom( 40 ) > BestAttack.ubChanceToReallyHit) ) ) + // 3 (UINT16) CONVERSIONS HERE TO AVOID ERRORS. GOTTHARD 7/15/08 + if ( ( (pSoldier->bTeam == MILITIA_TEAM) && (PreRandom( 20 ) > (UINT16)BestAttack.ubChanceToReallyHit) ) + || ( (pSoldier->bTeam != MILITIA_TEAM) && (PreRandom( 40 ) > (UINT16)BestAttack.ubChanceToReallyHit) ) ) { //ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_TESTVERSION, L"AI %d allowing cover check, chance to hit is only %d, at range %d", BestAttack.ubChanceToReallyHit, PythSpacesAway( pSoldier->sGridNo, BestAttack.sTarget ) ); // maybe taking cover would be better! fAllowCoverCheck = TRUE; - if ( PreRandom( 10 ) > BestAttack.ubChanceToReallyHit ) + if ( PreRandom( 10 ) > (UINT16)BestAttack.ubChanceToReallyHit ) { DebugMsg (TOPIC_JA2,DBG_LEVEL_3,"DecideActionBlack: can't hit so screw the attack"); // screw the attack! @@ -4301,13 +4304,14 @@ INT8 DecideActionBlack(SOLDIERTYPE *pSoldier) fChangeStanceFirst = FALSE; // default settings - pSoldier->aiData.bAimTime = BestAttack.ubAimTime; + //POSSIBLE STRUCTURE CHANGE PROBLEM, NOT CURRENTLY CHANGED. GOTTHARD 7/14/08 + pSoldier->aiData.bAimTime = BestAttack.ubAimTime; pSoldier->bDoBurst = 0; if (ubBestAttackAction == AI_ACTION_FIRE_GUN) { // Do we need to change stance? NB We'll have to ready our gun again - if ( !TANK( pSoldier ) && ( pSoldier->bActionPoints >= BestAttack.ubAPCost + AP_CROUCH + MinAPsToAttack( pSoldier, BestAttack.sTarget, ADDTURNCOST, 1 ) ) ) + if ( !TANK( pSoldier ) && ( pSoldier->bActionPoints >= BestAttack.ubAPCost + APBPConstants[AP_CROUCH] + MinAPsToAttack( pSoldier, BestAttack.sTarget, ADDTURNCOST, 1 ) ) ) { // since the AI considers shooting chance from standing primarily, if we are not // standing we should always consider a stance change @@ -4758,7 +4762,7 @@ INT8 DecideActionBlack(SOLDIERTYPE *pSoldier) // (we never want NPCs to choose to radio if they would have to wait a turn) // and we're not swimming in deep water, and somebody has called for spotters // and we see the location of at least 2 opponents - if ((gTacticalStatus.ubSpottersCalledForBy != NOBODY) && (pSoldier->bActionPoints >= AP_RADIO) && + if ((gTacticalStatus.ubSpottersCalledForBy != NOBODY) && (pSoldier->bActionPoints >= APBPConstants[AP_RADIO]) && (pSoldier->aiData.bOppCnt > 1) && !fCivilian && (gTacticalStatus.Team[pSoldier->bTeam].bMenInSector > 1) && !bInDeepWater) { @@ -4891,7 +4895,7 @@ INT8 DecideActionBlack(SOLDIERTYPE *pSoldier) // RADIO RED ALERT: determine %chance to call others and report contact //////////////////////////////////////////////////////////////////////////// - if ( pSoldier->bTeam == MILITIA_TEAM && (pSoldier->bActionPoints >= AP_RADIO) && (gTacticalStatus.Team[pSoldier->bTeam].bMenInSector > 1) ) + if ( pSoldier->bTeam == MILITIA_TEAM && (pSoldier->bActionPoints >= APBPConstants[AP_RADIO]) && (gTacticalStatus.Team[pSoldier->bTeam].bMenInSector > 1) ) { // if there hasn't been an initial RED ALERT yet in this sector @@ -5337,3 +5341,6 @@ void DecideAlertStatus( SOLDIERTYPE *pSoldier ) } + + + diff --git a/TacticalAI/FindLocations.cpp b/TacticalAI/FindLocations.cpp index 2915942a..c32a273a 100644 --- a/TacticalAI/FindLocations.cpp +++ b/TacticalAI/FindLocations.cpp @@ -43,7 +43,7 @@ extern void RenderCoverDebug( void ); #endif -INT8 gubAIPathCosts[19][19]; +INT16 gubAIPathCosts[19][19]; // FindBestNearbyCover - "Net" related stuff commented out extern UINT8 gubAICounter; @@ -127,13 +127,13 @@ INT8 CalcWorstCTGTForPosition( SOLDIERTYPE * pSoldier, UINT8 ubOppID, INT16 sOpp switch (bCubeLevel) { case 1: - if (iMyAPsLeft < AP_CROUCH + AP_PRONE) + if (iMyAPsLeft < APBPConstants[AP_CROUCH] + APBPConstants[AP_PRONE]) { continue; } break; case 2: - if (iMyAPsLeft < AP_CROUCH) + if (iMyAPsLeft < APBPConstants[AP_CROUCH]) { continue; } @@ -167,13 +167,13 @@ INT8 CalcAverageCTGTForPosition( SOLDIERTYPE * pSoldier, UINT8 ubOppID, INT16 sO switch (bCubeLevel) { case 1: - if (iMyAPsLeft < AP_CROUCH + AP_PRONE) + if (iMyAPsLeft < APBPConstants[AP_CROUCH] + APBPConstants[AP_PRONE]) { continue; } break; case 2: - if (iMyAPsLeft < AP_CROUCH) + if (iMyAPsLeft < APBPConstants[AP_CROUCH]) { continue; } @@ -429,7 +429,7 @@ INT32 CalcCoverValue(SOLDIERTYPE *pMe, INT16 sMyGridNo, INT32 iMyThreat, INT32 i { // if I CAN'T crouch when I get there, that makes it significantly less // appealing a spot (how much depends on range), so that's a penalty to me - if (iMyAPsLeft < AP_CROUCH) + if (iMyAPsLeft < APBPConstants[AP_CROUCH]) // subtract another 1 % penalty for NOT being able to crouch per tile // the farther away we are, the bigger a difference crouching will make! iMyPosValue -= ((iMyPosValue * (AIM_PENALTY_TARGET_CROUCHED + (iRange / CELL_X_SIZE))) / 100); @@ -1657,7 +1657,7 @@ INT8 SearchForItems( SOLDIERTYPE * pSoldier, INT8 bReason, UINT16 usItem ) return AI_ACTION_NONE; } - if (pSoldier->bActionPoints < AP_PICKUP_ITEM) + if (pSoldier->bActionPoints < APBPConstants[AP_PICKUP_ITEM]) { return( AI_ACTION_NONE ); } @@ -1714,7 +1714,7 @@ INT8 SearchForItems( SOLDIERTYPE * pSoldier, INT8 bReason, UINT16 usItem ) // set an AP limit too, to our APs less the cost of picking up an item // and less the cost of dropping an item since we might need to do that - gubNPCAPBudget = pSoldier->bActionPoints - AP_PICKUP_ITEM; + gubNPCAPBudget = pSoldier->bActionPoints - APBPConstants[AP_PICKUP_ITEM]; // reset the "reachable" flags in the region we're looking at for (sYOffset = -sMaxUp; sYOffset <= sMaxDown; sYOffset++) @@ -1951,7 +1951,7 @@ INT8 SearchForItems( SOLDIERTYPE * pSoldier, INT8 bReason, UINT16 usItem ) //if (pSoldier->inv[HANDPOS].exists() == true && PlaceInAnyPocket(pSoldier, &pSoldier->inv[HANDPOS], false) == false) if (FindBetterSpotForItem( pSoldier, HANDPOS ) == FALSE) { - if (pSoldier->bActionPoints < AP_PICKUP_ITEM + AP_PICKUP_ITEM) + if (pSoldier->bActionPoints < APBPConstants[AP_PICKUP_ITEM] + APBPConstants[AP_PICKUP_ITEM]) { return( AI_ACTION_NONE ); } @@ -1960,7 +1960,7 @@ INT8 SearchForItems( SOLDIERTYPE * pSoldier, INT8 bReason, UINT16 usItem ) // destroy this item! DebugAI( String( "%d decides he must drop %S first so destroys it", pSoldier->ubID, ItemNames[ pSoldier->inv[HANDPOS].usItem ] ) ); DeleteObj( &(pSoldier->inv[HANDPOS]) ); - DeductPoints( pSoldier, AP_PICKUP_ITEM, 0 ); + DeductPoints( pSoldier, APBPConstants[AP_PICKUP_ITEM], 0 ); } else { @@ -2848,3 +2848,4 @@ INT8 FindDirectionForClimbing( SOLDIERTYPE *pSoldier, INT16 sGridNo, INT8 bLevel } + diff --git a/TacticalAI/Movement.cpp b/TacticalAI/Movement.cpp index c13390b2..1da435d8 100644 --- a/TacticalAI/Movement.cpp +++ b/TacticalAI/Movement.cpp @@ -443,7 +443,7 @@ INT8 RandomPointPatrolAI(SOLDIERTYPE *pSoldier) -INT16 InternalGoAsFarAsPossibleTowards(SOLDIERTYPE *pSoldier, INT16 sDesGrid, INT8 bReserveAPs, INT8 bAction, INT8 fFlags ) +INT16 InternalGoAsFarAsPossibleTowards(SOLDIERTYPE *pSoldier, INT16 sDesGrid, INT16 bReserveAPs, INT8 bAction, INT8 fFlags ) { #ifdef DEBUGDECISIONS STR16 tempstr; @@ -470,7 +470,7 @@ INT16 InternalGoAsFarAsPossibleTowards(SOLDIERTYPE *pSoldier, INT16 sDesGrid, IN } else { - bReserveAPs = MAX_AP_CARRIED; + bReserveAPs = APBPConstants[MAX_AP_CARRIED]; } } @@ -703,15 +703,15 @@ INT16 InternalGoAsFarAsPossibleTowards(SOLDIERTYPE *pSoldier, INT16 sDesGrid, IN // in theory, no NPC should ever be in one of these animations as // things stand (they don't medic anyone), but leave it for robustness case START_AID : - case GIVING_AID : sAnimCost = AP_STOP_FIRST_AID; + case GIVING_AID : sAnimCost = APBPConstants[AP_STOP_FIRST_AID]; break; case TWISTOMACH : - case COLLAPSED : sAnimCost = AP_GET_UP; + case COLLAPSED : sAnimCost = APBPConstants[AP_GET_UP]; break; case TWISTBACK : - case UNCONSCIOUS : sAnimCost = (AP_ROLL_OVER + AP_GET_UP); + case UNCONSCIOUS : sAnimCost = (APBPConstants[AP_ROLL_OVER] + APBPConstants[AP_GET_UP]); break; default : sAnimCost = 0; @@ -723,7 +723,7 @@ INT16 InternalGoAsFarAsPossibleTowards(SOLDIERTYPE *pSoldier, INT16 sDesGrid, IN if (pSoldier->usUIMovementMode == RUNNING) { - sAPCost += AP_START_RUN_COST; + sAPCost += APBPConstants[AP_START_RUN_COST]; } } diff --git a/TacticalAI/PanicButtons.cpp b/TacticalAI/PanicButtons.cpp index 0c64e3c6..fdbd19c8 100644 --- a/TacticalAI/PanicButtons.cpp +++ b/TacticalAI/PanicButtons.cpp @@ -220,7 +220,7 @@ void PossiblyMakeThisEnemyChosenOne( SOLDIERTYPE * pSoldier ) pSoldier->flags.bHasKeys = (pSoldier->flags.bHasKeys << 1) | 1; // if he can't get to a spot where he could get at the panic trigger - iAPCost = AP_PULL_TRIGGER; + iAPCost = APBPConstants[AP_PULL_TRIGGER]; if (pSoldier->sGridNo != sPanicTriggerGridNo) { iPathCost = PlotPath( pSoldier, sPanicTriggerGridNo, FALSE, FALSE, FALSE, RUNNING, FALSE, FALSE, 0); @@ -269,7 +269,7 @@ INT8 PanicAI(SOLDIERTYPE *pSoldier, UINT8 ubCanMove) ////////////////////////////////////////////////////////////////////// // if we have enough APs to activate it now - if (pSoldier->bActionPoints >= AP_USE_REMOTE) + if (pSoldier->bActionPoints >= APBPConstants[AP_USE_REMOTE]) { #ifdef TESTVERSION sprintf(tempstr,"TEST MSG: %s - ACTIVATING his DETONATOR!",pSoldier->name); @@ -344,7 +344,7 @@ INT8 PanicAI(SOLDIERTYPE *pSoldier, UINT8 ubCanMove) //////////////////////////////////////////////////////////////// // and we have enough APs left to pull the trigger - if (pSoldier->bActionPoints >= AP_PULL_TRIGGER) + if (pSoldier->bActionPoints >= APBPConstants[AP_PULL_TRIGGER]) { // blow up the all the PANIC bombs (or just the journal) pSoldier->aiData.usActionData = sPanicTriggerGridNo; diff --git a/TacticalAI/ai.h b/TacticalAI/ai.h index c4171b62..8e162403 100644 --- a/TacticalAI/ai.h +++ b/TacticalAI/ai.h @@ -7,7 +7,7 @@ #define TESTAICONTROL -extern INT8 gubAIPathCosts[19][19]; +extern INT16 gubAIPathCosts[19][19]; #define AI_PATHCOST_RADIUS 9 extern BOOLEAN gfDisplayCoverValues; diff --git a/TileEngine/Exit Grids.cpp b/TileEngine/Exit Grids.cpp index 5a1fab82..485dd87b 100644 --- a/TileEngine/Exit Grids.cpp +++ b/TileEngine/Exit Grids.cpp @@ -241,7 +241,7 @@ INT16 FindGridNoFromSweetSpotCloseToExitGrid( SOLDIERTYPE *pSoldier, INT16 sSwee INT32 leftmost; BOOLEAN fFound = FALSE; SOLDIERTYPE soldier; - UINT8 ubSaveNPCAPBudget; + INT16 ubSaveNPCAPBudget; UINT8 ubSaveNPCDistLimit; EXITGRID ExitGrid; UINT8 ubGotoSectorX, ubGotoSectorY, ubGotoSectorZ; @@ -407,3 +407,4 @@ INT16 FindClosestExitGrid( SOLDIERTYPE *pSoldier, INT16 sSrcGridNo, INT8 ubRadiu + diff --git a/TileEngine/Interactive Tiles.cpp b/TileEngine/Interactive Tiles.cpp index 3d9ac20d..d7afcbe1 100644 --- a/TileEngine/Interactive Tiles.cpp +++ b/TileEngine/Interactive Tiles.cpp @@ -156,8 +156,8 @@ BOOLEAN CalcInteractiveObjectAPs( INT16 sGridNo, STRUCTURE * pStructure, INT16 * // If closed, we do not know what to do yet... //if ( pStructure->fFlags & STRUCTURE_OPEN ) //{ - *psAPCost = AP_OPEN_DOOR; - *psBPCost = AP_OPEN_DOOR; + *psAPCost = APBPConstants[AP_OPEN_DOOR]; + *psBPCost = APBPConstants[AP_OPEN_DOOR]; //} //else //{ @@ -167,8 +167,8 @@ BOOLEAN CalcInteractiveObjectAPs( INT16 sGridNo, STRUCTURE * pStructure, INT16 * } else { - *psAPCost = AP_OPEN_DOOR; - *psBPCost = AP_OPEN_DOOR; + *psAPCost = APBPConstants[AP_OPEN_DOOR]; + *psBPCost = APBPConstants[AP_OPEN_DOOR]; } return( TRUE ); diff --git a/Utils/XML_Items.cpp b/Utils/XML_Items.cpp index 580ccb32..0ea6e39c 100644 --- a/Utils/XML_Items.cpp +++ b/Utils/XML_Items.cpp @@ -683,6 +683,7 @@ itemEndElementHandle(void *userData, const XML_Char *name) { pData->curElement = ELEMENT; pData->curItem.APBonus = (INT16) atol(pData->szCharData); + pData->curItem.APBonus = (INT16)DynamicAdjustAPConstants(pData->curItem.APBonus, pData->curItem.APBonus); } else if(strcmp(name, "RateOfFireBonus") == 0) { diff --git a/gameloop.cpp b/gameloop.cpp index 1e8f1e15..c506d78a 100644 --- a/gameloop.cpp +++ b/gameloop.cpp @@ -107,6 +107,7 @@ BOOLEAN InitializeGame(void) // Snap: Read options from an INI file in the default of custom Data directory // Moved this up because some settings are used during other inits LoadGameExternalOptions(); + LoadGameAPBPConstants(); InitSightRange(); //lal // Initlaize mouse subsystems