h]c@sqddlmZeZddlZddlZddlZddlm Z m Z m Z dZ ddl Z ddlmZmZddlmZmZmZddlmZmZddlmZdd lmZmZmZmZdd lmZmZm Z dd lm!Z!m"Z"dd l#m$Z$dd l%m&Z&m'Z'm(Z(m)Z)m*Z*ddl%m+Z+m,Z,m-Z-m.Z/ddl%m0Z0ddl1m2Z2ddl3m4Z5ddl6m7Z7m7Z8m9Z9ddl6m:Z:m;Z;m<Z<m=Z=ddl6m>Z>ddl?m@Z@mAZAddlBmCZCmDZDddlEmFZFmGZGmHZHddlImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQddlImRZRmSZSmTZTmUZUmVZVmWZWddlXmYZZddlXm[Z\ddl]m^Z^ddl_m`Z`maZambZbddlcmdZdmeZeddlfmgZgmhZhdd limjZkdd!llmmZmdd"lnmoZompZpmqZqddlrjsjtZtddlujsjvZvdd#lwmxZydd$lmzZzdd%l{m|Z|m}Z}m~Z~dd&lmZmZmZmZdd'lmZdd(lmZmZdd)lmZdd*lmZdd+lmZmZe d,e d-e d.e d/e d0e d1e d2e d3e d4e d5ddlZddlZddlZddlZd6Z[d7Zdd8Zd9Zd:Zd;Zddd<Zed=Zd>Zd?Zd@ZejjjZdAZdBZdCZedDZdddEZdFdGZdFedHZdFdIZdddJZdddgdKZgddddgdeedL ZddMZdFdNZdOddPddddQZdadadRZddddSZdTZdUZdVefdWYZdXeddYdZd[d\d]idd^d_ed` ZdaefdbYZeZdcZddZdeZdedfdfddgZdddeddhZddiedjZededkZeedldZ?deddZ@dZAdZBdZCe dZDe dZEddlFmGZGddZHdZIdZJedZKdZLdidZMdZNdZOdZPdZQdZRdedZSddZTdZUdZVdZWdZXedZYdZZdZ[dZ\dZ]ddedZ^dZ_dZ`ddZadZbdZcddZddZedZfdZgdZheaidZjdZkdZldS(i(tprint_functionN(tconsttpuret not_constcCs3|}t|ts!|j}ntd||S(s. Marks renpy.`fn` as a pure function. srenpy.(t isinstancet basestringt__name__R(tfntname((srenpy/exports.pyt renpy_pure(s  (tParameterizedTexttfilter_text_tags(tregister_sfonttregister_mudgefonttregister_bmfont(tlanguage_tailortBASELINE(tKeymap(trunRt run_unhoveredt run_periodic(t map_eventt queue_eventtclear_keymap_cache(t is_selectedt is_sensitive(tMinigame(t define_screent show_screent hide_screent use_screentcurrent_screen(t has_screent get_screent get_widgett ScreenProfile(tget_widget_properties(tfocus_coordinates(tscreen(t image_existsR't list_images(tget_available_image_tagstget_available_image_attributestcheck_image_attributestget_ordered_image_attributes(tget_registered_image(t load_surfacet load_image(tcurrytpartial(tmovie_start_fullscreentmovie_start_displayablet movie_stop(tloadtsavetlist_saved_gamestcan_loadt rename_savet copy_savet unlink_savetscan_saved_game(t list_slotst newest_slott slot_mtimet slot_jsontslot_screenshottforce_autosave(tpy_eval(trng(t atl_warper(tpredictt displayabletsplit_properties(tunelide_filenametget_parse_errors(tchange_languagetknown_languages(tgeneric_filter(tregister_persistent(tshow_display_saytpredict_show_display_sayt display_say(tregister(tcheck_text_tags(tprofile_memoryt diff_memorytprofile_rollback(tTAGtTEXTt PARAGRAPHt DISPLAYABLE(tnot_infinite_loop(t CustomParsertregister_sl_displayable(teval_who(tadd_python_directory(t try_compilettry_evalR RR R'R0R1RIRLRSR cCsttftttfttttt t ft t t fttttfttttttttfttttttft t!t"t#t$t%ft&t't(t)t*t+t,t-ft.t/t0t1t2ft3t4t5ft6t7ft8t9ft:t;ft<t=t>t?t@t tAtBftCtDtEftFtGtHftItJtKtLftMtNtOftPtQtRftStTtUtVtWtXtYftZt[t\ft]t^t_fdS(sf :undocumented: This does nothing, except to make warnings about unused imports go away. N(`R R R R RRRt run_actionRRRRR0R1tplayR2R3R4R5R6R7R8R9R:R;R<R=R>R?R@RARBtevaltrandomRERORPRQtsoundtmusicttimeRRRRR RR!R"tprofile_screenR$R%RFtpredict_screenRGRHRIRJRKRLttransform_textRRNtregister_statementRSRRRRRR't has_imageR(R)R*R+R,R-R/R.RTRURVtTEXT_TAGt TEXT_TEXTtTEXT_PARAGRAPHtTEXT_DISPLAYABLER[tregister_sl_statementR]R^RRR_R`Ra(((srenpy/exports.pyt public_apis\                cCs&tjjjsdStjjjS(s :doc: rollback When in rollback, returns the data that was supplied to :func:`renpy.checkpoint` the last time this statement executed. Outside of rollback, returns None. N(trenpytgametcontexttrollbacktNonetlogt forward_info(((srenpy/exports.pytroll_forward_infoscCsV|dkrt}n|dkr(dSttjj_ttj_ttjj_ |S(s| :undocumented: To cause a roll_forward to occur, return the value of this function from an event handler. N( RxR{tTrueRtRut interfacetsuppress_transitiontafter_rollbackRytrolled_forward(tvalue((srenpy/exports.pytroll_forward_cores    cCstjjjptjjS(sL :doc: rollback Returns true if the game has been rolled back. (RtRuRyt in_rollbackR(((srenpy/exports.pyRscCs tjjstStjjjS(s> :doc: rollback Returns true if we can rollback. (Rttconfigtrollback_enabledtFalseRuRyt can_rollback(((srenpy/exports.pyRs cCstjjjS(s :doc: blockrollback Returns true if rollback is currently occurring and the current context is before an executed renpy.fix_rollback() statement. (RtRuRytin_fixed_rollback(((srenpy/exports.pyRscCsn|dkrtjj}ntjjj|d|dtjjtjjrjtjj rjt tjj _ ndS(s :doc: rollback :args: (data=None) Makes the current statement a checkpoint that the user can rollback to. Once this function has been called, there should be no more interaction with the user in the current statement. This will also clear the current screenshot used by saved games. `data` This data is returned by :func:`renpy.roll_forward_info` when the game is being rolled back. t keep_rollbackthardN( RxRtRtkeep_rollback_dataRuRyt checkpointtstoret _rollbacktauto_clear_screenshotR|R}tclear_screenshot(tdataR((srenpy/exports.pyRs  %cCstjjjd|dS(sy :doc: blockrollback :args: () Prevents the game from rolling back to before the current statement. tpurgeN(RtRuRytblock(R((srenpy/exports.pytblock_rollbacks cCstjjj|dS(s :doc: rollback :args: (flag) Rollback will skip sections of the game where rollback has been suspended. `flag`: When `flag` is true, rollback is suspended. When false, rollback is resumed. N(RtRuRytsuspend_checkpointing(tflag((srenpy/exports.pytsuspend_rollback*s cCstjjjdS(ss :doc: blockrollback Prevents the user from changing decisions made before the current statement. N(RtRuRyt fix_rollback(((srenpy/exports.pyR:scCstjjjdS(s :doc: retain_after_load Causes data modified between the current statement and the statement containing the next checkpoint to be retained when a load occurs. N(RtRuRytretain_after_load(((srenpy/exports.pyRDscCst}t|j|S(sB Returns how many displayables are in the supplied layer. (t scene_liststlentlayers(tlayertsls((srenpy/exports.pytcount_displayables_in_layerRs cCs|dkrtdntjjjs<tdnt|ts`t|j}ntj j |}tj j j ||dS(sx :doc: se_images Defines an image. This function is the Python equivalent of the image statement. `name` The name of the image to display, a string. `d` The displayable to associate with that image name. This function may only be run from inside an init block. It is an error to run this function once the game has started. s&Images may not be declared to be None.s/Images may only be declared inside init blocks.N(Rxt ExceptionRtRuRvt init_phaseRttupletsplitteasyRGtdisplaytimagetregister_image(Rtd((srenpy/exports.pyR\s cCst|ts$t|j}nt|tsHt|j}nt|}xltjjjjD]U\}}t||krqjn|| |krjtjjj ||||qjqjWdS(s  :doc: image_func Copies images beginning with one prefix to images beginning with another. For example:: renpy.copy_images("eileen", "eileen2") will create an image beginning with "eileen2" for every image beginning with "eileen". If "eileen happy" exists, "eileen2 happy" will be created. `old` A space-separated string giving the components of the old image name. `new` A space-separated string giving the components of the new image name. N( RRRRRtRRtimagestitemsR(toldtnewtlenoldtktv((srenpy/exports.pyt copy_imageszs "cCsq|dk r|S|rdSt|tr6|d}nd|krU|jd}ntjjj|tjjS(s :undocumented: If layer is not None, returns it. Otherwise, interprets `tag` as a name or tag, then looks up what the default layer for that tag is, and returns the result. tmasterit N( RxRRRRtRt tag_layertgettdefault_tag_layer(Rttagt expression((srenpy/exports.pyt default_layers   cCs~t|ts$t|j}n|dkr=|d}nt|d}y#tjjjj |||SWndSXdS(sI :doc: image_func Determines if `name` can be used to show an image. This interprets `name` as a tag and attributes. This is combined with the attributes of the currently-showing image with `tag` on `layer` to try to determine a unique image to show. If a unique image can be show, returns the name of that image as a tuple. Otherwise, returns None. `tag` The image tag to get attributes from. If not given, defaults to the first component of `name`. `layer` The layer to check. If None, uses the default layer for `tag`. iN( RRRRxRRtRuRvRtapply_attributes(RRR((srenpy/exports.pytcan_shows  #RcCsOt|ts$t|j}nt||}tjjjj||S(sv :doc: image_func Returns true if an image with the same tag as `name` is showing on `layer`. `image` May be a string giving the image name or a tuple giving each component of the image name. It may also be a string giving only the image tag. `layer` The layer to check. If None, uses the default layer for `tag`. ( RRRRRtRuRvRtshowing(RR((srenpy/exports.pyRscCs/|rtj|Stjjjj|S(s :doc: image_func Returns the set of image tags that are currently being shown on `layer`. If sort is true, returns a list of the tags from back to front. (Rtget_sorted_tagsRtRuRvRtget_showing_tags(Rtsort((srenpy/exports.pyRscCstjjjj|S(s :doc: image_func Returns the set of image tags on `layer` that are currently hidden, but still have attribute information associated with them. (RtRuRvRtget_hidden_tags(R((srenpy/exports.pyRscCs.t||}tjjjj|||S(s* :doc: image_func Return a tuple giving the image attributes for the image `tag`. If the image tag has not had any attributes associated since the last time it was hidden, returns `if_hidden`. `layer` The layer to check. If None, uses the default layer for `tag`. (RRtRuRvRtget_attributes(RRt if_hidden((srenpy/exports.pyR s c Cs|p |d}t||}|dkr4|}n$t|trXt|j}nt|tjjj r}|}}ntj j rtj j jj|||}|dk r|}|f|d}qntjjj|dd}}|jsdSxN|D]F} t| tjjjr9| d|}n | |}|jq Wtj j jj||ttjjj|dS(s} :undocumented: Predicts a scene or show statement. `name` The name of the image to show, a string. `layer` The layer the image is being shown on. `what` What is being show - if given, overrides `name`. `tag` The tag of the thing being shown. `at_list` A list of transforms to apply to the displayable. iitstyletimage_placementNtchild(RRxRRRRRtRtcoret DisplayableRtimage_attributesRuRvRRRtImageReferencet find_targettmotiont Transformt_uniquet predict_showR|RFRG( RRtwhatRtat_listtkeytbasetimgtnew_whatti((srenpy/exports.pyRs.    !    c Cstjj} tjjjr-tdnt|tsQt|j }n|dkrstjj rsd}nt } |p|d} t || }tjjr| r| | j|kr| j|| }qn|s/tjjj| d} | dk r/t| ts| g}q,t| }q/n|dkrD|}n$t|trht|j }nt|tjjjrtjjrt|tjjjrtjjj|dd}}d} q|}}ntjjr/tjjjj|| |}|dk r/|}| f|d}q/ntjjj|dd}}|j rtjj rtjj |||}t|tjjjr|}}q|rdSnxN|D]F}t|tjjjr|d|}n ||}|j!qWt"tjj#j$|<|r5| r5|f|d}ntjj%rWtjj%||n| j&||| ||d|d |d |d | d |dS( s :doc: se_images :args: (name, at_list=[ ], layer='master', what=None, zorder=0, tag=None, behind=[ ]) Shows an image on a layer. This is the programmatic equivalent of the show statement. `name` The name of the image to show, a string. `at_list` A list of transforms that are applied to the image. The equivalent of the ``at`` property. `layer` A string, giving the name of the layer on which the image will be shown. The equivalent of the ``onlayer`` property. If None, uses the default layer associated with the tag. `what` If not None, this is a displayable that will be shown in lieu of looking on the image. (This is the equivalent of the show expression statement.) When a `what` parameter is given, `name` can be used to associate a tag with the image. `zorder` An integer, the equivalent of the ``zorder`` property. If None, the zorder is preserved if it exists, and is otherwise set to 0. `tag` A string, used to specify the image tag of the shown image. The equivalent of the ``as`` property. `behind` A list of strings, giving image tags that this image is shown behind. The equivalent of the ``behind`` property. s%Show may not run while in init phase.iRRiNRRRtatltdefault_transformt transient('RtRRRuRvRRRRRRxtpreserve_zorderRRtsticky_positionsRt tag_transformRtlistRRRRtwrap_shown_transformsRRRRRRRRt missing_showRR|t persistentt _seen_imagest missing_hidetadd(RRRRtzorderRtbehindRRt munge_nameRRRtttRRRtresultR((srenpy/exports.pytshowUsf'        $   !      cCstjjjr!tdnt|tsEt|j}nt}|d}t ||}|j ||tj j rtj j ||ndS(s :doc: se_images Hides an image from a layer. The Python equivalent of the hide statement. `name` The name of the image to hide. Only the image tag is used, and any image with the tag is hidden (the precise name does not matter). `layer` The layer on which this function operates. If None, uses the default layer associated with the tag. s%Hide may not run while in init phase.iN( RtRuRvRRRRRRRtremoveRR(RRRR((srenpy/exports.pythides   cCso|dkrd}ntjjjr6tdnt}|j|tjj rktjj |ndS(s :doc: se_images Removes all displayables from `layer`. This is equivalent to the scene statement, when the scene statement is not given an image to show. A full scene statement is equivalent to a call to renpy.scene followed by a call to :func:`renpy.show`. For example:: scene bg beach is equivalent to:: $ renpy.scene() $ renpy.show("bg beach") Rs&Scene may not run while in init phase.N( RxRtRuRvRRRtclearRt missing_scene(RR((srenpy/exports.pytscenes     ts{}c Cstjjr|Stjjdtjj}t|tsGd}n|dk r\|}nt }t dri} t d|d|d|d|d| d|| dR@tcaptiontactiontchosenRR|t choice_layerRR(tmenu_showed_windowRRyR RR R}R (!Rt window_styleR RRMRNRORPRQtscopeRR&Rt predict_onlyRRRRR5t_tvalRR0t item_actionstpropsR1RRXRYR3R4tmeR((srenpy/exports.pyt display_menus*                             !     tTagQuotingDictcBseZdZRS(cCstjj}||krP||}t|ttfrL|jdd}n|Stjjrot d|nd|dSdS(Nt{s{{s:During an interpolation, '%s' was not found as a variable.t( RtRt__dict__RtstrtunicodetreplaceRtdebugR(tselfRRR((srenpy/exports.pyt __getitem__s    (RRARn(((srenpy/exports.pyRescCsl|dkrtjj}nt|ttfrCtjj||St|dd}|rh||ndS(sU :undocumented: This is called to predict the results of a say command. RFN( RxRtRtnarratorRRiRjt predict_saytgetattr(twhoRRF((srenpy/exports.pyRps cCs*y|j|_Wnt|_nXdS(sr :undocumented: Called when scry is called on a say statement. Needs to set the interacts field. N(t will_interactt interactsR|(Rrtscry((srenpy/exports.pytscry_sayscOstjjr|t}n|dkr4tjj}ntjjratjj|||\}}nt|t t frtjj ||||n||||dS(s, :doc: se_say The equivalent of the say statement. `who` Either the character that will say something, None for the narrator, or a string giving the character name. In the latter case, the :func:`say` is used to create the speaking character. `what` A string giving the line to say. Percent-substitutions are performed in this string. `interact` If true, Ren'Py waits for player input when displaying the dialogue. If false, Ren'Py shows the dialogue, but does not perform an interaction. (This is passed in as a keyword argument.) This function is rarely necessary, as the following three lines are equivalent. :: e "Hello, world." $ renpy.say(e, "Hello, world.") $ e("Hello, world.") N( RtRRRRxRRotsay_arguments_callbackRRiRjtsay(RrRRR((srenpy/exports.pyRxs    !timagemapc Kstjjdtjj|||d|d||tjj} | g|D]\} } } } }|^qNkr{d} ntrtjj rtjj ntjj d| ddd|d| }tjj ||dkrtjj }n|rtjjjddn|S( s} :undocumented: Use screens already. Displays an imagemap. An image map consists of two images and a list of hotspots that are defined on that image. When the user clicks on a hotspot, the value associated with that hotspot is returned. @param ground: The name of the file containing the ground image. The ground image is displayed for areas that are not part of any hotspots. @param selected: The name of the file containing the selected image. This image is displayed in hotspots when the mouse is over them. @param hotspots: A list of tuples defining the hotspots in this image map. Each tuple has the format (x0, y0, x1, y1, result). (x0, y0) gives the coordinates of the upper-left corner of the hotspot, (x1, y1) gives the lower-right corner, and result gives the value returned from this function if the mouse is clicked in the hotspot. @param unselected: If provided, then it is the name of a file containing the image that's used to fill in hotspots that are not selected as part of any image. If not provided, the ground image is used instead. @param overlays: If True, overlays are displayed when this imagemap is active. If False, the overlays are suppressed. @param with_none: If True, performs a with None after the input. If None, takes the value from config.implicit_with_none. Ryt unselectedRtsuppress_overlayRRRN(RtRRRtimagemap_compatR{RxRRRTR R RR RuR}R (tgroundtselectedthotspotsRztoverlaysRRRt propertiesRt_x0t_y0t_x1t_y1RR((srenpy/exports.pyRy;s$% .   c Cs|d kr*|d k r!t}q*t}ntjjdkr@tStjj}|ttgkrjd }ntjjd|d k rtj j j |}|d k r|}qn|d k rtj j r|d krd}n|d krd}nd }|stjj r*tjjd|ddntjjd||d k r_tjj|tntjjddd dd |}|rtjj|d tn|d krtjj}n|rtj jjd d n|S( s~ :doc: other :args: (delay=None, hard=False) Causes Ren'Py to pause. Returns true if the user clicked to end the pause, or false if the pause timed out or was skipped. `delay` If given, the number of seconds Ren'Py should pause for. `hard` This must be given as a keyword argument. When True, Ren'Py may prevent the user from clicking to interrupt the pause. If the player enables skipping, the hard pause will be skipped. There may be other circumstances where the hard pause ends early or prevents Ren'Py from operating properly, these will not be treated as bugs. In general, using hard pauses is rude. When the user clicks to advance the game, it's an explicit request - the user wishes the game to advance. To override that request is to assume you understand what the player wants more than the player does. Calling renpy.pause guarantees that whatever is on the screen will be displayed for at least one frame, and hence has been shown to the player. tl;dr - Don't use renpy.pause with hard=True. tfasttpauseiRtafmtdismisstdismiss_hard_pauseRRRRN(RxRR|RtRR8RR{RtaudioRgt get_delayRuRRt_dismiss_pauseRR RSR RR R}R ( tdelayRgRRRRtnewdelayRR((srenpy/exports.pyR|s@        $    ! icCstjjd|r/tjjjdtnt|d|tjj|dksd|dkrwtjj dntjj |t tj jjrt}nd}tjjdtd|}t|rtjjjdt n|S(s :doc: movie_cutscene This displays a movie cutscene for the specified number of seconds. The user can click to interrupt the cutscene. Overlays and Underlays are disabled for the duration of the cutscene. `filename` The name of a file containing any movie playable by Ren'Py. `delay` The number of seconds to wait before ending the cutscene. Normally the length of the movie, in seconds. If None, then the delay is computed from the number of loops (that is, loops + 1) * the length of the movie. If -1, we wait until the user clicks. `loops` The number of extra loops to show, -1 to loop forever. Returns True if the movie was terminated by the user, or False if the given delay elapsed uninterrupted. tmovieRgtloopsiR{RN(RtRRRtset_force_stopR|R2RR RxtsoundstopbehaviorRSRRuRytforwardR R4(tfilenameRRt stop_musicRR((srenpy/exports.pytmovie_cutscenes"   cCs1tjjjr!tdntjjr6d}ntjjj pH|sTd}ntj j dt |t r|jdd}|dkr|dkrdSnt |t rxB|jD]4\}}|dkrqntj j|d|qWd|krdS|d}ntjjj||d|S(s :doc: se_with :name: renpy.with_statement :args: (trans, always=False) Causes a transition to occur. This is the Python equivalent of the with statement. `trans` The transition. `always` If True, the transition will always occur, even if the user has disabled transitions. This function returns true if the user chose to interrupt the transition, and false otherwise. s0With statements may not run while in init phase.twithNRR(RtRuRvRRRR8RxR9t transitionsRRRRRRt transitionR}R (ttranstalwaystpairedRRR((srenpy/exports.pytwith_statements(      Ric Cs|r;ttjjdkr;||ftjjd_dS|sztjjsQdStjjjsgdStj j szdSndtj _ tjj jtjj j|d|d|d|tkd|d|dS( sX :doc: rollback :args: (force=False, checkpoints=1, defer=False, greedy=True, label=None, abnormal=True) Rolls the state of the game back to the last checkpoint. `force` If true, the rollback will occur in all circumstances. Otherwise, the rollback will only occur if rollback is enabled in the store, context, and config. `checkpoints` Ren'Py will roll back through this many calls to renpy.checkpoint. It will roll back as far as it can, subject to this condition. `defer` If true, the call will be deferred until control returns to the main context. `greedy` If true, rollback will finish just after the previous checkpoint. If false, rollback finish just before the current checkpoint. `label` If not None, a label that is called when rollback completes. `abnormal` If true, the default, script executed after the transition is run in an abnormal mode that skips transitions that would have otherwise occured. Abnormal mode ends when an interaction begins. iiNtgreedyR1tforcetabnormalt current_label(RRtRutcontextstdefer_rollbackRRRvRwRRRxR8RytcompleteR|(Rt checkpointstdeferRR1RR((srenpy/exports.pyRw>s!   cCstjjj tjj_dS(s9 :undocumented: Toggles the fullscreen mode. N(RtRuR9t fullscreen(((srenpy/exports.pyttoggle_fullscreensscCsdS(s* :undocumented: Does nothing. N((((srenpy/exports.pyt toggle_music|scCstjjj|S(s :doc: label Returns true if `name` is a valid label the program, or false otherwise. `name` Should be a string to check for the existence of a label. It can also be an opaque tuple giving the name of a non-label statement. (RtRutscriptt has_label(R((srenpy/exports.pyRs cCsUg}x<tjjjjD]%}t|tr|j|qqWtjj |S(s :doc: label Returns the set of all labels defined in the program, including labels defined for internal use in the libraries. ( RtRuRtnamemaptiterkeysRRR"R t RevertableSet(RR((srenpy/exports.pytget_all_labelss cCsD|dkr'tjjtjjf}ntjjj|d|dS(sx :doc: loadsave Causes a screenshot to be taken. This screenshot will be saved as part of a save game. t backgroundN(RxRtRtthumbnail_widthtthumbnail_heightRuR}ttake_screenshot(tscaleR((srenpy/exports.pyRs t_invoke_main_menut _main_menucCs:|tkrtjj}ntjj|||fdS(s :doc: other Causes Ren'Py to restart, returning the user to the main menu. `transition` If given, the transition to run, or None to not run a transition. False uses :var:`config.end_game_transition`. N(RRtRtend_game_transitionRutFullRestartException(RR1ttarget((srenpy/exports.pyt full_restarts cCstjjdS(s :undocumented: Used in the implementation of shift+R. Causes an utter restart of Ren'Py. This reloads the script and re-runs initialization. N(RtRutUtterRestartException(((srenpy/exports.pyt utter_restartscCs td}tjdd tjdd tjdd tjjs|d k r|jdtd<|jj dd td<|jj ditd|dk r!tjj|}nt||d|||dS(NR (RxRtR RCRx(RrRR RR((srenpy/exports.pyt do_reshow_sayPs cKsDttjj}|j|ttjjtjjtjj|S(N( RRtRt_last_say_kwargsRUtcurried_do_reshow_sayt _last_say_whot_last_say_whatt_last_say_args(Rtkw((srenpy/exports.pytget_reshow_say[s    cKst|dS(N(R(R((srenpy/exports.pyt reshow_sayfscCsttjjjddS(Nt_current_interact_type(RqRtRuRvRRx(((srenpy/exports.pytcurrent_interact_typejscCsttjjjddS(Nt_last_interact_type(RqRtRuRvRRx(((srenpy/exports.pytlast_interact_typenscGstjjj|dS(s+ :doc: other This can be given one or more variable names as arguments. This makes the variables dynamically scoped to the current call. The variables will be reset to their original value when the call returns. An example call is:: $ renpy.dynamic("x", "y", "z") N(RtRuRvt make_dynamic(tvars((srenpy/exports.pytdynamicrs cGs tjjj|dtdS(s6 :doc: other This can be given one or more variable names as arguments. This makes the variables dynamically scoped to the current context. The variables will be reset to their original value when the call returns. An example call is:: $ renpy.context_dynamic("x", "y", "z") RvN(RtRuRvRR|(R((srenpy/exports.pytcontext_dynamics cCs|tjjjkS(s :doc: label Returns true if the named label has executed at least once on the current user's system, and false otherwise. This can be used to unlock scene galleries, for example. (RtRuRt _seen_ever(R1((srenpy/exports.pyt seen_labelscCs(tjdd|}|tjjjkS(s} :doc: audio Returns True if the given filename has been played at least once on the current user's system. s^<.*?>R(tretsubRtRuRt _seen_audio(R((srenpy/exports.pyt seen_audioscCs7t|ts$t|j}n|tjjjkS(so :doc: image_func Returns True if the named image has been seen at least once on the user's system. An image has been seen if it's been displayed using the show statement, scene statement, or :func:`renpy.show` function. (Note that there are cases where the user won't actually see the image, like a show immediately followed by a hide.) (RRRRtRuRR(R((srenpy/exports.pyt seen_images cCstjj|S(s :doc: file Returns a read-only file-like object that accesses the file named `fn`. The file is accessed using Ren'Py's standard search method, and may reside in an RPA archive. or as an Android asset. The object supports a wide subset of the fields and methods found on Python's standard file object, opened in binary mode. (Basically, all of the methods that are sensible for a read-only file.) (RtRR5(R((srenpy/exports.pyRs cCstjj|dtS(sS :undocumented: Like file, but doesn't search the translation prefix. ttl(RtRR5R(R((srenpy/exports.pyt notl_filescCs\tjjtjj|}t|tjjjsFt dn|j }|j S(s :doc: file_rare Given an image manipulator, loads it and returns a (``width``, ``height``) tuple giving its size. This reads the image in from disk and decompresses it, without using the image cache. This can be slow. s6renpy.image_size expects it's argument to be an image.( RtRtindex_archivesRRGRRtimtImageRR5tget_size(R'tsurf((srenpy/exports.pyt image_sizes  cCs`t|tr$t|j}n|d}t||}tjjjj |j |dS(s :doc: se_images Returns the list of transforms being applied to the image with tag `name` on `layer`. Returns an empty list if no transofrms are being applied, or None if the image is not shown. If `layer` is None, uses the default layer for the given tag. iN( RRRRRRtRuRvRRRRx(RRR((srenpy/exports.pyt get_at_lists  cCsAt|ts|g}ntjjjj||d|dS(sX :doc: se_images :name: renpy.show_layer_at The Python equivalent of the ``show layer`` `layer` ``at`` `at_list` statement. `reset` If true, the transform state is reset to the start when it is shown. If false, the transform state is persisted, allowing the new transform to update that state. tresetN(RRRtRuRvRtset_layer_at_list(RRR-((srenpy/exports.pyt show_layer_ats cCs+ttjjjtjjjdS(sn :doc: other Attempts to free some memory. Useful before running a renpygame-based minigame. N(R RtRR}tkill_textures_and_surfacesRtfontt free_memory(((srenpy/exports.pyR2 scCs*|rtjj|Stjj|SdS(s :undocumented: N(RtRRGtdisplayable_or_none(Rtnone((srenpy/exports.pyteasy_displayable" scCstjjjdS(st :doc: other Triggers a quit event, as if the player clicked the quit button in the window chrome. N(RtRuR}t quit_event(((srenpy/exports.pyR6. scCstjjjdS(s. :doc: other Iconifies the game. N(RtRuR}ticonify(((srenpy/exports.pyR79 stcurried_call_in_new_contexttcurried_invoke_in_new_contextcCst|dS(N(R(R ((srenpy/exports.pyt_errorO scCstj|dS(N(t_error_handlersR"(teh((srenpy/exports.pytpush_error_handlerV scCstjdS(N(R;R(((srenpy/exports.pytpop_error_handlerZ scCstd|dS(s :doc: lint Reports `msg`, a string, as as error for the user. This is logged as a parse or lint error when approprate, and otherwise it is raised as an exception. iN(R;(R ((srenpy/exports.pyterror^ s cCstjjj|dS(s :doc: udd_utility Causes an event to be generated before `seconds` seconds have elapsed. This ensures that the event method of a user-defined displayable will be called. N(RtRuR}ttimeout(tseconds((srenpy/exports.pyR@j s cCs)|dkrdStjjj|dS(s :doc: udd_utility If `value` is not None, immediately ends the current interaction, causing the interaction to return `value`. If `value` is None, does nothing. This can be called from inside the render and event methods of a creator-defined displayable. N(RxRtRRtEndInteraction(R((srenpy/exports.pytend_interactionv s cCs1tjjj}tjjj|}|jS(s[ :doc: other Returns the scry object for the current statement. The scry object tells Ren'Py about things that must be true in the future of the current statement. Right now, the scry object has one field: ``nvl_clear`` Is true if an ``nvl clear`` statement will execute before the next interaction. (RtRuRvR$RtlookupRu(Rtnode((srenpy/exports.pyRu scCstjjtdS(Ni(Rttparsertmunge_filenameR(((srenpy/exports.pytmunged_filename scKs/tjjjs!tdn|tkr1dStj|tjj}t tj_tjj j |}tj j t }t|_tjjj||j|tjjj|xI|D]A\}}t|tjjrtjjj|q|qW|jtjjj|tj_dS(sO :doc: other This loads the Ren'Py module named name. A Ren'Py module consists of Ren'Py script that is loaded into the usual (store) namespace, contained in a file named name.rpym or name.rpymc. If a .rpym file exists, and is newer than the corresponding .rpymc file, it is loaded and a new .rpymc file is created. All of the init blocks (and other init-phase code) in the module are run before this function returns. An error is raised if the module name cannot be found, or is ambiguous. Module loading may only occur from inside an init block. s,Module loading is only allowed in init code.N(RtRuRvRRtloaded_modulesRRtlockedRRt load_modulet executiontContextR|RR"RRRhRURtasttNodeRtpop_all_dynamicR(RRt old_lockedtinitcodeRvtprioRE((srenpy/exports.pyRK s(        sc Cs+tjj}z tjj}ttj_tjjj|t|\}}|dkr[dStj j t}t |_ tjjj|xI|D]A\}}t|tjjrtjjj|q|qW|jtjjj|tj_tjjj|djSWd|tj_XdS(s :doc: other Loads `s` as Ren'Py script that can be called. Returns the name of the first statement in s. `filename` is the name of the filename that statements in the string will appear to be from. iN(RtRutexception_infoRRJRRt load_stringRjRxRLRMR|RRR"RRNRORvRRPRtanalyzeR( RRtold_exception_infoRQtstmtsRRRvRSRE((srenpy/exports.pyRU s(   $     cCstjjjdS(s :doc: other :name: renpy.pop_call Pops the current call from the call stack, without returning to the location. This can be used if a label that is called decides not to return to its caller. N(RtRuRvtpop_call(((srenpy/exports.pyRY s cCsttjjjS(s :doc: other Returns the depth of the call stack of the current context - the number of calls that have run without being returned from or popped from the call stack. (RRtRuRvt return_stack(((srenpy/exports.pytcall_stack_depth s cCs-|dkrtdntdd|dS(sR :undocumented: Probably not what we want in the presence of screens. t _game_menut_game_menu_screenN(RxR(R&((srenpy/exports.pyt game_menu# s  cCsttjjj_dS(s :doc: other Call this to indicate that the window has been shown. This interacts with the "window show" statement, which shows an empty window whenever this functions has not been called during an interaction. N(R|RtRuRvRR(((srenpy/exports.pyR/ s t placementcBs>eZdZedZedZedZRS(cCsrtt|j|d|_|d|_|d|_|d|_|d|_|d|_|d|_ dS(Niiiiiii( tsuperR_t__init__txpostypostxanchortyanchortxoffsettyoffsettsubpixel(Rmtp((srenpy/exports.pyRa= s      cCs|j|jfS(N(RbRc(Rm((srenpy/exports.pytposH scCs|j|jfS(N(RdRe(Rm((srenpy/exports.pytanchorL scCs|j|jfS(N(RfRg(Rm((srenpy/exports.pytoffsetP s(RRARatpropertyRjRkRl(((srenpy/exports.pyR_; s cCs|j}t|S(s :doc: image_func This gets the placement of displayable d. There's very little warranty on this information, as it might change when the displayable is rendered, and might not exist until the displayable is first rendered. This returns an object with the following fields, each corresponding to a style property: * pos * xpos * ypos * anchor * xanchor * yanchor * offset * xoffset * yoffset * subpixel (t get_placementR_(RRi((srenpy/exports.pyRnU s cCsn|jd}t||}|dkr:tjj}n|dkrUtjj}ntj||||S(s :doc: image_func If an image with `tag` exists on `layer`, returns the bounding box of that image. Returns None if the image is not found. The bounding box is an (x, y, width, height) tuple. The components of the tuples are expressed in pixels, and may be floating point numbers. `width`, `height` The width and height of the area that contains the image. If None, defaults the width and height of the screen, respectively. `layer` If None, uses the default layer for `tag`. iN( RRRxRtRt screen_widtht screen_heightRtget_image_bounds(RtwidththeightR((srenpy/exports.pyRqq s  RcBseZRS((RRA(((srenpy/exports.pyR st ContainercBseZejjZRS((RRARtR tRevertableListt _list_type(((srenpy/exports.pyRt scCs tjjjS(N(RtRuR}R(((srenpy/exports.pytget_roll_forward scGstjj}xX|D]P}tjj|}t|tjjjsYt d|n|j |qW|tj j Btj _ dS(s1 :undocumented: Cache pin is deprecated. s#Cannot pin non-image-manipulator %rN( RtR RRRGRRR't ImageBaseRRRt_cache_pin_set(Rtnew_pinsRR'((srenpy/exports.pyt cache_pin s cGstjj}xX|D]P}tjj|}t|tjjjsYt d|n|j |qWtj j |tj _ dS(s1 :undocumented: Cache pin is deprecated. s%Cannot unpin non-image-manipulator %rN( RtR RRRGRRR'RxRRRRy(RRzRR'((srenpy/exports.pyt cache_unpin s cCs]t|ts|gSd|kr)|gSd|krDtt}n t}tj||S(se :undocumented: Use the fnmatch function to expland `d` for the purposes of prediction. t*t.(RRt list_filesRR(tfnmatchtfilter(Rtl((srenpy/exports.pytexpand_predict s   cGsotjjtjj}xD|D]<}x3t|D]%}tjj|}|j|q2WqW|tj_dS(s :doc: image_func This function takes one or more displayables as arguments. It causes Ren'Py to predict those displayables during every interaction until the displayables are removed by :func:`renpy.stop_predict`. If a displayable name is a string containing one or more \* characters, the asterisks are used as a wildcard pattern. If there is at least one . in the string, the pattern is matched against filenames, otherwise it is matched against image names. For example:: $ renpy.start_predict("eileen *") starts predicting all images with the name eileen, while:: $ renpy.start_predict("images/concert*.*") matches all files starting with concert in the images directory. N( RtR RRt _predict_setRRRGR(Rt new_predictRR((srenpy/exports.pyt start_predict s  cGsotjjtjj}xD|D]<}x3t|D]%}tjj|}|j|q2WqW|tj_dS(s :doc: image_func This function takes one or more displayables as arguments. It causes Ren'Py to stop predicting those displayables during every interaction. Wildcard patterns can be used as described in :func:`renpy.start_predict`. N( RtR RRRRRRGtdiscard(RRRR((srenpy/exports.pyt stop_predict s  cOs8tjjtjj}||f||<|tj_dS(s  :doc: screens Causes Ren'Py to start predicting the screen named `_screen_name` will be shown with the given arguments. This replaces any previous prediction of `_screen_name`. To stop predicting a screen, call :func:`renpy.stop_predict_screen`. N(RtR tRevertableDictRt_predict_screen(t _screen_nameRRR((srenpy/exports.pytstart_predict_screen s cCs8tjjtjj}|j|d|tj_dS(sd :doc: screens Causes Ren'Py to stop predicting the screen named `name` will be shown. N(RtR RRRRRx(RR((srenpy/exports.pytstop_predict_screen! scOs3d}d|kr$|jd}ntjj|tjj}d|kr^|jd}nt|dt||tjj}y%tj j ddddd|}Wn+tj j tj j fk r}|}nXtjj||rtj jjddnt|tj j tj j fr/|n|S( s[ :doc: screens The programmatic equivalent of the call screen statement. This shows `_screen_name` as a screen, then causes an interaction to occur. The screen is hidden at the end of the interaction, and the result of the interaction is returned. Keyword arguments not beginning with _ are passed to the scope of the screen. If the keyword argument `_with_none` is false, "with None" is not run at the end of end of the interaction. If the keyword argument `_mode` in kwargs, it will be mode of this interaction, otherwise it will be "screen" mode. R&RJRIRRRRN(RRtRRRR RR|R{RR RuRRRR}R RxR(RRRRRRRte((srenpy/exports.pyt call_screen- s&   %! ! cCsYg}xBtjj|D].\}}|jdr:qn|j|qW|j|S(s :doc: file Lists the files in the game directory and archive files. Returns a list of files, with / as the directory separator. `common` If true, files in the common directory are included in the listing. ssaves/(RtRt listdirfilest startswithR"R(tcommonRtdirR((srenpy/exports.pyR_ s  cCs tjjjS(s :doc: other Returns a dictionary, giving information about the renderer Ren'Py is currently using. The dictionary has one required key: ``"renderer"`` One of ``"gl"`` or ``"sw"``, corresponding to the OpenGL and software renderers, respectively. ``"resizable"`` True if and only if the window is resizable. ``"additive"`` True if and only if the renderer supports additive blending. Other, renderer-specific, keys may also exist. The dictionary should be treated as immutable. This should only be called once the display has been started (that is, after the init phase has finished). (RtRtdrawR(((srenpy/exports.pytget_renderer_infoy scCsttjj_dS(sw :undocumented: Used internally. Causes the display to be restarted at the start of the next interaction. N(R|RtRR}t display_reset(((srenpy/exports.pyR scCstjj}|jsdS|j}zDt|_||dkrhx$tjjD]}|||qNWnWdt|_X||kr|j |n|j d|dS(sq :doc: modes Causes Ren'Py to enter the named mode, or stay in that mode if it's already in it. Ni( RtRuRvt use_modestmodesRRtmode_callbacksR|Rtinsert(RtctxRtc((srenpy/exports.pyR s     cCs-tjj}|jsdS|j}|dS(sR :doc: modes Returns the current mode, or None if it is not defined. iN(RtRuRvRRxR(RR((srenpy/exports.pytget_mode s   cCstjj|dS(sS :doc: other Causes Ren'Py to display the `message` using the notify screen. By default, this will cause the message to be dissolved in, displayed for two seconds, and dissolved out again. This is useful for actions that otherwise wouldn't produce feedback, like screenshots or quicksaves. Only one notification is displayed at a time. If a second notification is displayed, the first notification is replaced. This function just calls :var:`config.notify`, allowing its implementation to be replaced by assigning a new function to that variable. N(RtRtnotify(tmessage((srenpy/exports.pyR scCs%tdtdd|tdS(sN :doc: other The default implementation of :func:`renpy.notify`. RRN(RRR(R((srenpy/exports.pytdisplay_notify s cCsNt|tr|tjjkSx$|D]}|tjjkr&tSq&WtSdS(s :doc: screens Returns true if a `name` is a screen variant that can be chosen by Ren'Py. See :ref:`screen-variants` for more details. This function can be used as the condition in a Python if statement to set up the appropriate styles for the selected screen variant. `name` can also be a list of variants, in which case this function returns True if any of the variants is selected. N(RRRtRtvariantsR|R(RR((srenpy/exports.pytvariant s  cCs+yddl}|j|WnnXdS(s :doc: other Causes the device to vibrate for `duration` seconds. Currently, this is only supported on Android. iN(tandroidtvibrate(tdurationR((srenpy/exports.pyR s  cCstjjjS(s :doc: other Gets the attributes associated with the current say statement, or None if no attributes are associated with this statement. This is only valid when executing or predicting a say statement. (RtRuRvtsay_attributes(((srenpy/exports.pytget_say_attributes s c Cstjjj}|dk rIt||}|f|j||}n tjj}|s_dSt||}|r|j ||dfrdSt }t |} |j ||| dS(s[ :doc: other This attempts to find an image to show as the side image. It begins by determining a set of image attributes. If `image_tag` is given, it gets the image attributes from the tag. Otherwise, it gets them from the currently showing character. It then looks up an image with the tag `prefix_tag` and those attributes, and returns it if it exists. If not_showing is True, this only returns a side image if the image the attributes are taken from is not on the screen. If `layer` is None, uses the default layer for the currently showing tag. iN( RtRuRvRRxRRRt_side_image_attributesRR,t choose_image( t prefix_tagt image_tagt not_showingRRt image_layertattrst attr_layertrequiredtoptional((srenpy/exports.pytget_side_image! s    cCstjjjS(sC :doc: other Returns the size of the physical window. (RtRRtget_physical_size(((srenpy/exports.pyRK scCsEttjj_tdrAtjjj||tjj_ ndS(s :doc: other Attempts to set the size of the physical window to `size`. This has the side effect of taking the screen out of fullscreen mode. t resizableN( RRtRuR9RRRR}tset_modet last_resize(tsize((srenpy/exports.pytset_physical_sizeU s cCsHttjj_tdrDtjjjtj j tj j fndS(s :doc: other Attempts to set the size of the physical window to the specified values in renpy.config. (That is, screen_width and screen_height.) This has the side effect of taking the screen out of fullscreen mode. RN( RRtRuR9RRRR}RRRoRp(((srenpy/exports.pytreset_physical_sized s  cCs5t|ts|Stjp"d}|j|dS(sl :doc: file_rare :name: renpy.fsencode Converts s from unicode to the filesystem encoding. sutf-8Rk(RRjtsystgetfilesystemencodingR(Rt fsencoding((srenpy/exports.pytfsencodes s cCs2t|ts|Stjp"d}|j|S(sh :doc: file_rare :name: renpy.fsdecode Converts s from filesystem encoding to unicode. sutf-8(RRiRRtdecode(RR((srenpy/exports.pytfsdecode s (t launch_editorccs_|dk rtj|}nd}x3tjjjjD]}|d|krRPn|Vq8WdS(sG :doc: other A generator that yields a log of image loading activity. For the last 100 image loads, this returns: * The time the image was loaded (in seconds since the epoch). * The filename of the image that was loaded. * A boolean that is true if the image was preloaded, and false if the game stalled to load it. The entries are ordered from newest to oldest. `age` If not None, only images that have been loaded in the past `age` seconds are included. The image load log is only kept if config.developer = True. iN(RxRhRtRR'tcachetload_log(tagetdeadlineR((srenpy/exports.pytget_image_load_log s cCs"tjjrtjjndS(sk :doc: replay If we're in a replay, ends the replay immediately. Otherwise, does nothing. N(RtRt _in_replayRut EndReplay(((srenpy/exports.pyt end_replay s cCstjjtdS(sB :doc: persistent Saves the persistent data to disk. N(RtRRUR|(((srenpy/exports.pytsave_persistent scCstjjj|S(s :doc: other Returns true if the current line has been seen by the player. If `ever` is true, we check to see if the line has ever been seen by the player. If false, we check if the line has been seen in the current play-through. (RtRuRvt seen_current(tever((srenpy/exports.pytis_seen s cCstjjjS(s :doc: other Returns an (x, y) tuple giving the location of the mouse pointer or the current touch location. If the device does not support a mouse and is not currently being touched, x and y are numbers, but not meaningful. (RtRRt get_mouse_pos(((srenpy/exports.pyR scCstjjj|||dS(s) :doc: other Jump the mouse pointer to the location given by arguments x and y. If the device does not have a mouse pointer, this does nothing. `duration` The time it will take to perform the move, in seconds. During this time, the mouse may be unresponsive. N(RtRR}t set_mouse_pos(txtyR((srenpy/exports.pyR s cCs |t_dS(s :doc: other Sets the autoreload flag, which determines if the game will be automatically reloaded after file changes. Autoreload will not be fully enabled until the game is reloaded with :func:`renpy.utter_restart`. N(Rtt autoreload(R((srenpy/exports.pytset_autoreload s cCstjS(s4 :doc: other Gets the autoreload flag. (RtR(((srenpy/exports.pytget_autoreload scCstjjjjS(sa :doc: other Returns the number of dialogue blocks in the game's original language. (RtRuRt translatortcount_translates(((srenpy/exports.pytcount_dialogue_blocks scCs tjjS(s :doc: other Returns the number of dialogue blocks the user has seen in any play-through of the current game. (RtRutseen_translates_count(((srenpy/exports.pytcount_seen_dialogue_blocks scCs tjjS(s~ :doc: other Returns the number of dialogue blocks the user has seen for the first time during this session. (RtRutnew_translates_count(((srenpy/exports.pyt count_newly_seen_dialogue_blocks scCs tjj|d|d|dS(s8 :doc: other Applies translation and new-style formatting to the string `s`. `scope` If not None, a scope which is used in formatting, in addition to the default store. `translate` Determines if translation occurs. Returns the translated and formatted string. R]t translatei(Rtt substitutionsR(RR]R((srenpy/exports.pyR+ scCsb|dkr$tjdjj}n|jds7|S|jdrJ|Stjj ||dS(s :doc: other Munges `name`, which must begin with __. `filename` The filename the name is munged into. If None, the name is munged into the filename containing the call to this function. it__iN( RxRt _getframetf_codet co_filenameRtendswithRtRFRG(RR((srenpy/exports.pytmunge> s cCstjjjS(s :doc: label Returns a list giving the current return stack. The return stack is a list of statement names. The statement names will be strings (for labels), or opaque tuples (for non-label statements). (RtRuRvtget_return_stack(((srenpy/exports.pyRU s cCstjjj|dS(s :doc: label Sets the current return stack. The return stack is a list of statement names. Statement names may be strings (for labels) or opaque tuples (for non-label statements). N(RtRuRvtset_return_stack(tstack((srenpy/exports.pyRc s cs>fd}tjd|}t|_|jdS(s1 :doc: other Invokes the function `fn` in a background thread, passing it the provided arguments and keyword arguments. Restarts the interaction once the thread returns. This function creates a daemon thread, which will be automatically stopped when Ren'Py is shutting down. cs<yWnddl}|jnXtdS(Ni(t tracebackt print_excR(R(RRR(srenpy/exports.pyR} s  RN(t threadingtThreadR|tdaemontstart(RRRRR((RRRsrenpy/exports.pytinvoke_in_threadq s   cCstjjjjdS(s :doc: gesture Cancels the current gesture, preventing the gesture from being recognized. This should be called by displayables that have gesture-like behavior. N(RtRtgesturet recognizertcancel(((srenpy/exports.pytcancel_gesture scCs(x!tjjD]}|j|q WdS(s= :undocumented: Executes the default statement. N(RtRNtdefault_statementst set_default(RR((srenpy/exports.pytexecute_default_statement scGstjjj||dS(s0 :undocumented: Writes to log.txt. N(RtRRyR(RR((srenpy/exports.pyt write_log scCs tjjjS(sW :doc: screens Returns true if Ren'Py is currently predicting the screen. (RtRRFt predicting(((srenpy/exports.pyR scCstjjjS(s :undocumented: Returns the list of lines that have been shown since the last time :func:`renpy.clear_line_log` was called. (RtRuRvtline_log(((srenpy/exports.pyt get_line_log scCsgtjj_dS(s2 :undocumented: Clears the line log. N(RtRuRvR(((srenpy/exports.pytclear_line_log scCstjj}|tjjkr"dS|dk rI|dk rItdn|dk ry|j|d}Wqtk rtd|qXnR|dk ry|j|}Wqtk rtd|qXn td|j|||rtjjj |ndS(sZ :doc: other Adds a new layer to the screen. If the layer already exists, this function does nothing. One of `behind` or `above` must be given. `layer` A string giving the name of the new layer to add. `above` If not None, a string giving the name of a layer the new layer will be placed above. `below` If not None, a string giving the name of a layer the new layer will be placed below. `menu_clear` If true, this layer will be cleared when entering the game menu context, and restored when leaving the NsHThe above and below arguments to renpy.add_layer are mutually exclusive.isLayer '%s' does not exist.sIThe renpy.add_layer function requires either the above or below argument.( RtRRRxRtindext ValueErrorRtmenu_clear_layersR"(Rtabovetbelowt menu_clearRR((srenpy/exports.pyt add_layer s&      cCsktjjdk r(tjjj|n?|dkrFdtjj_n!ttjjj|tjj_dS(s :doc: other Forces Ren'Py to draw the screen at the maximum framerate for `t` seconds. If `t` is None, cancels the maximum framerate request. iN(RtRR}Rxtmaximum_framerateRtinitial_maximum_frameratetmax(R((srenpy/exports.pyRs  cCs tjjjS(s :doc: other Returns true if restart_interaction has not been called during the current interaction. This can be used to determine if the interaction is just being started, or has been restarted. (RtRR}tstart_interact(((srenpy/exports.pytis_start_interacts cKsQ|dkrdS|dkr+tjj}ntjjj|d|dt|dS(s :doc: audio Plays a sound effect. If `channel` is None, it defaults to :var:`config.play_channel`. This is used to play sounds defined in styles, :propref:`hover_sound` and :propref:`activate_sound`. NtchannelR(RxRtRt play_channelRRgRcR(RRR((srenpy/exports.pyRcs  cCstjjjtjjjfS(s :undocumented: Returns the current input value, and a flag that is true if it is editable. and false otherwise. (RtRtbehaviortcurrent_input_valuetinput_value_active(((srenpy/exports.pytget_editable_input_value/scCs"|tjj_|tjj_dS(sp :undocumented: Sets the currently active input value, and if it should be marked as editable. N(RtRRRR (t input_valueR((srenpy/exports.pytset_editable_input_value:sicCs:|d9}tjj}|j}t|||}|S(s :doc: other Returns the refresh rate of the current screen, as a floating-point number of frames per second. `precision` The raw data Ren'Py gets is number of frames per second, rounded down. This means that a monitor that runs at 59.95 frames per second will be reported at 59 fps. The precision argument reduces the precision of this reading, such that the only valid readings are multiples of the precision. Since all monitor framerates tend to be multiples of 5 (25, 30, 60, 75, and 120), this likely will improve accuracy. Setting precision to 1 disables this. g?(RtRtget_infot refresh_ratetround(t precisionRR((srenpy/exports.pytget_refresh_rateFs   cCstjjj|S(s  :doc: rollback Given a rollback_identifier from a HistoryEntry object, returns the number of checkpoints that need to be passed to :func:`renpy.rollback` to reach that identifier. Returns None of the identifier is not in the rollback history. (RtRuRytget_identifier_checkpoints(t identifier((srenpy/exports.pyRbs cCs |jS(s, :doc: other Given `bar_value`, a :class:`BarValue`, returns the :func:`ui.adjustment` if uses. The adjustment has the following to attributes defined: .. attribute:: value The current value of the bar. .. attribute:: range The current range of the bar. (tget_adjustment(t bar_value((srenpy/exports.pyRoscCs tjjS(s :doc: other Returns true if the Ren'Py is skipping, "fast" if Ren'Py is fast skipping, and false if it is not skipping. (RtRR8(((srenpy/exports.pyt get_skippingscCstjjjS(s :undocumented: Returns the number of bytes of memory locked up in OpenGL textures and the number of textures that are defined. (RtRRtget_texture_size(((srenpy/exports.pyRscCsOtjj}|jtjkr%tS|jtjkrAtatStatSdS(s :other: Returns True if Ren'Py is running on a device that is powered by an internal battery, or False if the device is being charged by some external source. N( t pygame_sdl2tpowertget_power_infotstatetPOWERSTATE_UNKNOWNt old_batterytPOWERSTATE_ON_BATTERYR|R(tpi((srenpy/exports.pytget_on_batterys cCs$tjjdkrdStjjdS(s :doc: image_func Returns the tag corresponding to the currently speaking character (the `image` argument given to that character). Returns None if no character is speaking or the current speaking character does not have a corresponding image tag. iN(RtRRRx(((srenpy/exports.pytget_say_image_tags cCs tjj S(s| :doc: other Returns True if Ren'Py is currently skipping (in fast or slow skip mode), or False otherwise. (RtRR8(((srenpy/exports.pyt is_skippings(mt __future__RRRRt renpy.displayRtt renpy.audiotrenpy.pyanalysisRRRR Rtrenpy.text.extrasR R trenpy.text.fontR R Rtrenpy.text.textRRtrenpy.display.behaviorRRRbRRRRRRRtrenpy.display.minigameRtrenpy.display.screenRRRRRR R!R"R#RiR$trenpy.display.focusR%trenpy.display.predictR&Rjtrenpy.display.imageR'RmR(R)R*R+R,R-trenpy.display.imR.R/t renpy.curryR0R1trenpy.display.videoR2R3R4trenpy.loadsaveR5R6R7R8R9R:R;R<R=R>R?R@RARBt renpy.pythonRCRdRDRet renpy.atlREt renpy.easyRFRGRHt renpy.parserRIRJtrenpy.translationRKRLtrenpy.translation.generationRMRktrenpy.persistentRNtrenpy.characterRORPRQtrenpy.audio.soundRRftrenpy.audio.musicRgtrenpy.statementsRRRlRSt renpy.memoryRTRURVtrenpy.text.textsupportRWRnRXRoRYRpRZRqtrenpy.executionR[trenpy.sl2.slparserR\RrR]t renpy.astR^t renpy.loaderR_t renpy.lintR`RaRhRRRRsR{RxRRRRRRRRRRRRRRRRRRRRRRRR|RRRRRRRR(R<R?RR@RdtobjectReRRpRvRxRyRRRtglobalsRwRRRRRRRRRRRRRRRtversion_stringt version_onlyt version_nameRtlicensetplatformt _platformtjoinRRtiosRRRRRRRRvRRRRRRyR R RRRRRRRRR"R#R%R+R,R/t layer_at_listR2R5R6R7RuRR8tinvoke_in_new_contextR9t call_replayR:R;R=R>R?R@RCRuRHR,RIRKRURYt pop_returnR[R^RR tRevertableObjectR_RnRqtrendertRendert IgnoreEventtredrawRRtRwR{R|RRRRRRRRRRRRRRRRRRRRRRt renpy.editorRRRRRRRRRRRRRRRRRRRRRRRRRRRcR R RRRRRRR R!R"(((srenpy/exports.pyts:     "("":."               6       '   ;${ [ m       ,@Q95 5  !       &            #                         1 /   ((     "   2       *   !        6