ConSys.Conversation

//=============================================================================
// Conversation
//=============================================================================
class Conversation extends ConObject
    native
    noexport;

var Name         conName;               // Conversation Name
var String       Description;           // Description
var String       CreatedBy;             // Who created event
var String       conOwnerName;          // Name of Actor owner
var Bool         bDataLinkCon;          // True if this is a DataLink conversation

var Bool         bDisplayOnce;          // Flag to display conversation only once
var Bool         bFirstPerson;          // Remain in First-Person mode
var Bool         bNonInteractive;       // True if non-interactive conversation
var Bool         bRandomCamera;         // True if random camera placement
var Bool         bCanBeInterrupted;     // True if this conversation can be interrupted by another
var Bool         bCannotBeInterrupted;  // True if this conversation CANNOT be interrupted by another
var Bool         bGenerateAudioNames;   // True if we're to auto-generate filenames for the audio

var Bool         bInvokeBump;           // Invoke by Bumping
var Bool         bInvokeFrob;           // Invoke by Frobbing
var Bool         bInvokeSight;          // Invoke by Sight
var Bool         bInvokeRadius;         // Invoke by Radius
var Int          radiusDistance;        // Distance from PC needed to invoke conversation, 0 = Frob

var ConEvent     eventList;             // First Event
var ConFlagRef   flagRefList;           // Flag List

var int          conversationID;        // Internal Conversation ID

// Unique identifier of audio package.  This is used to generate
// audio names so we can demand load audio from a package
var String       audioPackageName;

var Float        lastPlayedTime;        // Time when conversation last played (ended).
var Int          ownerRefCount;         // Number of owners this conversation has

intrinsic(2050) final function ConFlagRef CreateFlagRef( Name flagName, bool flagValue );
intrinsic(2051) final function ConCamera CreateConCamera();
intrinsic(2052) final function BindEvents(Actor conBoundActors[10], Actor invokeActor);
intrinsic(2053) final function BindActorEvents(Actor actorToBind);
intrinsic(2054) final function ClearBindEvents();
intrinsic(2055) final function Sound GetSpeechAudio(int soundID);
intrinsic(2056) final function Float GetSpeechLength(int soundID);

// ----------------------------------------------------------------------
// GetEventFromLabel()
//
// Searches this conversation for a label and returns it.  If it can't
// find a matching label then it returns None.
// ----------------------------------------------------------------------

function ConEvent GetEventFromLabel( String searchLabel )
{
    local ConEvent currentEvent;

    currentEvent = eventList;

    while( currentEvent != None )
    {
        if ( Caps(searchLabel) == Caps(currentEvent.Label) )
            break;

        currentEvent = currentEvent.nextEvent;
    }   

    return currentEvent;
}

// ----------------------------------------------------------------------
// AddFlagRef()
//
// Adds a flag reference, using the given flag name and value passed in
// ----------------------------------------------------------------------

function AddFlagRef( Name flagName, Bool value )
{
    local ConFlagRef newFlagRef;
    local ConFlagRef refChain;
    local ConFlagRef refMatch;
    
    newFlagRef = CreateFlagRef( flagName, value );
    
    // Now search through our flag refs to see if we already have a 
    // flag ref by this name

    refChain = flagRefList;
    refMatch = None;

    while( refChain != None )
    {
        if ( refChain.flagName == flagName )
        {
            refMatch = refChain;
            break;
        } 
        refChain = refChain.nextFlagRef;
    }

    // If we found a match, then update the value.  Otherwise 
    // insert this flag ref at the top of the food chain

    if ( refMatch != None )
    {
        refMatch.value = value;
    }
    else
    {
        newFlagRef.nextFlagRef = flagRefList;
        flagRefList = newFlagRef;
    }   
}

// ----------------------------------------------------------------------
// CheckActors()
//
// Checks to see if all the actors doing speaking in the conversation
// actually exist.
// ----------------------------------------------------------------------

function bool CheckActors(optional bool bLogActors)
{
    local ConEvent event;
    local ConEventSpeech eventSpeech;
    local bool bActorsValid;

    bActorsValid = True;
    event = eventList;

    while(event != None)
    {
        eventSpeech = ConEventSpeech(event);
        if (eventSpeech != None)
        {
            if ((eventSpeech.speaker == None) || (eventSpeech.speakingTo == None))
            {
                bActorsValid = False;

                if (bLogActors)
                {
                    if (eventSpeech.speaker == None)
                        log("  SpeakingActor   =" @ eventSpeech.speakerName);
                    if (eventSpeech.speakingTo == None)
                        log("  SpeakingToActor =" @ eventSpeech.speakingToName);
                }
                else
                {
                    break;
                }           
            }
        }

        event = event.nextEvent;
    }

    return bActorsValid;
}

// ----------------------------------------------------------------------
// CheckActorDistances()
//
// Checks to see how far all the actors are away from each other 
// to make sure it's reasonable to start a conversation.
// Ignore the player in these checks.
// ----------------------------------------------------------------------

function bool CheckActorDistances(Actor player)
{
    local ConEvent event;
    local ConEventSpeech eventSpeech;
    local int  actorIndex;
    local Int  dist;
    local bool bDistanceValid;

    bDistanceValid = True;

    event = eventList;

    // First fill up our array of actors
    while(event != None)
    {
        eventSpeech = ConEventSpeech(event);
        if (eventSpeech != None)
        {
            // Check the distance between the two actors
            if ((eventSpeech.speaker != None) && (eventSpeech.speaker != player) && 
                (eventSpeech.speakingTo != None) && (eventSpeech.speakingTo != player))
            {
                dist = VSize(eventSpeech.speaker.Location - eventSpeech.speakingTo.Location);

                if (dist > 300)
                {
                    bDistanceValid = False;
                    break;
                }
            }
        }
        event = event.nextEvent;
    }

    return bDistanceValid;
}

// ----------------------------------------------------------------------
// GetFirstSpeechActors()
//
// Looks for the first Speech event in this conversation and returns
// the speaker and speakingTo actors.  This is used to setup the first
// camera event
// ----------------------------------------------------------------------

function GetFirstSpeechActors( out Actor firstSpeaker, out Actor firstSpeakingTo )
{
    local ConEvent conEvent;

    conEvent = eventList;

    firstSpeaker    = None;
    firstSpeakingTo = None;

    while( conEvent != None )
    {   
        if ( ConEventSpeech( conEvent ) != None )
        {   
            firstSpeaker    = ConEventSpeech( conEvent ).speaker;
            firstSpeakingTo = ConEventSpeech( conEvent ).speakingTo;
            break;
        }
        conEvent = conEvent.nextEvent;
    }
}

// ----------------------------------------------------------------------
// GetFirstSpeakerDisplayName()
// ----------------------------------------------------------------------

function String GetFirstSpeakerDisplayName(optional String startLabel)
{
    local ConEvent conEvent;
    local Conversation con;
    local String   speakerName;

    if (startLabel != "")
        conEvent = GetEventFromLabel(startLabel);
    else
        conEvent = eventList;

    while(conEvent != None)
    {   
        // Follow any jump events
        if (ConEventJump(conEvent) != None)
        {
            if (ConEventJump(conEvent).jumpCon != None)
            {
                con = ConEventJump(conEvent).jumpCon;
                speakerName = con.GetFirstSpeakerDisplayName(ConEventJump(conEvent).jumpLabel);
                break;
            }
        }

        // If this is a speech event, grab the name and quit.
        if (ConEventSpeech(conEvent) != None)
        {   
            speakerName = ConEventSpeech(conEvent).speakerName;
            break;
        }
        conEvent = conEvent.nextEvent;
    }

    return speakerName;
}

// ----------------------------------------------------------------------
// IsSpeakingActor()
//
// Looks to see if the actor passed in is even involved in this
// conversation.  Returns True if the actor has a speaking part.
// ----------------------------------------------------------------------

function Bool IsSpeakingActor(Actor speakingActor)
{
    local bool bSpeaking;
    local ConEventSpeech eventSpeech;
    local ConEvent event;

    event = eventList;

    while(event != None)
    {
        eventSpeech = ConEventSpeech(event);
        if (eventSpeech != None)
        {
            if ((eventSpeech.speakerName == speakingActor.BindName) || (eventSpeech.speakingToName == speakingActor.BindName))
            {
                bSpeaking = True;
                break;
            }
        }
        event = event.nextEvent;
    }

    return bSpeaking;
}

// ----------------------------------------------------------------------
// ----------------------------------------------------------------------

defaultproperties
{
     bGenerateAudioNames=True
}