1 /////////////////////////////////////////////////////////////////////////////// 2 // Copyright (C) 2004-2011 by The Allacrost Project 3 // Copyright (C) 2012-2016 by Bertram (Valyria Tear) 4 // All Rights Reserved 5 // 6 // This code is licensed under the GNU GPL version 2. It is free software 7 // and you may modify it and/or redistribute it under the terms of this license. 8 // See http://www.gnu.org/copyleft/gpl.html for details. 9 /////////////////////////////////////////////////////////////////////////////// 10 11 /** **************************************************************************** 12 *** \file dialogue.h 13 *** \author Tyler Olsen, roots@allacrost.org 14 *** \author Yohann Ferreira, yohann ferreira orange fr 15 *** \brief Header file for common dialogue code 16 *** ***************************************************************************/ 17 18 #ifndef __DIALOGUE_HEADER__ 19 #define __DIALOGUE_HEADER__ 20 21 #include "utils/ustring.h" 22 #include "utils/utils_strings.h" 23 24 #include "common/gui/textbox.h" 25 #include "common/gui/option.h" 26 27 namespace vt_common 28 { 29 30 class DialogueOptions; 31 class DialogueSupervisor; 32 33 //! \name Constants used among common dialogue classes 34 //@{ 35 //! \brief Indicates that the next line to read should follow sequentially 36 const int32_t DIALOGUE_NEXT_LINE = -1; 37 //! \brief Indicates that the dialogue should end after the present line is finished 38 const int32_t DIALOGUE_END = -2; 39 //! \brief Indicates that a line has no display timer enabled 40 const int32_t DIALOGUE_NO_TIMER = -1; 41 //! \brief the default invalid value. 42 const int32_t DIALOGUE_INVALID = -1; 43 44 //! \brief The dialogue window should have no indicator (i.e. for automated text) 45 const uint8_t DIALOGUE_NO_INDICATOR = 0; 46 //! \brief The dialogue window should have the indicator that more lines exist 47 const uint8_t DIALOGUE_NEXT_INDICATOR = 1; 48 //! \brief The dialogue window should have the indicator that the last line is reached 49 const uint8_t DIALOGUE_LAST_INDICATOR = 2; 50 //! \brief The maximum number of options that a line of dialogue can present to the player 51 const uint32_t MAX_DIALOGUE_OPTIONS = 5; 52 //@} 53 54 //! \brief Defines the different states the dialogue can be in. 55 enum DIALOGUE_STATE { 56 DIALOGUE_STATE_INACTIVE = 0, //!< Active when the dialogue window is in the process of displaying a line of text 57 DIALOGUE_STATE_LINE = 1, //!< Active when the dialogue window is in the process of displaying a line of text 58 DIALOGUE_STATE_OPTION = 2, //!< Active when player-selectable options are present in the dialogue window 59 DIALOGUE_STATE_EMOTE = 3 //!< Active when the dialogue supervisor is waiting for an emote event to finish before drawing a line. 60 }; 61 62 /** **************************************************************************** 63 *** \brief Container for the data that represents a dialogue speaker 64 *** 65 *** This is used only by the DialogueSupervisor to store its speaker data. No other 66 *** classes use nor need to know about this class. The ID of the speaker is omitted because 67 *** the supervisor class stores those values as keys to the std::map container that holds 68 *** instances of this speaker class. 69 *** *************************************************/ 70 class Speaker 71 { 72 public: 73 //! \brief The name of this speaker as it will appear to the player 74 vt_utils::ustring name; 75 76 /** \brief Holds a reference to the portrait image to use for this speaker 77 *** 78 *** \note Not all speakers will have portraits available. For those that don't, this 79 *** member will simply remain a blank image that is drawn to the screen. 80 **/ 81 vt_video::StillImage portrait; 82 }; // class Speaker 83 84 /** **************************************************************************** 85 *** \brief A collection of related text lines and options used in a dialogue 86 *** 87 *** This class contains the most common set of data and methods necessary to execute 88 *** a dialogue on the screen. It does not contain any draw code nor does the class 89 *** "process" itself in displaying the dialogue. Instead, other classes are typically 90 *** employed for the display and execution of dialogue. Game modes which make use of 91 *** dialogue will likely require to extend the capabilities of this class to serve their 92 *** own needs. This class is designed with the expectation that other classes will inherit 93 *** from it and expand the base set of capabilities. 94 *** 95 *** The standard order of lines in a dialogue begin with the first line that is added and ends 96 *** with the last. However, dialogues do not always progress in this linear manner and thus this 97 *** class supports "branching" of dialogue. Each line contains a pointer to the next line that 98 *** should be read. If no valid line follows, the dialogue will end after the current line. 99 *** 100 *** Each line of text added to the dialogue has the following properties associated: 101 *** -# The text of the line 102 *** -# The next line that should be viewed after this line 103 *** -# An optional timer instructing how long the line should be displayed 104 *** -# An optional series of selectable options that the player may choose from on this line 105 *** 106 *** An example of the typical usage of this class to construct a dialogue would be as follows: 107 *** - CommonDialogue new_dialogue(my_new_id); 108 *** - new_dialogue.AddText("This is the first line."); 109 *** - new_dialogue.AddTextTimed("Line #2 is displayed for 2.5 seconds.", 2500); 110 *** - new_dialogue.AddText("Select from the options below."); 111 *** - new_dialogue.AddOption("Return to beginning", 0); 112 *** - new_dialogue.AddOption("End Dialogue"); 113 *** - if (new_dialogue.Validate() == false) cout << "Dialogue object is invalid" << std::endl; 114 *** 115 *** \note The interpretation of the display time member of the dialogue is subject to intrepretation 116 *** by the code that is processing the dialogue. For example, the code may read this to mean that the 117 *** dialogue will automatically move on after the timer has expired, or it may mean that the dialogue 118 *** must be displayed for that amount of time and that the player can not force the dialogue to move 119 *** faster. 120 *** ***************************************************************************/ 121 class Dialogue 122 { 123 public: 124 //! \param id The id number to represent the dialogue, 125 //! which should be unique to other dialogue ids within the same game mode context 126 explicit Dialogue(const std::string& dialogue_id); 127 128 virtual ~Dialogue(); 129 130 //! \brief A C++ wrapper made to create a new object from scripting, 131 //! without letting Lua handling the object life-cycle. 132 //! \note We don't permit luabind to use constructors here as it can't currently 133 //! give the object ownership at construction time. 134 //! This function also registers the dialogue to the dialogue manager. 135 static Dialogue* Create(DialogueSupervisor* dialogue_supervisor, const std::string& dialogue_id); 136 137 /** \brief Adds a new line of text to the dialogue 138 *** \param text The text to show on the screen 139 *** 140 *** Uses the default set of options for this line of text: proceed to next sequential line, no display timer. 141 **/ 142 void AddLine(const std::string& text); 143 144 /** \brief Adds a new line of text to the dialogue 145 *** \param text The text to show on the screen 146 *** \param next_line The line of dialogue which should follow this one 147 *** 148 *** No display timer is set for this version of AddText 149 **/ 150 void AddLine(const std::string& text, int32_t next_line); 151 152 /** \brief Adds a new line of text to the dialogue 153 *** \param text The text to show on the screen 154 *** \param speaker The ID of the speaker for this line 155 *** 156 *** The following line properties are set when using this call: 157 *** - proceed to next sequential line, no display time 158 **/ 159 void AddLine(const std::string& text, const std::string& speaker_id); 160 161 /** \brief Adds a new line of text to the dialogue 162 *** \param text The text to show on the screen 163 *** \param speaker The ID of the speaker for this line 164 *** \param next_line The line of dialogue which should follow this one 165 *** 166 *** The following line properties are set when using this call: 167 *** - no display time 168 **/ 169 void AddLine(const std::string& text, const std::string& speaker_id, int32_t next_line); 170 171 /** \brief Adds a new line of text to the dialogue that uses a display time 172 *** \param text The text to show on the screen 173 *** \param display_time The number of milliseconds that the line should be displayed for 174 *** 175 *** The dialogue will proceed to the next sequential line for this line of text. 176 **/ 177 void AddLineTimed(const std::string& text, uint32_t display_time); 178 179 /** \brief Adds a new line of text to the dialogue that uses a display time 180 *** \param text The text to show on the screen 181 *** \param next_line The line of dialogue which should follow this one 182 *** \param display_time The number of milliseconds that the line should be displayed for 183 *** 184 *** The dialogue will proceed to the next sequential line for this line of text. 185 **/ 186 void AddLineTimed(const std::string& text, int32_t next_line, uint32_t display_time); 187 188 /** \brief Adds a new line of text to the dialogue that uses a display time 189 *** \param text The text to show on the screen 190 *** \param speaker The ID of the speaker for this line 191 *** \param display_time The number of milliseconds that the line should be displayed for 192 *** 193 *** The following line properties are set when using this call: 194 *** - proceed to next sequential line 195 **/ 196 void AddLineTimed(const std::string& text, const std::string& speaker_id, uint32_t display_time); 197 198 /** \brief Adds a new line of text to the dialogue that uses a display time 199 *** \param text The text to show on the screen 200 *** \param speaker The ID of the speaker for this line 201 *** \param next_line The line of dialogue which should follow this one 202 *** \param display_time The number of milliseconds that the line should be displayed for 203 **/ 204 void AddLineTimed(const std::string& text, const std::string& speaker_id, int32_t next_line, uint32_t display_time); 205 206 /** \brief Adds an option to the most recently added line of text 207 *** \param text The text for this particular option 208 *** \note The next line will be the next sequential line should this option be selected 209 *** \note If no lines have been added to the dialogue yet, this option will not be added and a warning will be issued 210 **/ 211 void AddOption(const std::string& text); 212 213 /** \brief Adds an option to the most recently added line of text 214 *** \param text The text for this particular option 215 *** \param next_line The index value of the next line of dialogue to display should this option be selected 216 *** \note If no lines have been added to the dialogue yet, this option will not be added and a warning will be issued 217 **/ 218 void AddOption(const std::string& text, int32_t next_line); 219 220 /** \brief Checks all the data stored by the dialogue class to ensure that it is acceptable and ready for use 221 *** \return True if the validation was successful, false if any problems were discovered 222 *** 223 *** This function should be called after adding all the lines, options, and settings to a dialogue but before the dialogue is 224 *** actually used. It checks that all data is valid and warns of potentially dangerous data, such as referring to a line index 225 *** that doesn't exist. Any issues that raise concern will cause the function to return false. Additionally if debugging is enabled, 226 *** messages will be printed to the console providing details about any bad data discovered. 227 *** \note This function should not be called until after all battle speakers have been added to the battle dialogue supervisor. 228 *** The function checks that each speaker reference is valid and stored in the supervisor class. 229 **/ 230 bool Validate(); 231 232 //! \name Methods for retrieving properties of a specific line 233 //@{ 234 //! \brief Returns the text of the line specified GetLineText(uint32_t line)235 vt_utils::ustring GetLineText(uint32_t line) const { 236 if(line >= _line_count) return vt_utils::ustring(); 237 return _text[line]; 238 } 239 240 //! \brief Returns the line index that follows the line specified GetLineNextLine(uint32_t line)241 int32_t GetLineNextLine(uint32_t line) const { 242 if(line >= _line_count) return DIALOGUE_INVALID; 243 return _next_lines[line]; 244 } 245 246 //! \brief Returns the display time of the line specified GetLineDisplayTime(uint32_t line)247 int32_t GetLineDisplayTime(uint32_t line) const { 248 if(line >= _line_count) return DIALOGUE_INVALID; 249 return _display_times[line]; 250 } 251 252 //! \brief Returns the options container of the line specified GetLineOptions(uint32_t line)253 DialogueOptions* GetLineOptions(uint32_t line) const { 254 if(line >= _line_count) return nullptr; 255 return _options[line]; 256 } 257 //@} 258 259 //! \brief Returns the speaker ID for the line specified (or zero if the line index was invalid) GetLineSpeaker(uint32_t line)260 const std::string& GetLineSpeaker(uint32_t line) const { 261 if(line >= _line_count) return vt_utils::_empty_string; 262 return _speakers[line]; 263 } 264 265 //! \name Class Member Access Functions 266 //@{ GetDialogueID()267 const std::string& GetDialogueID() const { 268 return _dialogue_id; 269 } 270 GetLineCount()271 uint32_t GetLineCount() const { 272 return _line_count; 273 } 274 //@} 275 276 protected: 277 //! \brief A unique identification string that represents this dialogue 278 std::string _dialogue_id; 279 280 //! \brief Stores the amount of lines in the dialogue. 281 uint32_t _line_count; 282 283 //! \brief The text of the conversation, split up into multiple lines 284 std::vector<vt_utils::ustring> _text; 285 286 /** \brief Holds indeces pointing to which line should follow each line of text 287 *** \note When a line contains options, the value stored in this container for that line is never used 288 **/ 289 std::vector<int32_t> _next_lines; 290 291 //! \brief The display time for each line in the dialogue 292 std::vector<int32_t> _display_times; 293 294 //! \brief A set of dialogue options indexed according to the line of dialogue that they belong to 295 std::vector<DialogueOptions *> _options; 296 297 //! \brief Contains the speaker ID number corresponding to each line of text 298 std::vector<std::string> _speakers; 299 }; // class Dialogue 300 301 302 /** *************************************************************************************** 303 *** \brief A container class for option sets presented during dialogue 304 *** 305 *** When the player reads a dialogue, they may be presented with a small number of options to 306 *** select from when coming to a particular line. The selected option determines the next line 307 *** that will follow. Objects of this class are stored and managed by the CommonDialogue class 308 *** to allow options to occur duing a dialogue. 309 *** **************************************************************************************/ 310 class DialogueOptions 311 { 312 public: DialogueOptions()313 DialogueOptions() 314 {} 315 ~DialogueOptions()316 virtual ~DialogueOptions() 317 {} 318 319 /** \brief Adds a new option to the set of options 320 *** \param text The text for the new option 321 *** 322 *** \note The next line to be read for this option will be the sequential next line of the dialogue 323 **/ 324 virtual void AddOption(const std::string &text); 325 326 /** \brief Adds a new option to the set of options 327 *** \param text The text for the new option 328 *** \param next_line An integer index of the next line of dialogue should this option be selected. 329 **/ 330 virtual void AddOption(const std::string &text, int32_t next_line); 331 332 //! \name Methods for retrieving properties of a specific line 333 //@{ 334 //! \brief Returns the text of the option specified GetOptionText(uint32_t option)335 vt_utils::ustring GetOptionText(uint32_t option) const { 336 if(option >= GetNumberOptions()) return vt_utils::ustring(); 337 return _text[option]; 338 } 339 340 //! \brief Returns the line index that follows the line when the given option is selected GetOptionNextLine(uint32_t option)341 int32_t GetOptionNextLine(uint32_t option) const { 342 if(option >= GetNumberOptions()) return DIALOGUE_INVALID; 343 return _next_lines[option]; 344 } 345 //@} 346 347 //! \brief Returns the number of options stored by this class GetNumberOptions()348 uint32_t GetNumberOptions() const { 349 return _text.size(); 350 } 351 352 protected: 353 //! \brief Contains the text of each option 354 std::vector<vt_utils::ustring> _text; 355 356 //! \brief A index containing the next line of dialogue that should follow each option 357 std::vector<int32_t> _next_lines; 358 }; // class DialogueOptions 359 360 361 /** **************************************************************************** 362 *** \brief A display window for all GUI controls and graphics necessary to execute a dialogue 363 *** 364 *** This class handles all graphical management of a dialogue. It serves primarily 365 *** as a container class for dialogue graphics and is not responsible for tasks such 366 *** as updating the text box display or processing user input. This class operates in a 1024x768 367 *** coordinate system (screen resolution), regardless of the coordinate system that is set by the 368 *** game mode in where it is used. In other words, you don't need to concern yourself with changing 369 *** the coordinate system prior to drawing the contents of this class since the class does this 370 *** internally itself. 371 *** ***************************************************************************/ 372 class DialogueWindow 373 { 374 public: 375 DialogueWindow(); 376 ~DialogueWindow()377 ~DialogueWindow() 378 {} 379 380 /** \brief Sets the draw position for the window 381 *** \param pos_x The x coordinate for the center of the window 382 *** \param pos_y The y coordinate for the bottom of the window 383 *** 384 *** These positions take effect in a 1024x768 coordinate system and a a (VIDEO_X_LEFT, VIDEO_Y_BOTTOM) draw alignment| 385 *** This function should always be called once when setting up the dialogue window before the first draw call is made. 386 **/ 387 void SetPosition(float pos_x, float pos_y); 388 389 //! \brief Clears all text from the window 390 void Clear(); 391 392 //! \brief Draws the dialogue window and all other visuals 393 void Draw(); 394 395 //! \name Class member access methods 396 //@{ GetDisplayTextBox()397 vt_gui::TextBox &GetDisplayTextBox() { 398 return _display_textbox; 399 } 400 GetDisplayOptionBox()401 vt_gui::OptionBox &GetDisplayOptionBox() { 402 return _display_optionbox; 403 } 404 GetNameText()405 vt_video::TextImage &GetNameText() { 406 return _name_text; 407 } 408 GetPortraitImage()409 vt_video::StillImage *GetPortraitImage() const { 410 return _portrait_image; 411 } 412 SetPortraitImage(vt_video::StillImage * image)413 void SetPortraitImage(vt_video::StillImage *image) { 414 _portrait_image = image; 415 } 416 417 //! \brief Returns whether the type was already set SetIndicator(uint8_t type)418 bool SetIndicator(uint8_t type) { 419 if (type == _indicator_symbol) 420 return false; 421 _indicator_symbol = type; 422 return true; 423 } 424 //@} 425 426 private: 427 //! \brief Stores the draw coordinates for the bottom center of the dialogue window 428 vt_common::Position2D _pos; 429 430 //! \brief A parchment paper image embedded within the dialogue window 431 vt_video::StillImage _parchment_image; 432 433 //! \brief The nameplate image used along with the dialogue box image 434 vt_video::StillImage _nameplate_image; 435 436 //! \brief The image indicating following dialogue lines 437 vt_video::StillImage _next_line_image; 438 439 //! \brief The image indicating the last line of a dialogue 440 vt_video::StillImage _last_line_image; 441 442 //! \brief The indicator symbol to use (arrow, end_of_dialogue_symbol, or none) 443 uint8_t _indicator_symbol; 444 445 //! \brief The counter for the blinking indicators 446 uint16_t _blink_time; 447 448 //! \brief The status of the blinking indicators 449 bool _blink_state; 450 451 //! \brief The textbox used for rendering the dialogue text 452 vt_gui::TextBox _display_textbox; 453 454 //! \brief The option box used for rendering dialogue options where applicable 455 vt_gui::OptionBox _display_optionbox; 456 457 //! \brief Holds the name of the speaker 458 vt_video::TextImage _name_text; 459 460 //! \brief A pointer to a portrait image to display alongside the text. A nullptr value will display no portrait 461 vt_video::StillImage *_portrait_image; 462 }; // class DialogueWindow 463 464 465 /** **************************************************************************** 466 *** \brief Handles the storage and execution of dialogues 467 *** 468 *** This supervisor class retains two data containers. The first container holds 469 *** all of the speakers while the second holds all of the dialogues. 470 *** ***************************************************************************/ 471 class DialogueSupervisor 472 { 473 public: 474 DialogueSupervisor(); 475 476 virtual ~DialogueSupervisor(); 477 478 //! \brief Processes user input and updates the state of the dialogue 479 virtual void Update(); 480 481 //! \brief Draws the dialogue window, text, portraits, and other visuals to the screen 482 virtual void Draw(); 483 484 /** \brief Adds a new speaker using custom name and portrait data 485 *** \param id The unique ID number for this speaker 486 *** \param name The name of the speaker 487 *** \param portrait_filename The filename for the portrait to add 488 *** 489 *** Pass in an empty string to the arguments if you do not want the speaker to have a name or portrait image. 490 **/ 491 virtual void AddSpeaker(const std::string& speaker_id, const std::string& name, const std::string& portrait); 492 493 /** \brief Changes the name for a speaker that was previously added 494 *** \param id The unique ID number for the speaker to change 495 *** \param name The text to change the speaker's name to 496 **/ 497 virtual void ChangeSpeakerName(const std::string& speaker_id, const std::string& name); 498 499 /** \brief Changes the portrait image for a speaker that was previously added 500 *** \param id The unique ID number for the speaker to change 501 *** \param portrait The filename of the image to use as the speaker's portrait 502 **/ 503 virtual void ChangeSpeakerPortrait(const std::string& speaker_id, const std::string& portrait); 504 505 /** \brief Adds a new dialogue to be managed by the supervisor 506 *** \param dialogue Pointer to a Dialogue object that was created with the new operator 507 *** 508 *** The dialogue to add must have a unique dialogue ID that is not already stored by this class 509 *** instance. If a dialogue is found with the same ID, the dialogue will not be added and the 510 *** dialogue object will be deleted from memory. All dialogues that are successfully added will 511 *** be later deleted when this class' destructor is invoked, so make sure you only pass in objects 512 *** that were created with the "new" operator. 513 **/ 514 virtual void AddDialogue(Dialogue *dialogue); 515 516 /** \brief Prepares the dialogue manager to begin processing a new dialogue 517 *** \param dialogue_id The id number of the dialogue to begin 518 **/ 519 virtual void StartDialogue(const std::string& dialogue_id); 520 521 //! \brief Immediately ends any dialogue that is taking place 522 virtual void EndDialogue(); 523 524 //! \brief Forces the current dialogue to proceed to the next line immediately 525 virtual void ForceNextLine(); 526 527 /** \brief Returns a pointer to the Dialogue with the requested ID value 528 *** \param dialogue_id The identification number of the dialogue to retrieve 529 *** \return A pointer to the dialogue requested, or nullptr if no such dialogue was found 530 **/ 531 Dialogue* GetDialogue(const std::string& dialogue_id); 532 533 /** \brief Returns a pointer to the BattleSpeaker with the requested ID value 534 *** \param speaker The unique ID number of the speaker to retrieve 535 *** \return A pointer to the stored speaker, or nullptr if no speaker was found with the specified ID 536 **/ 537 Speaker* GetSpeaker(const std::string& speaker_id); 538 GetCurrentDialogue()539 Dialogue* GetCurrentDialogue() const { 540 return _current_dialogue; 541 } 542 543 //! \brief Returns true if any dialogue is currently active at this time IsDialogueActive()544 bool IsDialogueActive() const { 545 return (_current_dialogue != nullptr); 546 } 547 GetCurrentOptions()548 DialogueOptions* GetCurrentOptions() const { 549 return _current_options; 550 } 551 GetLineTimer()552 vt_system::SystemTimer& GetLineTimer() { 553 return _line_timer; 554 } 555 GetLineCounter()556 uint32_t GetLineCounter() const { 557 return _line_counter; 558 } 559 560 //! \brief Sets the bottom center position of the dialogue window. 561 void SetDialoguePosition(float x, float y); 562 563 protected: 564 //! \brief Retains the current state of the dialogue execution 565 DIALOGUE_STATE _state; 566 567 //! \brief Contains data for all of the speakers for every dialogue and each line. The speaker ID is the map key. 568 std::map<std::string, Speaker> _speakers; 569 570 //! \brief Contains all dialogues managed by this class instance in a std::map structure. The dialogue ID is the map key 571 std::map<std::string, Dialogue *> _dialogues; 572 573 //! \brief A pointer to the current piece of dialogue that is active 574 Dialogue *_current_dialogue; 575 576 //! \brief A pointer to the current set of options for the active dialogue line 577 DialogueOptions *_current_options; 578 579 //! \brief A timer that employed for dialogues which have a display time limit 580 vt_system::SystemTimer _line_timer; 581 582 //! \brief Keeps track of which line is active for the current dialogue 583 uint32_t _line_counter; 584 585 //! \brief Holds the text and graphics that should be displayed for the dialogue 586 DialogueWindow _dialogue_window; 587 588 //! \brief Updates the dialogue when it is in the line state 589 void _UpdateLine(); 590 591 //! \brief Updates the dialogue when it is in the option state 592 void _UpdateOptions(); 593 594 /** \brief Begins the display of the line indexed by the value of _line_counter 595 *** 596 *** This is called whenever a dialogue begins or is moved to the next line. Its duties include updating the 597 *** dialogue state, dialogue window displays with data from the new line, and setting up the line timer. 598 *** 599 *** \note This method does not check that the _line_counter member refers to a valid line. It is the caller's 600 *** responsibility to ensure that _line_counter is valid prior to calling this method. 601 **/ 602 void _BeginLine(); 603 604 /** \brief Finishes the current dialogue line and moves the dialogue forward to the next line 605 *** 606 *** This function determines the next line that the dialogue should proceed to based on the properties of the 607 *** current line. This includes "branching" to the appropriate next line based on the option selected by the player 608 *** when options were enabled on the current line. Should the line counter become invalid or the dialogue is to end 609 *** after the present line, this function will invoke the EndDialogue() method. In addition to proceeding to the next 610 *** line, this method is also responsible for invoking any events that were to occur at the conclusion of the present 611 *** line. 612 **/ 613 void _EndLine(); 614 }; // class DialogueSupervisor 615 616 } // namespace vt_common 617 618 #endif // __DIALOGUE_HEADER__ 619