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; i<num_found_taunt; i++)
+	for(UINT16 i=0; i<num_found_taunt; i++)
 	{
 		// check if attitudes are ok
 		switch( pCiv->aiData.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[] =