top of page

Project Overview

Weaver is a custom Dialogue Creator to be used for creating dialogue in games. It will support both branching and linear dialogue.
Using QT Creator for its UI and a custom C++ library for its API and data creation. Designed to explore tool development outside of an engine.

The eventual outcome of the application is to have a creator, where dialogue can be used in multiple engines.
The uniqueness comes from the dialogue creator being vertical stacked blocks, giving designers better way to manage dialogue.
(as opposed to a node-based dialogue, which can get very messy and big, losing the overview of the dialogue)

Future additions that are planned/worked on: Different dialogue block types, visual handling of branching dialogue, visual overhaul of dialogue blocks, story creation, character templates, handling events, support for data to be used in different engines.

tools.png

Skills Developed

  • QT Creator: Used QT Creator to make UI for dialogue application.

  • Custom Library: Creating custom C++ Library and API.

  • MVC Model: Learned to separate data and UI creation, by using the MVC model.

cog.png

Key Features

Current Application Overview

Currently the application can create dialogue that is connected to a character. Which is also saved to JSON.

A show case of the current application: Names can be added to a list of characters, which can then be used to create dialogue for. The red blocks is a "Dialogue" block type

A show case of the saved data: This is how the data is currently saved. Characters are global, since they can be used in multiple scenes later on. And each entry in the dialogue array has the line created, a line id for the line , and a reference to the ID of the speaker of this line (so the speaker can be easily swapped out for another, if necessary).

Dialogue order is also saved, this will be used to determine the flow of dialogue. Later if users wish to change dialogue order it will only happen in one place and the dialogue itself is not affected.

Support for branching and linear dialogue

Weaver will have support for branching and linear dialogue.
The creation of Dialogue will be done trough the use of blocks.

​

Three dialogue blocks will exist; "Dialogue", "Choice", "Reply". With each block adding a choice to further the dialogue.

​

Down below are some design made in Miro for how the blocks will look visually.

Visual design of linear dialogue blocks

Visual design of branching dialogue blocks

C++ library with custom API

The C++ library has a API for creating new dialogue, as well as getting dialogue information

C++ API

Example of using the API to create dialogue for characters

MVC Model (Model-View-Controller)

The weaver application is separated into the Model(C++ library), the View(all the UI elements and windows in QT Creator), and the Controller(The link between the Model and the View). To communicate between the View(s) and Controller, I use signals and slots.
The MVC model allows me to write my core dialogue logic separated from the UI, which means that the library itself is usable in any game engine, or another application that is used to create UI.

The initial UML draft of the MVC model for my application. Using signals between the Views and the Controller to create dialogue, create new characters, or save the data.

Save data to JSON

Below is a draft of what the data looks like for Weaver

  • UUID's are used, so every ID is unique. This can be handy if multiple people were to use the application within the same scenes for example. But it also means that each dialogue, character, or scene id is unique, which is important so ID's don't clash when being referenced.
     

  • Characters are globally stored, since they can be used in multiple scenes. And if something changes with the characters, the places where the character is referenced do not all need to be updated.
     

  • Dialogue: all the dialogue is stored in an array within a scene. Each dialogue entry has the id for the line, the character who speaks the line (which is a reference to the global character ID), the dialogue type and the dialogue itself.​
     

  • Dialogue Order: The order of dialogue is stored separate. This way the internal dialogue array doesn’t need to be changed in any way. This is useful when users would want to change the order of dialogue in the tool.

Changelog

Week 45 - 2025
UI:

  • Updated Dialogue Creation Window:

    • Opening the Character Creation window is now done in this window​ (instead of Dialogue Area)

    • Create dialogue blocks, by choosing a character name, the dialogue type ("Dialogue" for now only), and typing in the dialogue (Result: current application overview)

Week 42 - 2025
Design:

  • Created visual breakdown of Signal and Slot flow between Views and Controller

  • Create New UML for UI windows and elements, which includes the signal and slot flow
    ​

UI:

  • ​Added Dialogue Creation Window in QT. ( separate window for creating dialogue blocks more easily)

  • Updated Character Creation window to emit a signal when a character is created​
  • Connected UI signals/slots for dialogue creation and saving
     

​​

​Backend:

  • Added Weaver Controller and implement slots/signals for:

    • Saving dialogue

    • Creating dialogue

    • Creating characters

Week 40 - 2025

Design:

  • Designed UML based on MVC model on Miro
     

Library:

  • Created and implemented new API for C++ library

Week 38 - 2025

Library:

  • Implemented technical design in the C++ Library

    • Created static DialogueManager class

    • Added functions to add character, get character names, create scene, and create dialogue entry​

  • Implemented JSON data saving​

    • Created functionality to save scenes, dialogue, dialogue order, and characters to JSON
       

UI:

  • Used C++ functions in QT Creator

    • Add Dialogue button also creates a dialogue entry in data

    • Creating a new name in the Character Creation Window, also creates said character in data

  • Add Character button in Dialogue Area opens the Character Creation window
     

Design:

  • Updated design for the dialogue blocks and the User UI flow of the application​

Week 37 - 2025

Design:

  • Planned out technical design for the JSON data and C++ Library on Miro
     

Library:​

Week 36 - 2025
Design:

  • Created initial dialogue design in Miro
     

UI:​

  • Created the Dialogue Area window:

    • ​Added Add Dialogue button for inserting a new dialogue container to a scrollable list

    • Added ​Add Character button to open the Character Creation window

    • Will be the central window for dialogue

  • Created the Dialogue Container UI element:

    • Added dropdown (will later display character list)

    • Added text field (will later be used to capture dialogue)

    • Will be used for displaying dialogue

  • Created the Character Creation window

    • Added text field (will later be used to create new character names)​

    • Added Confirm and Cancel buttons

    • Will be used for creating new character names

bottom of page