/contrib/other/jumpnbump/AUTHORS |
---|
0,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,0 → 1,340 |
GNU GENERAL PUBLIC LICENSE |
Version 2, June 1991 |
Copyright (C) 1989, 1991 Free Software Foundation, Inc. |
59 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 |
0. 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. |
1. 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. |
2. 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. |
3. 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 |
1 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. |
4. 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. |
5. 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. |
6. 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. |
7. 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. |
8. 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. |
9. 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. |
10. 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 |
11. 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. |
12. 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,0 → 1,95 |
27 Jun 2004 - 1.51 |
- refactored code to make it a bit simpler |
- Added AI by Ricardo Cruz |
30 Mar 2004 - 1.42 |
- added support for gzip and bzip2 packed levels. |
21 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. |
17 Aug 2002 - 1.39 |
- added -noflies option |
- added client/server networking. Thanks to Ryan C. Gordon who did the base |
work for it. |
11 Aug 2002 - 1.35 |
- gobpack added |
- documentation updated |
- little fixes here and there |
2 Aug 2002 - 1.34 |
- fixed too dark font |
- attempt to fix sound and scaleup on big endian systems |
5 Jul 2002 - 1.33 |
- added -musicnosound option |
15 Jun 2002 - 1.32 |
- fix for off by one in -mirror |
add icon for application (macosx,windows,x) |
10 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 |
9 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 |
24 Feb 2002 - 1.1 |
- fixed timing problems |
- fixed crash when temporary music can't be written |
22 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. |
25 Feb 2001 - 0.69 |
initial linux port, worked fine with freebsd too (chuck mason) |
26 Feb 2001 - 0.69 |
made sound be played (chuck mason) |
03 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) |
16 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!) |
20 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,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,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,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 |
5635-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,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,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,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,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,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,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,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] = { |
{ |
6, 0, { |
{ |
0, 3}, { |
1, 3}, { |
2, 3}, { |
3, 3}, { |
4, 3}, { |
5, 3}, { |
0, 0}, { |
0, 0}, { |
0, 0}, { |
0, 0} |
} |
}, { |
9, 0, { |
{ |
6, 2}, { |
7, 2}, { |
8, 2}, { |
9, 2}, { |
10, 2}, { |
11, 2}, { |
12, 2}, { |
13, 2}, { |
14, 2}, { |
0, 0} |
} |
}, { |
5, 0, { |
{ |
15, 3}, { |
16, 3}, { |
16, 3}, { |
17, 3}, { |
18, 3}, { |
19, 3}, { |
0, 0}, { |
0, 0}, { |
0, 0}, { |
0, 0} |
} |
}, { |
10, 0, { |
{ |
20, 2}, { |
21, 2}, { |
22, 2}, { |
23, 2}, { |
24, 2}, { |
25, 2}, { |
24, 2}, { |
23, 2}, { |
22, 2}, { |
21, 2} |
} |
}, { |
10, 0, { |
{ |
26, 2}, { |
27, 2}, { |
28, 2}, { |
29, 2}, { |
30, 2}, { |
31, 2}, { |
30, 2}, { |
29, 2}, { |
28, 2}, { |
27, 2} |
} |
}, { |
10, 0, { |
{ |
32, 2}, { |
33, 2}, { |
34, 2}, { |
35, 2}, { |
36, 2}, { |
37, 2}, { |
36, 2}, { |
35, 2}, { |
34, 2}, { |
33, 2} |
} |
}, { |
10, 0, { |
{ |
38, 2}, { |
39, 2}, { |
40, 2}, { |
41, 2}, { |
42, 2}, { |
43, 2}, { |
42, 2}, { |
41, 2}, { |
40, 2}, { |
39, 2} |
} |
}, { |
4, 0, { |
{ |
76, 4}, { |
77, 4}, { |
78, 4}, { |
79, 4}, { |
0, 0}, { |
0, 0}, { |
0, 0}, { |
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] = { |
63,32,32,53,17,17,42, 7, |
7,28, 0, 0,24, 0, 0,19, |
0, 0,12, 0, 0, 7, 0, 0 |
}; |
char water[32] = { |
63,63,63,40,53,62,19,42, |
60, 0,33,60, 3,32,46, 3, |
26,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[] = { |
1, 0, 0, 0x7fff, 0, 0, 0, 0, 0, 0, |
4, 0, 0, 4, 1, 4, 2, 4, 3, 4, |
1, 0, 4, 0x7fff, 0, 0, 0, 0, 0, 0, |
4, 2, 5, 8, 6, 10, 7, 3, 6, 3, |
1, 0, 6, 0x7fff, 0, 0, 0, 0, 0, 0, |
2, 1, 5, 8, 4, 0x7fff, 0, 0, 0, 0, |
1, 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, ®s); |
#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,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,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,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,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,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,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,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,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,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,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 |