















transform hand_tremor_lvl1(shift=2, tm=.1):
    zoom 1.1
    linear tm xpos shift
    linear tm xpos -shift
    repeat
transform hand_tremor_lvl2(shift=4, tm=.1):
    zoom 1.1
    linear tm xpos shift
    linear tm xpos -shift
    linear tm ypos shift
    linear tm ypos -shift
    repeat
transform hand_tremor_lvl3(shift=6, tm=.1):
    zoom 1.1
    linear tm xpos shift
    linear tm xpos -shift
    linear tm ypos shift
    linear tm ypos -shift
    repeat

scene mother_profile at hand_tremor_lvl1 (4, .1)

transform custom_punch(shift=3, tm=.1):
    zoom 1.1
    linear tm xpos shift
    linear tm xpos -shift
    repeat
init:
    define custom_vpunch = Move((0, 5), (0, -5), .10, bounce=True, repeat=True, delay=0.5)

transform myzoom(start, end, tm):
    truecenter
    zoom start
    easeout tm zoom end
    easein tm zoom start
    repeat

init -2:
    transform ib_fade:
        alpha 0.0
        easein 1.0 alpha 1.0


transform notify_transition(shift=3, tm=.1):
    alpha 0.0
    easein 1.0 alpha 1.0



init:
    $ flash = Fade(.30, 0, .75, color="#fff")


transform fade_inout_2s:
    xalign 0.5
    yalign 0.5
    alpha 0.08
    easeout_back 1 alpha 0.9
    pause 0
    ease 1 alpha 0.0
    repeat








init python:
    import datetime
    class LifeCycle(renpy.store.object):
        def __init__(self, year, month, dayOfMonth, season, weather, cataclysm):
            
            self.calendar = datetime.datetime(year, month, dayOfMonth)
            
            
            
            
            
            self.started =  datetime.datetime(year, month, dayOfMonth, hour, minute, second)
            
            self.season = season
            self.weather = weather
            self.cataclysm = cataclysm
            
            self.times = (
                'Early Morning',
                'Morning',
                'Noon',
                'Evening',
                'Night',
            )
            self.period = self.times[0] 
        
        def advance_calendar(self, days_to_advance = 1):
            self.calendar += datetime.timedelta(days = days_to_advance)
        
        def advance_time(self, periods_to_advance = 1):
            was_night = self.period == self.times[len(self.times) - 1]
            delta = periods_to_advance % len(self.times)
            periods_advanced = periods_to_advance // len(self.times)
            
            self.period += delta
            
            if (periods_advanced > 1) or was_night:
                self.advance_calendar(periods_advanced)
        
        @property
        def day_of_week(self):
            return self.weekday() 
            
            
            return self.isoweekday() 
        
        @property
        def is_weekday(self):
            return self.day_of_week not in (6, 7) 
            
            
            return self.day_of_week not in (5, 6) 
        
        @property
        def is_weekend(self):
            return self.day_of_week in (6, 7) 
            
            
            return self.day_of_week in (5, 6) 
        
        @property
        def week(self):
            return self.calendar.isocalendar()[1]
        
        @property
        def year(self):
            return self.calendar.year
        
        @property
        def month(self):
            return self.calendar.month
        
        @property
        def day_of_month(self):
            return self.calendar.day









screen Lovefall:
    add "Lovefall"
    timer 5.0 action Hide("Lovefall", transition=dissolve)
image Lovefall = Lovefall("gui/text_icons/romantic_interest.png")

screen Lustfall:
    add "Lustfall"
    timer 5.0 action Hide("Lustfall", transition=dissolve)
image Lustfall = Lovefall("gui/text_icons/lust.png")
screen Lovefall_ri1:
    add "ri1"
    timer 5.0 action Hide("Lovefall_ri1", transition=dissolve)
screen Lovefall_ri5:
    add "ri5"
    timer 5.0 action Hide("Lovefall_ri5", transition=dissolve)
screen Lovefall_ri2:
    add "ri2"
    timer 5.0 action Hide("Lovefall_ri2", transition=dissolve)
screen Lovefall_ri7:
    add "ri7"
    timer 5.0 action Hide("Lovefall_ri7", transition=dissolve)
screen Lovefall_ri10:
    add "ri10"
    timer 5.0 action Hide("Lovefall_ri10", transition=dissolve)
screen Lovefall_ri12:
    add "ri12"
    timer 5.0 action Hide("Lovefall_ri12", transition=dissolve)
image ri1 = ri("gui/text_icons/ri_1.png")
image ri5 = ri("gui/text_icons/ri_5.png")
image ri2 = ri("gui/text_icons/ri_2.png")
image ri7 = ri("gui/text_icons/ri_7.png")
image ri10 = ri("gui/text_icons/ri_10.png")
image ri12 = ri("gui/text_icons/ri_12.png")

init python:



    import random

    random.seed()


    def ri(image, max_particles=25, speed=150, wind=100, xborder=(0,100), yborder=(50,400), **kwargs):
        """
        This creates the snow effect. You should use this function instead of instancing
        the SnowFactory directly (we'll, doesn't matter actually, but it saves typing if you're
        using the default values =D)

        @parm {image} image:
            The image used as the snowflakes. This should always be a image file or an im object,
            since we'll apply im transformations in it.

        @parm {int} max_particles:
            The maximum number of particles at once in the screen.

        @parm {float} speed:
            The base vertical speed of the particles. The higher the value, the faster particles will fall.
            Values below 1 will be changed to 1

        @parm {float} wind:
            The max wind force that'll be applyed to the particles.

        @parm {Tuple ({int} min, {int} max)} xborder:
            The horizontal border range. A random value between those two will be applyed when creating particles.

        @parm {Tuple ({int} min, {int} max)} yborder:
            The vertical border range. A random value between those two will be applyed when creating particles.
            The higher the values, the fartest from the screen they will be created.
        """
        return Particles(SnowFactory(image, max_particles, speed, wind, xborder, yborder, **kwargs))
    def Lovefall(image, max_particles=150, speed=150, wind=100, xborder=(0,100), yborder=(50,400), **kwargs):
        """
        This creates the snow effect. You should use this function instead of instancing
        the SnowFactory directly (we'll, doesn't matter actually, but it saves typing if you're
        using the default values =D)

        @parm {image} image:
            The image used as the snowflakes. This should always be a image file or an im object,
            since we'll apply im transformations in it.

        @parm {int} max_particles:
            The maximum number of particles at once in the screen.

        @parm {float} speed:
            The base vertical speed of the particles. The higher the value, the faster particles will fall.
            Values below 1 will be changed to 1

        @parm {float} wind:
            The max wind force that'll be applyed to the particles.

        @parm {Tuple ({int} min, {int} max)} xborder:
            The horizontal border range. A random value between those two will be applyed when creating particles.

        @parm {Tuple ({int} min, {int} max)} yborder:
            The vertical border range. A random value between those two will be applyed when creating particles.
            The higher the values, the fartest from the screen they will be created.
        """
        return Particles(SnowFactory(image, max_particles, speed, wind, xborder, yborder, **kwargs))

    class SnowFactory(object):
        """
        The factory that creates the particles we use in the snow effect.
        """
        def __init__(self, image, max_particles, speed, wind, xborder, yborder, **kwargs):
            """
            Initialize the factory. Parameters are the same as the Snow function.
            """
            
            self.max_particles = max_particles
            
            
            self.speed = speed
            
            
            self.wind = wind
            
            
            self.xborder = xborder
            self.yborder = yborder
            
            
            
            
            self.depth = kwargs.get("depth", 10)
            
            
            self.image = self.image_init(image)
        
        
        def create(self, particles, st):
            """
            This is internally called every frame by the Particles object to create new particles.
            We'll just create new particles if the number of particles on the screen is
            lower than the max number of particles we can have.
            """
            
            if particles is None or len(particles) < self.max_particles:
                
                
                depth = random.randint(1, self.depth)
                
                
                
                
                depth_speed = 1.5-depth/(self.depth+0.0)
                
                return [ SnowParticle(self.image[depth-1],      
                                      random.uniform(-self.wind, self.wind)*depth_speed,  
                                      self.speed*depth_speed,  
                                      random.randint(self.xborder[0], self.xborder[1]), 
                                      random.randint(self.yborder[0], self.yborder[1]), 
                                      ) ]
        
        
        def image_init(self, image):
            """
            This is called internally to initialize the images.
            will create a list of images with different sizes, so we
            can predict them all and use the cached versions to make it more memory efficient.
            """
            rv = [ ]
            
            
            for depth in range(self.depth):
                
                p = 1.1 - depth/(self.depth+0.0)
                if p > 1:
                    p = 1.0
                
                rv.append( im.FactorScale( im.Alpha(image, p), p ) )
            
            return rv
        
        
        def predict(self):
            """
            This is called internally by the Particles object to predict the images the particles
            are using. It's expected to return a list of images to predict.
            """
            return self.image


    class SnowParticle(object):
        """
        Represents every particle in the screen.
        """
        def __init__(self, image, wind, speed, xborder, yborder):
            """
            Initializes the snow particle. This is called automatically when the object is created.
            """
            
            
            self.image = image
            
            
            
            
            if speed <= 0:
                speed = 1
            
            
            self.wind = wind
            
            
            self.speed = speed
            
            
            
            self.oldst = None
            
            
            self.xpos = random.uniform(0-xborder, renpy.config.screen_width+xborder)
            self.ypos = -yborder
        
        
        def update(self, st):
            """
            Called internally in every frame to update the particle.
            """
            
            
            if self.oldst is None:
                self.oldst = st
            
            lag = st - self.oldst
            self.oldst = st
            
            
            self.xpos += lag * self.wind
            self.ypos += lag * self.speed
            
            
            if self.ypos > renpy.config.screen_height or\
            (self.wind< 0 and self.xpos < 0) or (self.wind > 0 and self.xpos > renpy.config.screen_width):
                    
                    return None
            
            
            
            
            return int(self.xpos), int(self.ypos), st, self.image
# Decompiled by unrpyc: https://github.com/CensoredUsername/unrpyc
