From 47210f9b14f6200ba7f0131bc00c613b981ca934 Mon Sep 17 00:00:00 2001 From: Wanne Date: Tue, 19 Nov 2013 07:52:51 +0000 Subject: [PATCH] Updated Enemy taunts feature (by anv) - ridiculous amount of tags: attack, hit, miss, kill, head pop, blinded, type of attack, is target a zombie... - ripostes to merc quotes, - taunts can now make noise, - bumped up amount of taunts to respectable 733, mostly thanks to your contributions guys, - accidently squashed bug with incorrect noise notifications ("hears scream" instead of "hears explosion" etc.) Ripostes At the moment enemies can react to quotes "enemy detected", "1st enemy detected", "multiple enemies detected", "bullet flew by", "under heavy fire", as these are most likely to be used in combat. In the first three cases, riposting enemy will be chosen randomly from all enemy witnesses, latter two - last enemy to attack this merc will taunt. Enemy's riposte will come as soon as merc quote is finished. Noisy taunts Taunts can be handled like other noises in game - shots, explosions, etc., meaning: - they will be displayed only if someone from our team is close enough to hear them, - they can be heard even if you don't see enemy (with twist of his name changed to "unknown voice". Yay.) - volume of taunts is configurable in .ini. see: http://www.ja-galaxy-forum.com/board/ubbthreads.php/topics/327830/4.html git-svn-id: https://ja2svn.mooo.com/source/ja2/trunk/GameSource/ja2_v1.13/Build@6628 3b4a5df2-a311-0410-b5c6-a8a6f20db521 --- GameSettings.cpp | 46 ++- GameSettings.h | 22 ++ Tactical/Civ Quotes.cpp | 514 ++++++++++++++++++++++++++++------ Tactical/Civ Quotes.h | 78 +++++- Tactical/Dialogue Control.cpp | 42 +++ Tactical/Interface.h | 1 + Tactical/Soldier Ani.cpp | 31 +- Tactical/Soldier Control.cpp | 48 +++- Tactical/Soldier Control.h | 114 ++++++-- Tactical/Weapons.cpp | 83 ++++-- Tactical/XML_Taunts.cpp | 487 +++++++++++++++++++++++++++----- Tactical/opplist.cpp | 113 ++++++-- Tactical/opplist.h | 5 +- TacticalAI/AIMain.cpp | 75 ++--- TacticalAI/Attacks.cpp | 11 + Utils/Event Pump.cpp | 2 +- Utils/Event Pump.h | 1 + Utils/Text.h | 1 + Utils/_ChineseText.cpp | 9 + Utils/_DutchText.cpp | 9 + Utils/_EnglishText.cpp | 8 + Utils/_FrenchText.cpp | 9 + Utils/_GermanText.cpp | 9 + Utils/_ItalianText.cpp | 9 + Utils/_PolishText.cpp | 9 + Utils/_RussianText.cpp | 9 + Utils/_TaiwaneseText.cpp | 9 + 27 files changed, 1477 insertions(+), 277 deletions(-) diff --git a/GameSettings.cpp b/GameSettings.cpp index f9222ec2d..b7d66ca82 100644 --- a/GameSettings.cpp +++ b/GameSettings.cpp @@ -3203,23 +3203,57 @@ void LoadCTHConstants() void LoadTauntsSettings() { CIniReader iniReader(TAUNTS_SETTINGS_FILE); - gTauntsSettings.fTauntShowInLog = iniReader.ReadBoolean("Taunts Settings","TAUNT_SHOW_IN_LOG", TRUE ); - gTauntsSettings.sModDelay = iniReader.ReadInteger("Taunts Settings","TAUNT_MIN_DELAY",100, -32767, 32767 ); + gTauntsSettings.fTauntShowPopupBox = iniReader.ReadBoolean("Taunts Settings","TAUNT_SHOW_POPUP_BOX", TRUE ); + gTauntsSettings.fTauntShowInLog = iniReader.ReadBoolean("Taunts Settings","TAUNT_SHOW_IN_LOG", TRUE ); + gTauntsSettings.fTauntMakeNoise = iniReader.ReadBoolean("Taunts Settings","TAUNT_MAKE_NOISE", TRUE ); + gTauntsSettings.fTauntOnlyVisibleEnemies = iniReader.ReadBoolean("Taunts Settings","TAUNT_ONLY_VISIBLE_ENEMIES", FALSE ); + gTauntsSettings.fTauntShowPopupBoxIfHeard = iniReader.ReadBoolean("Taunts Settings","TAUNT_SHOW_POPUP_BOX_IF_HEARD", TRUE ); + gTauntsSettings.fTauntShowInLogIfHeard = iniReader.ReadBoolean("Taunts Settings","TAUNT_SHOW_IN_LOG_IF_HEARD", TRUE ); + gTauntsSettings.fTauntAlwaysShowPopupBox = iniReader.ReadBoolean("Taunts Settings","TAUNT_ALWAYS_SHOW_POPUP_BOX", FALSE ); + gTauntsSettings.fTauntAlwaysShowInLog = iniReader.ReadBoolean("Taunts Settings","TAUNT_ALWAYS_SHOW_IN_LOG", FALSE ); + gTauntsSettings.sVolume = iniReader.ReadInteger("Taunts Settings","TAUNT_VOLUME",30, 0, 65535 ); + gTauntsSettings.sModDelay = iniReader.ReadInteger("Taunts Settings","TAUNT_MOD_DELAY",100, -32767, 32767 ); gTauntsSettings.sMinDelay = iniReader.ReadInteger("Taunts Settings","TAUNT_MIN_DELAY",500, 0, 65535 ); gTauntsSettings.sMaxDelay = iniReader.ReadInteger("Taunts Settings","TAUNT_MAX_DELAY",5000, 0, 65535 ); gTauntsSettings.ubTauntFireGunChance = iniReader.ReadInteger("Taunts Settings","TAUNT_FIRE_GUN_CHANCE",12, 0, 100); gTauntsSettings.ubTauntFireLauncherChance = iniReader.ReadInteger("Taunts Settings","TAUNT_FIRE_LAUNCHER_CHANCE",25, 0, 100); + gTauntsSettings.ubTauntAttackBladeChance = iniReader.ReadInteger("Taunts Settings","TAUNT_ATTACK_BLADE",15, 0, 100); + gTauntsSettings.ubTauntAttackHTHChance = iniReader.ReadInteger("Taunts Settings","TAUNT_ATTACK_HTH",15, 0, 100); + gTauntsSettings.ubTauntThrowKnifeChance = iniReader.ReadInteger("Taunts Settings","TAUNT_THROW_KNIFE_CHANCE",33, 0, 100); gTauntsSettings.ubTauntThrowGrenadeChance = iniReader.ReadInteger("Taunts Settings","TAUNT_THROW_GRENADE_CHANCE",33, 0, 100); - gTauntsSettings.ubTauntChargeKnifeChance = iniReader.ReadInteger("Taunts Settings","TAUNT_CHARGE_KNIFE_CHANCE",25, 0, 100); - gTauntsSettings.ubTauntChargeFistsChance = iniReader.ReadInteger("Taunts Settings","TAUNT_CHARGE_FISTS_CHANCE",25, 0, 100); + gTauntsSettings.ubTauntChargeKnifeChance = iniReader.ReadInteger("Taunts Settings","TAUNT_CHARGE_BLADE_CHANCE",33, 0, 100); + gTauntsSettings.ubTauntChargeFistsChance = iniReader.ReadInteger("Taunts Settings","TAUNT_CHARGE_HTH_CHANCE",33, 0, 100); + gTauntsSettings.ubTauntStealChance = iniReader.ReadInteger("Taunts Settings","TAUNT_STEAL_CHANCE",25, 0, 100); - gTauntsSettings.ubTauntRunAwayChance = iniReader.ReadInteger("Taunts Settings","TAUNT_RUN_AWAY_CHANCE",20, 0, 100); + + gTauntsSettings.ubTauntRunAwayChance = iniReader.ReadInteger("Taunts Settings","TAUNT_RUN_AWAY_CHANCE",33, 0, 100); gTauntsSettings.ubTauntSeekNoiseChance = iniReader.ReadInteger("Taunts Settings","TAUNT_SEEK_NOISE_CHANCE",33, 0, 100); gTauntsSettings.ubTauntAlertChance = iniReader.ReadInteger("Taunts Settings","TAUNT_ALERT_CHANCE",33, 0, 100); + gTauntsSettings.ubTauntSuspiciousChance = iniReader.ReadInteger("Taunts Settings","TAUNT_SUSPICIOUS_CHANCE",33, 0, 100); + gTauntsSettings.ubTauntGotHitChance = iniReader.ReadInteger("Taunts Settings","TAUNT_GOT_HIT_CHANCE",25, 0, 100); + gTauntsSettings.ubTauntGotDeafenedBlindedChance = iniReader.ReadInteger("Taunts Settings","TAUNT_GOT_BLINDED_DEAFENED_CHANCE",33, 0, 100); + gTauntsSettings.ubTauntGotRobbedChance = iniReader.ReadInteger("Taunts Settings","TAUNT_GOT_ROBBED_CHANCE",33, 0, 100); + gTauntsSettings.ubTauntGotMissedChance = iniReader.ReadInteger("Taunts Settings","TAUNT_GOT_MISSED_CHANCE",12, 0, 100); - gTauntsSettings.ubTauntNoticedUnseenChance = iniReader.ReadInteger("Taunts Settings","TAUNT_NOTICED_UNSEEN_MERC_CHANCE",10, 0, 100); + + gTauntsSettings.ubTauntHitChance = iniReader.ReadInteger("Taunts Settings","TAUNT_HIT_CHANCE",12, 0, 100); + + gTauntsSettings.ubTauntKillChance = iniReader.ReadInteger("Taunts Settings","TAUNT_KILL_CHANCE",33, 0, 100); + gTauntsSettings.ubTauntHeadPopChance = iniReader.ReadInteger("Taunts Settings","TAUNT_HEAD_POP_CHANCE",100, 0, 100); + + gTauntsSettings.ubTauntMissChance = iniReader.ReadInteger("Taunts Settings","TAUNT_MISS_CHANCE",12, 0, 100); + + gTauntsSettings.ubTauntOutOfAmmoChance = iniReader.ReadInteger("Taunts Settings","TAUNT_OUT_OF_AMMO",12, 0, 100); + gTauntsSettings.ubTauntReloadChance = iniReader.ReadInteger("Taunts Settings","TAUNT_RELOAD",12, 0, 100); + + gTauntsSettings.ubTauntNoticedUnseenChance = iniReader.ReadInteger("Taunts Settings","TAUNT_NOTICED_UNSEEN_MERC_CHANCE",12, 0, 100); + gTauntsSettings.ubTauntSayHiChance = iniReader.ReadInteger("Taunts Settings","TAUNT_SAY_HI",12, 0, 100); + gTauntsSettings.ubTauntInformAboutChance = iniReader.ReadInteger("Taunts Settings","TAUNT_INFORM_ABOUT",12, 0, 100); + + gTauntsSettings.ubRiposteChance = iniReader.ReadInteger("Taunts Settings","TAUNT_RIPOSTE",12, 0, 100); + } void FreeGameExternalOptions() diff --git a/GameSettings.h b/GameSettings.h index 39ae2678f..9b68bd6f3 100644 --- a/GameSettings.h +++ b/GameSettings.h @@ -1329,12 +1329,22 @@ typedef struct typedef struct { + BOOLEAN fTauntShowPopupBox; BOOLEAN fTauntShowInLog; + BOOLEAN fTauntMakeNoise; + BOOLEAN fTauntOnlyVisibleEnemies; + BOOLEAN fTauntShowPopupBoxIfHeard; + BOOLEAN fTauntShowInLogIfHeard; + BOOLEAN fTauntAlwaysShowPopupBox; + BOOLEAN fTauntAlwaysShowInLog; + UINT16 sVolume; INT16 sModDelay; UINT16 sMinDelay; UINT16 sMaxDelay; UINT8 ubTauntFireGunChance; UINT8 ubTauntFireLauncherChance; + UINT8 ubTauntAttackBladeChance; + UINT8 ubTauntAttackHTHChance; UINT8 ubTauntThrowKnifeChance; UINT8 ubTauntThrowGrenadeChance; UINT8 ubTauntChargeKnifeChance; @@ -1343,9 +1353,21 @@ typedef struct UINT8 ubTauntRunAwayChance; UINT8 ubTauntSeekNoiseChance; UINT8 ubTauntAlertChance; + UINT8 ubTauntSuspiciousChance; UINT8 ubTauntGotHitChance; + UINT8 ubTauntGotDeafenedBlindedChance; + UINT8 ubTauntGotRobbedChance; UINT8 ubTauntGotMissedChance; + UINT8 ubTauntKillChance; + UINT8 ubTauntHeadPopChance; + UINT8 ubTauntHitChance; + UINT8 ubTauntMissChance; + UINT8 ubTauntOutOfAmmoChance; + UINT8 ubTauntReloadChance; UINT8 ubTauntNoticedUnseenChance; + UINT8 ubTauntSayHiChance; + UINT8 ubTauntInformAboutChance; + UINT8 ubRiposteChance; } TAUNTS_SETTINGS; diff --git a/Tactical/Civ Quotes.cpp b/Tactical/Civ Quotes.cpp index a1ab1dfc3..5f66c4cb9 100644 --- a/Tactical/Civ Quotes.cpp +++ b/Tactical/Civ Quotes.cpp @@ -38,6 +38,7 @@ // for enemy taunts #include "Soldier Profile.h" #include "Campaign.h" +#include "opplist.h" #define DIALOGUE_DEFAULT_WIDTH 200 #define EXTREAMLY_LOW_TOWN_LOYALTY 20 @@ -1048,77 +1049,209 @@ BOOLEAN LoadCivQuotesFromLoadGameFile( HWFILE hFile ) // anv: start enemy taunt with probabilty depending on taunt settings void PossiblyStartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget ) { + // taunts disabled? + if( gGameSettings.fOptions[TOPTION_ALLOW_TAUNTS] == FALSE ) + { + return; + } + // uh, just in case + if( pCiv == NULL ) + { + return; + } + // check if generated person + if ( !(IS_MERC_BODY_TYPE( pCiv )) || !(pCiv->ubProfile == NO_PROFILE) ) + { + return; + } + // only enemies and militia taunt + if( ( !( pCiv->bTeam == ENEMY_TEAM ) && !( pCiv->bTeam == MILITIA_TEAM ) ) + && ( !( pCiv->bTeam == ENEMY_TEAM ) && !( pCiv->bTeam == MILITIA_TEAM ) ) ) + { + return; + } + // only visible enemies taunt (unless set otherwise) + if ( ( pCiv->bVisible == -1 ) && ( gTauntsSettings.fTauntOnlyVisibleEnemies == TRUE ) ) + { + return; + } + // only enemies that are able to speak at the moment can taunt + if ( pCiv->stats.bLife < OKLIFE || pCiv->bCollapsed ) + { + return; + } + // check probability switch(iTauntType) { case TAUNT_FIRE_GUN: - if( Random(100) > gTauntsSettings.ubTauntFireGunChance ) + if( Random(100)+1 > gTauntsSettings.ubTauntFireGunChance ) return; break; case TAUNT_FIRE_LAUNCHER: - if( Random(100) > gTauntsSettings.ubTauntFireLauncherChance ) + if( Random(100)+1 > gTauntsSettings.ubTauntFireLauncherChance ) return; break; - case TAUNT_THROW: - if( Random(100) > gTauntsSettings.ubTauntThrowKnifeChance ) + case TAUNT_ATTACK_BLADE: + if( Random(100)+1 > gTauntsSettings.ubTauntAttackBladeChance) return; break; - case TAUNT_CHARGE_KNIFE: - if( Random(100) > gTauntsSettings.ubTauntChargeKnifeChance ) + case TAUNT_ATTACK_HTH: + if( Random(100)+1 > gTauntsSettings.ubTauntAttackHTHChance ) return; break; - case TAUNT_CHARGE_FISTS: - if( Random(100) > gTauntsSettings.ubTauntChargeFistsChance ) - return; - break; - case TAUNT_STEAL: - if( Random(100) > gTauntsSettings.ubTauntStealChance ) - return; - break; - case TAUNT_RUN_AWAY: - if( Random(100) > gTauntsSettings.ubTauntRunAwayChance) - return; - break; - case TAUNT_SEEK_NOISE: - if( Random(100) > gTauntsSettings.ubTauntSeekNoiseChance ) - return; - break; - case TAUNT_ALERT: - if( Random(100) > gTauntsSettings.ubTauntAlertChance ) - return; - break; - case TAUNT_GOT_HIT: - if( Random(100) > gTauntsSettings.ubTauntGotHitChance ) - return; - break; - case TAUNT_NOTICED_UNSEEN_MERC: - if( Random(100) > gTauntsSettings.ubTauntNoticedUnseenChance ) + + case TAUNT_THROW_KNIFE: + if( Random(100)+1 > gTauntsSettings.ubTauntThrowKnifeChance ) return; break; case TAUNT_THROW_GRENADE: - if( Random(100) > gTauntsSettings.ubTauntThrowGrenadeChance ) + if( Random(100)+1 > gTauntsSettings.ubTauntThrowGrenadeChance ) return; break; + case TAUNT_CHARGE_BLADE: + if( Random(100)+1 > gTauntsSettings.ubTauntChargeKnifeChance ) + return; + break; + case TAUNT_CHARGE_HTH: + if( Random(100)+1 > gTauntsSettings.ubTauntChargeFistsChance ) + return; + break; + + case TAUNT_STEAL: + if( Random(100)+1 > gTauntsSettings.ubTauntStealChance ) + return; + break; + + case TAUNT_RUN_AWAY: + if( Random(100)+1 > gTauntsSettings.ubTauntRunAwayChance) + return; + break; + case TAUNT_SEEK_NOISE: + if( Random(100)+1 > gTauntsSettings.ubTauntSeekNoiseChance ) + return; + break; + case TAUNT_ALERT: + if( Random(100)+1 > gTauntsSettings.ubTauntAlertChance ) + return; + break; + case TAUNT_SUSPICIOUS: + if( Random(100)+1 > gTauntsSettings.ubTauntSuspiciousChance) + return; + break; + + case TAUNT_GOT_HIT: + case TAUNT_GOT_HIT_BLOODLOSS: + case TAUNT_GOT_HIT_EXPLOSION: + case TAUNT_GOT_HIT_FALLROOF: + case TAUNT_GOT_HIT_GAS: + case TAUNT_GOT_HIT_GUNFIRE: + case TAUNT_GOT_HIT_HTH: + case TAUNT_GOT_HIT_BLADE: + case TAUNT_GOT_HIT_OBJECT: + case TAUNT_GOT_HIT_STRUCTURE_EXPLOSION: + case TAUNT_GOT_HIT_TENTACLES: + case TAUNT_GOT_HIT_THROWING_KNIFE: + if( Random(100)+1 > gTauntsSettings.ubTauntGotHitChance ) + return; + break; + + case TAUNT_GOT_BLINDED: + case TAUNT_GOT_DEAFENED: + if( Random(100)+1 > gTauntsSettings.ubTauntGotDeafenedBlindedChance) + return; + break; + + case TAUNT_GOT_ROBBED: + if( Random(100)+1 > gTauntsSettings.ubTauntGotRobbedChance) + return; + break; + case TAUNT_GOT_MISSED: - if( Random(100) > gTauntsSettings.ubTauntGotMissedChance ) + case TAUNT_GOT_MISSED_GUNFIRE: + case TAUNT_GOT_MISSED_BLADE: + case TAUNT_GOT_MISSED_HTH: + case TAUNT_GOT_MISSED_THROWING_KNIFE: + if( Random(100)+1 > gTauntsSettings.ubTauntGotMissedChance ) return; break; + + case TAUNT_HIT: + case TAUNT_HIT_GUNFIRE: + case TAUNT_HIT_BLADE: + case TAUNT_HIT_HTH: + case TAUNT_HIT_THROWING_KNIFE: + if( Random(100)+1 > gTauntsSettings.ubTauntHitChance ) + return; + break; + + case TAUNT_KILL: + case TAUNT_KILL_GUNFIRE: + case TAUNT_KILL_BLADE: + case TAUNT_KILL_HTH: + case TAUNT_KILL_THROWING_KNIFE: + if( Random(100)+1 > gTauntsSettings.ubTauntKillChance ) + return; + break; + + case TAUNT_HEAD_POP: + if( Random(100)+1 > gTauntsSettings.ubTauntHeadPopChance ) + return; + break; + + case TAUNT_MISS: + case TAUNT_MISS_GUNFIRE: + case TAUNT_MISS_BLADE: + case TAUNT_MISS_HTH: + case TAUNT_MISS_THROWING_KNIFE: + if( Random(100)+1 > gTauntsSettings.ubTauntMissChance ) + return; + break; + + case TAUNT_OUT_OF_AMMO: + if( Random(100)+1 > gTauntsSettings.ubTauntOutOfAmmoChance ) + return; + break; + case TAUNT_RELOAD: + if( Random(100)+1 > gTauntsSettings.ubTauntReloadChance ) + return; + break; + + case TAUNT_NOTICED_UNSEEN: + if( Random(100)+1 > gTauntsSettings.ubTauntNoticedUnseenChance ) + return; + break; + case TAUNT_SAY_HI: + if( Random(100)+1 > gTauntsSettings.ubTauntSayHiChance ) + return; + break; + case TAUNT_INFORM_ABOUT: + if( Random(100)+1 > gTauntsSettings.ubTauntInformAboutChance ) + return; + break; + + case TAUNT_R_1ST_ENEMY_DETECTED: + case TAUNT_R_ENEMY_DETECTED: + case TAUNT_R_MULTIPLE_ENEMIES: + case TAUNT_R_BULLET_FLEW_BY: + case TAUNT_R_UNDER_HEAVY_FIRE: + if( Random(100)+1 > gTauntsSettings.ubRiposteChance) + return; + break; + default: break; } + StartEnemyTaunt( pCiv, iTauntType, pTarget ); + } // SANDRO - soldier taunts void StartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget ) { - INT16 sX, sY; - UINT8 ubEntryID = 0; - INT16 sScreenX, sScreenY; UINT16 iTauntNumber; - CHAR16 sTauntText[320]; - VIDEO_OVERLAY_DESC VideoOverlayDesc; + CHAR16 sTauntText[320]; CHAR16 gzTauntQuote[ 320 ]; - CHAR pFileName[320] = "NPCData\\TauntsEdt\\"; TAUNT_VALUES zApplicableTaunts[1024]; UINT16 iApplicableTaunts = 0; BOOLEAN fApplicableAttitude[6]; @@ -1137,7 +1270,7 @@ void StartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget ) } // anv: check all taunts, and remember those applicable - for(UINT16 i=1; iaiData.bAttitude ) @@ -1171,6 +1304,7 @@ void StartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget ) // check if situation is ok switch(iTauntType) { + // actions case TAUNT_FIRE_GUN: if( !(zTaunt[ i ].uiFlags & TAUNT_S_FIRE_GUN) ) continue; @@ -1179,16 +1313,40 @@ void StartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget ) if( !(zTaunt[ i ].uiFlags & TAUNT_S_FIRE_LAUNCHER) ) continue; break; - case TAUNT_THROW: + case TAUNT_ATTACK_BLADE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_ATTACK_BLADE) ) + continue; + break; + case TAUNT_ATTACK_HTH: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_ATTACK_HTH) ) + continue; + break; + + case TAUNT_THROW_KNIFE: if( !(zTaunt[ i ].uiFlags & TAUNT_S_THROW_KNIFE) ) continue; break; - case TAUNT_CHARGE_KNIFE: - if( !(zTaunt[ i ].uiFlags & TAUNT_S_CHARGE_KNIFE) ) + case TAUNT_THROW_GRENADE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_THROW_GRENADE) ) continue; break; - case TAUNT_CHARGE_FISTS: - if( !(zTaunt[ i ].uiFlags & TAUNT_S_CHARGE_FISTS) ) + + case TAUNT_OUT_OF_AMMO: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_OUT_OF_AMMO) ) + continue; + break; + case TAUNT_RELOAD: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_RELOAD) ) + continue; + break; + + // AI routines + case TAUNT_CHARGE_BLADE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_CHARGE_BLADE) ) + continue; + break; + case TAUNT_CHARGE_HTH: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_CHARGE_HTH) ) continue; break; case TAUNT_STEAL: @@ -1207,24 +1365,198 @@ void StartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget ) if( !(zTaunt[ i ].uiFlags & TAUNT_S_ALERT) ) continue; break; + case TAUNT_SUSPICIOUS: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_SUSPICIOUS) ) + continue; + break; + case TAUNT_NOTICED_UNSEEN: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_NOTICED_UNSEEN) ) + continue; + break; + case TAUNT_SAY_HI: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_SAY_HI) ) + continue; + break; + case TAUNT_INFORM_ABOUT: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_INFORM_ABOUT) ) + continue; + break; + + // got_hit_xxx case TAUNT_GOT_HIT: if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_HIT) ) continue; break; - case TAUNT_NOTICED_UNSEEN_MERC: - if( !(zTaunt[ i ].uiFlags & TAUNT_S_NOTICED_UNSEEN) ) + case TAUNT_GOT_HIT_GUNFIRE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_HIT_GUNFIRE) ) continue; break; - case TAUNT_THROW_GRENADE: - if( !(zTaunt[ i ].uiFlags & TAUNT_S_THROW_GRENADE) ) + case TAUNT_GOT_HIT_BLADE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_HIT_BLADE) ) continue; break; + case TAUNT_GOT_HIT_HTH: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_HIT_HTH) ) + continue; + break; + case TAUNT_GOT_HIT_FALLROOF: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_HIT_FALLROOF) ) + continue; + break; + case TAUNT_GOT_HIT_BLOODLOSS: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_HIT_BLOODLOSS) ) + continue; + break; + case TAUNT_GOT_HIT_EXPLOSION: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_HIT_EXPLOSION) ) + continue; + break; + case TAUNT_GOT_HIT_GAS: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_HIT_GAS) ) + continue; + break; + case TAUNT_GOT_HIT_TENTACLES: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_HIT_TENTACLES) ) + continue; + break; + case TAUNT_GOT_HIT_STRUCTURE_EXPLOSION: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_HIT_STRUCTURE_EXPLOSION) ) + continue; + break; + case TAUNT_GOT_HIT_OBJECT: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_HIT_OBJECT) ) + continue; + break; + case TAUNT_GOT_HIT_THROWING_KNIFE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_HIT) ) + continue; + break; + + case TAUNT_GOT_DEAFENED: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_DEAFENED) ) + continue; + break; + case TAUNT_GOT_BLINDED: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_BLINDED) ) + continue; + break; + + // got_missed_xxx case TAUNT_GOT_MISSED: if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_MISSED) ) continue; break; + case TAUNT_GOT_MISSED_GUNFIRE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_MISSED_GUNFIRE) ) + continue; + break; + case TAUNT_GOT_MISSED_BLADE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_MISSED_BLADE) ) + continue; + break; + case TAUNT_GOT_MISSED_HTH: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_MISSED_HTH) ) + continue; + break; + case TAUNT_GOT_MISSED_THROWING_KNIFE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_GOT_MISSED_THROWING_KNIFE) ) + continue; + break; + + // hit_xxx + case TAUNT_HIT: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_HIT) ) + continue; + break; + case TAUNT_HIT_GUNFIRE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_HIT_GUNFIRE) ) + continue; + break; + case TAUNT_HIT_BLADE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_HIT_BLADE) ) + continue; + break; + case TAUNT_HIT_HTH: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_HIT_HTH) ) + continue; + break; + case TAUNT_HIT_THROWING_KNIFE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_HIT_THROWING_KNIFE) ) + continue; + break; + + // kill_xxx + case TAUNT_KILL: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_KILL) ) + continue; + break; + case TAUNT_KILL_GUNFIRE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_KILL_GUNFIRE) ) + continue; + break; + case TAUNT_KILL_BLADE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_KILL_BLADE) ) + continue; + break; + case TAUNT_KILL_HTH: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_KILL_HTH) ) + continue; + break; + case TAUNT_KILL_THROWING_KNIFE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_KILL_THROWING_KNIFE) ) + continue; + break; + case TAUNT_HEAD_POP: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_HEAD_POP) ) + continue; + break; + + // miss_xxx + case TAUNT_MISS: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_MISS) ) + continue; + break; + case TAUNT_MISS_GUNFIRE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_MISS_GUNFIRE) ) + continue; + break; + case TAUNT_MISS_BLADE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_MISS_BLADE) ) + continue; + break; + case TAUNT_MISS_HTH: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_MISS_HTH) ) + continue; + break; + case TAUNT_MISS_THROWING_KNIFE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_MISS_THROWING_KNIFE) ) + continue; + break; + + // ripostes to merc quotes + case TAUNT_R_BULLET_FLEW_BY: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_R_BULLET_FLEW_BY) ) + continue; + break; + case TAUNT_R_UNDER_HEAVY_FIRE: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_R_UNDER_HEAVY_FIRE) ) + continue; + break; + case TAUNT_R_ENEMY_DETECTED: + if( !(zTaunt[ i ].uiFlags & TAUNT_S_R_ENEMY_DETECTED) ) + continue; + break; + case TAUNT_R_1ST_ENEMY_DETECTED: + if( !(zTaunt[ i ].uiFlags2 & TAUNT_S_R_1ST_ENEMY_DETECTED) ) + continue; + break; + case TAUNT_R_MULTIPLE_ENEMIES: + if( !(zTaunt[ i ].uiFlags2 & TAUNT_S_R_MULTIPLE_ENEMIES) ) + continue; + break; + default: - return; + continue; break; } @@ -1232,37 +1564,37 @@ void StartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget ) switch( pCiv->ubSoldierClass ) { case SOLDIER_CLASS_ADMINISTRATOR: - if( !(zTaunt[ i ].uiFlags & TAUNT_C_ADMIN) ) + if( !(zTaunt[ i ].uiFlags2 & TAUNT_C_ADMIN) ) continue; if( (zTaunt[ i ].value[TAUNT_PROFILE_ADMIN] != -1 ) && !(zTaunt[ i ].value[TAUNT_PROFILE_ADMIN] == pCiv->usSoldierProfile ) ) continue; break; case SOLDIER_CLASS_ARMY: - if( !(zTaunt[ i ].uiFlags & TAUNT_C_ARMY) ) + if( !(zTaunt[ i ].uiFlags2 & TAUNT_C_ARMY) ) continue; if( (zTaunt[ i ].value[TAUNT_PROFILE_ARMY] != -1 ) && !(zTaunt[ i ].value[TAUNT_PROFILE_ARMY] == pCiv->usSoldierProfile ) ) continue; break; case SOLDIER_CLASS_ELITE: - if( !(zTaunt[ i ].uiFlags & TAUNT_C_ELITE) ) + if( !(zTaunt[ i ].uiFlags2 & TAUNT_C_ELITE) ) continue; if( (zTaunt[ i ].value[TAUNT_PROFILE_ELITE] != -1 ) && !(zTaunt[ i ].value[TAUNT_PROFILE_ELITE] == pCiv->usSoldierProfile ) ) continue; break; case SOLDIER_CLASS_GREEN_MILITIA: - if( !(zTaunt[ i ].uiFlags & TAUNT_C_GREEN) ) + if( !(zTaunt[ i ].uiFlags2 & TAUNT_C_GREEN) ) continue; if( (zTaunt[ i ].value[TAUNT_PROFILE_GREEN] != -1 ) && !( zTaunt[ i ].value[TAUNT_PROFILE_GREEN] == pCiv->usSoldierProfile ) ) continue; break; case SOLDIER_CLASS_REG_MILITIA: - if( !(zTaunt[ i ].uiFlags & TAUNT_C_REGULAR) ) + if( !(zTaunt[ i ].uiFlags2 & TAUNT_C_REGULAR) ) continue; if( (zTaunt[ i ].value[TAUNT_PROFILE_ARMY] != -1 ) && !(zTaunt[ i ].value[TAUNT_PROFILE_ARMY] == pCiv->usSoldierProfile ) ) continue; break; case SOLDIER_CLASS_ELITE_MILITIA: - if( !(zTaunt[ i ].uiFlags & TAUNT_C_VETERAN) ) + if( !(zTaunt[ i ].uiFlags2 & TAUNT_C_VETERAN) ) continue; if( (zTaunt[ i ].value[TAUNT_PROFILE_ARMY] != -1 ) && !(zTaunt[ i ].value[TAUNT_PROFILE_ARMY] == pCiv->usSoldierProfile ) ) continue; @@ -1278,11 +1610,11 @@ void StartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget ) case REGMALE: case BIGMALE: case STOCKYMALE: - if( !(zTaunt[ i ].uiFlags & TAUNT_G_MALE) ) + if( !(zTaunt[ i ].uiFlags2 & TAUNT_G_MALE) ) continue; break; case REGFEMALE: - if( !(zTaunt[ i ].uiFlags & TAUNT_G_FEMALE) ) + if( !(zTaunt[ i ].uiFlags2 & TAUNT_G_FEMALE) ) continue; break; default: @@ -1353,9 +1685,9 @@ void StartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget ) if( pCiv->stats.bExpLevel <= zTaunt[ i ].value[TAUNT_EXP_LEVEL_GT] ) continue; } - if( zTaunt[ i ].value[TAUNT_TARGET_EXP_LEVEL_LT] != -1 ) + if( zTaunt[ i ].value[TAUNT_EXP_LEVEL_LT] != -1 ) { - if( pCiv->stats.bExpLevel >= zTaunt[ i ].value[TAUNT_TARGET_EXP_LEVEL_LT] ) + if( pCiv->stats.bExpLevel >= zTaunt[ i ].value[TAUNT_EXP_LEVEL_LT] ) continue; } @@ -1386,6 +1718,12 @@ void StartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget ) // target limitations if( pTarget != NULL ) { + // target should be zombie + if( zTaunt[ i ].uiFlags2 & TAUNT_T_ZOMBIE ) + { + if( pTarget->IsZombie() == FALSE ) + continue; + } // target merc profile if( zTaunt[ i ].value[TAUNT_TARGET_MERC_PROFILE] != -1 ) { @@ -1404,11 +1742,11 @@ void StartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget ) case REGMALE: case BIGMALE: case STOCKYMALE: - if( !(zTaunt[ i ].uiFlags & TAUNT_T_MALE) ) + if( !(zTaunt[ i ].uiFlags2 & TAUNT_T_MALE) ) continue; break; case REGFEMALE: - if( !(zTaunt[ i ].uiFlags & TAUNT_T_FEMALE) ) + if( !(zTaunt[ i ].uiFlags2 & TAUNT_T_FEMALE) ) continue; break; default: @@ -1548,7 +1886,8 @@ void StartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget ) ( zTaunt[ i ].value[TAUNT_TARGET_EXP_LEVEL_LT] != -1 ) || ( zTaunt[ i ].value[TAUNT_TARGET_MORALE_GT] != -1 ) || ( zTaunt[ i ].value[TAUNT_TARGET_MORALE_LT] != -1 ) || - ( zTaunt[ i ].value[TAUNT_TARGET_TYPE] != -1 ) ) + ( zTaunt[ i ].value[TAUNT_TARGET_TYPE] != -1 ) || + ( zTaunt[ i ].uiFlags2 & TAUNT_T_ZOMBIE ) ) continue; } @@ -1567,18 +1906,45 @@ void StartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget ) return; } - // Determine location... - // Get location of civ on screen..... - GetSoldierScreenPos( pCiv, &sScreenX, &sScreenY ); - sX = sScreenX; - sY = sScreenY; - #ifdef TAIWANESE swprintf( gzTauntQuote, L"%s", sTauntText ); #else swprintf( gzTauntQuote, L"\"%s\"", sTauntText ); #endif + if( gTauntsSettings.fTauntMakeNoise == TRUE ) + MakeNoise( pCiv->ubID, pCiv->sGridNo, pCiv->pathing.bLevel, pCiv->bOverTerrainType, gTauntsSettings.sVolume, NOISE_VOICE, gzTauntQuote ); + else + { + if(gTauntsSettings.fTauntShowPopupBox == TRUE) + { + if( gbPublicOpplist[gbPlayerNum][pCiv->ubID] == SEEN_CURRENTLY || gTauntsSettings.fTauntAlwaysShowPopupBox == TRUE ) + { + ShowTauntPopupBox( pCiv, gzTauntQuote ); + } + } + if(gTauntsSettings.fTauntShowInLog == TRUE) + { + if( gbPublicOpplist[gbPlayerNum][pCiv->ubID] == SEEN_CURRENTLY || gTauntsSettings.fTauntAlwaysShowInLog == TRUE ) + { + ScreenMsg( FONT_GRAY2, MSG_INTERFACE, L"%s: %s", pCiv->GetName(), gzTauntQuote ); + } + } + } +} + +void ShowTauntPopupBox( SOLDIERTYPE *pCiv, STR16 gzTauntQuote ) +{ + INT16 sX, sY; + INT16 sScreenX, sScreenY; + VIDEO_OVERLAY_DESC VideoOverlayDesc; + + // Determine location... + // Get location of civ on screen..... + GetSoldierScreenPos( pCiv, &sScreenX, &sScreenY ); + sX = sScreenX; + sY = sScreenY; + // Create video oeverlay.... memset( &VideoOverlayDesc, 0, sizeof( VIDEO_OVERLAY_DESC ) ); @@ -1625,7 +1991,6 @@ void StartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget ) gCivQuoteData.iVideoOverlay = RegisterVideoOverlay( 0, &VideoOverlayDesc ); - //Define main region MSYS_DefineRegion( &(gCivQuoteData.MouseRegion), VideoOverlayDesc.sLeft, VideoOverlayDesc.sTop, VideoOverlayDesc.sRight, VideoOverlayDesc.sBottom, MSYS_PRIORITY_HIGHEST, CURSOR_NORMAL, MSYS_NO_CALLBACK, QuoteOverlayClickCallback ); @@ -1640,11 +2005,4 @@ void StartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget ) gCivQuoteData.uiDelayTime = min( gTauntsSettings.sMaxDelay , max( gTauntsSettings.sMinDelay, FindDelayForString( gzTauntQuote ) + gTauntsSettings.sModDelay ) ); gCivQuoteData.pCiv = pCiv; - - if(gTauntsSettings.fTauntShowInLog == TRUE) - { - CHAR16 LogMsg[320]; - swprintf( LogMsg, L"%s: %s", pCiv->GetName(), gzTauntQuote ); - ScreenMsg( FONT_GRAY2, MSG_INTERFACE, LogMsg ); - } } \ No newline at end of file diff --git a/Tactical/Civ Quotes.h b/Tactical/Civ Quotes.h index 4cf924210..2770c4cf5 100644 --- a/Tactical/Civ Quotes.h +++ b/Tactical/Civ Quotes.h @@ -76,23 +76,91 @@ enum enum //enemy taunts - SANDRO { + // actions TAUNT_FIRE_GUN, TAUNT_FIRE_LAUNCHER, - TAUNT_THROW, - TAUNT_CHARGE_KNIFE, - TAUNT_CHARGE_FISTS, + TAUNT_ATTACK_BLADE, + TAUNT_ATTACK_HTH, + + TAUNT_THROW_KNIFE, + TAUNT_THROW_GRENADE, + + TAUNT_OUT_OF_AMMO, + TAUNT_RELOAD, + TAUNT_STEAL, + + // AI routines + TAUNT_CHARGE_BLADE, + TAUNT_CHARGE_HTH, TAUNT_RUN_AWAY, TAUNT_SEEK_NOISE, TAUNT_ALERT, + TAUNT_SUSPICIOUS, + TAUNT_NOTICED_UNSEEN, + TAUNT_SAY_HI, + TAUNT_INFORM_ABOUT, + + // got_hit_xxx TAUNT_GOT_HIT, - TAUNT_NOTICED_UNSEEN_MERC, - TAUNT_THROW_GRENADE, + TAUNT_GOT_HIT_GUNFIRE, + TAUNT_GOT_HIT_BLADE, + TAUNT_GOT_HIT_HTH, + TAUNT_GOT_HIT_FALLROOF, + TAUNT_GOT_HIT_BLOODLOSS, + TAUNT_GOT_HIT_EXPLOSION, + TAUNT_GOT_HIT_GAS, + TAUNT_GOT_HIT_TENTACLES, + TAUNT_GOT_HIT_STRUCTURE_EXPLOSION, + TAUNT_GOT_HIT_OBJECT, + TAUNT_GOT_HIT_THROWING_KNIFE, + + TAUNT_GOT_DEAFENED, + TAUNT_GOT_BLINDED, + + TAUNT_GOT_ROBBED, + + // got_missed_xxx TAUNT_GOT_MISSED, + TAUNT_GOT_MISSED_GUNFIRE, + TAUNT_GOT_MISSED_BLADE, + TAUNT_GOT_MISSED_HTH, + TAUNT_GOT_MISSED_THROWING_KNIFE, + + // hit_xxx + TAUNT_HIT, + TAUNT_HIT_GUNFIRE, + TAUNT_HIT_BLADE, + TAUNT_HIT_HTH, + TAUNT_HIT_EXPLOSION, + TAUNT_HIT_THROWING_KNIFE, + + // kill_xxx + TAUNT_KILL, + TAUNT_KILL_GUNFIRE, + TAUNT_KILL_BLADE, + TAUNT_KILL_HTH, + TAUNT_KILL_THROWING_KNIFE, + TAUNT_HEAD_POP, + + // miss_xxx + TAUNT_MISS, + TAUNT_MISS_GUNFIRE, + TAUNT_MISS_BLADE, + TAUNT_MISS_HTH, + TAUNT_MISS_THROWING_KNIFE, + + // ripostes to merc quotes + TAUNT_R_BULLET_FLEW_BY, + TAUNT_R_UNDER_HEAVY_FIRE, + TAUNT_R_ENEMY_DETECTED, + TAUNT_R_1ST_ENEMY_DETECTED, + TAUNT_R_MULTIPLE_ENEMIES, }; void PossiblyStartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget = NULL ); void StartEnemyTaunt( SOLDIERTYPE *pCiv, INT8 iTauntType, SOLDIERTYPE *pTarget = NULL ); //enemy taunts - SANDRO // anv: added pTarget argument +void ShowTauntPopupBox( SOLDIERTYPE *pCiv, STR16 gzTauntQuote ); void InitCivQuoteSystem( ); diff --git a/Tactical/Dialogue Control.cpp b/Tactical/Dialogue Control.cpp index 6a63fc03c..e385ec95a 100644 --- a/Tactical/Dialogue Control.cpp +++ b/Tactical/Dialogue Control.cpp @@ -2683,6 +2683,48 @@ void HandleDialogueEnd( FACETYPE *pFace ) fTextBoxMouseRegionCreated = FALSE; } + // anv: after merc finishes his quote, we want enemy to answer + if ( gbUIHandlerID == DIALOGUE_TACTICAL_UI ) + { + SOLDIERTYPE *pSoldier = FindSoldierByProfileID( gTacticalStatus.ubLastQuoteProfileNUm, FALSE ); + UINT8 ubSeenEnemies[ MAX_NUM_SOLDIERS ]; + UINT8 ubSeenEnemiesCnt = 0; + switch( gTacticalStatus.ubLastQuoteSaid ) + { + case QUOTE_SEE_ENEMY: + case QUOTE_SEE_ENEMY_VARIATION: + case QUOTE_IN_TROUBLE_SLASH_IN_BATTLE: + // select random enemy, who we see, who sees us and isn't deaf + for(UINT8 cnt = gTacticalStatus.Team[ ENEMY_TEAM ].bFirstID; cnt < gTacticalStatus.Team[ ENEMY_TEAM ].bLastID ; cnt++ ) + { + if( MercPtrs[cnt] != NULL && MercPtrs[cnt]->aiData.bOppList[pSoldier->ubID] == SEEN_CURRENTLY + && MercPtrs[pSoldier->ubID]->aiData.bOppList[cnt] == SEEN_CURRENTLY && !( MercPtrs[cnt]->bDeafenedCounter > 0 ) ) + { + ubSeenEnemies[ubSeenEnemiesCnt] = cnt; + ubSeenEnemiesCnt++; + } + } + if( ubSeenEnemiesCnt > 0 ) + { + if( gTacticalStatus.ubLastQuoteSaid == QUOTE_SEE_ENEMY ) + PossiblyStartEnemyTaunt( MercPtrs[ubSeenEnemies[ Random(ubSeenEnemiesCnt) ]], TAUNT_R_ENEMY_DETECTED, FindSoldierByProfileID( gTacticalStatus.ubLastQuoteProfileNUm, FALSE ) ); + else if( gTacticalStatus.ubLastQuoteSaid == QUOTE_SEE_ENEMY_VARIATION ) + PossiblyStartEnemyTaunt( MercPtrs[ubSeenEnemies[ Random(ubSeenEnemiesCnt) ]], TAUNT_R_1ST_ENEMY_DETECTED, FindSoldierByProfileID( gTacticalStatus.ubLastQuoteProfileNUm, FALSE ) ); + else if( gTacticalStatus.ubLastQuoteSaid == QUOTE_IN_TROUBLE_SLASH_IN_BATTLE ) + PossiblyStartEnemyTaunt( MercPtrs[ubSeenEnemies[ Random(ubSeenEnemiesCnt) ]], TAUNT_R_MULTIPLE_ENEMIES, FindSoldierByProfileID( gTacticalStatus.ubLastQuoteProfileNUm, FALSE ) ); + } + break; + case QUOTE_CLOSE_CALL: + PossiblyStartEnemyTaunt( MercPtrs[pSoldier->ubPreviousAttackerID], TAUNT_R_BULLET_FLEW_BY, FindSoldierByProfileID( gTacticalStatus.ubLastQuoteProfileNUm, FALSE ) ); + break; + case QUOTE_UNDER_HEAVY_FIRE: + PossiblyStartEnemyTaunt( MercPtrs[pSoldier->ubPreviousAttackerID], TAUNT_R_UNDER_HEAVY_FIRE, FindSoldierByProfileID( gTacticalStatus.ubLastQuoteProfileNUm, FALSE ) ); + break; + default: + break; + } + } + break; case DIALOGUE_NPC_UI: diff --git a/Tactical/Interface.h b/Tactical/Interface.h index 4a15919b1..9a8f522c1 100644 --- a/Tactical/Interface.h +++ b/Tactical/Interface.h @@ -265,6 +265,7 @@ typedef struct UINT16 uiIndex; CHAR16 szText[320]; UINT64 uiFlags; + UINT64 uiFlags2; INT16 value[TAUNT_MAX]; } TAUNT_VALUES; diff --git a/Tactical/Soldier Ani.cpp b/Tactical/Soldier Ani.cpp index 06084d1f6..9844cc478 100644 --- a/Tactical/Soldier Ani.cpp +++ b/Tactical/Soldier Ani.cpp @@ -63,6 +63,9 @@ #include "Food.h" #endif +// anv: for enemy taunts +#include "Civ Quotes.h" + //forward declarations of common classes to eliminate includes class OBJECTTYPE; class SOLDIERTYPE; @@ -3748,7 +3751,33 @@ BOOLEAN HandleSoldierDeath( SOLDIERTYPE *pSoldier , BOOLEAN *pfMadeCorpse ) else if(pSoldier->bTeam <6 && ((gTacticalStatus.ubTopMessageType == PLAYER_TURN_MESSAGE) || (gTacticalStatus.ubTopMessageType == PLAYER_INTERRUPT_MESSAGE))) send_death(pSoldier); } - + + // anv: enemy taunts after kill + SOLDIERTYPE *pKillerSoldier = NULL; + if(pSoldier->ubAttackerID != NOBODY) + { + pKillerSoldier = MercPtrs[pSoldier->ubAttackerID]; + } + else if(pSoldier->ubPreviousAttackerID != NOBODY) + { + pKillerSoldier = MercPtrs[pSoldier->ubPreviousAttackerID]; + } + if(pKillerSoldier != NULL) + { + if( pSoldier->usAnimState == JFK_HITDEATH ) + PossiblyStartEnemyTaunt( pKillerSoldier, TAUNT_HEAD_POP, pSoldier ); + else if( Item[pKillerSoldier->usAttackingWeapon].usItemClass & IC_GUN ) + PossiblyStartEnemyTaunt( pKillerSoldier, TAUNT_KILL_GUNFIRE, pSoldier ); + else if( Item[pKillerSoldier->usAttackingWeapon].usItemClass & IC_BLADE ) + PossiblyStartEnemyTaunt( pKillerSoldier, TAUNT_KILL_BLADE, pSoldier ); + else if( Item[pKillerSoldier->usAttackingWeapon].usItemClass & IC_PUNCH ) + PossiblyStartEnemyTaunt( pKillerSoldier, TAUNT_KILL_HTH, pSoldier ); + else if( Item[pKillerSoldier->usAttackingWeapon].usItemClass & IC_THROWING_KNIFE ) + PossiblyStartEnemyTaunt( pKillerSoldier, TAUNT_KILL_THROWING_KNIFE, pSoldier ); + else + PossiblyStartEnemyTaunt( pKillerSoldier, TAUNT_KILL, pSoldier ); + } + // Cancel services here... pSoldier->ReceivingSoldierCancelServices( ); pSoldier->GivingSoldierCancelServices( ); diff --git a/Tactical/Soldier Control.cpp b/Tactical/Soldier Control.cpp index fd3de9b7c..c735594e3 100644 --- a/Tactical/Soldier Control.cpp +++ b/Tactical/Soldier Control.cpp @@ -5917,24 +5917,30 @@ void SOLDIERTYPE::EVENT_SoldierGotHit( UINT16 usWeaponIndex, INT16 sDamage, INT1 } } DecayIndividualOpplist( this ); + PossiblyStartEnemyTaunt( this, TAUNT_S_GOT_BLINDED, MercPtrs[ubAttackerID]); + PossiblyStartEnemyTaunt( this, TAUNT_S_GOT_DEAFENED, MercPtrs[ubAttackerID]); break; case FIRE_WEAPON_BLINDED: + PossiblyStartEnemyTaunt( this, TAUNT_S_GOT_BLINDED, MercPtrs[ubAttackerID]); break; case FIRE_WEAPON_DEAFENED: - //ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, L"Soldier is deafened" ); + //ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_INTERFACE, L"Soldier is deafened" ); this->bDeafenedCounter = bDeafValue; + PossiblyStartEnemyTaunt( this, TAUNT_S_GOT_DEAFENED, MercPtrs[ubAttackerID]); break; }; if ( usWeaponIndex == STRUCTURE_EXPLOSION ) { ubReason = TAKE_DAMAGE_STRUCTURE_EXPLOSION; + PossiblyStartEnemyTaunt( this, TAUNT_S_GOT_HIT_STRUCTURE_EXPLOSION, MercPtrs[ubAttackerID]); } else { ubReason = TAKE_DAMAGE_EXPLOSION; + PossiblyStartEnemyTaunt( this, TAUNT_S_GOT_HIT_EXPLOSION, MercPtrs[ubAttackerID]); } } else @@ -6260,23 +6266,42 @@ void SOLDIERTYPE::EVENT_SoldierGotHit( UINT16 usWeaponIndex, INT16 sDamage, INT1 if ( Item[ usWeaponIndex ].usItemClass & ( IC_GUN | IC_THROWING_KNIFE ) ) { SoldierGotHitGunFire( this, usWeaponIndex, sDamage, bDirection, sRange, ubAttackerID, ubSpecial, ubHitLocation ); + if( Item[ usWeaponIndex ].usItemClass & IC_GUN ) + { + PossiblyStartEnemyTaunt( this, TAUNT_GOT_HIT_GUNFIRE, MercPtrs[ubAttackerID] ); + PossiblyStartEnemyTaunt( MercPtrs[ubAttackerID], TAUNT_HIT_GUNFIRE, this ); + } + else + { + PossiblyStartEnemyTaunt( this, TAUNT_GOT_HIT_THROWING_KNIFE, MercPtrs[ubAttackerID] ); + PossiblyStartEnemyTaunt( MercPtrs[ubAttackerID], TAUNT_HIT_THROWING_KNIFE, this ); + } } if ( Item[ usWeaponIndex ].usItemClass & IC_BLADE ) { SoldierGotHitBlade( this, usWeaponIndex, sDamage, bDirection, sRange, ubAttackerID, ubSpecial, ubHitLocation ); + // anv: taunts are called from UseBlade() } // marke setting ammo explosions included here with 3rd 'or' including ubReason if ( Item[ usWeaponIndex ].usItemClass & IC_EXPLOSV || Item[ usWeaponIndex ].usItemClass & IC_TENTACLES || ubReason == TAKE_DAMAGE_EXPLOSION ) { SoldierGotHitExplosion( this, usWeaponIndex, sDamage, bDirection, sRange, ubAttackerID, ubSpecial, ubHitLocation ); + if( Item[ usWeaponIndex ].usItemClass & IC_EXPLOSV || ubReason == TAKE_DAMAGE_EXPLOSION ) + { + PossiblyStartEnemyTaunt( this, TAUNT_GOT_HIT_EXPLOSION, MercPtrs[ubAttackerID] ); + //PossiblyStartEnemyTaunt( MercPtrs[ubAttackerID], TAUNT_HIT_EXPLOSION, this ); + } + else if(Item[ usWeaponIndex ].usItemClass & IC_TENTACLES) + { + PossiblyStartEnemyTaunt( this, TAUNT_GOT_HIT_TENTACLES, MercPtrs[ubAttackerID] ); + //PossiblyStartEnemyTaunt( MercPtrs[ubAttackerID], TAUNT_HIT_TENTACLES, this ); + } } if ( Item[ usWeaponIndex ].usItemClass & IC_PUNCH ) { SoldierGotHitPunch( this, usWeaponIndex, sDamage, bDirection, sRange, ubAttackerID, ubSpecial, ubHitLocation ); + // anv: taunts are called from UseHandToHand() } - if( ( this->bTeam == ENEMY_TEAM ) || ( this->bTeam == MILITIA_TEAM ) ) - PossiblyStartEnemyTaunt( this, TAUNT_GOT_HIT, MercPtrs[ubAttackerID]); - } UINT8 CalcScreamVolume( SOLDIERTYPE * pSoldier, UINT8 ubCombinedLoss ) @@ -10115,6 +10140,21 @@ UINT8 SOLDIERTYPE::SoldierTakeDamage( INT8 bHeight, INT16 sLifeDeduct, INT16 sPo } } #endif + switch(ubReason) + { + case TAKE_DAMAGE_FALLROOF: + PossiblyStartEnemyTaunt( this, TAUNT_GOT_HIT_FALLROOF ); + break; + case TAKE_DAMAGE_BLOODLOSS: + PossiblyStartEnemyTaunt( this, TAUNT_GOT_HIT_BLOODLOSS ); + break; + case TAKE_DAMAGE_GAS: + PossiblyStartEnemyTaunt( this, TAUNT_GOT_HIT_GAS ); + break; + default: + break; + } + return( ubCombinedLoss ); } diff --git a/Tactical/Soldier Control.h b/Tactical/Soldier Control.h index 9eb4fe7a1..87c716f39 100644 --- a/Tactical/Soldier Control.h +++ b/Tactical/Soldier Control.h @@ -425,43 +425,111 @@ enum #define TAUNT_A_DEFENSIVE 0x0000000000000020 //32 // situations +// actions #define TAUNT_S_FIRE_GUN 0x0000000000000040 //64 #define TAUNT_S_FIRE_LAUNCHER 0x0000000000000080 //128 - -#define TAUNT_S_GOT_HIT 0x0000000000000100 //256 -#define TAUNT_S_GOT_MISSED 0x0000000000000200 //512 //10 +#define TAUNT_S_ATTACK_BLADE 0x0000000000000100 //256 +#define TAUNT_S_ATTACK_HTH 0x0000000000000200 //512 #define TAUNT_S_THROW_KNIFE 0x0000000000000400 //1024 #define TAUNT_S_THROW_GRENADE 0x0000000000000800 //2048 -#define TAUNT_S_CHARGE_KNIFE 0x0000000000001000 //4096 -#define TAUNT_S_CHARGE_FISTS 0x0000000000002000 //8192 -#define TAUNT_S_STEAL 0x0000000000004000 //16384 -#define TAUNT_S_RUN_AWAY 0x0000000000008000 //32768 +#define TAUNT_S_OUT_OF_AMMO 0x0000000000001000 //4096 +#define TAUNT_S_RELOAD 0x0000000000002000 //8192 -#define TAUNT_S_SEEK_NOISE 0x0000000000010000 //65536 -#define TAUNT_S_ALERT 0x0000000000020000 //131072 -#define TAUNT_S_NOTICED_UNSEEN 0x0000000000040000 //262144 +#define TAUNT_S_STEAL 0x0000000000004000 //16384 + +// AI routines +#define TAUNT_S_CHARGE_BLADE 0x0000000000008000 //32768 +#define TAUNT_S_CHARGE_HTH 0x0000000000010000 //65536 +#define TAUNT_S_RUN_AWAY 0x0000000000020000 //131072 +#define TAUNT_S_SEEK_NOISE 0x0000000000040000 //262144 +#define TAUNT_S_ALERT 0x0000000000080000 //... +#define TAUNT_S_SUSPICIOUS 0x0000000000100000 +#define TAUNT_S_NOTICED_UNSEEN 0x0000000000200000 // +#define TAUNT_S_SAY_HI 0x0000000000400000 // +#define TAUNT_S_INFORM_ABOUT 0x0000000000800000 + +// got_hit_xxx +#define TAUNT_S_GOT_HIT 0x0000000001000000 // +#define TAUNT_S_GOT_HIT_GUNFIRE 0x0000000002000000 // +#define TAUNT_S_GOT_HIT_BLADE 0x0000000004000000 // +#define TAUNT_S_GOT_HIT_HTH 0x0000000008000000 // +#define TAUNT_S_GOT_HIT_FALLROOF 0x0000000010000000 // +#define TAUNT_S_GOT_HIT_BLOODLOSS 0x0000000020000000 // +#define TAUNT_S_GOT_HIT_EXPLOSION 0x0000000040000000 // +#define TAUNT_S_GOT_HIT_GAS 0x0000000080000000 // +#define TAUNT_S_GOT_HIT_TENTACLES 0x0000000100000000 // +#define TAUNT_S_GOT_HIT_STRUCTURE_EXPLOSION 0x0000000200000000 // +#define TAUNT_S_GOT_HIT_OBJECT 0x0000000400000000 // +#define TAUNT_S_GOT_HIT_THROWING_KNIFE 0x0000000800000000 // + +#define TAUNT_S_GOT_DEAFENED 0x0000001000000000 // +#define TAUNT_S_GOT_BLINDED 0x0000002000000000 // + +#define TAUNT_S_GOT_ROBBED 0x0000004000000000 // + +// got_missed_xxx +#define TAUNT_S_GOT_MISSED 0x0000008000000000 // +#define TAUNT_S_GOT_MISSED_GUNFIRE 0x0000010000000000 // +#define TAUNT_S_GOT_MISSED_BLADE 0x0000020000000000 // +#define TAUNT_S_GOT_MISSED_HTH 0x0000040000000000 // +#define TAUNT_S_GOT_MISSED_THROWING_KNIFE 0x0000080000000000 // + +// hit_xxx +#define TAUNT_S_HIT 0x0000100000000000 // +#define TAUNT_S_HIT_GUNFIRE 0x0000200000000000 // +#define TAUNT_S_HIT_BLADE 0x0000400000000000 // +#define TAUNT_S_HIT_HTH 0x0000800000000000 // +#define TAUNT_S_HIT_EXPLOSION 0x0001000000000000 // +#define TAUNT_S_HIT_THROWING_KNIFE 0x0002000000000000 // + +// kill_xxx +#define TAUNT_S_KILL 0x0004000000000000 // +#define TAUNT_S_KILL_GUNFIRE 0x0008000000000000 // +#define TAUNT_S_KILL_BLADE 0x0010000000000000 // +#define TAUNT_S_KILL_HTH 0x0020000000000000 // +#define TAUNT_S_KILL_THROWING_KNIFE 0x0040000000000000 // +#define TAUNT_S_HEAD_POP 0x0080000000000000 // + +// miss_xxx +#define TAUNT_S_MISS 0x0100000000000000 // +#define TAUNT_S_MISS_GUNFIRE 0x0200000000000000 // +#define TAUNT_S_MISS_BLADE 0x0400000000000000 // +#define TAUNT_S_MISS_HTH 0x0800000000000000 // +#define TAUNT_S_MISS_THROWING_KNIFE 0x1000000000000000 // + +// ripostes to merc quotes +#define TAUNT_S_R_BULLET_FLEW_BY 0x2000000000000000 // +#define TAUNT_S_R_UNDER_HEAVY_FIRE 0x4000000000000000 // +#define TAUNT_S_R_ENEMY_DETECTED 0x8000000000000000 // + +// NEW FLAGS, starting from the beginning (UINT128 is redundant? yeah, right) + +#define TAUNT_S_R_1ST_ENEMY_DETECTED 0x0000000000000001 //1 +#define TAUNT_S_R_MULTIPLE_ENEMIES 0x0000000000000002 //2 // class -#define TAUNT_C_ADMIN 0x0000000000080000 //524288 -//20 -#define TAUNT_C_ARMY 0x0000000000100000 //1048576 -#define TAUNT_C_ELITE 0x0000000000200000 //2097152 -#define TAUNT_C_GREEN 0x0000000000400000 //4194304 -#define TAUNT_C_REGULAR 0x0000000000800000 //8388608 +#define TAUNT_C_ADMIN 0x0000000000000004 //4 +#define TAUNT_C_ARMY 0x0000000000000008 //8 +#define TAUNT_C_ELITE 0x0000000000000010 //16 +#define TAUNT_C_GREEN 0x0000000000000020 //32 +#define TAUNT_C_REGULAR 0x0000000000000040 //64 +#define TAUNT_C_VETERAN 0x0000000000000080 //128 -#define TAUNT_C_VETERAN 0x0000000001000000 //16777216 -#define TAUNT_G_MALE 0x0000000002000000 //33554432 -#define TAUNT_G_FEMALE 0x0000000004000000 //67108864 +// sex +#define TAUNT_G_MALE 0x0000000000000100 //256 +#define TAUNT_G_FEMALE 0x0000000000000200 //512 // target -#define TAUNT_T_MALE 0x0000000008000000 //134217728 +#define TAUNT_T_MALE 0x0000000000000400 //1024 +#define TAUNT_T_FEMALE 0x0000000000000800 //2048 -#define TAUNT_T_FEMALE 0x0000000010000000 //268435456 +#define TAUNT_T_ZOMBIE 0x0000000000001000 //4096 - -#define TAUNT_FLAG_MAX 29 +#define TAUNT_FLAG_1_MAX 64 +#define TAUNT_FLAG_2_MAX 13 +#define TAUNT_FLAG_MAX TAUNT_FLAG_1_MAX + TAUNT_FLAG_2_MAX // Flugente: types of multi-turn actions enum diff --git a/Tactical/Weapons.cpp b/Tactical/Weapons.cpp index 79786ba76..0675267a4 100644 --- a/Tactical/Weapons.cpp +++ b/Tactical/Weapons.cpp @@ -3029,11 +3029,18 @@ BOOLEAN UseBlade( SOLDIERTYPE *pSoldier , INT32 sTargetGridNo ) } } + // anv: taunt on attack + PossiblyStartEnemyTaunt( pSoldier, TAUNT_ATTACK_BLADE, pTargetSoldier ); + // WDS 07/19/2008 - Random number use fix if ( iDiceRoll < iHitChance ) { fGonnaHit = TRUE; + // anv: taunts on hit + PossiblyStartEnemyTaunt( pSoldier, TAUNT_HIT_BLADE, pTargetSoldier ); + PossiblyStartEnemyTaunt( pTargetSoldier, TAUNT_GOT_HIT_BLADE, pSoldier ); + // CALCULATE DAMAGE! // attack HITS, calculate damage (base damage is 1-maximum knife sImpact) iImpact = HTHImpact( pSoldier, pTargetSoldier, (iHitChance - iDiceRoll), TRUE ); @@ -3100,6 +3107,11 @@ BOOLEAN UseBlade( SOLDIERTYPE *pSoldier , INT32 sTargetGridNo ) } else { + // anv: taunts on miss + PossiblyStartEnemyTaunt( pSoldier, TAUNT_MISS_BLADE, pTargetSoldier ); + if( pTargetSoldier->aiData.bOppList[ pSoldier->ubID ] == SEEN_CURRENTLY ) + PossiblyStartEnemyTaunt( pTargetSoldier, TAUNT_GOT_MISSED_BLADE, pSoldier ); + // if it was another team shooting at someone under our control if ( (pSoldier->bTeam != Menptr[ pTargetSoldier->ubID ].bTeam ) ) { @@ -3583,6 +3595,9 @@ BOOLEAN UseHandToHand( SOLDIERTYPE *pSoldier, INT32 sTargetGridNo, BOOLEAN fStea StatChange( pSoldier, DEXTAMT, 3, FALSE ); StatChange( pSoldier, AGILAMT, 3, FALSE ); } + + // anv: enemy taunt on getting robbed + PossiblyStartEnemyTaunt( pTargetSoldier, TAUNT_GOT_ROBBED, pSoldier ); } else { @@ -3613,6 +3628,10 @@ BOOLEAN UseHandToHand( SOLDIERTYPE *pSoldier, INT32 sTargetGridNo, BOOLEAN fStea // DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String("@@@@@@@ Freeing up attacker - steal") ); // #endif // FreeUpAttacker( (UINT8) pSoldier->ubID ); + + // anv: enemy taunt on steal + PossiblyStartEnemyTaunt( pSoldier, TAUNT_STEAL, pTargetSoldier ); + } // ----------------------------------- @@ -3620,6 +3639,9 @@ BOOLEAN UseHandToHand( SOLDIERTYPE *pSoldier, INT32 sTargetGridNo, BOOLEAN fStea // ----------------------------------- else { + // anv: enemy taunt on attack + PossiblyStartEnemyTaunt( pSoldier, TAUNT_ATTACK_HTH, pTargetSoldier ); + // SANDRO - new mercs' records if ( pSoldier->bTeam == gbPlayerNum && pSoldier->ubProfile != NO_PROFILE ) { @@ -3811,6 +3833,17 @@ BOOLEAN UseHandToHand( SOLDIERTYPE *pSoldier, INT32 sTargetGridNo, BOOLEAN fStea SWeaponHit.fHit = TRUE; SWeaponHit.ubSpecial = FIRE_WEAPON_NO_SPECIAL; AddGameEvent( S_WEAPONHIT, (UINT16) 20, &SWeaponHit ); + + // anv: enemy taunts on hit + PossiblyStartEnemyTaunt( pSoldier, TAUNT_HIT_HTH, pTargetSoldier ); + PossiblyStartEnemyTaunt( pTargetSoldier, TAUNT_GOT_HIT_HTH, pSoldier ); + } + else + { + // anv: enemy taunts on miss + PossiblyStartEnemyTaunt( pSoldier, TAUNT_MISS_HTH, pTargetSoldier ); + if( pTargetSoldier->aiData.bOppList[ pSoldier->ubID ] == SEEN_CURRENTLY ) + PossiblyStartEnemyTaunt( pTargetSoldier, TAUNT_GOT_MISSED_HTH, pSoldier ); } // 0verhaul: And this too // else @@ -4872,18 +4905,25 @@ void StructureHit( INT32 iBullet, UINT16 usWeaponIndex, INT16 bWeaponStatus, UIN } } } - // anv: make missed guy taunt his shooter - if (gGameSettings.fOptions[TOPTION_ALLOW_TAUNTS] == TRUE && - ( ( MercPtrs[pAttacker->ubOppNum]->bTeam == ENEMY_TEAM && SOLDIER_CLASS_ENEMY( MercPtrs[pAttacker->ubOppNum]->ubSoldierClass ) ) || - ( MercPtrs[pAttacker->ubOppNum]->bTeam == MILITIA_TEAM && SOLDIER_CLASS_MILITIA( MercPtrs[pAttacker->ubOppNum]->ubSoldierClass ) ) ) - && MercPtrs[pAttacker->ubOppNum]->bVisible != -1 ) - { - PossiblyStartEnemyTaunt(MercPtrs[pAttacker->ubOppNum], TAUNT_GOT_MISSED, pAttacker); - } } pBullet->usLastStructureHit = usStructureID; - + // anv: enemy taunt on miss + if( pBullet->pFirer != NULL && pBullet->pFirer->ubOppNum != NOBODY ) + { + if( Item[ pBullet->pFirer->usAttackingWeapon ].usItemClass & IC_GUN ) + { + if( MercPtrs[ pBullet->pFirer->ubOppNum ]->aiData.bOppList[ pBullet->pFirer->ubID ] == SEEN_CURRENTLY ) + PossiblyStartEnemyTaunt( MercPtrs[ pBullet->pFirer->ubOppNum ], TAUNT_GOT_MISSED_GUNFIRE, pBullet->pFirer ); + PossiblyStartEnemyTaunt( pBullet->pFirer, TAUNT_MISS_GUNFIRE, MercPtrs[ pBullet->pFirer->ubOppNum ] ); + } + else if( Item[ pBullet->pFirer->usAttackingWeapon ].usItemClass & IC_THROWING_KNIFE ) + { + if( MercPtrs[ pBullet->pFirer->ubOppNum ]->aiData.bOppList[ pBullet->pFirer->ubID ] == SEEN_CURRENTLY ) + PossiblyStartEnemyTaunt( MercPtrs[ pBullet->pFirer->ubOppNum ], TAUNT_GOT_MISSED_THROWING_KNIFE, pBullet->pFirer ); + PossiblyStartEnemyTaunt( pBullet->pFirer, TAUNT_MISS_THROWING_KNIFE,MercPtrs[ pBullet->pFirer->ubOppNum ] ); + } + } } } } @@ -10223,18 +10263,27 @@ void ShotMiss( UINT8 ubAttackerID, INT32 iBullet ) LocateGridNo( pBullet->sGridNo ); } } - //anv: make missed guy taunt his shooter - if (gGameSettings.fOptions[TOPTION_ALLOW_TAUNTS] == TRUE && - ( ( MercPtrs[pAttacker->ubOppNum]->bTeam == ENEMY_TEAM && SOLDIER_CLASS_ENEMY( MercPtrs[pAttacker->ubOppNum]->ubSoldierClass ) ) || - ( MercPtrs[pAttacker->ubOppNum]->bTeam == MILITIA_TEAM && SOLDIER_CLASS_MILITIA( MercPtrs[pAttacker->ubOppNum]->ubSoldierClass ) ) ) - && MercPtrs[pAttacker->ubOppNum]->bVisible != -1 ) - { - PossiblyStartEnemyTaunt(MercPtrs[pAttacker->ubOppNum], TAUNT_GOT_MISSED, pAttacker); - } } // DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String("@@@@@@@ Freeing up attacker - bullet missed") ); // FreeUpAttacker( ubAttackerID ); + + // anv: enemy taunt on miss + if ( pAttacker != NULL && pAttacker->ubOppNum != NOBODY ) + { + if( Item[ pAttacker->usAttackingWeapon ].usItemClass & IC_GUN ) + { + if( MercPtrs[pAttacker->ubOppNum]->aiData.bOppList[ pAttacker->ubID ] == SEEN_CURRENTLY ) + PossiblyStartEnemyTaunt( MercPtrs[pAttacker->ubOppNum], TAUNT_GOT_MISSED_GUNFIRE, pAttacker ); + PossiblyStartEnemyTaunt( pAttacker, TAUNT_MISS_GUNFIRE, MercPtrs[pAttacker->ubOppNum] ); + } + else if( Item[ pAttacker->usAttackingWeapon ].usItemClass & IC_THROWING_KNIFE ) + { + if( MercPtrs[pAttacker->ubOppNum]->aiData.bOppList[ pAttacker->ubID ] == SEEN_CURRENTLY ) + PossiblyStartEnemyTaunt( MercPtrs[pAttacker->ubOppNum], TAUNT_GOT_MISSED_THROWING_KNIFE, pAttacker ); + PossiblyStartEnemyTaunt( pAttacker, TAUNT_MISS_THROWING_KNIFE, MercPtrs[pAttacker->ubOppNum] ); + } + } } UINT32 CalcChanceHTH( SOLDIERTYPE * pAttacker,SOLDIERTYPE *pDefender, INT16 ubAimTime, UINT8 ubMode ) diff --git a/Tactical/XML_Taunts.cpp b/Tactical/XML_Taunts.cpp index 01e209421..c7f3c2632 100644 --- a/Tactical/XML_Taunts.cpp +++ b/Tactical/XML_Taunts.cpp @@ -55,6 +55,7 @@ tauntStartElementHandle(void *userData, const XML_Char *name, const XML_Char **a else if(pData->curElement == ELEMENT && (strcmp(name, "uiIndex") == 0 || strcmp(name, "szText") == 0 || + strcmp(name, "aggressive") == 0 || strcmp(name, "defensive") == 0 || strcmp(name, "cunning") == 0 || @@ -63,33 +64,100 @@ tauntStartElementHandle(void *userData, const XML_Char *name, const XML_Char **a strcmp(name, "brave") == 0 || strcmp(name, "brave_aid") == 0 || strcmp(name, "brave_solo") == 0 || + + strcmp(name, "attack") == 0 || strcmp(name, "fire_gun") == 0 || strcmp(name, "fire_launcher") == 0 || - strcmp(name, "charge_knife") == 0 || - strcmp(name, "charge_fists") == 0 || - strcmp(name, "steal") == 0 || + strcmp(name, "attack_blade") == 0 || + strcmp(name, "attack_hth") == 0 || + strcmp(name, "throw_knife") == 0 || strcmp(name, "throw_grenade") == 0 || - strcmp(name, "alert") == 0 || - strcmp(name, "seek_noise") == 0 || - strcmp(name, "noticed_unseen") == 0 || + + strcmp(name, "out_of_ammo") == 0 || + strcmp(name, "reload") == 0 || + + strcmp(name, "steal") == 0 || + + strcmp(name, "charge_blade") == 0 || + strcmp(name, "charge_hth") == 0 || strcmp(name, "run_away") == 0 || + strcmp(name, "seek_noise") == 0 || + strcmp(name, "alert") == 0 || + strcmp(name, "suspicious") == 0 || + strcmp(name, "noticed_unseen") == 0 || + strcmp(name, "say_hi") == 0 || + strcmp(name, "inform_about") == 0 || + strcmp(name, "got_hit") == 0 || + strcmp(name, "got_hit_gunfire") == 0 || + strcmp(name, "got_hit_blade") == 0 || + strcmp(name, "got_hit_hth") == 0 || + strcmp(name, "got_hit_fallroof") == 0 || + strcmp(name, "got_hit_bloodloss") == 0 || + strcmp(name, "got_hit_explosion") == 0 || + strcmp(name, "got_hit_gas") == 0 || + strcmp(name, "got_hit_tentacle") == 0 || + strcmp(name, "got_hit_structure_explosion") == 0 || + strcmp(name, "got_hit_object") == 0 || + strcmp(name, "got_hit_throwing_knife") == 0 || + + strcmp(name, "got_deafened") == 0 || + strcmp(name, "got_blinded") == 0 || + + strcmp(name, "got_robbed") == 0 || + strcmp(name, "got_missed") == 0 || + strcmp(name, "got_missed_gunfire") == 0 || + strcmp(name, "got_missed_blade") == 0 || + strcmp(name, "got_missed_hth") == 0 || + strcmp(name, "got_missed_throwing_knife") == 0 || + + strcmp(name, "hit") == 0 || + strcmp(name, "hit_gunfire") == 0 || + strcmp(name, "hit_blade") == 0 || + strcmp(name, "hit_hth") == 0 || + strcmp(name, "hit_throwing_knife") == 0 || + + strcmp(name, "kill") == 0 || + strcmp(name, "kill_gunfire") == 0 || + strcmp(name, "kill_blade") == 0 || + strcmp(name, "kill_hth") == 0 || + strcmp(name, "kill_throwing_knife") == 0 || + + strcmp(name, "head_pop") == 0 || + + strcmp(name, "miss") == 0 || + strcmp(name, "miss_gunfire") == 0 || + strcmp(name, "miss_blade") == 0 || + strcmp(name, "miss_hth") == 0 || + strcmp(name, "miss_throwing_knife") == 0 || + + strcmp(name, "riposte_bullet_flew_by") == 0 || + strcmp(name, "riposte_under_heavy_fire") == 0 || + strcmp(name, "riposte_enemy_detected") == 0 || + strcmp(name, "riposte_1st_enemy_detected") == 0 || + strcmp(name, "riposte_multiple_enemies") == 0 || + + strcmp(name, "enemy") == 0 || strcmp(name, "admin") == 0 || strcmp(name, "army") == 0 || strcmp(name, "elite") == 0 || + strcmp(name, "militia") == 0 || strcmp(name, "green") == 0 || strcmp(name, "regular") == 0 || strcmp(name, "veteran") == 0 || + strcmp(name, "admin_profile") == 0 || strcmp(name, "army_profile") == 0 || strcmp(name, "elite_profile") == 0 || strcmp(name, "green_profile") == 0 || strcmp(name, "regular_profile") == 0 || strcmp(name, "veteran_profile") == 0 || + strcmp(name, "male") == 0 || strcmp(name, "female") == 0 || + strcmp(name, "exp_level_gt") == 0 || strcmp(name, "exp_level_lt") == 0 || strcmp(name, "health_gt") == 0 || @@ -100,8 +168,11 @@ tauntStartElementHandle(void *userData, const XML_Char *name, const XML_Char **a strcmp(name, "energy_lt") == 0 || strcmp(name, "energy_max_gt") == 0 || strcmp(name, "energy_max_lt") == 0 || + strcmp(name, "morale_gt") == 0 || + strcmp(name, "morale_lt") == 0 || strcmp(name, "progress_gt") == 0 || strcmp(name, "progress_lt") == 0 || + strcmp(name, "target_type") == 0 || strcmp(name, "target_male") == 0 || strcmp(name, "target_female") == 0 || @@ -115,8 +186,11 @@ tauntStartElementHandle(void *userData, const XML_Char *name, const XML_Char **a strcmp(name, "target_energy_lt") == 0 || strcmp(name, "target_energy_max_gt") == 0 || strcmp(name, "target_energy_max_lt") == 0 || + strcmp(name, "target_morale_gt") == 0 || + strcmp(name, "target_morale_lt") == 0 || strcmp(name, "target_appearance") == 0 || - strcmp(name, "target_merc_profile") == 0 )) + strcmp(name, "target_merc_profile") == 0 ) || + strcmp(name, "target_zombie") == 0 ) { pData->curElement = ELEMENT_PROPERTY; @@ -167,12 +241,8 @@ tauntEndElementHandle(void *userData, const XML_Char *name) else { // no attitude specified -> set all - if( !(pData->curTaunt.uiFlags & TAUNT_A_AGGRESSIVE) && - !(pData->curTaunt.uiFlags & TAUNT_A_DEFENSIVE) && - !(pData->curTaunt.uiFlags & TAUNT_A_BRAVE_AID) && - !(pData->curTaunt.uiFlags & TAUNT_A_BRAVE_SOLO) && - !(pData->curTaunt.uiFlags & TAUNT_A_CUNNING_AID) && - !(pData->curTaunt.uiFlags & TAUNT_A_CUNNING_SOLO) ) + if( !(pData->curTaunt.uiFlags & ( TAUNT_A_AGGRESSIVE | TAUNT_A_DEFENSIVE | TAUNT_A_BRAVE_AID | TAUNT_A_BRAVE_SOLO | + TAUNT_A_CUNNING_AID | TAUNT_A_CUNNING_SOLO) ) ) { pData->curTaunt.uiFlags |= TAUNT_A_AGGRESSIVE; pData->curTaunt.uiFlags |= TAUNT_A_DEFENSIVE; @@ -182,51 +252,47 @@ tauntEndElementHandle(void *userData, const XML_Char *name) pData->curTaunt.uiFlags |= TAUNT_A_CUNNING_SOLO; } // no gender specified -> set all - if( !(pData->curTaunt.uiFlags & TAUNT_G_FEMALE) && - !(pData->curTaunt.uiFlags & TAUNT_G_MALE) ) + if( !(pData->curTaunt.uiFlags2 & ( TAUNT_G_FEMALE | TAUNT_G_MALE ) ) ) { - pData->curTaunt.uiFlags |= TAUNT_G_FEMALE; - pData->curTaunt.uiFlags |= TAUNT_G_MALE; + pData->curTaunt.uiFlags2 |= TAUNT_G_FEMALE; + pData->curTaunt.uiFlags2 |= TAUNT_G_MALE; } - if( !(pData->curTaunt.uiFlags & TAUNT_T_FEMALE) && - !(pData->curTaunt.uiFlags & TAUNT_T_MALE) ) + if( !(pData->curTaunt.uiFlags2 & TAUNT_T_FEMALE) && + !(pData->curTaunt.uiFlags2 & TAUNT_T_MALE) ) { - pData->curTaunt.uiFlags |= TAUNT_T_FEMALE; - pData->curTaunt.uiFlags |= TAUNT_T_MALE; + pData->curTaunt.uiFlags2 |= TAUNT_T_FEMALE; + pData->curTaunt.uiFlags2 |= TAUNT_T_MALE; } // no class specified -> set all enemies - if( !(pData->curTaunt.uiFlags & TAUNT_C_ADMIN) && - !(pData->curTaunt.uiFlags & TAUNT_C_ARMY) && - !(pData->curTaunt.uiFlags & TAUNT_C_ELITE) && - !(pData->curTaunt.uiFlags & TAUNT_C_GREEN) && - !(pData->curTaunt.uiFlags & TAUNT_C_REGULAR) && - !(pData->curTaunt.uiFlags & TAUNT_C_VETERAN) ) + if( !(pData->curTaunt.uiFlags2 & ( TAUNT_C_ADMIN | TAUNT_C_ARMY | TAUNT_C_ELITE | TAUNT_C_GREEN | + TAUNT_C_REGULAR | TAUNT_C_VETERAN ) ) ) { - pData->curTaunt.uiFlags |= TAUNT_C_ADMIN; - pData->curTaunt.uiFlags |= TAUNT_C_ARMY; - pData->curTaunt.uiFlags |= TAUNT_C_ELITE; - pData->curTaunt.uiFlags |= TAUNT_C_GREEN; - pData->curTaunt.uiFlags |= TAUNT_C_REGULAR; - pData->curTaunt.uiFlags |= TAUNT_C_VETERAN; + pData->curTaunt.uiFlags2 |= TAUNT_C_ADMIN; + pData->curTaunt.uiFlags2 |= TAUNT_C_ARMY; + pData->curTaunt.uiFlags2 |= TAUNT_C_ELITE; + pData->curTaunt.uiFlags2 |= TAUNT_C_GREEN; + pData->curTaunt.uiFlags2 |= TAUNT_C_REGULAR; + pData->curTaunt.uiFlags2 |= TAUNT_C_VETERAN; } + //pData->curArray[pData->curTaunt.uiIndex] = pData->curTaunt; pData->curArray[num_found_taunt-1] = pData->curTaunt; - pData->curTaunt.uiFlags = 0; - for(UINT16 i = 0; i < TAUNT_MAX; i++) - { - pData->curTaunt.value[i] = (-1); - } } - } - + } num_found_taunt++; - //num_found_taunt = pData->curTaunt.uiIndex; + //num_found_taunt = pData->curTaunt.uiIndex; } else if(strcmp(name, "uiIndex") == 0) { pData->curElement = ELEMENT; pData->curTaunt.uiIndex = (UINT16) atol(pData->szCharData); + for(UINT16 i = 0; i < TAUNT_MAX; i++) + { + pData->curTaunt.value[i] = (-1); + } + pData->curTaunt.uiFlags = 0; + pData->curTaunt.uiFlags2 = 0; } else if(strcmp(name, "szText") == 0 ) { @@ -277,6 +343,14 @@ tauntEndElementHandle(void *userData, const XML_Char *name) pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_A_CUNNING_AID : 0; pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_A_CUNNING_SOLO : 0; } + else if(strcmp(name, "attack") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_FIRE_GUN : 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_FIRE_LAUNCHER : 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_ATTACK_BLADE : 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_ATTACK_HTH : 0; + } else if(strcmp(name, "fire_gun") == 0) { pData->curElement = ELEMENT; @@ -287,21 +361,17 @@ tauntEndElementHandle(void *userData, const XML_Char *name) pData->curElement = ELEMENT; pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_FIRE_LAUNCHER : 0; } - else if(strcmp(name, "charge_knife") == 0) + else if(strcmp(name, "attack_blade") == 0) { pData->curElement = ELEMENT; - pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_CHARGE_KNIFE : 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_ATTACK_BLADE : 0; } - else if(strcmp(name, "charge_fists") == 0) + else if(strcmp(name, "attack_hth") == 0) { pData->curElement = ELEMENT; - pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_CHARGE_FISTS : 0; - } - else if(strcmp(name, "steal") == 0) - { - pData->curElement = ELEMENT; - pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_STEAL : 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_ATTACK_HTH : 0; } + else if(strcmp(name, "throw_knife") == 0) { pData->curElement = ELEMENT; @@ -312,50 +382,332 @@ tauntEndElementHandle(void *userData, const XML_Char *name) pData->curElement = ELEMENT; pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_THROW_GRENADE: 0; } - else if(strcmp(name, "alert") == 0) + + else if(strcmp(name, "out_of_ammo") == 0) { pData->curElement = ELEMENT; - pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_ALERT : 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_OUT_OF_AMMO : 0; } - else if(strcmp(name, "seek_noise") == 0) + else if(strcmp(name, "reload") == 0) { pData->curElement = ELEMENT; - pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_SEEK_NOISE : 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_RELOAD: 0; } - else if(strcmp(name, "noticed_unseen") == 0) + + else if(strcmp(name, "charge_blade") == 0) { pData->curElement = ELEMENT; - pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_NOTICED_UNSEEN : 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_CHARGE_BLADE : 0; + } + else if(strcmp(name, "charge_hth") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_CHARGE_HTH : 0; + } + else if(strcmp(name, "steal") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_STEAL : 0; } else if(strcmp(name, "run_away") == 0) { pData->curElement = ELEMENT; pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_RUN_AWAY : 0; } + else if(strcmp(name, "seek_noise") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_SEEK_NOISE : 0; + } + else if(strcmp(name, "alert") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_ALERT : 0; + } + else if(strcmp(name, "suspicious") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_SUSPICIOUS : 0; + } + else if(strcmp(name, "noticed_unseen") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_NOTICED_UNSEEN : 0; + } + else if(strcmp(name, "say_hi") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_SAY_HI : 0; + } + else if(strcmp(name, "inform_about") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_INFORM_ABOUT : 0; + } + else if(strcmp(name, "got_hit") == 0) { pData->curElement = ELEMENT; pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_GUNFIRE: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_BLADE: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_HTH: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_FALLROOF: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_BLOODLOSS: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_EXPLOSION: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_GAS: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_TENTACLES: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_STRUCTURE_EXPLOSION: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_THROWING_KNIFE: 0; } + else if(strcmp(name, "got_hit_gunfire") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_GUNFIRE: 0; + } + else if(strcmp(name, "got_hit_blade") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_BLADE: 0; + } + else if(strcmp(name, "got_hit_hth") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_HTH: 0; + } + else if(strcmp(name, "got_hit_fallroof") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_FALLROOF: 0; + } + else if(strcmp(name, "got_hit_bloodloss") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_BLOODLOSS: 0; + } + else if(strcmp(name, "got_hit_explosion") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_EXPLOSION: 0; + } + else if(strcmp(name, "got_hit_gas") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_GAS: 0; + } + else if(strcmp(name, "got_hit_tentacle") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_TENTACLES: 0; + } + else if(strcmp(name, "got_hit_structure_explosion") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_STRUCTURE_EXPLOSION: 0; + } + else if(strcmp(name, "got_hit_object") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_OBJECT: 0; + } + else if(strcmp(name, "got_hit_throwing_knife") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_HIT_THROWING_KNIFE: 0; + } + + else if(strcmp(name, "got_deafened") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_DEAFENED: 0; + } + else if(strcmp(name, "got_blinded") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_BLINDED: 0; + } + else if(strcmp(name, "got_robbed") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_ROBBED: 0; + } + else if(strcmp(name, "got_missed") == 0) { pData->curElement = ELEMENT; pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_MISSED: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_MISSED_GUNFIRE: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_MISSED_BLADE: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_MISSED_HTH: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_MISSED_THROWING_KNIFE: 0; + } + else if(strcmp(name, "got_missed_gunfire") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_MISSED_GUNFIRE: 0; + } + else if(strcmp(name, "got_missed_blade") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_MISSED_BLADE: 0; + } + else if(strcmp(name, "got_missed_hth") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_MISSED_HTH: 0; + } + else if(strcmp(name, "got_missed_throwing_knife") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_GOT_MISSED_THROWING_KNIFE: 0; + } + + else if(strcmp(name, "hit") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_HIT: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_HIT_GUNFIRE: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_HIT_BLADE: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_HIT_HTH: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_HIT_THROWING_KNIFE: 0; + } + else if(strcmp(name, "hit_gunfire") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_HIT_GUNFIRE: 0; + } + else if(strcmp(name, "hit_blade") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_HIT_BLADE: 0; + } + else if(strcmp(name, "hit_hth") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_HIT_HTH: 0; + } + else if(strcmp(name, "hit_throwing_knife") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_HIT_THROWING_KNIFE: 0; + } + + else if(strcmp(name, "kill") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_KILL : 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_KILL_GUNFIRE: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_KILL_BLADE: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_KILL_HTH: 0; + } + else if(strcmp(name, "kill_gunfire") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_KILL_GUNFIRE: 0; + } + else if(strcmp(name, "kill_blade") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_KILL_BLADE: 0; + } + else if(strcmp(name, "kill_hth") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_KILL_HTH: 0; + } + else if(strcmp(name, "kill_throwing_knife") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_KILL_THROWING_KNIFE: 0; + } + else if(strcmp(name, "head_pop") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_HEAD_POP : 0; + } + + else if(strcmp(name, "miss") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_MISS: 0; + } + else if(strcmp(name, "miss_gunfire") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_MISS_GUNFIRE: 0; + } + else if(strcmp(name, "miss_blade") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_MISS_BLADE: 0; + } + else if(strcmp(name, "miss_hth") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_MISS_HTH: 0; + } + else if(strcmp(name, "miss_throwing_knife") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_MISS_THROWING_KNIFE: 0; + } + + + + if(strcmp(name, "riposte_bullet_flew_by") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_R_BULLET_FLEW_BY: 0; + } + else if(strcmp(name, "riposte_under_heavy_fire") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_R_UNDER_HEAVY_FIRE: 0; + } + else if(strcmp(name, "riposte_enemy_detected") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_S_R_ENEMY_DETECTED: 0; + } + else if(strcmp(name, "riposte_1st_enemy_detected") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags2 |= (UINT16) atol(pData->szCharData) ? TAUNT_S_R_1ST_ENEMY_DETECTED: 0; + } + else if(strcmp(name, "riposte_multiple_enemies") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags2 |= (UINT16) atol(pData->szCharData) ? TAUNT_S_R_MULTIPLE_ENEMIES: 0; + } + + if(strcmp(name, "enemy") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags2 |= (UINT16) atol(pData->szCharData) ? TAUNT_C_ADMIN: 0; + pData->curTaunt.uiFlags2 |= (UINT16) atol(pData->szCharData) ? TAUNT_C_ARMY: 0; + pData->curTaunt.uiFlags2 |= (UINT16) atol(pData->szCharData) ? TAUNT_C_ELITE: 0; } else if(strcmp(name, "admin") == 0) { pData->curElement = ELEMENT; - pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_C_ADMIN: 0; + pData->curTaunt.uiFlags2 |= (UINT16) atol(pData->szCharData) ? TAUNT_C_ADMIN: 0; } else if(strcmp(name, "army") == 0) { pData->curElement = ELEMENT; - pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_C_ARMY: 0; + pData->curTaunt.uiFlags2 |= (UINT16) atol(pData->szCharData) ? TAUNT_C_ARMY: 0; } else if(strcmp(name, "elite") == 0) { pData->curElement = ELEMENT; - pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_C_ELITE: 0; + pData->curTaunt.uiFlags2 |= (UINT16) atol(pData->szCharData) ? TAUNT_C_ELITE: 0; + } + else if(strcmp(name, "militia") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_C_GREEN: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_C_REGULAR: 0; + pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_C_VETERAN: 0; } else if(strcmp(name, "green") == 0) { @@ -365,12 +717,12 @@ tauntEndElementHandle(void *userData, const XML_Char *name) else if(strcmp(name, "regular") == 0) { pData->curElement = ELEMENT; - pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_C_REGULAR: 0; + pData->curTaunt.uiFlags2 |= (UINT16) atol(pData->szCharData) ? TAUNT_C_REGULAR: 0; } else if(strcmp(name, "veteran") == 0) { pData->curElement = ELEMENT; - pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_C_VETERAN: 0; + pData->curTaunt.uiFlags2 |= (UINT16) atol(pData->szCharData) ? TAUNT_C_VETERAN: 0; } else if(strcmp(name, "admin_profile") == 0) { @@ -405,12 +757,12 @@ tauntEndElementHandle(void *userData, const XML_Char *name) else if(strcmp(name, "male") == 0) { pData->curElement = ELEMENT; - pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_G_MALE: 0; + pData->curTaunt.uiFlags2 |= (UINT16) atol(pData->szCharData) ? TAUNT_G_MALE: 0; } else if(strcmp(name, "female") == 0) { pData->curElement = ELEMENT; - pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_G_FEMALE: 0; + pData->curTaunt.uiFlags2 |= (UINT16) atol(pData->szCharData) ? TAUNT_G_FEMALE: 0; } else if(strcmp(name, "exp_level_gt") == 0) { @@ -510,12 +862,12 @@ tauntEndElementHandle(void *userData, const XML_Char *name) else if(strcmp(name, "target_male") == 0) { pData->curElement = ELEMENT; - pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_T_MALE: 0; + pData->curTaunt.uiFlags2 |= (UINT16) atol(pData->szCharData) ? TAUNT_T_MALE: 0; } else if(strcmp(name, "target_female") == 0) { pData->curElement = ELEMENT; - pData->curTaunt.uiFlags |= (UINT16) atol(pData->szCharData) ? TAUNT_T_FEMALE: 0; + pData->curTaunt.uiFlags2 |= (UINT16) atol(pData->szCharData) ? TAUNT_T_FEMALE: 0; } else if(strcmp(name, "target_exp_level_gt") == 0) { @@ -587,6 +939,11 @@ tauntEndElementHandle(void *userData, const XML_Char *name) pData->curElement = ELEMENT; pData->curTaunt.value[TAUNT_TARGET_MERC_PROFILE] = (INT16) atol(pData->szCharData); } + else if(strcmp(name, "target_zombie") == 0) + { + pData->curElement = ELEMENT; + pData->curTaunt.uiFlags2 |= (UINT16) atol(pData->szCharData) ? TAUNT_T_ZOMBIE: 0; + } pData->maxReadDepth--; } pData->currentDepth--; diff --git a/Tactical/opplist.cpp b/Tactical/opplist.cpp index 8749af673..b00ba732c 100644 --- a/Tactical/opplist.cpp +++ b/Tactical/opplist.cpp @@ -71,12 +71,12 @@ extern void SetSoldierAniSpeed( SOLDIERTYPE *pSoldier ); // HEADROCK HAM 3.6: Moved to header //void MakeBloodcatsHostile( void ); -void OurNoise( UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubVolume, UINT8 ubNoiseType ); -void TheirNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubVolume, UINT8 ubNoiseType ); -void ProcessNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubBaseVolume, UINT8 ubNoiseType); +void OurNoise( UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubVolume, UINT8 ubNoiseType, STR16 zNoiseMessage ); +void TheirNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubVolume, UINT8 ubNoiseType, STR16 zNoiseMessage = NULL ); +void ProcessNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubBaseVolume, UINT8 ubNoiseType, STR16 zNoiseMessage = NULL ); UINT8 CalcEffVolume(SOLDIERTYPE *pSoldier, INT32 sGridNo, INT8 bLevel, UINT8 ubNoiseType, UINT8 ubBaseVolume, UINT8 bCheckTerrain, UINT8 ubTerrType1, UINT8 ubTerrType2); void HearNoise(SOLDIERTYPE *pSoldier, UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubVolume, UINT8 ubNoiseType, UINT8 *ubSeen); -void TellPlayerAboutNoise(SOLDIERTYPE *pSoldier, UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubVolume, UINT8 ubNoiseType, UINT8 ubNoiseDir ); +void TellPlayerAboutNoise(SOLDIERTYPE *pSoldier, UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubVolume, UINT8 ubNoiseType, UINT8 ubNoiseDir, STR16 zNoiseMessage = NULL ); void OurTeamSeesSomeone( SOLDIERTYPE * pSoldier, INT8 bNumReRevealed, INT8 bNumNewEnemies ); void IncrementWatchedLoc( UINT8 ubID, INT32 sGridNo, INT8 bLevel ); @@ -2537,15 +2537,18 @@ void ManSeesMan(SOLDIERTYPE *pSoldier, SOLDIERTYPE *pOpponent, INT32 sOppGridNo, DebugMsg( TOPIC_JA2OPPLIST, DBG_LEVEL_3, String( "ManSeesMan: ID %d(%S) to ID %d NEW TO ME",pSoldier->ubID,pSoldier->name,pOpponent->ubID) ); #endif // SANDRO - if this is an enemy guy, who was unaware of us till now, and the combat didn't started yet, throw "taunt" and indicator we have been seen - if ( IS_MERC_BODY_TYPE( pSoldier ) && pSoldier->bTeam != gbPlayerNum ) + if ( pSoldier->aiData.bOppList[pOpponent->ubID] <= NOT_HEARD_OR_SEEN && pSoldier->aiData.bAlertStatus != STATUS_RED && pSoldier->aiData.bAlertStatus != STATUS_BLACK ) { - //if ( pSoldier->aiData.bOppList[pOpponent->ubID] <= NOT_HEARD_OR_SEEN && pSoldier->aiData.bAlertStatus != STATUS_RED && pSoldier->aiData.bAlertStatus != STATUS_BLACK ) - if ( pSoldier->aiData.bOppList[pOpponent->ubID] <= NOT_HEARD_OR_SEEN ) - { - PossiblyStartEnemyTaunt( pSoldier, TAUNT_NOTICED_UNSEEN_MERC, pOpponent ); - } - ShowRadioLocator( pSoldier->ubID, 1 ); + PossiblyStartEnemyTaunt( pSoldier, TAUNT_NOTICED_UNSEEN, pOpponent ); } + // anv: we're already in fight, but we still can say hi to new enemy + else if ( pSoldier->aiData.bOppList[pOpponent->ubID] <= NOT_HEARD_OR_SEEN ) + { + PossiblyStartEnemyTaunt( pSoldier, TAUNT_SAY_HI, pOpponent ); + } + + ShowRadioLocator( pSoldier->ubID, 1 ); + // if we also haven't seen him earlier this turn if (pSoldier->aiData.bOppList[pOpponent->ubID] != SEEN_THIS_TURN) @@ -2566,8 +2569,6 @@ void ManSeesMan(SOLDIERTYPE *pSoldier, SOLDIERTYPE *pOpponent, INT32 sOppGridNo, SetFactTrue( FACT_FIRST_BATTLE_BEING_FOUGHT ); } } - - } else { @@ -2583,6 +2584,10 @@ void ManSeesMan(SOLDIERTYPE *pSoldier, SOLDIERTYPE *pOpponent, INT32 sOppGridNo, (gsLastKnownOppLoc[pSoldier->ubID][pOpponent->ubID] != sOppGridNo)) { SetNewSituation( pSoldier ); // force the looker to re-evaluate + // anv: simulate informing buddies about detected enemy's position + if(gbPublicOpplist[pSoldier->bTeam][pOpponent->ubID] != SEEN_CURRENTLY) + PossiblyStartEnemyTaunt( pSoldier, TAUNT_INFORM_ABOUT, pOpponent ); + } else { @@ -3460,7 +3465,7 @@ void SaySeenQuote( SOLDIERTYPE *pSoldier, BOOLEAN fSeenCreature, BOOLEAN fVirgin { // Say quote! TacticalCharacterDialogue( pSoldier, QUOTE_IN_TROUBLE_SLASH_IN_BATTLE ); - + //pSoldier->ubLastEnemyAttackingProvokingQuote = pSoldier->usQuoteSaidFlags |= SOLDIER_QUOTE_SAID_IN_SHIT; return; @@ -3550,6 +3555,7 @@ void SaySeenQuote( SOLDIERTYPE *pSoldier, BOOLEAN fSeenCreature, BOOLEAN fVirgin else { TacticalCharacterDialogue( pSoldier, QUOTE_SEE_ENEMY ); + //pSoldier->ubLastEnemyDetectedProvokingQuote = pSoldier->aiData.ubCaller; } #else //ddd TacticalCharacterDialogue( pSoldier, QUOTE_SEE_ENEMY ); @@ -5481,7 +5487,7 @@ UINT8 DoorOpeningNoise( SOLDIERTYPE *pSoldier ) } } -void MakeNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubVolume, UINT8 ubNoiseType ) +void MakeNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubVolume, UINT8 ubNoiseType, STR16 zNoiseMessage ) { EV_S_NOISE SNoise; @@ -5491,6 +5497,8 @@ void MakeNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, SNoise.ubTerrType = ubTerrType; SNoise.ubVolume = ubVolume; SNoise.ubNoiseType = ubNoiseType; + swprintf( SNoise.zNoiseMessage, L"%s", zNoiseMessage ); + //SNoise.zNoiseMessage = zNoiseMessage; if ( gTacticalStatus.ubAttackBusyCount ) { @@ -5502,7 +5510,7 @@ void MakeNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, // AddGameEvent( S_NOISE, 0, &SNoise ); // now call directly - OurNoise( SNoise.ubNoiseMaker, SNoise.sGridNo, SNoise.bLevel, SNoise.ubTerrType, SNoise.ubVolume, SNoise.ubNoiseType ); + OurNoise( SNoise.ubNoiseMaker, SNoise.sGridNo, SNoise.bLevel, SNoise.ubTerrType, SNoise.ubVolume, SNoise.ubNoiseType, SNoise.zNoiseMessage ); } @@ -5577,7 +5585,7 @@ void MakeNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, } -void OurNoise( UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubVolume, UINT8 ubNoiseType ) +void OurNoise( UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubVolume, UINT8 ubNoiseType, STR16 zNoiseMessage ) { SOLDIERTYPE *pSoldier; @@ -5599,7 +5607,7 @@ void OurNoise( UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, #endif // see if anyone actually hears this noise, sees ubNoiseMaker, etc. - ProcessNoise(ubNoiseMaker, sGridNo, bLevel, ubTerrType, ubVolume, ubNoiseType); + ProcessNoise(ubNoiseMaker, sGridNo, bLevel, ubTerrType, ubVolume, ubNoiseType, zNoiseMessage ); if ((gTacticalStatus.uiFlags & TURNBASED) && (gTacticalStatus.uiFlags & INCOMBAT) && (ubNoiseMaker < TOTAL_SOLDIERS) && !gfDelayResolvingBestSightingDueToDoor ) { @@ -5616,7 +5624,7 @@ void OurNoise( UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, void TheirNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubVolume, - UINT8 ubNoiseType ) + UINT8 ubNoiseType, STR16 zNoiseMessage ) { // SOLDIERTYPE *pSoldier; @@ -5639,7 +5647,7 @@ void TheirNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType #endif // see if anyone actually hears this noise, sees noiseMaker, etc. - ProcessNoise(ubNoiseMaker,sGridNo,bLevel,ubTerrType,ubVolume,ubNoiseType); + ProcessNoise(ubNoiseMaker,sGridNo,bLevel,ubTerrType,ubVolume,ubNoiseType,zNoiseMessage); // if noiseMaker is SOMEBODY if (ubNoiseMaker < TOTAL_SOLDIERS) @@ -5677,7 +5685,7 @@ void TheirNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType -void ProcessNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubBaseVolume, UINT8 ubNoiseType) +void ProcessNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubBaseVolume, UINT8 ubNoiseType, STR16 zNoiseMessage ) { SOLDIERTYPE *pSoldier; UINT8 bLoop, bTeam; @@ -5799,7 +5807,7 @@ void ProcessNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrTy if (gTacticalStatus.Team[bTeam].bHuman) { - if (gbPublicOpplist[bTeam][ubNoiseMaker] == SEEN_CURRENTLY) + if (gbPublicOpplist[bTeam][ubNoiseMaker] == SEEN_CURRENTLY && ubNoiseType != NOISE_VOICE) { continue; } @@ -5867,6 +5875,12 @@ void ProcessNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrTy } */ + // anv: special exception: we want to report enemy taunt, because of text content + if ( ubNoiseType == NOISE_VOICE ) + { + bTellPlayer = TRUE; + } + if ( MercPtrs[ ubNoiseMaker ]->stats.bLife == 0 ) { // this guy is dead (just dying) so don't report to player @@ -5913,7 +5927,11 @@ void ProcessNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrTy // ChrisL: Crows will fly away if they hear any noise if ( !( pSoldier->aiData.bNeutral && ubNoiseType == NOISE_GUNFIRE ) && pSoldier->ubBodyType != CROW ) { - continue; // then who cares whether he can also hear the guy? + // anv: we want to report taunt even if we see noisemaker + if(ubNoiseType != NOISE_VOICE) + { + continue; // then who cares whether he can also hear the guy? + } } } @@ -6063,7 +6081,7 @@ void ProcessNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrTy { // the merc that heard it the LOUDEST is the one to comment // should add level to this function call - TellPlayerAboutNoise(MercPtrs[ubHeardLoudestBy],ubNoiseMaker,sGridNo,bLevel,ubLoudestEffVolume,ubNoiseType, ubLoudestNoiseDir); + TellPlayerAboutNoise(MercPtrs[ubHeardLoudestBy],ubNoiseMaker,sGridNo,bLevel,ubLoudestEffVolume,ubNoiseType, ubLoudestNoiseDir, zNoiseMessage); if ( ubNoiseType == NOISE_MOVEMENT) { @@ -6159,7 +6177,8 @@ UINT8 CalcEffVolume(SOLDIERTYPE *pSoldier, INT32 sGridNo, INT8 bLevel, UINT8 ubN if ( gTacticalStatus.uiFlags & INCOMBAT ) { // ATE: Funny things happen to ABC stuff if bNewSituation set.... - if ( gTacticalStatus.ubCurrentTeam == pSoldier->bTeam ) + // anv: added exception to NOISE_VOICE + if ( gTacticalStatus.ubCurrentTeam == pSoldier->bTeam && ubNoiseType != NOISE_VOICE ) { return( 0 ); } @@ -6623,7 +6642,7 @@ void HearNoise(SOLDIERTYPE *pSoldier, UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bL plan_lib->update_plan(pSoldier->bAIIndex, pSoldier, ai_input); } -void TellPlayerAboutNoise( SOLDIERTYPE *pSoldier, UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubVolume, UINT8 ubNoiseType, UINT8 ubNoiseDir ) +void TellPlayerAboutNoise( SOLDIERTYPE *pSoldier, UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubVolume, UINT8 ubNoiseType, UINT8 ubNoiseDir, STR16 zNoiseMessage ) { UINT8 ubVolumeIndex; @@ -6656,7 +6675,47 @@ void TellPlayerAboutNoise( SOLDIERTYPE *pSoldier, UINT8 ubNoiseMaker, INT32 sGri #endif } - if ( bLevel == pSoldier->pathing.bLevel || ubNoiseType == NOISE_EXPLOSION || ubNoiseType == NOISE_SCREAM || ubNoiseType == NOISE_ROCK_IMPACT || ubNoiseType == NOISE_GRENADE_IMPACT ) + // anv: special treatment of NOISE_VOICE - also display taunt message + if( ubNoiseType == NOISE_VOICE ) + { + // information about direction etc. only displayed if we don't see noise maker + if( gbPublicOpplist[gbPlayerNum][ubNoiseMaker] != SEEN_CURRENTLY && pSoldier->aiData.bOppList[ubNoiseMaker] != SEEN_CURRENTLY ) + { + if( bLevel == pSoldier->pathing.bLevel && ubNoiseType == NOISE_VOICE ) + { + ScreenMsg( MSG_FONT_YELLOW, MSG_INTERFACE, pNewNoiseStr[ubNoiseType], pSoldier->name, pNoiseVolStr[ubVolumeIndex], pDirectionStr[ubNoiseDir] ); + } + else if ( bLevel > pSoldier->pathing.bLevel ) + { + // from above! + ScreenMsg( MSG_FONT_YELLOW, MSG_INTERFACE, pNewNoiseStr[ubNoiseType], pSoldier->name, pNoiseVolStr[ubVolumeIndex], gzLateLocalizedString[6] ); + } + else + { + // from below! + ScreenMsg( MSG_FONT_YELLOW, MSG_INTERFACE, pNewNoiseStr[ubNoiseType], pSoldier->name, pNoiseVolStr[ubVolumeIndex], gzLateLocalizedString[7] ); + } + } + if( ubVolumeIndex > 0 ) // definite noise - we're able to recognize words + { + // do we know who said that? + if( gbPublicOpplist[gbPlayerNum][ubNoiseMaker] == SEEN_CURRENTLY || pSoldier->aiData.bOppList[ubNoiseMaker] == SEEN_CURRENTLY ) + { + if( gTauntsSettings.fTauntShowPopupBox == TRUE ) + ShowTauntPopupBox( MercPtrs[ubNoiseMaker], zNoiseMessage ); + if( gTauntsSettings.fTauntShowInLog == TRUE ) + ScreenMsg( FONT_GRAY2, MSG_INTERFACE, L"%s: %s", MercPtrs[ubNoiseMaker]->GetName(), zNoiseMessage ); + } + else + { + if( gTauntsSettings.fTauntShowPopupBox == TRUE && gTauntsSettings.fTauntShowPopupBoxIfHeard == TRUE ) + ShowTauntPopupBox( MercPtrs[ubNoiseMaker], zNoiseMessage ); + if( gTauntsSettings.fTauntShowInLog == TRUE && gTauntsSettings.fTauntShowInLogIfHeard == TRUE ) + ScreenMsg( FONT_GRAY2, MSG_INTERFACE, L"%s: %s", pTauntUnknownVoice[0], zNoiseMessage ); + } + } + } + else if ( bLevel == pSoldier->pathing.bLevel || ubNoiseType == NOISE_EXPLOSION || ubNoiseType == NOISE_SCREAM || ubNoiseType == NOISE_ROCK_IMPACT || ubNoiseType == NOISE_GRENADE_IMPACT ) { ScreenMsg( MSG_FONT_YELLOW, MSG_INTERFACE, pNewNoiseStr[ubNoiseType], pSoldier->name, pNoiseVolStr[ubVolumeIndex], pDirectionStr[ubNoiseDir] ); } diff --git a/Tactical/opplist.h b/Tactical/opplist.h index fb7bcd4b3..ba9b079b5 100644 --- a/Tactical/opplist.h +++ b/Tactical/opplist.h @@ -60,6 +60,7 @@ enum NOISE_WINDOW_SMASHING, NOISE_DOOR_SMASHING, NOISE_SILENT_ALARM, // only heard by enemies + NOISE_VOICE, // anv: for enemy taunts MAX_NOISES }; @@ -138,8 +139,8 @@ void DebugSoldierPage4( ); UINT8 MovementNoise( SOLDIERTYPE *pSoldier ); UINT8 DoorOpeningNoise( SOLDIERTYPE *pSoldier ); -void MakeNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubVolume, UINT8 ubNoiseType ); -void OurNoise( UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubVolume, UINT8 ubNoiseType ); +void MakeNoise(UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubVolume, UINT8 ubNoiseType, STR16 zNoiseMessage = NULL ); +void OurNoise( UINT8 ubNoiseMaker, INT32 sGridNo, INT8 bLevel, UINT8 ubTerrType, UINT8 ubVolume, UINT8 ubNoiseType, STR16 zNoiseMessage = NULL ); void ResolveInterruptsVs( SOLDIERTYPE * pSoldier, UINT8 ubInterruptType); diff --git a/TacticalAI/AIMain.cpp b/TacticalAI/AIMain.cpp index a6e2fb19e..4e4ad208d 100644 --- a/TacticalAI/AIMain.cpp +++ b/TacticalAI/AIMain.cpp @@ -1926,21 +1926,8 @@ INT8 ExecuteAction(SOLDIERTYPE *pSoldier) case AI_ACTION_TOSS_PROJECTILE: // throw grenade at/near opponent(s) LoadWeaponIfNeeded(pSoldier); // drop through here... - // randomly decide whether to say civ quote - if ( pSoldier->bVisible != -1 ) - { - // ATE: Make sure it's a person :) - if ( IS_MERC_BODY_TYPE( pSoldier ) && pSoldier->ubProfile == NO_PROFILE ) - { - // SANDRO - SOLDIER TAUNTS - if (gGameSettings.fOptions[TOPTION_ALLOW_TAUNTS] == TRUE && - ( ( pSoldier->bTeam == ENEMY_TEAM && SOLDIER_CLASS_ENEMY( pSoldier->ubSoldierClass ) ) || - ( pSoldier->bTeam == MILITIA_TEAM && SOLDIER_CLASS_MILITIA( pSoldier->ubSoldierClass ) ) ) ) - { - PossiblyStartEnemyTaunt( pSoldier, TAUNT_THROW_GRENADE ); - } - } - } + PossiblyStartEnemyTaunt( pSoldier, TAUNT_THROW_GRENADE ); + case AI_ACTION_KNIFE_MOVE: // preparing to stab opponent if (pSoldier->aiData.bAction == AI_ACTION_KNIFE_MOVE) // if statement because toss falls through @@ -1952,36 +1939,26 @@ INT8 ExecuteAction(SOLDIERTYPE *pSoldier) case AI_ACTION_FIRE_GUN: // shoot at nearby opponent case AI_ACTION_THROW_KNIFE: // throw knife at nearby opponent // randomly decide whether to say civ quote - if ( pSoldier->bVisible != -1 )//&& pSoldier->bTeam != MILITIA_TEAM ) + + if (Item[pSoldier->inv[HANDPOS].usItem].usItemClass == IC_GUN ) + PossiblyStartEnemyTaunt( pSoldier, TAUNT_FIRE_GUN, MercPtrs[pSoldier->ubOppNum] ); + else if (Item[pSoldier->inv[HANDPOS].usItem].grenadelauncher || Item[pSoldier->inv[HANDPOS].usItem].mortar || Item[pSoldier->inv[HANDPOS].usItem].rocketlauncher ) + PossiblyStartEnemyTaunt( pSoldier, TAUNT_FIRE_LAUNCHER, MercPtrs[pSoldier->ubOppNum] ); + else if (pSoldier->aiData.bAction == AI_ACTION_TOSS_PROJECTILE && Item[pSoldier->inv[HANDPOS].usItem].usItemClass == IC_THROWN && !Item[pSoldier->inv[HANDPOS].usItem].flare ) + PossiblyStartEnemyTaunt( pSoldier, TAUNT_THROW_KNIFE, MercPtrs[pSoldier->ubOppNum] ); + else if (pSoldier->aiData.bAction == AI_ACTION_KNIFE_MOVE ) { - // ATE: Make sure it's a person :) - if ( IS_MERC_BODY_TYPE( pSoldier ) && pSoldier->ubProfile == NO_PROFILE ) - { - // SANDRO - SOLDIER TAUNTS - if (gGameSettings.fOptions[TOPTION_ALLOW_TAUNTS] == TRUE && - ( ( pSoldier->bTeam == ENEMY_TEAM && SOLDIER_CLASS_ENEMY( pSoldier->ubSoldierClass ) ) || - ( pSoldier->bTeam == MILITIA_TEAM && SOLDIER_CLASS_MILITIA( pSoldier->ubSoldierClass ) ) ) ) - { - if (Item[pSoldier->inv[HANDPOS].usItem].usItemClass == IC_GUN ) - PossiblyStartEnemyTaunt( pSoldier, TAUNT_FIRE_GUN, MercPtrs[pSoldier->ubOppNum] ); - else if (Item[pSoldier->inv[HANDPOS].usItem].grenadelauncher || Item[pSoldier->inv[HANDPOS].usItem].mortar || Item[pSoldier->inv[HANDPOS].usItem].rocketlauncher ) - PossiblyStartEnemyTaunt( pSoldier, TAUNT_FIRE_LAUNCHER, MercPtrs[pSoldier->ubOppNum] ); - else if (pSoldier->aiData.bAction == AI_ACTION_TOSS_PROJECTILE && Item[pSoldier->inv[HANDPOS].usItem].usItemClass == IC_THROWN && !Item[pSoldier->inv[HANDPOS].usItem].flare ) - PossiblyStartEnemyTaunt( pSoldier, TAUNT_THROW, MercPtrs[pSoldier->ubOppNum] ); - else if (pSoldier->aiData.bAction == AI_ACTION_KNIFE_MOVE ) - { - if (Item[pSoldier->inv[HANDPOS].usItem].usItemClass == IC_BLADE ) - PossiblyStartEnemyTaunt( pSoldier, TAUNT_CHARGE_KNIFE ); - else if (Item[pSoldier->inv[HANDPOS].usItem].usItemClass == IC_PUNCH ) - StartEnemyTaunt( pSoldier, TAUNT_CHARGE_FISTS ); - } - } - // CC, ATE here - I put in some TEMP randomness... - else if ( Random( 50 ) == 0 ) - { - StartCivQuote( pSoldier ); - } - } + if (Item[pSoldier->inv[HANDPOS].usItem].usItemClass == IC_BLADE ) + PossiblyStartEnemyTaunt( pSoldier, TAUNT_CHARGE_BLADE ); + else if (Item[pSoldier->inv[HANDPOS].usItem].usItemClass == IC_PUNCH ) + PossiblyStartEnemyTaunt( pSoldier, TAUNT_CHARGE_HTH ); + } + + // CC, ATE here - I put in some TEMP randomness... + if ( Random( 50 ) == 0 && gGameSettings.fOptions[TOPTION_ALLOW_TAUNTS] == FALSE && + IS_MERC_BODY_TYPE( pSoldier ) && pSoldier->ubProfile == NO_PROFILE && pSoldier->bVisible != -1) + { + StartCivQuote( pSoldier ); } #ifdef RECORDNET fprintf(NetDebugFile,"\tExecuteAction: %d calling HandleItem(), inHand %d, actionData %d, anitype %d, oldani %d\n", @@ -2067,10 +2044,8 @@ INT8 ExecuteAction(SOLDIERTYPE *pSoldier) } // SANDRO - ENEMY TAUNTS - if (gGameSettings.fOptions[TOPTION_ALLOW_TAUNTS] == TRUE && pSoldier->bTeam == ENEMY_TEAM && SOLDIER_CLASS_ENEMY( pSoldier->ubSoldierClass ) && pSoldier->bVisible != -1 ) - { - PossiblyStartEnemyTaunt( pSoldier, TAUNT_ALERT ); - } + PossiblyStartEnemyTaunt( pSoldier, TAUNT_ALERT ); + //ScreenMsg( FONT_MCOLOR_LTYELLOW, MSG_BETAVERSION, L"Debug: AI radios your position!" ); // DROP THROUGH HERE! case AI_ACTION_YELLOW_ALERT: // tell friends opponent(s) heard @@ -2089,6 +2064,9 @@ INT8 ExecuteAction(SOLDIERTYPE *pSoldier) // ATE: Change to an animation! AIDecideRadioAnimation( pSoldier ); + // SANDRO - ENEMY TAUNTS + PossiblyStartEnemyTaunt( pSoldier, TAUNT_SUSPICIOUS ); + break; case AI_ACTION_CREATURE_CALL: // creature calling to others @@ -2285,6 +2263,7 @@ INT8 ExecuteAction(SOLDIERTYPE *pSoldier) if(bSlot != NO_SLOT) { ReloadGun( pSoldier, &(pSoldier->inv[pSoldier->aiData.usActionData]), &(pSoldier->inv[bSlot]) ); + PossiblyStartEnemyTaunt( pSoldier, TAUNT_RELOAD ); ActionDone( pSoldier ); } break; diff --git a/TacticalAI/Attacks.cpp b/TacticalAI/Attacks.cpp index e48fa7100..472af2a21 100644 --- a/TacticalAI/Attacks.cpp +++ b/TacticalAI/Attacks.cpp @@ -29,6 +29,9 @@ #include "Queen Command.h" // added by Flugente #endif +// anv: for enemy taunts +#include "Civ Quotes.h" + extern INT16 DirIncrementer[8]; // @@ -2491,6 +2494,14 @@ INT8 CanNPCAttack(SOLDIERTYPE *pSoldier) { // try to reload it bCanAttack = TryToReload( pSoldier ); + if( bCanAttack == TRUE ) + { + PossiblyStartEnemyTaunt( pSoldier, TAUNT_RELOAD ); + } + else + { + PossiblyStartEnemyTaunt( pSoldier, TAUNT_OUT_OF_AMMO ); + } } else if (bCanAttack == NOSHOOT_NOWEAPON) { diff --git a/Utils/Event Pump.cpp b/Utils/Event Pump.cpp index aa25312bc..c3ef49433 100644 --- a/Utils/Event Pump.cpp +++ b/Utils/Event Pump.cpp @@ -1201,7 +1201,7 @@ BOOLEAN ExecuteGameEvent( EVENT *pEvent ) case S_NOISE: memcpy( &SNoise, pEvent->pData, pEvent->uiDataSize ); DebugMsg( TOPIC_JA2, DBG_LEVEL_3, String( "Event Pump: Noise from %d at %d/%d, type %d volume %d", SNoise.ubNoiseMaker, SNoise.sGridNo, SNoise.bLevel, SNoise.ubNoiseType, SNoise.ubVolume ) ); - OurNoise( SNoise.ubNoiseMaker, SNoise.sGridNo, SNoise.bLevel, SNoise.ubTerrType, SNoise.ubVolume, SNoise.ubNoiseType ); + OurNoise( SNoise.ubNoiseMaker, SNoise.sGridNo, SNoise.bLevel, SNoise.ubTerrType, SNoise.ubVolume, SNoise.ubNoiseType, SNoise.zNoiseMessage ); break; case S_STOP_MERC: diff --git a/Utils/Event Pump.h b/Utils/Event Pump.h index b5123bc01..536d0ab52 100644 --- a/Utils/Event Pump.h +++ b/Utils/Event Pump.h @@ -211,6 +211,7 @@ typedef struct UINT8 ubTerrType; UINT8 ubVolume; UINT8 ubNoiseType; + CHAR16 zNoiseMessage[320]; } EV_S_NOISE; diff --git a/Utils/Text.h b/Utils/Text.h index 5c6575c94..ae4438d5a 100644 --- a/Utils/Text.h +++ b/Utils/Text.h @@ -298,6 +298,7 @@ extern STR16 gzMiscString[]; extern STR16 wMapScreenSortButtonHelpText[]; extern STR16 pNewNoiseStr[]; +extern STR16 pTauntUnknownVoice[]; // anv: for enemy taunts extern STR16 gzLateLocalizedString[]; extern STR16 gzCWStrings[]; diff --git a/Utils/_ChineseText.cpp b/Utils/_ChineseText.cpp index 27e1ef3e8..84605e3cd 100644 --- a/Utils/_ChineseText.cpp +++ b/Utils/_ChineseText.cpp @@ -6063,12 +6063,21 @@ STR16 pNewNoiseStr[] = L"%s听到%s吱吱声来自%s。", L"%s听到%s溅水声来自%s。", L"%s听到%s撞击声来自%s。", + L"%s hears a %s GUNFIRE coming from %s.", // anv: without this, all further noise notifications were off by 1! // TODO.Translate L"%s听到%s爆炸声发向%s。", L"%s听到%s尖叫声发向%s。", L"%s听到%s撞击声发向%s。", L"%s听到%s撞击声发向%s。", L"%s听到%s粉碎声来自%s。", L"%s听到%s破碎声来自%s。", + L"", // anv: placeholder for silent alarm // TODO.Translate + L"%s hears someone's %s VOICE coming from %s.", // anv: report enemy taunt to player // TODO.Translate +}; + +// TODO.Translate +STR16 pTauntUnknownVoice[] = +{ + L"Unknown Voice", }; STR16 wMapScreenSortButtonHelpText[] = diff --git a/Utils/_DutchText.cpp b/Utils/_DutchText.cpp index 4ad6066b0..9767b7181 100644 --- a/Utils/_DutchText.cpp +++ b/Utils/_DutchText.cpp @@ -6073,12 +6073,21 @@ STR16 pNewNoiseStr[] = L"%s hoort een %s KRAKEND geluid uit %s.", L"%s hoort een %s SPETTEREND geluid uit %s.", L"%s hoort een %s INSLAG uit %s.", + L"%s hears a %s GUNFIRE coming from %s.", // anv: without this, all further noise notifications were off by 1! // TODO.Translate L"%s hoort een %s EXPLOSIE naar %s.", L"%s hoort een %s SCHREEUW naar %s.", L"%s hoort een %s INSLAG naar %s.", L"%s hoort een %s INSLAG naar %s.", L"%s hoort een %s VERSPLINTEREN uit %s.", L"%s hoort een %s KLAP uit %s.", + L"", // anv: placeholder for silent alarm // TODO.Translate + L"%s hears someone's %s VOICE coming from %s.", // anv: report enemy taunt to player // TODO.Translate +}; + +// TODO.Translate +STR16 pTauntUnknownVoice[] = +{ + L"Unknown Voice", }; STR16 wMapScreenSortButtonHelpText[] = diff --git a/Utils/_EnglishText.cpp b/Utils/_EnglishText.cpp index 481cf0a64..f42e592d1 100644 --- a/Utils/_EnglishText.cpp +++ b/Utils/_EnglishText.cpp @@ -6063,12 +6063,20 @@ STR16 pNewNoiseStr[] = L"%s hears a %s CREAKING coming from %s.", L"%s hears a %s SPLASHING coming from %s.", L"%s hears a %s IMPACT coming from %s.", + L"%s hears a %s GUNFIRE coming from %s.", // anv: without this, all further noise notifications were off by 1! L"%s hears a %s EXPLOSION to %s.", L"%s hears a %s SCREAM to %s.", L"%s hears a %s IMPACT to %s.", L"%s hears a %s IMPACT to %s.", L"%s hears a %s SHATTERING coming from %s.", L"%s hears a %s SMASH coming from %s.", + L"", // anv: placeholder for silent alarm + L"%s hears someone's %s VOICE coming from %s.", // anv: report enemy taunt to player +}; + +STR16 pTauntUnknownVoice[] = +{ + L"Unknown Voice", }; STR16 wMapScreenSortButtonHelpText[] = diff --git a/Utils/_FrenchText.cpp b/Utils/_FrenchText.cpp index 50e130a5b..f1c91dcf2 100644 --- a/Utils/_FrenchText.cpp +++ b/Utils/_FrenchText.cpp @@ -6068,12 +6068,21 @@ STR16 pNewNoiseStr[] = L"%s entend un GRINCEMENT %s %s.", L"%s entend un CLAPOTIS %s %s.", L"%s entend un IMPACT %s %s.", + L"%s hears a %s GUNFIRE coming from %s.", // anv: without this, all further noise notifications were off by 1! // TODO.Translate L"%s entend une EXPLOSION %s %s.", L"%s entend un CRI %s %s.", L"%s entend un IMPACT %s %s.", L"%s entend un IMPACT %s %s.", L"%s entend un BRUIT %s %s.", L"%s entend un BRUIT %s %s.", + L"", // anv: placeholder for silent alarm // TODO.Translate + L"%s hears someone's %s VOICE coming from %s.", // anv: report enemy taunt to player // TODO.Translate +}; + +// TODO.Translate +STR16 pTauntUnknownVoice[] = +{ + L"Unknown Voice", }; STR16 wMapScreenSortButtonHelpText[] = diff --git a/Utils/_GermanText.cpp b/Utils/_GermanText.cpp index d48dc06c3..a678568c9 100644 --- a/Utils/_GermanText.cpp +++ b/Utils/_GermanText.cpp @@ -5904,12 +5904,21 @@ STR16 pNewNoiseStr[] = L"%s hört ein KNARREN (%s) von %s.", L"%s hört ein KLATSCHEN (%s) von %s.", L"%s hört einen AUFSCHLAG (%s) von %s.", + L"%s hears a %s GUNFIRE coming from %s.", // anv: without this, all further noise notifications were off by 1! // TODO.Translate L"%s hört eine EXPLOSION (%s) von %s.", L"%s hört einen SCHREI (%s) von %s.", L"%s hört einen AUFSCHLAG (%s) von %s.", L"%s hört einen AUFSCHLAG (%s) von %s.", L"%s hört ein ZERBRECHEN (%s) von %s.", L"%s hört ein ZERSCHMETTERN (%s) von %s.", + L"", // anv: placeholder for silent alarm // TODO.Translate + L"%s hears someone's %s VOICE coming from %s.", // anv: report enemy taunt to player // TODO.Translate +}; + +// TODO.Translate +STR16 pTauntUnknownVoice[] = +{ + L"Unknown Voice", }; STR16 wMapScreenSortButtonHelpText[] = diff --git a/Utils/_ItalianText.cpp b/Utils/_ItalianText.cpp index 2a2f52dd6..45deacae7 100644 --- a/Utils/_ItalianText.cpp +++ b/Utils/_ItalianText.cpp @@ -6053,12 +6053,21 @@ STR16 pNewNoiseStr[] = L"%s sente uno %s SCRICCHIOLIO proveniente da %s.", L"%s sente un %s TONFO NELL'ACQUA proveniente da %s.", L"%s sente un %s URTO proveniente da %s.", + L"%s hears a %s GUNFIRE coming from %s.", // anv: without this, all further noise notifications were off by 1! // TODO.Translate L"%s sente una %s ESPLOSIONE verso %s.", L"%s sente un %s URLO verso %s.", L"%s sente un %s IMPATTO verso %s.", L"%s sente un %s IMPATTO a %s.", L"%s sente un %s SCHIANTO proveniente da %s.", L"%s sente un %s FRASTUONO proveniente da %s.", + L"", // anv: placeholder for silent alarm // TODO.Translate + L"%s hears someone's %s VOICE coming from %s.", // anv: report enemy taunt to player // TODO.Translate +}; + +// TODO.Translate +STR16 pTauntUnknownVoice[] = +{ + L"Unknown Voice", }; STR16 wMapScreenSortButtonHelpText[] = diff --git a/Utils/_PolishText.cpp b/Utils/_PolishText.cpp index e622cd095..251eff176 100644 --- a/Utils/_PolishText.cpp +++ b/Utils/_PolishText.cpp @@ -6078,12 +6078,21 @@ STR16 pNewNoiseStr[] = L"%s słyszy %s ODGŁOS SKRZYPNIĘCIA dochodzący z %s.", L"%s słyszy %s PLUSK dochodzący z %s.", L"%s słyszy %s ODGŁOS UDERZENIA dochodzący z %s.", + L"%s słyszy %s ODGŁOS STRZAŁU dochodzący z %s.", // anv: without this, all further noise notifications were off by 1! // TODO.Translate L"%s słyszy %s WYBUCH dochodzący z %s.", L"%s słyszy %s KRZYK dochodzący z %s.", L"%s słyszy %s ODGŁOS UDERZENIA dochodzący z %s.", L"%s słyszy %s ODGŁOS UDERZENIA dochodzący z %s.", L"%s słyszy %s ŁOMOT dochodzący z %s.", L"%s słyszy %s TRZASK dochodzący z %s.", + L"", // anv: placeholder for silent alarm // TODO.Translate + L"%s słyszy czyjś %s GŁOS dochodzący z %s.", // anv: report enemy taunt to player // TODO.Translate +}; + +// TODO.Translate +STR16 pTauntUnknownVoice[] = +{ + L"Nieznany głos", }; STR16 wMapScreenSortButtonHelpText[] = diff --git a/Utils/_RussianText.cpp b/Utils/_RussianText.cpp index a1767044d..9936866e3 100644 --- a/Utils/_RussianText.cpp +++ b/Utils/_RussianText.cpp @@ -6062,12 +6062,21 @@ STR16 pNewNoiseStr[] = L"%s слышит %s скрип, идущий %s.", L"%s слышит %s звук всплеска %s.", L"%s слышит %s звук удара %s.", + L"%s hears a %s GUNFIRE coming from %s.", // anv: without this, all further noise notifications were off by 1! // TODO.Translate L"%s слышит %s звук взрыва %s.", L"%s слышит %s крик %s.", L"%s слышит %s звук удара %s.", L"%s слышит %s звук удара %s.", L"%s слышит %s звон %s.", L"%s слышит %s грохот %s.", + L"", // anv: placeholder for silent alarm // TODO.Translate + L"%s hears someone's %s VOICE coming from %s.", // anv: report enemy taunt to player // TODO.Translate +}; + +// TODO.Translate +STR16 pTauntUnknownVoice[] = +{ + L"Unknown Voice", }; STR16 wMapScreenSortButtonHelpText[] = diff --git a/Utils/_TaiwaneseText.cpp b/Utils/_TaiwaneseText.cpp index d9e8b107f..769ffa865 100644 --- a/Utils/_TaiwaneseText.cpp +++ b/Utils/_TaiwaneseText.cpp @@ -6075,12 +6075,21 @@ STR16 pNewNoiseStr[] = L"%s hears a %s CREAKING coming from %s.", L"%s hears a %s SPLASHING coming from %s.", L"%s hears a %s IMPACT coming from %s.", + L"%s hears a %s GUNFIRE coming from %s.", // anv: without this, all further noise notifications were off by 1! // TODO.Translate L"%s hears a %s EXPLOSION to %s.", L"%s hears a %s SCREAM to %s.", L"%s hears a %s IMPACT to %s.", L"%s hears a %s IMPACT to %s.", L"%s hears a %s SHATTERING coming from %s.", L"%s hears a %s SMASH coming from %s.", + L"", // anv: placeholder for silent alarm // TODO.Translate + L"%s hears someone's %s VOICE coming from %s.", // anv: report enemy taunt to player // TODO.Translate +}; + +// TODO.Translate +STR16 pTauntUnknownVoice[] = +{ + L"Unknown Voice", }; STR16 wMapScreenSortButtonHelpText[] =