top of page

Weaver: Dialogue Creator (WIP)

Project Type: Personal Project

Software: QT Creator, C++
Platform: PC

Role: Tools programmer​

Team Size: 1

Duration: Ongoing

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

  • Dialogue Creation Window made functional:

    • Opening the Character Creation window is now done in this window​

    • 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

  • 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

  • QT Creator Reworks & Additions:​

    • Added Dialogue Creation Window in QT. Which is a separate window to create dialogue blocks more easily

    • Character Creation: This window now emits a signal when the character is created​

    • Create Weaver Controller: Create and implement slots and signals for saving dialogue, creating dialogue, and the creation of a character

    • Connect signals and slots

Week 40 - 2025

  • Designed UML based on MVC model on Miro

  • Created and implemented new API for C++ library

Week 38 - 2025

  • 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

  • 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

  • Implemented JSON data saving​

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

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

Week 37 - 2025

Week 36 - 2025

  • Created initial dialogue design in Miro

  • Created front-end windows

    • "Dialogue Area" UI window.

      • "Add Dialogue" button adds a dialogue container to a scrollable list

      • "Add Character" button opens the character creation window

    • "Dialogue Container" UI element for displaying dialogue. Has a dropdown element (eventually will be used for characters to select for the dialogue) and a text field (will eventually be used to capture dialogue)

    • "Character Creation" UI window. Has a text field, confirm button, and cancel button. will be used to create new character names

bottom of page