From ffebbcd2dee04b8c06e90432618e0e013ac5b7dc Mon Sep 17 00:00:00 2001 From: Alex Xu Date: Sun, 30 Mar 2014 13:42:48 -0400 Subject: unrpyc -> ast2json --- unrpyc/renpy/LICENSE.txt | 1024 ------------- unrpyc/renpy/__init__.py | 271 ---- unrpyc/renpy/ast.py | 1757 ----------------------- unrpyc/renpy/atl.py | 1544 -------------------- unrpyc/renpy/display/__init__.py | 31 - unrpyc/renpy/display/accelerator.pyx | 296 ---- unrpyc/renpy/display/anim.py | 634 -------- unrpyc/renpy/display/behavior.py | 1531 -------------------- unrpyc/renpy/display/core.py | 2463 -------------------------------- unrpyc/renpy/display/dragdrop.py | 731 ---------- unrpyc/renpy/display/error.py | 159 --- unrpyc/renpy/display/focus.py | 449 ------ unrpyc/renpy/display/im.py | 1562 -------------------- unrpyc/renpy/display/image.py | 397 ----- unrpyc/renpy/display/imagelike.py | 382 ----- unrpyc/renpy/display/imagemap.py | 233 --- unrpyc/renpy/display/joystick.py | 126 -- unrpyc/renpy/display/layout.py | 1744 ---------------------- unrpyc/renpy/display/minigame.py | 25 - unrpyc/renpy/display/module.py | 275 ---- unrpyc/renpy/display/motion.py | 1526 -------------------- unrpyc/renpy/display/movetransition.py | 640 --------- unrpyc/renpy/display/particle.py | 615 -------- unrpyc/renpy/display/pgrender.py | 167 --- unrpyc/renpy/display/predict.py | 156 -- unrpyc/renpy/display/presplash.py | 113 -- unrpyc/renpy/display/render.pxd | 47 - unrpyc/renpy/display/render.pyx | 1174 --------------- unrpyc/renpy/display/scale.py | 109 -- unrpyc/renpy/display/screen.py | 639 --------- unrpyc/renpy/display/swdraw.py | 1102 -------------- unrpyc/renpy/display/transition.py | 922 ------------ unrpyc/renpy/display/video.py | 234 --- unrpyc/renpy/game.py | 437 ------ unrpyc/renpy/object.py | 60 - 35 files changed, 23575 deletions(-) delete mode 100644 unrpyc/renpy/LICENSE.txt delete mode 100644 unrpyc/renpy/__init__.py delete mode 100644 unrpyc/renpy/ast.py delete mode 100644 unrpyc/renpy/atl.py delete mode 100644 unrpyc/renpy/display/__init__.py delete mode 100644 unrpyc/renpy/display/accelerator.pyx delete mode 100644 unrpyc/renpy/display/anim.py delete mode 100644 unrpyc/renpy/display/behavior.py delete mode 100644 unrpyc/renpy/display/core.py delete mode 100644 unrpyc/renpy/display/dragdrop.py delete mode 100644 unrpyc/renpy/display/error.py delete mode 100644 unrpyc/renpy/display/focus.py delete mode 100644 unrpyc/renpy/display/im.py delete mode 100644 unrpyc/renpy/display/image.py delete mode 100644 unrpyc/renpy/display/imagelike.py delete mode 100644 unrpyc/renpy/display/imagemap.py delete mode 100644 unrpyc/renpy/display/joystick.py delete mode 100644 unrpyc/renpy/display/layout.py delete mode 100644 unrpyc/renpy/display/minigame.py delete mode 100644 unrpyc/renpy/display/module.py delete mode 100644 unrpyc/renpy/display/motion.py delete mode 100644 unrpyc/renpy/display/movetransition.py delete mode 100644 unrpyc/renpy/display/particle.py delete mode 100644 unrpyc/renpy/display/pgrender.py delete mode 100644 unrpyc/renpy/display/predict.py delete mode 100644 unrpyc/renpy/display/presplash.py delete mode 100644 unrpyc/renpy/display/render.pxd delete mode 100644 unrpyc/renpy/display/render.pyx delete mode 100644 unrpyc/renpy/display/scale.py delete mode 100644 unrpyc/renpy/display/screen.py delete mode 100644 unrpyc/renpy/display/swdraw.py delete mode 100644 unrpyc/renpy/display/transition.py delete mode 100644 unrpyc/renpy/display/video.py delete mode 100644 unrpyc/renpy/game.py delete mode 100644 unrpyc/renpy/object.py (limited to 'unrpyc/renpy') diff --git a/unrpyc/renpy/LICENSE.txt b/unrpyc/renpy/LICENSE.txt deleted file mode 100644 index 383a780..0000000 --- a/unrpyc/renpy/LICENSE.txt +++ /dev/null @@ -1,1024 +0,0 @@ -.. highlight:: none - -======= -License -======= - -Most of Ren'Py is covered by the terms of the following (MIT) license: - - 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. - -Portions of Ren'Py are derived from code that is copyright using the -Lesser GNU Public License, so Ren'Py games must be distributed in a -manner that satisfies the LGPL. - -Please see each individual source file for a list of copyright -holders. The artwork in the demo is released by various copyright -holders, under the same terms. - -Ren'Py binaries include code from the following projects: - -* Python (Python License) -* Pygame (LGPL) -* SDL (LGPL) -* SDL_image (LGPL) -* SDL_ttf (LGPL) -* Freetype (LGPL) -* Fribidi (LGPL) -* libav (LGPL) -* libjpeg-turbo (LGPL) -* libpng (PNG license) -* zlib (Zlib License) -* bzip2 (Bzip2 License) -* pyobjc (MIT License) -* py2exe (MIT License) -* GLEW (Modified BSD, MIT) -* zsync (Artistic License) - -For the purpose of LGPL compliance, the source code to all LGPL -software we depend on is either in the Ren'Py package (available from -http://www.renpy.org/), or in the renpy-deps package -(http://www.renpy.org/dl/lgpl/). We believe compliance can be achieved -by including a copy of this license with every copy of Ren'Py you -distribute, and referring to it in your project's README file. - -Ren'Py may be distributed alongside the jEdit or Editra text -editors. Editra is licensed under the wxWindows license, while -jEdit is under the GNU General Public License. - - -GNU Lesser General Public License -================================= - -:: - - GNU LESSER GENERAL PUBLIC LICENSE - Version 2.1, February 1999 - - Copyright (C) 1991, 1999 Free Software Foundation, Inc. - 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - - [This is the first released version of the Lesser GPL. It also counts - as the successor of the GNU Library Public License, version 2, hence - the version number 2.1.] - - Preamble - - The licenses for most software are designed to take away your - freedom to share and change it. By contrast, the GNU General Public - Licenses are intended to guarantee your freedom to share and change - free software--to make sure the software is free for all its users. - - This license, the Lesser General Public License, applies to some - specially designated software packages--typically libraries--of the - Free Software Foundation and other authors who decide to use it. You - can use it too, but we suggest you first think carefully about whether - this license or the ordinary General Public License is the better - strategy to use in any particular case, based on the explanations - below. - - When we speak of free software, we are referring to freedom of use, - not price. Our General Public Licenses are designed to make sure that - you have the freedom to distribute copies of free software (and charge - for this service if you wish); that you receive source code or can get - it if you want it; that you can change the software and use pieces of - it in new free programs; and that you are informed that you can do - these things. - - To protect your rights, we need to make restrictions that forbid - distributors to deny you these rights or to ask you to surrender these - rights. These restrictions translate to certain responsibilities for - you if you distribute copies of the library or if you modify it. - - For example, if you distribute copies of the library, whether gratis - or for a fee, you must give the recipients all the rights that we gave - you. You must make sure that they, too, receive or can get the source - code. If you link other code with the library, you must provide - complete object files to the recipients, so that they can relink them - with the library after making changes to the library and recompiling - it. And you must show them these terms so they know their rights. - - We protect your rights with a two-step method: (1) we copyright the - library, and (2) we offer you this license, which gives you legal - permission to copy, distribute and/or modify the library. - - To protect each distributor, we want to make it very clear that - there is no warranty for the free library. Also, if the library is - modified by someone else and passed on, the recipients should know - that what they have is not the original version, so that the original - author's reputation will not be affected by problems that might be - introduced by others. - - Finally, software patents pose a constant threat to the existence of - any free program. We wish to make sure that a company cannot - effectively restrict the users of a free program by obtaining a - restrictive license from a patent holder. Therefore, we insist that - any patent license obtained for a version of the library must be - consistent with the full freedom of use specified in this license. - - Most GNU software, including some libraries, is covered by the - ordinary GNU General Public License. This license, the GNU Lesser - General Public License, applies to certain designated libraries, and - is quite different from the ordinary General Public License. We use - this license for certain libraries in order to permit linking those - libraries into non-free programs. - - When a program is linked with a library, whether statically or using - a shared library, the combination of the two is legally speaking a - combined work, a derivative of the original library. The ordinary - General Public License therefore permits such linking only if the - entire combination fits its criteria of freedom. The Lesser General - Public License permits more lax criteria for linking other code with - the library. - - We call this license the "Lesser" General Public License because it - does Less to protect the user's freedom than the ordinary General - Public License. It also provides other free software developers Less - of an advantage over competing non-free programs. These disadvantages - are the reason we use the ordinary General Public License for many - libraries. However, the Lesser license provides advantages in certain - special circumstances. - - For example, on rare occasions, there may be a special need to - encourage the widest possible use of a certain library, so that it - becomes a de-facto standard. To achieve this, non-free programs must - be allowed to use the library. A more frequent case is that a free - library does the same job as widely used non-free libraries. In this - case, there is little to gain by limiting the free library to free - software only, so we use the Lesser General Public License. - - In other cases, permission to use a particular library in non-free - programs enables a greater number of people to use a large body of - free software. For example, permission to use the GNU C Library in - non-free programs enables many more people to use the whole GNU - operating system, as well as its variant, the GNU/Linux operating - system. - - Although the Lesser General Public License is Less protective of the - users' freedom, it does ensure that the user of a program that is - linked with the Library has the freedom and the wherewithal to run - that program using a modified version of the Library. - - The precise terms and conditions for copying, distribution and - modification follow. Pay close attention to the difference between a - "work based on the library" and a "work that uses the library". The - former contains code derived from the library, whereas the latter must - be combined with the library in order to run. - - GNU LESSER GENERAL PUBLIC LICENSE - TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION - - 0. This License Agreement applies to any software library or other - program which contains a notice placed by the copyright holder or - other authorized party saying it may be distributed under the terms of - this Lesser General Public License (also called "this License"). - Each licensee is addressed as "you". - - A "library" means a collection of software functions and/or data - prepared so as to be conveniently linked with application programs - (which use some of those functions and data) to form executables. - - The "Library", below, refers to any such software library or work - which has been distributed under these terms. A "work based on the - Library" means either the Library or any derivative work under - copyright law: that is to say, a work containing the Library or a - portion of it, either verbatim or with modifications and/or translated - straightforwardly into another language. (Hereinafter, translation is - included without limitation in the term "modification".) - - "Source code" for a work means the preferred form of the work for - making modifications to it. For a library, complete source code means - all the source code for all modules it contains, plus any associated - interface definition files, plus the scripts used to control - compilation and installation of the library. - - Activities other than copying, distribution and modification are not - covered by this License; they are outside its scope. The act of - running a program using the Library is not restricted, and output from - such a program is covered only if its contents constitute a work based - on the Library (independent of the use of the Library in a tool for - writing it). Whether that is true depends on what the Library does - and what the program that uses the Library does. - - 1. You may copy and distribute verbatim copies of the Library's - complete source code as you receive it, in any medium, provided that - you conspicuously and appropriately publish on each copy an - appropriate copyright notice and disclaimer of warranty; keep intact - all the notices that refer to this License and to the absence of any - warranty; and distribute a copy of this License along with the - Library. - - You may charge a fee for the physical act of transferring a copy, - and you may at your option offer warranty protection in exchange for a - fee. - - 2. You may modify your copy or copies of the Library or any portion - of it, thus forming a work based on the Library, and copy and - distribute such modifications or work under the terms of Section 1 - above, provided that you also meet all of these conditions: - - a) The modified work must itself be a software library. - - b) You must cause the files modified to carry prominent notices - stating that you changed the files and the date of any change. - - c) You must cause the whole of the work to be licensed at no - charge to all third parties under the terms of this License. - - d) If a facility in the modified Library refers to a function or a - table of data to be supplied by an application program that uses - the facility, other than as an argument passed when the facility - is invoked, then you must make a good faith effort to ensure that, - in the event an application does not supply such function or - table, the facility still operates, and performs whatever part of - its purpose remains meaningful. - - (For example, a function in a library to compute square roots has - a purpose that is entirely well-defined independent of the - application. Therefore, Subsection 2d requires that any - application-supplied function or table used by this function must - be optional: if the application does not supply it, the square - root function must still compute square roots.) - - These requirements apply to the modified work as a whole. If - identifiable sections of that work are not derived from the Library, - and can be reasonably considered independent and separate works in - themselves, then this License, and its terms, do not apply to those - sections when you distribute them as separate works. But when you - distribute the same sections as part of a whole which is a work based - on the Library, the distribution of the whole must be on the terms of - this License, whose permissions for other licensees extend to the - entire whole, and thus to each and every part regardless of who wrote - it. - - Thus, it is not the intent of this section to claim rights or contest - your rights to work written entirely by you; rather, the intent is to - exercise the right to control the distribution of derivative or - collective works based on the Library. - - In addition, mere aggregation of another work not based on the Library - with the Library (or with a work based on the Library) on a volume of - a storage or distribution medium does not bring the other work under - the scope of this License. - - 3. You may opt to apply the terms of the ordinary GNU General Public - License instead of this License to a given copy of the Library. To do - this, you must alter all the notices that refer to this License, so - that they refer to the ordinary GNU General Public License, version 2, - instead of to this License. (If a newer version than version 2 of the - ordinary GNU General Public License has appeared, then you can specify - that version instead if you wish.) Do not make any other change in - these notices. - - Once this change is made in a given copy, it is irreversible for - that copy, so the ordinary GNU General Public License applies to all - subsequent copies and derivative works made from that copy. - - This option is useful when you wish to copy part of the code of - the Library into a program that is not a library. - - 4. You may copy and distribute the Library (or a portion or - derivative of it, under Section 2) in object code or executable form - under the terms of Sections 1 and 2 above provided that you accompany - it with the complete corresponding machine-readable source code, which - must be distributed under the terms of Sections 1 and 2 above on a - medium customarily used for software interchange. - - If distribution of object code is made by offering access to copy - from a designated place, then offering equivalent access to copy the - source code from the same place satisfies the requirement to - distribute the source code, even though third parties are not - compelled to copy the source along with the object code. - - 5. A program that contains no derivative of any portion of the - Library, but is designed to work with the Library by being compiled or - linked with it, is called a "work that uses the Library". Such a - work, in isolation, is not a derivative work of the Library, and - therefore falls outside the scope of this License. - - However, linking a "work that uses the Library" with the Library - creates an executable that is a derivative of the Library (because it - contains portions of the Library), rather than a "work that uses the - library". The executable is therefore covered by this License. - Section 6 states terms for distribution of such executables. - - When a "work that uses the Library" uses material from a header file - that is part of the Library, the object code for the work may be a - derivative work of the Library even though the source code is not. - Whether this is true is especially significant if the work can be - linked without the Library, or if the work is itself a library. The - threshold for this to be true is not precisely defined by law. - - If such an object file uses only numerical parameters, data - structure layouts and accessors, and small macros and small inline - functions (ten lines or less in length), then the use of the object - file is unrestricted, regardless of whether it is legally a derivative - work. (Executables containing this object code plus portions of the - Library will still fall under Section 6.) - - Otherwise, if the work is a derivative of the Library, you may - distribute the object code for the work under the terms of Section 6. - Any executables containing that work also fall under Section 6, - whether or not they are linked directly with the Library itself. - - 6. As an exception to the Sections above, you may also combine or - link a "work that uses the Library" with the Library to produce a - work containing portions of the Library, and distribute that work - under terms of your choice, provided that the terms permit - modification of the work for the customer's own use and reverse - engineering for debugging such modifications. - - You must give prominent notice with each copy of the work that the - Library is used in it and that the Library and its use are covered by - this License. You must supply a copy of this License. If the work - during execution displays copyright notices, you must include the - copyright notice for the Library among them, as well as a reference - directing the user to the copy of this License. Also, you must do one - of these things: - - a) Accompany the work with the complete corresponding - machine-readable source code for the Library including whatever - changes were used in the work (which must be distributed under - Sections 1 and 2 above); and, if the work is an executable linked - with the Library, with the complete machine-readable "work that - uses the Library", as object code and/or source code, so that the - user can modify the Library and then relink to produce a modified - executable containing the modified Library. (It is understood - that the user who changes the contents of definitions files in the - Library will not necessarily be able to recompile the application - to use the modified definitions.) - - b) Use a suitable shared library mechanism for linking with the - Library. A suitable mechanism is one that (1) uses at run time a - copy of the library already present on the user's computer system, - rather than copying library functions into the executable, and (2) - will operate properly with a modified version of the library, if - the user installs one, as long as the modified version is - interface-compatible with the version that the work was made with. - - c) Accompany the work with a written offer, valid for at least - three years, to give the same user the materials specified in - Subsection 6a, above, for a charge no more than the cost of - performing this distribution. - - d) If distribution of the work is made by offering access to copy - from a designated place, offer equivalent access to copy the above - specified materials from the same place. - - e) Verify that the user has already received a copy of these - materials or that you have already sent this user a copy. - - For an executable, the required form of the "work that uses the - Library" must include any data and utility programs needed for - reproducing the executable from it. However, as a special exception, - the materials to be distributed need not include anything that is - normally distributed (in either source or binary form) with the major - components (compiler, kernel, and so on) of the operating system on - which the executable runs, unless that component itself accompanies - the executable. - - It may happen that this requirement contradicts the license - restrictions of other proprietary libraries that do not normally - accompany the operating system. Such a contradiction means you cannot - use both them and the Library together in an executable that you - distribute. - - 7. You may place library facilities that are a work based on the - Library side-by-side in a single library together with other library - facilities not covered by this License, and distribute such a combined - library, provided that the separate distribution of the work based on - the Library and of the other library facilities is otherwise - permitted, and provided that you do these two things: - - a) Accompany the combined library with a copy of the same work - based on the Library, uncombined with any other library - facilities. This must be distributed under the terms of the - Sections above. - - b) Give prominent notice with the combined library of the fact - that part of it is a work based on the Library, and explaining - where to find the accompanying uncombined form of the same work. - - 8. You may not copy, modify, sublicense, link with, or distribute - the Library except as expressly provided under this License. Any - attempt otherwise to copy, modify, sublicense, link with, or - distribute the Library is void, and will automatically terminate your - rights under this License. However, parties who have received copies, - or rights, from you under this License will not have their licenses - terminated so long as such parties remain in full compliance. - - 9. You are not required to accept this License, since you have not - signed it. However, nothing else grants you permission to modify or - distribute the Library or its derivative works. These actions are - prohibited by law if you do not accept this License. Therefore, by - modifying or distributing the Library (or any work based on the - Library), you indicate your acceptance of this License to do so, and - all its terms and conditions for copying, distributing or modifying - the Library or works based on it. - - 10. Each time you redistribute the Library (or any work based on the - Library), the recipient automatically receives a license from the - original licensor to copy, distribute, link with or modify the Library - subject to these terms and conditions. You may not impose any further - restrictions on the recipients' exercise of the rights granted herein. - You are not responsible for enforcing compliance by third parties with - this License. - - 11. If, as a consequence of a court judgment or allegation of patent - infringement or for any other reason (not limited to patent issues), - conditions are imposed on you (whether by court order, agreement or - otherwise) that contradict the conditions of this License, they do not - excuse you from the conditions of this License. If you cannot - distribute so as to satisfy simultaneously your obligations under this - License and any other pertinent obligations, then as a consequence you - may not distribute the Library at all. For example, if a patent - license would not permit royalty-free redistribution of the Library by - all those who receive copies directly or indirectly through you, then - the only way you could satisfy both it and this License would be to - refrain entirely from distribution of the Library. - - If any portion of this section is held invalid or unenforceable under - any particular circumstance, the balance of the section is intended to - apply, and the section as a whole is intended to apply in other - circumstances. - - It is not the purpose of this section to induce you to infringe any - patents or other property right claims or to contest validity of any - such claims; this section has the sole purpose of protecting the - integrity of the free software distribution system which is - implemented by public license practices. Many people have made - generous contributions to the wide range of software distributed - through that system in reliance on consistent application of that - system; it is up to the author/donor to decide if he or she is willing - to distribute software through any other system and a licensee cannot - impose that choice. - - This section is intended to make thoroughly clear what is believed to - be a consequence of the rest of this License. - - 12. If the distribution and/or use of the Library is restricted in - certain countries either by patents or by copyrighted interfaces, the - original copyright holder who places the Library under this License - may add an explicit geographical distribution limitation excluding those - countries, so that distribution is permitted only in or among - countries not thus excluded. In such case, this License incorporates - the limitation as if written in the body of this License. - - 13. The Free Software Foundation may publish revised and/or new - versions of the Lesser General Public License from time to time. - Such new versions will be similar in spirit to the present version, - but may differ in detail to address new problems or concerns. - - Each version is given a distinguishing version number. If the Library - specifies a version number of this License which applies to it and - "any later version", you have the option of following the terms and - conditions either of that version or of any later version published by - the Free Software Foundation. If the Library does not specify a - license version number, you may choose any version ever published by - the Free Software Foundation. - - 14. If you wish to incorporate parts of the Library into other free - programs whose distribution conditions are incompatible with these, - write to the author to ask for permission. For software which is - copyrighted by the Free Software Foundation, write to the Free - Software Foundation; we sometimes make exceptions for this. Our - decision will be guided by the two goals of preserving the free status - of all derivatives of our free software and of promoting the sharing - and reuse of software generally. - - NO WARRANTY - - 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO - WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. - EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR - OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY - KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE - LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME - THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. - - 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN - WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY - AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU - FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR - CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE - LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING - RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A - FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF - SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH - DAMAGES. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Libraries - - If you develop a new library, and you want it to be of the greatest - possible use to the public, we recommend making it free software that - everyone can redistribute and change. You can do so by permitting - redistribution under these terms (or, alternatively, under the terms - of the ordinary General Public License). - - To apply these terms, attach the following notices to the library. - It is safest to attach them to the start of each source file to most - effectively convey the exclusion of warranty; and each file should - have at least the "copyright" line and a pointer to where the full - notice is found. - - - - Copyright (C) - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - - Also add information on how to contact you by electronic and paper mail. - - You should also get your employer (if you work as a programmer) or - your school, if any, to sign a "copyright disclaimer" for the library, - if necessary. Here is a sample; alter the names: - - Yoyodyne, Inc., hereby disclaims all copyright interest in the - library `Frob' (a library for tweaking knobs) written by James - Random Hacker. - - , 1 April 1990 - Ty Coon, President of Vice - - That's all there is to it! - - -Python License -============== - -:: - - 1. This LICENSE AGREEMENT is between the Python Software Foundation - ("PSF"), and the Individual or Organization ("Licensee") accessing and - otherwise using Python 2.3 software in source or binary form and its - associated documentation. - - 2. Subject to the terms and conditions of this License Agreement, PSF - hereby grants Licensee a nonexclusive, royalty-free, world-wide - license to reproduce, analyze, test, perform and/or display publicly, - prepare derivative works, distribute, and otherwise use Python 2.3 - alone or in any derivative version, provided, however, that PSF's - License Agreement and PSF's notice of copyright, i.e., "Copyright (c) - 2001, 2002 Python Software Foundation; All Rights Reserved" are - retained in Python 2.3 alone or in any derivative version prepared by - Licensee. - - 3. In the event Licensee prepares a derivative work that is based on - or incorporates Python 2.3 or any part thereof, and wants to make - the derivative work available to others as provided herein, then - Licensee hereby agrees to include in any such work a brief summary of - the changes made to Python 2.3. - - 4. PSF is making Python 2.3 available to Licensee on an "AS IS" - basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR - IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND - DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS - FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 2.3 WILL NOT - INFRINGE ANY THIRD PARTY RIGHTS. - - 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON - 2.3 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS - A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.3, - OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. - - 6. This License Agreement will automatically terminate upon a material - breach of its terms and conditions. - - 7. Nothing in this License Agreement shall be deemed to create any - relationship of agency, partnership, or joint venture between PSF and - Licensee. This License Agreement does not grant permission to use PSF - trademarks or trade name in a trademark sense to endorse or promote - products or services of Licensee, or any third party. - - 8. By copying, installing or otherwise using Python 2.3, Licensee - agrees to be bound by the terms and conditions of this License - Agreement. - -Jpeg License -============ - -:: - - In plain English: - - 1. We don't promise that this software works. (But if you find any bugs, - please let us know!) - 2. You can use this software for whatever you want. You don't have to pay us. - 3. You may not pretend that you wrote this software. If you use it in a - program, you must acknowledge somewhere in your documentation that - you've used the IJG code. - - In legalese: - - The authors make NO WARRANTY or representation, either express or implied, - with respect to this software, its quality, accuracy, merchantability, or - fitness for a particular purpose. This software is provided "AS IS", and you, - its user, assume the entire risk as to its quality and accuracy. - - This software is copyright (C) 1991-1998, Thomas G. Lane. - All Rights Reserved except as specified below. - - Permission is hereby granted to use, copy, modify, and distribute this - software (or portions thereof) for any purpose, without fee, subject to these - conditions: - (1) If any part of the source code for this software is distributed, then this - README file must be included, with this copyright and no-warranty notice - unaltered; and any additions, deletions, or changes to the original files - must be clearly indicated in accompanying documentation. - (2) If only executable code is distributed, then the accompanying - documentation must state that "this software is based in part on the work of - the Independent JPEG Group". - (3) Permission for use of this software is granted only if the user accepts - full responsibility for any undesirable consequences; the authors accept - NO LIABILITY for damages of any kind. - - These conditions apply to any software derived from or based on the IJG code, - not just to the unmodified library. If you use our work, you ought to - acknowledge us. - - Permission is NOT granted for the use of any IJG author's name or company name - in advertising or publicity relating to this software or products derived from - it. This software may be referred to only as "the Independent JPEG Group's - software". - - We specifically permit and encourage the use of this software as the basis of - commercial products, provided that all warranty or liability claims are - assumed by the product vendor. - - -PNG License -=========== - -:: - - The PNG Reference Library is supplied "AS IS". The Contributing Authors - and Group 42, Inc. disclaim all warranties, expressed or implied, - including, without limitation, the warranties of merchantability and of - fitness for any purpose. The Contributing Authors and Group 42, Inc. - assume no liability for direct, indirect, incidental, special, exemplary, - or consequential damages, which may result from the use of the PNG - Reference Library, even if advised of the possibility of such damage. - - Permission is hereby granted to use, copy, modify, and distribute this - source code, or portions hereof, for any purpose, without fee, subject - to the following restrictions: - - 1. The origin of this source code must not be misrepresented. - - 2. Altered versions must be plainly marked as such and must not - be misrepresented as being the original source. - - 3. This Copyright notice may not be removed or altered from any - source or altered source distribution. - - The Contributing Authors and Group 42, Inc. specifically permit, without - fee, and encourage the use of this source code as a component to - supporting the PNG file format in commercial products. If you use this - source code in a product, acknowledgment is not required but would be - appreciated. - -Zlib License -============ - -:: - - This software is provided 'as-is', without any express or implied - warranty. In no event will the authors be held liable for any damages - arising from the use of this software. - - Permission is granted to anyone to use this software for any purpose, - including commercial applications, and to alter it and redistribute it - freely, subject to the following restrictions: - - 1. The origin of this software must not be misrepresented; you must not - claim that you wrote the original software. If you use this software - in a product, an acknowledgment in the product documentation would be - appreciated but is not required. - 2. Altered source versions must be plainly marked as such, and must not be - misrepresented as being the original software. - 3. This notice may not be removed or altered from any source distribution. - - -Bzip2 License -============= - -:: - - This program, "bzip2", the associated library "libbzip2", and all - documentation, are copyright (C) 1996-2005 Julian R Seward. All - rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions - are met: - - 1. Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - - 2. The origin of this software must not be misrepresented; you must - not claim that you wrote the original software. If you use this - software in a product, an acknowledgment in the product - documentation would be appreciated but is not required. - - 3. Altered source versions must be plainly marked as such, and must - not be misrepresented as being the original software. - - 4. The name of the author may not be used to endorse or promote - products derived from this software without specific prior written - permission. - - THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS - OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - -Modified BSD License -==================== - -:: - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - * The name of the author may be used to endorse or promote products - derived from this software without specific prior written permission. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE - LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF - THE POSSIBILITY OF SUCH DAMAGE. - - -Artistic License -================ - -:: - - The Artistic License - Version 2.0beta4, October 2000 - - Copyright (C) 2000, Larry Wall. - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - - Preamble - - This copyright license states the terms under which a given free - software Package may be copied, modified and/or redistributed, while the - Originator(s) maintain some artistic control over the future development - of that Package (at least as much artistic control as can be given under - copyright law while still making the Package open source and free software). - - This license is bound by copyright law, and thus it legally applies only - to works which the copyright holder has permitted copying, distribution - or modification under the terms of the Artistic License, Version 2.0. - - You are reminded that You are always permitted to make arrangements - wholly outside of a given copyright license directly with the copyright - holder(s) of a given Package. If the terms of this license impede your - ability to make full use of the Package, You are encouraged to contact - the copyright holder(s) and seek a different licensing arrangement. - - Definitions - - "Package" refers to the collection of files distributed by the - Originator(s), and derivatives of that collection of files created - through textual modification. - - "Standard Version" refers to the Package if it has not been modified, or - has been modified only in ways suggested by the Originator(s). - - "Modified Version" refers to the Package, if it has been changed by You - via textual modification of the source code, and such changes were not - suggested by the Originator(s). - - "Originator" refers to the author(s) and/or copyright holder(s) of the - Standard Version of the Package. - - "You" and "Your" refers to any person who would like to copy, - distribute, or modify the Package. - - "Distribution Fee" is any fee that You charge for providing a copy of - this Package to another party. It does not refer to licensing fees. - - "Freely Available" means that: - - (a) no fee is charged for the right to use the item (though a - Distribution Fee may be charged). - - (b) recipients of the item may redistribute it under the same - conditions they received it. - - (c) If the item is a binary, object code, bytecode, the complete - corresponding machine-readable source code is included with the - item. - - - Permission for Use and Modification Without Redistribution - - (1) You are permitted to use the Standard Version and create and use - Modified Versions for any purpose without restriction, provided that - you do not redistribute the Modified Version to others outside of your - company or organization. - - - Permissions for Redistribution of the Standard Version - - (2) You may make available verbatim copies of the source code of the - Standard Version of this Package in any medium without restriction, - either gratis or for a Distribution Fee, provided that you duplicate - all of the original copyright notices and associated disclaimers. At - Your discretion, such verbatim copies may or may not include compiled - bytecode, object code or binary versions of the corresponding source - code in the same medium. - - (3) You may apply any bug fixes, portability changes, and other - modifications made available from any of the Originator(s). The - resulting modified Package will still be considered the Standard - Version, and may be copied, modified and redistributed under the terms - of the original license of the Standard Version as if it were the - Standard Version. - - - Permissions for Redistribution of Modified Versions of the Package as Source - - (4) You may modify your copy of the source code of this Package in any way - and distribute that Modified Version (either gratis or for a - Distribution Fee, and with or without a corresponding binary, bytecode - or object code version of the Modified Version) provided that You - clearly indicate what changes You made to the Package, and provided - that You do at least ONE of the following: - - (a) make the Modified Version available to the Originator(s) of the - Standard Version, under the exact license of the Standard - Version, so that the Originator(s) may include your modifications - into the Standard Version (at their discretion). - - (b) modify any installation scripts and procedures so that - installation of the Modified Version will never conflict with an - installation of the Standard Version, include for each program - installed by the Modified Version clear documentation describing - how it differs from the Standard Version, and rename your - Modified Version so that the name is substantially different from - the Standard Version. - - (c) permit and encourage anyone who receives a copy of the Modified - Version permission to make your modifications Freely Available in - some specific way. - - If Your Modified Version is in turn derived from a Modified Version - made by a third party, then You are still required to ensure that Your - Modified Version complies with the requirements of this license. - - - Permissions for Redistribution of Non-Source Versions of Package - - (5) You may distribute binary, object code, bytecode or other non-source - versions of the Standard Version of the Package, provided that you - include complete instructions on where to get the source code of the - Standard Version. Such instructions must be valid at the time of Your - distribution. If these instructions, at any time while You are - carrying our such distribution, become invalid, you must provide new - instructions on demand or cease further distribution. If You cease - distribution within thirty days after You become aware that the - instructions are invalid, then You do not forfeit any of Your rights - under this license. - - (6) You may distribute binary, object code, bytecode or other non-source - versions of a Modified Version provided that You do at least ONE of - the following: - - (a) include a copy of the corresponding source code for the Modified - Version under the terms indicated in (4). - - (b) ensure that the installation of Your non-source Modified Version - does not conflict in any way with an installation of the Standard - Version, include for each program installed by the Modified - Version clear documentation describing how it differs from the - Standard Version, and rename your Modified Version so that the - name is substantially different from the Standard Version. - - (c) ensure that the Modified Version includes notification of the - changes made from the Standard Version, and offer to provide - machine-readable source code (under a license that permits making - that source code Freely Available) of the Modified Version via - mail order. - - - Permissions for Inclusion of the Package in Aggregate Works - - (7) You may aggregate this Package (either the Standard Version or - Modified Version) with other packages and distribute the resulting - aggregation provided that You do not charge a licensing fee for the - Package. Distribution Fees are permitted, and licensing fees for - other packages in the aggregation are permitted. Your permission to - distribute Standard or Modified Versions of the Package is still - subject to the other terms set forth in other sections of this - license. - - (8) In addition to the permissions given elsewhere by this license, You - are also permitted to link Modified and Standard Versions of this - Package with other works and distribute the result without - restriction, provided You have produced binary program(s) that do not - overtly expose the interfaces of the Package. This includes - permission to embed the Package in a larger work of your own without - exposing a direct interface to the Package. This also includes - permission to build stand-alone binary or bytecode versions of your - scripts that require the Package, but do not otherwise give the casual - user direct access to the Package itself. - - - Items That are Never Considered Part of a Modified Version Package - - (9) Works (including, but not limited to, subroutines and scripts) that - you have linked or aggregated with the Package that merely extend or - make use of the Package, but are not intended to cause the Package to - operate differently from the Standard Version, do not, by themselves, - cause the Package to be a Modified Version. In addition, such works - are not considered parts of the Package itself, and are not bound by - the terms of the Package's license. - - - Acceptance of License and Disclaimer of Warranty - - (10) You are not required to accept this License, since you have not signed - it. However, nothing else grants you permission to copy, modify or - distribute the Standard or Modified Versions of the Package. These - actions are prohibited by copyright law if you do not accept this - License. Therefore, by copying, modifying or distributing Standard - and Modified Versions of the Package, you indicate your acceptance of - the license of the Package. - - - (11) Disclaimer of Warranty: - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT UNLESS REQUIRED BY - LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER OR CONTRIBUTOR - BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, - OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT - OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, PROFITS; OR - BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, - EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - - diff --git a/unrpyc/renpy/__init__.py b/unrpyc/renpy/__init__.py deleted file mode 100644 index f2bd463..0000000 --- a/unrpyc/renpy/__init__.py +++ /dev/null @@ -1,271 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This file ensures that renpy packages will be imported in the right -# order. - -import sys -import os - -# Version numbers. -try: - from renpy.vc_version import vc_version; vc_version -except ImportError: - vc_version = 0 - -# The tuple giving the version. This needs to be updated when -# we bump the version. -# -# Be sure to change script_version in launcher/script_version.rpy. -# Be sure to change config.version in tutorial/game/options.rpy. -version_tuple = (6, 15, 4, vc_version) - -# A verbose string computed from that version. -version = "Ren'Py " + ".".join(str(i) for i in version_tuple) - -# Other versions. -script_version = 5003000 -savegame_suffix = "-LT1.save" -bytecode_version = 1 - -# True if this is the first time we've started - even including -# utter restarts. -first_utter_start = True - -def setup_modulefinder(modulefinder): - import _renpy - - libexec = os.path.dirname(_renpy.__file__) - - for i in [ "display", "gl", "angle", "text" ]: - - displaypath = os.path.join(libexec, "renpy", i) - - if os.path.exists(displaypath): - modulefinder.AddPackagePath('renpy.' + i, displaypath) - -def import_cython(): - """ - Never called, but necessary to ensure that modulefinder will properly - grab the various cython modules. - """ - - import renpy.arguments #@UnresolvedImport - - import renpy.display.accelerator #@UnresolvedImport - import renpy.display.render #@UnresolvedImport - - import renpy.gl.gldraw #@UnresolvedImport - import renpy.gl.glenviron_fixed #@UnresolvedImport - import renpy.gl.glenviron_limited #@UnresolvedImport - import renpy.gl.glenviron_shader #@UnresolvedImport - import renpy.gl.glrtt_copy #@UnresolvedImport - import renpy.gl.glrtt_fbo #@UnresolvedImport - import renpy.gl.gltexture #@UnresolvedImport - - import renpy.angle.gldraw #@UnresolvedImport - import renpy.angle.glenviron_shader #@UnresolvedImport - import renpy.angle.glrtt_copy #@UnresolvedImport - import renpy.angle.glrtt_fbo #@UnresolvedImport - import renpy.angle.gltexture #@UnresolvedImport - - -def import_all(): - - - import renpy.display #@UnresolvedImport - - # Adds in the Ren'Py loader. - import renpy.loader #@UnresolvedImport - - import renpy.ast #@UnresolvedImport - import renpy.atl #@UnresolvedImport - import renpy.curry #@UnresolvedImport - import renpy.easy #@UnresolvedImport - import renpy.execution #@UnresolvedImport - import renpy.loadsave #@UnresolvedImport - import renpy.parser #@UnresolvedImport - import renpy.python #@UnresolvedImport - import renpy.script #@UnresolvedImport - import renpy.statements #@UnresolvedImport - import renpy.style #@UnresolvedImport - import renpy.substitutions #@UnresolvedImport - import renpy.translation #@UnresolvedImport - - import renpy.display.presplash #@UnresolvedImport - import renpy.display.pgrender #@UnresolvedImport - import renpy.display.scale #@UnresolvedImport - import renpy.display.module #@UnresolvedImport - - def update_path(package): - """ - Update the __path__ of package, to import binary modules from a libexec - directory. - """ - - name = package.__name__.split(".") - - import _renpy #@UnresolvedImport - libexec = os.path.dirname(_renpy.__file__) - package.__path__.append(os.path.join(libexec, *name)) - - # Also find encodings, to deal with the way py2exe lays things out. - import encodings - libexec = os.path.dirname(encodings.__path__[0]) - package.__path__.append(os.path.join(libexec, *name)) - - update_path(renpy.display) - - import renpy.display.render # Most display stuff depends on this. @UnresolvedImport - import renpy.display.core # object @UnresolvedImport - - import renpy.text #@UnresolvedImport - update_path(renpy.text) - - import renpy.text.ftfont #@UnresolvedImport - import renpy.text.font #@UnresolvedImport - import renpy.text.textsupport #@UnresolvedImport - import renpy.text.texwrap #@UnresolvedImport - import renpy.text.text #@UnresolvedImport - import renpy.text.extras #@UnresolvedImport - - sys.modules['renpy.display.text'] = renpy.text.text - - import renpy.gl #@UnresolvedImport - update_path(renpy.gl) - - import renpy.angle #@UnresolvedImport - update_path(renpy.angle) - - import renpy.display.layout # core @UnresolvedImport - import renpy.display.motion # layout @UnresolvedImport - import renpy.display.behavior # layout @UnresolvedImport - import renpy.display.transition # core, layout @UnresolvedImport - import renpy.display.movetransition # core @UnresolvedImport - import renpy.display.im #@UnresolvedImport - import renpy.display.imagelike #@UnresolvedImport - import renpy.display.image # core, behavior, im, imagelike @UnresolvedImport - import renpy.display.video #@UnresolvedImport - import renpy.display.focus #@UnresolvedImport - import renpy.display.anim #@UnresolvedImport - import renpy.display.particle #@UnresolvedImport - import renpy.display.joystick #@UnresolvedImport - import renpy.display.minigame #@UnresolvedImport - import renpy.display.screen #@UnresolvedImport - import renpy.display.dragdrop #@UnresolvedImport - import renpy.display.imagemap #@UnresolvedImport - import renpy.display.predict #@UnresolvedImport - - import renpy.display.error #@UnresolvedImport - - # Note: For windows to work, renpy.audio.audio needs to be after - # renpy.display.module. - import renpy.audio.audio #@UnresolvedImport - import renpy.audio.music #@UnresolvedImport - import renpy.audio.sound #@UnresolvedImport - - import renpy.ui #@UnresolvedImport - import renpy.screenlang #@UnresolvedImport - - import renpy.lint #@UnresolvedImport - import renpy.warp #@UnresolvedImport - - import renpy.editor #@UnresolvedImport - import renpy.exports #@UnresolvedImport - import renpy.character # depends on exports. @UnresolvedImport - - import renpy.dump #@UnresolvedImport - - import renpy.config # depends on lots. @UnresolvedImport - import renpy.minstore # depends on lots. @UnresolvedImport - import renpy.defaultstore # depends on everything. @UnresolvedImport - import renpy.main #@UnresolvedImport - - # Create the store. - renpy.python.create_store("store") - - # Import the contents of renpy.defaultstore into renpy.store, and set - # up an alias as we do. - renpy.store = sys.modules['store'] - sys.modules['renpy.store'] = sys.modules['store'] - - import subprocess - sys.modules['renpy.subprocess'] = subprocess - - for k, v in renpy.defaultstore.__dict__.items(): - renpy.store.__dict__.setdefault(k, v) - - # Import everything into renpy.exports, provided it isn't - # already there. - for k, v in globals().items(): - vars(renpy.exports).setdefault(k, v) - -# Fool the analyzer. -if False: - import renpy.defaultstore as store - -# This reloads all modules. -def reload_all(): - - import renpy #@UnresolvedImport - - # Shut down the cache thread. - renpy.display.im.cache.quit() - - blacklist = [ "renpy", - "renpy.bootstrap", - "renpy.display", - "renpy.display.pgrender", - "renpy.display.scale" ] - - for i in list(sys.modules.keys()): - if i.startswith("renpy") and i not in blacklist: - del sys.modules[i] - - if i.startswith("store"): - del sys.modules[i] - - import gc - gc.collect() - - renpy.display.draw = None - - import_all() - -# Information about the platform we're running on. We break the platforms -# up into 4 groups - windows-like, mac-like, linux-like, and android-like. -windows = False -macintosh = False -linux = False -android = False - -import platform - -if platform.win32_ver()[0]: - windows = True -elif platform.mac_ver()[0]: - macintosh = True -else: - linux = True - -# The android init code in renpy.py will set linux=False and android=True. - - diff --git a/unrpyc/renpy/ast.py b/unrpyc/renpy/ast.py deleted file mode 100644 index 2f714ce..0000000 --- a/unrpyc/renpy/ast.py +++ /dev/null @@ -1,1757 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This file contains the AST for the Ren'Py script language. Each class -# here corresponds to a statement in the script language. - -# NOTE: -# When updating this file, consider if lint.py or warp.py also need -# updating. - -import renpy.display - -import re -import time -import hashlib -import collections - -def next_node(n): - """ - Indicates the next node that should be executed. When a statement - can crash, this should be set as early as possible, so that ignore - can bring us there. - """ - - renpy.game.context().next_node = n - -class ParameterInfo(object): - """ - This class is used to store information about parameters to a - label. - """ - def __init__(self, parameters, positional, extrapos, extrakw): - - # A list of parameter name, default value pairs. - self.parameters = parameters - - # A list, giving the positional parameters to this function, - # in order. - self.positional = positional - - # A variable that takes the extra positional arguments, if - # any. None if no such variable exists. - self.extrapos = extrapos - - # A variable that takes the extra keyword arguments, if - # any. None if no such variable exists. - self.extrakw = extrakw - -class ArgumentInfo(object): - - def __init__(self, arguments, extrapos, extrakw): - - # A list of (keyword, expression) pairs. If an argument doesn't - # have a keyword, it's thought of as positional. - self.arguments = arguments - - # An expression giving extra positional arguments being - # supplied to this function. - self.extrapos = extrapos - - # An expression giving extra keyword arguments that need - # to be supplied to this function. - self.extrakw = extrakw - - -def __newobj__(cls, *args): - return cls.__new__(cls, *args) - -# This represents a string containing python code. -class PyExpr(str): - - __slots__ = [ - 'filename', - 'linenumber', - ] - - def __new__(cls, s, filename, linenumber): - self = str.__new__(cls, s) - self.filename = filename - self.linenumber = linenumber - return self - - def __getnewargs__(self): - return (str(self), self.filename, self.linenumber) # E1101 - -class PyCode(object): - - __slots__ = [ - 'source', - 'location', - 'mode', - 'bytecode', - 'hash', - ] - - def __getstate__(self): - return (1, self.source, self.location, self.mode) - - def __setstate__(self, state): - (_, self.source, self.location, self.mode) = state - self.bytecode = None - - if renpy.game.script.record_pycode: - renpy.game.script.all_pycode.append(self) - - def __init__(self, source, loc=('', 1), mode='exec'): - - if isinstance(source, PyExpr): - loc = (source.filename, source.linenumber, source) - - # The source code. - self.source = source - - # The time is necessary so we can disambiguate between Python - # blocks on the same line in different script versions. - self.location = loc + ( int(time.time()), ) - self.mode = mode - - # This will be initialized later on, after we are serialized. - self.bytecode = None - - if renpy.game.script.record_pycode: - renpy.game.script.all_pycode.append(self) - - self.hash = None - - def get_hash(self): - try: - if self.hash is not None: - return self.hash - except: - pass - - code = self.source - if isinstance(code, renpy.python.ast.AST): #@UndefinedVariable - code = renpy.python.ast.dump(code) #@UndefinedVariable - - self.hash = chr(renpy.bytecode_version) + hashlib.md5(repr(self.location) + code.encode("utf-8")).digest() - return self.hash - - -def chain_block(block, next): #@ReservedAssignment - """ - This is called to chain together all of the nodes in a block. Node - n is chained with node n+1, while the last node is chained with - next. - """ - - if not block: - return - - for a, b in zip(block, block[1:]): - a.chain(b) - - block[-1].chain(next) - - -class Scry(object): - """ - This is used to store information about the future, if we know it. Unlike - predict, this tries to only get things we _know_ will happen. - """ - - # By default, all attributes are None. - def __getattr__(self, name): - return None - - def __next__(self): #@ReservedAssignment - if self._next is None: - return None - else: - return self._next.scry() - - -class Node(object): - """ - A node in the abstract syntax tree of the program. - - @ivar name: The name of this node. - - @ivar filename: The filename where this node comes from. - @ivar linenumber: The line number of the line on which this node is defined. - """ - - __slots__ = [ - 'name', - 'filename', - 'linenumber', - 'next', - ] - - # True if this node is translatable, false otherwise. (This can be set on - # the class or the instance.) - translatable = False - - # Called to set the state of a Node, when necessary. - def __setstate__(self, state): - for k, v in state[1].items(): - try: - setattr(self, k, v) - except AttributeError: - pass - - - def __init__(self, loc): - """ - Initializes this Node object. - - @param loc: A (filename, physical line number) tuple giving the - logical line on which this Node node starts. - """ - - self.filename, self.linenumber = loc - self.name = None - self.next = None - - def diff_info(self): - """ - Returns a tuple of diff info about ourself. This is used to - compare Nodes to see if they should be considered the same node. The - tuple returned must be hashable. - """ - - return ( id(self), ) - - def get_children(self): - """ - Returns a list of all of the nodes that are children of this - node. (That is, all of the nodes in any block associated with - this node.) - """ - - return [ ] - - def get_init(self): - """ - Returns a node that should be run at init time (that is, before - the normal start of the script.), or None if this node doesn't - care to suggest one. - - (The only class that needs to override this is Init.) - """ - - return None - - def chain(self, next): #@ReservedAssignment - """ - This is called with the Node node that should be followed after - executing this node, and all nodes that this node - executes. (For example, if this node is a block label, the - next is the node that should be executed after all nodes in - the block.) - """ - - self.next = next - - def execute(self): - """ - Causes this node to execute, and any action it entails to be - performed. The node should call next_node with the node to - be executed after this one. - """ - - assert False, "Node subclass forgot to define execute." - - def early_execute(self): - """ - Called when the module is loaded. - """ - - def predict(self): - """ - This is called to predictively load images from this node. It - should cause renpy.display.predict.image and - renpy.display.predict.screen to be called as necessary. - """ - - if self.__next__: - return [ self.__next__ ] - else: - return [ ] - - def scry(self): - """ - Called to return an object with some general, user-definable information - about the future. - """ - - rv = Scry() - rv._next = self.__next__ # W0201 - return rv - - def restructure(self, callback): - """ - Called to restructure the AST. - - When this method is called, callback is called once for each child - block of the node. The block, a list, can be updated by the callback - using slice assignment to the list. - """ - - # Does nothing for nodes that do not contain child blocks. - return - - def get_code(self, dialogue_filter=None): - """ - Returns the canonical form of the code corresponding to this statement. - This only needs to be defined if the statement is translatable. - - `filter` - If present, a filter that should be applied to human-readable - text in the statement. - """ - - raise Exception("Not Implemented") - -def say_menu_with(expression, callback): - """ - This handles the with clause of a say or menu statement. - """ - - if expression is not None: - what = renpy.python.py_eval(expression) - elif renpy.store.default_transition and renpy.game.preferences.transitions == 2: - what = renpy.store.default_transition - else: - return - - if not what: - return - - if renpy.game.preferences.transitions: - # renpy.game.interface.set_transition(what) - callback(what) - -class Say(Node): - - __slots__ = [ - 'who', - 'who_fast', - 'what', - 'with_', - 'interact', - 'attributes', - ] - - def diff_info(self): - return (Say, self.who, self.what) - - def __setstate__(self, state): - self.attributes = None - self.interact = True - Node.__setstate__(self, state) - - def __init__(self, loc, who, what, with_, interact=True, attributes=None): - - super(Say, self).__init__(loc) - - if who is not None: - self.who = who.strip() - - if re.match(r'[a-zA-Z_]\w*$', self.who): - self.who_fast = True - else: - self.who_fast = False - else: - self.who = None - self.who_fast = False - - self.what = what - self.with_ = with_ - self.interact = interact - - # A tuple of attributes that are applied to the character that's - # speaking, or None to disable this behavior. - self.attributes = attributes - - def get_code(self, dialogue_filter=None): - rv = [ ] - - if self.who: - rv.append(self.who) - - if self.attributes is not None: - rv.extend(self.attributes) - - what = self.what - if dialogue_filter is not None: - what = dialogue_filter(what) - - rv.append(renpy.translation.encode_say_string(what)) - - if not self.interact: - rv.append("nointeract") - - if self.with_: - rv.append("with") - rv.append(self.with_) - - return " ".join(rv) - - def execute(self): - - next_node(self.__next__) - - try: - - renpy.exports.say_attributes = self.attributes - - if self.who is not None: - if self.who_fast: - who = getattr(renpy.store, self.who, None) - if who is None: - raise Exception("Sayer '%s' is not defined." % self.who.encode("utf-8")) - else: - who = renpy.python.py_eval(self.who) - else: - who = None - - if not ( - (who is None) or - isinstance(who, collections.Callable) or - isinstance(who, str) ): - - raise Exception("Sayer %s is not a function or string." % self.who.encode("utf-8")) - - what = self.what - if renpy.config.say_menu_text_filter: - what = renpy.config.say_menu_text_filter(what) # E1102 - - if getattr(who, "record_say", True): - renpy.store._last_say_who = self.who - renpy.store._last_say_what = what - - say_menu_with(self.with_, renpy.game.interface.set_transition) - renpy.exports.say(who, what, interact=self.interact) - - finally: - renpy.exports.say_attributes = None - - - def predict(self): - - old_attributes = renpy.exports.say_attributes - - try: - - renpy.exports.say_attributes = self.attributes - - if self.who is not None: - if self.who_fast: - who = getattr(renpy.store, self.who) - else: - who = renpy.python.py_eval(self.who) - else: - who = None - - def predict_with(trans): - renpy.display.predict.displayable(trans(old_widget=None, new_widget=None)) - - say_menu_with(self.with_, predict_with) - - what = self.what - if renpy.config.say_menu_text_filter: - what = renpy.config.say_menu_text_filter(what) - - renpy.exports.predict_say(who, what) - - finally: - renpy.exports.say_attributes = old_attributes - - return [ self.__next__ ] - - def scry(self): - rv = Node.scry(self) - - if self.who is not None: - if self.who_fast: - who = getattr(renpy.store, self.who) - else: - who = renpy.python.py_eval(self.who) - else: - who = None - - if self.interact: - renpy.exports.scry_say(who, rv) - else: - rv.interacts = False - - return rv - -# Copy the descriptor. -setattr(Say, "with", Say.with_) # E1101 - -class Init(Node): - - __slots__ = [ - 'block', - 'priority', - ] - - def __init__(self, loc, block, priority): - super(Init, self).__init__(loc) - - self.block = block - self.priority = priority - - - def get_children(self): - return self.block - - def get_init(self): - return self.priority, self.block[0] - - # We handle chaining specially. We want to chain together the nodes in - # the block, but we want that chain to end in None, and we also want - # this node to just continue on to the next node in normal execution. - def chain(self, next): #@ReservedAssignment - self.next = next - - chain_block(self.block, None) - - def execute(self): - next_node(self.__next__) - - def restructure(self, callback): - callback(self.block) - -def apply_arguments(params, args, kwargs): - """ - Applies arguments to parameters to update scope. - - `scope` - A dict. - - `params` - The parameters object. - - `args`, `kwargs` - Positional and keyword arguments. - """ - - values = { } - rv = { } - - if args is None: - args = () - - if kwargs is None: - kwargs = { } - - if params is None: - if args or kwargs: - raise Exception("Arguments supplied, but parameter list not present") - else: - return rv - - for name, value in zip(params.positional, args): - if name in values: - raise Exception("Parameter %s has two values." % name) - - values[name] = value - - extrapos = tuple(args[len(params.positional):]) - - for name, value in kwargs.items(): - if name in values: - raise Exception("Parameter %s has two values." % name) - - values[name] = value - - for name, default in params.parameters: - - if name not in values: - if default is None: - raise Exception("Required parameter %s has no value." % name) - else: - rv[name] = renpy.python.py_eval(default) - - else: - rv[name] = values[name] - del values[name] - - # Now, values has the left-over keyword arguments, and extrapos - # has the left-over positional arguments. - - if params.extrapos: - rv[params.extrapos] = extrapos - elif extrapos: - raise Exception("Too many arguments in call (expected %d, got %d)." % (len(params.positional), len(args))) - - if params.extrakw: - rv[params.extrakw] = values - else: - if values: - raise Exception("Unknown keyword arguments: %s" % ( ", ".join(list(values.keys())))) - - return rv - -class Label(Node): - - __slots__ = [ - 'name', - 'parameters', - 'block', - 'hide', - ] - - def __setstate__(self, state): - self.parameters = None - self.hide = False - Node.__setstate__(self, state) - - def __init__(self, loc, name, block, parameters, hide=False): - """ - Constructs a new Label node. - - @param name: The name of this label. - @param block: A (potentially empty) list of nodes making up the - block associated with this label. - """ - - super(Label, self).__init__(loc) - - self.name = name - self.block = block - self.parameters = parameters - self.hide = hide - - def diff_info(self): - return (Label, self.name) - - def get_children(self): - return self.block - - def chain(self, next): #@ReservedAssignment - - if self.block: - self.next = self.block[0] - chain_block(self.block, next) - else: - self.next = next - - def execute(self): - next_node(self.__next__) - - renpy.game.context().mark_seen() - - values = apply_arguments(self.parameters, renpy.store._args, renpy.store._kwargs) - - for k, v in values.items(): - renpy.exports.dynamic(k) - setattr(renpy.store, k, v) - - renpy.store._args = None - renpy.store._kwargs = None - - if renpy.config.label_callback: - renpy.config.label_callback(self.name, renpy.game.context().last_abnormal) - - def restructure(self, callback): - callback(self.block) - - -class Python(Node): - - __slots__ = [ - 'hide', - 'code', - 'store', - ] - - def __setstate__(self, state): - self.store = "store" - super(Python, self).__setstate__(state) - - def __init__(self, loc, python_code, hide=False, store="store"): - """ - @param code: A PyCode object. - - @param hide: If True, the code will be executed with its - own local dictionary. - """ - - super(Python, self).__init__(loc) - - self.hide = hide - self.code = PyCode(python_code, loc=loc, mode='exec') - self.store = store - - def diff_info(self): - return (Python, self.code.source) - - def early_execute(self): - renpy.python.create_store(self.store) - - def execute(self): - next_node(self.__next__) - - try: - renpy.python.py_exec_bytecode(self.code.bytecode, self.hide, store=self.store) - finally: - - if not renpy.game.context().init_phase: - for i in renpy.config.python_callbacks: - i() - - def scry(self): - rv = Node.scry(self) - rv.interacts = True - return rv - -class EarlyPython(Node): - - __slots__ = [ - 'hide', - 'code', - 'store', - ] - - def __setstate__(self, state): - self.store = "store" - super(EarlyPython, self).__setstate__(state) - - def __init__(self, loc, python_code, hide=False, store="store"): - """ - @param code: A PyCode object. - - @param hide: If True, the code will be executed with its - own local dictionary. - """ - - super(EarlyPython, self).__init__(loc) - - self.hide = hide - self.code = PyCode(python_code, loc=loc, mode='exec') - self.store = store - - def diff_info(self): - return (EarlyPython, self.code.source) - - def execute(self): - next_node(self.__next__) - - def early_execute(self): - renpy.python.create_store(self.store) - - if self.code.bytecode: - renpy.python.py_exec_bytecode(self.code.bytecode, self.hide, store=self.store) - -class Image(Node): - - __slots__ = [ - 'imgname', - 'code', - 'atl', - ] - - def __init__(self, loc, name, expr=None, atl=None): - """ - @param name: The name of the image being defined. - - @param expr: An expression yielding a Displayable that is - assigned to the image. - """ - - super(Image, self).__init__(loc) - - self.imgname = name - - if expr: - self.code = PyCode(expr, loc=loc, mode='eval') - self.atl = None - else: - self.code = None - self.atl = atl - - def diff_info(self): - return (Image, tuple(self.imgname)) - - def execute(self): - - # Note: We should always check that self.code is None before - # accessing self.atl, as self.atl may not always exist. - - next_node(self.__next__) - - if self.code is not None: - img = renpy.python.py_eval_bytecode(self.code.bytecode) - else: - img = renpy.display.motion.ATLTransform(self.atl) - - renpy.exports.image(self.imgname, img) - - - -class Transform(Node): - - __slots__ = [ - - # The name of the transform. - 'varname', - - # The block of ATL associated with the transform. - 'atl', - - # The parameters associated with the transform, if any. - 'parameters', - ] - - default_parameters = ParameterInfo([ ], [ ], None, None) - - def __init__(self, loc, name, atl=None, parameters=default_parameters): - - super(Transform, self).__init__(loc) - - self.varname = name - self.atl = atl - self.parameters = parameters - - def diff_info(self): - return (Transform, self.varname) - - def execute(self): - - next_node(self.__next__) - - parameters = getattr(self, "parameters", None) - - if parameters is None: - parameters = Transform.default_parameters - - trans = renpy.display.motion.ATLTransform(self.atl, parameters=parameters) - renpy.dump.transforms.append((self.varname, self.filename, self.linenumber)) - setattr(renpy.store, self.varname, trans) - - -def predict_imspec(imspec, scene=False, atl=None): - """ - Call this to use the given callback to predict the image named - in imspec. - """ - - if len(imspec) == 7: - name, expression, tag, _at_list, layer, _zorder, _behind = imspec - - elif len(imspec) == 6: - name, expression, tag, _at_list, layer, _zorder = imspec - - elif len(imspec) == 3: - name, _at_list, layer = imspec - - - if expression: - try: - img = renpy.python.py_eval(expression) - img = renpy.easy.displayable(img) - except: - return - - else: - img = renpy.display.image.images.get(name, None) - if img is None: - return - - full_name = name - if tag: - full_name = (tag,) + full_name[1:] - - if scene: - renpy.game.context().images.predict_scene(layer) - - renpy.game.context().images.predict_show(tag or name, layer) - - if atl is not None: - try: - img = renpy.display.motion.ATLTransform(atl, child=img) - except: - import traceback - traceback.print_exc() - - renpy.display.predict.displayable(img) - - - -def show_imspec(imspec, atl=None): - - if len(imspec) == 7: - name, expression, tag, at_list, layer, zorder, behind = imspec - - elif len(imspec) == 6: - name, expression, tag, at_list, layer, zorder = imspec - behind = [ ] - - elif len(imspec) == 3: - name, at_list, layer = imspec - expression = None - tag = None - zorder = None - behind = [ ] - - if zorder is not None: - zorder = renpy.python.py_eval(zorder) - else: - zorder = 0 - - if expression is not None: - expression = renpy.python.py_eval(expression) - expression = renpy.easy.displayable(expression) - - at_list = [ renpy.python.py_eval(i) for i in at_list ] - - renpy.config.show(name, - at_list=at_list, - layer=layer, - what=expression, - zorder=zorder, - tag=tag, - behind=behind, - atl=atl) - -class Show(Node): - - __slots__ = [ - 'imspec', - 'atl', - ] - - def __init__(self, loc, imspec, atl=None): - """ - @param imspec: A triple consisting of an image name (itself a - tuple of strings), a list of at expressions, and a layer. - """ - - super(Show, self).__init__(loc) - - self.imspec = imspec - self.atl = atl - - def diff_info(self): - return (Show, tuple(self.imspec[0])) - - def execute(self): - next_node(self.__next__) - - show_imspec(self.imspec, atl=getattr(self, "atl", None)) - - def predict(self): - predict_imspec(self.imspec, atl=getattr(self, "atl", None)) - return [ self.__next__ ] - - -class Scene(Node): - - __slots__ = [ - 'imspec', - 'layer', - 'atl', - ] - - def __init__(self, loc, imgspec, layer, atl=None): - """ - @param imspec: A triple consisting of an image name (itself a - tuple of strings), a list of at expressions, and a layer, or - None to not have this scene statement also display an image. - """ - - super(Scene, self).__init__(loc) - - self.imspec = imgspec - self.layer = layer - self.atl = atl - - def diff_info(self): - - if self.imspec: - data = tuple(self.imspec[0]) - else: - data = None - - return (Scene, data) - - def execute(self): - - next_node(self.__next__) - - renpy.config.scene(self.layer) - - if self.imspec: - show_imspec(self.imspec, atl=getattr(self, "atl", None)) - - def predict(self): - - if self.imspec: - predict_imspec(self.imspec, atl=getattr(self, "atl", None), scene=True) - - return [ self.__next__ ] - - -class Hide(Node): - - __slots__ = [ - 'imspec', - ] - - def __init__(self, loc, imgspec): - """ - @param imspec: A triple consisting of an image name (itself a - tuple of strings), a list of at expressions, and a list of - with expressions. - """ - - super(Hide, self).__init__(loc) - - self.imspec = imgspec - - def diff_info(self): - return (Hide, tuple(self.imspec[0])) - - def predict(self): - - if len(self.imspec) == 3: - name, _at_list, layer = self.imspec - tag = None - _expression = None - _zorder = None - _behind = None - elif len(self.imspec) == 6: - name, _expression, tag, _at_list, layer, _zorder = self.imspec - _behind = None - elif len(self.imspec) == 7: - name, _expression, tag, _at_list, layer, _zorder, _behind = self.imspec - - - if tag is None: - tag = name[0] - - renpy.game.context().images.predict_hide(tag, layer) - - return [ self.__next__ ] - - def execute(self): - - next_node(self.__next__) - - if len(self.imspec) == 3: - name, _at_list, layer = self.imspec - _expression = None - tag = None - _zorder = 0 - elif len(self.imspec) == 6: - name, _expression, tag, _at_list, layer, _zorder = self.imspec - elif len(self.imspec) == 7: - name, _expression, tag, _at_list, layer, _zorder, _behind = self.imspec - - renpy.config.hide(tag or name, layer) - - -class With(Node): - - __slots__ = [ - 'expr', - 'paired', - ] - - def __setstate__(self, state): - self.paired = None - Node.__setstate__(self, state) - - def __init__(self, loc, expr, paired=None): - """ - @param expr: An expression giving a transition or None. - """ - - super(With, self).__init__(loc) - self.expr = expr - self.paired = paired - - def diff_info(self): - return (With, self.expr) - - def execute(self): - - next_node(self.__next__) - - trans = renpy.python.py_eval(self.expr) - - if self.paired is not None: - paired = renpy.python.py_eval(self.paired) - else: - paired = None - - renpy.exports.with_statement(trans, paired) - - def predict(self): - - try: - trans = renpy.python.py_eval(self.expr) - - if trans: - renpy.display.predict.displayable(trans(old_widget=None, new_widget=None)) - - except: - pass - - - return [ self.__next__ ] - - -class Call(Node): - - __slots__ = [ - 'label', - 'arguments', - 'expression', - ] - - def __setstate__(self, state): - self.arguments = None - Node.__setstate__(self, state) - - def __init__(self, loc, label, expression, arguments): - - super(Call, self).__init__(loc) - self.label = label - self.expression = expression - self.arguments = arguments - - def diff_info(self): - return (Call, self.label, self.expression) - - def execute(self): - - label = self.label - if self.expression: - label = renpy.python.py_eval(label) - - rv = renpy.game.context().call(label, return_site=self.next.name) - next_node(rv) - renpy.game.context().abnormal = True - - if self.arguments: - - args = [ ] - kwargs = renpy.python.RevertableDict() - - for name, expr in self.arguments.arguments: - - value = renpy.python.py_eval(expr) - - if name is None: - args.append(value) - else: - if name in kwargs: - raise Exception("The argument named %s appears twice." % name) - - kwargs[name] = value - - if self.arguments.extrapos: - args.extend(renpy.python.py_eval(self.arguments.extrapos)) - - if self.arguments.extrakw: - for name, value in renpy.python.py_eval(self.arguments.extrakw).items(): - if name in kwargs: - raise Exception("The argument named %s appears twice." % name) - - kwargs[name] = value - - - renpy.store._args = tuple(args) - renpy.store._kwargs = kwargs - - def predict(self): - if self.expression: - return [ ] - else: - return [ renpy.game.script.lookup(self.label) ] - - def scry(self): - rv = Node.scry(self) - rv._next = None - return rv - - -class Return(Node): - - __slots__ = [ 'expression'] - - def __setstate__(self, state): - self.expression = None - Node.__setstate__(self, state) - - def __init__(self, loc, expression): - super(Return, self).__init__(loc) - self.expression = expression - - def diff_info(self): - return (Return, ) - - # We don't care what the next node is. - def chain(self, next): #@ReservedAssignment - self.next = None - return - - def execute(self): - - if self.expression: - renpy.store._return = renpy.python.py_eval(self.expression) - else: - renpy.store._return = None - - renpy.game.context().pop_dynamic() - - next_node(renpy.game.context().lookup_return(pop=True)) - - def predict(self): - site = renpy.game.context().lookup_return(pop=False) - if site: - return [ site ] - else: - return [ ] - - def scry(self): - rv = Node.scry(self) - rv._next = None - return rv - - -class Menu(Node): - - __slots__ = [ - 'items', - 'set', - 'with_', - ] - - def __init__(self, loc, items, set, with_): #@ReservedAssignment - super(Menu, self).__init__(loc) - - self.items = items - self.set = set - self.with_ = with_ - - def diff_info(self): - return (Menu,) - - def get_children(self): - rv = [ ] - - for _label, _condition, block in self.items: - if block: - rv.extend(block) - - return rv - - # Blocks of statements in a choice continue after the menu. - def chain(self, next): #@ReservedAssignment - - self.next = next - - for (_label, _condition, block) in self.items: - if block: - chain_block(block, next) - - def execute(self): - - next_node(self.__next__) - - choices = [ ] - narration = [ ] - - for i, (label, condition, block) in enumerate(self.items): - - if renpy.config.say_menu_text_filter: - label = renpy.config.say_menu_text_filter(label) - - if block is None: - if renpy.config.narrator_menu and label: - narration.append(label) - else: - choices.append((label, condition, None)) - else: - choices.append((label, condition, i)) - next_node(block[0]) - - if narration: - renpy.exports.say(None, "\n".join(narration), interact=False) - - say_menu_with(self.with_, renpy.game.interface.set_transition) - choice = renpy.exports.menu(choices, self.set) - - if choice is not None: - next_node(self.items[choice][2][0]) - else: - next_node(self.__next__) - - - def predict(self): - rv = [ ] - - def predict_with(trans): - renpy.display.predict.displayable(trans(old_widget=None, new_widget=None)) - - say_menu_with(self.with_, predict_with) - - renpy.store.predict_menu() - - for _label, _condition, block in self.items: - if block: - rv.append(block[0]) - - return rv - - def scry(self): - rv = Node.scry(self) - rv._next = None - rv.interacts = True - return rv - - def restructure(self, callback): - for _label, _condition, block in self.items: - if block is not None: - callback(block) - -setattr(Menu, "with", Menu.with_) # E1101 - - -# Goto is considered harmful. So we decided to name it "jump" -# instead. -class Jump(Node): - - __slots__ = [ - 'target', - 'expression', - ] - - def __init__(self, loc, target, expression): - super(Jump, self).__init__(loc) - - self.target = target - self.expression = expression - - def diff_info(self): - return (Jump, self.target, self.expression) - - # We don't care what our next node is. - def chain(self, next): #@ReservedAssignment - self.next = None - return - - def execute(self): - - target = self.target - if self.expression: - target = renpy.python.py_eval(target) - - rv = renpy.game.script.lookup(target) - renpy.game.context().abnormal = True - - next_node(rv) - - def predict(self): - - if self.expression: - return [ ] - else: - return [ renpy.game.script.lookup(self.target) ] - - def scry(self): - rv = Node.scry(self) - if self.expression: - rv._next = None - else: - rv._next = renpy.game.script.lookup(self.target) - - return rv - - -# GNDN -class Pass(Node): - - __slots__ = [ ] - - def diff_info(self): - return (Pass,) - - def execute(self): - next_node(self.__next__) - - -class While(Node): - - __slots__ = [ - 'condition', - 'block', - ] - - def __init__(self, loc, condition, block): - super(While, self).__init__(loc) - - self.condition = condition - self.block = block - - def diff_info(self): - return (While, self.condition) - - def get_children(self): - return self.block - - def chain(self, next): #@ReservedAssignment - self.next = next - chain_block(self.block, self) - - def execute(self): - - next_node(self.__next__) - - if renpy.python.py_eval(self.condition): - next_node(self.block[0]) - - def predict(self): - return [ self.block[0], self.__next__ ] - - def scry(self): - rv = Node.scry(self) - rv._next = None - return rv - - def restructure(self, callback): - callback(self.block) - -class If(Node): - - __slots__ = [ 'entries' ] - - def __init__(self, loc, entries): - """ - @param entries: A list of (condition, block) tuples. - """ - - super(If, self).__init__(loc) - - self.entries = entries - - def diff_info(self): - return (If,) - - def get_children(self): - rv = [ ] - - for _condition, block in self.entries: - rv.extend(block) - - return rv - - def chain(self, next): #@ReservedAssignment - self.next = next - - for _condition, block in self.entries: - chain_block(block, next) - - def execute(self): - - next_node(self.__next__) - - for condition, block in self.entries: - if renpy.python.py_eval(condition): - next_node(block[0]) - return - - def predict(self): - - return [ block[0] for _condition, block in self.entries ] + \ - [ self.__next__ ] - - def scry(self): - rv = Node.scry(self) - rv._next = None - return rv - - def restructure(self, callback): - for _condition, block in self.entries: - callback(block) - -class UserStatement(Node): - - __slots__ = [ - 'line', - 'parsed', - 'block', - 'translatable' ] - - def __setstate__(self, state): - self.block = [ ] - self.translatable = False - Node.__setstate__(self, state) - - def __init__(self, loc, line, block): - - super(UserStatement, self).__init__(loc) - self.line = line - self.block = block - self.parsed = None - - # Do not store the parse quite yet. - _parse_info = renpy.statements.parse(self, self.line, self.block) - - def diff_info(self): - return (UserStatement, self.line) - - def execute(self): - next_node(self.get_next()) - - self.call("execute") - - def predict(self): - self.call("predict") - return [ self.get_next() ] - - def call(self, method, *args, **kwargs): - - parsed = self.parsed - if parsed is None: - parsed = renpy.statements.parse(self, self.line, self.block) - self.parsed = parsed - - renpy.statements.call(method, parsed, *args, **kwargs) - - def get_next(self): - rv = self.call("next") - if rv is not None: - return renpy.game.script.lookup(rv) - else: - return self.__next__ - - def scry(self): - rv = Node.scry(self) - rv._next = self.get_next() - self.call("scry", rv) - return rv - - def get_code(self, dialogue_filter=None): - return self.line - - -class Define(Node): - - __slots__ = [ - 'varname', - 'code', - ] - - def __init__(self, loc, name, expr): - """ - @param name: The name of the image being defined. - - @param expr: An expression yielding a Displayable that is - assigned to the image. - """ - - super(Define, self).__init__(loc) - - self.varname = name - self.code = PyCode(expr, loc=loc, mode='eval') - - def diff_info(self): - return (Define, tuple(self.varname)) - - def execute(self): - - next_node(self.__next__) - - value = renpy.python.py_eval_bytecode(self.code.bytecode) - renpy.dump.definitions.append((self.varname, self.filename, self.linenumber)) - setattr(renpy.store, self.varname, value) - - -class Screen(Node): - - __slots__ = [ - 'screen', - ] - - def __init__(self, loc, screen): - """ - @param name: The name of the image being defined. - - @param expr: An expression yielding a Displayable that is - assigned to the image. - """ - - super(Screen, self).__init__(loc) - - self.screen = screen - - def diff_info(self): - return (Screen, self.screen.name) - - def execute(self): - next_node(self.__next__) - self.screen.define() - renpy.dump.screens.append((self.screen.name, self.filename, self.linenumber)) - - -################################################################################ -# Translations -################################################################################ - -class Translate(Node): - """ - A translation block, produced either by explicit translation statements - or implicit translation blocs. - - If language is None, when executed this transfers control to the translate - statement in the current language, if any, and otherwise runs the block. - If language is not None, causes an error to occur if control reaches this - statement. - - When control normally leaves a translate statement, in any language, it - goes to the end of the translate statement in the None language. - """ - - __slots__ = [ - "identifier", - "language", - "block", - ] - - def __init__(self, loc, identifier, language, block): - super(Translate, self).__init__(loc) - - self.identifier = identifier - self.language = language - self.block = block - - def diff_info(self): - return (Translate, self.identifier, self.language) - - def chain(self, next): #@ReservedAssignment - self.next = next - chain_block(self.block, next) - - def execute(self): - - if self.language is not None: - next_node(self.__next__) - raise Exception("Translation nodes cannot be run directly.") - - next_node(renpy.game.script.translator.lookup_translate(self.identifier)) - renpy.game.context().translate_identifier = self.identifier - - def predict(self): - node = renpy.game.script.translator.lookup_translate(self.identifier) - return [ node ] - - def scry(self): - rv = Scry() - rv._next = renpy.game.script.translator.lookup_translate(self.identifier) - return rv - - def get_children(self): - return self.block - - def restructure(self, callback): - return callback(self.block) - - -class EndTranslate(Node): - """ - A node added implicitly after each translate block. It's responsible for - resetting the translation identifier. - """ - - def __init__(self, loc): - super(EndTranslate, self).__init__(loc) - - def diff_info(self): - return (EndTranslate,) - - def execute(self): - next_node(self.__next__) - renpy.game.context().translate_identifier = None - - -class TranslateString(Node): - """ - A node used for translated strings. - """ - - __slots__ = [ - "language", - "old", - "new" - ] - - def __init__(self, loc, language, old, new): - super(TranslateString, self).__init__(loc) - self.language = language - self.old = old - self.new = new - - def diff_info(self): - return (TranslateString,) - - def execute(self): - next_node(self.__next__) - renpy.translation.add_string_translation(self.language, self.old, self.new) - -class TranslatePython(Node): - - __slots__ = [ - 'language', - 'code', - ] - - def __init__(self, loc, language, python_code): - """ - @param code: A PyCode object. - - @param hide: If True, the code will be executed with its - own local dictionary. - """ - - super(TranslatePython, self).__init__(loc) - - self.language = language - self.code = PyCode(python_code, loc=loc, mode='exec') - - def diff_info(self): - return (TranslatePython, self.code.source) - - def execute(self): - next_node(self.__next__) - - # def early_execute(self): - # renpy.python.create_store(self.store) - # renpy.python.py_exec_bytecode(self.code.bytecode, self.hide, store=self.store) - - diff --git a/unrpyc/renpy/atl.py b/unrpyc/renpy/atl.py deleted file mode 100644 index f314e3e..0000000 --- a/unrpyc/renpy/atl.py +++ /dev/null @@ -1,1544 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -import renpy.display -import random - -def compiling(loc): - file, number = loc #@ReservedAssignment - - renpy.game.exception_info = "Compiling ATL code at %s:%d" % (file, number) - -def executing(loc): - file, number = loc #@ReservedAssignment - - renpy.game.exception_info = "Executing ATL code at %s:%d" % (file, number) - - -# A map from the name of a time warp function to the function itself. -warpers = { } - -def atl_warper(f): - name = f.__name__ - warpers[name] = f - return f - -# The pause warper is used internally when no other warper is -# specified. -@atl_warper -def pause(t): - if t < 1.0: - return 0.0 - else: - return 1.0 - -position = object() - -# A dictionary giving property names and the corresponding default -# values. -PROPERTIES = { - "pos" : (position, position), - "xpos" : position, - "ypos" : position, - "anchor" : (position, position), - "xanchor" : position, - "yanchor" : position, - "xaround" : position, - "yaround" : position, - "xanchoraround" : float, - "yanchoraround" : float, - "align" : (float, float), - "xalign" : float, - "yalign" : float, - "rotate" : float, - "rotate_pad" : bool, - "transform_anchor" : bool, - "xzoom" : float, - "yzoom" : float, - "zoom" : float, - "alpha" : float, - "around" : (position, position), - "alignaround" : (float, float), - "angle" : float, - "radius" : float, - "crop" : (float, float, float, float), - "size" : (int, int), - "corner1" : (float, float), - "corner2" : (float, float), - "subpixel" : bool, - "delay" : float, - "xoffset" : float, - "yoffset" : float, - "offset" : (int, int), - "xcenter" : position, - "ycenter" : position, - } - - -def correct_type(v, b, ty): - """ - Corrects the type of v to match ty. b is used to inform the match. - """ - - if ty is position: - if v is None: - return None - else: - return type(b)(v) - else: - return ty(v) - - -def interpolate(t, a, b, type): #@ReservedAssignment - """ - Linearly interpolate the arguments. - """ - - if t >= 1.0: - return b - - # Recurse into tuples. - if isinstance(b, tuple): - if a is None: - a = [ None ] * len(b) - - return tuple(interpolate(t, i, j, ty) for i, j, ty in zip(a, b, type)) - - # Deal with booleans, nones, etc. - elif b is None or isinstance(b, bool): - if t >= 1.0: - return b - else: - return a - - # Interpolate everything else. - else: - if a is None: - a = 0 - - return correct_type(a + t * (b - a), b, type) - -# Interpolate the value of a spline. This code is based on Aenakume's code, -# from 00splines.rpy. -def interpolate_spline(t, spline): - - if isinstance(spline[-1], tuple): - return tuple(interpolate_spline(t, i) for i in zip(*spline)) - - if spline[0] is None: - return spline[-1] - - if len(spline) == 2: - t_p = 1.0 - t - - rv = t_p * spline[0] + t * spline[-1] - - elif len(spline) == 3: - t_pp = (1.0 - t)**2 - t_p = 2 * t * (1.0 - t) - t2 = t**2 - - rv = t_pp * spline[0] + t_p * spline[1] + t2 * spline[2] - - elif len(spline) == 4: - - t_ppp = (1.0 - t)**3 - t_pp = 3 * t * (1.0 - t)**2 - t_p = 3 * t**2 * (1.0 - t) - t3 = t**3 - - rv = t_ppp * spline[0] + t_pp * spline[1] + t_p * spline[2] + t3 * spline[3] - - else: - raise Exception("ATL can't interpolate splines of length %d." % len(spline)) - - return correct_type(rv, spline[-1], position) - - -# This is the context used when compiling an ATL statement. It stores the -# scopes that are used to evaluate the various expressions in the statement, -# and has a method to do the evaluation and return a result. -class Context(object): - def __init__(self, context): - self.context = context - - def eval(self, expr): #@ReservedAssignment - expr = renpy.python.escape_unicode(expr) - return eval(expr, renpy.store.__dict__, self.context) #@UndefinedVariable - -# This is intended to be subclassed by ATLTransform. It takes care of -# managing ATL execution, which allows ATLTransform itself to not care -# much about the contents of this file. -class ATLTransformBase(renpy.object.Object): - - # Compatibility with older saves. - parameters = renpy.ast.ParameterInfo([ ], [ ], None, None) - - def __init__(self, atl, context, parameters): - - # The constructor will be called by atltransform. - - if parameters is None: - parameters = ATLTransformBase.parameters - - # The parameters that we take. - self.parameters = parameters - - # The raw code that makes up this ATL statement. - self.atl = atl - - # The context in which execution occurs. - self.context = Context(context) - - # The code after it has been compiled into a block. - self.block = None - - # The properties of the block, if it contains only an - # Interpolation. - self.properties = None - - # The state of the statement we are executing. As this can be - # shared between more than one object (in the case of a hide), - # the data must not be altered. - self.atl_state = None - - # Are we done? - self.done = False - - # The transform event we are going to process. - self.transform_event = None - - # The transform event we last processed. - self.last_transform_event = None - - # The child transform event we last processed. - self.last_child_transform_event = None - - def take_execution_state(self, t): - """ - Updates self to begin executing from the same point as t. This - requires that t.atl is self.atl. - """ - - super(ATLTransformBase, self).take_execution_state(t) - - if t.atl is not self.atl: - return - - self.done = t.done - self.block = t.block - self.atl_state = t.atl_state - self.transform_event = t.transform_event - self.last_transform_event = t.last_transform_event - self.last_child_transform_event = t.last_child_transform_event - - self.st = t.st - self.at = t.at - self.st_offset = t.st_offset - self.at_offset = t.at_offset - - if self.child is renpy.display.motion.null: - self.child = t.child - - - def __call__(self, *args, **kwargs): - - context = self.context.context.copy() - - for k, v in self.parameters.parameters: - if v is not None: - context[k] = renpy.python.py_eval(v) - - positional = list(self.parameters.positional) - args = list(args) - - child = None - - if not positional and args: - child = args.pop(0) - - # Handle positional arguments. - while positional and args: - name = positional.pop(0) - value = args.pop(0) - - if name in kwargs: - raise Exception('Parameter %r is used as both a positional and keyword argument to a transition.' % name) - - context[name] = value - - if args: - raise Exception("Too many arguments passed to ATL transform.") - - # Handle keyword arguments. - for k, v in kwargs.items(): - - if k in positional: - positional.remove(k) - context[k] = v - elif k in context: - context[k] = v - elif k == 'child': - child = v - else: - raise Exception('Parameter %r is not known by ATL Transform.' % k) - - if child is None: - child = self.child - - if child is None: - child = renpy.display.motion.get_null() - - # Create a new ATL Transform. - parameters = renpy.ast.ParameterInfo({}, positional, None, None) - - rv = renpy.display.motion.ATLTransform( - atl=self.atl, - child=child, - style=self.style_arg, - context=context, - parameters=parameters) - - rv.take_state(self) - - return rv - - - def compile(self): #@ReservedAssignment - """ - Compiles the ATL code into a block. As necessary, updates the - properties. - """ - - if self.parameters.positional and self.parameters.positional[0][1] is None: - raise Exception("Cannot compile ATL Transform, as it's missing positional parameter %s." % self.parameters.positional[0]) - - old_exception_info = renpy.game.exception_info - - self.block = self.atl.compile(self.context) - - if len(self.block.statements) == 1 \ - and isinstance(self.block.statements[0], Interpolation): - - interp = self.block.statements[0] - - if interp.duration == 0 and interp.properties: - self.properties = interp.properties[:] - - renpy.game.exception_info = old_exception_info - - - def execute(self, trans, st, at): - - if self.done: - return None - - if not self.block: - self.compile() - - # Propagate transform_events from children. - if self.child: - if self.child.transform_event != self.last_child_transform_event: - self.last_child_transform_event = self.child.transform_event - self.transform_event = self.child.transform_event - - # Hide request. - if trans.hide_request: - self.transform_event = "hide" - - if trans.replaced_request: - self.transform_event = "replaced" - - # Notice transform events. - if self.transform_event != self.last_transform_event: - event = self.transform_event - self.last_transform_event = self.transform_event - else: - event = None - - old_exception_info = renpy.game.exception_info - - if self.atl.animation: - timebase = at - else: - timebase = st - - action, arg, pause = self.block.execute(trans, timebase, self.atl_state, event) - - renpy.game.exception_info = old_exception_info - - # print "Executing", self, self.state, self.xpos, self.ypos - - if action == "continue": - self.atl_state = arg - else: - self.done = True - - return pause - - def predict_one(self): - self.atl.predict(self.context) - - def visit(self): - if not self.block: - self.compile() - - return self.children + self.block.visit() - - -# The base class for raw ATL statements. -class RawStatement(renpy.object.Object): - - def __init__(self, loc): - super(RawStatement, self).__init__() - self.loc = loc - - # Compiles this RawStatement into a Statement, by using ctx to - # evaluate expressions as necessary. - def compile(self, ctx): #@ReservedAssignment - raise Exception("Compile not implemented.") - - # Predicts the images used by this statement. - def predict(self, ctx): - return - -# The base class for compiled ATL Statements. -class Statement(renpy.object.Object): - - def __init__(self, loc): - super(Statement, self).__init__() - self.loc = loc - - # trans is the transform we're working on. - # st is the time since this statement started executing. - # state is the state stored by this statement, or None if - # we've just started executing this statement. - # event is an event we're triggering. - # - # "continue", state, pause - Causes this statement to execute - # again, with the given state passed in the second time around. - # - # - # "next", timeleft, pause - Causes the next statement to execute, - # with timeleft being the amount of time left after this statement - # finished. - # - # "event", (name, timeleft), pause - Causes an event to be reported, - # and control to head up to the event handler. - # - # "repeat", (count, timeleft), pause - Causes the repeat behavior - # to occur. - # - # As the Repeat statement can only appear in a block, only Block - # needs to deal with the repeat behavior. - # - # Pause is the amount of time until execute should be called again, - # or None if there's no need to call execute ever again. - def execute(self, trans, st, state, event): - raise Exception("Not implemented.") - - # Return a list of displayable children. - def visit(self): - return [ ] - -# This represents a Raw ATL block. -class RawBlock(RawStatement): - - # Should we use the animation timebase or the showing timebase? - animation = False - - def __init__(self, loc, statements, animation): - - super(RawBlock, self).__init__(loc) - - # A list of RawStatements in this block. - self.statements = statements - - self.animation = animation - - def compile(self, ctx): #@ReservedAssignment - compiling(self.loc) - - statements = [ i.compile(ctx) for i in self.statements ] - - return Block(self.loc, statements) - - def predict(self, ctx): - for i in self.statements: - i.predict(ctx) - - -# A compiled ATL block. -class Block(Statement): - def __init__(self, loc, statements): - - super(Block, self).__init__(loc) - - # A list of statements in the block. - self.statements = statements - - # The start times of various statements. - self.times = [ ] - - for i, s in enumerate(statements): - if isinstance(s, Time): - self.times.append((s.time, i + 1)) - - self.times.sort() - - def execute(self, trans, st, state, event): - - executing(self.loc) - - # Unpack the state. - if state is not None: - index, start, loop_start, repeats, times, child_state = state - else: - index, start, loop_start, repeats, times, child_state = 0, 0, 0, 0, self.times[:], None - - # What we might be returning. - action = "continue" - arg = None - pause = None - - while action == "continue": - - # Target is the time we're willing to execute to. - # Max_pause is how long we'll wait before executing again. - - # If we have times queued up, then use them to inform target - # and time. - if times: - time, tindex = times[0] - target = min(time, st) - max_pause = time - target - - # Otherwise, take the defaults. - else: - target = st - max_pause = 15 - - while True: - - # If we've hit the last statement, it's the end of - # this block. - if index >= len(self.statements): - return "next", target - start, None - - - # Find the statement and try to run it. - stmt = self.statements[index] - action, arg, pause = stmt.execute(trans, target - start, child_state, event) - - # On continue, persist our state. - if action == "continue": - if pause is None: - pause = max_pause - - action, arg, pause = "continue", (index, start, loop_start, repeats, times, arg), min(max_pause, pause) - break - - elif action == "event": - return action, arg, pause - - # On next, advance to the next statement in the block. - elif action == "next": - index += 1 - start = target - arg - child_state = None - - # On repeat, either terminate the block, or go to - # the first statement. - elif action == "repeat": - - count, arg = arg - loop_end = target - arg - duration = loop_end - loop_start - - if duration <= 0: - raise Exception("ATL appears to be in an infinite loop.") - - # Figure how many durations can occur between the - # start of the loop and now. - new_repeats = int((target - loop_start) / duration) - - if count is not None: - if repeats + new_repeats >= count: - new_repeats = count - repeats - loop_start += new_repeats * duration - return "next", target - loop_start, None - - repeats += new_repeats - loop_start = loop_start + new_repeats * duration - start = loop_start - index = 0 - child_state = None - - if times: - time, tindex = times[0] - if time <= target: - times.pop(0) - - index = tindex - start = time - child_state = None - - continue - - return action, arg, pause - - def visit(self): - return [ j for i in self.statements for j in i.visit() ] - -# This can become one of four things: -# -# - A pause. -# - An interpolation (which optionally can also reference other -# blocks, as long as they're not time-dependent, and have the same -# arity as the interpolation). -# - A call to another block. -# - A command to change the image, perhaps with a transition. -# -# We won't decide which it is until runtime, as we need the -# values of the variables here. -class RawMultipurpose(RawStatement): - - warp_function = None - - def __init__(self, loc): - - super(RawMultipurpose, self).__init__(loc) - - self.warper = None - self.duration = None - self.properties = [ ] - self.expressions = [ ] - self.splines = [ ] - self.revolution = None - self.circles = "0" - - def add_warper(self, name, duration, warp_function): - self.warper = name - self.duration = duration - self.warp_function = warp_function - - def add_property(self, name, exprs): - self.properties.append((name, exprs)) - - def add_expression(self, expr, with_clause): - self.expressions.append((expr, with_clause)) - - def add_revolution(self, revolution): - self.revolution = revolution - - def add_circles(self, circles): - self.circles = circles - - def add_spline(self, name, exprs): - self.splines.append((name, exprs)) - - def compile(self, ctx): #@ReservedAssignment - - compiling(self.loc) - - # Figure out what kind of statement we have. If there's no - # interpolator, and no properties, than we have either a - # call, or a child statement. - if (self.warper is None and - self.warp_function is None and - not self.properties and - not self.splines and - len(self.expressions) == 1): - - expr, withexpr = self.expressions[0] - - child = ctx.eval(expr) - if withexpr: - transition = ctx.eval(withexpr) - else: - transition = None - - if isinstance(child, (int, float)): - return Interpolation(self.loc, "pause", child, [ ], None, 0, [ ]) - - if isinstance(child, ATLTransformBase): - child.compile() - return child.block - - else: - return Child(self.loc, child, transition) - - compiling(self.loc) - - # Otherwise, we probably have an interpolation statement. - - if self.warp_function: - warper = ctx.eval(self.warp_function) - else: - warper = self.warper or "pause" - - if warper not in warpers: - raise Exception("ATL Warper %s is unknown at runtime." % warper) - - properties = [ ] - - for name, expr in self.properties: - if name not in PROPERTIES: - raise Exception("ATL Property %s is unknown at runtime." % property) - - value = ctx.eval(expr) - properties.append((name, value)) - - splines = [ ] - - for name, exprs in self.splines: - if name not in PROPERTIES: - raise Exception("ATL Property %s is unknown at runtime." % property) - - values = [ ctx.eval(i) for i in exprs ] - - splines.append((name, values)) - - for expr, _with in self.expressions: - try: - value = ctx.eval(expr) - except: - raise Exception("Could not evaluate expression %r when compiling ATL." % expr) - - if not isinstance(value, ATLTransformBase): - raise Exception("Expression %r is not an ATL transform, and so cannot be included in an ATL interpolation." % expr) - - value.compile() - - if value.properties is None: - raise Exception("ATL transform %r is too complicated to be included in interpolation." % expr) - - - properties.extend(value.properties) - - duration = ctx.eval(self.duration) - circles = ctx.eval(self.circles) - - return Interpolation(self.loc, warper, duration, properties, self.revolution, circles, splines) - - def predict(self, ctx): - - for i, _j in self.expressions: - - try: - i = ctx.eval(i) - except: - continue - - if isinstance(i, ATLTransformBase): - i.atl.predict(ctx) - return - - try: - renpy.easy.predict(i) - except: - continue - -# This lets us have an ATL transform as our child. -class RawContainsExpr(RawStatement): - - def __init__(self, loc, expr): - - super(RawContainsExpr, self).__init__(loc) - - self.expression = expr - - def compile(self, ctx): #@ReservedAssignment - compiling(self.loc) - child = ctx.eval(self.expression) - return Child(self.loc, child, None) - - -# This allows us to have multiple children, inside a Fixed. -class RawChild(RawStatement): - - def __init__(self, loc, child): - - super(RawChild, self).__init__(loc) - - self.children = [ child ] - - def compile(self, ctx): #@ReservedAssignment - box = renpy.display.layout.MultiBox(layout='fixed') - - for i in self.children: - box.add(renpy.display.motion.ATLTransform(i, context=ctx.context)) - - return Child(self.loc, box, None) - - -# This changes the child of this statement, optionally with a transition. -class Child(Statement): - - def __init__(self, loc, child, transition): - - super(Child, self).__init__(loc) - - self.child = renpy.easy.displayable(child) - self.transition = transition - - def execute(self, trans, st, state, event): - - executing(self.loc) - - old_child = trans.raw_child - - if (old_child is not None) and (old_child is not renpy.display.motion.null) and (self.transition is not None): - child = self.transition(old_widget=old_child, - new_widget=self.child) - else: - child = self.child - - trans.set_child(child) - trans.raw_child = self.child - - return "next", st, None - - def visit(self): - return [ self.child ] - - -# This causes interpolation to occur. -class Interpolation(Statement): - - def __init__(self, loc, warper, duration, properties, revolution, circles, splines): - - super(Interpolation, self).__init__(loc) - - self.warper = warper - self.duration = duration - self.properties = properties - self.splines = splines - - # The direction we revolve in: cw, ccw, or None. - self.revolution = revolution - - # The number of complete circles we make. - self.circles = circles - - def execute(self, trans, st, state, event): - - executing(self.loc) - - warper = warpers.get(self.warper, self.warper) - - if self.duration: - complete = min(1.0, st / self.duration) - else: - complete = 1.0 - - complete = warper(complete) - - if state is None: - - # Create a new transform state, and apply the property - # changes to it. - newts = renpy.display.motion.TransformState() - newts.take_state(trans.state) - - for k, v in self.properties: - setattr(newts, k, v) - - # Now, the things we change linearly are in the difference - # between the new and old states. - linear = trans.state.diff(newts) - - revolution = None - splines = [ ] - - # Clockwise revolution. - if self.revolution is not None: - - # Remove various irrelevant motions. - for i in [ 'xpos', 'ypos', - 'xanchor', 'yanchor', - 'xaround', 'yaround', - 'xanchoraround', 'yanchoraround', - ]: - - linear.pop(i, None) - - if newts.xaround is not None: - - # Ensure we rotate around the new point. - trans.state.xaround = newts.xaround - trans.state.yaround = newts.yaround - trans.state.xanchoraround = newts.xanchoraround - trans.state.yanchoraround = newts.yanchoraround - - # Get the start and end angles and radii. - startangle = trans.state.angle - endangle = newts.angle - startradius = trans.state.radius - endradius = newts.radius - - # Make sure the revolution is in the appropriate direction, - # and contains an appropriate number of circles. - - if self.revolution == "clockwise": - if endangle < startangle: - startangle -= 360 - - startangle -= self.circles * 360 - - elif self.revolution == "counterclockwise": - if endangle > startangle: - startangle += 360 - - startangle += self.circles * 360 - - # Store the revolution. - revolution = (startangle, endangle, startradius, endradius) - - # Figure out the splines. - for name, values in self.splines: - splines.append((name, [ getattr(trans.state, name) ] + values)) - - state = (linear, revolution, splines) - - # Ensure that we set things, even if they don't actually - # change from the old state. - for k, v in self.properties: - if k not in linear: - setattr(trans.state, k, v) - - else: - linear, revolution, splines = state - - # Linearly interpolate between the things in linear. - for k, (old, new) in linear.items(): - value = interpolate(complete, old, new, PROPERTIES[k]) - - setattr(trans.state, k, value) - - # Handle the revolution. - if revolution is not None: - startangle, endangle, startradius, endradius = revolution - trans.state.angle = interpolate(complete, startangle, endangle, float) - trans.state.radius = interpolate(complete, startradius, endradius, float) - - - # Handle any splines we might have. - for name, values in splines: - value = interpolate_spline(complete, values) - setattr(trans.state, name, value) - - if st >= self.duration: - return "next", st - self.duration, None - else: - if not self.properties and not self.revolution and not self.splines: - return "continue", state, self.duration - st - else: - return "continue", state, 0 - - -# Implementation of the repeat statement. -class RawRepeat(RawStatement): - - def __init__(self, loc, repeats): - - super(RawRepeat, self).__init__(loc) - - self.repeats = repeats - - def compile(self, ctx): #@ReservedAssignment - - compiling(self.loc) - - repeats = self.repeats - - if repeats is not None: - repeats = ctx.eval(repeats) - - return Repeat(self.loc, repeats) - -class Repeat(Statement): - - def __init__(self, loc, repeats): - - super(Repeat, self).__init__(loc) - - self.repeats = repeats - - def execute(self, trans, st, state, event): - return "repeat", (self.repeats, st), 0 - - -# Parallel statement. - -class RawParallel(RawStatement): - - def __init__(self, loc, block): - - super(RawParallel, self).__init__(loc) - self.blocks = [ block ] - - def compile(self, ctx): #@ReservedAssignment - return Parallel(self.loc, [i.compile(ctx) for i in self.blocks]) - - def predict(self, ctx): - for i in self.blocks: - i.predict(ctx) - - -class Parallel(Statement): - - def __init__(self, loc, blocks): - super(Parallel, self).__init__(loc) - self.blocks = blocks - - def execute(self, trans, st, state, event): - - executing(self.loc) - - if state is None: - state = [ (i, None) for i in self.blocks ] - - # The amount of time left after finishing this block. - left = [ ] - - # The duration of the pause. - pauses = [ ] - - # The new state structure. - newstate = [ ] - - for i, istate in state: - - action, arg, pause = i.execute(trans, st, istate, event) - - if pause is not None: - pauses.append(pause) - - if action == "continue": - newstate.append((i, arg)) - elif action == "next": - left.append(arg) - elif action == "event": - return action, arg, pause - - if newstate: - return "continue", newstate, min(pauses) - else: - return "next", min(left), None - - def visit(self): - return [ j for i in self.blocks for j in i.visit() ] - - -# The choice statement. - -class RawChoice(RawStatement): - - def __init__(self, loc, chance, block): - super(RawChoice, self).__init__(loc) - - self.choices = [ (chance, block) ] - - def compile(self, ctx): #@ReservedAssignment - compiling(self.loc) - return Choice(self.loc, [ (ctx.eval(chance), block.compile(ctx)) for chance, block in self.choices]) - - def predict(self, ctx): - for _i, j in self.choices: - j.predict(ctx) - -class Choice(Statement): - - def __init__(self, loc, choices): - - super(Choice, self).__init__(loc) - - self.choices = choices - - def execute(self, trans, st, state, event): - - executing(self.loc) - - if state is None: - - total = 0 - for chance, choice in self.choices: - total += chance - - n = random.uniform(0, total) - - for chance, choice in self.choices: - if n < chance: - break - n -= chance - - cstate = None - - else: - choice, cstate = state - - action, arg, pause = choice.execute(trans, st, cstate, event) - - if action == "continue": - return "continue", (choice, arg), pause - else: - return action, arg, None - - def visit(self): - return [ j for i in self.choices for j in i[1].visit() ] - - -# The Time statement. - -class RawTime(RawStatement): - - def __init__(self, loc, time): - - super(RawTime, self).__init__(loc) - self.time = time - - def compile(self, ctx): #@ReservedAssignment - compiling(self.loc) - return Time(self.loc, ctx.eval(self.time)) - -class Time(Statement): - - def __init__(self, loc, time): - super(Time, self).__init__(loc) - - self.time = time - - def execute(self, trans, st, state, event): - return "continue", None, None - - -# The On statement. - -class RawOn(RawStatement): - - def __init__(self, loc, name, block): - super(RawOn, self).__init__(loc) - - self.handlers = { name : block } - - def compile(self, ctx): #@ReservedAssignment - - compiling(self.loc) - - handlers = { } - - for k, v in self.handlers.items(): - handlers[k] = v.compile(ctx) - - return On(self.loc, handlers) - - def predict(self, ctx): - for i in self.handlers.values(): - i.predict(ctx) - -class On(Statement): - - def __init__(self, loc, handlers): - super(On, self).__init__(loc) - - self.handlers = handlers - - def execute(self, trans, st, state, event): - - executing(self.loc) - - # If it's our first time through, start in the start state. - if state is None: - name, start, cstate = ("start", st, None) - else: - name, start, cstate = state - - # If we have an external event, and we have a handler for it, - # handle it. - if event in self.handlers: - - # Do not allow people to abort the hide handler with another - # event. - if name != "hide": - name = event - start = st - cstate = None - - - while True: - - # If we don't have a handler, return until we change event. - if name not in self.handlers: - return "continue", (name, start, cstate), None - - action, arg, pause = self.handlers[name].execute(trans, st - start, cstate, event) - - # If we get a continue, save our state. - if action == "continue": - - # If it comes from a hide block, indicate that. - if name == "hide" or name == "replaced": - trans.hide_response = False - trans.replaced_response = False - - return "continue", (name, start, arg), pause - - # If we get a next, then try going to the default - # event, unless we're already in default, in which case we - # go to None. - elif action == "next": - if name == "default" or name == "hide" or name == "replaced": - name = None - else: - name = "default" - - start = st - arg - cstate = None - - continue - - # If we get an event, then either handle it if we can, or - # pass it up the stack if we can't. - elif action == "event": - - name, arg = arg - - if name in self.handlers: - start = max(st - arg, st - 30) - cstate = None - continue - - return "event", (name, arg), None - - def visit(self): - return [ j for i in self.handlers.values() for j in i.visit() ] - - -# Event statement. - -class RawEvent(RawStatement): - - def __init__(self, loc, name): - super(RawEvent, self).__init__(loc) - - self.name = name - - def compile(self, ctx): #@ReservedAssignment - return Event(self.loc, self.name) - - -class Event(Statement): - - def __init__(self, loc, name): - super(Event, self).__init__(loc) - - self.name = name - - def execute(self, trans, st, state, event): - return "event", (self.name, st), None - - -class RawFunction(RawStatement): - - def __init__(self, loc, expr): - super(RawFunction, self).__init__(loc) - - self.expr = expr - - def compile(self, ctx): #@ReservedAssignment - compiling(self.loc) - return Function(self.loc, ctx.eval(self.expr)) - - -class Function(Statement): - - def __init__(self, loc, function): - super(Function, self).__init__(loc) - - self.function = function - - def execute(self, trans, st, state, event): - fr = self.function(trans, st, trans.at) - - if fr is not None: - return "continue", None, fr - else: - return "next", 0, None - - -# This parses an ATL block. -def parse_atl(l): - - l.advance() - block_loc = l.get_location() - - statements = [ ] - - animation = False - - while not l.eob: - - loc = l.get_location() - - if l.keyword('repeat'): - - repeats = l.simple_expression() - statements.append(RawRepeat(loc, repeats)) - - elif l.keyword('block'): - l.require(':') - l.expect_eol() - l.expect_block('block') - - block = parse_atl(l.subblock_lexer()) - statements.append(block) - - elif l.keyword('contains'): - - expr = l.simple_expression() - - if expr: - - l.expect_noblock('contains expression') - statements.append(RawContainsExpr(loc, expr)) - - else: - - l.require(':') - l.expect_eol() - l.expect_block('contains') - - block = parse_atl(l.subblock_lexer()) - statements.append(RawChild(loc, block)) - - elif l.keyword('parallel'): - l.require(':') - l.expect_eol() - l.expect_block('parallel') - - block = parse_atl(l.subblock_lexer()) - statements.append(RawParallel(loc, block)) - - elif l.keyword('choice'): - - chance = l.simple_expression() - if not chance: - chance = "1.0" - - l.require(':') - l.expect_eol() - l.expect_block('choice') - - block = parse_atl(l.subblock_lexer()) - statements.append(RawChoice(loc, chance, block)) - - elif l.keyword('on'): - - name = l.require(l.word) - - l.require(':') - l.expect_eol() - l.expect_block('on') - - block = parse_atl(l.subblock_lexer()) - statements.append(RawOn(loc, name, block)) - - elif l.keyword('time'): - time = l.require(l.simple_expression) - l.expect_noblock('time') - - statements.append(RawTime(loc, time)) - - elif l.keyword('function'): - expr = l.require(l.simple_expression) - l.expect_noblock('function') - - statements.append(RawFunction(loc, expr)) - - elif l.keyword('event'): - name = l.require(l.word) - l.expect_noblock('event') - - statements.append(RawEvent(loc, name)) - - elif l.keyword('pass'): - l.expect_noblock('pass') - statements.append(None) - - elif l.keyword('animation'): - l.expect_noblock('animation') - animation = True - - else: - - # If we can't assign it it a statement more specifically, - # we try to parse it into a RawMultipurpose. That will - # then be turned into another statement, as appropriate. - - # The RawMultipurpose we add things to. - rm = renpy.atl.RawMultipurpose(loc) - - # Is the last clause an expression? - last_expression = False - - # Is this clause an expression? - this_expression = False - - # First, look for a warper. - cp = l.checkpoint() - warper = l.name() - - - if warper in warpers: - duration = l.require(l.simple_expression) - warp_function = None - - elif warper == "warp": - - warper = None - warp_function = l.require(l.simple_expression) - duration = l.require(l.simple_expression) - - else: - l.revert(cp) - - warper = None - warp_function = None - duration = "0" - - rm.add_warper(warper, duration, warp_function) - - # Now, look for properties and simple_expressions. - while True: - - # Update expression status. - last_expression = this_expression - this_expression = False - - if l.keyword('pass'): - continue - - # Parse revolution keywords. - if l.keyword('clockwise'): - rm.add_revolution('clockwise') - continue - - if l.keyword('counterclockwise'): - rm.add_revolution('counterclockwise') - continue - - if l.keyword('circles'): - expr = l.require(l.simple_expression) - rm.add_circles(expr) - - # Try to parse a property. - cp = l.checkpoint() - - prop = l.name() - - if prop in PROPERTIES: - - expr = l.require(l.simple_expression) - - # We either have a property or a spline. It's the - # presence of knots that determine which one it is. - - knots = [ ] - - while l.keyword('knot'): - knots.append(l.require(l.simple_expression)) - - if knots: - knots.append(expr) - rm.add_spline(prop, knots) - else: - rm.add_property(prop, expr) - - continue - - # Otherwise, try to parse it as a simple expressoon, - # with an optional with clause. - - l.revert(cp) - - expr = l.simple_expression() - - if not expr: - break - - if last_expression: - l.error('ATL statement contains two expressions in a row; is one of them a misspelled property? If not, separate them with pass.') - - this_expression = True - - if l.keyword("with"): - with_expr = l.require(l.simple_expression) - else: - with_expr = None - - rm.add_expression(expr, with_expr) - - l.expect_noblock('ATL') - - statements.append(rm) - - - if l.eol(): - l.advance() - continue - - l.require(",", "comma or end of line") - - - # Merge together statements that need to be merged together. - - merged = [ ] - old = None - - for new in statements: - - if isinstance(old, RawParallel) and isinstance(new, RawParallel): - old.blocks.extend(new.blocks) - continue - - elif isinstance(old, RawChoice) and isinstance(new, RawChoice): - old.choices.extend(new.choices) - continue - - elif isinstance(old, RawChild) and isinstance(new, RawChild): - old.children.extend(new.children) - continue - - elif isinstance(old, RawOn) and isinstance(new, RawOn): - old.handlers.update(new.handlers) - continue - - # None is a pause statement, which gets skipped, but also - # prevents things from combining. - elif new is None: - old = new - continue - - merged.append(new) - old = new - - return RawBlock(block_loc, merged, animation) diff --git a/unrpyc/renpy/display/__init__.py b/unrpyc/renpy/display/__init__.py deleted file mode 100644 index 3420500..0000000 --- a/unrpyc/renpy/display/__init__.py +++ /dev/null @@ -1,31 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# The draw object through which all drawing is routed. This object -# contains all of the distinction between the software and GL -# renderers. -draw = None - -# The interface object. -interface = None - -# Should we disable imagedissolve-type transitions? -less_imagedissolve = False diff --git a/unrpyc/renpy/display/accelerator.pyx b/unrpyc/renpy/display/accelerator.pyx deleted file mode 100644 index 8c4172c..0000000 --- a/unrpyc/renpy/display/accelerator.pyx +++ /dev/null @@ -1,296 +0,0 @@ -#cython: profile=False -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -import renpy -import math -from renpy.display.render cimport Render, Matrix2D, render - - -################################################################################ -# Surface copying -################################################################################ - -from pygame cimport * - -def nogil_copy(src, dest): - """ - Does a gil-less blit of src to dest, with minimal locking. - """ - - cdef SDL_Surface *src_surf - cdef SDL_Surface *dst_surf - - src_surf = PySurface_AsSurface(src) - dest_surf = PySurface_AsSurface(dest) - - old_alpha = src_surf.flags & SDL_SRCALPHA - - if old_alpha: - SDL_SetAlpha(src_surf, 0, 255) - - with nogil: - SDL_BlitSurface(src_surf, NULL, dest_surf, NULL) - - if old_alpha: - SDL_SetAlpha(src_surf, SDL_SRCALPHA, 255) - - - -################################################################################ -# Transform render function -################################################################################ - -cdef Matrix2D IDENTITY -IDENTITY = renpy.display.render.IDENTITY - -# This file contains implementations of methods of classes that -# are found in other files, for performance reasons. - -def transform_render(self, widtho, heighto, st, at): - - cdef double rxdx, rxdy, rydx, rydy - cdef double cosa, sina - cdef double xo, x1, x2, x3, px - cdef double yo, y1, y2, y3, py - cdef float zoom, xzoom, yzoom - cdef double cw, ch, nw, nh - cdef Render rv, cr - cdef double angle - cdef double alpha - cdef double width = widtho - cdef double height = heighto - - # Should we perform clipping? - clipping = False - - # Prevent time from ticking backwards, as can happen if we replace a - # transform but keep its state. - if st + self.st_offset <= self.st: - self.st_offset = self.st - st - if at + self.at_offset <= self.at: - self.at_offset = self.at - at - - self.st = st = st + self.st_offset - self.at = at = at + self.at_offset - - # Update the state. - self.update_state() - - # Render the child. - child = self.child - - if child is None: - raise Exception("Transform does not have a child.") - - state = self.state - - if state.size: - widtho, heighto = state.size - - cr = render(child, widtho, heighto, st - self.child_st_base, at) - - width = cr.width - height = cr.height - - self.child_size = width, height - - # The reverse matrix. - rxdx = 1 - rxdy = 0 - rydx = 0 - rydy = 1 - - xo = 0 - yo = 0 - - # Cropping. - crop = state.crop - if (state.corner1 is not None) and (crop is None) and (state.corner2 is not None): - x1, y1 = state.corner1 - x2, y2 = state.corner2 - - if x1 > x2: - x3 = x1 - x1 = x2 - x2 = x3 - if y1 > y2: - y3 = y1 - y1 = y2 - y2 = y3 - - crop = (x1, y1, x2-x1, y2-y1) - - if crop is not None: - - negative_xo, negative_yo, width, height = crop - - if state.rotate: - clipcr = Render(width, height) - clipcr.subpixel_blit(cr, (-negative_xo, -negative_yo)) - clipcr.clipping = True - cr = clipcr - else: - xo = -negative_xo - yo = -negative_yo - clipping = True - - # Size. - size = state.size - if (size is not None) and (size != (width, height)): - nw, nh = size - xzoom = 1.0 * nw / width - yzoom = 1.0 * nh / height - - rxdx = xzoom - rydy = yzoom - - xo *= xzoom - yo *= yzoom - - width, height = size - - # zoom - zoom = state.zoom - xzoom = zoom * state.xzoom - yzoom = zoom * state.yzoom - - if xzoom != 1: - - rxdx *= xzoom - - if xzoom < 0: - width *= -xzoom - else: - width *= xzoom - - xo *= xzoom - # origin corrections for flipping - if xzoom < 0: - xo += width - - if yzoom != 1: - - rydy *= yzoom - - if yzoom < 0: - height *= -yzoom - else: - height *= yzoom - - yo *= yzoom - # origin corrections for flipping - if yzoom < 0: - yo += height - - # Rotation. - rotate = state.rotate - if rotate is not None: - - cw = width - ch = height - - angle = rotate * 3.1415926535897931 / 180 - - cosa = math.cos(angle) - sina = math.sin(angle) - - # reverse = Matrix2D(xdx, xdy, ydx, ydy) * reverse - - # We know that at this point, rxdy and rydx are both 0, so - # we can simplify these formulae a bit. - rxdy = rydy * -sina - rydx = rxdx * sina - rxdx *= cosa - rydy *= cosa - - # first corner point (changes with flipping) - px = cw / 2.0 - if xzoom < 0: - px = -px - py = ch / 2.0 - if yzoom < 0: - py = -py - - if state.rotate_pad: - width = height = math.hypot(cw, ch) - - xo = -px * cosa + py * sina - yo = -px * sina - py * cosa - - else: - xo = -px * cosa + py * sina - yo = -px * sina - py * cosa - - x2 = -px * cosa - py * sina - y2 = -px * sina + py * cosa - - x3 = px * cosa - py * sina - y3 = px * sina + py * cosa - - x4 = px * cosa + py * sina - y4 = px * sina - py * cosa - - width = max(xo, x2, x3, x4) - min(xo, x2, x3, x4) - height = max(yo, y2, y3, y4) - min(yo, y2, y3, y4) - - xo += width / 2.0 - yo += height / 2.0 - - alpha = state.alpha - - rv = Render(width, height) - - # Default case - no transformation matrix. - if rxdx == 1 and rxdy == 0 and rydx == 0 and rydy == 1: - self.forward = IDENTITY - self.reverse = IDENTITY - - else: - - self.reverse = rv.reverse = Matrix2D(rxdx, rxdy, rydx, rydy) - - inv_det = rxdx * rydy - rxdy * rydx - - if not inv_det: - self.forward = rv.forward = Matrix2D(0, 0, 0, 0) - else: - self.forward = rv.forward = Matrix2D( - rydy / inv_det, - -rxdy / inv_det, - -rydx / inv_det, - rxdx / inv_det) - - rv.alpha = alpha - rv.clipping = clipping - - pos = (xo, yo) - - if state.subpixel: - rv.subpixel_blit(cr, pos) - else: - rv.blit(cr, pos) - - self.offsets = [ pos ] - self.render_size = (width, height) - - return rv - diff --git a/unrpyc/renpy/display/anim.py b/unrpyc/renpy/display/anim.py deleted file mode 100644 index de1398a..0000000 --- a/unrpyc/renpy/display/anim.py +++ /dev/null @@ -1,634 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This file contains support for state-machine controlled animations. - -import renpy.display -import random - -class State(object): - """ - This creates a state that can be used in a SMAnimation. - """ - - - def __init__(self, name, image, *atlist, **properties): - """ - @param name: A string giving the name of this state. - - @param image: The displayable that is shown to the user while - we are in (entering) this state. For convenience, this can - also be a string or tuple, which is interpreted with Image. - - image should be None when this State is used with motion, - to indicate that the image will be replaced with the child of - the motion. - - @param atlist: A list of functions to call on the image. (In - general, if something can be used in an at clause, it can be - used here as well.) - - If any keyword arguments are given, they are used to construct a - Position object, that modifies the position of the image. - """ - - if image and not isinstance(image, renpy.display.core.Displayable): - image = renpy.easy.displayable(image) - - self.name = name - self.image = image - self.atlist = atlist - self.properties = properties - - - def add(self, sma): - sma.states[self.name] = self - - def get_image(self): - rv = self.image - - for i in self.atlist: - rv = i(rv) - - if self.properties: - rv = renpy.display.layout.Position(rv, **self.properties) - - return rv - - def motion_copy(self, child): - - if self.image is not None: - child = self.image - - return State(self.name, child, *self.atlist) - - -class Edge(object): - """ - This creates an edge that can be used with a SMAnimation. - """ - - def __init__(self, old, delay, new, trans=None, prob=1): - """ - @param old: The name (a string) of the state that this transition is from. - - @param delay: The number of seconds that this transition takes. - - @param new: The name (a string) of the state that this transition is to. - - @param trans: The transition that will be used to show the - image found in the new state. If None, the image is show - immediately. - - When used with an SMMotion, the transition should probably be - move. - - @param prob: The number of times this edge is added. This can - be used to make a transition more probable then others. For - example, if one transition out of a state has prob=5, and the - other has prob=1, then the one with prob=5 will execute 5/6 of - the time, while the one with prob=1 will only occur 1/6 of the - time. (Don't make this too large, as memory use is proportional to - this value.) - """ - - self.old = old - self.delay = delay - self.new = new - self.trans = trans - self.prob = prob - - def add(self, sma): - for _i in range(0, self.prob): - sma.edges.setdefault(self.old, []).append(self) - - -class SMAnimation(renpy.display.core.Displayable): - """ - This creates a state-machine animation. Such an animation is - created by randomly traversing the edges between states in a - defined state machine. Each state corresponds to an image shown to - the user, with the edges corresponding to the amount of time an - image is shown, and the transition it is shown with. - - Images are shown, perhaps with a transition, when we are - transitioning into a state containing that image. - """ - - def __init__(self, initial, *args, **properties): - """ - @param initial: The name (a string) of the initial state we - start in. - - @param showold: If the keyword parameter showold is True, then - the old image is shown instead of the new image when in an - edge. - - @param anim_timebase: If True, we use the animation - timebase. If False, we use the displayable timebase. - - This accepts as additional arguments the anim.State and - anim.Edge objects that are used to make up this state - machine. - """ - - if 'delay' in properties: - self.delay = properties['delay'] - del properties['delay'] - else: - self.delay = None - - if 'showold' in properties: - self.showold = properties['showold'] - del properties['showold'] - else: - self.showold = False - - if 'anim_timebase' in properties: - self.anim_timebase = properties['anim_timebase'] - del properties['anim_timebase'] - else: - self.anim_timebase = True - - super(SMAnimation, self).__init__(**properties) - - self.properties = properties - - # The initial state. - self.initial = initial - - # A map from state name to State object. - self.states = { } - - # A map from state name to list of Edge objects. - self.edges = { } - - for i in args: - i.add(self) - - # The time at which the current edge started. If None, will be - # set to st by render. - self.edge_start = None - - # A cache for what the current edge looks like when rendered. - self.edge_cache = None - - # The current edge. - self.edge = None - - # The state we're in. - self.state = None - - def visit(self): - return [ i.image for i in self.states.values() ] - - def pick_edge(self, state): - """ - This randomly picks an edge out of the given state, if - one exists. It updates self.edge if a transition has - been selected, or returns None if none can be found. It also - updates self.image to be the new image on the selected edge. - """ - - if state not in self.edges: - self.edge = None - return - - edges = self.edges[state] - self.edge = random.choice(edges) - self.state = self.edge.new - - def update_cache(self): - """ - Places the correct Displayable into the edge cache, based on - what is contained in the given edge. This takes into account - the old and new states, and any transition that is present. - """ - - - if self.edge.trans: - im = self.edge.trans(old_widget=self.states[self.edge.old].get_image(), - new_widget=self.states[self.edge.new].get_image()) - elif self.showold: - im = self.states[self.edge.old].get_image() - else: - im = self.states[self.edge.new].get_image() - - self.edge_cache = im - - def get_placement(self): - - if self.edge_cache: - return self.edge_cache.get_placement() - - if self.state: - return self.states[self.state].get_image().get_placement() - - return super(SMAnimation, self).get_placement() - - def render(self, width, height, st, at): - - if self.anim_timebase: - t = at - else: - t = st - - if self.edge_start is None or t < self.edge_start: - self.edge_start = t - self.edge_cache = None - self.pick_edge(self.initial) - - while self.edge and t > self.edge_start + self.edge.delay: - self.edge_start += self.edge.delay - self.edge_cache = None - self.pick_edge(self.edge.new) - - # If edge is None, then we have a permanent, static picture. Deal - # with that. - - if not self.edge: - im = renpy.display.render.render(self.states[self.state].get_image(), - width, height, - st - self.edge_start, at) - - - # Otherwise, we have another edge. - - else: - if not self.edge_cache: - self.update_cache() - - im = renpy.display.render.render(self.edge_cache, width, height, t - self.edge_start, at) - - if not renpy.game.less_updates: - renpy.display.render.redraw(self.edge_cache, self.edge.delay - (t - self.edge_start)) - - - iw, ih = im.get_size() - - rv = renpy.display.render.Render(iw, ih) - rv.blit(im, (0, 0)) - - return rv - - def __call__(self, child=None, new_widget=None, old_widget=None): - """ - Used when this SMAnimation is used as a SMMotion. This creates - a duplicate of the animation, with all states containing None - as the image having that None replaced with the image that is provided here. - """ - - if child is None: - child = new_widget - - args = [ ] - - for state in self.states.values(): - args.append(state.motion_copy(child)) - - for edges in self.edges.values(): - args.extend(edges) - - return SMAnimation(self.initial, delay=self.delay, *args, **self.properties) - - -# class Animation(renpy.display.core.Displayable): -# """ -# A Displayable that draws an animation, which is a series of images -# that are displayed with time delays between them. -# """ - -# def __init__(self, *args, **properties): -# """ -# Odd (first, third, fifth, etc.) arguments to Animation are -# interpreted as image filenames, while even arguments are the -# time to delay between each image. If the number of arguments -# is odd, the animation will stop with the last image (well, -# actually delay for a year before looping). Otherwise, the -# animation will restart after the final delay time. - -# @param anim_timebase: If True, the default, use the animation -# timebase. Otherwise, use the displayable timebase. -# """ - -# properties.setdefault('style', 'animation') -# self.anim_timebase = properties.pop('anim_timebase', True) - -# super(Animation, self).__init__(**properties) - -# self.images = [ ] -# self.delays = [ ] - -# for i, arg in enumerate(args): - -# if i % 2 == 0: -# self.images.append(renpy.easy.displayable(arg)) -# else: -# self.delays.append(arg) - -# if len(self.images) > len(self.delays): -# self.delays.append(365.25 * 86400.0) # One year, give or take. - -# def render(self, width, height, st, at): - -# if self.anim_timebase: -# t = at % sum(self.delays) -# else: -# t = st % sum(self.delays) - -# for image, delay in zip(self.images, self.delays): -# if t < delay: -# renpy.display.render.redraw(self, delay - t) - -# im = renpy.display.render.render(image, width, height, t, at) -# width, height = im.get_size() -# rv = renpy.display.render.Render(width, height) -# rv.blit(im, (0, 0)) - -# return rv - -# else: -# t = t - delay - -# def visit(self): -# return self.images - -def Animation(*args, **kwargs): - newargs = [ ] - - for i, a in enumerate(args): - newargs.append(a) - if i % 2 == 1: - newargs.append(None) - - return TransitionAnimation(*newargs, **kwargs) - - -class TransitionAnimation(renpy.display.core.Displayable): - """ - A displayable that draws an animation with each frame separated - by a transition. - """ - - def __init__(self, *args, **properties): - """ - This takes arguments such that the 1st, 4th, 7th, ... - arguments are displayables, the 2nd, 5th, 8th, ... on arguments - are times, and the 3rd, 6th, 9th, ... are transitions. - - This displays the first displayable for the given time, then - transitions to the second displayable using the given - transition, and shows it for the given time (the time of the - transition is taken out of the time the frame is shown), and - so on. - - The last argument may be a displayable (in which case that - displayable is used to transition back to the first frame), or - a displayable (which is shown forever). - - There is one keyword argument, apart from the style properties: - - @param anim_timebase: If True, the default, use the animation - timebase. Otherwise, use the displayable timebase. - """ - - properties.setdefault('style', 'animation') - self.anim_timebase = properties.pop('anim_timebase', True) - - super(TransitionAnimation, self).__init__(**properties) - - images = [ ] - delays = [ ] - transitions = [ ] - - for i, arg in enumerate(args): - - if i % 3 == 0: - images.append(renpy.easy.displayable(arg)) - elif i % 3 == 1: - delays.append(arg) - else: - transitions.append(arg) - - if len(images) > len(delays): - delays.append(365.25 * 86400.0) # One year, give or take. - if len(images) > len(transitions): - transitions.append(None) - - self.images = images - self.prev_images = [ images[-1] ] + images[:-1] - self.delays = delays - self.transitions = [ transitions[-1] ] + transitions[:-1] - - - def render(self, width, height, st, at): - - if self.anim_timebase: - orig_t = at - else: - orig_t = st - - t = orig_t % sum(self.delays) - - for image, prev, delay, trans in zip(self.images, self.prev_images, self.delays, self.transitions): - if t < delay: - if not renpy.game.less_updates: - renpy.display.render.redraw(self, delay - t) - - if trans and orig_t >= self.delays[0]: - image = trans(old_widget=prev, new_widget=image) - - im = renpy.display.render.render(image, width, height, t, at) - width, height = im.get_size() - rv = renpy.display.render.Render(width, height) - rv.blit(im, (0, 0)) - - return rv - - else: - t = t - delay - - def visit(self): - return self.images - -class Blink(renpy.display.core.Displayable): - """ - """ - - def __init__(self, image, on=0.5, off=0.5, rise=0.5, set=0.5, #@ReservedAssignment - high=1.0, low=0.0, offset=0.0, anim_timebase=False, **properties): - - """ - This takes as an argument an image or widget, and blinks that image - by varying its alpha. The sequence of phases is - on - set - off - rise - on - ... All times are given in seconds, all - alphas are fractions between 0 and 1. - - @param image: The image or widget that will be blinked. - - @param on: The amount of time the widget spends on, at high alpha. - - @param off: The amount of time the widget spends off, at low alpha. - - @param rise: The amount time the widget takes to ramp from low to high alpha. - - @param set: The amount of time the widget takes to ram from high to low. - - @param high: The high alpha. - - @param low: The low alpha. - - @param offset: A time offset, in seconds. Use this to have a - blink that does not start at the start of the on phase. - - @param anim_timebase: If True, use the animation timebase, if false, the displayable timebase. - """ - - super(Blink, self).__init__(**properties) - - self.image = renpy.easy.displayable(image) - self.on = on - self.off = off - self.rise = rise - self.set = set - self.high = high - self.low = low - self.offset = offset - self.anim_timebase = anim_timebase - - self.cycle = on + set + off + rise - - - def visit(self): - return [ self.image ] - - def render(self, height, width, st, at): - - if self.anim_timebase: - t = at - else: - t = st - - time = (self.offset + t) % self.cycle - alpha = self.high - - if 0 <= time < self.on: - delay = self.on - time - alpha = self.high - - time -= self.on - - if 0 <= time < self.set: - delay = 0 - frac = time / self.set - alpha = self.low * frac + self.high * (1.0 - frac) - - time -= self.set - - if 0 <= time < self.off: - delay = self.off - time - alpha = self.low - - time -= self.off - - if 0 <= time < self.rise: - delay = 0 - frac = time / self.rise - alpha = self.high * frac + self.low * (1.0 - frac) - - - rend = renpy.display.render.render(self.image, height, width, st, at) - w, h = rend.get_size() - rv = renpy.display.render.Render(w, h) - - rv.blit(rend, (0, 0)) - rv.alpha = alpha - - if not renpy.game.less_updates: - renpy.display.render.redraw(self, delay) - - return rv - - - -def Filmstrip(image, framesize, gridsize, delay, frames=None, loop=True, **properties): - """ - This creates an animation from a single image. This image - must consist of a grid of frames, with the number of columns and - rows in the grid being taken from gridsize, and the size of each - frame in the grid being taken from framesize. This takes frames - and sticks them into an Animation, with the given delay between - each frame. The frames are taken by going from left-to-right - across the first row, left-to-right across the second row, and - so on until all frames are consumed, or a specified number of - frames are taken. - - @param image: The image that the frames must be taken from. - - @param framesize: A (width, height) tuple giving the size of - each of the frames in the animation. - - @param gridsize: A (columns, rows) tuple giving the number of - columns and rows in the grid. - - @param delay: The delay, in seconds, between frames. - - @param frames: The number of frames in this animation. If None, - then this defaults to colums * rows frames, that is, taking - every frame in the grid. - - @param loop: If True, loop at the end of the animation. If False, - this performs the animation once, and then stops. - - Other keyword arguments are as for anim.SMAnimation. - """ - - width, height = framesize - cols, rows = gridsize - - if frames is None: - frames = cols * rows - - i = 0 - - # Arguments to Animation - args = [ ] - - for r in range(0, rows): - for c in range(0, cols): - - x = c * width - y = r * height - - args.append(renpy.display.im.Crop(image, x, y, width, height)) - args.append(delay) - - i += 1 - if i == frames: - break - - if i == frames: - break - - if not loop: - args.pop() - - return Animation(*args, **properties) diff --git a/unrpyc/renpy/display/behavior.py b/unrpyc/renpy/display/behavior.py deleted file mode 100644 index 02eccf2..0000000 --- a/unrpyc/renpy/display/behavior.py +++ /dev/null @@ -1,1531 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This contains various Displayables that handle events. - - -import renpy.display -import renpy.audio - -from renpy.display.render import render, Render - -import pygame - -def compile_event(key, keydown): - """ - Compiles a keymap entry into a python expression. - - keydown determines if we are dealing with keys going down (press), - or keys going up (release). - """ - - # Lists or tuples get turned into or expressions. - if isinstance(key, (list, tuple)): - if not key: - return "(False)" - - return "(" + " or ".join([compile_event(i, keydown) for i in key]) + ")" - - # If it's in config.keymap, compile what's in config.keymap. - if key in renpy.config.keymap: - return compile_event(renpy.config.keymap[key], keydown) - - if key is None: - return "(False)" - - part = key.split("_") - - # Deal with the mouse. - if part[0] == "mousedown": - if keydown: - return "(ev.type == %d and ev.button == %d)" % (pygame.MOUSEBUTTONDOWN, int(part[1])) - else: - return "(False)" - - if part[0] == "mouseup": - if keydown: - return "(ev.type == %d and ev.button == %d)" % (pygame.MOUSEBUTTONUP, int(part[1])) - else: - return "(False)" - - # Deal with the Joystick. - if part[0] == "joy": - if keydown: - return "(ev.type == %d and ev.press and ev.press == renpy.game.preferences.joymap.get(%r, None))" % (renpy.display.core.JOYEVENT, key) - else: - return "(ev.type == %d and ev.release and ev.release == renpy.game.preferences.joymap.get(%r, None))" % (renpy.display.core.JOYEVENT, key) - - # Otherwise, deal with it as a key. - if keydown: - rv = "(ev.type == %d" % pygame.KEYDOWN - else: - rv = "(ev.type == %d" % pygame.KEYUP - - if part[0] == "alt": - part.pop(0) - rv += " and (ev.mod & %d)" % pygame.KMOD_ALT - else: - rv += " and not (ev.mod & %d)" % pygame.KMOD_ALT - - if part[0] == "meta": - part.pop(0) - rv += " and (ev.mod & %d)" % pygame.KMOD_META - else: - rv += " and not (ev.mod & %d)" % pygame.KMOD_META - - if part[0] == "shift": - part.pop(0) - rv += " and (ev.mod & %d)" % pygame.KMOD_SHIFT - - if part[0] == "noshift": - part.pop(0) - rv += " and not (ev.mod & %d)" % pygame.KMOD_SHIFT - - if len(part) == 1: - if len(part[0]) != 1: - if renpy.config.developer: - raise Exception("Invalid key specifier %s" % key) - else: - return "(False)" - - rv += " and ev.unicode == %r)" % part[0] - - else: - if part[0] != "K": - if renpy.config.developer: - raise Exception("Invalid key specifier %s" % key) - else: - return "(False)" - - key = "_".join(part) - - rv += " and ev.key == %d)" % (getattr(pygame.constants, key)) - - return rv - -# These store a lambda for each compiled key in the system. -event_cache = { } -keyup_cache = { } - -def map_event(ev, name): - """Returns true if the event matches the named keycode being pressed.""" - - check_code = event_cache.get(name, None) - if check_code is None: - check_code = eval("lambda ev : " + compile_event(name, True), globals()) - event_cache[name] = check_code - - return check_code(ev) - -def map_keyup(ev, name): - """Returns true if the event matches the named keycode being released.""" - - check_code = keyup_cache.get(name, None) - if check_code is None: - check_code = eval("lambda ev : " + compile_event(name, False), globals()) - keyup_cache[name] = check_code - - return check_code(ev) - - -def skipping(ev): - """ - This handles setting skipping in response to the press of one of the - CONTROL keys. The library handles skipping in response to TAB. - """ - - if not renpy.config.allow_skipping: - return - - if map_event(ev, "skip"): - renpy.config.skipping = "slow" - renpy.exports.restart_interaction() - - if map_keyup(ev, "skip"): - renpy.config.skipping = None - renpy.exports.restart_interaction() - - return - - -def inspector(ev): - return map_event(ev, "inspector") - - -############################################################################## -# Utility functions for dealing with actions. - -def predict_action(var): - """ - Predicts some of the actions that may be caused by a variable. - """ - - if var is None: - return - - if isinstance(var, renpy.ui.Action): - var.predict() - - if isinstance(var, (list, tuple)): - for i in var: - predict_action(i) - -def run(var, *args, **kwargs): - """ - Runs a variable. This is done by calling all the functions, and - iterating over the lists and tuples. - """ - - if var is None: - return None - - if isinstance(var, (list, tuple)): - rv = None - - for i in var: - new_rv = run(i, *args, **kwargs) - - if new_rv is not None: - rv = new_rv - - return rv - - return var(*args, **kwargs) - -def run_unhovered(var): - """ - Calls the unhovered method on the variable, if it exists. - """ - - if var is None: - return None - - if isinstance(var, (list, tuple)): - for i in var: - run_unhovered(i) - - return - - f = getattr(var, "unhovered", None) - if f is not None: - f() - -def run_periodic(var, st): - - if isinstance(var, (list, tuple)): - rv = None - - for i in var: - v = run_periodic(i, st) - - if rv is None or v < rv: - rv = v - - return rv - - if isinstance(var, renpy.ui.Action): - return var.periodic(st) - - -def is_selected(clicked): - - if isinstance(clicked, (list, tuple)): - return any(is_selected(i) for i in clicked) - - elif isinstance(clicked, renpy.ui.Action): - return clicked.get_selected() - else: - return False - - -def is_sensitive(clicked): - - if isinstance(clicked, (list, tuple)): - return all(is_sensitive(i) for i in clicked) - - elif isinstance(clicked, renpy.ui.Action): - return clicked.get_sensitive() - else: - return True - - -############################################################################## -# Special-Purpose Displayables - -class Keymap(renpy.display.layout.Null): - """ - This is a behavior that maps keys to actions that are called when - the key is pressed. The keys are specified by giving the appropriate - k_constant from pygame.constants, or the unicode for the key. - """ - - def __init__(self, replaces=None, **keymap): - super(Keymap, self).__init__(style='default') - self.keymap = keymap - - def event(self, ev, x, y, st): - - for name, action in self.keymap.items(): - if map_event(ev, name): - - rv = run(action) - - if rv is not None: - return rv - - raise renpy.display.core.IgnoreEvent() - - def predict_one_action(self): - for i in self.keymap.values(): - predict_action(i) - - -class RollForward(renpy.display.layout.Null): - """ - This behavior implements rollforward. - """ - - def __init__(self, value, **properties): - super(RollForward, self).__init__(**properties) - self.value = value - - - def event(self, ev, x, y, st): - - if map_event(ev, "rollforward"): - renpy.game.interface.suppress_transition = True - renpy.game.after_rollback = True - renpy.game.log.rolled_forward = True - return self.value - - -class PauseBehavior(renpy.display.layout.Null): - """ - This is a class implementing the Pause behavior, which is to - return a value after a certain amount of time has elapsed. - """ - - def __init__(self, delay, result=False, **properties): - super(PauseBehavior, self).__init__(**properties) - - self.delay = delay - self.result = result - - def event(self, ev, x, y, st): - - if st >= self.delay: - - # If we have been drawn since the timeout, simply return - # true. Otherwise, force a redraw, and return true when - # it comes back. - if renpy.game.interface.drawn_since(st - self.delay): - return self.result - else: - renpy.game.interface.force_redraw = True - - - renpy.game.interface.timeout(max(self.delay - st, 0)) - -class SoundStopBehavior(renpy.display.layout.Null): - """ - This is a class implementing the sound stop behavior, - which is to return False when a sound is no longer playing - on the named channel. - """ - - def __init__(self, channel, result=False, **properties): - super(SoundStopBehavior, self).__init__(**properties) - - self.channel = channel - self.result = result - - - def event(self, ev, x, y, st): - - if not renpy.audio.music.get_playing(self.channel): - return self.result - - renpy.game.interface.timeout(.025) - - -class SayBehavior(renpy.display.layout.Null): - """ - This is a class that implements the say behavior, - which is to return True (ending the interaction) if - the user presses space or enter, or clicks the left - mouse button. - """ - - focusable = True - - def __init__(self, default=True, afm=None, dismiss=[ 'dismiss' ], allow_dismiss=None, **properties): - super(SayBehavior, self).__init__(default=default, **properties) - - if not isinstance(dismiss, (list, tuple)): - dismiss = [ dismiss ] - - if afm is not None: - self.afm_length = len(afm) - else: - self.afm_length = None - - # What keybindings lead to dismissal? - self.dismiss = dismiss - - self.allow_dismiss = allow_dismiss - - def set_afm_length(self, afm_length): - self.afm_length = max(afm_length, 1) - - def event(self, ev, x, y, st): - - if self.afm_length and renpy.game.preferences.afm_time and renpy.game.preferences.afm_enable: - - afm_delay = ( 1.0 * ( renpy.config.afm_bonus + self.afm_length ) / renpy.config.afm_characters ) * renpy.game.preferences.afm_time - - if renpy.game.preferences.text_cps: - afm_delay += 1.0 / renpy.game.preferences.text_cps * self.afm_length - - if st > afm_delay: - if renpy.config.afm_callback: - if renpy.config.afm_callback(): - return True - else: - renpy.game.interface.timeout(0.1) - else: - return True - else: - renpy.game.interface.timeout(afm_delay - st) - - for dismiss in self.dismiss: - - if map_event(ev, dismiss) and self.is_focused(): - - if renpy.config.skipping: - renpy.config.skipping = None - renpy.exports.restart_interaction() - raise renpy.display.core.IgnoreEvent() - - if renpy.game.preferences.using_afm_enable and renpy.game.preferences.afm_enable: - renpy.game.preferences.afm_enable = False - renpy.exports.restart_interaction() - raise renpy.display.core.IgnoreEvent() - - if self.allow_dismiss: - if not self.allow_dismiss(): - raise renpy.display.core.IgnoreEvent() - - return True - - skip_delay = renpy.config.skip_delay / 1000.0 - - if renpy.config.allow_skipping and renpy.config.skipping: - - if st >= skip_delay: - if renpy.game.preferences.skip_unseen: - return True - elif renpy.config.skipping == "fast": - return True - elif renpy.game.context().seen_current(True): - return True - else: - renpy.game.interface.timeout(skip_delay - st) - - - return None - - -############################################################################## -# Button - -class Button(renpy.display.layout.Window): - - keymap = { } - action = None - - def __init__(self, child=None, style='button', clicked=None, - hovered=None, unhovered=None, action=None, role=None, - time_policy=None, keymap={}, - **properties): - - super(Button, self).__init__(child, style=style, **properties) - - if isinstance(clicked, renpy.ui.Action): - action = clicked - - if action is not None: - clicked = action - - if not is_sensitive(action): - clicked = None - - if role is None: - if action: - if is_selected(action): - role = 'selected_' - else: - role = '' - else: - role = '' - - self.action = action - self.activated = False - self.clicked = clicked - self.hovered = hovered - self.unhovered = unhovered - self.focusable = clicked is not None - self.role = role - self.keymap = keymap - - self.time_policy_data = None - - def predict_one_action(self): - predict_action(self.clicked) - predict_action(self.hovered) - predict_action(self.unhovered) - - if self.keymap: - for v in self.keymap.values(): - predict_action(v) - - def render(self, width, height, st, at): - - if self.style.time_policy: - st, self.time_policy_data = self.style.time_policy(st, self.time_policy_data, self.style) - - rv = super(Button, self).render(width, height, st, at) - - if self.clicked: - - rect = self.style.focus_rect - if rect is not None: - fx, fy, fw, fh = rect - else: - fx = self.style.left_margin - fy = self.style.top_margin - fw = rv.width - self.style.right_margin - fh = rv.height - self.style.bottom_margin - - mask = self.style.focus_mask - - if mask is True: - mask = rv - elif mask is not None: - mask = renpy.easy.displayable(mask) - mask = renpy.display.render.render(mask, rv.width, rv.height, st, at) - - if mask is not None: - fmx = 0 - fmy = 0 - else: - fmx = None - fmy = None - - rv.add_focus(self, None, - fx, fy, fw, fh, - fmx, fmy, mask) - - return rv - - - def focus(self, default=False): - super(Button, self).focus(default) - - if self.activated: - return None - - rv = None - - if not default: - rv = run(self.hovered) - - self.set_transform_event(self.role + "hover") - self.child.set_transform_event(self.role + "hover") - - return rv - - - def unfocus(self, default=False): - super(Button, self).unfocus(default) - - if self.activated: - return None - - if not default: - run_unhovered(self.hovered) - run(self.unhovered) - - self.set_transform_event(self.role + "idle") - self.child.set_transform_event(self.role + "idle") - - - def per_interact(self): - if not self.clicked: - self.set_style_prefix(self.role + "insensitive_", True) - else: - self.set_style_prefix(self.role + "idle_", True) - - super(Button, self).per_interact() - - def event(self, ev, x, y, st): - - # Call self.action.periodic() - timeout = run_periodic(self.action, st) - - if timeout is not None: - renpy.game.interface.timeout(timeout) - - # If we have a child, try passing the event to it. (For keyboard - # events, this only happens if we're focused.) - if self.is_focused() or not (ev.type == pygame.KEYDOWN or ev.type == pygame.KEYUP): - rv = super(Button, self).event(ev, x, y, st) - if rv is not None: - return rv - - # If not focused, ignore all events. - if not self.is_focused(): - return None - - # Check the keymap. - for name, action in self.keymap.items(): - if map_event(ev, name): - return run(action) - - # Ignore as appropriate: - if map_event(ev, "button_ignore") and self.clicked: - raise renpy.display.core.IgnoreEvent() - - # If clicked, - if map_event(ev, "button_select") and self.clicked: - - self.activated = True - self.style.set_prefix(self.role + 'activate_') - - if self.style.sound: - renpy.audio.music.play(self.style.sound, channel="sound") - - rv = run(self.clicked) - - if rv is not None: - return rv - else: - self.activated = False - - if self.is_focused(): - self.set_style_prefix(self.role + "hover_", True) - else: - self.set_style_prefix(self.role + "idle_", True) - - raise renpy.display.core.IgnoreEvent() - - return None - - - def set_style_prefix(self, prefix, root): - if root: - super(Button, self).set_style_prefix(prefix, root) - - -# Reimplementation of the TextButton widget as a Button and a Text -# widget. -def TextButton(text, style='button', text_style='button_text', - clicked=None, **properties): - - text = renpy.text.text.Text(text, style=text_style) #@UndefinedVariable - return Button(text, style=style, clicked=clicked, **properties) - -class ImageButton(Button): - """ - Used to implement the guts of an image button. - """ - - def __init__(self, - idle_image, - hover_image, - insensitive_image = None, - activate_image = None, - selected_idle_image = None, - selected_hover_image = None, - selected_insensitive_image = None, - selected_activate_image = None, - style='image_button', - clicked=None, - hovered=None, - **properties): - - insensitive_image = insensitive_image or idle_image - activate_image = activate_image or hover_image - - selected_idle_image = selected_idle_image or idle_image - selected_hover_image = selected_hover_image or hover_image - selected_insensitive_image = selected_insensitive_image or insensitive_image - selected_activate_image = selected_activate_image or activate_image - - self.state_children = dict( - idle_ = renpy.easy.displayable(idle_image), - hover_ = renpy.easy.displayable(hover_image), - insensitive_ = renpy.easy.displayable(insensitive_image), - activate_ = renpy.easy.displayable(activate_image), - - selected_idle_ = renpy.easy.displayable(selected_idle_image), - selected_hover_ = renpy.easy.displayable(selected_hover_image), - selected_insensitive_ = renpy.easy.displayable(selected_insensitive_image), - selected_activate_ = renpy.easy.displayable(selected_activate_image), - ) - - super(ImageButton, self).__init__(renpy.display.layout.Null(), - style=style, - clicked=clicked, - hovered=hovered, - **properties) - - def visit(self): - return list(self.state_children.values()) - - def get_child(self): - return self.style.child or self.state_children[self.style.prefix] - - -# This is used for an input that takes its focus from a button. -class HoveredProxy(object): - def __init__(self, a, b): - self.a = a - self.b = b - - def __call__(self): - self.a() - if self.b: - return self.b() - - -class Input(renpy.text.text.Text): #@UndefinedVariable - """ - This is a Displayable that takes text as input. - """ - - changed = None - prefix = "" - suffix = "" - caret_pos = 0 - - def __init__(self, - default="", - length=None, - style='input', - allow=None, - exclude=None, - prefix="", - suffix="", - changed=None, - button=None, - replaces=None, - editable=True, - **properties): - - super(Input, self).__init__("", style=style, replaces=replaces, substitute=False, **properties) - - self.content = str(default) - self.length = length - - self.allow = allow - self.exclude = exclude - self.prefix = prefix - self.suffix = suffix - - self.changed = changed - - self.editable = editable - - caretprops = { 'color' : None } - - for i in properties: - if i.endswith("color"): - caretprops[i] = properties[i] - - self.caret = renpy.display.image.Solid(xmaximum=1, style=style, **caretprops) - self.caret_pos = len(self.content) - - if button: - self.editable = False - button.hovered = HoveredProxy(self.enable, button.hovered) - button.unhovered = HoveredProxy(self.disable, button.unhovered) - - if isinstance(replaces, Input): - self.content = replaces.content - self.editable = replaces.editable - self.caret_pos = replaces.caret_pos - - self.update_text(self.content, self.editable) - - - def update_text(self, content, editable): - - if content != self.content or editable != self.editable: - renpy.display.render.redraw(self, 0) - - if content != self.content: - self.content = content - - if self.changed: - self.changed(content) - - if content == "": - content = "\u200b" - - self.editable = editable - - # Choose the caret. - caret = self.style.caret - if caret is None: - caret = self.caret - - if editable: - l = len(content) - self.set_text([self.prefix, content[0:self.caret_pos].replace("{", "{{"), caret, - content[self.caret_pos:l].replace("{", "{{"), self.suffix]) - else: - self.set_text([self.prefix, content.replace("{", "{{"), self.suffix ]) - - # This is needed to ensure the caret updates properly. - def set_style_prefix(self, prefix, root): - if prefix != self.style.prefix: - self.update_text(self.content, self.editable) - - super(Input, self).set_style_prefix(prefix, root) - - def enable(self): - self.update_text(self.content, True) - - def disable(self): - self.update_text(self.content, False) - - def event(self, ev, x, y, st): - - if not self.editable: - return None - - l = len(self.content) - - if map_event(ev, "input_backspace"): - - if self.content and self.caret_pos > 0: - content = self.content[0:self.caret_pos-1] + self.content[self.caret_pos:l] - self.caret_pos -= 1 - self.update_text(content, self.editable) - - renpy.display.render.redraw(self, 0) - raise renpy.display.core.IgnoreEvent() - - elif map_event(ev, "input_enter"): - if not self.changed: - return self.content - - elif map_event(ev, "input_left"): - if self.caret_pos > 0: - self.caret_pos -= 1 - self.update_text(self.content, self.editable) - - renpy.display.render.redraw(self, 0) - raise renpy.display.core.IgnoreEvent() - - elif map_event(ev, "input_right"): - if self.caret_pos < l: - self.caret_pos += 1 - self.update_text(self.content, self.editable) - - renpy.display.render.redraw(self, 0) - raise renpy.display.core.IgnoreEvent() - - elif map_event(ev, "input_delete"): - if self.caret_pos < l: - content = self.content[0:self.caret_pos] + self.content[self.caret_pos+1:l] - self.update_text(content, self.editable) - - renpy.display.render.redraw(self, 0) - raise renpy.display.core.IgnoreEvent() - - elif ev.type == pygame.KEYDOWN and ev.str: - if ord(ev.str[0]) < 32: - return None - - if self.length and len(self.content) >= self.length: - raise renpy.display.core.IgnoreEvent() - - if self.allow and ev.str not in self.allow: - raise renpy.display.core.IgnoreEvent() - - if self.exclude and ev.str in self.exclude: - raise renpy.display.core.IgnoreEvent() - - content = self.content[0:self.caret_pos] + ev.str + self.content[self.caret_pos:l] - self.caret_pos += 1 - - self.update_text(content, self.editable) - - raise renpy.display.core.IgnoreEvent() - -# A map from adjustment to lists of displayables that want to be redrawn -# if the adjustment changes. -adj_registered = { } - -# This class contains information about an adjustment that can change the -# position of content. -class Adjustment(renpy.object.Object): - """ - :doc: ui - :name: ui.adjustment class - - Adjustment objects represent a value that can be adjusted by a bar - or viewport. They contain information about the value, the range - of the value, and how to adjust the value in small steps and large - pages. - - - """ - - def __init__(self, range=1, value=0, step=None, page=0, changed=None, adjustable=None, ranged=None): #@ReservedAssignment - """ - The following parameters correspond to fields or properties on - the adjustment object: - - `range` - The range of the adjustment, a number. - - `value` - The value of the adjustment, a number. - - `step` - The step size of the adjustment, a number. If None, then - defaults to 1/10th of a page, if set. Otherwise, defaults - to the 1/20th of the range. - - This is used when scrolling a viewport with the mouse wheel. - - `page` - The page size of the adjustment. If None, this is set - automatically by a viewport. If never set, defaults to 1/10th - of the range. - - It's can be used when clicking on a scrollbar. - - The following parameters control the behavior of the adjustment. - - `adjustable` - If True, this adjustment can be changed by a bar. If False, - it can't. - - It defaults to being adjustable if a `changed` function - is given or if the adjustment is associated with a viewport, - and not adjustable otherwise. - - `changed` - This function is called with the new value when the value of - the adjustment changes. - - `ranged` - This function is called with the adjustment object when - the range of the adjustment is set by a viewport. - - .. method:: change(value) - - Changes the value of the adjustment to `value`, updating - any bars and viewports that use the adjustment. - """ - - - super(Adjustment, self).__init__() - - if adjustable is None: - if changed: - adjustable = True - - self._value = value - self._range = range - self._page = page - self._step = step - self.changed = changed - self.adjustable = adjustable - self.ranged = ranged - - def get_value(self): - if self._value > self._range: - return self._range - - return self._value - - def set_value(self, v): - self._value = v - - value = property(get_value, set_value) - - def get_range(self): - return self._range - - def set_range(self, v): - self._range = v - if self.ranged: - self.ranged(self) - - range = property(get_range, set_range) #@ReservedAssignment - - def get_page(self): - if self._page is not None: - return self._page - - return self._range / 10 - - def set_page(self, v): - self._page = v - - page = property(get_page, set_page) - - def get_step(self): - if self._step is not None: - return self._step - - if self._page is not None and self.page > 0: - return self._page / 10 - - if isinstance(self._range, float): - return self._range / 10 - else: - return 1 - - def set_step(self, v): - self._step = v - - step = property(get_step, set_step) - - # Register a displayable to be redrawn when this adjustment changes. - def register(self, d): - adj_registered.setdefault(self, [ ]).append(d) - - def change(self, value): - - if value < 0: - value = 0 - if value > self._range: - value = self._range - - if value != self._value: - self._value = value - for d in adj_registered.setdefault(self, [ ]): - renpy.display.render.redraw(d, 0) - if self.changed: - return self.changed(value) - - return None - -class Bar(renpy.display.core.Displayable): - """ - Implements a bar that can display an integer value, and respond - to clicks on that value. - """ - - __version__ = 2 - - def after_upgrade(self, version): - - if version < 1: - self.adjustment = Adjustment(self.range, self.value, changed=self.changed) # E1101 - self.adjustment.register(self) - del self.range # E1101 - del self.value # E1101 - del self.changed # E1101 - - if version < 2: - self.value = None - - def __init__(self, - range=None, #@ReservedAssignment - value=None, - width=None, - height=None, - changed=None, - adjustment=None, - step=None, - page=None, - bar=None, - style=None, - vertical=False, - replaces=None, - hovered=None, - unhovered=None, - **properties): - - self.value = None - - if adjustment is None: - if isinstance(value, renpy.ui.BarValue): - - if isinstance(replaces, Bar): - value.replaces(replaces.value) - - self.value = value - adjustment = value.get_adjustment() - renpy.game.interface.timeout(0) - else: - adjustment = Adjustment(range, value, step=step, page=page, changed=changed) - - if style is None: - if self.value is not None: - if vertical: - style = self.value.get_style()[1] - else: - style = self.value.get_style()[0] - else: - if vertical: - style = 'vbar' - else: - style = 'bar' - - if width is not None: - properties['xmaximum'] = width - - if height is not None: - properties['ymaximum'] = height - - super(Bar, self).__init__(style=style, **properties) - - self.adjustment = adjustment - self.focusable = True - - # These are set when we are first rendered. - self.thumb_dim = 0 - self.height = 0 - self.width = 0 - self.hidden = False - - self.hovered = hovered - self.unhovered = unhovered - - def per_interact(self): - self.focusable = self.adjustment.adjustable - self.adjustment.register(self) - - def predict_one(self): - pd = renpy.display.predict.displayable - style = self.style - - pd(style.insensitive_fore_bar) - pd(style.idle_fore_bar) - pd(style.hover_fore_bar) - pd(style.selected_idle_fore_bar) - pd(style.selected_hover_fore_bar) - - pd(style.insensitive_aft_bar) - pd(style.idle_aft_bar) - pd(style.hover_aft_bar) - pd(style.selected_idle_aft_bar) - pd(style.selected_hover_aft_bar) - - pd(style.insensitive_thumb) - pd(style.idle_thumb) - pd(style.hover_thumb) - pd(style.selected_idle_thumb) - pd(style.selected_hover_thumb) - - pd(style.insensitive_thumb_shadow) - pd(style.idle_thumb_shadow) - pd(style.hover_thumb_shadow) - pd(style.selected_idle_thumb_shadow) - pd(style.selected_hover_thumb_shadow) - - def render(self, width, height, st, at): - - # Handle redrawing. - if self.value is not None: - redraw = self.value.periodic(st) - - if redraw is not None: - renpy.display.render.redraw(self, redraw) - - # Store the width and height for the event function to use. - self.width = width - self.height = height - range = self.adjustment.range #@ReservedAssignment - value = self.adjustment.value - page = self.adjustment.page - - if range <= 0: - if self.style.unscrollable == "hide": - self.hidden = True - return renpy.display.render.Render(width, height) - elif self.style.unscrollable == "insensitive": - self.set_style_prefix("insensitive_", True) - - self.hidden = False - - if self.style.bar_invert ^ self.style.bar_vertical: - value = range - value - - bar_vertical = self.style.bar_vertical - - if bar_vertical: - dimension = height - else: - dimension = width - - fore_gutter = self.style.fore_gutter - aft_gutter = self.style.aft_gutter - - active = dimension - fore_gutter - aft_gutter - if range: - thumb_dim = active * page / (range + page) - else: - thumb_dim = active - - thumb_offset = abs(self.style.thumb_offset) - - if bar_vertical: - thumb = render(self.style.thumb, width, thumb_dim, st, at) - thumb_shadow = render(self.style.thumb_shadow, width, thumb_dim, st, at) - thumb_dim = thumb.height - else: - thumb = render(self.style.thumb, thumb_dim, height, st, at) - thumb_shadow = render(self.style.thumb_shadow, thumb_dim, height, st, at) - thumb_dim = thumb.width - - # Remove the offset from the thumb. - thumb_dim -= thumb_offset * 2 - self.thumb_dim = thumb_dim - - active -= thumb_dim - - if range: - fore_size = active * value / range - else: - fore_size = active - - fore_size = int(fore_size) - - aft_size = active - fore_size - - fore_size += fore_gutter - aft_size += aft_gutter - - rv = renpy.display.render.Render(width, height) - - if bar_vertical: - - if self.style.bar_resizing: - foresurf = render(self.style.fore_bar, width, fore_size, st, at) - aftsurf = render(self.style.aft_bar, width, aft_size, st, at) - rv.blit(thumb_shadow, (0, fore_size - thumb_offset)) - rv.blit(foresurf, (0, 0), main=False) - rv.blit(aftsurf, (0, height-aft_size), main=False) - rv.blit(thumb, (0, fore_size - thumb_offset)) - - else: - foresurf = render(self.style.fore_bar, width, height, st, at) - aftsurf = render(self.style.aft_bar, width, height, st, at) - - rv.blit(thumb_shadow, (0, fore_size - thumb_offset)) - rv.blit(foresurf.subsurface((0, 0, width, fore_size)), (0, 0), main=False) - rv.blit(aftsurf.subsurface((0, height - aft_size, width, aft_size)), (0, height - aft_size), main=False) - rv.blit(thumb, (0, fore_size - thumb_offset)) - - else: - if self.style.bar_resizing: - foresurf = render(self.style.fore_bar, fore_size, height, st, at) - aftsurf = render(self.style.aft_bar, aft_size, height, st, at) - rv.blit(thumb_shadow, (fore_size - thumb_offset, 0)) - rv.blit(foresurf, (0, 0), main=False) - rv.blit(aftsurf, (width-aft_size, 0), main=False) - rv.blit(thumb, (fore_size - thumb_offset, 0)) - - else: - foresurf = render(self.style.fore_bar, width, height, st, at) - aftsurf = render(self.style.aft_bar, width, height, st, at) - - rv.blit(thumb_shadow, (fore_size - thumb_offset, 0)) - rv.blit(foresurf.subsurface((0, 0, fore_size, height)), (0, 0), main=False) - rv.blit(aftsurf.subsurface((width - aft_size, 0, aft_size, height)), (width-aft_size, 0), main=False) - rv.blit(thumb, (fore_size - thumb_offset, 0)) - - if self.focusable: - rv.add_focus(self, None, 0, 0, width, height) - - return rv - - - def focus(self, default=False): - super(Bar, self).focus(default) - self.set_transform_event("hover") - - if not default: - run(self.hovered) - - - def unfocus(self, default=False): - super(Bar, self).unfocus() - self.set_transform_event("idle") - - if not default: - run_unhovered(self.hovered) - run(self.unhovered) - - def event(self, ev, x, y, st): - - if not self.focusable: - return None - - if not self.is_focused(): - return None - - if self.hidden: - return None - - range = self.adjustment.range #@ReservedAssignment - old_value = self.adjustment.value - value = old_value - - vertical = self.style.bar_vertical - invert = self.style.bar_invert ^ vertical - if invert: - value = range - value - - grabbed = (renpy.display.focus.get_grab() is self) - just_grabbed = False - - if not grabbed and map_event(ev, "bar_activate"): - renpy.display.focus.set_grab(self) - just_grabbed = True - grabbed = True - - if grabbed: - - if vertical: - increase = "bar_down" - decrease = "bar_up" - else: - increase = "bar_right" - decrease = "bar_left" - - if map_event(ev, decrease): - value -= self.adjustment.step - - if map_event(ev, increase): - value += self.adjustment.step - - if ev.type in (pygame.MOUSEMOTION, pygame.MOUSEBUTTONUP, pygame.MOUSEBUTTONDOWN): - - if vertical: - - tgutter = self.style.fore_gutter - bgutter = self.style.aft_gutter - zone_height = self.height - tgutter - bgutter - self.thumb_dim - if zone_height: - value = (y - tgutter - self.thumb_dim / 2) * range / zone_height - else: - value = 0 - - else: - lgutter = self.style.fore_gutter - rgutter = self.style.aft_gutter - zone_width = self.width - lgutter - rgutter - self.thumb_dim - if zone_width: - value = (x - lgutter - self.thumb_dim / 2) * range / zone_width - else: - value = 0 - - if isinstance(range, int): - value = int(value) - - if value < 0: - value = 0 - - if value > range: - value = range - - if invert: - value = range - value - - if grabbed and not just_grabbed and map_event(ev, "bar_deactivate"): - renpy.display.focus.set_grab(None) - - if value != old_value: - return self.adjustment.change(value) - - return None - - -class Conditional(renpy.display.layout.Container): - """ - This class renders its child if and only if the condition is - true. Otherwise, it renders nothing. (Well, a Null). - - Warning: the condition MUST NOT update the game state in any - way, as that would break rollback. - """ - - def __init__(self, condition, *args, **properties): - super(Conditional, self).__init__(*args, **properties) - - self.condition = condition - self.null = renpy.display.layout.Null() - - self.state = eval(self.condition, vars(renpy.store)) - - def render(self, width, height, st, at): - if self.state: - return render(self.child, width, height, st, at) - else: - return render(self.null, width, height, st, at) - - def event(self, ev, x, y, st): - - state = eval(self.condition, vars(renpy.store)) - - if state != self.state: - renpy.display.render.redraw(self, 0) - - self.state = state - - if state: - return self.child.event(ev, x, y, st) - - -class TimerState(renpy.python.RevertableObject): - """ - Stores the state of the timer, which may need to be rolled back. - """ - - # Prevents us from having to worry about our initialization being - # rolled back. - started = False - next_event = None - -class Timer(renpy.display.layout.Null): - - __version__ = 1 - - started = False - - def after_upgrade(self, version): - if version < 1: - self.state = TimerState() - self.state.started = self.started - self.state.next_event = self.next_event - - def __init__(self, delay, action=None, repeat=False, args=(), kwargs={}, replaces=None, **properties): - super(Timer, self).__init__(**properties) - - if action is None: - raise Exception("A timer must have an action supplied.") - - if delay <= 0: - raise Exception("A timer's delay must be > 0.") - - # The delay. - self.delay = delay - - # Should we repeat the event? - self.repeat = repeat - - # The time the next event should occur. - self.next_event = None - - # The function and its arguments. - self.function = action - self.args = args - self.kwargs = kwargs - - # Did we start the timer? - self.started = False - - if replaces is not None: - self.state = replaces.state - else: - self.state = TimerState() - - - def event(self, ev, x, y, st): - - state = self.state - - if not state.started: - state.started = True - state.next_event = st + self.delay - - if state.next_event is None: - return - - if st < state.next_event: - renpy.game.interface.timeout(state.next_event - st) - return - - if not self.repeat: - state.next_event = None - else: - state.next_event = state.next_event + self.delay - if state.next_event < st: - state.next_event = st + self.delay - - renpy.game.interface.timeout(state.next_event - st) - - return run(self.function, *self.args, **self.kwargs) - - -class MouseArea(renpy.display.core.Displayable): - - def __init__(self, hovered=None, unhovered=None, replaces=None, **properties): - super(MouseArea, self).__init__(**properties) - - self.hovered = hovered - self.unhovered = unhovered - - # Are we hovered right now? - self.is_hovered = False - - if replaces is not None: - self.is_hovered = replaces.is_hovered - - # Taken from the render. - self.width = 0 - self.height = 0 - - - def render(self, width, height, st, at): - self.width = width - self.height = height - - return Render(width, height) - - def event(self, ev, x, y, st): - - if 0 <= x < self.width and 0 <= y < self.height: - is_hovered = True - else: - is_hovered = False - - if is_hovered and not self.is_hovered: - self.is_hovered = True - - return run(self.hovered) - - elif not is_hovered and self.is_hovered: - self.is_hovered = False - - run_unhovered(self.hovered) - run(self.unhovered) - - diff --git a/unrpyc/renpy/display/core.py b/unrpyc/renpy/display/core.py deleted file mode 100644 index 4731df0..0000000 --- a/unrpyc/renpy/display/core.py +++ /dev/null @@ -1,2463 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This file contains code for initializing and managing the display -# window. - -import renpy.display -import renpy.audio -import renpy.text - -import pygame #@UnusedImport - -import sys -import os -import time -import io -import threading - -try: - import android #@UnresolvedImport @UnusedImport - import android.sound #@UnresolvedImport -except: - android = None - -# Is the cpu idle enough to do other things? -cpu_idle = threading.Event() -cpu_idle.clear() - -# Need to be +4, so we don't interfere with FFMPEG's events. -TIMEEVENT = pygame.USEREVENT + 4 -PERIODIC = pygame.USEREVENT + 5 -JOYEVENT = pygame.USEREVENT + 6 -REDRAW = pygame.USEREVENT + 7 - -# All events except for TIMEEVENT and REDRAW -ALL_EVENTS = [ i for i in range(0, REDRAW + 1) if i != TIMEEVENT and i != REDRAW ] - -# The number of msec between periodic events. -PERIODIC_INTERVAL = 50 - -# Time management. -time_base = None - -def init_time(): - global time_base - time_base = time.time() - pygame.time.get_ticks() / 1000.0 - -def get_time(): - return time_base + pygame.time.get_ticks() / 1000.0 - - -def displayable_by_tag(layer, tag): - """ - Get the displayable on the given layer with the given tag. - """ - - return renpy.game.context().scene_lists.get_displayable_by_tag(layer, tag) - -class IgnoreEvent(Exception): - """ - Exception that is raised when we want to ignore an event, but - also don't want to return anything. - """ - - pass - -class EndInteraction(Exception): - """ - Exception that can be raised (for example, during the render method of - a displayable) to end the current interaction immediately. - """ - - def __init__(self, value): - self.value = value - -class absolute(float): - """ - This represents an absolute float coordinate. - """ - __slots__ = [ ] - - -class Displayable(renpy.object.Object): - """ - The base class for every object in Ren'Py that can be - displayed to the screen. - - Drawables will be serialized to a savegame file. Therefore, they - shouldn't store non-serializable things (like pygame surfaces) in - their fields. - """ - - # Some invariants about method call order: - # - # per_interact is called before render. - # render is called before event. - # - # get_placement can be called at any time, so can't - # assume anything. - - activated = False - focusable = False - full_focus_name = None - role = '' - - # The event we'll pass on to our parent transform. - transform_event = None - - # Can we change our look in response to transform_events? - transform_event_responder = False - - def __init__(self, focus=None, default=False, style='default', **properties): # W0231 - self.style = renpy.style.Style(style, properties, heavy=True) - self.focus_name = focus - self.default = default - - def find_focusable(self, callback, focus_name): - - focus_name = self.focus_name or focus_name - - if self.focusable: - callback(self, focus_name) - - for i in self.visit(): - if i is None: - continue - - i.find_focusable(callback, focus_name) - - - def focus(self, default=False): - """ - Called to indicate that this widget has the focus. - """ - - if not self.activated: - self.set_style_prefix(self.role + "hover_", True) - - if not default and not self.activated: - if self.style.sound: - renpy.audio.music.play(self.style.sound, channel="sound") - - def unfocus(self, default=False): - """ - Called to indicate that this widget has become unfocused. - """ - - if not self.activated: - self.set_style_prefix(self.role + "idle_", True) - - def is_focused(self): - - if renpy.display.focus.grab and renpy.display.focus.grab is not self: - return - - return renpy.game.context().scene_lists.focused is self - - def set_style_prefix(self, prefix, root): - """ - Called to set the style prefix of this widget and its child - widgets, if any. - - `root` - True if this is the root of a style tree, False if this - has been passed on to a child. - """ - - if prefix == self.style.prefix: - return - - self.style.set_prefix(prefix) - renpy.display.render.redraw(self, 0) - - def parameterize(self, name, parameters): - """ - Called to parameterize this. By default, we don't take any - parameters. - """ - - if parameters: - raise Exception("Image '%s' can't take parameters '%s'. (Perhaps you got the name wrong?)" % - (' '.join(name), ' '.join(parameters))) - - return self - - def render(self, width, height, st, at): - """ - Called to display this displayable. This is called with width - and height parameters, which give the largest width and height - that this drawable can be drawn to without overflowing some - bounding box. It's also given two times. It returns a Surface - that is the current image of this drawable. - - @param st: The time since this widget was first shown, in seconds. - @param at: The time since a similarly named widget was first shown, - in seconds. - """ - - assert False, "Draw not implemented." - - def event(self, ev, x, y, st): - """ - Called to report than an event has occured. Ev is the raw - pygame event object representing that event. If the event - involves the mouse, x and y are the translation of the event - into the coordinates of this displayable. st is the time this - widget has been shown for. - - @returns A value that should be returned from Interact, or None if - no value is appropriate. - """ - - return None - - def get_placement(self): - """ - Returns a style object containing placement information for - this Displayable. Children are expected to overload this - to return something more sensible. - """ - - return self.style.get_placement() - - def visit_all(self, callback): - """ - Calls the callback on this displayable and all children of this - displayable. - """ - - for d in self.visit(): - if not d: - continue - d.visit_all(callback) - - callback(self) - - def visit(self): - """ - Called to ask the displayable to return a list of its children - (including children taken from styles). For convenience, this - list may also include None values. - """ - - return [ ] - - def per_interact(self): - """ - Called once per widget per interaction. - """ - - return None - - def predict_one(self): - """ - Called to ask this displayable to call the callback with all - the images it may want to load. - """ - - return - - def predict_one_action(self): - """ - Called to ask this displayable to cause image prediction - to occur for images that may be loaded by its actions. - """ - - return - - def place(self, dest, x, y, width, height, surf, main=True): - """ - This draws this Displayable onto a destination surface, using - the placement style information returned by this object's - get_placement() method. - - @param dest: The surface that this displayable will be drawn - on. - - @param x: The minimum x coordinate on this surface that this - Displayable will be drawn to. - - @param y: The minimum y coordinate on this surface that this - displayable will be drawn to. - - @param width: The width of the area allocated to this - Displayable. - - @param height: The height of the area allocated to this - Displayable. - - @param surf: The surface returned by a previous call to - self.render(). - """ - - xpos, ypos, xanchor, yanchor, xoffset, yoffset, subpixel = self.get_placement() - - if xpos is None: - xpos = 0 - if ypos is None: - ypos = 0 - if xanchor is None: - xanchor = 0 - if yanchor is None: - yanchor = 0 - if xoffset is None: - xoffset = 0 - if yoffset is None: - yoffset = 0 - - # We need to use type, since isinstance(absolute(0), float). - if xpos.__class__ is float: - xpos *= width - - if xanchor.__class__ is float: - xanchor *= surf.width - - xpos += x + xoffset - xanchor - - # y - - if ypos.__class__ is float: - ypos *= height - - if yanchor.__class__ is float: - yanchor *= surf.height - - ypos += y + yoffset - yanchor - - if dest is not None: - if subpixel: - dest.subpixel_blit(surf, (xpos, ypos), main, main, None) - else: - dest.blit(surf, (xpos, ypos), main, main, None) - - return xpos, ypos - - def set_transform_event(self, event): - """ - Sets the transform event of this displayable to event. - """ - - if event == self.transform_event: - return - - self.transform_event = event - if self.transform_event_responder: - renpy.display.render.redraw(self, 0) - - def _hide(self, st, at, kind): - """ - Returns None if this displayable is ready to be hidden, or - a replacement displayable if it doesn't want to be hidden - quite yet. Kind is either "hide" or "replaced". - """ - - return None - - def _show(self): - """ - Called when the displayable is added to a scene list. - """ - - def _get_parameterized(self): - """ - If this is a ImageReference to a parameterized image, return - the get_parameterized() of the parameterized image. Otherwise, - return this displayable. - """ - - return self - - def _change_transform_child(self, child): - """ - If this is a transform, makes a copy of the transform and sets - the child of the innermost transform to this. Otherwise, - simply returns child. - """ - - return child - - - -class SceneListEntry(renpy.object.Object): - """ - Represents a scene list entry. Since this was replacing a tuple, - it should be treated as immutable after its initial creation. - """ - - def __init__(self, tag, zorder, show_time, animation_time, displayable, name): - self.tag = tag - self.zorder = zorder - self.show_time = show_time - self.animation_time = animation_time - self.displayable = displayable - self.name = name - - def __iter__(self): - return iter((self.tag, self.zorder, self.show_time, self.animation_time, self.displayable)) - - def __getitem__(self, index): - return (self.tag, self.zorder, self.show_time, self.animation_time, self.displayable)[index] - - def __repr__(self): - return "" % (self.tag, self.name, self.displayable) - - def copy(self): - return SceneListEntry( - self.tag, - self.zorder, - self.show_time, - self.animation_time, - self.displayable, - self.name) - - def update_time(self, time): - - rv = self - - if self.show_time is None or self.animation_time is None: - rv = self.copy() - rv.show_time = rv.show_time or time - rv.animation_time = rv.animation_time or time - - return rv - - -class SceneLists(renpy.object.Object): - """ - This stores the current scene lists that are being used to display - things to the user. - """ - - __version__ = 6 - - def after_setstate(self): - for i in renpy.config.layers + renpy.config.top_layers: - if i not in self.layers: - self.layers[i] = [ ] - self.at_list[i] = { } - self.layer_at_list[i] = (None, [ ]) - - def after_upgrade(self, version): - - if version < 1: - - self.at_list = { } - self.layer_at_list = { } - - for i in renpy.config.layers + renpy.config.top_layers: - self.at_list[i] = { } - self.layer_at_list[i] = (None, [ ]) - - if version < 3: - self.shown_window = False - - if version < 4: - for k in self.layers: - self.layers[k] = [ SceneListEntry(*(i + (None,)) ) for i in self.layers[k] ] - - self.additional_transient = [ ] - - if version < 5: - self.drag_group = None - - if version < 6: - self.shown = self.image_predict_info - - def __init__(self, oldsl, shown): - - super(SceneLists, self).__init__() - - # Has a window been shown as part of these scene lists? - self.shown_window = False - - # A map from layer name -> list(SceneListEntry) - self.layers = { } - - # A map from layer name -> tag -> at_list associated with that tag. - self.at_list = { } - - # A map from layer to (star time, at_list), where the at list has - # been applied to the layer as a whole. - self.layer_at_list = { } - - # The current shown images, - self.shown = shown - - # A list of (layer, tag) pairs that are considered to be - # transient. - self.additional_transient = [ ] - - # Either None, or a DragGroup that's used as the default for - # drags with names. - self.drag_group = None - - if oldsl: - - for i in renpy.config.layers + renpy.config.top_layers: - - try: - self.layers[i] = oldsl.layers[i][:] - except KeyError: - self.layers[i] = [ ] - - if i in oldsl.at_list: - self.at_list[i] = oldsl.at_list[i].copy() - self.layer_at_list[i] = oldsl.layer_at_list[i] - else: - self.at_list[i] = { } - self.layer_at_list[i] = (None, [ ]) - - for i in renpy.config.overlay_layers: - self.clear(i) - - self.replace_transient() - - self.focused = None - - self.drag_group = oldsl.drag_group - - else: - for i in renpy.config.layers + renpy.config.top_layers: - self.layers[i] = [ ] - self.at_list[i] = { } - self.layer_at_list[i] = (None, [ ]) - - self.music = None - self.focused = None - - def replace_transient(self): - """ - Replaces the contents of the transient display list with - a copy of the master display list. This is used after a - scene is displayed to get rid of transitions and interface - elements. - """ - - for i in renpy.config.transient_layers: - self.clear(i, True) - - for layer, tag in self.additional_transient: - self.remove(layer, tag) - - self.additional_transient = [ ] - - def transient_is_empty(self): - """ - This returns True if all transient layers are empty. This is - used by the rollback code, as we can't start a new rollback - if there is something in a transient layer (as things in the - transient layer may contain objects that cannot be pickled, - like lambdas.) - """ - - for i in renpy.config.transient_layers: - if self.layers[i]: - return False - - return True - - def transform_state(self, old_thing, new_thing): - """ - If the old thing is a transform, then move the state of that transform - to the new thing. - """ - - if old_thing is None: - return new_thing - - # Don't bother wrapping screens, as they can't be transformed. - if isinstance(new_thing, renpy.display.screen.ScreenDisplayable): - return new_thing - - old_transform = old_thing._get_parameterized() - if not isinstance(old_transform, renpy.display.motion.Transform): - return new_thing - - new_transform = new_thing._get_parameterized() - if not isinstance(new_transform, renpy.display.motion.Transform): - new_thing = new_transform = renpy.display.motion.Transform(child=new_thing) - - new_transform.take_state(old_transform) - return new_thing - - - def find_index(self, layer, tag, zorder, behind): - """ - This finds the spot in the named layer where we should insert the - displayable. It returns two things: an index at which the new thing - should be added, and an index at which the old thing should be hidden. - (Note that the indexes are relative to the current state of the list, - which may change on an add or remove.) - """ - - add_index = None - remove_index = None - - - for i, sle in enumerate(self.layers[layer]): - - if add_index is None: - - if sle.zorder == zorder: - if sle.tag and (sle.tag == tag or sle.tag in behind): - add_index = i - - elif sle.zorder > zorder: - add_index = i - - - if remove_index is None: - if (sle.tag and sle.tag == tag) or sle.displayable == tag: - remove_index = i - - - if add_index is None: - add_index = len(self.layers[layer]) - - return add_index, remove_index - - - def add(self, - layer, - thing, - key=None, - zorder=0, - behind=[ ], - at_list=[ ], - name=None, - atl=None, - default_transform=None, - transient=False): - """ - Adds something to this scene list. Some of these names are quite a bit - out of date. - - `thing` - The displayable to add. - - `key` - A string giving the tag associated with this thing. - - `zorder` - Where to place this thing in the zorder, an integer - A greater value means closer to the user. - - `behind` - A list of tags to place the thing behind. - - `at_list` - The at_list associated with this - displayable. Counterintunitively, this is not actually - applied, but merely stored for future use. - - `name` - The full name of the image being displayed. This is used for - image lookup. - - `atl` - If not None, an atl block applied to the thing. (This actually is - applied here.) - - `default_transform` - The default transform that is used to initialized - the values in the other transforms. - """ - - if not isinstance(thing, Displayable): - raise Exception("Attempting to show something that isn't a displayable:" + repr(thing)) - - if layer not in self.layers: - raise Exception("Trying to add something to non-existent layer '%s'." % layer) - - if key: - self.remove_hide_replaced(layer, key) - self.at_list[layer][key] = at_list - - if key and name: - self.shown.predict_show(layer, name) - - if transient: - self.additional_transient.append((layer, key)) - - l = self.layers[layer] - - if atl: - thing = renpy.display.motion.ATLTransform(atl, child=thing) - - add_index, remove_index = self.find_index(layer, key, zorder, behind) - - at = None - st = None - - if remove_index is not None: - sle = l[remove_index] - at = sle.animation_time - old = sle.displayable - - if (not atl and - not at_list and - renpy.config.keep_running_transform and - isinstance(old, renpy.display.motion.Transform)): - - thing = sle.displayable._change_transform_child(thing) - else: - thing = self.transform_state(l[remove_index].displayable, thing) - - thing.set_transform_event("replace") - thing._show() - - else: - - if not isinstance(thing, renpy.display.motion.Transform): - thing = self.transform_state(default_transform, thing) - - thing.set_transform_event("show") - thing._show() - - sle = SceneListEntry(key, zorder, st, at, thing, name) - l.insert(add_index, sle) - - if remove_index is not None: - if add_index <= remove_index: - remove_index += 1 - - self.hide_or_replace(layer, remove_index, "replaced") - - def hide_or_replace(self, layer, index, prefix): - """ - Hides or replaces the scene list entry at the given - index. `prefix` is a prefix that is used if the entry - decides it doesn't want to be hidden quite yet. - """ - - if index is None: - return - - l = self.layers[layer] - oldsle = l[index] - - now = get_time() - - st = oldsle.show_time or now - at = oldsle.animation_time or now - - if oldsle.tag: - - d = oldsle.displayable._hide(now - st, now - at, prefix) - - # _hide can mutate the layers, so we need to recompute - # index. - index = l.index(oldsle) - - if d is not None: - - sle = SceneListEntry( - prefix + "$" + oldsle.tag, - oldsle.zorder, - st, - at, - d, - None) - - l[index] = sle - - return - - l.pop(index) - - def get_all_displayables(self): - """ - Gets all displayables reachable from this scene list. - """ - - rv = [ ] - for l in self.layers.values(): - for sle in l: - rv.append(sle.displayable) - - return rv - - def remove_above(self, layer, thing): - """ - Removes everything on the layer that is closer to the user - than thing, which may be either a tag or a displayable. Thing must - be displayed, or everything will be removed. - """ - - for i in reversed(range(len(self.layers[layer]))): - - sle = self.layers[layer][i] - - if thing: - if sle.tag == thing or sle.displayable == thing: - break - - if sle.tag and "$" in sle.tag: - continue - - self.hide_or_replace(layer, i, "hide") - - def remove(self, layer, thing): - """ - Thing is either a key or a displayable. This iterates through the - named layer, searching for entries matching the thing. - When they are found, they are removed from the displaylist. - - It's not an error to remove something that isn't in the layer in - the first place. - """ - - if layer not in self.layers: - raise Exception("Trying to remove something from non-existent layer '%s'." % layer) - - _add_index, remove_index = self.find_index(layer, thing, 0, [ ]) - - if remove_index is not None: - tag = self.layers[layer][remove_index].tag - - if tag: - self.shown.predict_hide(layer, (tag,)) - self.at_list[layer].pop(tag, None) - - self.hide_or_replace(layer, remove_index, "hide") - - def clear(self, layer, hide=False): - """ - Clears the named layer, making it empty. - - If hide is True, then objects are hidden. Otherwise, they are - totally wiped out. - """ - - if not hide: - self.layers[layer] = [ ] - - else: - - # Have to iterate in reverse order, since otherwise - # the indexes might change. - for i in reversed(range(len(self.layers[layer]))): - self.hide_or_replace(layer, i, hide) - - self.at_list[layer].clear() - self.shown.predict_scene(layer) - self.layer_at_list[layer] = (None, [ ]) - - def set_layer_at_list(self, layer, at_list): - self.layer_at_list[layer] = (None, list(at_list)) - - def set_times(self, time): - """ - This finds entries with a time of None, and replaces that - time with the given time. - """ - - for l, (t, list) in list(self.layer_at_list.items()): #@ReservedAssignment - self.layer_at_list[l] = (t or time, list) - - for l, ll in self.layers.items(): - self.layers[l] = [ i.update_time(time) for i in ll ] - - def showing(self, layer, name): - """ - Returns true if something with the prefix of the given name - is found in the scene list. - """ - - return self.shown.showing(layer, name) - - def make_layer(self, layer, properties): - """ - Creates a Fixed with the given layer name and scene_list. - """ - - rv = renpy.display.layout.MultiBox(layout='fixed', focus=layer, **properties) - rv.append_scene_list(self.layers[layer]) - - time, at_list = self.layer_at_list[layer] - - if at_list: - for a in at_list: - - if isinstance(a, renpy.display.motion.Transform): - rv = a(child=rv) - else: - rv = a(rv) - - f = renpy.display.layout.MultiBox(layout='fixed') - f.add(rv, time, time) - rv = f - - rv.layer_name = layer - return rv - - def remove_hide_replaced(self, layer, tag): - """ - Removes things that are hiding or replaced, that have the given - tag. - """ - - hide_tag = "hide$" + tag - replaced_tag = "replaced$" + tag - - l = self.layers[layer] - self.layers[layer] = [ i for i in l if i.tag != hide_tag and i.tag != replaced_tag ] - - def remove_hidden(self): - """ - Goes through all of the layers, and removes things that are - hidden and are no longer being kept alive by their hide - methods. - """ - - now = get_time() - - for l in self.layers: - newl = [ ] - - for sle in self.layers[l]: - - if sle.tag: - - if sle.tag.startswith("hide$"): - d = sle.displayable._hide(now - sle.show_time, now - sle.animation_time, "hide") - if not d: - continue - - elif sle.tag.startswith("replaced$"): - d = sle.displayable._hide(now - sle.show_time, now - sle.animation_time, "replaced") - if not d: - continue - - newl.append(sle) - - self.layers[l] = newl - - def get_displayable_by_tag(self, layer, tag): - """ - Returns the displayable on the layer with the given tag, or None - if no such displayable exists. Note that this will usually return - a Transform. - """ - - if layer not in self.layers: - raise Exception("Unknown layer %r." % layer) - - for sle in self.layers[layer]: - if sle.tag == tag: - return sle.displayable - - return None - - def get_displayable_by_name(self, layer, name): - """ - Returns the displayable on the layer with the given tag, or None - if no such displayable exists. Note that this will usually return - a Transform. - """ - - if layer not in self.layers: - raise Exception("Unknown layer %r." % layer) - - for sle in self.layers[layer]: - - if sle.name == name: - return sle.displayable - - return None - - -def scene_lists(index=-1): - """ - Returns either the current scenelists object, or the one for the - context at the given index. - """ - - return renpy.game.context(index).scene_lists - - -class Interface(object): - """ - This represents the user interface that interacts with the user. - It manages the Display objects that display things to the user, and - also handles accepting and responding to user input. - - @ivar display: The display that we used to display the screen. - - @ivar profile_time: The time of the last profiling. - - @ivar screenshot: A screenshot, or None if no screenshot has been - taken. - - @ivar old_scene: The last thing that was displayed to the screen. - - @ivar transition: A map from layer name to the transition that will - be applied the next time interact restarts. - - @ivar transition_time: A map from layer name to the time the transition - involving that layer started. - - @ivar transition_from: A map from layer name to the scene that we're - transitioning from on that layer. - - @ivar suppress_transition: If True, then the next transition will not - happen. - - @ivar force_redraw: If True, a redraw is forced. - - @ivar restart_interaction: If True, the current interaction will - be restarted. - - @ivar pushed_event: If not None, an event that was pushed back - onto the stack. - - @ivar mouse: The name of the mouse cursor to use during the current - interaction. - - @ivar ticks: The number of 20hz ticks. - - @ivar frame_time: The time at which we began drawing this frame. - - @ivar interact_time: The time of the start of the first frame of the current interact_core. - - @ivar time_event: A singleton ignored event. - - @ivar event_time: The time of the current event. - - @ivar timeout_time: The time at which the timeout will occur. - """ - - def __init__(self): - self.screenshot = None - self.old_scene = { } - self.transition = { } - self.ongoing_transition = { } - self.transition_time = { } - self.transition_from = { } - self.suppress_transition = False - self.quick_quit = False - self.force_redraw = False - self.restart_interaction = False - self.pushed_event = None - self.ticks = 0 - self.mouse = 'default' - self.timeout_time = None - self.last_event = None - self.current_context = None - self.roll_forward = None - - # Things to be preloaded. - self.preloads = [ ] - - # The time at which this draw occurs. - self.frame_time = 0 - - # The time when this interaction occured. - self.interact_time = None - - # The time we last tried to quit. - self.quit_time = 0 - - self.time_event = pygame.event.Event(TIMEEVENT) - self.redraw_event = pygame.event.Event(REDRAW) - - # Are we focused? - self.focused = True - - # Properties for each layer. - self.layer_properties = { } - - # Have we shown the window this interaction? - self.shown_window = False - - # Are we in fullscren mode? - self.fullscreen = False - - for layer in renpy.config.layers + renpy.config.top_layers: - if layer in renpy.config.layer_clipping: - x, y, w, h = renpy.config.layer_clipping[layer] - self.layer_properties[layer] = dict( - xpos = x, - xanchor = 0, - ypos = y, - yanchor = 0, - xmaximum = w, - ymaximum = h, - xminimum = w, - yminimum = h, - clipping = True, - ) - - else: - self.layer_properties[layer] = dict() - - - # A stack giving the values of self.transition and self.transition_time - # for contexts outside the current one. This is used to restore those - # in the case where nothing has changed in the new context. - self.transition_info_stack = [ ] - - # The time when the event was dispatched. - self.event_time = 0 - - # The time we saw the last mouse event. - self.mouse_event_time = None - - # Should we show the mouse? - self.show_mouse = True - - # Should we reset the display? - self.display_reset = False - - # The last size we were resized to. This lets us debounce the - # VIDEORESIZE event. - self.last_resize = None - - # Ensure that we kill off the presplash. - renpy.display.presplash.end() - - # Initialize pygame. - if pygame.version.vernum < (1, 8, 1): - raise Exception("Ren'Py requires pygame 1.8.1 to run.") - - try: - import pygame.macosx as macosx - macosx.init() #@UndefinedVariable - except: - pass - - try: - macosx.Video_AutoInit() #@UndefinedVariable - except: - pass - - pygame.font.init() - renpy.audio.audio.init() - renpy.display.joystick.init() - pygame.display.init() - - # Init timing. - init_time() - self.profile_time = get_time() - self.mouse_event_time = get_time() - - # The current window caption. - self.window_caption = None - - renpy.game.interface = self - renpy.display.interface = self - - # Are we in safe mode, from holding down shift at start? - self.safe_mode = False - if renpy.first_utter_start and (pygame.key.get_mods() & pygame.KMOD_SHIFT): - self.safe_mode = True - - # Setup the video mode. - self.set_mode() - - # Load the image fonts. - renpy.text.font.load_image_fonts() - - # Setup the android keymap. - if android is not None: - android.map_key(android.KEYCODE_BACK, pygame.K_PAGEUP) - android.map_key(android.KEYCODE_MENU, pygame.K_ESCAPE) - - # Double check, since at least on Linux, we can't set safe_mode until - # the window maps. - if renpy.first_utter_start and (pygame.key.get_mods() & pygame.KMOD_SHIFT): - self.safe_mode = True - - # Setup periodic event. - pygame.time.set_timer(PERIODIC, PERIODIC_INTERVAL) - - # Don't grab the screen. - pygame.event.set_grab(False) - - # Do we need a background screenshot? - self.bgscreenshot_needed = False - - # Event used to signal background screenshot taken. - self.bgscreenshot_event = threading.Event() - - # The background screenshot surface. - self.bgscreenshot_surface = None - - - def post_init(self): - # Setup. - - # Needed for Unity. - wmclass = renpy.config.save_directory or os.path.basename(sys.argv[0]) - os.environ['SDL_VIDEO_X11_WMCLASS'] = wmclass - - self.set_window_caption(force=True) - self.set_icon() - - if renpy.config.key_repeat is not None: - delay, repeat_delay = renpy.config.key_repeat - pygame.key.set_repeat(int(1000 * delay), int(1000 * repeat_delay)) - - def set_icon(self): - """ - This is called to set up the window icon. - """ - - # Window icon. - icon = renpy.config.window_icon - - if renpy.windows and renpy.config.windows_icon: - icon = renpy.config.windows_icon - - if icon: - - im = renpy.display.scale.image_load_unscaled( - renpy.loader.load(icon), - icon, - convert=False, - ) - - # Convert the aspect ratio to be square. - iw, ih = im.get_size() - imax = max(iw, ih) - square_im = renpy.display.pgrender.surface_unscaled((imax, imax), True) - square_im.blit(im, ( (imax-iw)/2, (imax-ih)/2 )) - im = square_im - - if renpy.windows and im.get_size() != (32, 32): - im = renpy.display.scale.real_smoothscale(im, (32, 32)) - - pygame.display.set_icon(im) - - - def set_window_caption(self, force=False): - caption = renpy.config.window_title + renpy.store._window_subtitle - if not force and caption == self.window_caption: - return - - self.window_caption = caption - pygame.display.set_caption(caption.encode("utf-8")) - - def iconify(self): - pygame.display.iconify() - - def get_draw_constructors(self): - """ - Figures out the list of draw constructors to try. - """ - - renderer = renpy.game.preferences.renderer - renderer = os.environ.get("RENPY_RENDERER", renderer) - - if self.safe_mode: - renderer = "sw" - - renpy.config.renderer = renderer - - if renderer == "auto": - if renpy.windows: - renderers = [ "gl", "angle", "sw" ] - else: - renderers = [ "gl", "sw" ] - else: - renderers = [ renderer, "sw" ] - - draw_objects = { } - - def make_draw(name, mod, cls, *args): - if name not in renderers: - return False - - try: - __import__(mod) - module = sys.modules[mod] - draw_class = getattr(module, cls) - draw_objects[name] = draw_class(*args) - return True - - except: - renpy.display.log.write("Couldn't import {0} renderer:".format(name)) - renpy.display.log.exception() - - return False - - if renpy.windows: - has_angle = make_draw("angle", "renpy.angle.gldraw", "GLDraw") - else: - has_angle = False - - make_draw("gl", "renpy.gl.gldraw", "GLDraw", not has_angle) - make_draw("sw", "renpy.display.swdraw", "SWDraw") - - rv = [ ] - - def append_draw(name): - if name in draw_objects: - rv.append(draw_objects[name]) - else: - renpy.display.log.write("Unknown renderer: {0}".format(name)) - - for i in renderers: - append_draw(i) - - return rv - - - def kill_textures(self): - renpy.display.render.free_memory() - renpy.text.text.layout_cache_clear() - - def kill_textures_and_surfaces(self): - """ - Kill all textures and surfaces that are loaded. - """ - - self.kill_textures() - - renpy.display.im.cache.clear() - renpy.display.module.bo_cache = None - - def set_mode(self, physical_size=None): - """ - This sets the video mode. It also picks the draw object. - """ - - # Ensure that we kill off the movie when changing screen res. - if renpy.display.draw and renpy.display.draw.info["renderer"] == "sw": - renpy.display.video.movie_stop(clear=False) - - if self.display_reset: - renpy.display.draw.deinit() - - if renpy.display.draw.info["renderer"] == "angle": - renpy.display.draw.quit() - - renpy.display.render.free_memory() - renpy.display.im.cache.clear() - renpy.text.text.layout_cache_clear() - - renpy.display.module.bo_cache = None - - self.kill_textures_and_surfaces() - - self.display_reset = False - - virtual_size = (renpy.config.screen_width, renpy.config.screen_height) - - if physical_size is None: - if renpy.android or renpy.game.preferences.physical_size is None: #@UndefinedVariable - physical_size = (renpy.config.screen_width, renpy.config.screen_height) - else: - physical_size = renpy.game.preferences.physical_size - - # Setup screen. - fullscreen = renpy.game.preferences.fullscreen - - # If we're in fullscreen mode, and changing to another mode, go to - # windowed mode first. - s = pygame.display.get_surface() - if s and (s.get_flags() & pygame.FULLSCREEN): - fullscreen = False - - old_fullscreen = self.fullscreen - self.fullscreen = fullscreen - - if os.environ.get('RENPY_DISABLE_FULLSCREEN', False): - fullscreen = False - self.fullscreen = renpy.game.preferences.fullscreen - - if renpy.display.draw: - draws = [ renpy.display.draw ] - else: - draws = self.get_draw_constructors() - - for draw in draws: - if draw.set_mode(virtual_size, physical_size, fullscreen): - renpy.display.draw = draw - break - else: - pygame.display.quit() - else: - # Ensure we don't get stuck in fullscreen. - renpy.game.preferences.fullscreen = False - raise Exception("Could not set video mode.") - - # Save the video size. - if renpy.config.save_physical_size and not fullscreen and not old_fullscreen: - renpy.game.preferences.physical_size = renpy.display.draw.get_physical_size() - - if android: - android.init() - - # We need to redraw the (now blank) screen. - self.force_redraw = True - - # Assume we have focus until told otherwise. - self.focused = True - - # Assume we're not minimized. - self.minimized = False - - # Force an interaction restart. - self.restart_interaction = True - - - def draw_screen(self, root_widget, fullscreen_video, draw): - - surftree = renpy.display.render.render_screen( - root_widget, - renpy.config.screen_width, - renpy.config.screen_height, - ) - - if draw: - renpy.display.draw.draw_screen(surftree, fullscreen_video) - - renpy.display.render.mark_sweep() - renpy.display.focus.take_focuses() - - self.surftree = surftree - self.fullscreen_video = fullscreen_video - - - def take_screenshot(self, scale, background=False): - """ - This takes a screenshot of the current screen, and stores it so - that it can gotten using get_screenshot() - - `background` - If true, we're in a background thread. So queue the request - until it can be handled by the main thread. - """ - - if background: - self.bgscreenshot_event.clear() - self.bgscreenshot_needed = True - self.bgscreenshot_event.wait() - - window = self.bgscreenshot_surface - self.bgscreenshot_surface = None - - else: - - window = renpy.display.draw.screenshot(self.surftree, self.fullscreen_video) - - surf = renpy.display.pgrender.copy_surface(window, True) - surf = renpy.display.scale.smoothscale(surf, scale) - surf = surf.convert() - - sio = io.StringIO() - renpy.display.module.save_png(surf, sio, 0) - self.screenshot = sio.getvalue() - sio.close() - - - def save_screenshot(self, filename): - """ - Saves a full-size screenshot in the given filename. - """ - - window = renpy.display.draw.screenshot(self.surftree, self.fullscreen_video) - - if renpy.config.screenshot_crop: - window = window.subsurface(renpy.config.screenshot_crop) - - try: - renpy.display.scale.image_save_unscaled(window, filename) - except: - if renpy.config.debug: - raise - pass - - - def get_screenshot(self): - """ - Gets the current screenshot, as a string. Returns None if there isn't - a current screenshot. - """ - - rv = self.screenshot - - if not rv: - self.take_screenshot((renpy.config.thumbnail_width, renpy.config.thumbnail_height)) - rv = self.screenshot - self.lose_screenshot() - - return rv - - - def lose_screenshot(self): - """ - This deallocates the saved screenshot. - """ - - self.screenshot = None - - - def show_window(self): - - if not renpy.store._window: - return - - if renpy.game.context().scene_lists.shown_window: - return - - if renpy.config.empty_window: - renpy.config.empty_window() - - def do_with(self, trans, paired, clear=False): - - if renpy.config.with_callback: - trans = renpy.config.with_callback(trans, paired) - - if (not trans) or self.suppress_transition: - self.with_none() - return False - else: - self.set_transition(trans) - return self.interact(trans_pause=True, - suppress_overlay=not renpy.config.overlay_during_with, - mouse='with', - clear=clear) - - def with_none(self): - """ - Implements the with None command, which sets the scene we will - be transitioning from. - """ - - renpy.exports.say_attributes = None - - # Show the window, if that's necessary. - self.show_window() - - # Compute the overlay. - self.compute_overlay() - - scene_lists = renpy.game.context().scene_lists - - # Compute the scene. - self.old_scene = self.compute_scene(scene_lists) - - # Get rid of transient things. - - for i in renpy.config.overlay_layers: - scene_lists.clear(i) - - scene_lists.replace_transient() - scene_lists.shown_window = False - - - def set_transition(self, transition, layer=None, force=False): - """ - Sets the transition that will be performed as part of the next - interaction. - """ - - if self.suppress_transition and not force: - return - - if transition is None: - self.transition.pop(layer, None) - else: - self.transition[layer] = transition - - - def event_peek(self): - """ - This peeks the next event. It returns None if no event exists. - """ - - if self.pushed_event: - return self.pushed_event - - ev = pygame.event.poll() - - if ev.type == pygame.NOEVENT: - # Seems to prevent the CPU from speeding up. - renpy.display.draw.event_peek_sleep() - return None - - self.pushed_event = ev - - return ev - - def event_poll(self): - """ - Called to busy-wait for an event while we're waiting to - redraw a frame. - """ - - if self.pushed_event: - rv = self.pushed_event - self.pushed_event = None - else: - rv = pygame.event.poll() - - self.last_event = rv - - return rv - - - def event_wait(self): - """ - This is in its own function so that we can track in the - profiler how much time is spent in interact. - """ - - if self.pushed_event: - rv = self.pushed_event - self.pushed_event = None - self.last_event = rv - return rv - - # Handle a request for a background screenshot. - if self.bgscreenshot_needed: - self.bgscreenshot_needed = False - self.bgscreenshot_surface = renpy.display.draw.screenshot(self.surftree, self.fullscreen_video) - self.bgscreenshot_event.set() - - try: - cpu_idle.set() - ev = pygame.event.wait() - finally: - cpu_idle.clear() - - self.last_event = ev - - return ev - - - def compute_overlay(self): - - if renpy.store.suppress_overlay: - return - - # Figure out what the overlay layer should look like. - renpy.ui.layer("overlay") - - for i in renpy.config.overlay_functions: - i() - - if renpy.game.context().scene_lists.shown_window: - for i in renpy.config.window_overlay_functions: - i() - - renpy.ui.close() - - - def compute_scene(self, scene_lists): - """ - This converts scene lists into a dictionary mapping layer - name to a Fixed containing that layer. - """ - - rv = { } - - for layer in renpy.config.layers + renpy.config.top_layers: - rv[layer] = scene_lists.make_layer(layer, self.layer_properties[layer]) - - root = renpy.display.layout.MultiBox(layout='fixed') - root.layers = { } - - for layer in renpy.config.layers: - root.layers[layer] = rv[layer] - root.add(rv[layer]) - rv[None] = root - - return rv - - - def quit_event(self): - """ - This is called to handle the user invoking a quit. - """ - - if self.quit_time > (time.time() - .75): - raise renpy.game.QuitException() - - if renpy.config.quit_action is not None: - self.quit_time = time.time() - - # Make the screen more suitable for interactions. - renpy.exports.movie_stop(only_fullscreen=True) - renpy.store.mouse_visible = True - - renpy.display.behavior.run(renpy.config.quit_action) - else: - raise renpy.game.QuitException() - - - def get_mouse_info(self): - # Figure out if the mouse visibility algorithm is hiding the mouse. - if self.mouse_event_time + renpy.config.mouse_hide_time < renpy.display.core.get_time(): - visible = False - else: - visible = renpy.store.mouse_visible and (not renpy.game.less_mouse) - - visible = visible and self.show_mouse - - # If not visible, hide the mouse. - if not visible: - return False, 0, 0, None - - # Deal with a hardware mouse, the easy way. - if not renpy.config.mouse: - return True, 0, 0, None - - # Deal with the mouse going offscreen. - if not self.focused: - return False, 0, 0, None - - mouse_kind = renpy.display.focus.get_mouse() or self.mouse - - # Figure out the mouse animation. - if mouse_kind in renpy.config.mouse: - anim = renpy.config.mouse[mouse_kind] - else: - anim = renpy.config.mouse[getattr(renpy.store, 'default_mouse', 'default')] - - img, x, y = anim[self.ticks % len(anim)] - tex = renpy.display.im.load_image(img) - - return False, x, y, tex - - def drawn_since(self, seconds_ago): - """ - Returns true if the screen has been drawn in the last `seconds_ago`, - and false otherwise. - """ - - return (get_time() - self.frame_time) <= seconds_ago - - def android_check_suspend(self): - - if android.check_pause(): - - android.sound.pause_all() - - pygame.time.set_timer(PERIODIC, 0) - pygame.time.set_timer(REDRAW, 0) - pygame.time.set_timer(TIMEEVENT, 0) - - # The game has to be saved. - renpy.loadsave.save("_reload-1") - - android.wait_for_resume() - - # Since we came back to life, we can get rid of the - # auto-reload. - renpy.loadsave.unlink_save("_reload-1") - - pygame.time.set_timer(PERIODIC, PERIODIC_INTERVAL) - - android.sound.unpause_all() - - def iconified(self): - """ - Called when we become an icon. - """ - - if self.minimized: - return - - self.minimized = True - - renpy.display.log.write("The window was minimized.") - - - def restored(self): - """ - Called when we are restored from being an icon. - """ - - # This is necessary on Windows/DirectX/Angle, as otherwise we get - # a blank screen. - - if not self.minimized: - return - - self.minimized = False - - renpy.display.log.write("The window was restored.") - - if renpy.windows: - self.display_reset = True - self.set_mode(self.last_resize) - - def enter_context(self): - """ - Called when we enter a new context. - """ - - # Stop ongoing transitions. - self.ongoing_transition.clear() - self.transition_from.clear() - self.transition_time.clear() - - def post_time_event(self): - """ - Posts a time_event object to the queue. - """ - - try: - pygame.event.post(self.time_event) - except: - pass - - def interact(self, clear=True, suppress_window=False, **kwargs): - """ - This handles an interaction, restarting it if necessary. All of the - keyword arguments are passed off to interact_core. - """ - - # Cancel magic error reporting. - renpy.bootstrap.report_error = None - - context = renpy.game.context() - - if context.interacting: - raise Exception("Cannot start an interaction in the middle of an interaction, without creating a new context.") - - context.interacting = True - - - # Show a missing window. - if not suppress_window: - self.show_window() - - # These things can be done once per interaction. - - preloads = self.preloads - self.preloads = [ ] - - try: - renpy.game.after_rollback = False - - for i in renpy.config.start_interact_callbacks: - i() - - repeat = True - - while repeat: - repeat, rv = self.interact_core(preloads=preloads, **kwargs) - - return rv - - finally: - - context.interacting = False - - # Clean out transient stuff at the end of an interaction. - if clear: - scene_lists = renpy.game.context().scene_lists - scene_lists.replace_transient() - - self.ongoing_transition = { } - self.transition_time = { } - self.transition_from = { } - - self.restart_interaction = True - - renpy.game.context().scene_lists.shown_window = False - - def interact_core(self, - show_mouse=True, - trans_pause=False, - suppress_overlay=False, - suppress_underlay=False, - mouse='default', - preloads=[], - roll_forward=None, - ): - - """ - This handles one cycle of displaying an image to the user, - and then responding to user input. - - @param show_mouse: Should the mouse be shown during this - interaction? Only advisory, and usually doesn't work. - - @param trans_pause: If given, we must have a transition. Should we - add a pause behavior during the transition? - - @param suppress_overlay: This suppresses the display of the overlay. - @param suppress_underlay: This suppresses the display of the underlay. - """ - - self.roll_forward = roll_forward - self.show_mouse = show_mouse - - suppress_transition = renpy.config.skipping or renpy.game.less_updates - - # The global one. - self.suppress_transition = False - - # Figure out transitions. - for k in self.transition: - if k not in self.old_scene: - continue - - self.ongoing_transition[k] = self.transition[k] - self.transition_from[k] = self.old_scene[k] - self.transition_time[k] = None - - self.transition.clear() - - if suppress_transition: - self.ongoing_transition.clear() - self.transition_from.clear() - self.transition_time.clear() - - ## Safety condition, prevents deadlocks. - if trans_pause: - if not self.ongoing_transition: - return False, None - if None not in self.ongoing_transition: - return False, None - if suppress_transition: - return False, None - if not self.old_scene: - return False, None - - # Check to see if the language has changed. - renpy.translation.check_language() - - # We just restarted. - self.restart_interaction = False - - # Setup the mouse. - self.mouse = mouse - - # The start and end times of this interaction. - start_time = get_time() - end_time = start_time - - # frames = 0 - - for i in renpy.config.interact_callbacks: - i() - - # Set the window caption. - self.set_window_caption() - - # Tick time forward. - renpy.display.im.cache.tick() - renpy.text.text.layout_cache_tick() - renpy.display.predict.reset() - - # Cleare the size groups. - renpy.display.layout.size_groups.clear() - - # Clear some events. - pygame.event.clear((pygame.MOUSEMOTION, - PERIODIC, - TIMEEVENT, - REDRAW)) - - # Add a single TIMEEVENT to the queue. - self.post_time_event() - - # Figure out the scene list we want to show. - scene_lists = renpy.game.context().scene_lists - - # Remove the now-hidden things. - scene_lists.remove_hidden() - - # Compute the overlay. - if not suppress_overlay: - self.compute_overlay() - - # The root widget of everything that is displayed on the screen. - root_widget = renpy.display.layout.MultiBox(layout='fixed') - root_widget.layers = { } - - # A list of widgets that are roots of trees of widgets that are - # considered for focusing. - focus_roots = [ ] - - # Add the underlay to the root widget. - if not suppress_underlay: - for i in renpy.config.underlay: - root_widget.add(i) - focus_roots.append(i) - - if roll_forward is not None: - rfw = renpy.display.behavior.RollForward(roll_forward) - root_widget.add(rfw) - focus_roots.append(rfw) - - # Figure out the scene. (All of the layers, and the root.) - scene = self.compute_scene(scene_lists) - - # If necessary, load all images here. - for w in scene.values(): - try: - renpy.display.predict.displayable(w) - except: - pass - - # The root widget of all of the layers. - layers_root = renpy.display.layout.MultiBox(layout='fixed') - layers_root.layers = { } - - def add_layer(where, layer): - - scene_layer = scene[layer] - focus_roots.append(scene_layer) - - if (self.ongoing_transition.get(layer, None) and - not suppress_transition): - - trans = self.ongoing_transition[layer]( - old_widget=self.transition_from[layer], - new_widget=scene_layer) - - if not isinstance(trans, Displayable): - raise Exception("Expected transition to be a displayable, not a %r" % trans) - - transition_time = self.transition_time.get(layer, None) - - where.add(trans, transition_time, transition_time) - where.layers[layer] = trans - - else: - where.layers[layer] = scene_layer - where.add(scene_layer) - - # Add layers (perhaps with transitions) to the layers root. - for layer in renpy.config.layers: - add_layer(layers_root, layer) - - # Add layers_root to root_widget, perhaps through a transition. - if (self.ongoing_transition.get(None, None) and - not suppress_transition): - - old_root = renpy.display.layout.MultiBox(layout='fixed') - old_root.layers = { } - - for layer in renpy.config.layers: - d = self.transition_from[None].layers[layer] - old_root.layers[layer] = d - old_root.add(d) - - trans = self.ongoing_transition[None]( - old_widget=old_root, - new_widget=layers_root) - - if not isinstance(trans, Displayable): - raise Exception("Expected transition to be a displayable, not a %r" % trans) - - trans._show() - - transition_time = self.transition_time.get(None, None) - root_widget.add(trans, transition_time, transition_time) - - if trans_pause: - sb = renpy.display.behavior.SayBehavior() - root_widget.add(sb) - focus_roots.append(sb) - - pb = renpy.display.behavior.PauseBehavior(trans.delay) - root_widget.add(pb, transition_time, transition_time) - focus_roots.append(pb) - - else: - root_widget.add(layers_root) - - # Add top_layers to the root_widget. - for layer in renpy.config.top_layers: - add_layer(root_widget, layer) - - prediction_coroutine = renpy.display.predict.prediction_coroutine(root_widget) - prediction_coroutine.send(None) - - # Clean out the registered adjustments. - renpy.display.behavior.adj_registered.clear() - - # Clean up some movie-related things. - renpy.display.video.early_interact() - - # Call per-interaction code for all widgets. - root_widget.visit_all(lambda i : i.per_interact()) - - # Now, update various things regarding scenes and transitions, - # so we are ready for a new interaction or a restart. - self.old_scene = scene - - # Okay, from here on we now have a single root widget (root_widget), - # which we will try to show to the user. - - # Figure out what should be focused. - renpy.display.focus.before_interact(focus_roots) - - # Redraw the screen. - renpy.display.render.process_redraws() - needs_redraw = True - - # First pass through the while loop? - first_pass = True - - # We don't yet know when the interaction began. - self.interact_time = None - - # We only want to do autosave once. - did_autosave = False - - old_timeout_time = None - old_redraw_time = None - - rv = None - - # Start sound. - renpy.audio.audio.interact() - - # How long until we redraw. - redraw_in = 3600 - - # Have we drawn a frame yet? - video_frame_drawn = False - - # This try block is used to force cleanup even on termination - # caused by an exception propagating through this function. - try: - - while rv is None: - - # Check for a change in fullscreen preference. - if self.fullscreen != renpy.game.preferences.fullscreen or self.display_reset: - self.set_mode() - needs_redraw = True - - # Check for suspend. - if android: - self.android_check_suspend() - - # Redraw the screen. - if (self.force_redraw or - ((first_pass or not pygame.event.peek(ALL_EVENTS)) and - renpy.display.draw.should_redraw(needs_redraw, first_pass))): - - self.force_redraw = False - - # If we have a movie, start showing it. - fullscreen_video = renpy.display.video.interact() - - # Clean out the redraws, if we have to. - # renpy.display.render.kill_redraws() - - # Draw the screen. - self.frame_time = get_time() - - if not self.interact_time: - self.interact_time = self.frame_time - - self.draw_screen(root_widget, fullscreen_video, (not fullscreen_video) or video_frame_drawn) - - if first_pass: - scene_lists.set_times(self.interact_time) - for k, v in self.transition_time.items(): - if v is None: - self.transition_time[k] = self.interact_time - - renpy.config.frames += 1 - - # If profiling is enabled, report the profile time. - if renpy.config.profile : - new_time = get_time() - - if new_time - self.profile_time > .015: - print("Profile: Redraw took %f seconds." % (new_time - self.frame_time)) - print("Profile: %f seconds to complete event." % (new_time - self.profile_time)) - - if first_pass and self.last_event: - x, y = renpy.display.draw.get_mouse_pos() - renpy.display.focus.mouse_handler(self.last_event, x, y, default=False) - - needs_redraw = False - first_pass = False - - pygame.time.set_timer(REDRAW, 0) - pygame.event.clear([REDRAW]) - old_redraw_time = None - - # Draw the mouse, if it needs drawing. - renpy.display.draw.update_mouse() - - # See if we want to restart the interaction entirely. - if self.restart_interaction: - return True, None - - # Determine if we need a redraw. (We want to run these - # functions, so we put them first to prevent short-circuiting.) - - if renpy.display.video.frequent(): - needs_redraw = True - video_frame_drawn = True - - needs_redraw = renpy.display.video.frequent() or needs_redraw - needs_redraw = renpy.display.render.process_redraws() or needs_redraw - - # How many seconds until we timeout. - timeout_in = 3600 - - # Handle the redraw timer. - redraw_time = renpy.display.render.redraw_time() - - if (redraw_time is not None) and not needs_redraw: - if redraw_time != old_redraw_time: - time_left = redraw_time - get_time() - time_left = min(time_left, 3600) - redraw_in = time_left - - if time_left <= 0: - try: - pygame.event.post(self.redraw_event) - except: - pass - pygame.time.set_timer(REDRAW, 0) - else: - pygame.time.set_timer(REDRAW, max(int(time_left * 1000), 1)) - - old_redraw_time = redraw_time - else: - redraw_in = 3600 - pygame.time.set_timer(REDRAW, 0) - - # Handle the timeout timer. - if not self.timeout_time: - pygame.time.set_timer(TIMEEVENT, 0) - else: - time_left = self.timeout_time - get_time() - time_left = min(time_left, 3600) - timeout_in = time_left - - if time_left <= 0: - self.timeout_time = None - pygame.time.set_timer(TIMEEVENT, 0) - self.post_time_event() - elif self.timeout_time != old_timeout_time: - # Always set to at least 1ms. - pygame.time.set_timer(TIMEEVENT, int(time_left * 1000 + 1)) - old_timeout_time = self.timeout_time - - # Predict images, if we haven't done so already. - while prediction_coroutine is not None: - - # Can we do expensive prediction? - expensive_predict = not (needs_redraw or self.event_peek() or renpy.audio.music.is_playing("movie")) - - result = prediction_coroutine.send(expensive_predict) - - if not result: - prediction_coroutine = None - break - - if not expensive_predict: - break - - # If we need to redraw again, do it if we don't have an - # event going on. - if needs_redraw and not self.event_peek(): - if renpy.config.profile: - self.profile_time = get_time() - continue - - # Handle autosaving, as necessary. - if not did_autosave and not needs_redraw and not self.event_peek() and redraw_in > .25 and timeout_in > .25: - renpy.loadsave.autosave() - did_autosave = True - - if needs_redraw or renpy.display.video.playing(): - ev = self.event_poll() - else: - ev = self.event_wait() - - if ev.type == pygame.NOEVENT: - continue - - if renpy.config.profile: - self.profile_time = get_time() - - # Try to merge an TIMEEVENT with other timeevents. - if ev.type == TIMEEVENT: - old_timeout_time = None - pygame.event.clear([TIMEEVENT]) - - # On Android, where we have multiple mouse buttons, we can - # merge a mouse down and mouse up event with its successor. This - # prevents us from getting overwhelmed with too many events on - # a multitouch screen. - if android and (ev.type == pygame.MOUSEBUTTONDOWN or ev.type == pygame.MOUSEBUTTONUP): - pygame.event.clear(ev.type) - - # Handle redraw timeouts. - if ev.type == REDRAW: - pygame.event.clear([REDRAW]) - old_redraw_time = None - continue - - # Handle periodic events. This includes updating the mouse timers (and through the loop, - # the mouse itself), and the audio system periodic calls. - if ev.type == PERIODIC: - events = 1 + len(pygame.event.get([PERIODIC])) - self.ticks += events - - if renpy.config.periodic_callback: - renpy.config.periodic_callback() - - renpy.audio.audio.periodic() - continue - - # This can set the event to None, to ignore it. - ev = renpy.display.joystick.event(ev) - if not ev: - continue - - # Handle skipping. - renpy.display.behavior.skipping(ev) - - # Handle quit specially for now. - if ev.type == pygame.QUIT: - self.quit_event() - continue - - # Handle videoresize. - if ev.type == pygame.VIDEORESIZE: - evs = pygame.event.get([pygame.VIDEORESIZE]) - if len(evs): - ev = evs[-1] - - if self.last_resize != ev.size: - self.last_resize = ev.size - self.set_mode((ev.w, ev.h)) - - continue - - if ev.type == pygame.MOUSEMOTION or \ - ev.type == pygame.MOUSEBUTTONDOWN or \ - ev.type == pygame.MOUSEBUTTONUP: - - self.mouse_event_time = renpy.display.core.get_time() - - # Merge mousemotion events. - if ev.type == pygame.MOUSEMOTION: - evs = pygame.event.get([pygame.MOUSEMOTION]) - if len(evs): - ev = evs[-1] - - if renpy.windows: - self.focused = True - - # Handle focus notifications. - if ev.type == pygame.ACTIVEEVENT: - if ev.state & 1: - self.focused = ev.gain - - if ev.state & 4: - if ev.gain: - self.restored() - else: - self.iconified() - - pygame.key.set_mods(0) - - # This returns the event location. It also updates the - # mouse state as necessary. - x, y = renpy.display.draw.mouse_event(ev) - - if not self.focused: - x = -1 - y = -1 - - self.event_time = end_time = get_time() - - try: - - # Handle the event normally. - rv = renpy.display.focus.mouse_handler(ev, x, y) - - - if rv is None: - rv = root_widget.event(ev, x, y, 0) - - if rv is None: - rv = renpy.display.focus.key_handler(ev) - - if rv is not None: - break - - # Handle displayable inspector. - if renpy.config.inspector and renpy.display.behavior.inspector(ev): - l = self.surftree.main_displayables_at_point(x, y, renpy.config.transient_layers + renpy.config.context_clear_layers + renpy.config.overlay_layers) - renpy.game.invoke_in_new_context(renpy.config.inspector, l) - - except IgnoreEvent: - # An ignored event can change the timeout. So we want to - # process an TIMEEVENT to ensure that the timeout is - # set correctly. - self.post_time_event() - - - # Check again after handling the event. - needs_redraw |= renpy.display.render.process_redraws() - - if self.restart_interaction: - return True, None - - # If we were trans-paused and rv is true, suppress - # transitions up to the next interaction. - if trans_pause and rv: - self.suppress_transition = True - - # But wait, there's more! The finally block runs some cleanup - # after this. - return False, rv - - except EndInteraction as e: - return False, e.value - - finally: - - renpy.exports.say_attributes = None - - # Clean out the overlay layers. - for i in renpy.config.overlay_layers: - scene_lists.clear(i) - - # Stop ongoing preloading. - renpy.display.im.cache.end_tick() - - # We no longer disable periodic between interactions. - # pygame.time.set_timer(PERIODIC, 0) - - pygame.time.set_timer(TIMEEVENT, 0) - pygame.time.set_timer(REDRAW, 0) - - renpy.game.context().runtime += end_time - start_time - - # Restart the old interaction, which also causes a - # redraw if needed. - self.restart_interaction = True - - # print "It took", frames, "frames." - - def timeout(self, offset): - if offset < 0: - return - - if self.timeout_time: - self.timeout_time = min(self.event_time + offset, self.timeout_time) - else: - self.timeout_time = self.event_time + offset - diff --git a/unrpyc/renpy/display/dragdrop.py b/unrpyc/renpy/display/dragdrop.py deleted file mode 100644 index 0b99e63..0000000 --- a/unrpyc/renpy/display/dragdrop.py +++ /dev/null @@ -1,731 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# TODO: Use overlap (rather than simple pointer location) to determine -# drag and drop. - -import renpy.display -from renpy.display.render import render, Render, redraw -from renpy.display.core import absolute -from renpy.display.behavior import map_event, run - -import pygame - -def default_drag_group(): - """ - Gets the default drag group. If it doesn't exist yet, creates it. - """ - - sls = renpy.game.context().scene_lists - - rv = sls.drag_group - - if rv is None: - rv = DragGroup() - sls.drag_group = rv - - return rv - -def default_drag_joined(drag): - return [ (drag, 0, 0) ] - -class Drag(renpy.display.core.Displayable, renpy.python.RevertableObject): - """ - :doc: drag_drop class - :args: (d=None, drag_name=None, draggable=True, droppable=True, drag_raise=True, dragged=None, dropped=None, drag_handle=(0.0, 0.0, 1.0, 1.0), drag_joined=..., clicked=None, hovered=None, unhovered=None, **properties) - - A displayable that represents an object that can be dragged around - its enclosing area. A Drag can also represent an area that - other Drags can be dropped on. - - A Drag can be moved around inside is parent. Generally, its parent - should be either a :func:`Fixed` or :class:`DragGroup`. - - A Drag has one child. The child's state reflects the status - of the drag and drop operation: - - * ``selected_hover`` - when it is being dragged. - * ``selected_idle`` - when it can be dropped on. - * ``hover`` - when the draggable will be dragged when the mouse is - clicked. - * ``idle`` - otherwise. - - The drag handle is a rectangle inside the child. The mouse must be over - a non-transparent pixel inside the drag handle for dragging or clicking - to occur. - - A newly-created draggable is added to the default DragGroup. A draggable - can only be in a single DragGroup - if it's added to a second group, - it's removed from the first. - - When a Drag is first rendered, if it's position cannot be determined - from the DragGroup it is in, the position of its upper-left corner - is computed using the standard layout algorithm. Once that position - - - `d` - If present, the child of this Drag. Drags use the child style - in preference to this, if it's not None. - - `drag_name` - If not None, the name of this draggable. This is available - as the `name` property of draggable objects. If a Drag - with the same name is or was in the DragGroup, the starting - position of this Drag is taken from that Draggable. - - `draggable` - If true, the Drag can be dragged around the screen with - the mouse. - - `droppable` - If true, other Drags can be dropped on this Drag. - - `drag_raise` - If true, this Drag is raised to the top when it is dragged. If - it is joined to other Drags, all joined drags are raised. - - `dragged` - A callback (or list of callbacks) that is called when the Drag - has been dragged. It is called with two arguments. The first is - a list of Drags that are being dragged. The second is either - a Drag that is being dropped onto, or None of a drop did not - occur. If the callback returns a value other than None, that - value is returned as the result of the interaction. - - `dropped` - A callback (or list of callbacks) that is called when this Drag - is dropped onto. It is called with two arguments. The first - is the Drag being dropped onto. The second is a list of Drags that - are being dragged. If the callback returns a value other than None, - that value is returned as the result of the interaction. - - When a dragged and dropped callback are triggered for the same - event, the dropped callback is only called if dragged returns - None. - - `clicked` - A callback this is called, with no arguments, when the Drag is - clicked without being moved. A droppable can also be focused - and clicked. If the callback returns a value othe than None, - that value is returned as the result of the interaction. - - `drag_handle` - A (x, y, width, height) tuple, giving the position of the drag - handle within the child. In this tuple, integers are considered - to be a literal number of pixels, while floats are relative to - the size of the child. - - `drag_joined` - This is called with the current Drag as an argument. It's - expected to return a list of [ (drag, x, y) ] tuples, giving - the draggables to drag as a unit. `x` and `y` are the offsets - of the drags relative to each other, they are not relative - to the corner of this drag. - - Except for `d`, all of the parameters are available as fields (with - the same name) on the Drag object. In addition, after the drag has - been rendered, the following fields become available: - - `x`, `y` - The position of the Drag relative to its parent, in pixels. - - `w`, `h` - The width and height of the Drag's child, in pixels. - """ - - def __init__(self, - d=None, - drag_name=None, - draggable=True, - droppable=True, - drag_raise=True, - dragged=None, - dropped=None, - drag_handle=(0.0, 0.0, 1.0, 1.0), - drag_joined=default_drag_joined, - clicked=None, - hovered=None, - unhovered=None, - replaces=None, - **properties): - - super(Drag, self).__init__(self, **properties) - - self.drag_name = drag_name - self.draggable = draggable - self.droppable = droppable - self.drag_raise = drag_raise - self.dragged = dragged - self.dropped = dropped - self.drag_handle = drag_handle - self.drag_joined = drag_joined - self.clicked = clicked - self.hovered = hovered - self.unhovered = unhovered - - self.child = None - - # Add us to a drag group on creation. - if drag_name: - self.drag_group = default_drag_group() - - # The current x and y coordinates of this displayable. - self.x = None - self.y = None - - # The width and height of the child. - self.w = None - self.h = None - - # The width and height of our parent. - self.parent_width = None - self.parent_height = None - - # The target x and y coordinates of this displayable. (The - # coordinates that we're snapping to.) - self.target_x = None - self.target_y = None - - # The offset from the location of the mouse to the "grab point", - # which is where the things that are being moved are offset from. - self.grab_x = None - self.grab_y = None - - # x and y from the last time we rendered. - self.last_x = None - self.last_y = None - - # The abs_x and abs_y from when we started the grab. - self.start_x = 0 - self.start_y = 0 - - # The last time we were shown, using the animation timebases. - self.at = 0 - - # The (animation timebase) time at which we should reach - # the target coordinates. - self.target_at = 0 - - # The displayable we were last dropping on. - self.last_drop = None - - # Did we move over the course of this drag? - self.drag_moved = False - - if replaces is not None: - self.x = replaces.x - self.y = replaces.y - self.at = replaces.at - self.target_x = replaces.target_x - self.target_y = replaces.target_y - self.target_at = replaces.target_at - - if d is not None: - self.add(d) - - - def snap(self, x, y, delay=0): - """ - :doc: drag_drop method - - Changes the position of the drag. If the drag is not showing, - then the position change is instantaneous. Otherwise, the - position change takes `delay` seconds, and is animated as a - linear move. - """ - - self.target_x = x - self.target_y = y - - if self.x is not None: - self.target_at = self.at + delay - else: - self.target_at = self.at - self.x = x - self.y = y - - redraw(self, 0) - - def set_style_prefix(self, prefix, root): - super(Drag, self).set_style_prefix(prefix, root) - - if self.child is not None: - self.child.set_style_prefix(prefix, False) - - def add(self, d): - if self.child is not None: - raise Exception("Drag expects either zero or one children.") - - self.child = renpy.easy.displayable(d) - - def set_child(self, d): - """ - :doc: drag_drop method - - Changes the child of this drag to `d`. - """ - - d.per_interact() - self.child = renpy.easy.displayable(d) - - def top(self): - """ - :doc: drag_drop method - - Raises this displayable to the top of its drag_group. - """ - - if self.drag_group is not None: - self.drag_group.raise_children([ self ]) - - def visit(self): - return [ self.child ] - - def focus(self, default=False): - super(Drag, self).focus(default) - - rv = None - - if not default: - rv = run(self.hovered) - - return rv - - def unfocus(self, default=False): - super(Drag, self).unfocus(default) - - if not default: - run(self.unhovered) - - def render(self, width, height, st, at): - - child = self.style.child - if child is None: - child = self.child - - self.parent_width = width - self.parent_height = height - - cr = render(child, width, height, st, at) - cw, ch = cr.get_size() - - rv = Render(cw, ch) - rv.blit(cr, (0, 0)) - - self.w = cw - self.h = ch - - # If we don't have a position, then look for it in a drag group. - if (self.x is None) and (self.drag_group is not None) and (self.drag_name is not None): - if self.drag_name in self.drag_group.positions: - self.x, self.y = self.drag_group.positions[self.drag_name] - - # If we don't have a position, run the placement code and use - # that to compute our placement. - if self.x is None: - self.x, self.y = self.place(None, 0, 0, width, height, rv) - self.x = int(self.x) - self.y = int(self.y) - - if self.target_x is None: - self.target_x = self.x - self.target_y = self.y - self.target_at = at - - # Determine if we need to do the snap animation. - if at >= self.target_at: - self.x = self.target_x - self.y = self.target_y - else: - done = (at - self.at) / (self.target_at - self.at) - self.x = absolute(self.x + done * (self.target_x - self.x)) - self.y = absolute(self.y + done * (self.target_y - self.y)) - redraw(self, 0) - - if self.draggable or self.clicked is not None: - - fx, fy, fw, fh = self.drag_handle - - if isinstance(fx, float): - fx = int(fx * cw) - - if isinstance(fy, float): - fy = int(fy * ch) - - if isinstance(fw, float): - fw = int(fw * cw) - - if isinstance(fh, float): - fh = int(fh * ch) - - rv.add_focus(self, None, fx, fy, fw, fh, fx, fy, cr.subsurface((fx, fy, fw, fh))) - - self.last_x = self.x - self.last_y = self.y - self.at = at - - return rv - - def event(self, ev, x, y, st): - - if not self.is_focused(): - return self.child.event(ev, x, y, st) - - # if not self.draggable: - # return self.child.event(ev, x, y, st) - - # Mouse, in parent-relative coordinates. - par_x = self.last_x + x - par_y = self.last_y + y - - grabbed = (renpy.display.focus.get_grab() is self) - - if grabbed: - joined_offsets = self.drag_joined(self) - joined = [ i[0] for i in joined_offsets ] - - elif self.draggable and map_event(ev, "drag_activate"): - - joined_offsets = self.drag_joined(self) - joined = [ i[0] for i in joined_offsets ] - - if not joined: - raise renpy.display.core.IgnoreEvent() - - renpy.display.focus.set_grab(self) - - self.grab_x = x - self.grab_y = y - - # If we're not the only thing we're joined with, we - # might need to adjust our grab point. - for i, xo, yo in joined_offsets: - if i is self: - self.grab_x += xo - self.grab_y += yo - break - - self.drag_moved = False - self.start_x = par_x - self.start_y = par_y - - grabbed = True - - # Handle clicking on droppables. - if not grabbed: - if self.clicked is not None and map_event(ev, "drag_deactivate"): - rv = run(self.clicked) - if rv is not None: - return rv - - raise renpy.display.core.IgnoreEvent() - - return self.child.event(ev, x, y, st) - - # Handle moves by moving things relative to the grab point. - if ev.type in (pygame.MOUSEMOTION, pygame.MOUSEBUTTONUP, pygame.MOUSEBUTTONDOWN): - - if not self.drag_moved and (self.start_x != par_x or self.start_y != par_y): - self.drag_moved = True - - # We may not be in the drag_joined group. - self.set_style_prefix("idle_", True) - - # Set the style. - for i in joined: - i.set_style_prefix("selected_hover_", True) - - # Raise the joined items. - if self.drag_raise and self.drag_group is not None: - self.drag_group.raise_children(joined) - - if self.drag_moved: - for i, xo, yo in joined_offsets: - - new_x = par_x - self.grab_x + xo - new_y = par_y - self.grab_y + yo - new_x = max(new_x, 0) - new_x = min(new_x, i.parent_width - i.w) - new_y = max(new_y, 0) - new_y = min(new_y, i.parent_height - i.h) - - if i.drag_group is not None and i.drag_name is not None: - i.drag_group.positions[i.drag_name] = (new_x, new_y) - - i.x = new_x - i.y = new_y - i.target_x = new_x - i.target_y = new_y - i.target_at = self.at - redraw(i, 0) - - if (self.drag_group is not None) and self.drag_moved: - drop = self.drag_group.get_best_drop(joined) - else: - drop = None - - if drop is not self.last_drop: - - if self.last_drop is not None: - self.last_drop.set_style_prefix("idle_", True) - - if drop is not None: - drop.set_style_prefix("selected_idle_", True) - - self.last_drop = drop - - if map_event(ev, 'drag_deactivate'): - renpy.display.focus.set_grab(None) - - if drop is not None: - drop.set_style_prefix("idle_", True) - - for i in joined: - i.set_style_prefix("idle_", True) - - self.set_style_prefix("hover_", True) - - self.grab_x = None - self.grab_y = None - self.last_drop = None - - if self.drag_moved: - - # Call the drag callback. - drag = joined[0] - if drag.dragged is not None: - rv = run(drag.dragged, joined, drop) - if rv is not None: - return rv - - # Call the drop callback. - if drop is not None and drop.dropped is not None: - rv = run(drop.dropped, drop, joined) - if rv is not None: - return rv - - else: - - # Call the clicked callback. - if self.clicked: - rv = run(self.clicked) - if rv is not None: - return rv - - raise renpy.display.core.IgnoreEvent() - - - def get_placement(self): - - if self.x is not None: - return self.x, self.y, 0, 0, 0, 0, True - else: - return super(Drag, self).get_placement() - - def per_interact(self): - self.set_style_prefix("idle_", True) - super(Drag, self).per_interact() - - -class DragGroup(renpy.display.layout.MultiBox): - """ - :doc: drag_drop class - - Represents a group of Drags. A Drag is limited to the boundary of - its DragGroup. Dropping only works between Drags that are in the - same DragGroup. Drags may only be raised when they are inside a - DragGroup. - - A DragGroup is laid out like a :func:`Fixed`. - - All positional parameters to the DragGroup constructor should be - Drags, that are added to the DragGroup. - """ - - _list_type = renpy.python.RevertableList - - def __init__(self, *children, **properties): - properties.setdefault("style", "fixed") - properties.setdefault("layout", "fixed") - - replaces = properties.pop("replaces", None) - - super(DragGroup, self).__init__(**properties) - - if replaces is not None: - self.positions = renpy.python.RevertableDict(replaces.positions) - self.sensitive = replaces.sensitive - else: - self.positions = renpy.python.RevertableDict() - self.sensitive = True - - for i in children: - self.add(i) - - - def add(self, child): - """ - :doc: drag_drop method - - Adds `child`, which must be a Drag, to this DragGroup. - """ - - if not isinstance(child, Drag): - raise Exception("Only drags can be added to a drag group.") - - child.drag_group = self - super(DragGroup, self).add(child) - - def remove(self, child): - """ - :doc: drag_drop method - - Removes `child` from this DragGroup. - """ - - - if not isinstance(child, Drag): - raise Exception("Only drags can be removed from a drag group.") - - child.x = None - super(DragGroup, self).remove(child) - - - def event(self, ev, x, y, st): - - if not self.sensitive: - return None - - return super(DragGroup, self).event(ev, x, y, st) - - def raise_children(self, l): - """ - Raises the children in `l` to the top of this drag_group, using the - order given in l for those children. - """ - - s = set(l) - - offset_map = { } - - children = [ ] - offsets = [ ] - - for i, c in enumerate(self.children): - if i < len(self.offsets): - o = self.offsets[i] - else: - o = (0, 0) - - if c not in s: - children.append(c) - offsets.append(o) - else: - offset_map[c] = o - - for c in l: - if c in offset_map: - children.append(c) - offsets.append(offset_map[c]) - - self.children = self._list_type(children) - self.offsets = self._list_type(offsets) - - - def get_best_drop(self, joined): - """ - Returns the droppable that the members of joined overlap the most. - """ - - max_overlap = 0 - rv = 0 - - joined_set = set(joined) - - for d in joined: - - r1 = (d.x, d.y, d.w, d.h) - - for c in self.children: - if c in joined_set: - continue - - if not c.droppable: - continue - - r2 = (c.x, c.y, c.w, c.h) - - overlap = rect_overlap_area(r1, r2) - - if overlap >= max_overlap: - rv = c - max_overlap = overlap - - if max_overlap <= 0: - return None - else: - return rv - - def get_children(self): - """ - Returns a list of Drags that are the children of - this DragGroup. - """ - - return renpy.python.RevertableList(self.children) - - def get_child_by_name(self, name): - """ - :doc: drag_drop method - - Returns the first child of this DragGroup that has a drag_name - of name. - """ - - for i in self.children: - if i.drag_name == name: - return i - - return None - - -def rect_overlap_area(r1, r2): - """ - Returns the number of pixels by which rectangles r1 and r2 overlap. - """ - - x1, y1, w1, h1 = r1 - x2, y2, w2, h2 = r2 - - maxleft = max(x1, x2) - minright = min(x1 + w1, x2 + w2) - maxtop = max(y1, y2) - minbottom = min(y1 + h1, y2 + h2) - - if minright < maxleft: - return 0 - - if minbottom < maxtop: - return 0 - - return (minright - maxleft) * (minbottom - maxtop) - - diff --git a/unrpyc/renpy/display/error.py b/unrpyc/renpy/display/error.py deleted file mode 100644 index a8f7e1b..0000000 --- a/unrpyc/renpy/display/error.py +++ /dev/null @@ -1,159 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This file contains code to handle GUI-based error reporting. - -import renpy.display -import os - -error_handled = False - -############################################################################## -# Initialized approach. - -def call_exception_screen(screen_name, **kwargs): - try: - - old_quit = renpy.config.quit_action - renpy.config.quit_action = renpy.exports.quit - - for i in renpy.config.layers: - renpy.game.context().scene_lists.clear(i) - - renpy.exports.show_screen(screen_name, _transient=True, **kwargs) - return renpy.ui.interact(mouse="screen", type="screen", suppress_overlay=True, suppress_underlay=True) - - finally: - renpy.config.quit_action = old_quit - -def rollback_action(): - renpy.exports.rollback(force=True) - -def init_display(): - """ - The minimum amount of code required to init the display. - """ - - if not renpy.game.interface: - renpy.display.core.Interface() - renpy.loader.index_archives() - renpy.display.im.cache.init() - renpy.style.styles_built = True # The styles we use were built in renpy.main. - - renpy.ui.reset() - -def error_dump(): - """ - Handles dumps in the case where an error occurs. - """ - - renpy.dump.dump(True) - -def report_exception(short, full, traceback_fn): - """ - Reports an exception to the user. Returns True if the exception should - be raised by the normal reporting mechanisms. Otherwise, should raise - the appropriate exception to cause a reload or quit or rollback. - """ - - global error_handled - error_handled = True - - error_dump() - - if renpy.game.args.command != "run": #@UndefinedVariable - return True - - if "RENPY_SIMPLE_EXCEPTIONS" in os.environ: - return True - - if not renpy.exports.has_screen("_exception"): - return True - - try: - init_display() - except: - return True - - if renpy.display.draw is None: - return True - - ignore_action = None - rollback_action = None - reload_action = None - - try: - if not renpy.game.context().init_phase: - - if renpy.config.rollback_enabled: - rollback_action = renpy.display.error.rollback_action - - reload_action = renpy.exports.curried_call_in_new_context("_save_reload_game") - - if renpy.game.context(-1).next_node is not None: - ignore_action = renpy.ui.returns(False) - except: - pass - - renpy.game.invoke_in_new_context( - call_exception_screen, - "_exception", - short=short, full=full, - rollback_action=rollback_action, - reload_action=reload_action, - ignore_action=ignore_action, - traceback_fn=traceback_fn, - ) - - -def report_parse_errors(errors, error_fn): - """ - Reports an exception to the user. Returns True if the exception should - be raised by the normal reporting mechanisms. Otherwise, should raise - the appropriate exception. - """ - - global error_handled - error_handled = True - - error_dump() - - if renpy.game.args.command != "run": #@UndefinedVariable - return True - - if "RENPY_SIMPLE_EXCEPTIONS" in os.environ: - return True - - if not renpy.exports.has_screen("_parse_errors"): - return True - - init_display() - - reload_action = renpy.exports.utter_restart - - renpy.game.invoke_in_new_context( - call_exception_screen, - "_parse_errors", - reload_action=reload_action, - errors=errors, - error_fn = error_fn, - ) - diff --git a/unrpyc/renpy/display/focus.py b/unrpyc/renpy/display/focus.py deleted file mode 100644 index 521fe22..0000000 --- a/unrpyc/renpy/display/focus.py +++ /dev/null @@ -1,449 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This file contains code to manage focus on the display. - -import pygame -import renpy.display - -class Focus(object): - - def __init__(self, widget, arg, x, y, w, h): - - self.widget = widget - self.arg = arg - self.x = x - self.y = y - self.w = w - self.h = h - - def copy(self): - return Focus( - self.widget, - self.arg, - self.x, - self.y, - self.w, - self.h) - - def __repr__(self): - return "" % ( - self.widget, - self.arg, - self.x, - self.y, - self.w, - self.h) - - -# The current focus argument. -argument = None - -# The widget currently grabbing the input, if any. -grab = None - -# The default focus for the current screen. -default_focus = None - -# Sets the currently focused widget. -def set_focused(widget, arg): - global argument - argument = arg - renpy.game.context().scene_lists.focused = widget - -# Gets the currently focused widget. -def get_focused(): - return renpy.game.context().scene_lists.focused - -# Get the mouse cursor for the focused widget. -def get_mouse(): - focused = get_focused() - if focused is None: - return None - else: - return focused.style.mouse - -def set_grab(widget): - global grab - grab = widget - -def get_grab(): - return grab - -# The current list of focuses that we know about. -focus_list = [ ] - -# This takes in a focus list from the rendering system. -def take_focuses(): - global focus_list - focus_list = [ ] - - renpy.display.render.take_focuses(focus_list) - - global default_focus - default_focus = None - - for f in focus_list: - if f.x is None: - default_focus = f - -def focus_coordinates(): - """ - :doc: other - - This attempts to find the coordinates of the currently-focused - displayable. If it can, it will return them as a (x, y, w, h) - tuple. If not, it will return a (None, None, None, None) tuple. - """ - - current = get_focused() - - for i in focus_list: - if i.widget == current and i.arg == argument: - return i.x, i.y, i.w, i.h - - return None, None, None, None - - -# This is called before each interaction. It's purpose is to choose -# the widget that is focused, and to mark it as focused and all of -# the other widgets as unfocused. - -# The new grab widget. (The one that replaced the old grab widget at the start -# of the interaction.) -new_grab = None - -def before_interact(roots): - - global new_grab - global grab - - # a list of focusable, name tuples. - fwn = [ ] - - def callback(f, n): - fwn.append((f, n)) - - for root in roots: - root.find_focusable(callback, None) - - # Assign a full name to each focusable. - - namecount = { } - - for f, n in fwn: - serial = namecount.get(n, 0) - namecount[n] = serial + 1 - - f.full_focus_name = n, serial - - # If there's something with the same full name as the current widget, - # it becomes the new current widget. - - current = get_focused() - - if current is not None: - current_name = current.full_focus_name - - for f, n in fwn: - if f.full_focus_name == current_name: - current = f - set_focused(f, None) - break - else: - current = None - - # Otherwise, focus the default widget, or nothing. - if current is None: - - for f, n in fwn: - if f.default: - current = f - set_focused(f, None) - break - else: - set_focused(None, None) - - # Finally, mark the current widget as the focused widget, and - # all other widgets as unfocused. - for f, n in fwn: - if f is not current: - f.unfocus(default=True) - - if current: - current.focus(default=True) - - grab = new_grab - new_grab = None - -# This changes the focus to be the widget contained inside the new -# focus object. -def change_focus(newfocus, default=False): - rv = None - - if grab: - return - - if newfocus is None: - widget = None - else: - widget = newfocus.widget - - current = get_focused() - - # Nothing to do. - if current is widget and (newfocus is None or newfocus.arg == argument): - return rv - - if current is not None: - current.unfocus(default=default) - - current = widget - - if newfocus is not None: - arg = newfocus.arg - else: - arg = None - - set_focused(current, arg) - - if widget is not None: - rv = widget.focus(default=default) - - return rv - -# This handles mouse events, to see if they change the focus. -def mouse_handler(ev, x, y, default=False): - - if ev.type not in (pygame.MOUSEMOTION, pygame.MOUSEBUTTONUP, pygame.MOUSEBUTTONDOWN): - return - - new_focus = renpy.display.render.focus_at_point(x, y) - - if new_focus is None: - new_focus = default_focus - - return change_focus(new_focus, default=default) - - -# This focuses an extreme widget, which is one of the widgets that's -# at an edge. To do this, we multiply the x, y, width, and height by -# the supplied multiplers, add them all up, and take the focus with -# the largest value. -def focus_extreme(xmul, ymul, wmul, hmul): - - max_focus = None - max_score = -(65536**2) - - for f in focus_list: - - if not f.x: - continue - - score = (f.x * xmul + - f.y * ymul + - f.w * wmul + - f.h * hmul) - - if score > max_score: - max_score = score - max_focus = f - - if max_focus: - return change_focus(max_focus) - - -# This calculates the distance between two points, applying -# the given fudge factors. The distance is left squared. -def points_dist(x0, y0, x1, y1, xfudge, yfudge): - return (( x0 - x1 ) * xfudge ) ** 2 + \ - (( y0 - y1 ) * yfudge ) ** 2 - - -# This computes the distance between two horizontal lines. (So the -# distance is either vertical, or has a vertical component to it.) -# -# The distance is left squared. -def horiz_line_dist(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1): - - # The lines overlap in x. - if bx0 <= ax0 <= ax1 <= bx1 or \ - ax0 <= bx0 <= bx1 <= ax1 or \ - ax0 <= bx0 <= ax1 <= bx1 or \ - bx0 <= ax0 <= bx1 <= ax1: - return (ay0 - by0) ** 2 - - # The right end of a is to the left of the left end of b. - if ax0 <= ax1 <= bx0 <= bx1: - return points_dist(ax1, ay1, bx0, by0, renpy.config.focus_crossrange_penalty, 1.0) - - if bx0 <= bx1 <= ax0 <= ax1: - return points_dist(ax0, ay0, bx1, by1, renpy.config.focus_crossrange_penalty, 1.0) - - assert False - -# This computes the distance between two vertical lines. (So the -# distance is either hortizontal, or has a horizontal component to it.) -# -# The distance is left squared. -def verti_line_dist(ax0, ay0, ax1, ay1, bx0, by0, bx1, by1): - - # The lines overlap in x. - if by0 <= ay0 <= ay1 <= by1 or \ - ay0 <= by0 <= by1 <= ay1 or \ - ay0 <= by0 <= ay1 <= by1 or \ - by0 <= ay0 <= by1 <= ay1: - return (ax0 - bx0) ** 2 - - # The right end of a is to the left of the left end of b. - if ay0 <= ay1 <= by0 <= by1: - return points_dist(ax1, ay1, bx0, by0, 1.0, renpy.config.focus_crossrange_penalty) - - if by0 <= by1 <= ay0 <= ay1: - return points_dist(ax0, ay0, bx1, by1, 1.0, renpy.config.focus_crossrange_penalty) - - assert False - - - -# This focuses the widget that is nearest to the current widget. To -# determine nearest, we compute points on the widgets using the -# {from,to}_{x,y}off values. We pick the nearest, applying a fudge -# multiplier to the distances in each direction, that satisfies -# the condition (which is given a Focus object to evaluate). -# -# If no focus can be found matching the above, we look for one -# with an x of None, and make that the focus. Otherwise, we do -# nothing. -# -# If no widget is focused, we pick one and focus it. -# -# If the current widget has an x of None, we pass things off to -# focus_extreme to deal with. -def focus_nearest(from_x0, from_y0, from_x1, from_y1, - to_x0, to_y0, to_x1, to_y1, - line_dist, - condition, - xmul, ymul, wmul, hmul): - - if not focus_list: - return - - # No widget focused. - current = get_focused() - - if not current: - change_focus(focus_list[0]) - return - - # Find the current focus. - for f in focus_list: - if f.widget is current and f.arg == argument: - from_focus = f - break - else: - # If we can't pick something. - change_focus(focus_list[0]) - return - - # If placeless, focus_extreme. - if from_focus.x is None: - focus_extreme(xmul, ymul, wmul, hmul) - return - - fx0 = from_focus.x + from_focus.w * from_x0 - fy0 = from_focus.y + from_focus.h * from_y0 - fx1 = from_focus.x + from_focus.w * from_x1 - fy1 = from_focus.y + from_focus.h * from_y1 - - placeless = None - new_focus = None - - # a really big number. - new_focus_dist = (65536.0 * renpy.config.focus_crossrange_penalty) ** 2 - - for f in focus_list: - - if f is from_focus: - continue - - if f.x is None: - placeless = f - continue - - if not condition(from_focus, f): - continue - - tx0 = f.x + f.w * to_x0 - ty0 = f.y + f.h * to_y0 - tx1 = f.x + f.w * to_x1 - ty1 = f.y + f.h * to_y1 - - dist = line_dist(fx0, fy0, fx1, fy1, - tx0, ty0, tx1, ty1) - - if dist < new_focus_dist: - new_focus = f - new_focus_dist = dist - - # If we couldn't find anything, try the placeless focus. - new_focus = new_focus or placeless - - # If we have something, switch to it. - if new_focus: - return change_focus(new_focus) - - # And, we're done. - - - -def key_handler(ev): - - if renpy.display.behavior.map_event(ev, 'focus_right'): - return focus_nearest(0.9, 0.1, 0.9, 0.9, - 0.1, 0.1, 0.1, 0.9, - verti_line_dist, - lambda old, new : old.x + old.w <= new.x, - -1, 0, 0, 0) - - if renpy.display.behavior.map_event(ev, 'focus_left'): - return focus_nearest(0.1, 0.1, 0.1, 0.9, - 0.9, 0.1, 0.9, 0.9, - verti_line_dist, - lambda old, new : new.x + new.w <= old.x, - 1, 0, 1, 0) - - if renpy.display.behavior.map_event(ev, 'focus_up'): - return focus_nearest(0.1, 0.1, 0.9, 0.1, - 0.1, 0.9, 0.9, 0.9, - horiz_line_dist, - lambda old, new : new.y + new.h <= old.y, - 0, 1, 0, 1) - - if renpy.display.behavior.map_event(ev, 'focus_down'): - return focus_nearest(0.1, 0.9, 0.9, 0.9, - 0.1, 0.1, 0.9, 0.1, - horiz_line_dist, - lambda old, new : old.y + old.h <= new.y, - 0, -1, 0, 0) - - - diff --git a/unrpyc/renpy/display/im.py b/unrpyc/renpy/display/im.py deleted file mode 100644 index d90fb51..0000000 --- a/unrpyc/renpy/display/im.py +++ /dev/null @@ -1,1562 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This file contains the new image code, which includes provisions for -# size-based caching and constructing images from operations (like -# cropping and scaling). - -import renpy.display - -import math -import zipfile -import io -import threading -import time - - -# This is an entry in the image cache. -class CacheEntry(object): - - def __init__(self, what, surf): - - # The object that is being cached (which needs to be - # hashable and comparable). - self.what = what - - # The pygame surface corresponding to the cached object. - self.surf = surf - - # The size of this image. - w, h = surf.get_size() - self.size = w * h - - # The time when this cache entry was last used. - self.time = 0 - -# This is the singleton image cache. -class Cache(object): - - def __init__(self): - - # The current arbitrary time. (Increments by one for each - # interaction.) - self.time = 0 - - # A map from Image object to CacheEntry. - self.cache = { } - - # A list of Image objects that we want to preload. - self.preloads = [ ] - - # False if this is not the first preload in this tick. - self.first_preload_in_tick = True - - # The total size of the current generation of images. - self.size_of_current_generation = 0 - - # The total size of everything in the cache. - self.total_cache_size = 0 - - # A lock that must be held when updating the cache. - self.lock = threading.Condition() - - # A lock that mist be held to notify the preload thread. - self.preload_lock = threading.Condition() - - # Is the preload_thread alive? - self.keep_preloading = True - - # A map from image object to surface, only for objects that have - # been pinned into memory. - self.pin_cache = { } - - # Images that we tried, and failed, to preload. - self.preload_blacklist = set() - - # The size of the cache, in pixels. - self.cache_limit = 0 - - # The preload thread. - self.preload_thread = threading.Thread(target=self.preload_thread_main, name="preloader") - self.preload_thread.setDaemon(True) - self.preload_thread.start() - - # Have we been added this tick? - self.added = set() - - # A list of (time, filename, preload) tuples. This is updated when - # config.developer is True and an image is loaded. Preload is a - # flag that is true if the image was loaded from the preload - # thread. The log is limited to 100 entries, and the newest entry - # is first. - # - # This is only updated when config.developer is True. - self.load_log = [ ] - - - def init(self): - """ - Updates the cache object to make use of settings that might be provided - by the game-maker. - """ - - self.cache_limit = renpy.config.image_cache_size * renpy.config.screen_width * renpy.config.screen_height - - def quit(self): #@ReservedAssignment - if not self.preload_thread.isAlive(): - return - - with self.preload_lock: - self.keep_preloading = False - self.preload_lock.notify() - - self.preload_thread.join() - - - # Clears out the cache. - def clear(self): - - self.lock.acquire() - - self.preloads = [ ] - self.pin_cache = { } - self.cache = { } - self.first_preload_in_tick = True - self.size_of_current_generation = 0 - self.total_cache_size = 0 - - self.added.clear() - - self.lock.release() - - # Increments time, and clears the list of images to be - # preloaded. - def tick(self): - - with self.lock: - self.time += 1 - self.preloads = [ ] - self.first_preload_in_tick = True - self.size_of_current_generation = 0 - self.added.clear() - - if renpy.config.debug_image_cache: - renpy.display.ic_log.write("----") - filename, line = renpy.exports.get_filename_line() - renpy.display.ic_log.write("%s %d", filename, line) - - # The preload thread can deal with this update, so we don't need - # to lock things. - def end_tick(self): - self.preloads = [ ] - - - # This returns the pygame surface corresponding to the provided - # image. It also takes care of updating the age of images in the - # cache to be current, and maintaining the size of the current - # generation of images. - def get(self, image, predict=False): - - if not isinstance(image, ImageBase): - raise Exception("Expected an image of some sort, but got" + str(image) + ".") - - if not image.cache: - surf = image.load() - renpy.display.render.mutated_surface(surf) - return surf - - # First try to grab the image out of the cache without locking it. - ce = self.cache.get(image, None) - - # Otherwise, we load the image ourselves. - if ce is None: - - try: - if image in self.pin_cache: - surf = self.pin_cache[image] - else: - surf = image.load() - - except: - raise - - with self.lock: - - ce = CacheEntry(image, surf) - - if image not in self.cache: - self.total_cache_size += ce.size - - self.cache[image] = ce - - # Indicate that this surface had changed. - renpy.display.render.mutated_surface(ce.surf) - - if renpy.config.debug_image_cache: - if predict: - renpy.display.ic_log.write("Added %r (%.02f%%)", ce.what, 100.0 * self.total_cache_size / self.cache_limit) - else: - renpy.display.ic_log.write("Total Miss %r", ce.what) - - renpy.display.draw.load_texture(ce.surf) - - - # Move it into the current generation. This isn't protected by - # a lock, so in certain circumstances we could have an - # inaccurate size - but that will be cured at the end of the - # current generation. - - if ce.time != self.time: - ce.time = self.time - self.size_of_current_generation += ce.size - - # Done... return the surface. - return ce.surf - - - # This kills off a given cache entry. - def kill(self, ce): - - # Should never happen... but... - if ce.time == self.time: - self.size_of_current_generation -= ce.size - - self.total_cache_size -= ce.size - del self.cache[ce.what] - - if renpy.config.debug_image_cache: - renpy.display.ic_log.write("Removed %r", ce.what) - - def cleanout(self): - """ - Cleans out the cache, if it's gotten too large. Returns True - if the cache is smaller than the size limit, or False if it's - bigger and we don't want to continue preloading. - """ - - # If we're within the limit, return. - if self.total_cache_size <= self.cache_limit: - return True - - # If we're outside the cache limit, we need to go and start - # killing off some of the entries until we're back inside it. - - for ce in sorted(iter(self.cache.values()), key=lambda a : a.time): - - if ce.time == self.time: - # If we're bigger than the limit, and there's nothing - # to remove, we should stop the preloading right away. - return False - - # Otherwise, kill off the given cache entry. - self.kill(ce) - - # If we're in the limit, we're done. - if self.total_cache_size <= self.cache_limit: - break - - return True - - - # Called to report that a given image would like to be preloaded. - def preload_image(self, im): - - if not isinstance(im, ImageBase): - return - - with self.lock: - - if im in self.added: - return - - self.added.add(im) - - if im in self.cache: - self.get(im) - in_cache = True - else: - self.preloads.append(im) - in_cache = False - - if not in_cache: - - with self.preload_lock: - self.preload_lock.notify() - - if in_cache and renpy.config.debug_image_cache: - renpy.display.ic_log.write("Kept %r", im) - - - def start_prediction(self): - """ - Called at the start of prediction, to ensure the thread runs - at least once to clean out the cache. - """ - - with self.preload_lock: - self.preload_lock.notify() - - def preload_thread_main(self): - - while self.keep_preloading: - - self.preload_lock.acquire() - self.preload_lock.wait() - self.preload_lock.release() - - while self.preloads and self.keep_preloading: - - start = time.time() - - # If the size of the current generation is bigger than the - # total cache size, stop preloading. - with self.lock: - - # If the cache is overfull, clean it out. - if not self.cleanout(): - - if renpy.config.debug_image_cache: - for i in self.preloads: - renpy.display.ic_log.write("Overfull %r", i) - - self.preloads = [ ] - - break - - try: - image = self.preloads.pop(0) - - if image not in self.preload_blacklist: - try: - self.get(image, True) - except: - self.preload_blacklist.add(image) - except: - pass - - with self.lock: - self.cleanout() - - # If we have time, preload pinned images. - if self.keep_preloading and not renpy.game.less_memory: - - workset = set(renpy.store._cache_pin_set) - - # Remove things that are not in the workset from the pin cache, - # and remove things that are in the workset from pin cache. - for i in list(self.pin_cache.keys()): - - if i in workset: - workset.remove(i) - else: - surf = self.pin_cache[i] - - del self.pin_cache[i] - - - # For each image in the worklist... - for image in workset: - - if image in self.preload_blacklist: - continue - - # If we have normal preloads, break out. - if self.preloads: - break - - try: - surf = image.load() - self.pin_cache[image] = surf - renpy.display.draw.load_texture(surf) - except: - self.preload_blacklist.add(image) - - def add_load_log(self, filename): - - if not renpy.config.developer: - return - - preload = (threading.current_thread() is self.preload_thread) - - self.load_log.insert(0, (time.time(), filename, preload)) - - while len(self.load_log) > 100: - self.load_log.pop() - - - -# The cache object. -cache = Cache() - -def free_memory(): - """ - Frees some memory. - """ - - renpy.display.draw.free_memory() - cache.clear() - - -class ImageBase(renpy.display.core.Displayable): - """ - This is the base class for all of the various kinds of images that - we can possibly have. - """ - - __version__ = 1 - - def after_upgrade(self, version): - if version < 1: - self.cache = True - - def __init__(self, *args, **properties): - - self.rle = properties.pop('rle', None) - self.cache = properties.pop('cache', True) - - properties.setdefault('style', 'image') - - super(ImageBase, self).__init__(**properties) - self.identity = (type(self).__name__, ) + args - - - def __hash__(self): - return hash(self.identity) - - def __eq__(self, other): - - if not isinstance(other, ImageBase): - return False - - return self.identity == other.identity - - def __repr__(self): - return "<" + " ".join([repr(i) for i in self.identity]) + ">" - - def load(self): - """ - This function is called by the image cache code to cause this - image to be loaded. It's expected that children of this class - would override this. - """ - - assert False - - def render(self, w, h, st, at): - - im = cache.get(self) - texture = renpy.display.draw.load_texture(im) - - w, h = im.get_size() - rv = renpy.display.render.Render(w, h) - rv.blit(texture, (0, 0)) - return rv - - def predict_one(self): - renpy.display.predict.image(self) - - def predict_files(self): - """ - Returns a list of files that will be accessed when this image - operation is performed. - """ - - return [ ] - -class Image(ImageBase): - """ - This image manipulator loads an image from a file. - """ - - def __init__(self, filename, **properties): - """ - @param filename: The filename that the image will be loaded from. - """ - - super(Image, self).__init__(filename, **properties) - self.filename = filename - - def get_mtime(self): - return renpy.loader.get_mtime(self.filename) - - def load(self, unscaled=False): - - cache.add_load_log(self.filename) - - try: - - if unscaled: - surf = renpy.display.pgrender.load_image_unscaled(renpy.loader.load(self.filename), self.filename) - else: - surf = renpy.display.pgrender.load_image(renpy.loader.load(self.filename), self.filename) - - return surf - - except Exception as e: - - if renpy.config.missing_image_callback: - im = renpy.config.missing_image_callback(self.filename) - if im is None: - raise e - - return im.load() - - raise - - def predict_files(self): - - if renpy.loader.loadable(self.filename): - return [ self.filename ] - else: - if renpy.config.missing_image_callback: - im = renpy.config.missing_image_callback(self.filename) - if im is not None: - return im.predict_files() - - return [ self.filename ] - -class ZipFileImage(ImageBase): - - def __init__(self, zipfilename, filename, mtime=0, **properties): - super(ZipFileImage, self).__init__(zipfilename, filename, mtime, **properties) - - self.zipfilename = zipfilename - self.filename = filename - - def load(self): - try: - zf = zipfile.ZipFile(self.zipfilename, 'r') - data = zf.read(self.filename) - sio = io.StringIO(data) - rv = renpy.display.pgrender.load_image(sio, self.filename) - zf.close() - return rv - except: - return renpy.display.pgrender.surface((2, 2), True) - - - - def predict_files(self): - return [ ] - - - -class Composite(ImageBase): - """ - :doc: im_im - - This image manipulator composites multiple images together to - form a single image. - - The `size` should be a (width, height) tuple giving the size - of the composed image. - - The remaining positional arguments are interpreted as groups of - two. The first argument in a group should be an (x, y) tuple, - while the second should be an image manipulator. The image - produced by the image manipulator is composited at the location - given by the tuple. - - :: - - image girl clothed happy = im.Composite( - (300, 600), - (0, 0), "girl_body.png", - (0, 0), "girl_clothes.png", - (100, 100), "girl_happy.png" - ) - - """ - - def __init__(self, size, *args, **properties): - - super(Composite, self).__init__(size, *args, **properties) - - if len(args) % 2 != 0: - raise Exception("Composite requires an odd number of arguments.") - - self.size = size - self.positions = args[0::2] - self.images = [ image(i) for i in args[1::2] ] - - def get_mtime(self): - return min(i.get_mtime() for i in self.images) - - def load(self): - - if self.size: - size = self.size - else: - size = cache.get(self.images[0]).get_size() - - rv = renpy.display.pgrender.surface(size, True) - - for pos, im in zip(self.positions, self.images): - rv.blit(cache.get(im), pos) - - return rv - - def predict_files(self): - - rv = [ ] - - for i in self.images: - rv.extend(i.predict_files()) - - return rv - -class Scale(ImageBase): - """ - :doc: im_im - - An image manipulator that scales `im` (an image manipulator) to - `width` and `height`. - - If `bilinear` is true, then bilinear interpolation is used for - the scaling. Otherwise, nearest neighbor interpolation is used. - - :: - - image logo scale = im.Scale("logo.png", 100, 150) - """ - - def __init__(self, im, width, height, bilinear=True, **properties): - - im = image(im) - super(Scale, self).__init__(im, width, height, bilinear, **properties) - - self.image = im - self.width = int(width) - self.height = int(height) - self.bilinear = bilinear - - def get_mtime(self): - return self.image.get_mtime() - - def load(self): - - child = cache.get(self.image) - - if self.bilinear: - try: - renpy.display.render.blit_lock.acquire() - rv = renpy.display.scale.smoothscale(child, (self.width, self.height)) - finally: - renpy.display.render.blit_lock.release() - else: - try: - renpy.display.render.blit_lock.acquire() - rv = renpy.display.pgrender.transform_scale(child, (self.width, self.height)) - finally: - renpy.display.render.blit_lock.release() - - return rv - - def predict_files(self): - return self.image.predict_files() - -class FactorScale(ImageBase): - """ - :doc: im_im - - An image manipulator that scales `im` (a second image manipulator) - to `width` times its original `width`, and `height` times its - original height. If `height` is ommitted, it defaults to `width`. - - If `bilinear` is true, then bilinear interpolation is used for - the scaling. Otherwise, nearest neighbor interpolation is used. - - :: - - image logo doubled = im.FactorScale("logo.png", 1.5) - """ - - - def __init__(self, im, width, height=None, bilinear=True, **properties): - - if height is None: - height = width - - im = image(im) - super(FactorScale, self).__init__(im, width, height, bilinear, **properties) - - self.image = im - self.width = width - self.height = height - self.bilinear = bilinear - - def get_mtime(self): - return self.image.get_mtime() - - def load(self): - - surf = cache.get(self.image) - width, height = surf.get_size() - - width = int(width * self.width) - height = int(height * self.height) - - if self.bilinear: - try: - renpy.display.render.blit_lock.acquire() - rv = renpy.display.scale.smoothscale(surf, (width, height)) - finally: - renpy.display.render.blit_lock.release() - - else: - try: - renpy.display.render.blit_lock.acquire() - rv = renpy.display.pgrender.transform_scale(surf, (width, height)) - finally: - renpy.display.render.blit_lock.release() - - return rv - - def predict_files(self): - return self.image.predict_files() - - -class Flip(ImageBase): - """ - :doc: im_im - - An image manipulator that flips `im` (an image manipulator) - vertically or horizontally. `vertical` and `horizontal` control - the directions in which the image is flipped. - - :: - - image eileen flip = im.Flip("eileen_happy.png", vertical=True) - """ - - def __init__(self, im, horizontal=False, vertical=False, **properties): - - if not (horizontal or vertical): - raise Exception("im.Flip must be called with a true value for horizontal or vertical.") - - im = image(im) - super(Flip, self).__init__(im, horizontal, vertical, **properties) - - self.image = im - self.horizontal = horizontal - self.vertical = vertical - - - def get_mtime(self): - return self.image.get_mtime() - - def load(self): - - child = cache.get(self.image) - - try: - renpy.display.render.blit_lock.acquire() - rv = renpy.display.pgrender.flip(child, self.horizontal, self.vertical) - finally: - renpy.display.render.blit_lock.release() - - return rv - - - def predict_files(self): - return self.image.predict_files() - - - -class Rotozoom(ImageBase): - """ - This is an image manipulator that is a smooth rotation and zoom of another image manipulator. - """ - - def __init__(self, im, angle, zoom, **properties): - """ - @param im: The image to be rotozoomed. - - @param angle: The number of degrees counterclockwise the image is - to be rotated. - - @param zoom: The zoom factor. Numbers that are greater than 1.0 - lead to the image becoming larger. - """ - - im = image(im) - super(Rotozoom, self).__init__(im, angle, zoom, **properties) - - self.image = im - self.angle = angle - self.zoom = zoom - - def get_mtime(self): - return self.image.get_mtime() - - def load(self): - - child = cache.get(self.image) - - try: - renpy.display.render.blit_lock.acquire() - rv = renpy.display.pgrender.rotozoom(child, self.angle, self.zoom) - finally: - renpy.display.render.blit_lock.release() - - return rv - - def predict_files(self): - return self.image.predict_files() - - - -class Crop(ImageBase): - """ - :doc: im_im - :args: (im, rect) - - An image manipulator that crops `rect`, a (x, y, width, height) tuple, - out of `im`, an image manipulator. - - :: - - image logo crop = im.Crop("logo.png", (0, 0, 100, 307)) - """ - - def __init__(self, im, x, y=None, w=None, h=None, **properties): - - im = image(im) - - if y is None: - (x, y, w, h) = x - - super(Crop, self).__init__(im, x, y, w, h, **properties) - - self.image = im - self.x = x - self.y = y - self.w = w - self.h = h - - def get_mtime(self): - return self.image.get_mtime() - - def load(self): - return cache.get(self.image).subsurface((self.x, self.y, - self.w, self.h)) - - def predict_files(self): - return self.image.predict_files() - - -ramp_cache = { } - - -def ramp(start, end): - """ - Returns a 256 character linear ramp, where the first character has - the value start and the last character has the value end. Such a - ramp can be used as a map argument of im.Map. - """ - - rv = ramp_cache.get((start, end), None) - if rv is None: - - chars = [ ] - - for i in range(0, 256): - i = i / 255.0 - chars.append(chr(int( end * i + start * (1.0 - i) ) ) ) - - rv = "".join(chars) - ramp_cache[start, end] = rv - - return rv - -identity = ramp(0, 255) - -class Map(ImageBase): - """ - This adjusts the colors of the image that is its child. It takes - as arguments 4 256 character strings. If a pixel channel has a - value of 192, then the value of the 192nd character in the string - is used for the mapped pixel component. - """ - - def __init__(self, im, rmap=identity, gmap=identity, bmap=identity, - amap=identity, force_alpha=False, **properties): - - im = image(im) - - super(Map, self).__init__(im, rmap, gmap, bmap, amap, force_alpha, **properties) - - self.image = im - self.rmap = rmap - self.gmap = gmap - self.bmap = bmap - self.amap = amap - - self.force_alpha = force_alpha - - def get_mtime(self): - return self.image.get_mtime() - - def load(self): - - surf = cache.get(self.image) - - rv = renpy.display.pgrender.surface(surf.get_size(), True) - - renpy.display.module.map(surf, rv, - self.rmap, self.gmap, self.bmap, self.amap) - - return rv - - def predict_files(self): - return self.image.predict_files() - -class Twocolor(ImageBase): - """ - This takes as arguments two colors, white and black. The image is - mapped such that pixels in white have the white color, pixels in - black have the black color, and shades of gray are linearly - interpolated inbetween. The alpha channel is mapped linearly - between 0 and the alpha found in the white color, the black - color's alpha is ignored. - """ - - def __init__(self, im, white, black, force_alpha=False, **properties): - - white = renpy.easy.color(white) - black = renpy.easy.color(black) - - im = image(im) - - super(Twocolor, self).__init__(im, white, black, force_alpha, **properties) - - self.image = im - self.white = white - self.black = black - - self.force_alpha = force_alpha - - def get_mtime(self): - return self.image.get_mtime() - - def load(self): - - surf = cache.get(self.image) - - rv = renpy.display.pgrender.surface(surf.get_size(), True) - - renpy.display.module.twomap(surf, rv, - self.white, self.black) - - return rv - - def predict_files(self): - return self.image.predict_files() - - -class Recolor(ImageBase): - """ - This adjusts the colors of the image that is its child. It takes as an - argument 4 numbers between 0 and 255, and maps each channel of the image - linearly between 0 and the supplied color. - """ - - def __init__(self, im, rmul=255, gmul=255, bmul=255, - amul=255, force_alpha=False, **properties): - - im = image(im) - - super(Recolor, self).__init__(im, rmul, gmul, bmul, amul, force_alpha, **properties) - - self.image = im - self.rmul = rmul + 1 - self.gmul = gmul + 1 - self.bmul = bmul + 1 - self.amul = amul + 1 - - self.force_alpha = force_alpha - - def get_mtime(self): - return self.image.get_mtime() - - def load(self): - - surf = cache.get(self.image) - - rv = renpy.display.pgrender.surface(surf.get_size(), True) - - renpy.display.module.linmap(surf, rv, - self.rmul, self.gmul, self.bmul, self.amul) - - return rv - - def predict_files(self): - return self.image.predict_files() - -class MatrixColor(ImageBase): - """ - :doc: im_matrixcolor - - An image operator that uses `matrix` to linearly transform the - image manipulator `im`. - - `Matrix` should be a list, tuple, or :func:`im.matrix` that is 20 - or 25 elements long. If the object has 25 elements, then elements - past the 20th are ignored. - - When the four components of the source color are R, G, B, and A, - which range from 0.0 to 1.0; the four components of the transformed - color are R', G', B', and A', with the same range; and the elements - of the matrix are named:: - - [ a, b, c, d, e, - f, g, h, i, j, - k, l, m, n, o, - p, q, r, s, t ] - - the transformed colors can be computed with the formula:: - - R' = (a * R) + (b * G) + (c * B) + (d * A) + e - G' = (f * R) + (g * G) + (h * B) + (i * A) + j - B' = (k * R) + (l * G) + (m * B) + (n * A) + o - A' = (p * R) + (q * G) + (r * B) + (s * A) + t - - The components of the transformed color are clamped to the - range [0.0, 1.0]. - """ - - def __init__(self, im, matrix, **properties): - - im = image(im) - - if len(matrix) != 20 and len(matrix) != 25: - raise Exception("ColorMatrix expects a 20 or 25 element matrix, got %d elements." % len(matrix)) - - matrix = tuple(matrix) - super(MatrixColor, self).__init__(im, matrix, **properties) - - self.image = im - self.matrix = matrix - - def get_mtime(self): - return self.image.get_mtime() - - def load(self): - - surf = cache.get(self.image) - - rv = renpy.display.pgrender.surface(surf.get_size(), True) - - renpy.display.module.colormatrix(surf, rv, self.matrix) - - return rv - - def predict_files(self): - return self.image.predict_files() - -class matrix(tuple): - """ - :doc: im_matrixcolor - - Constructs an im.matrix object from `matrix`. im.matrix objects - support The operations supported are matrix multiplication, scalar - multiplication, element-wise addition, and element-wise - subtraction. These operations are invoked using the standard - mathematical operators (\\*, \\*, +, and -, respectively). If two - im.matrix objects are multiplied, matrix multiplication is - performed, otherwise scalar multiplication is used. - - `matrix` is a 20 or 25 element list or tuple. If it is 20 elements - long, it is padded with (0, 0, 0, 0, 1) to make a 5x5 matrix, - suitable for multiplication. - """ - - def __new__(cls, *args): - - if len(args) == 1: - args = tuple(args[0]) - - if len(args) == 20: - args = args + (0, 0, 0, 0, 1) - - if len(args) != 25: - raise Exception("Matrix expects to be given 20 or 25 entries, not %d." % len(args)) - - return tuple.__new__(cls, args) - - def mul(self, a, b): - - if not isinstance(a, matrix): - a = matrix(a) - - if not isinstance(b, matrix): - b = matrix(b) - - result = [ 0 ] * 25 - for y in range(0, 5): - for x in range(0, 5): - for i in range(0, 5): - result[x + y * 5] += a[x + i * 5] * b[i + y * 5] - - return matrix(result) - - def scalar_mul(self, other): - other = float(other) - return matrix([ i * other for i in self ]) - - def vector_mul(self, o): - - return (o[0]*self[0] + o[1]*self[1] + o[2]*self[2] + o[3]*self[3] + self[4], - o[0]*self[5] + o[1]*self[6] + o[2]*self[7] + o[3]*self[8] + self[9], - o[0]*self[10] + o[1]*self[11] + o[2]*self[12] + o[3]*self[13] + self[14], - o[0]*self[15] + o[1]*self[16] + o[2]*self[17] + o[3]*self[18] + self[19], - 1) - - - def __add__(self, other): - if isinstance(other, (int, float)): - other = float(other) - return matrix([ i + other for i in self ]) - - other = matrix(other) - return matrix([ i + j for i, j in zip(self, other)]) - - __radd__ = __add__ - - def __sub__(self, other): - return self + other * -1 - - def __rsub__(self, other): - return self * -1 + other - - def __mul__(self, other): - if isinstance(other, (int, float)): - return self.scalar_mul(other) - - return self.mul(self, other) - - def __rmul__(self, other): - if isinstance(other, (int, float)): - return self.scalar_mul(other) - - return self.mul(other, self) - - def __repr__(self): - return """\ -im.matrix(%f, %f, %f, %f, %f. - %f, %f, %f, %f, %f, - %f, %f, %f, %f, %f, - %f, %f, %f, %f, %f, - %f, %f, %f, %f, %f)""" % self - - - @staticmethod - def identity(): - """ - :doc: im_matrixcolor - :name: im.matrix.identity - - Returns an identity matrix, one that does not change color or - alpha. - """ - - return matrix(1, 0, 0, 0, 0, - 0, 1, 0, 0, 0, - 0, 0, 1, 0, 0, - 0, 0, 0, 1, 0) - @staticmethod - def saturation(level, desat=(0.2126, 0.7152, 0.0722)): - """ - :doc: im_matrixcolor - :name: im.matrix.saturation - - Returns an im.matrix that alters the saturation of an - image. The alpha channel is untouched. - - `level` - The amount of saturation in the resulting image. 1.0 is - the unaltered image, while 0.0 is grayscale. - - `desat` - This is a 3-element tuple that controls how much of the - red, green, and blue channels will be placed into all - three channels of a fully desaturated image. The default - is based on the constants used for the luminance channel - of an NTSC television signal. Since the human eye is - mostly sensitive to green, more of the green channel is - kept then the other two channels. - """ - - r, g, b = desat - - def I(a, b): - return a + (b - a) * level - - return matrix(I(r, 1), I(g, 0), I(b, 0), 0, 0, - I(r, 0), I(g, 1), I(b, 0), 0, 0, - I(r, 0), I(g, 0), I(b, 1), 0, 0, - 0, 0, 0, 1, 0) - - @staticmethod - def desaturate(): - """ - :doc: im_matrixcolor - :name: im.matrix.desaturate - - Returns an im.matrix that desaturates the image (makes it - grayscale). This is equivalent to calling - im.matrix.saturation(0). - """ - - return matrix.saturation(0.0) - - @staticmethod - def tint(r, g, b): - """ - :doc: im_matrixcolor - :name: im.matrix.tint - - Returns an im.matrix that tints an image, without changing - the alpha channel. `r`, `g`, and `b` should be numbers between - 0 and 1, and control what fraction of the given channel is - placed into the final image. (For example, if `r` is .5, and - the value of the red channel is 100, the transformed color - will have a red value of 50.) - """ - - return matrix(r, 0, 0, 0, 0, - 0, g, 0, 0, 0, - 0, 0, b, 0, 0, - 0, 0, 0, 1, 0) - - @staticmethod - def invert(): - """ - :doc: im_matrixcolor - :name: im.matrix.invert - - Returns an im.matrix that inverts the red, green, and blue - channels of the image without changing the alpha channel. - """ - - return matrix(-1, 0, 0, 0, 1, - 0, -1, 0, 0, 1, - 0, 0, -1, 0, 1, - 0, 0, 0, 1, 0) - - @staticmethod - def brightness(b): - """ - :doc: im_matrixcolor - :name: im.matrix.brightness - - Returns an im.matrix that alters the brightness of an image. - - `b` - The amount of change in image brightness. This should be - a number between -1 and 1, with -1 the darkest possible - image and 1 the brightest. - """ - - return matrix(1, 0, 0, 0, b, - 0, 1, 0, 0, b, - 0, 0, 1, 0, b, - 0, 0, 0, 1, 0) - - @staticmethod - def opacity(o): - """ - :doc: im_matrixcolor - :name: im.matrix.opacity - - Returns an im.matrix that alters the opacity of an image. An - `o` of 0.0 is fully transparent, while 1.0 is fully opaque. - """ - - return matrix(1, 0, 0, 0, 0, - 0, 1, 0, 0, 0, - 0, 0, 1, 0, 0, - 0, 0, 0, o, 0) - - @staticmethod - def contrast(c): - """ - :doc: im_matrixcolor - :name: im.matrix.contrast - - Returns an im.matrix that alters the contrast of an image. `c` should - be greater than 0.0, with values between 0.0 and 1.0 decreasing contrast, and - values greater than 1.0 increasing contrast. - """ - - return matrix.brightness(-.5) * matrix.tint(c, c, c) * matrix.brightness(.5) - - # from http://www.gskinner.com/blog/archives/2005/09/flash_8_source.html - @staticmethod - def hue(h): - """ - :doc: im_matrixcolor - :name: im.matrix.hue - - Returns an im.matrix that rotates the hue by `h` degrees, while - preserving luminosity. - """ - - h = h * math.pi / 180 - cosVal = math.cos(h) - sinVal = math.sin(h) - lumR = 0.213 - lumG = 0.715 - lumB = 0.072 - return matrix( - lumR+cosVal*(1-lumR)+sinVal*(-lumR),lumG+cosVal*(-lumG)+sinVal*(-lumG),lumB+cosVal*(-lumB)+sinVal*(1-lumB),0,0, - lumR+cosVal*(-lumR)+sinVal*(0.143),lumG+cosVal*(1-lumG)+sinVal*(0.140),lumB+cosVal*(-lumB)+sinVal*(-0.283),0,0, - lumR+cosVal*(-lumR)+sinVal*(-(1-lumR)),lumG+cosVal*(-lumG)+sinVal*(lumG),lumB+cosVal*(1-lumB)+sinVal*(lumB),0,0, - 0,0,0,1,0, - 0,0,0,0,1 - ) - - @staticmethod - def colorize(black_color, white_color): - """ - :doc: im_matrixcolor - :name: im.matrix.colorize - - Returns an im.matrix that colorizes a black and white image. - `black_color` and `white_color` are Ren'Py style colors, so - they may be specfied as strings or tuples of (0-255) color - values. :: - - # This makes black colors red, and white colors blue. - image logo colored = im.MatrixColor( - "bwlogo.png", - im.matrix.colorize("#f00", "#00f")) - - """ - - (r0, g0, b0, _a0) = renpy.easy.color(black_color) - (r1, g1, b1, _a1) = renpy.easy.color(white_color) - - r0 /= 255.0 - g0 /= 255.0 - b0 /= 255.0 - r1 /= 255.0 - g1 /= 255.0 - b1 /= 255.0 - - return matrix((r1-r0), 0, 0, 0, r0, - 0, (g1-g0), 0, 0, g0, - 0, 0, (b1-b0), 0, b0, - 0, 0, 0, 1, 0) - - - -def Grayscale(im, desat=(0.2126, 0.7152, 0.0722), **properties): - """ - :doc: im_im - :args: (im, **properties) - - An image manipulator that creats a desaturated version of the image - manipulator `im`. - """ - - return MatrixColor(im, matrix.saturation(0.0, desat), **properties) - - -def Sepia(im, tint=(1.0, .94, .76), desat=(0.2126, 0.7152, 0.0722), **properties): - """ - :doc: im_im - :args: (im, **properties) - - An image manipulator that creates a sepia-toned version of the image - manipulator `im`. - """ - - return MatrixColor(im, matrix.saturation(0.0, desat) * matrix.tint(tint[0], tint[1], tint[2]), **properties) - - -def Color(im, color): - """ - This recolors the supplied image, mapping colors such that black is - black and white is the supplied color. - """ - - r, g, b, a = renpy.easy.color(color) - - return Recolor(im, r, g, b, a) - - -def Alpha(image, alpha, **properties): - """ - Returns an alpha-mapped version of the image. Alpha is the maximum - alpha that this image can have, a number between 0.0 (fully - transparent) and 1.0 (opaque). - - If an image already has an alpha channel, values in that alpha - channel are reduced as appropriate. - """ - - return Recolor(image, 255, 255, 255, int(255 * alpha), force_alpha=True, **properties) - -class Tile(ImageBase): - """ - :doc: im_im - - An image manipulator that tiles the image manipulator `im`, until - it is `size`. - - `size` - If not None, a (width, height) tuple. If None, this defaults to - (:var:`config.screen_width`, :var:`config.screen_height`). - """ - - def __init__(self, im, size=None, **properties): - - im = image(im) - - super(Tile, self).__init__(im, size, **properties) - self.image = im - self.size = size - - def get_mtime(self): - return self.image.get_mtime() - - def load(self): - - size = self.size - - if size is None: - size = (renpy.config.screen_width, renpy.config.screen_height) - - surf = cache.get(self.image) - - rv = renpy.display.pgrender.surface(size, True) - - width, height = size - sw, sh = surf.get_size() - - for y in range(0, height, sh): - for x in range(0, width, sw): - rv.blit(surf, (x, y)) - - return rv - - def predict_files(self): - return self.image.predict_files() - -class AlphaMask(ImageBase): - """ - :doc: im_im - - An image manipulator that takes two image manipulators, `base` and - `mask`, as arguments. It replaces the alpha channel of `base` with - the red channel of `mask`. - - This is used to provide an image's alpha channel in a second - image, like having one jpeg for color data, and a second one - for alpha. In some cases, two jpegs can be smaller than a - single png file. - """ - - def __init__(self, base, mask, **properties): - super(AlphaMask, self).__init__(base, mask, **properties) - - self.base = image(base) - self.mask = image(mask) - - def get_mtime(self): - return max(self.base.get_mtime(), self.image.get_mtime()) - - def load(self): - - basesurf = cache.get(self.base) - masksurf = cache.get(self.mask) - - if basesurf.get_size() != masksurf.get_size(): - raise Exception("AlphaMask surfaces must be the same size.") - - # Used to copy the surface. - rv = renpy.display.pgrender.copy_surface(basesurf) - renpy.display.module.alpha_munge(masksurf, rv, identity) - - return rv - - def predict_files(self): - return self.base.predict_files() + self.mask.predict_files() - -def image(arg, loose=False, **properties): - """ - :doc: im_image - :name: Image - :args: (filename, **properties) - - Loads an image from a file. `filename` is a - string giving the name of the file. - - `filename` should be a JPEG or PNG file with an appropriate - extension. - """ - - """ - (Actually, the user documentation is a bit misleading, as - this tries for compatibility with several older forms of - image specification.) - - If the loose argument is False, then this will report an error if an - arbitrary argument is given. If it's True, then the argument is passed - through unchanged. - """ - - if isinstance(arg, ImageBase): - return arg - - elif isinstance(arg, str): - return Image(arg, **properties) - - elif isinstance(arg, renpy.display.image.ImageReference): - arg.find_target() - return image(arg.target, loose=loose, **properties) - - elif isinstance(arg, tuple): - params = [ ] - - for i in arg: - params.append((0, 0)) - params.append(i) - - return Composite(None, *params) - - elif loose: - return arg - - if isinstance(arg, renpy.display.core.Displayable): - raise Exception("Expected an image, but got a general displayable.") - else: - raise Exception("Could not construct image from argument.") - - -def load_image(fn): - """ - This loads an image from the given filename, using the cache. - """ - - surf = cache.get(image(fn)) - return renpy.display.draw.load_texture(surf) diff --git a/unrpyc/renpy/display/image.py b/unrpyc/renpy/display/image.py deleted file mode 100644 index 362f87a..0000000 --- a/unrpyc/renpy/display/image.py +++ /dev/null @@ -1,397 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This file contains some miscellaneous displayables that involve images. -# Most of the guts of this file have been moved into im.py, with only some -# of the stuff thar uses images remaining. - -import renpy.display -import renpy.text -from renpy.display.render import render, Render - -import collections - -# A map from image name to the displayable object corresponding to that -# image. -images = { } - -# A map from image tag to lists of possible attributes for images with that -# tag. -image_attributes = collections.defaultdict(list) - -def register_image(name, d): - """ - Registers the existence of an image with `name`, and that the image - used displayable d. - """ - - tag = name[0] - rest = name[1:] - - images[name] = d - image_attributes[tag].append(rest) - - -def wrap_render(child, w, h, st, at): - rend = render(child, w, h, st, at) - rv = Render(rend.width, rend.height) - rv.blit(rend, (0, 0)) - return rv - -class ImageReference(renpy.display.core.Displayable): - """ - ImageReference objects are used to reference images by their name, - which is a tuple of strings corresponding to the name used to define - the image in an image statment. - """ - - nosave = [ 'target' ] - target = None - param_target = None - - def __init__(self, name, **properties): - """ - @param name: A tuple of strings, the name of the image. Or else - a displayable, containing the image directly. - """ - - super(ImageReference, self).__init__(**properties) - - self.name = name - - def _get_parameterized(self): - if self.param_target: - return self.param_target._get_parameterized() - - return self - - def find_target(self): - - if self.param_target: - self.target = self.param_target - return None - - name = self.name - - if isinstance(name, renpy.display.core.Displayable): - self.target = name - return True - - if not isinstance(name, tuple): - name = tuple(name.split()) - - parameters = [ ] - - def error(msg): - self.target = renpy.text.text.Text(msg, color=(255, 0, 0, 255), xanchor=0, xpos=0, yanchor=0, ypos=0) - - if renpy.config.debug: - raise Exception(msg) - - - # Scan through, searching for an image (defined with an - # input statement) that is a prefix of the given name. - while name: - if name in images: - target = images[name] - - try: - self.target = target.parameterize(name, parameters) - if self.target is not target: - self.param_target = self.target - - except Exception as e: - if renpy.config.debug: - raise - - error(str(e)) - - return True - - else: - parameters.insert(0, name[-1]) - name = name[:-1] - - error("Image '%s' not found." % ' '.join(self.name)) - return False - - def parameterize(self, name, parameters): - if not self.target: - self.find_target() - - return self.target.parameterize(name, parameters) - - def _hide(self, st, at, kind): - if not self.target: - self.find_target() - - return self.target._hide(st, at, kind) - - def set_transform_event(self, event): - if not self.target: - self.find_target() - - return self.target.set_transform_event(event) - - def event(self, ev, x, y, st): - if not self.target: - self.find_target() - - return self.target.event(ev, x, y, st) - - def render(self, width, height, st, at): - if not self.target: - self.find_target() - - return wrap_render(self.target, width, height, st, at) - - def get_placement(self): - if not self.target: - self.find_target() - - if not renpy.config.imagereference_respects_position: - return self.target.get_placement() - - xpos, ypos, xanchor, yanchor, xoffset, yoffset, subpixel = self.target.get_placement() - - if xpos is None: - xpos = self.style.xpos - - if ypos is None: - ypos = self.style.ypos - - if xanchor is None: - xanchor = self.style.xanchor - - if yanchor is None: - yanchor = self.style.yanchor - - return xpos, ypos, xanchor, yanchor, xoffset, yoffset, subpixel - - def visit(self): - if not self.target: - self.find_target() - - return [ self.target ] - - - -class ShownImageInfo(renpy.object.Object): - """ - This class keeps track of which images are being shown right now, - and what the attributes of those images are. (It's used for a similar - purpose during prediction, regarding the state in the future.) - """ - - __version__ = 2 - - def __init__(self, old=None): - """ - Creates a new object. If `old` is given, copies the default state - from old, otherwise initializes the object to a default state. - """ - - if old is None: - - # A map from (layer, tag) -> tuple of attributes - # This doesn't necessarily correspond to something that is - # currently showing, as we can remember the state of a tag - # for use in SideImage. - self.attributes = { } - - # A set of (layer, tag) pairs that are being shown on the - # screen right now. - self.shown = set() - - else: - self.attributes = old.attributes.copy() - self.shown = old.shown.copy() - - - def after_upgrade(self, version): - if version < 2: - - self.attributes = { } - self.shown = set() - - for layer in self.images: - for tag in self.images[layer]: - self.attributes[layer, tag] = self.images[layer][tag][1:] - self.shown.add((layer, tag)) - - def get_attributes(self, layer, tag): - """ - Get the attributes associated the image with tag on the given - layer. - """ - - return self.attributes.get((layer, tag), ()) - - def showing(self, layer, name): - """ - Returns true if name is the prefix of an image that is showing - on layer, or false otherwise. - """ - - tag = name[0] - rest = name[1:] - - if (layer, tag) not in self.shown: - return None - - shown = self.attributes[layer, tag] - - if len(shown) < len(rest): - return False - - for a, b in zip(shown, rest): - if a != b: - return False - - return True - - def predict_scene(self, layer): - """ - Predicts the scene statement being called on layer. - """ - - for l, t in list(self.attributes.keys()): - if l == layer: - del self.attributes[l, t] - - self.shown = set((l, t) for l, t in self.shown if l != layer) - - def predict_show(self, layer, name, show=True): - """ - Predicts name being shown on layer. - - `show` - If True, the image will be flagged as being shown to the user. If - False, only the attributes will be updated. - """ - - tag = name[0] - rest = name[1:] - - self.attributes[layer, tag] = rest - - if show: - self.shown.add((layer, tag)) - - def predict_hide(self, layer, name): - tag = name[0] - - if (layer, tag) in self.attributes: - del self.attributes[layer, tag] - - self.shown.discard((layer, tag)) - - - def apply_attributes(self, layer, tag, name): - """ - Given a layer, tag, and an image name (with attributes), - returns the canonical name of an image, if one exists. Raises - an exception if it's ambiguious, and returns None if an image - with that name couldn't be found. - """ - - # If the name matches one that exactly exists, return it. - if name in images: - return name - - nametag = name[0] - - # The set of attributes a matching image must have. - required = set(name[1:]) - - # The set of attributes a matching image may have. - optional = set(self.attributes.get((layer, tag), [ ])) - - # Deal with banned attributes.. - for i in name[1:]: - if i[0] == "-": - optional.discard(i[1:]) - required.discard(i) - - return self.choose_image(nametag, required, optional, name) - - def choose_image(self, tag, required, optional, exception_name): - """ - """ - - # The longest length of an image that matches. - max_len = 0 - - # The list of matching images. - matches = None - - for attrs in image_attributes[tag]: - - num_required = 0 - - for i in attrs: - if i in required: - num_required += 1 - continue - - elif i not in optional: - break - - else: - - # We don't have any not-found attributes. But we might not - # have all of the attributes. - - if num_required != len(required): - continue - - len_attrs = len(attrs) - - if len_attrs < max_len: - continue - - if len_attrs > max_len: - max_len = len_attrs - matches = [ ] - - matches.append((tag, ) + attrs) - - if matches is None: - return None - - if len(matches) == 1: - return matches[0] - - if exception_name: - raise Exception("Showing '" + " ".join(exception_name) + "' is ambiguous, possible images include: " + ", ".join(" ".join(i) for i in matches)) - else: - return None - -renpy.display.core.ImagePredictInfo = ShownImageInfo - - -# Functions that have moved from this module to other modules, -# that live here for the purpose of backward-compatibility. -Image = renpy.display.im.image -Solid = renpy.display.imagelike.Solid -Frame = renpy.display.imagelike.Frame -ImageButton = renpy.display.behavior.ImageButton - diff --git a/unrpyc/renpy/display/imagelike.py b/unrpyc/renpy/display/imagelike.py deleted file mode 100644 index aea1d15..0000000 --- a/unrpyc/renpy/display/imagelike.py +++ /dev/null @@ -1,382 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -import renpy.display -from renpy.display.render import render, Render, Matrix2D - -# This file contains displayables that are image-like, because they take -# up a rectangular area of the screen, and do not respond to input. - -class Solid(renpy.display.core.Displayable): - """ - :doc: disp_imagelike - - A displayable that fills the area its assigned with `color`. - - :: - - image white = Solid("#fff") - - """ - - def __init__(self, color, **properties): - - super(Solid, self).__init__(**properties) - - if color is not None: - self.color = renpy.easy.color(color) - else: - self.color = None - - def visit(self): - return [ ] - - def render(self, width, height, st, at): - - color = self.color or self.style.color - - rv = Render(width, height) - - if color is None or width <= 0 or height <= 0: - return rv - - SIZE = 10 - - if width < SIZE or height < SIZE: - tex = renpy.display.draw.solid_texture(width, height, color) - else: - tex = renpy.display.draw.solid_texture(SIZE, SIZE, color) - rv.forward = Matrix2D(1.0 * SIZE / width, 0, 0, 1.0 * SIZE / height) - rv.reverse = Matrix2D(1.0 * width / SIZE, 0, 0, 1.0 * height / SIZE) - - rv.blit(tex, (0, 0)) - - return rv - -class Frame(renpy.display.core.Displayable): - """ - :doc: disp_imagelike - :args: (image, xborder, yborder, tile=False, **properties) - - A displayable that resizes an image to fill the available area, - while preserving the width and height of its borders. is often - used as the background of a window or button. - - .. figure:: frame_example.png - - Using a frame to resize an image to double its size. - - `image` - An image manipulator that will be resized by this frame. - - `left` - The size of the border on the left side. - - `top` - The size of the border on the top. - - `right` - The size of the border on the right side. If None, defaults - to `left`. - - `bottom` - The side of the border on the bottom. If None, defaults to `top`. - - `tile` - If true, tiling is used to resize sections of the image, - rather than scaling. - - :: - - # Resize the background of the text window if it's too small. - init python: - style.window.background = Frame("frame.png", 10, 10) - """ - - __version__ = 1 - - def after_upgrade(self, version): - if version < 2: - self.left = self.xborder - self.right = self.xborder - self.top = self.yborder - self.bottom = self.yborder - - def __init__(self, image, left, top, right=None, bottom=None, bilinear=True, tile=False, **properties): - super(Frame, self).__init__(**properties) - - self.image = renpy.easy.displayable(image) - self.tile = tile - - if right is None: - right = left - if bottom is None: - bottom = top - - self.left = left - self.top = top - self.right = right - self.bottom = bottom - - def render(self, width, height, st, at): - - crend = render(self.image, width, height, st, at) - - sw, sh = crend.get_size() - sw = int(sw) - sh = int(sh) - - dw = int(width) - dh = int(height) - - bw = self.left + self.right - bh = self.top + self.bottom - - xborder = min(bw, sw - 2, dw) - if xborder: - left = self.left * xborder / bw - right = self.right * xborder / bw - else: - left = 0 - right = 0 - - yborder = min(bh, sh - 2, dh) - if yborder: - top = self.top * yborder / bh - bottom = self.bottom * yborder / bh - else: - top = 0 - bottom = 0 - - if renpy.display.draw.info["renderer"] == "sw": - return self.sw_render(crend, dw, dh, left, top, right, bottom) - - def draw(x0, x1, y0, y1): - - # Compute the coordinates of the left, right, top, and - # bottom sides of the region, for both the source and - # destination surfaces. - - # left side. - if x0 >= 0: - dx0 = x0 - sx0 = x0 - else: - dx0 = dw + x0 - sx0 = sw + x0 - - # right side. - if x1 > 0: - dx1 = x1 - sx1 = x1 - else: - dx1 = dw + x1 - sx1 = sw + x1 - - # top side. - if y0 >= 0: - dy0 = y0 - sy0 = y0 - else: - dy0 = dh + y0 - sy0 = sh + y0 - - # bottom side - if y1 > 0: - dy1 = y1 - sy1 = y1 - else: - dy1 = dh + y1 - sy1 = sh + y1 - - # Quick exit. - if sx0 == sx1 or sy0 == sy1: - return - - # Compute sizes. - csw = sx1 - sx0 - csh = sy1 - sy0 - cdw = dx1 - dx0 - cdh = dy1 - dy0 - - if csw <= 0 or csh <= 0 or cdh <= 0 or cdw <= 0: - return - - # Get a subsurface. - cr = crend.subsurface((sx0, sy0, csw, csh)) - - # Scale or tile if we have to. - if csw != cdw or csh != cdh: - - if self.tile: - newcr = Render(cdw, cdh) - newcr.clipping = True - - for x in range(0, cdw, csw): - for y in range(0, cdh, csh): - newcr.blit(cr, (x, y)) - - cr = newcr - - else: - - newcr = Render(cdw, cdh) - newcr.forward = Matrix2D(1.0 * csw / cdw, 0, 0, 1.0 * csh / cdh) - newcr.reverse = Matrix2D(1.0 * cdw / csw, 0, 0, 1.0 * cdh / csh) - newcr.blit(cr, (0, 0)) - - cr = newcr - - # Blit. - rv.blit(cr, (dx0, dy0)) - return - - rv = Render(dw, dh) - - self.draw_pattern(draw, left, top, right, bottom) - - return rv - - def draw_pattern(self, draw, left, top, right, bottom): - # Top row. - if top: - - if left: - draw(0, left, 0, top) - - draw(left, -right, 0, top) - - if right: - draw(-right, 0, 0, top) - - # Middle row. - if left: - draw(0, left, top, -bottom) - - draw(left, -right, top, -bottom) - - if right: - draw(-right, 0, top, -bottom) - - # Bottom row. - if bottom: - if left: - draw(0, left, -bottom, 0) - - draw(left, -right, -bottom, 0) - - if right: - draw(-right, 0, -bottom, 0) - - - - def sw_render(self, crend, dw, dh, left, top, right, bottom): - - source = crend.render_to_texture(True) - sw, sh = source.get_size() - - dest = renpy.display.swdraw.surface(dw, dh, True) - rv = dest - - def draw(x0, x1, y0, y1): - - # Compute the coordinates of the left, right, top, and - # bottom sides of the region, for both the source and - # destination surfaces. - - # left side. - if x0 >= 0: - dx0 = x0 - sx0 = x0 - else: - dx0 = dw + x0 - sx0 = sw + x0 - - # right side. - if x1 > 0: - dx1 = x1 - sx1 = x1 - else: - dx1 = dw + x1 - sx1 = sw + x1 - - # top side. - if y0 >= 0: - dy0 = y0 - sy0 = y0 - else: - dy0 = dh + y0 - sy0 = sh + y0 - - # bottom side - if y1 > 0: - dy1 = y1 - sy1 = y1 - else: - dy1 = dh + y1 - - sy1 = sh + y1 - - # Quick exit. - if sx0 == sx1 or sy0 == sy1 or dx1 <= dx0 or dy1 <= dy0: - return - - # Compute sizes. - srcsize = (sx1 - sx0, sy1 - sy0) - dstsize = (int(dx1 - dx0), int(dy1 - dy0)) - - # Get a subsurface. - surf = source.subsurface((sx0, sy0, srcsize[0], srcsize[1])) - - # Scale or tile if we have to. - if dstsize != srcsize: - if self.tile: - tilew, tileh = srcsize - dstw, dsth = dstsize - - surf2 = renpy.display.pgrender.surface_unscaled(dstsize, surf) - - for y in range(0, dsth, tileh): - for x in range(0, dstw, tilew): - surf2.blit(surf, (x, y)) - - surf = surf2 - - else: - surf2 = renpy.display.scale.real_transform_scale(surf, dstsize) - surf = surf2 - - # Blit. - dest.blit(surf, (dx0, dy0)) - - self.draw_pattern(draw, left, top, right, bottom) - - rrv = renpy.display.render.Render(dw, dh) - rrv.blit(rv, (0, 0)) - rrv.depends_on(crend) - - # And, finish up. - return rrv - - def visit(self): - return [ self.image ] - - diff --git a/unrpyc/renpy/display/imagemap.py b/unrpyc/renpy/display/imagemap.py deleted file mode 100644 index 380bf80..0000000 --- a/unrpyc/renpy/display/imagemap.py +++ /dev/null @@ -1,233 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This file handles imagemap caching. - -import pygame -import renpy.display - -from renpy.display.render import render - -import hashlib -import os - -# A list of cache images we've already written. -cached = set() - -class ImageMapCrop(renpy.display.core.Displayable): - """ - This handles the cropping of uncached imagemap components. - """ - - def __init__(self, child, rect): - super(ImageMapCrop, self).__init__() - - self.child = child - self.rect = rect - - def visit(self): - return [ self.child ] - - def render(self, width, height, st, at): - cr = render(self.child, width, height, st, at) - return cr.subsurface(self.rect) - - -class ImageCacheCrop(renpy.display.core.Displayable): - """ - This handles the cropping of an imagemap component. - """ - - def __init__(self, cache, index): - super(ImageCacheCrop, self).__init__() - - # The cache object we're associated with. - self.cache = cache - - # The index of - self.index = index - - def visit(self): - return self.cache.visit(self.index) - - def render(self, width, height, st, at): - return self.cache.render(self.index, width, height, st, at) - -class ImageMapCache(renpy.object.Object): - - def __init__(self, enable): - self.md5 = hashlib.md5() - - # A list of (image, rect) tuples. The index in this list is used - # as a unique identifier for an ImageCacheCrop object. - self.imagerect = [ ] - - # A map from (image, rect) to ImageCacheCrop object. - self.hotspots = { } - - # A list of (width, height, index) tuples. - self.areas = [ ] - - # The image containing our children. - self.cache = None - - # A list that, for each hotspot, gives the rectangle in the cache - # image corresponding to that hotspot. - self.cache_rect = None - - # The size of the cache. - self.cache_width = None - self.cache_height = None - - self.enable = enable - - def visit(self, index): - if self.cache is not None: - return [ self.cache ] - else: - return [ self.imagerect[index][0] ] - - def crop(self, d, rect): - if not isinstance(d, renpy.display.im.ImageBase) or \ - not renpy.config.imagemap_cache or \ - not self.enable: - return ImageMapCrop(d, rect) - - key = (d, rect) - rv = self.hotspots.get(key, None) - if rv is not None: - return rv - - self.md5.update(repr(d.identity)) - self.md5.update(repr(d.identity)) - - index = len(self.imagerect) - rv = ImageCacheCrop(self, index) - - self.imagerect.append(key) - self.hotspots[key] = rv - self.areas.append((rect[2] + 2, rect[3] + 2, index)) - - return rv - - def layout(self): - self.areas.sort() - self.areas.reverse() - self.cache_rect = [ None ] * len(self.areas) - - # The width of the cache image. - width = self.areas[0][0] - - x = 0 - y = 0 - line_height = 0 - - for w, h, i in self.areas: - - if x + w > width: - y += line_height - line_height = 0 - x = 0 - - self.cache_rect[i] = (x+1, y+1, w-2, h-2) - - x += w - if line_height < h: - line_height = h - - self.cache_width = width - self.cache_height = y + line_height - - def write_cache(self, filename): - - if filename in cached: - return - - cached.add(filename) - - # If all of our dependencies are of the same age or less, - # we don't need to rebuild the cache. - - if renpy.loader.loadable(filename): - d_set = set() - mtime = 0 - - for i, rect in self.imagerect: - if i in d_set: - continue - - d_set.add(i) - mtime = max(i.get_mtime(), mtime) - - if renpy.loader.get_mtime(filename) >= mtime: - return - - fn = os.path.join(renpy.config.gamedir, filename) - dir = os.path.dirname(fn) #@ReservedAssignment - - if not os.path.exists(dir): - os.makedirs(dir) - - cache = pygame.Surface((self.cache_width, self.cache_height), pygame.SRCALPHA, 32) - - for i, (d, rect) in enumerate(self.imagerect): - x, y, _w, _h = self.cache_rect[i] - - surf = renpy.display.im.cache.get(d).subsurface(rect) - cache.blit(surf, (x, y)) - - pygame.image.save(cache, renpy.exports.fsencode(fn)) - - def finish(self): - if not self.areas: - return - - filename = "im-%s.png" % (self.md5.hexdigest()) - - if renpy.game.preferences.language: - filename = renpy.game.preferences.language + "-" + filename - - filename = "cache/" + filename - - self.md5 = None - - self.layout() - - if renpy.config.developer: - try: - self.write_cache(filename) - except: - pass - - if renpy.loader.loadable(filename): - self.cache = renpy.display.im.Image(filename) - - - def render(self, index, width, height, st, at): - if self.cache is None: - d, rect = self.imagerect[index] - return render(d, width, height, st, at).subsurface(rect) - - return render(self.cache, width, height, st, at).subsurface(self.cache_rect[index]) - - - - diff --git a/unrpyc/renpy/display/joystick.py b/unrpyc/renpy/display/joystick.py deleted file mode 100644 index c606dd9..0000000 --- a/unrpyc/renpy/display/joystick.py +++ /dev/null @@ -1,126 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This file is responsible for joystick support in Ren'Py. - -import os -import pygame - -import renpy.display - -# Do we have a joystick enabled? -enabled = False - -# The old states for each axis. -old_axis_states = { } - -def init(): - """ - Initialize the joystick system. - """ - - global enabled - - if not renpy.config.joystick: - return - - if 'RENPY_DISABLE_JOYSTICK' in os.environ: - return - - try: - pygame.joystick.init() - - for i in range(0, pygame.joystick.get_count()): - pygame.joystick.Joystick(i).init() - enabled = True - except: - if renpy.config.debug: - raise - -def event(ev): - - if not enabled: - return ev - - if ev.type == pygame.JOYAXISMOTION: - - if not renpy.display.interface.focused: - return None - - if ev.value >= 0.5: - state = "Positive" - elif ev.value <= -0.5: - state = "Negative" - else: - state = None - - oldstate = old_axis_states.get((ev.joy, ev.axis), None) - - if state == oldstate: - return None - - if oldstate: - release = "Axis %d.%d %s" % (ev.joy, ev.axis, oldstate) - else: - release = None - - old_axis_states[ev.joy, ev.axis] = state - - if state: - press = "Axis %d.%d %s" % (ev.joy, ev.axis, state) - else: - press = None - - if not press and not release: - return None - - return pygame.event.Event(renpy.display.core.JOYEVENT, - press=press, release=release) - - if ev.type == pygame.JOYBUTTONDOWN: - - if not renpy.display.interface.focused: - return None - - return pygame.event.Event(renpy.display.core.JOYEVENT, - press="Button %d.%d" % (ev.joy, ev.button), - release=None) - if ev.type == pygame.JOYBUTTONUP: - - if not renpy.display.interface.focused: - return None - - return pygame.event.Event(renpy.display.core.JOYEVENT, - press=None, - release="Button %d.%d" % (ev.joy, ev.button)) - - return ev - -class JoyBehavior(renpy.display.layout.Null): - """ - This is a behavior intended for joystick calibration. If a joystick - event occurs, this returns it as a string. - """ - - def event(self, ev, x, y, st): - if ev.type == renpy.display.core.JOYEVENT: - return ev.press - diff --git a/unrpyc/renpy/display/layout.py b/unrpyc/renpy/display/layout.py deleted file mode 100644 index e07e28d..0000000 --- a/unrpyc/renpy/display/layout.py +++ /dev/null @@ -1,1744 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This file contains classes that handle layout of displayables on -# the screen. - -from renpy.display.render import render, Render -import renpy.display - - -def scale(num, base): - """ - If num is a float, multiplies it by base and returns that. Otherwise, - returns num unchanged. - """ - - if isinstance(num, float): - return num * base - else: - return num - -class Null(renpy.display.core.Displayable): - """ - :doc: disp_imagelike - - A displayable that creates an empty box on the screen. The size - of the box is controlled by `width` and `height`. This can be used - when a displayable requires a child, but no child is suitable, or - as a spacer inside a box. - - :: - - image logo spaced = HBox("logo.png", Null(width=100), "logo.png") - - """ - - def __init__(self, width=0, height=0, **properties): - super(Null, self).__init__(**properties) - self.width = width - self.height = height - - def render(self, width, height, st, at): - rv = renpy.display.render.Render(self.width, self.height) - - if self.focusable: - rv.add_focus(self, None, None, None, None, None) - - return rv - - -class Container(renpy.display.core.Displayable): - """ - This is the base class for containers that can have one or more - children. - - @ivar children: A list giving the children that have been added to - this container, in the order that they were added in. - - @ivar child: The last child added to this container. This is also - used to access the sole child in containers that can only hold - one child. - - @ivar offsets: A list giving offsets for each of our children. - It's expected that render will set this up each time it is called. - - @ivar sizes: A list giving sizes for each of our children. It's - also expected that render will set this each time it is called. - - """ - - # We indirect all list creation through this, so that we can - # use RevertableLists if we want. - _list_type = list - - def __init__(self, *args, **properties): - - self.children = self._list_type() - self.child = None - self.offsets = self._list_type() - - for i in args: - self.add(i) - - super(Container, self).__init__(**properties) - - def set_style_prefix(self, prefix, root): - super(Container, self).set_style_prefix(prefix, root) - - for i in self.children: - i.set_style_prefix(prefix, False) - - def add(self, d): - """ - Adds a child to this container. - """ - - child = renpy.easy.displayable(d) - - self.children.append(child) - - self.child = child - self.offsets = self._list_type() - - def remove(self, d): - """ - Removes the first instance of child from this container. May - not work with all containers. - """ - - for i, c in enumerate(self.children): - if c is d: - break - else: - return - - self.children.pop(i) # W0631 - self.offsets = self._list_type() - - if self.children: - self.child = self.children[-1] - else: - self.child = None - - - def update(self): - """ - This should be called if a child is added to this - displayable outside of the render function. - """ - - renpy.display.render.invalidate(self) - - - def render(self, width, height, st, at): - - rv = Render(width, height) - self.offsets = self._list_type() - - for c in self.children: - cr = render(c, width, height, st, at) - offset = c.place(rv, 0, 0, width, height, cr) - self.offsets.append(offset) - - return rv - - - def event(self, ev, x, y, st): - - children = self.children - offsets = self.offsets - - for i in range(len(offsets) - 1, -1, -1): - - d = children[i] - xo, yo = offsets[i] - - rv = d.event(ev, x - xo, y - yo, st) - if rv is not None: - return rv - - return None - - def visit(self): - return self.children - - # These interact with the ui functions to allow use as a context - # manager. - - def __enter__(self): - - renpy.ui.context_enter(self) - return self - - def __exit__(self, exc_type, exc_val, exc_tb): - - renpy.ui.context_exit(self) - return False - - - - -def LiveComposite(size, *args, **properties): - """ - :args: disp_imagelike - - This creates a new displayable of `size`, by compositing other - displayables. `size` is a (width, height) tuple. - - The remaining positional arguments are used to place images inside - the LiveComposite. The remaining positional arguments should come - in groups of two, with the first member of each group an (x, y) - tuple, and the second member of a group is a displayable that - is composited at that position. - - Displayables are composited from back to front. - - :: - - image eileen composite = LiveComposite( - (300, 600), - (0, 0), "body.png", - (0, 0), "clothes.png", - (50, 50), "expression.png") - """ - - properties.setdefault('style', 'image_placement') - - width, height = size - - rv = Fixed(xmaximum=width, ymaximum=height, xminimum=width, yminimum=height, **properties) - - if len(args) % 2 != 0: - raise Exception("LiveComposite requires an odd number of arguments.") - - for pos, widget in zip(args[0::2], args[1::2]): - xpos, ypos = pos - rv.add(Position(renpy.easy.displayable(widget), - xpos=xpos, xanchor=0, ypos=ypos, yanchor=0)) - - return rv - -class Position(Container): - """ - Controls the placement of a displayable on the screen, using - supplied position properties. This is the non-curried form of - Position, which should be used when the user has directly created - the displayable that will be shown on the screen. - """ - - def __init__(self, child, style='image_placement', **properties): - """ - @param child: The child that is being laid out. - - @param style: The base style of this position. - - @param properties: Position properties that control where the - child of this widget is placed. - """ - - super(Position, self).__init__(style=style, **properties) - self.add(child) - - def render(self, width, height, st, at): - - surf = render(self.child, width, height, st, at) - - self.offsets = [ (0, 0) ] - - rv = renpy.display.render.Render(surf.width, surf.height) - rv.blit(surf, (0, 0)) - - return rv - - def get_placement(self): - - xpos, ypos, xanchor, yanchor, xoffset, yoffset, subpixel = self.child.get_placement() - - v = self.style.xpos - if v is not None: - xpos = v - - v = self.style.ypos - if v is not None: - ypos = v - - v = self.style.xanchor - if v is not None: - xanchor = v - - v = self.style.yanchor - if v is not None: - yanchor = v - - v = self.style.xoffset - if v is not None: - xoffset = v - - v = self.style.yoffset - if v is not None: - yoffset = v - - v = self.style.subpixel - if v is not None: - subpixel = v - - return xpos, ypos, xanchor, yanchor, xoffset, yoffset, subpixel - - -class Grid(Container): - """ - A grid is a widget that evenly allocates space to its children. - The child widgets should not be greedy, but should instead be - widgets that only use part of the space available to them. - """ - - def __init__(self, cols, rows, padding=None, - transpose=False, - style='grid', **properties): - """ - @param cols: The number of columns in this widget. - - @params rows: The number of rows in this widget. - - @params transpose: True if the grid should be transposed. - """ - - if padding is not None: - properties.setdefault('spacing', padding) - - super(Grid, self).__init__(style=style, **properties) - - cols = int(cols) - rows = int(rows) - - self.cols = cols - self.rows = rows - - self.transpose = transpose - - def render(self, width, height, st, at): - - # For convenience and speed. - padding = self.style.spacing - cols = self.cols - rows = self.rows - - if len(self.children) != cols * rows: - if len(self.children) < cols * rows: - raise Exception("Grid not completely full.") - else: - raise Exception("Grid overfull.") - - # If necessary, transpose the grid (kinda hacky, but it works here.) - if self.transpose: - self.transpose = False - - old_children = self.children[:] - - for y in range(0, rows): - for x in range(0, cols): - self.children[x + y * cols] = old_children[ y + x * rows ] - - - # Now, start the actual rendering. - - renwidth = width - renheight = height - - if self.style.xfill: - renwidth = (width - (cols - 1) * padding) / cols - if self.style.yfill: - renheight = (height - (rows - 1) * padding) / rows - - renders = [ render(i, renwidth, renheight, st, at) for i in self.children ] - sizes = [ i.get_size() for i in renders ] - - cwidth = 0 - cheight = 0 - - for w, h in sizes: - cwidth = max(cwidth, w) - cheight = max(cheight, h) - - if self.style.xfill: - cwidth = renwidth - - if self.style.yfill: - cheight = renheight - - width = cwidth * cols + padding * (cols - 1) - height = cheight * rows + padding * (rows - 1) - - rv = renpy.display.render.Render(width, height) - - self.offsets = [ ] - - for y in range(0, rows): - for x in range(0, cols): - - child = self.children[ x + y * cols ] - surf = renders[x + y * cols] - - xpos = x * (cwidth + padding) - ypos = y * (cheight + padding) - - offset = child.place(rv, xpos, ypos, cwidth, cheight, surf) - self.offsets.append(offset) - - return rv - -class IgnoreLayers(Exception): - """ - Raise this to have the event ignored by layers, but reach the - underlay. - """ - - pass - -class MultiBox(Container): - - layer_name = None - first = True - order_reverse = False - - def __init__(self, spacing=None, layout=None, style='default', **properties): - - if spacing is not None: - properties['spacing'] = spacing - - super(MultiBox, self).__init__(style=style, **properties) - - self.default_layout = layout - - # The start and animation times for children of this - # box. - self.start_times = [ ] - self.anim_times = [ ] - - # A map from layer name to the widget corresponding to - # that layer. - self.layers = None - - # The scene list for this widget. - self.scene_list = None - - def add(self, widget, start_time=None, anim_time=None): # W0221 - super(MultiBox, self).add(widget) - self.start_times.append(start_time) - self.anim_times.append(anim_time) - - def append_scene_list(self, l): - - for sle in l: - self.add(sle.displayable, sle.show_time, sle.animation_time) - - if self.scene_list is None: - self.scene_list = [ ] - - self.scene_list.extend(l) - - def render(self, width, height, st, at): - - # Do we need to adjust the child times due to our being a layer? - if self.layer_name or (self.layers is not None): - adjust_times = True - else: - adjust_times = False - - xminimum = self.style.xminimum - if xminimum is not None: - width = max(width, scale(xminimum, width)) - - yminimum = self.style.yminimum - if yminimum is not None: - height = max(height, scale(yminimum, height)) - - if self.first: - - self.first = False - - if adjust_times: - - it = renpy.game.interface.interact_time - - self.start_times = [ i or it for i in self.start_times ] - self.anim_times = [ i or it for i in self.anim_times ] - - layout = self.style.box_layout - - if layout is None: - layout = self.default_layout - - self.layout = layout # W0201 - - else: - layout = self.layout - - - # Handle time adjustment, store the results in csts and cats. - if adjust_times: - t = renpy.game.interface.frame_time - - csts = [ t - start for start in self.start_times ] - cats = [ t - anim for anim in self.anim_times ] - - else: - csts = [ st ] * len(self.children) - cats = [ at ] * len(self.children) - - offsets = [ ] - - if layout == "fixed": - - rv = None - - if self.style.order_reverse: - iterator = list(zip(reversed(self.children), reversed(csts), reversed(cats))) - else: - iterator = list(zip(self.children, csts, cats)) - - for child, cst, cat in iterator: - - surf = render(child, width, height, cst, cat) - - if rv is None: - - if self.style.fit_first: - sw, sh = surf.get_size() - width = min(width, sw) - height = min(height, sh) - - - rv = renpy.display.render.Render(width, height, layer_name=self.layer_name) - - if surf: - offset = child.place(rv, 0, 0, width, height, surf) - offsets.append(offset) - else: - offsets.append((0, 0)) - - if rv is None: - rv = renpy.display.render.Render(width, height, layer_name=self.layer_name) - - if self.style.order_reverse: - offsets.reverse() - - self.offsets = offsets - - return rv - - # If we're here, we have a box, either horizontal or vertical. Which is good, - # as we can share some code between boxes. - - - spacing = self.style.spacing - first_spacing = self.style.first_spacing - - if first_spacing is None: - first_spacing = spacing - - spacings = [ first_spacing ] + [ spacing ] * (len(self.children) - 1) - - box_wrap = self.style.box_wrap - - xfill = self.style.xfill - yfill = self.style.yfill - - # The shared height and width of the current line. The line_height must - # be 0 for a vertical box, and the line_width must be 0 for a horizontal - # box. - line_width = 0 - line_height = 0 - - # The children to layout. - children = list(self.children) - if self.style.box_reverse: - children.reverse() - spacings.reverse() - - # a list of (child, x, y, w, h, surf) tuples that are turned into - # calls to child.place(). - placements = [ ] - - # The maximum x and y. - maxx = 0 - maxy = 0 - - def layout_line(line, xfill, yfill): - """ - Lays out a single line. - - `line` a list of (child, x, y, surf) tuples. - `xfill` the amount of space to add in the x direction. - `yfill` the amount of space to add in the y direction. - """ - - xfill = max(0, xfill) - yfill = max(0, yfill) - - if line: - xperchild = xfill / len(line) - yperchild = yfill / len(line) - else: - xperchild = 0 - yperchild = 0 - - maxxout = maxx - maxyout = maxy - - for i, (child, x, y, surf) in enumerate(line): - sw, sh = surf.get_size() - sw = max(line_width, sw) - sh = max(line_height, sh) - - x += i * xperchild - y += i * yperchild - - sw += xperchild - sh += yperchild - - placements.append((child, x, y, sw, sh, surf)) - - maxxout = max(maxxout, x + sw) - maxyout = max(maxyout, y + sh) - - return maxxout, maxyout - - x = 0 - y = 0 - - full_width = False - full_height = False - - if layout == "horizontal": - - full_height = yfill - - line_height = 0 - line = [ ] - remwidth = width - - for d, padding, cst, cat in zip(children, spacings, csts, cats): - - if box_wrap: - rw = width - else: - rw = remwidth - - surf = render(d, rw, height - y, cst, cat) - sw, sh = surf.get_size() - - if box_wrap and remwidth - sw - padding <= 0 and line: - maxx, maxy = layout_line(line, remwidth if xfill else 0, 0) - - y += line_height - x = 0 - line_height = 0 - remwidth = width - line = [ ] - - - line.append((d, x, y, surf)) - line_height = max(line_height, sh) - x += sw + padding - remwidth -= (sw + padding) - - maxx, maxy = layout_line(line, remwidth if xfill else 0, 0) - - - elif layout == "vertical": - - full_width = xfill - - line_width = 0 - line = [ ] - remheight = height - - for d, padding, cst, cat in zip(children, spacings, csts, cats): - - if box_wrap: - rh = height - else: - rh = remheight - - surf = render(d, width - x, rh, cst, cat) - sw, sh = surf.get_size() - - if box_wrap and remheight - sh - padding <= 0: - maxx, maxy = layout_line(line, 0, remheight if yfill else 0) - - x += line_width - y = 0 - line_width = 0 - remheight = height - line = [ ] - - line.append((d, x, y, surf)) - line_width = max(line_width, sw) - y += sh + padding - remheight -= (sh + padding) - - maxx, maxy = layout_line(line, 0, remheight if yfill else 0) - - # Back to the common for vertical and horizontal. - - if not xfill: - width = maxx - - if not yfill: - height = maxy - - rv = renpy.display.render.Render(width, height) - - if self.style.box_reverse ^ self.style.order_reverse: - placements.reverse() - - for child, x, y, w, h, surf in placements: - if full_width: - w = width - if full_height: - h = height - - offset = child.place(rv, x, y, w, h, surf) - offsets.append(offset) - - if self.style.order_reverse: - offsets.reverse() - - self.offsets = offsets - - return rv - - - def event(self, ev, x, y, st): - - - children_offsets = list(zip(self.children, self.offsets, self.start_times)) - - if not self.style.order_reverse: - children_offsets.reverse() - - try: - - for i, (xo, yo), t in children_offsets: - - if t is None: - cst = st - else: - cst = renpy.game.interface.event_time - t - - rv = i.event(ev, x - xo, y - yo, cst) - if rv is not None: - return rv - - except IgnoreLayers: - if self.layers: - return None - else: - raise - - return None - -def Fixed(**properties): - return MultiBox(layout='fixed', **properties) - -class SizeGroup(renpy.object.Object): - - def __init__(self): - - super(SizeGroup, self).__init__() - - self.members = [ ] - self._width = None - self.computing_width = False - - def width(self, width, height, st, at): - if self._width is not None: - return self._width - - if self.computing_width: - return 0 - - self.computing_width = True - - maxwidth = 0 - - for i in self.members: - rend = renpy.display.render.render(i, width, height, st, at) - maxwidth = max(rend.width, maxwidth) - renpy.display.render.invalidate(i) - - self._width = maxwidth - self.computing_width = False - - return maxwidth - - -size_groups = dict() - -class Window(Container): - """ - A window that has padding and margins, and can place a background - behind its child. `child` is the child added to this - displayable. All other properties are as for the :ref:`Window` - screen language statement. - """ - - def __init__(self, child, style='window', **properties): - - super(Window, self).__init__(style=style, **properties) - if child is not None: - self.add(child) - - def visit(self): - return [ self.style.background ] + self.children - - def get_child(self): - return self.style.child or self.child - - def per_interact(self): - size_group = self.style.size_group - - if size_group: - group = size_groups.get(size_group, None) - if group is None: - group = size_groups[size_group] = SizeGroup() - - group.members.append(self) - - def predict_one(self): - # Child will be predicted by visiting. - - pd = renpy.display.predict.displayable - style = self.style - - pd(style.insensitive_background) - pd(style.idle_background) - pd(style.hover_background) - pd(style.selected_idle_background) - pd(style.selected_hover_background) - - pd(style.insensitive_child) - pd(style.idle_child) - pd(style.hover_child) - pd(style.selected_idle_child) - pd(style.selected_hover_child) - - pd(style.insensitive_foreground) - pd(style.idle_foreground) - pd(style.hover_foreground) - pd(style.selected_idle_foreground) - pd(style.selected_hover_foreground) - - def render(self, width, height, st, at): - - # save some typing. - style = self.style - - xminimum = scale(style.xminimum, width) - yminimum = scale(style.yminimum, height) - - size_group = self.style.size_group - if size_group and size_group in size_groups: - xminimum = max(xminimum, size_groups[size_group].width(width, height, st, at)) - - left_margin = scale(style.left_margin, width) - left_padding = scale(style.left_padding, width) - - right_margin = scale(style.right_margin, width) - right_padding = scale(style.right_padding, width) - - top_margin = scale(style.top_margin, height) - top_padding = scale(style.top_padding, height) - - bottom_margin = scale(style.bottom_margin, height) - bottom_padding = scale(style.bottom_padding, height) - - # c for combined. - cxmargin = left_margin + right_margin - cymargin = top_margin + bottom_margin - - cxpadding = left_padding + right_padding - cypadding = top_padding + bottom_padding - - child = self.get_child() - - # Render the child. - surf = render(child, - width - cxmargin - cxpadding, - height - cymargin - cypadding, - st, at) - - sw, sh = surf.get_size() - - # If we don't fill, shrink our size to fit. - - if not style.xfill: - width = max(cxmargin + cxpadding + sw, xminimum) - - if not style.yfill: - height = max(cymargin + cypadding + sh, yminimum) - - rv = renpy.display.render.Render(width, height) - - # Draw the background. The background should render at exactly the - # requested size. (That is, be a Frame or a Solid). - if style.background: - bw = width - cxmargin - bh = height - cymargin - - back = render(style.background, bw, bh, st, at) - - style.background.place(rv, left_margin, top_margin, bw, bh, back, main=False) - - offsets = child.place(rv, - left_margin + left_padding, - top_margin + top_padding, - width - cxmargin - cxpadding, - height - cymargin - cypadding, - surf) - - # Draw the foreground. The background should render at exactly the - # requested size. (That is, be a Frame or a Solid). - if style.foreground: - bw = width - cxmargin - bh = height - cymargin - - back = render(style.foreground, bw, bh, st, at) - - style.foreground.place(rv, left_margin, top_margin, bw, bh, back, main=False) - - self.offsets = [ offsets ] - - self.window_size = width, height # W0201 - - return rv - - -def dynamic_displayable_compat(st, at, expr): - child = renpy.python.py_eval(expr) - return child, None - -class DynamicDisplayable(renpy.display.core.Displayable): - """ - :doc: disp_dynamic - - A displayable that can change its child based on a Python - function, over the course of an interaction. - - `function` - A function that is called with the arguments: - - * The amount of time the displayable has been shown for. - * The amount of time any displayable with the same tag has been shown for. - * Any positional or keyword arguments supplied to DynamicDisplayable. - - and should return a (d, redraw) tuple, where: - - * `d` is a displayable to show. - * `redraw` is the amount of time to wait before calling the - function again, or None to not call the function again - before the start of the next interaction. - - `function` is called at the start of every interaction. - - As a special case, `function` may also be a python string that evaluates - to a displayable. In that case, function is run once per interaction. - - :: - - # If tooltip is not empty, shows it in a text. Otherwise, - # show Null. Checks every tenth of a second to see if the - # tooltip has been updated. - init python: - def show_tooltip(st, at): - if tooltip: - return tooltip, .1 - else: - return Null() - - image tooltipper = DynamicDisplayable(show_tooltip) - - """ - - nosave = [ 'child' ] - - def after_setstate(self): - self.child = None - - def __init__(self, function, *args, **kwargs): - - super(DynamicDisplayable, self).__init__() - self.child = None - - if isinstance(function, str): - args = ( function, ) - kwargs = { } - function = dynamic_displayable_compat - - self.predict_function = kwargs.pop("_predict_function", None) - self.function = function - self.args = args - self.kwargs = kwargs - self.st = 0 - self.at = 0 - - def visit(self): - return [ ] - - def per_interact(self): - child, _ = self.function(self.st, self.at, *self.args, **self.kwargs) - child = renpy.easy.displayable(child) - child.visit_all(lambda a : a.per_interact()) - - if child is not self.child: - renpy.display.render.redraw(self, 0) - self.child = child - - def render(self, w, h, st, at): - - self.st = st - self.at = at - - child, redraw = self.function(st, at, *self.args, **self.kwargs) - child = renpy.easy.displayable(child) - child.visit_all(lambda c : c.per_interact()) - - self.child = child - - if redraw is not None: - renpy.display.render.redraw(self, redraw) - - return renpy.display.render.render(self.child, w, h, st, at) - - def predict_one(self): - if not self.predict_function: - return - - for i in self.predict_function(*self.args, **self.kwargs): - if i is not None: - renpy.display.predict.displayable(i) - - def get_placement(self): - if not self.child: - self.per_interact() - - return self.child.get_placement() - - - def event(self, ev, x, y, st): - if self.child: - return self.child.event(ev, x, y, st) - -# This chooses the first member of switch that's being shown on the -# given layer. -def condition_switch_pick(switch): - for cond, d in switch: - if cond is None or renpy.python.py_eval(cond): - return d - - raise Exception("Switch could not choose a displayable.") - -def condition_switch_show(st, at, switch): - return condition_switch_pick(switch), None - -def condition_switch_predict(switch): - - if renpy.game.lint: - return [ d for _cond, d in switch ] - - return [ condition_switch_pick(switch) ] - -def ConditionSwitch(*args, **kwargs): - """ - :doc: disp_dynamic - - This is a displayable that changes what it is showing based on - python conditions. The positional argument should be given in - groups of two, where each group consists of: - - * A string containing a python condition. - * A displayable to use if the condition is true. - - The first true condition has its displayable shown, at least - one condition should always be true. - - :: - - image jill = ConditionSwitch( - "jill_beers > 4", "jill_drunk.png", - "True", "jill_sober.png") - """ - - kwargs.setdefault('style', 'default') - - switch = [ ] - - if len(args) % 2 != 0: - raise Exception('ConditionSwitch takes an even number of arguments') - - for cond, d in zip(args[0::2], args[1::2]): - - d = renpy.easy.displayable(d) - switch.append((cond, d)) - - rv = DynamicDisplayable(condition_switch_show, - switch, - _predict_function=condition_switch_predict) - - return Position(rv, **kwargs) - - -def ShowingSwitch(*args, **kwargs): - """ - :doc: disp_dynamic - - This is a displayable that changes what it is showing based on the - images are showing on the screen. The positional argument should - be given in groups of two, where each group consists of: - - * A string giving an image name, or None to indicate the default. - * A displayable to use if the condition is true. - - A default image should be specified. - - One use of ShowingSwitch is to have side images change depending on - the current emotion of a character. For example:: - - define e = Character("Eileen", - show_side_image=ShowingSwitch( - "eileen happy", Image("eileen_happy_side.png", xalign=1.0, yalign=1.0), - "eileen vhappy", Image("eileen_vhappy_side.png", xalign=1.0, yalign=1.0), - None, Image("eileen_happy_default.png", xalign=1.0, yalign=1.0), - ) - ) - """ - - layer = kwargs.pop('layer', 'master') - - if len(args) % 2 != 0: - raise Exception('ShowingSwitch takes an even number of positional arguments') - - condargs = [ ] - - - for name, d in zip(args[0::2], args[1::2]): - if name is not None: - if not isinstance(name, tuple): - name = tuple(name.split()) - cond = "renpy.showing(%r, layer=%r)" % (name, layer) - else: - cond = None - - - condargs.append(cond) - condargs.append(d) - - return ConditionSwitch(*condargs, **kwargs) - - -class IgnoresEvents(Container): - - def __init__(self, child, **properties): - super(IgnoresEvents, self).__init__(**properties) - self.add(child) - - def render(self, w, h, st, at): - cr = renpy.display.render.render(self.child, w, h, st, at) - cw, ch = cr.get_size() - rv = renpy.display.render.Render(cw, ch) - rv.blit(cr, (0, 0), focus=False) - - return rv - - def get_placement(self): - return self.child.get_placement() - - # Ignores events. - def event(self, ev, x, y, st): - return None - -def edgescroll_proportional(n): - """ - An edgescroll function that causes the move speed to be proportional - from the edge distance. - """ - return n - -class Viewport(Container): - - __version__ = 3 - - def after_upgrade(self, version): - if version < 1: - self.xadjustment = renpy.display.behavior.Adjustment(1, 0) - self.yadjustment = renpy.display.behavior.Adjustment(1, 0) - self.set_adjustments = False - self.mousewheel = False - self.draggable = False - self.width = 0 - self.height = 0 - - if version < 2: - self.drag_position = None - - if version < 3: - self.edge_size = False - self.edge_speed = False - self.edge_function = None - self.edge_xspeed = 0 - self.edge_yspeed = 0 - self.edge_last_st = None - - def __init__(self, - child=None, - child_size=(None, None), - offsets=(None, None), - xadjustment=None, - yadjustment=None, - set_adjustments=True, - mousewheel=False, - draggable=False, - edgescroll=None, - style='viewport', - xinitial=None, - yinitial=None, - replaces=None, - **properties): - - super(Viewport, self).__init__(style=style, **properties) - if child is not None: - self.add(child) - - if xadjustment is None: - self.xadjustment = renpy.display.behavior.Adjustment(1, 0) - else: - self.xadjustment = xadjustment - - if yadjustment is None: - self.yadjustment = renpy.display.behavior.Adjustment(1, 0) - else: - self.yadjustment = yadjustment - - - if isinstance(replaces, Viewport): - self.xadjustment.range = replaces.xadjustment.range - self.yadjustment.range = replaces.yadjustment.range - self.xadjustment.value = replaces.xadjustment.value - self.yadjustment.value = replaces.yadjustment.value - self.xoffset = replaces.xoffset - self.yoffset = replaces.yoffset - self.drag_position = replaces.drag_position - else: - self.xoffset = offsets[0] if (offsets[0] is not None) else xinitial - self.yoffset = offsets[1] if (offsets[1] is not None) else yinitial - self.drag_position = None - - if self.xadjustment.adjustable is None: - self.xadjustment.adjustable = True - - if self.yadjustment.adjustable is None: - self.yadjustment.adjustable = True - - self.set_adjustments = set_adjustments - - self.child_width, self.child_height = child_size - - self.mousewheel = mousewheel - self.draggable = draggable - - self.width = 0 - self.height = 0 - - # The speed at which we scroll in the x and y directions, in pixels - # per second. - self.edge_xspeed = 0 - self.edge_yspeed = 0 - - # The last time we edgescrolled. - self.edge_last_st = None - - if edgescroll is not None: - - # The size of the edges that trigger scrolling. - self.edge_size = edgescroll[0] - - # How far from the edge we can scroll. - self.edge_speed = edgescroll[1] - - if len(edgescroll) >= 3: - self.edge_function = edgescroll[2] - else: - self.edge_function = edgescroll_proportional - - else: - self.edge_size = 0 - self.edge_speed = 0 - self.edge_function = edgescroll_proportional - - - def per_interact(self): - self.xadjustment.register(self) - self.yadjustment.register(self) - - def render(self, width, height, st, at): - - self.width = width - self.height = height - - child_width = self.child_width or width - child_height = self.child_height or height - - surf = render(self.child, child_width, child_height, st, at) - - cw, ch = surf.get_size() - - # width = min(cw, width) - # height = min(ch, height) - - if self.set_adjustments: - self.xadjustment.range = max(cw - width, 0) - self.xadjustment.page = width - self.yadjustment.range = max(ch - height, 0) - self.yadjustment.page = height - - if self.xoffset is not None: - if isinstance(self.xoffset, int): - value = self.xoffset - else: - value = max(cw - width, 0) * self.xoffset - - self.xadjustment.value = value - - if self.yoffset is not None: - if isinstance(self.yoffset, int): - value = self.yoffset - else: - value = max(ch - height, 0) * self.yoffset - - self.yadjustment.value = value - - if self.edge_size and self.edge_last_st and (self.edge_xspeed or self.edge_yspeed): - - duration = max(st - self.edge_last_st, 0) - self.xadjustment.change(self.xadjustment.value + duration * self.edge_xspeed) - self.yadjustment.change(self.yadjustment.value + duration * self.edge_yspeed) - - self.check_edge_redraw() - - self.edge_last_st = st - - cxo = -int(self.xadjustment.value) - cyo = -int(self.yadjustment.value) - - self.offsets = [ (cxo, cyo) ] - - rv = renpy.display.render.Render(width, height) - rv.blit(surf, (cxo, cyo)) - - return rv - - def check_edge_redraw(self): - redraw = False - - if (self.edge_xspeed > 0) and (self.xadjustment.value < self.xadjustment.range): - redraw = True - if (self.edge_xspeed < 0) and (self.xadjustment.value > 0): - redraw = True - - if (self.edge_yspeed > 0) and (self.yadjustment.value < self.yadjustment.range): - redraw = True - if (self.edge_yspeed < 0) and (self.yadjustment.value > 0): - redraw = True - - if redraw: - renpy.display.render.redraw(self, 0) - - - def event(self, ev, x, y, st): - - self.xoffset = None - self.yoffset = None - - rv = super(Viewport, self).event(ev, x, y, st) - if rv is not None: - return rv - - if self.draggable and renpy.display.focus.get_grab() == self: - - oldx, oldy = self.drag_position - dx = x - oldx - dy = y - oldy - - self.xadjustment.change(self.xadjustment.value - dx) - self.yadjustment.change(self.yadjustment.value - dy) - - self.drag_position = (x, y) # W0201 - - if renpy.display.behavior.map_event(ev, 'viewport_drag_end'): - renpy.display.focus.set_grab(None) - raise renpy.display.core.IgnoreEvent() - - if not ((0 <= x < self.width) and (0 <= y <= self.height)): - return - - if self.mousewheel: - - if renpy.display.behavior.map_event(ev, 'viewport_up'): - rv = self.yadjustment.change(self.yadjustment.value - self.yadjustment.step) - if rv is not None: - return rv - else: - raise renpy.display.core.IgnoreEvent() - - if renpy.display.behavior.map_event(ev, 'viewport_down'): - rv = self.yadjustment.change(self.yadjustment.value + self.yadjustment.step) - if rv is not None: - return rv - else: - raise renpy.display.core.IgnoreEvent() - - if self.draggable: - - if renpy.display.behavior.map_event(ev, 'viewport_drag_start'): - self.drag_position = (x, y) - renpy.display.focus.set_grab(self) - raise renpy.display.core.IgnoreEvent() - - if self.edge_size: - - def speed(n, zero, one): - """ - Given a position `n`, computes the speed. The speed is 0.0 - when `n` == `zero`, 1.0 when `n` == `one`, and linearly - interpolated when between. - - Returns 0.0 when outside the bounds - in either direction. - """ - - n = 1.0 * (n - zero) / (one - zero) - if n < 0.0: - return 0.0 - if n > 1.0: - return 0.0 - - return n - - xspeed = speed(x, self.width - self.edge_size, self.width) - xspeed -= speed(x, self.edge_size, 0) - self.edge_xspeed = self.edge_speed * self.edge_function(xspeed) - - yspeed = speed(y, self.height - self.edge_size, self.height) - yspeed -= speed(y, self.edge_size, 0) - self.edge_yspeed = self.edge_speed * self.edge_function(yspeed) - - if xspeed or yspeed: - self.check_edge_redraw() - if self.edge_last_st is None: - self.edge_last_st = st - else: - self.edge_last_st = None - - return None - - def set_xoffset(self, offset): - self.xoffset = offset - renpy.display.render.redraw(self, 0) - - def set_yoffset(self, offset): - self.yoffset = offset - renpy.display.render.redraw(self, 0) - -def LiveCrop(rect, child, **properties): - """ - :doc: disp_imagelike - - This created a displayable by cropping `child` to `rect`, where - `rect` is an (x, y, width, height) tuple. :: - - image eileen cropped = LiveCrop((0, 0, 300, 300), "eileen happy") - """ - - x, y, w, h = rect - - return Viewport(child, offsets=(x, y), xmaximum=w, ymaximum=h, **properties) - -class Side(Container): - - possible_positions = set([ 'tl', 't', 'tr', 'r', 'br', 'b', 'bl', 'l', 'c']) - - def after_setstate(self): - self.sized = False - - def __init__(self, positions, style='side', **properties): - - super(Side, self).__init__(style=style, **properties) - - if isinstance(positions, str): - positions = positions.split() - - for i in positions: - if not i in Side.possible_positions: - raise Exception("Side used with impossible position '%s'." % (i,)) - - self.positions = tuple(positions) - self.sized = False - - def render(self, width, height, st, at): - - pos_d = { } - pos_i = { } - - for i, (pos, d) in enumerate(zip(self.positions, self.children)): - pos_d[pos] = d - pos_i[pos] = i - - # Figure out the size of each widget (and hence where the - # widget needs to be placed). - - if not self.sized: - self.sized = True - - # Deal with various spacings. - spacing = self.style.spacing - - def spacer(a, b, c, axis): - if (a in pos_d) or (b in pos_d) or (c in pos_d): - return spacing, axis - spacing - else: - return 0, axis - - self.left_space, width = spacer('tl', 'l', 'bl', width) # W0201 - self.right_space, width = spacer('tr', 'r', 'br', width) # W0201 - self.top_space, height = spacer('tl', 't', 'tr', height) # W0201 - self.bottom_space, height = spacer('bl', 'b', 'br', height) # W0201 - - # The sizes of the various borders. - left = 0 - right = 0 - top = 0 - bottom = 0 - cwidth = 0 - cheight = 0 - - def sizeit(pos, width, height, owidth, oheight): - if pos not in pos_d: - return owidth, oheight - - rend = render(pos_d[pos], width, height, st, at) - rv = max(owidth, rend.width), max(oheight, rend.height) - rend.kill() - return rv - - cwidth, cheight = sizeit('c', width, height, 0, 0) - cwidth, top = sizeit('t', cwidth, height, cwidth, top) - cwidth, bottom = sizeit('b', cwidth, height, cwidth, bottom) - left, cheight = sizeit('l', width, cheight, left, cheight) - right, cheight = sizeit('r', width, cheight, right, cheight) - - left, top = sizeit('tl', left, top, left, top) - left, bottom = sizeit('bl', left, bottom, left, bottom) - right, top = sizeit('tr', right, top, right, top) - right, bottom = sizeit('br', right, bottom, right, bottom) - - self.cwidth = cwidth # W0201 - self.cheight = cheight # W0201 - - self.top = top # W0201 - self.bottom = bottom # W0201 - self.left = left # W0201 - self.right = right # W0201 - - else: - cwidth = self.cwidth - cheight = self.cheight - top = self.top - bottom = self.bottom - left = self.left - right = self.right - - # Now, place everything onto the render. - - self.offsets = [ None ] * len(self.children) - - lefts = self.left_space - rights = self.right_space - tops = self.top_space - bottoms = self.bottom_space - - - cwidth = min(cwidth, width - left - lefts - right - rights) - cheight = min(cheight, height - top - tops - bottom - bottoms) - - rv = renpy.display.render.Render(left + lefts + cwidth + rights + right, - top + tops + cheight + bottoms + bottom) - - def place(pos, x, y, w, h): - - if pos not in pos_d: - return - - d = pos_d[pos] - i = pos_i[pos] - rend = render(d, w, h, st, at) - self.offsets[i] = pos_d[pos].place(rv, x, y, w, h, rend) - - col1 = 0 - col2 = left + lefts - col3 = left + lefts + cwidth + rights - - row1 = 0 - row2 = top + tops - row3 = top + tops + cheight + bottoms - - place('c', col2, row2, cwidth, cheight) - - place('t', col2, row1, cwidth, top) - place('r', col3, row2, right, cheight) - place('b', col2, row3, cwidth, bottom) - place('l', col1, row2, left, cheight) - - place('tl', col1, row1, left, top) - place('tr', col3, row1, right, top) - place('br', col3, row3, right, bottom) - place('bl', col1, row3, left, bottom) - - return rv - -class Alpha(renpy.display.core.Displayable): - def __init__(self, start, end, time, child=None, repeat=False, bounce=False, - anim_timebase=False, time_warp=None, **properties): - - super(Alpha, self).__init__(**properties) - - self.start = start - self.end = end - self.time = time - self.child = renpy.easy.displayable(child) - self.repeat = repeat - self.anim_timebase = anim_timebase - self.time_warp = time_warp - - def visit(self): - return [ self.child ] - - def render(self, height, width, st, at): - if self.anim_timebase: - t = at - else: - t = st - - if self.time: - done = min(t / self.time, 1.0) - else: - done = 1.0 - - if renpy.game.less_updates: - done = 1.0 - elif self.repeat: - done = done % 1.0 - renpy.display.render.redraw(self, 0) - elif done != 1.0: - renpy.display.render.redraw(self, 0) - - if self.time_warp: - done = self.time_warp(done) - - alpha = self.start + done * (self.end - self.start) - - rend = renpy.display.render.render(self.child, height, width, st, at) - - w, h = rend.get_size() - rv = renpy.display.render.Render(w, h) - rv.blit(rend, (0, 0)) - rv.alpha = alpha - - return rv - - -class AdjustTimes(Container): - - def __init__(self, child, start_time, anim_time, **properties): - super(AdjustTimes, self).__init__(**properties) - - self.start_time = start_time - self.anim_time = anim_time - - self.add(child) - - def render(self, w, h, st, at): - - if self.start_time is None: - self.start_time = renpy.game.interface.frame_time - - if self.anim_time is None: - self.anim_time = renpy.game.interface.frame_time - - st = renpy.game.interface.frame_time - self.start_time - at = renpy.game.interface.frame_time - self.anim_time - - cr = renpy.display.render.render(self.child, w, h, st, at) - cw, ch = cr.get_size() - rv = renpy.display.render.Render(cw, ch) - rv.blit(cr, (0, 0)) - - self.offsets = [ (0, 0) ] - - return rv - - def get_placement(self): - return self.child.get_placement() - - -class LiveTile(Container): - """ - :doc: disp_imagelike - - Tiles `child` until it fills the area allocated to this displayable. - - :: - - image bg tile = LiveTile("bg.png") - - """ - - def __init__(self, child, style='tile', **properties): - super(LiveTile, self).__init__(style=style, **properties) - - self.add(child) - - def render(self, width, height, st, at): - - cr = renpy.display.render.render(self.child, width, height, st, at) - cw, ch = cr.get_size() - rv = renpy.display.render.Render(width, height) - - width = int(width) - height = int(height) - cw = int(cw) - ch = int(ch) - - for y in range(0, height, ch): - for x in range(0, width, cw): - rv.blit(cr, (x, y), focus=False) - - return rv diff --git a/unrpyc/renpy/display/minigame.py b/unrpyc/renpy/display/minigame.py deleted file mode 100644 index 7469922..0000000 --- a/unrpyc/renpy/display/minigame.py +++ /dev/null @@ -1,25 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - - -def Minigame(*args, **kwargs): - raise Exception("Minigame is no longer implemented.") - diff --git a/unrpyc/renpy/display/module.py b/unrpyc/renpy/display/module.py deleted file mode 100644 index 1bf66e0..0000000 --- a/unrpyc/renpy/display/module.py +++ /dev/null @@ -1,275 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This file mediates access to the _renpy module, which is a C module that -# allows us to enhance the feature set of pygame in a renpy specific way. - -VERSION = (6, 12, 0) - -import renpy.display -import pygame; pygame # prevents pyflakes warning. - -import sys - -try: - import _renpy - version = _renpy.version() - - if version != VERSION: - print("Found Ren'Py module version %s, while expecting %s." % ( - ".".join(str(i) for i in version), - ".".join(str(i) for i in VERSION), - )) - - print("Trying to run anyway, but you should expect errors.", file=sys.stderr) - -except: - print("The _renpy module was not found. Please read module/README.txt for", file=sys.stderr) - print("more information.", file=sys.stderr) - - sys.exit(-1) - -def convert_and_call(function, src, dst, *args): - """ - This calls the function with the source and destination - surface. The surfaces must have the same alpha. - - If the surfaces are not 24 or 32 bits per pixel, or don't have the - same format, they are converted and then converted back. - """ - - # Now that all surfaces are 32bpp, this function doesn't do much - # of anything anymore. - - if (dst.get_masks()[3] != 0) != (src.get_masks()[3] != 0): - raise Exception("Surface alphas do not match.") - - function(src, dst, *args) - - -def pixellate(src, dst, avgwidth, avgheight, outwidth, outheight): - """ - This pixellates the source surface. First, every pixel in the - source surface is projected onto a virtual surface, such that - the average value of every avgwidth x avgheight pixels becomes - one virtual pixel. It then gets projected back onto the - destination surface at a ratio of one virtual pixel to every - outwidth x outheight destination pixels. - - If either src or dst is not a 24 or 32 bit surface, they are - converted... but that may be a significant performance hit. - - The two surfaces must either have the same alpha or no alpha. - """ - - convert_and_call(_renpy.pixellate, - src, dst, - avgwidth, avgheight, - outwidth, outheight) - - -def scale(s, size): - """ - Scales down the supplied pygame surface by the given X and Y - factors. - - Always works, but may not be high quality. - """ - - d = renpy.display.pgrender.surface(size, True) - - bilinear_scale(s, d) - - return d - - -# What we have here are a pair of tables mapping masks to byte offsets -# for 24 and 32 bpp modes. We represent 0xff000000 as positive and negative -# numbers so that it doesn't yield a warning, and so that it works on -# 32 and 64 bit platforms. -if sys.byteorder == 'big': - bo32 = { 255 : 3, 65280 : 2, 16711680 : 1, 4278190080 : 0, -16777216 : 0, } -else: - bo32 = { 255 : 0, 65280 : 1, 16711680 : 2, 4278190080 : 3, -16777216 : 3, } - -bo_cache = None - -def byte_offset(src): - """ - Given the surface src, returns a 4-tuple giving the byte offsets - for the red, green, blue, and alpha components of the pixels in - the surface. If a component doesn't exist, None is returned. - """ - - global bo_cache - - if bo_cache is None: - bo_cache = [ bo32[i] for i in src.get_masks() ] - - return bo_cache - -def endian_order(src, r, g, b, a): - - if bo_cache is None: - byte_offset(src) - - rv = [ a, a, a, a ] - - for i, index_i in zip((r, g, b, a), bo_cache): - rv[index_i] = i - - return rv - - - -def linmap(src, dst, rmap, gmap, bmap, amap): - """ - This maps the colors between two surfaces. The various map - parameters should be fixed-point integers, with 1.0 == 256. - """ - - convert_and_call(_renpy.linmap, - src, dst, - *endian_order(dst, rmap, gmap, bmap, amap)) - - -save_png = _renpy.save_png - -def map(src, dst, rmap, gmap, bmap, amap): #@ReservedAssignment - """ - This maps the colors between two surfaces. The various map - parameters must be 256 character long strings, with the value - of a character at a given offset being what a particular pixel - component value is mapped to. - """ - - convert_and_call(_renpy.map, - src, dst, - *endian_order(dst, rmap, gmap, bmap, amap)) - - - -def twomap(src, dst, white, black): - """ - Given colors for white and black, linearly maps things - appropriately, taking the alpha channel from white. - """ - - wr = white[0] - wg = white[1] - wb = white[2] - wa = white[3] - - br = black[0] - bg = black[1] - bb = black[2] - - ramp = renpy.display.im.ramp - - if br == 0 and bg == 0 and bb == 0: - linmap(src, dst, - wr + 1, - wg + 1, - wb + 1, - wa + 1) - else: - list(map(src, dst, - ramp(br, wr), - ramp(bg, wg), - ramp(bb, wb), - ramp(0, wa))) - - -def alpha_munge(src, dst, amap): - """ - This samples the red channel from src, maps it through amap, and - place it into the alpha channel of amap. - """ - - if src.get_size() != dst.get_size(): - return - - red = byte_offset(src)[0] - alpha = byte_offset(dst)[3] - - if red is not None and alpha is not None: - _renpy.alpha_munge(src, dst, red, alpha, amap) - - -def bilinear_scale(src, dst, sx=0, sy=0, sw=None, sh=None, dx=0, dy=0, dw=None, dh=None, precise=0): - - if sw is None: - sw, sh = src.get_size() - if dw is None: - dw, dh = dst.get_size() - - while True: - - if sw <= dw * 2 and sh <= dh * 2: - break - - nsw = max(sw / 2, dw) - nsh = max(sh / 2, dh) - - nsrc = renpy.display.pgrender.surface((nsw, nsh), src.get_masks()[3]) - - _renpy.bilinear(src, nsrc, sx, sy, sw, sh, precise=precise) - - sx = 0 - sy = 0 - sw = nsw - sh = nsh - src = nsrc - - _renpy.bilinear(src, dst, sx, sy, sw, sh, dx, dy, dw, dh, precise=precise) - - -transform = _renpy.transform - -# Note: Blend requires all surfaces to be the same size. -blend = _renpy.blend - -def imageblend(a, b, dst, img, amap): - alpha = byte_offset(img)[3] - _renpy.imageblend(a, b, dst, img, alpha, amap) - - -def colormatrix(src, dst, matrix): - c = [ matrix[0:5], matrix[5:10], matrix[10:15], matrix[15:20] ] - offs = byte_offset(src) - - o = [ None ] * 4 - for i in range(0, 4): - o[offs[i]] = i - - _renpy.colormatrix(src, dst, - c[o[0]][o[0]], c[o[0]][o[1]], c[o[0]][o[2]], c[o[0]][o[3]], c[o[0]][4], - c[o[1]][o[0]], c[o[1]][o[1]], c[o[1]][o[2]], c[o[1]][o[3]], c[o[1]][4], - c[o[2]][o[0]], c[o[2]][o[1]], c[o[2]][o[2]], c[o[2]][o[3]], c[o[2]][4], - c[o[3]][o[0]], c[o[3]][o[1]], c[o[3]][o[2]], c[o[3]][o[3]], c[o[3]][4]) - - -def subpixel(src, dst, x, y): - - shift = src.get_shifts()[3] - _renpy.subpixel(src, dst, x, y, shift) - - diff --git a/unrpyc/renpy/display/motion.py b/unrpyc/renpy/display/motion.py deleted file mode 100644 index 1c9d667..0000000 --- a/unrpyc/renpy/display/motion.py +++ /dev/null @@ -1,1526 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This file contains displayables that move, zoom, rotate, or otherwise -# transform displayables. (As well as displayables that support them.) -import math -import types #@UnresolvedImport - -import renpy.display #@UnusedImport -from renpy.display.render import render -from renpy.display.layout import Container - -import renpy.display.accelerator - -# The null object that's used if we don't have a defined child. -null = None - -def get_null(): - global null - - if null is None: - null = renpy.display.layout.Null() - - return null - -# Convert a position from cartesian to polar coordinates. -def cartesian_to_polar(x, y, xaround, yaround): - """ - Converts cartesian coordinates to polar coordinates. - """ - - dx = x - xaround - dy = y - yaround - - radius = math.hypot(dx, dy) - angle = math.atan2(dx, -dy) / math.pi * 180 - - if angle < 0: - angle += 360 - - return angle, radius - -def polar_to_cartesian(angle, radius, xaround, yaround): - """ - Converts polart coordinates to cartesian coordinates. - """ - - angle = angle * math.pi / 180 - - dx = radius * math.sin(angle) - dy = -radius * math.cos(angle) - - x = type(xaround)(xaround + dx) - y = type(yaround)(yaround + dy) - - return x, y - -def first_not_none(*args): - """ - Returns the first argument that is not None. - """ - - for i in args: - if i is not None: - return i - return i - - -class TransformState(renpy.object.Object): - - xoffset = None - yoffset = None - default_xpos = None - default_ypos = None - default_xanchor = None - default_yanchor = None - default_xoffset = None - default_yoffset = None - transform_anchor = False - - def __init__(self): # W0231 - self.alpha = 1 - self.rotate = None - self.rotate_pad = True - self.transform_anchor = False - self.zoom = 1 - self.xzoom = 1 - self.yzoom = 1 - - self.xpos = None - self.ypos = None - self.xanchor = None - self.yanchor = None - self.xoffset = 0 - self.yoffset = 0 - - self.xaround = 0.0 - self.yaround = 0.0 - self.xanchoraround = 0.0 - self.yanchoraround = 0.0 - - self.subpixel = False - - self.crop = None - self.corner1 = None - self.corner2 = None - self.size = None - - self.delay = 0 - - # Note: When adding a new property, we need to add it to: - # - take_state - # - diff - # - renpy.atl.PROPERTIES - # - Proxies in Transform - - # Default values for various properties, taken from our - # parent. - self.default_xpos = None - self.default_ypos = None - self.default_xanchor = None - self.default_yanchor = None - - def take_state(self, ts): - - self.alpha = ts.alpha - self.rotate = ts.rotate - self.rotate_pad = ts.rotate_pad - self.transform_anchor = ts.transform_anchor - self.zoom = ts.zoom - self.xzoom = ts.xzoom - self.yzoom = ts.yzoom - - self.xaround = ts.xaround - self.yaround = ts.yaround - self.xanchoraround = ts.xanchoraround - self.yanchoraround = ts.yanchoraround - - self.subpixel = ts.subpixel - - self.crop = ts.crop - self.corner1 = ts.corner1 - self.corner2 = ts.corner2 - self.size = ts.size - - # Take the computed position properties, not the - # raw ones. - (self.default_xpos, - self.default_ypos, - self.default_xanchor, - self.default_yanchor, - self.xoffset, - self.yoffset, - self.subpixel) = ts.get_placement() - - # Returns a dict, with p -> (old, new) where p is a property that - # has changed between this object and the new object. - def diff(self, newts): - - rv = { } - - def diff2(prop, new, old): - if new != old: - rv[prop] = (old, new) - - def diff4(prop, new, default_new, old, default_old): - if new is None: - new_value = default_new - else: - new_value = new - - if old is None: - old_value = default_old - else: - old_value = old - - if new_value != old_value: - rv[prop] = (old_value, new_value) - - diff2("alpha", newts.alpha, self.alpha) - diff2("rotate", newts.rotate, self.rotate) - diff2("rotate_pad", newts.rotate_pad, self.rotate_pad) - diff2("transform_anchor", newts.transform_anchor, self.transform_anchor) - diff2("zoom", newts.zoom, self.zoom) - diff2("xzoom", newts.xzoom, self.xzoom) - diff2("yzoom", newts.yzoom, self.yzoom) - - diff2("xaround", newts.xaround, self.xaround) - diff2("yaround", newts.yaround, self.yaround) - diff2("xanchoraround", newts.xanchoraround, self.xanchoraround) - diff2("yanchoraround", newts.yanchoraround, self.yanchoraround) - - diff2("subpixel", newts.subpixel, self.subpixel) - - diff2("crop", newts.crop, self.crop) - diff2("corner1", newts.corner1, self.corner1) - diff2("corner2", newts.corner2, self.corner2) - diff2("size", newts.size, self.size) - - diff4("xpos", newts.xpos, newts.default_xpos, self.xpos, self.default_xpos) - - diff4("xanchor", newts.xanchor, newts.default_xanchor, self.xanchor, self.default_xanchor) - diff2("xoffset", newts.xoffset, self.xoffset) - - diff4("ypos", newts.ypos, newts.default_ypos, self.ypos, self.default_ypos) - diff4("yanchor", newts.yanchor, newts.default_yanchor, self.yanchor, self.default_yanchor) - diff2("yoffset", newts.yoffset, self.yoffset) - - return rv - - def get_placement(self, cxoffset=0, cyoffset=0): - - return ( - first_not_none(self.xpos, self.default_xpos), - first_not_none(self.ypos, self.default_ypos), - first_not_none(self.xanchor, self.default_xanchor), - first_not_none(self.yanchor, self.default_yanchor), - self.xoffset + cxoffset, - self.yoffset + cyoffset, - self.subpixel, - ) - - # These update various properties. - def get_xalign(self): - return self.xpos - - def set_xalign(self, v): - self.xpos = v - self.xanchor = v - - xalign = property(get_xalign, set_xalign) - - def get_yalign(self): - return self.ypos - - def set_yalign(self, v): - self.ypos = v - self.yanchor = v - - yalign = property(get_yalign, set_yalign) - - def get_around(self): - return (self.xaround, self.yaround) - - def set_around(self, value): - self.xaround, self.yaround = value - self.xanchoraround, self.yanchoraround = None, None - - def set_alignaround(self, value): - self.xaround, self.yaround = value - self.xanchoraround, self.yanchoraround = value - - around = property(get_around, set_around) - alignaround = property(get_around, set_alignaround) - - def get_angle(self): - xpos = first_not_none(self.xpos, self.default_xpos, 0) - ypos = first_not_none(self.ypos, self.default_ypos, 0) - angle, _radius = cartesian_to_polar(xpos, ypos, self.xaround, self.yaround) - return angle - - def get_radius(self): - xpos = first_not_none(self.xpos, self.default_xpos, 0) - ypos = first_not_none(self.ypos, self.default_ypos, 0) - _angle, radius = cartesian_to_polar(xpos, ypos, self.xaround, self.yaround) - return radius - - def set_angle(self, value): - xpos = first_not_none(self.xpos, self.default_xpos, 0) - ypos = first_not_none(self.ypos, self.default_ypos, 0) - _angle, radius = cartesian_to_polar(xpos, ypos, self.xaround, self.yaround) - angle = value - self.xpos, self.ypos = polar_to_cartesian(angle, radius, self.xaround, self.yaround) - - if self.xanchoraround: - self.xanchor, self.yanchor = polar_to_cartesian(angle, radius, self.xaround, self.yaround) - - def set_radius(self, value): - xpos = first_not_none(self.xpos, self.default_xpos, 0) - ypos = first_not_none(self.ypos, self.default_ypos, 0) - angle, _radius = cartesian_to_polar(xpos, ypos, self.xaround, self.yaround) - radius = value - self.xpos, self.ypos = polar_to_cartesian(angle, radius, self.xaround, self.yaround) - - if self.xanchoraround: - self.xanchor, self.yanchor = polar_to_cartesian(angle, radius, self.xaround, self.yaround) - - angle = property(get_angle, set_angle) - radius = property(get_radius, set_radius) - - def get_pos(self): - return self.xpos, self.ypos - - def set_pos(self, value): - self.xpos, self.ypos = value - - pos = property(get_pos, set_pos) - - def get_anchor(self): - return self.xanchor, self.yanchor - - def set_anchor(self, value): - self.xanchor, self.yanchor = value - - anchor = property(get_anchor, set_anchor) - - def get_align(self): - return self.xpos, self.ypos - - def set_align(self, value): - self.xanchor, self.yanchor = value - self.xpos, self.ypos = value - - align = property(get_align, set_align) - - def get_offset(self): - return self.xoffset, self.yoffset - - def set_offset(self, value): - self.xoffset, self.yoffset = value - - offset = property(get_offset, set_offset) - - def set_xcenter(self, value): - self.xpos = value - self.xanchor = 0.5 - - def get_xcenter(self): - return self.xpos - - def set_ycenter(self, value): - self.ypos = value - self.yanchor = 0.5 - - def get_ycenter(self): - return self.ypos - - xcenter = property(get_xcenter, set_xcenter) - ycenter = property(get_ycenter, set_ycenter) - -class Proxy(object): - """ - This class proxies a field from the transform to its state. - """ - - def __init__(self, name): - self.name = name - - def __get__(self, instance, owner): - return getattr(instance.state, self.name) - - def __set__(self, instance, value): - return setattr(instance.state, self.name, value) - -class Transform(Container): - """ - Documented in sphinx, because we can't scan this object. - """ - - __version__ = 5 - transform_event_responder = True - - # Proxying things over to our state. - alpha = Proxy("alpha") - rotate = Proxy("rotate") - rotate_pad = Proxy("rotate_pad") - transform_anchor = Proxy("rotate_pad") - zoom = Proxy("zoom") - xzoom = Proxy("xzoom") - yzoom = Proxy("yzoom") - - xpos = Proxy("xpos") - ypos = Proxy("ypos") - xanchor = Proxy("xanchor") - yanchor = Proxy("yanchor") - - xalign = Proxy("xalign") - yalign = Proxy("yalign") - - around = Proxy("around") - alignaround = Proxy("alignaround") - angle = Proxy("angle") - radius = Proxy("radius") - - xaround = Proxy("xaround") - yaround = Proxy("yaround") - xanchoraround = Proxy("xanchoraround") - yanchoraround = Proxy("yanchoraround") - - pos = Proxy("pos") - anchor = Proxy("anchor") - align = Proxy("align") - - crop = Proxy("crop") - corner1 = Proxy("corner1") - corner2 = Proxy("corner2") - size = Proxy("size") - - delay = Proxy("delay") - - xoffset = Proxy("xoffset") - yoffset = Proxy("yoffset") - offset = Proxy("offset") - - subpixel = Proxy("subpixel") - - xcenter = Proxy("xcenter") - ycenter = Proxy("ycenter") - - def after_upgrade(self, version): - - if version < 1: - self.active = False - self.state = TransformState() - - self.state.xpos = self.xpos or 0 - self.state.ypos = self.ypos or 0 - self.state.xanchor = self.xanchor or 0 - self.state.yanchor = self.yanchor or 0 - self.state.alpha = self.alpha - self.state.rotate = self.rotate - self.state.zoom = self.zoom - self.state.xzoom = self.xzoom - self.state.yzoom = self.yzoom - - self.hide_request = False - self.hide_response = True - - if version < 2: - self.st = 0 - self.at = 0 - - if version < 3: - self.st_offset = 0 - self.at_offset = 0 - self.child_st_base = 0 - - if version < 4: - self.style_arg = 'transform' - - if version < 5: - self.replaced_request = False - self.replaced_response = True - - DEFAULT_ARGUMENTS = { - "selected_activate" : { }, - "selected_hover" : { }, - "selected_idle" : { }, - "selected_insensitive" : { }, - "activate" : { }, - "hover" : { }, - "idle" : { }, - "insensitive" : { }, - "" : { }, - } - - # Compatibility with old versions of the class. - active = False - children = False - arguments = DEFAULT_ARGUMENTS - - def __init__(self, - child=None, - function=None, - - style='transform', - focus=None, - default=False, - - **kwargs): - - self.kwargs = kwargs - self.style_arg = style - - super(Transform, self).__init__(style=style, focus=focus, default=default) - - self.function = function - - child = renpy.easy.displayable_or_none(child) - if child is not None: - self.add(child) - - self.state = TransformState() - - self.arguments = dict((k, {}) for k in self.DEFAULT_ARGUMENTS) - - # Split up the keyword arguments. - for k, v in kwargs.items(): - if "_" in k: - prefix, prop = k.rsplit("_", 1) - else: - prefix = "" - prop = k - - if prefix not in self.arguments: - raise Exception("Unknown transform property prefix: %r" % prefix) - - if prop not in renpy.atl.PROPERTIES: - raise Exception("Unknown transform property: %r") - - self.arguments[prefix][prop] = v - - - # Apply the keyword arguments. - for k, v in kwargs.items(): - setattr(self.state, k, v) - - # This is the matrix transforming our coordinates into child coordinates. - self.forward = None - - # Have we called the function at least once? - self.active = False - - # Have we been requested to hide? - self.hide_request = False - - # True if it's okay for us to hide. - self.hide_response = True - - # Have we been requested to replaced? - self.replaced_request = False - - # True if it's okay for us to replaced. - self.replaced_response = True - - self.st = 0 - self.at = 0 - self.st_offset = 0 - self.at_offset = 0 - - self.child_st_base = 0 - - def visit(self): - if self.child is None: - return [ ] - else: - return [ self.child ] - - # The default function chooses entries from self.arguments that match - # the style prefix, and applies them to the state. - def default_function(self, state, st, at): - - prefix = self.style.prefix.strip("_") - prefixes = [ ] - - while prefix: - prefixes.insert(0, prefix) - _, _, prefix = prefix.partition("_") - - prefixes.insert(0, "") - - for i in prefixes: - for k, v in self.arguments[i].items(): - setattr(state, k, v) - - return None - - def set_transform_event(self, event): - if self.child is not None: - self.child.set_transform_event(event) - - super(Transform, self).set_transform_event(event) - - - def take_state(self, t): - """ - Takes the transformation state from object t into this object. - """ - - self.state.take_state(t.state) - - # The arguments will be applied when the default function is - # called. - - - def take_execution_state(self, t): - """ - Takes the execution state from object t into this object. This is - overridden by renpy.atl.TransformBase. - """ - - self.hide_request = t.hide_request - self.replaced_request = t.replaced_request - - self.state.xpos = t.state.xpos - self.state.ypos = t.state.ypos - self.state.xanchor = t.state.xanchor - self.state.yanchor = t.state.yanchor - - if isinstance(self.child, Transform) and isinstance(t.child, Transform): - self.child.take_execution_state(t.child) - - - def copy(self): - """ - Makes a copy of this transform. - """ - - d = self() - d.kwargs = { } - d.take_state(self) - d.take_execution_state(self) - d.st = self.st - d.at = self.at - - return d - - def _change_transform_child(self, child): - rv = self.copy() - - if self.child is not None: - rv.set_child(self.child._change_transform_child(child)) - - return rv - - def _hide(self, st, at, kind): - - if not self.child: - return None - - if not (self.hide_request or self.replaced_request): - d = self.copy() - else: - d = self - - d.st_offset = self.st_offset - d.at_offset = self.at_offset - - if kind == "hide": - d.hide_request = True - else: - d.replaced_request = True - - d.hide_response = True - d.replaced_response = True - - if d.function is not None: - d.function(d, st + d.st_offset, at + d.at_offset) - - new_child = d.child._hide(st, at, kind) - - if new_child is not None: - d.child = new_child - d.hide_response = False - d.replaced_response = False - - if (not d.hide_response) or (not d.replaced_response): - renpy.display.render.redraw(d, 0) - return d - - return None - - def set_child(self, child): - - child = renpy.easy.displayable(child) - - self.child = child - self.child_st_base = self.st - - child.per_interact() - - renpy.display.render.redraw(self, 0) - - def update_state(self): - """ - This updates the state to that at self.st, self.at. - """ - - # If we have to, call the function that updates this transform. - if self.function is not None: - fr = self.function(self, self.st, self.at) - else: - fr = self.default_function(self, self.st, self.at) - - # Order a redraw, if necessary. - if fr is not None: - renpy.display.render.redraw(self, fr) - - state = self.state - - self.active = True - - # Use non-None elements of the child placement as defaults. - child = self.child - if child is not None and renpy.config.transform_uses_child_position: - - pos = child.get_placement() - - if pos[0] is not None: - state.default_xpos = pos[0] - if pos[2] is not None: - state.default_xanchor = pos[2] - if pos[1] is not None: - state.default_ypos = pos[1] - if pos[3] is not None: - state.default_yanchor = pos[3] - - state.subpixel |= pos[6] - - # The render method is now defined in accelerator.pyx. - - def event(self, ev, x, y, st): - - if self.hide_request: - return None - - children = self.children - offsets = self.offsets - - if not offsets: - return None - - for i in range(len(self.children)-1, -1, -1): - - d = children[i] - xo, yo = offsets[i] - - cx = x - xo - cy = y - yo - - # Transform screen coordinates to child coordinates. - cx, cy = self.forward.transform(cx, cy) - - rv = d.event(ev, cx, cy, st) - if rv is not None: - return rv - - return None - - def __call__(self, child=None, take_state=True): - - if child is None: - child = self.child - - # If we don't have a child for some reason, set it to null. - if child is None: - child = get_null() - - rv = Transform( - child=child, - function=self.function, - style=self.style_arg, - **self.kwargs) - - rv.take_state(self) - - return rv - - def get_placement(self): - - if not self.active: - self.update_state() - - if self.child is not None: - _cxpos, _cypos, _cxanchor, _cyanchor, cxoffset, cyoffset, _csubpixel = self.child.get_placement() - else: - cxoffset = 0 - cyoffset = 0 - - cxoffset = cxoffset or 0 - cyoffset = cyoffset or 0 - - rv = self.state.get_placement(cxoffset, cyoffset) - - if self.state.transform_anchor: - - xpos, ypos, xanchor, yanchor, xoffset, yoffset, subpixel = rv - if (xanchor is not None) and (yanchor is not None): - - cw, ch = self.child_size - rw, rh = self.render_size - - if isinstance(xanchor, float): - xanchor *= cw - if isinstance(yanchor, float): - yanchor *= ch - - xanchor -= cw / 2.0 - yanchor -= ch / 2.0 - - xanchor, yanchor = self.reverse.transform(xanchor, yanchor) - - xanchor += rw / 2.0 - yanchor += rh / 2.0 - - xanchor = renpy.display.core.absolute(xanchor) - yanchor = renpy.display.core.absolute(yanchor) - - rv = (xpos, ypos, xanchor, yanchor, xoffset, yoffset, subpixel) - - return rv - - def update(self): - """ - This should be called when a transform property field is updated outside - of the callback method, to ensure that the change takes effect. - """ - - renpy.display.render.invalidate(self) - - def parameterize(self, name, parameters): - if parameters: - raise Exception("Image '%s' can't take parameters '%s'. (Perhaps you got the name wrong?)" % - (' '.join(name), ' '.join(parameters))) - - # Note the call here. - return self() - - def _show(self): - self.update_state() - -Transform.render = types.MethodType(renpy.display.accelerator.transform_render, None, Transform) - -class ATLTransform(renpy.atl.ATLTransformBase, Transform): - - def __init__(self, atl, child=None, context={}, parameters=None, **properties): - renpy.atl.ATLTransformBase.__init__(self, atl, context, parameters) - Transform.__init__(self, child=child, function=self.execute, **properties) - - self.raw_child = self.child - - def _show(self): - super(ATLTransform, self)._show() - self.execute(self, self.st, self.at) - - -class Motion(Container): - """ - This is used to move a child displayable around the screen. It - works by supplying a time value to a user-supplied function, - which is in turn expected to return a pair giving the x and y - location of the upper-left-hand corner of the child, or a - 4-tuple giving that and the xanchor and yanchor of the child. - - The time value is a floating point number that ranges from 0 to - 1. If repeat is True, then the motion repeats every period - sections. (Otherwise, it stops.) If bounce is true, the - time value varies from 0 to 1 to 0 again. - - The function supplied needs to be pickleable, which means it needs - to be defined as a name in an init block. It cannot be a lambda or - anonymous inner function. If you can get away with using Pan or - Move, use them instead. - - Please note that floats and ints are interpreted as for xpos and - ypos, with floats being considered fractions of the screen. - """ - - def __init__(self, function, period, child=None, new_widget=None, old_widget=None, repeat=False, bounce=False, delay=None, anim_timebase=False, tag_start=None, time_warp=None, add_sizes=False, style='motion', **properties): - """ - @param child: The child displayable. - - @param new_widget: If child is None, it is set to new_widget, - so that we can speak the transition protocol. - - @param old_widget: Ignored, for compatibility with the transition protocol. - - @param function: A function that takes a floating point value and returns - an xpos, ypos tuple. - - @param period: The amount of time it takes to go through one cycle, in seconds. - - @param repeat: Should we repeat after a period is up? - - @param bounce: Should we bounce? - - @param delay: How long this motion should take. If repeat is None, defaults to period. - - @param anim_timebase: If True, use the animation timebase rather than the shown timebase. - - @param time_warp: If not None, this is a function that takes a - fraction of the period (between 0.0 and 1.0), and returns a - new fraction of the period. Use this to warp time, applying - acceleration and deceleration to motions. - - This can also be used as a transition. When used as a - transition, the motion is applied to the new_widget for delay - seconds. - """ - - if child is None: - child = new_widget - - if delay is None and not repeat: - delay = period - - super(Motion, self).__init__(style=style, **properties) - - if child is not None: - self.add(child) - - self.function = function - self.period = period - self.repeat = repeat - self.bounce = bounce - self.delay = delay - self.anim_timebase = anim_timebase - self.time_warp = time_warp - self.add_sizes = add_sizes - - self.position = None - - - def get_placement(self): - - if self.position is None: - return super(Motion, self).get_placement() - else: - return self.position + (self.style.xoffset, self.style.yoffset, self.style.subpixel) - - def render(self, width, height, st, at): - - if self.anim_timebase: - t = at - else: - t = st - - if renpy.game.less_updates: - if self.delay: - t = self.delay - if self.repeat: - t = t % self.period - else: - t = self.period - elif self.delay and t >= self.delay: - t = self.delay - if self.repeat: - t = t % self.period - elif self.repeat: - t = t % self.period - renpy.display.render.redraw(self, 0) - else: - if t > self.period: - t = self.period - else: - renpy.display.render.redraw(self, 0) - - if self.period > 0: - t /= self.period - else: - t = 1 - - if self.time_warp: - t = self.time_warp(t) - - if self.bounce: - t = t * 2 - if t > 1.0: - t = 2.0 - t - - child = render(self.child, width, height, st, at) - cw, ch = child.get_size() - - if self.add_sizes: - res = self.function(t, (width, height, cw, ch)) - else: - res = self.function(t) - - res = tuple(res) - - if len(res) == 2: - self.position = res + (self.style.xanchor, self.style.yanchor) - else: - self.position = res - - rv = renpy.display.render.Render(cw, ch) - rv.blit(child, (0, 0)) - - self.offsets = [ (0, 0) ] - - return rv - - -class Interpolate(object): - - anchors = { - 'top' : 0.0, - 'center' : 0.5, - 'bottom' : 1.0, - 'left' : 0.0, - 'right' : 1.0, - } - - def __init__(self, start, end): - - if len(start) != len(end): - raise Exception("The start and end must have the same number of arguments.") - - self.start = [ self.anchors.get(i, i) for i in start ] - self.end = [ self.anchors.get(i, i) for i in end ] - - def __call__(self, t, sizes=(None, None, None, None)): - - def interp(a, b, c): - - if c is not None: - if type(a) is float: - a = a * c - if type(b) is float: - b = b * c - - rv = a + t * (b - a) - - return renpy.display.core.absolute(rv) - - return [ interp(a, b, c) for a, b, c in zip(self.start, self.end, sizes) ] - - -def Pan(startpos, endpos, time, child=None, repeat=False, bounce=False, - anim_timebase=False, style='motion', time_warp=None, **properties): - """ - This is used to pan over a child displayable, which is almost - always an image. It works by interpolating the placement of the - upper-left corner of the screen, over time. It's only really - suitable for use with images that are larger than the screen, - and we don't do any cropping on the image. - - @param startpos: The initial coordinates of the upper-left - corner of the screen, relative to the image. - - @param endpos: The coordinates of the upper-left corner of the - screen, relative to the image, after time has elapsed. - - @param time: The time it takes to pan from startpos to endpos. - - @param child: The child displayable. - - @param repeat: True if we should repeat this forever. - - @param bounce: True if we should bounce from the start to the end - to the start. - - @param anim_timebase: True if we use the animation timebase, False to use the - displayable timebase. - - @param time_warp: If not None, this is a function that takes a - fraction of the period (between 0.0 and 1.0), and returns a - new fraction of the period. Use this to warp time, applying - acceleration and deceleration to motions. - - This can be used as a transition. See Motion for details. - """ - - x0, y0 = startpos - x1, y1 = endpos - - return Motion(Interpolate((-x0, -y0), (-x1, -y1)), - time, - child, - repeat=repeat, - bounce=bounce, - style=style, - anim_timebase=anim_timebase, - time_warp=time_warp, - add_sizes=True, - **properties) - -def Move(startpos, endpos, time, child=None, repeat=False, bounce=False, - anim_timebase=False, style='motion', time_warp=None, **properties): - """ - This is used to pan over a child displayable relative to - the containing area. It works by interpolating the placement of the - the child, over time. - - @param startpos: The initial coordinates of the child - relative to the containing area. - - @param endpos: The coordinates of the child at the end of the - move. - - @param time: The time it takes to move from startpos to endpos. - - @param child: The child displayable. - - @param repeat: True if we should repeat this forever. - - @param bounce: True if we should bounce from the start to the end - to the start. - - @param anim_timebase: True if we use the animation timebase, False to use the - displayable timebase. - - @param time_warp: If not None, this is a function that takes a - fraction of the period (between 0.0 and 1.0), and returns a - new fraction of the period. Use this to warp time, applying - acceleration and deceleration to motions. - - This can be used as a transition. See Motion for details. - """ - - return Motion(Interpolate(startpos, endpos), - time, - child, - repeat=repeat, - bounce=bounce, - anim_timebase=anim_timebase, - style=style, - time_warp=time_warp, - add_sizes=True, - **properties) - - -class Revolver(object): - - def __init__(self, start, end, child, around=(0.5, 0.5), cor=(0.5, 0.5), pos=None): - self.start = start - self.end = end - self.around = around - self.cor = cor - self.pos = pos - self.child = child - - def __call__(self, t, xxx_todo_changeme): - - # Converts a float to an integer in the given range, passes - # integers through unchanged. - (w, h, cw, ch) = xxx_todo_changeme - def fti(x, r): - if x is None: - x = 0 - - if isinstance(x, float): - return int(x * r) - else: - return x - - if self.pos is None: - pos = self.child.get_placement() - else: - pos = self.pos - - xpos, ypos, xanchor, yanchor, _xoffset, _yoffset, _subpixel = pos - - xpos = fti(xpos, w) - ypos = fti(ypos, h) - xanchor = fti(xanchor, cw) - yanchor = fti(yanchor, ch) - - xaround, yaround = self.around - - xaround = fti(xaround, w) - yaround = fti(yaround, h) - - xcor, ycor = self.cor - - xcor = fti(xcor, cw) - ycor = fti(ycor, ch) - - angle = self.start + (self.end - self.start) * t - angle *= math.pi / 180 - - # The center of rotation, relative to the xaround. - x = xpos - xanchor + xcor - xaround - y = ypos - yanchor + ycor - yaround - - # Rotate it. - nx = x * math.cos(angle) - y * math.sin(angle) - ny = x * math.sin(angle) + y * math.cos(angle) - - # Project it back. - nx = nx - xcor + xaround - ny = ny - ycor + yaround - - return (renpy.display.core.absolute(nx), renpy.display.core.absolute(ny), 0, 0) - - -def Revolve(start, end, time, child, around=(0.5, 0.5), cor=(0.5, 0.5), pos=None, **properties): - - return Motion(Revolver(start, end, child, around=around, cor=cor, pos=pos), - time, - child, - add_sizes=True, - **properties) - - - -def zoom_render(crend, x, y, w, h, zw, zh, bilinear): - """ - This creates a render that zooms its child. - - `crend` - The render of the child. - `x`, `y`, `w`, `h` - A rectangle inside the child. - `zw`, `zh` - The size the rectangle is rendered to. - `bilinear` - Should we be rendering in bilinear mode? - """ - - rv = renpy.display.render.Render(zw, zh) - - if zw == 0 or zh == 0 or w == 0 or h == 0: - return rv - - - rv.forward = renpy.display.render.Matrix2D(w / zw, 0, 0, h / zh) - rv.reverse = renpy.display.render.Matrix2D(zw / w, 0, 0, zh / h) - - rv.clipping = True - - rv.blit(crend, rv.reverse.transform(-x, -y)) - - return rv - - -class ZoomCommon(renpy.display.core.Displayable): - def __init__(self, - time, child, - end_identity=False, - after_child=None, - time_warp=None, - bilinear=True, - opaque=True, - anim_timebase=False, - repeat=False, - style='motion', - **properties): - """ - @param time: The amount of time it will take to - interpolate from the start to the end rectange. - - @param child: The child displayable. - - @param after_child: If present, a second child - widget. This displayable will be rendered after the zoom - completes. Use this to snap to a sharp displayable after - the zoom is done. - - @param time_warp: If not None, this is a function that takes a - fraction of the period (between 0.0 and 1.0), and returns a - new fraction of the period. Use this to warp time, applying - acceleration and deceleration to motions. - """ - - super(ZoomCommon, self).__init__(style=style, **properties) - - child = renpy.easy.displayable(child) - - self.time = time - self.child = child - self.repeat = repeat - - if after_child: - self.after_child = renpy.easy.displayable(after_child) - else: - if end_identity: - self.after_child = child - else: - self.after_child = None - - self.time_warp = time_warp - self.bilinear = bilinear - self.opaque = opaque - self.anim_timebase = anim_timebase - - - def visit(self): - return [ self.child, self.after_child ] - - def render(self, width, height, st, at): - - if self.anim_timebase: - t = at - else: - t = st - - if self.time: - done = min(t / self.time, 1.0) - else: - done = 1.0 - - if self.repeat: - done = done % 1.0 - - if renpy.game.less_updates: - done = 1.0 - - self.done = done - - if self.after_child and done == 1.0: - return renpy.display.render.render(self.after_child, width, height, st, at) - - if self.time_warp: - done = self.time_warp(done) - - rend = renpy.display.render.render(self.child, width, height, st, at) - - rx, ry, rw, rh, zw, zh = self.zoom_rectangle(done, rend.width, rend.height) - - if rx < 0 or ry < 0 or rx + rw > rend.width or ry + rh > rend.height: - raise Exception("Zoom rectangle %r falls outside of %dx%d parent surface." % ((rx, ry, rw, rh), rend.width, rend.height)) - - rv = zoom_render(rend, rx, ry, rw, rh, zw, zh, self.bilinear) - - if self.done < 1.0: - renpy.display.render.redraw(self, 0) - - return rv - - def event(self, ev, x, y, st): - - if not self.time: - done = 1.0 - else: - done = min(st / self.time, 1.0) - - if done == 1.0 and self.after_child: - return self.after_child.event(ev, x, y, st) - else: - return None - - -class Zoom(ZoomCommon): - - def __init__(self, size, start, end, time, child, **properties): - - end_identity = (end == (0.0, 0.0) + size) - - super(Zoom, self).__init__(time, child, end_identity=end_identity, **properties) - - self.size = size - self.start = start - self.end = end - - def zoom_rectangle(self, done, width, height): - - rx, ry, rw, rh = [ (a + (b - a) * done) for a, b in zip(self.start, self.end) ] - - return rx, ry, rw, rh, self.size[0], self.size[1] - - -class FactorZoom(ZoomCommon): - - def __init__(self, start, end, time, child, **properties): - - end_identity = (end == 1.0) - - super(FactorZoom, self).__init__(time, child, end_identity=end_identity, **properties) - - self.start = start - self.end = end - - def zoom_rectangle(self, done, width, height): - - factor = self.start + (self.end - self.start) * done - - return 0, 0, width, height, factor * width, factor * height - - - -class SizeZoom(ZoomCommon): - - def __init__(self, start, end, time, child, **properties): - - end_identity = False - - super(SizeZoom, self).__init__(time, child, end_identity=end_identity, **properties) - - self.start = start - self.end = end - - def zoom_rectangle(self, done, width, height): - - sw, sh = self.start - ew, eh = self.end - - zw = sw + (ew - sw) * done - zh = sh + (eh - sh) * done - - return 0, 0, width, height, zw, zh - - -class RotoZoom(renpy.display.core.Displayable): - - transform = None - - def __init__(self, - rot_start, - rot_end, - rot_delay, - zoom_start, - zoom_end, - zoom_delay, - child, - rot_repeat=False, - zoom_repeat=False, - rot_bounce=False, - zoom_bounce=False, - rot_anim_timebase=False, - zoom_anim_timebase=False, - rot_time_warp=None, - zoom_time_warp=None, - opaque=False, - style='motion', - **properties): - - super(RotoZoom, self).__init__(style=style, **properties) - - self.rot_start = rot_start - self.rot_end = rot_end - self.rot_delay = rot_delay - - self.zoom_start = zoom_start - self.zoom_end = zoom_end - self.zoom_delay = zoom_delay - - self.child = renpy.easy.displayable(child) - - self.rot_repeat = rot_repeat - self.zoom_repeat = zoom_repeat - - self.rot_bounce = rot_bounce - self.zoom_bounce = zoom_bounce - - self.rot_anim_timebase = rot_anim_timebase - self.zoom_anim_timebase = zoom_anim_timebase - - self.rot_time_warp = rot_time_warp - self.zoom_time_warp = zoom_time_warp - - self.opaque = opaque - - - def visit(self): - return [ self.child ] - - - def render(self, width, height, st, at): - - if self.rot_anim_timebase: - rot_time = at - else: - rot_time = st - - if self.zoom_anim_timebase: - zoom_time = at - else: - zoom_time = st - - if self.rot_delay == 0: - rot_time = 1.0 - else: - rot_time /= self.rot_delay - - if self.zoom_delay == 0: - zoom_time = 1.0 - else: - zoom_time /= self.zoom_delay - - if self.rot_repeat: - rot_time %= 1.0 - - if self.zoom_repeat: - zoom_time %= 1.0 - - if self.rot_bounce: - rot_time *= 2 - rot_time = min(rot_time, 2.0 - rot_time) - - if self.zoom_bounce: - zoom_time *= 2 - zoom_time = min(zoom_time, 2.0 - zoom_time) - - if renpy.game.less_updates: - rot_time = 1.0 - zoom_time = 1.0 - - rot_time = min(rot_time, 1.0) - zoom_time = min(zoom_time, 1.0) - - if self.rot_time_warp: - rot_time = self.rot_time_warp(rot_time) - - if self.zoom_time_warp: - zoom_time = self.zoom_time_warp(zoom_time) - - - angle = self.rot_start + (1.0 * self.rot_end - self.rot_start) * rot_time - zoom = self.zoom_start + (1.0 * self.zoom_end - self.zoom_start) * zoom_time - # angle = -angle * math.pi / 180 - - zoom = max(zoom, 0.001) - - if self.transform is None: - self.transform = Transform(self.child) - - self.transform.rotate = angle - self.transform.zoom = zoom - - rv = renpy.display.render.render(self.transform, width, height, st, at) - - if rot_time <= 1.0 or zoom_time <= 1.0: - renpy.display.render.redraw(self.transform, 0) - - return rv - - -# For compatibility with old games. -renpy.display.layout.Transform = Transform -renpy.display.layout.RotoZoom = RotoZoom -renpy.display.layout.SizeZoom = SizeZoom -renpy.display.layout.FactorZoom = FactorZoom -renpy.display.layout.Zoom = Zoom -renpy.display.layout.Revolver = Revolver -renpy.display.layout.Motion = Motion -renpy.display.layout.Interpolate = Interpolate - -# Leave these functions around - they might have been pickled somewhere. -renpy.display.layout.Revolve = Revolve # function -renpy.display.layout.Move = Move # function -renpy.display.layout.Pan = Pan # function diff --git a/unrpyc/renpy/display/movetransition.py b/unrpyc/renpy/display/movetransition.py deleted file mode 100644 index 1b3bdd7..0000000 --- a/unrpyc/renpy/display/movetransition.py +++ /dev/null @@ -1,640 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# NOTE: -# Transitions need to be able to work even when old_widget and new_widget -# are None, at least to the point of making it through __init__. This is -# so that prediction of images works. - -import renpy.display - -# Utility function used by MoveTransition et al. -def position(d): - - xpos, ypos, xanchor, yanchor, _xoffset, _yoffset, _subpixel = d.get_placement() - - if xpos is None: - xpos = 0 - if ypos is None: - ypos = 0 - if xanchor is None: - xanchor = 0 - if yanchor is None: - yanchor = 0 - - return xpos, ypos, xanchor, yanchor - -def offsets(d): - - _xpos, _ypos, _xanchor, _yanchor, xoffset, yoffset, _subpixel = d.get_placement() - - if renpy.config.movetransition_respects_offsets: - return { 'xoffset' : xoffset, 'yoffset' : yoffset } - else: - return { } - - -# These are used by MoveTransition. -def MoveFactory(pos1, pos2, delay, d, **kwargs): - if pos1 == pos2: - return d - - return renpy.display.motion.Move(pos1, pos2, delay, d, **kwargs) - -def default_enter_factory(pos, delay, d, **kwargs): - return d - -def default_leave_factory(pos, delay, d, **kwargs): - return None - -# These can be used to move things in and out of the screen. -def MoveIn(pos, pos1, delay, d, **kwargs): - - def aorb(a, b): - if a is None: - return b - return a - - pos = tuple([aorb(a, b) for a, b in zip(pos, pos1)]) - return renpy.display.motion.Move(pos, pos1, delay, d, **kwargs) - -def MoveOut(pos, pos1, delay, d, **kwargs): - - def aorb(a, b): - if a is None: - return b - return a - - pos = tuple([aorb(a, b) for a, b in zip(pos, pos1)]) - return renpy.display.motion.Move(pos1, pos, delay, d, **kwargs) - -def ZoomInOut(start, end, pos, delay, d, **kwargs): - - xpos, ypos, xanchor, yanchor = pos - - FactorZoom = renpy.display.motion.FactorZoom - - if end == 1.0: - return FactorZoom(start, end, delay, d, after_child=d, opaque=False, - xpos=xpos, ypos=ypos, xanchor=xanchor, yanchor=yanchor, **kwargs) - else: - return FactorZoom(start, end, delay, d, opaque=False, - xpos=xpos, ypos=ypos, xanchor=xanchor, yanchor=yanchor, **kwargs) - -def RevolveInOut(start, end, pos, delay, d, **kwargs): - return renpy.display.motion.Revolve(start, end, delay, d, pos=pos, **kwargs) - - -def OldMoveTransition(delay, old_widget=None, new_widget=None, factory=None, enter_factory=None, leave_factory=None, old=False, layers=[ 'master' ]): - """ - Returns a transition that attempts to find images that have changed - position, and moves them from the old position to the new transition, taking - delay seconds to complete the move. - - If `factory` is given, it is expected to be a function that takes as - arguments: an old position, a new position, the delay, and a - displayable, and to return a displayable as an argument. If not - given, the default behavior is to move the displayable from the - starting to the ending positions. Positions are always given as - (xpos, ypos, xanchor, yanchor) tuples. - - If `enter_factory` or `leave_factory` are given, they are expected - to be functions that take as arguments a position, a delay, and a - displayable, and return a displayable. They are applied to - displayables that are entering or leaving the scene, - respectively. The default is to show in place displayables that - are entering, and not to show those that are leaving. - - If `old` is True, then factory moves the old displayable with the - given tag. Otherwise, it moves the new displayable with that - tag. - - `layers` is a list of layers that the transition will be applied - to. - - Images are considered to be the same if they have the same tag, in - the same way that the tag is used to determine which image to - replace or to hide. They are also considered to be the same if - they have no tag, but use the same displayable. - - Computing the order in which images are displayed is a three-step - process. The first step is to create a list of images that - preserves the relative ordering of entering and moving images. The - second step is to insert the leaving images such that each leaving - image is at the lowest position that is still above all images - that were below it in the original scene. Finally, the list - is sorted by zorder, to ensure no zorder violations occur. - - If you use this transition to slide an image off the side of the - screen, remember to hide it when you are done. (Or just use - a leave_factory.) - """ - - if factory is None: - factory = MoveFactory - - if enter_factory is None: - enter_factory = default_enter_factory - - if leave_factory is None: - leave_factory = default_leave_factory - - use_old = old - - def merge_slide(old, new): - - # If new does not have .layers or .scene_list, then we simply - # insert a move from the old position to the new position, if - # a move occured. - - if (not isinstance(new, renpy.display.layout.MultiBox) - or (new.layers is None and new.layer_name is None)): - - if use_old: - child = old - else: - child = new - - old_pos = position(old) - new_pos = position(new) - - if old_pos != new_pos: - return factory(old_pos, - new_pos, - delay, - child, - **offsets(child) - ) - - else: - return child - - # If we're in the layers_root widget, merge the child widgets - # for each layer. - if new.layers: - - assert old.layers - - rv = renpy.display.layout.MultiBox(layout='fixed') - rv.layers = { } - - for layer in renpy.config.layers: - - f = new.layers[layer] - - if (isinstance(f, renpy.display.layout.MultiBox) - and layer in layers - and f.scene_list is not None): - - f = merge_slide(old.layers[layer], new.layers[layer]) - - rv.layers[layer] = f - rv.add(f) - - return rv - - # Otherwise, we recompute the scene list for the two widgets, merging - # as appropriate. - - # Wraps the displayable found in SLE so that the various timebases - # are maintained. - def wrap(sle): - return renpy.display.layout.AdjustTimes(sle.displayable, sle.show_time, sle.animation_time) - - def tag(sle): - return sle.tag or sle.displayable - - def merge(sle, d): - rv = sle.copy() - rv.show_time = 0 - rv.displayable = d - return rv - - def entering(sle): - new_d = wrap(new_sle) - move = enter_factory(position(new_d), delay, new_d, **offsets(new_d)) - - if move is None: - return - - rv_sl.append(merge(new_sle, move)) - - def leaving(sle): - old_d = wrap(sle) - move = leave_factory(position(old_d), delay, old_d, **offsets(old_d)) - - if move is None: - return - - move = renpy.display.layout.IgnoresEvents(move) - rv_sl.append(merge(old_sle, move)) - - - def moving(old_sle, new_sle): - old_d = wrap(old_sle) - new_d = wrap(new_sle) - - if use_old: - child = old_d - else: - child = new_d - - move = factory(position(old_d), position(new_d), delay, child, **offsets(child)) - if move is None: - return - - rv_sl.append(merge(new_sle, move)) - - - # The old, new, and merged scene_lists. - old_sl = old.scene_list[:] - new_sl = new.scene_list[:] - rv_sl = [ ] - - - # A list of tags in old_sl, new_sl, and rv_sl. - old_map = dict((tag(i), i) for i in old_sl if i is not None) - new_tags = set(tag(i) for i in new_sl if i is not None) - rv_tags = set() - - while old_sl or new_sl: - - # If we have something in old_sl, then - if old_sl: - - old_sle = old_sl[0] - old_tag = tag(old_sle) - - # If the old thing has already moved, then remove it. - if old_tag in rv_tags: - old_sl.pop(0) - continue - - # If the old thing does not match anything in new_tags, - # have it enter. - if old_tag not in new_tags: - leaving(old_sle) - rv_tags.add(old_tag) - old_sl.pop(0) - continue - - - # Otherwise, we must have something in new_sl. We want to - # either move it or have it enter. - - new_sle = new_sl.pop(0) - new_tag = tag(new_sle) - - # If it exists in both, move. - if new_tag in old_map: - old_sle = old_map[new_tag] - - moving(old_sle, new_sle) - rv_tags.add(new_tag) - continue - - else: - entering(new_sle) - rv_tags.add(new_tag) - continue - - # Sort everything by zorder, to ensure that there are no zorder - # violations in the result. - rv_sl.sort(key=lambda a : a.zorder) - - layer = new.layer_name - rv = renpy.display.layout.MultiBox(layout='fixed', focus=layer, **renpy.game.interface.layer_properties[layer]) - rv.append_scene_list(rv_sl) - rv.layer_name = layer - - return rv - - - # This calls merge_slide to actually do the merging. - - rv = merge_slide(old_widget, new_widget) - rv.delay = delay # W0201 - - return rv - -############################################################################## -# New Move Transition (since 6.14) - - -class MoveInterpolate(renpy.display.core.Displayable): - """ - This displayable has two children. It interpolates between the positions - of its two children to place them on the screen. - """ - - def __init__(self, delay, old, new, use_old, time_warp): - super(MoveInterpolate, self).__init__() - - # The old and new displayables. - self.old = old - self.new = new - - # Should we display the old displayable? - self.use_old = False - - # Time warp function or None. - self.time_warp = time_warp - - # The width of the screen. - self.screen_width = 0 - self.screen_height = 0 - - # The width of the selected child. - self.child_width = 0 - self.child_height = 0 - - # The delay and st. - self.delay = delay - self.st = 0 - - def render(self, width, height, st, at): - self.screen_width = width - self.screen_height = height - - old_r = renpy.display.render.render(self.old, width, height, st, at) - new_r = renpy.display.render.render(self.new, width, height, st, at) - - if self.use_old: - cr = old_r - else: - cr = new_r - - self.child_width, self.child_height = cr.get_size() - self.st = st - - if self.st < self.delay: - renpy.display.render.redraw(self, 0) - - return cr - - def child_placement(self, child): - - def based(v, base): - if v is None: - return 0 - elif isinstance(v, int): - return v - elif isinstance(v, renpy.display.core.absolute): - return v - else: - return v * base - - xpos, ypos, xanchor, yanchor, xoffset, yoffset, subpixel = child.get_placement() - - xpos = based(xpos, self.screen_width) - ypos = based(ypos, self.screen_height) - xanchor = based(xanchor, self.child_width) - yanchor = based(yanchor, self.child_height) - - return xpos, ypos, xanchor, yanchor, xoffset, yoffset, subpixel - - def get_placement(self): - - if self.st > self.delay: - done = 1.0 - else: - done = self.st / self.delay - - if self.time_warp is not None: - done = self.time_warp(done) - - absolute = renpy.display.core.absolute - - def I(a, b): - return absolute(a + done * (b - a)) - - old_xpos, old_ypos, old_xanchor, old_yanchor, old_xoffset, old_yoffset, old_subpixel = self.child_placement(self.old) - new_xpos, new_ypos, new_xanchor, new_yanchor, new_xoffset, new_yoffset, new_subpixel = self.child_placement(self.new) - - xpos = I(old_xpos, new_xpos) - ypos = I(old_ypos, new_ypos) - xanchor = I(old_xanchor, new_xanchor) - yanchor = I(old_yanchor, new_yanchor) - xoffset = I(old_xoffset, new_xoffset) - yoffset = I(old_yoffset, new_yoffset) - subpixel = old_subpixel or new_subpixel - - return xpos, ypos, xanchor, yanchor, xoffset, yoffset, subpixel - - -def MoveTransition(delay, old_widget=None, new_widget=None, enter=None, leave=None, old=False, layers=[ 'master' ], time_warp=None, enter_time_warp=None, leave_time_warp=None): - """ - :doc: transition function - :args: (delay, enter=None, leave=None, old=False, layers=['master'], time_warp=None, enter_time_warp=None, leave_time_warp=None) - :name: MoveTransition - - Returns a transition that interpolates the position of images (with the - same tag) in the old and new scenes. - - `delay` - The time it takes for the interpolation to finish. - - `enter` - If not None, images entering the scene will also be moved. The value - of `enter` should be a transform that is applied to the image to - get its starting position. - - `leave` - If not None, images leaving the scene will also be move. The value - of `leave` should be a transform that is applied to the image to - get its ending position. - - `old` - If true, the old image will be used in preference to the new one. - - `layers` - A list of layers that moves are applied to. - - `time_warp` - A time warp function that's applied to the interpolation. This - takes a number between 0.0 and 1.0, and should return a number in - the same range. - - `enter_time_warp` - A time warp function that's applied to images entering the scene. - - `enter_time_warp` - A time warp function that's applied to images leaving the scene. - - """ - - use_old = old - - def merge_slide(old, new): - - # If new does not have .layers or .scene_list, then we simply - # insert a move from the old position to the new position, if - # a move occured. - - if (not isinstance(new, renpy.display.layout.MultiBox) - or (new.layers is None and new.layer_name is None)): - - if old is new: - return new - else: - return MoveInterpolate(delay, old, new, use_old, time_warp) - - - # If we're in the layers_root widget, merge the child widgets - # for each layer. - if new.layers: - - assert old.layers - - rv = renpy.display.layout.MultiBox(layout='fixed') - - for layer in renpy.config.layers: - - f = new.layers[layer] - - if (isinstance(f, renpy.display.layout.MultiBox) - and layer in layers - and f.scene_list is not None): - - f = merge_slide(old.layers[layer], new.layers[layer]) - - rv.add(f) - - return rv - - # Otherwise, we recompute the scene list for the two widgets, merging - # as appropriate. - - # Wraps the displayable found in SLE so that the various timebases - # are maintained. - def wrap(sle): - return renpy.display.layout.AdjustTimes(sle.displayable, sle.show_time, sle.animation_time) - - def tag(sle): - return sle.tag or sle.displayable - - def merge(sle, d): - rv = sle.copy() - rv.show_time = 0 - rv.displayable = d - return rv - - def entering(sle): - - if not enter: - return - - new_d = wrap(new_sle) - move = MoveInterpolate(delay, enter(new_d), new_d, False, enter_time_warp) - rv_sl.append(merge(new_sle, move)) - - def leaving(sle): - - if not leave: - return - - old_d = wrap(sle) - move = MoveInterpolate(delay, old_d, leave(old_d), True, leave_time_warp) - move = renpy.display.layout.IgnoresEvents(move) - rv_sl.append(merge(old_sle, move)) - - - def moving(old_sle, new_sle): - - if old_sle.displayable is new_sle.displayable: - rv_sl.append(new_sle) - return - - old_d = wrap(old_sle) - new_d = wrap(new_sle) - - move = MoveInterpolate(delay, old_d, new_d, use_old, time_warp) - - rv_sl.append(merge(new_sle, move)) - - - # The old, new, and merged scene_lists. - old_sl = old.scene_list[:] - new_sl = new.scene_list[:] - rv_sl = [ ] - - # A list of tags in old_sl, new_sl, and rv_sl. - old_map = dict((tag(i), i) for i in old_sl if i is not None) - new_tags = set(tag(i) for i in new_sl if i is not None) - rv_tags = set() - - while old_sl or new_sl: - - # If we have something in old_sl, then - if old_sl: - - old_sle = old_sl[0] - old_tag = tag(old_sle) - - # If the old thing has already moved, then remove it. - if old_tag in rv_tags: - old_sl.pop(0) - continue - - # If the old thing does not match anything in new_tags, - # have it enter. - if old_tag not in new_tags: - leaving(old_sle) - rv_tags.add(old_tag) - old_sl.pop(0) - continue - - - # Otherwise, we must have something in new_sl. We want to - # either move it or have it enter. - - new_sle = new_sl.pop(0) - new_tag = tag(new_sle) - - # If it exists in both, move. - if new_tag in old_map: - old_sle = old_map[new_tag] - - moving(old_sle, new_sle) - rv_tags.add(new_tag) - continue - - else: - entering(new_sle) - rv_tags.add(new_tag) - continue - - # Sort everything by zorder, to ensure that there are no zorder - # violations in the result. - rv_sl.sort(key=lambda a : a.zorder) - - layer = new.layer_name - rv = renpy.display.layout.MultiBox(layout='fixed', focus=layer, **renpy.game.interface.layer_properties[layer]) - rv.append_scene_list(rv_sl) - - return rv - - # Call merge_slide to actually do the merging. - rv = merge_slide(old_widget, new_widget) - rv.delay = delay - - return rv - diff --git a/unrpyc/renpy/display/particle.py b/unrpyc/renpy/display/particle.py deleted file mode 100644 index cf52417..0000000 --- a/unrpyc/renpy/display/particle.py +++ /dev/null @@ -1,615 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This code supports sprite and particle animation. - -from renpy.display.render import render, BLIT - -import renpy.display -import random - - -class SpriteCache(renpy.object.Object): - """ - This stores information about a displayble, including the identity - of the displayable, and when it was first displayed. It is also - responsible for caching the displayable surface, so it doesn't - need to be re-rendered. - """ - - # Private Fields: - # - # child - The child displayable. - # - # st - The shown time when this was first displayed, or None if it hasn't - # been rendered. - # - # render - The render of child. - # - # If true, then the render is simple enough it can just be appended to - # the manager's render's children list. - -class Sprite(renpy.object.Object): - """ - :doc: sprites class - - This represents a sprite that is managed by the SpriteManager. It contains - fields that control the placement of the sprite on the screen. Sprites - should not be created directly. Instead, they should be created by - calling :meth:`SpriteManager.create`. - - The fields of a sprite object are: - - `x`, `y` - The x and y coordinates of the upper-left corner of the sprite, - relative to the SpriteManager. - - `zorder` - An integer that's used to control the order of this sprite in the - relative to the other sprites in the SpriteManager. The larger the - number is, the closer to the viewer the sprite is. - - `events` - If True, then events are passed to child. If False, the default, - the children igore events (and hence don't spend time processing - them). - - The methods of a Sprite object are: - """ - - # Fields: - # - # child - the displayable that is the child of this sprite. - # cache - the SpriteCache of child. - # live - True if this sprite is still alive. - # manager - A reference to the SpriteManager. - - def set_child(self, d): - """ - :doc: sprites method - - Changes the Displayable associated with this sprite to `d`. - """ - - id_d = id(d) - - sc = self.manager.displayable_map.get(id_d, None) - if sc is None: - d = renpy.easy.displayable(d) - - sc = SpriteCache() - sc.render = None - sc.child = d - sc.st = None - - self.manager.displayable_map[id_d] = sc - - self.cache = sc - - def destroy(self): - """ - :doc: sprites method - - Destroys this sprite, preventing it from being displayed and - removing it from the SpriteManager. - """ - - self.manager.dead_child = True - self.live = False - self.events = False - - - -class SpriteManager(renpy.display.core.Displayable): - """ - :doc: sprites class - - This displayable manages a collection of sprites, and displays - them at the fastest speed possible. - """ - - def __init__(self, update=None, event=None, predict=None, ignore_time=False, **properties): - """ - `update` - If not None, a function that is called each time a sprite - is rendered by this sprite manager. It is called with one - argument, the time in seconds since this sprite manager - was first displayed. It is expected to return the number - of seconds until the function is called again, and the - SpriteManager is rendered again. - - `event` - If not None, a function that is called when an event occurs. - It takes as arguments: - * A pygame event object. - * The x coordinate of the event. - * The y coordinate of the event. - * The time since the sprite manager was first shown. - If it returns a non-None value, the interaction ends, and - that value is returned. - - `predict` - If not None, a function that returns a list of - displayables. These displayables are predicted when the - sprite manager is. - - `ignore_time` - If True, then time is ignored when rendering displayables. This - should be used when the sprite manager is used with a relatively - small pool of images, and those images do not change over time. - This should only be used with a small number of displayables, as - it will keep all displayables used in memory for the life of the - SpriteManager. - - After being rendered once (before the `update` function is called), - SpriteManagers have the following fields: - - `width`, `height` - - The width and height of this SpriteManager, in pixels. - - - SpriteManagers have the following methods: - """ - - super(SpriteManager, self).__init__(self, **properties) - - self.update_function = update - self.event_function = event - self.predict_function = predict - self.ignore_time = ignore_time - - # A map from a displayable to the SpriteDisplayable object - # representing that displayable. - self.displayable_map = { } - - # A list of children of this displayable, in zorder. (When sorted.) - # This is a list of Sprites. - self.children = [ ] - - # True if at least one child has been killed. - self.dead_child = False - - # True if at least one child responds to events. - self.events = False - - # The width and height. - self.width = None - self.height = None - - def create(self, d): - """ - :doc: sprites method - - Creates a new Sprite for the displayable `d`, and adds it to this - SpriteManager. - """ - - id_d = id(d) - - sc = self.displayable_map.get(id_d, None) - if sc is None: - d = renpy.easy.displayable(d) - - sc = SpriteCache() - sc.render = None - sc.child = d - sc.st = None - self.displayable_map[id_d] = sc - - s = Sprite() - s.x = 0 - s.y = 0 - s.zorder = 0 - s.cache = sc - s.live = True - s.manager = self - s.events = False - - self.children.append(s) - - return s - - def predict_one(self): - if self.predict_function is not None: - for i in self.predict_function(): - renpy.display.predict.displayable(i) - - - def redraw(self, delay=0): - """ - :doc: sprite method - - Causes this SpriteManager to be redrawn in `delay` seconds. - """ - - renpy.display.render.redraw(self, delay) - - def render(self, width, height, st, at): - - self.width = width - self.height = height - - if self.update_function is not None: - - redraw = self.update_function(st) - - if redraw is not None: - renpy.display.render.redraw(self, redraw) - - if not self.ignore_time: - self.displayable_map.clear() - - if self.dead_child: - self.children = [ i for i in self.children if i.live ] - - self.children.sort(key=lambda sc:sc.zorder) - - caches = [ ] - - rv = renpy.display.render.Render(width, height) - - events = False - - for i in self.children: - - events |= i.events - - cache = i.cache - r = i.cache.render - if cache.render is None: - if cache.st is None: - cache.st = st - - cst = st - cache.st - - cache.render = r = render(cache.child, width, height, cst, cst) - cache.fast = (r.operation == BLIT) and (r.forward is None) and (r.alpha == 1.0) - rv.depends_on(r) - - caches.append(cache) - - - if cache.fast: - for child, xo, yo, _focus, _main in r.children: - rv.children.append((child, - xo + i.x, - yo + i.y, - False, - False)) - - else: - rv.subpixel_blit(r, (i.x, i.y)) - - for i in caches: - i.render = None - - return rv - - def event(self, ev, x, y, st): - for i in range(len(self.children) -1, -1, -1): - s = self.children[i] - - if s.events: - rv = s.cache.child.event(ev, x - s.x, y - s.y, st - s.cache.st) - if rv is not None: - return rv - - if self.event_function is not None: - return self.event_function(ev, x, y, st) - else: - return None - - def visit(self): - rv = [ ] - - try: - if self.predict_function: - pl = self.predict_function() - for i in pl: - i = renpy.easy.displayable(i) - rv.append(i) - except: - pass - - return rv - - def destroy_all(self): - self.children = [ ] - - -class Particles(renpy.display.core.Displayable, renpy.python.NoRollback): - """ - Supports particle motion, using the old API. - """ - - __version__ = 1 - - nosave = [ 'particles' ] - - def after_upgrade(self, version): - if version < 1: - self.sm = SpriteManager(update=self.update_callback, predict=self.predict_callback) - - def after_setstate(self): - self.particles = None - - def __init__(self, factory, **properties): - """ - @param factory: A factory object. - """ - - super(Particles, self).__init__(**properties) - - self.sm = SpriteManager(update=self.update_callback, predict=self.predict_callback) - - self.factory = factory - self.particles = None - - def update_callback(self, st): - - particles = self.particles - - if st == 0 or particles is None: - self.sm.destroy_all() - particles = [ ] - - add_parts = self.factory.create(particles, st) - - new_particles = [ ] - - for sprite, p in particles: - update = p.update(st) - - if update is None: - sprite.destroy() - continue - - x, y, _t, d = update - - if d is not sprite.cache.child: - sprite.set_child(d) - - sprite.x = x - sprite.y = y - - new_particles.append((sprite, p)) - - if add_parts: - for p in add_parts: - update = p.update(st) - - if update is None: - continue - - x, y, _t, d = update - - if d is None: - continue - - sprite = self.sm.create(d) - sprite.x = x - sprite.y = y - - new_particles.append((sprite, p)) - - self.particles = new_particles - - return 0 - - def predict_callback(self): - return self.factory.predict() - - def render(self, w, h, st, at): - return renpy.display.render.render(self.sm, w, h, st, at) - -class SnowBlossomFactory(renpy.python.NoRollback): - - rotate = False - - def __setstate__(self, state): - self.start = 0 - vars(self).update(state) - self.init() - - def __init__(self, image, count, xspeed, yspeed, border, start, fast, rotate=False): - self.image = renpy.easy.displayable(image) - self.count = count - self.xspeed = xspeed - self.yspeed = yspeed - self.border = border - self.start = start - self.fast = fast - self.rotate = rotate - self.init() - - def init(self): - self.starts = [ random.uniform(0, self.start) for _i in range(0, self.count) ] # W0201 - self.starts.append(self.start) - self.starts.sort() - - def create(self, particles, st): - - def ranged(n): - if isinstance(n, tuple): - return random.uniform(n[0], n[1]) - else: - return n - - if not particles and self.fast: - rv = [ ] - - for _i in range(0, self.count): - rv.append(SnowBlossomParticle(self.image, - ranged(self.xspeed), - ranged(self.yspeed), - self.border, - st, - random.uniform(0, 100), - fast=True, - rotate=self.rotate)) - return rv - - - if particles is None or len(particles) < self.count: - - # Check to see if we have a particle ready to start. If not, - # don't start it. - if particles and st < self.starts[len(particles)]: - return None - - return [ SnowBlossomParticle(self.image, - ranged(self.xspeed), - ranged(self.yspeed), - self.border, - st, - random.uniform(0, 100), - fast=False, - rotate=self.rotate) ] - - def predict(self): - return [ self.image ] - - -class SnowBlossomParticle(renpy.python.NoRollback): - - def __init__(self, image, xspeed, yspeed, border, start, offset, fast, rotate): - - # safety. - if yspeed == 0: - yspeed = 1 - - self.image = image - self.xspeed = xspeed - self.yspeed = yspeed - self.border = border - self.start = start - self.offset = offset - self.rotate = rotate - - - if not rotate: - sh = renpy.config.screen_height - sw = renpy.config.screen_width - else: - sw = renpy.config.screen_height - sh = renpy.config.screen_width - - - if self.yspeed > 0: - self.ystart = -border - else: - self.ystart = sh + border - - - travel_time = (2.0 * border + sh) / abs(yspeed) - - xdist = xspeed * travel_time - - x0 = min(-xdist, 0) - x1 = max(sw + xdist, sw) - - self.xstart = random.uniform(x0, x1) - - if fast: - self.ystart = random.uniform(-border, sh + border) - self.xstart = random.uniform(0, sw) - - def update(self, st): - to = st - self.start - - xpos = self.xstart + to * self.xspeed - ypos = self.ystart + to * self.yspeed - - if not self.rotate: - sh = renpy.config.screen_height - else: - sh = renpy.config.screen_width - - if ypos > sh + self.border: - return None - - if ypos < -self.border: - return None - - if not self.rotate: - return int(xpos), int(ypos), to + self.offset, self.image - else: - return int(ypos), int(xpos), to + self.offset, self.image - -def SnowBlossom(d, - count=10, - border=50, - xspeed=(20, 50), - yspeed=(100, 200), - start=0, - fast=False, - horizontal=False): - - """ - :doc: sprites_extra - - The snowblossom effect moves multiple instances of a sprite up, - down, left or right on the screen. When a sprite leaves the screen, it - is returned to the start. - - `d` - The displayable to use for the sprites. - - `border` - The size of the border of the screen. The sprite is considered to be - on the screen until it clears the border, ensuring that sprites do - not disappear abruptly. - - `xspeed`, `yspeed` - The speed at which the sprites move, in the horizontal and vertical - directions, respectively. These can be a single number or a tuple of - two numbers. In the latter case, each particle is assigned a random - speed between the two numbers. The speeds can be positive or negative, - as long as the second number in a tuple is larger than the first. - - `start` - The delay, in seconds, before each particle is added. This can be - allows the particles to start at the top of the screen, while not - looking like a "wave" effect. - - `fast` - If true, particles start in the center of the screen, rather than - only at the edges. - - `horizontal` - If true, particles appear on the left or right side of the screen, - rather than the top or bottom. - """ - - # If going horizontal, swap the xspeed and the yspeed. - if horizontal: - xspeed, yspeed = yspeed, xspeed - - return Particles(SnowBlossomFactory(image=d, - count=count, - border=border, - xspeed=xspeed, - yspeed=yspeed, - start=start, - fast=fast, - rotate=horizontal)) - diff --git a/unrpyc/renpy/display/pgrender.py b/unrpyc/renpy/display/pgrender.py deleted file mode 100644 index 32d1df8..0000000 --- a/unrpyc/renpy/display/pgrender.py +++ /dev/null @@ -1,167 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This module wraps the pygame surface class (and associated functions). It -# ensures that returned surfaces have a 2px border around them. - -import sys -import pygame -import renpy.display - -# Sample surfaces, with and without alpha. -sample_alpha = None -sample_noalpha = None - -def set_rgba_masks(): - """ - This rebuilds the sample surfaces, to ones that use the given - masks. - """ - - # Annoyingly, the value for the big mask seems to vary from - # platform to platform. So we read it out of a surface. - - global sample_alpha - global sample_noalpha - - # Create a sample surface. - s = pygame.Surface((10, 10), 0, 32) - sample_alpha = s.convert_alpha() - - # Sort the components by absolute value. - masks = list(sample_alpha.get_masks()) - masks.sort(key=lambda a : abs(a)) - - # Choose the masks. - if sys.byteorder == 'big': - masks = ( masks[3], masks[2], masks[1], masks[0] ) - else: - masks = ( masks[0], masks[1], masks[2], masks[3] ) - - # Create the sample surface. - sample_alpha = pygame.Surface((10, 10), 0, 32, masks) - sample_noalpha = pygame.Surface((10, 10), 0, 32, masks[:3] + (0,)) - - -class Surface(pygame.Surface): - """ - This allows us to wrap around pygame's surface, to change - its mode, as necessary. - """ - - opaque = False - - def is_opaque(self): - return self.opaque - - def convert_alpha(self, surface=None): - return copy_surface_unscaled(self, True) - - def convert(self, surface=None): - return copy_surface(self, False) - - def copy(self): - return copy_surface(self, self) - - def subsurface(self, rect): - rv = pygame.Surface.subsurface(self, rect) - return rv - -def surface(xxx_todo_changeme, alpha): - """ - Constructs a new surface. The allocated surface is actually a subsurface - of a surface that has a 2 pixel border in all directions. - - `alpha` - True if the new surface should have an alpha channel. - """ - (width, height) = xxx_todo_changeme - if isinstance(alpha, pygame.Surface): - alpha = alpha.get_masks()[3] - - if alpha: - sample = sample_alpha - else: - sample = sample_noalpha - - # We might not have initialized properly yet. This is enough - # to get us underway. - if sample is None: - sample = pygame.Surface((4, 4), pygame.SRCALPHA, 32) - - surf = Surface((width + 4, height + 4), 0, sample) - return surf.subsurface((2, 2, width, height)) # E1101 - -surface_unscaled = surface - -def copy_surface(surf, alpha=True): - """ - Creates a copy of the surface. - """ - - rv = surface_unscaled(surf.get_size(), alpha) - renpy.display.accelerator.nogil_copy(surf, rv) # @UndefinedVariable - return rv - -copy_surface_unscaled = copy_surface - - -# Wrapper around image loading. - -def load_image(f, filename): - surf = pygame.image.load(f, renpy.exports.fsencode(filename)) - rv = copy_surface_unscaled(surf) - return rv - -load_image_unscaled = load_image - - -# Wrapper around functions we use from pygame.surface. - -def flip(surf, horizontal, vertical): - surf = pygame.transform.flip(surf, horizontal, vertical) - return copy_surface_unscaled(surf) - -flip_unscaled = flip - - -def rotozoom(surf, angle, zoom): - - surf = pygame.transform.rotozoom(surf, angle, zoom) - return copy_surface_unscaled(surf) - -rotozoom_unscaled = rotozoom - - -def transform_scale(surf, size): - surf = pygame.transform.scale(surf, size) - return copy_surface_unscaled(surf, surf) - -transform_scale_unscaled = transform_scale - - -def transform_rotate(surf, angle): - surf = pygame.transform.rotate(surf, angle) - return copy_surface(surf) - -transform_rotate_unscaled = transform_rotate - - - diff --git a/unrpyc/renpy/display/predict.py b/unrpyc/renpy/display/predict.py deleted file mode 100644 index 2bdc16f..0000000 --- a/unrpyc/renpy/display/predict.py +++ /dev/null @@ -1,156 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This file contains the routines that manage image prediction. - -import renpy.display - -# Called to indicate an image should be loaded or preloaded. This is -# a function that takes an image manipulator, set by reset and predict, -# and winds up bound to either im.cache.get or im.cache.preload_image -image = None - -# The set of displayables we've predicted since reset was last called. -predicted = set() - -# A flag that indicates if we're currently predicting. -predicting = False - -# A list of (screen name, argument dict) tuples, giving the screens we'd -# like to predict. -screens = [ ] - -def displayable(d): - """ - Called to predict that the displayable `d` will be shown. - """ - - if d is None: - return - - if d not in predicted: - predicted.add(d) - d.visit_all(lambda i : i.predict_one()) - -def screen(_screen_name, *args, **kwargs): - """ - Called to predict that the named screen is about to be shown - with the given arguments. - """ - - screens.append((_screen_name, args, kwargs)) - - -def reset(): - global image - image = renpy.display.im.cache.get - predicted.clear() - del screens[:] - - -def prediction_coroutine(root_widget): - """ - The image prediction co-routine. This predicts the images that can - be loaded in the near future, and passes them to the image cache's - preload_image method to be queued up for loading. - - The .send should be called with True to do a expensive prediction, - and with False to either do an inexpensive prediction or no - prediction at all. - - Returns True if there's more predicting to be done, or False - if there's no more predicting worth doing. - """ - - global predicting - - # Wait to be told to start. - yield True - - # Start the prediction thread (to clean out the cache). - renpy.display.im.cache.start_prediction() - - # Set up the image prediction method. - global image - image = renpy.display.im.cache.preload_image - - # Predict images that are going to be reached in the next few - # clicks. - predicting = True - - for _i in renpy.game.context().predict(): - - predicting = False - yield True - predicting = True - - # If there's a parent context, predict we'll be returning to it - # shortly. Otherwise, call the functions in - # config.predict_callbacks. - - if len(renpy.game.contexts) >= 2: - sls = renpy.game.contexts[-2].scene_lists - - for l in sls.layers.values(): - for sle in l: - try: - displayable(sle.displayable) - except: - pass - - else: - for i in renpy.config.predict_callbacks: - i() - - predicting = False - - while not (yield True): - continue - - # Predict things (especially screens) that are reachable through - # an action. - predicting = True - - try: - root_widget.visit_all(lambda i : i.predict_one_action()) - except: - pass - - predicting = False - - # Predict the screens themselves. - for name, args, kwargs in screens: - while not (yield True): - continue - - predicting = True - - try: - renpy.display.screen.predict_screen(name, *args, **kwargs) - except: - if renpy.config.debug_image_cache: - renpy.display.ic_log.write("While predicting screen %s %r", name, kwargs) - renpy.display.ic_log.exception() - - predicting = False - - yield False - diff --git a/unrpyc/renpy/display/presplash.py b/unrpyc/renpy/display/presplash.py deleted file mode 100644 index 54717fd..0000000 --- a/unrpyc/renpy/display/presplash.py +++ /dev/null @@ -1,113 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# Pre-splash code. The goal of this code is to try to get a pre-splash -# screen up as soon as possible, to let the user know something is -# going on. - -# The presplash process, if any. -proc = None - -# Called from the main process. This determines if -# we're even doing presplash, and if so what will be shown to the -# user. If it decides to show something to the user, uses subprocess -# to actually handle the showing. -def start(basedir, gamedir): - import os.path - - if "RENPY_LESS_UPDATES" in os.environ: - return - - global proc - - filenames = [ "/presplash.png", "/presplash.jpg" ] - for fn in filenames: - fn = gamedir + fn - if os.path.exists(fn): - break - else: - return - - try: - import subprocess - import sys - - cmd = [sys.executable, "-EOO", sys.argv[0], "show", "presplash", fn] - - def fsencode(s): - if isinstance(s, str): - return s - - return s.encode(sys.getfilesystemencoding() or "utf-8", "replace") - - proc = subprocess.Popen([ fsencode(i) for i in cmd ], stdin=subprocess.PIPE, stdout=subprocess.PIPE) - except: - pass - - -# Called just before we initialize the display for real, to -# hide the splash, and terminate window centering. -def end(): - - global proc - - if not proc: - return - - proc.stdin.close() - proc.wait() - - proc = None - -# Called in the presplash process, to actually display the presplash. -def show(fn): - - import pygame.display - import pygame.constants - import sys - import os - - os.environ['SDL_VIDEO_CENTERED'] = "1" - - try: - import pygame.macosx - pygame.macosx.init() #@UndefinedVariable - except: - pass - - try: - import pygame.macosx #@Reimport - pygame.macosx.Video_AutoInit() - except: - pass - - pygame.display.init() - - img = pygame.image.load(fn, fn) - screen = pygame.display.set_mode(img.get_size(), pygame.constants.NOFRAME) - screen.blit(img, (0, 0)) - pygame.display.update() - - sys.stdout.write("READY\r\n") - sys.stdout.flush() - sys.stdin.read() - - sys.exit(0) diff --git a/unrpyc/renpy/display/render.pxd b/unrpyc/renpy/display/render.pxd deleted file mode 100644 index a4d8d68..0000000 --- a/unrpyc/renpy/display/render.pxd +++ /dev/null @@ -1,47 +0,0 @@ -cdef class Matrix2D: - cdef public double xdx - cdef public double xdy - cdef public double ydx - cdef public double ydy - - cpdef tuple transform(Matrix2D self, double x, double y) - -cdef class Render: - - cdef public bint mark, cache_killed - - cdef public float width, height - cdef public object layer_name - - cdef public list children - cdef public set parents - cdef public list depends_on_list - - cdef public int operation - cdef public double operation_complete - cdef public bint operation_alpha - cdef public object operation_parameter - - cdef public Matrix2D forward, reverse - cdef public double alpha - - cdef public list focuses - cdef public list pass_focuses - cdef public object draw_func - cdef public object render_of - - cdef public bint opaque - cdef public list visible_children - - cdef public bint clipping - - cdef public object surface, alpha_surface, half_cache - - cdef public bint modal - - cpdef int blit(Render self, source, tuple pos, object focus=*, object main=*, object index=*) - cpdef int subpixel_blit(Render self, source, tuple pos, object focus=*, object main=*, object index=*) - - -cpdef render(object d, object widtho, object heighto, double st, double at) - diff --git a/unrpyc/renpy/display/render.pyx b/unrpyc/renpy/display/render.pyx deleted file mode 100644 index 5aa45a0..0000000 --- a/unrpyc/renpy/display/render.pyx +++ /dev/null @@ -1,1174 +0,0 @@ -#cython: profile=False -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -import collections -import pygame -import threading -import renpy -import gc - -# We grab the blit lock each time it is necessary to blit -# something. This allows call to the pygame.transform functions to -# disable blitting, should it prove necessary. -blit_lock = threading.Condition() - -# This is a dictionary containing all the renders that we know of. It's a -# map from displayable to dictionaries containing the render of that -# displayable. -render_cache = collections.defaultdict(dict) - -# The queue of redraws. A list of (time, displayable) pairs. -redraw_queue = [ ] - -# The render returned from render_screen. -screen_render = None - -# A list of renders the system knows about, and thinks are still alive. -cdef list live_renders -live_renders = [ ] - -# A copy of renpy.display.interface.frame_time, for speed reasons. -cdef double frame_time -frame_time = 0 - -def free_memory(): - """ - Frees memory used by the render system. - """ - - global screen_render - screen_render = None - - mark_sweep() - - render_cache.clear() - - # This can hang onto a render. - renpy.display.interface.surftree = None - - -def check_at_shutdown(): - """ - This is called at shutdown time to check that everything went okay. - The big thing it checks for is memory leaks. - """ - - if not renpy.config.developer: - return - - free_memory() - - gc.collect() - l = gc.get_objects() - - count = 0 - objects = gc.get_objects() - - for i in objects: - if isinstance(i, Render): - count += 1 - - if count: - raise Exception("%d Renders are alive at shutdown. This is probably a memory leak bug in Ren'Py." % count) - - - -cpdef render(d, object widtho, object heighto, double st, double at): - """ - :doc: udd_utility - :args: (d, width, height, st, at) - - Causes a displayable to be rendered, and a renpy.Render object to - be returned. - - `d` - The displayable to render. - - `width`, `height` - The width and height available for the displayable to render into. - - `st`, `at` - The shown and animation timebases. - - Renders returned by this object may be cached, and should not be modified - once they have been retrieved. - """ - - cdef float width, height - cdef float orig_width, orig_height - cdef tuple orig_wh, wh - cdef dict render_cache_d - cdef Render rv - - orig_wh = (widtho, heighto, frame_time-st, frame_time-at) - - render_cache_d = render_cache[d] - rv = render_cache_d.get(orig_wh, None) - - if rv is not None: - return rv - - orig_width = width = widtho - orig_height = height = heighto - - style = d.style - xmaximum = style.xmaximum - ymaximum = style.ymaximum - - if xmaximum is not None: - if isinstance(xmaximum, float): - width = width * xmaximum - else: - width = min(xmaximum, width) - - if ymaximum is not None: - if isinstance(ymaximum, float): - height = height * ymaximum - else: - height = min(ymaximum, height) - - if width < 0: - width = 0 - if height < 0: - height = 0 - - if orig_width != width or orig_height != height: - widtho = width - heighto = height - wh = (widtho, heighto, frame_time-st, frame_time-at) - rv = render_cache_d.get(wh, None) - - if rv is not None: - return rv - - else: - wh = orig_wh - - rv = d.render(widtho, heighto, st, at) - - rv.render_of.append(d) - - if style.clipping: - rv = rv.subsurface((0, 0, rv.width, rv.height), focus=True) - rv.render_of.append(d) - - render_cache_d[wh] = rv - - if wh is not orig_wh: - render_cache_d[orig_wh] = rv - - return rv - - -# This is true if something has been invalidated, and a redraw needs -# to occur. It's automatically cleared to False at the end of each -# redraw. -invalidated = False - -def invalidate(d): - """ - Removes d from the render cache. If we're not in a redraw, triggers - a redraw to start. - """ - - global invalidated - - if d in render_cache: - for v in render_cache[d].values(): - v.kill_cache() - - invalidated = True - - -def process_redraws(): - """ - Called to determine if any redraws are pending. Returns true if we - need to redraw the screen now, false otherwise. - """ - - global redraw_queue - - redraw_queue.sort() - - now = renpy.display.core.get_time() - rv = invalidated - - new_redraw_queue = [ ] - seen = set() - - for t in redraw_queue: - when, d = t - - if d in seen: - continue - - seen.add(d) - - if d not in render_cache: - continue - - if when <= now: - # Remove this displayable and all its parents from the - # render cache. But don't kill them yet, as that will kill the - # children that we want to reuse. - - for v in render_cache[d].values(): - v.kill_cache() - - rv = True - - else: - new_redraw_queue.append(t) - - redraw_queue = new_redraw_queue - - return rv - - -def redraw_time(): - """ - Returns the time at which the next redraw is scheduled. - """ - - if redraw_queue: - return redraw_queue[0][0] - - return None - - -def redraw(d, when): - """ - :doc: udd_utility - - Causes the displayable `d` to be redrawn after `when` seconds have - elapsed. - """ - - if not renpy.game.interface: - return - - redraw_queue.append((when + renpy.game.interface.frame_time, d)) - - -cdef class Matrix2D: - """ - This represents a 2d matrix that can be used to transform - points and things like that. - """ - - def __getstate__(self): - return dict( - xdx = self.xdx, - xdy = self.xdy, - ydx = self.ydx, - ydy = self.ydy) - - def __setstate__(self, state): - self.xdx = state['xdx'] - self.xdy = state['xdy'] - self.ydx = state['ydx'] - self.ydy = state['ydy'] - - def __init__(Matrix2D self, double xdx, double xdy, double ydx, double ydy): - self.xdx = xdx - self.xdy = xdy - self.ydx = ydx - self.ydy = ydy - - cpdef tuple transform(Matrix2D self, double x, double y): - return (x * self.xdx + y * self.xdy), (x * self.ydx + y * self.ydy) - - def __mul__(Matrix2D self, Matrix2D other): - return Matrix2D( - other.xdx * self.xdx + other.xdy * self.ydx, - other.xdx * self.xdy + other.xdy * self.ydy, - other.ydx * self.xdx + other.ydy * self.ydx, - other.ydx * self.xdy + other.ydy * self.ydy) - - def __repr__(self): - return "Matrix2D(xdx=%f, xdy=%f, ydx=%f, ydy=%f)" % (self.xdx, self.xdy, self.ydx, self.ydy) - -IDENTITY = Matrix2D(1, 0, 0, 1) - -def take_focuses(focuses): - """ - Adds a list of rectangular focus regions to the focuses list. - """ - - screen_render.take_focuses( - 0, 0, screen_render.width, screen_render.height, - IDENTITY, 0, 0, focuses) - -# The result of focus_at_point for a modal render. This overrides any -# specific focus from below us. -Modal = object() - -def focus_at_point(x, y): - """ - Returns a focus object corresponding to the uppermost displayable - at point, or None if nothing focusable is at point. - """ - - if screen_render is None: - return None - - cf = screen_render.focus_at_point(x, y) - if cf is None or cf is Modal: - return None - else: - d, arg = cf - return renpy.display.focus.Focus(d, arg, None, None, None, None) - - -def mutated_surface(surf): - """ - Called to indicate that the given surface has changed. - """ - - renpy.display.draw.mutated_surface(surf) - - -def render_screen(root, width, height): - """ - Renders `root` (a displayable) as the root of a screen with the given - `width` and `height`. - """ - - - - global old_screen_render - global screen_render - global invalidated - global frame_time - - frame_time = renpy.display.interface.frame_time - - rv = render(root, width, height, 0, 0) - screen_render = rv - - invalidated = False - - rv.is_opaque() - - return rv - -def mark_sweep(): - """ - This performs mark-and-sweep garbage collection on the live_renders - list. - """ - - global live_renders - - cdef list worklist - cdef int i - cdef Render r, j - - worklist = [ ] - - if screen_render is not None: - worklist.append(screen_render) - - i = 0 - - while i < len(worklist): - r = worklist[i] - - for j in r.depends_on_list: - if not j.mark: - j.mark = True - worklist.append(j) - - i += 1 - - for r in live_renders: - if not r.mark: - r.kill_cache() - else: - r.mark = False - - live_renders = worklist - -def compute_subline(sx0, sw, cx0, cw): - """ - Given a source line (start sx0, width sw) and a crop line (cx0, cw), - return three things: - - * The offset of the portion of the source line that overlaps with - the crop line, relative to the crop line. - * The offset of the portion of the source line that overlaps with the - the crop line, relative to the source line. - * The length of the overlap in pixels. (can be <= 0) - """ - - sx1 = sx0 + sw - cx1 = cx0 + cw - - if sx0 > cx0: - start = sx0 - else: - start = cx0 - - offset = start - cx0 - crop = start - sx0 - - if sx1 < cx1: - width = sx1 - start - else: - width = cx1 - start - - - return offset, crop, width - - - - -# Possible operations that can be done as part of a render. -BLIT = 0 -DISSOLVE = 1 -IMAGEDISSOLVE = 2 -PIXELLATE = 3 - -cdef class Render: - - def __init__(Render self, float width, float height, draw_func=None, layer_name=None, bint opaque=None): #@DuplicatedSignature - """ - Creates a new render corresponding to the given widget with - the specified width and height. - - If `layer_name` is given, then this render corresponds to a - layer. - """ - - # The mark bit, used for mark/sweep-style garbage collection of - # renders. - self.mark = False - - # Is has this render been removed from the cache? - self.cache_killed = False - - - self.width = width - self.height = height - - self.layer_name = layer_name - - # A list of (surface/render, xoffset, yoffset, focus, main) tuples, ordered from - # back to front. - self.children = [ ] - - # The set of renders that either have us as children, or depend on - # us. - self.parents = set() - - # The renders we depend on, including our children. - self.depends_on_list = [ ] - - # The operation we're performing. (BLIT, DISSOLVE, OR IMAGE_DISSOLVE) - self.operation = BLIT - - # The fraction of the operation that is complete. - self.operation_complete = 0.0 - - # Should the dissolve operations preserve alpha? - self.operation_alpha = False - - # The parameter to the operation. - self.operation_parameter = 0 - - # Forward is used to transform from screen coordinates to child - # coordinates. - # Reverse is used to transform from child coordinates to screen - # coordinates. - # - # For performance reasons, these aren't used to transform the - # x and y offsets found in self.children. Those offsets should - # be of the (0, 0) point in the child coordinate space. - self.forward = None - self.reverse = None - - # This is used to adjust the alpha of children of this render. - self.alpha = 1 - - # A list of focus regions in this displayable. - self.focuses = None - - # Other renders that we should pass focus onto. - self.pass_focuses = None - - # The displayable(s) that this is a render of. (Set by render) - self.render_of = [ ] - - # If set, this is a function that's called to draw this render - # instead of the default. - self.draw_func = draw_func - - # Is this displayable opaque? (May be set on init, or later on - # if we have opaque children.) This may be True, False, or None - # to indicate we don't know yet. - self.opaque = opaque - - # A list of our visible children. (That is, children above and - # including our uppermost opaque child.) If nothing is opaque, - # includes all children. - self.visible_children = self.children - - # Should children be clipped to a rectangle? - self.clipping = False - - # Caches of the texture created by rendering this surface. - self.surface = None - self.alpha_surface = None - - # Cache of the texture created by rendering this surface at half size. - # (This is set in gldraw.) - self.half_cache = None - - # Are we modal? - self.modal = False - - live_renders.append(self) - - def __repr__(self): #@DuplicatedSignature - return "" % (id(self), self.render_of) - - def __getstate__(self): #@DuplicatedSignature - if renpy.config.developer: - raise Exception("Can't pickle a Render.") - else: - return { } - - def __setstate__(self, state): #@DuplicatedSignature - return - - cpdef int blit(Render self, source, tuple pos, object focus=True, object main=True, object index=None): - """ - Blits `source` (a Render or Surface) to this Render, offset by - xo and yo. - - If `focus` is true, then focuses are added from the child to the - parent. - - This will only blit on integer pixel boundaries. - """ - - (xo, yo) = pos - - if source is self: - raise Exception("Blitting to self.") - - xo = int(xo) - yo = int(yo) - - if index is None: - self.children.append((source, xo, yo, focus, main)) - else: - self.children.insert(index, (source, xo, yo, focus, main)) - - if isinstance(source, Render): - self.depends_on_list.append(source) - source.parents.add(self) - - return 0 - - cpdef int subpixel_blit(Render self, source, tuple pos, object focus=True, object main=True, object index=None): - """ - Blits `source` (a Render or Surface) to this Render, offset by - xo and yo. - - If `focus` is true, then focuses are added from the child to the - parent. - - This blits at fractional pixel boundaries. - """ - - (xo, yo) = pos - - xo = float(xo) - yo = float(yo) - - if index is None: - self.children.append((source, xo, yo, focus, main)) - else: - self.children.insert(index, (source, xo, yo, focus, main)) - - if isinstance(source, Render): - self.depends_on_list.append(source) - source.parents.add(self) - - return 0 - - def get_size(self): - """ - Returns the size of this Render, a mostly ficticious value - that's taken from the inputs to the constructor. (As in, we - don't clip to this size.) - """ - - return self.width, self.height - - - def render_to_texture(self, alpha=True): - """ - Returns a texture constructed from this render. This may return - a cached textue, if one has already been rendered. - - `alpha` is a hint that controls if the surface should have - alpha or not. - """ - - if alpha: - if self.alpha_surface is not None: - return self.alpha_surface - else: - if self.surface is not None: - return self.surface - - rv = None - - opaque = self.is_opaque() - - # If we can, reuse a child's texture. - if opaque or alpha: - - if not self.forward and len(self.children) == 1: - child, x, y, focus, main = self.children[0] - cw, ch = child.get_size() - if x <= 0 and y <= 0 and cw + x >= self.width and ch + y >= self.height: - # Our single child overlaps us. - if isinstance(child, Render): - child = child.render_to_texture(alpha) - - if x != 0 or y != 0 or cw != self.width or ch != self.height: - rv = child.subsurface((-x, -y, self.width, self.height)) - else: - rv = child - - # Otherwise, render to a texture. - if rv is None: - # is_opaque has already been called. - rv = renpy.display.draw.render_to_texture(self, alpha) - - # Stash and return the surface. - if alpha: - self.alpha_surface = rv - else: - self.surface = rv - - return rv - - pygame_surface = render_to_texture - - def subsurface(self, rect, focus=False): - """ - Returns a subsurface of this render. If `focus` is true, then - the focuses are copied from this render to the child. - """ - - (x, y, w, h) = rect - rv = Render(w, h) - - reverse = self.reverse - - # This doesn't actually make a subsurface, as we can't easily do - # so for non-rectangle-aligned renders. - if (reverse is not None) and ( - reverse.xdx != 1.0 or - reverse.xdy != 0.0 or - reverse.ydx != 0.0 or - reverse.ydy != 1.0): - - rv.clipping = True - rv.blit(self, (-x, -y), focus=focus, main=True) - return rv - - # This is the path that executes for rectangle-aligned surfaces, - # making an actual subsurface. - - for child, cx, cy, cfocus, cmain in self.children: - - cw, ch = child.get_size() - xo, cx, cw = compute_subline(cx, cw, x, w) - yo, cy, ch = compute_subline(cy, ch, y, h) - - if cw <= 0 or ch <= 0: - continue - - crop = (cx, cy, cw, ch) - offset = (xo, yo) - - if isinstance(child, Render): - newchild = child.subsurface(crop, focus=focus) - newchild.render_of = child.render_of[:] - else: - newchild = child.subsurface(crop) - renpy.display.draw.mutated_surface(newchild) - - rv.blit(newchild, offset, focus=cfocus, main=cmain) - - if focus and self.focuses: - - for (d, arg, xo, yo, fw, fh, mx, my, mask) in self.focuses: - - if xo is None: - rv.add_focus(d, arg, xo, yo, fw, fh, mx, my, mask) - continue - - xo, cx, fw = compute_subline(xo, fw, x, w) - yo, cy, fh = compute_subline(yo, fh, y, h) - - if cw <= 0 or ch <= 0: - continue - - if mx is not None: - - mw, mh = mask.get_size() - - mx, mcx, mw = compute_subline(mx, mw, x, w) - my, mcy, mh = compute_subline(my, mh, y, h) - - if mw <= 0 or mh <= 0: - mx = None - my = None - mask = None - else: - mask = mask.subsurface((mcx, mcy, mw, mh)) - - rv.add_focus(d, arg, xo, yo, fw, fh, mx, my, mask) - - rv.depends_on(self) - rv.alpha = self.alpha - rv.operation = self.operation - rv.operation_alpha = self.operation_alpha - rv.operation_complete = self.operation_complete - - return rv - - - def depends_on(self, source, focus=False): - """ - Used to indicate that this render depends on another - render. Useful, for example, if we use pygame_surface to make - a surface, and then blit that surface into another render. - """ - - if source is self: - raise Exception("Render depends on itself.") - - self.depends_on_list.append(source) - source.parents.add(self) - - if focus: - if self.pass_focuses is None: - self.pass_focuses = [ source ] - else: - self.pass_focuses.append(source) - - - def kill_cache(self): - """ - Removes this render and its transitive parents from the cache. - """ - - if self.cache_killed: - return - - self.cache_killed = True - - for i in self.parents: - i.kill_cache() - - self.parents.clear() - - for i in self.depends_on_list: - if not i.cache_killed: - i.parents.discard(self) - - for ro in self.render_of: - cache = render_cache[ro] - for k, v in cache.items(): - if v is self: - del cache[k] - - if not cache: - del render_cache[ro] - - def kill(self): - """ - Retained for compatibility. - """ - - def add_focus(self, d, arg=None, x=0, y=0, w=None, h=None, mx=None, my=None, mask=None): - """ - This is called to indicate a region of the screen that can be - focused. - - `d` - the displayable that is being focused. - `arg` - an argument. - - The rest of the parameters are a rectangle giving the portion of - this region corresponding to the focus. If they are all None, than - this focus is assumed to be the singular full-screen focus. - """ - - if mask is not None and mask is not self: - self.depends_on(mask) - - t = (d, arg, x, y, w, h, mx, my, mask) - - if self.focuses is None: - self.focuses = [ t ] - else: - self.focuses.append(t) - - def take_focuses(self, cminx, cminy, cmaxx, cmaxy, reverse, x, y, focuses): #@DuplicatedSignature - """ - This adds to focuses Focus objects corresponding to the focuses - added to this object and its children, transformed into screen - coordinates. - - `cminx`, `cminy`, `cmaxx`, `cmaxy` - The clipping rectangle. - `reverse` - The transform from render to screen coordinates. - `x`, `y` - The offset of the upper-left corner of the render. - `focuses` - The list of focuses to add to. - """ - - if self.modal: - focuses[:] = [ ] - - if self.reverse: - reverse = reverse * self.reverse - - if self.focuses: - - for (d, arg, xo, yo, w, h, mx, my, mask) in self.focuses: - - if xo is None: - focuses.append(renpy.display.focus.Focus(d, arg, None, None, None, None)) - continue - - x1, y1 = reverse.transform(xo, yo) - x2, y2 = reverse.transform(xo + w, yo + h) - - minx = min(x1, x2) + x - miny = min(y1, y2) + y - maxx = max(x1, x2) + x - maxy = max(y1, y2) + y - - minx = max(minx, cminx) - miny = max(miny, cminy) - maxx = min(maxx, cmaxx) - maxy = min(maxy, cmaxy) - - if minx >= maxx or miny >= maxy: - continue - - focuses.append(renpy.display.focus.Focus(d, arg, minx, miny, maxx - minx, maxy - miny)) - - if self.clipping: - cminx = max(cminx, x) - cminy = max(cminy, y) - cmaxx = min(cmaxx, x + self.width) - cmaxy = min(cmaxx, x + self.height) - - for child, xo, yo, focus, main in self.children: - if not focus or not isinstance(child, Render): - continue - - xo, yo = reverse.transform(xo, yo) - child.take_focuses(cminx, cminy, cmaxx, cmaxy, reverse, x + xo, y + yo, focuses) - - if self.pass_focuses: - for child in self.pass_focuses: - child.take_focuses(cminx, cminy, cmaxx, cmaxy, reverse, x, y, focuses) - - def focus_at_point(self, x, y): #@DuplicatedSignature - """ - This returns the focus of this object at the given point. - """ - - if self.clipping: - if x < 0 or x >= self.width or y < 0 or y >= self.height: - return None - - rv = None - - if self.focuses: - for (d, arg, xo, yo, w, h, mx, my, mask) in self.focuses: - - if xo is None: - continue - - elif mx is not None: - cx = x - mx - cy = y - my - - if self.forward: - cx, cy = self.forward.transform(cx, cy) - - if mask.is_pixel_opaque(cx, cy): - rv = d, arg - - elif xo <= x < xo + w and yo <= y < yo + h: - rv = d, arg - - for child, xo, yo, focus, main in self.children: - - if not focus or not isinstance(child, Render): - continue - - cx = x - xo - cy = y - yo - - if self.forward: - cx, cy = self.forward.transform(cx, cy) - - cf = child.focus_at_point(cx, cy) - if cf is not None: - rv = cf - - if self.pass_focuses: - for child in self.pass_focuses: - cf = child.focus_at_point(x, y) - if cf is not None: - rv = cf - - if rv is None and self.modal: - rv = Modal - - return rv - - - def main_displayables_at_point(self, x, y, layers, depth=None): - """ - Returns the displayable at `x`, `y` on one of the layers in - the set or list `layers`. - """ - - rv = [ ] - - if x < 0 or y < 0 or x >= self.width or y >= self.height: - return rv - - if depth is not None: - for d in self.render_of: - rv.append((depth, self.width, self.height, d)) - depth += 1 - elif self.layer_name in layers: - depth = 0 - - for (child, xo, yo, focus, main) in self.children: - if not main or not isinstance(child, Render): - continue - - cx = x - xo - cy = y - yo - - if self.forward: - cx, cy = self.forward.transform(cx, cy) - - cf = child.main_displayables_at_point(cx, cy, layers, depth) - rv.extend(cf) - - return rv - - - def is_opaque(self): - """ - Returns true if this displayable is opaque, or False otherwise. - Also sets self.visible_children. - """ - - if self.opaque is not None: - return self.opaque - - # A rotated image is never opaque. (This isn't actually true, but it - # saves us from the expensive calculations require to prove it is.) - if self.forward: - self.opaque = False - return False - - rv = False - vc = [ ] - - for i in self.children: - child, xo, yo, focus, main = i - - if xo <= 0 and yo <= 0: - cw, ch = child.get_size() - if cw + xo < self.width or ch + yo < self.height: - if child.is_opaque(): - vc = [ ] - rv = True - - vc.append(i) - - self.visible_children = vc - self.opaque = rv - return rv - - - def is_pixel_opaque(self, x, y): - """ - Determine if the pixel at x and y is opaque or not. - """ - - if x < 0 or y < 0 or x >= self.width or y >= self.height: - return False - - if self.is_opaque(): - return True - - return renpy.display.draw.is_pixel_opaque(self, x, y) - - - def fill(self, color): - """ - Fills this Render with the given color. - """ - - color = renpy.easy.color(color) - solid = renpy.display.imagelike.Solid(color) - surf = render(solid, self.width, self.height, 0, 0) - self.blit(surf, (0, 0), focus=False, main=False) - - - def canvas(self): - """ - Returns a canvas object that draws to this Render. - """ - - surf = renpy.display.pgrender.surface((self.width, self.height), True) - - mutated_surface(surf) - - self.blit(surf, (0, 0)) - - return Canvas(surf) - - -class Canvas(object): - - def __init__(self, surf): #@DuplicatedSignature - self.surf = surf - - def rect(self, color, rect, width=0): - - try: - blit_lock.acquire() - pygame.draw.rect(self.surf, - renpy.easy.color(color), - rect, - width) - finally: - blit_lock.release() - - def polygon(self, color, pointlist, width=0): - try: - blit_lock.acquire() - pygame.draw.polygon(self.surf, - renpy.easy.color(color), - pointlist, - width) - finally: - blit_lock.release() - - def circle(self, color, pos, radius, width=0): - - try: - blit_lock.acquire() - pygame.draw.circle(self.surf, - renpy.easy.color(color), - pos, - radius, - width) - - finally: - blit_lock.release() - - def ellipse(self, color, rect, width=0): - try: - blit_lock.acquire() - pygame.draw.ellipse(self.surf, - renpy.easy.color(color), - rect, - width) - finally: - blit_lock.release() - - - def arc(self, color, rect, start_angle, stop_angle, width=1): - try: - blit_lock.acquire() - pygame.draw.arc(self.surf, - renpy.easy.color(color), - rect, - start_angle, - stop_angle, - width) - finally: - blit_lock.release() - - - def line(self, color, start_pos, end_pos, width=1): - try: - blit_lock.acquire() - pygame.draw.line(self.surf, - renpy.easy.color(color), - start_pos, - end_pos, - width) - finally: - blit_lock.release() - - def lines(self, color, closed, pointlist, width=1): - try: - blit_lock.acquire() - pygame.draw.lines(self.surf, - renpy.easy.color(color), - closed, - pointlist, - width) - finally: - blit_lock.release() - - def aaline(self, color, startpos, endpos, blend=1): - try: - blit_lock.acquire() - pygame.draw.aaline(self.surf, - renpy.easy.color(color), - startpos, - endpos, - blend) - finally: - blit_lock.release() - - def aalines(self, color, closed, pointlist, blend=1): - try: - blit_lock.acquire() - pygame.draw.aalines(self.surf, - renpy.easy.color(color), - closed, - pointlist, - blend) - finally: - blit_lock.release() diff --git a/unrpyc/renpy/display/scale.py b/unrpyc/renpy/display/scale.py deleted file mode 100644 index c9efbcc..0000000 --- a/unrpyc/renpy/display/scale.py +++ /dev/null @@ -1,109 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This used to hack pygame to support resolution-scaling. Now it just kinda -# sits here, to provide compatibility with what it used to be. - -import pygame -import renpy.display -import renpy.display.pgrender as pgrender - -import _renpy - -############################################################################## -# The scaling API that's used if we don't enable scaling. - -# Gets the real pygame surface. -def real(s): - return s - -# Scales the number, n. -def scale(n): - return n - -def real_bilinear(src, size): - rv = pgrender.surface_unscaled(size, src) - renpy.display.module.bilinear_scale(src, rv) - return rv - -# Does pygame.transform.scale. -def real_transform_scale(surf, size): - return pgrender.transform_scale_unscaled(surf, size) - -# Loads an image, without scaling it. -def image_load_unscaled(f, hint, convert=True): - rv = pgrender.load_image_unscaled(f, hint) - return rv - -# Saves an image without rescaling. -def image_save_unscaled(surf, filename): - pygame.image.save(surf, renpy.exports.fsencode(filename)) - -# Scales down a surface. -def surface_scale(full): - return full - -real_renpy_pixellate = _renpy.pixellate -real_renpy_transform = _renpy.transform - -def real_smoothscale(src, size, dest=None): - """ - This scales src up or down to size. This uses both the pixellate - and the transform operations to handle the scaling. - """ - - width, height = size - srcwidth, srcheight = src.get_size() - iwidth, iheight = srcwidth, srcheight - - if dest is None: - dest = pgrender.surface_unscaled(size, src) - - if width == 0 or height == 0: - return dest - - xshrink = 1 - yshrink = 1 - - while iwidth >= width * 2: - xshrink *= 2 - iwidth /= 2 - - while iheight >= height * 2: - yshrink *= 2 - iheight /= 2 - - if iwidth != srcwidth or iheight != srcheight: - inter = pgrender.surface_unscaled((iwidth, iheight), src) - real_renpy_pixellate(src, inter, xshrink, yshrink, 1, 1) - src = inter - - real_renpy_transform(src, dest, - 0, 0, - 1.0 * iwidth / width , 0, - 0, 1.0 * iheight / height, - precise=1, - ) - - return dest - -smoothscale = real_smoothscale - diff --git a/unrpyc/renpy/display/screen.py b/unrpyc/renpy/display/screen.py deleted file mode 100644 index 8fd529b..0000000 --- a/unrpyc/renpy/display/screen.py +++ /dev/null @@ -1,639 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -import renpy.display - -class Screen(renpy.object.Object): - """ - A screen is a collection of widgets that are displayed together. - This class stores information about the screen. - """ - - def __init__(self, - name, - function, - modal="False", - zorder="0", - tag=None, - predict=None, - variant=None, - parameters=False): - - # The name of this screen. - if isinstance(name, str): - name = tuple(name.split()) - - self.name = name - - screens[name[0], variant] = self - - # The function that is called to display this screen. - self.function = function - - # Expression: Are we modal? (A modal screen ignores screens under it.) - self.modal = modal - - # Expression: Our zorder. - self.zorder = zorder - - # The tag associated with the screen. - self.tag = tag or name[0] - - # Can this screen be predicted? - if predict is None: - predict = renpy.config.predict_screens - - self.predict = predict - - # True if this screen takes parameters via _args and _kwargs. - self.parameters = parameters - - -class ScreenDisplayable(renpy.display.layout.Container): - """ - A screen is a collection of widgets that are displayed together. This - class is responsible for managing the display of a screen. - """ - - nosave = [ 'screen', 'child', 'transforms', 'widgets', 'old_widgets', 'old_transforms' ] - - restarting = False - - def after_setstate(self): - self.screen = get_screen_variant(self.screen_name[0]) - self.child = None - self.transforms = { } - self.widgets = { } - self.old_widgets = None - self.old_transforms = None - - def __init__(self, screen, tag, layer, widget_properties={}, scope={}, **properties): - - super(ScreenDisplayable, self).__init__(**properties) - - # Stash the properties, so we can re-create the screen. - self.properties = properties - - # The screen, and it's name. (The name is used to look up the - # screen on save.) - self.screen = screen - self.screen_name = screen.name - - # The tag and layer screen was displayed with. - self.tag = tag - self.layer = layer - - # The scope associated with this statement. This is passed in - # as keyword arguments to the displayable. - self.scope = renpy.python.RevertableDict(scope) - - # The child associated with this screen. - self.child = None - - # Widget properties given to this screen the last time it was - # shown. - self.widget_properties = widget_properties - - # A map from name to the widget with that name. - self.widgets = { } - - if tag and layer: - old_screen = get_screen(tag, layer) - else: - old_screen = None - - # A map from name to the transform with that name. (This is - # taken from the old version of the screen, if it exists. - if old_screen is not None: - self.transforms = old_screen.transforms - else: - self.transforms = { } - - # What widgets and transforms were the last time this screen was - # updated. Used to communicate with the ui module, and only - # valid during an update - not used at other times. - self.old_widgets = None - self.old_transforms = None - - # Should we transfer data from the old_screen? This becomes - # true once this screen finishes updating for the first time, - # and also while we're using something. - self.old_transfers = (old_screen and old_screen.screen_name == self.screen_name) - - # The current transform event, and the last transform event to - # be processed. - self.current_transform_event = None - - # A dict-set of widgets (by id) that have been hidden from us. - self.hidden_widgets = { } - - # Are we hiding? - self.hiding = False - - # Are we restarting? - self.restarting = False - - # Modal and zorder. - self.modal = renpy.python.py_eval(self.screen.modal, locals=self.scope) - self.zorder = renpy.python.py_eval(self.screen.zorder, locals=self.scope) - - def __repr__(self): - return "" % (self.screen_name,) - - def visit(self): - return [ self.child ] - - def per_interact(self): - renpy.display.render.redraw(self, 0) - self.update() - - def set_transform_event(self, event): - super(ScreenDisplayable, self).set_transform_event(event) - self.current_transform_event = event - - def find_focusable(self, callback, focus_name): - if self.child and not self.hiding: - self.child.find_focusable(callback, focus_name) - - def _hide(self, st, at, kind): - - if self.hiding: - hid = self - else: - hid = ScreenDisplayable(self.screen, self.tag, self.layer, self.widget_properties, self.scope, **self.properties) - hid.transforms = self.transforms.copy() - hid.widgets = self.widgets.copy() - hid.old_transfers = True - - hid.hiding = True - - hid.current_transform_event = kind - hid.update() - - renpy.display.render.redraw(hid, 0) - - rv = None - - # Compute the reverse of transforms and widgets. - reverse_transforms = dict((id(v), k) for k, v in hid.transforms.items()) - reverse_widgets = dict((id(v), k) for k, v in hid.widgets.items()) - - # Assumption: the only displayables that can keep us around - # are Transforms that handle hide. - - # Iterate over our immediate children, trying to hide them. - for d in list(hid.child.children): - - id_d = id(d) - - # If we have a transform, call its _hide method. If that comes - # back non-None, store the new transform, and keep us alive. - # - # Otherwise, remove the child. - name = reverse_transforms.get(id_d, None) - - if name is not None: - c = d._hide(st, at, kind) - - if c is not None: - hid.transforms[name] = c - rv = hid - else: - hid.hidden_widgets[name] = True - hid.child.remove(d) - - continue - - # Remove any non-transform children. - name = reverse_widgets.get(id_d, None) - - if name is not None: - hid.hidden_widgets[name] = True - hid.child.remove(d) - - return rv - - def update(self): - - # If we're restarting, do not update - the update can use variables - # that are no longer in scope. - if self.restarting: - if not self.child: - self.child = renpy.display.layout.Null() - - return self.widgets - - # Update _current_screen - global _current_screen - old_screen = _current_screen - _current_screen = self - - # Cycle widgets and transforms. - self.old_widgets = self.widgets - self.old_transforms = self.transforms - self.widgets = { } - self.transforms = { } - - # Render the child. - old_ui_screen = renpy.ui.screen - renpy.ui.screen = self - - renpy.ui.detached() - self.child = renpy.ui.fixed(focus="_screen_" + "_".join(self.screen_name)) - self.children = [ self.child ] - - self.scope["_scope"] = self.scope - self.scope["_name"] = 0 - - self.screen.function(**self.scope) - - renpy.ui.close() - - renpy.ui.screen = old_ui_screen - _current_screen = old_screen - - # Visit all the children, to get them started. - self.child.visit_all(lambda c : c.per_interact()) - - # Finish up. - self.old_widgets = None - self.old_transforms = None - self.old_transfers = True - - if self.current_transform_event: - - for i in self.child.children: - i.set_transform_event(self.current_transform_event) - - self.current_transform_event = None - - return self.widgets - - def render(self, w, h, st, at): - - if not self.child: - self.update() - - child = renpy.display.render.render(self.child, w, h, st, at) - - rv = renpy.display.render.Render(w, h) - - rv.blit(child, (0, 0), focus=not self.hiding, main=not self.hiding) - rv.modal = self.modal and not self.hiding - - return rv - - def get_placement(self): - if not self.child: - self.update() - - return self.child.get_placement() - - def event(self, ev, x, y, st): - - if self.hiding: - return - - global _current_screen - old_screen = _current_screen - _current_screen = self - - rv = self.child.event(ev, x, y, st) - - _current_screen = old_screen - - if rv is not None: - return rv - - if self.modal: - raise renpy.display.layout.IgnoreLayers() - - -# The name of the screen that is currently being displayed, or -# None if no screen is being currently displayed. -_current_screen = None - -# A map from (screen_name, variant) tuples to screen. -screens = { } - -def get_screen_variant(name): - """ - Get a variant screen object for `name`. - """ - - for i in renpy.config.variants: - rv = screens.get((name, i), None) - if rv is not None: - return rv - - return None - -def define_screen(*args, **kwargs): - """ - :doc: screens - :args: (name, function, modal="False", zorder="0", tag=None, variant=None) - - Defines a screen with `name`, which should be a string. - - `function` - The function that is called to display the screen. The - function is called with the screen scope as keyword - arguments. It should ignore additional keyword arguments. - - The function should call the ui functions to add things to the - screen. - - `modal` - A string that, when evaluated, determines of the created - screen should be modal. A modal screen prevents screens - underneath it from receiving input events. - - `zorder` - A string that, when evaluated, should be an integer. The integer - controls the order in which screens are displayed. A screen - with a greater zorder number is displayed above screens with a - lesser zorder number. - - `tag` - The tag associated with this screen. When the screen is shown, - it replaces any other screen with the same tag. The tag - defaults to the name of the screen. - - `predict` - If true, this screen can be loaded for image prediction. If false, - it can't. Defaults to true. - - `variant` - String. Gives the variant of the screen to use. - - """ - - Screen(*args, **kwargs) - - - -def get_screen(name, layer="screens"): - """ - :doc: screens - - Returns the ScreenDisplayable with the given `tag`, on - `layer`. If no displayable with the tag is not found, it is - interpreted as screen name. If it's still not found, None is returned. - """ - - if isinstance(name, str): - name = tuple(name.split()) - - tag = name[0] - - sl = renpy.exports.scene_lists() - - sd = sl.get_displayable_by_tag(layer, tag) - - if sd is None: - sd = sl.get_displayable_by_name(layer, name) - - return sd - -def has_screen(name): - """ - Returns true if a screen with the given name exists. - """ - - if not isinstance(name, tuple): - name = tuple(name.split()) - - if not name: - return False - - if get_screen_variant(name[0]): - return True - else: - return False - -def show_screen(_screen_name, *_args, **kwargs): - """ - :doc: screens - - The programmatic equivalent of the show screen statement. - - Shows the named screen. This takes the following keyword arguments: - - `_screen_name` - The name of the screen to show. - `_layer` - The layer to show the screen on. - `_tag` - The tag to show the screen with. If not specified, defaults to - the tag associated with the screen. It that's not specified, - defaults to the name of the screen., - `_widget_properties` - A map from the id of a widget to a property name -> property - value map. When a widget with that id is shown by the screen, - the specified properties are added to it. - `_transient` - If true, the screen will be automatically hidden at the end of - the current interaction. - - Keyword arguments not beginning with underscore (_) are used to - initialize the screen's scope. - """ - - _layer = kwargs.pop("_layer", "screens") - _tag = kwargs.pop("_tag", None) - _widget_properties = kwargs.pop("_widget_properties", {}) - _transient = kwargs.pop("_transient", False) - - name = _screen_name - - if not isinstance(name, tuple): - name = tuple(name.split()) - - screen = get_screen_variant(name[0]) - - if screen is None: - raise Exception("Screen %s is not known.\n" % (name[0],)) - - if _tag is None: - _tag = screen.tag - - scope = { } - - if screen.parameters: - scope["_kwargs" ] = kwargs - scope["_args"] = _args - else: - scope.update(kwargs) - - d = ScreenDisplayable(screen, _tag, _layer, _widget_properties, scope) - renpy.exports.show(name, tag=_tag, what=d, layer=_layer, zorder=d.zorder, transient=_transient, munge_name=False) - - -def predict_screen(_screen_name, *_args, **kwargs): - """ - Predicts the displayables that make up the given screen. - - `_screen_name` - The name of the screen to show. - `_widget_properties` - A map from the id of a widget to a property name -> property - value map. When a widget with that id is shown by the screen, - the specified properties are added to it. - - Keyword arguments not beginning with underscore (_) are used to - initialize the screen's scope. - """ - - _widget_properties = kwargs.pop("_widget_properties", {}) - _scope = kwargs.pop - - kwargs["_kwargs" ] = kwargs.copy() - kwargs["_args"] = _args - - name = _screen_name - - if renpy.config.debug_image_cache: - renpy.display.ic_log.write("Predict screen %s", name) - - if not isinstance(name, tuple): - name = tuple(name.split()) - - screen = get_screen_variant(name[0]) - - scope = { } - - if screen.parameters: - scope["_kwargs" ] = kwargs - scope["_args"] = _args - else: - scope.update(kwargs) - - try: - - if screen is None: - raise Exception("Screen %s is not known.\n" % (name[0],)) - - if not screen.predict: - return - - d = ScreenDisplayable(screen, None, None, _widget_properties, scope) - - d.update() - renpy.display.predict.displayable(d) - - except: - if renpy.config.debug_image_cache: - import traceback - - print("While predicting screen", screen) - traceback.print_exc() - - renpy.ui.reset() - - -def hide_screen(tag, layer='screens'): - """ - :doc: screens - - The programmatic equivalent of the hide screen statement. - - Hides the screen with `tag` on `layer`. - """ - - screen = get_screen(tag, layer) - - if screen is not None: - renpy.exports.hide(screen.tag, layer=layer) - -def use_screen(_screen_name, *_args, **kwargs): - - _name = kwargs.pop("_name", ()) - _scope = kwargs.pop("_scope", { }) - - name = _screen_name - - if not isinstance(name, tuple): - name = tuple(name.split()) - - screen = get_screen_variant(name[0]) - - if screen is None: - raise Exception("Screen %r is not known." % name) - - old_transfers = _current_screen.old_transfers - _current_screen.old_transfers = True - - scope = _scope.copy() - - if screen.parameters: - scope["_kwargs"] = kwargs - scope["_args"] = _args - else: - scope.update(kwargs) - - scope["_scope"] = scope - scope["_name"] = (_name, name) - - screen.function(**scope) - - _current_screen.old_transfers = old_transfers - -def current_screen(): - return _current_screen - -def get_widget(screen, id, layer='screens'): #@ReservedAssignment - """ - :doc: screens - - From the `screen` on `layer`, returns the widget with - `id`. Returns None if the screen doesn't exist, or there is no - widget with that id on the screen. - """ - - if screen is None: - screen = current_screen() - else: - screen = get_screen(screen, layer) - - if not isinstance(screen, ScreenDisplayable): - return None - - if screen.child is None: - screen.update() - - rv = screen.widgets.get(id, None) - return rv - -def before_restart(): - """ - This is called before Ren'Py restarts to put the screens into restart - mode, which prevents crashes due to variables being used that are no - longer defined. - """ - - for k, layer in renpy.display.interface.old_scene.items(): - if k is None: - continue - - for i in layer.children: - if isinstance(i, ScreenDisplayable): - i.restarting = True - diff --git a/unrpyc/renpy/display/swdraw.py b/unrpyc/renpy/display/swdraw.py deleted file mode 100644 index d3ecb51..0000000 --- a/unrpyc/renpy/display/swdraw.py +++ /dev/null @@ -1,1102 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -import renpy.display -import pygame -import math -import weakref -import time -import os - -from renpy.display.render import blit_lock, IDENTITY, BLIT, DISSOLVE, IMAGEDISSOLVE, PIXELLATE - -# A map from cached surface to rle version of cached surface. -rle_cache = weakref.WeakKeyDictionary() - -class Clipper(object): - """ - This is used to calculate the clipping rectangle and update rectangles - used for a particular draw of the screen. - """ - - def __init__(self): - - # Lists of (x0, y0, x1, y1, clip, surface, transform) tuples, - # representing how a displayable is drawn to the screen. - self.blits = [ ] - self.old_blits = [ ] - - # Sets of (x0, y0, x1, y1) tuples, representing areas that - # aren't part of any displayable. - self.forced = set() - self.old_forced = set() - - # The set of surfaces that have been mutated recently. - self.mutated = set() - - def compute(self, full_redraw): - """ - This returns a clipping rectangle, and a list of update rectangles - that cover the changes between the old and new frames. - """ - - # First, get things out of the fields, and update them. This - # allows us to just return without having to do any cleanup - # code. - bl0 = self.old_blits - bl1 = self.blits - old_forced = self.old_forced - forced = self.forced - mutated = self.mutated - - self.old_blits = bl1 - self.blits = [ ] - self.old_forced = forced - self.forced = set() - self.mutated = set() - - sw = renpy.config.screen_width - sh = renpy.config.screen_height - sa = sw * sh - - # A tuple representing the size of the fullscreen. - fullscreen = (0, 0, sw, sh) - - # Check to see if a full redraw has been forced, and return - # early. - if full_redraw: - return fullscreen, [ fullscreen ] - - # Quick checks to see if a dissolve is happening, or something like - # that. - changes = forced | old_forced - - if fullscreen in changes: - return fullscreen, [ fullscreen ] - - # Compute the differences between the two sets, and add those - # to changes. - i0 = 0 - i1 = 0 - bl1set = set(bl1) - - while True: - if i0 >= len(bl0) or i1 >= len(bl1): - break - - b0 = bl0[i0] - b1 = bl1[i1] - - if b0 == b1: - if id(b0[5]) in mutated: - changes.add(b0[:5]) - - i0 += 1 - i1 += 1 - - elif b0 not in bl1set: - changes.add(b0[:5]) - i0 += 1 - - else: - changes.add(b1[:5]) - i1 += 1 - - changes.update(i[:5] for i in bl0[i0:]) - changes.update(i[:5] for i in bl1[i1:]) - - # No changes? Quit. - if not changes: - return None, [ ] - - # Compute the sizes of the updated rectangles. - sized = [ ] - - for x0, y0, x1, y1, (sx0, sy0, sx1, sy1) in changes: - - # Round up by a pixel, to prevent visual artifacts when scaled down. - x1 += 1 - y1 += 1 - - if x0 < sx0: - x0 = sx0 - if y0 < sy0: - y0 = sy0 - if x1 > sx1: - x1 = sx1 - if y1 > sy1: - y1 = sy1 - - w = x1 - x0 - h = y1 - y0 - - if w <= 0 or h <= 0: - continue - - area = w * h - - if area >= sa: - return fullscreen, [ fullscreen ] - - sized.append((area, x0, y0, x1, y1)) - - sized.sort() - - # The list of non-contiguous updates. - noncont = [ ] - - # The total area of noncont. - nca = 0 - - # Pick the largest area, merge with all overlapping smaller areas, repeat - # until no merge possible. - while sized: - area, x0, y0, x1, y1 = sized.pop() - - - merged = False - - if nca + area >= sa: - return (0, 0, sw, sh), [ (0, 0, sw, sh) ] - - i = 0 - - while i < len(sized): - _iarea, ix0, iy0, ix1, iy1 = sized[i] - - if (x0 <= ix0 <= x1 or x0 <= ix1 <= x1) and \ - (y0 <= iy0 <= y1 or y0 <= iy1 <= y1): - - merged = True - x0 = min(x0, ix0) - x1 = max(x1, ix1) - y0 = min(y0, iy0) - y1 = max(y1, iy1) - - area = (x1 - x0) * (y1 - y0) - - sized.pop(i) - - else: - i += 1 - - if merged: - sized.append((area, x0, y0, x1, y1)) - else: - noncont.append((x0, y0, x1, y1)) - nca += area - - if not noncont: - return None, [ ] - - x0, y0, x1, y1 = noncont.pop() - x0 = int(x0) - y0 = int(y0) - x1 = int(math.ceil(x1)) - y1 = int(math.ceil(y1)) - - # A list of (x, y, w, h) tuples for each update. - updates = [ (x0, y0, x1 - x0, y1 - y0) ] - - for ix0, iy0, ix1, iy1 in noncont: - - ix0 = int(ix0) - iy0 = int(iy0) - ix1 = int(math.ceil(ix1)) - iy1 = int(math.ceil(iy1)) - - x0 = min(x0, ix0) - y0 = min(y0, iy0) - x1 = max(x1, ix1) - y1 = max(y1, iy1) - - updates.append((ix0, iy0, ix1 - ix0, iy1 - iy0)) - - return (x0, y0, x1 - x0, y1 - y0), updates - -clippers = [ Clipper() ] - -def surface(w, h, alpha): - """ - Creates a surface that shares a pixel format with the screen. The created - surface will - """ - - if alpha: - rv = pygame.Surface((w + 4, h + 4), pygame.SRCALPHA) - else: - rv = pygame.Surface((w + 4, h + 4), 0) - - return rv.subsurface((2, 2, w, h)) - -def copy_surface(surf): - w, h = surf.get_size() - rv = surface(w, h, True) - - renpy.display.accelerator.nogil_copy(surf, rv) # @UndefinedVariable - return rv - -def draw_special(what, dest, x, y): - """ - This handles the special drawing operations, such as dissolve and - image dissolve. `x` and `y` are the offsets of the thing to be drawn - relative to the destination rectangle, and are always negative. - """ - - dw, dh = dest.get_size() - - w = min(dw, what.width + x) - h = min(dh, what.height + y) - - if w <= 0 or h <= 0: - return - - if what.operation == DISSOLVE: - - bottom = what.children[0][0].render_to_texture(True) - top = what.children[1][0].render_to_texture(True) - - if what.operation_alpha: - target = surface(w, h, True) - else: - target = dest.subsurface((0, 0, w, h)) - - renpy.display.module.blend( - bottom.subsurface((-x, -y, w, h)), - top.subsurface((-x, -y, w, h)), - target, - int(what.operation_complete * 255)) - - if what.operation_alpha: - dest.blit(target, (0, 0)) - - elif what.operation == IMAGEDISSOLVE: - - image = what.children[0][0].render_to_texture(True) - bottom = what.children[1][0].render_to_texture(True) - top = what.children[2][0].render_to_texture(True) - - if what.operation_alpha: - target = surface(w, h, True) - else: - target = dest.subsurface((0, 0, w, h)) - - ramplen = what.operation_parameter - - ramp = "\x00" * 256 - - for i in range(0, ramplen): - ramp += chr(255 * i / ramplen) - - ramp += "\xff" * 256 - - step = int( what.operation_complete * (256 + ramplen) ) - ramp = ramp[step:step+256] - - renpy.display.module.imageblend( - bottom.subsurface((-x, -y, w, h)), - top.subsurface((-x, -y, w, h)), - target, - image.subsurface((-x, -y, w, h)), - ramp) - - if what.operation_alpha: - dest.blit(target, (0, 0)) - - elif what.operation == PIXELLATE: - - surf = what.children[0][0].render_to_texture(False) - - px = what.operation_parameter - - renpy.display.module.pixellate( - surf.subsurface((-x, -y, w, h)), - dest.subsurface((0, 0, w, h)), - px, px, px, px) - - else: - raise Exception("Unknown operation: %d" % what.operation) - - -def draw(dest, clip, what, xo, yo, screen): - """ - This is the simple draw routine, which only works when alpha is 1.0 - and the matrices are None. If those aren't the case, draw_complex - is used instead. - - `dest` - Either a destination surface, or a clipper. - `clip` - If None, we should draw. Otherwise we should clip, and this is - the rectangle to clip to. - `what` - The Render or Surface we're drawing to. - `xo` - The X offset. - `yo` - The Y offset. - `screen` - True if this is a blit to the screen, False otherwise. - """ - - if not isinstance(what, renpy.display.render.Render): - - # Pixel-Aligned blit. - if isinstance(xo, int) and isinstance(yo, int): - if screen: - what = rle_cache.get(what, what) - - if clip: - w, h = what.get_size() - dest.blits.append((xo, yo, xo + w, yo + h, clip, what, None)) - else: - try: - blit_lock.acquire() - dest.blit(what, (xo, yo)) - finally: - blit_lock.release() - - # Subpixel blit. - else: - if clip: - w, h = what.get_size() - dest.blits.append((xo, yo, xo + w, yo + h, clip, what, None)) - else: - renpy.display.module.subpixel(what, dest, xo, yo) - - return - - # Deal with draw functions. - if what.operation != BLIT: - - xo = int(xo) - yo = int(yo) - - if clip: - dx0, dy0, dx1, dy1 = clip - dw = dx1 - dx0 - dh = dy1 - dy0 - else: - dw, dh = dest.get_size() - - if xo >= 0: - newx = 0 - subx = xo - else: - newx = xo - subx = 0 - - if yo >= 0: - newy = 0 - suby = yo - else: - newy = yo - suby = 0 - - if subx >= dw or suby >= dh: - return - - # newx and newy are the offset of this render relative to the - # subsurface. They can only be negative or 0, as otherwise we - # would make a smaller subsurface. - - subw = min(dw - subx, what.width + newx) - subh = min(dh - suby, what.height + newy) - - if subw <= 0 or subh <= 0: - return - - if clip: - dest.forced.add((subx, suby, subx + subw, suby + subh, clip)) - else: - newdest = dest.subsurface((subx, suby, subw, subh)) - # what.draw_func(newdest, newx, newy) - draw_special(what, newdest, newx, newy) - - - return - - # Deal with clipping, if necessary. - if what.clipping: - - if clip: - cx0, cy0, cx1, cy1 = clip - - cx0 = max(cx0, xo) - cy0 = max(cy0, yo) - cx1 = min(cx1, xo + what.width) - cy1 = min(cy1, yo + what.height) - - if cx0 > cx1 or cy0 > cy1: - return - - clip = (cx0, cy0, cx1, cy1) - - dest.forced.add(clip + (clip,)) - return - - else: - - # After this code, x and y are the coordinates of the subsurface - # relative to the destination. xo and yo are the offset of the - # upper-left corner relative to the subsurface. - - if xo >= 0: - x = xo - xo = 0 - else: - x = 0 - # xo = xo - - if yo >= 0: - y = yo - yo = 0 - else: - y = 0 - # yo = yo - - dw, dh = dest.get_size() - - width = min(dw - x, what.width + xo) - height = min(dh - y, what.height + yo) - - if width < 0 or height < 0: - return - - dest = dest.subsurface((x, y, width, height)) - - # Deal with alpha and transforms by passing them off to draw_transformed. - if what.alpha != 1 or (what.forward is not None and what.forward is not IDENTITY): - for child, cxo, cyo, _focus, _main in what.visible_children: - draw_transformed(dest, clip, child, xo + cxo, yo + cyo, - what.alpha, what.forward, what.reverse) - return - - for child, cxo, cyo, _focus, _main in what.visible_children: - draw(dest, clip, child, xo + cxo, yo + cyo, screen) - -def draw_transformed(dest, clip, what, xo, yo, alpha, forward, reverse): - - # If our alpha has hit 0, don't do anything. - if alpha <= 0.003: # (1 / 256) - return - - if forward is None: - forward = IDENTITY - reverse = IDENTITY - - if not isinstance(what, renpy.display.render.Render): - - # Figure out where the other corner of the transformed surface - # is on the screen. - sw, sh = what.get_size() - if clip: - - dx0, dy0, dx1, dy1 = clip - dw = dx1 - dx0 - dh = dy1 - dy0 - - else: - dw, dh = dest.get_size() - - x0, y0 = 0.0, 0.0 - x1, y1 = reverse.transform(sw, 0.0) - x2, y2 = reverse.transform(sw, sh) - x3, y3 = reverse.transform(0.0, sh) - - minx = math.floor(min(x0, x1, x2, x3) + xo) - maxx = math.ceil(max(x0, x1, x2, x3) + xo) - miny = math.floor(min(y0, y1, y2, y3) + yo) - maxy = math.ceil(max(y0, y1, y2, y3) + yo) - - if minx < 0: - minx = 0 - if miny < 0: - miny = 0 - - if maxx > dw: - maxx = dw - if maxy > dh: - maxy = dh - - if minx > dw or miny > dh or maxx < 0 or maxy < 0: - return - - cx, cy = forward.transform(minx - xo, miny - yo) - - if clip: - - dest.blits.append( - (minx, miny, maxx + dx0, maxy + dy0, clip, what, - (cx, cy, - forward.xdx, forward.ydx, - forward.xdy, forward.ydy, - alpha))) - - else: - - dest = dest.subsurface((minx, miny, maxx - minx, maxy - miny)) - - renpy.display.module.transform( - what, dest, - cx, cy, - forward.xdx, forward.ydx, - forward.xdy, forward.ydy, - alpha, True) - - return - - if what.clipping: - - if reverse.xdy or reverse.ydx: - draw_transformed(dest, clip, what.pygame_surface(True), xo, yo, alpha, forward, reverse) - return - - width = what.width * reverse.xdx - height = what.height * reverse.ydy - - if clip: - cx0, cy0, cx1, cy1 = clip - - cx0 = max(cx0, xo) - cy0 = max(cy0, yo) - cx1 = min(cx1, xo + width) - cy1 = min(cy1, yo + height) - - if cx0 > cx1 or cy0 > cy1: - return - - clip = (cx0, cy0, cx1, cy1) - - dest.forced.add(clip + (clip,)) - return - - else: - - # After this code, x and y are the coordinates of the subsurface - # relative to the destination. xo and yo are the offset of the - # upper-left corner relative to the subsurface. - - if xo >= 0: - x = xo - xo = 0 - else: - x = 0 - # xo = xo - - if yo >= 0: - y = yo - yo = 0 - else: - y = 0 - # yo = yo - - dw, dh = dest.get_size() - - width = min(dw - x, width + xo) - height = min(dh - y, height + yo) - - if width < 0 or height < 0: - return - - dest = dest.subsurface((x, y, width, height)) - - if what.draw_func or what.operation != BLIT: - child = what.pygame_surface(True) - draw_transformed(dest, clip, child, xo, yo, alpha, forward, reverse) - return - - for child, cxo, cyo, _focus, _main in what.visible_children: - - cxo, cyo = reverse.transform(cxo, cyo) - - if what.forward: - child_forward = forward * what.forward - child_reverse = what.reverse * reverse - else: - child_forward = forward - child_reverse = reverse - - draw_transformed(dest, clip, child, xo + cxo, yo + cyo, alpha * what.alpha, child_forward, child_reverse) - - - -def do_draw_screen(screen_render, full_redraw, swdraw): - """ - Draws the render produced by render_screen to the screen. - """ - - yoffset = xoffset = 0 - - screen_render.is_opaque() - - clip = (xoffset, yoffset, xoffset + screen_render.width, yoffset + screen_render.height) - clipper = clippers[0] - - draw(clipper, clip, screen_render, xoffset, yoffset, True) - - cliprect, updates = clipper.compute(full_redraw) - - if cliprect is None: - return [ ] - - x, y, _w, _h = cliprect - - dest = swdraw.window.subsurface(cliprect) - draw(dest, None, screen_render, -x, -y, True) - - return updates - - -class SWDraw(object): - """ - This uses the software renderer to draw to the screen. - """ - - def __init__(self): - self.display_info = None - - self.reset() - - def reset(self): - - # Should we draw the screen? - self.suppressed_blit = False - - # The earliest time at which the next frame can be redrawn. - self.next_frame = 0 - - # Mouse re-drawing. - self.mouse_location = None - self.mouse_backing = None - self.mouse_backing_pos = None - self.mouse_info = None - - - # Is the mouse currently visible? - self.mouse_old_visible = None - - # This is used to cache the surface->texture operation. - self.texture_cache = weakref.WeakKeyDictionary() - - # This is used to display video to the screen. - self.fullscreen_surface = None - - # Info. - self.info = { "renderer" : "sw", "resizable" : False } - - pygame.display.init() - renpy.display.interface.post_init() - - if self.display_info is None: - self.display_info = pygame.display.Info() - - # The scale factor we use for this display. - self.scale_factor = 1.0 - - # Should we scale fast, or scale good-looking? - self.scale_fast = "RENPY_SCALE_FAST" in os.environ - - # The screen returned to us from pygame. - self.screen = None - - # The window that we render into, if not the screen. This has a - # 1px border around it iff we're scaling. - self.window = None - - def set_mode(self, virtual_size, physical_size, fullscreen): - - # Reset before resize. - renpy.display.interface.kill_textures_and_surfaces() - self.reset() - - width, height = virtual_size - - # Set up scaling, if necessary. - screen_width = self.display_info.current_w - screen_height = self.display_info.current_h - - if not fullscreen: - screen_height -= 102 - screen_width -= 102 - - scale_factor = min(1.0 * screen_width / width, 1.0 * screen_height / height, 1.0) - if "RENPY_SCALE_FACTOR" in os.environ: - scale_factor = float(os.environ["RENPY_SCALE_FACTOR"]) - self.scale_factor = scale_factor - - # Figure out the fullscreen info. - if fullscreen: - fsflag = pygame.FULLSCREEN - else: - fsflag = 0 - - # If a window exists of the right size and flags, use it. Otherwise, - # make our own window. - old_screen = pygame.display.get_surface() - - scaled_width = int(width * scale_factor) - scaled_height = int(height * scale_factor) - - if ((old_screen is not None) and - (old_screen.get_size() == (scaled_width, scaled_height)) and - (old_screen.get_flags() & pygame.FULLSCREEN == fsflag)): - - self.screen = old_screen - - else: - self.screen = pygame.display.set_mode((scaled_width, scaled_height), fsflag, 32) - - if scale_factor != 1.0: - self.window = surface(width, height, True) - else: - self.window = self.screen - - renpy.display.pgrender.set_rgba_masks() - - # Should we redraw the screen from scratch? - self.full_redraw = True - - # The surface used to display fullscreen video. - self.fullscreen_surface = self.screen - - # Reset this on a mode change. - self.mouse_location = None - self.mouse_backing = None - self.mouse_backing_pos = None - self.mouse_info = None - - return True - - # private - def show_mouse(self, pos, info): - """ - Actually shows the mouse. - """ - - self.mouse_location = pos - self.mouse_info = info - - mxo, myo, tex = info - - mx, my = pos - mw, mh = tex.get_size() - - bx = mx - mxo - by = my - myo - - self.mouse_backing_pos = (bx, by) - self.mouse_backing = surface(mw, mh, False) - self.mouse_backing.blit(self.window, (0, 0), (bx, by, mw, mh)) - - self.screen.blit(tex, (bx, by)) - - return bx, by, mw, mh - - # private - def hide_mouse(self): - """ - Actually hides the mouse. - """ - - size = self.mouse_backing.get_size() - self.screen.blit(self.mouse_backing, self.mouse_backing_pos) - - rv = self.mouse_backing_pos + size - - self.mouse_backing = None - self.mouse_backing_pos = None - self.mouse_location = None - - return rv - - # private - def draw_mouse(self, show_mouse): - """ - This draws the mouse to the screen, if necessary. It uses the - buffer to minimize the amount of the screen that needs to be - drawn, and only redraws if the mouse has actually been moved. - """ - - hardware, x, y, tex = renpy.game.interface.get_mouse_info() - - if self.mouse_old_visible != hardware: - pygame.mouse.set_visible(hardware) - self.mouse_old_visible = hardware - - # The rest of this is for the software mouse. - - if self.suppressed_blit: - return [ ] - - if not show_mouse: - tex = None - - info = (x, y, tex) - pos = pygame.mouse.get_pos() - - if (pos == self.mouse_location and tex and info == self.mouse_info): - return [ ] - - updates = [ ] - - if self.mouse_location: - updates.append(self.hide_mouse()) - - if tex and pos and renpy.game.interface.focused: - updates.append(self.show_mouse(pos, info)) - - return updates - - def update_mouse(self): - """ - Draws the mouse, and then updates the screen. - """ - - updates = self.draw_mouse(True) - - if updates: - pygame.display.update(updates) - - def mouse_event(self, ev): - x, y = getattr(ev, 'pos', pygame.mouse.get_pos()) - - x /= self.scale_factor - y /= self.scale_factor - - return x, y - - def get_mouse_pos(self): - x, y = pygame.mouse.get_pos() - - x /= self.scale_factor - y /= self.scale_factor - - return x, y - - - def screenshot(self, surftree, fullscreen_video): - """ - Returns a pygame surface containing a screenshot. - """ - - return self.window - - def should_redraw(self, needs_redraw, first_pass): - """ - Uses the framerate to determine if we can and should redraw. - """ - - if not needs_redraw: - return False - - framerate = renpy.config.framerate - - if framerate is None: - return True - - next_frame = self.next_frame - now = pygame.time.get_ticks() - - frametime = 1000.0 / framerate - - # Handle timer rollover. - if next_frame > now + frametime: - next_frame = now - - # It's not yet time for the next frame. - if now < next_frame and not first_pass: - return False - - # Otherwise, it is. Schedule the next frame. - # if next_frame + frametime < now: - next_frame = now + frametime - # else: - # next_frame += frametime - - self.next_frame = next_frame - - return True - - - def draw_screen(self, surftree, fullscreen_video): - """ - Draws the screen. - """ - - if not fullscreen_video: - - updates = [ ] - - updates.extend(self.draw_mouse(False)) - - damage = do_draw_screen(surftree, self.full_redraw, self) - - if damage: - updates.extend(damage) - - self.full_redraw = False - - if self.window is self.screen: - - updates.extend(self.draw_mouse(True)) - pygame.display.update(updates) - - else: - - if self.scale_fast: - pygame.transform.scale(self.window, self.screen.get_size(), self.screen) - else: - renpy.display.scale.smoothscale(self.window, self.screen.get_size(), self.screen) - - self.draw_mouse(True) - pygame.display.flip() - - else: - pygame.display.flip() - self.full_redraw = True - - self.suppressed_blit = fullscreen_video - - - def render_to_texture(self, render, alpha): - - rv = surface(render.width, render.height, alpha) - draw(rv, None, render, 0, 0, False) - - return rv - - def is_pixel_opaque(self, what, x, y): - - if x < 0 or y < 0 or x >= what.width or y >= what.height: - return 0 - - for (child, xo, yo, _focus, _main) in what.visible_children: - cx = x - xo - cy = y - yo - - if what.forward: - cx, cy = what.forward.transform(cx, cy) - - - if isinstance(child, renpy.display.render.Render): - if self.is_pixel_opaque(child, x, y): - return True - - else: - cx = int(cx) - cy = int(cy) - - cw, ch = child.get_size() - if cx >= cw or cy >= ch: - return False - - - - if not child.get_masks()[3] or child.get_at((cx, cy))[3]: - return True - - return False - - - def mutated_surface(self, surf): - """ - Called to indicate that the given surface has changed. - """ - - for i in clippers: - i.mutated.add(id(surf)) - - if surf in rle_cache: - del rle_cache[surf] - - - def load_texture(self, surf, transient=False): - """ - Creates a texture from the surface. In the software implementation, - the only difference between a texture and a surface is that a texture - is in the RLE cache. - """ - - surf = copy_surface(surf) - self.mutated_surface(surf) - - if transient: - return surf - - if renpy.game.less_memory: - return surf - - if surf not in rle_cache: - rle_surf = copy_surface(surf) - rle_surf.set_alpha(255, pygame.RLEACCEL) - self.mutated_surface(rle_surf) - - rle_cache[surf] = rle_surf - - return surf - - def solid_texture(self, w, h, color): - """ - Creates a texture filled to the edges with color. - """ - - surf = surface(w + 4, h + 4, True) - surf.fill(color) - self.mutated_surface(surf) - - surf = surf.subsurface((2, 2, w, h)) - - self.mutated_surface(surf) - return surf - - - def free_memory(self): - """ - Frees up memory. - """ - - rle_cache.clear() - - def deinit(self): - """ - Called when we're restarted. - """ - - renpy.display.render.free_memory() - - return - - def quit(self): #@ReservedAssignment - """ - Shuts down the drawing system. - """ - - pygame.display.quit() - - return - - def event_peek_sleep(self): - """ - Wait a little bit so the CPU doesn't speed up. - """ - - time.sleep(.0001) - - def get_physical_size(self): - """ - Return the physical width and height of the screen. - """ - return renpy.config.screen_width, renpy.config.screen_height diff --git a/unrpyc/renpy/display/transition.py b/unrpyc/renpy/display/transition.py deleted file mode 100644 index 7f93312..0000000 --- a/unrpyc/renpy/display/transition.py +++ /dev/null @@ -1,922 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# NOTE: -# Transitions need to be able to work even when old_widget and new_widget -# are None, at least to the point of making it through __init__. This is -# so that prediction of images works. - -import renpy.display -from renpy.display.render import render - - -class Transition(renpy.display.core.Displayable): - """ - This is the base class of most transitions. It takes care of event - dispatching. - """ - - def __init__(self, delay, **properties): - super(Transition, self).__init__(**properties) - self.delay = delay - self.events = True - - def event(self, ev, x, y, st): - - if self.events or ev.type == renpy.display.core.TIMEEVENT: - return self.new_widget.event(ev, x, y, st) # E1101 - else: - return None - - def visit(self): - return [ self.new_widget, self.old_widget ] # E1101 - - -def null_render(d, width, height, st, at): - - d.events = True - surf = renpy.display.render.render(d.new_widget, - width, - height, - st, at) - - rv = renpy.display.render.Render(surf.width, surf.height) - rv.blit(surf, (0, 0)) - - return rv - -class NoTransition(Transition): - """ - :doc: transition function - :args: (delay) - - Returns a transition that only displays the new screen for `delay` seconds. - It can be useful as part of a MultipleTransition. - """ - - def __init__(self, delay, old_widget=None, new_widget=None, **properties): - super(NoTransition, self).__init__(delay, **properties) - - self.old_widget = old_widget - self.new_widget = new_widget - self.events = True - - def render(self, width, height, st, at): - return null_render(self, width, height, st, at) - - -class MultipleTransition(Transition): - """ - :doc: transition function - :args: (args) - - Returns a transition that allows multiple transitions to be displayed, one - after the other. - - `args` - A list containing an odd number of items. The first, third, and - other odd-numbered items must be scenes, and the even items - must be transitions. A scene can be one of: - - * A displayable. - * False, to use the old scene. - * True, to use the new scene. - - Almost always, the first argument will be False and the last True. - - The transitions in `args` are applied in order. For each transition, - the old scene is the screen preceding it, and the new scene is the - scene following it. For example:: - - define logodissolve = MultipleTransition( - False, Dissolve(0.5) - "logo.jpg", NoTransition(1.0), - "logo.jpg", dissolve, - True) - - This example will dissolve to logo.jpg, wait 1 second, and then - dissolve to the new scene. - """ - - def __init__(self, args, old_widget=None, new_widget=None, **properties): - - if len(args) % 2 != 1 or len(args) < 3: - raise Exception("MultipleTransition requires an odd number of arguments, and at least 3 arguments.") - - self.transitions = [ ] - - # The screens that we use for the transition. - self.screens = [ renpy.easy.displayable(i) for i in args[0::2] ] - - def oldnew(w): - if w is False: - return old_widget - if w is True: - return new_widget - - return w - - for old, trans, new in zip(self.screens[0:], args[1::2], self.screens[1:]): - old = oldnew(old) - new = oldnew(new) - - self.transitions.append(trans(old_widget=old, new_widget=new)) - - super(MultipleTransition, self).__init__(sum([i.delay for i in self.transitions]), **properties) - - self.new_widget = self.transitions[-1] - self.events = False - - def visit(self): - return [ i for i in self.screens if isinstance(i, renpy.display.core.Displayable)] + self.transitions - - def event(self, ev, x, y, st): - - if self.events or ev.type == renpy.display.core.TIMEEVENT: - return self.transitions[-1].event(ev, x, y, st) - else: - return None - - def render(self, width, height, st, at): - - if renpy.game.less_updates: - return null_render(self, width, height, st, at) - - for trans in self.transitions[:-1]: - - if trans.delay > st: - break - - st -= trans.delay - - else: - - trans = self.transitions[-1] - self.events = True - - if trans is not self.transitions[-1]: - renpy.display.render.render(self.transitions[-1], width, height, 0, 0) - - surf = renpy.display.render.render(trans, width, height, st, at) - width, height = surf.get_size() - rv = renpy.display.render.Render(width, height) - rv.blit(surf, (0, 0)) - - if st < trans.delay: - renpy.display.render.redraw(self, trans.delay - st) - - return rv - - -def Fade(out_time, - hold_time, - in_time, - old_widget=None, - new_widget=None, - color=None, - widget=None, - alpha=False, - ): - - """ - :doc: transition function - :args: (out_time, hold_time, in_time, color="#000") - :name: Fade - - Returns a transition that takes `out_time` seconds to fade to - a screen filled with `color`, holds at that screen for `hold_time` - seconds, and then takes `in_time` to fade to then new screen. - - :: - - # Fade to black and back. - define fade = Fade(0.5, 0.0, 0.5) - - # Hold at black for a bit. - define fadehold = Fade(0.5, 1.0, 0.5) - - # Camera flash - quickly fades to white, then back to the scene. - define flash = Fade(0.1, 0.0, 0.5, color="#fff") - """ - - dissolve = renpy.curry.curry(Dissolve) - notrans = renpy.curry.curry(NoTransition) - - widget = renpy.easy.displayable_or_none(widget) - - if color: - widget = renpy.display.image.Solid(color) - - if not widget: - widget = renpy.display.image.Solid((0, 0, 0, 255)) - - args = [ False, dissolve(out_time, alpha=alpha), widget ] - - if hold_time: - args.extend([ notrans(hold_time), widget, ]) - - args.extend([dissolve(in_time, alpha=alpha), True ]) - - return MultipleTransition(args, old_widget=old_widget, new_widget=new_widget) - - -class Pixellate(Transition): - """ - :doc: transition function - :args: (time, steps) - :name: Pixellate - - Returns a transition that pixellates out the old screen, and then - pixellates in the new screen. - - `time` - The total time the transition will take, in seconds. - - `steps` - The number of steps that will occur, in each direction. Each step - creates pixels about twice the size of those in the previous step, - so a 5-step pixellation will create 32x32 pixels. - """ - - def __init__(self, time, steps, old_widget=None, new_widget=None, **properties): - - time = float(time) - - super(Pixellate, self).__init__(time, **properties) - - self.time = time - self.steps = steps - - self.old_widget = old_widget - self.new_widget = new_widget - - self.events = False - - self.quantum = time / (2 * steps) - - def render(self, width, height, st, at): - - if renpy.game.less_updates: - return null_render(self, width, height, st, at) - - if st >= self.time: - self.events = True - return render(self.new_widget, width, height, st, at) - - step = st // self.quantum + 1 - visible = self.old_widget - - if step > self.steps: - step = (self.steps * 2) - step + 1 - visible = self.new_widget - self.events = True - - - rdr = render(visible, width, height, st, at) - rv = renpy.display.render.Render(rdr.width, rdr.height) - - rv.blit(rdr, (0, 0)) - - rv.operation = renpy.display.render.PIXELLATE - rv.operation_parameter = 2 ** step - - renpy.display.render.redraw(self, 0) - - return rv - - -class Dissolve(Transition): - """ - :doc: transition function - :args: (time, alpha=False, time_warp=None) - :name: Dissolve - - Returns a transition that dissolves from the old scene to the new scene. - - `time` - The time the dissolve will take. - - `alpha` - If true, the dissolve will alpha-composite the the result of the - transition with the screen. If false, the result of the transition - will replace the screen, which is more efficient. - - `time_warp` - A function that adjusts the timeline. If not None, this should be a - function that takes a fractional time between 0.0 and 1.0, and returns - a number in the same range. - """ - - __version__ = 1 - - def after_upgrade(self, version): - if version < 1: - self.alpha = False - - time_warp = None - - def __init__(self, time, old_widget=None, new_widget=None, alpha=False, time_warp=None, **properties): - super(Dissolve, self).__init__(time, **properties) - - self.time = time - self.old_widget = old_widget - self.new_widget = new_widget - self.events = False - self.alpha = alpha - self.time_warp = time_warp - - - def render(self, width, height, st, at): - - if renpy.game.less_updates: - return null_render(self, width, height, st, at) - - if st >= self.time: - self.events = True - return render(self.new_widget, width, height, st, at) - - complete = min(1.0, st / self.time) - - if self.time_warp is not None: - complete = self.time_warp(complete) - - bottom = render(self.old_widget, width, height, st, at) - top = render(self.new_widget, width, height, st, at) - - width = min(top.width, bottom.width) - height = min(top.height, bottom.height) - - rv = renpy.display.render.Render(width, height, opaque=not self.alpha) - - rv.operation = renpy.display.render.DISSOLVE - rv.operation_alpha = self.alpha - rv.operation_complete = complete - - rv.blit(bottom, (0, 0), focus=False, main=False) - rv.blit(top, (0, 0), focus=True, main=True) - - renpy.display.render.redraw(self, 0) - - return rv - - -class ImageDissolve(Transition): - """ - :doc: transition function - :args: (image, time, ramplen=8, reverse=False, alpha=True, time_warp=None) - :name: ImageDissolve - - Returns a transition that dissolves the old scene into the new scene, using - an image to control the dissolve process. This means that white pixels will - dissolve in first, and black pixels will dissolve in last. - - `image` - A control image to use. This must be either an image file or - image manipulator. The control image should be the size of - the scenes being dissolved. - - `time` - The time the dissolve will take. - - `ramplen` - The length of the ramp to use. This must be an integer power - of 2. When this is the default value of 8, when a white pixel - is fully dissolved, a pixel 8 shades of gray darker will have - completed one step of dissolving in. - - `reverse` - If true, black pixels will dissolve in before white pixels. - - `alpha` - If true, the dissolve will alpha-composite the the result of the - transition with the screen. If false, the result of the transition - will replace the screen, which is more efficient. - - `time_warp` - A function that adjusts the timeline. If not None, this should be a - function that takes a fractional time between 0.0 and 1.0, and returns - a number in the same range. - - :: - - define circirisout = ImageDissolve("circiris.png", 1.0) - define circirisin = ImageDissolve("circiris.png", 1.0, reverse=True) - define circiristbigramp = ImageDissolve("circiris.png", 1.0, ramplen=256) - """ - - __version__ = 1 - - def after_upgrade(self, version): - if version < 1: - self.alpha = False - - time_warp = None - - def __init__( - self, - image, - time, - ramplen=8, - ramptype='linear', - ramp=None, - reverse=False, - alpha=False, - old_widget=None, - new_widget=None, - time_warp=None, - **properties): - - # ramptype and ramp are now unused, but are kept for compatbility with - # older code. - - super(ImageDissolve, self).__init__(time, **properties) - - self.old_widget = old_widget - self.new_widget = new_widget - self.events = False - self.alpha = alpha - self.time_warp = time_warp - - if not reverse: - - # Copies red -> alpha - matrix = renpy.display.im.matrix( - 0, 0, 0, 0, 1, - 0, 0, 0, 0, 1, - 0, 0, 0, 0, 1, - 1, 0, 0, 0, 0) - - else: - - # Copies 1-red -> alpha - matrix = renpy.display.im.matrix( - 0, 0, 0, 0, 1, - 0, 0, 0, 0, 1, - 0, 0, 0, 0, 1, - - 1, 0, 0, 0, 1) - - self.image = renpy.display.im.MatrixColor(image, matrix) - - if ramp is not None: - ramplen = len(ramp) - - # The length of the ramp. - self.ramplen = max(ramplen, 1) - - - def visit(self): - return super(ImageDissolve, self).visit() + [ self.image ] - - - def render(self, width, height, st, at): - - if renpy.game.less_updates or renpy.display.less_imagedissolve: - return null_render(self, width, height, st, at) - - if st >= self.delay: - self.events = True - return render(self.new_widget, width, height, st, at) - - image = render(self.image, width, height, st, at) - bottom = render(self.old_widget, width, height, st, at) - top = render(self.new_widget, width, height, st, at) - - width = min(bottom.width, top.width, image.width) - height = min(bottom.height, top.height, image.height) - - rv = renpy.display.render.Render(width, height, opaque=not self.alpha) - - complete = st / self.delay - - if self.time_warp is not None: - complete = self.time_warp(complete) - - rv.operation = renpy.display.render.IMAGEDISSOLVE - rv.operation_alpha = self.alpha - rv.operation_complete = complete - rv.operation_parameter = self.ramplen - - rv.blit(image, (0, 0), focus=False, main=False) - rv.blit(bottom, (0, 0), focus=False, main=False) - rv.blit(top, (0, 0), focus=True, main=True) - - renpy.display.render.redraw(self, 0) - - return rv - - -class AlphaDissolve(Transition): - """ - :doc: transition function - :args: (control, delay=0.0, alpha=False, reverse=False) - - Returns a transition that uses a control displayable (almost always some - sort of animated transform) to transition from one screen to another. The - transform is evaluated. The new screen is used where the transform is - opaque, and the old image is used when it is transparent. - - `control` - The control transform. - - `delay` - The time the transition takes, before ending. - - `alpha` - If true, the image is composited with what's behind it. If false, - the default, the image is opaque and overwrites what's behind it. - - `reverse` - If true, the alpha channel is reversed. Opaque areas are taken - from the old image, while transparent areas are taken from the - new image. - """ - - def __init__( - self, - control, - delay=0.0, - old_widget=None, - new_widget=None, - alpha=False, - reverse=False, - **properties): - - super(AlphaDissolve, self).__init__(delay, **properties) - - self.control = renpy.display.layout.Fixed() - self.control.add(control) - - self.old_widget = renpy.easy.displayable(old_widget) - self.new_widget = renpy.easy.displayable(new_widget) - self.events = False - - self.alpha = alpha - self.reverse = reverse - - def visit(self): - return super(AlphaDissolve, self).visit() + [ self.control ] - - def render(self, width, height, st, at): - - if renpy.game.less_updates or renpy.display.less_imagedissolve: - return null_render(self, width, height, st, at) - - if st >= self.delay: - self.events = True - - bottom = render(self.old_widget, width, height, st, at) - top = render(self.new_widget, width, height, st, at) - - width = min(bottom.width, top.width) - height = min(bottom.height, top.height) - - control = render(self.control, width, height, st, at) - - rv = renpy.display.render.Render(width, height, opaque=not self.alpha) - - rv.operation = renpy.display.render.IMAGEDISSOLVE - rv.operation_alpha = self.alpha - rv.operation_complete = 256.0 / (256.0 + 256.0) - rv.operation_parameter = 256 - - rv.blit(control, (0, 0), focus=False, main=False) - - if not self.reverse: - rv.blit(bottom, (0, 0), focus=False, main=False) - rv.blit(top, (0, 0), focus=True, main=True) - else: - rv.blit(top, (0, 0), focus=True, main=True) - rv.blit(bottom, (0, 0), focus=False, main=False) - - return rv - - -class CropMove(Transition): - """ - :doc: transition function - :args: (time, mode="slideright", startcrop=(0.0, 0.0, 0.0, 1.0), startpos=(0.0, 0.0), endcrop=(0.0, 0.0, 1.0, 1.0), endpos=(0.0, 0.0), topnew=True) - :name: CropMove - - Returns a transition that works by cropping a scene and positioning it on the - screen. This can be used to implement a variety of effects, all of which - involved changing rectangular slices of scenes. - - `time` - The time the transition takes. - - `mode` - The name of the mode of the transition. There are three groups - of modes: wipes, slides, and other. This can also be "custom", - to allow a custom mode to be defined. - - In a wipe, the image stays fixed, and more of it is revealed as - the transition progresses. For example, in "wiperight", a wipe from left to right, first the left edge of the image is - revealed at the left edge of the screen, then the center of the image, - and finally the right side of the image at the right of the screen. - Other supported wipes are "wipeleft", "wipedown", and "wipeup". - - In a slide, the image moves. So in a "slideright", the right edge of the - image starts at the left edge of the screen, and moves to the right - as the transition progresses. Other slides are "slideleft", "slidedown", - and "slideup". - - There are also slideaways, in which the old image moves on top of - the new image. Slideaways include "slideawayright", "slideawayleft", - "slideawayup", and "slideawaydown". - - We also support a rectangular iris in with "irisin" and a - rectangular iris out with "irisout". - - The following parameters are only respected if the mode is "custom". Positions - are relative to the size of the screen, while the crops are relative to the - size of the image. So a crop of (0.25, 0.0, 0.5, 1.0) takes the middle - half of an image. - - `startcrop` - The starting rectangle that is cropped out of the - top image. A 4-element tuple containing x, y, width, and height. - - `startpos` - The starting place that the top image is drawn - to the screen at, a 2-element tuple containing x and y. - - `endcrop` - The ending rectangle that is cropped out of the - top image. A 4-element tuple containing x, y, width, and height. - - `endpos` - The ending place that the top image is drawn - to the screen at, a 2-element tuple containing x and y. - - `topnew` - If true, the scene that is cropped and moved (and is on top of - the other scene) is the new scene. If false, it is the old scene. - - :: - - define wiperight = CropMove(1.0, "wiperight") - define wipeleft = CropMove(1.0, "wipeleft") - define wipeup = CropMove(1.0, "wipeup") - define wipedown = CropMove(1.0, "wipedown") - - define slideright = CropMove(1.0, "slideright") - define slideleft = CropMove(1.0, "slideleft") - define slideup = CropMove(1.0, "slideup") - define slidedown = CropMove(1.0, "slidedown") - - define slideawayright = CropMove(1.0, "slideawayright") - define slideawayleft = CropMove(1.0, "slideawayleft") - define slideawayup = CropMove(1.0, "slideawayup") - define slideawaydown = CropMove(1.0, "slideawaydown") - - define irisout = CropMove(1.0, "irisout") - define irisin = CropMove(1.0, "irisin") - """ - - def __init__(self, time, - mode="slideright", - startcrop=(0.0, 0.0, 0.0, 1.0), - startpos=(0.0, 0.0), - endcrop=(0.0, 0.0, 1.0, 1.0), - endpos=(0.0, 0.0), - topnew=True, - old_widget=None, - new_widget=None, - **properties): - - super(CropMove, self).__init__(time, **properties) - self.time = time - - if mode == "wiperight": - startpos = (0.0, 0.0) - startcrop = (0.0, 0.0, 0.0, 1.0) - endpos = (0.0, 0.0) - endcrop = (0.0, 0.0, 1.0, 1.0) - topnew = True - - elif mode == "wipeleft": - startpos = (1.0, 0.0) - startcrop = (1.0, 0.0, 0.0, 1.0) - endpos = (0.0, 0.0) - endcrop = (0.0, 0.0, 1.0, 1.0) - topnew = True - - elif mode == "wipedown": - startpos = (0.0, 0.0) - startcrop = (0.0, 0.0, 1.0, 0.0) - endpos = (0.0, 0.0) - endcrop = (0.0, 0.0, 1.0, 1.0) - topnew = True - - elif mode == "wipeup": - startpos = (0.0, 1.0) - startcrop = (0.0, 1.0, 1.0, 0.0) - endpos = (0.0, 0.0) - endcrop = (0.0, 0.0, 1.0, 1.0) - topnew = True - - elif mode == "slideright": - startpos = (0.0, 0.0) - startcrop = (1.0, 0.0, 0.0, 1.0) - endpos = (0.0, 0.0) - endcrop = (0.0, 0.0, 1.0, 1.0) - topnew = True - - elif mode == "slideleft": - startpos = (1.0, 0.0) - startcrop = (0.0, 0.0, 0.0, 1.0) - endpos = (0.0, 0.0) - endcrop = (0.0, 0.0, 1.0, 1.0) - topnew = True - - elif mode == "slideup": - startpos = (0.0, 1.0) - startcrop = (0.0, 0.0, 1.0, 0.0) - endpos = (0.0, 0.0) - endcrop = (0.0, 0.0, 1.0, 1.0) - topnew = True - - elif mode == "slidedown": - startpos = (0.0, 0.0) - startcrop = (0.0, 1.0, 1.0, 0.0) - endpos = (0.0, 0.0) - endcrop = (0.0, 0.0, 1.0, 1.0) - topnew = True - - elif mode == "slideawayleft": - endpos = (0.0, 0.0) - endcrop = (1.0, 0.0, 0.0, 1.0) - startpos = (0.0, 0.0) - startcrop = (0.0, 0.0, 1.0, 1.0) - topnew = False - - elif mode == "slideawayright": - endpos = (1.0, 0.0) - endcrop = (0.0, 0.0, 0.0, 1.0) - startpos = (0.0, 0.0) - startcrop = (0.0, 0.0, 1.0, 1.0) - topnew = False - - elif mode == "slideawaydown": - endpos = (0.0, 1.0) - endcrop = (0.0, 0.0, 1.0, 0.0) - startpos = (0.0, 0.0) - startcrop = (0.0, 0.0, 1.0, 1.0) - topnew = False - - elif mode == "slideawayup": - endpos = (0.0, 0.0) - endcrop = (0.0, 1.0, 1.0, 0.0) - startpos = (0.0, 0.0) - startcrop = (0.0, 0.0, 1.0, 1.0) - topnew = False - - elif mode == "irisout": - startpos = (0.5, 0.5) - startcrop = (0.5, 0.5, 0.0, 0.0) - endpos = (0.0, 0.0) - endcrop = (0.0, 0.0, 1.0, 1.0) - topnew = True - - elif mode == "irisin": - startpos = (0.0, 0.0) - startcrop = (0.0, 0.0, 1.0, 1.0) - endpos = (0.5, 0.5) - endcrop = (0.5, 0.5, 0.0, 0.0) - topnew = False - - - elif mode == "custom": - pass - else: - raise Exception("Invalid mode %s passed into CropMove." % mode) - - self.delay = time - self.time = time - - self.startpos = startpos - self.endpos = endpos - - self.startcrop = startcrop - self.endcrop = endcrop - - self.topnew = topnew - - self.old_widget = old_widget - self.new_widget = new_widget - - self.events = False - - if topnew: - self.bottom = old_widget - self.top = new_widget - else: - self.bottom = new_widget - self.top = old_widget - - def render(self, width, height, st, at): - - if renpy.game.less_updates: - return null_render(self, width, height, st, at) - - time = 1.0 * st / self.time - - # Done rendering. - if time >= 1.0: - self.events = True - return render(self.new_widget, width, height, st, at) - - # How we scale each element of a tuple. - scales = (width, height, width, height) - - def interpolate_tuple(t0, t1): - return tuple([ int(s * (a * (1.0 - time) + b * time)) - for a, b, s in zip(t0, t1, scales) ]) - - crop = interpolate_tuple(self.startcrop, self.endcrop) - pos = interpolate_tuple(self.startpos, self.endpos) - - - top = render(self.top, width, height, st, at) - bottom = render(self.bottom, width, height, st, at) - - width = min(bottom.width, width) - height = min(bottom.height, height) - rv = renpy.display.render.Render(width, height) - - rv.blit(bottom, (0, 0), focus=not self.topnew) - - ss = top.subsurface(crop, focus=self.topnew) - rv.blit(ss, pos, focus=self.topnew) - - renpy.display.render.redraw(self, 0) - return rv - - -def ComposeTransition(trans, before=None, after=None, new_widget=None, old_widget=None): - """ - :doc: transition function - :args: (trans, before, after) - - Returns a transition that composes up to three transitions. If not None, - the `before` and `after` transitions are applied to the old and new - scenes, respectively. These updated old and new scenes are then supplied - to the `trans` transition. - - :: - - # Move the images in and out while dissolving. (This is a fairly expensive transition.) - define moveinoutdissolve = ComposeTransition(dissolve, before=moveoutleft, after=moveinright) - """ - - if before is not None: - old = before(new_widget=new_widget, old_widget=old_widget) - else: - old = old_widget - - if after is not None: - new = after(new_widget=new_widget, old_widget=old_widget) - else: - new = new_widget - - return trans(new_widget=new, old_widget=old) - - -def SubTransition(rect, trans, old_widget=None, new_widget=None, **properties): - """ - Applies a transition to a subset of the screen. Not documented. - """ - - x, y, _w, _h = rect - - old = renpy.display.layout.LiveCrop(rect, old_widget) - new = renpy.display.layout.LiveCrop(rect, new_widget) - - inner = trans(old_widget=old, new_widget=new) - delay = inner.delay - inner = renpy.display.layout.Position(inner, xpos=x, ypos=y, xanchor=0, yanchor=0) - - f = renpy.display.layout.MultiBox(layout='fixed') - f.add(new_widget) - f.add(inner) - - return NoTransition(delay, old_widget=f, new_widget=f) - diff --git a/unrpyc/renpy/display/video.py b/unrpyc/renpy/display/video.py deleted file mode 100644 index 5451e89..0000000 --- a/unrpyc/renpy/display/video.py +++ /dev/null @@ -1,234 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -import renpy.display -import renpy.audio - -# The movie displayable that's currently being shown on the screen. -current_movie = None - -# True if the movie that is currently displaying is in fullscreen mode, -# False if it's a smaller size. -fullscreen = False - -# The size of a Movie object that hasn't had an explicit size set. -default_size = (400, 300) - -# The file we allocated the surface for. -surface_file = None - -# The surface to display the movie on, if not fullscreen. -surface = None - -def movie_stop(clear=True, only_fullscreen=False): - """ - Stops the currently playing movie. - """ - - if (not fullscreen) and only_fullscreen: - return - - renpy.audio.music.stop(channel='movie') - - -def movie_start(filename, size=None, loops=0): - """ - This starts a movie playing. - """ - - if renpy.game.less_updates: - return - - global default_size - - if size is not None: - default_size = size - - filename = [ filename ] - - if loops == -1: - loop = True - else: - loop = False - filename = filename * (loops + 1) - - renpy.audio.music.play(filename, channel='movie', loop=loop) - -movie_start_fullscreen = movie_start -movie_start_displayable = movie_start - -def early_interact(): - """ - Called early in the interact process, to clear out the fullscreen - flag. - """ - - global fullscreen - global current_movie - - fullscreen = True - current_movie = None - - -def interact(): - """ - This is called each time the screen is redrawn. It helps us decide if - the movie should be displayed fullscreen or not. - """ - - global surface - global surface_file - - if not renpy.audio.music.get_playing("movie"): - surface = None - surface_file = None - return False - - if fullscreen: - return True - else: - return False - -def get_movie_texture(): - """ - Gets a movie texture we can draw to the screen. - """ - - global surface - global surface_file - - playing = renpy.audio.music.get_playing("movie") - - pss = renpy.audio.audio.pss - - if pss: - size = pss.movie_size() - else: - size = (64, 64) - - if (surface is None) or (surface.get_size() != size) or (surface_file != playing): - surface = renpy.display.pgrender.surface(size, False) - surface_file = playing - surface.fill((0, 0, 0, 255)) - - tex = None - - if playing is not None: - renpy.display.render.mutated_surface(surface) - tex = renpy.display.draw.load_texture(surface, True) - - return tex - - -def render_movie(width, height): - tex = get_movie_texture() - - if tex is None: - return None - - sw, sh = tex.get_size() - - scale = min(1.0 * width / sw, 1.0 * height / sh) - - dw = scale * sw - dh = scale * sh - - rv = renpy.display.render.Render(width, height, opaque=True) - rv.forward = renpy.display.render.Matrix2D(1.0 / scale, 0.0, 0.0, 1.0 / scale) - rv.reverse = renpy.display.render.Matrix2D(scale, 0.0, 0.0, scale) - rv.blit(tex, (int((width - dw) / 2), int((height - dh) / 2))) - - return rv - -class Movie(renpy.display.core.Displayable): - """ - This is a displayable that shows the current movie. - """ - - fullscreen = False - - def __init__(self, fps=24, size=None, **properties): - """ - @param fps: The framerate that the movie should be shown at. - """ - super(Movie, self).__init__(**properties) - self.size = size - - def render(self, width, height, st, at): - - size = self.size - - if size is None: - size = default_size - - width, height = size - - rv = render_movie(width, height) - - if rv is None: - rv = renpy.display.render.Render(0, 0) - - # Usually we get redrawn when the frame is ready - but we want - # the movie to disappear if it's ended, or if it hasn't started - # yet. - renpy.display.render.redraw(self, 0.1) - - return rv - - - def per_interact(self): - global fullscreen - fullscreen = False - - global current_movie - current_movie = self - - -def playing(): - return renpy.audio.music.get_playing("movie") - -def frequent(): - """ - Called to update the video playback. Returns true if a video refresh is - needed, false otherwise. - """ - - if not playing(): - return 0 - - pss = renpy.audio.audio.pss - - if pss.needs_alloc(): - - if renpy.display.video.fullscreen and renpy.display.draw.fullscreen_surface: - surf = renpy.display.draw.fullscreen_surface - else: - get_movie_texture() - surf = renpy.display.scale.real(surface) - - pss.alloc_event(surf) - - rv = pss.refresh_event() - - if rv and current_movie is not None: - renpy.display.render.redraw(current_movie, 0) - - return rv diff --git a/unrpyc/renpy/game.py b/unrpyc/renpy/game.py deleted file mode 100644 index 028da26..0000000 --- a/unrpyc/renpy/game.py +++ /dev/null @@ -1,437 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -# This module is intended to be used as a singleton object. -# It's purpose is to store in one global all of the data that would -# be to annoying to lug around otherwise. - -import renpy.display - -# The basepath. -basepath = None - -# A list of paths that we search to load things. This is searched for -# everything that can be loaded, before archives are used. -searchpath = [ ] - -# The options that were read off the command line. -args = None - -# The game's script. -script = None - -# A stack of execution contexts. -contexts = [ ] - -# The interface that the game uses to interact with the user. -interface = None - -# Are we inside lint? -lint = False - -# The RollbackLog that keeps track of changes to the game state -# and to the store. -log = None - -# Some useful additional information about program execution that -# can be added to the exception. -exception_info = '' - -# Used to store style information. -style = None - -# The set of statements we've seen in this session. -seen_session = { } - -# The set of statements we've ever seen. -seen_ever = { } - -# True if we're in the first interaction after a rollback or rollforward. -after_rollback = False - -# Code that's run after the init code. -post_init = [ ] - -# Should we attempt to run in a mode that uses less memory? -less_memory = False - -# Should we attempt to run in a mode that minimizes the number -# of screen updates? -less_updates = False - -# Should we never show the mouse? -less_mouse = False - -# Should we not imagedissiolve? -less_imagedissolve = False - -# The class that's used to hold the persistent data. -class Persistent(object): - - def __setstate__(self, data): - vars(self).update(data) - - def __getstate__(self): - return vars(self) - - # Undefined attributes return None. - def __getattr__(self, attr): - return None - -# The persistent data that's kept from session to session -persistent = Persistent() - -class Preferences(renpy.object.Object): - """ - Stores preferences that will one day be persisted. - """ - __version__ = 5 - - def after_upgrade(self, version): - if version < 1: - self.mute_volumes = 0 - if version < 2: - self.using_afm_enable = False - if version < 3: - self.physical_size = None - if version < 4: - self.renderer = "auto" - self.performance_test = True - if version < 5: - self.language = None - - def __init__(self): - self.fullscreen = False - self.skip_unseen = False - self.text_cps = 0 - self.afm_time = 0 - self.afm_enable = True - - # These will be going away soon. - self.sound = True - self.music = True - - # 2 - All transitions. - # 1 - Only non-default transitions. - # 0 - No transitions. - self.transitions = 2 - - self.skip_after_choices = False - - # Mixer channel info. - - # A map from channel name to the current volume (between 0 and 1). - self.volumes = { } - - # True if the channel should not play music. False - # otherwise. (Not used anymore.) - self.mute = { } - - # Joystick mappings. - self.joymap = dict( - joy_left="Axis 0.0 Negative", - joy_right="Axis 0.0 Positive", - joy_up="Axis 0.1 Negative", - joy_down="Axis 0.1 Positive", - joy_dismiss="Button 0.0") - - # The size of the window, or None if we don't know it yet. - self.physical_size = None - - # The graphics renderer we use. - self.renderer = "auto" - - # Should we do a performance test on startup? - self.performance_test = True - - # The language we use for translations. - self.language = None - - def set_volume(self, mixer, volume): - self.volumes[mixer] = volume - - def get_volume(self, mixer): - return self.volumes.get(mixer, 0) - - def set_mute(self, mixer, mute): - self.mute[mixer] = mute - - def get_mute(self, mixer): - return self.mute[mixer] - -# The current preferences. -preferences = Preferences() - -class RestartContext(Exception): - """ - Restarts the current context. If `label` is given, calls that label - in the restarted context. - """ - - def __init__(self, label): - self.label = label - -class RestartTopContext(Exception): - """ - Restarts the top context. If `label` is given, calls that label - in the restarted context. - """ - - def __init__(self, label): - self.label = label - -class FullRestartException(Exception): - """ - An exception of this type forces a hard restart, completely - destroying the store and config and so on. - """ - - def __init__(self, reason="end_game"): # W0231 - self.reason = reason - -class UtterRestartException(Exception): - """ - An exception of this type forces an even harder restart, causing - Ren'Py and the script to be reloaded. - """ - -class QuitException(Exception): - """ - An exception of this class will let us force a safe quit, from - anywhere in the program. - - `relaunch` - If given, the program will run another copy of itself, with the - same arguments. - """ - - def __init__(self, relaunch=False): - Exception.__init__(self) - self.relaunch = relaunch - -class JumpException(Exception): - """ - This should be raised with a label as the only argument. This causes - the current statement to terminate, and execution to be transferred - to the named label. - """ - -class JumpOutException(Exception): - """ - This should be raised with a label as the only argument. This exits - the current context, and then raises a JumpException. - """ - -class CallException(Exception): - """ - Raise this exception to cause the current statement to terminate, - and control to be transferred to the named label. - """ - - def __init__(self, label, args, kwargs): - Exception.__init__(self) - - self.label = label - self.args = args - self.kwargs = kwargs - -class EndReplay(Exception): - """ - Raise this exception to end the current replay (the current call to - call_replay). - """ - -class ParseErrorException(Exception): - """ - This is raised when a parse error occurs, after it has been - reported to the user. - """ - -# A tuple of exceptions that should not be caught by the -# exception reporting mechanism. -CONTROL_EXCEPTIONS = ( - RestartContext, - RestartTopContext, - FullRestartException, - UtterRestartException, - QuitException, - JumpException, - JumpOutException, - CallException, - EndReplay, - ParseErrorException, - KeyboardInterrupt, - ) - - -def context(index=-1): - """ - Return the current execution context, or the context at the - given index if one is specified. - """ - - return contexts[index] - -def invoke_in_new_context(callable, *args, **kwargs): #@ReservedAssignment - """ - This pushes the current context, and invokes the given python - function in a new context. When that function returns or raises an - exception, it removes the new context, and restores the current - context. - - Additional arguments and keyword arguments are passed to the - callable. - - Please note that the context so created cannot execute renpy - code. So exceptions that change the flow of renpy code (like - the one created by renpy.jump) cause this context to terminate, - and are handled by the next higher context. - - If you want to execute renpy code from the function, you can call - it with renpy.call_in_new_context. - - Use this to begin a second interaction with the user while - inside an interaction. - """ - - context = renpy.execution.Context(False, contexts[-1], clear=True) - contexts.append(context) - - if renpy.display.interface is not None: - renpy.display.interface.enter_context() - - try: - - return callable(*args, **kwargs) - - except renpy.game.JumpOutException as e: - - raise renpy.game.JumpException(e.args[0]) - - finally: - - contexts.pop() - contexts[-1].do_deferred_rollback() - - if interface.restart_interaction and contexts: - contexts[-1].scene_lists.focused = None - - - -def call_in_new_context(label, *args, **kwargs): - """ - This code creates a new context, and starts executing code from - that label in the new context. Rollback is disabled in the - new context. (Actually, it will just bring you back to the - real context.) - - Use this to begin a second interaction with the user while - inside an interaction. - """ - - context = renpy.execution.Context(False, contexts[-1], clear=True) - contexts.append(context) - - if renpy.display.interface is not None: - renpy.display.interface.enter_context() - - if args: - renpy.store._args = args - else: - renpy.store._args = None - - if kwargs: - renpy.store._kwargs = renpy.python.RevertableDict(kwargs) - else: - renpy.store._kwargs = None - - try: - - context.goto_label(label) - renpy.execution.run_context(False) - - rv = renpy.store._return #@UndefinedVariable - - return rv - - except renpy.game.JumpOutException as e: - - raise renpy.game.JumpException(e.args[0]) - - finally: - - contexts.pop() - contexts[-1].do_deferred_rollback() - - if interface.restart_interaction and contexts: - contexts[-1].scene_lists.focused = None - -def call_replay(label, scope={}): - """ - :doc: replay - - Calls a label as a memory. - - Keyword arguments are used to set the initial values of variables in the - memory context. - """ - - renpy.game.log.complete() - - old_log = renpy.game.log - renpy.game.log = renpy.python.RollbackLog() - - sb = renpy.python.StoreBackup() - renpy.python.clean_stores() - - context = renpy.execution.Context(True) - contexts.append(context) - - if renpy.display.interface is not None: - renpy.display.interface.enter_context() - - for k, v in scope.items(): - setattr(renpy.store, k, v) - - renpy.store._in_replay = label - - try: - - context.goto_label("_start_replay") - renpy.execution.run_context(False) - - except EndReplay: - pass - - finally: - contexts.pop() - renpy.game.log = old_log - sb.restore() - - if interface.restart_interaction and contexts: - contexts[-1].scene_lists.focused = None - - -# Type information. -if False: - script = renpy.script.Script() - interface = renpy.display.core.Interface() - log = renpy.python.RollbackLog() diff --git a/unrpyc/renpy/object.py b/unrpyc/renpy/object.py deleted file mode 100644 index c595e8c..0000000 --- a/unrpyc/renpy/object.py +++ /dev/null @@ -1,60 +0,0 @@ -# Copyright 2004-2013 Tom Rothamel -# -# 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. - -class Object(object): - """ - Our own base class. Contains methods to simplify serialization. - """ - - __version__ = 0 - - nosave = [ ] - - def __getstate__(self): - rv = vars(self).copy() - - for f in self.nosave: - if f in rv: - del rv[f] - - - rv["__version__"] = self.__version__ - - return rv - - - # None, to prevent this from being called when unnecessary. - after_setstate = None - - def __setstate__(self, new_dict): - - version = new_dict.pop("__version__", 0) - - self.__dict__.update(new_dict) - - if version != self.__version__: - self.after_upgrade(version) # E1101 - - if self.after_setstate: - self.after_setstate() # E1102 - -# We don't handle slots with this mechanism, since the call to vars should -# throw an error. -- cgit v1.2.3-70-g09d2