This fixes a bug where, if you're using the software renderer on Xorg on Debian Jessie,
switching into fullscreen produces an unusable screen (usually, a fullscreen window with
the current screen contents stuck on it; sometimes the game window scaled to full screen
but refusing to accept graphic updates (though clicks ARE passed through to the underlying
game), sometimes the game window drawn actual size in the upper left corner of the screen
with the rest of the screen occupied by the previous screen contents). This bug was
seen on two different Jessie machines.
If the user requests vsync yet vsync happens to be broken, we'll
consume 100% CPU. This can happen on a mac, for example when
the window is fully covered by another window. This code inserts
a sleep in that case.
Fixes#757.
This lets us write:
default weather = 'sunny'
add "logo [weather]"
textbutton "Make it Rain" action SetScreenVariable("weather", "rainy")
in SL2, and have it work properly.
This required a genericization of the way SL handles providing scopes to
displayables, especially Text.
Because of one of the changes made to support drawable-resolution
text, we would increase the size of Renders. When clipping was
involved, this could make the render too large, causing overlap.
This fixes a bug that affected the scrollbars in some of the
default themes.
This fixes a problem where hyperlinks were not being unscaled
properly, and hence hyperlinks that were not in the top-left
of a Text block would not handle focus the correct way.
This is necessary for setting _rollback to False to work
properly. Before this, greedy rollbacks could go to the
first line with _rollback=False, since they would go
until just after the last checkpoint.
Fixes#740.
This is used in inputs (and can be used with extend) to ensure that
text does not change spacing when it changes. However, when doing so
it's important that the creator ensure there's enough space for
the text at all reasonable resolutions.
We had the problem that spacing tweaks would force characters to
the right, leaving space between the last character and this one.
This fix now stores these adjutments, and uses them to add an
extra pixel to underlines and strikeouts when necessary to
compensate for this kind of shift.
A function to get the properties passed to a widget. The main reason
for this is so that it can be passed to other widgets - for example,
the "who" widget's color can be used to set up a background.
It's possible for drawable-res text to be bigger or smaller than
the virtual-res box. This can lead to ugliness in text layout, as
centered text will not be centered, margins will be uneven, etc.
This fix adds code that adjust glyph placement to ensure the
drawable glyphs fill the same place as the physical glyphs,
using techniques similar to kerning and line_spacing.
The goal here is to retain the proportion of the various outlines, to
avoid the case where 1px and 2 px outlines, when scaled up by 1.5x,
become 1px and 3px, respectively.
Text drawn using the new rendering code can be drawn outside the
Render, due to the difference between virtual- and drawable-resolution
text layout. Subsurface would not crop to the intersection of the
crop-box and the render, which cut text off.
This changes to only crop to the crop-rect, which means that text
leaving the Render ist still drawn (as long as it's in the crop-rect).
See: http://lemmasoft.renai.us/forums/viewtopic.php?f=8&t=31311&start=120#p385132
A problem with the new text code is that the text can change its
virtual size. This can cause other layouts to jump around as the
screen is scaled.
To fix this, this change renders text twice, first at the virtual
size, and then at the drawable size. The first pass is used to
compute line breaking, and to get the size of the final Render.
Once that's done, the drawable size is used to draw cleaner text.
Fixes#728.
A possibly-focusable thing is a button/bar/etc that is currently
insensitive, but might change to become sensitive in the future.
We want to have those things reserve their place in the focus
order, so the thing with focus doesn't lose focus when
something else becomes focusable.
Fixes#725, maybe. This is my best guess as to what's going on
there.
This is another attempt to fix Nyaatrap's problem. It's now
easy to align to drawable - and even if this fails to fix
the problem because their card is broken, it should fall back
to a reasonable rendering.
This is intended to fix an issue reported by Nyaatrap, here:
http://lemmasoft.renai.us/forums/viewtopic.php?p=384227#p384227
where the new text rendering code would cause artifacts. My guess
is the artifacts were caused by rounding errors that meant the
text images were not the correct size. By drawing the screen
at the drawable resolution, we attempt to eliminate these
errors.
text.
This is almost always visually spurious, but can happen due to scaling
of of bounding boxes of ruby text. This prevents such scaling from
causing errors.
The problem was that IMAGEDISSOLVE would cause a render-to-texture,
which would use the buffer that is_pixel_opaque had been drawing
to, causing a problem.
We check for this case, and try again - there should be no
render-to-texture the second time around, since all such
rendering has been done.
This should make posting errors easier. Fixes#722.
Right now, this is only supported on windows/mac. Linux should work,
but appears to be having problems - perhaps with the relatively
large text pastes.
This is mostly used by drawable-resolution text. Before this change,
the text (which was not generally drawable-aligned) might have
been bilinearly interpolated, which is less than ideal.
This is a method that, given virtual coordinates, returns the virtual
coordinates of the closest point in drawable space. This will be used
to eventually drawable-align text, even if the natural blit point is
not an integer pixel.
Fixes#695.
The problem is that Ren'Py had no way of telling Transforms created by
an at-list from those supplied to renpy.show as input. The result is
that we'd get a stack of transforms, and then change the child the
entire stack, which could cause repeats in the transform stack
(see the bug).
This is fixed by wrapping Transforms passed to renpy.show in an
ImageReference, which makes it clear which are on the "outside"
and which are on the "inside" of the at_list.
Backup is done if script_version.{rpy,rpyc,txt} is not present,
and at least one .rpy file has changed (as compared to the
corresponding .rpyc files).
Backups are placed in the "backups" directory underneath the
user-global saves directory.
Fixes#687.
There are cases (including joysticks and touch events) where SDL2
generates multiple events for every event we're interested in. For
example, it generates a touch and mouse event for each touch. We
filter events to the list of events we're interested in.
When an image is zoomed down and the drawable screen is bigger than
the virtual screen, Ren'Py will draw the additional information
present in the image. This information was being lost during RTT
operations that occured at the virtual resolution. (This usually
manifested as a blurry dissolve.)
Now, RTT occurs at the drawable resolution, and so the information
is shown to the player.
This also adds the information needed to render text at drawable
resolution.
This is a way of creating a new screen language statement that
returns a creator-defined displayable.
This is necessary since register_sl_statement doesn't integrate
closely enough with SL to allow proper style handling while still
allowing the screen to be optimized.
This is a class that represents a color. While functioning as a
tuple, it also has methods and properties that allows one to
convert to and frop other color systems.
If the user is trying to edit a file but has selected the None
editor, they're probably questioning the wisdom of their initial
decision. Prompt again for their selection.
Reloading wouldn't do much, since the underlying files do not
change. Reloading also requires us to back up Ren'Py, which
is moderately expensive, so eliminating that reduces start
time.
This event is triggered when a screen is updated without being shown
or replacing another screen, such as when the game is loaded or when
styles or translations change.
This allows code to take a displayable or None, without having to
be enclosed in an if statement - it makes customizing screens a
little easier.
Fixes#677.
- Fixes purchasing, which was broken because the products weren't
being validated on startup.
- Improves things in general - iOS will now only prompt for the
username and password when the user actually enters the IAP
screen.
I noticed that Ren'py did not have any simplified-chinese template in
GitHub, only one in our local blog, made by a Chinese guy who didn't
want to upload his work to GitHub. So I made a translation for free and
uploaded to Git.
Moving the evaluation of arguments later meant persistent data
would be saved when the game quit. This fixes that by adding a
flag that controls if persistent data is saved.
Analyzing parameters multiple times caused the creation of a new
global_constant set each time. If that was changed by the
parameters, the analysis would never reach a fixed point,
causing an infinite loop.
This will ensure that the various .rpyb files are emptied of legacy
code, and that they all reflect the version of Ren'Py the game
has been built with.
Fixes#660.
At this point, the vast majority of the script load time is in the
unpickler - we're going to have to address that if we want the script
to load any faster.
This was causing pulseaudio to lock up in a rare circumstance, and
doesn't really do much positive good, as the audio system will
terminate as the process quits.
Closes#658.
try to quit while Pulseaudio is locked.
To replicate the lockup:
startx as two different users.
Do something that locks the sound card as user1 (say, playing a pile of mp3s
through mpg321)
As the other user, start and then quit a Ren'Py game.
Result: strace will show the Ren'Py game sitting there waiting indefinitely
for a futex until such time as mpg321 releases the sound card.
This makes the caching of the screen analysis relatively
safe - if the Ren'Py version or the screens/init code/whatever
changes, the analysis will be performed again.
(The only potential problem is if the creator conditions renpy.const
or renpy.pure on init code - and in that case, they deserve what's
going to happen.)
This avoids a problem where script_version is created on distribution,
requiring Ren'Py to load it in, thus causing the various caches to
have to be updated and rewritten.
This changes the way we execute SL2 to try and improve performance,
compared to the previous version. The two big changes are:
* Avoid copying screens just to analyze them, although we will
load a copy of the cached analysis.
* Avoid copying screens that are used or transcluded - instead,
we make two copies of the screen (one where the transclude is
const, and one where it's not) and use the appropriate one.
This change ensures that the variants are compiled all at once when
args.compile is true, which is necessary to ensure that all the code
is placed into the analysis and ast caches.
A DeltaSet stores the difference between its contents and an
underlying set. This makes the DeltaSet much smaller than the
backing set, making it easier to store and faster to pickle
and copy.
The cache directory is for generated files that speed up Ren'Py but
don't cause incorrect behavior when omitted, so it makes sense to
put bytecode.rpyb there.
This is intended for performance reasons. In a large game, it
reduces the time it takes to prepare screens from 4s to 1s.
(And the interim results can be stored on disk, perhaps.)
While rpyc1 only supported a single representation of the script,
rpyc2 supports multiple representations. This will make it possible to
store both the original script, and a transformed version of the
script - allowing us to avoid such transformations at runtime.
This defines a label in an init parser context, so that
the style/image/define/etc statements inside will only
be run if the label is called.
This is intended to be part of the new theme system, allowing
a theme to be defined using style statements. It's not intended
for creator use.
Previously, positions would be inherited between frames, but
because the order was wrong, a 1-frame delay occured. This
meat that there would be a 1-frame lag between a transition,
and that transition wrapped in a second transition.
Now, the two transitions will run in lockstep.
Fixes#632.
The default statement now runs after all rollbacks, not just loads.
It also stores the names of the default variables that have already
been set - this will allow a default to override a builtin present
in a future Ren'Py version.
Lastly, it checks for multiple defaults for a single variable, and
errors out if it finds them.
There are some exceptions that are very unlikely to be internal
to Ren'Py, and hence it makes sense to report them as part of
the script code that logically triggered the exception.
The previous volume control was simply wrong, as we used the volume
as the exponent, which meant there was a hard floor of .1. Now, we
use volume ** 2 as the multiplier, which sounds right to me and
allows adjustment all the way down to zero.
We've been having problems where rapt goes out of sync with Ren'Py.
This will detect that problem, and will prompt the user to upgrade
again if it happed.
At the very least, this should have the problem occur earlier, rather
than being a hard-to-diagnose Android problem.
Screen preparation is expensive, and needs to be done every time
styles are rebuilt. Previously, we had been rebuilding multiple
times in the start process. Now, on a normal start, we only
prepare once.
This required quite a bit of reorganization of init code, but
it should be worth it.
Previously, current_screen was not updated during focus operations.
This meant that in hovered and unhovered, actions like
SetScreenVariable could be applied to the wrong screen (basically,
whatever screen happened to be lying around after the event
processing or update cycle).
After this change, we track the current screen as we change focus,
and update current_screen appropriately.
Fixes#610.
There's no way returning a save is a good thing. There are functions
for that, and it could cause problems with code that looks at files
that may or may not be there.
Steam stats (get_int_stat and set_int_stat) have been unreliable on
windows. I'm not sure what the problem is, but this doesn't use
them.
I'll revisit this if it proves to be a steam problem.
In steam, to display progress, we have to update a progress stat
associated with an achievement. This new code does that as part
of the achievement system.
This uses the alpha channel from a mask displayable to mask a child
displayable. While this could be done with AlphaDissolve, this is
a little more efficient. (And could plausibly be made much more
efficient.)
Previously, we'd consider the first undefined image to be shown to be
a placeholder background - even if a non-placeholder background was
already showing.
Fixes#602.
This triggers a total download of the update. That's a pain and
consumes bandwidth, but it's what the user would have to do anyway
if the update fails.
Before this change, we only stored uses_scope on the outermost
constant displayable (in a constant subtree). But this meant that
in the copy_on_change case, only the outermost displayable in the
tree would be copied.
This fixes that, by recursively killing the constant stuff until
all the copy_on_change displayables that uses the changes scope
have been copied.
We don't want to mark a tree of displayables constant if a displayable
in that tree throws an error during prediction, since the tree will
be incomplete. (This is possible if the displayables in the tree
access missing non-parameter data, like a Text that interpolates a
missing variable.)
We propagate such fails up the tree of contexts, and do not allow
a SLDisplayable to become constant if a failure has occured.
It's possible for the number of particles to drop to 0 if all
particles fall off the screen, but we don't want to do the fast
behavior in that case - only during the initial show, when st is 0.
Fixes#572.
This means that for event handling to respond to a repeated key,
Ren'Py has to expect it - preventing things like a toggling tab
key from slowing down skipping.
For some reason, SteamAPI_RunCallbacks() crashes after a callback has
been run, on Windows only. This happens both with our callbacks, and
with those registered using CCallback.
Since callbacks don't add much in normal use cases, and hours of
work didn't lead to a fix, I've disabled the callback support.
- Pop return blindly pops things - which prevents problems if the return
label doesn't exist.
- When config.developer is true, we monitor for and try to fix call stack
corruption.
- When config.developer is false, we try to survive call stack corruption,
although this may lead to other errors.
If an imagemap statement is non-constant, neither are its hotspot
children. We need to re-evaluate the hotspot children whenever
the non-constant imagemap changes.
Fixes#567.
This fixes a problem reported where ATL was being compiled at screen
prediction time - which might be before variables used by the ATL block
have finished updating.
The fix was to compile non-constant ATL twice - first, during ATL
prediction, and then again once the ATL is ready to execute for
real.
PM: http://lemmasoft.renai.us/forums/ucp.php?i=pm&mode=view&f=0&p=163661
Parameterization (a terrible name) is used to reset transforms. In
cases where a single transform should be reset, a Fixed full of
tranforms should be replaced with a Fixed full of reset transforms.
(This is especially true for Fixeds created as part of a multiple
contains block in an ATL transform.)
These are redundant on SDL2, which will synthesize more appropriate
system events from the platform-specific keypresses. This redundancy
can cause problems - when we first synthesize a quit event from
alt-F4, and then get the real QUIT, we behave incorrectly.
Fixes#554.
Windows seems to generate a spurious 1x1 resize event after leaving
fullscreen, and the occasional spurious (though correct) resize when
entering and leaving fullscreen mode.
We use the size of the window to debounce these events.
Fixes#382.
Many power users have no need for the edit shortcuts in the launcher,
and in projects with a large number of script files hitting "edit all
script files" by accident can be annoying
This makes editing the files possible, since we now know where we can
insert new clauses at the end of a statement.
As part of this commit, we change how we remove CR from the file,
so we can get unicode-byte accurate locations within the file.
These new text tags process the token list, which makes it possible
to change tags and text to other things. (For example, we are now
able to make a rot13 text tag.)
Add the translation function _() to `raise UpdateError` strings because they are showed to the end user.
Don't know how this can be done in line 1030: `raise UpdateError("While unpacking {}, unknown type {}.".format(info.name, info.type))`
This ensures that Transforms used as children of Sprites maintain
their own state (or more precisely, all Transforms added in a
single frame will have a state different than Transforms from
other frames).
Fixes#529.
Previously we only stroked the outside border. This caused problems
when a portion of the character had an interior border on the
outside.
For example, we encountered a ? character where the top
part was outside and the bottom part was inside - it seems to
have something to do with the clockwise/counterclockwise order
of the font's control points.
The latter is a flag that determines if we're on android or ios,
inclusive. (These platforms tend to behave similarly, and different
from the desktop platforms.)
To reduce the size of the compiled library, we replace the use of
python properties for prefixed style properties with the __setattr__
and __delattr__ methods.
This shouldn't have much performance impact, as sets of style
properties should only occur in init code.
Now that we're wrapping the GL functions, all the functions in gl.pyx
have to exist. The gl1 functions are missing on GLES2 systems, which
means they can't exist in a file we use there. Hence breaking things
up into two files.
These (especially the timed variants) tend to disrupt
text-to-speech. It's best to just have them speak in a
single block, whih is closest to the human speech pattern.
Fixes#483.
This is a function that contacts an update server and determines
if there is an update available. It does this in a background thread,
so as to not make the game unresponsive.
We now simply deliver "appear", "show", and "hide" to the child,
rather than trying to exploit _hide. The advantage of doing it this
way is that we can preserve the hide state going into show, without
having to transfer it between transforms.
These functions were marked as pure, but weren't actually pure
functions, since the scope they update can change. This change
has them return objects, which are pure.
When a displayable in a screen that has focus/grab is replaced,
we transfer the focus to its replacement. This fixes a problem where
we would transfer grab only, which could lead to a permagrab condition.
Fixes#477.
It doesn't make sense for Play on the sound channel to participate
in get_selected(), since it's very likely the sound will quickly
end.
See: http://lemmasoft.renai.us/forums/ucp.php?i=pm&mode=view&f=0&p=148211
where Play causes Ren'Py to restart the interaction repeatedly.
Setting this property to False hides a button, bar, or hotspot from the
keyboard focus mechanism. This might be useful for games where we
want to hide interface from the user, like hidden object games.
It seems like SDL_image has problems reentrantly loading some
formats, certainly GIF and maybe TGA and BMP. So we whitelist
the common formats (png and jpeg), and lock loads of the rest.
Fixes#426.
They're really the same operation, except invalidation can be
run in the middle of a render. So let's check for that, and
use a single codepath.
This fixes a bug where when something was shown twice, the
invalidate could not take.
See: twelvethousand
The actions (at least the purchase action) requires us be interacting,
so we can go to sleep and let play services take over to handle the
actual transaction.
This requires us to interact in the middle of a callback, so we do
an invoke_in_new_context to make that possible.
The ATL time adjustments only make sense after take_execution_state.
If we're in a context where take_execution_state is never called,
we don't want to do the time adjustments.
So now, we make it a requirement that take_execution_state be called
before doing time adjustments.
Using the object id proved to be error prone when new objects were
created during each iteration of the list (something we support).
This also returns the behavior to what it was in 6.17.
See: Seasons of the Wolf.
We really should be propagating the transform state, but there
isn't really a good way to do that at the moment. (It isn't clear
where we'd store the old state.)
This is a reasonable, if ugly, workaround.
See: http://lemmasoft.renai.us/forums/ucp.php?i=pm&mode=view&f=0&p=147158
This is a function that munges a string beginning with __ in the
same manner that Ren'Py munges names when parsing a file.
jump __test
and:
jump expression renpy.munge("__test")
Previously, ATL transforms began executing when the screen containing
the ATL transform was first shown, which meant that if the transform
changed over the course of screen display, a portion of the new
transform would be skipped.
This prevents an error that was caused by when an exception in
finish_load would cause the .rpy file to load after finish_load
had already started updating data structures.
This displays a placeholder image. The image displayed may be chosen
by the creator, or automatically determined based on the name of the
image being placeheld.
We do this by cheating heavily - avoiding re-preparing screens, and
busting the render cache. This wouldn't work for arbitrary code,
but it's good enough for the theme chooser.
Where sl1 used structural equality to transfer state between
screens sharing the same tag, sl2 can't do that. (Doing so would
require maintaining _name, which is expensive.)
Instead, we allow uses of screens to include an id property,
which explcitly specifies equality of used screens.
By being a displayable, OnEvent is able to invoke actions even when
a screen is not being updated. This is important in the new version
of Ren'Py, which tries to avoid screen updates as much as possible.
While a reserved word, it's the sort of thing we didn't use much,
and that might be used a lot by end users. So we'll try to avoid
adding uses of type, prefering _type instead.
This is purely to make it possible to port sl1 games up to newer
Ren'Py, without rewriting them. This shouldn't be used in new games,
and may go away at some point.
When a parameter to a transition changes, we have a different
transition, so taking the state doesn't work - it means we will
be representing the state of a different transition.
This prevents us from copying transforms that already have had
take_execution_state called. This fixes a regression that caused
copied transforms to reset, and hence the show event to be fired
multiple times.
When the return site exists, we simply return to it. If the return
site disappears, we look up the call site, and return to the next
node, if one exists.
If we're in developer mode, we report an error at this
point. Otherwise, we pop the stack, and try again.
We now treat this as a mute, and do not play the voice file. This
prevents us from emphasizing voice when the user has disabled the
voice of a particular character.
When an emphasized channel is playing, all non-emphasized channels
have their volume lowered. When emphasis ends, the non-emphasized
channels resume their normal volume.
This is a generalization of (and replacement for) #360.
This will break existing games, by changing the volumes in a way
creators will not expect. Let's make this opt in across the board.
Removed it from the various templates since voice stuff is pretty
rarely used, and shouldn't required attention from a new user.
With the new screen system, it's now possible to reuse the same
displayable between two interactions. Such displayables need to
retain grab until they go away, or grab is explicitly released.
This fixes a problem where a constant bar would lose focus after being
adjusted in a way that restarts the interaction, as volume sliders do.
Previously, we were handling this in SDL. However, this conflicted
with the MOUSEMOTION merging - the other event could be moved before
the mouse release, leading to unsightly jumps, and (perhaps) the
viewport being in the wrong place.
We now synthesize the mouse release move in Ren'Py, which lets us
control the order in which it occurs.
Fixes#391.
We had been using the mouse to determine focus at the start of
each interaction. We now only use the mouse to determine focus
if the last event - the event that ended the interaction - was
a mouse event.
Fixes#299.
This includes:
* When predicting, we do not stop on the first exception. Instead, we
keep going, trying to predict what we can.
* This includes screen parameters and arguments as well.
* If we can't evaluate the list part of a for loop, we use [ 0 ] - in
conjunction with the error handling, this should get us
something. In many cases, it gets us everything important.
* Once per if statement, we predict all branches.
This fixes a regression that caused screens without hide transforms to
immediately become empty, even when they should have been used in an
old transition.
There are certain nodes that can't have keywords, like if nodes that
occur after a python statement that defines a variable used by the if
statement.
This change ensures that we only execute the keywords() method if:
* Some keywords are present.
* Nothing precludes the keywords method from running.
The screen's format may not be the for RGBA format we expect surfaces
to be in when we load them into textures. This would cause
FileCurrentScreenshot to break.
Fixes#314.
We would pass say_vbox_properties, which is only used in pre-screens
code. When iterating through a say_list containing multiple
lines of text, we could use say_args from a previous line.
This is optionally a function that returns the size of the OpenGL
viewport in which Ren'Py draws the game. Having this a callback makes
it possible to constrain the sizes of the game window.
For example, this makes it possible to limit the viewport to integer
multiples of the starting window size, as requested in #406.
These are functions to count the number of dialogue blocks and the
number of seen dialogue blocks in the game. This makes it possible
to give an indication of how much of the game text the player has
seen.
The focusable field was not being set correctly, which made the button
participate in the focus mechanism and get the idle background when
it should have been insensitive.
Used screens that take parameters now run isolated from their parent
context. This lets us treat global const variables as constant,
without having to worry about the parent scope redefining them.
Our definition of constant includes field access, indexing, etc. Since
a screens parameter might be mutable (a list, for example), we can't
treat it as const in the general case.
We can analyze parameterized screens more thoroughly than
non-parameterized screens, since the parameters limit what can
be overridden in the screens' scope.
Each product has a name, used to identify it. This name may be
different from the names used in the various app stores, which can be
specified independently.
The SL fixed statement was calling renpy.display.layout.Fixed with
the layout parameter. Since Fixed also supplied a layout parameter
we'd get a crash.
We had previously been assuming the audio started at 0, while
respecting the video PTS. If the PTS of the first video frame was
non-zero, this would lead to the video being delayed behind the audio
and never catching up.
Fixes#386.
This ensures that when we prepare screens - such as after a language
change - the cache is dropped. If we don't do this, sl2 can use old
values for displayable arguments and const displayables.
Do not mark transforms that aren't intended for use in screens - but
may have names that would be common for screen parameters - as const.
This should improve compatibility with older screens.
This is required so we can pass the layout argument to MultiBox,
which makes the distiniction between fixed, horizontal, and vertical
layouts when the style does not.
This allows one to navigate through all of the displayables on the
screen with the cursor keys, without having to do 2-d navigation,
which is what Ren'Py does by default.
Pyttsx would try to invoke TTS from the python process, which
required a ton of dependencies. (Pyobjc and win32api) We now
use subprocess to run platform-specific executables, passing
the text to speak on the commands line.
* Generate alt text only when voice is enabled.
* Allow the text of the children to be interpolated into alt text.
* Alt text for the preferences screen.
This required several fixes, including making sure copy_on_change works
and copying constant displayables if a change to the scope causes a Text
to change its contents.
fixed the path where Ren'Py had the wrong path for the arabic font AdvertisingBold.ttf which created an error message while trying to access "Options" from the inside the game.
This is a function that takes displayables that are being implicitly
added to a widget by ChildOrFixed. We do not want to copy transforms
added this way, which we had been doing, causing problems.
We now only use the newly-created boxes if at least one displayable
has changed. Otherwise, we don't bother, preferring to use the old
box (which likely has been cached).
Transform had a problem parsing arguments with underscores in the
name, like transform_anchor. That's been fixed.
Transform also did a lot of allocation for rare cases, such a
Transform being given an argument with a style prefix,
like hover_xpos. This has been optimized in order to reduce
the amount of allocation required.
This determines if events will be passed to the child of the
transform. This allows one to prevent events from being passed
to the old_widget in an ATL transform.
This is a behavior change, and a potentially dangerous one, since it
could execute arguments with side effects multiple times. But those
should be rare, this provides a nice performance boost, and users
will be able to disable prediction using the new nopredict clause.
There are a couple of caveats here, since non-ascii identifiers
can't be used in python code.
* The names must be defined with the define statement.
* The names can't be accessed in python code.
Stil, something like:
define 彁 = Character("Boy who is not able satisfactorily to explain what a Hrung is, nor why it should choose to collapse on Betelgeuse Seven")
彁 "Don't forget your towel."
should work.
Chinese_Simplified translation for ren'py launcher
Created by huanxuantian
Translate by huanxuantian
Translation version 1.3.b
update to github on 2014-5-25 sun
This restarts the interaction, and then reports the amount of time
it took to do so. This can give us an idea of how much (if any)
performance is being improved by the new screens code.
--compile compiles the script before doing anything else.
--lint is a backwards compatable way of invoking the lint
command. We've been parsing it as an argument for a while, but it
didn't work.
These are displayables that have constant arguments and constant
children, and hence where the same displayable can alwaye be used. We
use a very fast path for these displayables (simply retrieving them
from the cache), and avoid evaluating their children entirely.
Due to inheritance of SLBlocks, we had the problem that
frame:
textbutton "test" xysize (100, 100)
Would pass the xysize parameter to both the textbutton and the frame.
Viewport was broken with sl2, so we now have a compatible
implementation.
Several screen language things are implemented as composite
displayables. For example, a textbutton consists of a Text
and a Button, and a viewport scrollbars "both" consists of
a Side, two Bars, and a Viewport.
The main displayable (stored in _main on the outer displayable) is the
displayable we add children to, and return for get_widget.
This is a workaround for #351, which only seems to manifest on certain
Macs, and hence is proving hard to actually fix. At least with this
change, it will only show up when switching to Arabic. (And may not
show up at all, as it may have something to do with filesystem
encodings.)
Reusing a displayable is possible when we realize that the positional
and keyword arguments of the displayable are the same. We can also
reuse the transform if we apply the same transform to the
displayable.
This fixes an issue where renpy.pause(0) would effectively block
rollback, since there would be no time for the rollback to occur.
(The same issue occurs when pausing for a short time.)
This is a class that can be used to create sentinel objects. Even if
we pickle and unpickle an object of this class, it remains the same
object, as far as the 'is' operator is concerned.
This fixes a problem with the shift+R module backups. (The same
problem 9dec1f32ab tried to fix.)
The reload backup process would back up singletons, but not functions
and methods that used those singletons as default arguments. The
result was that the singletons would change identity, but not
the default arguments - and the code using them would fail in
odd ways.
An example problem this caused is
http://lemmasoft.renai.us/forums/viewtopic.php?p=320775#p320757 .
The major problem fixed here is one where if a transform was
replaced (like one in a screen would be), it would not know that
the old child was being shown. This would prevent the
"<displayable> with <transition>" ATL construct from doing
anything.
Fixes#340.
The raspi one somewhat works (it has problems, such as positioning the
window in the wrong place), but the slowness of the raspi system make
using it problematic.
The x11 mode hasn't been tested.
We now use the .report_traceback method whenever it's available to
produce nicer-looking tracebacks. (Previously, we only used it
for the simple tracebacks, and only for Contexts.)
The regression was introduced by dd4d3410a6,
and shows up in the Sunrider tutorial battle, when the PACT ships
attack with missiles.
The problem was that we were adjusting the times improperly - using
AdjustTimes to make the adjustment. Instead, we want the MultiBox
containing the layer to make the adjustment (which it does when
layer_name is set). This is because the MultiBox handles start
and animation times that are not the time at which the layer
was shown.
This doesn't support arguments yet, and passes everything through to
use_screen. But it does successfully let one include SL2 and SL1
screens inside an SL2 screen.
This queues an event by name. For example, renpy.queue_event("dismiss")
will act like dismiss has been pressed.
This is intended to make it easier to interface Ren'Py with custom
controllers.
The problem would manifest when we did something like
$ renpy.transition(move), and restarted the interaction. We had been
creating a MultiBox with a layers dict, which would adjust the times
for its children. When shown as part of the second interaction, the
times would be reset to 0, and the move would appear to restart.
By getting rid of the layers dict, we prevent this the adjustment
of times from occuring, and things work as expected.
This fixes a problem where we'd inherit padding from the button
style, which could cause the hotspots to show up in odd places.
This would only occur if ui.hotspot was called directly - so almost
never in actual code.
This is necessary for us to have imagemap statements. The imagemap
needs the keywords to be evaluated, and the imagemap needs to be
created before the keywords can be created.
The Applications folder in OS X is large and installers tend to expect apps to stay where they were placed (i.e. the root of /Applications). Since Lion, there's been application category metadata for View --> Arrange by Application Category but if the metadata's not in info.plist, the app gets sorted into "Other" at the bottom.
https://developer.apple.com/library/Mac/releasenotes/General/SubmittingToMacAppStore/#//apple_ref/doc/uid/TP40010572-CH16-SW8 (this applies to all Mac apps, not just those installed through App Store).
The style rewrite prevented direct access to prefixed styles,
which caused prediction not to work. With this change, we
handle the prediction in cython, which has access to
prefixed and unprefixed styles.
This can happen with some game changes, especially when changing
config.developer = True to False. Rather than crashing in this
case, we display an empty screen.
Fixes#320.
Constant positional arguments are evaluated during a prepare phase,
while non-constant arguments are evaluated at runtime. (When a mix
of arguments is given, they are combined.)
If we don't do this, the children will be shown at the timebase
of the layer at_list, which cause huge problems if the children
themselves are being transformed.
It does some wierd direct keyboard access stuff that might change
in future versions of windows or linux, so this seems like a
reasonable bit of paranoia.
This is a feature that scans for changes in file existence and times.
If a file changes, this triggers a restart of Ren'Py, reloading the
script and game.
Directories in the projects directory might contain filenames
that aren't representable in the system encoding. We now
ignore these directories, rather than throwing an exception.
We were already using window_during_transitions for an obsolete
function, and the preference controls all versions of this, rather
than just during transitions.
This is separating the two functions out, since window during
transitions is useful with window show/window hide, and the
auto function should probably trigger window show/window hide.
These allow users to directly set the size of resizable
displayables.
The names are chosen so they don't conflict with height, width, and
size, which are already in use.
To get the console to work, changed the developer menu into a modal
screen that runs in the current context. Changed everything else to
work with this.
Apart from a lot of writing, this consisted of breaking the style
docs up into two files, one for the statements and python, and
a second one for the properties.
This wraps the renpy.layer_at_list function, which allows one to apply
transforms to entire layers. The show layer statement currently takes
at lists and ATL.
A style is too complex if inheritance goes more than 100 layers
deep. The most common reason for this is likely that there's a
loop in the style inheritance graph.
A problem was reported that Ren'Py would crash on a shift+R
reload. It turned out that while displaying the reload message,
Ren'Py would use the attributes from the previous say statement.
This fixes that.
This does not rollback data that is changed between the current
statement and the next checkpoint. The main use case is to be able
to save while a screen is displayed using call screen.
For example, a user can be assigning points to a character in a
screen, save, load, and have the same points assigned.
This is needed because we might be killed by suspend. If we're killed,
we'll reload the game, but persistent data (incl preferences) will be
lost - unless we save it.
This is a method that, when called on a style, returns a list giving,
for each parent of the style:
* The name of the parent.
* A dictionary that, for each property that affects the inspected
style. gives the property name and its value.
This lets us use different styles for different variants. For example,
we can use a style for touch devices that increases the size of
buttons, so the player can touch them.
* Only set the style name if it's not already set. This is for
compatibility with the way the old style code did it.
* Do not auto-create styles beginning with _. This prevents us
from accidentally creating a style that inherits from a
non-underscore style.
* activate_sound and hover_sound are now their own style properties,
and work again.
* Other than that, we ignore the various selected_activate and activate_
style properties.
This was the music used (as a midi file) for the very oldest versions
of the Ren'Py.
We use a 1994 recording by the US Marine Band, taken from
Wikipedia. It's public domain due to age (of the original) and due to
being the work of the US Government (for the recording).
On Windows, RAPT is responsible for detecting the JDK. If RAPT is
missing, the JDK will also be reported missing - even if it's
installed.
Changing the reporting order makes this less confusing.
* Do not cycle saves if the user says no to quicksave.
* Rescan immediately after a save.
* Ensure scan_saved_game always returns a valid result.
Fixes#236, hopefully.
We remove one -O from the python command line. This prevents python
from removing docstrings, which means we can now use renpy.sh to
generate the documentation includes.
When the auto-save thread kicked off at the end of the game, it could
sit there waiting for a screenshot that would never be taken. This
fixes that, both by taking the screenshot and adding timeouts
that should prevent eternal pauses.
It's possible to have the launcher without the tutorial or vice versa,
and some Linux distros package Ren'Py in this way. Copying the font
file ensures we work in this case.
This will increase the size of the zip file, but probably not of
the 7z or tar.bz2.
When we get "None" as the name of the language to generate translation
for, we generate it for the None language. We only generate string
translations, as that's the only thing that makes sense to translate
in the None language.
Fixes#203.
`after_checkout.sh` has been using `readlink(1)` to get an absolute path (with
no symlinks) to the renpy root directory. Unfortunately, `readlink -f` is a
GNU extension, and thus unavailable on the BSDs, including OS X.
There are[0] a number of options for those systems. While an exec out to
Python seems like overkill (and is, in fact, a bit slow on my system), the
delay is small enough to not be a problem in a one-time script like this.
Additionally, it seemed silly to include a dozen-line shell function just for
this one usage. Plus, we know for certain the user has Python, because
otherwise they couldn't run Ren'Py. ;)
I included the parens around `print` just to make sure it works with both
Python 2.x and 3.x. I doubt this matters, but I figured I might as well.
If we stop caring about resolving symlinks, this entire line can be replaced
with `$PWD##*`. [1]
[0]: http://stackoverflow.com/q/1055671/120999
[1]: http://stackoverflow.com/a/1371283/120999
Some truetype fonts have bounding boxes that contain the origin. (This
may be becuase of font design, auto-hinthing, or anti-aliasing.) We
deal with these fonts by rendering all the available pixels, even
those to the left of the origin.
This may make the actual area drawn to the screen bigger than the
displayable itself, so we deal with that when necessary.
Fixes#34.
* Make the order more consistent.
* Add rollback ("Back")
* We don't need to make F.Skip so easy to disable - it's no worse
than normal skip when skip unseen is off.
Japanese doc information shouldn't be shown in Japanese, and it should be untranslatable text.
This commit adds two tags: language_LANGUAGE and gettext to support it.
Automatically saving persistent data may be too slow (and might cause
a laptop's hard drive to spin up), so we now save it at shutdown or
when renpy.save_persistent is called.
We also allow creators to register a merge function that's called when
loading updated persistence data from disk.
This provides a way to associate arbitrary information with Ren'Py
save files. (For example, we could store which character's route
we're on, or scoring information.)
This introduces config.save_json_callbacks, which contains callback
functions that add information to the json callbacks.
The new MultiLocation lets us save to multiple locations. We now save
both to the user's save directory and a game-local save directory.
Also, refactored the save location in FileLocation into its own
method.
While only used for saves at the moment, this system will eventually
let us use multiple locations.
This also introduces the SaveRecord object, which is where save data
is stored before we write it to disk.
Now that we're almost always running on a multi-core device, there's
little reason not to just run the auto-save thread whenever we want.
This also will make some of the new save stuff simpler.
Previously, were re-compiling the expressions each time the
ConditionSwitch ran, which was leading to performance problem
when there was an absurdly large number of conditions.
<p>To advance through the game, <tt>left-click</tt> or press the <tt>space</tt> or <tt>enter</tt> keys. When at a menu, <tt>left-click</tt> to make a choice, or use the arrow keys to select a choice and <tt>enter</tt> to activate it.</p>
<p><aname="Game_Menu"id="Game_Menu"></a></p>
<h3><spanclass="editsection">[<ahref="/w/index.php?title=renpy/Help&action=edit&section=2"title="Edit section: Game Menu">edit</a>]</span><spanclass="mw-headline">Game Menu</span></h3>
<p>When playing a game, <tt>right-click</tt> or press the <tt>escape</tt> key to enter the game menu. The game menu gives the following choices:</p>
<dl>
<dt>Return</dt>
<dd>Returns to the game.</dd>
<dt>Save Game</dt>
<dd>Allows you to save a game by clicking on a save slot.</dd>
<dt>Load Game</dt>
<dd>Allows you to load a game by clicking on a save slot. Clicking on "Auto" accesses the automatic save slots.</dd>
<dt>Preferences</dt>
<dd>Changes the game preferences (options/configuration):
<dl>
<dt>Display</dt>
<dd>Switches between fullscreen and windowed mode.</dd>
<dt>Transitions</dt>
<dd>Controls the display of transitions between game screens.</dd>
<dt>Text Speed</dt>
<dd>Controls the rate at which text displays. The further to the right this slider is, the faster the text will display. All the way to the right causes text to be shown instantly.</dd>
<dt>Joystick</dt>
<dd>Lets you control the game using a joystick.</dd>
<dt>Skip</dt>
<dd>Chooses between skipping messages that have been already seen (in any play through the game), and skipping all messages.</dd>
<dt>Begin Skipping</dt>
<dd>Returns to the game, while skipping.</dd>
<dt>After Choices</dt>
<dd>Controls if skipping stops upon reaching a menu.</dd>
<dt>Auto-Forward Time</dt>
<dd>Controls automatic advance. The further to the left this slider is, the shorter the amount of time before the game advances. All the way to the right means text will never auto-forward.</dd>
<dt>Music, Sound, and Voice Volume</dt>
<dd>Controls the volume of the Music, Sound effect, and Voice channels, respectively. The further to the right these are, the louder the volume.</dd>
</dl>
</dd>
</dl>
<dl>
<dt>Main Menu</dt>
<dd>Returns to the main menu, ending the current game.</dd>
<dt>Help</dt>
<dd>Shows this help screen.</dd>
<dt>Quit</dt>
<dd>Exits the game; the game will be closed and ended.</dd>
<h3><spanclass="editsection">[<ahref="/w/index.php?title=renpy/Help&action=edit&section=3"title="Edit section: Key and Mouse Bindings">edit</a>]</span><spanclass="mw-headline">Key and Mouse Bindings</span></h3>
<dl>
<dt>Left-click, Enter</dt>
<dd>Advances through the game, activates menu choices, buttons, and sliders.</dd>
<dt>Space</dt>
<dd>Advances through the game, but does not activate choices.</dd>
<dt>Arrow Keys</dt>
<dd>Selects menu choices, buttons, and sliders.</dd>
<dt>Ctrl</dt>
<dd>Causes skipping to occur while the ctrl key is held down.</dd>
<dt>Tab</dt>
<dd>Toggles skipping, causing it to occur until tab is pressed again.</dd>
<dt>Mousewheel-Up, PageUp</dt>
<dd>Causes rollback to occur. Rollback reverses the game back in time, showing prior text and even allowing menu choices to be changed.</dd>
<dt>Mousewheel-Down, PageDown</dt>
<dd>Causes rollforward to occur, cancelling out a previous rollback.</dd>
<dt>Right-click, Escape</dt>
<dd>Enters the game menu. When in the game menu, returns to the game.</dd>
<dt>Middle-click, H</dt>
<dd>Hides the text window and other transient displays.</dd>
<dt>F</dt>
<dd>Toggles fullscreen mode</dd>
<dt>S</dt>
<dd>Takes a screenshot, saving it in a file named screenshotxxxx.png, where xxxx is a serial number.</dd>
<dt>Alt-M, Command-H</dt>
<dd>Hides (iconifies) the window.</dd>
<dt>Alt-F4, Command-Q</dt>
<dd>Quits the game.</dd>
<dt>Delete</dt>
<dd>When a save slot is selected, deletes that save slot.</dd>
<p>This game uses source code from a number of open source projects. For a list, and a location where the source code can be downloaded from, please view the LICENSE.txt file in the renpy directory, or visit <ahref="http://www.renpy.org/wiki/renpy/License"class="external free"title="http://www.renpy.org/wiki/renpy/License"rel="nofollow">http://www.renpy.org/wiki/renpy/License</a> .</p>
<h3>Controller Support and Bindings</h3>
<p>
This game should automatically detect and use game controllers supported by
SDL2. Other controllers can be configured using third-party configuration tools
like the <ahref="http://www.generalarcade.com/gamepadtool/">SDL2 Gampad Tool</a>
</p>
<p>
A small number of systems may have problems using detected game controllers. Should
that happen, hold down shift as the game starts, and disable the controller support.
</p>
<p>The following bindings are used:</p>
<dl>
<dt>Right Trigger, A (Bottom Button)</dt>
<dd>Advances through the game, activates menu choices, buttons, and sliders.</dd>
<dt>Guide, Start</dt>
<dd>Enters the game menu. When in the game menu, returns to the game.</dd>
<dt>Directional Pad, Analog Sticks</dt>
<dd>Navigates between menu choices, buttons, and sliders.</dd>
<dt>Left Trigger, Left Shoulder, Back</dt>
<dd>Causes rollback to occur. Rollback reverses the game back in time, showing prior text and even allowing
menu choices to be changed.</dd>
<dt>Right Shoulder</dt>
<dd>Causes rollforward to occur, canceling out a previous rollback.</dd>
<dt>Y (Top Button)</dt>
<dd>Hides the text window and other transient displays.</dd>
</dl>
<h2>Legal Notice</h2>
<p>
This program contains free software licensed under a number of licenses, including the GNU Lesser Public License. A
complete list of software is available at <ahref="http://www.renpy.org/doc/html/license.html">http://www.renpy.org/doc/html/license.html</a>.
contents += _("# Ren'Py automatically loads all script files ending with .rpy. To use this\n# file, define a label and jump to it from another file.\n")
contents += "\n"
try:
os.makedirs(dir)
except:
pass
contents = u"\uFEFF"
contents += _("# Ren'Py automatically loads all script files ending with .rpy. To use this\n# file, define a label and jump to it from another file.\n")
# Copyright 2004-2015 Tom Rothamel <pytom@bishoujo.us>
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
init python:
ANDROID_NO_RAPT = 0
ANDROID_NO_JDK = 1
ANDROID_NO_SDK = 2
ANDROID_NO_KEY = 3
ANDROID_NO_CONFIG = 4
ANDROID_OK = 5
NO_RAPT_TEXT = _("To build Android packages, please download RAPT, unzip it, and place it into the Ren'Py directory. Then restart the Ren'Py launcher.")
NO_JDK_TEXT = _("A 32-bit Java Development Kit is required to build Android packages on Windows. The JDK is different from the JRE, so it's possible you have Java without having the JDK.\n\nPlease {a=http://www.oracle.com/technetwork/java/javase/downloads/index.html}download and install the JDK{/a}, then restart the Ren'Py launcher.")
NO_SDK_TEXT = _("RAPT has been installed, but you'll need to install the Android SDK before you can build Android packages. Choose Install SDK to do this.")
NO_KEY_TEXT = _("RAPT has been installed, but a key hasn't been configured. Please create a new key, or restore android.keystore.")
NO_CONFIG_TEXT = _("The current project has not been configured. Use \"Configure\" to configure it before building.")
OK_TEXT = _("Choose \"Build\" to build the current project, or attach an Android device and choose \"Build & Install\" to build and install it on the device.")
PHONE_TEXT = _("Attempts to emulate an Android phone.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button.")
TABLET_TEXT = _("Attempts to emulate an Android tablet.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button.")
OUYA_TEXT = _("Attempts to emulate a televison-based Android console, like the OUYA or Fire TV.\n\nController input is mapped to the arrow keys, Enter is mapped to the select button, Escape is mapped to the menu button, and PageUp is mapped to the back button.")
INSTALL_SDK_TEXT = _("Downloads and installs the Android SDK and supporting packages. Optionally, generates the keys required to sign the package.")
CONFIGURE_TEXT = _("Configures the package name, version, and other information about this project.")
PLAY_KEYS_TEXT = _("Opens the file containing the Google Play keys in the editor.\n\nThis is only needed if the application is using an expansion APK. Read the documentation for more details.")
BUILD_TEXT = _("Builds the Android package.")
BUILD_AND_INSTALL_TEXT = _("Builds the Android package, and installs it on an Android device connected to your computer.")
BUILD_INSTALL_AND_LAUNCH_TEXT = _("Builds the Android package, installs it on an Android device connected to your computer, then launches the app on your device.")
CONNECT_TEXT = _("Connects to an Android device running ADB in TCP/IP mode.")
DISCONNECT_TEXT = _("Disconnects from an Android device running ADB in TCP/IP mode.")
LOGCAT_TEXT = _("Retrieves the log from the Android device and writes it to a file.")
$ interface.yesno(_("Before packaging Android apps, you'll need to download RAPT, the Ren'Py Android Packaging Tool. Would you like to download RAPT now?"), no=Jump("front_page"))
_("Please enter the IP address and port number to connect to, in the form \"192.168.1.143:5555\". Consult your device's documentation to determine if it supports remote ADB, and if so, the address and port to use."),
default=address,
cancel=Jump("android"),
)
address = address.strip()
try:
host, port = address.split(":")
except:
interface.error(_("Invalid remote ADB address"), _("The address must contain one exactly one ':'."), label=None)
continue
if " " in host:
interface.error(_("Invalid remote ADB address"), _("The host may not contain whitespace."), label=None)
continue
try:
int(port)
except:
interface.error(_("Invalid remote ADB address"), _("The port must be a number."), label=None)
interface.error(_("Ren'Py was unable to run python with tkinter to choose the directory. Please install the python-tk or tkinter package."), label=None)
if code:
interface.error(_("Ren'Py was unable to run python with tkinter to choose the directory. Please install the python-tk or tkinter package."), label=None)
interface.processing(_("Adding from clauses to call statements that do not have them."))
project.current.launch([ "add_from" ], wait=True)
return
label add_from:
call add_from_common
jump build_distributions
label start_distribute:
if project.current.data["add_from"]:
call add_from_common
jump distribute
label build_update_dump:
python:
project.current.update_dump(True)
if project.current.dump.get("error", False):
interface.error(_("Errors were detected when running the project. Please ensure the project runs without errors before building distributions."))
return
label build_distributions:
call build_update_dump
if not project.current.dump["build"]["directory_name"]:
jump build_missing
call screen build_distributions
label build_missing:
python hide:
interface.yesno(_("Your project does not contain build information. Would you like to add build information to the end of options.rpy?"), yes=Return(True), no=Jump("front_page"))
renpy.invoke_in_new_context(interface.error, _("An exception occured while launching the text editor:\n[exception!q]"), error_message, exception=exception)
renpy.invoke_in_new_context(interface.error, _("An exception occured while launching the text editor:\n[exception!q]"), error_message, exception=exception)
class EditAll(Action):
"""
Opens all scripts that are part of the current project in a web browser.
"""
alt = "Edit [text]."
def __init__(self):
return
def __call__(self):
if not check_editor():
return
scripts = project.current.script_files()
scripts = project.current.script_files()
scripts = [ i for i in scripts if not i.startswith("game/tl/") ]
scripts.sort(key=lambda fn : fn.lower())
@@ -349,12 +428,12 @@ init python in editor:
if fn in scripts:
scripts.remove(fn)
scripts.insert(0, fn)
try:
e = renpy.editor.editor
e.begin()
for fn in scripts:
fn = project.current.unelide_filename(fn)
e.open(fn)
@@ -366,56 +445,54 @@ init python in editor:
renpy.invoke_in_new_context(interface.error, _("An exception occured while launching the text editor:\n[exception!q]"), error_message, exception=exception)
screen editor:
frame:
style_group "l"
style "l_root"
window:
has vbox
label _("Select Editor")
add HALF_SPACER
hbox:
frame:
style "l_indent"
xfill True
viewport:
scrollbars "vertical"
mousewheel True
has vbox
text _("A text editor is the program you'll use to edit Ren'Py script files. Here, you can select the editor Ren'Py will use. If not already present, the editor will be automatically downloaded and installed.") style "l_small_text"
# Copyright 2004-2015 Tom Rothamel <pytom@bishoujo.us>
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
init python:
IOS_NO_RENIOS = 0
IOS_NO_DIRECTORY = 1
IOS_NO_PROJECT = 2
IOS_OK = 3
IOS_NO_RENIOS_TEXT = _("To build iOS packages, please download renios, unzip it, and place it into the Ren'Py directory. Then restart the Ren'Py launcher.")
IOS_NO_DIRECTORY_TEXT = _("The directory in where Xcode projects will be placed has not been selected. Choose 'Select Directory' to select it.")
IOS_NO_PROJECT_TEXT = _("There is no Xcode project corresponding to the current Ren'Py project. Choose 'Create Xcode Project' to create one.")
IOS_OK_TEXT = _("An Xcode project exists. Choose 'Update Xcode Project' to update it with the latest game files, or use Xcode to build and install it.")
IPHONE_TEXT = _("Attempts to emulate an iPhone.\n\nTouch input is emulated through the mouse, but only when the button is held down.")
IPAD_TEXT = _("Attempts to emulate an iPad.\n\nTouch input is emulated through the mouse, but only when the button is held down.")
IOS_SELECT_DIRECTORY_TEXT = _("Selects the directory where Xcode projects will be placed.")
IOS_CREATE_PROJECT_TEXT = _("Creates an Xcode project corresponding to the current Ren'Py project.")
IOS_UPDATE_PROJECT_TEXT = _("Updates the Xcode project with the latest game files. This must be done each time the Ren'Py project changes.")
IOS_XCODE_TEXT = _("Opens the Xcode project in Xcode.")
IOS_OPEN_DIRECTORY_TEXT = _("Opens the directory containing Xcode projects.")
$ interface.yesno(_("Before packaging iOS apps, you'll need to download renios, Ren'Py's iOS support. Would you like to download renios now?"), no=Jump("front_page"))
$ add_dlc("renios", restart=True)
call screen ios
label select_xcode_projects_directory:
python hide:
interface.interaction(_("XCODE PROJECTS DIRECTORY"), _("Please choose the Xcode Projects Directory using the directory chooser.\n{b}The directory chooser may have opened behind this window.{/b}"))
text _("Please select a template to use for your new project. Ren'Py ships with a default template that creates an English-language game with standard screens.")
text _("Please select a template to use for your new project. The template sets the default font and the user interface language. If your language is not supported, choose 'english'.")
interface.interaction(_("PROJECTS DIRECTORY"), _("Please choose the projects directory using the directory chooser.\n{b}The directory chooser may have opened behind this window.{/b}"), _("This launcher will scan for projects in this directory, will create new projects in this directory, and will place built projects into this directory."),)
old "To build Android packages, please download RAPT (from {a=http://www.renpy.org/dl/android}here{/a}), unzip it, and place it into the Ren'Py directory. Then restart the Ren'Py launcher."
new "لتجهيز اللعبة للعمل على اجهزة اندرويد يمكنك تحميل الحزمة الخاصة بذلك {a=http://www.renpy.org/dl/android}here{/a}) و فك الضغط عنها, ثم نسخها إلى مجلد رينباي الرئيسي ثم إعادة فتح هذا المشغِّل."
# game/android.rpy:13
old "RAPT has been installed, but you'll need to install the Android SDK before you can build Android packages. Choose Install SDK to do this."
new "حزمة الاندرويد RAPT موجوده, لكنك تحتاج لتنصيب Android SDK قبل ان تبدأ بتجهيز حزم للعمل على اندرويد. الرجاء اختيار تنصيب Android SDK لتستطيع ذلك."
# game/android.rpy:14
old "RAPT has been installed, but a key hasn't been configured. Please create a new key, or restore android.keystore."
new "حزمة اندرويد RAPT موجوده, لكن المفتاح لم يتم تجهيزه. الرجاء تكوين مفتاح جديد او استرجاع android.keystore"
# game/android.rpy:15
old "The current project has not been configured. Use \"Configure\" to configure it before building."
new "المشروع الحالي لم يتم تجهيز إعدادته. الرجاء اختيار \"Configure\" لتقوم بتجهيزها قبل بناء الحزمة."
# game/android.rpy:16
old "Choose \"Build\" to build the current project, or attach an Android device and choose \"Build & Install\" to build and install it on the device."
new "قم باختيار زر \"Build\" لتقوم بتجهيز المشروع الحالي إلى حزمة قابلة للعمل على اندرويد. او قم بربط جهاز اندرويد و اختيار \"Build & Install\" ليتم تنصيبها مباشرة على الجهاز المطلوب."
# game/android.rpy:18
old "Attempts to emulate an Android phone.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "يقوم بمحاكاة جهاز اندرويد هاتفي محمول. \n\n خاصية اللمس يتم محاكاتها عبر مؤشر الفأره, لكن فقط حين يكون زر الفأره مضغوطاً. زر الخروج يقوم باستدعاء نافذة القائمة الرئيسية, و PageUp هو زر العودة إلى الوراء."
# game/android.rpy:19
old "Attempts to emulate an Android tablet.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "يقوم بمحاكاة جهاز اندرويد تابلت. \n\n خاصية اللمس يتم محاكاتها عبر مؤشر الفأره, لكن فقط حين يكون زر الفأره مضغوطاً. زر الخروج يقوم باستدعاء نافذة القائمة الرئيسية, و PageUp هو زر العودة إلى الوراء"
# game/android.rpy:20
old "Attempts to emulate an OUYA console.\n\nController input is mapped to the arrow keys, Enter is mapped to the select button, Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "يقوم بمحاكاة جهاز Ouya. \n\n يد التحكم تتم محاكاتها بأزرار الإتجاهات, زر الإدخال يحاكي select, زر الخروج يحاكي زر menu, و PageUp يحاكي زر العودة."
# game/android.rpy:22
old "Downloads and installs the Android SDK and supporting packages. Optionally, generates the keys required to sign the package."
new "يقوم بتحميل و تنصيب Android SDK والحزم المساندة لها. يعطيك خيار تكوين المفاتيح المطلوبة لتتمكن من استعمال الحزمة."
# game/android.rpy:23
old "Configures the package name, version, and other information about this project."
new "يقوم بتجهيز إعدادات الحزمة, رقم النسخة, و معلومات أخرى تتعلق بهذا المشروع."
# game/android.rpy:24
old "Opens the file containing the Google Play keys in the editor.\n\nThis is only needed if the application is using an expansion APK. Read the documentation for more details."
new "يفتح الملف الخاص بمعلومات مفتاح Google Play في محرر النصوص. \n\n هذه الخطوة غير مطلوبة إلا لو كان البرنامج يحتاج إحدى الحوم المساندة expansion APK. الرجاء الإطلاع على ملفات المساعدة للحصول على المزيد من المعلومات."
# game/android.rpy:25
old "Builds the Android package."
new "يقوم ببناء حزمة للأندرويد."
# game/android.rpy:26
old "Builds the Android package, and installs it on an Android device connected to your computer."
new "يقوم ببناء حزمة للأندرويد, ثم يقوم بتنصيبها على جهاز أندرويد المتصل بحاسوبك."
# game/android.rpy:142
old "{a=%s}%s{/a}"
new "{a=%s}%s{/a}"
# game/android.rpy:361
old "Android: [project.current.name!q]"
new "أندرويد: [project.current.name!q]"
# game/android.rpy:381
old "Emulation:"
new "محاكاة"
# game/android.rpy:389
old "Phone"
new "هاتف"
# game/android.rpy:393
old "Tablet"
new "تابلت/ لوحي"
# game/android.rpy:397
old "Television / OUYA"
new "تلفزيون / OUYA"
# game/android.rpy:409
old "Build:"
new "بناء"
# game/android.rpy:417
old "Install SDK & Create Keys"
new "تنصيب SDK و اختلاق مفاتيح"
# game/android.rpy:421
old "Configure"
new "إعدادات"
# game/android.rpy:425
old "Build Package"
new "بناء الحزمة"
# game/android.rpy:429
old "Build & Install"
new "بناء و تنصيب"
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# game/android.rpy:30
old "To build Android packages, please download RAPT, unzip it, and place it into the Ren'Py directory. Then restart the Ren'Py launcher."
new "لبناء ملفات الأندرويد, الرجاء تحميل RAPT, ثم فك الضغط عن الملف ووضعه في مجلد رينباي. قد تحتاج لإعادة تشغيل رينباي ليعمل بشكل صحيح."
# game/android.rpy:31
old "A 32-bit Java Development Kit is required to build Android packages on Windows. The JDK is different from the JRE, so it's possible you have Java without having the JDK.\n\nPlease {a=http://www.oracle.com/technetwork/java/javase/downloads/index.html}download and install the JDK{/a}, then restart the Ren'Py launcher."
new "تحتاج لنسخة برمجية من جافا تعتمد الـ 32-بت لتستطيع إنشاء ملفات الأندرويد على نظام الوندوز. حزمة JDK تختلف عن JRE, قد تكون الجافا لديك موجوده لكنها تفتقد الـ JDK. \n\n الرجاء {a=http://www.oracle.com/technetwork/java/javase/downloads/index.html}تحميل و تنصيب JDK{/a} ثم إعادة تشغيل رينباي"
# game/android.rpy:39
old "Attempts to emulate a televison-based Android console, like the OUYA or Fire TV.\n\nController input is mapped to the arrow keys, Enter is mapped to the select button, Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "يحاول محاكاة نظام تلفزيوني للأندرويد مثل جهاز OUYA او Fire TV. \n\n يتم تخطيط الأزرار لعصا التحكم لتناسب ازرار جهاز التحكم عن بعد. Controller input is mapped to the arrow keys, Enter is mapped to the select button, Escape is mapped to the menu button, and PageUp is mapped to the back button."
# game/android.rpy:47
old "Connects to an Android device running ADB in TCP/IP mode."
new "يتصل بجهاز أندرويد يعمل على نظام ADB عن طريق TCP/IP mode"
# game/android.rpy:48
old "Disconnects from an Android device running ADB in TCP/IP mode."
new "يفصل الاتصال عن جهاز أندرويد يعمل على نظام ADB عن طريق TCP/IP mode"
# game/android.rpy:516
old "Other:"
new "آخر:"
# game/android.rpy:524
old "Remote ADB Connect"
new "الإتصال عن بعد عن طريق ADB"
# game/android.rpy:528
old "Remote ADB Disconnect"
new "قطع إتصال ADB عن بعد"
# game/android.rpy:561
old "Before packaging Android apps, you'll need to download RAPT, the Ren'Py Android Packaging Tool. Would you like to download RAPT now?"
new "قبل ان تصتطيع إنشاء ملفات للأندرويد, عليك ان تقوم بتحميل ملفات RAPT الخاصة بتحويل ملفات رينباي للأندرويد. هل تريد ان تقوم بتحميل الحزمة الآن؟"
# game/android.rpy:608
old "Remote ADB Address"
new "عنوان ADB عن بعد"
# game/android.rpy:609
old "Please enter the IP address and port number to connect to, in the form \"192.168.1.143:5555\". Consult your device's documentation to determine if it supports remote ADB, and if so, the address and port to use."
new "الرجاء إدخال عنوان الأي بي ورقم المنفذ المطلوب للإتصال, على شكل \"192.168.1.143:5555\". الرجاء العودة لدليل المستخدم الخاص بجهازك لتعرف إن كان يدعم الإتصال عن بعد للـ ADB و إن كان قادراً على ذلك, ستجد العنوان و المنفذ المطلوبان."
# game/android.rpy:619
old "Invalid remote ADB address"
new "عنوان ِADB خاطيء"
# game/android.rpy:619
old "The address must contain one exactly one ':'."
new "العنوان يجب ان يحتوي على علامة ':' واحده فقط لا غير"
# game/android.rpy:623
old "The host may not contain whitespace."
new "الخادم يجب ان لا يحتوي على مساحات فارغة"
# game/android.rpy:629
old "The port must be a number."
new "يجب ان يكون العنوان مكون من أرقام فقط"
translate arabic strings:
# game/android.rpy:46
old "Builds the Android package, installs it on an Android device connected to your computer, then launches the app on your device."
new "يبني الحزمة الخاصة بالأندرويد و يقوم بتنصيبها على جهاز أندرويد متصل بجهازك, ثم يقوم بإقلاع البرنامج على جهاز الأندرويد."
# game/android.rpy:290
old "Television"
new "تلفاز"
# game/android.rpy:326
old "Build, Install & Launch"
new "بناء,تنصيب و إقلاع."
# : Translation updated at 2015-06-19 08:55
translate arabic strings:
# game/android.rpy:50
old "Retrieves the log from the Android device and writes it to a file."
new "يجلب قائمة المهام من جعاز الأندرويد و يكتبها في ملف."
# game/android.rpy:240
old "Copying Android files to distributions directory."
new "يتم الآن نسخ ملفات الأندرويد إلى المجلد الخاص بالنشر"
new "فرض استعمال المحركات البرمجية software renderer"
# renpy/common/00gltest.rpy:73
old "Changes will take effect the next time this program is run."
new "سيتم تفعيل التغييرات في المرة القادمة التي تفتح فيها البرنامج"
# renpy/common/00gltest.rpy:77
old "Quit"
new "خروج"
# renpy/common/00gltest.rpy:82
old "Return"
new "عودة"
# renpy/common/00gltest.rpy:112
old "Performance Warning"
new "تحذير عن الأداء"
# renpy/common/00gltest.rpy:117
old "This computer is using software rendering."
new "هذا الجهاز يستعمل software rendering"
# renpy/common/00gltest.rpy:119
old "This computer is not using shaders."
new "هذا الجهاز لا يستعمل shaders"
# renpy/common/00gltest.rpy:121
old "This computer is displaying graphics slowly."
new "هذا الجهاز يستعرض الرسوميات بشكل بطيء"
# renpy/common/00gltest.rpy:123
old "This computer has a problem displaying graphics: [problem]."
new "هذا الجهاز يواجه مشكلة في استعراض الرسوميات [problem]"
# renpy/common/00gltest.rpy:128
old "Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display. Updating DirectX could fix this problem."
new "محركات الرسوميات قد تكون قديمة او لا تعمل بشكل صحيح. قد يسبب ذلك بطء او اخطاء في الاستعراض, القيام بتحديث directX قد يساعد في حل المشكلة."
# renpy/common/00gltest.rpy:130
old "Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display."
new " محركات الرسوميات قد تكون قديمة او لا تعمل بشكل صحيح. قد يسبب ذلك بطء او اخطاء في الاستعراض."
# renpy/common/00gltest.rpy:135
old "Update DirectX"
new "تحديث DirectX"
# renpy/common/00gltest.rpy:141
old "Continue, Show this warning again"
new "استمرار, الرجاء عرض هذا التحذير في المرة الثادمة ايضاً"
# renpy/common/00gltest.rpy:145
old "Continue, Don't show warning again"
new "استمرار, لا تعرض هذا التحذير مرة اخرى"
# renpy/common/00gltest.rpy:171
old "Updating DirectX."
new "يتم تحديث DirectX"
# renpy/common/00gltest.rpy:175
old "DirectX web setup has been started. It may start minimized in the taskbar. Please follow the prompts to install DirectX."
new "يتم الآن تنصيب DirectX, قد يبدأ ذلك بشكل مصغر في شريط المهام. الرجاء اتباع التعليمات لاكمال التنصيب."
# renpy/common/00gltest.rpy:179
old "{b}Note:{/b} Microsoft's DirectX web setup program will, by default, install the Bing toolbar. If you do not want this toolbar, uncheck the appropriate box."
new "{b}ملاحظة:{/b} مايكروسوفت دايركت أكس يقوم تلقائياً بتنصيب شريط بينق Bing toolbar. إذا لم ترغب بذلك الرجاء القيام بإلغاء تحديد خانة الاختيار"
# renpy/common/00gltest.rpy:183
old "When setup finishes, please click below to restart this program."
new "حيثن ينتهي التنصيب, الرجاء الضغط ادناه لإعادة تشغيل البرنامج"
# renpy/common/00gltest.rpy:185
old "Restart"
new "إعادة تشغيل"
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/00keymap.rpy:167
old "Saved screenshot as %s."
new "تم حفظ الصورة كـ %s"
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/00layout.rpy:421
old "Are you sure?"
new "هل انت متأكد؟"
# renpy/common/00layout.rpy:422
old "Are you sure you want to delete this save?"
new "هل انت متأكد من رغبتك في حذف خانة الحفظ هذه؟"
# renpy/common/00layout.rpy:423
old "Are you sure you want to overwrite your save?"
new "هل انت متأكد من رغبتك في الحفظ على هذه الخانة؟"
# renpy/common/00layout.rpy:424
old "Loading will lose unsaved progress.\nAre you sure you want to do this?"
new "الاسترجاع سيضيع كل ما فعلته منذ خانة الحفظ السابقة. \n هل انت متأكد من رغبتك في الاسترجاع إلى هذه النقطة؟"
# renpy/common/00layout.rpy:425
old "Are you sure you want to quit?"
new "هل انت متأكد من رغبتك في الخروج؟"
# renpy/common/00layout.rpy:426
old "Are you sure you want to return to the main menu?\nThis will lose unsaved progress."
new "هل انت متأكد من رغبتك في العودة للقائمة الرئيسية؟ \n كل ما لم تقم بحفظة سيضيع."
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/00library.rpy:77
old "Skip Mode"
new "وضع التسريع"
# renpy/common/00library.rpy:80
old "Fast Skip Mode"
new "وضع التسريع السريع"
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/00updater.rpy:1258
old "Updater"
new "برنامج التحديث"
# renpy/common/00updater.rpy:1267
old "This program is up to date."
new "هذه النسخة هي الأحدث"
# renpy/common/00updater.rpy:1269
old "[u.version] is available. Do you want to install it?"
new "النسخة [u.version] متوفرة, هل ترغب في تنصيبها؟"
# renpy/common/00updater.rpy:1271
old "Preparing to download the updates."
new "يتم التجهيز لتحميل البرنامج من الانترنت"
# renpy/common/00updater.rpy:1273
old "Downloading the updates."
new "يتم تنزيل التحديثات"
# renpy/common/00updater.rpy:1275
old "Unpacking the updates."
new "يتم فك الضغط عن التحديثات"
# renpy/common/00updater.rpy:1279
old "The updates have been installed. The program will restart."
new "تم التحديث.. سيتم إعادة تشغيل البرنامج."
# renpy/common/00updater.rpy:1281
old "The updates have been installed."
new "تم التحديث."
# renpy/common/00updater.rpy:1283
old "The updates were cancelled."
new "تم إلغاء التحديث."
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/_compat/gamemenu.rpym:180
old "Empty Slot."
new "خانة فارغة"
# renpy/common/_compat/gamemenu.rpym:337
old "Previous"
new "السابق"
# renpy/common/_compat/gamemenu.rpym:344
old "Next"
new "التالي"
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/_compat/preferences.rpym:411
old "Joystick Mapping"
new "خيارات عصى التحكم"
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/_errorhandling.rpym:408
old "An exception has occurred."
new "حصل استثناء"
# renpy/common/_errorhandling.rpym:434
old "Rollback"
new "تراجع"
# renpy/common/_errorhandling.rpym:436
old "Attempts a roll back to a prior time, allowing you to save or choose a different choice."
new "يقوم بالتراجع لنقطة سابقة لكي تستطيع اختيار شيء آخر"
# renpy/common/_errorhandling.rpym:439
old "Ignore"
new "تجاهل"
# renpy/common/_errorhandling.rpym:441
old "Ignores the exception, allowing you to continue. This often leads to additional errors."
new "يتجاهل الاستثناء مما يستمح لك بالاستمرار. قد يسبب هذا المزيد من الاخطاء."
# renpy/common/_errorhandling.rpym:444
old "Reload"
new "إعادة المحاولة"
# renpy/common/_errorhandling.rpym:446
old "Reloads the game from disk, saving and restoring game state if possible."
new "يعيد تشغيل اللعبة من القرص الصلب, مع محاولة استعمادة آخر نقطة وحفظها عند الإستطاعة."
# renpy/common/_errorhandling.rpym:448
old "Open Traceback"
new "قراءة التقرير"
# renpy/common/_errorhandling.rpym:450
old "Opens the traceback.txt file in a text editor."
new "يفتح تقرير الخطأ في برنامج الملفات النصية."
# renpy/common/_errorhandling.rpym:456
old "Quits the game."
new "يخرج من اللعبة."
# renpy/common/_errorhandling.rpym:483
old "Parsing the script failed."
new "حصل خطأ أثناء تشغيل النص."
# renpy/common/_errorhandling.rpym:510
old "Open Parse Errors"
new "يفتح قائمة اخطاء التشغيل."
# renpy/common/_errorhandling.rpym:512
old "Opens the errors.txt file in a text editor."
new "يفتح ملف errors.txt في برنامج الملفات النصية"
# : Translation updated at 2013-04-30 07:54
translate arabic strings:
# renpy/common/_layout/classic_load_save.rpym:152
old "a"
new "a"
# renpy/common/_layout/classic_load_save.rpym:161
old "q"
new "q"
# : Translation updated at 2013-11-17 23:18
translate arabic strings:
# renpy/common/00action_file.rpy:587
old "Quick save complete."
new "تم الحفظ السريع بنجاح"
# : Translation updated at 2013-11-17 23:18
translate arabic strings:
# renpy/common/00gallery.rpy:521
old "Image [index] of [count] locked."
new "يوجد عدد صور [index] من أصل [count] مقفل"
# renpy/common/00gallery.rpy:539
old "prev"
new "السابق"
# renpy/common/00gallery.rpy:540
old "next"
new "التالي"
# renpy/common/00gallery.rpy:541
old "slideshow"
new "عرض الشرائح"
# renpy/common/00gallery.rpy:542
old "return"
new "العودة"
# : Translation updated at 2013-11-17 23:18
translate arabic strings:
# renpy/common/00layout.rpy:427
old "Are you sure you want to begin skipping?"
new "هل أنت متأكد من رغبتك في البدء بالتسريع؟"
# renpy/common/00layout.rpy:428
old "Are you sure you want to skip to the next choice?"
new "هل انت متأكد من رغبتك في التسريع حتى الخيار التالي؟"
# renpy/common/00layout.rpy:429
old "Are you sure you want to skip to unseen dialogue or the next choice?"
new "هل انت متأكد من رغبتك في تسريع الخيارات و الحوار الذي لم يسبق لك قرائته؟"
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# renpy/common/00console.rpy:179
old "%(version)s console, originally by Shiz, C, and delta.\n"
new ""
# renpy/common/00console.rpy:180
old "Press <esc> to exit console. Type help for help.\n"
new "إضغط زر الخروج لإغلاق لوحة التحكم, اكتب كلمة help للمساعدة"
# renpy/common/00console.rpy:184
old "Ren'Py script enabled."
new "لغة برمحة رينباي متاحه"
# renpy/common/00console.rpy:186
old "Ren'Py script disabled."
new "لغة برمجة رينباي غير متاحه"
# renpy/common/00console.rpy:392
old "help: show this help"
new "مساعده: عرض هذه المساعده"
# renpy/common/00console.rpy:397
old "commands:\n"
new "أوامر: \n"
# renpy/common/00console.rpy:407
old " <renpy script statement>: run the statement\n"
new "<renpy script statement>: عرض الأوامر\n"
# renpy/common/00console.rpy:409
old " <python expression or statement>: run the expression or statement"
new " <python expression or statement>: عرض التعبير او الأوامر"
# renpy/common/00console.rpy:417
old "clear: clear the console history"
new "clear: مسح تاريخ لوحة التحكم"
# renpy/common/00console.rpy:421
old "exit: exit the console"
new "exit: الخروج من لوحة التحكم"
# renpy/common/00console.rpy:429
old "load <slot>: loads the game from slot"
new "استرجاع <slot>: يقوم باسترجاع اللعب من نقطة الحفظ"
# renpy/common/00console.rpy:442
old "save <slot>: saves the game in slot"
new "حفظ <slot>: يقوم بحفظ اللعب في نقطة الحفظ"
# renpy/common/00console.rpy:453
old "reload: reloads the game, refreshing the scripts"
new "reload: يعيد تشغيل اللعبة مع عرض التغييرات في النص"
# renpy/common/00console.rpy:461
old "watch <expression>: watch a python expression"
new "مشاهده <expression>: يقوم بعرض تبيرات بايثون"
# renpy/common/00console.rpy:470
old "unwatch <expression>: stop watching an expression"
new "unwatch <expression>: يقوم بإيقاف تعبير بايثون"
# renpy/common/00console.rpy:478
old "unwatchall: stop watching all expressions"
new "unwatchall: يقوم بإيقاف كل تعبيرات بايثون"
# renpy/common/00console.rpy:484
old "jump <label>: jumps to label"
new "jump <label>: يقفز للعنوان"
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# renpy/common/00keymap.rpy:332
old "Autoreload"
new "إعادة التحميل تلقائياً"
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# renpy/common/_developer/developer.rpym:65
old "Developer Menu"
new "قائمة المبرمج"
# renpy/common/_developer/developer.rpym:67
old "Reload Game (Shift+R)"
new "إعادة تشغيل اللعبة (Shift+R)"
# renpy/common/_developer/developer.rpym:69
old "Console (Shift+O)"
new "لوحة التحكم (Shift+O)"
# renpy/common/_developer/developer.rpym:71
old "Variable Viewer"
new "مستعرض الأوامر"
# renpy/common/_developer/developer.rpym:73
old "Theme Test"
new "اختبار القوالب"
# renpy/common/_developer/developer.rpym:75
old "Image Location Picker"
new "مكان الصور المطلوبة"
# renpy/common/_developer/developer.rpym:77
old "Filename List"
new "قائمة اسماء الملفات"
# renpy/common/_developer/developer.rpym:81
old "Show Image Load Log"
new "عرض قائمة الصور "
# renpy/common/_developer/developer.rpym:84
old "Hide Image Load Log"
new "إخفاء قائمة الصور"
# renpy/common/_developer/developer.rpym:149
old "No variables have changed since the game started."
new "لم يتم تغيير اي من الأوامر منذ ان بدأت اللعبة"
# renpy/common/_developer/developer.rpym:152
old "Return to the developer menu"
new "العودة للوحة المبرمج"
# renpy/common/_developer/developer.rpym:272
old "{b}Missing Images{/b}"
new "{b}صور مفقودة{/b}"
# renpy/common/_developer/developer.rpym:424
old "Rectangle: %r"
new "مثلث: %r"
# renpy/common/_developer/developer.rpym:429
old "Mouse position: %r"
new "مكان المؤشر: %r"
# renpy/common/_developer/developer.rpym:431
old "Right-click or escape to quit."
new "إضغط بالزر الايمن او إضغط زر الخروح للإغلاق"
# renpy/common/_developer/developer.rpym:482
old "Done"
new "تم"
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# renpy/common/_developer/inspector.rpym:43
old "Displayable Inspector"
new "اختبار المستعرضات"
# renpy/common/_developer/inspector.rpym:49
old "Nothing to inspect."
new "لا يوجد شيء ليتم اختباره"
# renpy/common/_developer/inspector.rpym:58
old "Size"
new "حجم"
# renpy/common/_developer/inspector.rpym:63
old "Style"
new "مظهر"
# renpy/common/_developer/inspector.rpym:123
old "Inspecting Styles of [displayable_name!q]"
new "يتم اختبار المظهر الخاص بـ [displayable_name!q]"
# renpy/common/_developer/inspector.rpym:135
old "displayable:"
new "مستعرضات"
# renpy/common/_developer/inspector.rpym:142
old " (no properties affect the displayable)"
new " (لا توجد اي مؤثرات على هذا المستعرض)"
# renpy/common/_developer/inspector.rpym:144
old " (default properties omitted)"
new " (تم استبعاد تأثير المؤثرات القياسية)"
# renpy/common/_developer/inspector.rpym:174
old "<repr() failed>"
new "<repr() failed>"
# Translation updated at 2014-09-30 23:01
translate arabic strings:
# renpy/common/_developer/inspector.rpym:80
old "Location"
new "الموقع"
translate arabic strings:
# renpy/common/00preferences.rpy:387
old "Clipboard voicing enabled. Press 'shift+C' to disable."
new "تشغيل الأصوات من الحافظة مفعّل. إضغط لإيقافه زريّ: Shift+C"
# renpy/common/00preferences.rpy:389
old "Self-voicing enabled. Press 'v' to disable."
new "التكلّم التلقائي مفعَل. لإيقافه إضغط زر V"
translate arabic strings:
# renpy/common/00updater.rpy:362
old "The Ren'Py Updater is not supported on mobile devices."
new "تحديث برنامج رينباي غير مدعوم على الأجهزة المحمولة."
# renpy/common/00updater.rpy:478
old "An error is being simulated."
new "يتم محاكاة خطأ الآن."
# renpy/common/00updater.rpy:654
old "Either this project does not support updating, or the update status file was deleted."
new "هذا المشروع لا يدعم التحديث، أو أن ملف حالة نسخة البرنامج محذوفة."
# renpy/common/00updater.rpy:668
old "This account does not have permission to perform an update."
new "هذا الحساب ليست لديه الصلاحية ليقوم بالتحديث."
# renpy/common/00updater.rpy:671
old "This account does not have permission to write the update log."
new " هذا الحساب ليست لديه الصلاحية ليكتب ملف التحديث."
# renpy/common/00updater.rpy:696
old "Could not verify update signature."
new "لم نتمكن من التحقق من توقيع التحديث update signature."
# renpy/common/00updater.rpy:956
old "The update file was not downloaded."
new "لم يتم تحميل ملف التحديث."
# renpy/common/00updater.rpy:974
old "The update file does not have the correct digest - it may have been corrupted."
new "ملف التحديث لا يحتوي على المختصرات الصحيحة - قد يكون معطوباً."
old "Processed {b}[complete]{/b} of {b}[total]{/b} files."
new "تم انهاء {b}[complete]{/b} من عدد {b}[total]{/b} من الملفات."
# game/distribute.rpy:915
old "All packages have been built.\n\nDue to the presence of permission information, unpacking and repacking the Linux and Macintosh distributions on Windows is not supported."
new "تم الإنتهاء من تكوين رزمة البيانات لنشر اللعبة. بسبب اختلاف نظام الملفات في الأنظمة التشغيلية ماك و لينوكس, لا يمكن فك الضغط عن الرزمة الخاصة بتلك الأنظمة على نظام وندوز."
# : Translation updated at 2013-11-17 23:18
translate arabic strings:
# game/distribute.rpy:358
old "No packages are selected, so there's nothing to do."
new "لم يتم اختيار اي حزمة, لم يحصل اي شيء."
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# game/distribute.rpy:335
old "Building distributions failed:\n\nThe build.directory_name variable may not include the space, colon, or semicolon characters."
new "فشل بناء ملفات النشر. build.directory_name يجب أن لا يحتوي على مساحات فارغة, فواصل, او فواصل منقوطة في إسم المجلد "
old "{b}Recommended.{/b} A beta editor with an easy to use interface and features that aid in development, such as spell-checking. Editra currently lacks the IME support required for Chinese, Japanese, and Korean text input."
new "{b}نقترح.{/b} محرر نص له واجهة سهلة الاستعمال ويعين على كتابة النصوص البرمجية يفضل برنامج يحتوي على مدقق لغوي. Editraحالياً لا يدعم اللغات الأجنبية مثل اللغه الكورية و الصينية و اليابانية."
# game/editor.rpy:121
old "{b}Recommended.{/b} A beta editor with an easy to use interface and features that aid in development, such as spell-checking. Editra currently lacks the IME support required for Chinese, Japanese, and Korean text input. On Linux, Editra requires wxPython."
new "{b}نقترح.{/b} محرر نص له واجهة سهلة الاستعمال ويعين على كتابة النصوص البرمجية يفضل برنامج يحتوي على مدقق لغوي. Editraحالياً لا يدعم اللغات الأجنبية مثل اللغه الكورية و الصينية و اليابانية. على نظام لينوكس, Editra يحتاج wxPython."
# game/editor.rpy:137
old "The may have occured because wxPython is not installed on this system."
new "قد يكون السبب ان wxPython غير موجود على هذا الجهاز."
# game/editor.rpy:144
old "Up to 22 MB download required."
new "مطلوب تحميل ملف بحجم 22 ميغا بايت."
# game/editor.rpy:157
old "1.8 MB download required."
new "مطلوب تحميل ملف بحجم 1.8 ميغا بايت."
# game/editor.rpy:158
old "This may have occured because Java is not installed on this system."
new "قد يكون السبب ان الجافا غير موجوده على هذا الجهاز."
# game/editor.rpy:327
old "An exception occured while launching the text editor:\n[exception!q]"
new "حصل استثناء اثناء فتح المحرر: \n[exception!q]"
# game/editor.rpy:378
old "Select Editor"
new "الرجاء اختيار المحرر"
# game/editor.rpy:393
old "A text editor is the program you'll use to edit Ren'Py script files. Here, you can select the editor Ren'Py will use. If not already present, the editor will be automatically downloaded and installed."
new "محرر النصوص هو برنامج يساعدك على تعديل ملفات رينباي البرمجية والحوار. هنا, يمكنك اختيار المحرر الذي سيستعلمه رينباي. إذا لم يكن لديك مسبقاً, سيتم تحميله و تنصيبه بشكل اوتوماتيكي."
# game/editor.rpy:415
old "Cancel"
new "إلغاء الامر"
# Translation updated at 2013-11-17 23:18
translate arabic strings:
# game/editor.rpy:137
old "This may have occured because wxPython is not installed on this system."
new "قد يكون سبب ذلك ان wxPython غير موجود في نظام التشغيل لديك"
# game/editor.rpy:155
old "A mature editor that requires Java."
new "محرر متخصص يستعمل لغة جافا"
# game/editor.rpy:164
old "Invokes the editor your operating system has associated with .rpy files."
new "يقوم بفتح البرنامج المسؤول عن تحرير ملفات .rpy في نظامك التشغيلي"
old "Please select a template to use for your new project. Ren'Py ships with a default template that creates an English-language game with standard screens."
new "الرجاء اختيار التصميم الذي ترغبه لمشروعك الجديد. رينباي يأتي بعدة تصاميم قياسية يمكنك التعديل عليها لاحقاً."
# game/new_project.rpy:55
old "PROJECT NAME"
new "اسم المشروع"
# game/new_project.rpy:56
old "Please enter the name of your project:"
new "الرجاء اختيار اسم لمشروعك الجديد"
# game/new_project.rpy:62
old "The project name may not be empty."
new "لا يمكن ان يكون اسم المشروع فارغاً"
# game/new_project.rpy:67
old "[project_name!q] already exists. Please choose a different project name."
new "الاسم [project_name!q] يوجد مسبقاً, الرجاء اختيار اسم مختلف."
# game/new_project.rpy:70
old "[project_dir!q] already exists. Please choose a different project name."
new "[project_dir!q] يوجد مسبقاً, الرجاء اختيار اسم مختلف."
# : Translation updated at 2013-11-17 23:18
translate arabic strings:
# game/new_project.rpy:40
old "Please select a template to use for your new project. The template sets the default font and the user interface language. If your language is not supported, choose 'english'."
new "الرجاء اختيار القالب المطلوب للمشروع الجديد. هذه القوالب تقوم بتجهيز اتجاه النص و اللغه المستخدمة في الواجهة لتسهل عملية البدء. إذا لم تكن لغتك مدعومة الرجاء اختيار اللغة الانجليزية."
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# game/new_project.rpy:71
old "The projects directory could not be set. Giving up."
old "Please choose the projects directory using the directory chooser.\n{b}The directory chooser may have opened behind this window.{/b}"
new "الرجاء اختيار نسق المشاريع من الصفحة الخاصة بذلك. \n{b}قد تكون النافذة ظهرت خلف هذه النافذة.{/b}"
# game/project.rpy:485
old "This launcher will scan for projects in this directory, will create new projects in this directory, and will place built projects into this directory."
new "سيقوم البرنامج بفحص المجلد هذا لإيجاد المشاريع السابقة, أو ليضع المشاريع الجديده فيه, و ايضاً لوضع المشاريع المنتهيه عند تجهيزها للنشر."
# game/project.rpy:525
old "Ren'Py was unable to run python with tkinter to choose the projects directory."
new "رينباي لم يستطع تشغيل برمجيات بايثون للبحث عن مجلد المشاريع."
# game/project.rpy:529
old "Ren'Py has set the projects directory to:"
new "رينباي قام بتحديد مجلد المشاريع إلى المكان التالي:"
# : Translation updated at 2014-04-17 13:01
translate arabic strings:
# game/project.rpy:48
old "After making changes to the script, press shift+R to reload your game."
new "عند إجراء أي تغييرات في ملف الحوار, يمكنك ضغط shift+R لترى التغييرات داخل اللعبة"
# game/project.rpy:49
old "Press shift+O (the letter) to access the console."
new "إضغط shift+O للدخول على لوحة التحكم"
# game/project.rpy:50
old "Press shift+D to access the developer menu."
new "إضغط shift+D للدخول على لوحة تحكم المبرمج"
# game/project.rpy:219
old "Launching the project failed."
new "لم تنجح محاولة إقلاع المشروع"
# game/project.rpy:219
old "Please ensure that your project launches normally before running this command."
new "الرجاء التأكد من سلامة إقلاع المشروع قبل تشغيل هذا الأمر البرمجي"
# game/project.rpy:516
old "Launching"
new "جاري الإقلاع"
# game/project.rpy:585
old "Ren'Py was unable to run python with tkinter to choose the projects directory. Please install the python-tk or tkinter package."
new "رينباي لم يتمكن من تشغيل بايثون مع tkinter لكي يختار مجلد المشاريع, الرجاء تنصيب Python-tk او tkinter"
# Translation updated at 2014-09-30 23:01
translate arabic strings:
# game/project.rpy:47
old "Have you backed up your projects recently?"
new "هل قمت بعمل نسخة احتياطية من مشاريعك مؤخراً؟"
old "Enter the name of the script file to create."
new "Kirjoita skriptitiedoston nimi, jonka haluat luoda."
# game/add_file.rpy:31
old "The filename must have the .rpy extension."
new "Tiedostolla on oltava .rpy -tunniste."
# game/add_file.rpy:39
old "The file already exists."
new "Tiedosto on jo olemassa."
# game/add_file.rpy:42
old "# Ren'Py automatically loads all script files ending with .rpy. To use this\n# file, define a label and jump to it from another file.\n"
new "# Ren'Py lataa automaattisesti kaikki scriptitiedostot, joilla on .rpy pääte. Käyttääksesi tätä\n# tiedostoa, luo label ja hyppää siihen toisesta tiedostosta.\n"
old "To build Android packages, please download RAPT, unzip it, and place it into the Ren'Py directory. Then restart the Ren'Py launcher."
new "Luodaksesi Android-sovelluksia, ole hyvä ja lataa RAPT, pura se, ja aseta se Ren'Py kansioon. Tämän jälkeen käynnistä Ren'Py uudelleen."
# game/android.rpy:31
old "A 32-bit Java Development Kit is required to build Android packages on Windows. The JDK is different from the JRE, so it's possible you have Java without having the JDK.\n\nPlease {a=http://www.oracle.com/technetwork/java/javase/downloads/index.html}download and install the JDK{/a}, then restart the Ren'Py launcher."
new "32-bittinen Javan kehitystyökalu vaaditaan Android-sovellusten luomiseen Windowsilla. JDK on erilainen kuin JRE, joten on mahdollista, että sinulla on Java ilman JDK:ta.\n\n{a=http://www.oracle.com/technetwork/java/javase/downloads/index.html}Lataa ja asenna JDK{/a}, ja sen jälkeen käynnistä Ren'Py uudelleen."
# game/android.rpy:32
old "RAPT has been installed, but you'll need to install the Android SDK before you can build Android packages. Choose Install SDK to do this."
new "RAPT on asennettu, mutta sinun on asennettava Android SDK ennen kuin voit luoda Android-sovelluksia. Valitse 'Asenna SDK' tehdäksesi tämän."
# game/android.rpy:33
old "RAPT has been installed, but a key hasn't been configured. Please create a new key, or restore android.keystore."
new "RAPT on asennettu, mutta avainta ei ole konfiguroitu. Luo uusi avain, tai palauta android.keystore."
# game/android.rpy:34
old "The current project has not been configured. Use \"Configure\" to configure it before building."
new "Valittua projektia ei ole konfiguroitu. Käytä \"Konfigurointi\" -toimintoa konfiguroidaksesi sen ennen sovelluksen kokoamista."
# game/android.rpy:35
old "Choose \"Build\" to build the current project, or attach an Android device and choose \"Build & Install\" to build and install it on the device."
new "Valitse \"Kokoa\" kootaksesi projektin, tai kiinnitä Android-laite ja valitse \"Kokoa ja asenna\" kootaksesi ja asentaaksesi sen laitteeseen."
# game/android.rpy:37
old "Attempts to emulate an Android phone.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "Ren'Py pyrkii emuloimaan Android-puhelinta.\n\nKosketus valintaa emuloidaan hiirellä, mutta vain kun nappia pidetään pohjassa. Esc toimii Menu-näppäimenä ja Pg Up toimii peruutusnappina."
# game/android.rpy:38
old "Attempts to emulate an Android tablet.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "Ren'Py pyrkii emuloimaan Android-tablettia.\n\nKosketusta emuloidaan hiirellä, mutta vain kun nappia pidetään pohjassa. Esc toimii Menu-näppäimenä ja Pg Up toimii peruutusnappina."
# game/android.rpy:39
old "Attempts to emulate a televison-based Android console, like the OUYA or Fire TV.\n\nController input is mapped to the arrow keys, Enter is mapped to the select button, Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "Ren'Py pyrkii emuloimaan televisiopohjaista Android-konsolia, kuten OUYA tai Fire TV.\n\nOhjainnäppäimet ovat nuolinäppäimet, Enter toimii valitsijana, Esc toimii Menu-näppäimenä ja Pg Up toimii peruutusnappina."
# game/android.rpy:41
old "Downloads and installs the Android SDK and supporting packages. Optionally, generates the keys required to sign the package."
new "Lataa ja asentaa Android SDK:n ja tarvittavat lisäpaketit. Lisäksi, voidaan käyttää avainten luomiseen."
# game/android.rpy:42
old "Configures the package name, version, and other information about this project."
new "Konfiguroi paketin nimen, version sekä kaiken muun projektia koskevan tiedon."
# game/android.rpy:43
old "Opens the file containing the Google Play keys in the editor.\n\nThis is only needed if the application is using an expansion APK. Read the documentation for more details."
new "Avaa tiedoston, joka sisältää Google Play -avaimet, editorissa.\n\nTätä tarvitaan vain, jos sovellus käyttää laajennus-APK:ta. Lue dokumentit saadaksesi lisätietoa."
# game/android.rpy:44
old "Builds the Android package."
new "Rakentaa Android-paketin."
# game/android.rpy:45
old "Builds the Android package, and installs it on an Android device connected to your computer."
new "Rakentaa Android-paketin, ja asentaa sen tietokoneeseen kytkettyyn Android-laitteeseen."
# game/android.rpy:47
old "Connects to an Android device running ADB in TCP/IP mode."
new "Yhdistää Android-laitteeseen, jossa on käytössä ADB TCP/IP -tilassa."
# game/android.rpy:48
old "Disconnects from an Android device running ADB in TCP/IP mode."
new "Katkaisee yhteyden Android-laitteeseen, jossa on käytössä ADB TCP/IP -tila."
# game/android.rpy:164
old "{a=%s}%s{/a}"
new "{a=%s}%s{/a}"
# game/android.rpy:176
old "QUESTION"
new "KYSYMYS"
# game/android.rpy:445
old "Android: [project.current.name!q]"
new "Android: [project.current.name!q]"
# game/android.rpy:465
old "Emulation:"
new "Emulointi:"
# game/android.rpy:473
old "Phone"
new "Puhelin"
# game/android.rpy:477
old "Tablet"
new "Tablettitietokone"
# game/android.rpy:481
old "Television / OUYA"
new "Televisio / OUYA"
# game/android.rpy:493
old "Build:"
new "Kokoa:"
# game/android.rpy:501
old "Install SDK & Create Keys"
new "Asenna SDK & Luo avaimet"
# game/android.rpy:505
old "Configure"
new "Muokkaa asetuksia"
# game/android.rpy:509
old "Build Package"
new "Kokoamispaketti:"
# game/android.rpy:513
old "Build & Install"
new "Kokoa & Asenna"
# game/android.rpy:524
old "Other:"
new "Muu:"
# game/android.rpy:532
old "Remote ADB Connect"
new "Langaton ADB-yhdistäminen:"
# game/android.rpy:536
old "Remote ADB Disconnect"
new "Langaton ADB-katkaisu:"
# game/android.rpy:569
old "Before packaging Android apps, you'll need to download RAPT, the Ren'Py Android Packaging Tool. Would you like to download RAPT now?"
new "Ennen Android-sovellusten pakkausta, sinun on ladattava RAPT (Ren'Py Android Packaging Tool). Haluatko ladata RAPT:in nyt?"
# game/android.rpy:615
old "Remote ADB Address"
new "Langaton ADB-osoite"
# game/android.rpy:615
old "Please enter the IP address and port number to connect to, in the form \"192.168.1.143:5555\". Consult your device's documentation to determine if it supports remote ADB, and if so, the address and port to use."
new "Syötä yhdistettävän kohteen IP-osoite ja porttinumero, esimerkin \"192.168.1.143:5555\" mukaisesti. Selvitä laitteesi tiedoista kykeneekö se langattomaan ADB:hen, ja jos näin on, käytettävä osoite ja portti."
# game/android.rpy:627
old "Invalid remote ADB address"
new "Langaton ADB-osoite ei kelpaa."
# game/android.rpy:627
old "The address must contain one exactly one ':'."
new "Osoitteessa on oltava yksi, ja vain yksi, ':'."
# game/android.rpy:631
old "The host may not contain whitespace."
new "Isäntä ei voi sisältää välilyöntejä."
# game/android.rpy:637
old "The port must be a number."
new "Portin on oltava numero."
translate finnish strings:
# game/android.rpy:46
old "Builds the Android package, installs it on an Android device connected to your computer, then launches the app on your device."
new "Kokoaa Android-paketin, asentaa sen tietokoneeseen kytkettyyn Android-laitteeseen ja käynnistää sovelluksen laitteessa."
# game/android.rpy:50
old "Retrieves the log from the Android device and writes it to a file."
new "Noutaa lokin Android-laitteesta ja kirjoittaa sen tiedostoon."
# game/android.rpy:240
old "Copying Android files to distributions directory."
new "Kopioidaan Android-tiedostoja jakelukansioon."
old "%(version)s console, originally by Shiz, C, and delta.\n"
new "%(version)n konsoli, alunperin tehneet Shiz, C ja delta.\n"
# renpy/common/00console.rpy:180
old "Press <esc> to exit console. Type help for help.\n"
new "Paina <esc> poistuaksesi konsolista. Käytä komentoa help saadaksesi apua."
# renpy/common/00console.rpy:184
old "Ren'Py script enabled."
new "Ren'Py-skriptikieli käytössä."
# renpy/common/00console.rpy:186
old "Ren'Py script disabled."
new "Ren'Py-skriptikieli poissa käytöstä."
# renpy/common/00console.rpy:392
old "help: show this help"
new "help: näytä tämä apuviesti"
# renpy/common/00console.rpy:397
old "commands:\n"
new "komennot:\n"
# renpy/common/00console.rpy:407
old " <renpy script statement>: run the statement\n"
new " <renpy script-väite>: suorita väite\n"
# renpy/common/00console.rpy:409
old " <python expression or statement>: run the expression or statement"
new " <python ekspressio tai väite>: suorita ekspressio tai väite"
# renpy/common/00console.rpy:417
old "clear: clear the console history"
new "clear: tyhjennä konsolin historia"
# renpy/common/00console.rpy:421
old "exit: exit the console"
new "exit: poistu konsolista"
# renpy/common/00console.rpy:429
old "load <slot>: loads the game from slot"
new "load <tallennuspaikka>: lataa pelin halutusta tallennuspaikasta"
# renpy/common/00console.rpy:442
old "save <slot>: saves the game in slot"
new "save <tallennuspaikka>: tallentaa pelin tallennuspaikkaan"
# renpy/common/00console.rpy:453
old "reload: reloads the game, refreshing the scripts"
new "reload: lataa pelin uudelleen, päivittäen skriptit"
# renpy/common/00console.rpy:461
old "watch <expression>: watch a python expression"
new "watch <ekspressio>: tarkkaile python-ekspressiota"
# renpy/common/00console.rpy:470
old "unwatch <expression>: stop watching an expression"
new "unwatch <ekspressio>: lakkaa tarkkailemasta ekspressiota"
# renpy/common/00console.rpy:478
old "unwatchall: stop watching all expressions"
new "unwatchall: lopeta kaikkien ekspressioiden tarkkailu"
# renpy/common/00console.rpy:484
old "jump <label>: jumps to label"
new "jump <tunnus>: hyppää 'script.rpy'-tiedosto(i)ssa olevaan, tunnuksella merkittyyn kohtaan"
translate finnish strings:
# renpy/common/00gallery.rpy:561
old "Image [index] of [count] locked."
new ""
# renpy/common/00gallery.rpy:581
old "prev"
new "edellinen"
# renpy/common/00gallery.rpy:582
old "next"
new "seuraava"
# renpy/common/00gallery.rpy:583
old "slideshow"
new "diaesitys"
# renpy/common/00gallery.rpy:584
old "return"
new "palaa"
translate finnish strings:
# renpy/common/00gltest.rpy:68
old "Graphics Acceleration"
new "Grafiikkakiihdytys"
# renpy/common/00gltest.rpy:72
old "Automatically Choose"
new "Valitse automaattisesti"
# renpy/common/00gltest.rpy:77
old "Force Angle/DirectX Renderer"
new "Pakota Angle/DirectX-renderöinti"
# renpy/common/00gltest.rpy:81
old "Force OpenGL Renderer"
new "Pakota OpenGL-renderöinti"
# renpy/common/00gltest.rpy:85
old "Force Software Renderer"
new "Pakota Software-renderöinti"
# renpy/common/00gltest.rpy:91
old "Changes will take effect the next time this program is run."
new "Muutokset tulevat voimaan, kun käynnistät ohjelman uudelleen."
# renpy/common/00gltest.rpy:95
old "Quit"
new "Poistu"
# renpy/common/00gltest.rpy:100
old "Return"
new "Palaa"
# renpy/common/00gltest.rpy:130
old "Performance Warning"
new "Suorituskyvyn varoitus"
# renpy/common/00gltest.rpy:135
old "This computer is using software rendering."
new "Tietokone käyttää software-renderöintiä."
# renpy/common/00gltest.rpy:137
old "This computer is not using shaders."
new "Tietokone ei käytä varjostimia."
# renpy/common/00gltest.rpy:139
old "This computer is displaying graphics slowly."
new "Tietokone näyttää grafiikkaa hitaasti."
# renpy/common/00gltest.rpy:141
old "This computer has a problem displaying graphics: [problem]."
new "Tietokoneella on ongelmia grafiikan näyttämisessä: [problem]"
# renpy/common/00gltest.rpy:146
old "Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display. Updating DirectX could fix this problem."
new "Sen grafiikka-ajurit voivat olla vanhentuneita tai ne saattavat toimia väärin. Tämä voi johtaa hitaaseen tai väärään grafiikan esittämiseen. DirectX:n päivittäminen saattaa korjata ongelman."
# renpy/common/00gltest.rpy:148
old "Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display."
new "Sen grafiikka-ajurit voivat olla vanhentuneita tai ne saattavat toimia väärin. Tämä voi johtaa hitaaseen tai väärään grafiikan esittämiseen."
# renpy/common/00gltest.rpy:153
old "Update DirectX"
new "Päivitä DirectX"
# renpy/common/00gltest.rpy:159
old "Continue, Show this warning again"
new "Jatka, näytä tämä varoitus uudelleen"
# renpy/common/00gltest.rpy:163
old "Continue, Don't show warning again"
new "Jatka, älä näytä tätä varoitusta enää uudelleen"
# renpy/common/00gltest.rpy:189
old "Updating DirectX."
new "Päivitetään DirectX:ää."
# renpy/common/00gltest.rpy:193
old "DirectX web setup has been started. It may start minimized in the taskbar. Please follow the prompts to install DirectX."
new "DirectX verkkoasennus on alkanut. Se voi olla aluksi minimisoituna työkalupalkilla. Seuraa ohjeita asentaaksesi DirectX:n."
# renpy/common/00gltest.rpy:197
old "{b}Note:{/b} Microsoft's DirectX web setup program will, by default, install the Bing toolbar. If you do not want this toolbar, uncheck the appropriate box."
new "{b}Huomaa:{/b} Microsoftin DirectX verkkoasennusohjelma asentaa, oletusarvoisesti, Bing-työkalupalkin. Jos et halua tätä työkalupalkkia, poista valinta oikeasta laatikosta."
# renpy/common/00gltest.rpy:201
old "When setup finishes, please click below to restart this program."
new "Kun asennus on valmis, klikkaa alhaalta käynnistääksesi tämän ohjelman uudelleen."
# renpy/common/00gltest.rpy:203
old "Restart"
new "Käynnistä uudelleen"
translate finnish strings:
# renpy/common/00keymap.rpy:199
old "Saved screenshot as %s."
new "Näytönkaappaus tallennettu nimellä %s."
translate finnish strings:
# renpy/common/00layout.rpy:444
old "Are you sure?"
new "Oletko varma?"
# renpy/common/00layout.rpy:445
old "Are you sure you want to delete this save?"
new "Oletko varma, että haluat poistaa tämän tallennuksen?"
# renpy/common/00layout.rpy:446
old "Are you sure you want to overwrite your save?"
new "Oletko varma, että haluat korvata tallennuksen uudella?"
# renpy/common/00layout.rpy:447
old "Loading will lose unsaved progress.\nAre you sure you want to do this?"
new "Lataamalla tallennuksen menetät tallentamattoman edistyksen.\nOletko varma, että haluat tehdä näin?"
# renpy/common/00layout.rpy:448
old "Are you sure you want to quit?"
new "Haluatko varmasti lopettaa?"
# renpy/common/00layout.rpy:449
old "Are you sure you want to return to the main menu?\nThis will lose unsaved progress."
new "Haluatko varmasti palata päävalikkoon?\nMenetät kaikki tallentamattomat tiedot."
# renpy/common/00layout.rpy:450
old "Are you sure you want to begin skipping?"
new "Oletko varma, että haluat käyttää skippausta?"
# renpy/common/00layout.rpy:451
old "Are you sure you want to skip to the next choice?"
new "Oletko varma, että haluat skipata seuraavaan valintaan?"
# renpy/common/00layout.rpy:452
old "Are you sure you want to skip to unseen dialogue or the next choice?"
new "Oletko varma, että haluat skipata uuteen dialogiin tai seuraavaan valintaan?"
translate finnish strings:
# renpy/common/00library.rpy:149
old "Skip Mode"
new "Skippaustila"
# renpy/common/00library.rpy:152
old "Fast Skip Mode"
new "Pikaskippaustila"
translate finnish strings:
# renpy/common/00preferences.rpy:373
old "Self-voicing enabled. Press 'v' to disable."
new "Tietokoneen ääninäyttely käytössä. Paina 'v' lopettaaksesi."
translate finnish strings:
# renpy/common/00updater.rpy:1377
old "Updater"
new "Päivittäjä"
# renpy/common/00updater.rpy:1386
old "This program is up to date."
new "Käytät jo uuinta versiota."
# renpy/common/00updater.rpy:1388
old "[u.version] is available. Do you want to install it?"
new "[u.version] on saatavilla. Haluatko asentaa sen?"
# renpy/common/00updater.rpy:1390
old "Preparing to download the updates."
new "Valmistellaan päivitysten lataamista."
# renpy/common/00updater.rpy:1392
old "Downloading the updates."
new "Ladataan päivityksiä."
# renpy/common/00updater.rpy:1394
old "Unpacking the updates."
new "Puretaan päivityksiä."
# renpy/common/00updater.rpy:1398
old "The updates have been installed. The program will restart."
new "Päivitykset on asennettu. Ohjelma käynnistyy nyt uudelleen."
# renpy/common/00updater.rpy:1400
old "The updates have been installed."
new "Päivitykset on asennettu."
# renpy/common/00updater.rpy:1402
old "The updates were cancelled."
new "Päivitykset peruttiin."
translate finnish strings:
# renpy/common/_compat/gamemenu.rpym:198
old "Empty Slot."
new "Tyhjä paikka."
# renpy/common/_compat/gamemenu.rpym:355
old "Previous"
new "Edellinen"
# renpy/common/_compat/gamemenu.rpym:362
old "Next"
new "Seuraava"
translate finnish strings:
# renpy/common/_compat/preferences.rpym:428
old "Joystick Mapping"
new "Peliohjaimen näppäimet"
translate finnish strings:
# renpy/common/_developer/developer.rpym:65
old "Developer Menu"
new "Kehittäjävalikko"
# renpy/common/_developer/developer.rpym:67
old "Reload Game (Shift+R)"
new "Käynnistä peli uudelleen (Shift+R)"
# renpy/common/_developer/developer.rpym:69
old "Console (Shift+O)"
new "Konsoli (Shift+O)"
# renpy/common/_developer/developer.rpym:71
old "Variable Viewer"
new "Muuttujat"
# renpy/common/_developer/developer.rpym:73
old "Theme Test"
new "Teematesti"
# renpy/common/_developer/developer.rpym:75
old "Image Location Picker"
new "Kuvan sijainnin selvitin"
# renpy/common/_developer/developer.rpym:77
old "Filename List"
new "Tiedostonimilista"
# renpy/common/_developer/developer.rpym:81
old "Show Image Load Log"
new "Näytä kuvanlatausloki"
# renpy/common/_developer/developer.rpym:84
old "Hide Image Load Log"
new "Piilota kuvanlatausloki"
# renpy/common/_developer/developer.rpym:150
old "No variables have changed since the game started."
new "Yksikään muuttuja ei ole muuttunut pelin alkamisen jälkeen."
# renpy/common/_developer/developer.rpym:153
old "Return to the developer menu"
new "Palaa kehittäjävalikkoon"
# renpy/common/_developer/developer.rpym:385
old "Rectangle: %r"
new "Suorakulmio: %r"
# renpy/common/_developer/developer.rpym:390
old "Mouse position: %r"
new "Hiiren sijainti: %r"
# renpy/common/_developer/developer.rpym:392
old "Right-click or escape to quit."
new "Paina Esc tai hiiren oikeaa näppäintä poistuaksesi."
# renpy/common/_developer/developer.rpym:443
old "Done"
new "Valmis"
translate finnish strings:
# renpy/common/_developer/inspector.rpym:46
old "Displayable Inspector"
new "Näkyvien objektien tutkija"
# renpy/common/_developer/inspector.rpym:52
old "Nothing to inspect."
new "Ei tutkittavaa."
# renpy/common/_developer/inspector.rpym:70
old "Size"
new "Koko"
# renpy/common/_developer/inspector.rpym:74
old "Style"
new "Tyyli"
# renpy/common/_developer/inspector.rpym:80
old "Location"
new "Sijainti"
# renpy/common/_developer/inspector.rpym:142
old "Inspecting Styles of [displayable_name!q]"
new "Tutkitaan [displayable_name!q]n tyylejä"
# renpy/common/_developer/inspector.rpym:155
old "displayable:"
new "näkyvä objekti:"
# renpy/common/_developer/inspector.rpym:162
old " (no properties affect the displayable)"
new " (mitkään ominaisuudet eivät vaikuta objektiin)"
# renpy/common/_developer/inspector.rpym:164
old " (default properties omitted)"
new " (perusominaisuudet sivuutettu)"
# renpy/common/_developer/inspector.rpym:206
old "<repr() failed>"
new "<repr() epäonnistui>"
translate finnish strings:
# renpy/common/_errorhandling.rpym:451
old "An exception has occurred."
new "Odottamaton virhe on tapahtunut."
# renpy/common/_errorhandling.rpym:477
old "Rollback"
new "Palaa edelliseen tilaan"
# renpy/common/_errorhandling.rpym:479
old "Attempts a roll back to a prior time, allowing you to save or choose a different choice."
new "Yrittää palata ajassa taaksepäin, antaen sinun tallentaa tai tehdä eri valinnan."
# renpy/common/_errorhandling.rpym:482
old "Ignore"
new "Sivuuta"
# renpy/common/_errorhandling.rpym:484
old "Ignores the exception, allowing you to continue. This often leads to additional errors."
new "Sivuuttaa poikkeuksen, antaen sinun jatkaa. Tämä johtaa usein uusiin virheisiin."
# renpy/common/_errorhandling.rpym:487
old "Reload"
new "Lataa uudelleen"
# renpy/common/_errorhandling.rpym:489
old "Reloads the game from disk, saving and restoring game state if possible."
new "Lataa pelin uudelleen muistista, tallentaen ja palauttaen pelitilan jos mahdollista."
# renpy/common/_errorhandling.rpym:491
old "Open Traceback"
new "Avaa virheenjäljitystoiminto"
# renpy/common/_errorhandling.rpym:493
old "Opens the traceback.txt file in a text editor."
new "Avaa traceback.txt-tiedoston tekstieditorissa."
# renpy/common/_errorhandling.rpym:499
old "Quits the game."
new "Lopettaa pelin."
# renpy/common/_errorhandling.rpym:526
old "Parsing the script failed."
new "Skriptin jäsennys epäonnistui."
# renpy/common/_errorhandling.rpym:553
old "Open Parse Errors"
new "Avaa jäsennysvirheet"
# renpy/common/_errorhandling.rpym:555
old "Opens the errors.txt file in a text editor."
new "Avaa errors.txt-tiedoston tekstieditorissa."
translate finnish strings:
# renpy/common/_layout/classic_load_save.rpym:170
old "a"
new "a"
# renpy/common/_layout/classic_load_save.rpym:179
old "q"
new "q"
translate finnish strings:
# renpy/common/00preferences.rpy:370
old "Clipboard voicing enabled. Press 'shift+C' to disable."
new "Leikepöydän teksti luetaan nyt ääneen. Paina 'shift+c' lopettaaksesi toimnnon käytön."
translate finnish strings:
# renpy/common/00updater.rpy:362
old "The Ren'Py Updater is not supported on mobile devices."
new "Mobiililaitteet eivät tue Ren'Py Updater -toimintoa."
# renpy/common/00updater.rpy:481
old "An error is being simulated."
new "Stimuloidaan havaittua ongelmaa."
# renpy/common/00updater.rpy:657
old "Either this project does not support updating, or the update status file was deleted."
new "Tämä projekti ei tue päivittämistä tai päivityksen statustiedosto poistettiin."
# renpy/common/00updater.rpy:671
old "This account does not have permission to perform an update."
new "Tällä käyttäjällä ei ole oikeutta päivityksen suorittamiseen."
# renpy/common/00updater.rpy:674
old "This account does not have permission to write the update log."
new "Tällä käyttäjällä ei ole oikeutta kirjoittaa dataa päivityslokiin."
# renpy/common/00updater.rpy:699
old "Could not verify update signature."
new "Päivityksen allekirjoitusta ei voitu vahvistaa."
# renpy/common/00updater.rpy:970
old "The update file was not downloaded."
new "Päivitystiedostoa ei ladattu."
# renpy/common/00updater.rpy:988
old "The update file does not have the correct digest - it may have been corrupted."
new "Päivitystiedosto ei sisällä oikeaa tiivistelmää - se on saattanut korruptoitua."
old "Building distributions failed:\n\nThe build.directory_name variable may not include the space, colon, or semicolon characters."
new "Ohjelman kokoaminen epäonnistui:\n\nbuild.directory_name -muuttuja ei saa sisältää välilyöntejä, pilkkuja tai puolipilkkuja."
# game/distribute.rpy:381
old "No packages are selected, so there's nothing to do."
new "Yhtäkään pakettia ei valittu, joten mitään ei ole tehtävissä."
# game/distribute.rpy:386
old "Scanning project files..."
new "Skannataan projektin tiedostoja..."
# game/distribute.rpy:396
old "Scanning Ren'Py files..."
new "Skannataan Ren'Py-tiedostoja..."
# game/distribute.rpy:444
old "All packages have been built.\n\nDue to the presence of permission information, unpacking and repacking the Linux and Macintosh distributions on Windows is not supported."
new "Kaikki paketit on koottu.\n\nLupainformaation läsnäolon vuoksi Linux- ja Macintosh-sovellusten pakkaamista Windows-järjestelmässä ei tueta."
# game/distribute.rpy:568
old "Archiving files..."
new "Arkistoidaan tiedostoja..."
# game/distribute.rpy:832
old "Writing the [variant] [format] package."
new "Kirjoitetaan [variant] [format]-pakettia."
# game/distribute.rpy:845
old "Making the [variant] update zsync file."
new "Luodaan [variant] zsync-päivitystiedostoa."
# game/distribute.rpy:941
old "Processed {b}[complete]{/b} of {b}[total]{/b} files."
new "Käsitelty {b}[complete]{/b}/{b}[total]{/b}:sta tiedostosta."
old "{b}Recommended.{/b} A beta editor with an easy to use interface and features that aid in development, such as spell-checking. Editra currently lacks the IME support required for Chinese, Japanese, and Korean text input."
new "{b}Suositeltu.{/b} Helppokäyttöinen beta-asteella oleva tekstieditori, joka sisältää kehitystä helpottavia toimintoja. Toistaiseksi Editrasta puuttuu täysin kiinalaisen, japanilaisen ja korealaisen tekstin kannatus."
# game/editor.rpy:151
old "{b}Recommended.{/b} A beta editor with an easy to use interface and features that aid in development, such as spell-checking. Editra currently lacks the IME support required for Chinese, Japanese, and Korean text input. On Linux, Editra requires wxPython."
new "{b}Suositeltu.{/b} Helppokäyttöinen beta-asteella oleva tekstieditori, joka sisältää kehitystä helpottavia toimintoja. Toistaiseksi Editrasta puuttuu täysin kiinalaisen, japanilaisen ja korealaisen tekstin kannatus."
# game/editor.rpy:167
old "This may have occured because wxPython is not installed on this system."
new "Tämä saattoi tapahtua, koska wxPythonia ei ole asennettu järjestelmään."
# game/editor.rpy:169
old "Up to 22 MB download required."
new "22 MB lataus vaaditaan"
# game/editor.rpy:182
old "A mature editor that requires Java."
new "Edistynyt editori, joka vaatii Javan."
# game/editor.rpy:182
old "1.8 MB download required."
new "1.8 MB lataus vaaditaan."
# game/editor.rpy:182
old "This may have occured because Java is not installed on this system."
new "Tämä saattoi tapahtua, koska Javaa ei ole asennettu."
# game/editor.rpy:191
old "Invokes the editor your operating system has associated with .rpy files."
new "Käyttää editoria, jota käyttöjärjestelmäsi käyttää .rpy-tiedostojen kanssa."
# game/editor.rpy:207
old "Prevents Ren'Py from opening a text editor."
new "Estää Ren'Py-ohjelmaa avaamasta tekstieditoria."
# game/editor.rpy:359
old "An exception occured while launching the text editor:\n[exception!q]"
new "Virhe käynnistäessä tekstieditoria:\n[exception!q]"
# game/editor.rpy:457
old "Select Editor"
new "Valitse editori"
# game/editor.rpy:472
old "A text editor is the program you'll use to edit Ren'Py script files. Here, you can select the editor Ren'Py will use. If not already present, the editor will be automatically downloaded and installed."
new "Tekstieditori on ohjelma, jota käytät Ren'Py-skriptitiedostojen muokkaamiseen. Täällä voit valita, mitä editoria Ren'Py käyttää. Jos valitsemaasi editoria ei vielä ole asennettu, se ladataan ja asennetaan automaattisesti."
old "To build iOS packages, please download renios, unzip it, and place it into the Ren'Py directory. Then restart the Ren'Py launcher."
new "Luodaksesi iOS-sovelluksia, ole hyvä ja lataa renios, pura se, ja aseta se Ren'Py kansioon. Tämän jälkeen käynnistä Ren'Py uudelleen."
# game/ios.rpy:29
old "The directory in where Xcode projects will be placed has not been selected. Choose 'Select Directory' to select it."
new "Kansiota, johon Xcode-projektit asetetaan, ei ole valittu. Klikkaa 'Valitse kansio' valitaksesi sen."
# game/ios.rpy:30
old "There is no Xcode project corresponding to the current Ren'Py project. Choose 'Create Xcode Project' to create one."
new "Nykyistä Ren'Py-projektia vastaavaa Xcode-projektia ei löydy. Klikkaa 'Luo Xcode-projekti' luodaksesi sellaisen."
# game/ios.rpy:31
old "An Xcode project exists. Choose 'Update Xcode Project' to update it with the latest game files, or use Xcode to build and install it."
new "Xcode-projekti on jo olemassa. Klikkaa 'Päivitä Xcode-projekti' päivittääksesi sen uusimmilla pelin tiedostoilla, tai käytä Xcodea kootaksesi ja asentaaksesi sen."
# game/ios.rpy:33
old "Attempts to emulate an iPhone.\n\nTouch input is emulated through the mouse, but only when the button is held down."
new "Ren'Py pyrkii emuloimaan iPhonea.\n\nKosketusta emuloidaan hiirellä, mutta vain kun nappia pidetään pohjassa."
# game/ios.rpy:34
old "Attempts to emulate an iPad.\n\nTouch input is emulated through the mouse, but only when the button is held down."
new "Ren'Py pyrkii emuloimaan iPadia.\n\nKosketusta emuloidaan hiirellä, mutta vain kun nappia pidetään pohjassa."
# game/ios.rpy:36
old "Selects the directory where Xcode projects will be placed."
new "Valitsee kansion, johon Xcode-projektit sijoitetaan."
# game/ios.rpy:37
old "Creates an Xcode project corresponding to the current Ren'Py project."
new "Luo Xcode-projektin tällä hetkellä valittuna olevasta Ren'Py-projektista."
# game/ios.rpy:38
old "Updates the Xcode project with the latest game files. This must be done each time the Ren'Py project changes."
new "Päivittää Xcode-projektin uusimmilla pelitiedostoilla. Tämä on tehtävä joka kerta Ren'Py-projektin muuttuessa."
# game/ios.rpy:39
old "Opens the Xcode project in Xcode."
new "Avaa Xcode-projektin Xcodessa."
# game/ios.rpy:41
old "Opens the directory containing Xcode projects."
new "Avaa Xcode-projektit sisältävän kansion."
# game/ios.rpy:126
old "The Xcode project already exists. Would you like to rename the old project, and replace it with a new one?"
new "Tämänniminen Xcode-projekti on jo olemassa. Haluatko nimetä vanhan projektin uudelleen ja korvata sen uudella?"
# game/ios.rpy:211
old "iOS: [project.current.name!q]"
new "iOS: [project.current.name!q]"
# game/ios.rpy:240
old "iPhone"
new "iPhone"
# game/ios.rpy:244
old "iPad"
new "iPad"
# game/ios.rpy:264
old "Select Xcode Projects Directory"
new "Valitse Xcode-projektikansio"
# game/ios.rpy:268
old "Create Xcode Project"
new "Luo Xcode-projekti"
# game/ios.rpy:272
old "Update Xcode Project"
new "Päivitä Xcode-projekti"
# game/ios.rpy:277
old "Launch Xcode"
new "Käynnistä Xcode"
# game/ios.rpy:312
old "Open Xcode Projects Directory"
new "Avaa Xcode-projektikansio"
# game/ios.rpy:345
old "Before packaging iOS apps, you'll need to download renios, Ren'Py's iOS support. Would you like to download renios now?"
new "Ennen iOS-sovellusten pakkaamista sinun on ladattava renios, Ren'Py:n iOS-tuki. Haluaisitko ladata reniosin nyt?"
# game/ios.rpy:354
old "XCODE PROJECTS DIRECTORY"
new "XCODE-PROJEKTIKANSIO"
# game/ios.rpy:354
old "Please choose the Xcode Projects Directory using the directory chooser.\n{b}The directory chooser may have opened behind this window.{/b}"
new "Ole hyvä ja valitse Xcode-projektikansio käyttämällä resurssienhallintaa.\n{b}Kansion valinta on saattanut aueta tämän ikkunan taakse.{/b}"
# game/ios.rpy:359
old "Ren'Py has set the Xcode Projects Directory to:"
new "Ren'Py on asettanut Xcode-projektikansioksi:"
old "Please select a template to use for your new project. The template sets the default font and the user interface language. If your language is not supported, choose 'english'."
new "Valitse pohja käytettäväksi uudessa projektissasi. Se asettaa perusfontin ja kielen. Jos kieltäsi ei löydy, valitse englanti (English)."
# game/new_project.rpy:71
old "The projects directory could not be set. Giving up."
new "Projektin kansiota ei voitu asettaa."
# game/new_project.rpy:75
old "PROJECT NAME"
new "PROJEKTIN NIMI"
# game/new_project.rpy:75
old "Please enter the name of your project:"
new "Ole hyvä ja anna projektillesi nimi."
# game/new_project.rpy:83
old "The project name may not be empty."
new "Projektin nimi ei voi olla tyhjä."
# game/new_project.rpy:88
old "[project_name!q] already exists. Please choose a different project name."
new "[project_name!q] on jo olemassa. Ole hyvä ja valitse toinen nimi projektillesi."
# game/new_project.rpy:91
old "[project_dir!q] already exists. Please choose a different project name."
new "[project_dir!q] on jo olemassa. Ole hyvä ja valitse toinen nimi projektillesi."
old "After making changes to the script, press shift+R to reload your game."
new "Kun olet tehnyt muutoksia pelin tiedostoihin, paina shift+R käynnistääksesi pelisi automaattisesti uudelleen."
# game/project.rpy:47
old "Press shift+O (the letter) to access the console."
new "Paina shift+O (kirjain) päästäksesi käsiksi konsoliin."
# game/project.rpy:47
old "Press shift+D to access the developer menu."
new "Paina shift+D avataksesi kehittäjävalikon."
# game/project.rpy:47
old "Have you backed up your projects recently?"
new "Oletko ottanut projekteistasi varmuuskopiot viime aikoina?"
# game/project.rpy:223
old "Launching the project failed."
new "Projektin käynnistys epäonnistui."
# game/project.rpy:223
old "Please ensure that your project launches normally before running this command."
new "Varmista, että projektisi käynnistyy normaalisti ennen kuin käytät tätä komentoa."
# game/project.rpy:236
old "Ren'Py is scanning the project..."
new "Ren'Py skannaa projektia..."
# game/project.rpy:525
old "Launching"
new "Käynnistetään..."
# game/project.rpy:554
old "PROJECTS DIRECTORY"
new "PROJEKTIKANSIO"
# game/project.rpy:554
old "Please choose the projects directory using the directory chooser.\n{b}The directory chooser may have opened behind this window.{/b}"
new "Ole hyvä ja valitse kansio, jota haluat käyttää projektiesi tallentamiseen.\n{b}Kansion valitsija on saattanut aueta tämän ikkunan taakse.{/b}"
# game/project.rpy:554
old "This launcher will scan for projects in this directory, will create new projects in this directory, and will place built projects into this directory."
new "Tämä työkalu etsii, luo sekä muokkaa projekteja, jotka löytyvät tästä kansiosta."
# game/project.rpy:594
old "Ren'Py was unable to run python with tkinter to choose the projects directory. Please install the python-tk or tkinter package."
new "Ren'Py ei kyennyt käyttämään pythonia tkinterillä valitakseen projektikansion. Ole hyvä ja asenna python-tk tai tkinter-paketti."
old "The update channel controls the version of Ren'Py the updater will download. Please select an update channel:"
new "Päivityskanava vaikuttaa siihen, mihin versioon Ren'Py päivitetään. Valitse päivityskanava:"
# game/updater.rpy:94
old "Release"
new "Vakaat versiot"
# game/updater.rpy:100
old "{b}Recommended.{/b} The version of Ren'Py that should be used in all newly-released games."
new "{b}Suositeltu.{/b} Ren'Py:n uusin, vakaa versio, jota suositellaan käytettäväksi."
# game/updater.rpy:105
old "Prerelease"
new "Esiversiot"
# game/updater.rpy:111
old "A preview of the next version of Ren'Py that can be used for testing and taking advantage of new features, but not for final releases of games."
new "Ennakkoversio Ren'Py:n seuraavasta versiosta, jota voidaan käyttää uusien ominaisuuksien testaamiseen ja hyödyntämiseen. Ei suositella pelien julkaisemiseen."
# game/updater.rpy:117
old "Experimental"
new "Kokeelliset versiot"
# game/updater.rpy:123
old "Experimental versions of Ren'Py. You shouldn't select this channel unless asked by a Ren'Py developer."
new "Ren'Py:n kokeellisia versioita. Sinun ei kannata valita tätä, ellei joku Ren'Py:n kehittäjistä erikseen sitä pyydä."
# game/updater.rpy:129
old "Nightly"
new "Jokaöiset julkaisut"
# game/updater.rpy:135
old "The bleeding edge of Ren'Py development. This may have the latest features, or might not run at all."
new "Upouudet Ren'Py-kehitysjulkaisut. Voi sisältää uusimmat toiminnot, tai ei ehkä toimi lainkaan."
# game/updater.rpy:155
old "An error has occured:"
new "On tapahtunut virhe:"
# game/updater.rpy:157
old "Checking for updates."
new "Haetaan päivityksiä."
# game/updater.rpy:159
old "Ren'Py is up to date."
new "Käytät uusinta Ren'Py-versiota."
# game/updater.rpy:161
old "[u.version] is now available. Do you want to install it?"
new "[u.version] on nyt saatavilla. Haluatko asentaa sen?"
# game/updater.rpy:163
old "Preparing to download the update."
new "Valmistellaan päivityksen lataamista."
# game/updater.rpy:165
old "Downloading the update."
new "Ladataan päivitystä."
# game/updater.rpy:167
old "Unpacking the update."
new "Puretaan päivitystä."
# game/updater.rpy:169
old "Finishing up."
new "Viimeistellään asennusta."
# game/updater.rpy:171
old "The update has been installed. Ren'Py will restart."
new "Päivitys on nyt asennettu. Ren'Py käynnistyy nyt uudelleen."
old "Enter the name of the script file to create."
new "Entrez le nom du fichier de script à créer."
# game/add_file.rpy:10
old "The filename must have the .rpy extension."
new "Le fichier doit avoir l'extension .rpy."
# game/add_file.rpy:18
old "The file already exists."
new "Le fichier éxiste déjà."
# game/add_file.rpy:21
old "# Ren'Py automatically loads all script files ending with .rpy. To use this\n# file, define a label and jump to it from another file.\n"
new "Ren'Py charge automatiquement tous les fichiers de script finissant par .rpy. Pour utiliser ce ficher\n#, définissez un label et faites un «jump» vers lui depuis un autre fichier.\n"
old "To build Android packages, please download RAPT (from {a=http://www.renpy.org/dl/android}here{/a}), unzip it, and place it into the Ren'Py directory. Then restart the Ren'Py launcher."
new "Pour construire les paquets Android, téléchargez RAPT (depuis {a=http://www.renpy.org/dl/android}here{/a}), dézippé le, et placez le dans le répertoire de Ren'Py. Puis, redémarrez Ren'Py."
# game/android.rpy:13
old "RAPT has been installed, but you'll need to install the Android SDK before you can build Android packages. Choose Install SDK to do this."
new "RAPT a été installé, mais vous devez installer le kit de développement Android pour pouvoir construire les paquets Android. Choisissez \"installer le kit de développement et créer les clés\" pour cela"
# game/android.rpy:14
old "RAPT has been installed, but a key hasn't been configured. Please create a new key, or restore android.keystore."
new "RAPT a été installé, mais aucune clé n'a été configurée. Créez une nouvelle clé, ou restaurez android.keystore."
# game/android.rpy:15
old "The current project has not been configured. Use \"Configure\" to configure it before building."
new "Le projet courant n'a pas été configuré. Choisissez \"Configurer\' pour effectuer la configuration."
# game/android.rpy:16
old "Choose \"Build\" to build the current project, or attach an Android device and choose \"Build & Install\" to build and install it on the device."
new "Choisissez \"Construire\" pour construire le projet courant, ou connecté un appareil Android et choisissez \"Construire et Installer\" pour l'installer sur l'appareil."
# game/android.rpy:18
old "Attempts to emulate an Android phone.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "Tentative d'émulation d'un téléphone Android.\n\nLe touché est émulé via la souris, mails uniquement lorsque le bouton est pressé. La barre d'espace correspond au bouton menu, et la touche PageUp correspond au bouton retour."
# game/android.rpy:19
old "Attempts to emulate an Android tablet.\n\nTouch input is emulated through the mouse, but only when the button is held down. Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "Tentative d'émulation d'une tablette Android.\n\nLe touché est émulé via la souris, mails uniquement lorsque le bouton est pressé. La barre d'espace correspond au bouton menu, et la touche PageUp correspond au bouton retour."
# game/android.rpy:20
old "Attempts to emulate an OUYA console.\n\nController input is mapped to the arrow keys, Enter is mapped to the select button, Escape is mapped to the menu button, and PageUp is mapped to the back button."
new "Tentative d'émulation d'une console OUYA.\n\nLe pad est émulé via les flèches du clavier. La touche Entrée correspond au bouton select, la barre d'espace au bouton menu, et la touche PageUp correspond au bouton retour."
# game/android.rpy:22
old "Downloads and installs the Android SDK and supporting packages. Optionally, generates the keys required to sign the package."
new "Télécharge et installe le kit de développement Android et les paquets supportés. Optionnellement, génère les clés requises pour signer le paquet."
# game/android.rpy:23
old "Configures the package name, version, and other information about this project."
new "Configure le nom du packet, sa version et d'autres informations à propos de ce projet."
# game/android.rpy:24
old "Opens the file containing the Google Play keys in the editor.\n\nThis is only needed if the application is using an expansion APK. Read the documentation for more details."
new "Ouvre le fichier contenant les clés Google Play dans l'éditeur.\n\nCela est nécessaire uniquement si l'application utilise une expansion APK. Référez-vous à la documentation pour plus d'informations."
# game/android.rpy:25
old "Builds the Android package."
new "Construire le paquet Android."
# game/android.rpy:26
old "Builds the Android package, and installs it on an Android device connected to your computer."
new "Construire le paquet Android, et l'installer sur l'appareil Android connecté à votre ordinateur."
# game/android.rpy:142
old "{a=%s}%s{/a}"
new "{a=%s}%s{/a}"
# game/android.rpy:361
old "Android: [project.current.name!q]"
new "Android: [project.current.name!q]"
# game/android.rpy:381
old "Emulation:"
new "Émulateur:"
# game/android.rpy:389
old "Phone"
new "Téléphone"
# game/android.rpy:393
old "Tablet"
new "Tablette"
# game/android.rpy:397
old "Television / OUYA"
new "Télévision / OUYA"
# game/android.rpy:409
old "Build:"
new "Construire:"
# game/android.rpy:417
old "Install SDK & Create Keys"
new "Installer le kit de développement et créer les clés"
# game/android.rpy:421
old "Configure"
new "Configurer"
# game/android.rpy:425
old "Build Package"
new "Construire le paquet"
# game/android.rpy:429
old "Build & Install"
new "Construire et installer"
# game/android.rpy:13
old "A 32-bit Java Development Kit is required to build Android packages on Windows. The JDK is different from the JRE, so it's possible you have Java without having the JDK.\n\nPlease {a=http://www.oracle.com/technetwork/java/javase/downloads/index.html}download and install the JDK{/a}, then restart the Ren'Py launcher."
new "Un Kit de Développement Java (JDK) 32 bits est nécessaire pour construire les paquets pour Android depuis Windows. Le JDK n'est pas la même chose que le JRE, il est possible que Java soit installé sur votre machine sans le JDK.\n\n{a=http://www.oracle.com/technetwork/java/javase/downloads/index.html}Téléchargez et installez le JDK{/a}, puis relancer le lanceur Ren'Py."
new "Êtes-vous sûr de vouloir supprimer cette sauvegarde ?"
# renpy/common/00layout.rpy:423
old "Are you sure you want to overwrite your save?"
new "Êtes-vous sûr de vouloir écraser cette sauvegarde ?"
# renpy/common/00layout.rpy:424
old "Loading will lose unsaved progress.\nAre you sure you want to do this?"
new "En effectuant ce chargement, vous perderez votre avancement non sauvegardé.\nÊtes-vous sûr de vouloire faire ça ?"
# renpy/common/00layout.rpy:425
old "Are you sure you want to quit?"
new "Êtes-vous sûr de vouloir quitter ?"
# renpy/common/00layout.rpy:426
old "Are you sure you want to return to the main menu?\nThis will lose unsaved progress."
new "Êtes-vous sûr de vouloir retourner au menu principal ?\nVous perdrez votre avancement non sauvegardé."
# renpy/common/00keymap.rpy:167
old "Saved screenshot as %s."
new "La capture d'écran a été enregistrée en tant que %s"
# renpy/common/00gltest.rpy:50
old "Graphics Acceleration"
new "Accélération graphique"
# renpy/common/00gltest.rpy:54
old "Automatically Choose"
new "Choix automatique"
# renpy/common/00gltest.rpy:59
old "Force Angle/DirectX Renderer"
new "Forcer le rendu Angle/DirectX"
# renpy/common/00gltest.rpy:63
old "Force OpenGL Renderer"
new "Forcer le rendu OpenGL"
# renpy/common/00gltest.rpy:67
old "Force Software Renderer"
new "Forcer le rendu logiciel"
# renpy/common/00gltest.rpy:73
old "Changes will take effect the next time this program is run."
new "Les changement seront pris en compte au prochin démarrage du programme."
# renpy/common/00gltest.rpy:77
old "Quit"
new "Quitter"
# renpy/common/00gltest.rpy:82
old "Return"
new "Retour"
# renpy/common/00gltest.rpy:112
old "Performance Warning"
new "Avertissement sur les performances"
# renpy/common/00gltest.rpy:117
old "This computer is using software rendering."
new "Cet ordinateur utilise le rendu logiciel."
# renpy/common/00gltest.rpy:119
old "This computer is not using shaders."
new "Cet ordinateur n'utilise pas les shaders."
# renpy/common/00gltest.rpy:121
old "This computer is displaying graphics slowly."
new "Cet ordinateur affiche lentement les graphismes."
# renpy/common/00gltest.rpy:123
old "This computer has a problem displaying graphics: [problem]."
new "Cet ordinateur rencontre des difficultés à afficher les graphismes: [problem]."
# renpy/common/00gltest.rpy:128
old "Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display. Updating DirectX could fix this problem."
new "Les pilotes graphiques ne semblent pas à jour ou dysfonctionnent. Cela peut entraîner des ralentissements ou de mauvais affichages. Mettre à jour DirectX pourraît régler ce problème."
# renpy/common/00gltest.rpy:130
old "Its graphics drivers may be out of date or not operating correctly. This can lead to slow or incorrect graphics display."
new "Les pilotes graphiques ne semblent pas à jour ou dysfonctionnent. Cela peut entraîner des ralentissements ou de mauvais affichages."
# renpy/common/00gltest.rpy:135
old "Update DirectX"
new "Mettre à jour DirectX"
# renpy/common/00gltest.rpy:141
old "Continue, Show this warning again"
new "Continer, Afficher cet avertissement la prochaine fois."
# renpy/common/00gltest.rpy:145
old "Continue, Don't show warning again"
new "Continer, Ne plus afficher cet avertissement."
# renpy/common/00gltest.rpy:171
old "Updating DirectX."
new "Mettre à jour de DirectX en cours"
# renpy/common/00gltest.rpy:175
old "DirectX web setup has been started. It may start minimized in the taskbar. Please follow the prompts to install DirectX."
new "La mise à jour de DirectX a débutée. Elle est sans doute minimisée dans la bare de tâche. Merci de suivre les instructions pour installer DirectX."
# renpy/common/00gltest.rpy:179
old "{b}Note:{/b} Microsoft's DirectX web setup program will, by default, install the Bing toolbar. If you do not want this toolbar, uncheck the appropriate box."
new "{b}Note:{/b} le programme d'installation de Microsoft's DirectX va, par defaut, installer la barre d'outils Bing. Si vous ne voulez pas de cette barre, décochez la case appropriée."
# renpy/common/00gltest.rpy:183
old "When setup finishes, please click below to restart this program."
new "Lorsque l'instllation sera terminée, cliquez ci-dessous pour redémarrer ce programme."
# renpy/common/00gltest.rpy:185
old "Restart"
new "Redémarrer"
# renpy/common/_errorhandling.rpym:408
old "An exception has occurred."
new "Une exception a été levée."
# renpy/common/_errorhandling.rpym:434
old "Rollback"
new "Revenir en arrière"
# renpy/common/_errorhandling.rpym:436
old "Attempts a roll back to a prior time, allowing you to save or choose a different choice."
new "Tenter de revenir en arrière, vous permet de sauvegarder ou de faire un autre choix."
# renpy/common/_errorhandling.rpym:439
old "Ignore"
new "Ignorer"
# renpy/common/_errorhandling.rpym:441
old "Ignores the exception, allowing you to continue. This often leads to additional errors."
new "Ignorer l'exception vous permet de continuer. Cela entraîne généralement des erreurs additionelles."
# renpy/common/_errorhandling.rpym:444
old "Reload"
new "Recharger"
# renpy/common/_errorhandling.rpym:446
old "Reloads the game from disk, saving and restoring game state if possible."
new "Recharger le jeu depuis le disque dur and tenter de restaurer le jeu dans l'état actuel."
# renpy/common/_errorhandling.rpym:448
old "Open Traceback"
new "Ouvrir la pile d'appel"
# renpy/common/_errorhandling.rpym:450
old "Opens the traceback.txt file in a text editor."
new "Ouvrir traceback.txt dans un éditeur de texte."
# renpy/common/_errorhandling.rpym:456
old "Quits the game."
new "Quitter le jeu."
# renpy/common/_errorhandling.rpym:483
old "Parsing the script failed."
new "L'analyse du script a échouée."
# renpy/common/_errorhandling.rpym:510
old "Open Parse Errors"
new "Ouvrir les erreurs d'analyse."
# renpy/common/_errorhandling.rpym:512
old "Opens the errors.txt file in a text editor."
new "Ouvrir errors.txt dans un éditeur de texte."
# renpy/common/00action_file.rpy:118
old "%b %d, %H:%M"
new "%b %d, %H:%M"
# renpy/common/_compat/gamemenu.rpym:337
old "Previous"
new "Précédent"
# renpy/common/_compat/gamemenu.rpym:344
old "Next"
new "Suivant"
# renpy/common/00library.rpy:77
old "Skip Mode"
new "Mode rapide"
# renpy/common/00library.rpy:80
old "Fast Skip Mode"
new "Mode très rapide"
# renpy/common/00gallery.rpy:521
old "Image [index] of [count] locked."
new "Image [index] sur [count] verrouillée."
# renpy/common/00gallery.rpy:539
old "prev"
new "précédent"
# renpy/common/00gallery.rpy:540
old "next"
new "suivant"
# renpy/common/00gallery.rpy:541
old "slideshow"
new "diaporama"
# renpy/common/00gallery.rpy:542
old "return"
new "retour"
# renpy/common/00layout.rpy:427
old "Are you sure you want to begin skipping?"
new "Êtes-vous sûr de vouloir commencer à sauter certaines étapes ?"
# renpy/common/00layout.rpy:428
old "Are you sure you want to skip to the next choice?"
new "Êtes-vous sûr de vouloir sauter le prochain choix ?"
# renpy/common/00layout.rpy:429
old "Are you sure you want to skip to unseen dialogue or the next choice?"
new "Êtes-vous sûr de vouloir sauter des dialogues non lus or le prochain choix ?"
new "Création du fichier de mise à jour zsync [variant]."
# game/distribute.rpy:854
old "Processed {b}[complete]{/b} of {b}[total]{/b} files."
new "Traitement du fichier {b}[complete]{/b} sur {b}[total]{/b}."
# game/distribute.rpy:915
old "All packages have been built.\n\nDue to the presence of permission information, unpacking and repacking the Linux and Macintosh distributions on Windows is not supported."
new "Tous les paquets ont été contruits.\n\nDu fait de la présence des systèmes de permissions, il n'est pas possible de reconstruire les paquets construits sur GNU-Linux ou Mac OS sur Windows."
# game/distribute.rpy:358
old "No packages are selected, so there's nothing to do."
new "Aucun paquet sélectionné, il n'y a donc rien à faire."
old "{b}Recommended.{/b} A beta editor with an easy to use interface and features that aid in development, such as spell-checking. Editra currently lacks the IME support required for Chinese, Japanese, and Korean text input."
new "{b}Recommendé.{/b} Un éditeur en version bêta avec une interface simple et des fonctionnalités d'assistance au développement. Editra manque pour le moment du support pour les textes en chinois, japonais et coréen."
# game/editor.rpy:121
old "{b}Recommended.{/b} A beta editor with an easy to use interface and features that aid in development, such as spell-checking. Editra currently lacks the IME support required for Chinese, Japanese, and Korean text input. On Linux, Editra requires wxPython."
new "{b}Recommendé.{/b} Un éditeur en version bêta avec une interface simple et des fonctionnalités d'assistance au développement. Editra manque pour le moment du support pour les textes en chinois, japonais et coréen. Sur GNU-Linux, Editra nécessite wxPython."
# game/editor.rpy:137
old "The may have occured because wxPython is not installed on this system."
new "Cela est sans doute arrivé car wxPython n'est pas installé sur ce système."
# game/editor.rpy:144
old "Up to 22 MB download required."
new "Jusqu'à 22 MB de téléchargement requis."
# game/editor.rpy:157
old "1.8 MB download required."
new "1.8 MB de réléchargement requis."
# game/editor.rpy:158
old "This may have occured because Java is not installed on this system."
new "Cela est sans doute arrivé car Java n'est pas installé sur ce système."
# game/editor.rpy:327
old "An exception occured while launching the text editor:\n[exception!q]"
new "Une exception a été levée lors du lancement de l'édieteur de texte :\n[exception!q]"
# game/editor.rpy:378
old "Select Editor"
new "Sélectionnez un éditeur"
# game/editor.rpy:393
old "A text editor is the program you'll use to edit Ren'Py script files. Here, you can select the editor Ren'Py will use. If not already present, the editor will be automatically downloaded and installed."
new "Un éditeur de texte est un logiciel que vous utilisez pour éditer les fichiers de script Ren'Py. Vous pouvez choisir l'édteur que Ren'Py utilise. Si ce n'est pas déjà le cas, l'éditeur sera automatiquement téléchargé et installé."
# game/editor.rpy:415
old "Cancel"
new "Annuler"
# game/editor.rpy:137
old "This may have occured because wxPython is not installed on this system."
new "Cela est sans doute dû au fait que wxPython n'est pas installé sur votre système."
# game/editor.rpy:155
old "A mature editor that requires Java."
new "Un éditeur éprouvé nécessitant Java."
# game/editor.rpy:164
old "Invokes the editor your operating system has associated with .rpy files."
new "Lance l'éditeur associé par votre systèmes aux fichiers .rpy."
# game/editor.rpy:180
old "Prevents Ren'Py from opening a text editor."
new "Empêche Ren'Py d'ouvrir un éditeur de texte."
old "Please select a template to use for your new project. Ren'Py ships with a default template that creates an English-language game with standard screens."
new "Merci de sélectioner un patron à utiliser pour votre nouveau projet. Ren'Py est livré avec un patron par défaut qui créé un jeu en anglais avec des écrans standards."
# game/new_project.rpy:55
old "PROJECT NAME"
new "NOM DU PROJET"
# game/new_project.rpy:56
old "Please enter the name of your project:"
new "Entrez le nom de votre projet:"
# game/new_project.rpy:62
old "The project name may not be empty."
new "Le nom du projet ne doit pas être vide."
# game/new_project.rpy:67
old "[project_name!q] already exists. Please choose a different project name."
new "Le projet [project_name!q] éxiste déjà. Choisissez un nom de projet différend."
# game/new_project.rpy:70
old "[project_dir!q] already exists. Please choose a different project name."
new "Le projet [project_name!q] éxiste déjà. Choisissez un nom de projet différend."
# game/new_project.rpy:40
old "Please select a template to use for your new project. The template sets the default font and the user interface language. If your language is not supported, choose 'english'."
new "Sélectionnez un gabarit pour votre nouveau projet. Le gabarit définit la police par défaut, ainsi que la langue de l'interface. Si votre langue n'est pas supportée, sélectionnez 'english'."
old "Please choose the projects directory using the directory chooser.\n{b}The directory chooser may have opened behind this window.{/b}"
new "Choisissez le répertoire des projets avec le sélecteur de fichier.\n{b}Il se peut que le sélecteur de fichier s'ouvre derière cette fenêtre.{/b}"
# game/project.rpy:485
old "This launcher will scan for projects in this directory, will create new projects in this directory, and will place built projects into this directory."
new "Ce lanceur va scanner ce répertoire pour trouver des projets éxistants, créra les nouveaux projets dans ce répertoire, et placera les projets construits dans ce répertoire."
# game/project.rpy:525
old "Ren'Py was unable to run python with tkinter to choose the projects directory."
new "Ren'Py n'a pas pu lancer python avec le module tkinker pout choisir le répertoire des projets."
# game/project.rpy:529
old "Ren'Py has set the projects directory to:"
new "Le répertoire des projets vient d'être établit:"
Some files were not shown because too many files have changed in this diff
Show More
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
Tom Rothamel
Spiky Caterpillar
Emmeken
Ricardo Pérez
javimat
RangHo Lee
Diapolo10
Rikxz
Yana
caryoscelus
Konstantin Nikolayev
bbs3223474
asfdfdfd
Renoa
Zigmut
baekansi
tlm-2501
kyouryuukunn
Nolanlemahn
Lukáš 'denzil' Frolka
evilantishad0w
Beuc
Daniel Luque
Lapalissiano
Civa Lin
kalawore
Matias Giachino
Koichi Akabe
Nobody Really
Helloise
Shiz
huanxuantian
duanemoody
antoinentx
M v H
Tom Rothamel
morio
DragoonHP
paulmorio
James Pearson
kyouryuukunn
Christian Koepp
