What are /r/RenPy's favorite Products & Services?

From 3.5 billion Reddit comments

Actually, this is common enough that renpy built it in. There's still a fair bit of work, but the hardest stuff is done for you.

https://www.renpy.org/doc/html/rooms.html#image-gallery

You'd build a screen.

If you're good with documentation, then this will help, otherwise - given how complex screens can be, you'd want a tutorial of some description, some pre-built code you can dump in a test game and then fiddle with to see what does what. Specifically you'd be looking for things relating to Imagebuttons.

I'd point you to a good tutorial, but I can't find any of the text based ones I used before, just a lot of videos, and I have no idea if any of those are good or not.

Use persistent variables, just use persistent.x with x as the variable name. For example, you could have persistent.playthroughs (int) or persistent.some_character_ending (bool). Check the official documentation and this Reddit post for more info.

There's no inbuild quest-menu in renpy. You could try and customize the ordinary menu screen to your needs but I wouldn't recommend it. Instead you should build the menu yourself. You can replicate the menu you posted, with 1-2 image screens, around 7 text buttons (the ones on the left) and 2 text screens ("opportunities" and the text below the image on the left).

Your best approach is to learn how to use screens by starting with the inbuild tutorials that comes with renpy. Read the documentation for screens: https://www.renpy.org/doc/html/screens.html and look around the lemmasoft forum for some examples and try for yourself again.

The first can be done using character callbacks as explained here:

https://www.renpy.org/doc/html/character_callbacks.html

There's an example doing exactly what you asked about.

The rare dialogue can be done using Ren'Py's random number generation.

https://www.renpy.org/doc/html/other.html#renpy-random

For example, you could generate a number from 1 to 10 and then use an "if" statement to only play it if a 1 was rolled.

Hope that helps!

I guess, "extend" could help?

u "text" with vpunch extend "text2"

and so on?

That aside you can add to your "u-character" some pre- and suffix ( what_prefix and what_suffix), so that you don't have to add the " that are shown in the textbox.

https://www.renpy.org/doc/html/dialogue.html#defining-character-objects

The room will be a Screen in Ren'Py. Each of the things you can click will be an Imagebutton. You can get the shine effect by setting a different image for "hover". You also want to define an "action" for each one. For the objects, the action would be to show text. For the door, the action would be to show a new Screen for the new room.

Let me know if anything doesn't make sense. I tried to write it as simply as I could. I know the links are in English, but there's no Spanish ones.

There's an antialias style property that you can disable.

https://www.renpy.org/doc/html/style_properties.html#style-property-antialias

Note that it will make your text look particularly unpleasant on anything that uses an High DPI/Retina display.

When the player makes a choice, you'll want to add some Python code. For example, if the player made a pro-Trevor decision, you could write $ trevor_points = trevor_points + 1. The "$" makes it so you are writing Python code by the way. Don't forget to set "trevor_points" to 0 at the start of the game too. The same stuff will apply to Coen.

Once you get to the scene that decides who you end up with, you'll want something like this:

"This is normal dialogue." if trevor_points > coen_points: jump trevor_ending elif coen_points > trevor_points: jump coen_ending else: jump neutral_ending

You may need to replace "jump" with "call" depending on if those scenes will return or not. Elsewhere, you'll need labels with those scene names.

Here's some information about if statements and Python statements so you can learn more. Hope this helps!

For generating random numbers use renpy.random.

For animations, this is how you do them:

image Test_animation: "Frame_1.png" 7 "Frame_2.png" 0.15 "Frame_3.png" 0.15 "Frame_4.png" 0.15 "Frame_5.png" 0.15 "Frame_6.png" 0.15 "Frame_7.png" 0.15 repeat

You use that by adding it to a screen that you show:

add "Test_animation"

For everything else you need to actually learn and use Python scripting.

If you are wondering how some game did something you can just use Ren'py decompiler to get the game source code.

I assure you that if you do that, you will realize that all advanced stuff is done in Python and it takes a lot of effort.

There is a (NSFW, adult) game called Allie's Quantum Adventure. You can learn a lot from looking at its code.

You can always use a persistent variable like for example $ persistent.playtrough = 0. Persistent variables are saved in a local persistent file and apply across all saves and new playthroughs (from my understanding). At the end of the first playthrough, you could increase the variable by one and add if statements across the files which only happen if the variable is equal to 1.
Here's the documentation.

There are two different types of double quote marks. One are the neutral ones that look like "this". The others are the fancier ones that look like “this”. You have to use the neutral ones on the outside of your dialogue:

bob "Hello."

That will not show any quotation marks. If you want to put quotes inside as in your second example, you'd want to use one of these methods depending on the type of quotation mark you want.

"The human said \"hello\"." "The human said “hello”."

In the first, you have to put backslashes in front, which is called an escape character. In the second, this isn't needed because fancy quotes aren't special characters in Ren'Py.

If you always want quatation marks around your dialogue, you'll want to define your characters to use what_prefix and what_suffix as talked about here.

Hope that helps!

Where did you get the line

block:

?

It looks like you're trying to play an animation - that's not really the method to do that - give this document a read

You're looking for persistent variables! There's a lot of things to read about it and how you can use it but I'll give you the gist.

For regular variables, you would declare them after start, so they have a default value that is reset each time the game is started over. Persistent variables, however, are not defined at start. Their default value is False, and once set to True (or any other state, they can take numbers, strings, etc. just like regular variables), they will stay that way until you change them or the persistent data is deleted, usually by deleting all game files or using the "delete persistent data" option on the Ren'py launcher for WIPs. Persistent variables look the same as regular variables, but have "persistent." in front of them.

label start: if persistent.remember: "You remember your previous life, and a sense of confusion washes over you." return elif persistent.forget: "You feel like you're forgetting something, but you can't quite seem to remember it..." return

menu: "Remember what happened here.": $ persistent.remember = True pass "Forget what happened here.": $ persistent.forget = True pass return

In this example, if the player has already played the game, the game will show one of the first two lines of dialogue and then return. If they haven't it'll show the choice and then return. You can use these in screen codes to show/hide things like CGs for galleries too!

It sounds like you're describing a spalsh screen - check out the documentation here: https://www.renpy.org/doc/html/splashscreen_presplash.html

Basically, you just need to put

label splashscreen:

$ renpy.movie_cutscene('opencard.mp4')

return

somewhere in your script, as long as it's not in a block (including label start). I put mine right near the top, immediately before start.

Hope that helps!

Yes, you want to use renpy random.

https://www.renpy.org/doc/html/other.html

For example, you could use:

Storyline = renpy.random.choice(['hacker','wizard','barbarian'])

Edit then set your storyline to have some checks so if storyline = 'hacker' goto...

For the door clicking you'll need to look into screens and screen language. You could make it easier on yourself by just having menu options pop up in a list on top of a picture of the room, but it might not be as aesthetically pleasing so either direction is understandable.

Here's the documentation for Ren'Py screens: https://www.renpy.org/doc/html/screens.html

And here's a YouTube tutorial I like: https://youtu.be/SaWkkmU1QLI

If you have any questions you can post them here and we'll try to help where we can. The community is really nice from my experience.

You want to set a default cps (characters per second) option and see the slider for it in the options menu. To force it for a specific line (since the player can change that value, see the cps text tag.

If you define your characters with an image attribute as explained here, you can just “show” the new sprites and Ren’Py will automatically hide the old ones that belong to the same character. So you only have to use hide when the character leaves the scene. Note that your images for the character have to begin with the same word in this case, like “eileen happy” and “eileen sad”.

Showing without effects is done using with None. Hope that helps!

So, the way the at left and at right work is that they put the bottom left/right corner of the image in the respective bottom corner of the screen.

If they are covering the central figure, then your images are too big.

Now maybe they're transparent PNGs with too much space on each side of them. If that's the case, readjust as needed. Cut off the empty space and the problem will self resolve.

But let's assume part of them needs to hang off screen AND that you need the full image because you have the figure on the left move across the screen to the right or vice versa.

What you're going to want to do is define your own transformation.

So instead of

show Mike at left

you'll use something like

show Mike at trueleft

or whatever you decide to name the transformation.

so you'd do something like

transform trueleft:

xalign 0.01

or whatever your xalign is.

If it's the same size and proportions as the default, then replacing /gui/textbox.png will work.

Otherwise you'll want to change it in options.rpy

This guide should help

Movies are not supported on Web

That said, it shouldn't cause it to crash.

You can use the animation features to run the images through one frame at a time, and the sound options to play the appropriate sounds.

The phrase "HD resolution" is meaningless, as that simply means 1280 pixels or higher on one dimension - technically two dimensions, 1920 X 1080 and 1280 X 720, but it's generally used as a catch-all for 1280 or higher that isn't 4K. That said, the resolution shouldn't matter.

https://www.renpy.org/doc/html/splashscreen_presplash.html
its not too hard, pretty much just make a label named "splashscreen." Everything in that label happens before the main menu is rendered!

Yes, you can use renpy.input for this with a prompt:
$ name = renpy.input("What is your name?", "hopiequinn")
That way, it'll display the prompt at the bottom as a text box with the input allow the player to type their name.

define config.rollback_enabled = True

Set that to False to prevent players from rolling back. I strongly suggest you not do that, especially if you like to add in blocks of "...." or clicks to finish a full textbox as players can accidentally skip text. One of the first comments on your game is likely to be someone giving a walkthrough on how to re-enable rollback, since people expect it to exist, thus negating the whole thing in the first place.

The way I'd recommend to "block" Rollback is $ renpy.fix_rollback()

Here's a description of how to use it. That way, players can still roll back to re-read text they missed, but they cannot change decisions they made.

It's not only harder to undo as it's not a simple boolean in a config but an entry after every single choice option, it also prevents accidental clicks from preventing the player from reading the story.

You can use the volume clause to decrease the volume of audio as shown in the second example here. I don't believe it's possible to increase it within Ren'Py.

Your best bet is to do it in an audio editing program like Audacity and modify the file directly. Just be sure to not to go too high or you'll oversaturate the audio and it'll sound distorted.

Oh boy. Five days is not much time and that's quite a bit. I'll take it item by item.

• Menus: I assume you mean like an "options menu" kind of menu. You can find info on that here.
• MMD models: Not that I know of. Ren'Py uses 2D sprites, in jpeg, png, or a couple other normal image formats.
• Moving characters: Technically yes, but anything other than "slide the image from one side of the screen to the other" will be custom and difficult.
• Snow/rain: Yes, but it'll have to be custom.
• Mini-games: Yes, but again custom, and pretty difficult.
• Waking up, screen shakes: Yes. Those aren't too bad. Screen shakes are built-in, and I'm sure someone online has code/images for waking up.

All that said, that is a lot to do and learn in 5 days. I'd recommend simplifying it by removing the mini games, and try to find some free sprites online. I know there are some websites that have them.

You should go through the bulit-in tutorial that comes with Ren'Py so you can get a better feel for what the engine has built-in support for so you can form your ideas around that.

> I only have five days left.

It will be very difficult to do most of the things on your list in five days if you have no experience with Ren'Py.

Your best resource will be the official documentation, especially the quickstart guide.

That said, in five days, you probably won't be able to anything except an extremely short and very simple game. That means something like "The Question", which is the demo game included with Ren'Py.

I know this is possible. I think you have to copy the menu screen, calling it something like "timed_menu". Add a timer to that screen. Jump to the second menu.

The old documentation provides an example but I don't know if it still works.

You might need to install an additional font. The boxes issue is what happens when it cannot find the appropriate font, and RenPy only uses DejaVuSans without additional fonts installed.

Google has some free fonts that can be used in free and commercial projects

While it would work, it really feel like something that could/should be defined by a warper or some other equation. (I'm not sure of the method, tho. Probably a bounce that get from X to Y, and then another from Y to X to go back to the default position)

There's a number of things that could be going wrong, but I think the most likely is that you're using characters that aren't available in your font, in which case you'll need to use font groups to define fallbacks

A rotating clock hand would be easier than an hourglass, as you just need to have the clock hand image (with the base of the hand being in the center of the image, most of the image being completely empty space) and then rotate it however many arcs you need (180 if you're doing 30 seconds on a stopwatch, for example) in however long you need it to rotate.

This thread has some older information that may help, as well as the documentation on transformations and animations

If you wanted to do an hourglass, an image of an hourglass with a translucent middle part, then a static image of a pile of sand could crudely work, of animating the sand as two different images behind the hourglass (one pile slowly rising up, the other pile inverted and sinking down). Would need to edit the images creatively, possibly have the hourglass in multiple parts....

A rotating arm is easier.

Thank you!
Adding emojis is actually very easy.

"message": "Check out this emoji! {image=/ui/phone_ui/emojis/waving.webp}"

Since messages are simple text strings, you can use tags on them.

In this case I'm using the image tag.

You could create your own function, I would suppose. Look at How to create my own functions? - https://www.reddit.com/r/RenPy/comments/8dv4cu/how_to_create_my_own_functions

You could also try to create your own statement, but I have never done that myself, so I don't know if it's a good idea or not. https://www.renpy.org/dev-doc/html/cds.html

These will go into your screens.rpy, something like:

style quick_button:

properties gui.button_properties("quick_button")

activate_sound "audio/sfx/Confirm-UI.ogg"

​

Also hm... I'm sorry the documentation isn't working for you. Maybe I linked it wrong?
https://www.renpy.org/doc/html/style\_properties.html

Append the following to your buttons/styles.

activate_sound "audio/sfx/Confirm-UI.ogg"

There is also hover_sound as well. Check the documentation below for more details:
https://www.renpy.org/doc/html/style\_properties.html?#style-property-hover\_sound

You can try to define custom transforms and use them like this:

show character at your_custom_transform

Here is how you define a custom transform: https://www.renpy.org/doc/html/atl.html#atl

But this will take some time to define all the needed transformations and you may lose a bit of flexibility if you want to create "custom" transformations.

When I get to this point my best friend is the classic copy/paste. It is faster and more flexible than to declare those custom transforms. But if I need a specific transform each time I do go and define it.

Hey, try replacing your call line with the following:

call expression "chapter" + str(chapters)

There's more information on call statements in the renpy wiki.

Good luck!

What exactly do you want to happen?

If you want to give the player a choice of scenes, then you want to use a menu instead.

If you want to set a flag/variable that is later checked and leads to a different scene depending on whether it's True or False, then check out the documentation here.

IIRC, "wav" is not supported.

https://www.renpy.org/doc/html/audio.html

Ren'Py supports playing music and sound effects in the background, using the following audio file formats:

Opus Ogg Vorbis MP3 WAV (uncompressed 16-bit signed PCM only)

Opus and Ogg Vorbis may not be supported in WebKit-based web browsers, such as Safari, but are the best formats for other platforms.

You could also use condition switches, so that you have a base image that gets/removes some stuff so you could still uses "eileen smiling" if that is more up your alley.

https://www.renpy.org/doc/html/displayables.html?highlight=condition%20switch#ConditionSwitch

You'll want to edit the navigation screen in the autogenerated screens.rpy file. Specifically, you'll want to add code like this under a main_menu check, probably just before or after the Start button:

if persistent.finished_game: textbutton _("New Game+") action Jump("new_game_plus")

You can read about the Jump screen action here, and remember to tweak it based on the names you've chosen for things. Then, just define the new_game_plus label, set a flag, and jump to the real game:

label new_game_plus: $ in_new_game_plus = True jump start

Check the default transitions that are available to be incorporated in your images.

https://www.renpy.org/doc/html/transitions.html

You can add the transition to any of your images using the "with" expression. For example:

scene first_image with dissolve

I agree!

Unfortunately, I wasn't able to discuss Transition Class (which has customizations) in the same video but I plan to make a video about it in the future.

You can learn more about transition class here to increase your game's quality:

https://www.renpy.org/doc/html/transitions.html#transition-classes

You're close, just missed one thing. Menus with if statements are explained here.

The short version is that you are missing the actual menu statement, so it should be like this:

label menu_tour: menu: smartass "Let's go to..." "Kitchen" if notint_kitchen: jump introduction_kitchen "Bathroom" if notint_bathroom: jump introduction_bathroom "Laundry Room" if notint_laundry: jump introduction_laundry "Living Room" if notint_living: jump introduction_living "Garage" if notint_garage: jump introduction_garage "Porch" if end_prologue == 5: jump introduction_porch

Also, note the "==" on the last if statement. That's how you comepare with integers properly. Hope that helps!

You want to use "call". After you return from a call, it will put you right back where you were in the previous code block.

https://www.renpy.org/doc/html/label.html#call-statement

Alternatively, you could just have the menu as its own separate label, we'll call it "menu". Then at the end of your dialogue snippets, they just use jump menu

show [character] at right with moveinright

show [character2] at left with moveinleft

show [character3] at left with moveinright

show [character4] at right with moveinleft

should get you started.

This page will help too

If a character is already on a screen, you can do something like

show [character]

linear 2.0 xpos 0.5

that'll move them to the middle of the screen. xpos 0.0 is one side (left I think?), 1.0 is the opposite side, 0.5 is dead center. The linear X.X is how long it takes to move in seconds.

You first need to define the images like this:

image delilah smile = "delilah_smile.png"

Then to show it you use this:

show delilah smile

More information here: https://www.renpy.org/doc/html/displaying_images.html

That’s doable in Ren’Py. You’d want to create a new Screen for the mini game, and add Imagebuttons for the ingredients. You’ll want to call some function when they’re clicked to check which were selected against the recipe or whatever. It’ll definitely take some work, but shouldn’t be too bad.

You want the nw tag for the interruptions. The half second pause could be done with a “pause 0.5” on the following line.

Edit: Maybe also the “fast” tag from the example at the link.

Is there a specific reason you're not using the predefined audio channels?

You shouldn't need to define audio just to play a song; Ren'Py is equipped to handle this already.

If you have a folder "audio" in your game directory, with "yearning.mp3" as a file in that audio folder, line 8 shouldn't be needed, and line 42 should read as:

play music "audio/yearning.mp3"

To later stop playing with a 1 second fadeout, code would read as:

stop music fadeout(1)

You can read more about predefined audio channels in Ren'Py here: https://www.renpy.org/doc/html/audio.html

Hope this helps :)

renpy.random.choice() Gets a random item from a list. Just assign that to a variable and then use variable interpolation to insert the selected item into the menu choice. Hope that helps!

I was also trying to play around with the side image feature of RenPy recently, so maybe I can help out?Here's an example directly from my VN code:

define c_f = Character("???", image="creator") image side creator happy_s = "side_creator_happy_s.png" label start: c_f happy_s "Hello, and welcome to the world of your ordinary high school life!"

To break down line by line what my code is doing:

1) Defining the character 'c_f' and also giving it the image name of "creator". This means that any image defined with its first tag as 'creator' (ex. image creator blargle) can be called up by the character 'c_f'.

2) Defining the particular image you want to display as a side image. It has its primary tag as 'creator' and its secondary tag as 'happy_s', meaning that it can be called with the character 'c_f'

3) 'start' is a special kind of label that indicates to RenPy that the game has officially started.

4) This line basically calls the character c_f to speak, while also assigning the image that will appear with the character's speech. In this case, the picture with the secondary tag 'happy_s' will automatically appear in the bottom left corner.

Your 2nd line is missing a secondary tag characteristic, and you should be defining it like:

image side mercy neutral = "wherever the picture is"

Your 3rd line may be unnecessary for what you're trying to accomplish.

Try giving Mercy a few words to say and test it out! Practice is the best way to get familiar with RenPy. And make sure to always have the RenPy Official Documentation handy. Good luck! :DD

Not sure about the icon issue.

For other things you should do, set config.developer to False or auto. You can also remove .rpy files from the distribution to save some space and/or package things into .rpa files. There’s quite a bit on this page if you haven’t seen it.

After you install it, run through the built-in tutorial. That'll teach you about 90% of how to make a game in the engine, but it's pretty basic. After that, have look through the online manual whenever you need to learn something new, or at least at the Quickstart section. It's well-organized and explains everything in more depth. That'll get you to about the 99% mark. That last 1% is Python, which you should only use when you need it. What you need to do will vary from project to project though, so just search on the internet for how to do that once the need arises.

Outside Ren'Py itself, you'll want a good text editor. I personally use Atom, but that's down to your preference.

Lastly, when questions come up, both this sub and the Lemma Soft forums have people who can help answer them.

Hope that helps!

Here's a link to the manual page. The short version is:

• Put the files in your "game" folder
• Add lines like play music "song.mp3" to your script

Hope that helps!

There's a game engine for it called pywright. You might want to use it instead.
Disclaimer: I haven't used it.

https://www.pygame.org/project-PyWright-904-.html#:\~:text=PyWright%20is%20a%20game%20engine,the%20Nintendo%20GBA%20and%20DS.&text=It%20feels%20somewhat%20like%20BASIC,borrowed%20elements%20from%20other%20languages.

I actually got it from a couple of places, but the official documentation is at https://www.renpy.org/doc/html/input.html.

In particular, the section that has:

define pov = Character("[povname]")

python: povname = renpy.input("What is your name?", length=32) povname = povname.strip()

if not povname: povname = "Pat Smith"

pov "My name is [povname]!"

Yes, sorry. That's exactly what a dynamic character is. It'll use the value of the variable named "player_name" as the name of the character in this case. You can read more about it if you serach for "dynamic" here.

You can manipulate the image, see here:

https://www.renpy.org/doc/html/im.html?highlight=contrast#

I have never tried these with videos !

I believe a Viewport is what you need for that. In case you haven't looked at the docs for that, here's a link: https://www.renpy.org/doc/html/screens.html#viewport

Don't have time at the moment, but might be able to give an example later on if you still need. Maybe play around with adding it to a screen, something like this:

viewport: mousewheel True text "testing"

You can probably name a variable as the password. Now on the chapter select, use text input to compare the variable to some text that a user inputted. If they are equal, jump to the next chapter. Else, deliver the message "incorrect chapter."

If that doesn't work, I also found this on the forums. I haven't read through it but it might be useful.

This is a general Ren'Py community, you'd probably be better off asking one dedicated to the game, but I'll give it a shot.

You need two things: Developer console access, and the name of the variable that stores your money.

For developer console access, hit capital "D". Does the screen change and let you type stuff? Then you have it already. If not, you'll need to enable it. More on that later.

For the money variable, you need to find that online somewhere. If you know it and had console access type:

name_of_variable = 100

Substitute however much money you want and the variable name of course.

Now, if you either don't have the console or don't knowthe variable, you'll have to decompile the game, edit the code to set config.developer to True if you didn't have the console, and then search through the code for the money variable if you didn't know the name of that.

Hope that helps!

This is a pretty common mistake. Basically, what you want to be doing is instead of hiding specific sprites, you want to hide the characters so to speak. Now, that'll force you to update your character definitions, but it'll also make a lot of things magically work too. The key is telling Ren'Py that certain images are actually tied to your Characters.

Let's take Himeko for example. You probably have something like this:

define H = Character("Himeko")

That should instead be this:

define H = Character("Himeko", image="himeko")

Your sprites then should not be like this:

image himeko-smile = "himeko-smile.png"

But like this, note the space:

image himeko smile = "himeko-smile.png"

"himeko" becomes a tag, so you can then use the sprites like this:

show himeko smile H "Dialogue" H frown "You can even change the sprites like this now." hide himeko

As it is, Ren'Py is treating each "emotion" as an individual thing, meaning you have to hide them every time or else it'll only hide one emotion of the several you show.

Hope that helps! Also, please change from hyphens to underscores in your naming of variables. I'm astounded hyphens work at all to be honest, but it'll only cause you problems down the line if/when you have to deal with Python.

You can also read more about this here.

You'll want to archive them, but as the docs say, it is fairly easy to work around and there are downsides since you are restricting people from running it on other platforms in the future, unless that workaround is applied first.

use zoom: https://www.renpy.org/doc/html/atl.html#transform-property-zoom

a number greater than 1.0 will enlarge the image (make it "closer"), a number less than 1.0 will be smaller (make it "further").

​

I'd recommend that you have a higher quality sprite. because the more you zoom in on an image, the more pixelated it appears. So try to get a higher resolution sprite to offset this.

if you wrap an image in SnowBlossom you can have it fall from the top of the screen:

image snow = SnowBlossom("snow.png", count=100)

Here are the docs, lots of optional arguments you can configure to get the exact effect you want :)

https://www.renpy.org/doc/html/sprites.html?highlight=snowblossom#SnowBlossom

You might be interested in the Blocking Rollback and Fixing Rollback sections of the official documentation.

Use condition switch: https://www.renpy.org/doc/html/displayables.html?highlight=condition%20switch#ConditionSwitch

Here is a documentation page on Displaying Images: https://www.renpy.org/doc/html/displaying_images.html

It mentions what the default layers are for Ren'py but it also shows you how to define your own layers, with config.layers

You'd potentially want to define a new layer that is above the overlay layer, just to be sure your images are always on the very top of everything.

Then when displaying your images with show just make sure to use the onlayer property for it and point it to your custom layer.

There are two ways, if I understand what you want correctly. One would be to add another new layer to your list and show your overlay "show image onlayer yourlayer"

https://www.renpy.org/doc/html/config.html#var-config.layers

or just use, when a new image is added "show newimage behind overlayimage"

Example code for textbutton outlines would be:

text_outlines [(2, "#000000", 0, 0)]

For regular text and labels inside of screens, it's the same except without the "text_" part.

From there on, you'd probably want to make a style with that code in it and use said style, or you could manually apply the code everywhere you need to. Though to be honest, I'm not sure where exactly you'd put it.

Disable the save screens so the player cannot access it. Set the keymaps for the quicksave/load keys (Not sure what they are offhand) via this method -

screen my_scr:

key "K_F1" action Null()

key "K_F2" action Null()

as I think it's F1/F2 by default - in any case, that should overwrite the defaults and make the buttons do nothing.

Or open the file listed here and erase the keys needed to get in.

I still urge you to strongly consider if that's narratively necessary. A very vocal set of people despise not being able to save as they please. Whether or not they're a large number is irrelevant as well - if you look at a game and see five or six people trashing it because they can't save, you're likely to skip it as well even if you don't care about saving.

not completely sure, but i found this page on the documentation and this excerpt:

"RPA archives are created by the engine upon clicking the "Build Distributions" option in the launcher. Ren'Py scans itself and the project and creates the archives it deems necessary, filling them with the files pertaining to the project. The files included in this archive will be those defined in the "build.classify" function."

Yes, you can do that. You’ll see that in the documentation. First, I’ll post a quick image of where I used it imagebutton code

The documentation is https://www.renpy.org/doc/html/screen_actions.html?highlight=imagebutton

And as you can see you can’t have the code directly there. You’ll have to write the function you want somewhere else and then call it.

You can change the font as well, if that’s what you’re looking for. You have a bunch of different fonts to use for free inside of your computer, so you can use those. Just be careful to copy and paste.

https://www.renpy.org/doc/html/gui.html?highlight=font

It’ll be in the intermediate section here.

I think you want renpy.music.play and stop in your text_chirps function, I can't find the "sound" ones in the Ren'Py manual. Could be wrong about that though.

I think the main cause is these two things though:

~~Your last line should be "play sfx" if you want to play on that channel instead of the built-in sound channel.~~ Edit: Scratch that.

You also need to specify that "sfx" is the mixer argument of the function as described here. So, like this:

renpy.music.register_channel("sfx1", mixer="sfx")

Hopefully that fixes it!

The default voice is controlled by the operating system. Your options will be limited there.

https://www.renpy.org/doc/html/self_voicing.html

init python:

if renpy.windows:

config.tts_voice = "Mark"

elif renpy.macintosh:

config.tts_voice = "Alex"

elif renpy.linux:

config.tts_voice = "english_rp"

Add that and change the voice to the one you want to use. Just remember it needs to be one of the Windows voices (for Mark) or relevant voice on the operating system in question.

You can use renpy.random.choice to choose a joke from a list of them. Then print the variable with the joke using interpolation. Hope that helps!

That's because you've only defined characters, not images for them. That's all automatic as long as you name the files properly and put them in the right spot, which you can read about here.

One other recommendation I have is to define the image attribute for your characters which you can read about here. For example:

define a = Character("Alice", image="alice")

That way Ren'Py "understands" that the "alice" images go to the "a" character and it will automate some things for you.

For your first question, the only way I know how to change the color of the button itself is the gui/button/choice_hover_background.png file described here, but it sounds like you found that already. Not sure on the second question.

For the main menu music, you want this option. Set it to the path to the music, like "audio/theme.mp3". If that doesn’t work, please post the code, show the path to the audio file, and show the error message.

Easiest way is to just add styling to the string like

"{color=#ff0000}Morning{/color}"

https://www.renpy.org/doc/html/text.html

You also might want to include a background box behind it too.

You can see how to set a different font for each language you want to support here. Korean especially is usually in different font files than Latin texts. Here's some good, but plain, fonts that have good coverage of a lot of character sets:

• Google Noto
• GNU FreeFont
• DejaVu fonts (the same one as default in Ren'Py, just make sure you get the full version)

You can see a more full list here.

I'm assuming you mean "More money" type cheats, where you manipulate a particular aspect of the game.

Because technically speaking = everything here will work, but most of it won't be particularly useful.

dir() should show you all the active variables. The downside is - it shows you all the active variables. A relatively straightforward game may have dozens, possibly hundreds of variables and this may not show you everything. You'll need to both dig through the list AND hope the developer named the variables functionally - player_money, for example, and not pm3 (alongside pm0, pm1, pm2, pm4, and pm5, none of which are explained)

Another method is, not using the console but a text editor, examine the files themselves and hope the developer commented in what the variables were doing where (... unfortunately, not as common as it should be)

For some esoterically named variables, you're going to need to know a bit about RenPy so you can take the game apart and figure it out from there.

And, of course, if the game is programmed in a nonstandard way or without the idea of cheating being possible, it's entirely possible your cheats'll be overwritten in six moves anyway, when the Dev does a "player_money = 500" instead of "player_money += 500" - hardsetting the funds to 500 instead of just adding.

So..

The TL:DR version is - dir() should do it, but it's probably not going to be particularly useful as it's going to overkill you with information, most of it irrelevant to what you're trying to do - and none of it explained.

This page says it’s out of date, but it’s still valid and a good summary of what you need to do in the first section. Hope it helps!

https://www.renpy.org/wiki/renpy/doc/tutorials/Remembering_User_Choices

Instead of using “jump”, use “call” and place a “return” at the end of each scene. I’d actually recommend doing that in general for this reason.

You can read more about them all on this page: https://www.renpy.org/doc/html/label.html

Ideally you use a photo manipulating program to generate new files of the appropriate size so that different zoom levels pixelate everything the same way.

But if you're only doing it on occasion, it may not make sense to generate one file for one scene.

So you use a Warper

show alice happy:

zoom 0.75

This will make the alice happy image 75% of it's regular size.

show alice happy:

zoom 3.0

will make Alice Happy 3 times it's normal size.

This may be of interest

Outside of that, I don't understand what you're asking as there's not enough detail to know if you're referring to a specific Live2D process or jargon or the generalized gaming meaning of the word physics and how it would be applied here.

It sounds like NVL is what you are looking for. It hides the default window permanently in favor of a larger, text-heavy window. Here is the docs for it.

This link explains some of it. Basically, by tying a character to an image tag, Ren'Py will "understand" that those images are of that character and it can then automate some things like my first and second suggestions. You will have to rename your image sprites to be like "image char1 talking" and "image char1 not_talking" though.

It's not a "huge problem" per se, but there's no reason not to do it and it will make your code significantly simpler. Plus when you add sprites, it'll be easier to do since you have everything set up already. There's a huge long-term benefit, so I 100% recommend doing that now and on all new projects.

This page of the manual describes how to define layered images. I've never seen one defined with just if/else statements before and no groups or attributes, so my guess is it's to do with that.

Also worth noting that since you're using variables that aren't set on game startup, you'll have to delay the definition of the Char image until after they've all been set by the player. Looks like you probably did that anyway, but it's hard to tell without looking at the full code, so thought I'd call it out.

Jump should be correct. My only theory is maybe that's not the right syntax for doing multiple actions or something. Can you try using only a Jump action to an intermediate label that in turn hides the screen and Jumps back to the start label?

For the "p" relpacement, you want "w", described here.

The signal you're talking about is called a "click to continue" marker. You define them for Characters and you can read more about them by looking at the "ctc" stuff here.

Hope those help!

What you want are called Transforms. There's a page in the manual about them here. The screen size is irrelevent. What you want to basically do is define custom ones, like this:

transform midleft: xalign 0.33 yalign 0.0

Then you can say "show alice at midleft" in your code and she'll be about a third the way across the screen from the left (the 0.33 is 33%). Figure out how many characters are on screen at once, and then experiment with what looks good in terms of those percentages to define positions.

Hope that helps!

Yeah, you can do that using the color tag. What I'd do is declare a string with that like this:

$ name_with_color = "{color=#123456}[player_name]{/color}"

Then just use "[name_with_color]" everywhere in the text.

Not 100% sure on how that will work by the way; try this if that doesn't work:

$ name_with_color = "{color=#123456}" + player_name + "{/color}"

That can be done with who_color when you define the character. It should look something like this since you're using a custom name:

define mc = Character("[player_name]", dynamic=True, who_color="#c8ffc8")

Hope that helps!

I bet there are a handful of ways to accomplish that, but you'll definitely want to use persistent data ( https://www.renpy.org/doc/html/persistent.html ). Which is saved data that transcends the specific save file. It is commonly used for unlocking gallery's or game wide secrets which show up in the main menu for example.

You could create a few bool variables initially set as False that are named something like 1stRouteCompleted with a 'persistent.' prefix. Once the player lands on the specific route's final label you would then set that variable to True via persistent data. The next time the player starts a new game, it will act exactly like it did before except for the variable 1stRouteCompleted which is now True.

How to use that variable to do what you want? A bunch of different ways here still, but what comes to the top of my mind is that you would create an if statement that checks for all routes completed at the beginning of the game to prompt the user for his choose on the true route or normal.

As a bare bones example

label start: if persistent.1stRouteCompleted and persistent.2ndRouteCompleted and persistent.3rdRouteCompleted: #only if all 3 are true do this jump choose_if_you_want_true_ending else: jump normal_next_label

label choose_if_you_want_true_ending: menu: "Would you like to play the normal routes or the True ending?" "Yes, True ending": jump true_ending_route "No, normal route": jump normal_next_label

So if they had previously completed the 3 Route's, on the 4th play through at this point they can choose to divert into the true ending story route everytime.

edit: forgot 'persistent.' du'h

Remove the ) from your characters name.

define a = Character('Ayumi', color="#YOUR-COLOR-CODE")

Also check indentation.

Renpy doc:

https://www.renpy.org/doc/html/quickstart.html#characters