2999 lines
90 KiB
Ucode
2999 lines
90 KiB
Ucode
//=============================================================================
|
|
// KFDialogManager
|
|
//=============================================================================
|
|
// Manager class for player dialog. Tracks delays, cooldowns, active dialog, etc.
|
|
//=============================================================================
|
|
// Killing Floor 2
|
|
// Copyright (C) 2015 Tripwire Interactive LLC
|
|
// - Jeff Robinson
|
|
//=============================================================================
|
|
|
|
class KFDialogManager extends Actor
|
|
dependson(KFPawnVoiceGroupEventData)
|
|
config(Game);
|
|
|
|
`include(KFGame/KFGameDialog.uci)
|
|
|
|
var bool bEnabled;
|
|
var config bool bLogDialog;
|
|
|
|
/** Information about dialog that has been spoken and is cooling down */
|
|
struct DialogCoolDownInfo
|
|
{
|
|
var int EventID;
|
|
var KFPawn Speaker;
|
|
var float EndTime;
|
|
var vector Location;
|
|
};
|
|
|
|
/** Event info for events that are cooling down */
|
|
var array< DialogCoolDownInfo > CoolDowns;
|
|
|
|
/** We only update one player pawn per "spotted" update, so we need to remember who's next */
|
|
var transient Pawn NextSpotterPawn;
|
|
|
|
/** Last time we checked if there should be "spotted" dialog */
|
|
var transient float LastSpotUpdateTime;
|
|
|
|
struct DelayedDialogInfo
|
|
{
|
|
var KFPawn Speaker;
|
|
var int EventID;
|
|
var float EndTime;
|
|
};
|
|
|
|
/** Event info for events that have a delay */
|
|
var array< DelayedDialogInfo > DelayedDialog;
|
|
|
|
/** Last time we checked if there should be idle dialog */
|
|
var float LastIdleUpdateTime;
|
|
|
|
/** Dialog at this priority level and above are considered "urgent" and will interrupt dialog of lower priority */
|
|
var byte InterruptPriorityThreshold;
|
|
/** Dialog at this priority level and below can be interrupted by any higher-priority dialog, disregarding InterruptPriorityThreshold */
|
|
var byte InterruptedByAnyPriorityThreshold;
|
|
|
|
/** Set at beginning of wave and beginning of trader time */
|
|
var bool bIsTraderTime;
|
|
|
|
|
|
// Variables to control dialog
|
|
|
|
// welding
|
|
var int WeldAboutToBreakThreshold;
|
|
|
|
// healing
|
|
var float NeedMoreHealingPctThreshold;
|
|
var float NeedNoMoreHealingPctThreshold;
|
|
|
|
// dosh
|
|
var int CaughtSomeDoshAmt;
|
|
var int CaughtMuchDoshAmt;
|
|
|
|
// reload/ammo
|
|
var int NumZedsForPressureReload;
|
|
var float LowSpareAmmoPctThreshold;
|
|
|
|
// kill zed
|
|
var int NumKillsForOnARoll;
|
|
var float CloseCallKillHealthPctThreshold;
|
|
|
|
var int NumZedsInAreaForMassacre;
|
|
var float AreaRadiusForMassacre;
|
|
var float TimeLimitForMassacre;
|
|
|
|
// zed damage
|
|
var int NumHitsForDeadHorse;
|
|
var float TimeBetweenHitsForDeadHorse;
|
|
|
|
var float TimeForContinuousDamageThreshold;
|
|
var float TimeBetweenHitsForContinuousDamage;
|
|
|
|
// player damage
|
|
var float PlayerHealthPctForNearDeath;
|
|
var float PlayerTakeDamageStreakInterval;
|
|
var float PlayerTakeDamageStreakPctForScream;
|
|
|
|
// spot zed
|
|
var float IdleTimeforSpottingZed;
|
|
var int SpotLargeHordeNumZeds;
|
|
|
|
var float ZedAlmostDeadHealthPctThreshold;
|
|
|
|
var float SprintTowardZedDuration;
|
|
|
|
// situational/idle
|
|
var float IdleTimeForSituationalDialog;
|
|
var int IdleLowDoshThreshold;
|
|
var int IdleHighDoshThreshold;
|
|
|
|
var int IdleLowAmmoPctThreshold;
|
|
var int IdleHighAmmoPctThreshold;
|
|
|
|
// sprinting
|
|
var float TimeUntilStartSprintPanting;
|
|
|
|
// global AkEvents
|
|
var AkEvent StopBreathingAkEvent;
|
|
|
|
/** Same as defined in KFPawn_HUman. This one should always match that one. */
|
|
delegate OnFinishedDialog( const out DialogResponseInfo ResponseInfo );
|
|
|
|
/*****************************************************************************
|
|
* Utility functions for getting event data
|
|
*****************************************************************************/
|
|
|
|
/** Gets the radius within which the event can occur */
|
|
function float GetEventRadius( int EventID, class< KFPawnVoiceGroupEventData > EventDataClass )
|
|
{
|
|
if( EventDataClass != none )
|
|
{
|
|
return EventDataClass.default.Events[EventID].Radius;
|
|
}
|
|
|
|
`warn("KFDialogManager::GetEventRadius - EventDataClass is none, using probably useless default value");
|
|
return 0.f;
|
|
}
|
|
|
|
/** Get the event radius squared */
|
|
function float GetEventRadiusSq( int EventID, class< KFPawnVoiceGroupEventData > EventDataClass )
|
|
{
|
|
local float Rad;
|
|
|
|
Rad = GetEventRadius( EventID, EventDataClass );
|
|
|
|
return Rad * Rad;
|
|
}
|
|
|
|
/** Gets the field-of-view within which the event can occur */
|
|
function float GetEventFOV( int EventID, class< KFPawnVoiceGroupEventData > EventDataClass )
|
|
{
|
|
if( EventDataClass != none )
|
|
{
|
|
return EventDataClass.default.Events[EventID].FOV;
|
|
}
|
|
|
|
`warn("KFDialogManager::GetEventFOV - EventDataClass is none, using probably useless default value");
|
|
return 0.f;
|
|
}
|
|
|
|
/** Gets the priority of the event */
|
|
function byte GetEventPriority( int EventID, class< KFPawnVoiceGroupEventData > EventDataClass )
|
|
{
|
|
if( EventDataClass != none )
|
|
{
|
|
return EventDataClass.default.Events[EventID].Priority;
|
|
}
|
|
|
|
`warn("KFDialogManager::GetEventPriority - EventDataClass is none, using probably useless default value");
|
|
return 255;
|
|
}
|
|
|
|
/** Gets the cooldown of the event */
|
|
function float GetEventCoolDownTime( int EventID, class< KFPawnVoiceGroupEventData > EventDataClass )
|
|
{
|
|
if( EventDataClass != none )
|
|
{
|
|
return EventDataClass.default.Events[EventID].CoolDownTime;
|
|
}
|
|
|
|
`warn("KFDialogManager::GetEventCoolDownTime - EventDataClass is none, using probably useless default value");
|
|
return 0.f;
|
|
}
|
|
|
|
/** Gets the radius of effect of the cooldown of the event */
|
|
function float GetEventCoolDownRadius( int EventID, class< KFPawnVoiceGroupEventData > EventDataClass )
|
|
{
|
|
if( EventDataClass != none )
|
|
{
|
|
return EventDataClass.default.Events[EventID].CoolDownRadius;
|
|
}
|
|
|
|
`warn("KFDialogManager::GetEventCoolDownRadius - EventDataClass is none, using probably useless default value");
|
|
return 0.f;
|
|
}
|
|
|
|
/** Gets the cooldown radius squared */
|
|
function float GetEventCoolDownRadiusSq( int EventID, class< KFPawnVoiceGroupEventData > EventDataClass )
|
|
{
|
|
local float CoolDownRadius;
|
|
|
|
CoolDownRadius = GetEventCoolDownRadius( EventID, EventDataClass );
|
|
|
|
return CoolDownRadius * CoolDownRadius;
|
|
}
|
|
|
|
/** Gets the cooldown category of the event */
|
|
function int GetEventCoolDownCategory( int EventID, class< KFPawnVoiceGroupEventData > EventDataClass )
|
|
{
|
|
if( EventDataClass != none )
|
|
{
|
|
if( EventDataClass.default.Events.Length > EventID )
|
|
{
|
|
return EventDataClass.default.Events[EventID].CoolDownCategory;
|
|
}
|
|
else
|
|
{
|
|
return 255;
|
|
}
|
|
}
|
|
|
|
`warn("KFDialogManager::GetEventCoolDownCategory - EventDataClass is none, using probably useless default value");
|
|
return 255;
|
|
}
|
|
|
|
/** Gets the cooldown category of the event */
|
|
function bool GetEventIsOnlyPlayedLocally( int EventID, class< KFPawnVoiceGroupEventData > EventDataClass )
|
|
{
|
|
if( EventDataClass != none )
|
|
{
|
|
return EventDataClass.default.Events[EventID].bOnlyPlayLocally;
|
|
}
|
|
|
|
`warn("KFDialogManager::GetEventIsOnlyPlayedLocally - EventDataClass is none, using probably useless default value");
|
|
return true;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* Utility functions for checking pawn validigy, proximity, FOV, and LOS
|
|
*****************************************************************************/
|
|
|
|
function bool PawnIsValidPlayer( KFPawn_Human KFPH )
|
|
{
|
|
// gotta be human!
|
|
if( KFPH.GetTeamNum() != 0 )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// gotta be alive!
|
|
if( !KFPH.IsAliveAndWell() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if( KFPH.VoiceGroupArch == none || KFPH.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function bool PawnCanSpotPawn( Pawn P1, Pawn P2, float MaxDistanceSq, float FOVCosine, optional bool CheckLOS, optional bool DoubleCheckLOS )
|
|
{
|
|
// check distance
|
|
if( VSizeSq(P2.Location - P1.Location) >= MaxDistanceSq )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if( !ActorWithinPawnFOV(P2, P1, FOVCosine) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// check LOS
|
|
return !CheckLOS || PawnWithinPawnLOS(P2, P1, DoubleCheckLOS);
|
|
}
|
|
|
|
function bool PawnCanSpotActor( Pawn P, Actor A, float MaxDistanceSq, float FOVCosine, optional bool CheckLOS )
|
|
{
|
|
// check distance
|
|
if( VSizeSq(A.Location - P.Location) >= MaxDistanceSq )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if( !ActorWithinPawnFOV(A, P, FOVCosine) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// check LOS
|
|
if( CheckLOS && !FastTrace(P.GetPawnViewLocation(), A.Location) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function bool ActorWithinPawnFOV( Actor A, Pawn P, float FOVCosine )
|
|
{
|
|
local vector PtoA, PFacing;
|
|
|
|
PFacing = vector( P.GetViewRotation() );
|
|
PtoA = Normal( A.Location - P.Location );
|
|
|
|
// check FOV
|
|
if( PtoA dot PFacing < FOVCosine )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function bool ActorWithinPawnRadius( Actor A, Pawn P, float Radius )
|
|
{
|
|
if( VSizeSq(A.Location - P.Location) > (Radius * Radius) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function bool PawnWithinPawnLOS( Pawn P1, Pawn P2, optional bool bDoubleCheckLOS )
|
|
{
|
|
if( !FastTrace(P2.GetPawnViewLocation(), P1.GetPawnViewLocation()) )
|
|
{
|
|
if( !bDoubleCheckLOS || !FastTrace(P1.GetPawnViewLocation(), P2.Location) )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function bool PlayerCanSpotEnemy( KFPawn_Human Player, KFPawn_Monster Enemy, optional float RadiusSq = -1.f, optional float FOVCosine = -1.f )
|
|
{
|
|
local class< KFPawnVoiceGroupEventData > EventDataClass;
|
|
|
|
EventDataClass = Player.GetVoiceGroupEventDataClass();
|
|
|
|
if( RadiusSq < 0 )
|
|
{
|
|
RadiusSq = GetEventRadiusSq(`SPOTZ_Generic, EventDataClass);
|
|
}
|
|
|
|
if( FOVCosine < 0 )
|
|
{
|
|
FOVCosine = GetEventFOV(`SPOTZ_Generic, EventDataClass);
|
|
}
|
|
|
|
return PawnCanSpotPawn(Player, Enemy, RadiusSq, FOVCosine, true, true );
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* Start real dialog manager functionality
|
|
*****************************************************************************/
|
|
|
|
function SetTraderTime( bool bTraderTime )
|
|
{
|
|
bIsTraderTime = bTraderTime;
|
|
}
|
|
|
|
event Tick( float DeltaTime )
|
|
{
|
|
if( !bEnabled || !WorldInfo.GRI.bMatchHasBegun )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( DelayedDialog.Length > 0 )
|
|
{
|
|
UpdateDelayedDialog();
|
|
}
|
|
|
|
if( `TimeSince(LastSpotUpdateTime) > 0.25 )
|
|
{
|
|
CheckSpottedDialog();
|
|
LastSpotUpdateTime = WorldInfo.TimeSeconds;
|
|
}
|
|
|
|
if( `TimeSince(LastIdleUpdateTime) > 0.5 )
|
|
{
|
|
CheckIdleDialog();
|
|
LastIdleUpdateTime = WorldInfo.TimeSeconds;
|
|
}
|
|
}
|
|
|
|
/** Updates delayed dialog, plays delayed dialog when delay time has elapsed */
|
|
function UpdateDelayedDialog()
|
|
{
|
|
local int i;
|
|
|
|
for( i = 0; i < DelayedDialog.Length; ++i )
|
|
{
|
|
if( DelayedDialog[i].EndTime < WorldInfo.TimeSeconds )
|
|
{
|
|
PlayDialogEvent( DelayedDialog[i].Speaker, DelayedDialog[i].EventID );
|
|
DelayedDialog.Remove( i--, 1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Checks if dialog should be considered to be "cooling down" */
|
|
function bool DialogIsCoolingDown( KFPawn KFP, int EventID, int EventCoolDownCategory )
|
|
{
|
|
local int i, CoolDownID, iCoolDownCategory;
|
|
local class< KFPawnVoiceGroupEventData > EventDataClass;
|
|
|
|
EventDataClass = KFP.GetVoiceGroupEventDataClass();
|
|
|
|
for( i = 0; i < CoolDowns.Length; ++i )
|
|
{
|
|
CoolDownID = CoolDowns[i].EventID;
|
|
iCoolDownCategory = GetEventCoolDownCategory(CoolDownID, EventDataClass);
|
|
|
|
// check cooldown for:
|
|
// - same event
|
|
// - any event, in the case that EventID is an idle/situational event (don't remark about the weather unless no one around you has talked for a while)
|
|
// - any event, in the case that CoolDownID is a response event (don't talk over responses... it gets confusing)
|
|
// - any event in the same cooldown category
|
|
if( EventID == CoolDownID ||
|
|
EventCoolDownCategory == ECC_Situ ||
|
|
iCoolDownCategory == ECC_Resp ||
|
|
(EventCoolDownCategory != 255 && EventCoolDownCategory == iCoolDownCategory) )
|
|
{
|
|
// instead of removing on tick, remove on demand
|
|
if( CoolDowns[i].EndTime <= WorldInfo.TimeSeconds )
|
|
{
|
|
CoolDowns.Remove( i--, 1 );
|
|
continue;
|
|
}
|
|
|
|
if( KFP == Cooldowns[i].Speaker )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if( VSizeSq(CoolDowns[i].Location - KFP.Location) < GetEventCoolDownRadiusSq(CoolDownID, EventDataClass) )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/** Checks if a dialog event can be played based on priority, cooldown, etc. */
|
|
function bool DialogEventCanBePlayed( KFPawn KFP, const out DialogEventInfo EventInfo )
|
|
{
|
|
if( KFP.IsSpeaking() )
|
|
{
|
|
// event isn't allowed to interrupt anything
|
|
if( EventInfo.Priority > InterruptPriorityThreshold && KFP.CurrDialogPriority < InterruptedByAnyPriorityThreshold )
|
|
{
|
|
`log(KFP.VoiceGroupArch.static.GetEventName(EventInfo.EventID)$" can't be played for "$Right(KFP.VoiceGroupArch.Name,Len(KFP.VoiceGroupArch.Name)-InStr(KFP.VoiceGroupArch.Name, "_")-1)$" - Already speaking "$KFP.VoiceGroupArch.static.GetEventName(KFP.CurrDialogEventID)$" (priority too low to cause interupt)", bLogDialog, 'BattleChatter');
|
|
return false;
|
|
}
|
|
|
|
// event is lower priority than dialog being spoken, so it can't interrupt it
|
|
if( EventInfo.Priority > KFP.CurrDialogPriority )
|
|
{
|
|
`log(KFP.VoiceGroupArch.static.GetEventName(EventInfo.EventID)$" can't be played for "$Right(KFP.VoiceGroupArch.Name,Len(KFP.VoiceGroupArch.Name)-InStr(KFP.VoiceGroupArch.Name, "_")-1)$" - Already speaking "$KFP.VoiceGroupArch.static.GetEventName(KFP.CurrDialogEventID)$" (lower priority)", bLogDialog, 'BattleChatter');
|
|
return false;
|
|
}
|
|
|
|
// event is same priority and isn't allowed to interrupt equal priority dialog
|
|
if( EventInfo.Priority == KFP.CurrDialogPriority && !EventInfo.bCanInterruptEqualPriority )
|
|
{
|
|
`log(KFP.VoiceGroupArch.static.GetEventName(EventInfo.EventID)$" can't be played for "$Right(KFP.VoiceGroupArch.Name,Len(KFP.VoiceGroupArch.Name)-InStr(KFP.VoiceGroupArch.Name, "_")-1)$" - Already speaking "$KFP.VoiceGroupArch.static.GetEventName(KFP.CurrDialogEventID)$" (same priority, not allowed to interrupt same priority)", bLogDialog, 'BattleChatter');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// don't re-play dialog in cool-down
|
|
if( DialogIsCoolingDown(KFP, EventInfo.EventID, EventInfo.CoolDownCategory) )
|
|
{
|
|
`log(KFP.VoiceGroupArch.static.GetEventName(EventInfo.EventID)$" can't be played for "$Right(KFP.VoiceGroupArch.Name,Len(KFP.VoiceGroupArch.Name)-InStr(KFP.VoiceGroupArch.Name, "_")-1)$" - Cooling down", bLogDialog, 'BattleChatter');
|
|
return false;
|
|
}
|
|
|
|
// don't play if it would be out of context with respect to number of players in the game
|
|
if( !EventInfo.bCanPlayAlone && KFGameInfo(WorldInfo.Game).GetLivingPlayerCount() < 2 )
|
|
{
|
|
`log(KFP.VoiceGroupArch.static.GetEventName(EventInfo.EventID)$" can't be played for "$Right(KFP.VoiceGroupArch.Name,Len(KFP.VoiceGroupArch.Name)-InStr(KFP.VoiceGroupArch.Name, "_")-1)$" - Alone", bLogDialog, 'BattleChatter');
|
|
return false;
|
|
}
|
|
|
|
// only allow dialog in the ECC_TTime category to be played during trader time
|
|
if( EventInfo.CoolDownCategory == ECC_TTime && !bIsTraderTime )
|
|
{
|
|
`log(KFP.VoiceGroupArch.static.GetEventName(EventInfo.EventID)$" can't be played for "$Right(KFP.VoiceGroupArch.Name,Len(KFP.VoiceGroupArch.Name)-InStr(KFP.VoiceGroupArch.Name, "_")-1)$" - Trader time only", bLogDialog, 'BattleChatter');
|
|
return false;
|
|
}
|
|
|
|
// only allow high-pri dialog (mostly pain/damages sounds) if being grabbed by Hans
|
|
if( KFP.SpecialMove == SM_HansGrappleVictim && EventInfo.Priority > InterruptPriorityThreshold )
|
|
{
|
|
`log(KFP.VoiceGroupArch.static.GetEventName(EventInfo.EventID)$" can't be played for "$Right(KFP.VoiceGroupArch.Name,Len(KFP.VoiceGroupArch.Name)-InStr(KFP.VoiceGroupArch.Name, "_")-1)$" - Being grabbed by Hans", bLogDialog, 'BattleChatter');
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/** Play dialog from given speaker and dialog anim on given speaker */
|
|
function PlayDialogEvent( KFPawn Speaker, int EventID )
|
|
{
|
|
local DialogCoolDownInfo CoolDownInfo;
|
|
local DialogEventInfo EventInfo;
|
|
local AkEvent EventAudioCue;
|
|
local name SpeakerName;
|
|
|
|
if( !bEnabled || Speaker == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( EventID < 0 || Speaker.VoiceGroupArch == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
EventInfo = Speaker.VoiceGroupArch.static.GetDialogEventInfo(EventID);
|
|
|
|
if( EventInfo.Delay > 0 )
|
|
{
|
|
if( AddDelayedDialogEvent(Speaker, EventID, EventInfo.Delay) )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
if( !DialogEventCanBePlayed(Speaker, EventInfo) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( FRand() > EventInfo.Chance )
|
|
{
|
|
return;
|
|
}
|
|
|
|
EventAudioCue = Speaker.VoiceGroupArch.static.GetDialogAkEvent( EventID, bIsTraderTime );
|
|
if( EventAudioCue == none )
|
|
{
|
|
`log("KFDialogManager::PlayDialogEvent - event "$Speaker.VoiceGroupArch.static.GetEventName(EventInfo.EventID)$" for speaker "$Speaker$" has no audio, bailing out", bLogDialog);
|
|
return;
|
|
}
|
|
|
|
if( EventAudioCue.Duration <= 0 )
|
|
{
|
|
`log("KFDialogManager::PlayDialogEvent - event "$Speaker.VoiceGroupArch.static.GetEventName(EventInfo.EventID)$" for speaker "$Speaker$" has invalid duration, bailing out", bLogDialog);
|
|
return;
|
|
}
|
|
|
|
SpeakerName = Speaker.VoiceGroupArch.Name;
|
|
|
|
if( Speaker.IsSpeaking() )
|
|
{
|
|
`log("Interrupting "$Speaker.VoiceGroupArch.static.GetEventName(Speaker.CurrDialogEventID)$" for "$Right(SpeakerName,Len(SpeakerName)-InStr(SpeakerName, "_")-1), bLogDialog, 'BattleChatter');
|
|
|
|
// interrupt current dialog
|
|
Speaker.StopDialog();
|
|
}
|
|
|
|
`log("Playing "$Speaker.VoiceGroupArch.static.GetEventName(EventInfo.EventID)$" for "$Right(SpeakerName,Len(SpeakerName)-InStr(SpeakerName, "_")-1), bLogDialog, 'BattleChatter');
|
|
|
|
Speaker.CurrDialogEventID = EventInfo.EventID;
|
|
Speaker.CurrDialogPriority = EventInfo.Priority;
|
|
|
|
// manage cool down info
|
|
if( EventInfo.CoolDownTime > 0.f )
|
|
{
|
|
CoolDownInfo.EventID = EventInfo.EventID;
|
|
CoolDownInfo.Speaker = Speaker;
|
|
CoolDownInfo.Location = Speaker.Location;
|
|
CoolDownInfo.EndTime = WorldInfo.TimeSeconds + EventInfo.CoolDownTime;
|
|
CoolDowns.AddItem( CoolDownInfo );
|
|
}
|
|
|
|
if( EventInfo.bOnlyPlayLocally )
|
|
{
|
|
if( Speaker.IsLocallyControlled() )
|
|
{
|
|
KFPlayerController(Speaker.Controller).ClientHearDialog( Speaker, EventAudioCue, EventInfo.bCanBeMinimized );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Speaker.PlayDialog( EventAudioCue, EventInfo.bCanBeMinimized );
|
|
}
|
|
|
|
// keep track of end-of-event with a timer (duration is max duration of all permutations of dialog)
|
|
SetTimer( EventAudioCue.Duration, false, nameof(Speaker.EndOfDialogTimer), Speaker );
|
|
}
|
|
|
|
/** Checks if a given player is speaking or is set to speak a given line of dialog */
|
|
function bool PlayerIsPlayingDialogEvent( KFPawn_Human Player, int EventID )
|
|
{
|
|
local int DelayedDialogIdx;
|
|
|
|
if( Player.IsPlayingDialogEvent(EventiD) )
|
|
{
|
|
// the player is currently saying the line
|
|
return true;
|
|
}
|
|
|
|
DelayedDialogIdx = DelayedDialog.Find('EventID', EventID);
|
|
if( DelayedDialogIdx != INDEX_NONE && DelayedDialog[DelayedDialogIdx].Speaker == Player )
|
|
{
|
|
// the player will start saying the line soon, so consider him to be speaking already
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/** Delegate for all responses that only require basic information and logic */
|
|
function BasicResponseDelegate( const out DialogResponseInfo RespInfo )
|
|
{
|
|
if( !RespInfo.Speaker.bDeleteMe && RespInfo.Speaker.IsAliveAndWell() )
|
|
{
|
|
PlayDialogEvent( RespInfo.Speaker, RespInfo.EventID );
|
|
}
|
|
}
|
|
|
|
/** Plays or sets up a basic (requires no special information or logic) response to a given line of dialog */
|
|
function PlayBasicDialogResponse( KFPawn_Human RespondToPawn, int RespondingToID, int ResponseID, optional KFPawn_Human Responder, optional KFPawn Target, optional bool bPlayOnlyAsResponse )
|
|
{
|
|
if( Responder == none )
|
|
{
|
|
Responder = FindPlayerResponder( RespondToPawn, ResponseID, Target );
|
|
}
|
|
|
|
if( Responder == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// if Speaker is speaking the dialog Responder is waiting for, then wait for it to finish
|
|
if( PlayerIsPlayingDialogEvent(RespondToPawn, RespondingToID) )
|
|
{
|
|
RespondToPawn.SetDialogResponseDelegate( Responder, BasicResponseDelegate, ResponseID, RespondingToID );
|
|
}
|
|
// otherwise just play the "response" right away, if we're allowed to do so
|
|
else if( !bPlayOnlyAsResponse )
|
|
{
|
|
PlayDialogEvent( Responder, ResponseID );
|
|
}
|
|
}
|
|
|
|
/** Finds a nearby player to respond to a given line of dialog */
|
|
function KFPawn_Human FindPlayerResponder( KFPawn_Human Speaker, int ResponseEventID, optional KFPawn Target )
|
|
{
|
|
local KFPawn_Human Responder;
|
|
local class< KFPawnVoiceGroupEventData > EventDataClass;
|
|
|
|
EventDataClass = Speaker.GetVoiceGroupEventDataClass();
|
|
|
|
foreach WorldInfo.AllPawns( class'KFPawn_Human', Responder )
|
|
{
|
|
if( Responder == Speaker || !PawnIsValidPlayer(Responder) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( ActorWithinPawnRadius(Speaker, Responder, GetEventRadius(ResponseEventID, EventDataClass))
|
|
&& (Target == none || (ActorWithinPawnFOV(Target, Responder, GetEventFOV(ResponseEventID, EventDataClass)) && PawnWithinPawnLOS(Target, Responder)))
|
|
)
|
|
{
|
|
return Responder;
|
|
}
|
|
}
|
|
|
|
return none;
|
|
}
|
|
|
|
/** Plays or sets up a response that requires customized information or logic */
|
|
function PlayCustomDialogResponse( KFPawn_Human Speaker, KFPawn Responder, int RespondingToID, delegate<OnFinishedDialog> CustomDelegate, optional bool bPlayOnlyAsResponse )
|
|
{
|
|
// if Speaker is speaking the dialog Responder is waiting for, then wait for it to finish
|
|
if( PlayerIsPlayingDialogEvent(Speaker, RespondingToID) )
|
|
{
|
|
Speaker.SetDialogResponseDelegate( Responder, CustomDelegate, -1, RespondingToID );
|
|
}
|
|
// otherwise just play the "response" right away, if we're allowed to do so
|
|
else if( !bPlayOnlyAsResponse )
|
|
{
|
|
Speaker.SetDialogResponseDelegate( Responder, none, -1, RespondingToID );
|
|
CustomDelegate( Speaker.DlgRespInfo );
|
|
}
|
|
}
|
|
|
|
/** Simulates adding elements to an array and picking a random element (without using an array) */
|
|
function AddRandomDialogOption( KFPawn Speaker, int OptionID, out int NumOptions, out int BestOptionID )
|
|
{
|
|
local DialogEventInfo NewOptionEventInfo, BestOptionEventInfo;
|
|
local int WeightCount;
|
|
|
|
if( OptionID < 0 || Speaker.VoiceGroupArch == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( BestOptionID >= 0 )
|
|
{
|
|
NewOptionEventInfo = Speaker.VoiceGroupArch.static.GetDialogEventInfo(OptionID);
|
|
BestOptionEventInfo = Speaker.VoiceGroupArch.static.GetDialogEventInfo(BestOptionID);
|
|
if( NewOptionEventInfo.Priority < BestOptionEventInfo.Priority )
|
|
{
|
|
NumOptions = 0;
|
|
}
|
|
else if( NewOptionEventInfo.Priority > BestOptionEventInfo.Priority )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
NumOptions++;
|
|
WeightCount = NewOptionEventInfo.Weight;
|
|
while( WeightCount-- > 0 )
|
|
{
|
|
if( Frand() <= 1.f / float(NumOptions) )
|
|
{
|
|
BestOptionID = OptionID;
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Adds an entry to the delayed dialog array */
|
|
function bool AddDelayedDialogEvent( KFPawn Speaker, int EventID, float Delay )
|
|
{
|
|
local int DelayedDialogIdx;
|
|
|
|
DelayedDialogIdx = DelayedDialog.Find('EventID', EventID);
|
|
if( DelayedDialogIdx == INDEX_NONE )
|
|
{
|
|
DelayedDialog.Add( 1 );
|
|
DelayedDialog[ DelayedDialog.Length - 1 ].Speaker = Speaker;
|
|
DelayedDialog[ DelayedDialog.Length - 1 ].EventID = EventID;
|
|
DelayedDialog[ DelayedDialog.Length - 1 ].EndTime = WorldInfo.TimeSeconds + Delay;
|
|
return true;
|
|
}
|
|
else if( DelayedDialog[DelayedDialogIdx].Speaker != Speaker )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/************************************************
|
|
* Door Dialog
|
|
************************************************/
|
|
|
|
function PlayWeldDialog( KFPawn Speaker, KFDoorActor Door, KFPawn Welder )
|
|
{
|
|
local int WeldDialogID, WeldRespDialogID;
|
|
|
|
if( Speaker.VoiceGroupArch == none || Speaker.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( Door.UnderAttack() )
|
|
{
|
|
WeldDialogID = `ACT_WeldDoorUnderAttack;
|
|
WeldRespDialogID = `ACT_WeldDoorUnderAttackResp;
|
|
}
|
|
else
|
|
{
|
|
WeldDialogID = `ACT_WeldDoor;
|
|
WeldRespDialogID = `ACT_WeldDoorResp;
|
|
}
|
|
|
|
if( Speaker == Welder )
|
|
{
|
|
// if door is now welded in full, play finished dialog
|
|
if( Door.WeldIntegrity >= Door.MaxWeldIntegrity )
|
|
{
|
|
PlayDialogEvent( KFPawn_Human(Speaker), `ACT_WeldDoorFinish );
|
|
}
|
|
// else play general "welding" dialog, but only when the player first starts welding
|
|
else if( !Door.BeingWelded() )
|
|
{
|
|
PlayDialogEvent( KFPawn_Human(Speaker), WeldDialogID );
|
|
}
|
|
// else if door is under attack and about to break, play "about to break" dialog
|
|
else if( WeldDialogID == `ACT_WeldDoorUnderAttack && Door.WeldIntegrity < WeldAboutToBreakThreshold )
|
|
{
|
|
PlayDialogEvent( KFPawn_Human(Speaker), `ACT_WeldDoorAboutToBreak );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PlayBasicDialogResponse( KFPawn_Human(Speaker), WeldDialogID, WeldRespDialogID, KFPawn_Human(Welder) );
|
|
}
|
|
}
|
|
|
|
function PlayUnweldDialog( KFPawn Speaker, KFDoorActor Door, KFPawn Unwelder )
|
|
{
|
|
if( Speaker.VoiceGroupArch == none || Speaker.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( Speaker == Unwelder )
|
|
{
|
|
// if door is now unwelded in full, play finished dialog
|
|
if( Door.WeldIntegrity <= 0 )
|
|
{
|
|
PlayDialogEvent( KFPawn_Human(Speaker), `ACT_UnweldDoorFinish );
|
|
}
|
|
// else play unwelding dialog, but only when the player first starts unwelding
|
|
else if( !Door.BeingUnwelded() )
|
|
{
|
|
PlayDialogEvent( KFPawn_Human(Speaker), `ACT_UnweldDoor );
|
|
}
|
|
}
|
|
}
|
|
|
|
function PlayDoorTakeDamageDialog( KFDoorActor Door )
|
|
{
|
|
local KFPawn_Human KFPH;
|
|
local bool bDoorWeldBroken;
|
|
local class< KFPawnVoiceGroupEventData > EventDataClass;
|
|
|
|
bDoorWeldBroken = Door.WeldIntegrity <= 0;
|
|
|
|
foreach WorldInfo.AllPawns( class'KFPawn_Human', KFPH )
|
|
{
|
|
if( !PawnIsValidPlayer(KFPH) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
EventDataClass = KFPH.GetVoiceGroupEventDataClass();
|
|
|
|
//@todo: should probably check LOS, but that doesn't seem to be reliable with door actors...
|
|
if( !PawnCanSpotActor(KFPH, Door, GetEventRadiusSq(`ACT_SpotDoorAttacked, EventDataClass), GetEventFOV(`ACT_SpotDoorAttacked, EventDataClass)) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( bDoorWeldBroken )
|
|
{
|
|
PlayDialogEvent( KFPH, `ACT_SpotDoorBreak );
|
|
}
|
|
else
|
|
{
|
|
PlayDialogEvent( KFPH, `ACT_SpotDoorAttacked );
|
|
}
|
|
}
|
|
}
|
|
|
|
/************************************************
|
|
* Heal Dialog
|
|
************************************************/
|
|
|
|
function PlayHealMissDialog( KFPawn Healer, KFPawn IntendedHealee )
|
|
{
|
|
local KFPawn_Human KFPH, KFPH_Healee;
|
|
|
|
if( Healer.VoiceGroupArch == none || Healer.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
KFPH = KFPawn_Human(Healer);
|
|
|
|
if( KFPH == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
KFPH_Healee = KFPawn_Human(IntendedHealee);
|
|
|
|
if( KFPH_Healee == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
PlayDialogEvent( KFPH, `ACT_HealMiss );
|
|
PlayCustomDialogResponse( KFPawn_Human(Healer), IntendedHealee, `ACT_HealMiss, PlayHealMissResponse, true );
|
|
}
|
|
|
|
function PlayHealMissResponse( const out DialogResponseInfo RespInfo )
|
|
{
|
|
if( !RespInfo.Speaker.bIsMoving && ActorWithinPawnRadius(RespInfo.Speaker, RespInfo.RespondingToPawn, GetEventRadius(`ACT_HealMissResp, RespInfo.Speaker.GetVoiceGroupEventDataClass())) )
|
|
{
|
|
PlayDialogEvent( RespInfo.Speaker, `ACT_HealMissResp );
|
|
}
|
|
}
|
|
|
|
function PlayHealingDialog( KFPawn Healer, KFPawn Healee, float HealeeHealthPct )
|
|
{
|
|
local KFPawn_Human KFPH;
|
|
|
|
if( Healer.VoiceGroupArch == none || Healer.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
KFPH = KFPawn_Human(Healer);
|
|
|
|
if( KFPH == none )
|
|
{
|
|
// not an act of healing by a player
|
|
return;
|
|
}
|
|
|
|
if( KFPH != Healee )
|
|
{
|
|
PlayDialogEvent( KFPH, `ACT_HealSomeone );
|
|
|
|
if( HealeeHealthPct < NeedMoreHealingPctThreshold )
|
|
{
|
|
PlayBasicDialogResponse( KFPH, `ACT_HealSomeone, `ACT_HealSomeoneRespLT50pct, KFPawn_Human(Healee) );
|
|
}
|
|
else if( HealeeHealthPct >= NeedNoMoreHealingPctThreshold )
|
|
{
|
|
PlayBasicDialogResponse( KFPH, `ACT_HealSomeone, `ACT_HealSomeoneRespMT75pct, KFPawn_Human(Healee) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PlayDialogEvent( KFPH, `ACT_HealSelf );
|
|
}
|
|
}
|
|
|
|
/************************************************
|
|
* Dosh Dialog
|
|
************************************************/
|
|
|
|
function PlayDoshCaughtDialog( KFPawn_Human Speaker )
|
|
{
|
|
if( Speaker.VoiceGroupArch == none || Speaker.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( Speaker.DoshCaughtStreakAmt >= CaughtMuchDoshAmt )
|
|
{
|
|
PlayDialogEvent( Speaker, `ACT_DoshAtSomeoneRespLots );
|
|
}
|
|
else if( Speaker.DoshCaughtStreakAmt >= CaughtSomeDoshAmt )
|
|
{
|
|
PlayDialogEvent( Speaker, `ACT_DoshAtSomeoneRespSome );
|
|
}
|
|
}
|
|
|
|
function PlayDoshTossDialog( KFPawn Speaker )
|
|
{
|
|
local Actor HitActor;
|
|
local vector HitLocation, HitNormal;
|
|
local vector TraceStart, TraceEnd;
|
|
|
|
TraceEnd = Speaker.GetPawnViewLocation();
|
|
TraceStart = TraceEnd + vector(Speaker.GetViewRotation()) * 500;
|
|
HitActor = Trace( HitLocation, HitNormal, TraceEnd, TraceStart, true );
|
|
if( HitActor != Speaker && KFPawn_Human(HitActor) != none )
|
|
{
|
|
PlayDialogEvent( Speaker, `ACT_DoshAtSomeone );
|
|
}
|
|
else
|
|
{
|
|
PlayDialogEvent( Speaker, `ACT_DoshAtGround );
|
|
}
|
|
}
|
|
|
|
/************************************************
|
|
* Weapon Dialog
|
|
************************************************/
|
|
|
|
function PlayReloadDialog( KFPawn Speaker )
|
|
{
|
|
if( Speaker.VoiceGroupArch == none || Speaker.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( Speaker.IsSurrounded(true, NumZedsForPressureReload, GetEventRadius(`ACT_ReloadUnderPres, Speaker.GetVoiceGroupEventDataClass())) )
|
|
{
|
|
PlayDialogEvent( Speaker, `ACT_ReloadUnderPres );
|
|
}
|
|
else
|
|
{
|
|
PlayDialogEvent( Speaker, `ACT_Reload );
|
|
}
|
|
}
|
|
|
|
function PlayAmmoDialog( KFPawn Speaker, float SpareAmmoLeftPct )
|
|
{
|
|
if( Speaker.VoiceGroupArch == none || Speaker.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( SpareAmmoLeftPct <= LowSpareAmmoPctThreshold )
|
|
{
|
|
PlayDialogEvent( Speaker, `ACT_AmmoLow );
|
|
PlayBasicDialogResponse( KFPawn_Human(Speaker), `ACT_AmmoLow, `ACT_AmmoLowResp, /*Responder*/, /*Target*/, true );
|
|
}
|
|
}
|
|
|
|
function PlayDropWeaponDialog( KFPawn Speaker )
|
|
{
|
|
if( Speaker.VoiceGroupArch == none || Speaker.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
PlayDialogEvent( Speaker, `ACT_DropWeap );
|
|
}
|
|
|
|
function PlayMeleeAttackDialog( KFPawn Speaker, bool bIsHeavyAttack )
|
|
{
|
|
if( Speaker.VoiceGroupArch == none || Speaker.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( bIsHeavyAttack )
|
|
{
|
|
PlayDialogEvent( Speaker, `ACT_AttackHeavy );
|
|
}
|
|
else
|
|
{
|
|
PlayDialogEvent( Speaker, `ACT_AttackLight );
|
|
}
|
|
}
|
|
|
|
function PlayIronsightsDialog( KFPawn Speaker )
|
|
{
|
|
if( Speaker.VoiceGroupArch == none || Speaker.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
PlayDialogEvent( Speaker, `ACT_Ironsights );
|
|
}
|
|
|
|
function PlayJumpDialog( KFPawn Speaker )
|
|
{
|
|
if( Speaker.VoiceGroupArch == none || Speaker.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
PlayDialogEvent( Speaker, `ACT_Jump );
|
|
}
|
|
|
|
/************************************************
|
|
* Sprint Dialog
|
|
************************************************/
|
|
|
|
function PlaySprintPantingDialog( KFPawn_Human Speaker, bool bNewSprintStatus )
|
|
{
|
|
if( bNewSprintStatus && !Speaker.bIsSprinting )
|
|
{
|
|
Speaker.SprintStartTime = WorldInfo.TimeSeconds;
|
|
}
|
|
else if ( !bNewSprintStatus )
|
|
{
|
|
StopBreathingDialog(Speaker);
|
|
}
|
|
|
|
if( `TimeSince(Speaker.SprintStartTime) > TimeUntilStartSprintPanting )
|
|
{
|
|
Speaker.SprintStartTime = WorldInfo.TimeSeconds;
|
|
PlayDialogEvent( Speaker, `ACT_Sprint );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A stop event for sprinting and ironsight breathing. The breathing sounds also have a max duration,
|
|
* so even though this event is not perfect (changing controllers, etc...) it won't break anything.
|
|
*/
|
|
function StopBreathingDialog(KFPawn Speaker)
|
|
{
|
|
if( Speaker.IsSpeaking() )
|
|
{
|
|
if ( Speaker.CurrDialogEventID == `ACT_Sprint || Speaker.CurrDialogEventID == `ACT_Ironsights )
|
|
{
|
|
KFPlayerController(Speaker.Controller).ClientHearDialog( Speaker, StopBreathingAkEvent, 0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
/************************************************
|
|
* Level Up Dialog
|
|
************************************************/
|
|
|
|
function PlayLevelUpDialog( KFPlayerController LevellerKFPC )
|
|
{
|
|
local KFPawn_Human Leveller, Commenter;
|
|
local int CommentEventID;
|
|
|
|
local int LevellerLevel, CommenterLevel;
|
|
|
|
LevellerLevel = KFPlayerReplicationInfo( LevellerKFPC.PlayerReplicationInfo ).GetActivePerkLevel();
|
|
|
|
if( LevellerLevel < 5 )
|
|
{
|
|
CommentEventID = `ACT_CommentLvlLT10;
|
|
}
|
|
else if( LevellerLevel < 15 )
|
|
{
|
|
CommentEventID = `ACT_CommentLvlLT25;
|
|
}
|
|
else if( LevellerLevel < 25 )
|
|
{
|
|
CommentEventID = `ACT_CommentLvlLT50;
|
|
}
|
|
else
|
|
{
|
|
CommentEventID = `ACT_CommentLvlMax;
|
|
}
|
|
|
|
Leveller = KFPawn_Human( LevellerKFPC.Pawn );
|
|
Commenter = FindPlayerResponder( Leveller, CommentEventID );
|
|
|
|
if( Commenter != none )
|
|
{
|
|
PlayDialogEvent( Commenter, CommentEventID );
|
|
|
|
CommenterLevel = KFPlayerReplicationInfo( KFPlayerController(Commenter.Controller).PlayerReplicationInfo ).GetActivePerkLevel();
|
|
if( CommenterLevel > LevellerLevel )
|
|
{
|
|
PlayBasicDialogResponse( Commenter, CommentEventID, `ACT_CommentLvlUpRespHigher, Leveller, Commenter, true );
|
|
}
|
|
else if( CommenterLevel < LevellerLevel )
|
|
{
|
|
PlayBasicDialogResponse( Commenter, CommentEventID, `ACT_CommentLvlUpRespLower, Leveller, Commenter, true );
|
|
}
|
|
}
|
|
}
|
|
|
|
/************************************************
|
|
* KillZed Dialog
|
|
************************************************/
|
|
|
|
function PlayKilledZedDialog( KFPawn_Human Killer, KFPawn_Monster Zed, class<DamageType> DamageType, bool bWasKnockedDown )
|
|
{
|
|
local int NumOptions, BestOptionID;
|
|
|
|
if( Killer.VoiceGroupArch == none || Killer.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
BestOptionID = -1;
|
|
|
|
CheckOnARollDialog( Killer, NumOptions, BestOptionID );
|
|
CheckMassacreDialog( Killer, Zed, NumOptions, BestOptionID );
|
|
CheckCloseCallKillDialog( Killer, Zed, NumOptions, BestOptionID );
|
|
CheckKillAsLastAliveDialog( Killer, Zed, NumOptions, BestOptionID );
|
|
CheckKilledWithFavoriteWeaponDialog( Killer, NumOptions, BestOptionID );
|
|
|
|
AddRandomDialogOption( Killer, Zed.GetKillerDialogID(), NumOptions, BestOptionID );
|
|
|
|
if( class<KFDamageType>(DamageType) != none )
|
|
{
|
|
AddRandomDialogOption( Killer, class<KFDamageType>(DamageType).static.GetKillerDialogID(), NumOptions, BestOptionID );
|
|
}
|
|
|
|
if( bWasKnockedDown )
|
|
{
|
|
AddRandomDialogOption( Killer, `KILL_KnockedDown, NumOptions, BestOptionID );
|
|
}
|
|
|
|
PlayDialogEvent( Killer, BestOptionID );
|
|
PlayBasicKilledResponse( Killer, Zed, BestOptionID );
|
|
}
|
|
|
|
/** Adds "on a roll" random dialog if player has killed enough zeds without taking damage */
|
|
function CheckOnARollDialog( KFPawn_Human Speaker, out int out_NumOptions, out int out_BestOptionID )
|
|
{
|
|
Speaker.UpdateKillStreak();
|
|
|
|
if( Speaker.ZedsKilledStreakAmt >= NumKillsForOnARoll )
|
|
{
|
|
AddRandomDialogOption( Speaker, `KILL_OnARoll, out_NumOptions, out_BestOptionID );
|
|
}
|
|
}
|
|
|
|
/** Adds "massacre" random dialog if enough zeds have been killed in a certain amount of time and within a certain radius */
|
|
function CheckMassacreDialog( KFPawn_Human Killer, KFPawn_Monster KilledZed, out int out_NumOptions, out int out_BestOptionID )
|
|
{
|
|
local int i, MassacreCount;
|
|
local KFGoreManager KFGM;
|
|
local KFPawn Corpse;
|
|
local float AreaRadiusSq;
|
|
|
|
KFGM = KFGoreManager(WorldInfo.MyGoreEffectManager);
|
|
|
|
if( KFGM == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
AreaRadiusSq = AreaRadiusForMassacre * AreaRadiusForMassacre;
|
|
|
|
// check corpses for proximity to KilledZed
|
|
for( i = 0; i < KFGM.CorpsePool.Length && MassacreCount < NumZedsInAreaForMassacre; ++i )
|
|
{
|
|
Corpse = KFGM.CorpsePool[i];
|
|
|
|
// don't count KilledZed toward massacre
|
|
if( Corpse == KilledZed )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// only check zeds that have died within the time limit for a "massacre"
|
|
if( `TimeSince(Corpse.TimeOfDeath) > TimeLimitForMassacre )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// only check zeds that are within the radius limit for a "massacre"
|
|
if( VSizeSq(Corpse.Location - KilledZed.Location) > AreaRadiusSq )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
++MassacreCount;
|
|
}
|
|
|
|
if( MassacreCount >= NumZedsInAreaForMassacre )
|
|
{
|
|
AddRandomDialogOption( Killer, `KILL_Massacre, out_NumOptions, out_BestOptionID );
|
|
}
|
|
}
|
|
|
|
/** Add "close call" random dialog if player killed zed right before zed killed him */
|
|
function CheckCloseCallKillDialog( KFPawn_Human Killer, KFPawn_Monster Zed, out int out_NumOptions, out int out_BestOptionID )
|
|
{
|
|
if( Killer.LastHitBy == Zed.MyKFAIC
|
|
&& (float(Killer.Health) / float(Killer.HealthMax) <= CloseCallKillHealthPctThreshold) )
|
|
{
|
|
AddRandomDialogOption( Killer, `KILL_CloseCall, out_NumOptions, out_BestOptionID );
|
|
}
|
|
}
|
|
|
|
function CheckKillAsLastAliveDialog( KFPawn_Human Killer, KFPawn_Monster Zed, out int out_NumOptions, out int out_BestOptionID )
|
|
{
|
|
if( KFGameInfo(WorldInfo.Game).GetLivingPlayerCount() == 1 )
|
|
{
|
|
AddRandomDialogOption( Killer, `KILL_AsLastPlayer, out_NumOptions, out_BestOptionID );
|
|
}
|
|
}
|
|
|
|
function CheckKilledWithFavoriteWeaponDialog( KFPawn_Human Killer, out int out_NumOptions, out int out_BestOptionID )
|
|
{
|
|
local int FavoriteWeaponIndex;
|
|
local KFCharacterInfo_Human KFCI;
|
|
|
|
KFCI = KFCharacterInfo_Human( Killer.CharacterArch );
|
|
if( KFCI == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
FavoriteWeaponIndex = KFCI.GetFavoriteWeaponIndexOf( Killer.Weapon );
|
|
if( FavoriteWeaponIndex < 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
AddRandomDialogOption( Killer, `KILL_Fave1 + FavoriteWeaponIndex, out_NumOptions, out_BestOptionID );
|
|
}
|
|
|
|
/** Set up response for selected "kill zed" dialog */
|
|
function PlayBasicKilledResponse( KFPawn_Human Killer, KFPawn_Monster KilledZed, int KilledEventID )
|
|
{
|
|
local int ResponseEventID;
|
|
local bool bPlayOnlyAsResponse;
|
|
|
|
switch( KilledEventID )
|
|
{
|
|
case `KILL_OnARoll:
|
|
ResponseEventID = `KILL_OnARollResp;
|
|
bPlayOnlyAsResponse = true;
|
|
break;
|
|
|
|
case `KILL_Massacre:
|
|
ResponseEventID = `KILL_MassacreResp;
|
|
bPlayOnlyAsResponse = true;
|
|
break;
|
|
|
|
case `KILL_Slashing:
|
|
ResponseEventID = `KILL_SlashingResp;
|
|
break;
|
|
|
|
case `KILL_Blunt:
|
|
ResponseEventID = `KILL_BluntResp;
|
|
break;
|
|
|
|
case `KILL_Ballistic:
|
|
ResponseEventID = `KILL_BallisticResp;
|
|
break;
|
|
|
|
case `KILL_Explosive:
|
|
ResponseEventID = `KILL_ExplosiveResp;
|
|
break;
|
|
|
|
case `KILL_Fire:
|
|
ResponseEventID = `KILL_FireResp;
|
|
break;
|
|
|
|
default:
|
|
return; // do nothing
|
|
};
|
|
|
|
PlayBasicDialogResponse( Killer, KilledEventID, ResponseEventID, /*Responder*/, KilledZed, bPlayOnlyAsResponse );
|
|
}
|
|
|
|
/************************************************
|
|
* Damage Zed Dialog
|
|
************************************************/
|
|
|
|
function PlayDamagedZedDialog( KFPawn_Human Damager, KFPawn_Monster Zed, class<DamageType> DamageType )
|
|
{
|
|
local int NumOptions, BestOptionID;
|
|
|
|
if( Damager.VoiceGroupArch == none || Damager.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
BestOptionID = -1;
|
|
|
|
if( Zed.IsDoingSpecialMove(SM_Knockdown) )
|
|
{
|
|
AddRandomDialogOption( Damager, `DAMZ_Knockdown, NumOptions, BestOptionID );
|
|
}
|
|
else if( Zed.IsDoingSpecialMove(SM_Stumble) )
|
|
{
|
|
AddRandomDialogOption( Damager, `DAMZ_Stumble, NumOptions, BestOptionID );
|
|
}
|
|
else if( Zed.IsDoingSpecialMove(SM_Stunned) )
|
|
{
|
|
AddRandomDialogOption( Damager, `DAMZ_Stun, NumOptions, BestOptionID );
|
|
}
|
|
|
|
if( class<KFDamageType>(DamageType) != none )
|
|
{
|
|
AddRandomDialogOption( Damager, class< KFDamageType >( DamageType ).static.GetDamagerDialogID(), NumOptions, BestOptionID );
|
|
}
|
|
|
|
PlayDialogEvent( Damager, BestOptionID );
|
|
}
|
|
|
|
/** Play "over and over" random dialog if player deals enough consecutive damage to a given zed
|
|
* NOTE: this needs to be called before zed's LastHitBy and LastPainTime are set for current hit */
|
|
function PlayDamageZedContinuousDialog( KFPawn_Human Damager, KFPawn_Monster Zed )
|
|
{
|
|
Damager.UpdateContinuousDamage( Zed, TimeBetweenHitsForContinuousDamage );
|
|
if( `TimeSince(Damager.InitialContinousDamageTime) >= TimeForContinuousDamageThreshold )
|
|
{
|
|
PlayDialogEvent( Damager, `DAMZ_OverAndOver );
|
|
}
|
|
}
|
|
|
|
/** Add "dead horse" random dialog if player hits a corpse repeatedly */
|
|
function PlayBeatDeadHorseDialog( KFPawn_Human Speaker, KFPawn_Monster DeadZed )
|
|
{
|
|
if( DeadZed.DeadHorseHitStreakAmt < NumHitsForDeadHorse && `TimeSince(DeadZed.LastDeadHorseHitTime) < TimeBetweenHitsForDeadHorse )
|
|
{
|
|
DeadZed.UpdateDeadHorseStreak( true );
|
|
}
|
|
else
|
|
{
|
|
DeadZed.UpdateDeadHorseStreak( false );
|
|
}
|
|
|
|
if( DeadZed.DeadHorseHitStreakAmt >= NumHitsForDeadHorse )
|
|
{
|
|
PlayDialogEvent( Speaker, `KILL_BeatDeadHorse );
|
|
PlayBasicDialogResponse( Speaker, `KILL_BeatDeadHorse, `KILL_BeatDeadHorseResp, /*Responder*/, DeadZed );
|
|
}
|
|
}
|
|
|
|
/************************************************
|
|
* Player Damage Dialog
|
|
************************************************/
|
|
|
|
function PlayPlayerDamageDialog( KFPawn_Human Player, class< DamageType > DamageType, int Damage )
|
|
{
|
|
local int NumOptions, BestOptionID;
|
|
|
|
if( Player.VoiceGroupArch == none || Player.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
BestOptionID = -1;
|
|
|
|
if( (float(Player.Health) / float(Player.HealthMax) < PlayerHealthPctForNearDeath) )
|
|
{
|
|
AddRandomDialogOption( Player, `DAMP_NearDeath, NumOptions, BestOptionID );
|
|
}
|
|
else
|
|
{
|
|
CheckPlayerDamageGeneric( Player, Damage, NumOptions, BestOptionID );
|
|
}
|
|
|
|
if( class<KFDamageType>(DamageType) != none )
|
|
{
|
|
AddRandomDialogOption( Player, class<KFDamageType>(DamageType).static.GetDamageeDialogID(), NumOptions, BestOptionID );
|
|
|
|
// if player has been blinded (due to toxic damage, though berserker doesn't get blinded), add "blinded" random option
|
|
if( ClassIsChildOf(DamageType, class'KFDT_Toxic') && !ClassIsChildOf(Player.GetPerk().Class, class'KFPerk_Berserker') )
|
|
{
|
|
AddRandomDialogOption( Player, `DAMP_Blinded, NumOptions, BestOptionID );
|
|
}
|
|
}
|
|
|
|
PlayDialogEvent( Player, BestOptionID );
|
|
|
|
// if playing "blinded" dialog, prepare for "blinded" dialog response
|
|
if( BestOptionID == `DAMP_Blinded )
|
|
{
|
|
PlayBasicDialogResponse( Player, `DAMP_Blinded, `DAMP_BlindedResp, /*Responder*/, /*Target*/, true );
|
|
}
|
|
}
|
|
|
|
/** Add generic damage vocalizations depending on how hard the player was hit */
|
|
function CheckPlayerDamageGeneric( KFPawn_Human Player, int Damage, out int out_NumOptions, out int out_BestOptionID )
|
|
{
|
|
local float DamageTakenStreakPct;
|
|
|
|
Player.UpdateDamageTakenStreak( Damage, PlayerTakeDamageStreakInterval );
|
|
DamageTakenStreakPct = float( Player.DamageTakenStreakAmt ) / float( Player.HealthMax );
|
|
if( DamageTakenStreakPct >= PlayerTakeDamageStreakPctForScream )
|
|
{
|
|
AddRandomDialogOption( Player, `DAMP_Scream, out_NumOptions, out_BestOptionID );
|
|
}
|
|
else
|
|
{
|
|
AddRandomDialogOption( Player, `DAMP_Grunt, out_NumOptions, out_BestOptionID );
|
|
}
|
|
}
|
|
|
|
function PlayPlayerGrabbedDialog( KFPawn_Human Speaker )
|
|
{
|
|
if( Speaker != none )
|
|
{
|
|
PlayDialogEvent( Speaker, `SPOTZ_GrabbedMe );
|
|
}
|
|
}
|
|
|
|
function PlayPlayerGrabbedByPatriarchDialog( KFPawn_Human Speaker )
|
|
{
|
|
if( Speaker != none )
|
|
{
|
|
PlayDialogEvent( Speaker, `SPOTZ_PulledMeIn );
|
|
}
|
|
}
|
|
|
|
/************************************************
|
|
* Player Death Dialog
|
|
************************************************/
|
|
|
|
function PlayPlayerDeathDialog( KFPawn_Human Player )
|
|
{
|
|
local KFPawn_Human KFPH;
|
|
local float MaxDistanceSq;
|
|
|
|
if( Player.VoiceGroupArch == none || Player.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
PlayDialogEvent( Player, `DAMP_Dying );
|
|
|
|
MaxDistanceSq = GetEventRadiusSq( `DAMP_SpotTeamDeathLast, Player.GetVoiceGroupEventDataClass() );
|
|
|
|
foreach WorldInfo.AllPawns( class'KFPawn_Human', KFPH )
|
|
{
|
|
if( !PawnIsValidPlayer(KFPH) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( PawnCanSpotPawn(KFPH, Player, MaxDistanceSq, GetEventFOV(`DAMP_SpotTeamDeathLast, KFPH.GetVoiceGroupEventDataClass()), true) )
|
|
{
|
|
// player just saw only other player die
|
|
if( KFGameInfo(WorldInfo.Game).GetLivingPlayerCount() == 1 )
|
|
{
|
|
PlayDialogEvent( KFPH, `DAMP_SpotTeamDeathLast );
|
|
}
|
|
// player just saw female teammate die
|
|
else if( KFCharacterInfo_Human(KFPH.CharacterArch).bIsFemale )
|
|
{
|
|
PlayDialogEvent( KFPH, `DAMP_SpotTeamDeathF );
|
|
}
|
|
// player just saw male teammate die
|
|
else
|
|
{
|
|
PlayDialogEvent( KFPH, `DAMP_SpotTeamDeathM );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/************************************************
|
|
* Spot Zed Dialog
|
|
************************************************/
|
|
|
|
/** Compares priority of two events */
|
|
function bool CheckSpottedDialogPriority( KFPawn_Human Spotter, int CheckEventID, int BestEventID )
|
|
{
|
|
local DialogEventInfo CheckEventInfo, BestEventInfo;
|
|
|
|
if( BestEventID < 0 )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
CheckEventInfo = Spotter.VoiceGroupArch.static.GetDialogEventInfo(CheckEventID);
|
|
BestEventInfo = Spotter.VoiceGroupArch.static.GetDialogEventInfo(BestEventID);
|
|
|
|
if( CheckEventInfo.Priority > BestEventInfo.Priority )
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/** Called when a zed spots a player (line of sight check has already passed).
|
|
* We use this in reverse... when a zed spots a player, then check if the player spots the zed
|
|
*/
|
|
function CheckSpotMonsterDialog( Pawn Spotter, KFPawn_Monster Spotted )
|
|
{
|
|
local int SpottedDialogEventID, BestSpottedEventID;
|
|
local KFPawn_Human KFPHSpotter;
|
|
local class<KFPawnVoiceGroupEventData> EventDataClass;
|
|
|
|
BestSpottedEventID = -1;
|
|
|
|
Spotted.MyKFAIC.bWasVisibleToEnemy = Spotted.MyKFAIC.bIsVisibleToEnemy;
|
|
|
|
KFPHSpotter = KFPawn_Human(Spotter);
|
|
if (KFPHSpotter == none)
|
|
{
|
|
return;
|
|
}
|
|
|
|
EventDataClass = KFPHSpotter.GetVoiceGroupEventDataClass();
|
|
|
|
// if zed is within FOV
|
|
if( ActorWithinPawnFOV(Spotted, Spotter, GetEventFOV(`SPOTZ_Generic, EventDataClass)) )
|
|
{
|
|
Spotted.MyKFAIC.bIsVisibleToEnemy = true;
|
|
|
|
// if zed just entered a player's view
|
|
if( !Spotted.MyKFAIC.bWasVisibleToEnemy && Spotted.MyKFAIC.bIsVisibleToEnemy )
|
|
{
|
|
// if zed is within "surprise" (really close) range
|
|
if( ActorWithinPawnRadius(Spotted, Spotter, GetEventRadius(`SPOTZ_Surprise, EventDataClass)) )
|
|
{
|
|
PlayDialogEvent( KFPHSpotter, `SPOTZ_Surprise );
|
|
}
|
|
else if( ActorWithinPawnRadius(Spotted, Spotter, GetEventRadius(`SPOTZ_Generic, EventDataClass)) )
|
|
{
|
|
SpottedDialogEventID = Spotted.GetSpotterDialogID();
|
|
if( CheckSpottedDialogPriority(KFPHSpotter, SpottedDialogEventID, BestSpottedEventID) )
|
|
{
|
|
BestSpottedEventID = SpottedDialogEventID;
|
|
}
|
|
PlayDialogEvent( KFPHSpotter, BestSpottedEventID );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Spotted.MyKFAIC.bIsVisibleToEnemy = false;
|
|
}
|
|
}
|
|
|
|
/** Check all of the things that can be spotted and pick the best one to comment on.
|
|
* Called from Tick.
|
|
*/
|
|
function CheckSpottedDialog()
|
|
{
|
|
local Pawn P;
|
|
local KFPawn_Human KFPH;
|
|
local KFPawn_Monster BestMonster;
|
|
local int SpottedCount, SpottedEventID;
|
|
|
|
local int NumOptions, BestOptionID;
|
|
|
|
SpottedEventID = -1;
|
|
BestOptionID = -1;
|
|
|
|
// we only check one human pawn per call to CheckSpottedDialog, so we cache the next pawn we need to check.
|
|
// if that pawn is invalid, reset it.
|
|
if( NextSpotterPawn == none || NextSpotterPawn.bDeleteMe || !NextSpotterPawn.IsAliveAndWell() )
|
|
{
|
|
NextSpotterPawn = WorldInfo.PawnList;
|
|
}
|
|
|
|
// check what each player can spot
|
|
for( P = NextSpotterPawn; P != none; P = P.NextPawn )
|
|
{
|
|
KFPH = KFPawn_Human(P);
|
|
if( KFPH == none || !PawnIsValidPlayer(KFPH) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// only call out zeds if you haven't been engaged with zeds for a little while
|
|
if( KFPH.TimeSpentIdling() > IdleTimeForSpottingZed )
|
|
{
|
|
// FindBestSpottedMonster checks proximity, FOV, and dialog priority, but NOT line-of-sight.
|
|
// We check line of sight only against the BestMonster returned by FindBestSpottedMonster for performance's sake.
|
|
BestMonster = FindBestSpottedMonster( KFPH, SpottedCount, SpottedEventID );
|
|
if( BestMonster != none && FastTrace(KFPH.GetPawnViewLocation(), BestMonster.Location) )
|
|
{
|
|
AddRandomDialogOption( KFPH, SpottedEventID, NumOptions, BestOptionID );
|
|
|
|
if( float(BestMonster.Health) / float(BestMonster.HealthMax) <= ZedAlmostDeadHealthPctThreshold )
|
|
{
|
|
AddRandomDialogOption( KFPH, `SPOTZ_AlmostDead, NumOptions, BestOptionID );
|
|
}
|
|
|
|
if( SpottedCount >= SpotLargeHordeNumZeds )
|
|
{
|
|
AddRandomDialogOption( KFPH, `SPOTZ_Horde, NumOptions, BestOptionID );
|
|
}
|
|
|
|
// check if BestMonster is "behind" any teammates
|
|
if( SpotEnemyBehindPlayer(KFPH, BestMonster) )
|
|
{
|
|
AddRandomDialogOption( KFPH, `SPOTZ_Behind, NumOptions, BestOptionID );
|
|
}
|
|
}
|
|
}
|
|
|
|
// SprintTowardZedStartTime is set/reset in FindBestSpottedMonster, called above
|
|
if( KFPH.SprintTowardZedStartTime > 0 && `TimeSince(KFPH.SprintTowardZedStartTime) >= SprintTowardZedDuration )
|
|
{
|
|
AddRandomDialogOption( KFPH, `DAMZ_SprintToward, NumOptions, BestOptionID );
|
|
}
|
|
|
|
// only check for SpotItem and SpotAmmo dialog if we haven't already added higher priority dialog (like SpotZed)
|
|
if( BestOptionID < 0 || GetEventPriority(BestOptionID, KFPH.GetVoiceGroupEventDataClass()) >= 5 )
|
|
{
|
|
CheckSpotPickupsDialog( KFPH, NumOptions, BestOptionID );
|
|
}
|
|
|
|
PlayDialogEvent( KFPH, BestOptionID );
|
|
PlayBasicSpottedResponse(KFPH, BestMonster, BestOptionID);
|
|
|
|
// since we're only checking one pawn per call, cache the next pawn in line and break
|
|
NextSpotterPawn = KFPH.NextPawn;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/** Finds the best zed to comment on based on proximity, field of view, and zed dialog priority */
|
|
function KFPawn_Monster FindBestSpottedMonster( KFPawn_Human Spotter, out int NumSpotted, out int BestSpottedEventID )
|
|
{
|
|
local Pawn MP;
|
|
local KFPawn_Monster KFPM, BestMonster;
|
|
local int SpottedDialogEventID;
|
|
local bool bSprintingTowardZed;
|
|
local class<KFPawnVoiceGroupEventData> EventDataClass;
|
|
|
|
EventDataClass = Spotter.GetVoiceGroupEventDataClass();
|
|
|
|
for( MP = WorldInfo.PawnList; MP != none; MP = MP.NextPawn )
|
|
{
|
|
if( !MP.IsAliveAndWell() || MP.GetTeamNum() == 0 )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
KFPM = KFPawn_Monster( MP );
|
|
if( KFPM == none )
|
|
{
|
|
// should never happen, right?
|
|
continue;
|
|
}
|
|
|
|
if( KFPM.bIsHeadless )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( VSizeSq(KFPM.Location - Spotter.Location) >= GetEventRadiusSq(`SPOTZ_Generic, EventDataClass) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( ActorWithinPawnFOV(KFPM, Spotter, GetEventFOV(`SPOTZ_Generic, EventDataClass)) )
|
|
{
|
|
NumSpotted++;
|
|
|
|
SpottedDialogEventID = KFPM.GetSpotterDialogID();
|
|
|
|
// check priority of spotted dialog event for this zed against priority of best-so-far zed
|
|
if( CheckSpottedDialogPriority(Spotter, SpottedDialogEventID, BestSpottedEventID) )
|
|
{
|
|
BestSpottedEventID = SpottedDialogEventID;
|
|
BestMonster = KFPM;
|
|
}
|
|
|
|
// check if player is charging toward a zed
|
|
if( Spotter.bIsSprinting && !bSprintingTowardZed && ActorWithinPawnFOV(KFPM, Spotter, GetEventFOV(`DAMZ_SprintToward, EventDataClass)) )
|
|
{
|
|
bSprintingTowardZed = true;
|
|
if( Spotter.SprintTowardZedStartTime < 0 )
|
|
{
|
|
Spotter.SprintTowardZedStartTime = WorldInfo.TimeSeconds;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// reset sprint-toward-zed start time if not sprinting toward zed
|
|
if( !bSprintingTowardZed )
|
|
{
|
|
Spotter.SprintTowardZedStartTime = -1;
|
|
}
|
|
|
|
return BestMonster;
|
|
}
|
|
|
|
/** Checks if given zed is within spotter's view and right behind another player */
|
|
function bool SpotEnemyBehindPlayer( KFPawn_Human Spotter, KFPawn_Monster Enemy )
|
|
{
|
|
local Pawn OtherPlayer;
|
|
local vector FacingDir, ToEnemyDir, ToPlayerDir;
|
|
local float EventRadiusSq;
|
|
local class<KFPawnVoiceGroupEventData> EventDataClass;
|
|
|
|
EventDataClass = Spotter.GetVoiceGroupEventDataClass();
|
|
|
|
for( OtherPlayer = WorldInfo.PawnList; OtherPlayer != none; OtherPlayer = OtherPlayer.NextPawn )
|
|
{
|
|
if( !OtherPlayer.IsAliveAndWell() || OtherPlayer.GetTeamNum() != 0 || OtherPlayer == Spotter )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// check if the player is within view
|
|
ToPlayerDir = OtherPlayer.Location - Spotter.Location;
|
|
if( VSizeSq(ToPlayerDir) >= GetEventRadiusSq(`SPOTZ_Generic, EventDataClass) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
FacingDir = vector( Spotter.Rotation );
|
|
ToPlayerDir = Normal( ToPlayerDir );
|
|
|
|
if( ToPlayerDir dot FacingDir < GetEventFOV(`SPOTZ_Generic, EventDataClass) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
EventRadiusSq = GetEventRadiusSq(`SPOTZ_Behind, EventDataClass);
|
|
|
|
// check if Enemy is within "behind view" of the player
|
|
ToEnemyDir = Enemy.Location - OtherPlayer.Location;
|
|
if( VSizeSq(ToEnemyDir) >= EventRadiusSq )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
FacingDir = vector( OtherPlayer.Rotation );
|
|
ToEnemyDir = Normal( ToEnemyDir );
|
|
|
|
if( ToEnemyDir dot FacingDir <= -GetEventFOV(`SPOTZ_Behind, EventDataClass) )
|
|
{
|
|
// only consider behind if we can actually see the player whom Enemy is behind
|
|
if( FastTrace(Spotter.GetPawnViewLocation(), OtherPlayer.GetPawnViewLocation()) )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// for efficiency's sake, break out after we find one good candidate, even if we don't succeed trace
|
|
break;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/** Checks if Spotter can see any pickups in the map */
|
|
function CheckSpotPickupsDialog( KFPawn_Human Spotter, out int out_NumOptions, out int out_BestOptionID )
|
|
{
|
|
local int i;
|
|
local KFGameInfo KFGI;
|
|
local bool bSpottedWeapon, bSpottedArmor, bSpottedAmmo;
|
|
local class< KFPawnVoiceGroupEventData > EventDataClass;
|
|
|
|
KFGI = KFGameInfo( WorldInfo.Game );
|
|
|
|
if( KFGI == none )
|
|
{
|
|
// should never happen, right?
|
|
return;
|
|
}
|
|
|
|
EventDataClass = Spotter.GetVoiceGroupEventDataClass();
|
|
|
|
for( i = 0; i < KFGI.AllPickupFactories.Length; ++i )
|
|
{
|
|
// ignore factories without visible pickups
|
|
if( KFGI.AllPickupFactories[i].bPickupHidden )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// ignore weapon factories if a weapon was already spotted
|
|
if( KFGI.AllPickupFactories[i].CurrentPickupIsWeapon() && bSpottedWeapon )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// ignore armor factories if armor was already spotted
|
|
if( KFGI.AllPickupFactories[i].CurrentPickupIsArmor() && bSpottedArmor )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// ignore ammo factories if ammo was already spotted
|
|
if( KFGI.AllPickupFactories[i].CurrentPickupIsAmmo() && bSpottedAmmo )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( !PawnCanSpotActor(Spotter, KFGI.AllPickupFactories[i], GetEventRadiusSq(`ACT_SpotWeap, EventDataClass), GetEventFOV(`ACT_SpotWeap, EventDataClass), true) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( KFGI.AllPickupFactories[i].CurrentPickupIsWeapon() )
|
|
{
|
|
AddRandomDialogOption( Spotter, `ACT_SpotWeap, out_NumOptions, out_BestOptionID );
|
|
bSpottedWeapon = true;
|
|
}
|
|
else if( KFGI.AllPickupFactories[i].CurrentPickupIsArmor() )
|
|
{
|
|
AddRandomDialogOption( Spotter, `ACT_SpotArmor, out_NumOptions, out_BestOptionID );
|
|
bSpottedArmor = true;
|
|
}
|
|
else if( KFGI.AllPickupFactories[i].CurrentPickupIsAmmo() )
|
|
{
|
|
AddRandomDialogOption( Spotter, `ACT_SpotAmmo, out_NumOptions, out_BestOptionID );
|
|
bSpottedAmmo = true;
|
|
}
|
|
|
|
// break out early if we've added all possible random dialog for pickups
|
|
if( bSpottedWeapon && bSpottedArmor && bSpottedAmmo )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Checks if any player can spot a zed that just cloaked/uncloaked */
|
|
function PlaySpotCloakDialog( KFPawn_Monster Cloaker, bool bNewCloaking )
|
|
{
|
|
local KFPawn_Human KFPH;
|
|
|
|
foreach WorldInfo.AllPawns( class'KFPawn_Human', KFPH )
|
|
{
|
|
if( !PawnIsValidPlayer(KFPH) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( PlayerCanSpotEnemy(KFPH, Cloaker) )
|
|
{
|
|
if( bNewCloaking )
|
|
{
|
|
PlayDialogEvent( KFPH, `SPOTZ_JustCloaked );
|
|
}
|
|
else
|
|
{
|
|
PlayDialogEvent( KFPH, `SPOTZ_JustUncloaked );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Checks if any player can spot a zed that just became enraged */
|
|
function PlaySpotEnragedDialog( KFPawn_Monster EnragedEnemy )
|
|
{
|
|
local KFPawn_Human KFPH;
|
|
|
|
foreach WorldInfo.AllPawns( class'KFPawn_Human', KFPH )
|
|
{
|
|
if( !PawnIsValidPlayer(KFPH) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( PlayerCanSpotEnemy(KFPH, EnragedEnemy) )
|
|
{
|
|
PlayDialogEvent( KFPH, `SPOTZ_RagingAtMe );
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Checks if player being charged can spot the zed charging him */
|
|
function PlaySpotChargeDialog( KFPawn_Monster ChargingEnemy, KFPawn TargetPlayer )
|
|
{
|
|
local KFPawn_Human KFPH;
|
|
|
|
KFPH = KFPawn_Human( TargetPlayer );
|
|
if( KFPH == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( KFPH.VoiceGroupArch == none || KFPH.VoiceGroupArch.default.EventDataClass == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( PlayerCanSpotEnemy(KFPH, ChargingEnemy) )
|
|
{
|
|
PlayDialogEvent( KFPH, `SPOTZ_ChargingAtMe );
|
|
}
|
|
}
|
|
|
|
/** Checks if any player can spot a zed about to shoot a rocket */
|
|
function PlaySpotRocketsDialog( KFPawn_Monster Spotted )
|
|
{
|
|
local KFPawn_Human KFPH;
|
|
local class< KFPawnVoiceGroupEventData > EventDataClass;
|
|
|
|
foreach WorldInfo.AllPawns( class'KFPawn_Human', KFPH )
|
|
{
|
|
if( !PawnIsValidPlayer(KFPH) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
EventDataClass = KFPH.GetVoiceGroupEventDataClass();
|
|
|
|
if( PlayerCanSpotEnemy(KFPH, Spotted, GetEventRadiusSq(`SPOTZ_ShootingRockets, EventDataClass), GetEventFOV(`SPOTZ_ShootingRockets, EventDataClass)) )
|
|
{
|
|
PlayDialogEvent( KFPH, `SPOTZ_ShootingRockets );
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Checks if any player can spot a zed about to throw a grenade */
|
|
function PlaySpotGrenadeDialog( KFPawn_Monster Spotted )
|
|
{
|
|
local KFPawn_Human KFPH;
|
|
local class< KFPawnVoiceGroupEventData > EventDataClass;
|
|
|
|
foreach WorldInfo.AllPawns( class'KFPawn_Human', KFPH )
|
|
{
|
|
if( !PawnIsValidPlayer(KFPH) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
EventDataClass = KFPH.GetVoiceGroupEventDataClass();
|
|
|
|
if( PlayerCanSpotEnemy(KFPH, Spotted, GetEventRadiusSq(`SPOTZ_ThrowGrenade, EventDataClass), GetEventFOV(`SPOTZ_ThrowGrenade, EventDataClass)) )
|
|
{
|
|
PlayDialogEvent( KFPH, `SPOTZ_ThrowGrenade );
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Checks if a player being shot at can see shooter */
|
|
function PlayBeingShotAtDialog( KFPawn_Human Target, KFPawn_Monster Shooter )
|
|
{
|
|
local class< KFPawnVoiceGroupEventData > EventDataClass;
|
|
|
|
if( Target == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
EventDataClass = Target.GetVoiceGroupEventDataClass();
|
|
|
|
if( PlayerCanSpotEnemy(Target, Shooter, GetEventRadiusSq(`SPOTZ_ShootingAtMe, EventDataClass), GetEventFOV(`SPOTZ_ShootingAtMe, EventDataClass)) )
|
|
{
|
|
PlayDialogEvent( Target, `SPOTZ_ShootingAtMe );
|
|
}
|
|
}
|
|
|
|
/** Checks if any player can spot a zed about to heal */
|
|
function PlaySpotZedHealingDialog( KFPawn_Monster Spotted )
|
|
{
|
|
local KFPawn_Human KFPH;
|
|
|
|
foreach WorldInfo.AllPawns( class'KFPawn_Human', KFPH )
|
|
{
|
|
if( !PawnIsValidPlayer(KFPH) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( PlayerCanSpotEnemy(KFPH, Spotted) )
|
|
{
|
|
PlayDialogEvent( KFPH, `SPOTZ_Healing );
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Checks if any player can spot a zed that is running away */
|
|
function PlaySpotRunAwayDialog( KFPawn_Monster Spotted )
|
|
{
|
|
local KFPawn_Human KFPH;
|
|
|
|
foreach WorldInfo.AllPawns( class'KFPawn_Human', KFPH )
|
|
{
|
|
if( !PawnIsValidPlayer(KFPH) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( PlayerCanSpotEnemy(KFPH, Spotted) )
|
|
{
|
|
PlayDialogEvent( KFPH, `SPOTZ_RunningAway );
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Checks if player who could see boss can no longer see boss */
|
|
function PlayLoseSightOfBossDialog( KFPawn_Monster Boss, KFPawn_Human Speaker )
|
|
{
|
|
local class< KFPawnVoiceGroupEventData > EventDataClass;
|
|
|
|
EventDataClass = Speaker.GetVoiceGroupEventDataClass();
|
|
|
|
if( ActorWithinPawnFOV(Boss, Speaker, GetEventFOV(`SPOTZ_NotSeen, EventDataClass)) )
|
|
{
|
|
PlayDialogEvent( Speaker, `SPOTZ_NotSeen );
|
|
}
|
|
}
|
|
|
|
/** Sets up basic response for spoken "spotted" dialog */
|
|
function PlayBasicSpottedResponse( KFPawn_Human Spotter, KFPawn_Monster Spotted, int SpottedEventID )
|
|
{
|
|
local int ResponseEventID;
|
|
|
|
if( Spotted == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch( SpottedEventID )
|
|
{
|
|
case `SPOTZ_Siren:
|
|
ResponseEventID = `SPOTZ_FemaleResp;
|
|
break;
|
|
|
|
case `SPOTZ_Fleshpound:
|
|
case `SPOTZ_Scrake:
|
|
case `SPOTZ_BossGeneric: // ?
|
|
case `SPOTZ_BossFemale: // ?
|
|
ResponseEventID = `SPOTZ_BigZedResp;
|
|
break;
|
|
|
|
case `SPOTZ_Generic:
|
|
ResponseEventID =`SPOTZ_GenericResp;
|
|
break;
|
|
|
|
default:
|
|
return; // do nothing
|
|
};
|
|
|
|
PlayBasicDialogResponse( Spotter, SpottedEventID, ResponseEventID, /*Responder*/, Spotted, true );
|
|
}
|
|
|
|
/************************************************
|
|
* Situational Dialog
|
|
************************************************/
|
|
|
|
/** Checks if any player should play idle dialog */
|
|
function CheckIdleDialog()
|
|
{
|
|
local KFPawn_Human KFPH;
|
|
|
|
foreach WorldInfo.AllPawns( class'KFPawn_Human', KFPH )
|
|
{
|
|
if( !PawnIsValidPlayer(KFPH) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( KFPH.TimeSpentIdling() > IdleTimeForSituationalDialog )
|
|
{
|
|
PlaySituationalDialog( KFPH );
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Plays idle/situational dialog for a given speaker to a target player */
|
|
function PlaySituationalDialog( KFPawn_Human Speaker )
|
|
{
|
|
local KFPawn_Human Target;
|
|
local class< KFPawnVoiceGroupEventData > EventDataClass;
|
|
|
|
EventDataClass = Speaker.GetVoiceGroupEventDataClass();
|
|
|
|
foreach WorldInfo.AllPawns( class'KFPawn_Human', Target )
|
|
{
|
|
if( Target == Speaker || !PawnIsValidPlayer(Target) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( PawnCanSpotPawn(Speaker, Target, GetEventRadiusSq(`SITU_General, EventDataClass), GetEventFOV(`SITU_General, EventDataClass)) )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
PlayRandomSituationalDialog( Speaker, Target );
|
|
}
|
|
|
|
/** Calculates situational dialog options, then plays a random one */
|
|
function PlayRandomSituationalDialog( KFPawn_Human Speaker, KFPawn_Human Target )
|
|
{
|
|
local int NumPlayers, NumLivingPlayers;
|
|
|
|
local int NumOptions, BestOptionID;
|
|
|
|
NumPlayers = WorldInfo.Game.NumPlayers;
|
|
NumLivingPlayers = KFGameInfo( WorldInfo.Game ).GetLivingPlayerCount();
|
|
|
|
BestOptionID = -1;
|
|
|
|
// add option for environmental dialog (dark, cold, etc.) if player is within certain volumes
|
|
if( Speaker.EnvironmentDialogEventID > 0 )
|
|
{
|
|
AddRandomDialogOption( Speaker, Speaker.EnvironmentDialogEventID, NumOptions, BestOptionID );
|
|
}
|
|
|
|
// if speaker has someone to speak to, play conversational dialog
|
|
if( Target != none )
|
|
{
|
|
if( Target.MyKFWeapon != none && Target.MyKFWeapon.GetMaxAmmoAmount(0) > 0 )
|
|
{
|
|
AddRandomDialogOption( Speaker, `SITU_AmmoCheck, NumOptions, BestOptionID );
|
|
}
|
|
AddRandomDialogOption( Speaker, `SITU_HealthCheck, NumOptions, BestOptionID );
|
|
AddRandomDialogOption( Speaker, `SITU_General, NumOptions, BestOptionID );
|
|
|
|
if( NumLivingPlayers == NumPlayers )
|
|
{
|
|
AddRandomDialogOption( Speaker, `SITU_AllAlive, NumOptions, BestOptionID );
|
|
}
|
|
else if( NumLivingPlayers > NumPlayers / 2 )
|
|
{
|
|
AddRandomDialogOption( Speaker, `SITU_MostAlive, NumOptions, BestOptionID );
|
|
}
|
|
else if( NumLivingPlayers == NumPlayers / 2 )
|
|
{
|
|
AddRandomDialogOption( Speaker, `SITU_HalfAlive, NumOptions, BestOptionID );
|
|
}
|
|
|
|
if( Speaker.PlayerReplicationInfo.Score >= IdleHighDoshThreshold )
|
|
{
|
|
AddRandomDialogOption( Speaker, `SITU_LotsOfDosh, NumOptions, BestOptionID );
|
|
}
|
|
else if( Speaker.PlayerReplicationInfo.Score <= IdleLowDoshThreshold )
|
|
{
|
|
AddRandomDialogOption( Speaker, `SITU_LittleDosh, NumOptions, BestOptionID );
|
|
}
|
|
|
|
PlayDialogEvent( Speaker, BestOptionID );
|
|
PlayCustomDialogResponse( Speaker, Target, BestOptionID, PlayRandomSituationalResponse, true );
|
|
}
|
|
// otherwise talk to self
|
|
else if( NumPlayers > 1 && NumLivingPlayers == 1 )
|
|
{
|
|
AddRandomDialogOption( Speaker, `SITU_TalkSelf, NumOptions, BestOptionID );
|
|
}
|
|
|
|
PlayDialogEvent( Speaker, BestOptionID );
|
|
}
|
|
|
|
/** Plays response to random situational dialog */
|
|
function PlayRandomSituationalResponse( const out DialogResponseInfo RespInfo )
|
|
{
|
|
local int ResponseID, ResponderDoshAmt;
|
|
local float ResponderHealthPct, ResponderAmmoPCt;
|
|
|
|
ResponseID = -1;
|
|
|
|
switch( RespInfo.RespondingToID )
|
|
{
|
|
case `SITU_HealthCheck:
|
|
ResponderHealthPct = RespInfo.Speaker.GetHealthPercentage();
|
|
if( ResponderHealthPct >= NeedNoMoreHealingPctThreshold )
|
|
{
|
|
ResponseID = `SITU_HealthCheckRespHigh;
|
|
}
|
|
else if( ResponderHealthPct < NeedMoreHealingPctThreshold )
|
|
{
|
|
ResponseID = `SITU_HealthCheckRespLow;
|
|
}
|
|
break;
|
|
|
|
case `SITU_AmmoCheck:
|
|
ResponderAmmoPCt = RespInfo.Speaker.MyKFWeapon.GetAmmoPercentage();
|
|
if( ResponderAmmoPct >= 0.f )
|
|
{
|
|
if( ResponderAmmoPct > IdleHighAmmoPctThreshold)
|
|
{
|
|
ResponseID = `SITU_AmmoCheckRespHigh;
|
|
}
|
|
else if( ResponderAmmoPCt < IdleLowAmmoPctThreshold)
|
|
{
|
|
ResponseID = `SITU_AmmoCheckRespLow;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case `SITU_AllAlive:
|
|
ResponseID = `SITU_AllAliveResp;
|
|
break;
|
|
|
|
case `SITU_HalfAlive:
|
|
ResponseID = `SITU_HalfAliveResp;
|
|
break;
|
|
|
|
case `SITU_MostAlive:
|
|
ResponseID = `SITU_MostAliveResp;
|
|
break;
|
|
|
|
case `SITU_LotsOfDosh:
|
|
ResponderDoshAmt = RespInfo.Speaker.PlayerReplicationInfo.Score;
|
|
if( ResponderDoshAmt > IdleHighDoshThreshold)
|
|
{
|
|
ResponseID = `SITU_LotsOfDoshRespLots;
|
|
}
|
|
else if( ResponderDoshAmt < IdleLowDoshThreshold )
|
|
{
|
|
ResponseID = `SITU_LotsOfDoshRespLittle;
|
|
}
|
|
break;
|
|
|
|
case `SITU_LittleDosh:
|
|
ResponderDoshAmt = RespInfo.Speaker.PlayerReplicationInfo.Score;
|
|
if( ResponderDoshAmt < IdleLowDoshThreshold )
|
|
{
|
|
ResponseID = `SITU_LittleDoshResp;
|
|
}
|
|
break;
|
|
};
|
|
|
|
if( ResponseID >= 0 )
|
|
{
|
|
PlayDialogEvent( RespInfo.Speaker, ResponseID );
|
|
}
|
|
}
|
|
|
|
/** Plays the "wave start" dialog from a random pawn */
|
|
function PlayWaveStartDialog( bool bBossWave )
|
|
{
|
|
local int RandomPlayer;
|
|
local KFPawn_Human KFPH;
|
|
|
|
RandomPlayer = rand( KFGameInfo(WorldInfo.Game).GetLivingPlayerCount() );
|
|
|
|
foreach WorldInfo.AllPawns( class'KFPawn_Human', KFPH )
|
|
{
|
|
if( PawnIsValidPlayer(KFPH) && (RandomPlayer-- == 0) )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( bBossWave )
|
|
{
|
|
PlayDialogEvent( KFPH, `SITU_WaveStartBoss );
|
|
}
|
|
else
|
|
{
|
|
PlayDialogEvent( KFPH, `SITU_WaveStartGeneral );
|
|
}
|
|
}
|
|
|
|
function PlayEnvironmentalDialog( KFPawn_Human Speaker, int EventID )
|
|
{
|
|
PlayDialogEvent( Speaker, EventID );
|
|
}
|
|
|
|
/************************************************
|
|
* Objective Dialog
|
|
************************************************/
|
|
|
|
function PlayAcceptObjectiveDialog( array<PlayerReplicationInfo> PRIsInObj )
|
|
{
|
|
local array< KFPawn_Human > PawnsInObj;
|
|
|
|
GetHumanPawnsInObj( PawnsInObj, PRIsInObj );
|
|
PlayObjectiveDialogOnRandomPlayers( PawnsInObj, `OBJ_Accept );
|
|
}
|
|
|
|
function PlayDeclineObjectiveDialog( array<PlayerReplicationInfo> PRIsInObj )
|
|
{
|
|
local array< KFPawn_Human > PawnsInObj;
|
|
|
|
GetHumanPawnsInObj( PawnsInObj, PRIsInObj );
|
|
PlayObjectiveDialogOnRandomPlayers( PawnsInObj, `OBJ_Decline );
|
|
}
|
|
|
|
function PlayWinObjectiveDialog( array<PlayerReplicationInfo> PRIsInObj )
|
|
{
|
|
local array< KFPawn_Human > PawnsInObj;
|
|
|
|
GetHumanPawnsInObj( PawnsInObj, PRIsInObj );
|
|
PlayObjectiveDialogOnRandomPlayers( PawnsInObj, `OBJ_Win, `OBJ_WinResp );
|
|
}
|
|
|
|
function PlayLoseObjectiveDialog( array<PlayerReplicationInfo> PRIsInObj )
|
|
{
|
|
local array< KFPawn_Human > PawnsInObj;
|
|
|
|
GetHumanPawnsInObj( PawnsInObj, PRIsInObj );
|
|
PlayObjectiveDialogOnRandomPlayers( PawnsInObj, `OBJ_Lose, `OBJ_LoseResp );
|
|
}
|
|
|
|
/** Fills an "out" array with pawns that are in an objective given the PRIs in the objective */
|
|
function GetHumanPawnsInObj( out array<KFPawn_Human> out_PawnsInObj, const out array<PlayerReplicationInfo> PRIsInObj )
|
|
{
|
|
local KFPawn_Human KFPH;
|
|
local int PRIIdx;
|
|
|
|
foreach WorldInfo.AllPawns( class'KFPawn_Human', KFPH )
|
|
{
|
|
if( PawnIsValidPlayer(KFPH) )
|
|
{
|
|
PRIIdx = PRIsInObj.Find( KFPH.PlayerReplicationInfo );
|
|
if( PRIIdx != INDEX_None )
|
|
{
|
|
out_PawnsInObj.AddItem( KFPH );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Plays dialog for random player within an objective */
|
|
function PlayObjectiveDialogOnRandomPlayers( array<KFPawn_Human> PawnsInObj, int EventID, optional int ResponseID = -1 )
|
|
{
|
|
local int RandIdx;
|
|
local KFPawn_Human Speaker, Responder;
|
|
|
|
RandIdx = Rand( PawnsInObj.Length );
|
|
Speaker = PawnsInObj[RandIdx];
|
|
PawnsInObj.Remove( RandIdx, 1 );
|
|
if( Speaker != none )
|
|
{
|
|
PlayDialogEvent( Speaker, EventID );
|
|
}
|
|
|
|
if( ResponseID < 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
RandIdx = Rand( PawnsInObj.Length );
|
|
Responder = PawnsInObj[RandIdx];
|
|
if( Responder != none )
|
|
{
|
|
PlayBasicDialogResponse( Speaker, EventID, ResponseID, Responder,, true );
|
|
}
|
|
}
|
|
|
|
function PlayDefendObjDialog( byte PrevObjProgress, byte CurrObjProgress )
|
|
{
|
|
local KFPawn_Human KFPH;
|
|
|
|
// check obj progress
|
|
foreach WorldInfo.AllPawns( class'KFPawn_Human', KFPH )
|
|
{
|
|
if( !PawnIsValidPlayer(KFPH) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if( CurrObjProgress == 0 )
|
|
{
|
|
PlayDialogEvent( KFPH, `OBJ_DefendAStart );
|
|
}
|
|
else if( PrevObjProgress < 100 && CurrObjProgress >= 100 )
|
|
{
|
|
PlayDialogEvent( KFPH, `OBJ_Win );
|
|
}
|
|
else if( PrevObjProgress < 50 && CurrObjProgress >= 50 )
|
|
{
|
|
PlayDialogEvent( KFPH, `OBJ_DefendAAlmostSecured );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/************************************************
|
|
* Favorite Weapons Dialog
|
|
************************************************/
|
|
|
|
function PlaySwitchToFavoriteWeaponDialog( KFPawn_Human Speaker )
|
|
{
|
|
local int FavoriteWeaponIndex;
|
|
local KFCharacterInfo_Human KFCI;
|
|
|
|
if( Speaker == none || Speaker.Weapon == none )
|
|
{
|
|
// wut?
|
|
return;
|
|
}
|
|
|
|
KFCI = KFCharacterInfo_Human( Speaker.CharacterArch );
|
|
if( KFCI == none )
|
|
{
|
|
return;
|
|
}
|
|
|
|
FavoriteWeaponIndex = KFCI.GetFavoriteWeaponIndexOf( Speaker.Weapon );
|
|
if( FavoriteWeaponIndex < 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
PlayDialogEvent( Speaker, `ACT_SelectFaveWeap1 + FavoriteWeaponIndex );
|
|
}
|
|
|
|
/************************************************
|
|
* Voice Command Dialog
|
|
************************************************/
|
|
|
|
function PlayVoiceCommandDialog( KFPawn Speaker, int CommandIndex )
|
|
{
|
|
switch( CommandIndex )
|
|
{
|
|
case 0:
|
|
PlayDialogEvent( Speaker, `COMM_RequestHeal);
|
|
break;
|
|
|
|
case 1:
|
|
PlayDialogEvent( Speaker, `COMM_RequestDosh);
|
|
break;
|
|
case 2:
|
|
PlayDialogEvent( Speaker, `COMM_RequestHelp);
|
|
break;
|
|
case 3:
|
|
PlayDialogEvent( Speaker, `COMM_InsultZeds);
|
|
break;
|
|
case 4:
|
|
PlayDialogEvent( Speaker, `COMM_FollowMe);
|
|
break;
|
|
case 5:
|
|
PlayDialogEvent( Speaker, `COMM_GetToTrader);
|
|
break;
|
|
case 6:
|
|
PlayDialogEvent( Speaker, `COMM_ConfirmGeneric);
|
|
break;
|
|
case 7:
|
|
PlayDialogEvent( Speaker, `COMM_DenyGeneric);
|
|
break;
|
|
case 9:
|
|
PlayDialogEvent(Speaker, `COMM_ThankYou);
|
|
break;
|
|
};
|
|
}
|
|
|
|
/************************************************
|
|
* Common Boss Dialog
|
|
************************************************/
|
|
|
|
function PlayBossMonologue( KFPawn Boss, byte MonologueType )
|
|
{
|
|
if( ETheatricType(MonologueType) == THEATRIC_Entrance )
|
|
{
|
|
PlayDialogEvent( Boss, `BOSS_Intro );
|
|
}
|
|
else if( ETheatricType(MonologueType) == THEATRIC_Victory )
|
|
{
|
|
PlayDialogEvent( Boss, `BOSS_Victory );
|
|
}
|
|
}
|
|
|
|
function PlayBossLoseSightOfDialog( KFPawn_Monster BossSpeaker, KFPawn_Human Target )
|
|
{
|
|
local class< KFPawnVoiceGroupEventData > EventDataClass;
|
|
|
|
EventDataClass = BossSpeaker.GetVoiceGroupEventDataClass();
|
|
|
|
if( ActorWithinPawnFOV(Target, BossSpeaker, GetEventFOV(`BOSS_LoseTarget, EventDataClass)) )
|
|
{
|
|
PlayDialogEvent( BossSpeaker, `BOSS_LoseTarget );
|
|
}
|
|
}
|
|
|
|
function PlayBossChallengeDialog( KFPawn Boss )
|
|
{
|
|
PlayDialogEvent( Boss, `BOSS_Challenge );
|
|
}
|
|
|
|
function PlayBossGrabDialog( KFPawn Boss )
|
|
{
|
|
PlayDialogEvent( Boss, `BOSS_Grab );
|
|
}
|
|
|
|
function PlayBossHealDialog( KFPawn Boss )
|
|
{
|
|
PlayDialogEvent( Boss, `BOSS_Heal );
|
|
}
|
|
|
|
function PlayBossTakeDamageDialog( KFPawn Boss )
|
|
{
|
|
if( float(Boss.Health) / float(Boss.HealthMax) < 0.25f )
|
|
{
|
|
PlayDialogEvent( Boss, `BOSS_TakeDmg_LT25 );
|
|
}
|
|
else
|
|
{
|
|
PlayDialogEvent( Boss, `BOSS_TakeDmgBase );
|
|
}
|
|
}
|
|
|
|
function PlayBossDeathDialog( KFPawn Boss )
|
|
{
|
|
PlayDialogEvent( Boss, `BOSS_Death );
|
|
}
|
|
|
|
function PlayBossLeapedDialog( KFPawn Boss )
|
|
{
|
|
PlayDialogEvent( Boss, `BOSS_Jump );
|
|
}
|
|
|
|
function PlayBossLandedDialog( KFPawn Boss )
|
|
{
|
|
PlayDialogEvent( Boss, `BOSS_Land );
|
|
}
|
|
|
|
/************************************************
|
|
* Hans Dialog
|
|
************************************************/
|
|
|
|
function PlayHansTickDialog( KFPawn Hans )
|
|
{
|
|
local int NumPlayers, NumLivingPlayers, NumOptions, BestOptionID;
|
|
local float PlayersAlivePct, DistToTargetSq, MaxDistToTargetSq;
|
|
local KFPawn_ZedHansBase HansBase;
|
|
|
|
BestOptionID = -1;
|
|
|
|
if( Hans.bIsSprinting && Hans.MyKFAIC.Enemy != none )
|
|
{
|
|
DistToTargetSq = VSizeSq(Hans.Location - Hans.MyKFAIC.Enemy.Location);
|
|
MaxDistToTargetSq = GetEventRadiusSq( `HANS_SprintToward, Hans.GetVoiceGroupEventDataClass() );
|
|
if( DistToTargetSq <= MaxDistToTargetSq )
|
|
{
|
|
AddRandomDialogOption( Hans, `HANS_SprintToward, NumOptions, BestOptionID );
|
|
}
|
|
}
|
|
|
|
NumPlayers = WorldInfo.Game.NumPlayers;
|
|
NumLivingPlayers = KFGameInfo( WorldInfo.Game ).GetLivingPlayerCount();
|
|
if( NumLivingPlayers > 0 )
|
|
{
|
|
HansBase = KFPawn_ZedHansBase( Hans );
|
|
if( HansBase != none && HansBase.bInHuntAndHealMode )
|
|
{
|
|
AddRandomDialogOption( Hans, `HANS_HuntTaunt, NumOptions, BestOptionID );
|
|
}
|
|
|
|
PlayersAlivePct = float(NumLivingPlayers) / float(NumPlayers);
|
|
|
|
if( PlayersAlivePct >= 0.5 )
|
|
{
|
|
AddRandomDialogOption( Hans, `BOSS_TauntBase, NumOptions, BestOptionID );
|
|
}
|
|
else if( PlayersAlivePct >= 0.25 )
|
|
{
|
|
AddRandomDialogOption( Hans, `BOSS_Taunt_LT50, NumOptions, BestOptionID );
|
|
}
|
|
else
|
|
{
|
|
AddRandomDialogOption( Hans, `BOSS_Taunt_LT25, NumOptions, BestOptionID );
|
|
|
|
// @todo: hook up taunt for unfrozen German soldier
|
|
}
|
|
}
|
|
|
|
PlayDialogEvent( Hans, BestOptionID );
|
|
}
|
|
|
|
function PlayHansDrawGunsDialog( KFPawn Hans )
|
|
{
|
|
PlayDialogEvent( Hans, `HANS_DrawGuns );
|
|
}
|
|
|
|
function PlayHansNadeDialog( KFPawn Hans, bool bBarrage )
|
|
{
|
|
if( bBarrage )
|
|
{
|
|
PlayDialogEvent( Hans, `HANS_NadeBarrage );
|
|
}
|
|
else
|
|
{
|
|
PlayDialogEvent( Hans, `HANS_NadeToss );
|
|
}
|
|
}
|
|
|
|
function PlayHansSmokeDialog( KFPawn Hans, bool bBarrage )
|
|
{
|
|
if( bBarrage )
|
|
{
|
|
PlayDialogEvent( Hans, `HANS_SmokeBarrage );
|
|
}
|
|
else
|
|
{
|
|
PlayDialogEvent( Hans, `HANS_SmokeToss );
|
|
}
|
|
}
|
|
|
|
function PlayHansGasDialog( KFPawn Hans, bool bBarrage )
|
|
{
|
|
if( bBarrage )
|
|
{
|
|
PlayDialogEvent( Hans, `HANS_GasBarrage );
|
|
}
|
|
else
|
|
{
|
|
PlayDialogEvent( Hans, `HANS_GasToss );
|
|
}
|
|
}
|
|
|
|
function PlayHansKilledDialog( KFPawn Hans, class<DamageType> DmgType )
|
|
{
|
|
local int NumOptions, BestOptionID;
|
|
|
|
BestOptionID = -1;
|
|
|
|
AddRandomDialogOption( Hans, `BOSS_KillBase, NumOptions, BestOptionID );
|
|
|
|
if( class<KFDamageType>(DmgType) != none )
|
|
{
|
|
AddRandomDialogOption( Hans, class<KFDamageType>(DmgType).static.GetKillerDialogID(), NumOptions, BestOptionID );
|
|
}
|
|
|
|
// @todo: figure out a way to make this less hard-coded? (see also KFAIController::DoStrike)
|
|
if( Hans.GetSpecialMoveTag() == 'Frenzy_Lunge' )
|
|
{
|
|
AddRandomDialogOption( Hans, `HANS_KillFrenzy, NumOptions, BestOptionID );
|
|
}
|
|
|
|
PlayDialogEvent( Hans, BestOptionID );
|
|
}
|
|
|
|
function PlayHansDamagePlayerDialog( KFPawn Hans, class<DamageType> DmgType )
|
|
{
|
|
if( DmgType.Name == 'KFDT_Ballistic_HansAK12' ) // Hans' MkB42s use this damage type at the moment. @todo: fix this if/when necessary
|
|
{
|
|
PlayDialogEvent( Hans, `HANS_DmgGuns );
|
|
}
|
|
}
|
|
|
|
function PlayHansFrenzyDialog( KFPawn Hans )
|
|
{
|
|
PlayDialogEvent( Hans, `HANS_Frenzy );
|
|
}
|
|
|
|
function PlayHansAOEDialog( KFPawn Hans )
|
|
{
|
|
PlayDialogEvent( Hans, `HANS_AOE );
|
|
}
|
|
|
|
function PlayHansBattlePhaseDialog( KFPawn Hans, int CurrBattlePhase )
|
|
{
|
|
if( !Hans.IsAliveAndWell() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch( CurrBattlePhase )
|
|
{
|
|
case 2:
|
|
PlayDialogEvent( Hans, `HANS_NextBattlePhase1 );
|
|
break;
|
|
|
|
case 3:
|
|
PlayDialogEvent( Hans, `HANS_NextBattlePhase2 );
|
|
break;
|
|
|
|
case 4:
|
|
PlayDialogEvent( Hans, `HANS_NextBattlePhase3 );
|
|
break;
|
|
};
|
|
}
|
|
|
|
/************************************************
|
|
* Patriarch Dialog
|
|
************************************************/
|
|
|
|
function PlayPatriarchTickDialog( KFPawn Patty )
|
|
{
|
|
local int NumPlayers, NumLivingPlayers, NumOptions, BestOptionID;
|
|
local float PlayersAlivePct;
|
|
|
|
BestOptionID = -1;
|
|
|
|
NumPlayers = WorldInfo.Game.NumPlayers;
|
|
NumLivingPlayers = KFGameInfo( WorldInfo.Game ).GetLivingPlayerCount();
|
|
if( NumLivingPlayers > 0 )
|
|
{
|
|
PlayersAlivePct = float(NumLivingPlayers) / float(NumPlayers);
|
|
|
|
if( PlayersAlivePct >= 0.5 )
|
|
{
|
|
AddRandomDialogOption( Patty, `BOSS_TauntBase, NumOptions, BestOptionID );
|
|
}
|
|
else if( PlayersAlivePct >= 0.25 )
|
|
{
|
|
AddRandomDialogOption( Patty, `BOSS_Taunt_LT50, NumOptions, BestOptionID );
|
|
}
|
|
else
|
|
{
|
|
AddRandomDialogOption( Patty, `BOSS_Taunt_LT25, NumOptions, BestOptionID );
|
|
}
|
|
}
|
|
|
|
PlayDialogEvent( Patty, BestOptionID );
|
|
}
|
|
|
|
function PlayPattyMinigunWarnDialog( KFPawn Patty )
|
|
{
|
|
PlayDialogEvent( Patty, `PATTY_MinigunWarn );
|
|
}
|
|
|
|
function PlayPattyMinigunAttackDialog( KFPawn Patty )
|
|
{
|
|
PlayDialogEvent( Patty, `PATTY_MinigunAttack );
|
|
}
|
|
|
|
function PlayPattyTentaclePullDialog( KFPawn Patty )
|
|
{
|
|
PlayDialogEvent( Patty, `PATTY_TentaclePull );
|
|
}
|
|
|
|
function PlayPattyChildKilledDialog( KFPawn Patty )
|
|
{
|
|
PlayDialogEvent( Patty, `PATTY_ChildKilled );
|
|
}
|
|
|
|
function PlayPattyKilledDialog( KFPawn Patty, class<DamageType> DmgType )
|
|
{
|
|
local int NumOptions, BestOptionID;
|
|
|
|
BestOptionID = -1;
|
|
|
|
AddRandomDialogOption( Patty, `BOSS_KillBase, NumOptions, BestOptionID );
|
|
|
|
if( class<KFDamageType>(DmgType) != none )
|
|
{
|
|
AddRandomDialogOption( Patty, class<KFDamageType>(DmgType).static.GetKillerDialogID(), NumOptions, BestOptionID );
|
|
}
|
|
|
|
PlayDialogEvent( Patty, BestOptionID );
|
|
}
|
|
|
|
function PlayPattyBattlePhaseDialog( KFPawn Patty, int CurrBattlePhase )
|
|
{
|
|
if( !Patty.IsAliveAndWell() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch( CurrBattlePhase )
|
|
{
|
|
case 1:
|
|
PlayDialogEvent( Patty, `PATTY_NextBattlePhase1 );
|
|
break;
|
|
|
|
case 2:
|
|
PlayDialogEvent( Patty, `PATTY_NextBattlePhase2 );
|
|
break;
|
|
|
|
case 3:
|
|
PlayDialogEvent( Patty, `PATTY_NextBattlePhase3 );
|
|
break;
|
|
};
|
|
}
|
|
|
|
function PlayPattyWhirlwindDialog( KFPawn Patty )
|
|
{
|
|
PlayDialogEvent( Patty, `PATTY_WhirlwindAttack );
|
|
}
|
|
|
|
/************************************************
|
|
* Matriarch Dialog
|
|
************************************************/
|
|
|
|
function PlayMatriarchBattlePhaseDialog(KFPawn Matriarch, int CurrentBattlePhase)
|
|
{
|
|
if (!Matriarch.IsAliveAndWell())
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch (CurrentBattlePhase)
|
|
{
|
|
case 1:
|
|
PlayDialogEvent(Matriarch, `MATTY_NextBattlePhase1);
|
|
break;
|
|
|
|
case 2:
|
|
PlayDialogEvent(Matriarch, `MATTY_NextBattlePhase2);
|
|
break;
|
|
|
|
case 3:
|
|
PlayDialogEvent(Matriarch, `MATTY_NextBattlePhase3);
|
|
break;
|
|
};
|
|
}
|
|
|
|
function PlayMatriarchTickDialog(KFPawn Matriarch, int ArmorZoneStatus, int CurrentBattlePhase)
|
|
{
|
|
switch (CurrentBattlePhase)
|
|
{
|
|
case 0:
|
|
PlayDialogEvent(Matriarch, `MATTY_Taunt_Phase1);
|
|
break;
|
|
|
|
case 1:
|
|
PlayDialogEvent(Matriarch, `MATTY_Taunt_Phase2);
|
|
break;
|
|
|
|
case 2:
|
|
PlayDialogEvent(Matriarch, `MATTY_Taunt_Phase3);
|
|
break;
|
|
|
|
case 3:
|
|
PlayDialogEvent(Matriarch, `MATTY_Taunt_Phase4);
|
|
break;
|
|
};
|
|
}
|
|
|
|
function PlayMatriarchExplodeArmorDialog(KFPawn Matriarch, name ArmorZoneName)
|
|
{
|
|
switch (ArmorZoneName)
|
|
{
|
|
case 'head':
|
|
PlayDialogEvent(Matriarch, `MATTY_TauntPilotCompartDestroyed);
|
|
break;
|
|
|
|
case 'claw':
|
|
PlayDialogEvent(Matriarch, `MATTY_TauntPowerClawDestroyed);
|
|
break;
|
|
};
|
|
}
|
|
|
|
function PlayMattyKilledDialog(KFPawn Matriarch)
|
|
{
|
|
if (Matriarch.IsDoingSpecialMove(SM_Custom1))
|
|
{
|
|
PlayDialogEvent(Matriarch, `MATTY_SweepingClawKill);
|
|
}
|
|
else if (Matriarch.IsDoingSpecialMove(SM_StandAndShootAttack))
|
|
{
|
|
PlayDialogEvent(Matriarch, `MATTY_TeslaBlastKill);
|
|
}
|
|
else if (Matriarch.IsDoingSpecialMove(SM_HoseWeaponAttack))
|
|
{
|
|
PlayDialogEvent(Matriarch, `MATTY_PlasmaCannonKill);
|
|
}
|
|
else if (Matriarch.IsDoingSpecialMove(SM_Custom2))
|
|
{
|
|
PlayDialogEvent(Matriarch, `MATTY_LightningStormKill);
|
|
}
|
|
else if (Matriarch.IsDoingSpecialMove(SM_GrappleAttack))
|
|
{
|
|
PlayDialogEvent(Matriarch, `MATTY_ScorpionWhipKill);
|
|
}
|
|
else if (Matriarch.IsDoingSpecialMove(SM_SonicAttack))
|
|
{
|
|
PlayDialogEvent(Matriarch, `MATTY_WarningSirenKill);
|
|
}
|
|
}
|
|
|
|
function PlayMattyMinionKilledDialog(KFPawn Matriarch)
|
|
{
|
|
PlayDialogEvent(Matriarch, `MATTY_DeadEDAR);
|
|
}
|
|
|
|
function PlayMatriarchSweepingClawEvent(KFPawn Matriarch)
|
|
{
|
|
PlayDialogEvent(Matriarch, `MATTY_SweepingClawAttack);
|
|
}
|
|
|
|
function PlayMatriarchTeslaBlastEvent(KFPawn Matriarch)
|
|
{
|
|
PlayDialogEvent(Matriarch, `MATTY_TeslaBlastWarning);
|
|
}
|
|
|
|
function PlayMatriarchPlasmaCannonEvent(KFPawn Matriarch)
|
|
{
|
|
PlayDialogEvent(Matriarch, `MATTY_PlasmaCannonWarning);
|
|
}
|
|
|
|
function PlayMatriarchLightningStormEvent(KFPawn Matriarch)
|
|
{
|
|
PlayDialogEvent(Matriarch, `MATTY_LightningStormWarning);
|
|
}
|
|
|
|
function PlayMatriarchScorpionWhipEvent(KFPawn Matriarch)
|
|
{
|
|
PlayDialogEvent(Matriarch, `MATTY_ScorpionWhipWarning);
|
|
}
|
|
|
|
function PlayMatriarchWarningSirenEvent(KFPawn Matriarch)
|
|
{
|
|
PlayDialogEvent(Matriarch, `MATTY_WarningSirenWarning);
|
|
}
|
|
|
|
function PlayMatriarchShieldUpEvent(KFPawn Matriarch)
|
|
{
|
|
PlayDialogEvent(Matriarch, `MATTY_ShieldActivate);
|
|
}
|
|
|
|
function PlayMatriarchCloakedEvent(KFPawn Matriarch)
|
|
{
|
|
PlayDialogEvent(Matriarch, `MATTY_Cloak);
|
|
}
|
|
|
|
DefaultProperties
|
|
{
|
|
bEnabled=true
|
|
|
|
InterruptPriorityThreshold=2
|
|
InterruptedByAnyPriorityThreshold=7
|
|
|
|
WeldAboutToBreakThreshold=60
|
|
|
|
NeedMoreHealingPctThreshold=0.75
|
|
NeedNoMoreHealingPctThreshold=0.75
|
|
|
|
CaughtSomeDoshAmt=50
|
|
CaughtMuchDoshAmt=250
|
|
|
|
NumZedsForPressureReload=1
|
|
|
|
LowSpareAmmoPctThreshold=0.15
|
|
|
|
NumKillsForOnARoll=6
|
|
CloseCallKillHealthPctThreshold=0.3
|
|
|
|
NumHitsForDeadHorse=3
|
|
TimeBetweenHitsForDeadHorse=1.0
|
|
|
|
TimeForContinuousDamageThreshold=3.0
|
|
TimeBetweenHitsForContinuousDamage=0.75
|
|
|
|
PlayerHealthPctForNearDeath=0.2
|
|
PlayerTakeDamageStreakInterval=1.0
|
|
PlayerTakeDamageStreakPctForScream=0.25
|
|
|
|
IdleTimeforSpottingZed=5.f
|
|
SpotLargeHordeNumZeds=6
|
|
|
|
ZedAlmostDeadHealthPctThreshold=0.3
|
|
|
|
SprintTowardZedDuration=1.5
|
|
|
|
NumZedsInAreaForMassacre=9
|
|
AreaRadiusForMassacre=2500.0
|
|
TimeLimitForMassacre=30.0
|
|
|
|
IdleTimeForSituationalDialog=7.0
|
|
IdleLowDoshThreshold=350
|
|
IdleHighDoshThreshold=3500
|
|
IdleLowAmmoPctThreshold=0.2
|
|
IdleHighAmmoPctThreshold=0.3
|
|
|
|
TimeUntilStartSprintPanting=3.0
|
|
|
|
// global ak events
|
|
StopBreathingAkEvent=AkEvent'WW_GLO_Runtime.Stop_Breathing'
|
|
}
|