blubber-server (empty) → 0.0.1
raw patch · 11 files changed
+1690/−0 lines, 11 filesdep +Cabaldep +basedep +blubber-serverbuild-type:Customsetup-changedbinary-added
Dependencies added: Cabal, base, blubber-server, cereal, containers, data-default-class, network, pandoc, process, random, scotty, text, transformers, unix
Files
- LICENSE +661/−0
- Setup.hs +86/−0
- blubber-server.cabal +58/−0
- src-exec/blubber-server.hs +287/−0
- src/Blubber/Server/Entity.hs +96/−0
- src/Blubber/Server/Message.hs +49/−0
- src/Blubber/Server/Vector.hs +57/−0
- src/Blubber/Server/ViewPort.hs +128/−0
- src/Blubber/Server/World.hs +262/−0
- web/index.markdown +6/−0
- web/src.tar.gz binary
+ LICENSE view
@@ -0,0 +1,661 @@+ GNU AFFERO GENERAL PUBLIC LICENSE+ Version 3, 19 November 2007++ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>+ 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.++ <one line to give the program's name and a brief idea of what it does.>+ Copyright (C) <year> <name of author>++ 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 <http://www.gnu.org/licenses/>.++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+<http://www.gnu.org/licenses/>.
+ Setup.hs view
@@ -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."
+ blubber-server.cabal view
@@ -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
+ src-exec/blubber-server.hs view
@@ -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
+ src/Blubber/Server/Entity.hs view
@@ -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)
+ src/Blubber/Server/Message.hs view
@@ -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
+ src/Blubber/Server/Vector.hs view
@@ -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
+ src/Blubber/Server/ViewPort.hs view
@@ -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
+ src/Blubber/Server/World.hs view
@@ -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
+ web/index.markdown view
@@ -0,0 +1,6 @@+---+title: blubber-server+---+Welcome to the blubber-server!++***[blubber-server source code](src.tar.gz)***
+ web/src.tar.gz view
binary file changed (absent → 12781 bytes)