Chatrooms

Navigation

Creating a Chatroom

Tip

The following section is for creating chatrooms using Ren’Py scripting and additions added for Mysterious Messenger. If you’re interested in the visual chatroom creator, see Chatroom Creator.

Note

Example files to look at:

  • tutorial_5_coffee.rpy

  • tutorial_6_meeting.rpy

A brief overview of the steps required (more detail below):

  1. Create a new .rpy file (Optional, but recommended)

  2. Create a new label for the chatroom.

  3. (Optional) Set the background with scene morning where morning is replaced by whatever time of day/background you want to use.

  4. Add background music with play music mystic_chat where mystic_chat is replaced by the desired music variable.

  5. Write the chatroom dialogue.

    1. You may want to use either Script Generator.xlsx or the msg CDS.

  6. End the label with return.

The first thing you should do when creating a new chatroom is create a new .rpy file and name it something descriptive so it’s easy to find it again. For example, you might name it something like day_1_chatroom_3.rpy or day_1_3.rpy. It’s a good idea to put all the files related to a particular route inside a folder for organization.

In your newly created .rpy file, begin by making a label for the chatroom:

label day_1_1:

Don’t forget the colon after the label name. Your label name also can’t have any spaces in it or begin with a number.

Next, it’s time to set up the chatroom background. Note that everything under the label name should be indented at least one level to the right. You can look at the example files mentioned above if you’re not sure what this means.

New to v3.3.0 is the “autobackground” feature, where Mysterious Messenger will automatically set the background for a chatroom based on the time of day it should trigger at. If you don’t set a background, the automatic one will be used instead. If you want the program to set up the background for you, you can skip over this next section. Otherwise, you can manually set up the background like so:

label day_1_1:
    scene morning

While chatrooms also use Ren’Py’s scene statement to show backgrounds, there is a limited number of built-in backgrounds to use. New backgrounds must be defined as described in Adding Chatroom Backgrounds. Your background options are:

  • morning

  • noon

  • evening

  • night

  • earlyMorn

  • hack

  • redhack

  • redcrack

  • secure

  • rainy_day

  • snowy_day

  • morning_snow

The background names are case-sensitive, so you need to get the capitalization correct. The program will automatically clear the chat history when beginning a new chatroom so new messages begin appearing at the bottom.

Tip

If you’re using Mysterious Messenger’s autobackground feature to set up the background for you, but you need to change the background manually during a chatroom (e.g. to show the hacked background), if you want to change it back according to the time-of-day rules, you can use the special line:

scene autobackground

When this line is encountered, the program will automatically switch to whatever background should be used based on the time-of-day this chatroom triggers at.

Note

The autobackground feature is based off of the trigger time of the chatroom where it is used, not what real-life time the player plays the chatroom at. So, for example, if the player buys back a chatroom that had expired, and that chatroom’s trigger time is 8:00am, whether it is 8:00am now or 10:00pm, autobackground will show the morning background to the player for that chatroom, since it was set to trigger at 8:00am and that’s within the range of the “morning” background time.

Now that the background is set up, you probably want some music. Music is played with the line:

play music mystic_chat

where mystic_chat can be replaced by the name of whatever music you want. There are several files pre-defined in variables_music_sound.rpy. If you want to define your own music, you need to add it to the music_dictionary as well so that it is compatible with audio captions. See Adding New Audio for more information.

Next, you’ll write the dialogue for your chatroom. See Writing Chatroom Dialogue. Finally, to end the chatroom, end the label with return:

label day_1_1:
    scene earlyMorn
    play music mint_eye
    # Dialogue will go here
    return

To learn how to make this chatroom appear in your game, check out Setting up a Route.

Writing Chatroom Dialogue

There are two primary ways of writing dialogue for your chatroom. The first is to use the msg CDS, and the second is to use a special spreadsheet to help generate the dialogue for you.

Using the msg CDS

The msg CDS helps add effects to your dialogue, such as special speech bubbles or alternative fonts, without sacrificing the readability of the dialogue. Dialogue written with the msg CDS looks like the following:

msg r "Usually, the program would delay sending text messages and phone calls" sser1
msg r "until after both this chatroom and the Story Mode were played." sser1
msg r "But since v3.0, things are more flexible!" flower_m
msg r "If you declare a route using the new format,"
msg r "you can have text messages and phone calls and the like after any story item,"
msg r "even a chatroom that has a Story Mode attached" glow

(Dialogue taken from tutorial_3_text_message.rpy)

The msg CDS requires a speaker (in the example, r) and some dialogue (surrounded by ""). There are several optional clauses that can be added after the dialogue to affect how it displays.

Fonts

The msg CDS has several built-in fonts that can be applied to the text. These are:

Short form

Description

sser1

Sans serif font 1 (Nanum Gothic)

sser2

Sans serif font 2 (Seoul Namsan)

ser1

Serif font 1 (Nanum Myeongjo)

ser2

Serif font 2 (Seoul Hangang)

curly

Cursive font (Sandoll Misaeng)

blocky

Blocky font (BM-HANNA)

You can also use your own fonts with the msg CDS. See Custom Fonts and Bubbles for more on custom fonts and special bubbles.

In order to use one of the built-in fonts, just include the name of the desired font after the dialogue e.g.

msg u "This is example dialogue in the cursive font." curly
msg u "This is in the sans serif 1 font." sser1

Note that you can only have one font at a time; including more than one will simply use the last font given. The default font is sser1, and dialogue will show up using sser1 unless you give it a different font.

Emphasis

You can emphasize text in several ways. To use the bold version of a font, use the argument bold after the dialogue e.g.

msg u "This text is bolded." bold

Some fonts have extra-bold variants as well. These are defined in variables_editable.rpy in the variable bold_xbold_fonts_list. To make a font extra bold, add the xbold clause after the dialogue e.g.

msg ja "This text is in the sans serif 2 font, extra bold." sser2 xbold

Finally, you can increase the size of the text inside a speech bubble with the big argument e.g.

msg ju "This text is shown at a bigger size." big

You can also combine big and bold or xbold for additional emphasis.

msg s "VERY IMPORTANT MESSAGE!!" sser2 big xbold

To apply these styles only to parts of a word, you can use the {b} text tag for bolded text:

msg y "I can't believe you {b}left{/b} me..."

And the custom {big} text tag for larger text:

msg z "I can't believe you think it's {big}not a big deal!{/big}"

Underline

To underline all the text in a bubble, you can use either underline or under as part of the msg CDS:

msg u "This text is underlined!" curly underline
msg u "This is also underlined." under

If you just want to underline particular words, the built-in {u} tag will handle that:

msg u "This is {u}underlined{/u} for emphasis." glow

Special Bubbles

You can also use special speech bubbles as the background of dialogue. There are several bubbles built in to the program:

Base bubble

Sizes

Additional Notes

cloud

s, m, l

round

s, m, l

Only available for ja, ju, s, v, and y. Using a round style for z or r will result in using the flower bubble.

round2

s, m, l

Only available for s

sigh

s, m, l

Not available for sa.

spike

s, m, l

small (s) size only available for ja, ju, s, y, and z.

square

s, m, l

Not available for s.

square2

s, m, l

Only available for r.

flower

s, m, l

Only available for r and z. Previously called round.

glow

N/A

Available for all pre-defined characters excluding m i.e. u and ri also have this bubble.

glow2

N/A

Only available for sa. An extra variant on the glow bubble.

Unless otherwise mentioned, u, ri, and m have no special bubble variants of their own.

For bubbles which have sizes, you must include which size bubble you would like (s for small, m for medium, and l for large) after the name of the bubble e.g. square_m or sigh_l.

To use a special bubble, add the name of the bubble after dialogue e.g.

msg r "This is a bubble with the flower background." flower_m
msg r "And this is a bubble with the glowing background." glow
msg r "These can be combined with other fonts and effects, too!" glow curly big

You can also have the characters use each other’s special speech bubbles by prefacing the bubble name with their file_id e.g.

msg s "I'm using Jumin's cat bubble!" bubble ju_cloud_l
y "This message uses Zen's flower bubble~" (bounce=True, specBubble="z_flower_m")

Finally, you can use your own bubbles with the msg CDS. See Custom Fonts and Bubbles for more on custom special bubbles and fonts.

Images

The msg CDS will automatically detect if dialogue includes a recognized emoji and mark the dialogue as an image accordingly. If you want a character to post an image in the chatroom (such as a CG), then you can use the img argument:

msg s "cg s_1" img
msg s "I just posted a CG!"

You need to follow the rules outlined in Defining a CG and Showing a CG in a Chatroom or Text Message in order for the program to find the correct image and display it during a chatroom. For CGs, the program will also automatically unlock the image in the gallery.

For emojis, it’s sufficient to write:

msg s "{image=seven_wow}"

where seven_wow is the name of the emoji image to be shown. The program will automatically recognize it as an emoji.

Modifying Message Speed

Finally, you can also adjust the speed at which a message is posted. For example, if you want a character to post a bunch of messages in quick succession, you can use the pv clause to use a multiplier on the speed at which a message is posted e.g.

msg s "These" pv 0.1
msg s "messages" pv 0.1
msg s "are" pv 0.1
msg s "posted" pv 0.1
msg s "quickly!!!" pv 0.1

If you have paraphrase_choices turned off, you will generally want to add pv 0 after a message posted by the main character after a menu e.g.

menu:
    "Emojis and Images":
        msg m "I want to learn how to use emojis and images." pv 0
        msg u "Emojis and images, huh?" ser1

Using the Chatroom Spreadsheet

The second way of writing chatroom dialogue is similar to writing regular Ren’Py script, but passes special keyword arguments in brackets after the dialogue. A spreadsheet, Script Generator.xlsx, is included with the program to make this style of writing easier.

The first tab in the spreadsheet is called Chatroom Instructions and explains how the CHATROOM TEMPLATE tab is used. Where possible, the spreadsheet will try to check off the appropriate boxes depending on what fonts, emphasis, or bubbles you want to use. It will also notify you if you’ve typed a character’s name incorrectly.

The tab tutorial_6_meeting has examples directly from the corresponding .rpy file of how dialogue for that chatroom was written using the spreadsheet.

In general, you should create a copy of the CHATROOM TEMPLATE tab and fill it out with your desired dialogue. Don’t forget that messages such as 707 has entered the chatroom are handled differently – see Advanced Chatroom Features for more.

If you’ve filled out the spreadsheet correctly, you should be able to copy-paste the dialogue from the “What should be filled into the program” column into your script file.

Comparison of Chatroom Dialogue

Both methods of writing dialogue can be mixed and matched freely in-game. For example, if you don’t want to add any additional fonts, emphasis, or special bubbles, it can be easier to type out dialogue using just the character variable and their dialogue. Here is a comparison of what dialogue looks like for each method when various fonts, emphasis, and special bubbles are added:

# msg CDS
msg u "Extra bold sans serif 2 font" sser2 xbold
# Spreadsheet dialogue
u "{=sser2xb}Extra bold sans serif 2 font{/=sser2xb}"

# msg CDS
msg u "Glowing bubble with blocky font" blocky glow
# Spreadsheet dialogue
u "{=blocky}Glowing bubble with blocky font{/=blocky}" (bounce=True)

# msg CDS
msg z "Bold large curly font with flower bubble" curly bold big flower_m
# Spreadsheet dialogue
z "{=curly}{size=+10}{b}Bold large curly font with flower bubble{/b}{/size}{/=curly}" (bounce=True, specBubble="flower_m")

# msg CDS
msg s "{image=seven_wow}"
# Spreadsheet dialogue
s "{image=seven_wow}" (img=True)

# msg CDS
msg m "Dialogue with a speed modifier." pv 0
# Spreadsheet dialogue
m "Dialogue with a speed modifier." (pauseVal=0)

# msg CDS
msg s "cg s_1" img
# Spreadsheet dialogue
s "cg s_1" (img=True)

Attention

If you have script from v2.x or earlier, you don’t need to modify it to work with the msg CDS. You can mix and match script writing styles within the same chatroom.

Advanced Chatroom Features

Now that you’ve made a label for your chatroom and filled it with some dialogue, you may want to add additional polish to your chatroom, like allowing the player to make a choice or adding the special 707 has entered the chatroom-style messages.

Entering and Exiting the Chatroom

To get the message Character has entered the chatroom, use the enter chatroom CDS:

enter chatroom s

where s is the variable of the character who is entering the chatroom. See Creating Characters for a list of the characters currently programmed into the game.

Tip

You can also use call enter(s) to have a character enter the chatroom.

To get the message Character has left the chatroom, use the exit chatroom CDS:

exit chatroom s

where s is the variable of the character who is exiting the chatroom.

Tip

You can also use call exit(s) to have a character leave the chatroom.

Updating the Characters’ Profiles

Updating the Profile Picture

To update a character’s profile picture, you just need to write

$ ja.prof_pic = "Profile Pics/Jaehee/jae-2.webp"

where ja is the ChatCharacter variable of the character whose profile picture you’d like to update. Profile pictures should be 110x110 pixels at minimum, and can optionally have a second, larger version supplied that is up to 314x314 pixels and will be used on the character’s profile screen. The program looks for the larger version under the same name with the suffix -b e.g. Profile Pics/Jaehee/jae-2-b.webp.

You can update a profile picture anywhere – during a chatroom, phone call, text message, etc. To have the profile picture show up in the History screen as well as during regular gameplay, it is recommended that you change the profile picture at the beginning of a label and its associated expired version, if applicable e.g.

label day_1_chatroom_1():
    $ r.prof_pic = "Profile Pics/Ray/ray-1.webp"
    play music mint_eye
    enter chatroom r
    msg r "Good morning!" curly glow

Updating a character’s profile picture will automatically change their portrait on the homepage to have an “updated” background.

Note

There are also bonus profile pictures, which the player can update themselves. For more on that, see Bonus Profile Pictures.

Updating a Character’s Status

To update a character’s status, use

$ ju.status = "I wonder what Elizabeth the 3rd is up to..."

where ju is the ChatCharacter variable of the character whose status you would like to update. Updating a character’s status will automatically give their portrait on the homepage an “updated” background to indicate there is new information on their profile page.

You can update a character’s status wherever you like inside a label; in the middle of phone calls, at the end of a chatroom, in the after_ label, wherever.

Updating the Character’s Cover Photo

To update a character’s cover photo, use

$ s.cover_pic = "Cover Photos/rfa_cover.webp"

where s is the ChatCharacter variable of the character whose cover photo you would like to update. Cover photos should be 750 x 672 pixels in size.

Updating a character’s cover photo will automatically give their portrait on the homepage an “updated” background to indicate their is new information on their profile page.

You can update a character’s cover photo wherever you like inside a label; during Story Mode, in the middle of an expired chatroom, in a text message, wherever.

Clearing the Chat History

If you would like to clear the chat history so that all previous messages are erased, you can use the clear chat CDS:

y "Anyway, I should go now."
exit chatroom y
clear chat
scene hack
show hack effect
enter chatroom u
u "Hi, [name]."

Note

The chat history is automatically cleared before beginning a new chatroom.

Clearing Chatroom Participants

If you would like to clear all current chatroom participants from the chatroom header, you can use the extra argument participants for the clear chat CDS:

label my_chatroom:
    scene morning
    play music narcissistic_jazz
    enter chatroom z
    z "Has the chatroom been acting up for you too, [name]?"
    msg z "I've been having trouble with it all morning." sigh_s
    clear chat participants
    scene hack
    show hack effect
    enter chatroom u
    u "Ah, excellent."
    u "I've gained access to the messenger."

This will both clear the chat history and remove any existing participants from the list at the top of the messenger screen.

This isn’t typically used outside of using story mode sections in the middle of chatrooms (see Including a Story Mode During a Chatroom) or linking together “separate” chatrooms as part of a scene for something like an After End.

Resetting Chatroom Participants

Similar to the above section on clearing chat participants, there is also a special function provided to reset chat participants even without jumping to Story Mode and back, for example, as part of a montage of chatroom sequences. The function is called reset_participants and takes one parameter, a list of ChatCharacters to add back to the participants list.

u "This is the end of the first chatroom."
$ reset_participants([z, s, m])
s "Hey [name], Zen, you haven't seen anything suspicious lately, right?"

Note

You will need to add m to the participant list yourself if you would like the player to appear in the participants list after the reset, regardless of whether the chatroom was expired or not.

Providing Choices

During a chatroom, you may want to allow the player to make a choice. This can be accomplished with Ren’Py’s built-in menu system:

msg s "What kind of food do you eat?"
menu:
    "I like soup.":
        msg s "You like soup?"
    "I eat a lot of junk food.":
        msg s "lolol same."
msg s "But you should have a balanced diet, unlike me~" glow

Note that for this menu, it is assumed that paraphrase_choices is turned on for this route. This means that the main character will automatically say the exact dialogue on the chosen choice. If paraphrase_choices is turned off, the menu might look something like this:

msg s "What kind of food do you eat?"
menu:
    "I like soup.":
        msg m "I like soup." pv 0
        msg s "You like soup?"
    "I eat a lot of junk food.":
        msg m "I eat a lot of junk food." pv 0
        msg s "lolol same."
msg s "But you should have a balanced diet, unlike me~" glow

You can also turn paraphrased on or off on a per-menu or per-choice basis. For more on paraphrasing, see Paraphrased Choices.

You can add as many choices as you want to the menu, though only 5 options will fit on the screen at once. All code indented after a choice will only be run if the player picks that choice. So, only a player who chose "I like soup" will see the line "You like soup?". Anything indented at the same level as the menu will be run regardless of the choice made, so the player will see the line "But you should have a balanced diet, unlike me~" regardless of whether they said they like soup or eat junk food.

Warning

You can use the TAB key to indent your code an additional level to the right, but make sure your code editor is using spaces to indent code. Otherwise, you will get errors complaining about “tab” characters in your code.

You’ll also notice in the “paraphrased” version of the menu, the main character (m) has the clauses pv 0 after their dialogue. This tells the program to not wait at all before posting the MC’s message. Usually the program will pause before posting a message to simulate “typing time”, but you want the player’s choice to appear right away after a choice, so you should include pv 0 if you’re using the msg CDS, or (pauseVal=0) if you’re using the spreadsheet style.

Showing a Chatroom Banner

There are four special banners included in the program. The available banners are:

  • lightning

  • heart

  • annoy

  • well

You can show a banner with the code:

show banner lightning

Note that while the order of banner and lightning don’t matter, the name is case-sensitive. So, you could also use show lightning banner but show Lightning banner would not work.

Note

These images are not displayed for players who have toggled the Chatroom Banners setting off.

Showing a Heart Icon

Awarding a heart point

To show a heart icon to the player and award them “heart points” associated with a particular character, use

award heart s

where s is the variable of the character whose heart icon you’d like to show. The player will receive one heart point with that character when this code is run. See Creating Characters for a list of the characters built-in to the program and how to add your own character.

Note

Ray (r) and Saeran (sa) share heart points. So, if you award a heart point for Saeran via award heart sa, Ray will also receive 1 heart point.

By default, each award heart statement gives one heart point to the specified character. You can award multiple at the same time, however, by providing a number e.g. award heart u 10 would give Unknown 10 heart points.

There is also a second optional argument to award heart:

award heart ju bad

bad tells the program that this heart is a “bad” heart point, and should count towards a bad ending. In-game, a bad heart appears the same as a normal heart point. You can use this method to count the number of choices a player makes that would lead towards a bad ending, and then check whether the player made more “good” or “bad” ending choices when they reach a plot branch. See Plot Branches for more information on this.

Removing a heart point

If the player makes a choice a character doesn’t like, you can cause them to lose a point with a character by showing a “heart break” icon.

break heart ju

where ju is the variable of the character whose heart break you’d like to show. This will always subtract points from the character’s “good” heart points and never the “bad” points. Note that losing heart points in this way does not subtract from the heart point totals the player uses to unlock additional profile pictures for a character (See Bonus Profile Pictures).

Tip

Both break heart ju and heart break ju will show the heart break animation for the character ju. You can’t switch the word order for award heart though!

Like with awarding heart points, you can take away multiple heart points by adding a number at the end e.g. break heart s 4 would remove 4 heart points from 707.

Awarding an Hourglass

Hourglasses are randomly awarded to players when certain bubbles (specified in hourglass_bubbles in variables_editable.rpy) are used in chatroom dialogue so long as Receive Hourglasses in Chatrooms is active from the Developer options. However, you can also manually award the player hourglasses with a special function, award_hourglass. The function takes two fields:

random

False by default. Set this to True if you would like there to be a random chance of getting an hourglass even when this function is triggered (e.g. you have a specific message you’d like to potentially award an hourglass, but it shouldn’t be guaranteed).

force

False by default. Set this to True if you’d like to force the player to receive an hourglass in all circumstances. Note that this isn’t the same as having random=False; force means that even if the player is viewing an expired chatroom or watching a replay from the History, they will receive an hourglass, including if you have Receive Hourglasses in Chatrooms turned off from the developer settings.

This option is largely intended for non-playable gameplay such that you might record a video of. If you’d simply like to guarantee the player receives an hourglass in the event that it is possible to receive them based on how they’re viewing the current story item, then you should leave both random and force as False.

In the game, you might use it as follows:

msg z "I hope I'll see you soon, [name]~" flower_m curly
$ award_hourglass(random=True)
msg z "I should go get ready."

This will randomly award the player an hourglass when they see the line “I hope I’ll see you soon, [name]~” (that is, on some playthroughs they will receive an hourglass, and on others they will not). They won’t see this hourglass if they’re viewing this chat from the History or on a rewatch.

Showing the Hacked Scroll Effect

To show the scrolling “hack” effect during a chatroom, use the line

show hack effect

or alternatively,

show redhack effect

for the red version of the scrolling hack image. You can reverse the direction of the scrolling with reverse e.g.

show hack effect reverse
exit chatroom u
show redhack effect reverse

There is also a “red static” effect which can be shown with:

show red static effect

This can also be reversed by adding the reverse tag:

show red static effect reverse

Note

These effects are not displayed for players who have toggled the Hacking Effects setting off.

Showing the Secure Chatroom Animation

To show the “secure chatroom” animation, use the line

show secure anim

Note

If you’re using this effect, you may also want to change the background of the chatroom box on the timeline screen. You can do this with the box_bg parameter when defining a ChatRoom for the route e.g.

ChatRoom('Hacking', 'hack_example', '20:41', box_bg='secure')

Shaking the Screen

To shake the screen, use the line

show shake

Screen shake is compatible both with regular backgrounds and with the animated backgrounds.

Note

This effect is not displayed for players who have toggled the Screen Shake setting off.

Showing the Cracked Overlay

There is also a “cracked” overlay you can layer on top of any chatroom background (including animated backgrounds). It gives the appearance of cracked glass on top of the background. After showing your background, show the crack effect like:

scene redhack
show screen_crack

Custom Fonts and Bubbles

Mysterious Messenger supports user-defined fonts and special bubbles through customizable variables and functions. These work with the msg CDS as well as the text tag approach used for the spreadsheet dialogue.

Custom Fonts

To add your own font to the game, first you need to add it to the all_fonts_list found in variables_editable.rpy:

define all_fonts_list = ['sser1', 'sser2', 'ser1', 'ser2', 'curly', 'blocky']

In general you should not replace this list; just add your new font to the end. For this example, a font called “cursive” will be added.

define all_fonts_list = ['sser1', 'sser2', 'ser1', 'ser2',
    'curly', 'blocky', 'cursive']

Now you need to add it to the font_dict:

define font_dict = { 'curly' : gui.curly_font, 'ser1' : gui.serif_1,
        'ser1b' : gui.serif_1b, 'ser1xb' : gui.serif_1xb,
        'ser2' : gui.serif_2, 'ser2b' : gui.serif_2b,
        'ser2xb' : gui.serif_2xb, 'sser1' : gui.sans_serif_1,
        'sser1b' : gui.sans_serif_1b, 'sser1xb' : gui.sans_serif_1xb,
        'sser2' : gui.sans_serif_2, 'sser2b' : gui.sans_serif_2b,
        'sser2xb' : gui.sans_serif_2xb, 'blocky' : gui.blocky_font,
        'cursive' : "fonts/cursivefont.ttf"
    }

“fonts/cursivefont.ttf” should be the path to the .ttf or .otf file of your desired font.

If your font has bold and/or extra bold variants, you will also add it to the bold_xbold_fonts_list variable:

define bold_xbold_fonts_list = ['sser1', 'sser2', 'ser1', 'ser2', 'cursive']

And you will need to specify how the bold and extra bold variants should be mapped. The bold version of a font is always the name of the font in the all_fonts_list + b, and the extra bold is the name + xb.

define font_dict = { 'curly' : gui.curly_font, 'ser1' : gui.serif_1,
        'ser1b' : gui.serif_1b, 'ser1xb' : gui.serif_1xb,
        'ser2' : gui.serif_2, 'ser2b' : gui.serif_2b,
        'ser2xb' : gui.serif_2xb, 'sser1' : gui.sans_serif_1,
        'sser1b' : gui.sans_serif_1b, 'sser1xb' : gui.sans_serif_1xb,
        'sser2' : gui.sans_serif_2, 'sser2b' : gui.sans_serif_2b,
        'sser2xb' : gui.sans_serif_2xb, 'blocky' : gui.blocky_font,
        'cursive' : "fonts/cursivefont.ttf",
        'cursiveb' : "fonts/cursivefont-bold.ttf",
        'cursivexb' : "fonts/cursivefont-xbold.ttf"
    }

In this example, the bold is called “cursiveb” and the extra bold “cursivexb”. Note that you will need an entry for both bold and extra bold, even if you only have one font. In that case, you can set the file path for both entries to the same font.

Finally, to use the font as a text tag, you need to define a style for it. Existing styles can be found in style_definitions.rpy:

style cursive:
    font "fonts/cursivefont.ttf"

style cursiveb:
    font "fonts/cursivefont-bold.ttf"

style cursivexb:
    font "fonts/cursivefont-xbold.ttf"

Now you can use the font while writing chatroom or text message dialogue. If you use the msg CDS, you need to preface the name of the font with the tag font e.g.

msg s "This is a new font!" font cursive
msg s "You can add other effects, too!" big font cursive xbold

And text tags work the way they would with the predefined fonts:

s "{=cursive}This is a bit more verbose.{/=cursive}"
s "{=cursivexb}Which method you use depends on your preference.{/=cursivexb}"

Custom Bubbles

You can also add your own custom bubbles to work with the msg CDS and spreadsheet dialogue method, or expand the functionality of existing bubbles.

To add a new bubble, first you must add it to the all_bubbles_list in variables_editable.rpy. For this example, three bubbles called “spooky_s”, “spooky_m”, and “spooky_l” will be added (for small, medium, and large variants).

define all_bubbles_list = ['cloud_l', 'cloud_m', 'cloud_s', 'round_l',
    'round_m', 'round_s', 'sigh_l', 'sigh_m', 'sigh_s', 'spike_l', 'spike_m',
    'spike_s', 'square_l', 'square_m', 'square_s', 'square2_l', 'square2_m',
    'square2_s', 'round2_l', 'round2_m', 'round2_s', 'flower_l', 'flower_m',
    'flower_s', 'glow2', 'spooky_s', 'spooky_m', 'spooky_l']

Next, you need to define a base style for the bubble. Typically the most important property is the padding. First, define a general style:

style spooky_s:
    padding (25, 25, 25, 25)

style spooky_m:
    padding (25, 25, 25, 25)

style spooky_l:
    padding (25, 25, 25, 25)

This defines a style for the spooky bubbles with 25 pixels of padding on the left, top, right, and bottom of the bubble. These numbers should, of course, be adjusted to suit the actual bubble image you’re using.

Next, if any characters have a variant of this bubble that requires different styling, you can define a style for them. For example, if the padding for s’s spooky_m bubble is different, you can create an s_spooky_m style:

style s_spooky_m:
    is spooky_m # This inherits the spooky_m padding
    top_padding 35

is spooky_m tells the style to inherit from the original spooky_m style; this is optional, but can be helpful. In this case, it means that the s_spooky_m bubble has a left/right/bottom padding of 25, as in the spooky_m style, but the top_padding is now 35.

Finally, you need to define an offset for each of your new bubbles. This is how far the bubble should be relative to the top left corner of the character’s profile picture (for bubbles posted on the left side of the messenger). All the existing bubble offsets can be found in gui.rpy. For the spooky_ bubbles, three variables are needed:

define gui.spooky_s_offset = (140, 38)
define gui.spooky_m_offset = (130, 38)
define gui.spooky_l_offset = (140, 32)

Note that these are the name of the bubble + the suffix _offset. You can also define specific offsets for characters using their file_id. e.g. if em’s spooky_m bubble needs to be a bit further to the right than the rest of the characters’, you can define the value define gui.em_spooky_m_offset = (150, 32).

And that’s all! To show this special bubble in-game, you must ensure you have the appropriate images defined inside the “Bubbles/Special/” folder.

  • The image extension must be one of .webp, .png, or .jpg

  • If every character uses the same bubble, it is sufficient to have a “Bubbles/Special/spooky_s.webp” image. Otherwise, you will need an image with the file_id of each character who has a variant e.g. “Bubbles/Special/ja_spooky_s.webp”, “Bubbles/Special/ju_spooky_s.webp”, etc.

Then you can write dialogue which will show the bubble in-game e.g.

ju "This will use the spooky_m bubble." (bounce=True, specBubble="spooky_m")
msg ja "This message will also use the spooky_m bubble" bubble spooky_m

Unlike the predefined bubbles, custom bubbles must be prefixed with bubble as in bubble spooky_m when used in the msg CDS.

Tip

You can also add the name of your bubble to the hourglass_bubbles variable in variables_editable.rpy. This means that when a character uses that bubble in-game, it has a chance of awarding the player an hourglass.

Typically only the large (l) version of a bubble is added to this list e.g. "spooky_l"

Extending Custom Bubbles

Besides adding your own bubbles, you can also extend the functionality of existing bubbles (or your own custom bubbles) via some special provided functions in variables_editable.rpy. There are three such functions. All are passed a msg variable, which is a ChatEntry object with the following fields:

who

The ChatCharacter object of the sender of the message.

e.g. s

what

The contents (dialogue) of the message.

e.g. “Have you heard from V lately?”

thetime

A MyTime object with information on the time the message was sent at (in real-time)

img

True if this message contains either an emoji or a CG; False otherwise.

bounce

True if this message should “bounce” in as its animation. This is True if the message uses the “glowing” style of bubble, and also True if a special speech bubble is used (such as “cloud_m”). It is generally False for images and the default speech bubble.

specBubble

The special bubble. Typically this is equal to something like “sigh_s” or “spike_l”. However, you can pass in particular strings and use this function to take care of what background image it should evaluate to.

Custom Bubble Background Function

Inside variables_editable.rpy is a function called custom_bubble_bg under the CUSTOM MESSENGER ITEMS header. Each chatroom message is passed to this function, which allows you a chance to check for certain conditions and return particular bubble backgrounds.

Warning

You must ensure any new bubbles you allow characters to use (such as a third glowing bubble variant) are added to the all_bubbles_list and have styles defined for them as described above, and aren’t just defined in the custom bubble function.

You can also return general displayables, such as a Frame(), inside the custom_bubble_bg function. For example, you could give Emma (from the new character examples) a second “glowing” bubble variant:

def custom_bubble_bg(msg):

    if msg.who.file_id == "em" and msg.specBubble == "glow2":
        return Frame("Bubble/Special/em_glow2.webp", 25, 25)

    return False

This returns the “Bubble/Special/em_glow2.webp” image, formatted as a frame with borders 25 pixels wide. The inside of the bubble will expand to be large enough to accommodate the text (this is how the regular speech bubbles and glowing bubble variants are defined and used).

You could then write dialogue to use this bubble like:

em "This goes in my glowing bubble." (bounce=True, specBubble="glow2")
msg em "As does this message." bubble glow2

Custom Bubble Style Function

Although the program will try to pick out specific styles based on the name of the special speech bubble used, there may be some cases in which you want to apply a particular style to a bubble. The custom_bubble_style function in variables_editable.rpy will let you return a particular style.

For example, you might want to apply special styling to em’s second glowing bubble variant from the last example:

def custom_bubble_style(msg):

    if msg.who.file_id == "em" and msg.specBubble == "glow2":
        return "em_glow2_style"

    return False

style em_glow2_style:
    padding (30, 40)

This function should return a string that corresponds to the name of a style. For example, if you want a bubble to use the style style my_special_bubble, then you need to return the string "my_special_bubble".

Custom Bubble Offset Function

This function allows you to fine-tune the offset of a message, relative to the top-left corner of the message box (typically the top-left corner of the character’s profile picture). For example, if you wanted to use special speech bubbles for the character on the right side of the messenger (typically the MC), you would need to adjust these values appropriately. This function is expected to return either False or a tuple of (x, y) integers for the position of this bubble.

An example utilizing all three custom functions that allows the right messenger to use Jumin’s large and medium-sized “cat” bubbles might look like the following:

def custom_bubble_bg(msg):
    # If the messenger is on the right side (usually the player), flip
    # the background of the special cat bubble
    if msg.who.right_msgr and msg.specBubble == "ju_cloud_l":
        return Transform("Bubble/Special/ju_cloud_l.webp", xzoom=-1)
    elif msg.who.right_msgr and msg.specBubble == "ju_cloud_m":
        return Transform("Bubble/Special/ju_cloud_m.webp", xzoom=-1)
    return False

def custom_bubble_offset(msg):
    # If the messenger is on the right side, adjust the offset for
    # the two cat bubbles
    if msg.who.right_msgr and msg.specBubble == "ju_cloud_l":
        return (650, 10)
    elif msg.who.right_msgr and msg.specBubble == "ju_cloud_m":
        return (640, 39)
    return False

def custom_bubble_style(msg):
    # Ensure the bubbles use their original styling rather than styling
    # for the main character's bubbles
    if msg.who.right_msgr and msg.specBubble == "ju_cloud_m":
        return 'ju_cloud_m'
    if msg.who.right_msgr and msg.specBubble == "ju_cloud_l":
        return 'ju_cloud_l'
    return False

Adding Chatroom Backgrounds

Chatroom backgrounds must be defined in a particular way in order to be compatible with the scene and show statements to display them.

Existing background options are:

  • morning

  • noon

  • evening

  • night

  • earlyMorn

  • hack

  • redhack

  • redcrack

  • secure

  • rainy_day

  • snowy_day

  • morning_snow

The background names are case-sensitive, so you need to get the capitalization correct.

For this example, you’ll see how the rainy_day background was set up.

To add a new background, inside variables_editable.rpy under the header CUSTOM MESSENGER ITEMS are several variables. First, you need to define the image that will be used as the background. This should be bg + the name of the image as you want to write when displaying it in a chatroom:

image bg rainy_day = "center_bg:Phone UI/bg-rainy-day.webp"

The center_bg: before the file path to the image file itself is optional, but will center the image on the screen if it is not exactly 750x1334 pixels. If your image is exactly 750x1334 pixels, then just image bg rainy_day = "Phone UI/bg-rainy-day.webp" would be sufficient.

You can put this image definition wherever you like, though it may make sense to keep it under the CUSTOM MESSENGER ITEMS header alongside the background variable definitions.

Next, add the background name to the all_static_backgrounds list:

define all_static_backgrounds = ['morning', 'noon', 'evening', 'hack',
        'redhack', 'night', 'earlyMorn', 'redcrack', 'secure', 'rainy_day']

Note that you do not add the “bg” part to the name of your background.

Next, if the characters’ names should appear in black during a chatroom (as is typical of the lighter backgrounds, such as “morning” and “noon”), you also need to add it to the black_text_bgs list:

define black_text_bgs = ['morning', 'noon', 'evening', 'rainy_day']

Otherwise, if the background is not in this list, the characters’ names will be displayed in white.

Adding an Animated Background

If you would also like to add an animated version of your new background, you need to define a specific screen for it. First, however, you will add the background to the all_animated_backgrounds list in variables_editable.rpy:

define all_animated_backgrounds = ['morning', 'noon', 'evening', 'night',
            'earlyMorn', 'rainy_day']

Next, you need to define the screen which will have the animated background. The existing backgrounds are defined in screens_backgrounds.rpy.

Because the new background is called “rainy_day”, you need to create a new screen called animated_rainy_day:

screen animated_rainy_day():
    zorder 0
    tag animated_bg

    # add images here

You must include the lines zorder 0 (to ensure the animated backgrounds appears behind other screen elements) and tag animated_bg (to ensure only one animated background is shown at once, and so that the background is properly cleared at the end of a chatroom).

You can then add animated elements to the screen. For a rainy day background, for example, you might take advantage of the existing slow_pan transform for clouds, and perhaps add raindrops which fall from the top of the screen to the bottom. As the exact requirements for a given animated background will vary substantially depending on what sort of background you want to add, this part is largely up to your own skill with screen language. You can see how the existing animated backgrounds are put together in the screens_backgrounds.rpy file.

Warning

If you would like to include an animated background, it must have a corresponding “static” version that can be displayed to users who don’t have animated backgrounds turned on.

Timed Menus

Note

Example files to look at:

  • tutorial_5_coffee.rpy

  • tutorial_6_meeting.rpy

Mysterious Messenger includes a new kind of menu which will display answers at the bottom of the screen for a brief period of time while the characters continue to post messages to the chat. The player can choose an answer at any time before the timer runs out, or refrain from choosing anything and stay silent. The time the player has to choose a reply depends on the length of the dialogue before the menu. Currently, this type of menu is only available for chatrooms.

An example timed menu may look like the following:

u "Hello, [name]!"
timed menu:
    u "I'm working on a UI for the choices you see at the bottom of the screen."
    u "It's typed almost identically to regular menus this time,"
    u "but with some convenience features I think you'll like."
    u "You should try clicking the options before the timer runs out."
    "This is really neat!":
        msg u "I'm glad you think so!" curly
        award heart u
    "Does it remember choices?":
        msg u "Yes it does!" bounce big curly
        award heart u
        msg u "And you can use regular Ren'Py code in the choices"
        msg u "to do things like award heart points and the like." curly
msg u "You can choose an answer any time while the choices are on-screen,"
msg u "Or just let the timer run out to stay silent, too."

Timed menus are written almost identically to regular Ren’Py menus, but you can add as many lines of dialogue before the first choice as you like. The choices included in the menu will be on-screen while the dialogue after the timed menu: statement is shown.

The dialogue for the menu can be written using the msg CDS or the spreadsheet format. You can also include other regular scripting lines, such as characters entering/exiting chatrooms, inviting guests, or awarding heart points. You can include conditional statements inside the menu dialogue or on choices themselves e.g.

ju "[name], do you own a cat?"
menu:
    "No.":
        $ owns_cat = False
    "I do.":
        $ owns_cat = True
ju "I see. Cats are wonderful creatures, aren't they?"
timed menu:
    ju "Elizabeth the 3rd has been a constant source of joy in my life"
    if owns_cat:
        ju "as I'm sure your cat is in yours."
    ju "It's a shame some may never know the joy of owning a cat."
    "Some people are allergic though, like Zen.":
        ju "That is true."
        ju "I believe that can be overcome with appropriate medication."
    "I don't know what I'd do without my cat" if owns_cat:
        ju "May the two of you never have to be parted, then."
    "I think dogs are better, though.":
        ju "Hmm. I don't agree but I will respect your opinion."

For this menu, the line “as I’m sure your cat is in yours” only appears to a player who previously answered that they own a cat. Similarly, a player who didn’t say they own a cat will not see the choice “I don’t know what I’d do without my cat”.

Tip

Since the choices for a timed menu are smaller, it’s often a good idea to either paraphrase the choices and/or keep the amount of text for each choice caption short. A maximum of three choices can appear on the screen at once for a timed menu.

Warning

While you can use Python statements inside timed menus, such as $ owns_cat = True, you should not change the value of variables that are used in the menu, such as in conditionals. This will cause undefined behaviour. So, the following is incorrect:

$ owns_cat = False
timed menu:
    ju "I believe you mentioned you own a cat, [name]?"
    $ owns_cat = True
    ju "They are wonderful companions."
    "Yeah I do own a cat" if owns_cat:
        ju "I see."
    "I don't have a cat" if not owns_cat:
        ju "Oh, I was mistaken."

Because owns_cat was set to True inside the menu itself, its initial value before the menu (False) is used and it will be impossible for the player to ever see the “Yeah I do own a cat” choice, even if they see all the timed menu dialogue.

You can, however, set variables inside the menu provided they are not used in that same menu. So, the following is acceptable:

# These variables are set up outside the menu in the case that the player
# doesn't see the full menu
$ owns_cat = False
$ answered_jumin = False
timed menu:
    ju "Do you own a cat, [name]?"
    ju "Elizabeth the 3rd has been a constant source of joy in my life"
    ju "It's a shame some may never know the joy of owning a cat."
    $ answered_jumin = False
    "I have a cat.":
        $ owns_cat = True
        $ answered_jumin = True
        ju "You're someone of excellent taste, I see."
    "I don't have a cat.":
        $ owns_cat = False
        $ answered_jumin = True
        ju "Ah, that is most unfortunate then."
if not answered_jumin:
    # The player didn't reply to the timed menu
    ju "I apologize if that was an overly personal question."

Timed Menu Settings

There are two options in the settings that affect timed menus. Both are found under the Preferences tab. The first is Timed Menu Speed, a slider at the top of the screen. Clicking the title will cause the timed menu speed to be set to your current chatroom speed. Moving the slider further to the left will slow timed menus down (giving the player more time to reply), and moving the slider further to the right will speed timed menus up.

This creates a sort of “bullet time” for timed menus, where the regular chat speed may be very fast, but the timed menus will slow down to give the player time to read the messages and possible responses before deciding what to do.

The second option is under Accessibility Options and allows the player to toggle timed menus off altogether. If timed menus are turned off, the menu will act like a regular menu. All of the dialogue before the choices will be shown, and then the player will be presented with the “answer” button at the bottom of the screen. They will be able to choose between any of the given answers, or use a special choice that will be shown as “(Say nothing)” and will function as though the timer on the menu ran out without the player responding.

Keep these options in mind when using timed menus in your script, as not all players will want to keep them turned on.

Timed Menu Functionality

There are a few special things to note about timed menus:

  • The time the player has to answer the timed menu depends on what the Timed Menu Speed slider in the settings is set to. By default this is set to the equivalent of SPEED 5 in the chatrooms.

  • The timed menu’s timer will expire after all the dialogue inside the menu before the choices has been posted. How long it takes to post all the messages depends on the Timed Menu Speed as mentioned above. So, regardless of the player’s chat speed or timed menu speed, they will always have enough time to view all the dialogue inside a menu before choosing an answer.

  • If a player is on Max Speed, the timed menu will be skipped entirely. The dialogue will be posted, but there will be no choices at the bottom of the screen and the program will act as though the player did not reply.

    • However, if the player has timed menus turned off, the answer button will still appear at the bottom of the screen and allow the player to choose an answer (or choose to remain silent)

  • If a player chooses an answer before all the menu dialogue has been posted, they will not be able to see the rest of the menu dialogue.

  • If a player replays a chatroom with timed menus from the History screen, it will always act as though the Timed Menus option is turned off; that is, the chat will always stop at the end of the timed menu dialogue and show the answer button to allow the player to pick a response they have previously seen in-game.

    • If the player has never chosen any of the menu choices in a past playthrough, the answer button and choices will not appear at all (since the only option would be to remain silent). The menu dialogue will be posted and the chat will simply move on.

  • If all the choices in the menu have a conditional dictating when they should be shown (e.g. "I want to visit Seven" if s.heart_points > 10:) and none of those conditions evaluate to True (that is, none of the choices should be shown to the player because they don’t meet the conditions), then the menu dialogue will be shown only if show_empty_menus is True. This variable can be found in variables_editable.rpy and is True by default. If set to False, if a menu has no valid choices then the menu dialogue will be skipped altogether and the chat will continue after the menu.

Chatroom Creator

While scripting chatrooms yourself will allow for the greatest flexibility and allow you to create entire routes inside Mysterious Messenger, the program also offers the Chatroom Creator to visually put together chatrooms and watch them play out or export them to code.

To access the Chatroom Creator, head to Developer options on the main menu and select the Chatroom Creator button. You will then see a sub-menu to either create a new chat or load an existing one.

Creating a New Chat

Upon creating a new chat, you will be prompted to enter a title for the chatroom. This will be recorded on the save screen, and is also used to auto-generate the label and title of the chatroom when exporting it to code. You can change this later in the Other tab of the creator.

The Dialogue Tab

There are several tabs in the chatroom creator. The first one contains several features for adding basic chat messages.

You can select the person who sends the message by clicking the Speaker dropdown. This is also the person who will enter/exit the chatroom if you click the Add Enter Msg or Add Exit Msg buttons (e.g. if the speaker is 707, Add Enter Msg will add the message 707 has entered the chatroom to the chat).

Next there are several buttons to toggle Bold, Italics, Underline, decrease/increase or reset the text size, and an additional dropdown for Fonts. You will be able to see these changes reflected in the text inside the text box.

To add a message to the chat, choose your speaker and add any font options, then click the text box to enter your dialogue. You can either hit Enter on your keyboard or Add to Chat in the bottom right corner to add the dialogue to the chat.

If you make a mistake, the Undo button at the bottom of the Dialogue tab will allow you to undo up to 5 messages. Redo will redo messages you previously undid.

Lastly, Clear Chat will remove all messages from the chatlog. Use this only if you want to completely start over.

Undo & Redo

On the Dialogue tab beneath the text input box, there are also buttons to Clear Chat, Undo, and Redo. Note that undo & redo only go back 5 changes in the past - so save often to be safe!

Clear Chat will ask for confirmation before clearing all of the messages from the chatlog to start completely from scratch. Note that while this can be undone, it’s a good idea to be really sure you want to clear the chat before clicking this option!

The Effects Tab

Emojis

To add emojis to the chat, use the Add Emoji button under the Effects tab. This will initially bring up all of the emojis available to the current speaker. You can select one of these emojis and click Confirm to add it to the chat, or click the X in the top-right corner to cancel.

At the top of the Emojis popup are two dropdowns: Emojis and Speaker.

  • Emojis changes the set of emojis shown which can be selected to add to the chat

  • Speaker changes the character who will send the message

Note that the Speaker and Emojis do not have to be the same person. If you select a different person’s Emojis to be shown, the speaker will be updated to that person. However, you can then update the Speaker to someone else.

For example, if you wanted 707 to send V’s emojis, you would first set Emojis to V to see V’s emojis. Then you would change Speaker to 707, select one of V’s emojis, and click Confirm.

Special Bubbles

To use special bubbles in the background of a message, use the Special Bubbles button under the Effects tab.

This will bring up a popup showing the available bubbles to use. At the top of the Special Bubbles popup there are two dropdowns: Bubbles and Speaker.

  • Bubbles changes the set of special bubbles that can be selected to add to the chat

  • Speaker changes the character who will send the message

As with emojis, the Speaker and Bubbles do not have to be the same person. If you select a different Speaker, the bubbles will be updated to that person. However, you can then update the Bubbles to someone else.

For example, if you wanted 707 to send Jumin’s cat bubble, you would select 707 as the speaker, then select Jumin Han under the Bubbles dropdown and select the appropriate bubble.

When you click a bubble, in most cases you will be given a small popup letting you choose the size of the bubble. After selecting this, you can hit Confirm and the current dialogue in the dialogue box will be posted to the chat with the selected background.

Screen Shake

To make the screen shake, on the Effects tab, you can click Add Shake. This will display a message in the chatlog to indicate where the screen shake will occur.

Animations

To add animations such as the scrolling hack effects or secure chatroom animation, under the Effects tab click Add Animations and select the animation you would like to add.

For the scrolling hack effects, you will also have the option to reverse the animation by checking the Reverse Animation box before clicking Confirm. A message will appear in the chatlog indicating where this animation will play.

The Other Tab

Select Background

To change the chat background, go to the Other tab and click Select Background. You’ll also have the option to include the cracked screen overlay by checking that option at the bottom. Note that this applies to all backgrounds for the duration of this chatroom.

By default this background will appear after the last message added to the chatlog, but you can force it to be set up at the start of the chatroom by checking Add to the beginning of the chat. A message will be displayed in the chatlog to indicate where the background will be changed.

Add Music

To add music to the chat, on the Other tab select the button Add Music. Here you’ll see a list of available songs to add to the game.

Select a song and click Confirm to add it to the chat. A message will appear indicating when the song will begin playing. You can also force the song to start at the beginning of the chat by checking Add to the beginning of the chat above the Confirm button.

Add Participants

To select who begins in the chatroom, on the Other tab, select the button Add Participants. Here you’ll see a list of all characters currently in the game. You can check off who begins in the chatroom and hit Confirm.

Note that this only dictates whose name appears as in the chatroom at the top of the screen during a chatroom. If you use the enter/exit messages, characters will still appear/disappear from that list accordingly.

Play Chat

Clicking Play Chat on the Other tab will let you play out the chatroom as if it had been in-game. Any messages like Play Music: Mint Eye will play as they should in this format (as opposed to it appearing as text). You can use the toggles in the settings at the top-right of the chat creator to turn on/off things like animated backgrounds and the hacking effects as well, which will affect how the chat looks when it’s played out.

Generate Code

Clicking Generate Code on the Other tab will generate a .rpy file inside the game/generated/ folder with the chatroom formatted into code you can put into the program. There are several features the program supports which the chatroom creator does not, such as providing choice menus or jumping to story mode in the middle of a chatroom. If you’d like to use these features, you can use the chatroom creator to build the base of your chatroom before exporting it to code to add these additional features.

Note that the name of the file and associated labels will take the name of the chatroom, as provided when you first made the chat. If you click Generate Code when a file with the same name exists in the generated folder, you will be prompted if you would like to overwrite this file. Keep this in mind if you’ve made changes to the code outside of the chatroom creator, as that will not be reflected in the chatroom creator.

You can rename the chatroom using the Rename Chat button on the Other tab.

The generated code will include a label for your chatroom, an after_ label, optionally for adding things like text messages etc, and a ChatRoom definition for your chatroom that you can use as part of a route definition. Note that you will need to fill in the trigger time yourself; it defaults to 00:00 in the generated code.

Saving & Loading Chats

On the Other tab, there are also buttons to Save and Load. These buttons lead to a different save screen than the main game. You can save chatrooms here and load them later to edit, play, or export to code. They will be saved with the name of the chatroom, which can also be changed on the Other tab.

Editing Messages

In the chatroom creator, you can also edit messages by clicking on them in the preview window. Most messages will have the following options:

Remove message

Remove this message from the chatlog.

Insert message before

Creates an overlay above the selected message. Any new messages will then be added at that particular location in the chatlog. Click the overlay to remove it, and new messages will be added to the bottom of the chat as usual.

Edit text

Update the text and/or speaker of the selected message. You can change the font, size, and the bold/italics/underine of the message.

Change bubble

Change the bubble used for this message.

Change speaker

Change the speaker of this message.

Change profile picture

Update the profile picture of the current speaker.

Note that when editing an emoji, you can only choose another emoji to swap it with. If you’d like to add text instead of an emoji, you can use the message dropdown to remove the emoji, and then click on the line below the one where you’d like to add the new message and click Insert message before. Then type your new message and add it to the chatlog.