Ren'ai Games

DSE Tutorial

by ShiraiJunichi

The Files
main.rpy
events.rpy
A More Subtle Use of the Day Planner
Using Arcs to Structure Your Game: Basic Theory

The Files

The executable file to start a dse game is named "run_dse.exe". It loads the game stored in the "dse" folder. Here's a quick rundown of the files within the "dse" folder:

main.rpy	This file is the one most like the "script.rpy" file of a normal ren'py game. You can think of it sort of like the skeleton of your game, as it contains very little of the actual game, but provides basic flow control for events to run.
events.rpy	This file contains all the events that will run during the game. It will contain the majority of your code.
event_dispatcher.rpy	Implements the code needed to actually run events.
day_planner.rpy	Provides structure for the days in the game and creates a GUI for selecting what events to do during a given day.
old_day_planner.rpy	An alternate version of the day planner
stats.rpy	Defines the Stat class- useful for storing numerical variables in your game.

Of these five files, only two of them need to be edited- main.rpy, and events.rpy.

main.rpy

There are six parts of the main.rpy file:

The init block
The start block
The day block
A block for each period of the day
The night block
The dp_callback block

The init Block

- Day structure

        # A list of the periods of the day that are present in the
        # day planner. This can be changed at runtime.
        dp_period_names = [ "Morning", "Afternoon", "Evening" ]

        # A list of variables that will take the selected choices
        # for each of the periods named above.
        dp_period_vars = [ "morning_act",
                           "afternoon_act",
                           "evening_act", ]

        # A map from the period names to a list of the activities
        # available for that period. This may be conputed before
        # each call to day_planner. Each entry is a tuple, where
        # the first element is the name shown to the user, and the
        # second is the name assigned to the variable for that
        # period.
        dp_period_acts = {        
            'Morning': [
            ( 'Attend Class', "class" ),
            ( 'Cut Class', "cut"),
            ],
            
            'Afternoon': [
            ( 'Study', "study" ),
            ( 'Hang Out', "hang" ),
            ],
            
            'Evening' : [
            ( 'Exercise', "exercise" ),
            ( 'Play Games', "play" ),
            ],
            }

morning_act

The start Block

    # Required to initialize the event engine.
    call events_init from _call_events_init_1

    # Initialize the default values of some of the variables used in
    # the game.
    $ day = 0

    # Initialize the statistics used by the game. 
    $ strength = Stat('Strength', 10, 100)
    $ intelligence = Stat('Intelligence', 10, 100)

    # Pick the stats to show to the user.
    $ shown_stats = [ strength, intelligence ]

- Stat Objects

The day Block

    # Increment the day it is.
    $ day += 1

    # We may also want to compute the name for the day here, but
    # right now we don't bother.

    "It's day %(day)d."

    # Here, we want to set up some of the default values for the
    # day planner. In a more complicated game, we would probably
    # want to add and remove choices from the dp_ variables
    # (especially dp_period_acts) to reflect the choices the
    # user has available to him.

    $ morning_act = None
    $ afternoon_act = None
    $ evening_act = None

    # Now, we call the day planner, which may set the act variables
    # to new values. 
    call day_planner from _call_day_planner_1

IMPORTANT! If you plan on changing any of the dp variables at runtime, you'll need to move the dp variable declarations outside of the init block and place them somewhere else!

Blocks for Each Period of the Day

        label afternoon:

    # It's possible that we will be skipping the afternoon, if one
    # of the events in the morning jumped to skip_next_period. If
    # so, we should skip the afternoon.
    if check_skip_period():
        jump evening

    # The rest of this is the same as for the morning.

    centered "Afternoon"

    # set variables so they are current
    $ period = "afternoon"
    $ act = afternoon_act

    # start running events for this period
    call events_run_period from _call_events_run_period_2

The night Block

    # This is now the end of the day, and not a period in which
    # events can be run. We put some boilerplate end-of-day text
    # in here.

    centered "Night"

    "It's getting late, so I decide to go to sleep."

    # We call events_end_day to let it know that the day is done.
    call events_end_day from _call_events_end_day_1

    # And we jump back to day to start the next day. This goes
    # on forever, until an event ends the game.
    jump day

The night Block

    $ narrator("What should I do today?", interact=False)

    call stats_show from call_stats_show_1

events.rpy

Creating Event Objects

$ event('name_of_event', 'boolean_expression',
        event.depends("event1"), event.depends("event2"),
        event.solo(), event.once(), priority=50)

Writing Blocks for Events

Make sure the label is named after the event it is for.
At the end of the block, either return, or restart ren'py. Otherwise, Ren'py will execute the blocks for other events that are written below the event that just ran.
Consider using the skip_periods variable. By using the skip_periods variable, you can make certain events last more than one period. Note, however, that no event can last overnight or take part of the next day.

A More Subtle Use of the Day Planner

Ignore the dp_period_vars variable
Ignore the dp_period_acts variable
Don't even create variables that would correspond with the strings in the dp_period_vars variable - you won't need them.
Omit the code that calls the day planner

    call day_planner from _call_day_planner_1

Omit the dp_callback block within the main.rpy file

Using Arcs to Structure Your Game: Basic Theory

Arc Behavior: Events and Outcomes

Start
Progress
Pause (progress is not currently possible, but may be made possible later in the game)
End prematurely (progress is no longer possible, but the arc didn't finish to completion)
Spawn another arc (one arc becomes two)
Fork (arc can progress only one of two (or more) ways)
End