Cookbook de Ren'Py

Bienvenido al Cookbook de Ren'Py, donde podrs encontrar algunas

recetas, contribuidas por los usuarios que te ayudarn a cumplir tareas
comunes (y no tan comunes) con Ren'Py.
Nota que muchas de ellas estn creadas para cumplir con funciones
especficas y no son realmente buenos ejemplos del cdigo Ren'py
usado para escribir juegos.

Recetas Existentes
Efectos Especiales

Corriendo a pantalla completa

Mostrando una pequea splash screen mientras Ren'Py se carga

Mostrando una pantalla Splash previa despues que Ren'Py se ha

cargado

Un efecto simple de destello (por saturacin de luz)

Usando un efecto de disolucin (Dissolve) tipo "interferencia" con
imgenes
Implementando un efecto de visin doble

Interfaz de usuario

Agregando botones en pantalla

Cmo implementar un sistema de retroceso de lectura

Cargado y Guardado Rpido

Reposicionando elementos en el men principal o en el men del

juego
Ajustando el sistema para lectura automtica

Ajustando la velocidad por defecto del texto

Regionalizaciones

Traduciendo botones, mens de Ren'Py, etc.

Efectos Especiales

Ajuste a pantalla completa

Para hacer que el juego se ejecute a pantalla completa desde la primera
vez que lo ejecutes, debes agregar las siguientes lneas de cdigo:
init:
if not persistent.set_fullscreen:
$ _preferences.fullscreen = True
$ persistent.set_fullscreen = True

Esto ajusta el valor por defecto hacia pantalla completa cuando se

ejecute el juego desde el principio. Despus de esto, queda la opcin de
que el usuario elija si lo cambia a modo ventana.
Consejo: Para simular la primera ejecucin, mueve o borra el directorio
game/save/.
El ajuste a pantalla completa puede interferir con la pantalla Splash, as
que si tienes ambos pon una pausa de 1 segundo al principio del cdigo
para evitar conflictos.

Imagen Splash de Precarga

Para crear una imagen de precarga (una imagen que aparece mientras
Ren'Py lee los scripts e inicializa el juego), crea una imagen
llamada presplash.png, y pon la imagen en el directorio del juego.
Nota: Ren'Py tarda ms tiempo para cargar la primera vez que se ejecute
el script, luego tarda menos. Carga el juego dos veces consecutivas para
que te fijes cunto tarda la segunda vez.

Efecto de pantalla Splash

Un ejemplo de una pantalla splash se encuentra al final del archivo
"script.rpy" en el directorio demo/game de Ren'py :
# Se llama a la pantalla Splash, si existe, antes de que el
# men inicial se muestre. No se recarga si el juego es reiniciado.
# Fin de los comentarios.
#
# label splashscreen:
#
$ renpy.pause(0)
#
scene black
#
show text "American Bishoujo Presenta..." with dissolve
#
$ renpy.pause(1.0)
#
hide text with dissolve
#
#
return

Para agregar un mensaje de texto como pantalla Splash, inserte el

cdigo siguiente en cualquier parte de tu script (siempre y cuando no sea
dentro de un bloque):
label splashscreen:
$ renpy.pause(0)
scene black
show text "American Bishoujo Presenta..."
with dissolve
with Pause(1.0)
hide text
with dissolve
return

Y ste es otro ejemplo de una pantalla Splash, esta vez usando una
imagen:

init:
image splash = "splash.png"
label splashscreen:
$ renpy.pause(0)
scene black
with Pause(0.5)
show splash
with dissolve
with Pause(2.0)
scene black
with dissolve
with Pause(1.0)
return

Debes declarar la imagen en el bloque de inicio, el cual debe estar en

cualquier parte de tu archivo script, (ya sea antes o despus del codigo
de pantalla splash). Tambin debes declarar otra interaccin antes de la
escena de transicin, que puede ser $ renpy.pause(0) y debe existir
como primera instancia en la etiqueta llamada "splashscreen" (Revisa el
ejemplo).

Efecto simple de Destello

sta es la versin del efecto que se uso en "Ori, Ochi, Onoe". Est
diseada para trabajar con Ren'Py 5.6.1 y posteriores.
El efecto puede ser usado como transicin para recuerdos, efectos de
saturacin de luz y mucho ms.
init:
image bg road = "road.jpg"
$ flash = Fade(.25, 0, .75, color="#fff")
label start:
scene black # Or whatever image you're transitioning from.
"Vamos a cambiar el fondo en un destello."
scene bg road
with flash
"Wow!"

Efecto simple de Interferencia

Vi este efecto por primera vez en un juego llamado Moe: Moegi Iro No
Machi, como transicin entre imgenes de los personajes. Me pareci
muy bueno, as que intente emularlo en Ren'Py. No me tom mucho
tiempo, es realmente simple. El cdigo ha sido probado y se ha
confirmado que trabaja en versiones de Ren'Py de la 5.6.1 a la 5.6.4,
pero debera funcionar en cualquier version de la 5.0 en adelante.
He proporcionado una imagen para usar este efecto:
Esa imagen debe ser colocada en la carpeta game o data, la que uses
para los datos del juego.
Este cdigo est en el script demo incluido con Ren'Py. Puede ser
modificado fcilmente para ajustarse a tu juego.
init:
$ noisedissolve = ImageDissolve(im.Tile("noisetile.png"), 1.0, 1)
label start:
scene bg washington with fade
show eileen vhappy with noisedissolve
"Eileen" "Just popping in!"
hide eileen with noisedissolve

Eso es todo. Es muy fcil de implementar y se ve muy bien. Este efecto

no est limitado a imgenes de personajes; t puedes usarlo para
mostrar u ocultar cualquier imagen o escena.

Efecto de visin doble

El siguiente cdigo produce un efecto borroso de "Visin Doble" (como
de borracho). Este efecto se ha usado en los juegos "Gakuen Redux" y
"Secretary of Death".
La idea bsica es que crees una imagen medio opaca del fondo, y luego
mostrarla en ubicacin aleatoria despus de mostrar el fondo. Esto
significa que, a diferencia de otros muchos efectos, llamar este efecto
requiere dos declaraciones, no una sola.
init:
image cs2 = Image("b_city_scape_02.gif")
image cs2alpha = im.Alpha("b_city_scape_02.gif", 0.5)
python hide:
def gen_randmotion(count, dist, delay):
import random
args = [ ]
for i in range(0, count):
args.append(anim.State(i, None,
Position(xpos=random.randrange(dist, dist),
ypos=random.randrange(dist, dist),
xanchor='left',
yanchor='top',
)))
for i in range(0, count):
for j in range(0, count):
if i == j:
continue
args.append(anim.Edge(i, delay, j,
MoveTransition(delay)))

return anim.SMAnimation(0, *args)

store.randmotion = gen_randmotion(5, 5, 1.0)
label start:
scene cs2
show cs2alpha at randmotion
"Presented in DOUBLE-VISION (where drunk)."

En este cdigo, las declaraciones que reproducen el efecto en la historia

son:
scene cs2
show cs2alpha at randmotion

Como te puedes dar cuenta, para cada imagen que quieras mostrar en
visin doble, tienes que crear las dos imgenes tambin. Para el cdigo
superior, stas son las lineas que crean las imgenes (Ntese que como
todas las declaraciones de imgenes, deben ser colocadas en el bloque
init):
image cs2 = Image("b_city_scape_02.gif")
image cs2alpha = im.Alpha("b_city_scape_02.gif", 0.5)

Interfaz de usuario

Botones de Mens
#Este archivo agrega un nmero de botones a la esquina inferior derecha
de
#la pantalla. Tres de estos botones saltan al men del juego, dando
#acceso a Cargar, Salvar y Preferencias. El cuarto botn cambia la
#opcin para saltar el texto, para hacerlo ms conveniente.
init:
# Dejar algo de espacio en la equina derecha de la pantalla.
$ style.window.right_margin = 100
python:
def toggle_skipping():
config.skipping = not config.skipping
def button_game_menu():
# para ahorrar el tecleo
ccinc = renpy.curried_call_in_new_context
ui.vbox(xpos=0.98, ypos=0.98, xanchor='right',
yanchor='bottom')
ui.textbutton("Skip", clicked=toggle_skipping)
ui.textbutton("Save", clicked=ccinc("_game_menu_save"))
ui.textbutton("Load", clicked=ccinc("_game_menu_load"))
ui.textbutton("Prefs",
clicked=ccinc("_game_menu_preferences"))
ui.close()

config.overlay_functions.append(button_game_menu)

Traducidos los botones quedaran as:

ui.vbox(xpos=0.98, ypos=0.98, xanchor='right',

yanchor='bottom')
ui.textbutton("Saltar", clicked=toggle_skipping)
ui.textbutton("Guardar", clicked=ccinc("_game_menu_save"))
ui.textbutton("Cargar", clicked=ccinc("_game_menu_load"))
ui.textbutton("Prefs",
clicked=ccinc("_game_menu_preferences"))
ui.close()

Leer atrs
#
#
#
#

ste es el molesto comando de releer. Lo he implementado

porque la gente lo solicit, no porque me guste.
Preferira que uses rollback, que es mucho mejor en todos
los sentidos.

#
#
#
#
#

Para usar relectura, inserta este archivo en tu directorio del

juego. Releer te regresa a puntos donde rollback no funciona,
as que tambin tendrs que reducir el lmite de la variable
config.hard_rollback_limit o cambiar config.rollback_enabled a
valor = false

init -100:
$ config.rollback_enabled = False
#
#
#
#
#
#
#
#
#

Releer funciona al reemplazar el personaje default y los objetos

del men con unos que graben lo que se dijo en buffer de relectura
El usuario entonces puede volver, y todo lo que se haya dicho se
va a mostrar de nuevo. Imgenes y opciones no cambiarn, si eso es
lo que necesitas entonces usa rollback!
El nmero de lneas de relectura puede cambiarse asignando un
nmero entero a la variable readback_limit
Dejndola en None dejar el juego completo en el buffer. Como esto
puede resultar ms eficiente, posiblemente lo debas dejar en None

# Releer usa dos estilos, readback_dialogue y readback_thought.

# Cmbialos para que aparezca en distinto color y estilo el texto
# cuando hagas una relectura
# Si quieres agregar tu propio mensaje, como narracin, al releer,
# puedes hacerlo llamando la funcion readback o por medio del
# personaje readback que lo diga:
#
#
#
#
#
#

$ readback('Mensaje para relecturas solamente.')

readback "Mensaje similar."
Nota: Cuando usas Readback, no puedes usar cadenas para un nombre
de personaje. Todo el dialogo debe ser relativo a objetos de
personaje para que se muestren en el buffer de readback. Esta
limitacion ser corregida en versiones futuras de Ren'Py.

init -100:

python:
# El lmite del nmero de readbacks a mantener. None quiere
# decir que no hay lmite.
readback_limit = None
# Set this to true to print out the contents of the readback
# buffer when it is saved.
readback_debug = False
# Estilos de Readback.
style.create('readback_dialogue', 'say_dialogue', '')
style.create('readback_thought', 'say_thought', '')
style.readback_dialogue.color = (255, 128, 128, 255)
style.readback_thought.color = (255, 128, 128, 255)

# No user-servicable parts below this line.

######################
# The readback buffer is a doubly-linked list of readback
# objects.
class Readback(object):
def __init__(self, obj, args):
self.older = None
self.newer = None
self.obj = obj
self.args = args
def show(self):
self.obj.readback(*self.args)

readback_oldest = None
readback_newest = None
readback_count = 0

# This saves a readback entry to the readback buffer.

def readback_save(obj, *args):
store.readback_count += 1
if readback_limit and readback_count > readback_limit:
store.readback_count -= 1
readback_oldest.newer.older = None

store.readback_oldest = readback_oldest.newer
rb = Readback(obj, args)

if readback_newest:
readback_newest.newer = rb
else:
store.readback_oldest = rb
rb.older = readback_newest
store.readback_newest = rb

if readback_debug:
print "---- Readback Buffer ----"
rb = readback_oldest
while rb:
print rb.obj, rb.args
rb = rb.newer

# The rest of this file is replacing the default objects and

# functions with versions that save things in the readback
# buffer.
# Save the old character object.
readback_OldCharacter = Character
readback_oldmenu = menu
class Character(readback_OldCharacter):
def __init__(self, who,
readback_style='readback_dialogue',
**kwargs):
readback_OldCharacter.__init__(self, who, **kwargs)
self.readback_style = readback_style
def __call__(self, what, **kwargs):
if not self.check_condition():
return

readback_OldCharacter.__call__(self, what, **kwargs)

def store_readback(self, who, what):
readback_save(self, who, what)
def readback(self, who, what):
self.function(who, what,
who_style=self.who_style,
what_style=self.readback_style,
window_style=self.window_style,
interact=False,
all_at_once=True,
**self.properties)
class Sayer(object):
def __call__(self, who, what):
renpy.display_say(who, what)
readback_save(self, who, what)
def readback(self, who, what):
renpy.display_say(who, what,
what_style='readback_dialogue',
all_at_once=True,
interact=False)

narrator = Character(None, what_style='say_thought')

say = Sayer()
def readback(what):
narrator.store_readback(None, what)
def menu(menuitems):
rv = readback_oldmenu(menuitems)
text = '\n'.join([ l for l, v in menuitems
if v is None or v == rv ])
readback(text)
return rv
# This stuff is involved in entering the readback mode.
def readback_mode():
# Try rollback, first.
renpy.rollback()

# If we made it here, we're into readback mode. So let's

# go there now.
renpy.call_in_new_context("readback")
# Add in the readback function.
config.underlay.append(renpy.Keymap(rollback=readback_mode))

# This label is called in a new context, when the user succesfully

# enters Readback mode.
label readback:
# If we have an empty readback buffer, go home.
if not readback_newest:
return
python hide:
rb = readback_newest
while True:
rb.show()
ui.add(renpy.Keymap(rollback=lambda : "older",
rollforward=lambda : "newer",
dismiss=lambda : "dismiss",
))
res = ui.interact()
if res == "newer":
rb = rb.newer
if not rb:
break
elif res == "older":
if rb.older:
rb = rb.older
elif res == "dismiss":
break
return

Cargado y Guardado rpido

#
#
#
#
#
#

Esta opcin implementa el guardado y cargado rpido.

La funcin de cargado rpido agrega un botn al fondo que se
muestra durante el juego. Cuando el boton se presiona, el juego
se guarda en un bloque de guardado rpido. Tambien coloca un
boton de carga rpida, al hacer click en el el juego guardado en
el bloque de guardado rpido es cargado.

# Este proceso es ejecutado cuando se presiona el botn.

label _quick_save:
call _enter_menu_without_scene from __call__enter_menu_4
# Guarda el juego.
$ renpy.save('quicksave', _('Guardado rapido'))
# Mostrar al usuario de que se ha guardado el juego.
$ ui.add(Solid((0, 0, 0, 128)))
$ ui.text(_('Juego guardado en formato rapido.'),
xpos=0.5, xanchor='center', ypos=0.5, yanchor='center')
$ ui.saybehavior()
$ ui.interact(suppress_overlay=True, suppress_underlay=True)
return
# Proceso llamado cuando el botn de cargado rpido es presionado,
# para cargar el juego.
label _quick_load:
$ renpy.load('quicksave')
return
init -1:
python hide:
# Add the quick save button in as an overlay function.
def quick_save_button():
ui.textbutton(_("Salvado rapido"),
xpos=0.98, ypos=0.02,
xanchor='right', yanchor='top',
clicked=renpy.curried_call_in_new_context('_quick_save'))

config.overlay_functions.append(quick_save_button)
# Add the quick load function to the main menu.
library.main_menu.insert(1, ('Cargado rapido',
ui.jumps("_quick_load"),
'renpy.can_load("quicksave")'))

Posiciones Men
#
#
#
#
#

Este archivo ofrece un ejemplo de cmo las entradas en el men

principal y el men de juego pueden ser reposicionadas en la
pantalla. A diferencia de otros extras, no intentamos que esto
se haga tal cual, pero puede ser copiado y cambiado a las
posiciones de los botones en la pantalla.

# Los botones no deben encimarse y ciertas configuraciones pueden

# hacer los botones inaccesibles a la navegacin por teclado.
# No traduzcas los comandos. son comandos, no etiquetas de botn.
init:
python hide:
library.main_menu_positions = {
'Start Game' : dict(xpos=400, ypos=400, xanchor='left',
yanchor='top'),
'Continue Game' : dict(xpos=450, ypos=430, xanchor='left',
yanchor='top'),
'Preferences' : dict(xpos=500, ypos=460, xanchor='left',
yanchor='top'),
'Quit Game' : dict(xpos=550, ypos=490, xanchor='left',
yanchor='top'),
}
library.game_menu_positions = {
'Return' : dict(xpos=400, ypos=400, xanchor='left',
yanchor='top'),
'Preferences' : dict(xpos=450, ypos=430, xanchor='left',
yanchor='top'),
'Save Game' : dict(xpos=500, ypos=460, xanchor='left',
yanchor='top'),
'Load Game' : dict(xpos=550, ypos=490, xanchor='left',
yanchor='top'),
'Main Menu' : dict(xpos=600, ypos=520, xanchor='left',
yanchor='top'),
'Quit' : dict(xpos=650, ypos=550, xanchor='left',
yanchor='top'),
}

Configuracin de Auto-lectura
Para activar y usar el retraso del modo de auto-lectura la primera vez que
ejecutas el juego (en vez de abrir el men de preferencias), slo tienes
que agregar al script:
init:
if not persistent.set_afm_time:
$ persistent.set_afm_time = True
$ _preferences.afm_time = 10

Esto cambiar la configuracion a 10 la primera vez que el jugador ejecute

el juego. Puede entonces ser guardada la activacin en
game/saves/persistent, para que cuando el usuario cambia la
configuracion, no se restaure.
El valor mximo es 41 para el Men de Preferencias por defecto en la
interfaz de usuario, pero puede ser mayor en el script de tu juego. El
valor mnimo es 1 y con l, todas las lneas de texto se mostrarn sin
interrupcin

Configuracin de velocidad de
Texto
Para ajustar la velocidad por defecto del texto debes colocar este cdigo
en tu script:
python:
if not persistent.set_text_cps:
persistent.set_text_cps = True
_preferences.text_cps = 100

100 es el nmero que define la velocidad del texto, tambin es la

velocidad mxima, lo que significa que una lnea completa de texto se
mostrar de manera instantnea.

Regionalizaciones

Traducciones
(Para ms informacin acerca de Localizar Ren'Py, echa un vistazo
en Localizar Ren'Py en el manual de referencia.)
# Este archivo contiene las traducciones al espaol del cdigo de Ren'Py
# Si quieres cambiar algo, simplemente edita la parte en espaol.
init:
# Traduccin de common/mainmenu.rpy
$
$
$
$

library.translations[u'Start Game'] = u'Nueva Partida'

library.translations[u'Continue Game'] = u'Continuar Partida'
library.translations[u'Preferences'] = u'Preferencias'
library.translations[u'Quit'] = u'Salir'

# Traduccin de common/gamemenu.rpy
$
$
$
$
$
$
$
$
$

library.translations[u'Return'] = u'Volver'
library.translations[u'Begin Skipping'] = u'Empezar Salto'
library.translations[u'Save Game'] = u'Guardar Partida'
library.translations[u'Load Game'] = u'Cargar Partida'
library.translations[u'Main Menu'] = u'Men Principal'
library.translations[u'Empty Slot.'] = u'Bloque Vaco.'
library.translations[u'Yes'] = u'S'
library.translations[u'No'] = u'No'
library.translations[u'Please click to continue.'] = u'Haz click
para continuar.'
$ library.translations[u'Are you sure you want to quit?'] = u'Seguro
que quieres salir?'
$ library.translations[u'Are you sure you want to return to the main
menu?\nThis will lose unsaved progress.'] = u'Seguro que quieres volver
al men principal?\nLos datos sin guardar se perdern.'
$ library.translations[u'Loading will lose unsaved progress.\nAre you
sure you want to do this?'] = u'Los datos sin guardar se perdern al
cargar una partida.\nSeguro que quieres continuar?'
$ library.translations[u'Are you sure you want to overwrite your
save?'] = u'Seguro que quieres sobreescribir el archivo?'
$ library.translations[u'The error message was:'] = u'El mensaje de
error es:'
$ library.translations[u'You may want to try saving in a different
slot, or playing for a while and trying again later.'] = u'Puede que
quieras intentar guardar en otro bloque, o intentarlo ms tarde.'

$ library.translations[u'Save Failed.'] = u'Guardar fallido.'

$ library.translations[u'Previous'] = u'Anterior'
$ library.translations[u'Next'] = u'Siguiente'
# Traduccin de common/voice.rpy
$ library.translations[u'Voice Volume'] = u'Volumen de Voz'
# Traduccin de common/library.rpy
$ library.translations[u'Skip Mode'] = u'Modo Salto'
$ library.translations[u'Fast Skip Mode'] = u'Modo Salto Rpido'
$ library.translations[u"While Ren'Py games may be playable without
the renpy module, some features may be disabled. For more information,
read the module/README.txt file or go to http://www.bishoujo.us/renpy/."]
= u"Mientras los juegos de Ren'Py pueden ser jugado sin el mdulo renpy,
algunas funciones estarn desactivadas. Para ms informacin, lea el
archivo module/README.txt o ve a http://www.bishoujo.us/renpy/."
$ library.translations[u'renpy module not found.'] = u'No se ha
encontrado el mdulo renpy.'
$ library.translations[u'The renpy module could not be loaded on your
system.'] = u'El mdulo renpy no pudo ser cargado en su equipo.'
$ library.translations[u'Old renpy module found.'] = u'Encontrado
mdulo renpy antiguo.'
$ library.translations[u"An old version (%d) of the Ren'Py module was
found on your system, while this game requires version %d."] = u"Una
versin antigua (%d) del Mdulo de Ren'Py se encuentra en su equipo,
mientras que el juego requiere la versin %d."
# Traduccin de common/preferences.rpy
$
$
$
$
$
$
$
$
$
$
$
$
$
$
$

library.translations[u'Test'] = u'Prueba'
library.translations[u'Joystick Mapping'] = u'Mapeo de Joystick'
library.translations[u'Not Assigned'] = u'Sin Asignar'
library.translations[u'Music Volume'] = u'Volumen de Msica'
library.translations[u'Sound Volume'] = u'Volumen de Sonido'
library.translations[u'Left'] = u'Izquierda'
library.translations[u'Right'] = u'Derecha'
library.translations[u'Up'] = u'Arriba'
library.translations[u'Down'] = u'Abajo'
library.translations[u'Select/Dismiss'] = u'Seleccionar/Descartar'
library.translations[u'Rollback'] = u'Retroceso'
library.translations[u'Hold to Skip'] = u'Presione para Saltar'
library.translations[u'Toggle Skip'] = u'Toggle Skip'
library.translations[u'Hide Text'] = u'Ocultar Texto'
library.translations[u'Menu'] = u'Men'

$ library.translations[u'Move the joystick or press a joystick button

to create the mapping. Click the mouse to remove the mapping.'] = u'Move
the joystick or press a joystick button to create the mapping. Click the
mouse to remove the mapping.'
$ library.translations[u'Display'] = u'Muestra'
$ library.translations[u'Window'] = u'Ventana'
$ library.translations[u'Fullscreen'] = u'Pantalla Completa'
$ library.translations[u'Transitions'] = u'Transiciones'
$ library.translations[u'All'] = u'Todo'
$ library.translations[u'Some'] = u'Algn'
$ library.translations[u'None'] = u'Ninguno'
$ library.translations[u'Skip'] = u'Saltar'
$ library.translations[u'Seen Messages'] = u'Mensajes Vistos'
$ library.translations[u'All Messages'] = u'Todos los Mensajes'
$ library.translations[u'After Choices'] = u'Despus de Elegir'
$ library.translations[u'Stop Skipping'] = u'Parar Salto'
$ library.translations[u'Keep Skipping'] = u'Continuar Salto'
$ library.translations[u'Text Speed'] = u'Velocidad de Texto'
$ library.translations[u'Auto-Forward Time'] = u'Auto-Forward Time'
$ library.translations[u'Joystick...'] = u'Joystick...'
$ library.translations[u'Joystick Configuration'] = u'Configuracin
de Joystick'