diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,661 @@ + GNU AFFERO GENERAL PUBLIC LICENSE + Version 3, 19 November 2007 + + 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. + + Preamble + + The GNU Affero General Public License is a free, copyleft license for +software and other kinds of works, specifically designed to ensure +cooperation with the community in the case of network server 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, +our General Public Licenses are 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. + + 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. + + Developers that use our General Public Licenses protect your rights +with two steps: (1) assert copyright on the software, and (2) offer +you this License which gives you legal permission to copy, distribute +and/or modify the software. + + A secondary benefit of defending all users' freedom is that +improvements made in alternate versions of the program, if they +receive widespread use, become available for other developers to +incorporate. Many developers of free software are heartened and +encouraged by the resulting cooperation. However, in the case of +software used on network servers, this result may fail to come about. +The GNU General Public License permits making a modified version and +letting the public access it on a server without ever releasing its +source code to the public. + + The GNU Affero General Public License is designed specifically to +ensure that, in such cases, the modified source code becomes available +to the community. It requires the operator of a network server to +provide the source code of the modified version running there to the +users of that server. Therefore, public use of a modified version, on +a publicly accessible server, gives the public access to the source +code of the modified version. + + An older license, called the Affero General Public License and +published by Affero, was designed to accomplish similar goals. This is +a different license, not a version of the Affero GPL, but Affero has +released a new version of the Affero GPL which permits relicensing under +this license. + + 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 Affero 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. Remote Network Interaction; Use with the GNU General Public License. + + Notwithstanding any other provision of this License, if you modify the +Program, your modified version must prominently offer all users +interacting with it remotely through a computer network (if your version +supports such interaction) an opportunity to receive the Corresponding +Source of your version by providing access to the Corresponding Source +from a network server at no charge, through some standard or customary +means of facilitating copying of software. This Corresponding Source +shall include the Corresponding Source for any work covered by version 3 +of the GNU General Public License that is incorporated pursuant to the +following paragraph. + + 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 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 work with which it is combined will remain governed by version +3 of the GNU General Public License. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU Affero 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 Affero 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 Affero 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 Affero 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 Affero 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If your software can interact with users remotely through a computer +network, you should also make sure that it provides a way for users to +get its source. For example, if your program is a web application, its +interface could display a "Source" link that leads users to an archive +of the code. There are many ways you could offer source, and different +solutions will be better for different programs; see section 13 for the +specific requirements. + + 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 AGPL, see +. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,86 @@ +{- | +- Module : $Header$ +- Description : The blubber server Cabal setup file. +- Copyright : (c) plaimi 2015 +- License : AGPL-3 +- +- Maintainer : blubber@plaimi.net +- -} + +import Control.Exception + ( + catch, + ) +import Control.Monad + ( + unless, + ) +import Data.Text + ( + pack, + toTitle, + unpack, + ) +import Distribution.Simple + ( + defaultMainWithHooks, + preBuild, + simpleUserHooks, + ) +import System.Exit + ( + ExitCode (ExitSuccess), + ) +import System.IO.Error + ( + isAlreadyExistsError, + ioeGetErrorString, + ) +import System.Posix + ( + createDirectory, + ) +import System.Process + ( + rawSystem, + ) +import Text.Printf + ( + printf, + ) + +main :: IO () +-- | Make web/src.tar.gz pre-build, so an URL may be served to clients upon +-- request. +main = defaultMainWithHooks + $ simpleUserHooks + {preBuild = \args buildFlags -> do + createDirectory "web" 0o755 `catch` \e -> + unless (isAlreadyExistsError e) $ + printf ("couldn't make the web directory: %s\n" + ++ "please do it yourself. we need it!") + $ unpack . toTitle . pack $ ioeGetErrorString e + exitCode <- rawSystem "tar" $ tarOut ++ tarIn + putStrLn $ echoOut exitCode + preBuild simpleUserHooks args buildFlags + } + +tarOut :: [String] +-- | The file generated by tar. +tarOut = ["cfz", "web/src.tar.gz"] + +tarIn :: [String] +-- | The files passed to tar. +tarIn = ["Setup.hs" + ,"blubber-server.cabal" + ,"src" + ,"src-exec" + ] + +echoOut :: ExitCode -> String +-- | Make an output text to echo, depending on the passed in 'ExitCode'. +echoOut ExitSuccess = "'put src in web/src.tar.gz'" +echoOut _ = "'uh-oh! couldn't make a gzipped tarball of the src! " + ++ "you need to put the src of your blubber server in a " + ++ "file \"web/src.tar.gz\" before building. this is to " + ++ "comply with the GNU AGPLv3." diff --git a/blubber-server.cabal b/blubber-server.cabal new file mode 100644 --- /dev/null +++ b/blubber-server.cabal @@ -0,0 +1,58 @@ +name: blubber-server +version: 0.0.1 +synopsis: The blubber server, serves blubber clients. +description: The blubber server. blubber is an arcade game in + which the player tries to build the biggest blob + by blubberping the other blobs before they + blubber the player's blob. +homepage: https://secure.plaimi.net/games/blubber.html +license: AGPL-3 +license-file: LICENSE +author: plaimi +maintainer: blubber@plaimi.net +copyright: (c) plaimi 2015 +category: Game +build-type: Custom +cabal-version: >=1.10 +data-files: web/index.markdown + web/src.tar.gz + +source-repository head + type: git + location: git://github.com/plaimi/blubber-server.git + +library + exposed-modules: Blubber.Server.Entity + Blubber.Server.Message + Blubber.Server.Vector + Blubber.Server.World + Blubber.Server.ViewPort + other-extensions: DeriveGeneric + build-depends: base >=4.7 && <4.8, + cereal >=0.4 && <0.5, + containers >=0.5 && <0.6, + random >=1.1 && <1.2 + hs-source-dirs: src + default-language: Haskell2010 + +executable blubber-server + main-is: blubber-server.hs + other-extensions: OverloadedStrings + other-modules: Paths_blubber_server + build-depends: base >=4.7 && <4.9, + blubber-server, + Cabal >=1.18 && <1.23, + cereal >=0.4 && <0.5, + containers >=0.5 && <0.6, + data-default-class >=0.0.1 && <0.1, + network >=2.6 && <2.7, + pandoc >=1.14 && <1.15, + process >=1.2 && <1.3, + random >=1.1 && <1.2, + scotty >=0.7 && <0.11, + text >=1.2 && <1.3, + transformers >=0.4 && <0.5, + unix >=2.7 && <2.8 + hs-source-dirs: src-exec + default-language: Haskell2010 + ghc-options: -threaded -with-rtsopts=-N diff --git a/src-exec/blubber-server.hs b/src-exec/blubber-server.hs new file mode 100644 --- /dev/null +++ b/src-exec/blubber-server.hs @@ -0,0 +1,287 @@ +{-# LANGUAGE OverloadedStrings #-} +{-# OPTIONS_GHC -fno-warn-type-defaults #-} + +{- | +Module : $Header$ +Description : The blubber server entry point. +Copyright : (c) plaimi 2015 +License : AGPL-3 + +Maintainer : blubber@plaimi.net +-} module Main where + +import Control.Arrow + ( + second, + ) +import Control.Concurrent + ( + forkIO, + ) +import Control.Concurrent.Chan + ( + Chan, + newChan, + readChan, + writeChan, + ) +import Control.Monad + ( + forever, + void, + ) +import Control.Monad.IO.Class + ( + liftIO, + ) +import Data.Default.Class + ( + def, + ) +import Data.IORef + ( + IORef, + newIORef, + readIORef, + writeIORef, + ) +import Data.Functor + ( + (<$>), + ) +import qualified Data.Foldable as F +import Data.Map + ( + Map, + delete, + empty, + fromList, + insert, + toList, + ) +import qualified Data.Map as M +import Data.Text.Lazy + ( + pack, + ) +import Data.Serialize + ( + decode, + encode, + ) +import Network.Socket + ( + Family (AF_INET), + SockAddr (SockAddrInet), + Socket, + SocketType (Datagram), + bind, + iNADDR_ANY, + socket, + withSocketsDo + ) +import Network.Socket.ByteString + ( + recvFrom, + sendTo, + ) +import System.Random + ( + newStdGen, + ) +import System.Posix.Unistd + ( + usleep, + ) +import Text.Pandoc.Readers.Markdown + ( + readMarkdown, + ) +import Text.Pandoc.Writers.HTML + ( + writeHtmlString, + ) +import Web.Scotty + ( + file, + get, + html, + setHeader, + scotty, + ) +import System.Environment + ( + getArgs, + ) + +import Blubber.Server.Message + ( + Message (AddPlayer, Connect, Disconnect, SrcPls, UpdateVelocity), + Reply (SrcLink, View) + ) +import Blubber.Server.ViewPort + ( + ViewPort, + mkViewPort, + ) +import Blubber.Server.World + ( + World, + addNeutral, + addPlayer, + createWorld, + delPlayer, + handleInput, + updateWorld, + ) + +import Paths_blubber_server + +-- | An 'Event' can either be a message from the client, or a 'Tick' to +-- the 'World' a bit further ahead. +data Event = ClientMessage SockAddr Message + -- ^ A 'Message' from the client. + | Tick Double Double + -- A 'Tick' means an update is due. + deriving (Show) + +-- | An internal wrapper type for server news to the client. +data ServerNews = WorldUpdate (Map SockAddr ViewPort) + -- ^ The 'World' has been updated; new 'ViewPorts' required. + | SourceLink SockAddr String + -- ^ Someone's asked for a link to the source code. + deriving (Show) + +main :: IO () +-- | Our 'main' entry point. Sets up chans & IOrefs, & spawns the right +-- threads to do the actual work. +-- +-- It also sets up a tiny Web server at port 8765, serving some info and +-- the source code. The game itself is on port 12354. +main = withSocketsDo $ do + s <- socket AF_INET Datagram 0 + r <- newStdGen + as <- getArgs + let (gp, wp) = case as of + [g', w'] -> (fromInteger . read $ g', fromInteger . read $ w') + _ -> error "start with ./blubber-server [PORT] [PORT]" + bind s $ SockAddrInet gp iNADDR_ANY + wi <- newChan + wo <- newChan + is <- newIORef empty + _ <- forkIO $ forever $ listen s wi is + _ <- forkIO $ forever $ talk s wo + _ <- forkIO $ watch wi 0.01 0.0 + _ <- forkIO $ serve wp + putStrLn $ "Setting blubbers to blub... (port " ++ show gp + ++ ") (ctrl-c to quit)" + step wp wi wo is (createWorld r) empty + +watch :: Chan Event -> Double -> Double -> IO () +-- | Sleep a bit, and add a new 'Tick' via a 'Chan Event' +watch wi dt t = do + usleep . round $ 1000000 * dt + writeChan wi $ Tick dt t + watch wi dt (t + dt) + +step :: Int + -> Chan Event + -> Chan ServerNews + -> IORef (Map SockAddr (Double, Double)) + -> World + -> Map SockAddr String + -> IO () +-- | 'step' the 'World' one 'step' ahead. It takes five arguments, and is +-- jolly complicated at present. +-- +-- First 'wi', which is a 'Chan' written to by 'listen' +-- when it wants to 'Connect', 'DisConnect', or 'AddPlayer', and by 'watch' +-- when it wants to 'Tick'. +-- +-- Then 'wo', which is the 'IORef' which 'step' writes to when it has updated +-- the clients and/or the 'World'. This is used by 'talk' to send out +-- a 'ViewPort' based on the 'World' to each client. +-- +-- Next up, we have 'is' -- an 'IORef' with a 'Map' of 'SockAddr's and their +-- latest desired inputs, as two 'Double's, one for x, one for y. 'listen' +-- writes to this channel; 'step' reads it and is responsible for actually +-- doing 'handleInput' +-- +-- Then the two last arguments are the 'World' and a list of clients. These +-- are updated in 'step', and written to the 'wo' channel for 'talk' to use. +-- 'step' recurses with these two arguments as its state. +step wp wi wo is w cs = do + wj <- readChan wi + (cs', w') <- case wj of + Tick dt t -> do + js <- readIORef is + let w' = handleInput (toList js) cs w + let w'' = updateWorld dt w' + let w''' = if round (t / 5) /= round ((t - dt) / 5) + then addNeutral w'' + else w'' + writeChan wo $ WorldUpdate (mkViewPorts cs w) + return (cs, w''') + ClientMessage c m -> + case m of + Connect -> do + return (insert c "" cs, w) + Disconnect -> do + case M.lookup c cs of + Just p -> return (delete c cs + ,w `delPlayer` p) + Nothing -> return (cs, w) + (AddPlayer p) -> return (insert c p cs, w `addPlayer` p) + SrcPls i -> do + writeChan wo (SourceLink c (i ++ ":" ++ show wp + ++ "/src.tar.gz")) + return (cs, w) + _ -> return (cs, w) + step wp wi wo is w' cs' + + +listen :: Socket -> Chan Event -> IORef (Map SockAddr (Double, Double)) + -> IO () +-- | Check if the clients have anything to say. Put the last thing each client +-- has to say in the 'Map' of 'IORef's. +listen sock wi is = do + (m, c) <- recvFrom sock 4096 + case decode m of + Right cm -> case cm of + UpdateVelocity (x, y) -> do + js <- readIORef is + writeIORef is $ insert c (x, y) js + _ -> writeChan wi $ ClientMessage c cm + Left _ -> return () + +talk :: Socket -> Chan ServerNews -> IO () +-- | Send out updated 'ViewPort's to the connect clients. +talk s wo = do + m <- readChan wo + case m of + WorldUpdate cv -> (\(c, vp) -> + sendTo s (encode (View vp)) c) `F.mapM_` toList cv + SourceLink c a -> void $ sendTo s (encode (SrcLink a)) c + +serve :: Int -> IO () +-- | Very simple Web server with an info page and the source code of the game. +-- +-- The info page is compiled from web/index.markdown. +-- +-- The source is served from web/src.tar.gz. +serve = flip scotty $ do + get "/src.tar.gz" $ do + setHeader "Content-Disposition" "attachment" + setHeader "Content-Type" "application/x-gzip" + setHeader "filename" "src.tar.gz" + file =<< liftIO (getDataFileName "web/src.tar.gz") + get "/" $ do + setHeader "Content-Type" "text/html" + f <- liftIO $ readFile =<< getDataFileName "web/index.markdown" + case readMarkdown def f of + Left _ -> html "blubber-server" + Right m -> html . pack . writeHtmlString def $ m + +mkViewPorts :: Map SockAddr String -> World -> Map SockAddr ViewPort +-- | Make a 'ViewPort' for ever client. +mkViewPorts cs w = fromList $ (mkViewPort w `second`) <$> toList cs diff --git a/src/Blubber/Server/Entity.hs b/src/Blubber/Server/Entity.hs new file mode 100644 --- /dev/null +++ b/src/Blubber/Server/Entity.hs @@ -0,0 +1,96 @@ +{-# LANGUAGE DeriveGeneric #-} + +{- | +Module : $Header$ +Description : The Entity type and its operations. +Copyright : (c) plaimi 2015 +License : AGPL-3 + +Maintainer : blubber@plaimi.net +-} module Blubber.Server.Entity where + +import Data.Serialize + ( + Serialize, + ) +import GHC.Generics + ( + Generic, + ) + +import Blubber.Server.Vector + ( + Vector (Vec), + (^+^), + (^-^), + (^*^), + (^/^), + magVec, + ) + +-- | An 'Entity' is a 'Blub' with a position and mass. +data Entity = MkEntity + {position :: Vector -- ^ The position of the 'Blub'. + ,mass :: Double -- ^ The mass of the 'Blub'. + ,entity :: Blub -- ^ The Blub itself. + } deriving (Eq, Generic, Show) + +-- | 'Entity's may be ordered based on their 'mass'. +instance Ord Entity where compare e f = compare (mass e) (mass f) + +-- | 'Entity' uses a 'Serialize' instance to encode its data. +instance Serialize Entity + +-- | The 'Blub' is our hero. It is either a 'NeutralBlub' that may simply be +-- consumed by 'PlayerBlub', or it is indeed a 'PlayerBlub'. +-- A human-controlled 'Blub' has a velocity and a target position in +-- addition to the usual 'Entity' stuff. +data Blub = NeutralBlub + | PlayerBlub + {velocity :: Vector + ,targetPos :: Vector + } deriving (Eq, Generic, Show) + +-- | 'Blub' uses a 'Serialize' instance to encode its data. +instance Serialize Blub + +radius :: Entity -> Double +-- | The 'radius' of the 'Entity'. +radius = sqrt . mass + +isNeutral :: Entity -> Bool +-- | 'isNeutral' is a quick hack to check if an 'Entity' holds a 'NeutralBlub' +-- or not. +isNeutral = n . entity where n NeutralBlub = True + n _ = False + +intersect :: Entity -> Entity -> Maybe Vector +-- | Simple circle-circle-based intersect check of 'Entity's based on their +-- 'radius'. +intersect e f | radius e + radius f > magVec v = Just v + | otherwise = Nothing + where v = position e ^-^ position f + +fite :: (Entity, Entity) -> (Maybe Entity, Maybe Entity) +-- | A 'fite' between the passed in 'Entity's. The bigger one eats the +-- smaller. If they are equal no one eats each other. They just hug. +fite (b, c) = case b `intersect` c of + Just _ | b > c -> (Just $ b `blubber` c + ,Nothing) + | b < c -> (Nothing + ,Just $ c `blubber` b) + | otherwise -> (Just b, Just c) + Nothing -> (Just b, Just c) + +blubber :: Entity -> Entity -> Entity +-- | Let the first 'Entity' 'blubber' the second 'Entity'. I.e. EAT IT! +-- Omnomnom. +blubber b c | isNeutral b = b + | otherwise = b + {mass = mass b + mass c + ,entity = (entity b) + {velocity = (velocity (entity b) ^*^ mass b + ^+^ vc ^*^ mass c) ^/^ (mass b + mass c)} + } + where vc | isNeutral c = Vec 0 0 + | otherwise = velocity (entity c) diff --git a/src/Blubber/Server/Message.hs b/src/Blubber/Server/Message.hs new file mode 100644 --- /dev/null +++ b/src/Blubber/Server/Message.hs @@ -0,0 +1,49 @@ +{-# LANGUAGE DeriveGeneric #-} + +{- | +Module : $Header$ +Description : The blubber messaging format for communicating with the server. +Copyright : (c) plaimi 2015 +License : AGPL-3 + +Maintainer : blubber@plaimi.net +-} module Blubber.Server.Message where + +import Data.Serialize + ( + Serialize, + ) +import GHC.Generics + ( + Generic, + ) + +import Blubber.Server.ViewPort + ( + ViewPort, + ) + +-- | The types of messages the blubber server accepts. +data Message = Connect + -- ^ Ask to shake hands. + | Disconnect + -- ^ Ask to part ways. + | AddPlayer String + -- ^ Ask to add a new player to the world. + | UpdateVelocity (Double, Double) + -- ^ Ask to update the velocity of a player's 'Blub' + | SrcPls String + -- ^ Ask the given IP for the source code. + deriving (Eq, Generic, Show) + +-- | The types of replies the blubber server sends. +data Reply = View ViewPort + -- ^ The latest 'ViewPort' for the client. + | SrcLink String + -- ^ A link to the server's source code. + deriving (Eq, Generic, Show) + +instance Serialize Reply + +-- | 'Message' uses a 'Serialize' instance to encode its data. +instance Serialize Message diff --git a/src/Blubber/Server/Vector.hs b/src/Blubber/Server/Vector.hs new file mode 100644 --- /dev/null +++ b/src/Blubber/Server/Vector.hs @@ -0,0 +1,57 @@ +{-# LANGUAGE DeriveGeneric #-} + +{- | +Module : $Header$ +Description : The vector type and its operations. +Copyright : (c) plaimi 2015 +License : AGPL-3 + +Maintainer : blubber@plaimi.net +-} module Blubber.Server.Vector where + +import Data.Serialize + ( + Serialize, + ) +import GHC.Generics + ( + Generic, + ) + +-- A simple vector type with an x and a y. +data Vector = Vec + {vx :: Double -- ^ The x position. + ,vy :: Double -- ^ The y position. + } deriving (Eq, Generic, Show) + +-- | 'Vector' uses a 'Serialize' instance to encode its data. +instance Serialize Vector + +infixl 6 ^-^ +(^-^) :: Vector -> Vector -> Vector +-- | 'Vector' subtraction. +(Vec x y) ^-^ (Vec x' y') = Vec (x - x') (y - y') + +infixl 6 ^+^ +-- | 'Vector' addition. +(^+^) :: Vector -> Vector -> Vector +(Vec x y) ^+^ (Vec x' y') = Vec (x + x') (y + y') + +infixl 7 ^*^ +-- | Multiply a 'Vector' with a scalar. +(^*^) :: Vector -> Double -> Vector +(Vec x y) ^*^ n = Vec (n * x) (n * y) + +infixl 7 ^/^ +-- | Divide a 'Vector' by a scalar. +(^/^) :: Vector -> Double -> Vector +(Vec x y) ^/^ n = Vec (n / x) (n / y) + +magVec :: Vector -> Double +-- | Calculate the magnitude of a 'Vector'. +magVec (Vec x y) = sqrt (x * x + y * y) + +vecLimitMag :: Double -> Vector -> Vector +-- | Limit the magnitude of a 'Vector' to a scalar. +vecLimitMag m v | magVec v > m = v ^*^ (m / magVec v) + | otherwise = v diff --git a/src/Blubber/Server/ViewPort.hs b/src/Blubber/Server/ViewPort.hs new file mode 100644 --- /dev/null +++ b/src/Blubber/Server/ViewPort.hs @@ -0,0 +1,128 @@ +{-# LANGUAGE DeriveGeneric #-} +{-# OPTIONS_GHC -fno-warn-type-defaults #-} + +{- | +Module : $Header$ +Description : The ViewPort type and its operations. +Copyright : (c) plaimi 2015 +License : AGPL-3 + +Maintainer : blubber@plaimi.net +-} module Blubber.Server.ViewPort where + +import Data.Map (Map) +import qualified Data.Map as M +import Data.Set (Set) +import qualified Data.Set as S +import Data.Maybe + ( + fromJust, + ) +import Data.Serialize + ( + Serialize, + ) +import GHC.Generics + ( + Generic, + ) + +import Blubber.Server.Entity + ( + Entity, + mass, + position, + radius, + ) +import Blubber.Server.Vector + ( + Vector (Vec), + (^-^), + magVec, + vx, + vy, + ) +import Blubber.Server.World + ( + World, + neutrals, + clamp, + height, + neutrals, + players, + width, + ) + +-- | A 'ViewPort' is the part of the 'World' that a client is privy to. +data ViewPort = MkViewPort + {viewPos :: Vector + -- ^ The absolute position of the 'ViewPort' + ,viewWidth :: Double + -- ^ The width of the 'ViewPort'. + ,viewHeight :: Double + -- ^ The height of the 'ViewPort'. + ,visiblePlayers :: Map String Entity + -- ^ The visible 'PlayerBlob's in the 'ViewPort'. + ,visibleNeutrals :: [Entity] + -- ^ The visible 'NeutralBlob's in the 'ViewPort'. + } deriving (Eq, Generic, Show) + + +-- | 'ViewPort' uses a 'Serialize' instance to encode its data. +instance Serialize ViewPort + +mkViewPort :: World -> String -> ViewPort +-- | Make a 'ViewPort' for the passed in client's 'Entity'. If they don't have +-- an 'Entity', then we'll just give them the entire 'World' via +-- 'worldViewPort'. The 'ViewPort' also includes the 'mass' of the player's +-- own 'Entity'. +mkViewPort w p = + case M.lookup p (players w) of + Just b -> MkViewPort {viewPos = position e + ,viewWidth = wid + ,viewHeight = hei + ,visiblePlayers = + M.insert (p ++ ": " ++ show (floor (mass e))) b + . M.delete p $ getVisiblePlayers (players w) + (position e) + (radius e) + ,visibleNeutrals = S.toList + $ getVisibles (neutrals w) + (position e) + (radius e) + } + Nothing -> worldViewPort w + where e = fromJust (M.lookup p (players w)) -- Stooopid. + wid = radius e * 16 + hei = radius e * 9 + +getVisiblePlayers :: Map String Entity -> Vector -> Double + -> Map String Entity +-- | Figure out which 'PlayerBlob's are visible to a client, based on their +-- 'position' and 'radius'. +getVisiblePlayers v pos r = M.filter visibleP v + where visibleP e = magVec (dev e ^-^ Vec (c 16 vx e) (c 9 vy e)) <= radius e + dev = (^-^ pos) . position + c a d e = clamp ((-(r * a)) / 2) (r * a / 2) (d (dev e)) + +getVisibles :: Set Entity -> Vector -> Double -> Set Entity +-- | Figure out which 'NeutralBlob's are visible to a client, based on their +-- 'position' and 'radius'. +getVisibles v pos r = S.filter visibleP v + where visibleP e = magVec (dev e ^-^ Vec (c 16 vx e) (c 9 vy e)) <= radius e + dev = (^-^ pos) . position + c a d e = clamp ((-(r * a)) / 2) (r * a / 2) (d (dev e)) + +worldViewPort :: World -> ViewPort +-- | Make a 'ViewPort' of essentieally the whole 'World' and all its +-- 'Entity's. +worldViewPort w = MkViewPort + {viewPos = Vec 0 0 + ,viewWidth = width w + ,viewHeight = height w + ,visiblePlayers = players w + ,visibleNeutrals = S.elems (neutrals w) + } + +viewPort :: World -> String -> ViewPort +viewPort w p = w `mkViewPort` p diff --git a/src/Blubber/Server/World.hs b/src/Blubber/Server/World.hs new file mode 100644 --- /dev/null +++ b/src/Blubber/Server/World.hs @@ -0,0 +1,262 @@ +{-# LANGUAGE DeriveGeneric #-} + +{- | +Module : $Header$ +Description : The blubber world. +Copyright : (c) plaimi 2015 +License : AGPL-3 + +Maintainer : blubber@plaimi.net +-} module Blubber.Server.World where + +import Data.Functor + ( + (<$>), + ) +import qualified Data.List as L +import Data.Maybe + ( + catMaybes, + ) +import Data.Map (Map) +import qualified Data.Map as M +import Data.Set (Set) +import qualified Data.Set as S +import System.Random + ( + StdGen, + randomR, + ) + +import Blubber.Server.Entity + ( + Entity (MkEntity), + Blub (NeutralBlub, PlayerBlub), + entity, + intersect, + isNeutral, + fite, + mass, + position, + targetPos, + velocity, + ) +import Blubber.Server.Vector + ( + Vector (Vec), + (^+^), + (^-^), + (^*^), + (^/^), + magVec, + vecLimitMag, + ) + +-- | The 'World' in which the 'Entity's reside. +data World = MkWorld + {width :: Double + -- ^ The width of the 'World'. + ,height :: Double + -- ^ The height of the 'World'. + ,players :: Map String Entity + -- ^ The 'PlayerBlob's in the 'World' indexed on their names. + ,neutrals :: Set Entity + -- ^ The 'NeutralBlob's in the 'World'. + ,entropy :: StdGen + -- ^ The 'entropy' of the 'World', for randomising things. + } deriving (Show) + +addNeutral :: World -> World +-- | Try to add a 'NeutralBlub' to the 'World', if there is room for it. But +-- don't try *very* hard. +addNeutral w | S.size (neutrals w) < 32 + && available w b = w' {neutrals = S.insert b (neutrals w)} + | otherwise = w' + where b = MkEntity {position = Vec px py + ,mass = m + ,entity = NeutralBlub + } + (m, entropy') = randomR (1.0, 5.0) $ entropy w + (px, entropy'') = randomR (0.0, width w) entropy' + (py, entropy''') = randomR (0.0, height w) entropy'' + w' = w {entropy = entropy'''} + +addPlayer :: World -> String -> World +-- | Add a 'PlayerBlub' belonging to the name in the passed in 'String', lest +-- it already has a 'PlayerBlub', in which case it's just ignored. +addPlayer w s | s `M.member` players w + /= True = if available w b + then w' {players = M.insert s b (players w)} + else addPlayer w' s + | otherwise = w + where + b = MkEntity {position = Vec px py + ,mass = 10.0 + ,entity = PlayerBlub {velocity = Vec 0 0 + ,targetPos = Vec 0 0 + } + } + (px, e') = randomR (0.0, width w) $ entropy w + (py, e'') = randomR (0.0, height w) e' + w' = w {entropy = e''} + +delPlayer :: World -> String -> World +-- | Delete a 'PlayerBlub' belonging to the name in the passed in 'String', +-- lest it doesn't exist, in which case it's just ignored. +delPlayer w p = w {players = M.delete p (players w)} + +available :: World -> Entity -> Bool +-- | For use with 'Entity's that are not yet placed in the 'World', in order +-- to check that the spot you are attempting to place them in is actually +-- available -- i.e. that it doesn't intersect with already placed out +-- 'Entity's +available w b = null . catMaybes $ intersect b + <$> (S.elems (neutrals w) ++ M.elems (players w)) + +clamp :: Ord a => a -> a -> a -> a +-- | 'clamp' stuff between a min and a max. +clamp l h = max l . min h + +createWorld :: StdGen -> World +-- | The initial 'World'. +createWorld s = MkWorld + {width = 160 + ,height = 90 + ,players = M.empty + ,neutrals = S.empty + ,entropy = s + } + +updateVel :: Double -> Entity -> Entity +-- | Update the 'velocity' of an 'Entity' based on its 'targetPos', and +-- limited by its 'mass'. +updateVel dt e@(MkEntity {entity = b, mass = m}) + | isNeutral e = e + | otherwise = e {entity = b {velocity = velocity b ^+^ a ^*^ dt}} + where a | magVec dv <= 0.01 = Vec 0 0 + | otherwise = vecLimitMag (magVec dv / dt) + $ dv ^/^ (magVec dv * m) + dv = tv ^-^ velocity b + tv = vecLimitMag maxSpeed $ targetPos b ^*^ (maxSpeed / m) + maxSpeed = 64 / (1 + log m) + +updatePos :: Double -> World -> Entity -> Entity +-- | Update the 'position of an 'Entity' based on its 'velocity'. Makes sure +-- to 'clamp' the 'Entity' to the 'World' edges. +updatePos dt w e | isNeutral e = e + | otherwise = e {position = clampPos $ position e + ^+^ velocity (entity e) + ^*^ dt} + where clampPos (Vec x y) = Vec (clamp 0 (width w) x) (clamp 0 (height w) y) + +decay :: Double -> Entity -> Entity +-- | Natural decaying of 'Entity' 'mass', so as to not have too huge +-- 'Entity's. +decay dt e | isNeutral e = e + | mass e > 1 = e {mass = 1 + (mass e - 1) * 0.999 ** dt} + | otherwise = e + +blubs :: World -> World +blubs = playerBlubbers . neutralBlubbers + +playerBlubbers :: World -> World +-- | Check if any one 'Entity' collides with any one other. If they do, delete +-- them out of the recursion, and keep checking the others until every +-- 'Entity' is checked with every other. +playerBlubbers w = go (M.toList (players w)) (M.toList (players w)) w + where + go :: [(String, Entity)] -> [(String, Entity)] -> World -> World + go [] _ v = v + go _ [] v = v + go (a:as) bs v = + case playerBlubs a bs of + Nothing -> go as bs v + Just ((s, Just a') ,(t, Nothing)) -> + let z = M.delete t . M.insert s a' $ players v + in go as (L.delete a $ M.toList z) v {players = z} + Just ((s, Nothing) ,(t, Just b')) -> + let z = M.delete s . M.insert t b' $ players v + in go as (L.delete a $ M.toList z) v {players = z} + Just _ -> go as bs v + +neutralBlubbers :: World -> World +-- | Check if any one 'Entity' collides with any one other. If they do, delete +-- them out of the recursion, and keep checking the others until every +-- 'Entity' is checked with every other. +neutralBlubbers w = go (M.toList (players w)) (S.toList (neutrals w)) w + where + go :: [(String, Entity)] -> [Entity] -> World -> World + go [] _ v = v + go _ [] v = v + go (a:as) bs v = + case neutralBlubs a bs of + Nothing -> go as bs v + Just ((s, a') ,b) -> let p' = M.insert s a' $ players v + n' = S.delete b $ neutrals v + in go as (L.delete b $ S.toList n') + v {players = p', neutrals = n'} + +playerBlubs :: (String, Entity) -> [(String, Entity)] + -> Maybe ((String, Maybe Entity), (String, Maybe Entity)) +-- | Given an 'Entity' of a 'PlayerBlub' and its id (as a 'String'), and +-- a list of other such things, let the 'Entity' 'fite' all the ones in the +-- passed in the list. +-- +-- It keeps checking until there's a collision. At that point, it figures out +-- which one 'blubber's which. The 'blubber'er grows, and the 'blubber'ee is +-- deleted. Ruthless. +-- +-- If there is no collision it returns 'Nothing'. If there is one, it returns +-- a 'Just' with two tuples -- one for each 'Blub'. The survivor will be +-- a 'Just', the other one 'Nothing'. +playerBlubs _ [] = Nothing +playerBlubs (s, a) ((t, b):bs) + | s /= t = case fite (a, b) of + (Just _, Just _) -> playerBlubs (s, a) bs + (Just a', Nothing) -> Just ((s, Just a'), (t, Nothing)) + (Nothing, Just b') -> Just ((s, Nothing), (t, Just b')) + -- This next one should not happen at all. + (Nothing, Nothing) -> Just ((s, Nothing), (t, Nothing)) + | otherwise = playerBlubs (s, a) bs + +neutralBlubs :: (String, Entity) -> [Entity] + -> Maybe ((String, Entity), Entity) +-- | Given an 'Entity' of a 'PlayerBlub' and its id (as a 'String'), and +-- a list of 'NeturalBlub's 'Entity's, let the 'PlayerBlub' 'Entity' 'fite' +-- all the 'NeutralbBlub's in the passed in list. +-- +-- It keeps checking until there's a collision. At that point, it returns the +-- now rather quiute big 'PlayerBlub' and the poor 'NeutralBlub' it has +-- blubbered. If there is no collision it just returns 'Nothing'. +neutralBlubs _ [] = Nothing +neutralBlubs (s, a) (b:bs) = case fite (a, b) of + (Just a', Nothing) -> Just ((s, a'), b) + _ -> neutralBlubs (s, a) bs + +setTargetPos :: String -> Double -> Double -> World -> Map String Entity +-- | Check if the client in the passed in 'String' is the owner of an +-- 'Entity'; if so, set its 'targetPos' to the passed in 'Double's. +setTargetPos p x y w = + case M.lookup p (players w) of + Just e | isNeutral e -> players w + | otherwise -> M.insert p e {entity = (entity e) + {targetPos = Vec x y}} (players w) + Nothing -> players w + +updateWorld :: Double -> World -> World +-- | Update the 'World'. 'updateVel', 'updatePos', 'decay', and check for +-- 'blubbers'. +updateWorld dt w = + blubs w {players = M.map (decay dt . updatePos dt w + . updateVel dt) (players w)} + + +handleInput :: Ord c => [(c, (Double, Double))] -> Map c String -> World + -> World +-- | Checks if a client has a player. If it does, then update the 'targetPos' +-- of the player's 'Entity'. +handleInput [] _ w = w +handleInput ((c,(x, y)):as) cs w = + case M.lookup c cs of + Just p -> handleInput as cs $ w {players = setTargetPos p x y w} + Nothing -> handleInput as cs w diff --git a/web/index.markdown b/web/index.markdown new file mode 100644 --- /dev/null +++ b/web/index.markdown @@ -0,0 +1,6 @@ +--- +title: blubber-server +--- +Welcome to the blubber-server! + +***[blubber-server source code](src.tar.gz)*** diff --git a/web/src.tar.gz b/web/src.tar.gz new file mode 100644 Binary files /dev/null and b/web/src.tar.gz differ