Chatrooms
- Chatrooms
- Creating a Chatroom
- Writing Chatroom Dialogue
- Advanced Chatroom Features
- Entering and Exiting the Chatroom
- Updating the Characters’ Profiles
- Clearing the Chat History
- Clearing Chatroom Participants
- Resetting Chatroom Participants
- Providing Choices
- Showing a Chatroom Banner
- Showing a Heart Icon
- Awarding an Hourglass
- Showing the Hacked Scroll Effect
- Showing the Secure Chatroom Animation
- Shaking the Screen
- Showing the Cracked Overlay
- Sending Links
- Custom Fonts and Bubbles
- Adding Chatroom Backgrounds
- Timed Menus
- Chatroom Creator
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):
Create a new
.rpy
file (Optional, but recommended)Create a new label for the chatroom.
(Optional) Set the background with
scene morning
wheremorning
is replaced by whatever time of day/background you want to use.Add background music with
play music mystic_chat
wheremystic_chat
is replaced by the desired music variable.Write the chatroom dialogue.
You may want to use either
Script Generator.xlsx
or themsg
CDS.
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 |
round2 |
s, m, l |
Only available for |
sigh |
s, m, l |
Not available for |
spike |
s, m, l |
small (s) size only available for |
square |
s, m, l |
Not available for |
square2 |
s, m, l |
Only available for |
flower |
s, m, l |
Only available for |
glow |
N/A |
Available for all pre-defined characters excluding |
glow2 |
N/A |
Only available for |
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 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 haveReceive 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
andforce
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
Sending Links
Characters may also send links in the chatroom. You can provide an action for a link message, which will be executed when the player clicks on it. Some convenience functions are provided to make some of these actions simpler.
The simplest way to show a link looks like:
va "Click Link" (link_title="Password")
There are several fields you can provide to a link message to customize it. You must provide at least one of these fields in order for a message to be considered a link.
- link_title
By default, links do not have titles. If provided, the title will be shown in a smaller size above the link’s text inside square brackets (so,
link_title="Password"
appears in-game like[Password]
.e.g. “Address”
- link_img
By default, this is an image of a house. It is 81x81 pixels but can be slightly larger or smaller. You can also provide a general displayable such as a Transform or an AlphaMask.
If you don’t want an image at all, this should be
Null()
, solink_img=Null()
will prevent the link message from having an image.e.g. “Bubble/link_house_btn.webp”
- link_action
By default, a link button will not have any action at all and will not be interactable. See Link Actions for more action examples.
e.g. ShowCG(‘common_1’)
- link_text
Optional. If this isn’t provided, the link text takes the character’s dialogue (so in the line
va "Click me" (link_action=ShowCG('common_1'))
, thelink_text
is “Click me”. If the dialogue is empty, it will be the phrase “Click Link”.e.g. “Click Link”
Note
You can use the msg
CDS for links as well, though it can’t take any additional special parameters such as font, bounce/glow, image, or specBubble. A msg version of a link post might look like:
msg va "Click Link" (link_title="Password", link_img=Null(), link_action=JumpVN('unlock_door'))
Link Actions
Link messages can take any action you want. By default, only a ShowCG
action (which shows a CG image) can be clicked more than once. All other actions (including multiple actions in a list) cause the link button to be insensitive after the action has executed once.
Some special link actions include:
- ShowCG
Takes one argument, the name of the CG image to show. This follows the same naming rules as Defining a CG and Showing a CG in a Chatroom or Text Message, so if you have:
image cg common_4 = "CGs/common_album/cg-4.webp" default common_album = [ GalleryImage("cg common_1"), GalleryImage("cg common_2"), GalleryImage("cg common_3"), GalleryImage("cg common_4") ]
and you want to show “cg common_4”, then you should use the action
ShowCG("common_4")
.This will also take care of automatically unlocking the CG in the player’s album.
- JumpVN
This action will take the player to a Story Mode (VN) section before returning to the chat. It works the same way as
call vn_during_chat
as explained in Including a Story Mode During a Chatroom. The first argument should be the name of the label the program should jump to for the story mode.It also takes all the same arguments, including
clearchat_on_return
,new_bg
,reset_participants
, andend_after_vn
.e.g.
JumpVN("my_story_label", end_after_vn=True)
Note
Unless you pass the argument
end_after_vn=True
to JumpVN, when the Story Mode ends the game will return to the chatroom exactly where the chat left off before the player clicked the link which took them to Story Mode.This means if you have a chatroom like:
u "Click Link" (link_title="Password", link_action=JumpVN("prologue_unlock_door")) u "That's the password for the door." # Player clicks the link before this next message appears u "Try to use it, okay?"
If the player clicks the link where indicated, when they return to the chatroom, Unknown will post the message “Try to use it, okay?” and the rest of the chatroom will proceed as normal. It’s the equivalent of:
u "That's the password for the door." call vn_during_chat('prologue_unlock_door') u "Try to use it, okay?"
However, with the link, the player does not have to click the link to proceed; the chat will simply continue even if they do nothing. If you want to stop the chat to ensure the player clicks the link, see Stopping the Chat.
- LinkJump(label=None, is_menu=False)
Similar to
JumpVN
, this action acts as a jump between labels. UnlikeJumpVN
, however, the jump is intended to be within the same chatroom, rather than jumping to a Story Mode (VN) section.LinkJump
takes two optional parameters. The first,label
, is the name of a label or menu to jump to when the link is pressed. If left blank, this acts likeContinueChat
if the chat is stopped, or does nothing if the chat is not stopped.is_menu
can be set to True if you would like this LinkJump to jump to a menu without showing the answer button at the bottom of the screen. For example:u "Click Link" (link_title="Address", link_action=LinkJump('getaddress', is_menu=True)) stop chat menu getaddress (paraphrased=True): "(Go to the sent address).": pass
When the player presses the link, they will immediately see the option to (Go to the sent address) as though they had pressed the answer button on a menu.
- ContinueChat
This action will cause the chat to continue if it was previously stopped.
- IfChatStopped(true_action, false_action=None)
This is a special action that takes two parameters. The first is the action (or list of actions) to perform if the chat is stopped when this button is clicked. It can also be
None
to do nothing if the chat is stopped.The second parameter is the action to perform if the chat is not stopped (see the section below for more on stopping the chat). This parameter can also be
None
or omitted to do nothing if the chat is not stopped.e.g.
link_action=IfChatStopped([ShowCG('common_2'), ContinueChat()], ShowCG('common_3'))
This causes the CG “common_2” to be shown to the player if the chat is paused before continuing the chat. Otherwise, if the chat is not paused, clicking the link will show the “common_3” CG instead.
This action is useful if you only want the player to be able to proceed by clicking a link once the chat is stopped e.g.
link_action=IfChatStopped(JumpVN('drive_scene_2'))
If used as the link action, the player can only click on the link when the chat is stopped.
Stopping the Chat
If you want to stop the chat to wait for the player to click on a link, you can do so with stop chat
e.g.
u "Click Link" (link_title="Password",
link_action=JumpVN('unlock_door_password'))
stop chat
This will prevent any further messages from being posted and displays the text “Click the link to proceed” at the bottom of the screen. If you would like to change the text, at the bottom, you can also provide a string after stop chat
like:
u "Click Link" (link_title="Password",
link_action=JumpVN('unlock_door_password'))
stop chat "Click the link to continue"
There is also an optional toggle in the Developer Settings called Use pause footer for links which will show the pause button at the bottom of the screen while waiting for the player to press a link. Note that if you do choose to enable this, it is less clear to the player what they should do to proceed with the story when the chat stops to wait for them to click a link.
Warning
If you use the JumpVN
action, the chat will automatically resume after it returns from the VN label. However, if your action is doing something like viewing a CG or setting a variable, you must include the action ContinueChat()
as the final action in your link_action parameter:
s "Add to Contacts" (link_title="Contact Info", link_img=Null(),
link_action=[CConfirm("Phone number added to contact list."), ContinueChat()])
Note
CConfirm
is a special action which shows a confirmation prompt to the user. In this case, it displays the given message and requires the player to press Confirm to dismiss it.
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.
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.