From e69c86283c06dbee989bbf4fd428befd57077d9c Mon Sep 17 00:00:00 2001 From: SeanOMik Date: Sat, 20 Nov 2021 00:48:28 -0500 Subject: [PATCH] Delete all old 2d code, change license --- LICENSE | 687 +++++++++++++++++- examples/animation/CMakeLists.txt | 15 - examples/animation/src/main.cpp | 70 -- examples/snake/CMakeLists.txt | 15 - examples/snake/src/main.cpp | 321 -------- include/simpleengine/animation.h | 43 -- include/simpleengine/async_event.h | 67 -- include/simpleengine/component.h | 33 - .../components/animation_component.h | 45 -- .../components/collision_component.h | 48 -- .../components/movement/movement_component.h | 41 -- .../simpleengine/components/ssma_component.h | 50 -- include/simpleengine/destructable.h | 25 - include/simpleengine/entity.h | 84 --- include/simpleengine/event.h | 28 - .../simpleengine/events/collision_handler.h | 31 - include/simpleengine/events/entity_event.h | 40 - include/simpleengine/random.h | 35 - src/animation.cpp | 66 -- src/components/animation_component.cpp | 63 -- src/components/collision_component.cpp | 84 --- .../movement/movement_component.cpp | 174 ----- src/components/ssma_component.cpp | 130 ---- src/entity.cpp | 51 -- src/events/collision_handler.cpp | 48 -- 25 files changed, 670 insertions(+), 1624 deletions(-) delete mode 100644 examples/animation/CMakeLists.txt delete mode 100644 examples/animation/src/main.cpp delete mode 100644 examples/snake/CMakeLists.txt delete mode 100644 examples/snake/src/main.cpp delete mode 100644 include/simpleengine/animation.h delete mode 100644 include/simpleengine/async_event.h delete mode 100644 include/simpleengine/component.h delete mode 100644 include/simpleengine/components/animation_component.h delete mode 100644 include/simpleengine/components/collision_component.h delete mode 100644 include/simpleengine/components/movement/movement_component.h delete mode 100644 include/simpleengine/components/ssma_component.h delete mode 100644 include/simpleengine/destructable.h delete mode 100644 include/simpleengine/entity.h delete mode 100644 include/simpleengine/event.h delete mode 100644 include/simpleengine/events/collision_handler.h delete mode 100644 include/simpleengine/events/entity_event.h delete mode 100644 include/simpleengine/random.h delete mode 100644 src/animation.cpp delete mode 100644 src/components/animation_component.cpp delete mode 100644 src/components/collision_component.cpp delete mode 100644 src/components/movement/movement_component.cpp delete mode 100644 src/components/ssma_component.cpp delete mode 100644 src/entity.cpp delete mode 100644 src/events/collision_handler.cpp diff --git a/LICENSE b/LICENSE index 69ae75e..f288702 100644 --- a/LICENSE +++ b/LICENSE @@ -1,21 +1,674 @@ -MIT License + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 -Copyright (c) 2020 SeanOMik + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. -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: + Preamble -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. + The GNU General Public License is a free, copyleft license for +software and other kinds of works. -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 licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, 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 +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If 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 convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU 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 +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "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 PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM 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 PROGRAM (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 PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state 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 program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/examples/animation/CMakeLists.txt b/examples/animation/CMakeLists.txt deleted file mode 100644 index f33cca9..0000000 --- a/examples/animation/CMakeLists.txt +++ /dev/null @@ -1,15 +0,0 @@ -cmake_minimum_required (VERSION 3.6) -project(AnimationExample) - -add_executable(animation_example src/main.cpp) - -# Link headers and source files. -file(GLOB_RECURSE source_list src/*.cpp) -target_sources(animation_example PRIVATE ${source_list}) -target_include_directories(animation_example PUBLIC include) - -# Link simpleengine -target_link_libraries(animation_example PUBLIC simpleengine) - -# Set standard to C++17 -set_target_properties(animation_example PROPERTIES CXX_STANDARD 17 CXX_EXTENSIONS OFF) \ No newline at end of file diff --git a/examples/animation/src/main.cpp b/examples/animation/src/main.cpp deleted file mode 100644 index aca8e20..0000000 --- a/examples/animation/src/main.cpp +++ /dev/null @@ -1,70 +0,0 @@ -// -// Created by SeanOMik on 7/2/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -class PlayerEntity : public simpleengine::Entity { -private: - sf::Sprite sprite; - sf::Texture texture; - float movement_speed = 50; - sf::Vector2u window_size; - - // Components - std::shared_ptr hitbox_component; - std::shared_ptr move_anim_component; -public: - explicit PlayerEntity(sf::Vector2u window_size, simpleengine::Game& game) : Entity(sprite), window_size(window_size) { - texture.loadFromFile("player_sheet.png"); - texture.setSmooth(true); - sprite.setTexture(texture); - sprite.setScale(0.5, 0.5); - sprite.setPosition(100, 100); - - move_anim_component = std::make_shared(*this, game, sprite, - texture, movement_speed, 6, 3); - move_anim_component->SetAnimation(simpleengine::MovementAnimationType::WALK_LEFT, 8, 0, 9, 9, 9, 128, 128); - move_anim_component->SetAnimation(simpleengine::MovementAnimationType::IDLE_LEFT, 20, 0, 0, 6, 0, 128, 128); - AddComponent(move_anim_component); - - hitbox_component = std::make_shared(*this, sprite, -13, 12, - sprite.getGlobalBounds().width - 35.f, sprite.getGlobalBounds().height - 15.f); - AddComponent(hitbox_component); - } - - ~PlayerEntity() override { - std::cout << "Destroying" << std::endl; - - simpleengine::Entity::~Entity(); - } - - void Update(const float& delta_time) override { - Entity::Update(delta_time); - } - - void Render(sf::RenderTarget* target) override { - Entity::Render(target); - - target->draw(sprite); - } -}; - -int main(int argc, char *argv[]) { - simpleengine::Game game(700, 700, "SimpleEngine - Animation Example"); - game.AddEvent(new simpleengine::EntityEvent(game.GetWindow(), std::make_unique(game.GetWindow()->getSize(), game))); - - return game.Run(); -} \ No newline at end of file diff --git a/examples/snake/CMakeLists.txt b/examples/snake/CMakeLists.txt deleted file mode 100644 index 2523cc7..0000000 --- a/examples/snake/CMakeLists.txt +++ /dev/null @@ -1,15 +0,0 @@ -cmake_minimum_required (VERSION 3.6) -project(Snake) - -add_executable(snake src/main.cpp) - -# Link headers and source files. -file(GLOB_RECURSE source_list src/*.cpp) -target_sources(snake PRIVATE ${source_list}) -target_include_directories(snake PUBLIC include) - -# Link simpleengine -target_link_libraries(snake PUBLIC simpleengine) - -# Set standard to C++17 -set_target_properties(snake PROPERTIES CXX_STANDARD 17 CXX_EXTENSIONS OFF) \ No newline at end of file diff --git a/examples/snake/src/main.cpp b/examples/snake/src/main.cpp deleted file mode 100644 index 664eb11..0000000 --- a/examples/snake/src/main.cpp +++ /dev/null @@ -1,321 +0,0 @@ -// -// Created by SeanOMik on 7/2/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#include -#include -#include -#include -#include -#include -#include - -#include - -#include -#include - -#include - -// Simple engine components -#include -#include - -// Simpleengine events -#include -#include - -// Simple engine utils -#include - -#include -#include -#include -#include - -class SnakeMovementComponent : public simpleengine::Component { -private: - float movement_speed = 15; - sf::Vector2i movement_direction; - std::chrono::high_resolution_clock::time_point last_movement; - sf::Vector2u window_size; - const sf::Vector2f& entity_pos; - - simpleengine::Game& game; - - bool IsStill() { - return movement_direction.x == 0 && movement_direction.y == 0; - } -public: - explicit SnakeMovementComponent(simpleengine::Entity& owning_entity, float movement_speed, const sf::Vector2u& window_size, simpleengine::Game& game) - : simpleengine::Component(owning_entity), movement_speed(movement_speed), window_size(window_size), - entity_pos(owning_entity.GetTransformable().getPosition()), game(game) { - - game.AddEventCallback(std::function([this](sf::Event::KeyEvent event) { - this->OnKeyPress(event); - })); - } - - void OnKeyPress(sf::Event::KeyEvent event) { - sf::Keyboard::Key key = event.code; - - switch (key) { - case sf::Keyboard::W: - // Make sure we're not trying to move the opposite direction. - if (IsStill() || movement_direction.x != 0 && movement_direction.y != 15) { - movement_direction.x = 0; - movement_direction.y = -15; - } - break; - case sf::Keyboard::A: - if (IsStill() || movement_direction.x != 15 && movement_direction.y != 0) { - movement_direction.x = -15; - movement_direction.y = 0; - } - break; - case sf::Keyboard::S: - if (IsStill() || movement_direction.x != 0 && movement_direction.y != 15) { - movement_direction.x = 0; - movement_direction.y = 15; - } - break; - case sf::Keyboard::D: - if (IsStill() || movement_direction.x != -15 && movement_direction.y != 0) { - movement_direction.x = 15; - movement_direction.y = 0; - } - break; - case sf::Keyboard::Space: - movement_direction.x = 0; - movement_direction.y = 0; - break; - default: - break; - } - } - - const sf::Vector2i& GetDirection() { - return movement_direction; - } - - void Update(const float& delta_time) override { - long long duration = std::chrono::duration_cast(std::chrono::high_resolution_clock::now() - last_movement).count(); - - // Only move every 115 ticks. - if (duration >= 115 && (movement_direction.x != 0 || movement_direction.y != 0)) { - owning_entity.Move(delta_time, movement_direction.x, movement_direction.y); - last_movement = std::chrono::high_resolution_clock::now(); - - sf::RectangleShape& shape = dynamic_cast(owning_entity.GetTransformable()); - - // Wrap entity around the side of the screen. - if (entity_pos.x < 0) { - sf::Vector2f new_pos(window_size.x - shape.getSize().x, owning_entity.GetTransformable().getPosition().y); - owning_entity.GetTransformable().setPosition(new_pos); - } else if (entity_pos.x > window_size.x) { - sf::Vector2f new_pos(shape.getSize().x, owning_entity.GetTransformable().getPosition().y); - owning_entity.GetTransformable().setPosition(new_pos); - } - - if (entity_pos.y < 0) { - sf::Vector2f new_pos(owning_entity.GetTransformable().getPosition().x, window_size.y - shape.getSize().y); - owning_entity.GetTransformable().setPosition(new_pos); - } else if (entity_pos.y > window_size.y) { - sf::Vector2f new_pos(owning_entity.GetTransformable().getPosition().x, shape.getSize().y); - owning_entity.GetTransformable().setPosition(new_pos); - } - } - } -}; - -class SnakePlayerEntity; - -class SnakeFoodEntity : public simpleengine::Entity { -private: - sf::RectangleShape shape; - sf::Vector2u window_size; - std::shared_ptr snake_player; - - std::shared_ptr collision_component; -public: - explicit SnakeFoodEntity(sf::Vector2u window_size, std::shared_ptr snake_player) - : Entity(shape), window_size(window_size), snake_player(snake_player) { - - shape.setSize(sf::Vector2f(15, 15)); - shape.setPosition(45, 45); - shape.setFillColor(sf::Color::Red); - - collision_component = std::make_shared(*this, shape, 0, 0, 15, 15); - AddComponent(collision_component); - } - - void Move(const float& delta_time, const float& x, const float& y) override { - shape.move(x, y); - } - - void Move(const float& delta_time, const sf::Vector2f& offset) override { - shape.move(offset * delta_time); - } - - void Move(const sf::Vector2f& offset) override { - shape.move(offset); - } - - void Render(sf::RenderTarget* target) override { - target->draw(shape); - } - - // Find a new location for the snake food. - void Relocate() { - simpleengine::Random random; - sf::Vector2f pos(random.NextInRange(0, window_size.x), random.NextInRange(0, window_size.y)); - - // Make sure its on the 15 pixel grid. - pos.x -= (int) pos.x % 15; - pos.y -= (int) pos.y % 15; - - shape.setPosition(pos); - } -}; - -struct BodyPiece { - sf::RectangleShape shape; - sf::Vector2i movement_direction; -}; - -class SnakePlayerEntity : public simpleengine::Entity { -private: - sf::RectangleShape head; - - std::vector body; - - float movement_speed = 15; - sf::Vector2u window_size; - sf::Text& score_text; - - std::shared_ptr movement_component; - std::shared_ptr collision_component; - - bool alive = true; -public: - explicit SnakePlayerEntity(sf::Vector2u window_size, sf::Text& score_text, simpleengine::Game& game) : - Entity(head), window_size(window_size), score_text(score_text) { - head = sf::RectangleShape(sf::Vector2f(15, 15)); - head.setFillColor(sf::Color(220, 220, 220)); - - movement_component = std::make_shared(*this, movement_speed, window_size, game); - AddComponent(movement_component); - - collision_component = std::make_shared(*this, head, 0, 0, 15, 15); - collision_component->SetOnCollide(std::bind(&SnakePlayerEntity::OnCollide, this, std::placeholders::_1)); - AddComponent(collision_component); - } - - void Move(const float& delta_time, const float& x, const float& y) override { - if (alive) { - sf::FloatRect rect(head.getPosition(), head.getSize()); - // Add movement to position - rect.left += x; - rect.top += y; - - for (BodyPiece& piece : body) { - if (piece.movement_direction != sf::Vector2i(0, 0) && rect.intersects(piece.shape.getGlobalBounds())) { - alive = false; - break; - } - } - - if (!alive) return; - - head.move(x, y); - - sf::Vector2i last_movement_dir(x, y); - for (BodyPiece& piece : body) { - piece.shape.move(piece.movement_direction.x, piece.movement_direction.y); - - std::swap(last_movement_dir, piece.movement_direction); - - // Wrap piece around the side of the screen. - sf::Vector2f piece_pos = piece.shape.getPosition(); - if (piece_pos.x < 0) { - sf::Vector2f new_pos(window_size.x - piece.shape.getSize().x, piece_pos.y); - piece.shape.setPosition(new_pos); - } else if (piece_pos.x > window_size.x) { - sf::Vector2f new_pos(piece.shape.getSize().x, piece_pos.y); - piece.shape.setPosition(new_pos); - } - - if (piece_pos.y < 0) { - sf::Vector2f new_pos(piece_pos.x, window_size.y - piece.shape.getSize().y); - piece.shape.setPosition(new_pos); - } else if (piece_pos.y > window_size.y) { - sf::Vector2f new_pos(piece_pos.x, piece.shape.getSize().y); - piece.shape.setPosition(new_pos); - } - } - } - } - - void Move(const float& delta_time, const sf::Vector2f& offset) override { - head.move(offset * delta_time); - } - - void Move(const sf::Vector2f& offset) override { - head.move(offset); - } - - void Render(sf::RenderTarget* target) override { - target->draw(score_text); - target->draw(head); - - for (const BodyPiece& piece : body) { - target->draw(piece.shape); - } - } - - void OnCollide(std::shared_ptr entity) { - if (std::shared_ptr shared = std::dynamic_pointer_cast(entity); shared) { - shared->Relocate(); - - BodyPiece piece{ sf::RectangleShape(sf::Vector2f(15, 15)), sf::Vector2i(0, 0) }; - piece.shape.setFillColor(sf::Color::White); - - if (body.empty()) { - piece.shape.setPosition(head.getPosition()); - } else { - piece.shape.setPosition(body.back().shape.getPosition()); - } - - body.push_back(piece); - score_text.setString(std::to_string(body.size())); - } - } -}; - -int main(int argc, char *argv[]) { - sf::Vector2u window_size(495, 495); - simpleengine::Game game(window_size, "SimpleEngine - Snake Example"); - - sf::Font font; - if (!font.loadFromFile("arial.ttf")) { - std::cout << "Failed to find \"arial.ttf\"" << std::endl; - return 0; - } - - sf::Text score_text; - score_text.setFont(font); - score_text.setString("0"); - score_text.setCharacterSize(24); - score_text.setFillColor(sf::Color::Green); - score_text.setPosition(window_size.x - 50, 5); - - auto snake_player = std::make_shared(window_size, score_text, std::ref(game)); - auto snake_food = std::make_shared(window_size, snake_player); - game.AddEvent(new simpleengine::EntityEvent(game.GetWindow(), snake_food)); - game.AddEvent(new simpleengine::EntityEvent(game.GetWindow(), snake_player)); - game.AddEvent(new simpleengine::CollisionHandler(game)); - - return game.Run(); -} \ No newline at end of file diff --git a/include/simpleengine/animation.h b/include/simpleengine/animation.h deleted file mode 100644 index ae027ee..0000000 --- a/include/simpleengine/animation.h +++ /dev/null @@ -1,43 +0,0 @@ -// -// Created by SeanOMik on 7/5/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#ifndef SIMPLEENGINE_ANIMATION_H -#define SIMPLEENGINE_ANIMATION_H - -#include - -namespace simpleengine { - class Animation { - public: - Animation(sf::Sprite &sprite, sf::Texture &texture_sheet, float speed, int start_frame_x, - int start_frame_y, int frame_ct_x, int frame_ct_y, int width, int height); - - void Update(const float& delta_time); - void Reset(); - - void FlipHorizontally(); - void FlipVertically(); - - bool IsHorizontallyFlipped() const; - bool IsVerticallyFlipped() const; - private: - sf::Sprite &sprite; - sf::Texture &texture_sheet; - float speed; // Speed is how long it takes until it swaps to next texture. - float timer; - int width; - int height; - sf::IntRect start_rect; - sf::IntRect current_rect; - sf::IntRect end_rect; - sf::Vector2f start_scale; - - bool horizontally_flipped = false; - bool vertically_flipped = false; - }; -} - -#endif //SIMPLEENGINE_ANIMATION_H diff --git a/include/simpleengine/async_event.h b/include/simpleengine/async_event.h deleted file mode 100644 index 23e0280..0000000 --- a/include/simpleengine/async_event.h +++ /dev/null @@ -1,67 +0,0 @@ -// -// Created by SeanOMik on 3/12/2021. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#ifndef SIMPLEENGINE_ASYNC_EVENT_H -#define SIMPLEENGINE_ASYNC_EVENT_H - -#include "event.h" - -#include -#include -#include - -namespace simpleengine { - class AsyncEvent : public simpleengine::Event { - public: - explicit AsyncEvent(sf::RenderWindow* window = nullptr) : simpleengine::Event(window) { - update_thread = std::thread( [this]() { - while (!quit) { - std::unique_lock unique_lock(mutex); - cond_var.wait(unique_lock); - - // After waiting check if we're quiting and if we need to stop this thread. - if (quit) break; - - AsyncUpdate(tick_delta_time); - } - }); - } - - virtual ~AsyncEvent() { - quit = true; - - // Notify the async updating thread that we're quiting. - { - std::unique_lock unique_lock(mutex); - cond_var.notify_all(); - } - - // Quit the async updating thread if its still running. - if (update_thread.joinable()) { - update_thread.join(); - } - }; - - virtual void AsyncUpdate(const float delta_time) = 0; - - // DO NOT OVERRIDE THIS FUNCTION - // Notify the update thread to trigger the async update. - virtual void Update(const float& delta_time) final { - std::unique_lock unique_lock(mutex); - tick_delta_time = delta_time; - cond_var.notify_all(); - } - - virtual void Render(sf::RenderTarget* target) { }; - protected: - std::mutex mutex; - std::condition_variable cond_var; - std::thread update_thread; - float tick_delta_time; - }; -} - -#endif //SIMPLEENGINE_ASYNC_EVENT_H diff --git a/include/simpleengine/component.h b/include/simpleengine/component.h deleted file mode 100644 index 86b394f..0000000 --- a/include/simpleengine/component.h +++ /dev/null @@ -1,33 +0,0 @@ -// -// Created by SeanOMik on 7/2/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#ifndef SIMPLEENGINE_COMPONENT_H -#define SIMPLEENGINE_COMPONENT_H - -#include "destructable.h" - -#include - -#include - -namespace simpleengine { - class Entity; - class Component : public simpleengine::Destructable { - public: - explicit Component(Entity& owning_entity) : owning_entity(owning_entity) { - - } - virtual ~Component() = default; - - virtual void Update(const float& delta_time) = 0; - virtual void Render(sf::RenderTarget* target) {}; // Most components won't need to be rendered. - protected: - Entity& owning_entity; - bool destroying = false; - }; -} - -#endif //SIMPLEENGINE_COMPONENT_H diff --git a/include/simpleengine/components/animation_component.h b/include/simpleengine/components/animation_component.h deleted file mode 100644 index d7d53f4..0000000 --- a/include/simpleengine/components/animation_component.h +++ /dev/null @@ -1,45 +0,0 @@ -// -// Created by SeanOMik on 7/4/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#ifndef SIMPLEENGINE_ANIMATION_COMPONENT_H -#define SIMPLEENGINE_ANIMATION_COMPONENT_H - -#include "../component.h" -#include "../animation.h" - -#include - -namespace simpleengine { - class Entity; - - class AnimationComponent : public Component { - private: - - sf::Sprite& sprite; - sf::Texture& texture_sheet; - std::map animations; - - public: - explicit AnimationComponent(Entity& owning_entity, sf::Sprite& sprite, sf::Texture& texture_sheet); - - void Update(const float& delta_time) override; - - void AddAnimation(const std::string& animation_name, float speed, int start_frame_x, int start_frame_y, int frame_ct_x, - int frame_ct_y, int width, int height); - void AddAnimation(const std::string& animation_name, simpleengine::Animation animation); - bool HasAnimation(const std::string& animation_name); - - // Animation class specific - void UpdateAnimation(const std::string& animation_name, const float& delta_time); - Animation& GetAnimation(const std::string& animation_name); - - sf::Sprite &GetSprite() const; - sf::Texture &GetTextureSheet() const; - const std::map &GetAnimations() const; - }; -} - -#endif //SIMPLEENGINE_ANIMATION_COMPONENT_H \ No newline at end of file diff --git a/include/simpleengine/components/collision_component.h b/include/simpleengine/components/collision_component.h deleted file mode 100644 index e715f8b..0000000 --- a/include/simpleengine/components/collision_component.h +++ /dev/null @@ -1,48 +0,0 @@ -// -// Created by SeanOMik on 7/6/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#ifndef SIMPLEENGINE_COLLISION_COMPONENT_H -#define SIMPLEENGINE_COLLISION_COMPONENT_H - -#include "../component.h" -#include "../entity.h" - -#include -#include - -#include - -namespace simpleengine { - class CollisionComponent : public Component { - private: - sf::Transformable& transformable; - sf::RectangleShape hitbox; - - float offset_x; - float offset_y; - std::function)> collide_function; - public: - CollisionComponent(Entity& owning_entity, sf::Transformable& transformable, float offset_x, float offset_y, float width, float height); - CollisionComponent(Entity& owning_entity, sf::Transformable& transformable, sf::Vector2f offset, sf::Vector2f size); - - CollisionComponent(Entity& owning_entity, sf::Transformable& transformable, const sf::RectangleShape& hitbox, float offset_x, float offset_y); - CollisionComponent(Entity& owning_entity, sf::Transformable& transformable, const sf::RectangleShape& hitbox, sf::Vector2f offset); - - sf::RectangleShape& GetHitbox(); - - virtual bool DoesIntersect(const sf::FloatRect& rect) const; - virtual bool DoesIntersect(const sf::RectangleShape& rect) const; - virtual bool DoesIntersect(Entity& entity) const; - - void Update(const float &delta_time) override; - void Render(sf::RenderTarget *target) override; - - virtual void SetOnCollide(std::function)> func); - virtual void OnCollide(std::shared_ptr collided_entity); - }; -} - -#endif //SIMPLEENGINE_COLLISION_COMPONENT_H diff --git a/include/simpleengine/components/movement/movement_component.h b/include/simpleengine/components/movement/movement_component.h deleted file mode 100644 index 3fc76f3..0000000 --- a/include/simpleengine/components/movement/movement_component.h +++ /dev/null @@ -1,41 +0,0 @@ -// -// Created by SeanOMik on 7/2/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#ifndef SIMPLEENGINE_MOVEMENT_COMPONENT_H -#define SIMPLEENGINE_MOVEMENT_COMPONENT_H - -#include "../../component.h" - -#include - -namespace simpleengine { - class Entity; - class Game; - - class MovementComponent : public Component { - public: - MovementComponent(Entity& owning_entity, Game& game, float max_velocity, float acceleration = 7, float deceleration = 2.5); - - void OnKeyPress(sf::Event::KeyEvent event); - void OnKeyRelease(sf::Event::KeyEvent event); - - void Move(const float& delta_time, const float& dir_x, const float& dir_y); - - void Update(const float& delta_time) override; - - const sf::Vector2f& GetVelocity() const; - const sf::Vector2f& GetLastDirection() const; - private: - sf::Vector2f direction; - float max_velocity; - sf::Vector2f velocity; - sf::Vector2f last_direction; - float acceleration; - float deceleration; - }; -} - -#endif //SIMPLEENGINE_MOVEMENT_COMPONENT_H diff --git a/include/simpleengine/components/ssma_component.h b/include/simpleengine/components/ssma_component.h deleted file mode 100644 index 5e4ffb8..0000000 --- a/include/simpleengine/components/ssma_component.h +++ /dev/null @@ -1,50 +0,0 @@ -// -// Created by SeanOMik on 7/5/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#ifndef SIMPLEENGINE_SSMA_COMPONENT_H -#define SIMPLEENGINE_SSMA_COMPONENT_H - -#include "../component.h" -#include "animation_component.h" -#include "movement/movement_component.h" - -#include - -namespace simpleengine { - class Entity; - class Animation; - - enum MovementAnimationType { - WALK_LEFT, - WALK_RIGHT, - IDLE_LEFT, - IDLE_RIGHT - }; - - // Use this for side scrollers! - class SideScrollerMovementAnimationComponent : public Component { - public: - SideScrollerMovementAnimationComponent(Entity& owning_entity, Game& game, sf::Sprite &sprite, sf::Texture &texture_sheet, - float max_velocity, float acceleration, float deceleration); - - void SetAnimation(const MovementAnimationType& type, simpleengine::Animation animation); - void SetAnimation(const MovementAnimationType& type, float speed, int start_frame_x, int start_frame_y, int frame_ct_x, int frame_ct_y, - int width, int height); - - void Update(const float& delta_time) override; - - simpleengine::AnimationComponent& GetAnimationComponent(); - simpleengine::MovementComponent& GetMovementComponent(); - private: - std::string MovementAnimationTypeToStr(const MovementAnimationType& type); - - simpleengine::AnimationComponent anim_component; - simpleengine::MovementComponent move_component; - }; -} - - -#endif //SIMPLEENGINE_SSMA_COMPONENT_H diff --git a/include/simpleengine/destructable.h b/include/simpleengine/destructable.h deleted file mode 100644 index 817593a..0000000 --- a/include/simpleengine/destructable.h +++ /dev/null @@ -1,25 +0,0 @@ -// -// Created by SeanOMik on 3/12/2021. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#ifndef SIMPLEENGINE_DESTRUCTABLE_H -#define SIMPLEENGINE_DESTRUCTABLE_H - -namespace simpleengine { - class Destructable { - public: - virtual void Destroy() { - destroying = true; - } - - virtual const bool& IsDestroying() const { - return destroying; - } - protected: - bool destroying = false; - }; -} - -#endif //SIMPLEENGINE_DESTRUCTABLE_H diff --git a/include/simpleengine/entity.h b/include/simpleengine/entity.h deleted file mode 100644 index 1c2616b..0000000 --- a/include/simpleengine/entity.h +++ /dev/null @@ -1,84 +0,0 @@ -// -// Created by SeanOMik on 7/2/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#ifndef SIMPLEENGINE_ENTITY_H -#define SIMPLEENGINE_ENTITY_H - -#include "destructable.h" - -#include - -#include -#include -#include -#include -#include - -namespace simpleengine { - class Component; - class Game; - class Event; - - class Entity : public simpleengine::Destructable { - friend class Game; - friend class Event; - public: - explicit Entity(sf::Transformable& transformable); - virtual ~Entity() = default; - Entity(const Entity& entity) = delete; - - virtual void Move(const float& delta_time, const float& dir_x, const float& dir_y); - virtual void Move(const float& delta_time, const sf::Vector2f& offset); - virtual void Move(const sf::Vector2f& offset); - - virtual void Render(sf::RenderTarget* target); - virtual void Update(const float& delta_time); - - template - bool HasComponent() const { - for (std::shared_ptr comp : components) { - if (std::dynamic_pointer_cast(comp)) { - return true; - } - } - - return false; - } - - template - std::shared_ptr GetComponent() const { - for (std::shared_ptr comp : components) { - if (std::shared_ptr dyn_comp = std::dynamic_pointer_cast(comp); dyn_comp) { - return dyn_comp; - } - } - - return nullptr; - } - - void UpdateComponents(const float& delta_time); - void RenderComponents(sf::RenderTarget* target); - - template - void AddComponent(std::shared_ptr component) { - static_assert(std::is_base_of_v, "Component class must derive from simpleengine::Component"); - - // Only allow one type of the same component. - assert(!HasComponent()); - components.push_back(component); - } - - inline sf::Transformable& GetTransformable() { - return transformable; - } - protected: - sf::Transformable& transformable; - std::vector> components; - bool destroying = false; - }; -} - -#endif //GAMEENGINE_ENTITY_H diff --git a/include/simpleengine/event.h b/include/simpleengine/event.h deleted file mode 100644 index 590d1fe..0000000 --- a/include/simpleengine/event.h +++ /dev/null @@ -1,28 +0,0 @@ -// -// Created by SeanOMik on 7/2/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#ifndef SIMPLEENGINE_EVENT_H -#define SIMPLEENGINE_EVENT_H - -#include "destructable.h" - -#include - -namespace simpleengine { - class Event : public simpleengine::Destructable { - public: - explicit Event(sf::RenderWindow* window = nullptr) : window(window) {} - virtual ~Event() = default; - - virtual void Update(const float& delta_time) = 0; - virtual void Render(sf::RenderTarget* target) = 0; - protected: - sf::RenderWindow* window; - bool quit = false; - }; -} - -#endif //GAMEENGINE_EVENT_H diff --git a/include/simpleengine/events/collision_handler.h b/include/simpleengine/events/collision_handler.h deleted file mode 100644 index 953e6ab..0000000 --- a/include/simpleengine/events/collision_handler.h +++ /dev/null @@ -1,31 +0,0 @@ -// -// Created by SeanOMik on 3/1/2021. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#ifndef SIMPLEENGINE_COLLISION_HANDLER_H -#define SIMPLEENGINE_COLLISION_HANDLER_H - -#include "../event.h" -#include "../entity.h" - -namespace simpleengine { - class Game; - class CollisionHandler : public Event { - public: - explicit CollisionHandler(simpleengine::Game& game) : simpleengine::Event(nullptr), game(game) { - - } - - void Update(const float& delta_time) override; - void Render(sf::RenderTarget* target) override { } - - void UpdateHandledEntities(); - private: - std::vector> handled_entities; - simpleengine::Game& game; - }; -} - -#endif //SIMPLEENGINE_COLLISION_HANDLER_H diff --git a/include/simpleengine/events/entity_event.h b/include/simpleengine/events/entity_event.h deleted file mode 100644 index 1abc32d..0000000 --- a/include/simpleengine/events/entity_event.h +++ /dev/null @@ -1,40 +0,0 @@ -// -// Created by SeanOMik on 7/3/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#ifndef SIMPLEENGINE_ENTITY_EVENT_H -#define SIMPLEENGINE_ENTITY_EVENT_H - -#include "../event.h" -#include "../entity.h" - -namespace simpleengine { - class EntityEvent : public Event { - public: - explicit EntityEvent(sf::RenderWindow* window, std::shared_ptr entity) : simpleengine::Event(window), entity(entity) { - - } - - void Update(const float& delta_time) override { - entity->Update(delta_time); - - if (entity->IsDestroying()) { - quit = true; - } - } - - void Render(sf::RenderTarget* target) override { - entity->Render(target); - } - - std::shared_ptr GetEntity() { - return entity; - } - private: - std::shared_ptr entity; - }; -} - -#endif //SIMPLEENGINE_ENTITY_EVENT_H diff --git a/include/simpleengine/random.h b/include/simpleengine/random.h deleted file mode 100644 index 9fc6ab0..0000000 --- a/include/simpleengine/random.h +++ /dev/null @@ -1,35 +0,0 @@ -// -// Created by SeanOMik on 7/6/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#ifndef SIMPLEENGINE_RANDOM_H -#define SIMPLEENGINE_RANDOM_H - -#include -#include -#include - -namespace simpleengine { - template - class Random { - private: - RandomDevice rd; - Generator gen; - public: - Random() { - this->gen = Generator(rd()); - } - - template || std::is_same_v, - std::uniform_int_distribution, std::uniform_real_distribution>> - T NextInRange(T min, T max) { - Dist dist(min, max); - - return dist(gen); - } - }; -} - -#endif //SIMPLEENGINE_RANDOM_H \ No newline at end of file diff --git a/src/animation.cpp b/src/animation.cpp deleted file mode 100644 index 7d8f11e..0000000 --- a/src/animation.cpp +++ /dev/null @@ -1,66 +0,0 @@ -// -// Created by SeanOMik on 7/5/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#include "animation.h" - -simpleengine::Animation::Animation(sf::Sprite &sprite, sf::Texture &texture_sheet, float speed, int start_frame_x, - int start_frame_y, int frame_ct_x, int frame_ct_y, int width, int height) : sprite(sprite), texture_sheet(texture_sheet), - speed(speed), start_rect(sf::IntRect(start_frame_x * width, start_frame_y * height, width, height)), - end_rect(sf::IntRect(frame_ct_x * width, frame_ct_y * height, width, height)), width(width), height(height) { - - timer = 0; - - // Set start of sprite. - this->sprite.setTexture(texture_sheet, true); - this->sprite.setTextureRect(start_rect); - this->start_scale = sprite.getScale(); - this->current_rect = start_rect; - - sprite.setOrigin({ static_cast(sprite.getLocalBounds().width * 0.5), 0 }); -} - -void simpleengine::Animation::Update(const float& delta_time) { - // Update timer - timer += 100 * delta_time; - if (timer >= speed) { - // Reset animation - timer = 0; - - // We have not reached the end, so change the texture. - if (current_rect != end_rect) { - current_rect.left += width; - } else { - current_rect.left = start_rect.left; - } - - sprite.setTextureRect(current_rect); - } -} - -void simpleengine::Animation::Reset() { - timer = 0; - current_rect = start_rect; -} - -void simpleengine::Animation::FlipHorizontally() { - sf::Vector2f scale = sprite.getScale(); - sprite.setScale(-scale.x, scale.y); - horizontally_flipped = !horizontally_flipped; -} - -void simpleengine::Animation::FlipVertically() { - sf::Vector2f scale = sprite.getScale(); - sprite.setScale(scale.x, -scale.y); - vertically_flipped = !vertically_flipped; -} - -bool simpleengine::Animation::IsHorizontallyFlipped() const { - return horizontally_flipped; -} - -bool simpleengine::Animation::IsVerticallyFlipped() const { - return vertically_flipped; -} diff --git a/src/components/animation_component.cpp b/src/components/animation_component.cpp deleted file mode 100644 index d3e18b0..0000000 --- a/src/components/animation_component.cpp +++ /dev/null @@ -1,63 +0,0 @@ -// -// Created by SeanOMik on 7/4/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#include "components/animation_component.h" -#include "animation.h" - -simpleengine::AnimationComponent::AnimationComponent(Entity& owning_entity, sf::Sprite& sprite, sf::Texture& texture_sheet) - : Component(owning_entity), sprite(sprite), texture_sheet(texture_sheet) { - -} - -void simpleengine::AnimationComponent::Update(const float& delta_time) { - -} - -void simpleengine::AnimationComponent::AddAnimation(const std::string& animation_name, float speed, int start_frame_x, int start_frame_y, int frame_ct_x, - int frame_ct_y, int width, int height) { - - animations.emplace(animation_name, Animation(sprite, texture_sheet, speed, start_frame_x, start_frame_y, frame_ct_x, frame_ct_y, width, height)); -} - -void simpleengine::AnimationComponent::AddAnimation(const std::string& animation_name, simpleengine::Animation animation) { - animations.emplace(animation_name, animation); -} - -void simpleengine::AnimationComponent::UpdateAnimation(const std::string &animation_name, const float& delta_time) { - auto anim = animations.find(animation_name); - if (anim != animations.end()) { - anim->second.Update(delta_time); - } else { - throw std::runtime_error("Animation, \"" + animation_name + "\", was not found!"); - } -} - -sf::Sprite &simpleengine::AnimationComponent::GetSprite() const { - return sprite; -} - -sf::Texture &simpleengine::AnimationComponent::GetTextureSheet() const { - return texture_sheet; -} - -const std::map &simpleengine::AnimationComponent::GetAnimations() const { - return animations; -} - -simpleengine::Animation& simpleengine::AnimationComponent::GetAnimation(const std::string &animation_name) { - auto anim = animations.find(animation_name); - if (anim != animations.end()) { - return anim->second; - } else { - throw std::runtime_error("Animation, \"" + animation_name + "\", was not found!"); - } -} - - -bool simpleengine::AnimationComponent::HasAnimation(const std::string &animation_name) { - auto anim = animations.find(animation_name); - return anim != animations.end(); -} \ No newline at end of file diff --git a/src/components/collision_component.cpp b/src/components/collision_component.cpp deleted file mode 100644 index 8d72f25..0000000 --- a/src/components/collision_component.cpp +++ /dev/null @@ -1,84 +0,0 @@ -// -// Created by SeanOMik on 7/6/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#include "components/collision_component.h" -#include "components/ssma_component.h" -#include "entity.h" - -#include -#include - -simpleengine::CollisionComponent::CollisionComponent(Entity& owning_entity, sf::Transformable &transformable, float offset_x, float offset_y, - float width, float height) : simpleengine::CollisionComponent::CollisionComponent(owning_entity, transformable, sf::RectangleShape(), offset_x, offset_y) { - - hitbox.setPosition(transformable.getPosition().x + offset_x, transformable.getPosition().y + offset_y); - hitbox.setSize(sf::Vector2f(width, height)); - hitbox.setFillColor(sf::Color::Transparent); - hitbox.setOutlineThickness(1); - hitbox.setOutlineColor(sf::Color::Red); -} - -simpleengine::CollisionComponent::CollisionComponent(Entity& owning_entity, sf::Transformable& transformable, sf::Vector2f offset, sf::Vector2f size) - : simpleengine::CollisionComponent::CollisionComponent(owning_entity, transformable, offset.x, offset.y, size.x, size.y) { -} - -simpleengine::CollisionComponent::CollisionComponent(Entity& owning_entity, sf::Transformable& transformable, const sf::RectangleShape& hit, - float offset_x, float offset_y) : Component(owning_entity), transformable(transformable), hitbox(hit), offset_x(offset_x), offset_y(offset_y) { - - // SSMA Component set's the sprites texture offset so we need to set - // the offset to the origin if the entity has the SSMA component. - if (auto ssma_comp = owning_entity.GetComponent(); ssma_comp) { - offset_x += ssma_comp->GetAnimationComponent().GetSprite().getGlobalBounds().width * -0.5f; - } -} - -simpleengine::CollisionComponent::CollisionComponent(Entity& owning_entity, sf::Transformable& transformable, const sf::RectangleShape& hit, - sf::Vector2f offset) : simpleengine::CollisionComponent::CollisionComponent(owning_entity, transformable, hit, offset.x, offset.y) { - -} - -sf::RectangleShape &simpleengine::CollisionComponent::GetHitbox() { - return hitbox; -} - -sf::FloatRect CreateBounds(sf::RectangleShape rect) { - return sf::FloatRect(rect.getPosition(), rect.getSize()); -} - -bool simpleengine::CollisionComponent::DoesIntersect(const sf::FloatRect &rect) const { - return CreateBounds(hitbox).intersects(rect); -} - -bool simpleengine::CollisionComponent::DoesIntersect(const sf::RectangleShape &rect) const { - return CreateBounds(hitbox).intersects(CreateBounds(rect)); -} - -bool simpleengine::CollisionComponent::DoesIntersect(Entity& entity) const { - std::shared_ptr other_collider = entity.GetComponent(); - if (other_collider) { - return other_collider->DoesIntersect(hitbox); - } - - return false; -} - -void simpleengine::CollisionComponent::Update(const float &delta_time) { - hitbox.setPosition(owning_entity.GetTransformable().getPosition().x + offset_x, owning_entity.GetTransformable().getPosition().y + offset_y); -} - -void simpleengine::CollisionComponent::Render(sf::RenderTarget *target) { - //target->draw(hitbox); -} - -void simpleengine::CollisionComponent::SetOnCollide(std::function)> func) { - collide_function = func; -} - -void simpleengine::CollisionComponent::OnCollide(std::shared_ptr collided_entity) { - if (collide_function) { - collide_function(collided_entity); - } -} \ No newline at end of file diff --git a/src/components/movement/movement_component.cpp b/src/components/movement/movement_component.cpp deleted file mode 100644 index ef5e684..0000000 --- a/src/components/movement/movement_component.cpp +++ /dev/null @@ -1,174 +0,0 @@ -// -// Created by SeanOMik on 7/2/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#include "components/movement/movement_component.h" -#include "entity.h" -#include "game.h" - -#include -#include - -#include - -simpleengine::MovementComponent::MovementComponent(Entity& owning_entity, Game& game, float max_velocity, float acceleration, float deceleration) : - Component(owning_entity), max_velocity(max_velocity), acceleration(acceleration), deceleration(deceleration) { - - game.AddEventCallback(std::function([this](sf::Event::KeyEvent event) { - this->OnKeyPress(event); - })); - game.AddEventCallback(std::function([this](sf::Event::KeyEvent event) { - this->OnKeyRelease(event); - })); -} - -void simpleengine::MovementComponent::Move(const float& delta_time, const float& dir_x, const float& dir_y) { - // Acceleration - velocity.x += acceleration * dir_x; - // Limit the horizontal velocity - if (velocity.x > 0) { // Right - velocity.x = std::min(velocity.x, max_velocity); - } else if (velocity.x < 0) { // Left - velocity.x = std::max(velocity.x, -max_velocity); - } - - velocity.y += acceleration * dir_y; - // Limit the vertical velocity - if (velocity.y > 0) { // Up - velocity.y = std::min(velocity.y, max_velocity); - } else if (velocity.y < 0) { // Down - velocity.y = std::max(velocity.y, -max_velocity); - } - - // Limit total velocity - float y_sq = velocity.y * velocity.y; - float x_sq = velocity.x * velocity.x; - float abs_sq = y_sq + x_sq; - if (abs_sq > max_velocity * max_velocity) { - float abs = sqrt(abs_sq); - velocity.x *= max_velocity / abs; - velocity.y *= max_velocity / abs; - } - - owning_entity.Move(delta_time, velocity); -} - -void simpleengine::MovementComponent::OnKeyPress(sf::Event::KeyEvent event) { - sf::Keyboard::Key key = event.code; - - switch(key) { - case sf::Keyboard::W: - direction.y = -1; - break; - case sf::Keyboard::A: - direction.x = -1; - break; - case sf::Keyboard::S: - direction.y = 1; - break; - case sf::Keyboard::D: - direction.x = 1; - break; - default: - break; - } -} - -void simpleengine::MovementComponent::OnKeyRelease(sf::Event::KeyEvent event) { - sf::Keyboard::Key key = event.code; - - switch(key) { - case sf::Keyboard::W: - direction.y = (!sf::Keyboard::isKeyPressed(sf::Keyboard::S)) ? 0 : 1; - break; - case sf::Keyboard::A: - direction.x = (!sf::Keyboard::isKeyPressed(sf::Keyboard::D)) ? 0 : 1; - break; - case sf::Keyboard::S: - direction.y = (!sf::Keyboard::isKeyPressed(sf::Keyboard::W)) ? 0 : -1; - break; - case sf::Keyboard::D: - direction.x = (!sf::Keyboard::isKeyPressed(sf::Keyboard::A)) ? 0 : -1; - break; - default: - break; - } -} - -void simpleengine::MovementComponent::Update(const float& delta_time) { - // If we're not moving from deceleration or player input, then reset velocity. - bool no_movement = true; - - if (velocity.y > 0) { - if (velocity.y > max_velocity) { - velocity.y = max_velocity; - } - - velocity.y -= deceleration; - if (velocity.y < 0) { - velocity.y = 0; - } - - owning_entity.Move(velocity * delta_time); - no_movement = false; - } else if (velocity.y < 0) { - if (velocity.y < -max_velocity) { - velocity.y = -max_velocity; - } - - velocity.y += deceleration; - if (velocity.y > 0) { - velocity.y = 0; - } - - owning_entity.Move(velocity * delta_time); - no_movement = false; - } - - if (velocity.x > 0) { - if (velocity.x > max_velocity) { - velocity.x = max_velocity; - } - - velocity.x -= deceleration; - if (velocity.x < 0) { - velocity.x = 0; - } - - owning_entity.Move(velocity * delta_time); - no_movement = false; - } else if (velocity.x < 0) { - if (velocity.x < -max_velocity) { - velocity.x = -max_velocity; - } - - velocity.x += deceleration; - if (velocity.x > 0) { - velocity.x = 0; - } - - owning_entity.Move(velocity * delta_time); - no_movement = false; - } - - - if (direction.x != 0 || direction.y != 0) { - last_direction = direction; - Move(delta_time, direction.x, direction.y); - no_movement = false; - } - - if (no_movement) { - velocity = sf::Vector2f(); - } -} - -const sf::Vector2f &simpleengine::MovementComponent::GetVelocity() const { - return velocity; -} - -const sf::Vector2f &simpleengine::MovementComponent::GetLastDirection() const { - return last_direction; -} diff --git a/src/components/ssma_component.cpp b/src/components/ssma_component.cpp deleted file mode 100644 index 84d5c8a..0000000 --- a/src/components/ssma_component.cpp +++ /dev/null @@ -1,130 +0,0 @@ -// -// Created by SeanOMik on 7/5/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#include "components/ssma_component.h" - -simpleengine::SideScrollerMovementAnimationComponent::SideScrollerMovementAnimationComponent(simpleengine::Entity &owning_entity, - Game& game, sf::Sprite &sprite, sf::Texture &texture_sheet, float max_velocity, float acceleration, float deceleration) - : Component(owning_entity), anim_component(owning_entity, sprite, texture_sheet), - move_component(owning_entity, game, max_velocity, acceleration, deceleration) { -} - -void simpleengine::SideScrollerMovementAnimationComponent::SetAnimation(const simpleengine::MovementAnimationType &type, - simpleengine::Animation animation) { - - anim_component.AddAnimation(MovementAnimationTypeToStr(type), animation); -} - -void simpleengine::SideScrollerMovementAnimationComponent::SetAnimation(const simpleengine::MovementAnimationType &type, - float speed, int start_frame_x, int start_frame_y, int frame_ct_x, int frame_ct_y, int width, int height) { - - anim_component.AddAnimation(MovementAnimationTypeToStr(type), speed, start_frame_x, start_frame_y, - frame_ct_x, frame_ct_y, width, height); -} - - -void simpleengine::SideScrollerMovementAnimationComponent::Update(const float& delta_time) { - move_component.Update(delta_time); - - if (move_component.GetVelocity().x > 0) { // Moving right - // If the user never set a WALK_RIGHT animation, then we need to flip the WALK_LEFT one. - if (anim_component.HasAnimation("WALK_RIGHT")) { - Animation& anim = anim_component.GetAnimation("WALK_RIGHT"); - if (anim.IsHorizontallyFlipped()) { - anim.FlipHorizontally(); - } - - anim.Update(delta_time); - } else { - Animation& anim = anim_component.GetAnimation("WALK_LEFT"); - if (!anim.IsHorizontallyFlipped()) { - anim.FlipHorizontally(); - } - anim.Update(delta_time); - } - } else if (move_component.GetVelocity().x < 0) { // Moving left - // If the user never set a WALK_LEFT animation, then we need to flip the WALK_RIGHT one. - if (anim_component.HasAnimation("WALK_LEFT")) { - Animation& anim = anim_component.GetAnimation("WALK_LEFT"); - if (anim.IsHorizontallyFlipped()) { - anim.FlipHorizontally(); - } - - anim.Update(delta_time); - } else { - Animation& anim = anim_component.GetAnimation("WALK_RIGHT"); - if (!anim.IsHorizontallyFlipped()) { - anim.FlipHorizontally(); - } - anim.Update(delta_time); - } - } else { - // If the user never set an IDLE_RIGHT animation, then we need to flip the IDLE_LEFT one. - if (move_component.GetLastDirection().x > 0) { // Facing right - if (anim_component.HasAnimation("IDLE_RIGHT")) { - Animation& anim = anim_component.GetAnimation("IDLE_RIGHT"); - if (anim.IsHorizontallyFlipped()) { - anim.FlipHorizontally(); - } - - anim.Update(delta_time); - } else { - Animation& anim = anim_component.GetAnimation("IDLE_LEFT"); - anim.Update(delta_time); - } - } else if (move_component.GetLastDirection().x < 0) { // Facing left - if (anim_component.HasAnimation("IDLE_LEFT")) { - Animation& anim = anim_component.GetAnimation("IDLE_LEFT"); - if (anim.IsHorizontallyFlipped()) { - anim.FlipHorizontally(); - } - - anim.Update(delta_time); - } else { - Animation& anim = anim_component.GetAnimation("IDLE_RIGHT"); - anim.Update(delta_time); - } - } else { - // If the user never set an IDLE_LEFT animation, then we need to flip the IDLE_RIGHT one. - if (anim_component.HasAnimation("IDLE_LEFT")) { - Animation& anim = anim_component.GetAnimation("IDLE_LEFT"); - if (anim.IsHorizontallyFlipped()) { - anim.FlipHorizontally(); - } - - anim.Update(delta_time); - } else { - Animation& anim = anim_component.GetAnimation("IDLE_RIGHT"); - anim.Update(delta_time); - } - } - } -} - -std::string simpleengine::SideScrollerMovementAnimationComponent::MovementAnimationTypeToStr( - const simpleengine::MovementAnimationType &type) { - - switch (type) { - case WALK_LEFT: - return "WALK_LEFT"; - case WALK_RIGHT: - return "WALK_RIGHT"; - case IDLE_LEFT: - return "IDLE_LEFT"; - case IDLE_RIGHT: - return "IDLE_RIGHT"; - default: - return "UNKNOWN_MOVEMENT_ANIMATION_TYPE"; - } -} - -simpleengine::AnimationComponent& simpleengine::SideScrollerMovementAnimationComponent::GetAnimationComponent() { - return anim_component; -} - -simpleengine::MovementComponent& simpleengine::SideScrollerMovementAnimationComponent::GetMovementComponent() { - return move_component; -} diff --git a/src/entity.cpp b/src/entity.cpp deleted file mode 100644 index 6bfa161..0000000 --- a/src/entity.cpp +++ /dev/null @@ -1,51 +0,0 @@ -// -// Created by SeanOMik on 7/3/2020. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#include "entity.h" -#include "component.h" - -simpleengine::Entity::Entity(sf::Transformable &transformable) : transformable(transformable) { - -} - -void simpleengine::Entity::Move(const float &delta_time, const float &dir_x, const float &dir_y) { - transformable.setPosition(dir_x * delta_time, dir_y * delta_time); -} - -void simpleengine::Entity::Move(const float &delta_time, const sf::Vector2f &offset) { - transformable.move(offset * delta_time); -} - -void simpleengine::Entity::Move(const sf::Vector2f &offset) { - transformable.move(offset); -} - -void simpleengine::Entity::Render(sf::RenderTarget *target) { - RenderComponents(target); -} - -void simpleengine::Entity::Update(const float &delta_time) { - UpdateComponents(delta_time); -} - -void simpleengine::Entity::UpdateComponents(const float& delta_time) { - // Update each component and if they are being destroyed, destroy them. - for (std::vector>::iterator it = components.begin(); it != components.end(); ) { - (*it)->Update(delta_time); - - if ((*it)->IsDestroying()) { - it = components.erase(it); - } else { - ++it; - } - } -} - -void simpleengine::Entity::RenderComponents(sf::RenderTarget* target) { - for (std::shared_ptr& component : components) { - component->Render(target); - } -} \ No newline at end of file diff --git a/src/events/collision_handler.cpp b/src/events/collision_handler.cpp deleted file mode 100644 index 73f224f..0000000 --- a/src/events/collision_handler.cpp +++ /dev/null @@ -1,48 +0,0 @@ -// -// Created by SeanOMik on 3/1/2021. -// Github: https://github.com/SeanOMik -// Email: seanomik@gmail.com -// - -#include "events/collision_handler.h" -#include "components/collision_component.h" -#include "entity.h" -#include "events/entity_event.h" -#include "game.h" - -#include - -void simpleengine::CollisionHandler::Update(const float& delta_time) { - // Update list of handled entities. - handled_entities.erase(std::remove_if(handled_entities.begin(), handled_entities.end(), - [](std::shared_ptr ptr) { return ptr == nullptr; }), handled_entities.end()); - - for (simpleengine::Event* event : game.events) { - auto* entity_event = dynamic_cast(event); - - if (entity_event) { - std::shared_ptr entity = entity_event->GetEntity(); - if (std::count(handled_entities.begin(), handled_entities.end(), entity) == 0) { - handled_entities.push_back(entity); - } - } - } - - // Check for collisions in all entities. - for (std::shared_ptr entity : handled_entities) { - std::shared_ptr entity_col = entity->GetComponent(); - - if (entity_col) { - for (std::shared_ptr two : handled_entities) { - if (two == entity) continue; - - std::shared_ptr two_col = two->GetComponent(); - if (two_col) { - if (entity_col->DoesIntersect(two_col->GetHitbox())) { - entity_col->OnCollide(two); - } - } - } - } - } -} \ No newline at end of file