WebSVN – Kolibri OS – Path Comparison – / – /contrib Rev 8525 and /contrib Rev 8526

Regard whitespace Rev 8525 → Rev 8526

 /contrib/other/jumpnbump/AUTHORS
 ,0 → 1,61
+Jump'n'Bump is done by many people. The authors and contributors are listed
+below. Invented and implemented was Jump'n'Bump by Brainchild Design as a
+DOS game. Later the source was released and Chuck Mason did the port to
+Linux using SDL. Some people contributed various stuff to it.
+The current maintainer is Florian Schulze.
+Mattias Brynervall <matbr656@student.liu.se>
+  Original DOS code.
+Andreas Brynervall <andreasb@acc.umu.se>
+Martin Magnusson <marma102@student.liu.se>
+  Original Graphics.
+Anders Nilsson <equel@swipnet.se>
+  Original Music.
+Chuck Mason <cemason@users.sourceforge.net>
+  The first Linux port using SDL.
+Philippe Brochard <phil.brochard@wanadoo.fr>
+  The jbmenu.tcl script.
+Joe Wreschnig <piman@sacredchao.net>
+  The manual page
+"timecop" <timecop@japan.co.jp>
+  pack and unpack.
+Jon Atkins <jcatki@home.com>
+  The network code of the Linux version.
+Gürkan Sengün <gurkan@linuks.mine.nu>
+  Made the website http://www.jumpbump.mine.nu/ and hosts it. Promotion.
+Florian Schulze <crow@icculus.org>
+  Cleaned up code. Added scaling graphics mode (800x512). Fixed sound.
+Ben Hines <bhines@alumni.ucsd.edu>
+  MacOS X fixes.
+Gil Megidish
+  Made the Kaillera network version.
+David García Rodríguez <bkron@hotmail.com>
+  Level making tutorial.
+Ryan C. Gordon <icculus@clutteredmind.org>
+  Made networking possible again.
+Martin Willemoes Hansen <mwh@sysrq.dk>
+  The python frontend.
+  http://mwh.sysrq.dk/programs/programs.phtml
+Alessandro Gatti <a.gatti@tiscali.it>
+  FreeBSD fixes.
+Ulrich Eckhardt <uli@doommachine.dyndns.org>
+  Cleanup and small patches for enhanced networking.
+Ricardo Cruz <rick2@aeiou.pt>
+  AI functions
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/COPYING
 ,0 → 1,340
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+                            Preamble
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+  The precise terms and conditions for copying, distribution and
+modification follow.
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+. You may copy and distribute 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 and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+and 2 above on a medium customarily used for software interchange; or,
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+. The Free Software Foundation may publish revised and/or new versions
+of the 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 a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+                            NO WARRANTY
+. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.
+. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE 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.
+                     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
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+    <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 General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+Also add information on how to contact you by electronic and paper mail.
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+    Gnomovision version 69, Copyright (C) year  name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/ChangeLog
 ,0 → 1,95
+Jun 2004 - 1.51
+  - refactored code to make it a bit simpler
+  - Added AI by Ricardo Cruz
+Mar 2004 - 1.42
+  - added support for gzip and bzip2 packed levels.
+Mar 2003 - 1.41
+  - new scaling filter which works with 8bit graphics. Removed the old scaler
+    completely, now fading and everything else works in scaled up mode.
+  - another attempt to fix sound on big endian systems.
+Sep 2002 - 1.40
+  - manpage update
+  - joystick support added
+  - freebsd ports (thanks rigel from #demoscene)
+  - a while back network code using kaillera was send to me by Gil Megidish,
+    it's not enabled, because it doesn't seem to work good enough.
+Aug 2002 - 1.39
+  - added -noflies option
+  - added client/server networking. Thanks to Ryan C. Gordon who did the base
+    work for it.
+Aug 2002 - 1.35
+   - gobpack added
+   - documentation updated
+   - little fixes here and there
+Aug 2002 - 1.34
+   - fixed too dark font
+   - attempt to fix sound and scaleup on big endian systems
+Jul 2002 - 1.33
+   - added -musicnosound option
+Jun 2002 - 1.32
+   - fix for off by one in -mirror
+     add icon for application (macosx,windows,x)
+Jun 2002 - 1.31
+   - rename jbmenu.tcl to jnbmenu.tcl, make it +x, add
+     options for -mirror and -scaleup
+     update manpage and -h with -scaleup
+     update makefiles accordingly
+     rename pack/unpack to jnbpack/jnbunpack
+     set gametitle
+Jun 2002 - 1.3
+   - Added -mirror commandline option to play the level mirrored
+   - Deleting temporary music file
+- 1.2
+   - MacOS X fixes
+   - some endian fixes
+Feb 2002 - 1.1
+   - fixed timing problems
+   - fixed crash when temporary music can't be written
+Feb 2002 - 1.0
+   - working sound
+   - new scaling graphics mode
+   - cleaned up code
+===========================================================================
+This is the changelog of the linux version from which this port is derived.
+Feb 2001 - 0.69
+   initial linux port, worked fine with freebsd too (chuck mason)
+Feb 2001 - 0.69
+   made sound be played (chuck mason)
+Mar 2001 - 0.70
+   fixing fps (longislandman)
+   changing player input: 4 player at one keyboard (tarzeau)
+   pack/unpack which packs/unpacks the leveldata (timecop)
+?? Mar 2001 - 0.70
+   network code has been written (longislandman, jonatkins.org)
+   it werks but we won't release it until it's good for the masses,
+   for test and fun play come join #keen on irc.linux.com
+   (be sure to have one udp port open if you have a firewall,
+   and also have sdl-mixer, sdl and sdl-net)
+Mar 2001 - 0.70
+   did a new screenshot http://jumpbump.mine.nu/port/jumpbumprocks.jpg
+   wrote a little faq http://jumpbump.mine.nu/port/jumpbumpfaq.txt
+   put online level-selector-menu http://jumpbump.mine.nu/port/jbmenu.tcl
+   (received from philippe brochard, thank you!)
+Mar 2001 - 0.72
+   repackaged tarballs with network code jnb-net.tar.gz,
+   menusystem and unpack/pack
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/LINKS
 ,0 → 1,8
+http://www.jumpbump.mine.nu/
+http://www.icculus.org/jumpnbump/
+http://freshmeat.net/projects/jumpnbump/
+http://www.geocities.com/bkron2000
+http://bloodybunnies.8m.com/
+http://gohanz.www7.50megs.com/jumpbump/
+http://brainchilddesign.com/games/jumpnbump/index.html
+http://www.libsdl.org/
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/Makefile
 ,0 → 1,24
+CC = kos32-gcc
+LD = kos32-ld
+SDK_DIR = $(abspath ../../sdk)
+CFLAGS = -c -fno-ident -O2 -fomit-frame-pointer -fno-ident -U__WIN32__ -U_Win32 -U_WIN32 -U__MINGW32__ -UWIN32  -Dstricmp=strcasecmp -DZLIB_SUPPORT -Dstrnicmp=strncasecmp -DUSE_SDL -DNDEBUG
+LDFLAGS = -static -S -nostdlib -T $(SDK_DIR)/sources/newlib/app.lds --image-base 0
+INCLUDES = -I $(SDK_DIR)/sources/newlib/libc/include -I. -I$(SDK_DIR)/sources/SDL-1.2.2_newlib/include -I $(SDK_DIR)/sources/zlib
+LIBPATH = -L $(SDK_DIR)/lib -L /home/autobuild/tools/win32/mingw32/lib -Lsdl
+SRC = fireworks.c main.c menu.c filter.c stub.c
+OBJECTS = $(patsubst %.c, %.o, $(SRC))
+default: $(patsubst %.c,%.o,$(SRC))
+        kos32-ld $(LDFLAGS) $(LIBPATH) --subsystem native -o jumpnbump $(OBJECTS) -ls -lSDLn -lsound -lz -lgcc -lc.dll
+        objcopy jumpnbump -O binary
+%.o : %.c Makefile $(SRC)
+        $(CC) $(CFLAGS) $(INCLUDES) -o $@ $<
+clean:
+        rm *.o
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/SDL_mixer.h
 ,0 → 1,235
+/*
+    MIXERLIB:  An audio mixer library based on the SDL library
+    Copyright (C) 1997-1999  Sam Lantinga
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+    Sam Lantinga
+-34 Springhouse Dr.
+    Pleasanton, CA 94588 (USA)
+    slouken@devolution.com
+*/
+#ifndef _MIXER_H_
+#define _MIXER_H_
+#include "SDL_types.h"
+#include "SDL_rwops.h"
+#include "SDL_audio.h"
+#include "SDL_byteorder.h"
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* The default mixer has 8 simultaneous mixing channels */
+#ifndef MIX_CHANNELS
+#define MIX_CHANNELS    8
+#endif
+/* Good default values for a PC soundcard */
+#define MIX_DEFAULT_FREQUENCY   22050
+#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+#define MIX_DEFAULT_FORMAT      AUDIO_S16LSB
+#else
+#define MIX_DEFAULT_FORMAT      AUDIO_S16MSB
+#endif
+#define MIX_DEFAULT_CHANNELS    2
+#define MIX_MAX_VOLUME          128     /* Volume of a chunk */
+/* The internal format for an audio chunk */
+typedef struct {
+        int allocated;
+        Uint8 *abuf;
+        Uint32 alen;
+        Uint8 volume;           /* Per-sample volume, 0-128 */
+} Mix_Chunk;
+/* The different fading types supported */
+typedef enum {
+        MIX_NO_FADING,
+        MIX_FADING_OUT,
+        MIX_FADING_IN
+} Mix_Fading;
+/* The internal format for a music chunk interpreted via mikmod */
+typedef struct _Mix_Music Mix_Music;
+/* Open the mixer with a certain audio format */
+extern DECLSPEC int Mix_OpenAudio(int frequency, Uint16 format, int channels,
+                                                        int chunksize);
+/* Dynamically change the number of channels managed by the mixer.
+   If decreasing the number of channels, the upper channels are
+   stopped.
+   This function returns the new number of allocated channels.
+ */
+extern DECLSPEC int Mix_AllocateChannels(int numchans);
+/* Find out what the actual audio device parameters are.
+   This function returns 1 if the audio has been opened, 0 otherwise.
+ */
+extern DECLSPEC int Mix_QuerySpec(int *frequency,Uint16 *format,int *channels);
+/* Load a wave file or a music (.mod .s3m .it .xm) file */
+extern DECLSPEC Mix_Chunk *Mix_LoadWAV_RW(SDL_RWops *src, int freesrc);
+#define Mix_LoadWAV(file)       Mix_LoadWAV_RW(SDL_RWFromFile(file, "rb"), 1)
+extern DECLSPEC Mix_Music *Mix_LoadMUS(const char *file);
+#if 0 /* This hasn't been hooked into music.c yet */
+/* Load a music file from an SDL_RWop object (MikMod-specific currently)
+   Matt Campbell (matt@campbellhome.dhs.org) April 2000 */
+extern DECLSPEC Mix_Music *Mix_LoadMUS_RW(SDL_RWops *rw);
+#endif
+/* Load a wave file of the mixer format from a memory buffer */
+extern DECLSPEC Mix_Chunk *Mix_QuickLoad_WAV(Uint8 *mem);
+/* Free an audio chunk previously loaded */
+extern DECLSPEC void Mix_FreeChunk(Mix_Chunk *chunk);
+extern DECLSPEC void Mix_FreeMusic(Mix_Music *music);
+/* Set a function that is called after all mixing is performed.
+   This can be used to provide real-time visual display of the audio stream
+   or add a custom mixer filter for the stream data.
+*/
+extern DECLSPEC void Mix_SetPostMix(void (*mix_func)
+                             (void *udata, Uint8 *stream, int len), void *arg);
+/* Add your own music player or additional mixer function.
+   If 'mix_func' is NULL, the default music player is re-enabled.
+ */
+extern DECLSPEC void Mix_HookMusic(void (*mix_func)
+                          (void *udata, Uint8 *stream, int len), void *arg);
+/* Add your own callback when the music has finished playing.
+ */
+extern DECLSPEC void Mix_HookMusicFinished(void (*music_finished)(void));
+/* Get a pointer to the user data for the current music hook */
+extern DECLSPEC void *Mix_GetMusicHookData(void);
+/* Reserve the first channels (0 -> n-1) for the application, i.e. don't allocate
+   them dynamically to the next sample if requested with a -1 value below.
+   Returns the number of reserved channels.
+ */
+extern DECLSPEC int Mix_ReserveChannels(int num);
+/* Channel grouping functions */
+/* Attach a tag to a channel. A tag can be assigned to several mixer
+   channels, to form groups of channels.
+   If 'tag' is -1, the tag is removed (actually -1 is the tag used to
+   represent the group of all the channels).
+   Returns true if everything was OK.
+ */
+extern DECLSPEC int Mix_GroupChannel(int which, int tag);
+/* Assign several consecutive channels to a group */
+extern DECLSPEC int Mix_GroupChannels(int from, int to, int tag);
+/* Finds the first available channel in a group of channels */
+extern DECLSPEC int Mix_GroupAvailable(int tag);
+/* Returns the number of channels in a group. This is also a subtle
+   way to get the total number of channels when 'tag' is -1
+ */
+extern DECLSPEC int Mix_GroupCount(int tag);
+/* Finds the "oldest" sample playing in a group of channels */
+extern DECLSPEC int Mix_GroupOldest(int tag);
+/* Finds the "most recent" (i.e. last) sample playing in a group of channels */
+extern DECLSPEC int Mix_GroupNewer(int tag);
+/* Play an audio chunk on a specific channel.
+   If the specified channel is -1, play on the first free channel.
+   If 'loops' is greater than zero, loop the sound that many times.
+   If 'loops' is -1, loop inifinitely (~65000 times).
+   Returns which channel was used to play the sound.
+*/
+#define Mix_PlayChannel(channel,chunk,loops) Mix_PlayChannelTimed(channel,chunk,loops,-1)
+/* The same as above, but the sound is played at most 'ticks' milliseconds */
+extern DECLSPEC int Mix_PlayChannelTimed(int channel, Mix_Chunk *chunk, int loops, int ticks);
+extern DECLSPEC int Mix_PlayMusic(Mix_Music *music, int loops);
+/* Fade in music or a channel over "ms" milliseconds, same semantics as the "Play" functions */
+extern DECLSPEC int Mix_FadeInMusic(Mix_Music *music, int loops, int ms);
+#define Mix_FadeInChannel(channel,chunk,loops,ms) Mix_FadeInChannelTimed(channel,chunk,loops,ms,-1)
+extern DECLSPEC int Mix_FadeInChannelTimed(int channel, Mix_Chunk *chunk, int loops, int ms, int ticks);
+/* Set the volume in the range of 0-128 of a specific channel or chunk.
+   If the specified channel is -1, set volume for all channels.
+   Returns the original volume.
+   If the specified volume is -1, just return the current volume.
+*/
+extern DECLSPEC int Mix_Volume(int channel, int volume);
+extern DECLSPEC int Mix_VolumeChunk(Mix_Chunk *chunk, int volume);
+extern DECLSPEC int Mix_VolumeMusic(int volume);
+/* Halt playing of a particular channel */
+extern DECLSPEC int Mix_HaltChannel(int channel);
+extern DECLSPEC int Mix_HaltGroup(int tag);
+extern DECLSPEC int Mix_HaltMusic(void);
+/* Change the expiration delay for a particular channel.
+   The sample will stop playing after the 'ticks' milliseconds have elapsed,
+   or remove the expiration if 'ticks' is -1
+*/
+extern DECLSPEC int Mix_ExpireChannel(int channel, int ticks);
+/* Halt a channel, fading it out progressively till it's silent
+   The ms parameter indicates the number of milliseconds the fading
+   will take.
+ */
+extern DECLSPEC int Mix_FadeOutChannel(int which, int ms);
+extern DECLSPEC int Mix_FadeOutGroup(int tag, int ms);
+extern DECLSPEC int Mix_FadeOutMusic(int ms);
+/* Query the fading status of a channel */
+extern DECLSPEC Mix_Fading Mix_FadingMusic(void);
+extern DECLSPEC Mix_Fading Mix_FadingChannel(int which);
+/* Pause/Resume a particular channel */
+extern DECLSPEC void Mix_Pause(int channel);
+extern DECLSPEC void Mix_Resume(int channel);
+extern DECLSPEC int  Mix_Paused(int channel);
+/* Pause/Resume the music stream */
+extern DECLSPEC void Mix_PauseMusic(void);
+extern DECLSPEC void Mix_ResumeMusic(void);
+extern DECLSPEC void Mix_RewindMusic(void);
+extern DECLSPEC int  Mix_PausedMusic(void);
+/* Check the status of a specific channel.
+   If the specified channel is -1, check all channels.
+*/
+extern DECLSPEC int Mix_Playing(int channel);
+extern DECLSPEC int Mix_PlayingMusic(void);
+/* Stop music and set external music playback command */
+extern DECLSPEC int Mix_SetMusicCMD(const char *command);
+/* Close the mixer, halting all playing audio */
+extern DECLSPEC void Mix_CloseAudio(void);
+/* We'll use SDL for reporting errors */
+#define Mix_SetError    SDL_SetError
+#define Mix_GetError    SDL_GetError
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+#include "close_code.h"
+#endif /* _MIXER_H_ */
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

/contrib/other/jumpnbump/TODO
0,0 → 1,5
- add network code back in
- port for dreamcast

Debian:
- the game isn't in update-menus
Property changes:
Added: svn:executable
+*
\ No newline at end of property

 /contrib/other/jumpnbump/config.h
 ,0 → 1,29
+/*
+ * config.h
+ * Copyright (C) 1998 Brainchild Design - http://brainchilddesign.com/
+ *
+ * Copyright (C) 2001 Chuck Mason <cemason@users.sourceforge.net>
+ *
+ * Copyright (C) 2002 Florian Schulze <crow@icculus.org>
+ *
+ * This file is part of Jump'n'Bump.
+ *
+ * Jump'n'Bump is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Jump'n'Bump is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#ifndef __CONFIG_H
+#define __CONFIG_H
+#endif
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/dj.h
 ,0 → 1,135
+/*
+ * dj.h
+ * Copyright (C) 1998 Brainchild Design - http://brainchilddesign.com/
+ *
+ * Copyright (C) 2002 Florian Schulze - crow@icculus.org
+ *
+ * This file is part of Jump'n'Bump.
+ *
+ * Jump'n'Bump is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Jump'n'Bump is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef DOS
+#include <pc.h>
+#include <dpmi.h>
+#include <go32.h>
+#include <sys/nearptr.h>
+#endif
+#define DJ_SD_TYPE_NOSOUND 0
+#define DJ_SD_TYPE_SBLASTER 1
+#define DJ_SFX_TYPE_SSS 0
+#define DJ_SFX_TYPE_WAV 1
+#define DJ_SFX_TYPE_SMP 2
+typedef struct dj_hardware_info {
+        char sd_type;
+  short sd_version;
+        short port;
+        char irq;
+        char dma;
+} dj_hardware_info;
+typedef struct dj_mixing_info {
+  char sfx_volume, num_sfx_channels;
+  char mod_volume, num_mod_channels;
+        char stereo_mix, auto_mix;
+  unsigned short mixing_freq;
+  unsigned short dma_time, dmabuf_len;
+  char cur_dmabuf;
+        unsigned long dmabuf_address[2];
+  char *mixed_buf;
+} dj_mixing_info;
+typedef struct sfx_data {
+  char priority;
+  unsigned short default_freq;
+  char default_volume;
+  unsigned long length;
+  char loop;
+  unsigned long loop_start, loop_length;
+  unsigned char *buf;
+} sfx_data;
+typedef struct dj_mod_info {
+  char num_channels;
+        char speed;
+        short bpm;
+        char order_pos;
+        char pat_pos;
+        char name[20];
+        struct {
+                char name[22];
+                unsigned short length;
+                char finetune;
+                char volume;
+                unsigned short loop_start;
+                unsigned short loop_length;
+                char *buf;
+        } samples[31];
+        char song_length;
+        char num_pat;
+        char pat_order[128];
+  char *pat[128];
+} dj_mod_info;
+extern char dj_init(void);
+extern void dj_deinit(void);
+extern void dj_start(void);
+extern void dj_stop(void);
+extern void dj_set_nosound(char flag);
+extern char dj_set_sd(char sd_type, short port, char irq, char dma);
+extern char dj_autodetect_sd(void);
+extern void dj_get_sd_string(char *strbuf);
+extern char dj_set_stereo(char flag);
+extern void dj_reverse_stereo(char flag);
+extern void dj_set_auto_mix(char flag);
+extern unsigned short dj_set_mixing_freq(unsigned short freq);
+extern void dj_set_dma_time(unsigned short time);
+extern char dj_get_hardware_info(dj_hardware_info *ptr);
+extern char dj_get_mixing_info(dj_mixing_info *ptr);
+extern char dj_get_mod_info(char mod_num, dj_mod_info *ptr);
+extern void dj_set_fake_vu_speed(unsigned char speed);
+extern unsigned char dj_get_fake_vu(char channel);
+extern char dj_reset_sd(void);
+extern char dj_mix_needed(void);
+extern void dj_mix(void);
+extern char dj_set_num_sfx_channels(char num_channels);
+extern void dj_set_sfx_volume(char volume);
+extern char dj_get_sfx_volume(void);
+extern void dj_play_sfx(unsigned char sfx_num, unsigned short freq, char volume, char panning, unsigned short delay, char channel);
+extern char dj_get_sfx_settings(unsigned char sfx_num, sfx_data *data);
+extern char dj_set_sfx_settings(unsigned char sfx_num, sfx_data *data);
+extern void dj_set_sfx_channel_volume(char channel_num, char volume);
+extern void dj_stop_sfx_channel(char channel_num);
+extern char dj_load_sfx(unsigned char *file_handle, char *filename, int file_length, char sfx_type, unsigned char sfx_num);
+extern void dj_free_sfx(unsigned char sfx_num);
+extern char dj_ready_mod(char mod_num);
+extern char dj_start_mod(void);
+extern void dj_stop_mod(void);
+extern void dj_set_mod_volume(char volume);
+extern char dj_get_mod_volume(void);
+extern char dj_load_mod(unsigned char *file_handle, char *filename, char mod_num);
+extern void dj_free_mod(char mod_num);
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/filter.c
 ,0 → 1,251
+/*
+ * filter.c
+ * Copyright (C) 2003 Florian Schulze <crow@icculus.org>
+ *
+ * This file is part of Jump'n'Bump.
+ *
+ * Jump'n'Bump is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Jump'n'Bump is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+/*
+ The following scaling filter is called advancedmame2x.
+ The implementation found here was possible because of the great ideas of
+ Lucas Pope.
+ */
+typedef unsigned char byte;
+static int scale2x_inited = 0;
+static byte lookup_map[4*16];
+void init_scale2x(void)
+{
+        int i;
+        if (scale2x_inited)
+                return;
+        //-------------------------------------------------------------------------
+        // scale2x takes the following source:
+        // A B C
+        // D E F
+        // G H I
+        //
+        // and doubles the size of E to produce:
+        // E0 E1
+        // E2 E3
+        //
+        //  E0 = D == B && B != F && D != H ? D : E;
+        //  E1 = B == F && B != D && F != H ? F : E;
+        //  E2 = D == H && D != B && H != F ? D : E;
+        //  E3 = H == F && D != H && B != F ? F : E;
+        //
+        // to make this comparison regimen faster, we encode source color
+        // equivalency into a single byte with the getCode() macro
+        //
+        // #define getCode(b,f,h,d) ( (b == f)<<0 | (f == h)<<1 | (h == d)<<2 | (d == b)<<3 )
+        // encode the scale2x conditionals into a lookup code
+        for (i=0; i<16; i++) {
+                //  E0 = D == B && B != F && D != H ? D : E; // 10-0 => 1000 or 1010 => 8 or A
+                lookup_map[0*16+i] = (i == 0x8 || i == 0xA) ? 0 : 1;
+                //  E1 = B == F && B != D && F != H ? F : E; // 0-01 => 0101 or 0001 => 5 or 1
+                lookup_map[1*16+i] = (i == 0x5 || i == 0x1) ? 2 : 1;
+                //  E2 = D == H && D != B && H != F ? D : E; // 010- => 0101 or 0100 => 5 or 4
+                lookup_map[2*16+i] = (i == 0x4 || i == 0x5) ? 0 : 1;
+                //  E3 = H == F && D != H && B != F ? F : E; // -010 => 1010 or 0010 => A or 2
+                lookup_map[3*16+i] = (i == 0xA || i == 0x2) ? 2 : 1;
+        }
+}
+void do_scale2x(unsigned char *src,
+                int src_width,
+                int src_height,
+                unsigned char *dst)
+{
+        int x;
+        int y;
+        int dst_width = src_width * 2;
+        int dst_height = src_height * 2;
+        int code;
+        byte rowColors[3];
+        byte *e0;
+        byte *e1;
+        byte *e2;
+        byte *e3;
+        if (!scale2x_inited)
+                init_scale2x();
+        // special top case - b is always unknown
+        {
+                byte *d;
+                byte *e;
+                byte *f;
+                byte *h;
+                e0 = &dst[0];
+                e1 = &dst[1];
+                e2 = &dst[dst_width];
+                e3 = &dst[dst_width + 1];
+                e = &src[0];
+                f = &src[1];
+                h = &src[src_width];
+                // special left case - d is unknown
+                rowColors[0] = *e;
+                rowColors[1] = *e;
+                rowColors[2] = *f;
+                code = ( (*f == *h)<<1 );
+                *e0 = rowColors[lookup_map[0*16+code]];
+                *e1 = rowColors[lookup_map[1*16+code]];
+                *e2 = rowColors[lookup_map[2*16+code]];
+                *e3 = rowColors[lookup_map[3*16+code]];
+                e++; f++; h++;
+                d = &src[src_width]; // (src_width - 1) + 1
+                e0+=2; e1+=2; e2+=2; e3+=2;
+                // normal case
+                for (x=1; x<(src_width-1); x++) {
+                        rowColors[0] = *d;
+                        rowColors[1] = *e;
+                        rowColors[2] = *f;
+                        code = ( (*f == *h)<<1 | (*h == *d)<<2 );
+                        *e0 = rowColors[lookup_map[0*16+code]];
+                        *e1 = rowColors[lookup_map[1*16+code]];
+                        *e2 = rowColors[lookup_map[2*16+code]];
+                        *e3 = rowColors[lookup_map[3*16+code]];
+                        d++; e++; f++; h++;
+                        e0+=2; e1+=2; e2+=2; e3+=2;
+                }
+                // special right case - f is unknown
+                rowColors[0] = *d;
+                rowColors[1] = *e;
+                rowColors[2] = *e;
+                code = ( (*h == *d)<<2 );
+                *e0 = rowColors[lookup_map[0*16+code]];
+                *e1 = rowColors[lookup_map[1*16+code]];
+                *e2 = rowColors[lookup_map[2*16+code]];
+                *e3 = rowColors[lookup_map[3*16+code]];
+        }
+        // top and bottom always known
+        for (y=1; y<(src_height-1); y++) {
+                byte *b;
+                byte *d;
+                byte *e;
+                byte *f;
+                byte *h;
+                e0 = &dst[y*dst_width*2];
+                e1 = &dst[y*dst_width*2 + 1];
+                e2 = &dst[y*dst_width*2 + dst_width];
+                e3 = &dst[y*dst_width*2 + dst_width + 1];
+                b = &src[y * src_width - src_width];
+                e = &src[y * src_width];
+                f = &src[y * src_width + 1];
+                h = &src[y * src_width + src_width];
+                // special left case - d is unknown
+                rowColors[0] = *e;
+                rowColors[1] = *e;
+                rowColors[2] = *f;
+                code = ( (*b == *f)<<0 | (*f == *h)<<1 );
+                *e0 = rowColors[lookup_map[0*16+code]];
+                *e1 = rowColors[lookup_map[1*16+code]];
+                *e2 = rowColors[lookup_map[2*16+code]];
+                *e3 = rowColors[lookup_map[3*16+code]];
+                b++; e++; f++; h++;
+                d = &src[y * src_width]; // (y * src_width - 1) + 1
+                e0+=2; e1+=2; e2+=2; e3+=2;
+                // normal case
+                for (x=1; x<(src_width-1); x++) {
+                        rowColors[0] = *d;
+                        rowColors[1] = *e;
+                        rowColors[2] = *f;
+                        code = ( (*b == *f)<<0 | (*f == *h)<<1 | (*h == *d)<<2 | (*d == *b)<<3 );
+                        *e0 = rowColors[lookup_map[0*16+code]];
+                        *e1 = rowColors[lookup_map[1*16+code]];
+                        *e2 = rowColors[lookup_map[2*16+code]];
+                        *e3 = rowColors[lookup_map[3*16+code]];
+                        b++; d++; e++; f++; h++;
+                        e0+=2; e1+=2; e2+=2; e3+=2;
+                }
+                // special right case - f is unknown
+                rowColors[0] = *d;
+                rowColors[1] = *e;
+                rowColors[2] = *e;
+                code = ( (*h == *d)<<2 | (*d == *b)<<3 );
+                *e0 = rowColors[lookup_map[0*16+code]];
+                *e1 = rowColors[lookup_map[1*16+code]];
+                *e2 = rowColors[lookup_map[2*16+code]];
+                *e3 = rowColors[lookup_map[3*16+code]];
+        }
+        // special bottom case - h is always unknown
+        {
+                byte *b;
+                byte *d;
+                byte *e;
+                byte *f;
+                e0 = &dst[y*dst_width*2];
+                e1 = &dst[y*dst_width*2 + 1];
+                e2 = &dst[y*dst_width*2 + dst_width];
+                e3 = &dst[y*dst_width*2 + dst_width + 1];
+                b = &src[y * src_width - src_width];
+                e = &src[y * src_width];
+                f = &src[y * src_width + 1];
+                // special left case - d is unknown
+                rowColors[0] = *e;
+                rowColors[1] = *e;
+                rowColors[2] = *f;
+                code = ( (*b == *f)<<0 );
+                *e0 = rowColors[lookup_map[0*16+code]];
+                *e1 = rowColors[lookup_map[1*16+code]];
+                *e2 = rowColors[lookup_map[2*16+code]];
+                *e3 = rowColors[lookup_map[3*16+code]];
+                b++; e++; f++;
+                d = &src[y * src_width]; // (y * src_width - 1) + 1
+                e0+=2; e1+=2; e2+=2; e3+=2;
+                // normal case
+                for (x=1; x<(src_width-1); x++) {
+                        rowColors[0] = *d;
+                        rowColors[1] = *e;
+                        rowColors[2] = *f;
+                        code = ( (*b == *f)<<0 | (*d == *b)<<3 );
+                        *e0 = rowColors[lookup_map[0*16+code]];
+                        *e1 = rowColors[lookup_map[1*16+code]];
+                        *e2 = rowColors[lookup_map[2*16+code]];
+                        *e3 = rowColors[lookup_map[3*16+code]];
+                        b++; d++; e++; f++;
+                        e0+=2; e1+=2; e2+=2; e3+=2;
+                }
+                // special right case - f is unknown
+                rowColors[0] = *d;
+                rowColors[1] = *e;
+                rowColors[2] = *e;
+                code = ( (*d == *b)<<3 );
+                *e0 = rowColors[lookup_map[0*16+code]];
+                *e1 = rowColors[lookup_map[1*16+code]];
+                *e2 = rowColors[lookup_map[2*16+code]];
+                *e3 = rowColors[lookup_map[3*16+code]];
+        }
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/filter.h
 ,0 → 1,34
+/*
+ * config.h
+ * Copyright (C) 1998 Brainchild Design - http://brainchilddesign.com/
+ *
+ * Copyright (C) 2001 Chuck Mason <cemason@users.sourceforge.net>
+ *
+ * Copyright (C) 2002 Florian Schulze <crow@icculus.org>
+ *
+ * This file is part of Jump'n'Bump.
+ *
+ * Jump'n'Bump is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Jump'n'Bump is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#ifndef __FILTER_H__
+#define __FILTER_H__
+void do_scale2x(unsigned char *src,
+                int src_width,
+                int src_height,
+                unsigned char *dst);
+#endif // __FILTER_H__
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/fireworks.c
 ,0 → 1,249
+/*
+ * fireworks.c
+ * Copyright (C) 1998 Brainchild Design - http://brainchilddesign.com/
+ *
+ * Copyright (C) 2001 Chuck Mason <cemason@users.sourceforge.net>
+ *
+ * Copyright (C) 2002 Florian Schulze <crow@icculus.org>
+ *
+ * This file is part of Jump'n'Bump.
+ *
+ * Jump'n'Bump is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Jump'n'Bump is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include "globals.h"
+extern unsigned int ban_map[17][22];
+void fireworks(void)
+{
+        char *handle;
+        int c1, c2;
+        int s1, s2, s3;
+        char pal[768];
+        struct {
+                int used, direction, colour;
+                int x, y;
+                int x_add, y_add;
+                int timer;
+                int anim, frame, frame_tick, image;
+        } rabbits[20];
+        struct {
+                int x, y;
+                int old_x, old_y;
+                int col;
+                int back[2];
+        } stars[300];
+        register_background(NULL, NULL);
+        if ((handle = dat_open("level.pcx")) == 0) {
+                strcpy(main_info.error_str, "Error loading 'level.pcx', aborting...\n");
+                return;
+        }
+        read_pcx(handle, mask_pic, JNB_WIDTH*JNB_HEIGHT, pal);
+        memset(mask_pic, 0, JNB_WIDTH*JNB_HEIGHT);
+        register_mask(mask_pic);
+        recalculate_gob(&rabbit_gobs, pal);
+        recalculate_gob(&object_gobs, pal);
+        memset(ban_map, 0, sizeof(ban_map));
+        fillpalette(0, 0, 0);
+        draw_begin();
+        for (c2 = JNB_HEIGHT - 63; c2 < JNB_HEIGHT; c2++) {
+                clear_lines(0, c2, 1, get_color((c2 - 192) >> 2, pal));
+                clear_lines(1, c2, 1, get_color((c2 - 192) >> 2, pal));
+        }
+        draw_end();
+        setpalette(0, 256, pal);
+        for (c1 = 0; c1 < 20; c1++)
+                rabbits[c1].used = 0;
+        rabbits[0].used = 1;
+        rabbits[0].colour = rnd(4);
+        rabbits[0].x = (int) (150 + rnd(100)) << 16;
+        rabbits[0].y = 256 << 16;
+        rabbits[0].x_add = ((int) rnd(65535) << 1) - 65536;
+        if (rabbits[0].x_add > 0)
+                rabbits[0].direction = 0;
+        else
+                rabbits[0].direction = 1;
+        rabbits[0].y_add = -262144 + (rnd(16384) * 5);
+        rabbits[0].timer = 30 + rnd(150);
+        rabbits[0].anim = 2;
+        rabbits[0].frame = 0;
+        rabbits[0].frame_tick = 0;
+        rabbits[0].image = player_anims[rabbits[0].anim].frame[rabbits[0].frame].image + rabbits[0].colour * 18 + rabbits[0].direction * 9;
+        draw_begin();
+        for (c1 = 0; c1 < 300; c1++) {
+                s1 = rnd(JNB_WIDTH);
+                s2 = rnd(JNB_HEIGHT);
+                s3 = 30 - rnd(7);
+                stars[c1].x = stars[c1].old_x = (s1 << 16);
+                stars[c1].y = stars[c1].old_y = (s2 << 16);
+                stars[c1].col = s3;
+                stars[c1].back[0] = stars[c1].back[1] = get_pixel(0, s1, s2);
+        }
+        draw_end();
+        dj_set_nosound(0);
+        main_info.page_info[0].num_pobs = 0;
+        main_info.page_info[1].num_pobs = 0;
+        main_info.view_page = 0;
+        main_info.draw_page = 1;
+        while (key_pressed(1) == 0) {
+                dj_mix();
+                intr_sysupdate();
+                for (c1 = 0; c1 < 300; c1++) {
+                        stars[c1].old_x = stars[c1].x;
+                        stars[c1].old_y = stars[c1].y;
+                        stars[c1].y -= (int) (31 - stars[c1].col) * 16384;
+                        if ((stars[c1].y >> 16) < 0)
+                                stars[c1].y += JNB_HEIGHT << 16;
+                        if ((stars[c1].y >> 16) >= JNB_HEIGHT)
+                                stars[c1].y -= JNB_HEIGHT << 16;
+                }
+                for (c1 = 0, c2 = 0; c1 < 20; c1++) {
+                        if (rabbits[c1].used == 1)
+                                c2++;
+                }
+                if ((c2 == 0 && rnd(10000) < 200) || (c2 == 1 && rnd(10000) < 150) || (c2 == 2 && rnd(10000) < 100) || (c2 == 3 && rnd(10000) < 50)) {
+                        for (c1 = 0; c1 < 20; c1++) {
+                                if (rabbits[c1].used == 0) {
+                                        rabbits[c1].used = 1;
+                                        rabbits[c1].colour = rnd(4);
+                                        rabbits[c1].x = (int) (150 + rnd(100)) << 16;
+                                        rabbits[c1].y = 256 << 16;
+                                        rabbits[c1].x_add = ((int) rnd(65535) << 1) - 65536;
+                                        if (rabbits[c1].x_add > 0)
+                                                rabbits[c1].direction = 0;
+                                        else
+                                                rabbits[c1].direction = 1;
+                                        rabbits[c1].y_add = -262144 + (rnd(16384) * 5);
+                                        rabbits[c1].timer = 30 + rnd(150);
+                                        rabbits[c1].anim = 2;
+                                        rabbits[c1].frame = 0;
+                                        rabbits[c1].frame_tick = 0;
+                                        rabbits[c1].image = player_anims[rabbits[c1].anim].frame[rabbits[c1].frame].image + rabbits[c1].colour * 18 + rabbits[c1].direction * 9;
+                                        break;
+                                }
+                        }
+                }
+                dj_mix();
+                main_info.page_info[main_info.draw_page].num_pobs = 0;
+                for (c1 = 0; c1 < 20; c1++) {
+                        if (rabbits[c1].used == 1) {
+                                rabbits[c1].y_add += 2048;
+                                if (rabbits[c1].y_add > 36864 && rabbits[c1].anim != 3) {
+                                        rabbits[c1].anim = 3;
+                                        rabbits[c1].frame = 0;
+                                        rabbits[c1].frame_tick = 0;
+                                        rabbits[c1].image = player_anims[rabbits[c1].anim].frame[rabbits[c1].frame].image + rabbits[c1].colour * 18 + rabbits[c1].direction * 9;
+                                }
+                                rabbits[c1].x += rabbits[c1].x_add;
+                                rabbits[c1].y += rabbits[c1].y_add;
+                                if ((rabbits[c1].x >> 16) < 16 || (rabbits[c1].x >> 16) > JNB_WIDTH || (rabbits[c1].y >> 16) > JNB_HEIGHT) {
+                                        rabbits[c1].used = 0;
+                                        continue;
+                                }
+                                rabbits[c1].timer--;
+                                if (rabbits[c1].timer <= 0) {
+                                        rabbits[c1].used = 0;
+                                        for (c2 = 0; c2 < 6; c2++)
+                                                add_object(OBJ_FUR, (rabbits[c1].x >> 16) + 6 + rnd(5), (rabbits[c1].y >> 16) + 6 + rnd(5), rabbits[c1].x_add + (rnd(65535) - 32768) * 3, rabbits[c1].y_add + (rnd(65535) - 32768) * 3, 0, 44 + rabbits[c1].colour * 8);
+                                        for (c2 = 0; c2 < 6; c2++)
+                                                add_object(OBJ_FLESH, (rabbits[c1].x >> 16) + 6 + rnd(5), (rabbits[c1].y >> 16) + 6 + rnd(5), rabbits[c1].x_add + (rnd(65535) - 32768) * 3, rabbits[c1].y_add + (rnd(65535) - 32768) * 3, 0, 76);
+                                        for (c2 = 0; c2 < 6; c2++)
+                                                add_object(OBJ_FLESH, (rabbits[c1].x >> 16) + 6 + rnd(5), (rabbits[c1].y >> 16) + 6 + rnd(5), rabbits[c1].x_add + (rnd(65535) - 32768) * 3, rabbits[c1].y_add + (rnd(65535) - 32768) * 3, 0, 77);
+                                        for (c2 = 0; c2 < 8; c2++)
+                                                add_object(OBJ_FLESH, (rabbits[c1].x >> 16) + 6 + rnd(5), (rabbits[c1].y >> 16) + 6 + rnd(5), rabbits[c1].x_add + (rnd(65535) - 32768) * 3, rabbits[c1].y_add + (rnd(65535) - 32768) * 3, 0, 78);
+                                        for (c2 = 0; c2 < 10; c2++)
+                                                add_object(OBJ_FLESH, (rabbits[c1].x >> 16) + 6 + rnd(5), (rabbits[c1].y >> 16) + 6 + rnd(5), rabbits[c1].x_add + (rnd(65535) - 32768) * 3, rabbits[c1].y_add + (rnd(65535) - 32768) * 3, 0, 79);
+                                        dj_play_sfx(SFX_DEATH, SFX_DEATH_FREQ, 64, 0, 0, -1);
+                                        continue;
+                                }
+                                rabbits[c1].frame_tick++;
+                                if (rabbits[c1].frame_tick >= player_anims[rabbits[c1].anim].frame[rabbits[c1].frame].ticks) {
+                                        rabbits[c1].frame++;
+                                        if (rabbits[c1].frame >= player_anims[rabbits[c1].anim].num_frames)
+                                                rabbits[c1].frame = player_anims[rabbits[c1].anim].restart_frame;
+                                        rabbits[c1].frame_tick = 0;
+                                }
+                                rabbits[c1].image = player_anims[rabbits[c1].anim].frame[rabbits[c1].frame].image + rabbits[c1].colour * 18 + rabbits[c1].direction * 9;
+                                if (rabbits[c1].used == 1)
+                                        add_pob(main_info.draw_page, rabbits[c1].x >> 16, rabbits[c1].y >> 16, rabbits[c1].image, &rabbit_gobs);
+                        }
+                }
+                dj_mix();
+                update_objects();
+                draw_begin();
+                for (c1 = 0; c1 < 300; c1++) {
+                        stars[c1].back[main_info.draw_page] = get_pixel(main_info.draw_page, stars[c1].x >> 16, stars[c1].y >> 16);
+                        set_pixel(main_info.draw_page, stars[c1].x >> 16, stars[c1].y >> 16, get_color(stars[c1].col, pal));
+                }
+                dj_mix();
+                draw_pobs(main_info.draw_page);
+                draw_end();
+                main_info.draw_page ^= 1;
+                main_info.view_page ^= 1;
+                flippage(main_info.view_page);
+                wait_vrt(1);
+                draw_begin();
+                redraw_pob_backgrounds(main_info.draw_page);
+                dj_mix();
+                intr_sysupdate();
+                for (c1 = 299; c1 >= 0; c1--) {
+                        set_pixel(main_info.draw_page, stars[c1].old_x >> 16, stars[c1].old_y >> 16, stars[c1].back[main_info.draw_page]);
+                }
+                draw_end();
+        }
+        dj_set_nosound(1);
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/globals.h
 ,0 → 1,369
+/*
+ * globals.h
+ * Copyright (C) 1998 Brainchild Design - http://brainchilddesign.com/
+ *
+ * Copyright (C) 2001 Chuck Mason <cemason@users.sourceforge.net>
+ *
+ * Copyright (C) 2002 Florian Schulze <crow@icculus.org>
+ *
+ * This file is part of Jump'n'Bump.
+ *
+ * Jump'n'Bump is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Jump'n'Bump is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#ifndef __GLOBALS_H
+#define __GLOBALS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "config.h"
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifndef _MSC_VER
+#include <strings.h>
+#endif
+#include <time.h>
+#include <math.h>
+#include <dj.h>
+#ifdef DOS
+# include <conio.h>
+# include <dpmi.h>
+# include <sys/nearptr.h>
+# include <pc.h>
+#endif
+#ifdef _MSC_VER
+# define WIN32_LEAN_AND_MEAN
+# include <windows.h>
+# include <sys/stat.h>
+# include <io.h>
+# include "SDL.h"
+# if USE_SDL_MIXER
+#  include "SDL_mixer.h"
+# endif
+#else
+# ifdef USE_SDL
+#  include <sys/stat.h>
+#  include "SDL.h"
+#  if USE_SDL_MIXER
+#   include "SDL_mixer.h"
+#  endif
+# endif
+#endif
+#define JNB_MAX_PLAYERS 4
+#define JNB_INETPORT 11111
+extern int client_player_num;
+void tellServerPlayerMoved(int playerid, int movement_type, int newval);
+#define MOVEMENT_LEFT  1
+#define MOVEMENT_RIGHT 2
+#define MOVEMENT_UP    3
+#define JNB_VERSION "1.51"
+#define JNB_WIDTH 400
+#define JNB_HEIGHT 256
+extern int screen_width;
+extern int screen_height;
+extern int screen_pitch;
+extern int scale_up;
+extern int ai[JNB_MAX_PLAYERS];
+#ifndef USE_SDL
+#define KEY_PL1_LEFT 0xcb
+#define KEY_PL1_RIGHT   0xcd
+#define KEY_PL1_JUMP 0xc8
+#define KEY_PL2_LEFT 0x1e
+#define KEY_PL2_RIGHT   0x20
+#define KEY_PL2_JUMP 0x11
+#else
+#define KEY_PL1_LEFT SDLK_LEFT
+#define KEY_PL1_RIGHT   SDLK_RIGHT
+#define KEY_PL1_JUMP SDLK_UP
+#define KEY_PL2_LEFT SDLK_a
+#define KEY_PL2_RIGHT   SDLK_d
+#define KEY_PL2_JUMP SDLK_w
+#define KEY_PL3_LEFT SDLK_j
+#define KEY_PL3_RIGHT   SDLK_l
+#define KEY_PL3_JUMP SDLK_i
+#define KEY_PL4_LEFT SDLK_KP4
+#define KEY_PL4_RIGHT   SDLK_KP6
+#define KEY_PL4_JUMP SDLK_KP8
+#endif
+#define NUM_POBS 200
+#define NUM_OBJECTS 200
+#define NUM_FLIES 20
+#define NUM_LEFTOVERS 50
+#define OBJ_SPRING 0
+#define OBJ_SPLASH 1
+#define OBJ_SMOKE 2
+#define OBJ_YEL_BUTFLY 3
+#define OBJ_PINK_BUTFLY 4
+#define OBJ_FUR 5
+#define OBJ_FLESH 6
+#define OBJ_FLESH_TRACE 7
+#define OBJ_ANIM_SPRING 0
+#define OBJ_ANIM_SPLASH 1
+#define OBJ_ANIM_SMOKE 2
+#define OBJ_ANIM_YEL_BUTFLY_RIGHT 3
+#define OBJ_ANIM_YEL_BUTFLY_LEFT 4
+#define OBJ_ANIM_PINK_BUTFLY_RIGHT 5
+#define OBJ_ANIM_PINK_BUTFLY_LEFT 6
+#define OBJ_ANIM_FLESH_TRACE 7
+#define MOD_MENU 0
+#define MOD_GAME 1
+#define MOD_SCORES 2
+#define SFX_JUMP 0
+#define SFX_LAND 1
+#define SFX_DEATH 2
+#define SFX_SPRING 3
+#define SFX_SPLASH 4
+#define SFX_FLY 5
+#define NUM_SFX 6
+#define SFX_JUMP_FREQ 15000
+#define SFX_LAND_FREQ 15000
+#define SFX_DEATH_FREQ 20000
+#define SFX_SPRING_FREQ 15000
+#define SFX_SPLASH_FREQ 12000
+#define SFX_FLY_FREQ 12000
+#define BAN_VOID        0
+#define BAN_SOLID       1
+#define BAN_WATER       2
+#define BAN_ICE         3
+#define BAN_SPRING      4
+#ifndef DATA_PATH
+#ifdef __APPLE__
+#define DATA_PATH "data/jumpbump.dat"
+#elif _WIN32
+#define DATA_PATH "data/jumpbump.dat"
+#else
+#define DATA_PATH "jumpbump.dat"
+#endif
+#endif
+typedef struct {
+        int num_images;
+        int *width;
+        int *height;
+        int *hs_x;
+        int *hs_y;
+        void **data;
+        void **orig_data;
+} gob_t;
+typedef struct {
+        int joy_enabled, mouse_enabled;
+        int no_sound, music_no_sound, no_gore, fireworks;
+        char error_str[256];
+        int draw_page, view_page;
+        struct {
+                int num_pobs;
+                struct {
+                        int x, y;
+                        int image;
+                        gob_t *pob_data;
+                        int back_buf_ofs;
+                } pobs[NUM_POBS];
+        } page_info[2];
+        void *pob_backbuf[2];
+} main_info_t;
+typedef struct {
+        int action_left,action_up,action_right;
+        int enabled, dead_flag;
+        int bumps;
+        int bumped[JNB_MAX_PLAYERS];
+        int x, y;
+        int x_add, y_add;
+        int direction, jump_ready, jump_abort, in_water;
+        int anim, frame, frame_tick, image;
+} player_t;
+typedef struct {
+        int num_frames;
+        int restart_frame;
+        struct {
+                int image;
+                int ticks;
+        } frame[4];
+} player_anim_t;
+typedef struct {
+        int used, type;
+        int x, y;
+        int x_add, y_add;
+        int x_acc, y_acc;
+        int anim;
+        int frame, ticks;
+        int image;
+} object_t;
+typedef struct {
+        int x, y;
+        int raw_x, raw_y;
+        int but1, but2;
+        struct {
+                int x1, x2, x3;
+                int y1, y2, y3;
+        } calib_data;
+} joy_t;
+typedef struct {
+        int but1, but2, but3;
+} mouse_t;
+extern main_info_t main_info;
+extern player_t player[JNB_MAX_PLAYERS];
+extern player_anim_t player_anims[7];
+extern object_t objects[NUM_OBJECTS];
+extern joy_t joy;
+extern mouse_t mouse;
+extern char datfile_name[2048];
+extern char *background_pic;
+extern char *mask_pic;
+extern gob_t rabbit_gobs;
+extern gob_t font_gobs;
+extern gob_t object_gobs;
+extern gob_t number_gobs;
+/* fireworks.c */
+void fireworks(void);
+/* main.c */
+void steer_players(void);
+void position_player(int player_num);
+void fireworks(void);
+void add_object(int type, int x, int y, int x_add, int y_add, int anim, int frame);
+void update_objects(void);
+int add_pob(int page, int x, int y, int image, gob_t *pob_data);
+void draw_flies(int page);
+void draw_pobs(int page);
+void redraw_flies_background(int page);
+void redraw_pob_backgrounds(int page);
+int add_leftovers(int page, int x, int y, int image, gob_t *pob_data);
+void draw_leftovers(int page);
+int init_level(int level, char *pal);
+void deinit_level(void);
+int init_program(int argc, char *argv[], char *pal);
+void deinit_program(void);
+unsigned short rnd(unsigned short max);
+int read_level(void);
+unsigned char *dat_open(char *file_name);
+int dat_filelen(char *file_name);
+void write_calib_data(void);
+/* input.c */
+void update_player_actions(void);
+void init_inputs(void);
+int calib_joy(int type);
+/* menu.c */
+int menu(void);
+int menu_init(void);
+void menu_deinit(void);
+/* gfx.c */
+void set_scaling(int scale);
+void open_screen(void);
+void wait_vrt(int mix);
+void draw_begin(void);
+void draw_end(void);
+void flippage(int page);
+void draw_begin(void);
+void draw_end(void);
+void clear_lines(int page, int y, int count, int color);
+int get_color(int color, char pal[768]);
+int get_pixel(int page, int x, int y);
+void set_pixel(int page, int x, int y, int color);
+void setpalette(int index, int count, char *palette);
+void fillpalette(int red, int green, int blue);
+#ifdef DOS
+void get_block(char page, short x, short y, short width, short height, char *buffer);
+void put_block(char page, short x, short y, short width, short height, char *buffer);
+#else
+void get_block(int page, int x, int y, int width, int height, void *buffer);
+void put_block(int page, int x, int y, int width, int height, void *buffer);
+#endif
+void put_text(int page, int x, int y, char *text, int align);
+void put_pob(int page, int x, int y, int image, gob_t *gob, int mask, void *mask_pic);
+int pob_width(int image, gob_t *gob);
+int pob_height(int image, gob_t *gob);
+int pob_hs_x(int image, gob_t *gob);
+int pob_hs_y(int image, gob_t *gob);
+int read_pcx(unsigned char * handle, void *buffer, int buf_len, char *pal);
+void register_background(char *pixels, char pal[768]);
+int register_gob(unsigned char *handle, gob_t *gob, int len);
+void recalculate_gob(gob_t *gob, char pal[768]);
+void register_mask(void *pixels);
+/* gfx.c */
+#ifdef USE_SDL
+/* long filelength(int handle); */
+void fs_toggle();
+int intr_sysupdate();
+#endif
+/* interrpt.c */
+extern char last_keys[50];
+int hook_keyb_handler(void);
+void remove_keyb_handler(void);
+int key_pressed(int key);
+int addkey(unsigned int key);
+/* sound-linux.c */
+#ifdef LINUX
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/main.c
 ,0 → 1,3590
+/*
+ * main.c
+ * Copyright (C) 1998 Brainchild Design - http://brainchilddesign.com/
+ *
+ * Copyright (C) 2001 Chuck Mason <cemason@users.sourceforge.net>
+ *
+ * Copyright (C) 2002 Florian Schulze <crow@icculus.org>
+ *
+ * This file is part of Jump'n'Bump.
+ *
+ * Jump'n'Bump is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Jump'n'Bump is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include "globals.h"
+#include <fcntl.h>
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+#ifdef BZLIB_SUPPORT
+#include "bzlib.h"
+#endif
+#ifdef ZLIB_SUPPORT
+#include "zlib.h"
+#endif
+#ifdef USE_NET
+#include "SDL_net.h"
+#endif /* USE_NET */
+#ifndef M_PI
+#define M_PI            3.14159265358979323846
+#endif
+gob_t rabbit_gobs = { 0 };
+gob_t font_gobs = { 0 };
+gob_t object_gobs = { 0 };
+gob_t number_gobs = { 0 };
+main_info_t main_info;
+player_t player[JNB_MAX_PLAYERS];
+player_anim_t player_anims[7];
+object_t objects[NUM_OBJECTS];
+joy_t joy;
+mouse_t mouse;
+char datfile_name[2048];
+char *background_pic;
+char *mask_pic;
+int flip = 0;
+char pal[768];
+char cur_pal[768];
+int ai[JNB_MAX_PLAYERS];
+unsigned int ban_map[17][22] = {
+        {1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0},
+        {1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0},
+        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1},
+        {1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1},
+        {1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
+        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1},
+        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1},
+        {1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1},
+        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 1},
+        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1},
+        {1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1},
+        {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
+        {1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1},
+        {2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 0, 0, 0, 0, 0, 1, 3, 3, 3, 1, 1, 1},
+        {2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
+        {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
+};
+#define GET_BAN_MAP_XY(x,y) ban_map[(y) >> 4][(x) >> 4]
+struct {
+        int num_frames;
+        int restart_frame;
+        struct {
+                int image;
+                int ticks;
+        } frame[10];
+} object_anims[8] = {
+        {
+, 0, {
+                        {
+, 3}, {
+, 3}, {
+, 3}, {
+, 3}, {
+, 3}, {
+, 3}, {
+, 0}, {
+, 0}, {
+, 0}, {
+, 0}
+                }
+        }, {
+, 0, {
+                        {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 0}
+                }
+        }, {
+, 0, {
+                        {
+, 3}, {
+, 3}, {
+, 3}, {
+, 3}, {
+, 3}, {
+, 3}, {
+, 0}, {
+, 0}, {
+, 0}, {
+, 0}
+                }
+        }, {
+, 0, {
+                        {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}
+                }
+        }, {
+, 0, {
+                        {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}
+                }
+        }, {
+, 0, {
+                        {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}
+                }
+        }, {
+, 0, {
+                        {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}, {
+, 2}
+                }
+        }, {
+, 0, {
+                        {
+, 4}, {
+, 4}, {
+, 4}, {
+, 4}, {
+, 0}, {
+, 0}, {
+, 0}, {
+, 0}, {
+, 0}, {
+, 0}
+                }
+        }
+};
+int flies_enabled = 1;
+struct {
+        int x, y;
+        int old_x, old_y;
+        int old_draw_x, old_draw_y;
+        int back[2];
+        int back_defined[2];
+} flies[NUM_FLIES];
+struct {
+        struct {
+                short num_pobs;
+                struct {
+                        int x, y;
+                        int image;
+                        gob_t *pob_data;
+                } pobs[NUM_LEFTOVERS];
+        } page[2];
+} leftovers;
+int pogostick, bunnies_in_space, jetpack, lord_of_the_flies, blood_is_thicker_than_water;
+#ifndef _MSC_VER
+int filelength(int handle)
+{
+        struct stat buf;
+        if (fstat(handle, &buf) == -1) {
+                perror("filelength");
+                exit(EXIT_FAILURE);
+        }
+        return buf.st_size;
+}
+#endif
+/* networking shite. */
+int client_player_num = -1;
+int is_server = 1;
+int is_net = 0;
+#ifdef USE_NET
+TCPsocket sock = NULL;
+SDLNet_SocketSet socketset = NULL;
+typedef struct
+{
+        TCPsocket sock;
+        IPaddress addr;
+        SDLNet_SocketSet socketset;
+} NetInfo;
+NetInfo net_info[JNB_MAX_PLAYERS];
+#endif
+typedef struct
+{
+        unsigned long cmd;
+        long arg;
+        long arg2;
+        long arg3;
+        long arg4;
+} NetPacket;
+#define NETPKTBUFSIZE (4 + 4 + 4 + 4 + 4)
+#define NETCMD_NACK         (0xF00DF00D + 0)
+#define NETCMD_ACK          (0xF00DF00D + 1)
+#define NETCMD_HELLO        (0xF00DF00D + 2)
+#define NETCMD_GREENLIGHT   (0xF00DF00D + 3)
+#define NETCMD_MOVE         (0xF00DF00D + 4)
+#define NETCMD_BYE          (0xF00DF00D + 5)
+#define NETCMD_POSITION     (0xF00DF00D + 6)
+#define NETCMD_ALIVE        (0xF00DF00D + 7)
+#define NETCMD_KILL         (0xF00DF00D + 8)
+#ifdef USE_NET
+void bufToPacket(const char *buf, NetPacket *pkt)
+{
+        SDLNet_Write32(*((Uint32*) (buf +  0)), &pkt->cmd);
+        SDLNet_Write32(*((Uint32*) (buf +  4)), &pkt->arg);
+        SDLNet_Write32(*((Uint32*) (buf +  8)), &pkt->arg2);
+        SDLNet_Write32(*((Uint32*) (buf + 12)), &pkt->arg3);
+        SDLNet_Write32(*((Uint32*) (buf + 16)), &pkt->arg4);
+/*
+        pkt->cmd               =        ntohl(*((unsigned long *) (buf +  0)));
+        pkt->arg               = (long) ntohl(*((unsigned long *) (buf +  4)));
+        pkt->arg2              = (long) ntohl(*((unsigned long *) (buf +  8)));
+        pkt->arg3              = (long) ntohl(*((unsigned long *) (buf + 12)));
+        pkt->arg4              = (long) ntohl(*((unsigned long *) (buf + 16)));
+*/
+}
+void packetToBuf(const NetPacket *pkt, char *buf)
+{
+        *((Uint32*) (buf +  0)) = SDLNet_Read32(&pkt->cmd);
+        *((Uint32*) (buf +  4)) = SDLNet_Read32(&pkt->arg);
+        *((Uint32*) (buf +  8)) = SDLNet_Read32(&pkt->arg2);
+        *((Uint32*) (buf + 12)) = SDLNet_Read32(&pkt->arg3);
+        *((Uint32*) (buf + 16)) = SDLNet_Read32(&pkt->arg4);
+/*
+        *((unsigned long *) (buf +  0)) = htonl(pkt->cmd);
+        *((unsigned long *) (buf +  4)) = htonl((unsigned long) pkt->arg);
+        *((unsigned long *) (buf +  8)) = htonl((unsigned long) pkt->arg2);
+        *((unsigned long *) (buf + 12)) = htonl((unsigned long) pkt->arg3);
+        *((unsigned long *) (buf + 16)) = htonl((unsigned long) pkt->arg4);
+*/
+}
+void sendPacketToSock(TCPsocket s, NetPacket *pkt)
+{
+        int bytes_left = NETPKTBUFSIZE;
+        int bw;
+        char buf[NETPKTBUFSIZE];
+        char *ptr = buf;
+        packetToBuf(pkt, buf);
+        while (bytes_left > 0) {
+                bw = SDLNet_TCP_Send(s, ptr, bytes_left);
+                if (bw < 0) {
+                        fprintf(stderr, "SERVER: SDLNet_TCP_Send(): %s\n", SDLNet_GetError());
+                        SDLNet_TCP_Close(s);
+                        exit(42);
+                } else if (bw == 0) {
+                        SDL_Delay(1);
+                } else {
+                        bytes_left -= bw;
+                        ptr += bw;
+                }
+        }
+}
+void sendPacket(int playerid, NetPacket *pkt)
+{
+        if ( (playerid < JNB_MAX_PLAYERS) && (playerid >= 0)) {
+                if ((player[playerid].enabled) && (playerid != client_player_num)) {
+                        sendPacketToSock(net_info[playerid].sock, pkt);
+                }
+        }
+}
+void sendPacketToAll(NetPacket *pkt)
+{
+        int i;
+        for (i = 0; i < JNB_MAX_PLAYERS; i++) {
+                sendPacket(i, pkt);
+        }
+}
+/** read a packet from the given TCPsocket
+Returns -1 if some error occured, 0 if there was no data available and 1 if a
+packet was successfully read.
+Note: the socket has to be in the supplied socketset.
+TODO: this function will bomb if a packet arrives in pieces, there is no
+inherent guarantee that the next call will be made on the same socket. */
+int grabPacket(TCPsocket s, SDLNet_SocketSet ss, NetPacket *pkt)
+{
+        static char buf[NETPKTBUFSIZE];
+        static int buf_count = 0;
+        int rc;
+        if (SDLNet_CheckSockets(ss, 0) <= 0)
+                return 0;
+        if(!SDLNet_SocketReady(s))
+                return 0;
+        rc = SDLNet_TCP_Recv(s, &buf[buf_count], NETPKTBUFSIZE - buf_count);
+        if (rc <= 0) {
+                /* closed connection? */
+                return -1;
+        } else if (rc != NETPKTBUFSIZE) {
+                /* we got a partial packet. Store what we got in the static buffer and
+                return so that the next call can read the rest. Hopefully. */
+                buf_count = rc;
+                return 0;
+        } else {
+                buf_count = 0;
+                bufToPacket(buf, pkt);
+                return 1;
+        }
+}
+int serverRecvPacket(NetPacket *pkt)
+{
+        int rc;
+        int i;
+        assert(is_server);
+        for (i = 0; i < JNB_MAX_PLAYERS; i++) {
+                TCPsocket s = net_info[i].sock;
+                if ((i == client_player_num) || (!player[i].enabled))
+                        continue;
+                rc = grabPacket(s, net_info[i].socketset, pkt);
+                if (rc < 0) {
+                        NetPacket pkt;
+                        player[i].enabled = 0;
+                        SDLNet_TCP_Close(s);
+                        pkt.cmd = NETCMD_BYE;
+                        pkt.arg = i;
+                        pkt.arg2 = 0;
+                        pkt.arg3 = 0;
+                        pkt.arg4 = 0;
+                        sendPacketToAll(&pkt);
+                } else if (rc > 0) {
+                        return(i);  /* it's all good. */
+                }
+        }
+        return(-1);  /* no packets available currently. */
+}
+void wait_for_greenlight(void)
+{
+        NetPacket pkt;
+        int i;
+        printf("CLIENT: Waiting for greenlight...\n");
+        do {
+                int rc;
+                while ((rc = grabPacket(sock, socketset, &pkt)) == 0) {
+                        SDL_Delay(100);  /* nap and then try again. */
+                }
+                if (rc < 0) {
+                        printf("CLIENT: Lost connection.\n");
+                        SDLNet_TCP_Close(sock);
+                        exit(42);
+                }
+        } while (pkt.cmd != NETCMD_GREENLIGHT);
+        printf("CLIENT: Got greenlight.\n");
+        for (i = 0; i < JNB_MAX_PLAYERS; i++) {
+                if (pkt.arg & (1 << i)) {
+                        printf("CLIENT: There is a player #%d.\n", i);
+                        player[i].enabled = 1;
+                }
+        }
+}
+static int buggered_off = 0;
+void tellServerGoodbye(void)
+{
+        NetPacket pkt;
+        if (!buggered_off) {
+                buggered_off = 1;
+                pkt.cmd = NETCMD_BYE;
+                pkt.arg = client_player_num;
+                pkt.arg2 = 0;
+                pkt.arg3 = 0;
+                pkt.arg4 = 0;
+                sendPacketToSock(sock, &pkt);
+        }
+}
+#endif /* USE_NET */
+void processMovePacket(NetPacket *pkt)
+{
+        int playerid = pkt->arg;
+        int movetype = ((pkt->arg2 >> 16) & 0xFF);
+        int newval   = ((pkt->arg2 >>  0) & 0xFF);
+        if (movetype == MOVEMENT_LEFT) {
+                player[playerid].action_left = newval;
+        } else if (movetype == MOVEMENT_RIGHT) {
+                player[playerid].action_right = newval;
+        } else if (movetype == MOVEMENT_UP) {
+                player[playerid].action_up = newval;
+        } else {
+                printf("bogus MOVE packet!\n");
+        }
+        player[playerid].x = pkt->arg3;
+        player[playerid].y = pkt->arg4;
+}
+void tellServerPlayerMoved(int playerid, int movement_type, int newval)
+{
+        NetPacket pkt;
+        pkt.cmd = NETCMD_MOVE;
+        pkt.arg = playerid;
+        pkt.arg2 = ( ((movement_type & 0xFF) << 16) | ((newval & 0xFF) << 0) );
+        pkt.arg3 = player[playerid].x;
+        pkt.arg4 = player[playerid].y;
+        if (is_server) {
+                processMovePacket(&pkt);
+#ifdef USE_NET
+                if (is_net)
+                        sendPacketToAll(&pkt);
+        } else {
+                sendPacketToSock(sock, &pkt);
+#endif
+        }
+}
+#ifdef USE_NET
+void tellServerNewPosition(void)
+{
+        NetPacket pkt;
+        pkt.cmd = NETCMD_POSITION;
+        pkt.arg = client_player_num;
+        pkt.arg2 = player[client_player_num].x;
+        pkt.arg3 = player[client_player_num].y;
+        if (is_server) {
+                sendPacketToAll(&pkt);
+        } else {
+                sendPacketToSock(sock, &pkt);
+        }
+}
+#endif /* USE_NET */
+void processKillPacket(NetPacket *pkt)
+{
+        int c1 = pkt->arg;
+        int c2 = pkt->arg2;
+        int x = pkt->arg3;
+        int y = pkt->arg4;
+        int c4 = 0;
+        int s1 = 0;
+        player[c1].y_add = -player[c1].y_add;
+        if (player[c1].y_add > -262144L)
+                player[c1].y_add = -262144L;
+        player[c1].jump_abort = 1;
+        player[c2].dead_flag = 1;
+        if (player[c2].anim != 6) {
+                player[c2].anim = 6;
+                player[c2].frame = 0;
+                player[c2].frame_tick = 0;
+                player[c2].image = player_anims[player[c2].anim].frame[player[c2].frame].image + player[c2].direction * 9;
+                if (main_info.no_gore == 0) {
+                        for (c4 = 0; c4 < 6; c4++)
+                                add_object(OBJ_FUR, (x >> 16) + 6 + rnd(5), (y >> 16) + 6 + rnd(5), (rnd(65535) - 32768) * 3, (rnd(65535) - 32768) * 3, 0, 44 + c2 * 8);
+                        for (c4 = 0; c4 < 6; c4++)
+                                add_object(OBJ_FLESH, (x >> 16) + 6 + rnd(5), (y >> 16) + 6 + rnd(5), (rnd(65535) - 32768) * 3, (rnd(65535) - 32768) * 3, 0, 76);
+                        for (c4 = 0; c4 < 6; c4++)
+                                add_object(OBJ_FLESH, (x >> 16) + 6 + rnd(5), (y >> 16) + 6 + rnd(5), (rnd(65535) - 32768) * 3, (rnd(65535) - 32768) * 3, 0, 77);
+                        for (c4 = 0; c4 < 8; c4++)
+                                add_object(OBJ_FLESH, (x >> 16) + 6 + rnd(5), (y >> 16) + 6 + rnd(5), (rnd(65535) - 32768) * 3, (rnd(65535) - 32768) * 3, 0, 78);
+                        for (c4 = 0; c4 < 10; c4++)
+                                add_object(OBJ_FLESH, (x >> 16) + 6 + rnd(5), (y >> 16) + 6 + rnd(5), (rnd(65535) - 32768) * 3, (rnd(65535) - 32768) * 3, 0, 79);
+                }
+                dj_play_sfx(SFX_DEATH, (unsigned short)(SFX_DEATH_FREQ + rnd(2000) - 1000), 64, 0, 0, -1);
+                player[c1].bumps++;
+                player[c1].bumped[c2]++;
+                s1 = player[c1].bumps % 100;
+                add_leftovers(0, 360, 34 + c1 * 64, s1 / 10, &number_gobs);
+                add_leftovers(1, 360, 34 + c1 * 64, s1 / 10, &number_gobs);
+                add_leftovers(0, 376, 34 + c1 * 64, s1 - (s1 / 10) * 10, &number_gobs);
+                add_leftovers(1, 376, 34 + c1 * 64, s1 - (s1 / 10) * 10, &number_gobs);
+        }
+}
+#ifdef USE_NET
+void processPositionPacket(NetPacket *pkt)
+{
+        int playerid = pkt->arg;
+        player[playerid].x = pkt->arg2;
+        player[playerid].y = pkt->arg3;
+}
+void processAlivePacket(NetPacket *pkt)
+{
+        int playerid = pkt->arg;
+        player[playerid].dead_flag = 0;
+        player[playerid].x = pkt->arg2;
+        player[playerid].y = pkt->arg3;
+}
+void serverTellEveryoneGoodbye(void)
+{
+        int i;
+        if (!buggered_off) {
+                buggered_off = 1;
+                for (i = 0; i < JNB_MAX_PLAYERS; i++) {
+                        if (player[i].enabled) {
+                                NetPacket pkt;
+                                pkt.cmd = NETCMD_BYE;
+                                pkt.arg = i;
+                                pkt.arg2 = 0;
+                                pkt.arg3 = 0;
+                                pkt.arg4 = 0;
+                                sendPacketToAll(&pkt);
+                        }
+                }
+        }
+}
+int server_said_bye = 0;
+int update_players_from_server(void)
+{
+        NetPacket pkt;
+        int rc;
+        assert(!is_server);
+        while ((rc = grabPacket(sock, socketset, &pkt)) != 0) {
+                if (rc < 0) {
+                        printf("CLIENT: Lost connection.\n");
+                        pkt.cmd = NETCMD_BYE;
+                        pkt.arg = client_player_num;
+                }
+                if (pkt.cmd == NETCMD_BYE) {
+                        if (pkt.arg == client_player_num) {
+                                SDLNet_FreeSocketSet(socketset);
+                                SDLNet_TCP_Close(sock);
+                                sock = NULL;
+                                server_said_bye = 1;
+                                return(0);
+                        } else {
+                                player[pkt.arg].enabled = 0;
+                        }
+                } else if (pkt.cmd == NETCMD_MOVE) {
+                        processMovePacket(&pkt);
+                } else if (pkt.cmd == NETCMD_ALIVE) {
+                        processAlivePacket(&pkt);
+                } else if (pkt.cmd == NETCMD_POSITION) {
+                        processPositionPacket(&pkt);
+                } else if (pkt.cmd == NETCMD_KILL) {
+                        processKillPacket(&pkt);
+                } else {
+                        printf("CLIENT: Got an unknown packet: 0x%lX.\n", pkt.cmd);
+                }
+        }
+        return(1);
+}
+void serverSendAlive(int playerid)
+{
+        NetPacket pkt;
+        assert(is_server);
+        pkt.cmd = NETCMD_ALIVE;
+        pkt.arg = playerid;
+        pkt.arg2 = player[playerid].x;
+        pkt.arg3 = player[playerid].y;
+        sendPacketToAll(&pkt);
+}
+#endif /* USE_NET */
+void serverSendKillPacket(int killer, int victim)
+{
+        NetPacket pkt;
+        assert(is_server);
+        pkt.cmd = NETCMD_KILL;
+        pkt.arg = killer;
+        pkt.arg2 = victim;
+        pkt.arg3 = player[victim].x;
+        pkt.arg4 = player[victim].y;
+        processKillPacket(&pkt);
+#ifdef USE_NET
+        if (is_net)
+                sendPacketToAll(&pkt);
+#endif
+}
+#ifdef USE_NET
+void update_players_from_clients(void)
+{
+        int i;
+        NetPacket pkt;
+        int playerid;
+        assert(is_server);
+        while ((playerid = serverRecvPacket(&pkt)) >= 0) {
+                if (pkt.cmd == NETCMD_BYE) {
+                        pkt.arg = playerid;  /* just in case. */
+                        sendPacketToAll(&pkt);
+                        player[playerid].enabled = 0;
+                        SDLNet_FreeSocketSet(net_info[playerid].socketset);
+                        SDLNet_TCP_Close(net_info[playerid].sock);
+                } else if (pkt.cmd == NETCMD_POSITION) {
+                        pkt.arg = playerid;  /* just in case. */
+                        processPositionPacket(&pkt);
+                        for (i = 0; i < JNB_MAX_PLAYERS; i++) {
+                                if (i != playerid) {
+                                        sendPacket(i, &pkt);
+                                }
+                        }
+                } else if (pkt.cmd == NETCMD_MOVE) {
+                        pkt.arg = playerid;  /* just in case. */
+                        /*
+                        pkt.arg3 = player[playerid].x;
+                        pkt.arg4 = player[playerid].y;
+                        */
+                        processMovePacket(&pkt);
+                        sendPacketToAll(&pkt);
+                } else {
+                        printf("SERVER: Got unknown packet (0x%lX).\n", pkt.cmd);
+                }
+        }
+}
+void init_server(const char *netarg)
+{
+        NetPacket pkt;
+        IPaddress addr;
+        int i;
+        int wait_for_clients = ((netarg == NULL) ? 0 : atoi(netarg));
+        char *ipstr;
+        /** assign player number zero as default for the server */
+        if(-1 == client_player_num)
+                client_player_num = 0;
+        if ((wait_for_clients >= JNB_MAX_PLAYERS) || (wait_for_clients < 0)) {
+                printf("SERVER: Waiting for bogus client count (%d).\n", wait_for_clients);
+                exit(42);
+        }
+        if (SDLNet_Init() < 0) {
+                exit(42);
+        }
+        atexit(SDLNet_Quit);
+        SDLNet_ResolveHost(&addr, NULL, JNB_INETPORT);
+        ipstr = SDLNet_ResolveIP(&addr);
+        SDLNet_ResolveHost(&addr, ipstr, JNB_INETPORT);
+        printf("SERVER: we are %s (%i.%i.%i.%i:%i).\n", ipstr, (addr.host >> 0) & 0xff, (addr.host >> 8) & 0xff, (addr.host >> 16) & 0xff, (addr.host >> 24) & 0xff, addr.port);
+        net_info[client_player_num].addr = addr;
+        addr.host = INADDR_ANY;
+        sock = SDLNet_TCP_Open(&addr);
+        if (sock == NULL) {
+                fprintf(stderr, "SERVER: SDLNet_TCP_Open(): %s\n", SDLNet_GetError());
+                exit(42);
+        }
+        player[client_player_num].enabled = 1;
+        printf("SERVER: waiting for (%d) clients...\n", wait_for_clients);
+        socketset = SDLNet_AllocSocketSet(JNB_MAX_PLAYERS + 1);
+        SDLNet_TCP_AddSocket(socketset, sock);
+        while (wait_for_clients > 0)
+        {
+                char buf[NETPKTBUFSIZE];
+                IPaddress *from;
+                int negatory = 1;
+                int br;
+                TCPsocket s;
+                /* Wait for events */
+                SDLNet_CheckSockets(socketset, ~0);
+                if ( SDLNet_SocketReady(sock) ) {
+                        s = SDLNet_TCP_Accept(sock);
+                        if (s == NULL)
+                        {
+                                fprintf(stderr, "SERVER: SDLNet_TCP_Accept(): %s", SDLNet_GetError());
+                                SDLNet_TCP_Close(sock);
+                                exit(42);
+                        }
+                } else
+                        continue;
+                br = SDLNet_TCP_Recv(s, buf, NETPKTBUFSIZE);
+                if (br < 0) {
+                        fprintf(stderr, "SERVER: SDLNet_TCP_Recv(): %s\n", SDLNet_GetError());
+                        SDLNet_TCP_Close(s);
+                        SDLNet_TCP_Close(sock);
+                        exit(42);
+                }
+                from = SDLNet_TCP_GetPeerAddress(s);
+                ipstr = SDLNet_ResolveIP(from);
+                printf("SERVER: Got data from %s (%i.%i.%i.%i:%i).\n", ipstr, (from->host >> 0) & 0xff, (from->host >> 8) & 0xff, (from->host >> 16) & 0xff, (from->host >> 24) & 0xff, from->port);
+                if (br != NETPKTBUFSIZE) {
+                        printf("SERVER: Bogus packet.\n");
+                        continue;
+                }
+                bufToPacket(buf, &pkt);
+                if (pkt.cmd != NETCMD_HELLO) {
+                        printf("SERVER: Bogus packet.\n");
+                        continue;
+                }
+                printf("SERVER: Client claims to be player #%ld.\n", pkt.arg);
+                if (-1 == pkt.arg) {
+                        int i;
+                        for(i=0; i!=JNB_MAX_PLAYERS; ++i) {
+                                if(!player[i].enabled) {
+                                        printf("SERVER: assigning %d as player number\n", i);
+                                        pkt.arg = i;
+                                        break;
+                                }
+                        }
+                }
+                if ((pkt.arg>=JNB_MAX_PLAYERS)||(pkt.arg<0)) {
+                        printf("SERVER:  (that's an invalid player number.)\n");
+                } else if (player[pkt.arg].enabled) {
+                        printf("SERVER:  (that player number is already taken.)\n");
+                } else {
+                        negatory = 0;
+                }
+                if (negatory) {
+                        printf("SERVER: Forbidding connection.\n");
+                        pkt.cmd = NETCMD_NACK;
+                        sendPacketToSock(s, &pkt);
+                        SDLNet_TCP_Close(s);
+                } else {
+                        player[pkt.arg].enabled = 1;
+                        net_info[pkt.arg].sock = s;
+                        net_info[pkt.arg].addr = *from;
+                        net_info[pkt.arg].socketset = SDLNet_AllocSocketSet(1);
+                        SDLNet_TCP_AddSocket(net_info[pkt.arg].socketset, net_info[pkt.arg].sock);
+                        wait_for_clients--;
+                        printf("SERVER: Granting connection. (%d) to go.\n", wait_for_clients);
+                        pkt.cmd = NETCMD_ACK;
+                        sendPacket(pkt.arg, &pkt);
+                }
+        }
+        SDLNet_TCP_Close(sock);  /* done with the listen socket. */
+        SDLNet_FreeSocketSet(socketset);
+        sock = NULL;
+        socketset = NULL;
+        printf("SERVER: Got all our connections. Greenlighting clients...\n");
+        pkt.cmd = NETCMD_GREENLIGHT;
+        pkt.arg = 0;
+        for (i = 0; i < JNB_MAX_PLAYERS; i++) {
+                if (player[i].enabled) {
+                        pkt.arg |= (1 << i);
+                }
+        }
+        sendPacketToAll(&pkt);
+}
+void connect_to_server(char *netarg)
+{
+        NetPacket pkt;
+        char buf[NETPKTBUFSIZE];
+        char *ipstr;
+        IPaddress hent;
+        IPaddress addr;
+        int br;
+        if (netarg == NULL) {
+                printf("CLIENT: Need to specify host to connect to.\n");
+                exit(42);
+        }
+        if (SDLNet_Init() < 0) {
+                exit(42);
+        }
+        atexit(SDLNet_Quit);
+        SDLNet_ResolveHost(&addr, NULL, JNB_INETPORT);
+        ipstr = SDLNet_ResolveIP(&addr);
+        SDLNet_ResolveHost(&addr, ipstr, JNB_INETPORT);
+        printf("CLIENT: we are %s (%i.%i.%i.%i:%i).\n", ipstr, (addr.host >> 0) & 0xff, (addr.host >> 8) & 0xff, (addr.host >> 16) & 0xff, (addr.host >> 24) & 0xff, addr.port);
+        if (SDLNet_ResolveHost(&hent, netarg, JNB_INETPORT) < 0) {
+                fprintf(stderr, "CLIENT: couldn't find host: %s\n", SDLNet_GetError());
+                exit(42);
+        }
+        sock = SDLNet_TCP_Open(&hent);
+        if (sock == NULL) {
+                fprintf(stderr, "CLIENT: SDLNet_TCP_Open(): %s\n", SDLNet_GetError());
+                exit(42);
+        }
+        socketset = SDLNet_AllocSocketSet(1);
+        SDLNet_TCP_AddSocket(socketset, sock);
+        printf("CLIENT: connected to %s...\n", SDLNet_ResolveIP(&hent));
+        printf("CLIENT: Sending HELLO packet...\n");
+        pkt.cmd = NETCMD_HELLO;
+        pkt.arg = client_player_num;
+        sendPacketToSock(sock, &pkt);
+        printf("CLIENT: Waiting for ACK from server...\n");
+        br = SDLNet_TCP_Recv(sock, buf, NETPKTBUFSIZE);
+        if (br < 0) {
+                fprintf(stderr, "CLIENT: recv(): %s\n", SDLNet_GetError());
+                SDLNet_FreeSocketSet(socketset);
+                SDLNet_TCP_Close(sock);
+                exit(42);
+        }
+        if (br != NETPKTBUFSIZE) {
+                printf("CLIENT: Bogus packet size (%d of %d). FIXME.\n", br, NETPKTBUFSIZE);
+                SDLNet_FreeSocketSet(socketset);
+                SDLNet_TCP_Close(sock);
+                exit(42);
+        }
+        bufToPacket(buf, &pkt);
+        if (pkt.cmd == NETCMD_NACK) {
+                printf("CLIENT: Server forbid us from playing.\n");
+                SDLNet_FreeSocketSet(socketset);
+                SDLNet_TCP_Close(sock);
+                exit(42);
+        }
+        if (pkt.cmd != NETCMD_ACK) {
+                printf("CLIENT: Unexpected packet (cmd=0x%lX).\n", pkt.cmd);
+                SDLNet_FreeSocketSet(socketset);
+                SDLNet_TCP_Close(sock);
+                exit(42);
+        }
+        client_player_num = pkt.arg;
+        player[client_player_num].enabled = 1;
+        net_info[client_player_num].addr = addr;
+        printf("CLIENT: Server accepted our connection.\n");
+        wait_for_greenlight();
+}
+#endif /* USE_NET */
+static void flip_pixels(unsigned char *pixels)
+{
+        int x,y;
+        unsigned char temp;
+        assert(pixels);
+        for (y = 0; y < JNB_HEIGHT; y++) {
+                for (x = 0; x < (352/2); x++) {
+                        temp = pixels[y*JNB_WIDTH+x];
+                        pixels[y*JNB_WIDTH+x] = pixels[y*JNB_WIDTH+(352-x)-1];
+                        pixels[y*JNB_WIDTH+(352-x)-1] = temp;
+                }
+        }
+}
+void get_closest_player_to_point(int x,int y,int *dist,int *closest_player)
+{
+        int c1;
+        int cur_dist = 0;
+        *dist = 0x7fff;
+        for (c1 = 0; c1 < JNB_MAX_PLAYERS; c1++) {
+                if (player[c1].enabled == 1) {
+                        cur_dist = (int)sqrt((x - ((player[c1].x >> 16) + 8)) * (x - ((player[c1].x >> 16) + 8)) + (y - ((player[c1].y >> 16) + 8)) * (y - ((player[c1].y >> 16) + 8)));
+                        if (cur_dist < *dist) {
+                                *closest_player = c1;
+                                *dist = cur_dist;
+                        }
+                }
+        }
+}
+static void update_flies(int update_count)
+{
+        int c1;
+        int closest_player = 0, dist;
+        int s1, s2, s3, s4;
+        /* get center of fly swarm */
+        s1 = s2 = 0;
+        for (c1 = 0; c1 < NUM_FLIES; c1++) {
+                s1 += flies[c1].x;
+                s2 += flies[c1].y;
+        }
+        s1 /= NUM_FLIES;
+        s2 /= NUM_FLIES;
+        if (update_count == 1) {
+                /* get closest player to fly swarm */
+                get_closest_player_to_point(s1, s2, &dist, &closest_player);
+                /* update fly swarm sound */
+                s3 = 32 - dist / 3;
+                if (s3 < 0)
+                        s3 = 0;
+                dj_set_sfx_channel_volume(4, (char)(s3));
+        }
+        for (c1 = 0; c1 < NUM_FLIES; c1++) {
+                /* get closest player to fly */
+                get_closest_player_to_point(flies[c1].x, flies[c1].y, &dist, &closest_player);
+                flies[c1].old_x = flies[c1].x;
+                flies[c1].old_y = flies[c1].y;
+                s3 = 0;
+                if ((s1 - flies[c1].x) > 30)
+                        s3 += 1;
+                else if ((s1 - flies[c1].x) < -30)
+                        s3 -= 1;
+                if (dist < 30) {
+                        if (((player[closest_player].x >> 16) + 8) > flies[c1].x) {
+                                if (lord_of_the_flies == 0)
+                                        s3 -= 1;
+                                else
+                                        s3 += 1;
+                        } else {
+                                if (lord_of_the_flies == 0)
+                                        s3 += 1;
+                                else
+                                        s3 -= 1;
+                        }
+                }
+                s4 = rnd(3) - 1 + s3;
+                if ((flies[c1].x + s4) < 16)
+                        s4 = 0;
+                if ((flies[c1].x + s4) > 351)
+                        s4 = 0;
+                if (GET_BAN_MAP_XY(flies[c1].x + s4, flies[c1].y) != BAN_VOID)
+                        s4 = 0;
+                flies[c1].x += s4;
+                s3 = 0;
+                if ((s2 - flies[c1].y) > 30)
+                        s3 += 1;
+                else if ((s2 - flies[c1].y) < -30)
+                        s3 -= 1;
+                if (dist < 30) {
+                        if (((player[closest_player].y >> 16) + 8) > flies[c1].y) {
+                                if (lord_of_the_flies == 0)
+                                        s3 -= 1;
+                                else
+                                        s3 += 1;
+                        } else {
+                                if (lord_of_the_flies == 0)
+                                        s3 += 1;
+                                else
+                                        s3 -= 1;
+                        }
+                }
+                s4 = rnd(3) - 1 + s3;
+                if ((flies[c1].y + s4) < 0)
+                        s4 = 0;
+                if ((flies[c1].y + s4) > 239)
+                        s4 = 0;
+                if (GET_BAN_MAP_XY(flies[c1].x, flies[c1].y + s4) != BAN_VOID)
+                        s4 = 0;
+                flies[c1].y += s4;
+        }
+}
+static void player_kill(int c1, int c2)
+{
+        if (player[c1].y_add >= 0) {
+                if (is_server)
+                        serverSendKillPacket(c1, c2);
+        } else {
+                if (player[c2].y_add < 0)
+                        player[c2].y_add = 0;
+        }
+}
+static void check_cheats(void)
+{
+        if (strncmp(last_keys, "kcitsogop", strlen("kcitsogop")) == 0) {
+                pogostick ^= 1;
+                last_keys[0] = 0;
+        }
+        if (strncmp(last_keys, "ecapsniseinnub", strlen("ecapsniseinnub")) == 0) {
+                bunnies_in_space ^= 1;
+                last_keys[0] = 0;
+        }
+        if (strncmp(last_keys, "kcaptej", strlen("kcaptej")) == 0) {
+                jetpack ^= 1;
+                last_keys[0] = 0;
+        }
+        if (strncmp(last_keys, "seilfehtfodrol", strlen("seilfehtfodrol")) == 0) {
+                lord_of_the_flies ^= 1;
+                last_keys[0] = 0;
+        }
+        if (strncmp(last_keys, "retawnahtrekcihtsidoolb", strlen("retawnahtrekcihtsidoolb")) == 0) {
+                char blood[32] = {
+,32,32,53,17,17,42, 7,
+,28, 0, 0,24, 0, 0,19,
+, 0,12, 0, 0, 7, 0, 0
+                };
+                char water[32] = {
+,63,63,40,53,62,19,42,
+, 0,33,60, 3,32,46, 3,
+,33, 3,19,21, 1, 8, 8
+                };
+                int i;
+                blood_is_thicker_than_water ^= 1;
+                if (blood_is_thicker_than_water == 1) {
+                        for (i=0; i<32; i++)
+                                pal[432+i] = blood[i];
+                } else {
+                        for (i=0; i<32; i++)
+                                pal[432+i] = water[i];
+                }
+                register_background(background_pic, pal);
+                recalculate_gob(&object_gobs, pal);
+                last_keys[0] = 0;
+        }
+}
+static void collision_check(void)
+{
+        int c1 = 0, c2 = 0, c3 = 0;
+        int l1;
+        /* collision check */
+        for (c3 = 0; c3 < 6; c3++) {
+                if (c3 == 0) {
+                        c1 = 0;
+                        c2 = 1;
+                } else if (c3 == 1) {
+                        c1 = 0;
+                        c2 = 2;
+                } else if (c3 == 2) {
+                        c1 = 0;
+                        c2 = 3;
+                } else if (c3 == 3) {
+                        c1 = 1;
+                        c2 = 2;
+                } else if (c3 == 4) {
+                        c1 = 1;
+                        c2 = 3;
+                } else if (c3 == 5) {
+                        c1 = 2;
+                        c2 = 3;
+                }
+                if (player[c1].enabled == 1 && player[c2].enabled == 1) {
+                        if (labs(player[c1].x - player[c2].x) < (12L << 16) && labs(player[c1].y - player[c2].y) < (12L << 16)) {
+                                if ((labs(player[c1].y - player[c2].y) >> 16) > 5) {
+                                        if (player[c1].y < player[c2].y) {
+                                                player_kill(c1,c2);
+                                        } else {
+                                                player_kill(c2,c1);
+                                        }
+                                } else {
+                                        if (player[c1].x < player[c2].x) {
+                                                if (player[c1].x_add > 0)
+                                                        player[c1].x = player[c2].x - (12L << 16);
+                                                else if (player[c2].x_add < 0)
+                                                        player[c2].x = player[c1].x + (12L << 16);
+                                                else {
+                                                        player[c1].x -= player[c1].x_add;
+                                                        player[c2].x -= player[c2].x_add;
+                                                }
+                                                l1 = player[c2].x_add;
+                                                player[c2].x_add = player[c1].x_add;
+                                                player[c1].x_add = l1;
+                                                if (player[c1].x_add > 0)
+                                                        player[c1].x_add = -player[c1].x_add;
+                                                if (player[c2].x_add < 0)
+                                                        player[c2].x_add = -player[c2].x_add;
+                                        } else {
+                                                if (player[c1].x_add > 0)
+                                                        player[c2].x = player[c1].x - (12L << 16);
+                                                else if (player[c2].x_add < 0)
+                                                        player[c1].x = player[c2].x + (12L << 16);
+                                                else {
+                                                        player[c1].x -= player[c1].x_add;
+                                                        player[c2].x -= player[c2].x_add;
+                                                }
+                                                l1 = player[c2].x_add;
+                                                player[c2].x_add = player[c1].x_add;
+                                                player[c1].x_add = l1;
+                                                if (player[c1].x_add < 0)
+                                                        player[c1].x_add = -player[c1].x_add;
+                                                if (player[c2].x_add > 0)
+                                                        player[c2].x_add = -player[c2].x_add;
+                                        }
+                                }
+                        }
+                }
+        }
+}
+static void game_loop(void) {
+        int mod_vol, sfx_vol;
+        int update_count = 1;
+        int end_loop_flag = 0;
+        int fade_flag = 0;
+        int update_palette = 0;
+        int mod_fade_direction;
+        int i;
+        mod_vol = sfx_vol = 0;
+        mod_fade_direction = 1;
+        dj_ready_mod(MOD_GAME);
+        dj_set_mod_volume((char)mod_vol);
+        dj_set_sfx_volume((char)mod_vol);
+        dj_start_mod();
+        intr_sysupdate();
+        while (1) {
+                while (update_count) {
+                        if (key_pressed(1) == 1) {
+#ifdef USE_NET
+                                if (is_net) {
+                                        if (is_server) {
+                                                serverTellEveryoneGoodbye();
+                                        } else {
+                                                tellServerGoodbye();
+                                        }
+                                }
+#endif
+                                end_loop_flag = 1;
+                                memset(pal, 0, 768);
+                                mod_fade_direction = 0;
+                        }
+                        check_cheats();
+#ifdef USE_NET
+                        if (is_net) {
+                                if (is_server) {
+                                        update_players_from_clients();
+                                } else {
+                                        if (!update_players_from_server()) {
+                                                break;  /* got a BYE packet */
+                                        }
+                                }
+                        }
+#endif
+                        steer_players();
+                        dj_mix();
+                        collision_check();
+                        dj_mix();
+                        main_info.page_info[main_info.draw_page].num_pobs = 0;
+                        for (i = 0; i < JNB_MAX_PLAYERS; i++) {
+                                if (player[i].enabled == 1)
+                                        main_info.page_info[main_info.draw_page].num_pobs++;
+                        }
+                        update_objects();
+                        dj_mix();
+                        if (flies_enabled) {
+                                update_flies(update_count);
+                        }
+                        dj_mix();
+                        if (update_count == 1) {
+                                int c2;
+                                for (i = 0, c2 = 0; i < JNB_MAX_PLAYERS; i++) {
+                                        if (player[i].enabled == 1) {
+                                                main_info.page_info[main_info.draw_page].pobs[c2].x = player[i].x >> 16;
+                                                main_info.page_info[main_info.draw_page].pobs[c2].y = player[i].y >> 16;
+                                                main_info.page_info[main_info.draw_page].pobs[c2].image = player[i].image + i * 18;
+                                                main_info.page_info[main_info.draw_page].pobs[c2].pob_data = &rabbit_gobs;
+                                                c2++;
+                                        }
+                                }
+                                draw_begin();
+                                draw_pobs(main_info.draw_page);
+                                dj_mix();
+                                if (flies_enabled)
+                                        draw_flies(main_info.draw_page);
+                                draw_end();
+                        }
+                        if (mod_fade_direction == 1) {
+                                if (mod_vol < 30) {
+                                        mod_vol++;
+                                        dj_set_mod_volume((char)mod_vol);
+                                }
+                                if (sfx_vol < 64) {
+                                        sfx_vol++;
+                                        dj_set_sfx_volume((char)sfx_vol);
+                                }
+                        } else {
+                                if (mod_vol > 0) {
+                                        mod_vol--;
+                                        dj_set_mod_volume((char)mod_vol);
+                                }
+                                if (sfx_vol > 0) {
+                                        sfx_vol--;
+                                        dj_set_sfx_volume((char)sfx_vol);
+                                }
+                        }
+                        fade_flag = 0;
+                        for (i = 0; i < 768; i++) {
+                                if (cur_pal[i] < pal[i]) {
+                                        cur_pal[i]++;
+                                        fade_flag = 1;
+                                } else if (cur_pal[i] > pal[i]) {
+                                        cur_pal[i]--;
+                                        fade_flag = 1;
+                                }
+                        }
+                        if (fade_flag == 1)
+                                update_palette = 1;
+                        if (fade_flag == 0 && end_loop_flag == 1)
+                                break;
+                        if (update_count == 1) {
+                                if (update_palette == 1) {
+                                        setpalette(0, 256, cur_pal);
+                                        update_palette = 0;
+                                }
+                                main_info.draw_page ^= 1;
+                                main_info.view_page ^= 1;
+                                flippage(main_info.view_page);
+                                wait_vrt(1);
+                                draw_begin();
+                                if (flies_enabled)
+                                        redraw_flies_background(main_info.draw_page);
+                                redraw_pob_backgrounds(main_info.draw_page);
+                                draw_leftovers(main_info.draw_page);
+                                draw_end();
+                        }
+                        update_count--;
+                }
+#ifdef USE_NET
+                if (is_net) {
+                        if ( (player[client_player_num].dead_flag == 0) &&
+                                (
+                                 (player[client_player_num].action_left) ||
+                                 (player[client_player_num].action_right) ||
+                                 (player[client_player_num].action_up) ||
+                                 (player[client_player_num].jump_ready == 0)
+                                )
+                           ) {
+                                tellServerNewPosition();
+                        }
+                }
+#endif
+                update_count = intr_sysupdate();
+#ifdef USE_NET
+                if (is_net) {
+                        if ((server_said_bye) || ((fade_flag == 0) && (end_loop_flag == 1)))
+                                break;
+                } else
+#endif
+                if ((fade_flag == 0) && (end_loop_flag == 1))
+                        break;
+        }
+}
+static int menu_loop(void)
+{
+        unsigned char *handle;
+        int mod_vol;
+        int c1, c2;
+        int s1, s2;
+        for(c1 = 0; c1 < JNB_MAX_PLAYERS; c1++)         // reset player values
+        {
+                ai[c1] = 0;
+        }
+        while (1) {
+                if (!is_net)
+                        if (menu() != 0)
+                                deinit_program();
+                if (key_pressed(1) == 1) {
+                        return 0;
+                }
+                if (init_level(0, pal) != 0) {
+                        deinit_level();
+                        deinit_program();
+                }
+                memset(cur_pal, 0, 768);
+                setpalette(0, 256, cur_pal);
+                recalculate_gob(&rabbit_gobs, pal);
+                recalculate_gob(&object_gobs, pal);
+                recalculate_gob(&number_gobs, pal);
+                flippage(1);
+                register_background(background_pic, pal);
+                flippage(0);
+                if (flies_enabled) {
+                        s1 = rnd(250) + 50;
+                        s2 = rnd(150) + 50;
+                        for (c1 = 0; c1 < NUM_FLIES; c1++) {
+                                while (1) {
+                                        flies[c1].x = s1 + rnd(101) - 50;
+                                        flies[c1].y = s2 + rnd(101) - 50;
+                                        if (GET_BAN_MAP_XY(flies[c1].x, flies[c1].y) == BAN_VOID)
+                                                break;
+                                }
+                                flies[c1].back_defined[0] = 0;
+                                flies[c1].back_defined[1] = 0;
+                        }
+                }
+                if (flies_enabled)
+                        dj_play_sfx(SFX_FLY, SFX_FLY_FREQ, 0, 0, 0, 4);
+                dj_set_nosound(0);
+                lord_of_the_flies = bunnies_in_space = jetpack = pogostick = blood_is_thicker_than_water = 0;
+                main_info.page_info[0].num_pobs = 0;
+                main_info.page_info[1].num_pobs = 0;
+                main_info.view_page = 0;
+                main_info.draw_page = 1;
+                game_loop();
+#ifdef USE_NET
+                if (is_net) {
+                        if (is_server) {
+                                serverTellEveryoneGoodbye();
+                                SDLNet_TCP_Close(sock);
+                                sock = NULL;
+                        } else {
+                                if (!server_said_bye) {
+                                        tellServerGoodbye();
+                                }
+                                SDLNet_TCP_Close(sock);
+                                sock = NULL;
+                        }
+                }
+#endif
+                main_info.view_page = 0;
+                main_info.draw_page = 1;
+                dj_stop_sfx_channel(4);
+                deinit_level();
+                memset(mask_pic, 0, JNB_WIDTH*JNB_HEIGHT);
+                register_mask(mask_pic);
+                register_background(NULL, NULL);
+                draw_begin();
+                put_text(main_info.view_page, 100, 50, "DOTT", 2);
+                put_text(main_info.view_page, 160, 50, "JIFFY", 2);
+                put_text(main_info.view_page, 220, 50, "FIZZ", 2);
+                put_text(main_info.view_page, 280, 50, "MIJJI", 2);
+                put_text(main_info.view_page, 40, 80, "DOTT", 2);
+                put_text(main_info.view_page, 40, 110, "JIFFY", 2);
+                put_text(main_info.view_page, 40, 140, "FIZZ", 2);
+                put_text(main_info.view_page, 40, 170, "MIJJI", 2);
+                for (c1 = 0; c1 < JNB_MAX_PLAYERS; c1++) {
+                        char str1[100];
+                        for (c2 = 0; c2 < JNB_MAX_PLAYERS; c2++) {
+                                if (c2 != c1) {
+                                        sprintf(str1, "%d", player[c1].bumped[c2]);
+                                        put_text(main_info.view_page, 100 + c2 * 60, 80 + c1 * 30, str1, 2);
+                                } else
+                                        put_text(main_info.view_page, 100 + c2 * 60, 80 + c1 * 30, "-", 2);
+                        }
+                        sprintf(str1, "%d", player[c1].bumps);
+                        put_text(main_info.view_page, 350, 80 + c1 * 30, str1, 2);
+                }
+                put_text(main_info.view_page, 200, 230, "Press ESC to continue", 2);
+                draw_end();
+                flippage(main_info.view_page);
+                if ((handle = dat_open("menu.pcx")) == 0) {
+                        strcpy(main_info.error_str, "Error loading 'menu.pcx', aborting...\n");
+                        return 1;
+                }
+                if (read_pcx(handle, background_pic, JNB_WIDTH*JNB_HEIGHT, pal) != 0) {
+                        strcpy(main_info.error_str, "Error loading 'menu.pcx', aborting...\n");
+                        return 1;
+                }
+                /* fix dark font */
+                for (c1 = 0; c1 < 16; c1++) {
+                        pal[(240 + c1) * 3 + 0] = c1 << 2;
+                        pal[(240 + c1) * 3 + 1] = c1 << 2;
+                        pal[(240 + c1) * 3 + 2] = c1 << 2;
+                }
+                memset(cur_pal, 0, 768);
+                setpalette(0, 256, cur_pal);
+                mod_vol = 0;
+                dj_ready_mod(MOD_SCORES);
+                dj_set_mod_volume((char)mod_vol);
+                dj_start_mod();
+                dj_set_nosound(0);
+                while (key_pressed(1) == 0) {
+                        if (mod_vol < 35)
+                                mod_vol++;
+                        dj_set_mod_volume((char)mod_vol);
+                        for (c1 = 0; c1 < 768; c1++) {
+                                if (cur_pal[c1] < pal[c1])
+                                        cur_pal[c1]++;
+                        }
+                        dj_mix();
+                        intr_sysupdate();
+                        wait_vrt(0);
+                        setpalette(0, 256, cur_pal);
+                        flippage(main_info.view_page);
+                }
+                while (key_pressed(1) == 1) {
+                        dj_mix();
+                        intr_sysupdate();
+                }
+                memset(pal, 0, 768);
+                while (mod_vol > 0) {
+                        mod_vol--;
+                        dj_set_mod_volume((char)mod_vol);
+                        for (c1 = 0; c1 < 768; c1++) {
+                                if (cur_pal[c1] > pal[c1])
+                                        cur_pal[c1]--;
+                        }
+                        dj_mix();
+                        wait_vrt(0);
+                        setpalette(0, 256, cur_pal);
+                        flippage(main_info.view_page);
+                }
+                fillpalette(0, 0, 0);
+                dj_set_nosound(1);
+                dj_stop_mod();
+                if (is_net)
+                        return 0; /* don't go back to menu if in net game. */
+        }
+}
+int main(int argc, char *argv[])
+{
+        int result;
+        if (init_program(argc, argv, pal) != 0)
+                deinit_program();
+        if (main_info.fireworks == 1) {
+                fireworks();
+                deinit_program();
+        }
+        result = menu_loop();
+        deinit_program();
+        return result;
+}
+static void player_action_left(int c1)
+{
+        int s1 = 0, s2 = 0;
+        int below_left, below, below_right;
+    s1 = (player[c1].x >> 16);
+    s2 = (player[c1].y >> 16);
+        below_left = GET_BAN_MAP_XY(s1, s2 + 16);
+        below = GET_BAN_MAP_XY(s1 + 8, s2 + 16);
+        below_right = GET_BAN_MAP_XY(s1 + 15, s2 + 16);
+    if (below == BAN_ICE) {
+        if (player[c1].x_add > 0)
+            player[c1].x_add -= 1024;
+        else
+            player[c1].x_add -= 768;
+    } else if ((below_left != BAN_SOLID && below_right == BAN_ICE) || (below_left == BAN_ICE && below_right != BAN_SOLID)) {
+        if (player[c1].x_add > 0)
+            player[c1].x_add -= 1024;
+        else
+            player[c1].x_add -= 768;
+    } else {
+        if (player[c1].x_add > 0) {
+            player[c1].x_add -= 16384;
+            if (player[c1].x_add > -98304L && player[c1].in_water == 0 && below == BAN_SOLID)
+                add_object(OBJ_SMOKE, (player[c1].x >> 16) + 2 + rnd(9), (player[c1].y >> 16) + 13 + rnd(5), 0, -16384 - rnd(8192), OBJ_ANIM_SMOKE, 0);
+        } else
+            player[c1].x_add -= 12288;
+    }
+    if (player[c1].x_add < -98304L)
+        player[c1].x_add = -98304L;
+    player[c1].direction = 1;
+    if (player[c1].anim == 0) {
+        player[c1].anim = 1;
+        player[c1].frame = 0;
+        player[c1].frame_tick = 0;
+        player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+    }
+}
+static void player_action_right(int c1)
+{
+        int s1 = 0, s2 = 0;
+        int below_left, below, below_right;
+    s1 = (player[c1].x >> 16);
+    s2 = (player[c1].y >> 16);
+        below_left = GET_BAN_MAP_XY(s1, s2 + 16);
+        below = GET_BAN_MAP_XY(s1 + 8, s2 + 16);
+        below_right = GET_BAN_MAP_XY(s1 + 15, s2 + 16);
+    if (below == BAN_ICE) {
+        if (player[c1].x_add < 0)
+            player[c1].x_add += 1024;
+        else
+            player[c1].x_add += 768;
+    } else if ((below_left != BAN_SOLID && below_right == BAN_ICE) || (below_left == BAN_ICE && below_right != BAN_SOLID)) {
+        if (player[c1].x_add > 0)
+            player[c1].x_add += 1024;
+        else
+            player[c1].x_add += 768;
+    } else {
+        if (player[c1].x_add < 0) {
+            player[c1].x_add += 16384;
+            if (player[c1].x_add < 98304L && player[c1].in_water == 0 && below == BAN_SOLID)
+                add_object(OBJ_SMOKE, (player[c1].x >> 16) + 2 + rnd(9), (player[c1].y >> 16) + 13 + rnd(5), 0, -16384 - rnd(8192), OBJ_ANIM_SMOKE, 0);
+        } else
+            player[c1].x_add += 12288;
+    }
+    if (player[c1].x_add > 98304L)
+        player[c1].x_add = 98304L;
+    player[c1].direction = 0;
+    if (player[c1].anim == 0) {
+        player[c1].anim = 1;
+        player[c1].frame = 0;
+        player[c1].frame_tick = 0;
+        player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+    }
+}
+int map_tile(int pos_x, int pos_y)
+{
+int tile;
+pos_x = pos_x >> 4;
+pos_y = pos_y >> 4;
+if(pos_x < 0 || pos_x >= 17 || pos_y < 0 || pos_y >= 22)
+  return BAN_VOID;
+tile = ban_map[pos_y][pos_x];
+return tile;
+}
+void cpu_move(void)
+{
+        int lm, rm, jm;
+        int i, j;
+        int cur_posx, cur_posy, tar_posx, tar_posy;
+        int players_distance;
+        player_t* target = NULL;
+        int nearest_distance = -1;
+        for (i = 0; i < JNB_MAX_PLAYERS; i++)
+                {
+          nearest_distance = -1;
+                if(ai[i] && player[i].enabled)          // this player is a computer
+                        {               // get nearest target
+                        for (j = 0; j < JNB_MAX_PLAYERS; j++)
+                                {
+                                int deltax, deltay;
+                                if(i == j || !player[j].enabled)
+                                        continue;
+                                deltax = player[j].x - player[i].x;
+                                deltay = player[j].y - player[i].y;
+                                players_distance = deltax*deltax + deltay*deltay;
+                                if (players_distance < nearest_distance || nearest_distance == -1)
+                                        {
+                                        target = &player[j];
+                                        nearest_distance = players_distance;
+                                        }
+                                }
+                        if(target == NULL)
+                                continue;
+                        cur_posx = player[i].x >> 16;
+                        cur_posy = player[i].y >> 16;
+                        tar_posx = target->x >> 16;
+                        tar_posy = target->y >> 16;
+                        /** nearest player found, get him */
+                        /* here goes the artificial intelligence code */
+                        /* X-axis movement */
+                        if(tar_posx > cur_posx)       // if true target is on the right side
+                                {    // go after him
+                                lm=0;
+                                rm=1;
+                                }
+                        else    // target on the left side
+                                {
+                                lm=1;
+                                rm=0;
+                                }
+                        if(cur_posy - tar_posy < 32 && cur_posy - tar_posy > 0 &&
+              tar_posx - cur_posx < 32+8 && tar_posx - cur_posx > -32)
+                                {
+                                lm = !lm;
+                                rm = !rm;
+                                }
+                        else if(tar_posx - cur_posx < 4+8 && tar_posx - cur_posx > -4)
+                                {      // makes the bunnies less "nervous"
+                                lm=0;
+                                lm=0;
+                                }
+                        /* Y-axis movement */
+                        if(map_tile(cur_posx, cur_posy+16) != BAN_VOID &&
+                                ((i == 0 && key_pressed(KEY_PL1_JUMP)) ||
+                                (i == 1 && key_pressed(KEY_PL2_JUMP)) ||
+                                (i == 2 && key_pressed(KEY_PL3_JUMP)) ||
+                                (i == 3 && key_pressed(KEY_PL4_JUMP))))
+                                        jm=0;   // if we are on ground and jump key is being pressed,
+                                                                        //first we have to release it or else we won't be able to jump more than once
+                        else if(map_tile(cur_posx, cur_posy-8) != BAN_VOID &&
+                                map_tile(cur_posx, cur_posy-8) != BAN_WATER)
+                                        jm=0;   // don't jump if there is something over it
+                        else if(map_tile(cur_posx-(lm*8)+(rm*16), cur_posy) != BAN_VOID &&
+                                map_tile(cur_posx-(lm*8)+(rm*16), cur_posy) != BAN_WATER &&
+                                cur_posx > 16 && cur_posx < 352-16-8)  // obstacle, jump
+                                        jm=1;   // if there is something on the way, jump over it
+                        else if(((i == 0 && key_pressed(KEY_PL1_JUMP)) ||
+                                                        (i == 1 && key_pressed(KEY_PL2_JUMP)) ||
+                                                        (i == 2 && key_pressed(KEY_PL3_JUMP)) ||
+                                                        (i == 3 && key_pressed(KEY_PL4_JUMP))) &&
+                                                        (map_tile(cur_posx-(lm*8)+(rm*16), cur_posy+8) != BAN_VOID &&
+                                                        map_tile(cur_posx-(lm*8)+(rm*16), cur_posy+8) != BAN_WATER))
+                                        jm=1;   // this makes it possible to jump over 2 tiles
+                        else if(cur_posy - tar_posy < 32 && cur_posy - tar_posy > 0 &&
+              tar_posx - cur_posx < 32+8 && tar_posx - cur_posx > -32)  // don't jump - running away
+                                jm=0;
+                        else if(tar_posy <= cur_posy)   // target on the upper side
+                                jm=1;
+                        else   // target below
+                                jm=0;
+                        /** Artificial intelligence done, now apply movements */
+                        if(lm)
+                                {
+                                SDLKey key;
+                                if(i == 0)
+                                        key = KEY_PL1_LEFT;
+                                else if(i == 1)
+                                        key = KEY_PL2_LEFT;
+                                else if(i == 2)
+                                        key = KEY_PL3_LEFT;
+                                else
+                                        key = KEY_PL4_LEFT;
+                                key &= 0x7f;
+                                addkey(key);
+                                }
+                        else
+                                {
+                                SDLKey key;
+                                if(i == 0)
+                                        key = KEY_PL1_LEFT;
+                                else if(i == 1)
+                                        key = KEY_PL2_LEFT;
+                                else if(i == 2)
+                                        key = KEY_PL3_LEFT;
+                                else
+                                        key = KEY_PL4_LEFT;
+                                key &= 0x7f;
+                                addkey(key | 0x8000);
+                                }
+                        if(rm)
+                                {
+                                SDLKey key;
+                                if(i == 0)
+                                        key = KEY_PL1_RIGHT;
+                                else if(i == 1)
+                                        key = KEY_PL2_RIGHT;
+                                else if(i == 2)
+                                        key = KEY_PL3_RIGHT;
+                                else
+                                        key = KEY_PL4_RIGHT;
+                                key &= 0x7f;
+                                addkey(key);
+                                }
+                        else
+                                {
+                                SDLKey key;
+                                if(i == 0)
+                                        key = KEY_PL1_RIGHT;
+                                else if(i == 1)
+                                        key = KEY_PL2_RIGHT;
+                                else if(i == 2)
+                                        key = KEY_PL3_RIGHT;
+                                else
+                                        key = KEY_PL4_RIGHT;
+                                key &= 0x7f;
+                                addkey(key | 0x8000);
+                                }
+                        if(jm)
+                                {
+                                SDLKey key;
+                                if(i == 0)
+                                        key = KEY_PL1_JUMP;
+                                else if(i == 1)
+                                        key = KEY_PL2_JUMP;
+                                else if(i == 2)
+                                        key = KEY_PL3_JUMP;
+                                else
+                                        key = KEY_PL4_JUMP;
+                                key &= 0x7f;
+                                addkey(key);
+                                }
+                        else
+                                {
+                                SDLKey key;
+                                if(i == 0)
+                                        key = KEY_PL1_JUMP;
+                                else if(i == 1)
+                                        key = KEY_PL2_JUMP;
+                                else if(i == 2)
+                                        key = KEY_PL3_JUMP;
+                                else
+                                        key = KEY_PL4_JUMP;
+                                key &= 0x7f;
+                                addkey(key | 0x8000);
+                                }
+                        }
+                }
+}
+#define GET_BAN_MAP_IN_WATER(s1, s2) (GET_BAN_MAP_XY((s1), ((s2) + 7)) == BAN_VOID || GET_BAN_MAP_XY(((s1) + 15), ((s2) + 7)) == BAN_VOID) && (GET_BAN_MAP_XY((s1), ((s2) + 8)) == BAN_WATER || GET_BAN_MAP_XY(((s1) + 15), ((s2) + 8)) == BAN_WATER)
+void steer_players(void)
+{
+        int c1, c2;
+        int s1 = 0, s2 = 0;
+        cpu_move();
+        update_player_actions();
+        for (c1 = 0; c1 < JNB_MAX_PLAYERS; c1++) {
+                if (player[c1].enabled == 1) {
+                        if (player[c1].dead_flag == 0) {
+                                if (player[c1].action_left && player[c1].action_right) {
+                                        if (player[c1].direction == 0) {
+                                                if (player[c1].action_right) {
+                                                        player_action_right(c1);
+                                                }
+                                        } else {
+                                                if (player[c1].action_left) {
+                                                        player_action_left(c1);
+                                                }
+                                        }
+                                } else if (player[c1].action_left) {
+                                        player_action_left(c1);
+                                } else if (player[c1].action_right) {
+                                        player_action_right(c1);
+                                } else if ((!player[c1].action_left) && (!player[c1].action_right)) {
+                                        int below_left, below, below_right;
+                                        s1 = (player[c1].x >> 16);
+                                        s2 = (player[c1].y >> 16);
+                                        below_left = GET_BAN_MAP_XY(s1, s2 + 16);
+                                        below = GET_BAN_MAP_XY(s1 + 8, s2 + 16);
+                                        below_right = GET_BAN_MAP_XY(s1 + 15, s2 + 16);
+                                        if (below == BAN_SOLID || below == BAN_SPRING || (((below_left == BAN_SOLID || below_left == BAN_SPRING) && below_right != BAN_ICE) || (below_left != BAN_ICE && (below_right == BAN_SOLID || below_right == BAN_SPRING)))) {
+                                                if (player[c1].x_add < 0) {
+                                                        player[c1].x_add += 16384;
+                                                        if (player[c1].x_add > 0)
+                                                                player[c1].x_add = 0;
+                                                } else {
+                                                        player[c1].x_add -= 16384;
+                                                        if (player[c1].x_add < 0)
+                                                                player[c1].x_add = 0;
+                                                }
+                                                if (player[c1].x_add != 0 && GET_BAN_MAP_XY((s1 + 8), (s2 + 16)) == BAN_SOLID)
+                                                        add_object(OBJ_SMOKE, (player[c1].x >> 16) + 2 + rnd(9), (player[c1].y >> 16) + 13 + rnd(5), 0, -16384 - rnd(8192), OBJ_ANIM_SMOKE, 0);
+                                        }
+                                        if (player[c1].anim == 1) {
+                                                player[c1].anim = 0;
+                                                player[c1].frame = 0;
+                                                player[c1].frame_tick = 0;
+                                                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                        }
+                                }
+                                if (jetpack == 0) {
+                                        /* no jetpack */
+                                        if (pogostick == 1 || (player[c1].jump_ready == 1 && player[c1].action_up)) {
+                                                s1 = (player[c1].x >> 16);
+                                                s2 = (player[c1].y >> 16);
+                                                if (s2 < -16)
+                                                        s2 = -16;
+                                                /* jump */
+                                                if (GET_BAN_MAP_XY(s1, (s2 + 16)) == BAN_SOLID || GET_BAN_MAP_XY(s1, (s2 + 16)) == BAN_ICE || GET_BAN_MAP_XY((s1 + 15), (s2 + 16)) == BAN_SOLID || GET_BAN_MAP_XY((s1 + 15), (s2 + 16)) == BAN_ICE) {
+                                                        player[c1].y_add = -280000L;
+                                                        player[c1].anim = 2;
+                                                        player[c1].frame = 0;
+                                                        player[c1].frame_tick = 0;
+                                                        player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                                        player[c1].jump_ready = 0;
+                                                        player[c1].jump_abort = 1;
+                                                        if (pogostick == 0)
+                                                                dj_play_sfx(SFX_JUMP, (unsigned short)(SFX_JUMP_FREQ + rnd(2000) - 1000), 64, 0, 0, -1);
+                                                        else
+                                                                dj_play_sfx(SFX_SPRING, (unsigned short)(SFX_SPRING_FREQ + rnd(2000) - 1000), 64, 0, 0, -1);
+                                                }
+                                                /* jump out of water */
+                                                if (GET_BAN_MAP_IN_WATER(s1, s2)) {
+                                                        player[c1].y_add = -196608L;
+                                                        player[c1].in_water = 0;
+                                                        player[c1].anim = 2;
+                                                        player[c1].frame = 0;
+                                                        player[c1].frame_tick = 0;
+                                                        player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                                        player[c1].jump_ready = 0;
+                                                        player[c1].jump_abort = 1;
+                                                        if (pogostick == 0)
+                                                                dj_play_sfx(SFX_JUMP, (unsigned short)(SFX_JUMP_FREQ + rnd(2000) - 1000), 64, 0, 0, -1);
+                                                        else
+                                                                dj_play_sfx(SFX_SPRING, (unsigned short)(SFX_SPRING_FREQ + rnd(2000) - 1000), 64, 0, 0, -1);
+                                                }
+                                        }
+                                        /* fall down by gravity */
+                                        if (pogostick == 0 && (!player[c1].action_up)) {
+                                                player[c1].jump_ready = 1;
+                                                if (player[c1].in_water == 0 && player[c1].y_add < 0 && player[c1].jump_abort == 1) {
+                                                        if (bunnies_in_space == 0)
+                                                                /* normal gravity */
+                                                                player[c1].y_add += 32768;
+                                                        else
+                                                                /* light gravity */
+                                                                player[c1].y_add += 16384;
+                                                        if (player[c1].y_add > 0)
+                                                                player[c1].y_add = 0;
+                                                }
+                                        }
+                                } else {
+                                        /* with jetpack */
+                                        if (player[c1].action_up) {
+                                                player[c1].y_add -= 16384;
+                                                if (player[c1].y_add < -400000L)
+                                                        player[c1].y_add = -400000L;
+                                                if (GET_BAN_MAP_IN_WATER(s1, s2))
+                                                        player[c1].in_water = 0;
+                                                if (rnd(100) < 50)
+                                                        add_object(OBJ_SMOKE, (player[c1].x >> 16) + 6 + rnd(5), (player[c1].y >> 16) + 10 + rnd(5), 0, 16384 + rnd(8192), OBJ_ANIM_SMOKE, 0);
+                                        }
+                                }
+                                player[c1].x += player[c1].x_add;
+                                if ((player[c1].x >> 16) < 0) {
+                                        player[c1].x = 0;
+                                        player[c1].x_add = 0;
+                                }
+                                if ((player[c1].x >> 16) + 15 > 351) {
+                                        player[c1].x = 336L << 16;
+                                        player[c1].x_add = 0;
+                                }
+                                {
+                                        if (player[c1].y > 0) {
+                                                s2 = (player[c1].y >> 16);
+                                        } else {
+                                                /* check top line only */
+                                                s2 = 0;
+                                        }
+                                        s1 = (player[c1].x >> 16);
+                                        if (GET_BAN_MAP_XY(s1, s2) == BAN_SOLID || GET_BAN_MAP_XY(s1, s2) == BAN_ICE || GET_BAN_MAP_XY(s1, s2) == BAN_SPRING || GET_BAN_MAP_XY(s1, (s2 + 15)) == BAN_SOLID || GET_BAN_MAP_XY(s1, (s2 + 15)) == BAN_ICE || GET_BAN_MAP_XY(s1, (s2 + 15)) == BAN_SPRING) {
+                                                player[c1].x = (((s1 + 16) & 0xfff0)) << 16;
+                                                player[c1].x_add = 0;
+                                        }
+                                        s1 = (player[c1].x >> 16);
+                                        if (GET_BAN_MAP_XY((s1 + 15), s2) == BAN_SOLID || GET_BAN_MAP_XY((s1 + 15), s2) == BAN_ICE || GET_BAN_MAP_XY((s1 + 15), s2) == BAN_SPRING || GET_BAN_MAP_XY((s1 + 15), (s2 + 15)) == BAN_SOLID || GET_BAN_MAP_XY((s1 + 15), (s2 + 15)) == BAN_ICE || GET_BAN_MAP_XY((s1 + 15), (s2 + 15)) == BAN_SPRING) {
+                                                player[c1].x = (((s1 + 16) & 0xfff0) - 16) << 16;
+                                                player[c1].x_add = 0;
+                                        }
+                                }
+                                player[c1].y += player[c1].y_add;
+                                s1 = (player[c1].x >> 16);
+                                s2 = (player[c1].y >> 16);
+                                if (GET_BAN_MAP_XY((s1 + 8), (s2 + 15)) == BAN_SPRING || ((GET_BAN_MAP_XY(s1, (s2 + 15)) == BAN_SPRING && GET_BAN_MAP_XY((s1 + 15), (s2 + 15)) != BAN_SOLID) || (GET_BAN_MAP_XY(s1, (s2 + 15)) != BAN_SOLID && GET_BAN_MAP_XY((s1 + 15), (s2 + 15)) == BAN_SPRING))) {
+                                        player[c1].y = ((player[c1].y >> 16) & 0xfff0) << 16;
+                                        player[c1].y_add = -400000L;
+                                        player[c1].anim = 2;
+                                        player[c1].frame = 0;
+                                        player[c1].frame_tick = 0;
+                                        player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                        player[c1].jump_ready = 0;
+                                        player[c1].jump_abort = 0;
+                                        for (c2 = 0; c2 < NUM_OBJECTS; c2++) {
+                                                if (objects[c2].used == 1 && objects[c2].type == OBJ_SPRING) {
+                                                        if (GET_BAN_MAP_XY((s1 + 8), (s2 + 15)) == BAN_SPRING) {
+                                                                if ((objects[c2].x >> 20) == ((s1 + 8) >> 4) && (objects[c2].y >> 20) == ((s2 + 15) >> 4)) {
+                                                                        objects[c2].frame = 0;
+                                                                        objects[c2].ticks = object_anims[objects[c2].anim].frame[objects[c2].frame].ticks;
+                                                                        objects[c2].image = object_anims[objects[c2].anim].frame[objects[c2].frame].image;
+                                                                        break;
+                                                                }
+                                                        } else {
+                                                                if (GET_BAN_MAP_XY(s1, (s2 + 15)) == BAN_SPRING) {
+                                                                        if ((objects[c2].x >> 20) == (s1 >> 4) && (objects[c2].y >> 20) == ((s2 + 15) >> 4)) {
+                                                                                objects[c2].frame = 0;
+                                                                                objects[c2].ticks = object_anims[objects[c2].anim].frame[objects[c2].frame].ticks;
+                                                                                objects[c2].image = object_anims[objects[c2].anim].frame[objects[c2].frame].image;
+                                                                                break;
+                                                                        }
+                                                                } else if (GET_BAN_MAP_XY((s1 + 15), (s2 + 15)) == BAN_SPRING) {
+                                                                        if ((objects[c2].x >> 20) == ((s1 + 15) >> 4) && (objects[c2].y >> 20) == ((s2 + 15) >> 4)) {
+                                                                                objects[c2].frame = 0;
+                                                                                objects[c2].ticks = object_anims[objects[c2].anim].frame[objects[c2].frame].ticks;
+                                                                                objects[c2].image = object_anims[objects[c2].anim].frame[objects[c2].frame].image;
+                                                                                break;
+                                                                        }
+                                                                }
+                                                        }
+                                                }
+                                        }
+                                        dj_play_sfx(SFX_SPRING, (unsigned short)(SFX_SPRING_FREQ + rnd(2000) - 1000), 64, 0, 0, -1);
+                                }
+                                s1 = (player[c1].x >> 16);
+                                s2 = (player[c1].y >> 16);
+                                if (s2 < 0)
+                                        s2 = 0;
+                                if (GET_BAN_MAP_XY(s1, s2) == BAN_SOLID || GET_BAN_MAP_XY(s1, s2) == BAN_ICE || GET_BAN_MAP_XY(s1, s2) == BAN_SPRING || GET_BAN_MAP_XY((s1 + 15), s2) == BAN_SOLID || GET_BAN_MAP_XY((s1 + 15), s2) == BAN_ICE || GET_BAN_MAP_XY((s1 + 15), s2) == BAN_SPRING) {
+                                        player[c1].y = (((s2 + 16) & 0xfff0)) << 16;
+                                        player[c1].y_add = 0;
+                                        player[c1].anim = 0;
+                                        player[c1].frame = 0;
+                                        player[c1].frame_tick = 0;
+                                        player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                }
+                                s1 = (player[c1].x >> 16);
+                                s2 = (player[c1].y >> 16);
+                                if (s2 < 0)
+                                        s2 = 0;
+                                if (GET_BAN_MAP_XY((s1 + 8), (s2 + 8)) == BAN_WATER) {
+                                        if (player[c1].in_water == 0) {
+                                                /* falling into water */
+                                                player[c1].in_water = 1;
+                                                player[c1].anim = 4;
+                                                player[c1].frame = 0;
+                                                player[c1].frame_tick = 0;
+                                                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                                if (player[c1].y_add >= 32768) {
+                                                        add_object(OBJ_SPLASH, (player[c1].x >> 16) + 8, ((player[c1].y >> 16) & 0xfff0) + 15, 0, 0, OBJ_ANIM_SPLASH, 0);
+                                                        if (blood_is_thicker_than_water == 0)
+                                                                dj_play_sfx(SFX_SPLASH, (unsigned short)(SFX_SPLASH_FREQ + rnd(2000) - 1000), 64, 0, 0, -1);
+                                                        else
+                                                                dj_play_sfx(SFX_SPLASH, (unsigned short)(SFX_SPLASH_FREQ + rnd(2000) - 5000), 64, 0, 0, -1);
+                                                }
+                                        }
+                                        /* slowly move up to water surface */
+                                        player[c1].y_add -= 1536;
+                                        if (player[c1].y_add < 0 && player[c1].anim != 5) {
+                                                player[c1].anim = 5;
+                                                player[c1].frame = 0;
+                                                player[c1].frame_tick = 0;
+                                                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                        }
+                                        if (player[c1].y_add < -65536L)
+                                                player[c1].y_add = -65536L;
+                                        if (player[c1].y_add > 65535L)
+                                                player[c1].y_add = 65535L;
+                                        if (GET_BAN_MAP_XY(s1, (s2 + 15)) == BAN_SOLID || GET_BAN_MAP_XY(s1, (s2 + 15)) == BAN_ICE || GET_BAN_MAP_XY((s1 + 15), (s2 + 15)) == BAN_SOLID || GET_BAN_MAP_XY((s1 + 15), (s2 + 15)) == BAN_ICE) {
+                                                player[c1].y = (((s2 + 16) & 0xfff0) - 16) << 16;
+                                                player[c1].y_add = 0;
+                                        }
+                                } else if (GET_BAN_MAP_XY(s1, (s2 + 15)) == BAN_SOLID || GET_BAN_MAP_XY(s1, (s2 + 15)) == BAN_ICE || GET_BAN_MAP_XY(s1, (s2 + 15)) == BAN_SPRING || GET_BAN_MAP_XY((s1 + 15), (s2 + 15)) == BAN_SOLID || GET_BAN_MAP_XY((s1 + 15), (s2 + 15)) == BAN_ICE || GET_BAN_MAP_XY((s1 + 15), (s2 + 15)) == BAN_SPRING) {
+                                        player[c1].in_water = 0;
+                                        player[c1].y = (((s2 + 16) & 0xfff0) - 16) << 16;
+                                        player[c1].y_add = 0;
+                                        if (player[c1].anim != 0 && player[c1].anim != 1) {
+                                                player[c1].anim = 0;
+                                                player[c1].frame = 0;
+                                                player[c1].frame_tick = 0;
+                                                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                        }
+                                } else {
+                                        if (player[c1].in_water == 0) {
+                                                if (bunnies_in_space == 0)
+                                                        player[c1].y_add += 12288;
+                                                else
+                                                        player[c1].y_add += 6144;
+                                                if (player[c1].y_add > 327680L)
+                                                        player[c1].y_add = 327680L;
+                                        } else {
+                                                player[c1].y = (player[c1].y & 0xffff0000) + 0x10000;
+                                                player[c1].y_add = 0;
+                                        }
+                                        player[c1].in_water = 0;
+                                }
+                                if (player[c1].y_add > 36864 && player[c1].anim != 3 && player[c1].in_water == 0) {
+                                        player[c1].anim = 3;
+                                        player[c1].frame = 0;
+                                        player[c1].frame_tick = 0;
+                                        player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                }
+                        }
+                        player[c1].frame_tick++;
+                        if (player[c1].frame_tick >= player_anims[player[c1].anim].frame[player[c1].frame].ticks) {
+                                player[c1].frame++;
+                                if (player[c1].frame >= player_anims[player[c1].anim].num_frames) {
+                                        if (player[c1].anim != 6)
+                                                player[c1].frame = player_anims[player[c1].anim].restart_frame;
+                                        else
+                                                position_player(c1);
+                                }
+                                player[c1].frame_tick = 0;
+                        }
+                        player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                }
+        }
+}
+void position_player(int player_num)
+{
+        int c1;
+        int s1, s2;
+        while (1) {
+                while (1) {
+                        s1 = rnd(22);
+                        s2 = rnd(16);
+                        if (ban_map[s2][s1] == BAN_VOID && (ban_map[s2 + 1][s1] == BAN_SOLID || ban_map[s2 + 1][s1] == BAN_ICE))
+                                break;
+                }
+                for (c1 = 0; c1 < JNB_MAX_PLAYERS; c1++) {
+                        if (c1 != player_num && player[c1].enabled == 1) {
+                                if (abs((s1 << 4) - (player[c1].x >> 16)) < 32 && abs((s2 << 4) - (player[c1].y >> 16)) < 32)
+                                        break;
+                        }
+                }
+                if (c1 == JNB_MAX_PLAYERS) {
+                        player[player_num].x = (long) s1 << 20;
+                        player[player_num].y = (long) s2 << 20;
+                        player[player_num].x_add = player[player_num].y_add = 0;
+                        player[player_num].direction = 0;
+                        player[player_num].jump_ready = 1;
+                        player[player_num].in_water = 0;
+                        player[player_num].anim = 0;
+                        player[player_num].frame = 0;
+                        player[player_num].frame_tick = 0;
+                        player[player_num].image = player_anims[player[player_num].anim].frame[player[player_num].frame].image;
+                        if (is_server) {
+#ifdef USE_NET
+                                if (is_net)
+                                        serverSendAlive(player_num);
+#endif
+                                player[player_num].dead_flag = 0;
+                        }
+                        break;
+                }
+        }
+}
+void add_object(int type, int x, int y, int x_add, int y_add, int anim, int frame)
+{
+        int c1;
+        for (c1 = 0; c1 < NUM_OBJECTS; c1++) {
+                if (objects[c1].used == 0) {
+                        objects[c1].used = 1;
+                        objects[c1].type = type;
+                        objects[c1].x = (long) x << 16;
+                        objects[c1].y = (long) y << 16;
+                        objects[c1].x_add = x_add;
+                        objects[c1].y_add = y_add;
+                        objects[c1].x_acc = 0;
+                        objects[c1].y_acc = 0;
+                        objects[c1].anim = anim;
+                        objects[c1].frame = frame;
+                        objects[c1].ticks = object_anims[anim].frame[frame].ticks;
+                        objects[c1].image = object_anims[anim].frame[frame].image;
+                        break;
+                }
+        }
+}
+void update_objects(void)
+{
+        int c1;
+        int s1 = 0;
+        for (c1 = 0; c1 < NUM_OBJECTS; c1++) {
+                if (objects[c1].used == 1) {
+                        switch (objects[c1].type) {
+                        case OBJ_SPRING:
+                                objects[c1].ticks--;
+                                if (objects[c1].ticks <= 0) {
+                                        objects[c1].frame++;
+                                        if (objects[c1].frame >= object_anims[objects[c1].anim].num_frames) {
+                                                objects[c1].frame--;
+                                                objects[c1].ticks = object_anims[objects[c1].anim].frame[objects[c1].frame].ticks;
+                                        } else {
+                                                objects[c1].ticks = object_anims[objects[c1].anim].frame[objects[c1].frame].ticks;
+                                                objects[c1].image = object_anims[objects[c1].anim].frame[objects[c1].frame].image;
+                                        }
+                                }
+                                if (objects[c1].used == 1)
+                                        add_pob(main_info.draw_page, objects[c1].x >> 16, objects[c1].y >> 16, objects[c1].image, &object_gobs);
+                                break;
+                        case OBJ_SPLASH:
+                                objects[c1].ticks--;
+                                if (objects[c1].ticks <= 0) {
+                                        objects[c1].frame++;
+                                        if (objects[c1].frame >= object_anims[objects[c1].anim].num_frames)
+                                                objects[c1].used = 0;
+                                        else {
+                                                objects[c1].ticks = object_anims[objects[c1].anim].frame[objects[c1].frame].ticks;
+                                                objects[c1].image = object_anims[objects[c1].anim].frame[objects[c1].frame].image;
+                                        }
+                                }
+                                if (objects[c1].used == 1)
+                                        add_pob(main_info.draw_page, objects[c1].x >> 16, objects[c1].y >> 16, objects[c1].image, &object_gobs);
+                                break;
+                        case OBJ_SMOKE:
+                                objects[c1].x += objects[c1].x_add;
+                                objects[c1].y += objects[c1].y_add;
+                                objects[c1].ticks--;
+                                if (objects[c1].ticks <= 0) {
+                                        objects[c1].frame++;
+                                        if (objects[c1].frame >= object_anims[objects[c1].anim].num_frames)
+                                                objects[c1].used = 0;
+                                        else {
+                                                objects[c1].ticks = object_anims[objects[c1].anim].frame[objects[c1].frame].ticks;
+                                                objects[c1].image = object_anims[objects[c1].anim].frame[objects[c1].frame].image;
+                                        }
+                                }
+                                if (objects[c1].used == 1)
+                                        add_pob(main_info.draw_page, objects[c1].x >> 16, objects[c1].y >> 16, objects[c1].image, &object_gobs);
+                                break;
+                        case OBJ_YEL_BUTFLY:
+                        case OBJ_PINK_BUTFLY:
+                                objects[c1].x_acc += rnd(128) - 64;
+                                if (objects[c1].x_acc < -1024)
+                                        objects[c1].x_acc = -1024;
+                                if (objects[c1].x_acc > 1024)
+                                        objects[c1].x_acc = 1024;
+                                objects[c1].x_add += objects[c1].x_acc;
+                                if (objects[c1].x_add < -32768)
+                                        objects[c1].x_add = -32768;
+                                if (objects[c1].x_add > 32768)
+                                        objects[c1].x_add = 32768;
+                                objects[c1].x += objects[c1].x_add;
+                                if ((objects[c1].x >> 16) < 16) {
+                                        objects[c1].x = 16 << 16;
+                                        objects[c1].x_add = -objects[c1].x_add >> 2;
+                                        objects[c1].x_acc = 0;
+                                } else if ((objects[c1].x >> 16) > 350) {
+                                        objects[c1].x = 350 << 16;
+                                        objects[c1].x_add = -objects[c1].x_add >> 2;
+                                        objects[c1].x_acc = 0;
+                                }
+                                if (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] != 0) {
+                                        if (objects[c1].x_add < 0) {
+                                                objects[c1].x = (((objects[c1].x >> 16) + 16) & 0xfff0) << 16;
+                                        } else {
+                                                objects[c1].x = ((((objects[c1].x >> 16) - 16) & 0xfff0) + 15) << 16;
+                                        }
+                                        objects[c1].x_add = -objects[c1].x_add >> 2;
+                                        objects[c1].x_acc = 0;
+                                }
+                                objects[c1].y_acc += rnd(64) - 32;
+                                if (objects[c1].y_acc < -1024)
+                                        objects[c1].y_acc = -1024;
+                                if (objects[c1].y_acc > 1024)
+                                        objects[c1].y_acc = 1024;
+                                objects[c1].y_add += objects[c1].y_acc;
+                                if (objects[c1].y_add < -32768)
+                                        objects[c1].y_add = -32768;
+                                if (objects[c1].y_add > 32768)
+                                        objects[c1].y_add = 32768;
+                                objects[c1].y += objects[c1].y_add;
+                                if ((objects[c1].y >> 16) < 0) {
+                                        objects[c1].y = 0;
+                                        objects[c1].y_add = -objects[c1].y_add >> 2;
+                                        objects[c1].y_acc = 0;
+                                } else if ((objects[c1].y >> 16) > 255) {
+                                        objects[c1].y = 255 << 16;
+                                        objects[c1].y_add = -objects[c1].y_add >> 2;
+                                        objects[c1].y_acc = 0;
+                                }
+                                if (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] != 0) {
+                                        if (objects[c1].y_add < 0) {
+                                                objects[c1].y = (((objects[c1].y >> 16) + 16) & 0xfff0) << 16;
+                                        } else {
+                                                objects[c1].y = ((((objects[c1].y >> 16) - 16) & 0xfff0) + 15) << 16;
+                                        }
+                                        objects[c1].y_add = -objects[c1].y_add >> 2;
+                                        objects[c1].y_acc = 0;
+                                }
+                                if (objects[c1].type == OBJ_YEL_BUTFLY) {
+                                        if (objects[c1].x_add < 0 && objects[c1].anim != OBJ_ANIM_YEL_BUTFLY_LEFT) {
+                                                objects[c1].anim = OBJ_ANIM_YEL_BUTFLY_LEFT;
+                                                objects[c1].frame = 0;
+                                                objects[c1].ticks = object_anims[objects[c1].anim].frame[objects[c1].frame].ticks;
+                                                objects[c1].image = object_anims[objects[c1].anim].frame[objects[c1].frame].image;
+                                        } else if (objects[c1].x_add > 0 && objects[c1].anim != OBJ_ANIM_YEL_BUTFLY_RIGHT) {
+                                                objects[c1].anim = OBJ_ANIM_YEL_BUTFLY_RIGHT;
+                                                objects[c1].frame = 0;
+                                                objects[c1].ticks = object_anims[objects[c1].anim].frame[objects[c1].frame].ticks;
+                                                objects[c1].image = object_anims[objects[c1].anim].frame[objects[c1].frame].image;
+                                        }
+                                } else {
+                                        if (objects[c1].x_add < 0 && objects[c1].anim != OBJ_ANIM_PINK_BUTFLY_LEFT) {
+                                                objects[c1].anim = OBJ_ANIM_PINK_BUTFLY_LEFT;
+                                                objects[c1].frame = 0;
+                                                objects[c1].ticks = object_anims[objects[c1].anim].frame[objects[c1].frame].ticks;
+                                                objects[c1].image = object_anims[objects[c1].anim].frame[objects[c1].frame].image;
+                                        } else if (objects[c1].x_add > 0 && objects[c1].anim != OBJ_ANIM_PINK_BUTFLY_RIGHT) {
+                                                objects[c1].anim = OBJ_ANIM_PINK_BUTFLY_RIGHT;
+                                                objects[c1].frame = 0;
+                                                objects[c1].ticks = object_anims[objects[c1].anim].frame[objects[c1].frame].ticks;
+                                                objects[c1].image = object_anims[objects[c1].anim].frame[objects[c1].frame].image;
+                                        }
+                                }
+                                objects[c1].ticks--;
+                                if (objects[c1].ticks <= 0) {
+                                        objects[c1].frame++;
+                                        if (objects[c1].frame >= object_anims[objects[c1].anim].num_frames)
+                                                objects[c1].frame = object_anims[objects[c1].anim].restart_frame;
+                                        else {
+                                                objects[c1].ticks = object_anims[objects[c1].anim].frame[objects[c1].frame].ticks;
+                                                objects[c1].image = object_anims[objects[c1].anim].frame[objects[c1].frame].image;
+                                        }
+                                }
+                                if (objects[c1].used == 1)
+                                        add_pob(main_info.draw_page, objects[c1].x >> 16, objects[c1].y >> 16, objects[c1].image, &object_gobs);
+                                break;
+                        case OBJ_FUR:
+                                if (rnd(100) < 30)
+                                        add_object(OBJ_FLESH_TRACE, objects[c1].x >> 16, objects[c1].y >> 16, 0, 0, OBJ_ANIM_FLESH_TRACE, 0);
+                                if (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] == 0) {
+                                        objects[c1].y_add += 3072;
+                                        if (objects[c1].y_add > 196608L)
+                                                objects[c1].y_add = 196608L;
+                                } else if (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] == 2) {
+                                        if (objects[c1].x_add < 0) {
+                                                if (objects[c1].x_add < -65536L)
+                                                        objects[c1].x_add = -65536L;
+                                                objects[c1].x_add += 1024;
+                                                if (objects[c1].x_add > 0)
+                                                        objects[c1].x_add = 0;
+                                        } else {
+                                                if (objects[c1].x_add > 65536L)
+                                                        objects[c1].x_add = 65536L;
+                                                objects[c1].x_add -= 1024;
+                                                if (objects[c1].x_add < 0)
+                                                        objects[c1].x_add = 0;
+                                        }
+                                        objects[c1].y_add += 1024;
+                                        if (objects[c1].y_add < -65536L)
+                                                objects[c1].y_add = -65536L;
+                                        if (objects[c1].y_add > 65536L)
+                                                objects[c1].y_add = 65536L;
+                                }
+                                objects[c1].x += objects[c1].x_add;
+                                if ((objects[c1].y >> 16) > 0 && (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] == 1 || ban_map[objects[c1].y >> 20][objects[c1].x >> 20] == 3)) {
+                                        if (objects[c1].x_add < 0) {
+                                                objects[c1].x = (((objects[c1].x >> 16) + 16) & 0xfff0) << 16;
+                                                objects[c1].x_add = -objects[c1].x_add >> 2;
+                                        } else {
+                                                objects[c1].x = ((((objects[c1].x >> 16) - 16) & 0xfff0) + 15) << 16;
+                                                objects[c1].x_add = -objects[c1].x_add >> 2;
+                                        }
+                                }
+                                objects[c1].y += objects[c1].y_add;
+                                if ((objects[c1].x >> 16) < -5 || (objects[c1].x >> 16) > 405 || (objects[c1].y >> 16) > 260)
+                                        objects[c1].used = 0;
+                                if ((objects[c1].y >> 16) > 0 && (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] != 0)) {
+                                        if (objects[c1].y_add < 0) {
+                                                if (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] != 2) {
+                                                        objects[c1].y = (((objects[c1].y >> 16) + 16) & 0xfff0) << 16;
+                                                        objects[c1].x_add >>= 2;
+                                                        objects[c1].y_add = -objects[c1].y_add >> 2;
+                                                }
+                                        } else {
+                                                if (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] == 1) {
+                                                        if (objects[c1].y_add > 131072L) {
+                                                                objects[c1].y = ((((objects[c1].y >> 16) - 16) & 0xfff0) + 15) << 16;
+                                                                objects[c1].x_add >>= 2;
+                                                                objects[c1].y_add = -objects[c1].y_add >> 2;
+                                                        } else
+                                                                objects[c1].used = 0;
+                                                } else if (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] == 3) {
+                                                        objects[c1].y = ((((objects[c1].y >> 16) - 16) & 0xfff0) + 15) << 16;
+                                                        if (objects[c1].y_add > 131072L)
+                                                                objects[c1].y_add = -objects[c1].y_add >> 2;
+                                                        else
+                                                                objects[c1].y_add = 0;
+                                                }
+                                        }
+                                }
+                                if (objects[c1].x_add < 0 && objects[c1].x_add > -16384)
+                                        objects[c1].x_add = -16384;
+                                if (objects[c1].x_add > 0 && objects[c1].x_add < 16384)
+                                        objects[c1].x_add = 16384;
+                                if (objects[c1].used == 1) {
+                                        s1 = (int)(atan2(objects[c1].y_add, objects[c1].x_add) * 4 / M_PI);
+                                        if (s1 < 0)
+                                                s1 += 8;
+                                        if (s1 < 0)
+                                                s1 = 0;
+                                        if (s1 > 7)
+                                                s1 = 7;
+                                        add_pob(main_info.draw_page, objects[c1].x >> 16, objects[c1].y >> 16, objects[c1].frame + s1, &object_gobs);
+                                }
+                                break;
+                        case OBJ_FLESH:
+                                if (rnd(100) < 30) {
+                                        if (objects[c1].frame == 76)
+                                                add_object(OBJ_FLESH_TRACE, objects[c1].x >> 16, objects[c1].y >> 16, 0, 0, OBJ_ANIM_FLESH_TRACE, 1);
+                                        else if (objects[c1].frame == 77)
+                                                add_object(OBJ_FLESH_TRACE, objects[c1].x >> 16, objects[c1].y >> 16, 0, 0, OBJ_ANIM_FLESH_TRACE, 2);
+                                        else if (objects[c1].frame == 78)
+                                                add_object(OBJ_FLESH_TRACE, objects[c1].x >> 16, objects[c1].y >> 16, 0, 0, OBJ_ANIM_FLESH_TRACE, 3);
+                                }
+                                if (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] == 0) {
+                                        objects[c1].y_add += 3072;
+                                        if (objects[c1].y_add > 196608L)
+                                                objects[c1].y_add = 196608L;
+                                } else if (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] == 2) {
+                                        if (objects[c1].x_add < 0) {
+                                                if (objects[c1].x_add < -65536L)
+                                                        objects[c1].x_add = -65536L;
+                                                objects[c1].x_add += 1024;
+                                                if (objects[c1].x_add > 0)
+                                                        objects[c1].x_add = 0;
+                                        } else {
+                                                if (objects[c1].x_add > 65536L)
+                                                        objects[c1].x_add = 65536L;
+                                                objects[c1].x_add -= 1024;
+                                                if (objects[c1].x_add < 0)
+                                                        objects[c1].x_add = 0;
+                                        }
+                                        objects[c1].y_add += 1024;
+                                        if (objects[c1].y_add < -65536L)
+                                                objects[c1].y_add = -65536L;
+                                        if (objects[c1].y_add > 65536L)
+                                                objects[c1].y_add = 65536L;
+                                }
+                                objects[c1].x += objects[c1].x_add;
+                                if ((objects[c1].y >> 16) > 0 && (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] == 1 || ban_map[objects[c1].y >> 20][objects[c1].x >> 20] == 3)) {
+                                        if (objects[c1].x_add < 0) {
+                                                objects[c1].x = (((objects[c1].x >> 16) + 16) & 0xfff0) << 16;
+                                                objects[c1].x_add = -objects[c1].x_add >> 2;
+                                        } else {
+                                                objects[c1].x = ((((objects[c1].x >> 16) - 16) & 0xfff0) + 15) << 16;
+                                                objects[c1].x_add = -objects[c1].x_add >> 2;
+                                        }
+                                }
+                                objects[c1].y += objects[c1].y_add;
+                                if ((objects[c1].x >> 16) < -5 || (objects[c1].x >> 16) > 405 || (objects[c1].y >> 16) > 260)
+                                        objects[c1].used = 0;
+                                if ((objects[c1].y >> 16) > 0 && (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] != 0)) {
+                                        if (objects[c1].y_add < 0) {
+                                                if (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] != 2) {
+                                                        objects[c1].y = (((objects[c1].y >> 16) + 16) & 0xfff0) << 16;
+                                                        objects[c1].x_add >>= 2;
+                                                        objects[c1].y_add = -objects[c1].y_add >> 2;
+                                                }
+                                        } else {
+                                                if (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] == 1) {
+                                                        if (objects[c1].y_add > 131072L) {
+                                                                objects[c1].y = ((((objects[c1].y >> 16) - 16) & 0xfff0) + 15) << 16;
+                                                                objects[c1].x_add >>= 2;
+                                                                objects[c1].y_add = -objects[c1].y_add >> 2;
+                                                        } else {
+                                                                if (rnd(100) < 10) {
+                                                                        s1 = rnd(4) - 2;
+                                                                        add_leftovers(0, objects[c1].x >> 16, (objects[c1].y >> 16) + s1, objects[c1].frame, &object_gobs);
+                                                                        add_leftovers(1, objects[c1].x >> 16, (objects[c1].y >> 16) + s1, objects[c1].frame, &object_gobs);
+                                                                }
+                                                                objects[c1].used = 0;
+                                                        }
+                                                } else if (ban_map[objects[c1].y >> 20][objects[c1].x >> 20] == 3) {
+                                                        objects[c1].y = ((((objects[c1].y >> 16) - 16) & 0xfff0) + 15) << 16;
+                                                        if (objects[c1].y_add > 131072L)
+                                                                objects[c1].y_add = -objects[c1].y_add >> 2;
+                                                        else
+                                                                objects[c1].y_add = 0;
+                                                }
+                                        }
+                                }
+                                if (objects[c1].x_add < 0 && objects[c1].x_add > -16384)
+                                        objects[c1].x_add = -16384;
+                                if (objects[c1].x_add > 0 && objects[c1].x_add < 16384)
+                                        objects[c1].x_add = 16384;
+                                if (objects[c1].used == 1)
+                                        add_pob(main_info.draw_page, objects[c1].x >> 16, objects[c1].y >> 16, objects[c1].frame, &object_gobs);
+                                break;
+                        case OBJ_FLESH_TRACE:
+                                objects[c1].ticks--;
+                                if (objects[c1].ticks <= 0) {
+                                        objects[c1].frame++;
+                                        if (objects[c1].frame >= object_anims[objects[c1].anim].num_frames)
+                                                objects[c1].used = 0;
+                                        else {
+                                                objects[c1].ticks = object_anims[objects[c1].anim].frame[objects[c1].frame].ticks;
+                                                objects[c1].image = object_anims[objects[c1].anim].frame[objects[c1].frame].image;
+                                        }
+                                }
+                                if (objects[c1].used == 1)
+                                        add_pob(main_info.draw_page, objects[c1].x >> 16, objects[c1].y >> 16, objects[c1].image, &object_gobs);
+                                break;
+                        }
+                }
+        }
+}
+int add_pob(int page, int x, int y, int image, gob_t *pob_data)
+{
+        if (main_info.page_info[page].num_pobs >= NUM_POBS)
+                return 1;
+        main_info.page_info[page].pobs[main_info.page_info[page].num_pobs].x = x;
+        main_info.page_info[page].pobs[main_info.page_info[page].num_pobs].y = y;
+        main_info.page_info[page].pobs[main_info.page_info[page].num_pobs].image = image;
+        main_info.page_info[page].pobs[main_info.page_info[page].num_pobs].pob_data = pob_data;
+        main_info.page_info[page].num_pobs++;
+        return 0;
+}
+void draw_flies(int page)
+{
+        int c2;
+        for (c2 = 0; c2 < NUM_FLIES; c2++) {
+                flies[c2].back[main_info.draw_page] = get_pixel(main_info.draw_page, flies[c2].x, flies[c2].y);
+                flies[c2].back_defined[main_info.draw_page] = 1;
+                if (mask_pic[(flies[c2].y * JNB_WIDTH) + flies[c2].x] == 0)
+                        set_pixel(main_info.draw_page, flies[c2].x, flies[c2].y, 0);
+        }
+}
+void draw_pobs(int page)
+{
+        int c1;
+        int back_buf_ofs;
+        back_buf_ofs = 0;
+        for (c1 = main_info.page_info[page].num_pobs - 1; c1 >= 0; c1--) {
+                main_info.page_info[page].pobs[c1].back_buf_ofs = back_buf_ofs;
+                get_block(page, main_info.page_info[page].pobs[c1].x - pob_hs_x(main_info.page_info[page].pobs[c1].image, main_info.page_info[page].pobs[c1].pob_data), main_info.page_info[page].pobs[c1].y - pob_hs_y(main_info.page_info[page].pobs[c1].image, main_info.page_info[page].pobs[c1].pob_data), pob_width(main_info.page_info[page].pobs[c1].image, main_info.page_info[page].pobs[c1].pob_data), pob_height(main_info.page_info[page].pobs[c1].image, main_info.page_info[page].pobs[c1].pob_data), (unsigned char *)main_info.pob_backbuf[page] + back_buf_ofs);
+                if (scale_up)
+                        back_buf_ofs += pob_width(main_info.page_info[page].pobs[c1].image, main_info.page_info[page].pobs[c1].pob_data) * pob_height(main_info.page_info[page].pobs[c1].image, main_info.page_info[page].pobs[c1].pob_data) * 4;
+                else
+                        back_buf_ofs += pob_width(main_info.page_info[page].pobs[c1].image, main_info.page_info[page].pobs[c1].pob_data) * pob_height(main_info.page_info[page].pobs[c1].image, main_info.page_info[page].pobs[c1].pob_data);
+                put_pob(page, main_info.page_info[page].pobs[c1].x, main_info.page_info[page].pobs[c1].y, main_info.page_info[page].pobs[c1].image, main_info.page_info[page].pobs[c1].pob_data, 1, mask_pic);
+        }
+}
+void redraw_flies_background(int page)
+{
+        int c2;
+        for (c2 = NUM_FLIES - 1; c2 >= 0; c2--) {
+                if (flies[c2].back_defined[page] == 1)
+                        set_pixel(page, flies[c2].old_draw_x, flies[c2].old_draw_y, flies[c2].back[page]);
+                flies[c2].old_draw_x = flies[c2].x;
+                flies[c2].old_draw_y = flies[c2].y;
+        }
+}
+void redraw_pob_backgrounds(int page)
+{
+        int c1;
+        for (c1 = 0; c1 < main_info.page_info[page].num_pobs; c1++)
+                put_block(page, main_info.page_info[page].pobs[c1].x - pob_hs_x(main_info.page_info[page].pobs[c1].image, main_info.page_info[page].pobs[c1].pob_data), main_info.page_info[page].pobs[c1].y - pob_hs_y(main_info.page_info[page].pobs[c1].image, main_info.page_info[page].pobs[c1].pob_data), pob_width(main_info.page_info[page].pobs[c1].image, main_info.page_info[page].pobs[c1].pob_data), pob_height(main_info.page_info[page].pobs[c1].image, main_info.page_info[page].pobs[c1].pob_data), (unsigned char *)main_info.pob_backbuf[page] + main_info.page_info[page].pobs[c1].back_buf_ofs);
+}
+int add_leftovers(int page, int x, int y, int image, gob_t *pob_data)
+{
+        if (leftovers.page[page].num_pobs >= NUM_LEFTOVERS)
+                return 1;
+        leftovers.page[page].pobs[leftovers.page[page].num_pobs].x = x;
+        leftovers.page[page].pobs[leftovers.page[page].num_pobs].y = y;
+        leftovers.page[page].pobs[leftovers.page[page].num_pobs].image = image;
+        leftovers.page[page].pobs[leftovers.page[page].num_pobs].pob_data = pob_data;
+        leftovers.page[page].num_pobs++;
+        return 0;
+}
+void draw_leftovers(int page)
+{
+        int c1;
+        for (c1 = leftovers.page[page].num_pobs - 1; c1 >= 0; c1--)
+                put_pob(page, leftovers.page[page].pobs[c1].x, leftovers.page[page].pobs[c1].y, leftovers.page[page].pobs[c1].image, leftovers.page[page].pobs[c1].pob_data, 1, mask_pic);
+        leftovers.page[page].num_pobs = 0;
+}
+int init_level(int level, char *pal)
+{
+        unsigned char *handle;
+        int c1, c2;
+        int s1, s2;
+        if ((handle = dat_open("level.pcx")) == 0) {
+                strcpy(main_info.error_str, "Error loading 'level.pcx', aborting...\n");
+                return 1;
+        }
+        if (read_pcx(handle, background_pic, JNB_WIDTH*JNB_HEIGHT, pal) != 0) {
+                strcpy(main_info.error_str, "Error loading 'level.pcx', aborting...\n");
+                return 1;
+        }
+        if (flip)
+                flip_pixels(background_pic);
+        if ((handle = dat_open("mask.pcx")) == 0) {
+                strcpy(main_info.error_str, "Error loading 'mask.pcx', aborting...\n");
+                return 1;
+        }
+        if (read_pcx(handle, mask_pic, JNB_WIDTH*JNB_HEIGHT, 0) != 0) {
+                strcpy(main_info.error_str, "Error loading 'mask.pcx', aborting...\n");
+                return 1;
+        }
+        if (flip)
+                flip_pixels(mask_pic);
+        register_mask(mask_pic);
+        for (c1 = 0; c1 < JNB_MAX_PLAYERS; c1++) {
+                if (player[c1].enabled == 1) {
+                        player[c1].bumps = 0;
+                        for (c2 = 0; c2 < JNB_MAX_PLAYERS; c2++)
+                                player[c1].bumped[c2] = 0;
+                        position_player(c1);
+                }
+        }
+        for (c1 = 0; c1 < NUM_OBJECTS; c1++)
+                objects[c1].used = 0;
+        for (c1 = 0; c1 < 16; c1++) {
+                for (c2 = 0; c2 < 22; c2++) {
+                        if (ban_map[c1][c2] == BAN_SPRING)
+                                add_object(OBJ_SPRING, c2 << 4, c1 << 4, 0, 0, OBJ_ANIM_SPRING, 5);
+                }
+        }
+        while (1) {
+                s1 = rnd(22);
+                s2 = rnd(16);
+                if (ban_map[s2][s1] == BAN_VOID) {
+                        add_object(OBJ_YEL_BUTFLY, (s1 << 4) + 8, (s2 << 4) + 8, (rnd(65535) - 32768) * 2, (rnd(65535) - 32768) * 2, 0, 0);
+                        break;
+                }
+        }
+        while (1) {
+                s1 = rnd(22);
+                s2 = rnd(16);
+                if (ban_map[s2][s1] == BAN_VOID) {
+                        add_object(OBJ_YEL_BUTFLY, (s1 << 4) + 8, (s2 << 4) + 8, (rnd(65535) - 32768) * 2, (rnd(65535) - 32768) * 2, 0, 0);
+                        break;
+                }
+        }
+        while (1) {
+                s1 = rnd(22);
+                s2 = rnd(16);
+                if (ban_map[s2][s1] == BAN_VOID) {
+                        add_object(OBJ_PINK_BUTFLY, (s1 << 4) + 8, (s2 << 4) + 8, (rnd(65535) - 32768) * 2, (rnd(65535) - 32768) * 2, 0, 0);
+                        break;
+                }
+        }
+        while (1) {
+                s1 = rnd(22);
+                s2 = rnd(16);
+                if (ban_map[s2][s1] == BAN_VOID) {
+                        add_object(OBJ_PINK_BUTFLY, (s1 << 4) + 8, (s2 << 4) + 8, (rnd(65535) - 32768) * 2, (rnd(65535) - 32768) * 2, 0, 0);
+                        break;
+                }
+        }
+        return 0;
+}
+void deinit_level(void)
+{
+        dj_set_nosound(1);
+        dj_stop_mod();
+}
+#ifndef PATH_MAX
+#define PATH_MAX 1024
+#endif
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+unsigned char *datafile_buffer = NULL;
+static void preread_datafile(const char *fname)
+{
+    int fd = 0;
+    int len;
+#ifdef ZLIB_SUPPORT
+    char *gzfilename;
+    gzFile gzf;
+#endif
+#ifdef BZLIB_SUPPORT
+    char *bzfilename;
+    BZFILE *bzf;
+#endif
+#ifdef BZLIB_SUPPORT
+    bzfilename = malloc(strlen(fname) + 5);
+    strcpy(bzfilename, fname);
+    strcat(bzfilename, ".bz2");
+    bzf = BZ2_bzopen(bzfilename, "rb");
+    free(bzfilename);
+    bzfilename = NULL;
+    if (bzf != NULL) {
+        int bufsize = 0;
+        int bufpos = 0;
+        int br;
+        unsigned char *ptr;
+        do {
+            if (bufpos >= bufsize) {
+                bufsize += 1024 * 1024;
+                datafile_buffer = (unsigned char *) realloc(datafile_buffer, bufsize);
+                if (datafile_buffer == NULL) {
+                    perror("realloc()");
+                    exit(42);
+                }
+            }
+            br = BZ2_bzread(bzf, datafile_buffer + bufpos, bufsize - bufpos);
+            if (br == -1) {
+                fprintf(stderr, "gzread failed.\n");
+                exit(42);
+            }
+            bufpos += br;
+        } while (br>0);
+        /* try to shrink buffer... */
+        ptr = (unsigned char *) realloc(datafile_buffer, bufpos);
+        if (ptr != NULL)
+            datafile_buffer = ptr;
+        BZ2_bzclose(bzf);
+        return;
+    }
+    /* drop through and try for an gzip compressed or uncompressed datafile... */
+#endif
+#ifdef ZLIB_SUPPORT
+    gzfilename = malloc(strlen(fname) + 4);
+    strcpy(gzfilename, fname);
+    strcat(gzfilename, ".gz");
+    gzf = gzopen(gzfilename, "rb");
+    free(gzfilename);
+    gzfilename = NULL;
+    if (gzf != NULL) {
+        int bufsize = 0;
+        int bufpos = 0;
+        unsigned char *ptr;
+        do {
+            int br;
+            if (bufpos >= bufsize) {
+                bufsize += 1024 * 1024;
+                datafile_buffer = (unsigned char *) realloc(datafile_buffer, bufsize);
+                if (datafile_buffer == NULL) {
+                    perror("realloc()");
+                    exit(42);
+                }
+            }
+            br = gzread(gzf, datafile_buffer + bufpos, bufsize - bufpos);
+            if (br == -1) {
+                fprintf(stderr, "gzread failed.\n");
+                exit(42);
+            }
+            bufpos += br;
+        } while (!gzeof(gzf));
+        /* try to shrink buffer... */
+        ptr = (unsigned char *) realloc(datafile_buffer, bufpos);
+        if (ptr != NULL)
+            datafile_buffer = ptr;
+        gzclose(gzf);
+        return;
+    }
+    /* drop through and try for an uncompressed datafile... */
+#endif
+    fd = open(fname, O_RDONLY | O_BINARY);
+    if (fd == -1) {
+        fprintf(stderr, "can't open %s:", fname);
+        perror("");
+        exit(42);
+    }
+    len = filelength(fd);
+    datafile_buffer = (unsigned char *) malloc(len);
+    if (datafile_buffer == NULL) {
+        perror("malloc()");
+        close(fd);
+        exit(42);
+    }
+    if (read(fd, datafile_buffer, len) != len) {
+        perror("read()");
+        close(fd);
+        exit(42);
+    }
+    close(fd);
+}
+int init_program(int argc, char *argv[], char *pal)
+{
+        char *netarg = NULL;
+        unsigned char *handle = (unsigned char *) NULL;
+        int c1 = 0, c2 = 0;
+        int load_flag = 0;
+        int force2, force3;
+        sfx_data fly;
+        int player_anim_data[] = {
+, 0, 0, 0x7fff, 0, 0, 0, 0, 0, 0,
+, 0, 0, 4, 1, 4, 2, 4, 3, 4,
+, 0, 4, 0x7fff, 0, 0, 0, 0, 0, 0,
+, 2, 5, 8, 6, 10, 7, 3, 6, 3,
+, 0, 6, 0x7fff, 0, 0, 0, 0, 0, 0,
+, 1, 5, 8, 4, 0x7fff, 0, 0, 0, 0,
+, 0, 8, 5, 0, 0, 0, 0, 0, 0
+        };
+#ifdef USE_NET
+        memset(&net_info, 0, sizeof(net_info));
+#endif
+#ifdef DOS
+        if (__djgpp_nearptr_enable() == 0)
+                return 1;
+#endif
+        srand(time(NULL));
+        if (hook_keyb_handler() != 0)
+                return 1;
+        memset(&main_info, 0, sizeof(main_info));
+        strcpy(datfile_name, DATA_PATH);
+        force2 = force3 = 0;
+        if (argc > 1) {
+                for (c1 = 1; c1 < argc; c1++) {
+                        if (stricmp(argv[c1], "-nosound") == 0)
+                                main_info.no_sound = 1;
+                        else if (stricmp(argv[c1], "-musicnosound") == 0)
+                                main_info.music_no_sound = 1;
+                        else if (stricmp(argv[c1], "-nogore") == 0)
+                                main_info.no_gore = 1;
+                        else if (stricmp(argv[c1], "-noflies") == 0)
+                                flies_enabled = 0;
+                        else if (stricmp(argv[c1], "-nojoy") == 0)
+                                main_info.joy_enabled = 0;
+                        else if (stricmp(argv[c1], "-fireworks") == 0)
+                                main_info.fireworks = 1;
+#ifdef USE_SDL
+                        else if (stricmp(argv[c1], "-fullscreen") == 0)
+                                fs_toggle();
+#endif
+                        else if (stricmp(argv[c1], "-scaleup") == 0)
+                                set_scaling(1);
+                        else if (stricmp(argv[c1], "-mirror") == 0)
+                                flip = 1;
+                        else if (stricmp(argv[c1], "-dat") == 0) {
+                                if (c1 < (argc - 1)) {
+                                        FILE *f;
+                                        if ((f = fopen(argv[c1 + 1], "rb")) != NULL) {
+                                                fclose(f);
+                                                strcpy(datfile_name, argv[c1 + 1]);
+                                        }
+                                }
+                        } else if (stricmp(argv[c1], "-player") == 0) {
+                                if (c1 < (argc - 1)) {
+                                        if (client_player_num < 0)
+                                                client_player_num = atoi(argv[c1 + 1]);
+                                }
+#ifdef USE_NET
+                        } else if (stricmp(argv[c1], "-server") == 0) {
+                                if (c1 < (argc - 1)) {
+                                        is_server = 1;
+                                        is_net = 1;
+                                        netarg = argv[c1 + 1];
+                                }
+                        } else if (stricmp(argv[c1], "-connect") == 0) {
+                                if (c1 < (argc - 1)) {
+                                        is_server = 0;
+                                        is_net = 1;
+                                        netarg = argv[c1 + 1];
+                                }
+#endif
+                        } else if (stricmp(argv[c1], "-mouse") == 0) {
+                                if (c1 < (argc - 1)) {
+                                        if (stricmp(argv[c1 + 1], "2") == 0)
+                                                force2 = 1;
+                                        if (stricmp(argv[c1 + 1], "3") == 0)
+                                                force3 = 1;
+                                }
+                        }
+                        else if (strstr(argv[1],"-v")) {
+                                printf("jumpnbump %s compiled %s at %s with",JNB_VERSION,__DATE__,__TIME__);
+#ifndef USE_NET
+                                printf("out");
+#endif
+                                printf(" network support.\n");
+                                return 1;
+                        }
+                        else if (strstr(argv[1],"-h")) {
+                                printf("Usage: jumpnbump [OPTION]...\n");
+                                printf("\n");
+                                printf("  -h                       this help\n");
+                                printf("  -v                       print version\n");
+                                printf("  -dat level.dat           play a different level\n");
+#ifdef USE_NET
+                                printf("  -server playercount      start as server waiting for players\n");
+                                printf("  -connect host            connect to server\n");
+#endif
+                                printf("  -player num              set main player to num (0-3). Needed for networking\n");
+                                printf("  -fireworks               screensaver mode\n");
+                                printf("  -fullscreen              run in fullscreen mode\n");
+                                printf("  -nosound                 play without sound\n");
+                                printf("  -nogore                  play without blood\n");
+                                printf("  -noflies                 disable flies\n");
+                                printf("  -mirror                  play with mirrored level\n");
+                                printf("  -scaleup                 play with doubled resolution (800x512)\n");
+                                printf("  -musicnosound            play with music but without sound\n");
+                                printf("\n");
+                                return 1;
+                        }
+                }
+        }
+        preread_datafile(datfile_name);
+#if 0
+/** It should not be necessary to assign a default player number here. The
+server assigns one in init_server, the client gets one assigned by the server,
+all provided the user didn't choose one on the commandline. */
+        if (is_net) {
+                if (client_player_num < 0)
+                        client_player_num = 0;
+                player[client_player_num].enabled = 1;
+        }
+#endif
+        main_info.pob_backbuf[0] = malloc(screen_pitch*screen_height);
+        main_info.pob_backbuf[1] = malloc(screen_pitch*screen_height);
+        for (c1 = 0; c1 < 7; c1++) {
+                player_anims[c1].num_frames = player_anim_data[c1 * 10];
+                player_anims[c1].restart_frame = player_anim_data[c1 * 10 + 1];
+                for (c2 = 0; c2 < 4; c2++) {
+                        player_anims[c1].frame[c2].image = player_anim_data[c1 * 10 + c2 * 2 + 2];
+                        player_anims[c1].frame[c2].ticks = player_anim_data[c1 * 10 + c2 * 2 + 3];
+                }
+        }
+        if ((handle = dat_open("menu.pcx")) == 0) {
+                strcpy(main_info.error_str, "Error loading 'menu.pcx', aborting...\n");
+                return 1;
+        }
+        if (read_pcx(handle, background_pic, JNB_WIDTH*JNB_HEIGHT, pal) != 0) {
+                strcpy(main_info.error_str, "Error loading 'menu.pcx', aborting...\n");
+                return 1;
+        }
+        if ((handle = dat_open("rabbit.gob")) == 0) {
+                strcpy(main_info.error_str, "Error loading 'rabbit.gob', aborting...\n");
+                return 1;
+        }
+        if (register_gob(handle, &rabbit_gobs, dat_filelen("rabbit.gob"))) {
+                /* error */
+                return 1;
+        }
+        if ((handle = dat_open("objects.gob")) == 0) {
+                strcpy(main_info.error_str, "Error loading 'objects.gob', aborting...\n");
+                return 1;
+        }
+        if (register_gob(handle, &object_gobs, dat_filelen("objects.gob"))) {
+                /* error */
+                return 1;
+        }
+        if ((handle = dat_open("font.gob")) == 0) {
+                strcpy(main_info.error_str, "Error loading 'font.gob', aborting...\n");
+                return 1;
+        }
+        if (register_gob(handle, &font_gobs, dat_filelen("font.gob"))) {
+                /* error */
+                return 1;
+        }
+        if ((handle = dat_open("numbers.gob")) == 0) {
+                strcpy(main_info.error_str, "Error loading 'numbers.gob', aborting...\n");
+                return 1;
+        }
+        if (register_gob(handle, &number_gobs, dat_filelen("numbers.gob"))) {
+                /* error */
+                return 1;
+        }
+        if (read_level() != 0) {
+                strcpy(main_info.error_str, "Error loading 'levelmap.txt', aborting...\n");
+                return 1;
+        }
+        dj_init();
+        if (main_info.no_sound == 0) {
+                dj_autodetect_sd();
+                dj_set_mixing_freq(20000);
+                dj_set_stereo(0);
+                dj_set_auto_mix(0);
+                dj_set_dma_time(8);
+                dj_set_num_sfx_channels(5);
+                dj_set_sfx_volume(64);
+                dj_set_nosound(1);
+                dj_start();
+                if ((handle = dat_open("jump.mod")) == 0) {
+                        strcpy(main_info.error_str, "Error loading 'jump.mod', aborting...\n");
+                        return 1;
+                }
+                if (dj_load_mod(handle, 0, MOD_MENU) != 0) {
+                        strcpy(main_info.error_str, "Error loading 'jump.mod', aborting...\n");
+                        return 1;
+                }
+                if ((handle = dat_open("bump.mod")) == 0) {
+                        strcpy(main_info.error_str, "Error loading 'bump.mod', aborting...\n");
+                        return 1;
+                }
+                if (dj_load_mod(handle, 0, MOD_GAME) != 0) {
+                        strcpy(main_info.error_str, "Error loading 'bump.mod', aborting...\n");
+                        return 1;
+                }
+                if ((handle = dat_open("scores.mod")) == 0) {
+                        strcpy(main_info.error_str, "Error loading 'scores.mod', aborting...\n");
+                        return 1;
+                }
+                if (dj_load_mod(handle, 0, MOD_SCORES) != 0) {
+                        strcpy(main_info.error_str, "Error loading 'scores.mod', aborting...\n");
+                        return 1;
+                }
+                if ((handle = dat_open("jump.smp")) == 0) {
+                        strcpy(main_info.error_str, "Error loading 'jump.smp', aborting...\n");
+                        return 1;
+                }
+                if (dj_load_sfx(handle, 0, dat_filelen("jump.smp"), DJ_SFX_TYPE_SMP, SFX_JUMP) != 0) {
+                        strcpy(main_info.error_str, "Error loading 'jump.smp', aborting...\n");
+                        return 1;
+                }
+                if ((handle = dat_open("death.smp")) == 0) {
+                        strcpy(main_info.error_str, "Error loading 'death.smp', aborting...\n");
+                        return 1;
+                }
+                if (dj_load_sfx(handle, 0, dat_filelen("death.smp"), DJ_SFX_TYPE_SMP, SFX_DEATH) != 0) {
+                        strcpy(main_info.error_str, "Error loading 'death.smp', aborting...\n");
+                        return 1;
+                }
+                if ((handle = dat_open("spring.smp")) == 0) {
+                        strcpy(main_info.error_str, "Error loading 'spring.smp', aborting...\n");
+                        return 1;
+                }
+                if (dj_load_sfx(handle, 0, dat_filelen("spring.smp"), DJ_SFX_TYPE_SMP, SFX_SPRING) != 0) {
+                        strcpy(main_info.error_str, "Error loading 'spring.smp', aborting...\n");
+                        return 1;
+                }
+                if ((handle = dat_open("splash.smp")) == 0) {
+                        strcpy(main_info.error_str, "Error loading 'splash.smp', aborting...\n");
+                        return 1;
+                }
+                if (dj_load_sfx(handle, 0, dat_filelen("splash.smp"), DJ_SFX_TYPE_SMP, SFX_SPLASH) != 0) {
+                        strcpy(main_info.error_str, "Error loading 'splash.smp', aborting...\n");
+                        return 1;
+                }
+                if ((handle = dat_open("fly.smp")) == 0) {
+                        strcpy(main_info.error_str, "Error loading 'fly.smp', aborting...\n");
+                        return 1;
+                }
+                if (dj_load_sfx(handle, 0, dat_filelen("fly.smp"), DJ_SFX_TYPE_SMP, SFX_FLY) != 0) {
+                        strcpy(main_info.error_str, "Error loading 'fly.smp', aborting...\n");
+                        return 1;
+                }
+                dj_get_sfx_settings(SFX_FLY, &fly);
+                fly.priority = 10;
+                fly.default_freq = SFX_FLY_FREQ;
+                fly.loop = 1;
+                fly.loop_start = 0;
+                fly.loop_length = fly.length;
+                dj_set_sfx_settings(SFX_FLY, &fly);
+        }
+        if ((background_pic = malloc(JNB_WIDTH*JNB_HEIGHT)) == NULL)
+                return 1;
+        if ((mask_pic = malloc(JNB_WIDTH*JNB_HEIGHT)) == NULL)
+                return 1;
+        memset(mask_pic, 0, JNB_WIDTH*JNB_HEIGHT);
+        register_mask(mask_pic);
+        /* fix dark font */
+        for (c1 = 0; c1 < 16; c1++) {
+                pal[(240 + c1) * 3 + 0] = c1 << 2;
+                pal[(240 + c1) * 3 + 1] = c1 << 2;
+                pal[(240 + c1) * 3 + 2] = c1 << 2;
+        }
+        setpalette(0, 256, pal);
+        init_inputs();
+        recalculate_gob(&font_gobs, pal);
+        if (main_info.joy_enabled == 1 && main_info.fireworks == 0) {
+                load_flag = 0;
+                put_text(0, 200, 40, "JOYSTICK CALIBRATION", 2);
+                put_text(0, 200, 100, "Move the joystick to the", 2);
+                put_text(0, 200, 115, "UPPER LEFT", 2);
+                put_text(0, 200, 130, "and press button A", 2);
+                put_text(0, 200, 200, "Or press ESC to use", 2);
+                put_text(0, 200, 215, "previous settings", 2);
+                if (calib_joy(0) != 0)
+                        load_flag = 1;
+                else {
+                        register_background(NULL, NULL);
+                        main_info.view_page = 1;
+                        flippage(1);
+                        wait_vrt(0);
+                        put_text(1, 200, 40, "JOYSTICK CALIBRATION", 2);
+                        put_text(1, 200, 100, "Move the joystick to the", 2);
+                        put_text(1, 200, 115, "LOWER RIGHT", 2);
+                        put_text(1, 200, 130, "and press button A", 2);
+                        put_text(1, 200, 200, "Or press ESC to use", 2);
+                        put_text(1, 200, 215, "previous settings", 2);
+                        if (calib_joy(1) != 0)
+                                load_flag = 1;
+                        else {
+                                register_background(NULL, NULL);
+                                flippage(0);
+                                wait_vrt(0);
+                                put_text(0, 200, 40, "JOYSTICK CALIBRATION", 2);
+                                put_text(0, 200, 100, "Move the joystick to the", 2);
+                                put_text(0, 200, 115, "CENTER", 2);
+                                put_text(0, 200, 130, "and press button A", 2);
+                                put_text(0, 200, 200, "Or press ESC to use", 2);
+                                put_text(0, 200, 215, "previous settings", 2);
+                                if (calib_joy(2) != 0)
+                                        load_flag = 1;
+                                else {
+                                        if (joy.calib_data.x1 == joy.calib_data.x2)
+                                                joy.calib_data.x1 -= 10;
+                                        if (joy.calib_data.x3 == joy.calib_data.x2)
+                                                joy.calib_data.x3 += 10;
+                                        if (joy.calib_data.y1 == joy.calib_data.y2)
+                                                joy.calib_data.y1 -= 10;
+                                        if (joy.calib_data.y3 == joy.calib_data.y2)
+                                                joy.calib_data.y3 += 10;
+                                        write_calib_data();
+                                }
+                        }
+                }
+                if (load_flag == 1) {
+                        if ((handle = dat_open("calib.dat")) == 0) {
+                                strcpy(main_info.error_str, "Error loading 'calib.dat', aborting...\n");
+                                return 1;
+                        }
+                        joy.calib_data.x1 = (handle[0]) + (handle[1] << 8) + (handle[2] << 16) + (handle[3] << 24); handle += 4;
+                        joy.calib_data.x2 = (handle[0]) + (handle[1] << 8) + (handle[2] << 16) + (handle[3] << 24); handle += 4;
+                        joy.calib_data.x3 = (handle[0]) + (handle[1] << 8) + (handle[2] << 16) + (handle[3] << 24); handle += 4;
+                        joy.calib_data.y1 = (handle[0]) + (handle[1] << 8) + (handle[2] << 16) + (handle[3] << 24); handle += 4;
+                        joy.calib_data.y2 = (handle[0]) + (handle[1] << 8) + (handle[2] << 16) + (handle[3] << 24); handle += 4;
+                        joy.calib_data.y3 = (handle[0]) + (handle[1] << 8) + (handle[2] << 16) + (handle[3] << 24); handle += 4;
+                }
+        }
+#ifdef USE_NET
+        if (is_net) {
+                if (is_server) {
+                        init_server(netarg);
+                } else {
+                        connect_to_server(netarg);
+                }
+        }
+#endif
+        return 0;
+}
+void deinit_program(void)
+{
+#ifdef DOS
+        __dpmi_regs regs;
+#endif
+        dj_stop();
+        dj_free_mod(MOD_MENU);
+        dj_free_mod(MOD_GAME);
+        dj_free_sfx(SFX_DEATH);
+        dj_free_sfx(SFX_SPRING);
+        dj_free_sfx(SFX_SPLASH);
+        dj_deinit();
+        if (background_pic != 0)
+                free(background_pic);
+        if (mask_pic != 0)
+                free(mask_pic);
+        remove_keyb_handler();
+#ifdef DOS
+        regs.x.ax = 0x3;
+        __dpmi_int(0x10, &regs);
+#endif
+        if (main_info.error_str[0] != 0) {
+                printf(main_info.error_str);
+#ifdef _MSC_VER
+                MessageBox(0, main_info.error_str, "Jump'n'Bump", 0);
+#endif
+                exit(1);
+        } else
+                exit(0);
+}
+unsigned short rnd(unsigned short max)
+{
+#if (RAND_MAX < 0x7fff)
+#error "rand returns too small values"
+#elif (RAND_MAX == 0x7fff)
+        return (unsigned short)((rand()*2) % (int)max);
+#else
+        return (unsigned short)(rand() % (int)max);
+#endif
+}
+int read_level(void)
+{
+        unsigned char *handle;
+        int c1, c2;
+        int chr;
+        if ((handle = dat_open("levelmap.txt")) == 0) {
+                strcpy(main_info.error_str, "Error loading 'levelmap.txt', aborting...\n");
+                return 1;
+        }
+        for (c1 = 0; c1 < 16; c1++) {
+                for (c2 = 0; c2 < 22; c2++) {
+                        while (1) {
+                                chr = (int) *(handle++);
+                                if (chr >= '0' && chr <= '4')
+                                        break;
+                        }
+                        if (flip)
+                                ban_map[c1][21-c2] = chr - '0';
+                        else
+                                ban_map[c1][c2] = chr - '0';
+                }
+        }
+        for (c2 = 0; c2 < 22; c2++)
+                ban_map[16][c2] = BAN_SOLID;
+        return 0;
+}
+unsigned char *dat_open(char *file_name)
+{
+        int num;
+        int c1;
+        char name[21];
+        int ofs;
+        unsigned char *ptr;
+        if (datafile_buffer == NULL)
+                return 0;
+        memset(name, 0, sizeof(name));
+        num = ( (datafile_buffer[0] <<  0) +
+                (datafile_buffer[1] <<  8) +
+                (datafile_buffer[2] << 16) +
+                (datafile_buffer[3] << 24) );
+        ptr = datafile_buffer + 4;
+        for (c1 = 0; c1 < num; c1++) {
+                memcpy(name, ptr, 12);
+                ptr += 12;
+                if (strnicmp(name, file_name, strlen(file_name)) == 0) {
+                        ofs = ( (ptr[0] <<  0) +
+                                (ptr[1] <<  8) +
+                                (ptr[2] << 16) +
+                                (ptr[3] << 24) );
+                        return (datafile_buffer + ofs);
+                }
+                ptr += 8;
+        }
+        return 0;
+}
+int dat_filelen(char *file_name)
+{
+        unsigned char *ptr;
+        int num;
+        int c1;
+        char name[21];
+        int len;
+        memset(name, 0, sizeof(name));
+        num = ( (datafile_buffer[0] <<  0) +
+                (datafile_buffer[1] <<  8) +
+                (datafile_buffer[2] << 16) +
+                (datafile_buffer[3] << 24) );
+        ptr = datafile_buffer + 4;
+        for (c1 = 0; c1 < num; c1++) {
+                memcpy(name, ptr, 12);
+                ptr += 12;
+                if (strnicmp(name, file_name, strlen(file_name)) == 0) {
+                        ptr += 4;
+                        len = ( (ptr[0] <<  0) +
+                                (ptr[1] <<  8) +
+                                (ptr[2] << 16) +
+                                (ptr[3] << 24) );
+                        return len;
+                }
+                ptr += 8;
+        }
+        return 0;
+}
+void write_calib_data(void)
+{
+        FILE *handle;
+        int c1;
+        int len, num;
+        char *mem;
+        int ofs;
+        if ((handle = fopen(datfile_name, "rb")) == NULL)
+                return;
+        len = filelength(fileno(handle));
+        if ((mem = malloc(len)) == NULL)
+                return;
+        fread(mem, 1, len, handle);
+        fclose(handle);
+        ofs = 4;
+        num = *(int *) (&mem[0]);
+        for (c1 = 0; c1 < num; c1++) {
+                if (strnicmp(&mem[ofs], "calib.dat", strlen("calib.dat")) == 0) {
+                        ofs = *(int *) (&mem[ofs + 12]);
+                        break;
+                }
+                ofs += 20;
+        }
+        mem[ofs] = joy.calib_data.x1 & 0xff;
+        mem[ofs + 1] = (joy.calib_data.x1 >> 8) & 0xff;
+        mem[ofs + 2] = (joy.calib_data.x1 >> 16) & 0xff;
+        mem[ofs + 3] = (joy.calib_data.x1 >> 24) & 0xff;
+        mem[ofs + 4] = joy.calib_data.x2 & 0xff;
+        mem[ofs + 5] = (joy.calib_data.x2 >> 8) & 0xff;
+        mem[ofs + 6] = (joy.calib_data.x2 >> 16) & 0xff;
+        mem[ofs + 7] = (joy.calib_data.x2 >> 24) & 0xff;
+        mem[ofs + 8] = joy.calib_data.x3 & 0xff;
+        mem[ofs + 9] = (joy.calib_data.x3 >> 8) & 0xff;
+        mem[ofs + 10] = (joy.calib_data.x3 >> 16) & 0xff;
+        mem[ofs + 11] = (joy.calib_data.x3 >> 24) & 0xff;
+        mem[ofs + 12] = joy.calib_data.y1 & 0xff;
+        mem[ofs + 13] = (joy.calib_data.y1 >> 8) & 0xff;
+        mem[ofs + 14] = (joy.calib_data.y1 >> 16) & 0xff;
+        mem[ofs + 15] = (joy.calib_data.y1 >> 24) & 0xff;
+        mem[ofs + 16] = joy.calib_data.y2 & 0xff;
+        mem[ofs + 17] = (joy.calib_data.y2 >> 8) & 0xff;
+        mem[ofs + 18] = (joy.calib_data.y2 >> 16) & 0xff;
+        mem[ofs + 19] = (joy.calib_data.y2 >> 24) & 0xff;
+        mem[ofs + 20] = joy.calib_data.y3 & 0xff;
+        mem[ofs + 21] = (joy.calib_data.y3 >> 8) & 0xff;
+        mem[ofs + 22] = (joy.calib_data.y3 >> 16) & 0xff;
+        mem[ofs + 23] = (joy.calib_data.y3 >> 24) & 0xff;
+        if ((handle = fopen(datfile_name, "wb")) == NULL)
+                return;
+        fwrite(mem, 1, len, handle);
+        fclose(handle);
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/menu.c
 ,0 → 1,637
+/*
+ * menu.c
+ * Copyright (C) 1998 Brainchild Design - http://brainchilddesign.com/
+ *
+ * Copyright (C) 2001 Chuck Mason <cemason@users.sourceforge.net>
+ *
+ * Copyright (C) 2002 Florian Schulze <crow@icculus.org>
+ *
+ * This file is part of Jump'n'Bump.
+ *
+ * Jump'n'Bump is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Jump'n'Bump is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include "globals.h"
+char *menu_background;
+char menu_pal[768];
+char menu_cur_pal[768];
+char *message[] = {
+        "Jump 'n Bump "JNB_VERSION,
+        "by Brainchild Design in 1998.",
+        "Code by Mattias Brynervall.",
+        "Graphics by Martin Magnusson",
+        "and Andreas Brynervall.",
+        "Music by Anders Nilsson.",
+        "Linux port by Chuck Mason.",
+        "New SDL port by Florian Schulze.",
+        "http://www.icculus.org/jumpnbump/",
+        "Ryan C. Gordon made networking possible again!",
+        "Visit our homepage at:",
+        "http://www.algonet.se/~mattiasb",
+        "Jump 'n Bump is e-mailware.",
+        "That means you're supposed to send us an e-mail!",
+        "Write for example where you're from",
+        "and what you thought about this game.",
+        "If you do that, you will greatly encourage us",
+        "to make more games for you!",
+        "Send your e-mail to: matbr656@student.liu.se",
+        "Oh, and by the way, there're a lot of secrets!",
+        "If you can't find them, you'd better ask us...",
+        "If you'd like to contact a specific member of BCD,",
+        "these are their e-mail addresses:",
+        "Andreas Brynervall: andreasb@acc.umu.se",
+        "Mattias Brynervall: matbr656@student.liu.se",
+        "Martin Magnusson: marma102@student.liu.se",
+        "Anders Nilsson: equel@swipnet.se",
+        ""
+};
+#define NUM_MESSAGES (sizeof(message)/sizeof(char *))
+int menu(void)
+{
+        int c1;
+        int esc_pressed;
+        int end_loop_flag, new_game_flag, fade_flag;
+        int mod_vol = 0, mod_fade_direction = 0;
+        int cur_message;
+        int fade_dir, fade_count, fade_tick;
+        char fade_pal[48];
+        int update_count;
+        if (menu_init() != 0)
+                return 1;
+  /* After a game, we have to release the keys, cause AI player
+     can still be using them */
+        addkey((KEY_PL1_LEFT & 0x7f) | 0x8000);
+        addkey((KEY_PL2_LEFT & 0x7f) | 0x8000);
+        addkey((KEY_PL3_LEFT & 0x7f) | 0x8000);
+        addkey((KEY_PL4_LEFT & 0x7f) | 0x8000);
+        addkey((KEY_PL1_RIGHT & 0x7f) | 0x8000);
+        addkey((KEY_PL2_RIGHT & 0x7f) | 0x8000);
+        addkey((KEY_PL3_RIGHT & 0x7f) | 0x8000);
+        addkey((KEY_PL4_RIGHT & 0x7f) | 0x8000);
+        addkey((KEY_PL1_JUMP & 0x7f) | 0x8000);
+        addkey((KEY_PL2_JUMP & 0x7f) | 0x8000);
+        addkey((KEY_PL3_JUMP & 0x7f) | 0x8000);
+        addkey((KEY_PL4_JUMP & 0x7f) | 0x8000);
+        mod_vol = 0;
+        mod_fade_direction = 1;
+        dj_ready_mod(MOD_MENU);
+        dj_set_mod_volume((char)mod_vol);
+        dj_set_sfx_volume(64);
+        dj_start_mod();
+        dj_set_nosound(0);
+        memset(fade_pal, 0, 48);
+        setpalette(240, 16, fade_pal);
+        fade_dir = 0;
+        fade_count = 0;
+        fade_tick = 0;
+        cur_message = NUM_MESSAGES - 1;
+        main_info.page_info[0].num_pobs = 0;
+        main_info.page_info[1].num_pobs = 0;
+        main_info.view_page = 0;
+        main_info.draw_page = 1;
+        esc_pressed = key_pressed(1);
+        end_loop_flag = new_game_flag = 0;
+        update_count = 1;
+        while (1) {
+                dj_mix();
+        for(c1 = 0; c1 < JNB_MAX_PLAYERS; c1++)         // set AI to false
+                ai[c1] = 0;
+                while (update_count) {
+                        if (key_pressed(1) == 1 && esc_pressed == 0) {
+                                end_loop_flag = 1;
+                                new_game_flag = 0;
+                                memset(menu_pal, 0, 768);
+                                mod_fade_direction = 0;
+                        } else if (key_pressed(1) == 0)
+                                esc_pressed = 0;
+                        update_player_actions();
+                        for (c1 = 0; c1 < JNB_MAX_PLAYERS; c1++) {
+                                if (end_loop_flag == 1 && new_game_flag == 1) {
+                                        if ((player[c1].x >> 16) > (165 + c1 * 2)) {
+                                                if (player[c1].x_add < 0)
+                                                        player[c1].x_add += 16384;
+                                                else
+                                                        player[c1].x_add += 12288;
+                                                if (player[c1].x_add > 98304L)
+                                                        player[c1].x_add = 98304L;
+                                                player[c1].direction = 0;
+                                                if (player[c1].anim == 0) {
+                                                        player[c1].anim = 1;
+                                                        player[c1].frame = 0;
+                                                        player[c1].frame_tick = 0;
+                                                        player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                                }
+                                                player[c1].enabled = 1;
+                                        }
+                                        if (!player[c1].action_up) {
+                                                if (player[c1].y_add < 0) {
+                                                        player[c1].y_add += 32768;
+                                                        if (player[c1].y_add > 0)
+                                                                player[c1].y_add = 0;
+                                                }
+                                        }
+                                        player[c1].y_add += 12288;
+                                        if (player[c1].y_add > 36864 && player[c1].anim != 3) {
+                                                player[c1].anim = 3;
+                                                player[c1].frame = 0;
+                                                player[c1].frame_tick = 0;
+                                                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                        }
+                                        player[c1].y += player[c1].y_add;
+                                        if ((player[c1].x >> 16) <= (165 + c1 * 2) || (player[c1].x >> 16) >= (208 + c1 * 2)) {
+                                                if ((player[c1].y >> 16) > (160 + c1 * 2)) {
+                                                        player[c1].y = (160L + c1 * 2) << 16;
+                                                        player[c1].y_add = 0;
+                                                        if (player[c1].anim != 0 && player[c1].anim != 1) {
+                                                                player[c1].anim = 0;
+                                                                player[c1].frame = 0;
+                                                                player[c1].frame_tick = 0;
+                                                                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                                        }
+                                                }
+                                        } else {
+                                                if ((player[c1].y >> 16) > (138 + c1 * 2)) {
+                                                        player[c1].y = (138L + c1 * 2) << 16;
+                                                        player[c1].y_add = 0;
+                                                        if (player[c1].anim != 0 && player[c1].anim != 1) {
+                                                                player[c1].anim = 0;
+                                                                player[c1].frame = 0;
+                                                                player[c1].frame_tick = 0;
+                                                                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                                        }
+                                                        if (!player[c1].action_up)
+                                                                player[c1].jump_ready = 1;
+                                                }
+                                        }
+                                        player[c1].x += player[c1].x_add;
+                                        if ((player[c1].y >> 16) > (138 + c1 * 2)) {
+                                                if ((player[c1].x >> 16) > (165 + c1 * 2) && (player[c1].x >> 16) < (190 + c1 * 2)) {
+                                                        player[c1].x = (165L + c1 * 2) << 16;
+                                                        player[c1].x_add = 0;
+                                                }
+                                                if ((player[c1].x >> 16) > (190 + c1 * 2) && (player[c1].x >> 16) < (208 + c1 * 2)) {
+                                                        player[c1].x = (208L + c1 * 2) << 16;
+                                                        player[c1].x_add = 0;
+                                                }
+                                        }
+                                } else {
+                                        if (player[c1].action_left && player[c1].action_right) {
+                                                if (player[c1].direction == 1) {
+                                                        if ((player[c1].x >> 16) <= (165 + c1 * 2) || (player[c1].x >> 16) >= (208 + c1 * 2)) {
+                                                                if (player[c1].x_add > 0) {
+                                                                        player[c1].x_add -= 16384;
+                                                                        if ((player[c1].y >> 16) >= (160 + c1 * 2))
+                                                                                add_object(OBJ_SMOKE, (player[c1].x >> 16) + 2 + rnd(9), (player[c1].y >> 16) + 13 + rnd(5), 0, -16384 - rnd(8192), OBJ_ANIM_SMOKE, 0);
+                                                                } else
+                                                                        player[c1].x_add -= 12288;
+                                                        }
+                                                        if ((player[c1].x >> 16) > (165 + c1 * 2) && (player[c1].x >> 16) < (208 + c1 * 2)) {
+                                                                if (player[c1].x_add > 0) {
+                                                                        player[c1].x_add -= 16384;
+                                                                        if ((player[c1].y >> 16) >= (138 + c1 * 2))
+                                                                                add_object(OBJ_SMOKE, (player[c1].x >> 16) + 2 + rnd(9), (player[c1].y >> 16) + 13 + rnd(5), 0, -16384 - rnd(8192), OBJ_ANIM_SMOKE, 0);
+                                                                } else
+                                                                        player[c1].x_add -= 12288;
+                                                        }
+                                                        if (player[c1].x_add < -98304L)
+                                                                player[c1].x_add = -98304L;
+                                                        player[c1].direction = 1;
+                                                        if (player[c1].anim == 0) {
+                                                                player[c1].anim = 1;
+                                                                player[c1].frame = 0;
+                                                                player[c1].frame_tick = 0;
+                                                                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                                        }
+                                                } else {
+                                                        if ((player[c1].x >> 16) <= (165 + c1 * 2) || (player[c1].x >> 16) >= (208 + c1 * 2)) {
+                                                                if (player[c1].x_add < 0) {
+                                                                        player[c1].x_add += 16384;
+                                                                        if ((player[c1].y >> 16) >= (160 + c1 * 2))
+                                                                                add_object(OBJ_SMOKE, (player[c1].x >> 16) + 2 + rnd(9), (player[c1].y >> 16) + 13 + rnd(5), 0, -16384 - rnd(8192), OBJ_ANIM_SMOKE, 0);
+                                                                } else
+                                                                        player[c1].x_add += 12288;
+                                                        }
+                                                        if ((player[c1].x >> 16) > (165 + c1 * 2) && (player[c1].x >> 16) < (208 + c1 * 2)) {
+                                                                if (player[c1].x_add < 0) {
+                                                                        player[c1].x_add += 16384;
+                                                                        if ((player[c1].y >> 16) >= (138 + c1 * 2))
+                                                                                add_object(OBJ_SMOKE, (player[c1].x >> 16) + 2 + rnd(9), (player[c1].y >> 16) + 13 + rnd(5), 0, -16384 - rnd(8192), OBJ_ANIM_SMOKE, 0);
+                                                                } else
+                                                                        player[c1].x_add += 12288;
+                                                        }
+                                                        if (player[c1].x_add > 98304L)
+                                                                player[c1].x_add = 98304L;
+                                                        player[c1].direction = 0;
+                                                        if (player[c1].anim == 0) {
+                                                                player[c1].anim = 1;
+                                                                player[c1].frame = 0;
+                                                                player[c1].frame_tick = 0;
+                                                                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                                        }
+                                                }
+                                        } else if (player[c1].action_left) {
+                                                if ((player[c1].x >> 16) <= (165 + c1 * 2) || (player[c1].x >> 16) >= (208 + c1 * 2)) {
+                                                        if (player[c1].x_add > 0) {
+                                                                player[c1].x_add -= 16384;
+                                                                if ((player[c1].y >> 16) >= (160 + c1 * 2))
+                                                                        add_object(OBJ_SMOKE, (player[c1].x >> 16) + 2 + rnd(9), (player[c1].y >> 16) + 13 + rnd(5), 0, -16384 - rnd(8192), OBJ_ANIM_SMOKE, 0);
+                                                        } else
+                                                                player[c1].x_add -= 12288;
+                                                }
+                                                if ((player[c1].x >> 16) > (165 + c1 * 2) && (player[c1].x >> 16) < (208 + c1 * 2)) {
+                                                        if (player[c1].x_add > 0) {
+                                                                player[c1].x_add -= 16384;
+                                                                if ((player[c1].y >> 16) >= (138 + c1 * 2))
+                                                                        add_object(OBJ_SMOKE, (player[c1].x >> 16) + 2 + rnd(9), (player[c1].y >> 16) + 13 + rnd(5), 0, -16384 - rnd(8192), OBJ_ANIM_SMOKE, 0);
+                                                        } else
+                                                                player[c1].x_add -= 12288;
+                                                }
+                                                if (player[c1].x_add < -98304L)
+                                                        player[c1].x_add = -98304L;
+                                                player[c1].direction = 1;
+                                                if (player[c1].anim == 0) {
+                                                        player[c1].anim = 1;
+                                                        player[c1].frame = 0;
+                                                        player[c1].frame_tick = 0;
+                                                        player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                                }
+                                        } else if (player[c1].action_right) {
+                                                if ((player[c1].x >> 16) <= (165 + c1 * 2) || (player[c1].x >> 16) >= (208 + c1 * 2)) {
+                                                        if (player[c1].x_add < 0) {
+                                                                player[c1].x_add += 16384;
+                                                                if ((player[c1].y >> 16) >= (160 + c1 * 2))
+                                                                        add_object(OBJ_SMOKE, (player[c1].x >> 16) + 2 + rnd(9), (player[c1].y >> 16) + 13 + rnd(5), 0, -16384 - rnd(8192), OBJ_ANIM_SMOKE, 0);
+                                                        } else
+                                                                player[c1].x_add += 12288;
+                                                }
+                                                if ((player[c1].x >> 16) > (165 + c1 * 2) && (player[c1].x >> 16) < (208 + c1 * 2)) {
+                                                        if (player[c1].x_add < 0) {
+                                                                player[c1].x_add += 16384;
+                                                                if ((player[c1].y >> 16) >= (138 + c1 * 2))
+                                                                        add_object(OBJ_SMOKE, (player[c1].x >> 16) + 2 + rnd(9), (player[c1].y >> 16) + 13 + rnd(5), 0, -16384 - rnd(8192), OBJ_ANIM_SMOKE, 0);
+                                                        } else
+                                                                player[c1].x_add += 12288;
+                                                }
+                                                if (player[c1].x_add > 98304L)
+                                                        player[c1].x_add = 98304L;
+                                                player[c1].direction = 0;
+                                                if (player[c1].anim == 0) {
+                                                        player[c1].anim = 1;
+                                                        player[c1].frame = 0;
+                                                        player[c1].frame_tick = 0;
+                                                        player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                                }
+                                        } else {
+                                                if (((player[c1].x >> 16) <= (165 + c1 * 2) || (player[c1].x >> 16) >= (208 + c1 * 2)) && (player[c1].y >> 16) >= (160 + c1 * 2)) {
+                                                        if (player[c1].x_add < 0) {
+                                                                player[c1].x_add += 16384;
+                                                                if (player[c1].x_add > 0)
+                                                                        player[c1].x_add = 0;
+                                                                add_object(OBJ_SMOKE, (player[c1].x >> 16) + 2 + rnd(9), (player[c1].y >> 16) + 13 + rnd(5), 0, -16384 - rnd(8192), OBJ_ANIM_SMOKE, 0);
+                                                        } else if (player[c1].x_add > 0) {
+                                                                player[c1].x_add -= 16384;
+                                                                if (player[c1].x_add < 0)
+                                                                        player[c1].x_add = 0;
+                                                                add_object(OBJ_SMOKE, (player[c1].x >> 16) + 2 + rnd(9), (player[c1].y >> 16) + 13 + rnd(5), 0, -16384 - rnd(8192), OBJ_ANIM_SMOKE, 0);
+                                                        }
+                                                }
+                                                if ((((player[c1].x >> 16) > (165 + c1 * 2) && (player[c1].x >> 16) < (208 + c1 * 2)) && (player[c1].y >> 16) >= (138 + c1 * 2))) {
+                                                        if (player[c1].x_add < 0) {
+                                                                player[c1].x_add += 16384;
+                                                                if (player[c1].x_add > 0)
+                                                                        player[c1].x_add = 0;
+                                                                add_object(OBJ_SMOKE, (player[c1].x >> 16) + 2 + rnd(9), (player[c1].y >> 16) + 13 + rnd(5), 0, -16384 - rnd(8192), OBJ_ANIM_SMOKE, 0);
+                                                        } else if (player[c1].x_add > 0) {
+                                                                player[c1].x_add -= 16384;
+                                                                if (player[c1].x_add < 0)
+                                                                        player[c1].x_add = 0;
+                                                                add_object(OBJ_SMOKE, (player[c1].x >> 16) + 2 + rnd(9), (player[c1].y >> 16) + 13 + rnd(5), 0, -16384 - rnd(8192), OBJ_ANIM_SMOKE, 0);
+                                                        }
+                                                }
+                                                if (player[c1].anim == 1) {
+                                                        player[c1].anim = 0;
+                                                        player[c1].frame = 0;
+                                                        player[c1].frame_tick = 0;
+                                                        player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                                }
+                                        }
+                                        if ((player[c1].jump_ready == 1) && player[c1].action_up) {
+                                                if ((player[c1].x >> 16) <= (165 + c1 * 2) || (player[c1].x >> 16) >= (208 + c1 * 2)) {
+                                                        if ((player[c1].y >> 16) >= (160 + c1 * 2)) {
+                                                                player[c1].y_add = -280000L;
+                                                                player[c1].anim = 2;
+                                                                player[c1].frame = 0;
+                                                                player[c1].frame_tick = 0;
+                                                                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                                                player[c1].jump_ready = 0;
+                                                                dj_play_sfx(SFX_JUMP, (unsigned short)(SFX_JUMP_FREQ + rnd(2000) - 1000), 64, 0, 0, -1);
+                                                        }
+                                                } else {
+                                                        if ((player[c1].y >> 16) >= (138 + c1 * 2)) {
+                                                                player[c1].y_add = -280000L;
+                                                                player[c1].anim = 2;
+                                                                player[c1].frame = 0;
+                                                                player[c1].frame_tick = 0;
+                                                                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                                                player[c1].jump_ready = 0;
+                                                                dj_play_sfx(SFX_JUMP, (unsigned short)(SFX_JUMP_FREQ + rnd(2000) - 1000), 64, 0, 0, -1);
+                                                        }
+                                                }
+                                        }
+                                        if (!player[c1].action_up) {
+                                                if (player[c1].y_add < 0) {
+                                                        player[c1].y_add += 32768;
+                                                        if (player[c1].y_add > 0)
+                                                                player[c1].y_add = 0;
+                                                }
+                                        }
+                                        if (!player[c1].action_up)
+                                                player[c1].jump_ready = 1;
+                                        player[c1].y_add += 12288;
+                                        if (player[c1].y_add > 36864 && player[c1].anim != 3) {
+                                                player[c1].anim = 3;
+                                                player[c1].frame = 0;
+                                                player[c1].frame_tick = 0;
+                                                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                        }
+                                        player[c1].y += player[c1].y_add;
+                                        if ((player[c1].x >> 16) <= (165 + c1 * 2) || (player[c1].x >> 16) >= (208 + c1 * 2)) {
+                                                if ((player[c1].y >> 16) > (160 + c1 * 2)) {
+                                                        player[c1].y = (160L + c1 * 2) << 16;
+                                                        player[c1].y_add = 0;
+                                                        if (player[c1].anim != 0 && player[c1].anim != 1) {
+                                                                player[c1].anim = 0;
+                                                                player[c1].frame = 0;
+                                                                player[c1].frame_tick = 0;
+                                                                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                                        }
+                                                }
+                                        } else {
+                                                if ((player[c1].y >> 16) > (138 + c1 * 2)) {
+                                                        player[c1].y = (138L + c1 * 2) << 16;
+                                                        player[c1].y_add = 0;
+                                                        if (player[c1].anim != 0 && player[c1].anim != 1) {
+                                                                player[c1].anim = 0;
+                                                                player[c1].frame = 0;
+                                                                player[c1].frame_tick = 0;
+                                                                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                                                        }
+                                                }
+                                        }
+                                        player[c1].x += player[c1].x_add;
+                                        if ((player[c1].x >> 16) < 0) {
+                                                player[c1].x = 0;
+                                                player[c1].x_add = 0;
+                                        }
+                                        if ((player[c1].x >> 16) > JNB_WIDTH) {
+                                                end_loop_flag = 1;
+                                                new_game_flag = 1;
+                                                memset(menu_pal, 0, 768);
+                                                mod_fade_direction = 0;
+                                        }
+                                        if ((player[c1].y >> 16) > (138 + c1 * 2)) {
+                                                if ((player[c1].x >> 16) > (165 + c1 * 2) && (player[c1].x >> 16) < (190 + c1 * 2)) {
+                                                        player[c1].x = (165L + c1 * 2) << 16;
+                                                        player[c1].x_add = 0;
+                                                }
+                                                if ((player[c1].x >> 16) > (190 + c1 * 2) && (player[c1].x >> 16) < (208 + c1 * 2)) {
+                                                        player[c1].x = (208L + c1 * 2) << 16;
+                                                        player[c1].x_add = 0;
+                                                }
+                                        }
+                                }
+                                player[c1].frame_tick++;
+                                if (player[c1].frame_tick >= player_anims[player[c1].anim].frame[player[c1].frame].ticks) {
+                                        player[c1].frame++;
+                                        if (player[c1].frame >= player_anims[player[c1].anim].num_frames)
+                                                player[c1].frame = player_anims[player[c1].anim].restart_frame;
+                                        player[c1].frame_tick = 0;
+                                }
+                                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image + player[c1].direction * 9;
+                        }
+                        dj_mix();
+                        main_info.page_info[main_info.draw_page].num_pobs = 0;
+                        for (c1 = 3; c1 >= 0; c1--)
+                                add_pob(main_info.draw_page, player[c1].x >> 16, player[c1].y >> 16, player[c1].image + c1 * 18, &rabbit_gobs);
+                        update_objects();
+                        if (update_count == 1) {
+                                draw_begin();
+                                draw_pobs(main_info.draw_page);
+                                draw_end();
+                                dj_mix();
+                                if (mod_fade_direction == 1) {
+                                        if (mod_vol < 35) {
+                                                mod_vol++;
+                                                dj_set_mod_volume((char)mod_vol);
+                                        }
+                                } else {
+                                        if (mod_vol > 0) {
+                                                mod_vol--;
+                                                dj_set_mod_volume((char)mod_vol);
+                                        }
+                                }
+                        }
+                        fade_flag = 0;
+                        for (c1 = 0; c1 < 720; c1++) {
+                                if (menu_cur_pal[c1] < menu_pal[c1]) {
+                                        menu_cur_pal[c1]++;
+                                        fade_flag = 1;
+                                } else if (menu_cur_pal[c1] > menu_pal[c1]) {
+                                        menu_cur_pal[c1]--;
+                                        fade_flag = 2;
+                                }
+                        }
+                        if (fade_flag == 0 && end_loop_flag == 1) {
+                                menu_deinit();
+                                if (new_game_flag == 1)
+                                        return 0;
+                                else
+                                        return 1;
+                        }
+                        switch (fade_dir) {
+                        case 0:
+                                if (fade_count < 30) {
+                                        for (c1 = 0; c1 < 48; c1++) {
+                                                if (fade_pal[c1] > 0)
+                                                        fade_pal[c1]--;
+                                        }
+                                        fade_count++;
+                                } else {
+                                        draw_begin();
+                                        clear_lines(0, 220, 20, 0);
+                                        clear_lines(1, 220, 20, 0);
+                                        cur_message++;
+                                        if (cur_message >= NUM_MESSAGES)
+                                                cur_message -= NUM_MESSAGES;
+                                        put_text(0, 200, 220, message[cur_message], 2);
+                                        put_text(1, 200, 220, message[cur_message], 2);
+                                        fade_dir = 1;
+                                        fade_count = 0;
+                                        fade_tick = 0;
+                                        draw_end();
+                                }
+                                break;
+                        case 1:
+                                if (fade_count < 100) {
+                                        for (c1 = 0; c1 < 48; c1++) {
+                                                if (fade_pal[c1] < menu_pal[c1 + 720])
+                                                        fade_pal[c1]++;
+                                        }
+                                        fade_count++;
+                                } else {
+                                        fade_dir = 0;
+                                        fade_count = 0;
+                                        fade_tick = 0;
+                                }
+                                break;
+                        }
+                        for (c1 = 0; c1 < 48; c1++) {
+                                if (fade_pal[c1] > menu_pal[c1 + 720])
+                                        fade_pal[c1]--;
+                        }
+                        if (update_count == 1) {
+                                main_info.draw_page ^= 1;
+                                main_info.view_page ^= 1;
+                                flippage(main_info.view_page);
+                                wait_vrt(1);
+                        }
+                        if (fade_flag != 0) {
+                                setpalette(0, 240, menu_cur_pal);
+                        }
+                        if (update_count == 1) {
+                                setpalette(240, 16, fade_pal);
+                                dj_mix();
+                                draw_begin();
+                                redraw_pob_backgrounds(main_info.draw_page);
+                                draw_end();
+                        }
+                        update_count--;
+                }
+                update_count = intr_sysupdate();
+        }
+        menu_deinit();
+        return 0;
+}
+int menu_init(void)
+{
+        char *handle;
+        int c1;
+        fillpalette(0, 0, 0);
+        if ((handle = dat_open("menu.pcx")) == 0) {
+                strcpy(main_info.error_str, "Error loading 'menu.pcx', aborting...\n");
+                return 1;
+        }
+        if (read_pcx(handle, background_pic, JNB_WIDTH*JNB_HEIGHT, menu_pal) != 0) {
+                strcpy(main_info.error_str, "Error loading 'menu.pcx', aborting...\n");
+                return 1;
+        }
+        if ((handle = dat_open("menumask.pcx")) == 0) {
+                strcpy(main_info.error_str, "Error loading 'menumask.pcx', aborting...\n");
+                return 1;
+        }
+        if (read_pcx(handle, mask_pic, JNB_WIDTH*JNB_HEIGHT, 0) != 0) {
+                strcpy(main_info.error_str, "Error loading 'menumask.pcx', aborting...\n");
+                return 1;
+        }
+        memset(menu_cur_pal, 0, 768);
+        /* fix dark font */
+        for (c1 = 0; c1 < 16; c1++) {
+                menu_pal[(240 + c1) * 3 + 0] = c1 << 2;
+                menu_pal[(240 + c1) * 3 + 1] = c1 << 2;
+                menu_pal[(240 + c1) * 3 + 2] = c1 << 2;
+        }
+        recalculate_gob(&rabbit_gobs, menu_pal);
+        recalculate_gob(&font_gobs, menu_pal);
+        recalculate_gob(&object_gobs, menu_pal);
+        register_background(background_pic, menu_pal);
+        register_mask(mask_pic);
+        for (c1 = 0; c1 < JNB_MAX_PLAYERS; c1++) {
+                player[c1].enabled = 0;
+                player[c1].x = (long) rnd(150) << 16;
+                player[c1].y = (160L + c1 * 2) << 16;
+                player[c1].x_add = 0;
+                player[c1].y_add = 0;
+                player[c1].direction = rnd(2);
+                player[c1].jump_ready = 1;
+                player[c1].anim = 0;
+                player[c1].frame = 0;
+                player[c1].frame_tick = 0;
+                player[c1].image = player_anims[player[c1].anim].frame[player[c1].frame].image;
+        }
+        for (c1 = 0; c1 < NUM_OBJECTS; c1++)
+                objects[c1].used = 0;
+        main_info.page_info[0].num_pobs = 0;
+        main_info.page_info[1].num_pobs = 0;
+        return 0;
+}
+void menu_deinit(void)
+{
+        dj_set_nosound(1);
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/sdl/Makefile
 ,0 → 1,23
+CC = kos32-gcc
+LD = kos32-ld
+SDK_DIR = $(abspath ../../../sdk)
+CFLAGS = -c -fno-ident -O2 -fomit-frame-pointer -fno-ident -U__WIN32__ -U_Win32 -U_WIN32 -U__MINGW32__ -UWIN32  -Dstricmp=strcasecmp -Dstrnicmp=strncasecmp -DUSE_SDL
+LDFLAGS = -static -S -nostdlib -T $(SDK_DIR)/sources/newlib/app.lds --image-base 0
+INCLUDES = -I$(SDK_DIR)/sources/newlib/libc/include -I$(SDK_DIR)/sources/SDL-1.2.2_newlib/include -DNDEBUG -I..
+LIBPATH = -L $(SDK_DIR)/lib -L /home/autobuild/tools/win32/mingw32/lib
+SRC = gfx.c interrpt.c sound.c input.c
+OBJECTS = $(patsubst %.c, %.o, $(SRC))
+default: $(patsubst %.c,%.o,$(SRC))
+        ar rcs libs.a *.o
+%.o : %.c Makefile $(SRC)
+        $(CC) $(CFLAGS) $(INCLUDES) -o $@ $<
+clean:
+        rm *.o
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/sdl/gfx.c
 ,0 → 1,865
+/*
+ * gfx.c
+ * Copyright (C) 1998 Brainchild Design - http://brainchilddesign.com/
+ *
+ * Copyright (C) 2001 Chuck Mason <cemason@users.sourceforge.net>
+ *
+ * Copyright (C) 2002 Florian Schulze <crow@icculus.org>
+ *
+ * This file is part of Jump'n'Bump.
+ *
+ * Jump'n'Bump is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Jump'n'Bump is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include "globals.h"
+#include "SDL_endian.h"
+#include "SDL.h"
+#include "filter.h"
+#include "jumpnbump64.xpm"
+SDL_Surface *icon;
+int screen_width=400;
+int screen_height=256;
+int screen_pitch=400;
+int scale_up=0;
+int dirty_block_shift=4;
+static SDL_Surface *jnb_surface;
+static int fullscreen = 0;
+static int vinited = 0;
+static void *screen_buffer[2];
+static int drawing_enable = 0;
+static void *background = NULL;
+static int background_drawn;
+static void *mask = NULL;
+static int dirty_blocks[2][25*16*2];
+static SDL_Surface *load_xpm_from_array(char **xpm)
+{
+#define NEXT_TOKEN { \
+        while ((*p != ' ') && (*p != '\t')) p++; \
+        while ((*p == ' ') || (*p == '\t')) p++; }
+        SDL_Surface *surface;
+        char *p;
+        int width;
+        int height;
+        int colors;
+        int images;
+        int color;
+        int pal[256];
+        int x,y;
+        p = *xpm++;
+        width = atoi(p);
+        if (width <= 0)
+                return NULL;
+        NEXT_TOKEN;
+        height = atoi(p);
+        if (height <= 0)
+                return NULL;
+        NEXT_TOKEN;
+        colors = atoi(p);
+        if (colors <= 0)
+                return NULL;
+        NEXT_TOKEN;
+        images = atoi(p);
+        if (images <= 0)
+                return NULL;
+        surface = SDL_CreateRGBSurface(SDL_SWSURFACE, width, height, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000);
+        if (!surface)
+                return NULL;
+        SDL_SetColorKey(surface, SDL_SRCCOLORKEY, SDL_MapRGBA(surface->format, 0, 0, 0, 0));
+        while (colors--) {
+                p = *xpm++;
+                color = *p++;
+                NEXT_TOKEN;
+                if (*p++ != 'c') {
+                        SDL_FreeSurface(surface);
+                        return NULL;
+                }
+                NEXT_TOKEN;
+                if (*p == '#')
+                        pal[color] = strtoul(++p, NULL, 16) | 0xff000000;
+                else
+                        pal[color] = 0;
+        }
+        y = 0;
+        while (y < height) {
+                int *pixels;
+                p = *xpm++;
+                pixels = (int *)&((char *)surface->pixels)[y++ * surface->pitch];
+                x = 0;
+                while (x < width) {
+                        Uint8 r,g,b,a;
+                        if (*p == '\0') {
+                                SDL_FreeSurface(surface);
+                                return NULL;
+                        }
+                        r = (pal[(int)*p] >> 16) & 0xff;
+                        b = (pal[(int)*p] & 0xff);
+                        g = (pal[(int)*p] >> 8) & 0xff;
+                        a = (pal[(int)*p] >> 24) & 0xff;
+                        pixels[x] = SDL_MapRGBA(surface->format, r, g, b, a);
+                        x++;
+                        p++;
+                }
+        }
+        return surface;
+}
+unsigned char *get_vgaptr(int page, int x, int y)
+{
+        assert(drawing_enable==1);
+        return (unsigned char *)screen_buffer[page] + (y*screen_pitch)+(x);
+}
+void set_scaling(int scale)
+{
+        if (scale==1) {
+                screen_width=800;
+                screen_height=512;
+                scale_up=1;
+                dirty_block_shift=5;
+                screen_pitch=screen_width;
+        } else {
+                screen_width=400;
+                screen_height=256;
+                scale_up=0;
+                dirty_block_shift=4;
+                screen_pitch=screen_width;
+        }
+}
+void open_screen(void)
+{
+        int lval = 0;
+        int flags;
+        lval = SDL_Init(SDL_INIT_TIMER | SDL_INIT_AUDIO | SDL_INIT_VIDEO );
+        if (lval < 0) {
+                fprintf(stderr, "SDL ERROR: %s\n", SDL_GetError());
+                //exit(EXIT_FAILURE);
+        }
+        flags = SDL_SWSURFACE;
+        if (fullscreen)
+                flags |= SDL_FULLSCREEN;
+        jnb_surface = SDL_SetVideoMode(screen_width, screen_height, 8, flags);
+        if (!jnb_surface) {
+                fprintf(stderr, "SDL ERROR: %s\n", SDL_GetError());
+                exit(EXIT_FAILURE);
+        }
+        if(fullscreen)
+                SDL_ShowCursor(0);
+        else
+                SDL_ShowCursor(1);
+        SDL_WM_SetCaption("Jump'n'Bump","");
+        icon=load_xpm_from_array(jumpnbump_xpm);
+        if (icon==NULL) {
+            printf("Couldn't load icon\n");
+        } else {
+            SDL_WM_SetIcon(icon,NULL);
+        }
+        vinited = 1;
+        memset(dirty_blocks, 0, sizeof(dirty_blocks));
+        screen_buffer[0]=malloc(screen_width*screen_height);
+        screen_buffer[1]=malloc(screen_width*screen_height);
+/*
+        dirty_blocks[0]=malloc(sizeof(int)*25*16+1000);
+        dirty_blocks[1]=malloc(sizeof(int)*25*16+1000);
+*/
+        return;
+}
+void fs_toggle()
+{
+        if (!vinited) {
+                fullscreen ^= 1;
+                return;
+        }
+        if (SDL_WM_ToggleFullScreen(jnb_surface))
+                fullscreen ^= 1;
+}
+void wait_vrt(int mix)
+{
+        return;
+}
+void clear_page(int page, int color)
+{
+        int i,j;
+        unsigned char *buf = get_vgaptr(page, 0, 0);
+        assert(drawing_enable==1);
+        for (i=0; i<(25*16); i++)
+                dirty_blocks[page][i] = 1;
+        for (i=0; i<screen_height; i++)
+                for (j=0; j<screen_width; j++)
+                        *buf++ = color;
+}
+void clear_lines(int page, int y, int count, int color)
+{
+        int i,j;
+        assert(drawing_enable==1);
+        if (scale_up) {
+                count *= 2;
+                y *= 2;
+        }
+        for (i=0; i<count; i++) {
+                if ((i+y)<screen_height) {
+                        unsigned char *buf = get_vgaptr(page, 0, i+y);
+                        for (j=0; j<screen_width; j++)
+                                *buf++ = color;
+                }
+        }
+        count = ((y+count)>>dirty_block_shift) - (y>>dirty_block_shift) + 1;
+        y >>= dirty_block_shift;
+        for (i=0; i<count; i++)
+                for (j=0; j<25; j++)
+                        dirty_blocks[page][(y+i)*25+j] = 1;
+}
+int get_color(int color, char pal[768])
+{
+        assert(color<256);
+        assert(pal);
+        return SDL_MapRGB(jnb_surface->format, (Uint8)(pal[color*3+0]<<2), (Uint8)(pal[color*3+1]<<2), (Uint8)(pal[color*3+2]<<2));
+}
+int get_pixel(int page, int x, int y)
+{
+        assert(drawing_enable==1);
+        if (scale_up) {
+                x *= 2;
+                y *= 2;
+        }
+        assert(x<screen_width);
+        assert(y<screen_height);
+        return *(unsigned char *)get_vgaptr(page, x, y);
+}
+void set_pixel(int page, int x, int y, int color)
+{
+        assert(drawing_enable==1);
+        if (scale_up) {
+                x *= 2;
+                y *= 2;
+        }
+        assert(x<screen_width);
+        assert(y<screen_height);
+        dirty_blocks[page][(y>>dirty_block_shift)*25+(x>>dirty_block_shift)] = 1;
+        *(unsigned char *)get_vgaptr(page, x, y) = color;
+}
+void flippage(int page)
+{
+        int x,y;
+        unsigned char *src;
+        unsigned char *dest;
+        assert(drawing_enable==0);
+        SDL_LockSurface(jnb_surface);
+        if (!jnb_surface->pixels) {
+                for (x=0; x<(25*16); x++) {
+                        dirty_blocks[0][x] = 1;
+                        dirty_blocks[1][x] = 1;
+                }
+                return;
+        }
+        dest=(unsigned char *)jnb_surface->pixels;
+        src=screen_buffer[page];
+        for (y=0; y<screen_height; y++) {
+                for (x=0; x<25; x++) {
+                        int count;
+                        int test_x;
+                        count=0;
+                        test_x=x;
+                        while ( (test_x<25) && (dirty_blocks[page][(y>>dirty_block_shift)*25+test_x]) ) {
+                                count++;
+                                test_x++;
+                        }
+                        if (count) {
+                                memcpy( &dest[y*jnb_surface->pitch+(x<<dirty_block_shift)],
+                                        &src[y*screen_pitch+((x<<dirty_block_shift))],
+                                        ((16<<dirty_block_shift)>>4)*count);
+                        }
+                        x = test_x;
+                }
+        }
+        memset(&dirty_blocks[page], 0, sizeof(int)*25*16);
+        SDL_UnlockSurface(jnb_surface);
+        SDL_Flip(jnb_surface);
+}
+void draw_begin(void)
+{
+        assert(drawing_enable==0);
+        drawing_enable = 1;
+        if (background_drawn == 0) {
+                if (background) {
+                        put_block(0, 0, 0, JNB_WIDTH, JNB_HEIGHT, background);
+                        put_block(1, 0, 0, JNB_WIDTH, JNB_HEIGHT, background);
+                } else {
+                        clear_page(0, 0);
+                        clear_page(1, 0);
+                }
+                background_drawn = 1;
+        }
+}
+void draw_end(void)
+{
+        assert(drawing_enable==1);
+        drawing_enable = 0;
+}
+void setpalette(int index, int count, char *palette)
+{
+        SDL_Color colors[256];
+        int i;
+        assert(drawing_enable==0);
+        for (i = 0; i < count; i++) {
+                colors[i+index].r = palette[i * 3 + 0] << 2;
+                colors[i+index].g = palette[i * 3 + 1] << 2;
+                colors[i+index].b = palette[i * 3 + 2] << 2;
+        }
+        SDL_SetColors(jnb_surface, &colors[index], index, count);
+}
+void fillpalette(int red, int green, int blue)
+{
+        SDL_Color colors[256];
+        int i;
+        assert(drawing_enable==0);
+        for (i = 0; i < 256; i++) {
+                colors[i].r = red << 2;
+                colors[i].g = green << 2;
+                colors[i].b = blue << 2;
+        }
+        SDL_SetColors(jnb_surface, colors, 0, 256);
+}
+void get_block(int page, int x, int y, int width, int height, void *buffer)
+{
+        unsigned char *buffer_ptr, *vga_ptr;
+        int h;
+        assert(drawing_enable==1);
+        if (scale_up) {
+                x *= 2;
+                y *= 2;
+                width *= 2;
+                height *= 2;
+        }
+        if (x < 0)
+                x = 0;
+        if (y < 0)
+                y = 0;
+        if (y + height >= screen_height)
+                height = screen_height - y;
+        if (x + width >= screen_width)
+                width = screen_width - x;
+        if (width<=0)
+                return;
+        if(height<=0)
+                return;
+        vga_ptr = get_vgaptr(page, x, y);
+        buffer_ptr = buffer;
+        for (h = 0; h < height; h++) {
+                memcpy(buffer_ptr, vga_ptr, width);
+                vga_ptr += screen_pitch;
+                buffer_ptr += width;
+        }
+}
+void put_block(int page, int x, int y, int width, int height, void *buffer)
+{
+        int h;
+        unsigned char *vga_ptr, *buffer_ptr;
+        assert(drawing_enable==1);
+        if (scale_up) {
+                x *= 2;
+                y *= 2;
+                width *= 2;
+                height *= 2;
+        }
+        if (x < 0)
+                x = 0;
+        if (y < 0)
+                y = 0;
+        if (y + height >= screen_height)
+                height = screen_height - y;
+        if (x + width >= screen_width)
+                width = screen_width - x;
+        if (width<=0)
+                return;
+        if(height<=0)
+                return;
+        vga_ptr = get_vgaptr(page, x, y);
+        buffer_ptr = buffer;
+        for (h = 0; h < height; h++) {
+                memcpy(vga_ptr, buffer_ptr, width);
+                vga_ptr += screen_pitch;
+                buffer_ptr += width;
+        }
+        width = ((x+width)>>dirty_block_shift) - (x>>dirty_block_shift) + 1;
+        height = ((y+height)>>dirty_block_shift) - (y>>dirty_block_shift) + 1;
+        x >>= dirty_block_shift;
+        y >>= dirty_block_shift;
+        while (width--)
+                for (h=0; h<height; h++)
+                        dirty_blocks[page][(y+h)*25+(x+width)] = 1;
+}
+void put_text(int page, int x, int y, char *text, int align)
+{
+        int c1;
+        int t1;
+        int width;
+        int cur_x;
+        int image;
+        assert(drawing_enable==1);
+        if (text == NULL || strlen(text) == 0)
+                return;
+        if (font_gobs.num_images == 0)
+                return;
+        width = 0;
+        c1 = 0;
+        while (text[c1] != 0) {
+                t1 = text[c1];
+                c1++;
+                if (t1 == ' ') {
+                        width += 5;
+                        continue;
+                }
+                if (t1 >= 33 && t1 <= 34)
+                        image = t1 - 33;
+                else if (t1 >= 39 && t1 <= 41)
+                        image = t1 - 37;
+                else if (t1 >= 44 && t1 <= 59)
+                        image = t1 - 39;
+                else if (t1 >= 64 && t1 <= 90)
+                        image = t1 - 43;
+                else if (t1 >= 97 && t1 <= 122)
+                        image = t1 - 49;
+                else if (t1 == '~')
+                        image = 74;
+                else if (t1 == 0x84)
+                        image = 75;
+                else if (t1 == 0x86)
+                        image = 76;
+                else if (t1 == 0x8e)
+                        image = 77;
+                else if (t1 == 0x8f)
+                        image = 78;
+                else if (t1 == 0x94)
+                        image = 79;
+                else if (t1 == 0x99)
+                        image = 80;
+                else
+                        continue;
+                width += pob_width(image, &font_gobs) + 1;
+        }
+        switch (align) {
+        case 0:
+                cur_x = x;
+                break;
+        case 1:
+                cur_x = x - width;
+                break;
+        case 2:
+                cur_x = x - width / 2;
+                break;
+        default:
+                cur_x = 0;      /* this should cause error? -Chuck */
+                break;
+        }
+        c1 = 0;
+        while (text[c1] != 0) {
+                t1 = text[c1];
+                c1++;
+                if (t1 == ' ') {
+                        cur_x += 5;
+                        continue;
+                }
+                if (t1 >= 33 && t1 <= 34)
+                        image = t1 - 33;
+                else if (t1 >= 39 && t1 <= 41)
+                        image = t1 - 37;
+                else if (t1 >= 44 && t1 <= 59)
+                        image = t1 - 39;
+                else if (t1 >= 64 && t1 <= 90)
+                        image = t1 - 43;
+                else if (t1 >= 97 && t1 <= 122)
+                        image = t1 - 49;
+                else if (t1 == '~')
+                        image = 74;
+                else if (t1 == 0x84)
+                        image = 75;
+                else if (t1 == 0x86)
+                        image = 76;
+                else if (t1 == 0x8e)
+                        image = 77;
+                else if (t1 == 0x8f)
+                        image = 78;
+                else if (t1 == 0x94)
+                        image = 79;
+                else if (t1 == 0x99)
+                        image = 80;
+                else
+                        continue;
+                put_pob(page, cur_x, y, image, &font_gobs, 1, mask_pic);
+                cur_x += pob_width(image, &font_gobs) + 1;
+        }
+}
+void put_pob(int page, int x, int y, int image, gob_t *gob, int use_mask, void *mask_pic)
+{
+        int c1, c2;
+        int pob_x, pob_y;
+        int width, height;
+        int draw_width, draw_height;
+        int colour;
+        unsigned char *vga_ptr;
+        unsigned char *pob_ptr;
+        unsigned char *mask_ptr;
+        assert(drawing_enable==1);
+        assert(gob);
+        assert(image>=0);
+        assert(image<gob->num_images);
+        if (scale_up) {
+                x *= 2;
+                y *= 2;
+                width = draw_width = gob->width[image]*2;
+                height = draw_height = gob->height[image]*2;
+                x -= gob->hs_x[image]*2;
+                y -= gob->hs_y[image]*2;
+        } else {
+                width = draw_width = gob->width[image];
+                height = draw_height = gob->height[image];
+                x -= gob->hs_x[image];
+                y -= gob->hs_y[image];
+        }
+        if ((x + width) <= 0 || x >= screen_width)
+                return;
+        if ((y + height) <= 0 || y >= screen_height)
+                return;
+        pob_x = 0;
+        pob_y = 0;
+        if (x < 0) {
+                pob_x -= x;
+                draw_width += x;
+                x = 0;
+        }
+        if ((x + width) > screen_width)
+                draw_width -= x + width - screen_width;
+        if (y < 0) {
+                pob_y -= y;
+                draw_height += y;
+                y = 0;
+        }
+        if ((y + height) > screen_height)
+                draw_height -= y + height - screen_height;
+        vga_ptr = get_vgaptr(page, x, y);
+        pob_ptr = ((unsigned char *)gob->data[image]) + ((pob_y * width) + pob_x);
+        mask_ptr = ((unsigned char *)mask) + ((y * screen_pitch) + (x));
+        for (c1 = 0; c1 < draw_height; c1++) {
+                for (c2 = 0; c2 < draw_width; c2++) {
+                        colour = *mask_ptr;
+                        if (use_mask == 0 || (use_mask == 1 && colour == 0)) {
+                                colour = *pob_ptr;
+                                if (colour != 0) {
+                                        *vga_ptr = colour;
+                                }
+                        }
+                        vga_ptr++;
+                        pob_ptr++;
+                        mask_ptr++;
+                }
+                pob_ptr += width - c2;
+                vga_ptr += (screen_width - c2);
+                mask_ptr += (screen_width - c2);
+        }
+        draw_width = ((x+draw_width)>>dirty_block_shift) - (x>>dirty_block_shift) + 1;
+        draw_height = ((y+draw_height)>>dirty_block_shift) - (y>>dirty_block_shift) + 1;
+        x >>= dirty_block_shift;
+        y >>= dirty_block_shift;
+        while (draw_width--)
+                for (c1=0; c1<draw_height; c1++)
+                        dirty_blocks[page][(y+c1)*25+(x+draw_width)] = 1;
+}
+int pob_width(int image, gob_t *gob)
+{
+        assert(gob);
+        assert(image>=0);
+        assert(image<gob->num_images);
+        return gob->width[image];
+}
+int pob_height(int image, gob_t *gob)
+{
+        assert(gob);
+        assert(image>=0);
+        assert(image<gob->num_images);
+        return gob->height[image];
+}
+int pob_hs_x(int image, gob_t *gob)
+{
+        assert(gob);
+        assert(image>=0);
+        assert(image<gob->num_images);
+        return gob->hs_x[image];
+}
+int pob_hs_y(int image, gob_t *gob)
+{
+        assert(gob);
+        assert(image>=0);
+        assert(image<gob->num_images);
+        return gob->hs_y[image];
+}
+int read_pcx(unsigned char * handle, void *buf, int buf_len, char *pal)
+{
+        unsigned char *buffer=buf;
+        short c1;
+        short a, b;
+        long ofs1;
+        if (buffer != 0) {
+                handle += 128;
+                ofs1 = 0;
+                while (ofs1 < buf_len) {
+                        a = *(handle++);
+                        if ((a & 0xc0) == 0xc0) {
+                                b = *(handle++);
+                                a &= 0x3f;
+                                for (c1 = 0; c1 < a && ofs1 < buf_len; c1++)
+                                        buffer[ofs1++] = (char) b;
+                        } else
+                                buffer[ofs1++] = (char) a;
+                }
+                if (pal != 0) {
+                        handle++;
+                        for (c1 = 0; c1 < 768; c1++)
+                                pal[c1] = *(handle++) /*fgetc(handle)*/ >> 2;
+                }
+        }
+        return 0;
+}
+void register_background(char *pixels, char pal[768])
+{
+        if (background) {
+                free(background);
+                background = NULL;
+        }
+        background_drawn = 0;
+        if (!pixels)
+                return;
+        assert(pal);
+        if (scale_up) {
+                background = malloc(screen_pitch*screen_height);
+                assert(background);
+                do_scale2x((unsigned char *)pixels, JNB_WIDTH, JNB_HEIGHT, (unsigned char *)background);
+        } else {
+                background = malloc(JNB_WIDTH*JNB_HEIGHT);
+                assert(background);
+                memcpy(background, pixels, JNB_WIDTH*JNB_HEIGHT);
+        }
+}
+int register_gob(unsigned char *handle, gob_t *gob, int len)
+{
+        unsigned char *gob_data;
+        int i;
+        gob_data = malloc(len);
+        memcpy(gob_data, handle, len);
+        gob->num_images = (short)((gob_data[0]) + (gob_data[1] << 8));
+        gob->width = malloc(gob->num_images*sizeof(int));
+        gob->height = malloc(gob->num_images*sizeof(int));
+        gob->hs_x = malloc(gob->num_images*sizeof(int));
+        gob->hs_y = malloc(gob->num_images*sizeof(int));
+        gob->data = malloc(gob->num_images*sizeof(void *));
+        gob->orig_data = malloc(gob->num_images*sizeof(void *));
+        for (i=0; i<gob->num_images; i++) {
+                int image_size;
+                int offset;
+                offset = (gob_data[i*4+2]) + (gob_data[i*4+3] << 8) + (gob_data[i*4+4] << 16) + (gob_data[i*4+5] << 24);
+                gob->width[i]  = (short)((gob_data[offset]) + (gob_data[offset+1] << 8)); offset += 2;
+                gob->height[i] = (short)((gob_data[offset]) + (gob_data[offset+1] << 8)); offset += 2;
+                gob->hs_x[i]   = (short)((gob_data[offset]) + (gob_data[offset+1] << 8)); offset += 2;
+                gob->hs_y[i]   = (short)((gob_data[offset]) + (gob_data[offset+1] << 8)); offset += 2;
+                image_size = gob->width[i] * gob->height[i];
+                gob->orig_data[i] = malloc(image_size);
+                memcpy(gob->orig_data[i], &gob_data[offset], image_size);
+                if (scale_up) {
+                        image_size = gob->width[i] * gob->height[i] * 4;
+                        gob->data[i] = malloc(image_size);
+                        do_scale2x((unsigned char *)gob->orig_data[i], gob->width[i], gob->height[i], (unsigned char *)gob->data[i]);
+                } else {
+                        gob->data[i] = (unsigned short *)gob->orig_data[i];
+                }
+        }
+        free(gob_data);
+        return 0;
+}
+void recalculate_gob(gob_t *gob, char pal[768])
+{
+}
+void register_mask(void *pixels)
+{
+        if (mask) {
+                free(mask);
+                mask = NULL;
+        }
+        assert(pixels);
+        if (scale_up) {
+                mask = malloc(screen_pitch*screen_height);
+                assert(mask);
+                do_scale2x((unsigned char *)pixels, JNB_WIDTH, JNB_HEIGHT, (unsigned char *)mask);
+        } else {
+                mask = malloc(JNB_WIDTH*JNB_HEIGHT);
+                assert(mask);
+                memcpy(mask, pixels, JNB_WIDTH*JNB_HEIGHT);
+        }
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/sdl/input.c
 ,0 → 1,113
+/*
+ * input.c
+ * Copyright (C) 1998 Brainchild Design - http://brainchilddesign.com/
+ *
+ * Copyright (C) 2001 Chuck Mason <cemason@users.sourceforge.net>
+ *
+ * Copyright (C) 2002 Florian Schulze <crow@icculus.org>
+ *
+ * This file is part of Jump'n'Bump.
+ *
+ * Jump'n'Bump is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Jump'n'Bump is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include "globals.h"
+static int num_joys=0;
+static SDL_Joystick *joys[4];
+/* assumes joysticks have at least one button, could check numbuttons first? */
+#define JOY_LEFT(num) (num_joys>num && SDL_JoystickGetAxis(joys[num], 0)<-3200)
+#define JOY_RIGHT(num) (num_joys>num && SDL_JoystickGetAxis(joys[num], 0)>3200)
+/* I find using the vertical axis to be annoying -- dnb */
+#define JOY_JUMP(num) (num_joys>num && SDL_JoystickGetButton(joys[num], 0))
+int calib_joy(int type)
+{
+        return 1;
+}
+void update_player_actions(void)
+{
+        int tmp;
+        if (client_player_num < 0) {
+                tmp = (key_pressed(KEY_PL1_LEFT) == 1) || JOY_LEFT(3);
+                if (tmp != player[0].action_left)
+                        tellServerPlayerMoved(0, MOVEMENT_LEFT, tmp);
+                tmp = (key_pressed(KEY_PL1_RIGHT) == 1) || JOY_RIGHT(3);
+                if (tmp != player[0].action_right)
+                        tellServerPlayerMoved(0, MOVEMENT_RIGHT, tmp);
+                tmp = (key_pressed(KEY_PL1_JUMP) == 1) || JOY_JUMP(3);
+                if (tmp != player[0].action_up)
+                        tellServerPlayerMoved(0, MOVEMENT_UP, tmp);
+                tmp = (key_pressed(KEY_PL2_LEFT) == 1) || JOY_LEFT(2);
+                if (tmp != player[1].action_left)
+                        tellServerPlayerMoved(1, MOVEMENT_LEFT, tmp);
+                tmp = (key_pressed(KEY_PL2_RIGHT) == 1) || JOY_RIGHT(2);
+                if (tmp != player[1].action_right)
+                        tellServerPlayerMoved(1, MOVEMENT_RIGHT, tmp);
+                tmp = (key_pressed(KEY_PL2_JUMP) == 1) || JOY_JUMP(2);
+                if (tmp != player[1].action_up)
+                        tellServerPlayerMoved(1, MOVEMENT_UP, tmp);
+                tmp = (key_pressed(KEY_PL3_LEFT) == 1) || JOY_LEFT(1);
+                if (tmp != player[2].action_left)
+                        tellServerPlayerMoved(2, MOVEMENT_LEFT, tmp);
+                tmp = (key_pressed(KEY_PL3_RIGHT) == 1) || JOY_RIGHT(1);
+                if (tmp != player[2].action_right)
+                        tellServerPlayerMoved(2, MOVEMENT_RIGHT, tmp);
+                tmp = (key_pressed(KEY_PL3_JUMP) == 1) || JOY_JUMP(1);
+                if (tmp != player[2].action_up)
+                        tellServerPlayerMoved(2, MOVEMENT_UP, tmp);
+                tmp = (key_pressed(KEY_PL4_LEFT) == 1) || JOY_LEFT(0);
+                if (tmp != player[3].action_left)
+                tellServerPlayerMoved(3, MOVEMENT_LEFT, tmp);
+                tmp = (key_pressed(KEY_PL4_RIGHT) == 1) || JOY_RIGHT(0);
+                if (tmp != player[3].action_right)
+                tellServerPlayerMoved(3, MOVEMENT_RIGHT, tmp);
+                tmp = (key_pressed(KEY_PL4_JUMP) == 1) || JOY_JUMP(0);
+                if (tmp != player[3].action_up)
+                tellServerPlayerMoved(3, MOVEMENT_UP, tmp);
+        } else {
+                tmp = (key_pressed(KEY_PL1_LEFT) == 1) || JOY_LEFT(0);
+                if (tmp != player[client_player_num].action_left)
+                        tellServerPlayerMoved(client_player_num, MOVEMENT_LEFT, tmp);
+                tmp = (key_pressed(KEY_PL1_RIGHT) == 1) || JOY_RIGHT(0);
+                if (tmp != player[client_player_num].action_right)
+                        tellServerPlayerMoved(client_player_num, MOVEMENT_RIGHT, tmp);
+                tmp = (key_pressed(KEY_PL1_JUMP) == 1) || JOY_JUMP(0);
+                if (tmp != player[client_player_num].action_up)
+                        tellServerPlayerMoved(client_player_num, MOVEMENT_UP, tmp);
+        }
+}
+void init_inputs(void)
+{
+        int i;
+        num_joys = SDL_NumJoysticks();
+        for(i = 0; i < 4 && i < num_joys; ++i)
+                joys[i] = SDL_JoystickOpen(i);
+        main_info.mouse_enabled = 0;
+        main_info.joy_enabled = 0;
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/sdl/interrpt.c
 ,0 → 1,462
+/*
+ * interrpt.c
+ * Copyright (C) 1998 Brainchild Design - http://brainchilddesign.com/
+ *
+ * Copyright (C) 2001 Chuck Mason <cemason@users.sourceforge.net>
+ *
+ * Copyright (C) 2002 Florian Schulze <crow@icculus.org>
+ *
+ * This file is part of Jump'n'Bump.
+ *
+ * Jump'n'Bump is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Jump'n'Bump is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+#include "globals.h"
+#ifdef USE_KAILLERA
+#include "SDL_thread.h"
+#include "SDL_mutex.h"
+#include <kailleraclient.h>
+char local_keyb[256];
+#endif /* USE_KAILLERA */
+char keyb[256];
+char last_keys[50];
+#ifdef USE_KAILLERA
+/* information about the party in this session */
+static int my_player = -1;
+static int my_numplayers = -1;
+/* semaphore for controlling kaillera thread */
+static SDL_sem *game_start_sem = NULL;
+/* keys supported on my end */
+static int my_player_up = -1;
+static int my_player_left = -1;
+static int my_player_right = 1;
+/* values for the kaillera client interface */
+static char kaillera_app_name[] = "Jump 'n Bump";
+static char kaillera_game_name[] = "Jump 'n Bump\0\0";
+static int player_keys[4][3] = {
+        {
+                KEY_PL1_LEFT,
+                KEY_PL1_RIGHT,
+                KEY_PL1_JUMP
+        },
+        {
+                KEY_PL2_LEFT,
+                KEY_PL2_RIGHT,
+                KEY_PL2_JUMP
+        },
+        {
+                KEY_PL3_LEFT,
+                KEY_PL3_RIGHT,
+                KEY_PL3_JUMP
+        },
+        {
+                KEY_PL4_LEFT,
+                KEY_PL4_RIGHT,
+                KEY_PL4_JUMP
+        }
+};
+static int WINAPI kaillera_game_callback(char *game, int player, int numplayers)
+{
+        int length;
+        int urand;
+        unsigned char random[8];
+        if (strcmp(game, kaillera_game_name) != 0) {
+                printf("unknown game selected: %s\n", game);
+                my_player = -1;
+                goto release;
+        }
+        printf("start network game with %d players\n", numplayers);
+        printf("I am player %d\n", player);
+        my_player = player;
+        my_numplayers = numplayers;
+        my_player_up = player_keys[player-1][0] & 0xff;
+        my_player_left = player_keys[player-1][1] & 0xff;
+        my_player_right = player_keys[player-1][2] & 0xff;
+        /* initialize randomizer agreed by all players */
+        random[0] = time(0) & 0xff;
+        random[1] = random[2] = random[3] = 0x00;
+        length = kailleraModifyPlayValues(&random, sizeof(random[0]));
+        if (length < 0) {
+                goto release;
+        }
+        urand = random[3] << 24 | random[2] << 16 | random[1] << 8 | random[0];
+        srand(urand);
+release:
+        SDL_SemPost(game_start_sem);
+        return 0;
+}
+static kailleraInfos kaillera_data = {
+        kaillera_app_name,
+        kaillera_game_name,
+        kaillera_game_callback,
+        NULL,
+        NULL,
+        NULL
+};
+static void print_version()
+{
+        char version[16];
+        kailleraGetVersion(version);
+        printf("using kaillera version %s\n", version);
+}
+static int kaillera_thread(void *arg)
+{
+        kailleraInit();
+        /* print_version(); */
+        kailleraSetInfos(&kaillera_data);
+        kailleraSelectServerDialog(0);
+        if (SDL_SemValue(game_start_sem) == 0) {
+                /* server dialog returned and game didnt start */
+                /* release blocking thread */
+                my_player = -1;
+                SDL_SemPost(game_start_sem);
+        }
+        return 0;
+}
+static int start_kaillera_thread(void)
+{
+        SDL_Thread *thread;
+        game_start_sem = SDL_CreateSemaphore(0);
+        thread = SDL_CreateThread(kaillera_thread, NULL);
+        if (!thread) {
+                printf("SDL_CreateThread failed\n");
+                return -1;
+        }
+        return 0;
+}
+int addkey(unsigned int key)
+{
+        /* it doesnt matter if a player presses keys
+         * that control other bunnies. whatever is sent
+         * is packed by pack_keys()
+         */
+        if (!(key & 0x8000)) {
+                local_keyb[key & 0x7fff] = 1;
+        } else
+                local_keyb[key & 0x7fff] = 0;
+        return 0;
+}
+void remove_keyb_handler(void)
+{
+        kailleraShutdown();
+}
+int pack_keys(void)
+{
+        int rv;
+        rv = local_keyb[my_player_up];
+        rv |= local_keyb[my_player_left] << 1;
+        rv |= local_keyb[my_player_right] << 2;
+        rv |= local_keyb[1] << 3;
+        return rv;
+}
+void unpack_keys(int player, char value)
+{
+        keyb[player_keys[player][0] & 0xff] = (value >> 0) & 1;
+        keyb[player_keys[player][1] & 0xff] = (value >> 1) & 1;
+        keyb[player_keys[player][2] & 0xff] = (value >> 2) & 1;
+        /* escape key is shared among all users */
+        keyb[1] |= (value >> 3) & 1;
+}
+int update_kaillera_keys(void)
+{
+        char keys[8];
+        int length;
+        int player;
+        keys[0] = pack_keys();
+        length = kailleraModifyPlayValues(&keys, sizeof(keys[0]));
+        if (length < 0) {
+                /* terminate session */
+                printf("** LOST CONNECTION **\n");
+                kailleraEndGame();
+                my_player = -1;
+                return -1;
+        }
+        for (player=0; player<length; player++) {
+                unpack_keys(player, keys[player]);
+        }
+        return 0;
+}
+int hook_keyb_handler(void)
+{
+        SDL_EnableUNICODE(1);
+        memset((void *) last_keys, 0, sizeof(last_keys));
+        start_kaillera_thread();
+        SDL_SemWait(game_start_sem);
+        if (my_player < 0) {
+                printf("GAME ABORTED!\n");
+                return -1;
+        }
+        printf("GAME STARTS!\n");
+        return 0;
+}
+int key_pressed(int key)
+{
+        if (key == 1 && my_player < 0) {
+                /* if game completed or aborted, post ESC */
+                return 1;
+        }
+        return keyb[(unsigned char) key];
+}
+#else /* USE_KAILLERA */
+int addkey(unsigned int key)
+{
+        int c1;
+        if (!(key & 0x8000)) {
+                keyb[key & 0x7fff] = 1;
+                for (c1 = 48; c1 > 0; c1--)
+                        last_keys[c1] = last_keys[c1 - 1];
+                last_keys[0] = key & 0x7fff;
+        } else
+                keyb[key & 0x7fff] = 0;
+        return 0;
+}
+void remove_keyb_handler(void)
+{
+}
+int hook_keyb_handler(void)
+{
+        SDL_EnableUNICODE(1);
+        memset((void *) last_keys, 0, sizeof(last_keys));
+        return 0;
+}
+int key_pressed(int key)
+{
+        return keyb[(unsigned char) key];
+}
+#endif /* USE_KAILLERA */
+int intr_sysupdate()
+{
+        SDL_Event e;
+        int i = 0;
+        static int last_time = 0;
+        int now, time_diff;
+        while (SDL_PollEvent(&e)) {
+                switch (e.type) {
+                case SDL_MOUSEBUTTONDOWN:
+                case SDL_MOUSEBUTTONUP:
+                        if(e.button.state == SDL_PRESSED &&
+                                        ((key_pressed(KEY_PL3_LEFT) && e.button.button == SDL_BUTTON_RIGHT) ||
+                                        (key_pressed(KEY_PL3_RIGHT) && e.button.button == SDL_BUTTON_LEFT) ||
+                                        (e.button.button == SDL_BUTTON_LEFT && e.button.button == SDL_BUTTON_RIGHT) ||
+          e.button.button == SDL_BUTTON_MIDDLE))
+                                {
+                                addkey(KEY_PL3_JUMP & 0x7f);
+                                }
+                        else if(e.button.state == SDL_RELEASED &&
+                                        ((key_pressed(KEY_PL3_LEFT) && e.button.button == SDL_BUTTON_RIGHT) ||
+                                        (key_pressed(KEY_PL3_RIGHT) && e.button.button == SDL_BUTTON_LEFT) ||
+          e.button.button == SDL_BUTTON_MIDDLE))
+                                {
+                                addkey((KEY_PL3_JUMP & 0x7f) | 0x8000);
+                                }
+                        if(e.button.button == SDL_BUTTON_LEFT)
+                                {
+                                SDLKey sym = KEY_PL3_LEFT;
+                                sym &= 0x7f;
+                                if(e.button.state == SDL_RELEASED)
+                                        {
+                                        if(key_pressed(KEY_PL3_JUMP) && (SDL_GetMouseState(NULL, NULL)&SDL_BUTTON(SDL_BUTTON_RIGHT)))
+                                                addkey(KEY_PL3_RIGHT & 0x7f);
+                                        else
+                                                sym |= 0x8000;
+                                        }
+                                addkey(sym);
+                                }
+                        else if(e.button.button == SDL_BUTTON_RIGHT)
+                                {
+                                SDLKey sym = KEY_PL3_RIGHT;
+                                sym &= 0x7f;
+                                if (e.button.state == SDL_RELEASED)
+                                        {
+                                        if(key_pressed(KEY_PL3_JUMP) && (SDL_GetMouseState(NULL, NULL)&SDL_BUTTON(SDL_BUTTON_LEFT)))
+                                                addkey(KEY_PL3_LEFT & 0x7f);
+                                        else
+                                                sym |= 0x8000;
+                                        }
+                                addkey(sym);
+                                }
+                        break;
+                case SDL_KEYDOWN:
+                case SDL_KEYUP:
+                        switch (e.key.keysym.sym) {
+                        case SDLK_F12:
+                                if (e.type == SDL_KEYDOWN) {
+                                        SDL_Quit();
+                                        exit(1);
+                                }
+                                break;
+                        case SDLK_F10:
+                                if (e.type == SDL_KEYDOWN) {
+                                        fs_toggle();
+                                }
+                                break;
+                        case SDLK_1:
+                                if (e.type == SDL_KEYUP)
+                                        ai[0] = !ai[0];
+                                /* Release keys, otherwise it will continue moving that way */
+                                addkey((KEY_PL1_LEFT & 0x7f) | 0x8000);
+                                addkey((KEY_PL1_RIGHT & 0x7f) | 0x8000);
+                                addkey((KEY_PL1_JUMP & 0x7f) | 0x8000);
+                                break;
+                        case SDLK_2:
+                                if (e.type == SDL_KEYUP)
+                                        ai[1] = !ai[1];
+                                /* Release keys, otherwise it will continue moving that way */
+                                addkey((KEY_PL2_LEFT & 0x7f) | 0x8000);
+                                addkey((KEY_PL2_RIGHT & 0x7f) | 0x8000);
+                                addkey((KEY_PL2_JUMP & 0x7f) | 0x8000);
+                                break;
+                        case SDLK_3:
+                                if (e.type == SDL_KEYUP)
+                                        ai[2] = !ai[2];
+                                /* Release keys, otherwise it will continue moving that way */
+                                addkey((KEY_PL3_LEFT & 0x7f) | 0x8000);
+                                addkey((KEY_PL3_RIGHT & 0x7f) | 0x8000);
+                                addkey((KEY_PL3_JUMP & 0x7f) | 0x8000);
+                                break;
+                        case SDLK_4:
+                                if (e.type == SDL_KEYUP)
+                                        ai[3] = !ai[3];
+                                /* Release keys, otherwise it will continue moving that way */
+                                addkey((KEY_PL4_LEFT & 0x7f) | 0x8000);
+                                addkey((KEY_PL4_RIGHT & 0x7f) | 0x8000);
+                                addkey((KEY_PL4_JUMP & 0x7f) | 0x8000);
+                                break;
+                        case SDLK_ESCAPE:
+                                if (e.type == SDL_KEYUP)
+                                        addkey(1 | 0x8000);
+                                else
+                                        addkey(1 & 0x7f);
+                                break;
+                        default:
+                                e.key.keysym.sym &= 0x7f;
+                                if (e.type == SDL_KEYUP)
+                                        e.key.keysym.sym |= 0x8000;
+                                addkey(e.key.keysym.sym);
+                                break;
+                        }
+                        break;
+                default:
+                        break;
+                }
+                i++;
+        }
+        SDL_Delay(1);
+        now = SDL_GetTicks();
+        time_diff = now - last_time;
+        if (time_diff>0) {
+                i = time_diff / (1000 / 60);
+                if (i) {
+                        last_time = now;
+                } else {
+                        int tmp;
+                        tmp = (1000/60) - i - 10;
+                        if (tmp>0)
+                                SDL_Delay(tmp);
+                }
+        }
+/*
+        if (!then)
+                SDL_Delay(1);
+        else {
+                then = (1000 / 60) - (now - then);
+                if (then > 0 && then < 1000)
+                        SDL_Delay(then);
+        }
+        then = now;
+*/
+#ifdef USE_KAILLERA
+        if (my_player >= 0) {
+                update_kaillera_keys();
+                i=1;
+        }
+#endif /* USE_KAILLERA */
+        return i;
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/sdl/jumpnbump128.xpm
 ,0 → 1,196
+/* XPM */
+static char * jumpnbump_xpm[] = {
+"128 128 65 1",
+"       c None",
+".      c #06070A",
+"+      c #B6B6B6",
+"@      c #F60202",
+"#      c #727272",
+"$      c #B60202",
+"%      c #5A5C5D",
+"&      c #FC8622",
+"*      c #3A1602",
+"=      c #C6C6C6",
+"-      c #A6221A",
+";      c #8E8E8E",
+">      c #D6D6D6",
+",      c #FB8E24",
+"'      c #4A2A1A",
+")      c #E6E6E6",
+"!      c #CE7222",
+"~      c #505252",
+"{      c #A15A1F",
+"]      c #F79B37",
+"^      c #FEB666",
+"/      c #AE5A0A",
+"(      c #D66C16",
+"_      c #DE6A18",
+":      c #EFEEEE",
+"<      c #7A0202",
+"[      c #FEA640",
+"}      c #664833",
+"|      c #CCA085",
+"1      c #2A2A32",
+"2      c #895F38",
+"3      c #3C3A3F",
+"4      c #EAAE7C",
+"5      c #A8805B",
+"6      c #9E9E9E",
+"7      c #FEC68E",
+"8      c #BB5E0F",
+"9      c #EE3A3A",
+"0       c #AF5207",
+"a      c #FEAE42",
+"b      c #5A2A02",
+"c      c #F8F6F9",
+"d      c #636262",
+"e      c #CB6312",
+"f      c #E67215",
+"g      c #8E4202",
+"h      c #1D1C20",
+"i      c #6A3202",
+"j      c #7A685D",
+"k      c #A4500C",
+"l      c #F5781A",
+"m      c #7A7A7A",
+"n      c #F6CEA6",
+"o      c #4A4242",
+"p      c #FEDEBF",
+"q      c #FDFEFD",
+"r      c #D67A3A",
+"s      c #FDA64D",
+"t      c #7A3A02",
+"u      c #B64242",
+"v      c #FE7A12",
+"w      c #6A6A6A",
+"x      c #DE7A2A",
+"y      c #150D0C",
+"z      c #FEAE4C",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                     6;;66                                      ",
+"                                                                                     6;;66                                      ",
+"                                                                                    6;;;##                                      ",
+"                                                                     mm           6;;;####                                      ",
+"                                                                     ##m          mm;#dwmm                                      ",
+"                                                                     ##m          mm;mw#mm                                      ",
+"                                                                    %%%~         m;;;#~%                                        ",
+"                                    mm#=66                          ~~~3         ;66#dmm                                        ",
+"                                    ;;m+6666                        ~~~3        #6;;%w66                                        ",
+"                                    ;;m+;666                   +   ~~~~3        #;;;%w66                                        ",
+"                                    ;;m+66;6                   +   ~~~~3        #6;;~w66                                        ",
+"                                    666+++::66               66d6  ~%~~o       m;6~%d6                                          ",
+"                                      6>;;==qq6             +##~;  ~%~%3w      #6m~~;                                           ",
+"                                      6:++mm::6            +;ddw6  ~~dd1~    ;;m6#mm6                                           ",
+"                                      6)++mm::6            +;ddw6  ~~dd1~    ;;m6wmm6                                           ",
+"                                      6c::##==q6         ==;mddm+  ~%ww33   ;;;;;w666                                           ",
+"                                      ;)qq++66q6         ++6mmm+=  %%##%o   mmm6;m66;                                           ",
+"                                      6=qq))66:6    7744=+++666+   %%###m66 mm#6;;66                                            ",
+"                                      6=qq))66)6    7744=+++666+   %%###m66 mmm6m;66                                            ",
+"                                       6qqcc==)q66[]]]||===>=++=   %om#m;;;;mmm6;;6;                                            ",
+"                                      4;::qq))>q66z[4z==>)))===>   33wwmmmmd;;;6;;;;                                            ",
+"                                      4;::qq))>q66a[44==>)))===>    3w#mmmmd;;;6;;;;                                            ",
+"                                      4;::qq))>q66s[44==>)))===>    3wwmmmmd;;;6;;;;                                            ",
+"                                  za[[]5))cccc:cqq^[==>>)cc>=>>n^   1%%mmmm#;;;m;m55                                            ",
+"                         xszz[[[[[[[aa[|++ccqqcqqqn4==))c))>>==^]77|.oo#mmm##mm;;m55r{}2                                        ",
+"                       e8zzaz[aa[s[sss[]jj==qqqqqqp=))::c)))>44s[[s,y11w###m;;;66666m1y.ii&&,                                   ",
+"                       8ezzaas[a[sa[^sz]#j==qqqqqqp=))::c)))>44ss[s,.11d###m;;;66666m1.yii&&&                                   ",
+"                       22]z[[z[[aas[^^77r|++ccqqqq:>))ccq::>=^4s[,,lb..ow##m;666;;666#yhxx&&&lvv,                               ",
+"                         /zzzzzz[[z^zsn:ppccqqqcqqq:ccqqc))=^ss]&!!!*hh~w##;66666hw#+633tt,&&&&&&&&,,,                          ",
+"                         txsszszsz^z77pcqqqqqqqqqqqqqqqqc))n]fffe88}}%ddw##;666661.y66mm''&&&&&&&&&&&&&&&]                      ",
+"                          ta[zzz^^^7ppcqqqqqqqqqqqqqqqqqcqq4r_((822~~~~%w##m;m;6+w..d+66~}ff&&v&v&&&v&&v&&vlv                   ",
+"                          t[[zza^^^7ppcqqqqqqqqcqqqqqqqqcqq4!((!822}~~~%d##m;;;6+w..%+66~}lf&&&&&v&&&&&&&&vvv                   ",
+"                          'ee^aaazs^:cqqqqqqqqqqqqqqqqqqqqqc^!!e0}t11oo%d##m;;;;6611166;ddflv&&,&&&v&&&&,&vs]                   ",
+"                          '!!^zzzss^::qqqqqqqqqqqqqcqqqqqqqc^!!ekt}11oo%d##m;;;66611h6662j_l&&,,&&&&&&,,]&x                     ",
+"                           bb,zszzs^::qqqqqqqqqqqqqqqqqqcqqqn!!e{''yh33%dwwm;;;;;6%dh666jjxx&&,&&v&&&&&&&&                      ",
+"                           bb]zzzzz^::qqqqqqqqcqqqqqqqqqqqqqn!!ek''yy33%dwwm;m;;;6ddy666#jxxv&&,&&,,x&,&&&                      ",
+"                             gzzs^s=))qqcc::qqqqccqqqqqqqccqq]]e{**yy33~%dd#mmm;;;mm3;;;mmrr],&&&,]]&,&&]                       ",
+"                             *//lfr=::cq6666qqqqqqcqqqqqqqqqc44eg...h33o~%%wmm#m#;;;;;;;mm''g_&&,&&,vvss                        ",
+"                             ikkffx+>>))hh66qqq:;;=qqqqqcqqqq77!g.y.13oo~~%w####mm;;;m55uubb**bb{8eess                          ",
+"                             ik0ffr+>>))hy66qqq:;;=qqqqqcqqqq77!gy..1ooo~%%d####m#;;;;;5uubby*bbkeeess                          ",
+"                      g00_fllvvvvlvr++);..::qqq;..>qqqqqqqqqqnnx0*y.1333o%%%ddww##w#m#99@@tttibb*b00&x                          ",
+"                  kgkl&vvvvlvlvv&lvlrr|~yyccqqq~yhcqqqqqqqqqqnnx8**11*h13oo~%%%ddwwd%2--$$bbgkeef,]]]]zz                        ",
+"                     t8vvvvvvvvvvvvvv&l822ppccc.ddqqqqqqqqqc:44!eii*yyyh133o~~~%~~oo~o<<tt00x&[[[sss[[]]                        ",
+"                     t8vvvvvvvvvv&lvlll8{{ppcccyddqqqqqqqqqq:44!8ii*yhyy133o~~~%~~oo~~<<tt88x,[[[[[[[[]]                        ",
+"                       0/lvvl&lvll&lvvvvllllssp.66qqqqcqqqqqprreegg****y.yh11113o3~}2/__,][[[[[[[[[[[[[[]                       ",
+"                       00lv&lvvllvvv&vlvlvllssp.66qqqqccqqqqprre8gg****..hh11113o3}o2{__],[[[[[[[[[[[[[[,                       ",
+"                         t8ll&vv&vlvvvvvvvlllfl{nnqcqqqqq::)=rree88k*yy.....hhh}{e!fv][[a[[[[[[[[[[[[[[[[[                      ",
+"                           {{_lvvvlv&lvlvvvlvvlv&&^:cccc:>>>|!feekg*.....y*t!x!l,]s[sz[[[[[[s][[][[[[[[[[]z                     ",
+"                           {{(vlvvvvll&vvvllvvlv&&^ccccc:>>>|r!eekk*.....*ytf!fl,][[[z[[[[[[[s[[[[[][[[[[]z                     ",
+"                             ikklf&v&lvvvlvvlvvlvvl,44===>>|!ee__ib..**gevv][sszz[zz[[[[s][[[[[[][[[[[[[[[,                     ",
+"                             ibi**/&&&vvvl&vllvvvvllvv&l4|4re_(e_gg{l]][saazss[a[z[[s[s]zs[]s[[[[[[[[][[[[[]]                   ",
+"                           iiiiiiiiiff&,&&lv&vlvllv&lll&l(_((fff&[[aszzasaas[aasa[sz[z[[[[s[[[[[[[[[[[[[[[[[[[                  ",
+"                           iiiiiiiiiff&&&&vlvvvvv&v&lllll__f_ffl&[[asazzsaasaaasa[zz[z[[[[[[[]s[[][[[[[[[[[[[[                  ",
+"                           iiiiiiiii**i8&&lv&&&&vlvf00ttbbb0e!fazssazzzs[ssaaa[sasaaszs][[azs[[[[s[[s][[[[[[[[                  ",
+"                           iiiiiiiiibiiiii((vvfe{kbiiiiiibbkekk]zzzzzasaz[[z[[[a[[zs[[zzs[sz[as]z[[]zs[s[[[[[[[                 ",
+"                           iiiiiiiiiiiiiiiiibb*iiiiiiiiiiii/_kk!zzzsszzzsaszzzz[z[aaaszs[[aaszss[sza[][[][][[],                 ",
+"                           iiiiiiiiiiiiiiiiibb*iiiiiiiiiiii8_kkezzzssazzszazszs[z[aaz[zz[[aasass[saa[s[[s[][[]]                 ",
+"                           iiiiiiiiiiiiiiiiibi*iiiiiiiiiiii/_kk!zzzzszzzzzzzazz]z[aaz[zzs]a[sas][saa[[[[[[]]]                   ",
+"                          iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiitt8f//0sszzzzzzszzzzzz[sassas[assaaz]zas[[ass][&!                      ",
+"                          iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiitte(eek!^^szzzsz[szazzzzs[[saaz[[zz[za]za[sx,!5d#                      ",
+"                          iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiitte(eek!^aaazzzzs]szzzzasaasazz[[zz[z[[sa[[,r58dw                      ",
+"                          iiib-iiiiiiiiiiiiiiiiiiiiiiiiiitt_fee/k]]szzzzzzzszzazzz[[asaas]aazz[[]r5m#www#wd                     ",
+"                          iiiiiibiiiiiiiiiiiiiiiiiiiiiiiigke__(/k//zszzzszzzss]szzssz[zszz[[,!88k2dd#mwww                       ",
+"                          iiiiiib-iiiiiiiiiiiiiiiiiiiiiiikg(e((8kkk!^szzzsszszzzazzszz[[xx08kk00kwm#ww                          ",
+"                          iiiiiiiibiiiiiiiiiiiiiiiiiiiiii0k_(((e0k0k]z^[zzzzzzzszszz,!/8k/k00000{w##ww                          ",
+"                          iiiiiiiiiiib-iiiib-iiib-iiiiiiik0_(((8000g]^^szazzszzzzzzz]!80kk000000{w##ww                          ",
+"                          iiiiiiiiiiiiibiiiiibiiiiibiiiii08(e((e0//k/[[zsszzzzz],r880k00000000002#m#wwmm                        ",
+"                          iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiie8(e((e0//0k88s^]]x8//k0k00000000000000######w#w                       ",
+"                          iiiiiiiiiiiiiiiiiiiiiiiiii-biii88(e((e///0k8ezz]]r08/00/000/000k000000j##m##www;                      ",
+"                          iiiiiib-iiiiiiiiiiiiiiiiiiiiiii8e_e((e0//0ge8sz]]x/8/0kkk0k0k0000k0000######w#w;                      ",
+"                             iiiiiibi-biiiiiiiiiiiiiiiiit!!(e((e/k/0/kk{e{0k000000000000k0000k{/w#w######w#                     ",
+"                              iiiiiiiiiiiib-iiiiiiiiiiiit8e(ee(e/k0/{k0kkkk/kkk00/0k000k/0000022#w#########ww                   ",
+"                                  iiiiiiiiiibiiiiibiiiiikeeeeeee8//k/00/k//00000k0000k0000k0{2jj#############w                  ",
+"                                  iiiiiiiiib-iiiiiiiiiiigeeeeeee8//k/00/k//00k00000000000000{2jj#w############                  ",
+"                                   iiiiiiiiiiibiiiiiiiiik__!eeee8kk//kk/0/0//kk00k0k/k00{{2jw#m######w#ww#wwwww                 ",
+"                                    b-iiiiiiiii-iiiiiiii0e(eeeeeekk/k00/k0k0kkk000000{22jj##################ww#                 ",
+"                                      iiiiiiiiibiiiiiiii/eeeeee8e00k/kk0k00k/k00/k{{jw##wwww############www;;                   ",
+"                                      iiiiiiiiiiiiiiiiii8ee8ee(8e00//kk0kk0k00k000{{jw#mwwww##m#########w#w;;                   ",
+"                                        iiiiiiiiiiiiiiii0eeee88ee000/kk/k0/k000k2jww#w##w#######ww#####w#                       ",
+"                                          iiiiiiiiiiiiii!eee8!8(888kk/00000k2j2j##ww#www###www#w#mw#dw                          ",
+"                                           iiiiiii-biiiieeee8eee888kk0k000/k2j2###ww#ww###wwwwww#m                              ",
+"                                           iiiibiiiiiiii!eee8eeee88kk000k0k{222j##wwmwww##w#wwwwwm                              ",
+"                                              iiiiiiibtte88!888/80000kk{222#www#ww##ww##wwdd#;                                  ",
+"                                                iiiibbgk88e88e880!e{jjjw#ww##wwwmwww#wdd##                                      ",
+"                                                  tbbbkg!88/0//x    wwww#www##mww##wdm                                          ",
+"                                                   tbbkk088!         wwww##wwww#dw;;                                            ",
+"                                                   }bbk/088!         wwww##w#ww#dw;;                                            ",
+"                                                      88               ww#wwddd#                                                ",
+"                                                                        www#                                                    ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                ",
+"                                                                                                                                "};
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/sdl/jumpnbump32.xpm
 ,0 → 1,100
+/* XPM */
+static char * jumpnbump_xpm[] = {
+"32 32 65 1",
+"       c None",
+".      c #261814",
+"+      c #B3B3B2",
+"@      c #EC7818",
+"#      c #747373",
+"$      c #B83A18",
+"%      c #6D6D6B",
+"&      c #C8C1BB",
+"*      c #6B3203",
+"=      c #DB8434",
+"-      c #E28A32",
+";      c #DCCEC6",
+">      c #CA7C30",
+",      c #A05618",
+"'      c #2A262A",
+")      c #999998",
+"!      c #F59239",
+"~      c #9B4E10",
+"{      c #EFE8E4",
+"]      c #FDB055",
+"^      c #AB530B",
+"/      c #3A363A",
+"(      c #8F8E8D",
+"_      c #CE6915",
+":      c #6A4E3A",
+"<      c #BEB8B2",
+"[      c #EF9A47",
+"}      c #F4F1F0",
+"|      c #C0691C",
+"1      c #661834",
+"2      c #C8A68C",
+"3      c #434143",
+"4      c #894209",
+"5      c #C2610F",
+"6      c #F79E3F",
+"7      c #848482",
+"8      c #504C4C",
+"9      c #5E2E06",
+"0       c #823E06",
+"a      c #F6C29E",
+"b      c #EAB68A",
+"c      c #967A60",
+"d      c #D6A67A",
+"e      c #8B6241",
+"f      c #B66016",
+"g      c #FDA542",
+"h      c #FCFCFD",
+"i      c #846A54",
+"j      c #E6A86C",
+"k      c #ABA7A5",
+"l      c #BA590C",
+"m      c #F8DCC2",
+"n      c #AE9276",
+"o      c #864C1E",
+"p      c #585757",
+"q      c #E0DDDB",
+"r      c #733403",
+"s      c #5E3A1E",
+"t      c #7B7B7B",
+"u      c #FEAA48",
+"v      c #F68627",
+"w      c #F97B13",
+"x      c #746D6A",
+"y      c #DAB69E",
+"z      c #B45A0F",
+"                                ",
+"                                ",
+"                     ))         ",
+"                 x  (7#         ",
+"       )k       p8  (##         ",
+"       k)&    ((p3  (%)         ",
+"       }k<<  kt(p8 7t(          ",
+"       qq+h b+(+p%)7()          ",
+"       )}{&6y;& 8#t7(           ",
+"   vuuu[q}}bq{;]ppt7(|:         ",
+"   >ugu]kqh{}{&[~3t((tsvwv      ",
+"   ,=]]{hhhhh{-f8p7)px#@vvvvv   ",
+"    ,]]}hhhhhhjo'8t(tp7@vvvvv   ",
+"    ~>j{&{{}hhms.8%t7%cf|w!!    ",
+" ~__w@@nt})}hhm4./p%%#$*05!     ",
+"  ^@www@=a<hhh;,..//8:$=66g6    ",
+"   ~_ww@w@6{hqdl119o=!uggggg    ",
+"    *0_wwwwv[d_l~|6guuggggggg   ",
+"    *9*~z_l~~~|6uuuugggugggggg  ",
+"    ******9**45guu]uugugugg66!  ",
+"    *********4_-]uuuuguuu[>c    ",
+"    ***9*****~_^-]]]u6=zfi%     ",
+"    ***r**9**l_^^[!=|^^^^x%%    ",
+"    9********l5z^||^^^^^,##x%   ",
+"      ******r5_l^^^^^^^ex%%x%%  ",
+"       ***r*055fz^^,^e%x####t#  ",
+"        ****0_5l^^,exx%%#%%%    ",
+"          **4555ex%%%%%         ",
+"           *~l   %x%##          ",
+"                                ",
+"                                ",
+"                                "};
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/sdl/jumpnbump64.xpm
 ,0 → 1,132
+/* XPM */
+static char * jumpnbump_xpm[] = {
+"64 64 65 1",
+"       c None",
+".      c #171010",
+"+      c #B2B2B2",
+"@      c #E61E1A",
+"#      c #6E6C6B",
+"$      c #C20606",
+"%      c #D0C6C4",
+"&      c #FA7A12",
+"*      c #411A05",
+"=      c #D06D19",
+"-      c #DA8636",
+";      c #5B5B5B",
+">      c #979696",
+",      c #F18A2D",
+"'      c #D9D6D4",
+")      c #7D0A5E",
+"!      c #BD752F",
+"~      c #E8DED9",
+"{      c #BABABA",
+"]      c #8B8A88",
+"^      c #F28E39",
+"/      c #724E32",
+"(      c #5A2A02",
+"_      c #CA6410",
+":      c #E7E3DF",
+"<      c #FEB256",
+"[      c #AB5309",
+"}      c #D69256",
+"|      c #EEEAEA",
+"1      c #563216",
+"2      c #828282",
+"3      c #C26210",
+"4      c #6A3202",
+"5      c #875F3D",
+"6      c #D5B5A0",
+"7      c #832907",
+"8      c #D9711E",
+"9      c #EF9E49",
+"0       c #F2F2F2",
+"a      c #302C2F",
+"b      c #7A7A7A",
+"c      c #C6AA92",
+"d      c #434043",
+"e      c #FECA96",
+"f      c #BA5A0A",
+"g      c #A64911",
+"h      c #FB8321",
+"i      c #E5A673",
+"j      c #AD621E",
+"k      c #505150",
+"l      c #7E6552",
+"m      c #A9A6A3",
+"n      c #F5B683",
+"o      c #843F05",
+"p      c #FAA23A",
+"q      c #9E5A26",
+"r      c #FAD6BA",
+"s      c #92765A",
+"t      c #974C0A",
+"u      c #FCFCFD",
+"v      c #F07616",
+"w      c #FEA847",
+"x      c #727272",
+"y      c #F5993F",
+"z      c #222026",
+"                                                                ",
+"                                                                ",
+"                                                                ",
+"                                                                ",
+"                                                                ",
+"                                           >>>                  ",
+"                                          >>2b                  ",
+"                                  #x     ]2b#x                  ",
+"                                 k;k    2]2x#                   ",
+"              2+m                ;dd    ]>b#b                   ",
+"              ]mm>>              ;ka    >>#;>                   ",
+"               %>++0         ]] kkkd    22xx                    ",
+"               :+>m|>       mx] ;k;a   2xx2                     ",
+"               0:bb':      m2#> k;;d  ]2b2>                     ",
+"               |u+m+u     {m2b+ ;;#k  222>>                     ",
+"               %0''m0   n6++m>  ;;#b> b]>>>                     ",
+"               m000%~mpyi6%%%+  ;k#2]]x]>>                      ",
+"               >:uu:%cww6%':'%   d#bxb]]>]                      ",
+"            www!'u000|<i':0:%'n  a;2b2]2]]                      ",
+"       ,wwwwww<}m|0uu|e6'00''%pnc.dxxxb]]]!j/                   ",
+"      !<<pwwww<ws{{uuu:'|0|:'6wy,.z#x2]>>>]k.4-h                ",
+"      j-wwww<w<e6%%uuu|:000:%iy-81zkb]>>2b]2dj&h&&,             ",
+"       q-w<w<<e|uuuuu0uuuu0'p,_j/;;;b]>>#z;>]dv,,hhhhhhh        ",
+"        t9<<<nruuuuuuuuuuuuri8f5ddk;x]]>]dd]c;8hhh,h,h^hh       ",
+"        o-<<w<:uuuuuuuuuuuuue-[/aad;x2]>>;ax>#8&,,hhhh^h,       ",
+"        4!ww<nruuuuuuuuuuuuur-q4zzd;x2]>>#dx>x8h,,&hh,^h        ",
+"         t-ww6:u0u0uuuuuuuuu09j*..d;#b22>bkb>b8^hh,^,hhy        ",
+"          t8,c'0b+{u0{:uuuuuuej..zdk;#xx22xb]jooot=&yy          ",
+"      f8&v=v&-cmz%:u'k:uuuuuur=*.zdd;;###xsxf@41((4_^^          ",
+"   t[vvv&&&&&v-#.|0u'k0uuuuu0r=*.aaakk;;##x5g$4otf=^yp          ",
+"     [&&&&&&&&&f5~|0'buuuuuu0%=4*..zdkkk;kdk)7t8hpypppp         ",
+"      3&&&&&&&&&v&&nr+uuuuuu|}=o***.zaaadd/q3vpwwpppwwy         ",
+"       t=&&&&&&&&&&v^ru0uu|:'}_ft*.)..z1q8h^wwwpwwppppww        ",
+"         j8&&&&&&&&&&^n||0:'683g*)))(j8,^py<wwwpppwppppw        ",
+"          of8&&&&&&&&h&pi{%c-_=4)((q,ppww<wwwppwwpwwwwppp       ",
+"         44(o=&&&&&&&&&&&^}-==vf!^wpwwwwwwwwpwwpppwpwpwppp      ",
+"         44444q_=vv&v=_=_=jf__,wpw<wwww<pwwwwpwwwppwwpppwww     ",
+"         44444444[[3gt(4444g_f9w<wwwwwwwpwwwwwwwwwwwpwwpppp     ",
+"         4444444444(*444444t_f9w<ww<<wwwwwwp<wwwwwwwppwppp^     ",
+"        444444444444(447444g_f9<wwwww<w<p<wwwpwwpwwwwwy,        ",
+"        4444474447444444444[__-w<<<w<ww<pwwwwwwwwwwwy-!!        ",
+"        744444444(444444474[8_fyww<wwwwwwwwwwww<wwy!ssxx        ",
+"        444444444474444444o3__[f-<<ww<<w<ww<w,=_3!jx##          ",
+"        444444444444444444o38=f[[p<ww<w<<wy-=j[[[[q###          ",
+"        447(74444444474444g___f[[fwwwwwwy8f[[[[[[[lx##          ",
+"        4444444444444(4444g_==fqft=<98ff[[[[[[[[[[xxx##         ",
+"        4444447(7(47444474t___f[[t=9-8[[[[[[[[[g[[xxx###        ",
+"           444444444444444g=__3[f[[[[[[[[[[[[[[[[5xxbxx##       ",
+"            4444444444444of_=_3[[[[[j[[[[[[[[[[ql##x#xxx##      ",
+"             444444444444o___33[[[[[[[[[[[[[[qlxbxx########     ",
+"              44444474444o3____[j[[[[[q[[[qql#xxxxxxxxxxxxx     ",
+"                444444444t3f3_ff[[[[[[[g[55####xxxxx#x##]       ",
+"                 44444474t3__33[[[[[[[qq5#x######x#xx;x         ",
+"                   444444t__33ff[[[qqll#xx######b               ",
+"                    44444[_33j33q55l######x###                  ",
+"                     44(4[f3f3   #####x##x;##                   ",
+"                       4offf      #######bb                     ",
+"                                    #x                          ",
+"                                                                ",
+"                                                                ",
+"                                                                ",
+"                                                                ",
+"                                                                ",
+"                                                                "};
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/sdl/sound.c
 ,0 → 1,568
+/*
+ * sound.c
+ * Copyright (C) 1998 Brainchild Design - http://brainchilddesign.com/
+ *
+ * Copyright (C) 2001 Chuck Mason <cemason@users.sourceforge.net>
+ *
+ * Copyright (C) 2002 Florian Schulze <crow@icculus.org>
+ *
+ * This file is part of Jump'n'Bump.
+ *
+ * Jump'n'Bump is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Jump'n'Bump is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include "globals.h"
+#include <limits.h>
+#ifndef _MSC_VER
+#include <unistd.h>
+#endif
+#include "SDL.h"
+#ifndef NO_SDL_MIXER
+#include "SDL_mixer.h"
+static Mix_Music *current_music = (Mix_Music *) NULL;
+#endif
+sfx_data sounds[NUM_SFX];
+static int SAMPLECOUNT = 512;
+#define MAX_CHANNELS    32
+typedef struct {
+        /* loop flag */
+        int loop;
+        /* The channel step amount... */
+        unsigned int step;
+        /* ... and a 0.16 bit remainder of last step. */
+        unsigned int stepremainder;
+        unsigned int samplerate;
+        /* The channel data pointers, start and end. */
+        signed short* data;
+        signed short* startdata;
+        signed short* enddata;
+        /* Hardware left and right channel volume lookup. */
+        int leftvol;
+        int rightvol;
+} channel_info_t;
+channel_info_t channelinfo[MAX_CHANNELS];
+/* Sample rate in samples/second */
+int audio_rate = 44100;
+int global_sfx_volume = 0;
+/*
+// This function loops all active (internal) sound
+//  channels, retrieves a given number of samples
+//  from the raw sound data, modifies it according
+//  to the current (internal) channel parameters,
+//  mixes the per channel samples into the given
+//  mixing buffer, and clamping it to the allowed
+//  range.
+//
+// This function currently supports only 16bit.
+*/
+static void stopchan(int i)
+{
+        if (channelinfo[i].data) {
+                memset(&channelinfo[i], 0, sizeof(channel_info_t));
+        }
+}
+/*
+// This function adds a sound to the
+//  list of currently active sounds,
+//  which is maintained as a given number
+//  (eight, usually) of internal channels.
+// Returns a handle.
+*/
+int addsfx(signed short *data, int len, int loop, int samplerate, int channel)
+{
+        stopchan(channel);
+        /* We will handle the new SFX. */
+        /* Set pointer to raw data. */
+        channelinfo[channel].data = data;
+        channelinfo[channel].startdata = data;
+        /* Set pointer to end of raw data. */
+        channelinfo[channel].enddata = channelinfo[channel].data + len - 1;
+        channelinfo[channel].samplerate = samplerate;
+        channelinfo[channel].loop = loop;
+        channelinfo[channel].stepremainder = 0;
+        return channel;
+}
+static void updateSoundParams(int slot, int volume)
+{
+        int rightvol;
+        int leftvol;
+        /*
+        // Set stepping
+        // MWM 2000-12-24: Calculates proportion of channel samplerate
+        // to global samplerate for mixing purposes.
+        // Patched to shift left *then* divide, to minimize roundoff errors
+        // as well as to use SAMPLERATE as defined above, not to assume 11025 Hz
+        */
+        channelinfo[slot].step = ((channelinfo[slot].samplerate<<16)/audio_rate);
+        leftvol = volume;
+        rightvol= volume;
+        /* Sanity check, clamp volume. */
+        if (rightvol < 0)
+                rightvol = 0;
+        if (rightvol > 127)
+                rightvol = 127;
+        if (leftvol < 0)
+                leftvol = 0;
+        if (leftvol > 127)
+                leftvol = 127;
+        channelinfo[slot].leftvol = leftvol;
+        channelinfo[slot].rightvol = rightvol;
+}
+void mix_sound(void *unused, Uint8 *stream, int len)
+{
+        /* Mix current sound data. */
+        /* Data, from raw sound, for right and left. */
+        register int sample;
+        register int    dl;
+        register int    dr;
+        /* Pointers in audio stream, left, right, end. */
+        signed short*   leftout;
+        signed short*   rightout;
+        signed short*   leftend;
+        /* Step in stream, left and right, thus two. */
+        int       step;
+        /* Mixing channel index. */
+        int       chan;
+        /* Left and right channel */
+        /*  are in audio stream, alternating. */
+        leftout = (signed short *)stream;
+        rightout = ((signed short *)stream)+1;
+        step = 2;
+        /* Determine end, for left channel only */
+        /*  (right channel is implicit). */
+        leftend = leftout + (len/4)*step;
+        /* Mix sounds into the mixing buffer. */
+        /* Loop over step*SAMPLECOUNT, */
+        /*  that is 512 values for two channels. */
+        while (leftout != leftend) {
+                /* Reset left/right value. */
+                dl = *leftout * 256;
+                dr = *rightout * 256;
+                /* Love thy L2 chache - made this a loop. */
+                /* Now more channels could be set at compile time */
+                /*  as well. Thus loop those  channels. */
+                for ( chan = 0; chan < MAX_CHANNELS; chan++ ) {
+                        /* Check channel, if active. */
+                        if (channelinfo[chan].data) {
+                                /* Get the raw data from the channel. */
+                                /* no filtering */
+                                /* sample = *channelinfo[chan].data; */
+                                /* linear filtering */
+                                sample = (int)(((int)channelinfo[chan].data[0] * (int)(0x10000 - channelinfo[chan].stepremainder))
+                                        + ((int)channelinfo[chan].data[1] * (int)(channelinfo[chan].stepremainder))) >> 16;
+                                /* Add left and right part */
+                                /*  for this channel (sound) */
+                                /*  to the current data. */
+                                /* Adjust volume accordingly. */
+                                dl += sample * (channelinfo[chan].leftvol * global_sfx_volume) / 128;
+                                dr += sample * (channelinfo[chan].rightvol * global_sfx_volume) / 128;
+                                /* Increment index ??? */
+                                channelinfo[chan].stepremainder += channelinfo[chan].step;
+                                /* MSB is next sample??? */
+                                channelinfo[chan].data += channelinfo[chan].stepremainder >> 16;
+                                /* Limit to LSB??? */
+                                channelinfo[chan].stepremainder &= 0xffff;
+                                /* Check whether we are done. */
+                                if (channelinfo[chan].data >= channelinfo[chan].enddata) {
+                                        if (channelinfo[chan].loop) {
+                                                channelinfo[chan].data = channelinfo[chan].startdata;
+                                        } else {
+                                                stopchan(chan);
+                                        }
+                                }
+                        }
+                }
+                /* Clamp to range. Left hardware channel. */
+                /* Has been char instead of short. */
+                /* if (dl > 127) *leftout = 127; */
+                /* else if (dl < -128) *leftout = -128; */
+                /* else *leftout = dl; */
+                dl = dl / 256;
+                dr = dr / 256;
+                if (dl > SHRT_MAX)
+                        *leftout = SHRT_MAX;
+                else if (dl < SHRT_MIN)
+                        *leftout = SHRT_MIN;
+                else
+                        *leftout = (signed short)dl;
+                /* Same for right hardware channel. */
+                if (dr > SHRT_MAX)
+                        *rightout = SHRT_MAX;
+                else if (dr < SHRT_MIN)
+                        *rightout = SHRT_MIN;
+                else
+                        *rightout = (signed short)dr;
+                /* Increment current pointers in stream */
+                leftout += step;
+                rightout += step;
+        }
+}
+/* misc handling */
+char dj_init(void)
+{
+        Uint16 audio_format = MIX_DEFAULT_FORMAT;
+        int audio_channels = 2;
+        int audio_buffers = 4096;
+        open_screen();
+        if (main_info.no_sound)
+                return 0;
+        audio_buffers = SAMPLECOUNT*audio_rate/11025;
+        memset(channelinfo, 0, sizeof(channelinfo));
+        memset(sounds, 0, sizeof(sounds));
+#ifndef NO_SDL_MIXER
+        if (Mix_OpenAudio(audio_rate, audio_format, audio_channels, audio_buffers) < 0) {
+                fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError());
+                main_info.no_sound = 1;
+                return 1;
+        }
+        Mix_QuerySpec(&audio_rate, &audio_format, &audio_channels);
+        printf("Opened audio at %dHz %dbit %s, %d bytes audio buffer\n", audio_rate, (audio_format & 0xFF), (audio_channels > 1) ? "stereo" : "mono", audio_buffers);
+        Mix_SetMusicCMD(getenv("MUSIC_CMD"));
+        Mix_SetPostMix(mix_sound, NULL);
+#else
+        main_info.no_sound = 1;
+        return 1;
+#endif
+        return 0;
+}
+void dj_deinit(void)
+{
+        if (main_info.no_sound)
+                return;
+#ifndef NO_SDL_MIXER
+        Mix_HaltMusic();
+        if (current_music)
+                Mix_FreeMusic(current_music);
+        current_music = NULL;
+        Mix_CloseAudio();
+#endif
+        SDL_Quit();
+}
+void dj_start(void)
+{
+}
+void dj_stop(void)
+{
+}
+char dj_autodetect_sd(void)
+{
+        return 0;
+}
+char dj_set_stereo(char flag)
+{
+        return 0;
+}
+void dj_set_auto_mix(char flag)
+{
+}
+unsigned short dj_set_mixing_freq(unsigned short freq)
+{
+        return freq;
+}
+void dj_set_dma_time(unsigned short time)
+{
+}
+void dj_set_nosound(char flag)
+{
+}
+/* mix handling */
+void dj_mix(void)
+{
+}
+/* sfx handling */
+char dj_set_num_sfx_channels(char num_channels)
+{
+        return num_channels;
+}
+void dj_set_sfx_volume(char volume)
+{
+        if (main_info.no_sound)
+                return;
+        SDL_LockAudio();
+        global_sfx_volume = volume*2;
+        SDL_UnlockAudio();
+}
+void dj_play_sfx(unsigned char sfx_num, unsigned short freq, char volume, char panning, unsigned short delay, char channel)
+{
+        int slot;
+        if (main_info.music_no_sound || main_info.no_sound)
+                return;
+        if (channel<0) {
+                for (slot=0; slot<MAX_CHANNELS; slot++)
+                        if (channelinfo[slot].data==NULL)
+                                break;
+                if (slot>=MAX_CHANNELS)
+                        return;
+        } else
+                slot = channel;
+        SDL_LockAudio();
+        addsfx((short *)sounds[sfx_num].buf, sounds[sfx_num].length, sounds[sfx_num].loop, freq, slot);
+        updateSoundParams(slot, volume*2);
+        SDL_UnlockAudio();
+}
+char dj_get_sfx_settings(unsigned char sfx_num, sfx_data *data)
+{
+        if (main_info.no_sound)
+                return 0;
+        memcpy(data, &sounds[sfx_num], sizeof(sfx_data));
+        return 0;
+}
+char dj_set_sfx_settings(unsigned char sfx_num, sfx_data *data)
+{
+        if (main_info.no_sound)
+                return 0;
+        memcpy(&sounds[sfx_num], data, sizeof(sfx_data));
+        return 0;
+}
+void dj_set_sfx_channel_volume(char channel_num, char volume)
+{
+        if (main_info.no_sound)
+                return;
+        SDL_LockAudio();
+        updateSoundParams(channel_num, volume*2);
+        SDL_UnlockAudio();
+}
+void dj_stop_sfx_channel(char channel_num)
+{
+        if (main_info.no_sound)
+                return;
+        SDL_LockAudio();
+        stopchan(channel_num);
+        SDL_UnlockAudio();
+}
+char dj_load_sfx(unsigned char * file_handle, char *filename, int file_length, char sfx_type, unsigned char sfx_num)
+{
+        unsigned int i;
+        unsigned char *src;
+        unsigned short *dest;
+        if (main_info.no_sound)
+                return 0;
+        sounds[sfx_num].buf = malloc(file_length);
+        memcpy(sounds[sfx_num].buf, file_handle, file_length);
+        sounds[sfx_num].length = file_length / 2;
+        src = sounds[sfx_num].buf;
+        dest = (unsigned short *)sounds[sfx_num].buf;
+        for (i=0; i<sounds[sfx_num].length; i++)
+        {
+                unsigned short temp;
+                temp = src[0] + (src[1] << 8);
+                *dest = temp;
+                src += 2;
+                dest++;
+        }
+        return 0;
+}
+void dj_free_sfx(unsigned char sfx_num)
+{
+        if (main_info.no_sound)
+                return;
+        free(sounds[sfx_num].buf);
+        memset(&sounds[sfx_num], 0, sizeof(sfx_data));
+}
+/* mod handling */
+char dj_ready_mod(char mod_num)
+{
+#ifndef NO_SDL_MIXER
+        FILE *tmp;
+# if ((defined _MSC_VER) || (defined __MINGW32__))
+        char filename[] = "jnb.tmpmusic.mod";
+# else
+        char filename[] = "/tmp/jnb.tmpmusic.mod";
+# endif
+        unsigned char *fp;
+        int len;
+        if (main_info.no_sound)
+                return 0;
+        switch (mod_num) {
+        case MOD_MENU:
+                fp = dat_open("jump.mod");
+                len = dat_filelen("jump.mod");
+                break;
+        case MOD_GAME:
+                fp = dat_open("bump.mod");
+                len = dat_filelen("bump.mod");
+                break;
+        case MOD_SCORES:
+                fp = dat_open("scores.mod");
+                len = dat_filelen("scores.mod");
+                break;
+        default:
+                fprintf(stderr, "bogus parameter to dj_ready_mod()\n");
+                fp = NULL;
+                len = 0;
+                break;
+        }
+        if (Mix_PlayingMusic())
+                Mix_FadeOutMusic(1500);
+        if (current_music) {
+                Mix_FreeMusic(current_music);
+                current_music = NULL;
+        }
+        if (fp == NULL) {
+                return 0;
+        }
+        tmp = fopen(filename, "wb");
+        if (tmp) {
+        fwrite(fp, len, 1, tmp);
+                fflush(tmp);
+                fclose(tmp);
+        }
+        current_music = Mix_LoadMUS(filename);
+        unlink(filename);
+        if (current_music == NULL) {
+                fprintf(stderr, "Couldn't load music: %s\n", SDL_GetError());
+                return 0;
+        }
+#endif
+        return 0;
+}
+char dj_start_mod(void)
+{
+#ifndef NO_SDL_MIXER
+        if (main_info.no_sound)
+                return 0;
+        Mix_VolumeMusic(0);
+        Mix_PlayMusic(current_music, -1);
+#endif
+        return 0;
+}
+void dj_stop_mod(void)
+{
+#ifndef NO_SDL_MIXER
+        if (main_info.no_sound)
+                return;
+        Mix_HaltMusic();
+#endif
+}
+void dj_set_mod_volume(char volume)
+{
+#ifndef NO_SDL_MIXER
+        if (main_info.no_sound)
+                return;
+        Mix_VolumeMusic(volume);
+#endif
+}
+char dj_load_mod(unsigned char * file_handle, char *filename, char mod_num)
+{
+        return 0;
+}
+void dj_free_mod(char mod_num)
+{
+}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

 /contrib/other/jumpnbump/stub.c
 ,0 → 1,24
+int SDL_JoystickGetAxis(void){return -1;}
+int SDL_JoystickGetButton(void){return -1;}
+int SDL_NumJoysticks (void)  {return -1;}
+int SDL_JoystickOpen(void) {return -1;}
+Mix_VolumeMusic(void) {}
+ Mix_PlayMusic(void) {}
+Mix_PlayingMusic(void) {}
+ Mix_FadeOutMusic(void) {}
+ Mix_FreeMusic(void) {}
+ Mix_LoadMUS(void) {}
+ Mix_HaltMusic(void) {}
+ Mix_CloseAudio(void) {}
+Mix_OpenAudio(void) {}
+Mix_QuerySpec(void) {}
+Mix_SetMusicCMD(void) {}
+Mix_SetPostMix(void) {}
 Property changes:
 Added: svn:executable
 +*
 \ No newline at end of property

Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 8525 → Rev 8526