mirror of
https://github.com/lowbit/ps5-doom.git
synced 2026-10-06 05:00:25 +02:00
Native DOOM for PS5 from id's linuxdoom-1.10 source
id Software's original engine, made 64-bit clean, on a new platform layer: VideoOut with tiled scanout, an AGC compute presenter, ScePad, AudioOut, an OPL FM synth with a DMX-style MUS player, and a headless PC build for testing. Ships Freedoom as the bundled game; id's own IWADs take priority.
This commit is contained in:
rijads committed
commit
61c14ce8a2
175 files changed
+57170
No files matched your search
@@ -0,0 +1,5 @@
|
||||
build/
|
||||
dist/
|
||||
.deps/
|
||||
out/
|
||||
wads/
|
||||
+140
@@ -0,0 +1,140 @@
|
||||
# DOOM for PS5 (native)
|
||||
|
||||
id Software's original `linuxdoom-1.10` source running as a native PS5 title: its own home-screen
|
||||
icon, launched like a game, drawing through Sony's VideoOut and AGC (GPU) drivers, reading the
|
||||
DualSense through ScePad and playing sound through AudioOut. Title ID `PPSA99666`.
|
||||
|
||||
All PS5, platform, audio and test code here is written for this project. The only external code
|
||||
is id's game source and the build tools listed at the end.
|
||||
|
||||
## Layout
|
||||
|
||||
| Path | What |
|
||||
| --- | --- |
|
||||
| `src/doom/` | id's original game code with the 64-bit and portability fixes listed below |
|
||||
| `src/port/` | Doom's `i_*` layer (main, system, video, sound, network, controller mapping) on top of the platform API |
|
||||
| `src/platform/platform.h` | The platform API: time, log, files, video present, pad, rumble, audio output |
|
||||
| `src/audio/` | Sound engine: SFX mixer, MUS sequencer with DMX-style voice allocation, OPL FM synth |
|
||||
| `src/ps5/` | PS5 backend: startup (`crt0.c`), system, VideoOut, AGC compute presenter, pad, AudioOut |
|
||||
| `src/ps5/present.cl` | GPU kernel: palette lookup, sharp-bilinear scaling to 1080p, tiled scanout writes (gfx1010, wave64) |
|
||||
| `src/host/` | Headless Linux backend for testing on the PC: PNG frames, scripted pad, WAV audio |
|
||||
| `test/` | `render_music` (MUS lump to WAV) and `present_preview` (runs the GPU kernel's math on the CPU) |
|
||||
| `title/` | `param.json` and the icon |
|
||||
| `tools/` | Tool fetch, shareware WAD fetch, kernel embedding, deploy |
|
||||
|
||||
## Build
|
||||
|
||||
Everything builds in the `ps5-doom-build` image (`docker/Dockerfile`: clang/lld/llvm 18, ninja, gdb).
|
||||
|
||||
```bash
|
||||
docker build -t ps5-doom-build docker/
|
||||
MSYS_NO_PATHCONV=1 docker run --rm -v "$(cygpath -w "$PWD"):/src" -w /src ps5-doom-build make -j16 ps5 host
|
||||
```
|
||||
|
||||
`make ps5` fetches the pinned tools and the shareware WAD on first use, then:
|
||||
|
||||
1. compiles the game and the PS5 layer for `x86_64-sie-ps5` against the PS5 payload SDK headers;
|
||||
2. compiles `present.cl` for `gfx1010` (wave64), links it and embeds it with `tools/embed-kernel.py`, which
|
||||
reads the register values from the compiler's kernel descriptor and fails the build if the
|
||||
kernel needs anything the presenter does not set up;
|
||||
3. generates `libSceAgc` / `libSceAgcDriver` import stubs from `src/ps5/stubs/*.txt` (the SDK has none);
|
||||
4. links a PIE, converts it to a PS5 module, signs the FSELF and assembles `dist/PPSA99666/`.
|
||||
|
||||
## Testing on the PC
|
||||
|
||||
`build/host/bin/doom` is the same game on the headless backend. Environment variables:
|
||||
`DOOM_WADDIR`, `DOOM_SAVEDIR`, `DOOM_OUT` (frame output dir), `DOOM_CAPTURE` (frame numbers to
|
||||
save as PNG plus raw indices and palette), `DOOM_FRAMES` (exit after N frames), `DOOM_AUDIO`
|
||||
(absolute WAV path), `DOOM_INPUT` (pad script: `frame:BUTTON+BUTTON+LX=-32000:frames;...`).
|
||||
|
||||
```bash
|
||||
DOOM_OUT=out DOOM_CAPTURE=120,900 build/host/bin/doom -timedemo demo1
|
||||
```
|
||||
|
||||
For memory errors, build with AddressSanitizer:
|
||||
`make host HOST_DIR=build/asan HOST_FLAGS="-O1 -g -fsanitize=address" HOST_CC="clang -fsanitize=address"`.
|
||||
|
||||
## On the console
|
||||
|
||||
`uv run --no-project python tools/deploy.py` uploads `dist/PPSA99666` to `/data/homebrew/PPSA99666`
|
||||
(PS5Upload helper must be running), where ShadowMountPlus registers it. The package bundles Freedoom
|
||||
(`tools/fetch-freedoom.sh`). id's IWADs (`DOOM.WAD`, `DOOM2.WAD`, `PLUTONIA.WAD`, `TNT.WAD`) dropped
|
||||
into `/data/homebrew/PPSA99666/wads/` take priority; order: DOOM II-style id WADs, DOOM-style id
|
||||
WADs, Freedoom 2, Freedoom 1; holding L2 at launch prefers the DOOM-style game. `make release` writes
|
||||
`dist/PPSA99666.zip` and its `.sha256`.
|
||||
|
||||
The app is sandboxed: it reads `/app0` (its folder) and writes `/download0` (config, saves and
|
||||
`doom.log`). Log lines also go to the kernel log (`sceKernelDebugOutText`), readable with klogsrv.
|
||||
Fatal errors show as a system notification.
|
||||
|
||||
Presentation uses the AGC compute path by default. Hold **L1+R1** while the game starts to force the
|
||||
CPU scaler. If a GPU frame does not complete within 500 ms, the game switches to the CPU scaler by
|
||||
itself and logs why.
|
||||
|
||||
## Console testing
|
||||
|
||||
`tools/console_test.py <plan>` runs the deployed title hands-free: it writes the plan as `test.cfg`
|
||||
into the title folder, launches through the `doomlaunch` payload (`tools/launcher`, put into
|
||||
`/data/pldmgr/payloads/doomlaunch/`), pulls captured frames over TCP from the running game (the
|
||||
app listens on 9119; the PC firewall blocks the other direction), de-tiles them to PNG in
|
||||
`build/test/run/`, prints the log from klogsrv (port 3232, captured to `build/test/klog.txt`), then
|
||||
deletes `test.cfg`. Plan lines: `input <steps>`, `capture <frames>`, `frames <N>` (clean exit),
|
||||
`present cpu`. Plans: `test/console-play.cfg` (menus, play, save, load), `console-cpu.cfg`,
|
||||
`console-soak.cfg` (6 minutes).
|
||||
|
||||
## PS5 facts learned on hardware (FW 13.00)
|
||||
|
||||
- `downloadDataSize` 64 is rejected (`0x80a40087`, launch fails); 256 works.
|
||||
- The libc heap of a native app is small: large blocks must come from `mmap` (the zone does).
|
||||
- The sandbox refuses `access`, `chdir`, `opendir`, `dup`, `dup2` (EPERM). `open` works. Saves use
|
||||
explicit `/download0/...` paths; output is captured by pointing `stdout`/`stderr` at a pipe
|
||||
(`fdopen`), and klog wants one line per `sceKernelDebugOutText`.
|
||||
- Scanout must be tiled (`sceVideoOutSetBufferAttribute2` tiling 0; 1 is `0x80290007`), 16 MB per
|
||||
1080p buffer. Pixel layout: 512x128 tiles with the bit interleave in `src/ps5/tiling.h`.
|
||||
- GPU memory: direct memory type 12, protection 0x33, CPU writes flushed with `clflush` before GPU
|
||||
use and invalidated before CPU reads of GPU output (`ps5_cache_flush`).
|
||||
- Compute runs as wave64 whatever the dispatch flag says, and the GPU mishandles the gfx10.3 `null`
|
||||
carry-out operand (writes are dropped). The kernel is built for gfx1010, wave64; `embed-kernel.py`
|
||||
rejects wave32. GPU page faults appear in klog as `GPU Protection fault ... addr(VA)`.
|
||||
- After rest mode ShadowMountPlus can lose its install hook ("TitleDir bridge unavailable");
|
||||
restarting the ShadowMountPlus payload through the Payload Manager fixes it without a reboot.
|
||||
|
||||
## Controls
|
||||
|
||||
| Input | In game | In menus |
|
||||
| --- | --- | --- |
|
||||
| Left stick | Move and strafe (analog) | Navigate |
|
||||
| Right stick | Turn (analog; speed follows the Mouse Sensitivity slider) | |
|
||||
| D-pad | Move and turn (digital) | Navigate (repeats when held) |
|
||||
| R2 | Fire | |
|
||||
| Cross / Square | Use | Select (Cross), answers yes to prompts |
|
||||
| Circle | Strafe modifier | Back, answers no to prompts |
|
||||
| L1 / R1 | Previous / next weapon (zoom on the automap) | |
|
||||
| L2 | Run | |
|
||||
| Triangle / touchpad | Automap (Square toggles follow mode on the map) | |
|
||||
| Options | Menu | Close menu |
|
||||
|
||||
Saving needs no keyboard: an empty slot is pre-filled with the level name, Cross saves.
|
||||
|
||||
## Changes to id's code
|
||||
|
||||
- 64-bit: pointers stored in `int` (config string defaults, save game pointer fields, the
|
||||
`columndirectory` field of the on-disk texture struct), pointer arrays sized `count*4`
|
||||
(`r_data.c`, `p_setup.c`), table alignment through `int` casts, 16-byte zone alignment.
|
||||
- Undefined behaviour and latent bugs: the unterminated `sprnames` list, unsequenced event queue
|
||||
updates, button array resets that cleared 8 bytes of pointers, save games written into the
|
||||
screen buffers (now a dedicated 4 MB buffer).
|
||||
- Portability: no `values.h`/`alloca.h`/sound server; IWAD search through `I_GetWadDirs`; config in
|
||||
the working directory (the port changes into the save directory at start).
|
||||
- Behaviour: 1.9 demos play (the WADs' attract demos); empty save slots get a default name;
|
||||
default SFX channels 8 (the DOS default) instead of 3; Freedoom IWADs recognised; static limits
|
||||
raised (visplanes, drawsegs, sprites, openings, intercepts, plats, ceilings, buttons, scrollers)
|
||||
so limit-removing maps such as Freedoom's run.
|
||||
|
||||
## External tools (pinned)
|
||||
|
||||
- [ps5-native-app-boilerplate](https://github.com/blackbearreloaded/ps5-native-app-boilerplate)
|
||||
`b1315a9`: its `ps5-native-tool` (PIE to PS5 module, FSELF signing), its clean-room `libc.prx`,
|
||||
its intermediate PIE linker script, and the PS5 payload SDK v0.42 it fetches. Built in
|
||||
`.deps/native-app` by `tools/fetch-native-tools.sh`; nothing from it is copied into `src/`.
|
||||
- clang/lld/llvm 18 (x86_64-sie-ps5 and amdgcn targets).
|
||||
@@ -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.
|
||||
@@ -0,0 +1,116 @@
|
||||
DOOM_SRC := $(wildcard src/doom/*.c)
|
||||
PORT_SRC := $(wildcard src/port/*.c) $(wildcard src/audio/*.c) $(wildcard src/platform/*.c)
|
||||
HOST_SRC := $(wildcard src/host/*.c)
|
||||
PS5_SRC := $(wildcard src/ps5/*.c)
|
||||
|
||||
INCLUDES := -Isrc/doom -Isrc/port -Isrc/platform -Isrc/audio
|
||||
DOOM_WARNINGS := -Wall -Wno-unused-const-variable -Wno-unused-but-set-variable \
|
||||
-Wno-unused-variable -Wno-logical-not-parentheses -Wno-missing-braces
|
||||
OWN_WARNINGS := -Wall -Wextra -Wno-unused-parameter
|
||||
|
||||
HOST_CC := clang
|
||||
HOST_FLAGS := -O2 -g -fno-strict-aliasing -MMD -MP
|
||||
|
||||
HOST_DIR := build/host
|
||||
HOST_OBJ := $(patsubst src/%.c,$(HOST_DIR)/%.o,$(DOOM_SRC) $(PORT_SRC) $(HOST_SRC))
|
||||
|
||||
TITLE := PPSA99666
|
||||
NATIVE := .deps/native-app
|
||||
SDK := $(NATIVE)/.deps/native/ps5-payload-sdk
|
||||
NATIVE_TOOL := $(NATIVE)/build/host/ps5-native-tool
|
||||
RUNTIME := $(NATIVE)/runtime/libc.prx
|
||||
|
||||
PS5_DIR := build/ps5
|
||||
PS5_GEN := $(PS5_DIR)/gen
|
||||
PS5_STUBS := $(PS5_DIR)/stubs
|
||||
PS5_OBJ := $(patsubst src/%.c,$(PS5_DIR)/%.o,$(DOOM_SRC) $(PORT_SRC) $(PS5_SRC))
|
||||
AGC_STUBS := $(patsubst src/ps5/stubs/%.txt,$(PS5_STUBS)/%.so,$(wildcard src/ps5/stubs/*.txt))
|
||||
PS5_CC := clang -target x86_64-sie-ps5 -fvisibility-nodllstorageclass=default \
|
||||
-isysroot $(SDK) -isystem $(SDK)/target/include \
|
||||
-fno-stack-protector -fno-plt -femulated-tls -ffunction-sections -fdata-sections
|
||||
PS5_FLAGS := -O2 -fno-strict-aliasing -MMD -MP
|
||||
APP := dist/$(TITLE)
|
||||
|
||||
.PHONY: host ps5 release tools clean
|
||||
|
||||
host: $(HOST_DIR)/bin/doom
|
||||
|
||||
$(HOST_DIR)/bin/doom: $(HOST_OBJ)
|
||||
@mkdir -p $(dir $@)
|
||||
$(HOST_CC) -o $@ $^ -lm -lpthread
|
||||
|
||||
$(HOST_DIR)/doom/%.o: src/doom/%.c
|
||||
@mkdir -p $(dir $@)
|
||||
$(HOST_CC) -std=gnu99 $(HOST_FLAGS) $(DOOM_WARNINGS) $(INCLUDES) -c $< -o $@
|
||||
|
||||
$(HOST_DIR)/%.o: src/%.c
|
||||
@mkdir -p $(dir $@)
|
||||
$(HOST_CC) -std=gnu11 $(HOST_FLAGS) $(OWN_WARNINGS) $(INCLUDES) -c $< -o $@
|
||||
|
||||
tools: $(NATIVE_TOOL)
|
||||
|
||||
$(NATIVE_TOOL) $(RUNTIME) $(SDK)/target/lib/libkernel.so:
|
||||
bash tools/fetch-native-tools.sh
|
||||
|
||||
wads/DOOM1.WAD:
|
||||
bash tools/fetch-shareware.sh $@
|
||||
|
||||
wads/freedoom2.wad:
|
||||
bash tools/fetch-freedoom.sh wads
|
||||
|
||||
ps5: $(APP)/eboot.bin
|
||||
|
||||
$(PS5_STUBS)/.sdk: $(SDK)/target/lib/libkernel.so
|
||||
@mkdir -p $(PS5_STUBS)
|
||||
cp $(SDK)/target/lib/*.so $(PS5_STUBS)/
|
||||
@touch $@
|
||||
|
||||
$(PS5_STUBS)/%.so: src/ps5/stubs/%.txt $(PS5_STUBS)/.sdk
|
||||
sed 's/.*/void &(void) {}/' $< > $(PS5_STUBS)/$*.c
|
||||
$(PS5_CC) -fPIC -c $(PS5_STUBS)/$*.c -o $(PS5_STUBS)/$*.o
|
||||
$(SDK)/bin/prospero-lld --shared -soname $*.sprx -o $@ $(PS5_STUBS)/$*.o
|
||||
|
||||
$(PS5_GEN)/present_kernel.h: src/ps5/present.cl tools/embed-kernel.py
|
||||
@mkdir -p $(PS5_GEN)
|
||||
clang -target amdgcn-amd-amdhsa -mcpu=gfx1010 -mwavefrontsize64 -x cl -cl-std=CL1.2 -O3 -nogpulib \
|
||||
-c $< -o $(PS5_GEN)/present.o
|
||||
ld.lld -shared $(PS5_GEN)/present.o -o $(PS5_GEN)/present.co
|
||||
python3 tools/embed-kernel.py $(PS5_GEN)/present.co present $@
|
||||
|
||||
$(PS5_DIR)/ps5/gpu.o: $(PS5_GEN)/present_kernel.h
|
||||
|
||||
$(PS5_DIR)/doom/%.o: src/doom/%.c $(SDK)/target/lib/libkernel.so
|
||||
@mkdir -p $(dir $@)
|
||||
$(PS5_CC) -std=gnu99 $(PS5_FLAGS) $(DOOM_WARNINGS) $(INCLUDES) -c $< -o $@
|
||||
|
||||
$(PS5_DIR)/%.o: src/%.c $(SDK)/target/lib/libkernel.so
|
||||
@mkdir -p $(dir $@)
|
||||
$(PS5_CC) -std=gnu11 $(PS5_FLAGS) $(OWN_WARNINGS) $(INCLUDES) -I$(PS5_GEN) -c $< -o $@
|
||||
|
||||
$(PS5_DIR)/llvm-pie.elf: $(PS5_OBJ) $(AGC_STUBS) src/ps5/symbols.map
|
||||
$(SDK)/bin/prospero-lld -T $(NATIVE)/tooling/native/ps5-pie.ld --eh-frame-hdr --gc-sections \
|
||||
--version-script src/ps5/symbols.map -e _start -o $@ $(PS5_OBJ) \
|
||||
--as-needed $(PS5_STUBS)/*.so
|
||||
|
||||
$(PS5_DIR)/eboot.elf: $(PS5_DIR)/llvm-pie.elf $(NATIVE_TOOL)
|
||||
$(NATIVE_TOOL) link --in $< --out $@ --stub-dir $(PS5_STUBS) \
|
||||
--module-sdk 0x02000009 --companion-sdk 0x08050001 --file-name eboot.elf
|
||||
|
||||
$(APP)/eboot.bin: $(PS5_DIR)/eboot.elf $(RUNTIME) title/param.json title/icon0.png wads/freedoom2.wad
|
||||
rm -rf $(APP)
|
||||
mkdir -p $(APP)/sce_sys $(APP)/sce_module $(APP)/wads
|
||||
$(NATIVE_TOOL) self --sign --in $< --out $@ --magic 0x1D3D154F
|
||||
cp $(RUNTIME) $(APP)/sce_module/libc.prx
|
||||
cp title/param.json title/icon0.png $(APP)/sce_sys/
|
||||
cp wads/freedoom1.wad wads/freedoom2.wad wads/FREEDOOM-COPYING.txt wads/FREEDOOM-CREDITS.txt $(APP)/wads/
|
||||
$(NATIVE_TOOL) self --inspect --file $@
|
||||
$(NATIVE_TOOL) self --inspect --file $(APP)/sce_module/libc.prx
|
||||
|
||||
release: $(APP)/eboot.bin
|
||||
rm -f dist/$(TITLE).zip dist/$(TITLE).zip.sha256
|
||||
cd dist && python3 -m zipfile -c $(TITLE).zip $(TITLE) && sha256sum $(TITLE).zip > $(TITLE).zip.sha256
|
||||
|
||||
-include $(HOST_OBJ:.o=.d) $(PS5_OBJ:.o=.d)
|
||||
|
||||
clean:
|
||||
rm -rf build dist
|
||||
@@ -0,0 +1,52 @@
|
||||
<p align="center"><img src="title/icon0.png" width="160" alt="DOOM icon"></p>
|
||||
|
||||
# DOOM for PS5 (native)
|
||||
|
||||
id Software's original DOOM source (`linuxdoom-1.10`) running as a native PS5 title: its own
|
||||
home-screen icon, drawn on the GPU through Sony's AGC driver and VideoOut, DualSense input with
|
||||
analog sticks and rumble, and the DOS-era FM music synthesised from the game's own instrument bank.
|
||||
It ships with [Freedoom](https://freedoom.github.io/), a free full-length game, and plays id's
|
||||
DOOM and DOOM II if you add your own WADs.
|
||||
|
||||
## Requirements
|
||||
|
||||
A jailbroken PS5 with kstuff (fake-signed executables) and
|
||||
[ShadowMountPlus](https://github.com/drakmor/ShadowMountPlus). Tested on firmware 13.00.
|
||||
|
||||
## Install
|
||||
|
||||
1. Download `PPSA99666.zip` from the [releases](../../releases) and check it against
|
||||
`PPSA99666.zip.sha256`.
|
||||
2. Extract it and copy the `PPSA99666` folder to `/data/homebrew/` (FTP, ps5upload or USB).
|
||||
3. ShadowMountPlus registers it within a few seconds and **DOOM** appears on the home screen.
|
||||
|
||||
## Games
|
||||
|
||||
- Launch normally: Freedoom Phase 2 (DOOM II style, 32 maps).
|
||||
- Hold **L2** while it starts: Freedoom Phase 1 (DOOM style, 4 episodes).
|
||||
- Your own `DOOM.WAD`, `DOOM2.WAD`, `PLUTONIA.WAD` or `TNT.WAD` in `/data/homebrew/PPSA99666/wads/`
|
||||
take priority over Freedoom (DOOM II first; hold L2 for DOOM).
|
||||
|
||||
## Controls
|
||||
|
||||
| Input | In game | In menus |
|
||||
| --- | --- | --- |
|
||||
| Left stick | Move and strafe | Navigate |
|
||||
| Right stick | Turn (speed follows Mouse Sensitivity) | |
|
||||
| D-pad | Move and turn | Navigate |
|
||||
| R2 | Fire | |
|
||||
| Cross / Square | Use | Select, yes |
|
||||
| Circle | Strafe modifier | Back, no |
|
||||
| L1 / R1 | Previous / next weapon (automap zoom) | |
|
||||
| L2 | Run | |
|
||||
| Triangle / touchpad | Automap (Square: follow mode) | |
|
||||
| Options | Menu | Close menu |
|
||||
|
||||
Saves and settings stay on the console. Holding **L1+R1** at launch uses the CPU scaler instead of
|
||||
the GPU, should a firmware ever disagree with the GPU path.
|
||||
|
||||
## Building and internals
|
||||
|
||||
See [DEVELOPMENT.md](DEVELOPMENT.md) for the build, the architecture, the console test loop and the
|
||||
PS5 behaviour learned along the way. Licenses and credits: [LICENSE](LICENSE) (GPL v2, id's
|
||||
source) and [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).
|
||||
@@ -0,0 +1,36 @@
|
||||
# Third-party notices
|
||||
|
||||
Everything in this project that came from someone else, what it is used for, and its license.
|
||||
|
||||
## Shipped in the release
|
||||
|
||||
| Component | Used as | License |
|
||||
| --- | --- | --- |
|
||||
| [DOOM source code](https://github.com/id-Software/DOOM) (`linuxdoom-1.10`), id Software | The game engine in `src/doom/`, with the changes listed in `DEVELOPMENT.md` | GNU GPL v2 (`LICENSE`) |
|
||||
| [Freedoom](https://freedoom.github.io/) 0.13.0, Freedoom project | Bundled game data: `wads/freedoom1.wad`, `wads/freedoom2.wad` | BSD 3-Clause (`wads/FREEDOOM-COPYING.txt`, credits in `wads/FREEDOOM-CREDITS.txt`) |
|
||||
| `libc.prx` from [ps5-native-app-boilerplate](https://github.com/blackbearreloaded/ps5-native-app-boilerplate), BlackBearReloaded | Runtime module the PS5 loader requires next to a native title (`sce_module/libc.prx`), built from its source at commit `b1315a9` | GNU GPL v3 or later |
|
||||
|
||||
## Used to build
|
||||
|
||||
| Component | Used as | License |
|
||||
| --- | --- | --- |
|
||||
| [ps5-native-app-boilerplate](https://github.com/blackbearreloaded/ps5-native-app-boilerplate) `b1315a9` | `ps5-native-tool` (PIE to PS5 module conversion, FSELF signing) and its intermediate linker script `ps5-pie.ld`, fetched by `tools/fetch-native-tools.sh`, not copied into this repository | GNU GPL v3 or later |
|
||||
| [PS5 Payload SDK](https://github.com/ps5-payload-dev/sdk) v0.42, John Törnblom | C library headers, system import stubs, `prospero-lld`; the SDK compiler wrapper for the test launcher payload | GNU GPL v3 |
|
||||
| [LLVM/Clang](https://llvm.org/) 18 | C compiler for the x86-64 PS5 target and the AMDGPU compute kernel | Apache 2.0 with LLVM exception |
|
||||
| DOOM shareware IWAD (`DOOM1.WAD`), id Software | Regression data for the PC test build only (demo playback); fetched by `tools/fetch-shareware.sh`, not shipped | id Software shareware terms |
|
||||
|
||||
## Studied for platform facts (no code copied)
|
||||
|
||||
These open-source projects were read to learn how the PS5's system interfaces behave. Their code was
|
||||
not copied; the facts they document are hardware and system behaviour.
|
||||
|
||||
| Project | What was learned | License |
|
||||
| --- | --- | --- |
|
||||
| [ps5-opengl](https://github.com/blackbearreloaded/ps5-opengl) | AGC call sequence (wait-for-safe-render, command buffer layout, dispatch, flip, suspend point), compute register offsets, direct memory type and cache maintenance, the RELEASE_MEM/WAIT_REG_MEM fence pattern and its packet constants | GNU GPL v3 or later |
|
||||
| [SDL PS5 port](https://github.com/ps5-payload-dev/SDL) | VideoOut, ScePad and AudioOut call contracts and the tiled scanout pixel layout | zlib |
|
||||
| [ps5-native-app-boilerplate](https://github.com/blackbearreloaded/ps5-native-app-boilerplate) | Native title startup contract, `param.json` fields, sandbox notes | GNU GPL v3 or later |
|
||||
| [ps5-yamagi-quake2](https://github.com/blackbearreloaded/ps5-yamagi-quake2) | Native app heap limits and the system exit path | GNU GPL v3 or later |
|
||||
| [websrv](https://github.com/ps5-payload-dev/websrv), [ps5upload](https://github.com/phantomptr/ps5upload) | How homebrew is launched and how files reach the console (the test tools use ps5upload's helper) | GNU GPL v3 |
|
||||
|
||||
DOOM is a registered trademark of id Software / ZeniMax Media. This project is not affiliated with
|
||||
or endorsed by them. No commercial game data is included.
|
||||
@@ -0,0 +1,8 @@
|
||||
FROM ubuntu:24.04
|
||||
ENV DEBIAN_FRONTEND=noninteractive
|
||||
RUN apt-get update && apt-get install -y --no-install-recommends \
|
||||
ca-certificates wget unzip make ninja-build python3 git file xxd gdb \
|
||||
clang-18 lld-18 llvm-18 libclang-rt-18-dev \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
ENV PATH=/usr/lib/llvm-18/bin:$PATH
|
||||
WORKDIR /src
|
||||
@@ -0,0 +1,235 @@
|
||||
#include <math.h>
|
||||
#include <pthread.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "audio.h"
|
||||
#include "music.h"
|
||||
#include "platform.h"
|
||||
|
||||
#define SFX_CHANNELS 16
|
||||
#define BLOCK_FRAMES 512
|
||||
#define MUSIC_GAIN 0.7f
|
||||
|
||||
typedef struct
|
||||
{
|
||||
const uint8_t *samples;
|
||||
uint32_t length;
|
||||
uint64_t position, step;
|
||||
int rate, left, right;
|
||||
int handle;
|
||||
} sfx_t;
|
||||
|
||||
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
static sfx_t sfx[SFX_CHANNELS];
|
||||
static int serial;
|
||||
static int music_ready;
|
||||
static float music_block[BLOCK_FRAMES];
|
||||
|
||||
static void set_params(sfx_t *s, int volume, int sep, int pitch)
|
||||
{
|
||||
int left, right, swing;
|
||||
|
||||
s->step = (uint64_t)(s->rate * pow(2.0, (pitch - 128) / 64.0) / AUDIO_RATE * 4294967296.0);
|
||||
|
||||
swing = sep + 1;
|
||||
left = volume - ((volume * swing * swing) >> 16);
|
||||
swing -= 257;
|
||||
right = volume - ((volume * swing * swing) >> 16);
|
||||
s->left = left < 0 ? 0 : left;
|
||||
s->right = right < 0 ? 0 : right;
|
||||
}
|
||||
|
||||
static sfx_t *find(int handle)
|
||||
{
|
||||
sfx_t *s;
|
||||
|
||||
if (handle < 0)
|
||||
return NULL;
|
||||
s = &sfx[handle % SFX_CHANNELS];
|
||||
return s->samples && s->handle == handle ? s : NULL;
|
||||
}
|
||||
|
||||
static int clip(int32_t value)
|
||||
{
|
||||
return value > 32767 ? 32767 : value < -32768 ? -32768 : value;
|
||||
}
|
||||
|
||||
static void mix_block(int16_t *out, int frames)
|
||||
{
|
||||
int i, c;
|
||||
|
||||
if (music_ready)
|
||||
music_render(music_block, frames);
|
||||
else
|
||||
memset(music_block, 0, frames * sizeof(*music_block));
|
||||
|
||||
for (i = 0; i < frames; i++)
|
||||
{
|
||||
int32_t music = (int32_t)(music_block[i] * MUSIC_GAIN * 32767.0f);
|
||||
int32_t left = music, right = music;
|
||||
|
||||
for (c = 0; c < SFX_CHANNELS; c++)
|
||||
{
|
||||
sfx_t *s = &sfx[c];
|
||||
uint32_t index;
|
||||
int32_t a, b, sample;
|
||||
|
||||
if (!s->samples)
|
||||
continue;
|
||||
index = (uint32_t)(s->position >> 32);
|
||||
if (index >= s->length)
|
||||
{
|
||||
s->samples = NULL;
|
||||
continue;
|
||||
}
|
||||
a = s->samples[index] - 128;
|
||||
b = index + 1 < s->length ? s->samples[index + 1] - 128 : a;
|
||||
sample = (a << 8) + (int32_t)(((int64_t)(b - a) * (uint32_t)s->position) >> 24);
|
||||
left += sample * s->left / 127;
|
||||
right += sample * s->right / 127;
|
||||
s->position += s->step;
|
||||
}
|
||||
out[i * 2] = (int16_t)clip(left);
|
||||
out[i * 2 + 1] = (int16_t)clip(right);
|
||||
}
|
||||
}
|
||||
|
||||
static void render(int16_t *stereo, int frames, void *user)
|
||||
{
|
||||
(void)user;
|
||||
while (frames > 0)
|
||||
{
|
||||
int count = frames > BLOCK_FRAMES ? BLOCK_FRAMES : frames;
|
||||
|
||||
pthread_mutex_lock(&lock);
|
||||
mix_block(stereo, count);
|
||||
pthread_mutex_unlock(&lock);
|
||||
stereo += count * 2;
|
||||
frames -= count;
|
||||
}
|
||||
}
|
||||
|
||||
int audio_init(const uint8_t *genmidi, int genmidi_length)
|
||||
{
|
||||
music_ready = music_init(AUDIO_RATE, genmidi, genmidi_length) == 0;
|
||||
if (!music_ready)
|
||||
plat_log("audio: no usable GENMIDI, music disabled\n");
|
||||
if (plat_audio_init(AUDIO_RATE, render, NULL))
|
||||
{
|
||||
plat_log("audio: no output device, sound disabled\n");
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void audio_shutdown(void)
|
||||
{
|
||||
plat_audio_shutdown();
|
||||
if (music_ready)
|
||||
music_shutdown();
|
||||
music_ready = 0;
|
||||
}
|
||||
|
||||
int audio_sfx_start(const uint8_t *samples, int length, int rate, int volume, int sep, int pitch)
|
||||
{
|
||||
sfx_t *s = NULL;
|
||||
int c, handle;
|
||||
|
||||
pthread_mutex_lock(&lock);
|
||||
for (c = 0; c < SFX_CHANNELS; c++)
|
||||
if (!sfx[c].samples)
|
||||
{
|
||||
s = &sfx[c];
|
||||
break;
|
||||
}
|
||||
if (!s)
|
||||
{
|
||||
s = &sfx[0];
|
||||
for (c = 1; c < SFX_CHANNELS; c++)
|
||||
if (sfx[c].handle < s->handle)
|
||||
s = &sfx[c];
|
||||
}
|
||||
|
||||
serial++;
|
||||
handle = serial * SFX_CHANNELS + (int)(s - sfx);
|
||||
s->samples = samples;
|
||||
s->length = (uint32_t)length;
|
||||
s->position = 0;
|
||||
s->handle = handle;
|
||||
s->rate = rate;
|
||||
set_params(s, volume, sep, pitch);
|
||||
pthread_mutex_unlock(&lock);
|
||||
return handle;
|
||||
}
|
||||
|
||||
void audio_sfx_stop(int handle)
|
||||
{
|
||||
sfx_t *s;
|
||||
|
||||
pthread_mutex_lock(&lock);
|
||||
if ((s = find(handle)))
|
||||
s->samples = NULL;
|
||||
pthread_mutex_unlock(&lock);
|
||||
}
|
||||
|
||||
int audio_sfx_playing(int handle)
|
||||
{
|
||||
int playing;
|
||||
|
||||
pthread_mutex_lock(&lock);
|
||||
playing = find(handle) != NULL;
|
||||
pthread_mutex_unlock(&lock);
|
||||
return playing;
|
||||
}
|
||||
|
||||
void audio_sfx_update(int handle, int volume, int sep, int pitch)
|
||||
{
|
||||
sfx_t *s;
|
||||
|
||||
pthread_mutex_lock(&lock);
|
||||
if ((s = find(handle)))
|
||||
set_params(s, volume, sep, pitch);
|
||||
pthread_mutex_unlock(&lock);
|
||||
}
|
||||
|
||||
int audio_music_load(const uint8_t *mus)
|
||||
{
|
||||
int result;
|
||||
|
||||
pthread_mutex_lock(&lock);
|
||||
result = music_ready ? music_load(mus) : -1;
|
||||
pthread_mutex_unlock(&lock);
|
||||
return result;
|
||||
}
|
||||
|
||||
void audio_music_play(int looping)
|
||||
{
|
||||
pthread_mutex_lock(&lock);
|
||||
if (music_ready)
|
||||
music_play(looping);
|
||||
pthread_mutex_unlock(&lock);
|
||||
}
|
||||
|
||||
void audio_music_stop(void)
|
||||
{
|
||||
pthread_mutex_lock(&lock);
|
||||
if (music_ready)
|
||||
music_stop();
|
||||
pthread_mutex_unlock(&lock);
|
||||
}
|
||||
|
||||
void audio_music_pause(int paused)
|
||||
{
|
||||
pthread_mutex_lock(&lock);
|
||||
if (music_ready)
|
||||
music_pause(paused);
|
||||
pthread_mutex_unlock(&lock);
|
||||
}
|
||||
|
||||
void audio_music_volume(int volume)
|
||||
{
|
||||
pthread_mutex_lock(&lock);
|
||||
if (music_ready)
|
||||
music_volume(volume);
|
||||
pthread_mutex_unlock(&lock);
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
#ifndef AUDIO_H
|
||||
#define AUDIO_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#define AUDIO_RATE 48000
|
||||
|
||||
int audio_init(const uint8_t *genmidi, int genmidi_length);
|
||||
void audio_shutdown(void);
|
||||
|
||||
int audio_sfx_start(const uint8_t *samples, int length, int rate, int volume, int sep, int pitch);
|
||||
void audio_sfx_stop(int handle);
|
||||
int audio_sfx_playing(int handle);
|
||||
void audio_sfx_update(int handle, int volume, int sep, int pitch);
|
||||
|
||||
int audio_music_load(const uint8_t *mus);
|
||||
void audio_music_play(int looping);
|
||||
void audio_music_stop(void);
|
||||
void audio_music_pause(int paused);
|
||||
void audio_music_volume(int volume);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,511 @@
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "music.h"
|
||||
#include "opl.h"
|
||||
|
||||
#define VOICES 9
|
||||
#define MUS_CHANNELS 16
|
||||
#define PERCUSSION_CHANNEL 15
|
||||
#define PERCUSSION_FIRST 35
|
||||
#define PERCUSSION_LAST 81
|
||||
#define INSTRUMENTS 175
|
||||
#define INSTRUMENT_SIZE 36
|
||||
#define GENMIDI_HEADER "#OPL_II#"
|
||||
#define TICK_RATE 140.0
|
||||
#define CHIP_RATE 49716.0
|
||||
|
||||
#define MAX_EVENTS_WITHOUT_DELAY 65536
|
||||
|
||||
#define FLAG_FIXED_PITCH 0x0001
|
||||
#define FLAG_DOUBLE_VOICE 0x0004
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint8_t tremolo, attack, sustain, wave, scale, level;
|
||||
} operator_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
operator_t mod, car;
|
||||
uint8_t feedback;
|
||||
int16_t base_note;
|
||||
} layer_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint16_t flags;
|
||||
uint8_t fine_tuning, fixed_note;
|
||||
layer_t layers[2];
|
||||
} instrument_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
const instrument_t *instrument;
|
||||
int volume, bend, velocity;
|
||||
} channel_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int active, channel, note, velocity, layer;
|
||||
const instrument_t *instrument;
|
||||
uint32_t age;
|
||||
} voice_t;
|
||||
|
||||
static struct
|
||||
{
|
||||
opl_t *opl;
|
||||
double samples_per_tick;
|
||||
instrument_t instruments[INSTRUMENTS];
|
||||
|
||||
const uint8_t *score;
|
||||
int score_length, position;
|
||||
int playing, paused, looping;
|
||||
double wait;
|
||||
|
||||
int volume;
|
||||
channel_t channels[MUS_CHANNELS];
|
||||
voice_t voices[VOICES];
|
||||
uint32_t age;
|
||||
} m;
|
||||
|
||||
static void parse_operator(operator_t *op, const uint8_t *p)
|
||||
{
|
||||
op->tremolo = p[0];
|
||||
op->attack = p[1];
|
||||
op->sustain = p[2];
|
||||
op->wave = p[3];
|
||||
op->scale = p[4];
|
||||
op->level = p[5];
|
||||
}
|
||||
|
||||
static void parse_instrument(instrument_t *ins, const uint8_t *p)
|
||||
{
|
||||
int i;
|
||||
|
||||
ins->flags = p[0] | p[1] << 8;
|
||||
ins->fine_tuning = p[2];
|
||||
ins->fixed_note = p[3];
|
||||
for (i = 0; i < 2; i++)
|
||||
{
|
||||
const uint8_t *l = p + 4 + i * 16;
|
||||
|
||||
parse_operator(&ins->layers[i].mod, l);
|
||||
ins->layers[i].feedback = l[6];
|
||||
parse_operator(&ins->layers[i].car, l + 7);
|
||||
ins->layers[i].base_note = (int16_t)(l[14] | l[15] << 8);
|
||||
}
|
||||
}
|
||||
|
||||
static int operator_offset(int voice, int carrier)
|
||||
{
|
||||
return (voice / 3) * 8 + voice % 3 + (carrier ? 3 : 0);
|
||||
}
|
||||
|
||||
static int attenuation(const voice_t *voice)
|
||||
{
|
||||
double gain = voice->velocity / 127.0 * m.channels[voice->channel].volume / 127.0 *
|
||||
m.volume / 127.0;
|
||||
int steps;
|
||||
|
||||
if (gain <= 0)
|
||||
return 63;
|
||||
steps = (int)(-20.0 * log10(gain) / 0.75 + 0.5);
|
||||
return steps > 63 ? 63 : steps;
|
||||
}
|
||||
|
||||
static void write_levels(const voice_t *voice)
|
||||
{
|
||||
const layer_t *layer = &voice->instrument->layers[voice->layer];
|
||||
int att = attenuation(voice);
|
||||
int car = layer->car.level + att;
|
||||
int mod = layer->mod.level;
|
||||
|
||||
if (layer->feedback & 1)
|
||||
mod += att;
|
||||
opl_write(m.opl, 0x40 + operator_offset(voice - m.voices, 1),
|
||||
(layer->car.scale & 0xc0) | (car > 63 ? 63 : car));
|
||||
opl_write(m.opl, 0x40 + operator_offset(voice - m.voices, 0),
|
||||
(layer->mod.scale & 0xc0) | (mod > 63 ? 63 : mod));
|
||||
}
|
||||
|
||||
static void write_operator(int offset, const operator_t *op)
|
||||
{
|
||||
opl_write(m.opl, 0x20 + offset, op->tremolo);
|
||||
opl_write(m.opl, 0x60 + offset, op->attack);
|
||||
opl_write(m.opl, 0x80 + offset, op->sustain);
|
||||
opl_write(m.opl, 0xe0 + offset, op->wave);
|
||||
}
|
||||
|
||||
static void write_frequency(const voice_t *voice, int key)
|
||||
{
|
||||
const instrument_t *ins = voice->instrument;
|
||||
const layer_t *layer = &ins->layers[voice->layer];
|
||||
int index = voice - m.voices;
|
||||
double note, freq;
|
||||
int block = 0, fnum;
|
||||
|
||||
note = (ins->flags & FLAG_FIXED_PITCH) ? ins->fixed_note : voice->note;
|
||||
note += layer->base_note;
|
||||
if (voice->layer)
|
||||
note += (ins->fine_tuning / 2 - 64) / 32.0;
|
||||
note += m.channels[voice->channel].bend / 64.0;
|
||||
|
||||
freq = 440.0 * pow(2.0, (note - 69.0) / 12.0);
|
||||
while (block < 7 && freq * (1 << (20 - block)) / CHIP_RATE >= 1024)
|
||||
block++;
|
||||
fnum = (int)(freq * (1 << (20 - block)) / CHIP_RATE + 0.5);
|
||||
if (fnum > 1023)
|
||||
fnum = 1023;
|
||||
|
||||
opl_write(m.opl, 0xa0 + index, fnum & 0xff);
|
||||
opl_write(m.opl, 0xb0 + index, (key ? 0x20 : 0) | block << 2 | fnum >> 8);
|
||||
}
|
||||
|
||||
static void release_voice(voice_t *voice)
|
||||
{
|
||||
if (!voice->active)
|
||||
return;
|
||||
voice->active = 0;
|
||||
write_frequency(voice, 0);
|
||||
}
|
||||
|
||||
static voice_t *find_voice(int may_steal)
|
||||
{
|
||||
voice_t *best = NULL;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < VOICES; i++)
|
||||
{
|
||||
voice_t *v = &m.voices[i];
|
||||
|
||||
if (!v->active && (!best || v->age < best->age))
|
||||
best = v;
|
||||
}
|
||||
if (best || !may_steal)
|
||||
return best;
|
||||
|
||||
for (i = 0; i < VOICES; i++)
|
||||
{
|
||||
voice_t *v = &m.voices[i];
|
||||
|
||||
if (!best || v->channel > best->channel ||
|
||||
(v->channel == best->channel && v->age < best->age))
|
||||
best = v;
|
||||
}
|
||||
release_voice(best);
|
||||
return best;
|
||||
}
|
||||
|
||||
static void start_voice(voice_t *voice, int channel, int note, int velocity,
|
||||
const instrument_t *ins, int layer)
|
||||
{
|
||||
const layer_t *l = &ins->layers[layer];
|
||||
int index = voice - m.voices;
|
||||
|
||||
voice->active = 1;
|
||||
voice->channel = channel;
|
||||
voice->note = note;
|
||||
voice->velocity = velocity;
|
||||
voice->instrument = ins;
|
||||
voice->layer = layer;
|
||||
voice->age = ++m.age;
|
||||
|
||||
write_operator(operator_offset(index, 0), &l->mod);
|
||||
write_operator(operator_offset(index, 1), &l->car);
|
||||
opl_write(m.opl, 0xc0 + index, l->feedback | 0x30);
|
||||
write_levels(voice);
|
||||
write_frequency(voice, 1);
|
||||
}
|
||||
|
||||
static void note_on(int channel, int note, int velocity)
|
||||
{
|
||||
const instrument_t *ins;
|
||||
voice_t *voice;
|
||||
|
||||
if (channel == PERCUSSION_CHANNEL)
|
||||
{
|
||||
if (note < PERCUSSION_FIRST || note > PERCUSSION_LAST)
|
||||
return;
|
||||
ins = &m.instruments[128 + note - PERCUSSION_FIRST];
|
||||
}
|
||||
else
|
||||
ins = m.channels[channel].instrument;
|
||||
|
||||
voice = find_voice(1);
|
||||
start_voice(voice, channel, note, velocity, ins, 0);
|
||||
if ((ins->flags & FLAG_DOUBLE_VOICE) && (voice = find_voice(0)))
|
||||
start_voice(voice, channel, note, velocity, ins, 1);
|
||||
}
|
||||
|
||||
static void note_off(int channel, int note)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < VOICES; i++)
|
||||
if (m.voices[i].active && m.voices[i].channel == channel && m.voices[i].note == note)
|
||||
release_voice(&m.voices[i]);
|
||||
}
|
||||
|
||||
static void channel_off(int channel)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < VOICES; i++)
|
||||
if (m.voices[i].active && (channel < 0 || m.voices[i].channel == channel))
|
||||
release_voice(&m.voices[i]);
|
||||
}
|
||||
|
||||
static void refresh_channel(int channel, int frequency)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < VOICES; i++)
|
||||
{
|
||||
voice_t *v = &m.voices[i];
|
||||
|
||||
if (!v->active || (channel >= 0 && v->channel != channel))
|
||||
continue;
|
||||
if (frequency)
|
||||
write_frequency(v, 1);
|
||||
else
|
||||
write_levels(v);
|
||||
}
|
||||
}
|
||||
|
||||
static void reset_channels(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < MUS_CHANNELS; i++)
|
||||
{
|
||||
m.channels[i].instrument = &m.instruments[0];
|
||||
m.channels[i].volume = 127;
|
||||
m.channels[i].bend = 0;
|
||||
m.channels[i].velocity = 127;
|
||||
}
|
||||
}
|
||||
|
||||
static void controller(int channel, int number, int value)
|
||||
{
|
||||
switch (number)
|
||||
{
|
||||
case 0:
|
||||
m.channels[channel].instrument = &m.instruments[value & 127];
|
||||
break;
|
||||
case 3:
|
||||
m.channels[channel].volume = value > 127 ? 127 : value;
|
||||
refresh_channel(channel, 0);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void system_event(int channel, int number)
|
||||
{
|
||||
switch (number)
|
||||
{
|
||||
case 10:
|
||||
case 11:
|
||||
channel_off(channel);
|
||||
break;
|
||||
case 14:
|
||||
m.channels[channel].volume = 127;
|
||||
m.channels[channel].bend = 0;
|
||||
refresh_channel(channel, 1);
|
||||
refresh_channel(channel, 0);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static int next_byte(void)
|
||||
{
|
||||
if (m.position >= m.score_length)
|
||||
return -1;
|
||||
return m.score[m.position++];
|
||||
}
|
||||
|
||||
static void end_of_score(void)
|
||||
{
|
||||
if (m.looping)
|
||||
{
|
||||
m.position = 0;
|
||||
return;
|
||||
}
|
||||
channel_off(-1);
|
||||
m.playing = 0;
|
||||
}
|
||||
|
||||
static void run_events(void)
|
||||
{
|
||||
int budget = MAX_EVENTS_WITHOUT_DELAY;
|
||||
|
||||
while (m.playing)
|
||||
{
|
||||
int event = next_byte();
|
||||
int channel, a, b;
|
||||
|
||||
if (!budget--)
|
||||
{
|
||||
channel_off(-1);
|
||||
m.playing = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
if (event < 0)
|
||||
{
|
||||
end_of_score();
|
||||
continue;
|
||||
}
|
||||
channel = event & 15;
|
||||
|
||||
switch ((event >> 4) & 7)
|
||||
{
|
||||
case 0:
|
||||
note_off(channel, next_byte() & 127);
|
||||
break;
|
||||
case 1:
|
||||
a = next_byte();
|
||||
if (a & 128)
|
||||
m.channels[channel].velocity = next_byte() & 127;
|
||||
note_on(channel, a & 127, m.channels[channel].velocity);
|
||||
break;
|
||||
case 2:
|
||||
m.channels[channel].bend = (next_byte() & 255) - 128;
|
||||
refresh_channel(channel, 1);
|
||||
break;
|
||||
case 3:
|
||||
system_event(channel, next_byte());
|
||||
break;
|
||||
case 4:
|
||||
a = next_byte();
|
||||
b = next_byte();
|
||||
controller(channel, a, b);
|
||||
break;
|
||||
case 6:
|
||||
end_of_score();
|
||||
continue;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (event & 128)
|
||||
{
|
||||
int delay = 0;
|
||||
|
||||
do
|
||||
{
|
||||
b = next_byte();
|
||||
if (b < 0)
|
||||
break;
|
||||
delay = delay * 128 + (b & 127);
|
||||
} while (b & 128);
|
||||
if (delay)
|
||||
{
|
||||
m.wait += delay * m.samples_per_tick;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int music_init(int sample_rate, const uint8_t *genmidi, int length)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (!genmidi || length < 8 + INSTRUMENTS * INSTRUMENT_SIZE ||
|
||||
memcmp(genmidi, GENMIDI_HEADER, 8))
|
||||
return -1;
|
||||
for (i = 0; i < INSTRUMENTS; i++)
|
||||
parse_instrument(&m.instruments[i], genmidi + 8 + i * INSTRUMENT_SIZE);
|
||||
|
||||
m.opl = opl_create(sample_rate);
|
||||
if (!m.opl)
|
||||
return -1;
|
||||
m.samples_per_tick = sample_rate / TICK_RATE;
|
||||
m.volume = 127;
|
||||
reset_channels();
|
||||
return 0;
|
||||
}
|
||||
|
||||
void music_shutdown(void)
|
||||
{
|
||||
opl_destroy(m.opl);
|
||||
m.opl = NULL;
|
||||
m.playing = 0;
|
||||
}
|
||||
|
||||
int music_load(const uint8_t *mus)
|
||||
{
|
||||
int start;
|
||||
|
||||
if (!m.opl || memcmp(mus, "MUS\x1a", 4))
|
||||
return -1;
|
||||
music_stop();
|
||||
m.score_length = mus[4] | mus[5] << 8;
|
||||
start = mus[6] | mus[7] << 8;
|
||||
m.score = mus + start;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void music_play(int looping)
|
||||
{
|
||||
if (!m.score)
|
||||
return;
|
||||
channel_off(-1);
|
||||
reset_channels();
|
||||
m.position = 0;
|
||||
m.wait = 0;
|
||||
m.looping = looping;
|
||||
m.paused = 0;
|
||||
m.playing = 1;
|
||||
}
|
||||
|
||||
void music_stop(void)
|
||||
{
|
||||
if (!m.opl)
|
||||
return;
|
||||
channel_off(-1);
|
||||
m.playing = 0;
|
||||
}
|
||||
|
||||
void music_pause(int paused)
|
||||
{
|
||||
m.paused = paused;
|
||||
}
|
||||
|
||||
void music_volume(int volume)
|
||||
{
|
||||
m.volume = volume < 0 ? 0 : volume > 127 ? 127 : volume;
|
||||
if (m.opl)
|
||||
refresh_channel(-1, 0);
|
||||
}
|
||||
|
||||
void music_render(float *out, int frames)
|
||||
{
|
||||
int done = 0;
|
||||
|
||||
if (!m.opl || m.paused)
|
||||
{
|
||||
memset(out, 0, frames * sizeof(*out));
|
||||
return;
|
||||
}
|
||||
|
||||
while (done < frames)
|
||||
{
|
||||
int chunk = frames - done;
|
||||
|
||||
while (m.playing && m.wait < 1)
|
||||
run_events();
|
||||
if (m.playing && m.wait < chunk)
|
||||
chunk = (int)m.wait;
|
||||
|
||||
opl_render(m.opl, out + done, chunk);
|
||||
done += chunk;
|
||||
if (m.playing)
|
||||
m.wait -= chunk;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
#ifndef MUSIC_H
|
||||
#define MUSIC_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
int music_init(int sample_rate, const uint8_t *genmidi, int length);
|
||||
void music_shutdown(void);
|
||||
int music_load(const uint8_t *mus);
|
||||
void music_play(int looping);
|
||||
void music_stop(void);
|
||||
void music_pause(int paused);
|
||||
void music_volume(int volume);
|
||||
void music_render(float *out, int frames);
|
||||
|
||||
#endif
|
||||
+408
@@ -0,0 +1,408 @@
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "opl.h"
|
||||
|
||||
#define CHIP_RATE 49716.0
|
||||
#define WAVE_BITS 10
|
||||
#define WAVE_SIZE (1 << WAVE_BITS)
|
||||
#define GAIN_STEPS 1024
|
||||
#define ENV_SILENT 511.0f
|
||||
#define SLOTS (OPL_CHANNELS * 2)
|
||||
#define CHANNEL_SCALE 0.25f
|
||||
#define TREMOLO_HZ 3.7
|
||||
#define VIBRATO_HZ 6.07
|
||||
|
||||
enum
|
||||
{
|
||||
EG_OFF,
|
||||
EG_ATTACK,
|
||||
EG_DECAY,
|
||||
EG_SUSTAIN,
|
||||
EG_RELEASE
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint8_t tremolo, vibrato, sustained, ksr, mult;
|
||||
uint8_t ksl, level, attack, decay, sustain, release, wave;
|
||||
|
||||
uint32_t phase, step;
|
||||
int stage;
|
||||
float env, ksl_att, sustain_env;
|
||||
float attack_k, decay_inc, release_inc;
|
||||
float out, prev;
|
||||
} slot_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint16_t fnum;
|
||||
uint8_t block, key, feedback, additive;
|
||||
slot_t *mod, *car;
|
||||
} channel_t;
|
||||
|
||||
struct opl
|
||||
{
|
||||
double rate_scale;
|
||||
slot_t slots[SLOTS];
|
||||
channel_t channels[OPL_CHANNELS];
|
||||
uint8_t deep_tremolo, deep_vibrato;
|
||||
double tremolo_phase, tremolo_step;
|
||||
double vibrato_phase, vibrato_step;
|
||||
};
|
||||
|
||||
static float wave_table[8][WAVE_SIZE];
|
||||
static float gain_table[GAIN_STEPS];
|
||||
static int tables_ready;
|
||||
|
||||
static const uint8_t mult_x2[16] = {1, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 20, 24, 24, 30, 30};
|
||||
static const uint8_t ksl_rom[16] = {0, 32, 40, 45, 48, 51, 53, 55, 56, 58, 59, 60, 61, 62, 63, 64};
|
||||
static const uint8_t ksl_shift[4] = {0, 1, 2, 0};
|
||||
|
||||
static void build_tables(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < WAVE_SIZE; i++)
|
||||
{
|
||||
double angle = 2 * M_PI * i / WAVE_SIZE;
|
||||
float s = (float)sin(angle);
|
||||
float s2 = (float)sin(2 * angle);
|
||||
int first_half = i < WAVE_SIZE / 2;
|
||||
int quarter = (i / (WAVE_SIZE / 4)) & 1;
|
||||
int folded = first_half ? i : WAVE_SIZE - 1 - i;
|
||||
|
||||
wave_table[0][i] = s;
|
||||
wave_table[1][i] = first_half ? s : 0;
|
||||
wave_table[2][i] = fabsf(s);
|
||||
wave_table[3][i] = quarter ? 0 : fabsf(s);
|
||||
wave_table[4][i] = first_half ? s2 : 0;
|
||||
wave_table[5][i] = first_half ? fabsf(s2) : 0;
|
||||
wave_table[6][i] = first_half ? 1.0f : -1.0f;
|
||||
wave_table[7][i] = (first_half ? 1.0f : -1.0f) * exp2f(-folded / 32.0f);
|
||||
}
|
||||
for (i = 0; i < GAIN_STEPS; i++)
|
||||
gain_table[i] = exp2f(-i / 32.0f);
|
||||
tables_ready = 1;
|
||||
}
|
||||
|
||||
static int effective_rate(int reg_rate, const slot_t *slot, const channel_t *channel)
|
||||
{
|
||||
int ksv = (channel->block << 1) | ((channel->fnum >> 9) & 1);
|
||||
int rate;
|
||||
|
||||
if (!reg_rate)
|
||||
return 0;
|
||||
rate = reg_rate * 4 + (slot->ksr ? ksv : ksv >> 2);
|
||||
return rate > 63 ? 63 : rate;
|
||||
}
|
||||
|
||||
static double rate_divisor(int rate)
|
||||
{
|
||||
return (double)(1 << (rate >> 2)) * ((rate & 3) + 4) / 4.0;
|
||||
}
|
||||
|
||||
static float linear_increment(int rate, double rate_scale)
|
||||
{
|
||||
double seconds;
|
||||
|
||||
if (!rate)
|
||||
return 0;
|
||||
seconds = 78.56 / rate_divisor(rate);
|
||||
return (float)(ENV_SILENT / (seconds * CHIP_RATE) * rate_scale);
|
||||
}
|
||||
|
||||
static void update_slot(opl_t *opl, slot_t *slot, const channel_t *channel)
|
||||
{
|
||||
int ksl, attack_rate;
|
||||
uint64_t step;
|
||||
|
||||
step = (uint64_t)((double)((uint32_t)channel->fnum << channel->block) *
|
||||
mult_x2[slot->mult] * 2048.0 * opl->rate_scale);
|
||||
slot->step = (uint32_t)step;
|
||||
|
||||
ksl = (ksl_rom[channel->fnum >> 6] << 2) - ((8 - channel->block) << 5);
|
||||
slot->ksl_att = slot->ksl && ksl > 0 ? (float)(ksl >> ksl_shift[slot->ksl]) : 0;
|
||||
|
||||
attack_rate = effective_rate(slot->attack, slot, channel);
|
||||
if (attack_rate >= 60)
|
||||
slot->attack_k = 1;
|
||||
else if (attack_rate == 0)
|
||||
slot->attack_k = 0;
|
||||
else
|
||||
{
|
||||
double samples = 5.65248 / rate_divisor(attack_rate) * CHIP_RATE / opl->rate_scale;
|
||||
slot->attack_k = (float)(1.0 - exp(log(1.0 / ENV_SILENT) / samples));
|
||||
}
|
||||
slot->decay_inc = linear_increment(effective_rate(slot->decay, slot, channel), opl->rate_scale);
|
||||
slot->release_inc = linear_increment(effective_rate(slot->release, slot, channel), opl->rate_scale);
|
||||
slot->sustain_env = (slot->sustain == 15 ? 31 : slot->sustain) * 16.0f;
|
||||
}
|
||||
|
||||
static void update_channel(opl_t *opl, channel_t *channel)
|
||||
{
|
||||
update_slot(opl, channel->mod, channel);
|
||||
update_slot(opl, channel->car, channel);
|
||||
}
|
||||
|
||||
static void key_on(slot_t *slot)
|
||||
{
|
||||
slot->phase = 0;
|
||||
slot->stage = EG_ATTACK;
|
||||
if (slot->attack_k >= 1)
|
||||
{
|
||||
slot->env = 0;
|
||||
slot->stage = EG_DECAY;
|
||||
}
|
||||
}
|
||||
|
||||
static void key_off(slot_t *slot)
|
||||
{
|
||||
if (slot->stage != EG_OFF)
|
||||
slot->stage = EG_RELEASE;
|
||||
}
|
||||
|
||||
static void advance_envelope(slot_t *slot)
|
||||
{
|
||||
switch (slot->stage)
|
||||
{
|
||||
case EG_ATTACK:
|
||||
slot->env -= slot->env * slot->attack_k;
|
||||
if (slot->env < 0.5f)
|
||||
{
|
||||
slot->env = 0;
|
||||
slot->stage = EG_DECAY;
|
||||
}
|
||||
break;
|
||||
case EG_DECAY:
|
||||
slot->env += slot->decay_inc;
|
||||
if (slot->env >= slot->sustain_env)
|
||||
{
|
||||
slot->env = slot->sustain_env;
|
||||
slot->stage = slot->sustained ? EG_SUSTAIN : EG_RELEASE;
|
||||
}
|
||||
break;
|
||||
case EG_RELEASE:
|
||||
slot->env += slot->release_inc;
|
||||
if (slot->env >= ENV_SILENT)
|
||||
{
|
||||
slot->env = ENV_SILENT;
|
||||
slot->stage = EG_OFF;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static float slot_output(slot_t *slot, int modulation, float tremolo, double vibrato)
|
||||
{
|
||||
float att;
|
||||
int index;
|
||||
|
||||
advance_envelope(slot);
|
||||
slot->phase += slot->vibrato ? (uint32_t)(uint64_t)(slot->step * vibrato) : slot->step;
|
||||
|
||||
att = slot->env + slot->level * 4 + slot->ksl_att + (slot->tremolo ? tremolo : 0);
|
||||
if (slot->stage == EG_OFF || att >= GAIN_STEPS)
|
||||
return 0;
|
||||
index = ((int)(slot->phase >> (32 - WAVE_BITS)) + modulation) & (WAVE_SIZE - 1);
|
||||
return wave_table[slot->wave][index] * gain_table[(int)att];
|
||||
}
|
||||
|
||||
static float channel_output(channel_t *channel, float tremolo, double vibrato)
|
||||
{
|
||||
slot_t *mod = channel->mod, *car = channel->car;
|
||||
int feedback = 0;
|
||||
|
||||
if (mod->stage == EG_OFF && car->stage == EG_OFF)
|
||||
{
|
||||
mod->out = mod->prev = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (channel->feedback)
|
||||
feedback = (int)((mod->prev + mod->out) * 4095.0f) >> (9 - channel->feedback);
|
||||
mod->prev = mod->out;
|
||||
mod->out = slot_output(mod, feedback, tremolo, vibrato);
|
||||
|
||||
if (channel->additive)
|
||||
return mod->out + slot_output(car, 0, tremolo, vibrato);
|
||||
return slot_output(car, (int)(mod->out * 4095.0f), tremolo, vibrato);
|
||||
}
|
||||
|
||||
opl_t *opl_create(int sample_rate)
|
||||
{
|
||||
opl_t *opl;
|
||||
|
||||
if (!tables_ready)
|
||||
build_tables();
|
||||
opl = calloc(1, sizeof(*opl));
|
||||
if (!opl)
|
||||
return NULL;
|
||||
opl->rate_scale = CHIP_RATE / sample_rate;
|
||||
opl->tremolo_step = TREMOLO_HZ / sample_rate;
|
||||
opl->vibrato_step = VIBRATO_HZ / sample_rate;
|
||||
opl_reset(opl);
|
||||
return opl;
|
||||
}
|
||||
|
||||
void opl_destroy(opl_t *opl)
|
||||
{
|
||||
free(opl);
|
||||
}
|
||||
|
||||
void opl_reset(opl_t *opl)
|
||||
{
|
||||
int c;
|
||||
|
||||
memset(opl->slots, 0, sizeof(opl->slots));
|
||||
memset(opl->channels, 0, sizeof(opl->channels));
|
||||
for (c = 0; c < OPL_CHANNELS; c++)
|
||||
{
|
||||
int bank = c / 9, local = c % 9;
|
||||
int mod = bank * 18 + (local / 3) * 6 + local % 3;
|
||||
|
||||
opl->channels[c].mod = &opl->slots[mod];
|
||||
opl->channels[c].car = &opl->slots[mod + 3];
|
||||
}
|
||||
for (c = 0; c < SLOTS; c++)
|
||||
{
|
||||
opl->slots[c].env = ENV_SILENT;
|
||||
opl->slots[c].stage = EG_OFF;
|
||||
}
|
||||
for (c = 0; c < OPL_CHANNELS; c++)
|
||||
update_channel(opl, &opl->channels[c]);
|
||||
}
|
||||
|
||||
static channel_t *slot_channel(opl_t *opl, int slot_index)
|
||||
{
|
||||
int bank = slot_index / 18, local = slot_index % 18;
|
||||
int channel = (local / 6) * 3 + (local % 6) % 3;
|
||||
|
||||
return &opl->channels[bank * 9 + channel];
|
||||
}
|
||||
|
||||
static void write_slot(opl_t *opl, int bank, int offset, int group, uint8_t value)
|
||||
{
|
||||
int index;
|
||||
slot_t *slot;
|
||||
|
||||
if ((offset & 7) >= 6 || offset > 0x15)
|
||||
return;
|
||||
index = bank * 18 + (offset >> 3) * 6 + (offset & 7);
|
||||
slot = &opl->slots[index];
|
||||
|
||||
switch (group)
|
||||
{
|
||||
case 0x20:
|
||||
slot->tremolo = (value >> 7) & 1;
|
||||
slot->vibrato = (value >> 6) & 1;
|
||||
slot->sustained = (value >> 5) & 1;
|
||||
slot->ksr = (value >> 4) & 1;
|
||||
slot->mult = value & 15;
|
||||
break;
|
||||
case 0x40:
|
||||
slot->ksl = value >> 6;
|
||||
slot->level = value & 63;
|
||||
break;
|
||||
case 0x60:
|
||||
slot->attack = value >> 4;
|
||||
slot->decay = value & 15;
|
||||
break;
|
||||
case 0x80:
|
||||
slot->sustain = value >> 4;
|
||||
slot->release = value & 15;
|
||||
break;
|
||||
case 0xe0:
|
||||
slot->wave = value & 7;
|
||||
return;
|
||||
}
|
||||
update_slot(opl, slot, slot_channel(opl, index));
|
||||
}
|
||||
|
||||
void opl_write(opl_t *opl, int reg, uint8_t value)
|
||||
{
|
||||
int bank = (reg >> 8) & 1;
|
||||
int r = reg & 0xff;
|
||||
channel_t *channel;
|
||||
|
||||
switch (r & 0xe0)
|
||||
{
|
||||
case 0x20:
|
||||
case 0x40:
|
||||
case 0x60:
|
||||
case 0x80:
|
||||
case 0xe0:
|
||||
write_slot(opl, bank, r & 0x1f, r & 0xe0, value);
|
||||
return;
|
||||
case 0xa0:
|
||||
if (r == 0xbd && !bank)
|
||||
{
|
||||
opl->deep_tremolo = (value >> 7) & 1;
|
||||
opl->deep_vibrato = (value >> 6) & 1;
|
||||
return;
|
||||
}
|
||||
if ((r & 0x0f) > 8)
|
||||
return;
|
||||
channel = &opl->channels[bank * 9 + (r & 0x0f)];
|
||||
if (r < 0xb0)
|
||||
channel->fnum = (channel->fnum & 0x300) | value;
|
||||
else
|
||||
{
|
||||
uint8_t key = (value >> 5) & 1;
|
||||
|
||||
channel->fnum = (channel->fnum & 0xff) | (value & 3) << 8;
|
||||
channel->block = (value >> 2) & 7;
|
||||
update_channel(opl, channel);
|
||||
if (key && !channel->key)
|
||||
{
|
||||
key_on(channel->mod);
|
||||
key_on(channel->car);
|
||||
}
|
||||
else if (!key && channel->key)
|
||||
{
|
||||
key_off(channel->mod);
|
||||
key_off(channel->car);
|
||||
}
|
||||
channel->key = key;
|
||||
return;
|
||||
}
|
||||
update_channel(opl, channel);
|
||||
return;
|
||||
case 0xc0:
|
||||
if ((r & 0x0f) > 8 || r >= 0xd0)
|
||||
return;
|
||||
channel = &opl->channels[bank * 9 + (r & 0x0f)];
|
||||
channel->feedback = (value >> 1) & 7;
|
||||
channel->additive = value & 1;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void opl_render(opl_t *opl, float *out, int frames)
|
||||
{
|
||||
float tremolo_depth = opl->deep_tremolo ? 25.6f : 5.3f;
|
||||
double vibrato_depth = opl->deep_vibrato ? 0.0081 : 0.0041;
|
||||
int i, c;
|
||||
|
||||
for (i = 0; i < frames; i++)
|
||||
{
|
||||
double tri = opl->tremolo_phase < 0.5 ? opl->tremolo_phase * 2 : 2 - opl->tremolo_phase * 2;
|
||||
float tremolo = (float)(tri * tremolo_depth);
|
||||
double vibrato = 1.0 + vibrato_depth * sin(2 * M_PI * opl->vibrato_phase);
|
||||
float sum = 0;
|
||||
|
||||
for (c = 0; c < OPL_CHANNELS; c++)
|
||||
sum += channel_output(&opl->channels[c], tremolo, vibrato);
|
||||
out[i] = sum * CHANNEL_SCALE;
|
||||
|
||||
opl->tremolo_phase += opl->tremolo_step;
|
||||
if (opl->tremolo_phase >= 1)
|
||||
opl->tremolo_phase -= 1;
|
||||
opl->vibrato_phase += opl->vibrato_step;
|
||||
if (opl->vibrato_phase >= 1)
|
||||
opl->vibrato_phase -= 1;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
#ifndef OPL_H
|
||||
#define OPL_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#define OPL_CHANNELS 18
|
||||
|
||||
typedef struct opl opl_t;
|
||||
|
||||
opl_t *opl_create(int sample_rate);
|
||||
void opl_destroy(opl_t *opl);
|
||||
void opl_reset(opl_t *opl);
|
||||
void opl_write(opl_t *opl, int reg, uint8_t value);
|
||||
void opl_render(opl_t *opl, float *out, int frames);
|
||||
|
||||
#endif
|
||||
+1349
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,52 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// AutoMap module.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __AMMAP_H__
|
||||
#define __AMMAP_H__
|
||||
|
||||
// Used by ST StatusBar stuff.
|
||||
#define AM_MSGHEADER (('a'<<24)+('m'<<16))
|
||||
#define AM_MSGENTERED (AM_MSGHEADER | ('e'<<8))
|
||||
#define AM_MSGEXITED (AM_MSGHEADER | ('x'<<8))
|
||||
|
||||
|
||||
// Called by main loop.
|
||||
boolean AM_Responder (event_t* ev);
|
||||
|
||||
// Called by main loop.
|
||||
void AM_Ticker (void);
|
||||
|
||||
// Called by main loop,
|
||||
// called instead of view drawer if automap active.
|
||||
void AM_Drawer (void);
|
||||
|
||||
// Called to force the automap to quit
|
||||
// if the level is completed while it is up.
|
||||
void AM_Stop (void);
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,701 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Printed strings for translation.
|
||||
// English language support (default).
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __D_ENGLSH__
|
||||
#define __D_ENGLSH__
|
||||
|
||||
//
|
||||
// Printed strings for translation
|
||||
//
|
||||
|
||||
//
|
||||
// D_Main.C
|
||||
//
|
||||
#define D_DEVSTR "Development mode ON.\n"
|
||||
#define D_CDROM "CD-ROM Version: default.cfg from c:\\doomdata\n"
|
||||
|
||||
//
|
||||
// M_Menu.C
|
||||
//
|
||||
#define PRESSKEY "press a key."
|
||||
#define PRESSYN "press y or n."
|
||||
#define QUITMSG "are you sure you want to\nquit this great game?"
|
||||
#define LOADNET "you can't do load while in a net game!\n\n"PRESSKEY
|
||||
#define QLOADNET "you can't quickload during a netgame!\n\n"PRESSKEY
|
||||
#define QSAVESPOT "you haven't picked a quicksave slot yet!\n\n"PRESSKEY
|
||||
#define SAVEDEAD "you can't save if you aren't playing!\n\n"PRESSKEY
|
||||
#define QSPROMPT "quicksave over your game named\n\n'%s'?\n\n"PRESSYN
|
||||
#define QLPROMPT "do you want to quickload the game named\n\n'%s'?\n\n"PRESSYN
|
||||
|
||||
#define NEWGAME \
|
||||
"you can't start a new game\n"\
|
||||
"while in a network game.\n\n"PRESSKEY
|
||||
|
||||
#define NIGHTMARE \
|
||||
"are you sure? this skill level\n"\
|
||||
"isn't even remotely fair.\n\n"PRESSYN
|
||||
|
||||
#define SWSTRING \
|
||||
"this is the shareware version of doom.\n\n"\
|
||||
"you need to order the entire trilogy.\n\n"PRESSKEY
|
||||
|
||||
#define MSGOFF "Messages OFF"
|
||||
#define MSGON "Messages ON"
|
||||
#define NETEND "you can't end a netgame!\n\n"PRESSKEY
|
||||
#define ENDGAME "are you sure you want to end the game?\n\n"PRESSYN
|
||||
|
||||
#define DOSY "(press y to quit)"
|
||||
|
||||
#define DETAILHI "High detail"
|
||||
#define DETAILLO "Low detail"
|
||||
#define GAMMALVL0 "Gamma correction OFF"
|
||||
#define GAMMALVL1 "Gamma correction level 1"
|
||||
#define GAMMALVL2 "Gamma correction level 2"
|
||||
#define GAMMALVL3 "Gamma correction level 3"
|
||||
#define GAMMALVL4 "Gamma correction level 4"
|
||||
#define EMPTYSTRING "empty slot"
|
||||
|
||||
//
|
||||
// P_inter.C
|
||||
//
|
||||
#define GOTARMOR "Picked up the armor."
|
||||
#define GOTMEGA "Picked up the MegaArmor!"
|
||||
#define GOTHTHBONUS "Picked up a health bonus."
|
||||
#define GOTARMBONUS "Picked up an armor bonus."
|
||||
#define GOTSTIM "Picked up a stimpack."
|
||||
#define GOTMEDINEED "Picked up a medikit that you REALLY need!"
|
||||
#define GOTMEDIKIT "Picked up a medikit."
|
||||
#define GOTSUPER "Supercharge!"
|
||||
|
||||
#define GOTBLUECARD "Picked up a blue keycard."
|
||||
#define GOTYELWCARD "Picked up a yellow keycard."
|
||||
#define GOTREDCARD "Picked up a red keycard."
|
||||
#define GOTBLUESKUL "Picked up a blue skull key."
|
||||
#define GOTYELWSKUL "Picked up a yellow skull key."
|
||||
#define GOTREDSKULL "Picked up a red skull key."
|
||||
|
||||
#define GOTINVUL "Invulnerability!"
|
||||
#define GOTBERSERK "Berserk!"
|
||||
#define GOTINVIS "Partial Invisibility"
|
||||
#define GOTSUIT "Radiation Shielding Suit"
|
||||
#define GOTMAP "Computer Area Map"
|
||||
#define GOTVISOR "Light Amplification Visor"
|
||||
#define GOTMSPHERE "MegaSphere!"
|
||||
|
||||
#define GOTCLIP "Picked up a clip."
|
||||
#define GOTCLIPBOX "Picked up a box of bullets."
|
||||
#define GOTROCKET "Picked up a rocket."
|
||||
#define GOTROCKBOX "Picked up a box of rockets."
|
||||
#define GOTCELL "Picked up an energy cell."
|
||||
#define GOTCELLBOX "Picked up an energy cell pack."
|
||||
#define GOTSHELLS "Picked up 4 shotgun shells."
|
||||
#define GOTSHELLBOX "Picked up a box of shotgun shells."
|
||||
#define GOTBACKPACK "Picked up a backpack full of ammo!"
|
||||
|
||||
#define GOTBFG9000 "You got the BFG9000! Oh, yes."
|
||||
#define GOTCHAINGUN "You got the chaingun!"
|
||||
#define GOTCHAINSAW "A chainsaw! Find some meat!"
|
||||
#define GOTLAUNCHER "You got the rocket launcher!"
|
||||
#define GOTPLASMA "You got the plasma gun!"
|
||||
#define GOTSHOTGUN "You got the shotgun!"
|
||||
#define GOTSHOTGUN2 "You got the super shotgun!"
|
||||
|
||||
//
|
||||
// P_Doors.C
|
||||
//
|
||||
#define PD_BLUEO "You need a blue key to activate this object"
|
||||
#define PD_REDO "You need a red key to activate this object"
|
||||
#define PD_YELLOWO "You need a yellow key to activate this object"
|
||||
#define PD_BLUEK "You need a blue key to open this door"
|
||||
#define PD_REDK "You need a red key to open this door"
|
||||
#define PD_YELLOWK "You need a yellow key to open this door"
|
||||
|
||||
//
|
||||
// G_game.C
|
||||
//
|
||||
#define GGSAVED "game saved."
|
||||
|
||||
//
|
||||
// HU_stuff.C
|
||||
//
|
||||
#define HUSTR_MSGU "[Message unsent]"
|
||||
|
||||
#define HUSTR_E1M1 "E1M1: Hangar"
|
||||
#define HUSTR_E1M2 "E1M2: Nuclear Plant"
|
||||
#define HUSTR_E1M3 "E1M3: Toxin Refinery"
|
||||
#define HUSTR_E1M4 "E1M4: Command Control"
|
||||
#define HUSTR_E1M5 "E1M5: Phobos Lab"
|
||||
#define HUSTR_E1M6 "E1M6: Central Processing"
|
||||
#define HUSTR_E1M7 "E1M7: Computer Station"
|
||||
#define HUSTR_E1M8 "E1M8: Phobos Anomaly"
|
||||
#define HUSTR_E1M9 "E1M9: Military Base"
|
||||
|
||||
#define HUSTR_E2M1 "E2M1: Deimos Anomaly"
|
||||
#define HUSTR_E2M2 "E2M2: Containment Area"
|
||||
#define HUSTR_E2M3 "E2M3: Refinery"
|
||||
#define HUSTR_E2M4 "E2M4: Deimos Lab"
|
||||
#define HUSTR_E2M5 "E2M5: Command Center"
|
||||
#define HUSTR_E2M6 "E2M6: Halls of the Damned"
|
||||
#define HUSTR_E2M7 "E2M7: Spawning Vats"
|
||||
#define HUSTR_E2M8 "E2M8: Tower of Babel"
|
||||
#define HUSTR_E2M9 "E2M9: Fortress of Mystery"
|
||||
|
||||
#define HUSTR_E3M1 "E3M1: Hell Keep"
|
||||
#define HUSTR_E3M2 "E3M2: Slough of Despair"
|
||||
#define HUSTR_E3M3 "E3M3: Pandemonium"
|
||||
#define HUSTR_E3M4 "E3M4: House of Pain"
|
||||
#define HUSTR_E3M5 "E3M5: Unholy Cathedral"
|
||||
#define HUSTR_E3M6 "E3M6: Mt. Erebus"
|
||||
#define HUSTR_E3M7 "E3M7: Limbo"
|
||||
#define HUSTR_E3M8 "E3M8: Dis"
|
||||
#define HUSTR_E3M9 "E3M9: Warrens"
|
||||
|
||||
#define HUSTR_E4M1 "E4M1: Hell Beneath"
|
||||
#define HUSTR_E4M2 "E4M2: Perfect Hatred"
|
||||
#define HUSTR_E4M3 "E4M3: Sever The Wicked"
|
||||
#define HUSTR_E4M4 "E4M4: Unruly Evil"
|
||||
#define HUSTR_E4M5 "E4M5: They Will Repent"
|
||||
#define HUSTR_E4M6 "E4M6: Against Thee Wickedly"
|
||||
#define HUSTR_E4M7 "E4M7: And Hell Followed"
|
||||
#define HUSTR_E4M8 "E4M8: Unto The Cruel"
|
||||
#define HUSTR_E4M9 "E4M9: Fear"
|
||||
|
||||
#define HUSTR_1 "level 1: entryway"
|
||||
#define HUSTR_2 "level 2: underhalls"
|
||||
#define HUSTR_3 "level 3: the gantlet"
|
||||
#define HUSTR_4 "level 4: the focus"
|
||||
#define HUSTR_5 "level 5: the waste tunnels"
|
||||
#define HUSTR_6 "level 6: the crusher"
|
||||
#define HUSTR_7 "level 7: dead simple"
|
||||
#define HUSTR_8 "level 8: tricks and traps"
|
||||
#define HUSTR_9 "level 9: the pit"
|
||||
#define HUSTR_10 "level 10: refueling base"
|
||||
#define HUSTR_11 "level 11: 'o' of destruction!"
|
||||
|
||||
#define HUSTR_12 "level 12: the factory"
|
||||
#define HUSTR_13 "level 13: downtown"
|
||||
#define HUSTR_14 "level 14: the inmost dens"
|
||||
#define HUSTR_15 "level 15: industrial zone"
|
||||
#define HUSTR_16 "level 16: suburbs"
|
||||
#define HUSTR_17 "level 17: tenements"
|
||||
#define HUSTR_18 "level 18: the courtyard"
|
||||
#define HUSTR_19 "level 19: the citadel"
|
||||
#define HUSTR_20 "level 20: gotcha!"
|
||||
|
||||
#define HUSTR_21 "level 21: nirvana"
|
||||
#define HUSTR_22 "level 22: the catacombs"
|
||||
#define HUSTR_23 "level 23: barrels o' fun"
|
||||
#define HUSTR_24 "level 24: the chasm"
|
||||
#define HUSTR_25 "level 25: bloodfalls"
|
||||
#define HUSTR_26 "level 26: the abandoned mines"
|
||||
#define HUSTR_27 "level 27: monster condo"
|
||||
#define HUSTR_28 "level 28: the spirit world"
|
||||
#define HUSTR_29 "level 29: the living end"
|
||||
#define HUSTR_30 "level 30: icon of sin"
|
||||
|
||||
#define HUSTR_31 "level 31: wolfenstein"
|
||||
#define HUSTR_32 "level 32: grosse"
|
||||
|
||||
#define PHUSTR_1 "level 1: congo"
|
||||
#define PHUSTR_2 "level 2: well of souls"
|
||||
#define PHUSTR_3 "level 3: aztec"
|
||||
#define PHUSTR_4 "level 4: caged"
|
||||
#define PHUSTR_5 "level 5: ghost town"
|
||||
#define PHUSTR_6 "level 6: baron's lair"
|
||||
#define PHUSTR_7 "level 7: caughtyard"
|
||||
#define PHUSTR_8 "level 8: realm"
|
||||
#define PHUSTR_9 "level 9: abattoire"
|
||||
#define PHUSTR_10 "level 10: onslaught"
|
||||
#define PHUSTR_11 "level 11: hunted"
|
||||
|
||||
#define PHUSTR_12 "level 12: speed"
|
||||
#define PHUSTR_13 "level 13: the crypt"
|
||||
#define PHUSTR_14 "level 14: genesis"
|
||||
#define PHUSTR_15 "level 15: the twilight"
|
||||
#define PHUSTR_16 "level 16: the omen"
|
||||
#define PHUSTR_17 "level 17: compound"
|
||||
#define PHUSTR_18 "level 18: neurosphere"
|
||||
#define PHUSTR_19 "level 19: nme"
|
||||
#define PHUSTR_20 "level 20: the death domain"
|
||||
|
||||
#define PHUSTR_21 "level 21: slayer"
|
||||
#define PHUSTR_22 "level 22: impossible mission"
|
||||
#define PHUSTR_23 "level 23: tombstone"
|
||||
#define PHUSTR_24 "level 24: the final frontier"
|
||||
#define PHUSTR_25 "level 25: the temple of darkness"
|
||||
#define PHUSTR_26 "level 26: bunker"
|
||||
#define PHUSTR_27 "level 27: anti-christ"
|
||||
#define PHUSTR_28 "level 28: the sewers"
|
||||
#define PHUSTR_29 "level 29: odyssey of noises"
|
||||
#define PHUSTR_30 "level 30: the gateway of hell"
|
||||
|
||||
#define PHUSTR_31 "level 31: cyberden"
|
||||
#define PHUSTR_32 "level 32: go 2 it"
|
||||
|
||||
#define THUSTR_1 "level 1: system control"
|
||||
#define THUSTR_2 "level 2: human bbq"
|
||||
#define THUSTR_3 "level 3: power control"
|
||||
#define THUSTR_4 "level 4: wormhole"
|
||||
#define THUSTR_5 "level 5: hanger"
|
||||
#define THUSTR_6 "level 6: open season"
|
||||
#define THUSTR_7 "level 7: prison"
|
||||
#define THUSTR_8 "level 8: metal"
|
||||
#define THUSTR_9 "level 9: stronghold"
|
||||
#define THUSTR_10 "level 10: redemption"
|
||||
#define THUSTR_11 "level 11: storage facility"
|
||||
|
||||
#define THUSTR_12 "level 12: crater"
|
||||
#define THUSTR_13 "level 13: nukage processing"
|
||||
#define THUSTR_14 "level 14: steel works"
|
||||
#define THUSTR_15 "level 15: dead zone"
|
||||
#define THUSTR_16 "level 16: deepest reaches"
|
||||
#define THUSTR_17 "level 17: processing area"
|
||||
#define THUSTR_18 "level 18: mill"
|
||||
#define THUSTR_19 "level 19: shipping/respawning"
|
||||
#define THUSTR_20 "level 20: central processing"
|
||||
|
||||
#define THUSTR_21 "level 21: administration center"
|
||||
#define THUSTR_22 "level 22: habitat"
|
||||
#define THUSTR_23 "level 23: lunar mining project"
|
||||
#define THUSTR_24 "level 24: quarry"
|
||||
#define THUSTR_25 "level 25: baron's den"
|
||||
#define THUSTR_26 "level 26: ballistyx"
|
||||
#define THUSTR_27 "level 27: mount pain"
|
||||
#define THUSTR_28 "level 28: heck"
|
||||
#define THUSTR_29 "level 29: river styx"
|
||||
#define THUSTR_30 "level 30: last call"
|
||||
|
||||
#define THUSTR_31 "level 31: pharaoh"
|
||||
#define THUSTR_32 "level 32: caribbean"
|
||||
|
||||
#define HUSTR_CHATMACRO1 "I'm ready to kick butt!"
|
||||
#define HUSTR_CHATMACRO2 "I'm OK."
|
||||
#define HUSTR_CHATMACRO3 "I'm not looking too good!"
|
||||
#define HUSTR_CHATMACRO4 "Help!"
|
||||
#define HUSTR_CHATMACRO5 "You suck!"
|
||||
#define HUSTR_CHATMACRO6 "Next time, scumbag..."
|
||||
#define HUSTR_CHATMACRO7 "Come here!"
|
||||
#define HUSTR_CHATMACRO8 "I'll take care of it."
|
||||
#define HUSTR_CHATMACRO9 "Yes"
|
||||
#define HUSTR_CHATMACRO0 "No"
|
||||
|
||||
#define HUSTR_TALKTOSELF1 "You mumble to yourself"
|
||||
#define HUSTR_TALKTOSELF2 "Who's there?"
|
||||
#define HUSTR_TALKTOSELF3 "You scare yourself"
|
||||
#define HUSTR_TALKTOSELF4 "You start to rave"
|
||||
#define HUSTR_TALKTOSELF5 "You've lost it..."
|
||||
|
||||
#define HUSTR_MESSAGESENT "[Message Sent]"
|
||||
|
||||
// The following should NOT be changed unless it seems
|
||||
// just AWFULLY necessary
|
||||
|
||||
#define HUSTR_PLRGREEN "Green: "
|
||||
#define HUSTR_PLRINDIGO "Indigo: "
|
||||
#define HUSTR_PLRBROWN "Brown: "
|
||||
#define HUSTR_PLRRED "Red: "
|
||||
|
||||
#define HUSTR_KEYGREEN 'g'
|
||||
#define HUSTR_KEYINDIGO 'i'
|
||||
#define HUSTR_KEYBROWN 'b'
|
||||
#define HUSTR_KEYRED 'r'
|
||||
|
||||
//
|
||||
// AM_map.C
|
||||
//
|
||||
|
||||
#define AMSTR_FOLLOWON "Follow Mode ON"
|
||||
#define AMSTR_FOLLOWOFF "Follow Mode OFF"
|
||||
|
||||
#define AMSTR_GRIDON "Grid ON"
|
||||
#define AMSTR_GRIDOFF "Grid OFF"
|
||||
|
||||
#define AMSTR_MARKEDSPOT "Marked Spot"
|
||||
#define AMSTR_MARKSCLEARED "All Marks Cleared"
|
||||
|
||||
//
|
||||
// ST_stuff.C
|
||||
//
|
||||
|
||||
#define STSTR_MUS "Music Change"
|
||||
#define STSTR_NOMUS "IMPOSSIBLE SELECTION"
|
||||
#define STSTR_DQDON "Degreelessness Mode On"
|
||||
#define STSTR_DQDOFF "Degreelessness Mode Off"
|
||||
|
||||
#define STSTR_KFAADDED "Very Happy Ammo Added"
|
||||
#define STSTR_FAADDED "Ammo (no keys) Added"
|
||||
|
||||
#define STSTR_NCON "No Clipping Mode ON"
|
||||
#define STSTR_NCOFF "No Clipping Mode OFF"
|
||||
|
||||
#define STSTR_BEHOLD "inVuln, Str, Inviso, Rad, Allmap, or Lite-amp"
|
||||
#define STSTR_BEHOLDX "Power-up Toggled"
|
||||
|
||||
#define STSTR_CHOPPERS "... doesn't suck - GM"
|
||||
#define STSTR_CLEV "Changing Level..."
|
||||
|
||||
//
|
||||
// F_Finale.C
|
||||
//
|
||||
#define E1TEXT \
|
||||
"Once you beat the big badasses and\n"\
|
||||
"clean out the moon base you're supposed\n"\
|
||||
"to win, aren't you? Aren't you? Where's\n"\
|
||||
"your fat reward and ticket home? What\n"\
|
||||
"the hell is this? It's not supposed to\n"\
|
||||
"end this way!\n"\
|
||||
"\n" \
|
||||
"It stinks like rotten meat, but looks\n"\
|
||||
"like the lost Deimos base. Looks like\n"\
|
||||
"you're stuck on The Shores of Hell.\n"\
|
||||
"The only way out is through.\n"\
|
||||
"\n"\
|
||||
"To continue the DOOM experience, play\n"\
|
||||
"The Shores of Hell and its amazing\n"\
|
||||
"sequel, Inferno!\n"
|
||||
|
||||
|
||||
#define E2TEXT \
|
||||
"You've done it! The hideous cyber-\n"\
|
||||
"demon lord that ruled the lost Deimos\n"\
|
||||
"moon base has been slain and you\n"\
|
||||
"are triumphant! But ... where are\n"\
|
||||
"you? You clamber to the edge of the\n"\
|
||||
"moon and look down to see the awful\n"\
|
||||
"truth.\n" \
|
||||
"\n"\
|
||||
"Deimos floats above Hell itself!\n"\
|
||||
"You've never heard of anyone escaping\n"\
|
||||
"from Hell, but you'll make the bastards\n"\
|
||||
"sorry they ever heard of you! Quickly,\n"\
|
||||
"you rappel down to the surface of\n"\
|
||||
"Hell.\n"\
|
||||
"\n" \
|
||||
"Now, it's on to the final chapter of\n"\
|
||||
"DOOM! -- Inferno."
|
||||
|
||||
|
||||
#define E3TEXT \
|
||||
"The loathsome spiderdemon that\n"\
|
||||
"masterminded the invasion of the moon\n"\
|
||||
"bases and caused so much death has had\n"\
|
||||
"its ass kicked for all time.\n"\
|
||||
"\n"\
|
||||
"A hidden doorway opens and you enter.\n"\
|
||||
"You've proven too tough for Hell to\n"\
|
||||
"contain, and now Hell at last plays\n"\
|
||||
"fair -- for you emerge from the door\n"\
|
||||
"to see the green fields of Earth!\n"\
|
||||
"Home at last.\n" \
|
||||
"\n"\
|
||||
"You wonder what's been happening on\n"\
|
||||
"Earth while you were battling evil\n"\
|
||||
"unleashed. It's good that no Hell-\n"\
|
||||
"spawn could have come through that\n"\
|
||||
"door with you ..."
|
||||
|
||||
|
||||
#define E4TEXT \
|
||||
"the spider mastermind must have sent forth\n"\
|
||||
"its legions of hellspawn before your\n"\
|
||||
"final confrontation with that terrible\n"\
|
||||
"beast from hell. but you stepped forward\n"\
|
||||
"and brought forth eternal damnation and\n"\
|
||||
"suffering upon the horde as a true hero\n"\
|
||||
"would in the face of something so evil.\n"\
|
||||
"\n"\
|
||||
"besides, someone was gonna pay for what\n"\
|
||||
"happened to daisy, your pet rabbit.\n"\
|
||||
"\n"\
|
||||
"but now, you see spread before you more\n"\
|
||||
"potential pain and gibbitude as a nation\n"\
|
||||
"of demons run amok among our cities.\n"\
|
||||
"\n"\
|
||||
"next stop, hell on earth!"
|
||||
|
||||
|
||||
// after level 6, put this:
|
||||
|
||||
#define C1TEXT \
|
||||
"YOU HAVE ENTERED DEEPLY INTO THE INFESTED\n" \
|
||||
"STARPORT. BUT SOMETHING IS WRONG. THE\n" \
|
||||
"MONSTERS HAVE BROUGHT THEIR OWN REALITY\n" \
|
||||
"WITH THEM, AND THE STARPORT'S TECHNOLOGY\n" \
|
||||
"IS BEING SUBVERTED BY THEIR PRESENCE.\n" \
|
||||
"\n"\
|
||||
"AHEAD, YOU SEE AN OUTPOST OF HELL, A\n" \
|
||||
"FORTIFIED ZONE. IF YOU CAN GET PAST IT,\n" \
|
||||
"YOU CAN PENETRATE INTO THE HAUNTED HEART\n" \
|
||||
"OF THE STARBASE AND FIND THE CONTROLLING\n" \
|
||||
"SWITCH WHICH HOLDS EARTH'S POPULATION\n" \
|
||||
"HOSTAGE."
|
||||
|
||||
// After level 11, put this:
|
||||
|
||||
#define C2TEXT \
|
||||
"YOU HAVE WON! YOUR VICTORY HAS ENABLED\n" \
|
||||
"HUMANKIND TO EVACUATE EARTH AND ESCAPE\n"\
|
||||
"THE NIGHTMARE. NOW YOU ARE THE ONLY\n"\
|
||||
"HUMAN LEFT ON THE FACE OF THE PLANET.\n"\
|
||||
"CANNIBAL MUTATIONS, CARNIVOROUS ALIENS,\n"\
|
||||
"AND EVIL SPIRITS ARE YOUR ONLY NEIGHBORS.\n"\
|
||||
"YOU SIT BACK AND WAIT FOR DEATH, CONTENT\n"\
|
||||
"THAT YOU HAVE SAVED YOUR SPECIES.\n"\
|
||||
"\n"\
|
||||
"BUT THEN, EARTH CONTROL BEAMS DOWN A\n"\
|
||||
"MESSAGE FROM SPACE: \"SENSORS HAVE LOCATED\n"\
|
||||
"THE SOURCE OF THE ALIEN INVASION. IF YOU\n"\
|
||||
"GO THERE, YOU MAY BE ABLE TO BLOCK THEIR\n"\
|
||||
"ENTRY. THE ALIEN BASE IS IN THE HEART OF\n"\
|
||||
"YOUR OWN HOME CITY, NOT FAR FROM THE\n"\
|
||||
"STARPORT.\" SLOWLY AND PAINFULLY YOU GET\n"\
|
||||
"UP AND RETURN TO THE FRAY."
|
||||
|
||||
|
||||
// After level 20, put this:
|
||||
|
||||
#define C3TEXT \
|
||||
"YOU ARE AT THE CORRUPT HEART OF THE CITY,\n"\
|
||||
"SURROUNDED BY THE CORPSES OF YOUR ENEMIES.\n"\
|
||||
"YOU SEE NO WAY TO DESTROY THE CREATURES'\n"\
|
||||
"ENTRYWAY ON THIS SIDE, SO YOU CLENCH YOUR\n"\
|
||||
"TEETH AND PLUNGE THROUGH IT.\n"\
|
||||
"\n"\
|
||||
"THERE MUST BE A WAY TO CLOSE IT ON THE\n"\
|
||||
"OTHER SIDE. WHAT DO YOU CARE IF YOU'VE\n"\
|
||||
"GOT TO GO THROUGH HELL TO GET TO IT?"
|
||||
|
||||
|
||||
// After level 29, put this:
|
||||
|
||||
#define C4TEXT \
|
||||
"THE HORRENDOUS VISAGE OF THE BIGGEST\n"\
|
||||
"DEMON YOU'VE EVER SEEN CRUMBLES BEFORE\n"\
|
||||
"YOU, AFTER YOU PUMP YOUR ROCKETS INTO\n"\
|
||||
"HIS EXPOSED BRAIN. THE MONSTER SHRIVELS\n"\
|
||||
"UP AND DIES, ITS THRASHING LIMBS\n"\
|
||||
"DEVASTATING UNTOLD MILES OF HELL'S\n"\
|
||||
"SURFACE.\n"\
|
||||
"\n"\
|
||||
"YOU'VE DONE IT. THE INVASION IS OVER.\n"\
|
||||
"EARTH IS SAVED. HELL IS A WRECK. YOU\n"\
|
||||
"WONDER WHERE BAD FOLKS WILL GO WHEN THEY\n"\
|
||||
"DIE, NOW. WIPING THE SWEAT FROM YOUR\n"\
|
||||
"FOREHEAD YOU BEGIN THE LONG TREK BACK\n"\
|
||||
"HOME. REBUILDING EARTH OUGHT TO BE A\n"\
|
||||
"LOT MORE FUN THAN RUINING IT WAS.\n"
|
||||
|
||||
|
||||
|
||||
// Before level 31, put this:
|
||||
|
||||
#define C5TEXT \
|
||||
"CONGRATULATIONS, YOU'VE FOUND THE SECRET\n"\
|
||||
"LEVEL! LOOKS LIKE IT'S BEEN BUILT BY\n"\
|
||||
"HUMANS, RATHER THAN DEMONS. YOU WONDER\n"\
|
||||
"WHO THE INMATES OF THIS CORNER OF HELL\n"\
|
||||
"WILL BE."
|
||||
|
||||
|
||||
// Before level 32, put this:
|
||||
|
||||
#define C6TEXT \
|
||||
"CONGRATULATIONS, YOU'VE FOUND THE\n"\
|
||||
"SUPER SECRET LEVEL! YOU'D BETTER\n"\
|
||||
"BLAZE THROUGH THIS ONE!\n"
|
||||
|
||||
|
||||
// after map 06
|
||||
|
||||
#define P1TEXT \
|
||||
"You gloat over the steaming carcass of the\n"\
|
||||
"Guardian. With its death, you've wrested\n"\
|
||||
"the Accelerator from the stinking claws\n"\
|
||||
"of Hell. You relax and glance around the\n"\
|
||||
"room. Damn! There was supposed to be at\n"\
|
||||
"least one working prototype, but you can't\n"\
|
||||
"see it. The demons must have taken it.\n"\
|
||||
"\n"\
|
||||
"You must find the prototype, or all your\n"\
|
||||
"struggles will have been wasted. Keep\n"\
|
||||
"moving, keep fighting, keep killing.\n"\
|
||||
"Oh yes, keep living, too."
|
||||
|
||||
|
||||
// after map 11
|
||||
|
||||
#define P2TEXT \
|
||||
"Even the deadly Arch-Vile labyrinth could\n"\
|
||||
"not stop you, and you've gotten to the\n"\
|
||||
"prototype Accelerator which is soon\n"\
|
||||
"efficiently and permanently deactivated.\n"\
|
||||
"\n"\
|
||||
"You're good at that kind of thing."
|
||||
|
||||
|
||||
// after map 20
|
||||
|
||||
#define P3TEXT \
|
||||
"You've bashed and battered your way into\n"\
|
||||
"the heart of the devil-hive. Time for a\n"\
|
||||
"Search-and-Destroy mission, aimed at the\n"\
|
||||
"Gatekeeper, whose foul offspring is\n"\
|
||||
"cascading to Earth. Yeah, he's bad. But\n"\
|
||||
"you know who's worse!\n"\
|
||||
"\n"\
|
||||
"Grinning evilly, you check your gear, and\n"\
|
||||
"get ready to give the bastard a little Hell\n"\
|
||||
"of your own making!"
|
||||
|
||||
// after map 30
|
||||
|
||||
#define P4TEXT \
|
||||
"The Gatekeeper's evil face is splattered\n"\
|
||||
"all over the place. As its tattered corpse\n"\
|
||||
"collapses, an inverted Gate forms and\n"\
|
||||
"sucks down the shards of the last\n"\
|
||||
"prototype Accelerator, not to mention the\n"\
|
||||
"few remaining demons. You're done. Hell\n"\
|
||||
"has gone back to pounding bad dead folks \n"\
|
||||
"instead of good live ones. Remember to\n"\
|
||||
"tell your grandkids to put a rocket\n"\
|
||||
"launcher in your coffin. If you go to Hell\n"\
|
||||
"when you die, you'll need it for some\n"\
|
||||
"final cleaning-up ..."
|
||||
|
||||
// before map 31
|
||||
|
||||
#define P5TEXT \
|
||||
"You've found the second-hardest level we\n"\
|
||||
"got. Hope you have a saved game a level or\n"\
|
||||
"two previous. If not, be prepared to die\n"\
|
||||
"aplenty. For master marines only."
|
||||
|
||||
// before map 32
|
||||
|
||||
#define P6TEXT \
|
||||
"Betcha wondered just what WAS the hardest\n"\
|
||||
"level we had ready for ya? Now you know.\n"\
|
||||
"No one gets out alive."
|
||||
|
||||
|
||||
#define T1TEXT \
|
||||
"You've fought your way out of the infested\n"\
|
||||
"experimental labs. It seems that UAC has\n"\
|
||||
"once again gulped it down. With their\n"\
|
||||
"high turnover, it must be hard for poor\n"\
|
||||
"old UAC to buy corporate health insurance\n"\
|
||||
"nowadays..\n"\
|
||||
"\n"\
|
||||
"Ahead lies the military complex, now\n"\
|
||||
"swarming with diseased horrors hot to get\n"\
|
||||
"their teeth into you. With luck, the\n"\
|
||||
"complex still has some warlike ordnance\n"\
|
||||
"laying around."
|
||||
|
||||
|
||||
#define T2TEXT \
|
||||
"You hear the grinding of heavy machinery\n"\
|
||||
"ahead. You sure hope they're not stamping\n"\
|
||||
"out new hellspawn, but you're ready to\n"\
|
||||
"ream out a whole herd if you have to.\n"\
|
||||
"They might be planning a blood feast, but\n"\
|
||||
"you feel about as mean as two thousand\n"\
|
||||
"maniacs packed into one mad killer.\n"\
|
||||
"\n"\
|
||||
"You don't plan to go down easy."
|
||||
|
||||
|
||||
#define T3TEXT \
|
||||
"The vista opening ahead looks real damn\n"\
|
||||
"familiar. Smells familiar, too -- like\n"\
|
||||
"fried excrement. You didn't like this\n"\
|
||||
"place before, and you sure as hell ain't\n"\
|
||||
"planning to like it now. The more you\n"\
|
||||
"brood on it, the madder you get.\n"\
|
||||
"Hefting your gun, an evil grin trickles\n"\
|
||||
"onto your face. Time to take some names."
|
||||
|
||||
#define T4TEXT \
|
||||
"Suddenly, all is silent, from one horizon\n"\
|
||||
"to the other. The agonizing echo of Hell\n"\
|
||||
"fades away, the nightmare sky turns to\n"\
|
||||
"blue, the heaps of monster corpses start \n"\
|
||||
"to evaporate along with the evil stench \n"\
|
||||
"that filled the air. Jeeze, maybe you've\n"\
|
||||
"done it. Have you really won?\n"\
|
||||
"\n"\
|
||||
"Something rumbles in the distance.\n"\
|
||||
"A blue light begins to glow inside the\n"\
|
||||
"ruined skull of the demon-spitter."
|
||||
|
||||
|
||||
#define T5TEXT \
|
||||
"What now? Looks totally different. Kind\n"\
|
||||
"of like King Tut's condo. Well,\n"\
|
||||
"whatever's here can't be any worse\n"\
|
||||
"than usual. Can it? Or maybe it's best\n"\
|
||||
"to let sleeping gods lie.."
|
||||
|
||||
|
||||
#define T6TEXT \
|
||||
"Time for a vacation. You've burst the\n"\
|
||||
"bowels of hell and by golly you're ready\n"\
|
||||
"for a break. You mutter to yourself,\n"\
|
||||
"Maybe someone else can kick Hell's ass\n"\
|
||||
"next time around. Ahead lies a quiet town,\n"\
|
||||
"with peaceful flowing water, quaint\n"\
|
||||
"buildings, and presumably no Hellspawn.\n"\
|
||||
"\n"\
|
||||
"As you step off the transport, you hear\n"\
|
||||
"the stomp of a cyberdemon's iron shoe."
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Character cast strings F_FINALE.C
|
||||
//
|
||||
#define CC_ZOMBIE "ZOMBIEMAN"
|
||||
#define CC_SHOTGUN "SHOTGUN GUY"
|
||||
#define CC_HEAVY "HEAVY WEAPON DUDE"
|
||||
#define CC_IMP "IMP"
|
||||
#define CC_DEMON "DEMON"
|
||||
#define CC_LOST "LOST SOUL"
|
||||
#define CC_CACO "CACODEMON"
|
||||
#define CC_HELL "HELL KNIGHT"
|
||||
#define CC_BARON "BARON OF HELL"
|
||||
#define CC_ARACH "ARACHNOTRON"
|
||||
#define CC_PAIN "PAIN ELEMENTAL"
|
||||
#define CC_REVEN "REVENANT"
|
||||
#define CC_MANCU "MANCUBUS"
|
||||
#define CC_ARCH "ARCH-VILE"
|
||||
#define CC_SPIDER "THE SPIDER MASTERMIND"
|
||||
#define CC_CYBER "THE CYBERDEMON"
|
||||
#define CC_HERO "OUR HERO"
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,122 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
//
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __D_EVENT__
|
||||
#define __D_EVENT__
|
||||
|
||||
|
||||
#include "doomtype.h"
|
||||
|
||||
|
||||
//
|
||||
// Event handling.
|
||||
//
|
||||
|
||||
// Input event types.
|
||||
typedef enum
|
||||
{
|
||||
ev_keydown,
|
||||
ev_keyup,
|
||||
ev_mouse,
|
||||
ev_joystick
|
||||
} evtype_t;
|
||||
|
||||
// Event structure.
|
||||
typedef struct
|
||||
{
|
||||
evtype_t type;
|
||||
int data1; // keys / mouse/joystick buttons
|
||||
int data2; // mouse/joystick x move
|
||||
int data3; // mouse/joystick y move
|
||||
} event_t;
|
||||
|
||||
|
||||
typedef enum
|
||||
{
|
||||
ga_nothing,
|
||||
ga_loadlevel,
|
||||
ga_newgame,
|
||||
ga_loadgame,
|
||||
ga_savegame,
|
||||
ga_playdemo,
|
||||
ga_completed,
|
||||
ga_victory,
|
||||
ga_worlddone,
|
||||
ga_screenshot
|
||||
} gameaction_t;
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Button/action code definitions.
|
||||
//
|
||||
typedef enum
|
||||
{
|
||||
// Press "Fire".
|
||||
BT_ATTACK = 1,
|
||||
// Use button, to open doors, activate switches.
|
||||
BT_USE = 2,
|
||||
|
||||
// Flag: game events, not really buttons.
|
||||
BT_SPECIAL = 128,
|
||||
BT_SPECIALMASK = 3,
|
||||
|
||||
// Flag, weapon change pending.
|
||||
// If true, the next 3 bits hold weapon num.
|
||||
BT_CHANGE = 4,
|
||||
// The 3bit weapon mask and shift, convenience.
|
||||
BT_WEAPONMASK = (8+16+32),
|
||||
BT_WEAPONSHIFT = 3,
|
||||
|
||||
// Pause the game.
|
||||
BTS_PAUSE = 1,
|
||||
// Save the game at each console.
|
||||
BTS_SAVEGAME = 2,
|
||||
|
||||
// Savegame slot numbers
|
||||
// occupy the second byte of buttons.
|
||||
BTS_SAVEMASK = (4+8+16),
|
||||
BTS_SAVESHIFT = 2,
|
||||
|
||||
} buttoncode_t;
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// GLOBAL VARIABLES
|
||||
//
|
||||
#define MAXEVENTS 64
|
||||
|
||||
extern event_t events[MAXEVENTS];
|
||||
extern int eventhead;
|
||||
extern int eventtail;
|
||||
|
||||
extern gameaction_t gameaction;
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,433 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Printed strings, french translation.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __D_FRENCH__
|
||||
#define __D_FRENCH__
|
||||
|
||||
//
|
||||
// D_Main.C
|
||||
//
|
||||
#define D_DEVSTR "MODE DEVELOPPEMENT ON.\n"
|
||||
#define D_CDROM "VERSION CD-ROM: DEFAULT.CFG DANS C:\\DOOMDATA\n"
|
||||
|
||||
//
|
||||
// M_Menu.C
|
||||
//
|
||||
#define PRESSKEY "APPUYEZ SUR UNE TOUCHE."
|
||||
#define PRESSYN "APPUYEZ SUR Y OU N"
|
||||
#define QUITMSG "VOUS VOULEZ VRAIMENT\nQUITTER CE SUPER JEU?"
|
||||
#define LOADNET "VOUS NE POUVEZ PAS CHARGER\nUN JEU EN RESEAU!\n\n"PRESSKEY
|
||||
#define QLOADNET "CHARGEMENT RAPIDE INTERDIT EN RESEAU!\n\n"PRESSKEY
|
||||
#define QSAVESPOT "VOUS N'AVEZ PAS CHOISI UN EMPLACEMENT!\n\n"PRESSKEY
|
||||
#define SAVEDEAD "VOUS NE POUVEZ PAS SAUVER SI VOUS NE JOUEZ "\
|
||||
"PAS!\n\n"PRESSKEY
|
||||
#define QSPROMPT "SAUVEGARDE RAPIDE DANS LE FICHIER \n\n'%s'?\n\n"PRESSYN
|
||||
#define QLPROMPT "VOULEZ-VOUS CHARGER LA SAUVEGARDE"\
|
||||
"\n\n'%s'?\n\n"PRESSYN
|
||||
#define NEWGAME "VOUS NE POUVEZ PAS LANCER\n"\
|
||||
"UN NOUVEAU JEU SUR RESEAU.\n\n"PRESSKEY
|
||||
#define NIGHTMARE "VOUS CONFIRMEZ? CE NIVEAU EST\n"\
|
||||
"VRAIMENT IMPITOYABLE!n"PRESSYN
|
||||
#define SWSTRING "CECI EST UNE VERSION SHAREWARE DE DOOM.\n\n"\
|
||||
"VOUS DEVRIEZ COMMANDER LA TRILOGIE COMPLETE.\n\n"PRESSKEY
|
||||
#define MSGOFF "MESSAGES OFF"
|
||||
#define MSGON "MESSAGES ON"
|
||||
#define NETEND "VOUS NE POUVEZ PAS METTRE FIN A UN JEU SUR "\
|
||||
"RESEAU!\n\n"PRESSKEY
|
||||
#define ENDGAME "VOUS VOULEZ VRAIMENT METTRE FIN AU JEU?\n\n"PRESSYN
|
||||
|
||||
#define DOSY "(APPUYEZ SUR Y POUR REVENIR AU OS.)"
|
||||
|
||||
#define DETAILHI "GRAPHISMES MAXIMUM "
|
||||
#define DETAILLO "GRAPHISMES MINIMUM "
|
||||
#define GAMMALVL0 "CORRECTION GAMMA OFF"
|
||||
#define GAMMALVL1 "CORRECTION GAMMA NIVEAU 1"
|
||||
#define GAMMALVL2 "CORRECTION GAMMA NIVEAU 2"
|
||||
#define GAMMALVL3 "CORRECTION GAMMA NIVEAU 3"
|
||||
#define GAMMALVL4 "CORRECTION GAMMA NIVEAU 4"
|
||||
#define EMPTYSTRING "EMPLACEMENT VIDE"
|
||||
|
||||
//
|
||||
// P_inter.C
|
||||
//
|
||||
#define GOTARMOR "ARMURE RECUPEREE."
|
||||
#define GOTMEGA "MEGA-ARMURE RECUPEREE!"
|
||||
#define GOTHTHBONUS "BONUS DE SANTE RECUPERE."
|
||||
#define GOTARMBONUS "BONUS D'ARMURE RECUPERE."
|
||||
#define GOTSTIM "STIMPACK RECUPERE."
|
||||
#define GOTMEDINEED "MEDIKIT RECUPERE. VOUS EN AVEZ VRAIMENT BESOIN!"
|
||||
#define GOTMEDIKIT "MEDIKIT RECUPERE."
|
||||
#define GOTSUPER "SUPERCHARGE!"
|
||||
|
||||
#define GOTBLUECARD "CARTE MAGNETIQUE BLEUE RECUPEREE."
|
||||
#define GOTYELWCARD "CARTE MAGNETIQUE JAUNE RECUPEREE."
|
||||
#define GOTREDCARD "CARTE MAGNETIQUE ROUGE RECUPEREE."
|
||||
#define GOTBLUESKUL "CLEF CRANE BLEUE RECUPEREE."
|
||||
#define GOTYELWSKUL "CLEF CRANE JAUNE RECUPEREE."
|
||||
#define GOTREDSKULL "CLEF CRANE ROUGE RECUPEREE."
|
||||
|
||||
#define GOTINVUL "INVULNERABILITE!"
|
||||
#define GOTBERSERK "BERSERK!"
|
||||
#define GOTINVIS "INVISIBILITE PARTIELLE "
|
||||
#define GOTSUIT "COMBINAISON ANTI-RADIATIONS "
|
||||
#define GOTMAP "CARTE INFORMATIQUE "
|
||||
#define GOTVISOR "VISEUR A AMPLIFICATION DE LUMIERE "
|
||||
#define GOTMSPHERE "MEGASPHERE!"
|
||||
|
||||
#define GOTCLIP "CHARGEUR RECUPERE."
|
||||
#define GOTCLIPBOX "BOITE DE BALLES RECUPEREE."
|
||||
#define GOTROCKET "ROQUETTE RECUPEREE."
|
||||
#define GOTROCKBOX "CAISSE DE ROQUETTES RECUPEREE."
|
||||
#define GOTCELL "CELLULE D'ENERGIE RECUPEREE."
|
||||
#define GOTCELLBOX "PACK DE CELLULES D'ENERGIE RECUPERE."
|
||||
#define GOTSHELLS "4 CARTOUCHES RECUPEREES."
|
||||
#define GOTSHELLBOX "BOITE DE CARTOUCHES RECUPEREE."
|
||||
#define GOTBACKPACK "SAC PLEIN DE MUNITIONS RECUPERE!"
|
||||
|
||||
#define GOTBFG9000 "VOUS AVEZ UN BFG9000! OH, OUI!"
|
||||
#define GOTCHAINGUN "VOUS AVEZ LA MITRAILLEUSE!"
|
||||
#define GOTCHAINSAW "UNE TRONCONNEUSE!"
|
||||
#define GOTLAUNCHER "VOUS AVEZ UN LANCE-ROQUETTES!"
|
||||
#define GOTPLASMA "VOUS AVEZ UN FUSIL A PLASMA!"
|
||||
#define GOTSHOTGUN "VOUS AVEZ UN FUSIL!"
|
||||
#define GOTSHOTGUN2 "VOUS AVEZ UN SUPER FUSIL!"
|
||||
|
||||
//
|
||||
// P_Doors.C
|
||||
//
|
||||
#define PD_BLUEO "IL VOUS FAUT UNE CLEF BLEUE"
|
||||
#define PD_REDO "IL VOUS FAUT UNE CLEF ROUGE"
|
||||
#define PD_YELLOWO "IL VOUS FAUT UNE CLEF JAUNE"
|
||||
#define PD_BLUEK PD_BLUEO
|
||||
#define PD_REDK PD_REDO
|
||||
#define PD_YELLOWK PD_YELLOWO
|
||||
|
||||
//
|
||||
// G_game.C
|
||||
//
|
||||
#define GGSAVED "JEU SAUVEGARDE."
|
||||
|
||||
//
|
||||
// HU_stuff.C
|
||||
//
|
||||
#define HUSTR_MSGU "[MESSAGE NON ENVOYE]"
|
||||
|
||||
#define HUSTR_E1M1 "E1M1: HANGAR"
|
||||
#define HUSTR_E1M2 "E1M2: USINE NUCLEAIRE "
|
||||
#define HUSTR_E1M3 "E1M3: RAFFINERIE DE TOXINES "
|
||||
#define HUSTR_E1M4 "E1M4: CENTRE DE CONTROLE "
|
||||
#define HUSTR_E1M5 "E1M5: LABORATOIRE PHOBOS "
|
||||
#define HUSTR_E1M6 "E1M6: TRAITEMENT CENTRAL "
|
||||
#define HUSTR_E1M7 "E1M7: CENTRE INFORMATIQUE "
|
||||
#define HUSTR_E1M8 "E1M8: ANOMALIE PHOBOS "
|
||||
#define HUSTR_E1M9 "E1M9: BASE MILITAIRE "
|
||||
|
||||
#define HUSTR_E2M1 "E2M1: ANOMALIE DEIMOS "
|
||||
#define HUSTR_E2M2 "E2M2: ZONE DE CONFINEMENT "
|
||||
#define HUSTR_E2M3 "E2M3: RAFFINERIE"
|
||||
#define HUSTR_E2M4 "E2M4: LABORATOIRE DEIMOS "
|
||||
#define HUSTR_E2M5 "E2M5: CENTRE DE CONTROLE "
|
||||
#define HUSTR_E2M6 "E2M6: HALLS DES DAMNES "
|
||||
#define HUSTR_E2M7 "E2M7: CUVES DE REPRODUCTION "
|
||||
#define HUSTR_E2M8 "E2M8: TOUR DE BABEL "
|
||||
#define HUSTR_E2M9 "E2M9: FORTERESSE DU MYSTERE "
|
||||
|
||||
#define HUSTR_E3M1 "E3M1: DONJON DE L'ENFER "
|
||||
#define HUSTR_E3M2 "E3M2: BOURBIER DU DESESPOIR "
|
||||
#define HUSTR_E3M3 "E3M3: PANDEMONIUM"
|
||||
#define HUSTR_E3M4 "E3M4: MAISON DE LA DOULEUR "
|
||||
#define HUSTR_E3M5 "E3M5: CATHEDRALE PROFANE "
|
||||
#define HUSTR_E3M6 "E3M6: MONT EREBUS"
|
||||
#define HUSTR_E3M7 "E3M7: LIMBES"
|
||||
#define HUSTR_E3M8 "E3M8: DIS"
|
||||
#define HUSTR_E3M9 "E3M9: CLAPIERS"
|
||||
|
||||
#define HUSTR_1 "NIVEAU 1: ENTREE "
|
||||
#define HUSTR_2 "NIVEAU 2: HALLS SOUTERRAINS "
|
||||
#define HUSTR_3 "NIVEAU 3: LE FEU NOURRI "
|
||||
#define HUSTR_4 "NIVEAU 4: LE FOYER "
|
||||
#define HUSTR_5 "NIVEAU 5: LES EGOUTS "
|
||||
#define HUSTR_6 "NIVEAU 6: LE BROYEUR "
|
||||
#define HUSTR_7 "NIVEAU 7: L'HERBE DE LA MORT"
|
||||
#define HUSTR_8 "NIVEAU 8: RUSES ET PIEGES "
|
||||
#define HUSTR_9 "NIVEAU 9: LE PUITS "
|
||||
#define HUSTR_10 "NIVEAU 10: BASE DE RAVITAILLEMENT "
|
||||
#define HUSTR_11 "NIVEAU 11: LE CERCLE DE LA MORT!"
|
||||
|
||||
#define HUSTR_12 "NIVEAU 12: L'USINE "
|
||||
#define HUSTR_13 "NIVEAU 13: LE CENTRE VILLE"
|
||||
#define HUSTR_14 "NIVEAU 14: LES ANTRES PROFONDES "
|
||||
#define HUSTR_15 "NIVEAU 15: LA ZONE INDUSTRIELLE "
|
||||
#define HUSTR_16 "NIVEAU 16: LA BANLIEUE"
|
||||
#define HUSTR_17 "NIVEAU 17: LES IMMEUBLES"
|
||||
#define HUSTR_18 "NIVEAU 18: LA COUR "
|
||||
#define HUSTR_19 "NIVEAU 19: LA CITADELLE "
|
||||
#define HUSTR_20 "NIVEAU 20: JE T'AI EU!"
|
||||
|
||||
#define HUSTR_21 "NIVEAU 21: LE NIRVANA"
|
||||
#define HUSTR_22 "NIVEAU 22: LES CATACOMBES "
|
||||
#define HUSTR_23 "NIVEAU 23: LA GRANDE FETE "
|
||||
#define HUSTR_24 "NIVEAU 24: LE GOUFFRE "
|
||||
#define HUSTR_25 "NIVEAU 25: LES CHUTES DE SANG"
|
||||
#define HUSTR_26 "NIVEAU 26: LES MINES ABANDONNEES "
|
||||
#define HUSTR_27 "NIVEAU 27: CHEZ LES MONSTRES "
|
||||
#define HUSTR_28 "NIVEAU 28: LE MONDE DE L'ESPRIT "
|
||||
#define HUSTR_29 "NIVEAU 29: LA LIMITE "
|
||||
#define HUSTR_30 "NIVEAU 30: L'ICONE DU PECHE "
|
||||
|
||||
#define HUSTR_31 "NIVEAU 31: WOLFENSTEIN"
|
||||
#define HUSTR_32 "NIVEAU 32: LE MASSACRE"
|
||||
|
||||
|
||||
#define HUSTR_CHATMACRO1 "JE SUIS PRET A LEUR EN FAIRE BAVER!"
|
||||
#define HUSTR_CHATMACRO2 "JE VAIS BIEN."
|
||||
#define HUSTR_CHATMACRO3 "JE N'AI PAS L'AIR EN FORME!"
|
||||
#define HUSTR_CHATMACRO4 "AU SECOURS!"
|
||||
#define HUSTR_CHATMACRO5 "TU CRAINS!"
|
||||
#define HUSTR_CHATMACRO6 "LA PROCHAINE FOIS, MINABLE..."
|
||||
#define HUSTR_CHATMACRO7 "VIENS ICI!"
|
||||
#define HUSTR_CHATMACRO8 "JE VAIS M'EN OCCUPER."
|
||||
#define HUSTR_CHATMACRO9 "OUI"
|
||||
#define HUSTR_CHATMACRO0 "NON"
|
||||
|
||||
#define HUSTR_TALKTOSELF1 "VOUS PARLEZ TOUT SEUL "
|
||||
#define HUSTR_TALKTOSELF2 "QUI EST LA?"
|
||||
#define HUSTR_TALKTOSELF3 "VOUS VOUS FAITES PEUR "
|
||||
#define HUSTR_TALKTOSELF4 "VOUS COMMENCEZ A DELIRER "
|
||||
#define HUSTR_TALKTOSELF5 "VOUS ETES LARGUE..."
|
||||
|
||||
#define HUSTR_MESSAGESENT "[MESSAGE ENVOYE]"
|
||||
|
||||
// The following should NOT be changed unless it seems
|
||||
// just AWFULLY necessary
|
||||
|
||||
#define HUSTR_PLRGREEN "VERT: "
|
||||
#define HUSTR_PLRINDIGO "INDIGO: "
|
||||
#define HUSTR_PLRBROWN "BRUN: "
|
||||
#define HUSTR_PLRRED "ROUGE: "
|
||||
|
||||
#define HUSTR_KEYGREEN 'g' // french key should be "V"
|
||||
#define HUSTR_KEYINDIGO 'i'
|
||||
#define HUSTR_KEYBROWN 'b'
|
||||
#define HUSTR_KEYRED 'r'
|
||||
|
||||
//
|
||||
// AM_map.C
|
||||
//
|
||||
|
||||
#define AMSTR_FOLLOWON "MODE POURSUITE ON"
|
||||
#define AMSTR_FOLLOWOFF "MODE POURSUITE OFF"
|
||||
|
||||
#define AMSTR_GRIDON "GRILLE ON"
|
||||
#define AMSTR_GRIDOFF "GRILLE OFF"
|
||||
|
||||
#define AMSTR_MARKEDSPOT "REPERE MARQUE "
|
||||
#define AMSTR_MARKSCLEARED "REPERES EFFACES "
|
||||
|
||||
//
|
||||
// ST_stuff.C
|
||||
//
|
||||
|
||||
#define STSTR_MUS "CHANGEMENT DE MUSIQUE "
|
||||
#define STSTR_NOMUS "IMPOSSIBLE SELECTION"
|
||||
#define STSTR_DQDON "INVULNERABILITE ON "
|
||||
#define STSTR_DQDOFF "INVULNERABILITE OFF"
|
||||
|
||||
#define STSTR_KFAADDED "ARMEMENT MAXIMUM! "
|
||||
#define STSTR_FAADDED "ARMES (SAUF CLEFS) AJOUTEES"
|
||||
|
||||
#define STSTR_NCON "BARRIERES ON"
|
||||
#define STSTR_NCOFF "BARRIERES OFF"
|
||||
|
||||
#define STSTR_BEHOLD " inVuln, Str, Inviso, Rad, Allmap, or Lite-amp"
|
||||
#define STSTR_BEHOLDX "AMELIORATION ACTIVEE"
|
||||
|
||||
#define STSTR_CHOPPERS "... DOESN'T SUCK - GM"
|
||||
#define STSTR_CLEV "CHANGEMENT DE NIVEAU..."
|
||||
|
||||
//
|
||||
// F_Finale.C
|
||||
//
|
||||
#define E1TEXT "APRES AVOIR VAINCU LES GROS MECHANTS\n"\
|
||||
"ET NETTOYE LA BASE LUNAIRE, VOUS AVEZ\n"\
|
||||
"GAGNE, NON? PAS VRAI? OU EST DONC VOTRE\n"\
|
||||
" RECOMPENSE ET VOTRE BILLET DE\n"\
|
||||
"RETOUR? QU'EST-QUE CA VEUT DIRE?CE"\
|
||||
"N'EST PAS LA FIN ESPEREE!\n"\
|
||||
"\n" \
|
||||
"CA SENT LA VIANDE PUTREFIEE, MAIS\n"\
|
||||
"ON DIRAIT LA BASE DEIMOS. VOUS ETES\n"\
|
||||
"APPAREMMENT BLOQUE AUX PORTES DE L'ENFER.\n"\
|
||||
"LA SEULE ISSUE EST DE L'AUTRE COTE.\n"\
|
||||
"\n"\
|
||||
"POUR VIVRE LA SUITE DE DOOM, JOUEZ\n"\
|
||||
"A 'AUX PORTES DE L'ENFER' ET A\n"\
|
||||
"L'EPISODE SUIVANT, 'L'ENFER'!\n"
|
||||
|
||||
#define E2TEXT "VOUS AVEZ REUSSI. L'INFAME DEMON\n"\
|
||||
"QUI CONTROLAIT LA BASE LUNAIRE DE\n"\
|
||||
"DEIMOS EST MORT, ET VOUS AVEZ\n"\
|
||||
"TRIOMPHE! MAIS... OU ETES-VOUS?\n"\
|
||||
"VOUS GRIMPEZ JUSQU'AU BORD DE LA\n"\
|
||||
"LUNE ET VOUS DECOUVREZ L'ATROCE\n"\
|
||||
"VERITE.\n" \
|
||||
"\n"\
|
||||
"DEIMOS EST AU-DESSUS DE L'ENFER!\n"\
|
||||
"VOUS SAVEZ QUE PERSONNE NE S'EN\n"\
|
||||
"EST JAMAIS ECHAPPE, MAIS CES FUMIERS\n"\
|
||||
"VONT REGRETTER DE VOUS AVOIR CONNU!\n"\
|
||||
"VOUS REDESCENDEZ RAPIDEMENT VERS\n"\
|
||||
"LA SURFACE DE L'ENFER.\n"\
|
||||
"\n" \
|
||||
"VOICI MAINTENANT LE CHAPITRE FINAL DE\n"\
|
||||
"DOOM! -- L'ENFER."
|
||||
|
||||
#define E3TEXT "LE DEMON ARACHNEEN ET REPUGNANT\n"\
|
||||
"QUI A DIRIGE L'INVASION DES BASES\n"\
|
||||
"LUNAIRES ET SEME LA MORT VIENT DE SE\n"\
|
||||
"FAIRE PULVERISER UNE FOIS POUR TOUTES.\n"\
|
||||
"\n"\
|
||||
"UNE PORTE SECRETE S'OUVRE. VOUS ENTREZ.\n"\
|
||||
"VOUS AVEZ PROUVE QUE VOUS POUVIEZ\n"\
|
||||
"RESISTER AUX HORREURS DE L'ENFER.\n"\
|
||||
"IL SAIT ETRE BEAU JOUEUR, ET LORSQUE\n"\
|
||||
"VOUS SORTEZ, VOUS REVOYEZ LES VERTES\n"\
|
||||
"PRAIRIES DE LA TERRE, VOTRE PLANETE.\n"\
|
||||
"\n"\
|
||||
"VOUS VOUS DEMANDEZ CE QUI S'EST PASSE\n"\
|
||||
"SUR TERRE PENDANT QUE VOUS AVEZ\n"\
|
||||
"COMBATTU LE DEMON. HEUREUSEMENT,\n"\
|
||||
"AUCUN GERME DU MAL N'A FRANCHI\n"\
|
||||
"CETTE PORTE AVEC VOUS..."
|
||||
|
||||
|
||||
|
||||
// after level 6, put this:
|
||||
|
||||
#define C1TEXT "VOUS ETES AU PLUS PROFOND DE L'ASTROPORT\n" \
|
||||
"INFESTE DE MONSTRES, MAIS QUELQUE CHOSE\n" \
|
||||
"NE VA PAS. ILS ONT APPORTE LEUR PROPRE\n" \
|
||||
"REALITE, ET LA TECHNOLOGIE DE L'ASTROPORT\n" \
|
||||
"EST AFFECTEE PAR LEUR PRESENCE.\n" \
|
||||
"\n"\
|
||||
"DEVANT VOUS, VOUS VOYEZ UN POSTE AVANCE\n" \
|
||||
"DE L'ENFER, UNE ZONE FORTIFIEE. SI VOUS\n" \
|
||||
"POUVEZ PASSER, VOUS POURREZ PENETRER AU\n" \
|
||||
"COEUR DE LA BASE HANTEE ET TROUVER \n" \
|
||||
"L'INTERRUPTEUR DE CONTROLE QUI GARDE LA \n" \
|
||||
"POPULATION DE LA TERRE EN OTAGE."
|
||||
|
||||
// After level 11, put this:
|
||||
|
||||
#define C2TEXT "VOUS AVEZ GAGNE! VOTRE VICTOIRE A PERMIS\n" \
|
||||
"A L'HUMANITE D'EVACUER LA TERRE ET \n"\
|
||||
"D'ECHAPPER AU CAUCHEMAR. VOUS ETES \n"\
|
||||
"MAINTENANT LE DERNIER HUMAIN A LA SURFACE \n"\
|
||||
"DE LA PLANETE. VOUS ETES ENTOURE DE \n"\
|
||||
"MUTANTS CANNIBALES, D'EXTRATERRESTRES \n"\
|
||||
"CARNIVORES ET D'ESPRITS DU MAL. VOUS \n"\
|
||||
"ATTENDEZ CALMEMENT LA MORT, HEUREUX \n"\
|
||||
"D'AVOIR PU SAUVER VOTRE RACE.\n"\
|
||||
"MAIS UN MESSAGE VOUS PARVIENT SOUDAIN\n"\
|
||||
"DE L'ESPACE: \"NOS CAPTEURS ONT LOCALISE\n"\
|
||||
"LA SOURCE DE L'INVASION EXTRATERRESTRE.\n"\
|
||||
"SI VOUS Y ALLEZ, VOUS POURREZ PEUT-ETRE\n"\
|
||||
"LES ARRETER. LEUR BASE EST SITUEE AU COEUR\n"\
|
||||
"DE VOTRE VILLE NATALE, PRES DE L'ASTROPORT.\n"\
|
||||
"VOUS VOUS RELEVEZ LENTEMENT ET PENIBLEMENT\n"\
|
||||
"ET VOUS REPARTEZ POUR LE FRONT."
|
||||
|
||||
// After level 20, put this:
|
||||
|
||||
#define C3TEXT "VOUS ETES AU COEUR DE LA CITE CORROMPUE,\n"\
|
||||
"ENTOURE PAR LES CADAVRES DE VOS ENNEMIS.\n"\
|
||||
"VOUS NE VOYEZ PAS COMMENT DETRUIRE LA PORTE\n"\
|
||||
"DES CREATURES DE CE COTE. VOUS SERREZ\n"\
|
||||
"LES DENTS ET PLONGEZ DANS L'OUVERTURE.\n"\
|
||||
"\n"\
|
||||
"IL DOIT Y AVOIR UN MOYEN DE LA FERMER\n"\
|
||||
"DE L'AUTRE COTE. VOUS ACCEPTEZ DE\n"\
|
||||
"TRAVERSER L'ENFER POUR LE FAIRE?"
|
||||
|
||||
// After level 29, put this:
|
||||
|
||||
#define C4TEXT "LE VISAGE HORRIBLE D'UN DEMON D'UNE\n"\
|
||||
"TAILLE INCROYABLE S'EFFONDRE DEVANT\n"\
|
||||
"VOUS LORSQUE VOUS TIREZ UNE SALVE DE\n"\
|
||||
"ROQUETTES DANS SON CERVEAU. LE MONSTRE\n"\
|
||||
"SE RATATINE, SES MEMBRES DECHIQUETES\n"\
|
||||
"SE REPANDANT SUR DES CENTAINES DE\n"\
|
||||
"KILOMETRES A LA SURFACE DE L'ENFER.\n"\
|
||||
"\n"\
|
||||
"VOUS AVEZ REUSSI. L'INVASION N'AURA.\n"\
|
||||
"PAS LIEU. LA TERRE EST SAUVEE. L'ENFER\n"\
|
||||
"EST ANEANTI. EN VOUS DEMANDANT OU IRONT\n"\
|
||||
"MAINTENANT LES DAMNES, VOUS ESSUYEZ\n"\
|
||||
"VOTRE FRONT COUVERT DE SUEUR ET REPARTEZ\n"\
|
||||
"VERS LA TERRE. SA RECONSTRUCTION SERA\n"\
|
||||
"BEAUCOUP PLUS DROLE QUE SA DESTRUCTION.\n"
|
||||
|
||||
// Before level 31, put this:
|
||||
|
||||
#define C5TEXT "FELICITATIONS! VOUS AVEZ TROUVE LE\n"\
|
||||
"NIVEAU SECRET! IL SEMBLE AVOIR ETE\n"\
|
||||
"CONSTRUIT PAR LES HUMAINS. VOUS VOUS\n"\
|
||||
"DEMANDEZ QUELS PEUVENT ETRE LES\n"\
|
||||
"HABITANTS DE CE COIN PERDU DE L'ENFER."
|
||||
|
||||
// Before level 32, put this:
|
||||
|
||||
#define C6TEXT "FELICITATIONS! VOUS AVEZ DECOUVERT\n"\
|
||||
"LE NIVEAU SUPER SECRET! VOUS FERIEZ\n"\
|
||||
"MIEUX DE FONCER DANS CELUI-LA!\n"
|
||||
|
||||
//
|
||||
// Character cast strings F_FINALE.C
|
||||
//
|
||||
#define CC_ZOMBIE "ZOMBIE"
|
||||
#define CC_SHOTGUN "TYPE AU FUSIL"
|
||||
#define CC_HEAVY "MEC SUPER-ARME"
|
||||
#define CC_IMP "DIABLOTIN"
|
||||
#define CC_DEMON "DEMON"
|
||||
#define CC_LOST "AME PERDUE"
|
||||
#define CC_CACO "CACODEMON"
|
||||
#define CC_HELL "CHEVALIER DE L'ENFER"
|
||||
#define CC_BARON "BARON DE L'ENFER"
|
||||
#define CC_ARACH "ARACHNOTRON"
|
||||
#define CC_PAIN "ELEMENTAIRE DE LA DOULEUR"
|
||||
#define CC_REVEN "REVENANT"
|
||||
#define CC_MANCU "MANCUBUS"
|
||||
#define CC_ARCH "ARCHI-INFAME"
|
||||
#define CC_SPIDER "L'ARAIGNEE CERVEAU"
|
||||
#define CC_CYBER "LE CYBERDEMON"
|
||||
#define CC_HERO "NOTRE HEROS"
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
@@ -0,0 +1,138 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id:$";
|
||||
|
||||
// We are referring to sprite numbers.
|
||||
#include "info.h"
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "d_items.h"
|
||||
#endif
|
||||
#include "d_items.h"
|
||||
|
||||
|
||||
//
|
||||
// PSPRITE ACTIONS for waepons.
|
||||
// This struct controls the weapon animations.
|
||||
//
|
||||
// Each entry is:
|
||||
// ammo/amunition type
|
||||
// upstate
|
||||
// downstate
|
||||
// readystate
|
||||
// atkstate, i.e. attack/fire/hit frame
|
||||
// flashstate, muzzle flash
|
||||
//
|
||||
weaponinfo_t weaponinfo[NUMWEAPONS] =
|
||||
{
|
||||
{
|
||||
// fist
|
||||
am_noammo,
|
||||
S_PUNCHUP,
|
||||
S_PUNCHDOWN,
|
||||
S_PUNCH,
|
||||
S_PUNCH1,
|
||||
S_NULL
|
||||
},
|
||||
{
|
||||
// pistol
|
||||
am_clip,
|
||||
S_PISTOLUP,
|
||||
S_PISTOLDOWN,
|
||||
S_PISTOL,
|
||||
S_PISTOL1,
|
||||
S_PISTOLFLASH
|
||||
},
|
||||
{
|
||||
// shotgun
|
||||
am_shell,
|
||||
S_SGUNUP,
|
||||
S_SGUNDOWN,
|
||||
S_SGUN,
|
||||
S_SGUN1,
|
||||
S_SGUNFLASH1
|
||||
},
|
||||
{
|
||||
// chaingun
|
||||
am_clip,
|
||||
S_CHAINUP,
|
||||
S_CHAINDOWN,
|
||||
S_CHAIN,
|
||||
S_CHAIN1,
|
||||
S_CHAINFLASH1
|
||||
},
|
||||
{
|
||||
// missile launcher
|
||||
am_misl,
|
||||
S_MISSILEUP,
|
||||
S_MISSILEDOWN,
|
||||
S_MISSILE,
|
||||
S_MISSILE1,
|
||||
S_MISSILEFLASH1
|
||||
},
|
||||
{
|
||||
// plasma rifle
|
||||
am_cell,
|
||||
S_PLASMAUP,
|
||||
S_PLASMADOWN,
|
||||
S_PLASMA,
|
||||
S_PLASMA1,
|
||||
S_PLASMAFLASH1
|
||||
},
|
||||
{
|
||||
// bfg 9000
|
||||
am_cell,
|
||||
S_BFGUP,
|
||||
S_BFGDOWN,
|
||||
S_BFG,
|
||||
S_BFG1,
|
||||
S_BFGFLASH1
|
||||
},
|
||||
{
|
||||
// chainsaw
|
||||
am_noammo,
|
||||
S_SAWUP,
|
||||
S_SAWDOWN,
|
||||
S_SAW,
|
||||
S_SAW1,
|
||||
S_NULL
|
||||
},
|
||||
{
|
||||
// super shotgun
|
||||
am_shell,
|
||||
S_DSGUNUP,
|
||||
S_DSGUNDOWN,
|
||||
S_DSGUN,
|
||||
S_DSGUN1,
|
||||
S_DSGUNFLASH1
|
||||
},
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Items: key cards, artifacts, weapon, ammunition.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __D_ITEMS__
|
||||
#define __D_ITEMS__
|
||||
|
||||
#include "doomdef.h"
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
// Weapon info: sprite frames, ammunition use.
|
||||
typedef struct
|
||||
{
|
||||
ammotype_t ammo;
|
||||
int upstate;
|
||||
int downstate;
|
||||
int readystate;
|
||||
int atkstate;
|
||||
int flashstate;
|
||||
|
||||
} weaponinfo_t;
|
||||
|
||||
extern weaponinfo_t weaponinfo[NUMWEAPONS];
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
+1176
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,64 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// System specific interface stuff.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __D_MAIN__
|
||||
#define __D_MAIN__
|
||||
|
||||
#include "d_event.h"
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#define MAXWADFILES 20
|
||||
extern char* wadfiles[MAXWADFILES];
|
||||
|
||||
void D_AddFile (char *file);
|
||||
|
||||
|
||||
|
||||
//
|
||||
// D_DoomMain()
|
||||
// Not a globally visible function, just included for source reference,
|
||||
// calls all startup code, parses command line options.
|
||||
// If not overrided by user input, calls N_AdvanceDemo.
|
||||
//
|
||||
void D_DoomMain (void);
|
||||
|
||||
// Called by IO functions when input is detected.
|
||||
void D_PostEvent (event_t* ev);
|
||||
|
||||
|
||||
|
||||
//
|
||||
// BASE LEVEL
|
||||
//
|
||||
void D_PageTicker (void);
|
||||
void D_PageDrawer (void);
|
||||
void D_AdvanceDemo (void);
|
||||
void D_StartTitle (void);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,755 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// DOOM Network game communication and protocol,
|
||||
// all OS independend parts.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
static const char rcsid[] = "$Id: d_net.c,v 1.3 1997/02/03 22:01:47 b1 Exp $";
|
||||
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#include "m_menu.h"
|
||||
#include "i_system.h"
|
||||
#include "i_video.h"
|
||||
#include "i_net.h"
|
||||
#include "g_game.h"
|
||||
#include "doomdef.h"
|
||||
#include "doomstat.h"
|
||||
|
||||
#define NCMD_EXIT 0x80000000
|
||||
#define NCMD_RETRANSMIT 0x40000000
|
||||
#define NCMD_SETUP 0x20000000
|
||||
#define NCMD_KILL 0x10000000 // kill game
|
||||
#define NCMD_CHECKSUM 0x0fffffff
|
||||
|
||||
|
||||
doomcom_t* doomcom;
|
||||
doomdata_t* netbuffer; // points inside doomcom
|
||||
|
||||
|
||||
//
|
||||
// NETWORKING
|
||||
//
|
||||
// gametic is the tic about to (or currently being) run
|
||||
// maketic is the tick that hasn't had control made for it yet
|
||||
// nettics[] has the maketics for all players
|
||||
//
|
||||
// a gametic cannot be run until nettics[] > gametic for all players
|
||||
//
|
||||
#define RESENDCOUNT 10
|
||||
#define PL_DRONE 0x80 // bit flag in doomdata->player
|
||||
|
||||
ticcmd_t localcmds[BACKUPTICS];
|
||||
|
||||
ticcmd_t netcmds[MAXPLAYERS][BACKUPTICS];
|
||||
int nettics[MAXNETNODES];
|
||||
boolean nodeingame[MAXNETNODES]; // set false as nodes leave game
|
||||
boolean remoteresend[MAXNETNODES]; // set when local needs tics
|
||||
int resendto[MAXNETNODES]; // set when remote needs tics
|
||||
int resendcount[MAXNETNODES];
|
||||
|
||||
int nodeforplayer[MAXPLAYERS];
|
||||
|
||||
int maketic;
|
||||
int lastnettic;
|
||||
int skiptics;
|
||||
int ticdup;
|
||||
int maxsend; // BACKUPTICS/(2*ticdup)-1
|
||||
|
||||
|
||||
void D_ProcessEvents (void);
|
||||
void G_BuildTiccmd (ticcmd_t *cmd);
|
||||
void D_DoAdvanceDemo (void);
|
||||
|
||||
boolean reboundpacket;
|
||||
doomdata_t reboundstore;
|
||||
|
||||
|
||||
|
||||
//
|
||||
//
|
||||
//
|
||||
int NetbufferSize (void)
|
||||
{
|
||||
return offsetof(doomdata_t, cmds) + netbuffer->numtics*sizeof(ticcmd_t);
|
||||
}
|
||||
|
||||
//
|
||||
// Checksum
|
||||
//
|
||||
unsigned NetbufferChecksum (void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
//
|
||||
//
|
||||
//
|
||||
int ExpandTics (int low)
|
||||
{
|
||||
int delta;
|
||||
|
||||
delta = low - (maketic&0xff);
|
||||
|
||||
if (delta >= -64 && delta <= 64)
|
||||
return (maketic&~0xff) + low;
|
||||
if (delta > 64)
|
||||
return (maketic&~0xff) - 256 + low;
|
||||
if (delta < -64)
|
||||
return (maketic&~0xff) + 256 + low;
|
||||
|
||||
I_Error ("ExpandTics: strange value %i at maketic %i",low,maketic);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// HSendPacket
|
||||
//
|
||||
void
|
||||
HSendPacket
|
||||
(int node,
|
||||
int flags )
|
||||
{
|
||||
netbuffer->checksum = NetbufferChecksum () | flags;
|
||||
|
||||
if (!node)
|
||||
{
|
||||
reboundstore = *netbuffer;
|
||||
reboundpacket = true;
|
||||
return;
|
||||
}
|
||||
|
||||
if (demoplayback)
|
||||
return;
|
||||
|
||||
if (!netgame)
|
||||
I_Error ("Tried to transmit to another node");
|
||||
|
||||
doomcom->command = CMD_SEND;
|
||||
doomcom->remotenode = node;
|
||||
doomcom->datalength = NetbufferSize ();
|
||||
|
||||
if (debugfile)
|
||||
{
|
||||
int i;
|
||||
int realretrans;
|
||||
if (netbuffer->checksum & NCMD_RETRANSMIT)
|
||||
realretrans = ExpandTics (netbuffer->retransmitfrom);
|
||||
else
|
||||
realretrans = -1;
|
||||
|
||||
fprintf (debugfile,"send (%i + %i, R %i) [%i] ",
|
||||
ExpandTics(netbuffer->starttic),
|
||||
netbuffer->numtics, realretrans, doomcom->datalength);
|
||||
|
||||
for (i=0 ; i<doomcom->datalength ; i++)
|
||||
fprintf (debugfile,"%i ",((byte *)netbuffer)[i]);
|
||||
|
||||
fprintf (debugfile,"\n");
|
||||
}
|
||||
|
||||
I_NetCmd ();
|
||||
}
|
||||
|
||||
//
|
||||
// HGetPacket
|
||||
// Returns false if no packet is waiting
|
||||
//
|
||||
boolean HGetPacket (void)
|
||||
{
|
||||
if (reboundpacket)
|
||||
{
|
||||
*netbuffer = reboundstore;
|
||||
doomcom->remotenode = 0;
|
||||
reboundpacket = false;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!netgame)
|
||||
return false;
|
||||
|
||||
if (demoplayback)
|
||||
return false;
|
||||
|
||||
doomcom->command = CMD_GET;
|
||||
I_NetCmd ();
|
||||
|
||||
if (doomcom->remotenode == -1)
|
||||
return false;
|
||||
|
||||
if (doomcom->datalength != NetbufferSize ())
|
||||
{
|
||||
if (debugfile)
|
||||
fprintf (debugfile,"bad packet length %i\n",doomcom->datalength);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (NetbufferChecksum () != (netbuffer->checksum&NCMD_CHECKSUM) )
|
||||
{
|
||||
if (debugfile)
|
||||
fprintf (debugfile,"bad packet checksum\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (debugfile)
|
||||
{
|
||||
int realretrans;
|
||||
int i;
|
||||
|
||||
if (netbuffer->checksum & NCMD_SETUP)
|
||||
fprintf (debugfile,"setup packet\n");
|
||||
else
|
||||
{
|
||||
if (netbuffer->checksum & NCMD_RETRANSMIT)
|
||||
realretrans = ExpandTics (netbuffer->retransmitfrom);
|
||||
else
|
||||
realretrans = -1;
|
||||
|
||||
fprintf (debugfile,"get %i = (%i + %i, R %i)[%i] ",
|
||||
doomcom->remotenode,
|
||||
ExpandTics(netbuffer->starttic),
|
||||
netbuffer->numtics, realretrans, doomcom->datalength);
|
||||
|
||||
for (i=0 ; i<doomcom->datalength ; i++)
|
||||
fprintf (debugfile,"%i ",((byte *)netbuffer)[i]);
|
||||
fprintf (debugfile,"\n");
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// GetPackets
|
||||
//
|
||||
char exitmsg[80];
|
||||
|
||||
void GetPackets (void)
|
||||
{
|
||||
int netconsole;
|
||||
int netnode;
|
||||
ticcmd_t *src, *dest;
|
||||
int realend;
|
||||
int realstart;
|
||||
|
||||
while ( HGetPacket() )
|
||||
{
|
||||
if (netbuffer->checksum & NCMD_SETUP)
|
||||
continue; // extra setup packet
|
||||
|
||||
netconsole = netbuffer->player & ~PL_DRONE;
|
||||
netnode = doomcom->remotenode;
|
||||
|
||||
// to save bytes, only the low byte of tic numbers are sent
|
||||
// Figure out what the rest of the bytes are
|
||||
realstart = ExpandTics (netbuffer->starttic);
|
||||
realend = (realstart+netbuffer->numtics);
|
||||
|
||||
// check for exiting the game
|
||||
if (netbuffer->checksum & NCMD_EXIT)
|
||||
{
|
||||
if (!nodeingame[netnode])
|
||||
continue;
|
||||
nodeingame[netnode] = false;
|
||||
playeringame[netconsole] = false;
|
||||
strcpy (exitmsg, "Player 1 left the game");
|
||||
exitmsg[7] += netconsole;
|
||||
players[consoleplayer].message = exitmsg;
|
||||
if (demorecording)
|
||||
G_CheckDemoStatus ();
|
||||
continue;
|
||||
}
|
||||
|
||||
// check for a remote game kill
|
||||
if (netbuffer->checksum & NCMD_KILL)
|
||||
I_Error ("Killed by network driver");
|
||||
|
||||
nodeforplayer[netconsole] = netnode;
|
||||
|
||||
// check for retransmit request
|
||||
if ( resendcount[netnode] <= 0
|
||||
&& (netbuffer->checksum & NCMD_RETRANSMIT) )
|
||||
{
|
||||
resendto[netnode] = ExpandTics(netbuffer->retransmitfrom);
|
||||
if (debugfile)
|
||||
fprintf (debugfile,"retransmit from %i\n", resendto[netnode]);
|
||||
resendcount[netnode] = RESENDCOUNT;
|
||||
}
|
||||
else
|
||||
resendcount[netnode]--;
|
||||
|
||||
// check for out of order / duplicated packet
|
||||
if (realend == nettics[netnode])
|
||||
continue;
|
||||
|
||||
if (realend < nettics[netnode])
|
||||
{
|
||||
if (debugfile)
|
||||
fprintf (debugfile,
|
||||
"out of order packet (%i + %i)\n" ,
|
||||
realstart,netbuffer->numtics);
|
||||
continue;
|
||||
}
|
||||
|
||||
// check for a missed packet
|
||||
if (realstart > nettics[netnode])
|
||||
{
|
||||
// stop processing until the other system resends the missed tics
|
||||
if (debugfile)
|
||||
fprintf (debugfile,
|
||||
"missed tics from %i (%i - %i)\n",
|
||||
netnode, realstart, nettics[netnode]);
|
||||
remoteresend[netnode] = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
// update command store from the packet
|
||||
{
|
||||
int start;
|
||||
|
||||
remoteresend[netnode] = false;
|
||||
|
||||
start = nettics[netnode] - realstart;
|
||||
src = &netbuffer->cmds[start];
|
||||
|
||||
while (nettics[netnode] < realend)
|
||||
{
|
||||
dest = &netcmds[netconsole][nettics[netnode]%BACKUPTICS];
|
||||
nettics[netnode]++;
|
||||
*dest = *src;
|
||||
src++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// NetUpdate
|
||||
// Builds ticcmds for console player,
|
||||
// sends out a packet
|
||||
//
|
||||
int gametime;
|
||||
|
||||
void NetUpdate (void)
|
||||
{
|
||||
int nowtime;
|
||||
int newtics;
|
||||
int i,j;
|
||||
int realstart;
|
||||
int gameticdiv;
|
||||
|
||||
// check time
|
||||
nowtime = I_GetTime ()/ticdup;
|
||||
newtics = nowtime - gametime;
|
||||
gametime = nowtime;
|
||||
|
||||
if (newtics <= 0) // nothing new to update
|
||||
goto listen;
|
||||
|
||||
if (skiptics <= newtics)
|
||||
{
|
||||
newtics -= skiptics;
|
||||
skiptics = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
skiptics -= newtics;
|
||||
newtics = 0;
|
||||
}
|
||||
|
||||
|
||||
netbuffer->player = consoleplayer;
|
||||
|
||||
// build new ticcmds for console player
|
||||
gameticdiv = gametic/ticdup;
|
||||
for (i=0 ; i<newtics ; i++)
|
||||
{
|
||||
I_StartTic ();
|
||||
D_ProcessEvents ();
|
||||
if (maketic - gameticdiv >= BACKUPTICS/2-1)
|
||||
break; // can't hold any more
|
||||
|
||||
//printf ("mk:%i ",maketic);
|
||||
G_BuildTiccmd (&localcmds[maketic%BACKUPTICS]);
|
||||
maketic++;
|
||||
}
|
||||
|
||||
|
||||
if (singletics)
|
||||
return; // singletic update is syncronous
|
||||
|
||||
// send the packet to the other nodes
|
||||
for (i=0 ; i<doomcom->numnodes ; i++)
|
||||
if (nodeingame[i])
|
||||
{
|
||||
netbuffer->starttic = realstart = resendto[i];
|
||||
netbuffer->numtics = maketic - realstart;
|
||||
if (netbuffer->numtics > BACKUPTICS)
|
||||
I_Error ("NetUpdate: netbuffer->numtics > BACKUPTICS");
|
||||
|
||||
resendto[i] = maketic - doomcom->extratics;
|
||||
|
||||
for (j=0 ; j< netbuffer->numtics ; j++)
|
||||
netbuffer->cmds[j] =
|
||||
localcmds[(realstart+j)%BACKUPTICS];
|
||||
|
||||
if (remoteresend[i])
|
||||
{
|
||||
netbuffer->retransmitfrom = nettics[i];
|
||||
HSendPacket (i, NCMD_RETRANSMIT);
|
||||
}
|
||||
else
|
||||
{
|
||||
netbuffer->retransmitfrom = 0;
|
||||
HSendPacket (i, 0);
|
||||
}
|
||||
}
|
||||
|
||||
// listen for other packets
|
||||
listen:
|
||||
GetPackets ();
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// CheckAbort
|
||||
//
|
||||
void CheckAbort (void)
|
||||
{
|
||||
event_t *ev;
|
||||
int stoptic;
|
||||
|
||||
stoptic = I_GetTime () + 2;
|
||||
while (I_GetTime() < stoptic)
|
||||
I_StartTic ();
|
||||
|
||||
I_StartTic ();
|
||||
for ( ; eventtail != eventhead
|
||||
; eventtail = (eventtail+1)&(MAXEVENTS-1) )
|
||||
{
|
||||
ev = &events[eventtail];
|
||||
if (ev->type == ev_keydown && ev->data1 == KEY_ESCAPE)
|
||||
I_Error ("Network game synchronization aborted.");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// D_ArbitrateNetStart
|
||||
//
|
||||
void D_ArbitrateNetStart (void)
|
||||
{
|
||||
int i;
|
||||
boolean gotinfo[MAXNETNODES];
|
||||
|
||||
autostart = true;
|
||||
memset (gotinfo,0,sizeof(gotinfo));
|
||||
|
||||
if (doomcom->consoleplayer)
|
||||
{
|
||||
// listen for setup info from key player
|
||||
printf ("listening for network start info...\n");
|
||||
while (1)
|
||||
{
|
||||
CheckAbort ();
|
||||
if (!HGetPacket ())
|
||||
continue;
|
||||
if (netbuffer->checksum & NCMD_SETUP)
|
||||
{
|
||||
if (netbuffer->player != VERSION)
|
||||
I_Error ("Different DOOM versions cannot play a net game!");
|
||||
startskill = netbuffer->retransmitfrom & 15;
|
||||
deathmatch = (netbuffer->retransmitfrom & 0xc0) >> 6;
|
||||
nomonsters = (netbuffer->retransmitfrom & 0x20) > 0;
|
||||
respawnparm = (netbuffer->retransmitfrom & 0x10) > 0;
|
||||
startmap = netbuffer->starttic & 0x3f;
|
||||
startepisode = netbuffer->starttic >> 6;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// key player, send the setup info
|
||||
printf ("sending network start info...\n");
|
||||
do
|
||||
{
|
||||
CheckAbort ();
|
||||
for (i=0 ; i<doomcom->numnodes ; i++)
|
||||
{
|
||||
netbuffer->retransmitfrom = startskill;
|
||||
if (deathmatch)
|
||||
netbuffer->retransmitfrom |= (deathmatch<<6);
|
||||
if (nomonsters)
|
||||
netbuffer->retransmitfrom |= 0x20;
|
||||
if (respawnparm)
|
||||
netbuffer->retransmitfrom |= 0x10;
|
||||
netbuffer->starttic = startepisode * 64 + startmap;
|
||||
netbuffer->player = VERSION;
|
||||
netbuffer->numtics = 0;
|
||||
HSendPacket (i, NCMD_SETUP);
|
||||
}
|
||||
|
||||
#if 1
|
||||
for(i = 10 ; i && HGetPacket(); --i)
|
||||
{
|
||||
if((netbuffer->player&0x7f) < MAXNETNODES)
|
||||
gotinfo[netbuffer->player&0x7f] = true;
|
||||
}
|
||||
#else
|
||||
while (HGetPacket ())
|
||||
{
|
||||
gotinfo[netbuffer->player&0x7f] = true;
|
||||
}
|
||||
#endif
|
||||
|
||||
for (i=1 ; i<doomcom->numnodes ; i++)
|
||||
if (!gotinfo[i])
|
||||
break;
|
||||
} while (i < doomcom->numnodes);
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// D_CheckNetGame
|
||||
// Works out player numbers among the net participants
|
||||
//
|
||||
extern int viewangleoffset;
|
||||
|
||||
void D_CheckNetGame (void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=0 ; i<MAXNETNODES ; i++)
|
||||
{
|
||||
nodeingame[i] = false;
|
||||
nettics[i] = 0;
|
||||
remoteresend[i] = false; // set when local needs tics
|
||||
resendto[i] = 0; // which tic to start sending
|
||||
}
|
||||
|
||||
// I_InitNetwork sets doomcom and netgame
|
||||
I_InitNetwork ();
|
||||
if (doomcom->id != DOOMCOM_ID)
|
||||
I_Error ("Doomcom buffer invalid!");
|
||||
|
||||
netbuffer = &doomcom->data;
|
||||
consoleplayer = displayplayer = doomcom->consoleplayer;
|
||||
if (netgame)
|
||||
D_ArbitrateNetStart ();
|
||||
|
||||
printf ("startskill %i deathmatch: %i startmap: %i startepisode: %i\n",
|
||||
startskill, deathmatch, startmap, startepisode);
|
||||
|
||||
// read values out of doomcom
|
||||
ticdup = doomcom->ticdup;
|
||||
maxsend = BACKUPTICS/(2*ticdup)-1;
|
||||
if (maxsend<1)
|
||||
maxsend = 1;
|
||||
|
||||
for (i=0 ; i<doomcom->numplayers ; i++)
|
||||
playeringame[i] = true;
|
||||
for (i=0 ; i<doomcom->numnodes ; i++)
|
||||
nodeingame[i] = true;
|
||||
|
||||
printf ("player %i of %i (%i nodes)\n",
|
||||
consoleplayer+1, doomcom->numplayers, doomcom->numnodes);
|
||||
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// D_QuitNetGame
|
||||
// Called before quitting to leave a net game
|
||||
// without hanging the other players
|
||||
//
|
||||
void D_QuitNetGame (void)
|
||||
{
|
||||
int i, j;
|
||||
|
||||
if (debugfile)
|
||||
fclose (debugfile);
|
||||
|
||||
if (!netgame || !usergame || consoleplayer == -1 || demoplayback)
|
||||
return;
|
||||
|
||||
// send a bunch of packets for security
|
||||
netbuffer->player = consoleplayer;
|
||||
netbuffer->numtics = 0;
|
||||
for (i=0 ; i<4 ; i++)
|
||||
{
|
||||
for (j=1 ; j<doomcom->numnodes ; j++)
|
||||
if (nodeingame[j])
|
||||
HSendPacket (j, NCMD_EXIT);
|
||||
I_WaitVBL (1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// TryRunTics
|
||||
//
|
||||
int frametics[4];
|
||||
int frameon;
|
||||
int frameskip[4];
|
||||
int oldnettics;
|
||||
|
||||
extern boolean advancedemo;
|
||||
|
||||
void TryRunTics (void)
|
||||
{
|
||||
int i;
|
||||
int lowtic;
|
||||
int entertic;
|
||||
static int oldentertics;
|
||||
int realtics;
|
||||
int availabletics;
|
||||
int counts;
|
||||
int numplaying;
|
||||
|
||||
// get real tics
|
||||
entertic = I_GetTime ()/ticdup;
|
||||
realtics = entertic - oldentertics;
|
||||
oldentertics = entertic;
|
||||
|
||||
// get available tics
|
||||
NetUpdate ();
|
||||
|
||||
lowtic = MAXINT;
|
||||
numplaying = 0;
|
||||
for (i=0 ; i<doomcom->numnodes ; i++)
|
||||
{
|
||||
if (nodeingame[i])
|
||||
{
|
||||
numplaying++;
|
||||
if (nettics[i] < lowtic)
|
||||
lowtic = nettics[i];
|
||||
}
|
||||
}
|
||||
availabletics = lowtic - gametic/ticdup;
|
||||
|
||||
// decide how many tics to run
|
||||
if (realtics < availabletics-1)
|
||||
counts = realtics+1;
|
||||
else if (realtics < availabletics)
|
||||
counts = realtics;
|
||||
else
|
||||
counts = availabletics;
|
||||
|
||||
if (counts < 1)
|
||||
counts = 1;
|
||||
|
||||
frameon++;
|
||||
|
||||
if (debugfile)
|
||||
fprintf (debugfile,
|
||||
"=======real: %i avail: %i game: %i\n",
|
||||
realtics, availabletics,counts);
|
||||
|
||||
if (!demoplayback)
|
||||
{
|
||||
// ideally nettics[0] should be 1 - 3 tics above lowtic
|
||||
// if we are consistantly slower, speed up time
|
||||
for (i=0 ; i<MAXPLAYERS ; i++)
|
||||
if (playeringame[i])
|
||||
break;
|
||||
if (consoleplayer == i)
|
||||
{
|
||||
// the key player does not adapt
|
||||
}
|
||||
else
|
||||
{
|
||||
if (nettics[0] <= nettics[nodeforplayer[i]])
|
||||
{
|
||||
gametime--;
|
||||
// printf ("-");
|
||||
}
|
||||
frameskip[frameon&3] = (oldnettics > nettics[nodeforplayer[i]]);
|
||||
oldnettics = nettics[0];
|
||||
if (frameskip[0] && frameskip[1] && frameskip[2] && frameskip[3])
|
||||
{
|
||||
skiptics = 1;
|
||||
// printf ("+");
|
||||
}
|
||||
}
|
||||
}// demoplayback
|
||||
|
||||
// wait for new tics if needed
|
||||
while (lowtic < gametic/ticdup + counts)
|
||||
{
|
||||
NetUpdate ();
|
||||
lowtic = MAXINT;
|
||||
|
||||
for (i=0 ; i<doomcom->numnodes ; i++)
|
||||
if (nodeingame[i] && nettics[i] < lowtic)
|
||||
lowtic = nettics[i];
|
||||
|
||||
if (lowtic < gametic/ticdup)
|
||||
I_Error ("TryRunTics: lowtic < gametic");
|
||||
|
||||
// don't stay in here forever -- give the menu a chance to work
|
||||
if (I_GetTime ()/ticdup - entertic >= 20)
|
||||
{
|
||||
M_Ticker ();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// run the count * ticdup dics
|
||||
while (counts--)
|
||||
{
|
||||
for (i=0 ; i<ticdup ; i++)
|
||||
{
|
||||
if (gametic/ticdup > lowtic)
|
||||
I_Error ("gametic>lowtic");
|
||||
if (advancedemo)
|
||||
D_DoAdvanceDemo ();
|
||||
M_Ticker ();
|
||||
G_Ticker ();
|
||||
gametic++;
|
||||
|
||||
// modify command for duplicated tics
|
||||
if (i != ticdup-1)
|
||||
{
|
||||
ticcmd_t *cmd;
|
||||
int buf;
|
||||
int j;
|
||||
|
||||
buf = (gametic/ticdup)%BACKUPTICS;
|
||||
for (j=0 ; j<MAXPLAYERS ; j++)
|
||||
{
|
||||
cmd = &netcmds[j][buf];
|
||||
cmd->chatchar = 0;
|
||||
if (cmd->buttons & BT_SPECIAL)
|
||||
cmd->buttons = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
NetUpdate (); // check for new console commands
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,149 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Networking stuff.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __D_NET__
|
||||
#define __D_NET__
|
||||
|
||||
#include "d_player.h"
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
//
|
||||
// Network play related stuff.
|
||||
// There is a data struct that stores network
|
||||
// communication related stuff, and another
|
||||
// one that defines the actual packets to
|
||||
// be transmitted.
|
||||
//
|
||||
|
||||
#define DOOMCOM_ID 0x12345678l
|
||||
|
||||
// Max computers/players in a game.
|
||||
#define MAXNETNODES 8
|
||||
|
||||
|
||||
// Networking and tick handling related.
|
||||
#define BACKUPTICS 12
|
||||
|
||||
typedef enum
|
||||
{
|
||||
CMD_SEND = 1,
|
||||
CMD_GET = 2
|
||||
|
||||
} command_t;
|
||||
|
||||
|
||||
//
|
||||
// Network packet data.
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
// High bit is retransmit request.
|
||||
unsigned checksum;
|
||||
// Only valid if NCMD_RETRANSMIT.
|
||||
byte retransmitfrom;
|
||||
|
||||
byte starttic;
|
||||
byte player;
|
||||
byte numtics;
|
||||
ticcmd_t cmds[BACKUPTICS];
|
||||
|
||||
} doomdata_t;
|
||||
|
||||
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
// Supposed to be DOOMCOM_ID?
|
||||
long id;
|
||||
|
||||
// DOOM executes an int to execute commands.
|
||||
short intnum;
|
||||
// Communication between DOOM and the driver.
|
||||
// Is CMD_SEND or CMD_GET.
|
||||
short command;
|
||||
// Is dest for send, set by get (-1 = no packet).
|
||||
short remotenode;
|
||||
|
||||
// Number of bytes in doomdata to be sent
|
||||
short datalength;
|
||||
|
||||
// Info common to all nodes.
|
||||
// Console is allways node 0.
|
||||
short numnodes;
|
||||
// Flag: 1 = no duplication, 2-5 = dup for slow nets.
|
||||
short ticdup;
|
||||
// Flag: 1 = send a backup tic in every packet.
|
||||
short extratics;
|
||||
// Flag: 1 = deathmatch.
|
||||
short deathmatch;
|
||||
// Flag: -1 = new game, 0-5 = load savegame
|
||||
short savegame;
|
||||
short episode; // 1-3
|
||||
short map; // 1-9
|
||||
short skill; // 1-5
|
||||
|
||||
// Info specific to this node.
|
||||
short consoleplayer;
|
||||
short numplayers;
|
||||
|
||||
// These are related to the 3-display mode,
|
||||
// in which two drones looking left and right
|
||||
// were used to render two additional views
|
||||
// on two additional computers.
|
||||
// Probably not operational anymore.
|
||||
// 1 = left, 0 = center, -1 = right
|
||||
short angleoffset;
|
||||
// 1 = drone
|
||||
short drone;
|
||||
|
||||
// The packet data to be sent.
|
||||
doomdata_t data;
|
||||
|
||||
} doomcom_t;
|
||||
|
||||
|
||||
|
||||
// Create any new ticcmds and broadcast to other players.
|
||||
void NetUpdate (void);
|
||||
|
||||
// Broadcasts special packets to other players
|
||||
// to notify of game exit
|
||||
void D_QuitNetGame (void);
|
||||
|
||||
//? how many ticks to run?
|
||||
void TryRunTics (void);
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
@@ -0,0 +1,219 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
//
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __D_PLAYER__
|
||||
#define __D_PLAYER__
|
||||
|
||||
|
||||
// The player data structure depends on a number
|
||||
// of other structs: items (internal inventory),
|
||||
// animation states (closely tied to the sprites
|
||||
// used to represent them, unfortunately).
|
||||
#include "d_items.h"
|
||||
#include "p_pspr.h"
|
||||
|
||||
// In addition, the player is just a special
|
||||
// case of the generic moving object/actor.
|
||||
#include "p_mobj.h"
|
||||
|
||||
// Finally, for odd reasons, the player input
|
||||
// is buffered within the player data struct,
|
||||
// as commands per game tick.
|
||||
#include "d_ticcmd.h"
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Player states.
|
||||
//
|
||||
typedef enum
|
||||
{
|
||||
// Playing or camping.
|
||||
PST_LIVE,
|
||||
// Dead on the ground, view follows killer.
|
||||
PST_DEAD,
|
||||
// Ready to restart/respawn???
|
||||
PST_REBORN
|
||||
|
||||
} playerstate_t;
|
||||
|
||||
|
||||
//
|
||||
// Player internal flags, for cheats and debug.
|
||||
//
|
||||
typedef enum
|
||||
{
|
||||
// No clipping, walk through barriers.
|
||||
CF_NOCLIP = 1,
|
||||
// No damage, no health loss.
|
||||
CF_GODMODE = 2,
|
||||
// Not really a cheat, just a debug aid.
|
||||
CF_NOMOMENTUM = 4
|
||||
|
||||
} cheat_t;
|
||||
|
||||
|
||||
//
|
||||
// Extended player object info: player_t
|
||||
//
|
||||
typedef struct player_s
|
||||
{
|
||||
mobj_t* mo;
|
||||
playerstate_t playerstate;
|
||||
ticcmd_t cmd;
|
||||
|
||||
// Determine POV,
|
||||
// including viewpoint bobbing during movement.
|
||||
// Focal origin above r.z
|
||||
fixed_t viewz;
|
||||
// Base height above floor for viewz.
|
||||
fixed_t viewheight;
|
||||
// Bob/squat speed.
|
||||
fixed_t deltaviewheight;
|
||||
// bounded/scaled total momentum.
|
||||
fixed_t bob;
|
||||
|
||||
// This is only used between levels,
|
||||
// mo->health is used during levels.
|
||||
int health;
|
||||
int armorpoints;
|
||||
// Armor type is 0-2.
|
||||
int armortype;
|
||||
|
||||
// Power ups. invinc and invis are tic counters.
|
||||
int powers[NUMPOWERS];
|
||||
boolean cards[NUMCARDS];
|
||||
boolean backpack;
|
||||
|
||||
// Frags, kills of other players.
|
||||
int frags[MAXPLAYERS];
|
||||
weapontype_t readyweapon;
|
||||
|
||||
// Is wp_nochange if not changing.
|
||||
weapontype_t pendingweapon;
|
||||
|
||||
boolean weaponowned[NUMWEAPONS];
|
||||
int ammo[NUMAMMO];
|
||||
int maxammo[NUMAMMO];
|
||||
|
||||
// True if button down last tic.
|
||||
int attackdown;
|
||||
int usedown;
|
||||
|
||||
// Bit flags, for cheats and debug.
|
||||
// See cheat_t, above.
|
||||
int cheats;
|
||||
|
||||
// Refired shots are less accurate.
|
||||
int refire;
|
||||
|
||||
// For intermission stats.
|
||||
int killcount;
|
||||
int itemcount;
|
||||
int secretcount;
|
||||
|
||||
// Hint messages.
|
||||
char* message;
|
||||
|
||||
// For screen flashing (red or bright).
|
||||
int damagecount;
|
||||
int bonuscount;
|
||||
|
||||
// Who did damage (NULL for floors/ceilings).
|
||||
mobj_t* attacker;
|
||||
|
||||
// So gun flashes light up areas.
|
||||
int extralight;
|
||||
|
||||
// Current PLAYPAL, ???
|
||||
// can be set to REDCOLORMAP for pain, etc.
|
||||
int fixedcolormap;
|
||||
|
||||
// Player skin colorshift,
|
||||
// 0-3 for which color to draw player.
|
||||
int colormap;
|
||||
|
||||
// Overlay view sprites (gun, etc).
|
||||
pspdef_t psprites[NUMPSPRITES];
|
||||
|
||||
// True if secret level has been done.
|
||||
boolean didsecret;
|
||||
|
||||
} player_t;
|
||||
|
||||
|
||||
//
|
||||
// INTERMISSION
|
||||
// Structure passed e.g. to WI_Start(wb)
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
boolean in; // whether the player is in game
|
||||
|
||||
// Player stats, kills, collected items etc.
|
||||
int skills;
|
||||
int sitems;
|
||||
int ssecret;
|
||||
int stime;
|
||||
int frags[4];
|
||||
int score; // current score on entry, modified on return
|
||||
|
||||
} wbplayerstruct_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int epsd; // episode # (0-2)
|
||||
|
||||
// if true, splash the secret level
|
||||
boolean didsecret;
|
||||
|
||||
// previous and next levels, origin 0
|
||||
int last;
|
||||
int next;
|
||||
|
||||
int maxkills;
|
||||
int maxitems;
|
||||
int maxsecret;
|
||||
int maxfrags;
|
||||
|
||||
// the par time
|
||||
int partime;
|
||||
|
||||
// index of this player in game
|
||||
int pnum;
|
||||
|
||||
wbplayerstruct_t plyr[MAXPLAYERS];
|
||||
|
||||
} wbstartstruct_t;
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,51 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Typedefs related to to textures etc.,
|
||||
// isolated here to make it easier separating modules.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __D_TEXTUR__
|
||||
#define __D_TEXTUR__
|
||||
|
||||
#include "doomtype.h"
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Flats?
|
||||
//
|
||||
// a pic is an unmasked block of pixels
|
||||
typedef struct
|
||||
{
|
||||
byte width;
|
||||
byte height;
|
||||
byte data;
|
||||
} pic_t;
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,79 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// MapObj data. Map Objects or mobjs are actors, entities,
|
||||
// thinker, take-your-pick... anything that moves, acts, or
|
||||
// suffers state changes of more or less violent nature.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __D_THINK__
|
||||
#define __D_THINK__
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Experimental stuff.
|
||||
// To compile this as "ANSI C with classes"
|
||||
// we will need to handle the various
|
||||
// action functions cleanly.
|
||||
//
|
||||
typedef void (*actionf_v)();
|
||||
typedef void (*actionf_p1)( void* );
|
||||
typedef void (*actionf_p2)( void*, void* );
|
||||
|
||||
typedef union
|
||||
{
|
||||
actionf_p1 acp1;
|
||||
actionf_v acv;
|
||||
actionf_p2 acp2;
|
||||
|
||||
} actionf_t;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// Historically, "think_t" is yet another
|
||||
// function pointer to a routine to handle
|
||||
// an actor.
|
||||
typedef actionf_t think_t;
|
||||
|
||||
|
||||
// Doubly linked list of actors.
|
||||
typedef struct thinker_s
|
||||
{
|
||||
struct thinker_s* prev;
|
||||
struct thinker_s* next;
|
||||
think_t function;
|
||||
|
||||
} thinker_t;
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,53 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// System specific interface stuff.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __D_TICCMD__
|
||||
#define __D_TICCMD__
|
||||
|
||||
#include "doomtype.h"
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
// The data sampled per tick (single player)
|
||||
// and transmitted to other peers (multiplayer).
|
||||
// Mainly movements/button commands per game tick,
|
||||
// plus a checksum for internal state consistency.
|
||||
typedef struct
|
||||
{
|
||||
char forwardmove; // *2048 for move
|
||||
char sidemove; // *2048 for move
|
||||
short angleturn; // <<16 for angle delta
|
||||
short consistancy; // checks for net game
|
||||
byte chatchar;
|
||||
byte buttons;
|
||||
} ticcmd_t;
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,222 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// all external data is defined here
|
||||
// most of the data is loaded into different structures at run time
|
||||
// some internal structures shared by many modules are here
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __DOOMDATA__
|
||||
#define __DOOMDATA__
|
||||
|
||||
// The most basic types we use, portability.
|
||||
#include "doomtype.h"
|
||||
|
||||
// Some global defines, that configure the game.
|
||||
#include "doomdef.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Map level types.
|
||||
// The following data structures define the persistent format
|
||||
// used in the lumps of the WAD files.
|
||||
//
|
||||
|
||||
// Lump order in a map WAD: each map needs a couple of lumps
|
||||
// to provide a complete scene geometry description.
|
||||
enum
|
||||
{
|
||||
ML_LABEL, // A separator, name, ExMx or MAPxx
|
||||
ML_THINGS, // Monsters, items..
|
||||
ML_LINEDEFS, // LineDefs, from editing
|
||||
ML_SIDEDEFS, // SideDefs, from editing
|
||||
ML_VERTEXES, // Vertices, edited and BSP splits generated
|
||||
ML_SEGS, // LineSegs, from LineDefs split by BSP
|
||||
ML_SSECTORS, // SubSectors, list of LineSegs
|
||||
ML_NODES, // BSP nodes
|
||||
ML_SECTORS, // Sectors, from editing
|
||||
ML_REJECT, // LUT, sector-sector visibility
|
||||
ML_BLOCKMAP // LUT, motion clipping, walls/grid element
|
||||
};
|
||||
|
||||
|
||||
// A single Vertex.
|
||||
typedef struct
|
||||
{
|
||||
short x;
|
||||
short y;
|
||||
} mapvertex_t;
|
||||
|
||||
|
||||
// A SideDef, defining the visual appearance of a wall,
|
||||
// by setting textures and offsets.
|
||||
typedef struct
|
||||
{
|
||||
short textureoffset;
|
||||
short rowoffset;
|
||||
char toptexture[8];
|
||||
char bottomtexture[8];
|
||||
char midtexture[8];
|
||||
// Front sector, towards viewer.
|
||||
short sector;
|
||||
} mapsidedef_t;
|
||||
|
||||
|
||||
|
||||
// A LineDef, as used for editing, and as input
|
||||
// to the BSP builder.
|
||||
typedef struct
|
||||
{
|
||||
short v1;
|
||||
short v2;
|
||||
short flags;
|
||||
short special;
|
||||
short tag;
|
||||
// sidenum[1] will be -1 if one sided
|
||||
short sidenum[2];
|
||||
} maplinedef_t;
|
||||
|
||||
|
||||
//
|
||||
// LineDef attributes.
|
||||
//
|
||||
|
||||
// Solid, is an obstacle.
|
||||
#define ML_BLOCKING 1
|
||||
|
||||
// Blocks monsters only.
|
||||
#define ML_BLOCKMONSTERS 2
|
||||
|
||||
// Backside will not be present at all
|
||||
// if not two sided.
|
||||
#define ML_TWOSIDED 4
|
||||
|
||||
// If a texture is pegged, the texture will have
|
||||
// the end exposed to air held constant at the
|
||||
// top or bottom of the texture (stairs or pulled
|
||||
// down things) and will move with a height change
|
||||
// of one of the neighbor sectors.
|
||||
// Unpegged textures allways have the first row of
|
||||
// the texture at the top pixel of the line for both
|
||||
// top and bottom textures (use next to windows).
|
||||
|
||||
// upper texture unpegged
|
||||
#define ML_DONTPEGTOP 8
|
||||
|
||||
// lower texture unpegged
|
||||
#define ML_DONTPEGBOTTOM 16
|
||||
|
||||
// In AutoMap: don't map as two sided: IT'S A SECRET!
|
||||
#define ML_SECRET 32
|
||||
|
||||
// Sound rendering: don't let sound cross two of these.
|
||||
#define ML_SOUNDBLOCK 64
|
||||
|
||||
// Don't draw on the automap at all.
|
||||
#define ML_DONTDRAW 128
|
||||
|
||||
// Set if already seen, thus drawn in automap.
|
||||
#define ML_MAPPED 256
|
||||
|
||||
|
||||
|
||||
|
||||
// Sector definition, from editing.
|
||||
typedef struct
|
||||
{
|
||||
short floorheight;
|
||||
short ceilingheight;
|
||||
char floorpic[8];
|
||||
char ceilingpic[8];
|
||||
short lightlevel;
|
||||
short special;
|
||||
short tag;
|
||||
} mapsector_t;
|
||||
|
||||
// SubSector, as generated by BSP.
|
||||
typedef struct
|
||||
{
|
||||
short numsegs;
|
||||
// Index of first one, segs are stored sequentially.
|
||||
short firstseg;
|
||||
} mapsubsector_t;
|
||||
|
||||
|
||||
// LineSeg, generated by splitting LineDefs
|
||||
// using partition lines selected by BSP builder.
|
||||
typedef struct
|
||||
{
|
||||
short v1;
|
||||
short v2;
|
||||
short angle;
|
||||
short linedef;
|
||||
short side;
|
||||
short offset;
|
||||
} mapseg_t;
|
||||
|
||||
|
||||
|
||||
// BSP node structure.
|
||||
|
||||
// Indicate a leaf.
|
||||
#define NF_SUBSECTOR 0x8000
|
||||
|
||||
typedef struct
|
||||
{
|
||||
// Partition line from (x,y) to x+dx,y+dy)
|
||||
short x;
|
||||
short y;
|
||||
short dx;
|
||||
short dy;
|
||||
|
||||
// Bounding box for each child,
|
||||
// clip against view frustum.
|
||||
short bbox[2][4];
|
||||
|
||||
// If NF_SUBSECTOR its a subsector,
|
||||
// else it's a node of another subtree.
|
||||
unsigned short children[2];
|
||||
|
||||
} mapnode_t;
|
||||
|
||||
|
||||
|
||||
|
||||
// Thing definition, position, orientation and type,
|
||||
// plus skill/visibility flags and attributes.
|
||||
typedef struct
|
||||
{
|
||||
short x;
|
||||
short y;
|
||||
short angle;
|
||||
short type;
|
||||
short options;
|
||||
} mapthing_t;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#endif // __DOOMDATA__
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// DoomDef - basic defines for DOOM, e.g. Version, game mode
|
||||
// and skill level, and display parameters.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "doomdef.h"
|
||||
#endif
|
||||
#include "doomdef.h"
|
||||
|
||||
// Location for any defines turned variables.
|
||||
|
||||
// None.
|
||||
|
||||
|
||||
@@ -0,0 +1,332 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Internally used data structures for virtually everything,
|
||||
// key definitions, lots of other stuff.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __DOOMDEF__
|
||||
#define __DOOMDEF__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
// Console output goes to stderr, which every platform can redirect.
|
||||
#define printf(...) fprintf (stderr, __VA_ARGS__)
|
||||
|
||||
//
|
||||
// Global parameters/defines.
|
||||
//
|
||||
// DOOM version
|
||||
enum { VERSION = 110 };
|
||||
|
||||
|
||||
// Game mode handling - identify IWAD version
|
||||
// to handle IWAD dependend animations etc.
|
||||
typedef enum
|
||||
{
|
||||
shareware, // DOOM 1 shareware, E1, M9
|
||||
registered, // DOOM 1 registered, E3, M27
|
||||
commercial, // DOOM 2 retail, E1 M34
|
||||
// DOOM 2 german edition not handled
|
||||
retail, // DOOM 1 retail, E4, M36
|
||||
indetermined // Well, no IWAD found.
|
||||
|
||||
} GameMode_t;
|
||||
|
||||
|
||||
// Mission packs - might be useful for TC stuff?
|
||||
typedef enum
|
||||
{
|
||||
doom, // DOOM 1
|
||||
doom2, // DOOM 2
|
||||
pack_tnt, // TNT mission pack
|
||||
pack_plut, // Plutonia pack
|
||||
none
|
||||
|
||||
} GameMission_t;
|
||||
|
||||
|
||||
// Identify language to use, software localization.
|
||||
typedef enum
|
||||
{
|
||||
english,
|
||||
french,
|
||||
german,
|
||||
unknown
|
||||
|
||||
} Language_t;
|
||||
|
||||
|
||||
// If rangecheck is undefined,
|
||||
// most parameter validation debugging code will not be compiled
|
||||
#define RANGECHECK
|
||||
|
||||
|
||||
|
||||
// This one switches between MIT SHM (no proper mouse)
|
||||
// and XFree86 DGA (mickey sampling). The original
|
||||
// linuxdoom used SHM, which is default.
|
||||
//#define X11_DGA 1
|
||||
|
||||
|
||||
//
|
||||
// For resize of screen, at start of game.
|
||||
// It will not work dynamically, see visplanes.
|
||||
//
|
||||
#define BASE_WIDTH 320
|
||||
|
||||
// It is educational but futile to change this
|
||||
// scaling e.g. to 2. Drawing of status bar,
|
||||
// menues etc. is tied to the scale implied
|
||||
// by the graphics.
|
||||
#define SCREEN_MUL 1
|
||||
#define INV_ASPECT_RATIO 0.625 // 0.75, ideally
|
||||
|
||||
// Defines suck. C sucks.
|
||||
// C++ might sucks for OOP, but it sure is a better C.
|
||||
// So there.
|
||||
#define SCREENWIDTH 320
|
||||
//SCREEN_MUL*BASE_WIDTH //320
|
||||
#define SCREENHEIGHT 200
|
||||
//(int)(SCREEN_MUL*BASE_WIDTH*INV_ASPECT_RATIO) //200
|
||||
|
||||
|
||||
|
||||
|
||||
// The maximum number of players, multiplayer/networking.
|
||||
#define MAXPLAYERS 4
|
||||
|
||||
// State updates, number of tics / second.
|
||||
#define TICRATE 35
|
||||
|
||||
// The current state of the game: whether we are
|
||||
// playing, gazing at the intermission screen,
|
||||
// the game final animation, or a demo.
|
||||
typedef enum
|
||||
{
|
||||
GS_LEVEL,
|
||||
GS_INTERMISSION,
|
||||
GS_FINALE,
|
||||
GS_DEMOSCREEN
|
||||
} gamestate_t;
|
||||
|
||||
//
|
||||
// Difficulty/skill settings/filters.
|
||||
//
|
||||
|
||||
// Skill flags.
|
||||
#define MTF_EASY 1
|
||||
#define MTF_NORMAL 2
|
||||
#define MTF_HARD 4
|
||||
|
||||
// Deaf monsters/do not react to sound.
|
||||
#define MTF_AMBUSH 8
|
||||
|
||||
typedef enum
|
||||
{
|
||||
sk_baby,
|
||||
sk_easy,
|
||||
sk_medium,
|
||||
sk_hard,
|
||||
sk_nightmare
|
||||
} skill_t;
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Key cards.
|
||||
//
|
||||
typedef enum
|
||||
{
|
||||
it_bluecard,
|
||||
it_yellowcard,
|
||||
it_redcard,
|
||||
it_blueskull,
|
||||
it_yellowskull,
|
||||
it_redskull,
|
||||
|
||||
NUMCARDS
|
||||
|
||||
} card_t;
|
||||
|
||||
|
||||
|
||||
// The defined weapons,
|
||||
// including a marker indicating
|
||||
// user has not changed weapon.
|
||||
typedef enum
|
||||
{
|
||||
wp_fist,
|
||||
wp_pistol,
|
||||
wp_shotgun,
|
||||
wp_chaingun,
|
||||
wp_missile,
|
||||
wp_plasma,
|
||||
wp_bfg,
|
||||
wp_chainsaw,
|
||||
wp_supershotgun,
|
||||
|
||||
NUMWEAPONS,
|
||||
|
||||
// No pending weapon change.
|
||||
wp_nochange
|
||||
|
||||
} weapontype_t;
|
||||
|
||||
|
||||
// Ammunition types defined.
|
||||
typedef enum
|
||||
{
|
||||
am_clip, // Pistol / chaingun ammo.
|
||||
am_shell, // Shotgun / double barreled shotgun.
|
||||
am_cell, // Plasma rifle, BFG.
|
||||
am_misl, // Missile launcher.
|
||||
NUMAMMO,
|
||||
am_noammo // Unlimited for chainsaw / fist.
|
||||
|
||||
} ammotype_t;
|
||||
|
||||
|
||||
// Power up artifacts.
|
||||
typedef enum
|
||||
{
|
||||
pw_invulnerability,
|
||||
pw_strength,
|
||||
pw_invisibility,
|
||||
pw_ironfeet,
|
||||
pw_allmap,
|
||||
pw_infrared,
|
||||
NUMPOWERS
|
||||
|
||||
} powertype_t;
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Power up durations,
|
||||
// how many seconds till expiration,
|
||||
// assuming TICRATE is 35 ticks/second.
|
||||
//
|
||||
typedef enum
|
||||
{
|
||||
INVULNTICS = (30*TICRATE),
|
||||
INVISTICS = (60*TICRATE),
|
||||
INFRATICS = (120*TICRATE),
|
||||
IRONTICS = (60*TICRATE)
|
||||
|
||||
} powerduration_t;
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// DOOM keyboard definition.
|
||||
// This is the stuff configured by Setup.Exe.
|
||||
// Most key data are simple ascii (uppercased).
|
||||
//
|
||||
#define KEY_RIGHTARROW 0xae
|
||||
#define KEY_LEFTARROW 0xac
|
||||
#define KEY_UPARROW 0xad
|
||||
#define KEY_DOWNARROW 0xaf
|
||||
#define KEY_ESCAPE 27
|
||||
#define KEY_ENTER 13
|
||||
#define KEY_TAB 9
|
||||
#define KEY_F1 (0x80+0x3b)
|
||||
#define KEY_F2 (0x80+0x3c)
|
||||
#define KEY_F3 (0x80+0x3d)
|
||||
#define KEY_F4 (0x80+0x3e)
|
||||
#define KEY_F5 (0x80+0x3f)
|
||||
#define KEY_F6 (0x80+0x40)
|
||||
#define KEY_F7 (0x80+0x41)
|
||||
#define KEY_F8 (0x80+0x42)
|
||||
#define KEY_F9 (0x80+0x43)
|
||||
#define KEY_F10 (0x80+0x44)
|
||||
#define KEY_F11 (0x80+0x57)
|
||||
#define KEY_F12 (0x80+0x58)
|
||||
|
||||
#define KEY_BACKSPACE 127
|
||||
#define KEY_PAUSE 0xff
|
||||
|
||||
#define KEY_EQUALS 0x3d
|
||||
#define KEY_MINUS 0x2d
|
||||
|
||||
#define KEY_RSHIFT (0x80+0x36)
|
||||
#define KEY_RCTRL (0x80+0x1d)
|
||||
#define KEY_RALT (0x80+0x38)
|
||||
|
||||
#define KEY_LALT KEY_RALT
|
||||
|
||||
|
||||
|
||||
// DOOM basic types (boolean),
|
||||
// and max/min values.
|
||||
//#include "doomtype.h"
|
||||
|
||||
// Fixed point.
|
||||
//#include "m_fixed.h"
|
||||
|
||||
// Endianess handling.
|
||||
//#include "m_swap.h"
|
||||
|
||||
|
||||
// Binary Angles, sine/cosine/atan lookups.
|
||||
//#include "tables.h"
|
||||
|
||||
// Event type.
|
||||
//#include "d_event.h"
|
||||
|
||||
// Game function, skills.
|
||||
//#include "g_game.h"
|
||||
|
||||
// All external data is defined here.
|
||||
//#include "doomdata.h"
|
||||
|
||||
// All important printed strings.
|
||||
// Language selection (message strings).
|
||||
//#include "dstrings.h"
|
||||
|
||||
// Player is a special actor.
|
||||
//struct player_s;
|
||||
|
||||
|
||||
//#include "d_items.h"
|
||||
//#include "d_player.h"
|
||||
//#include "p_mobj.h"
|
||||
//#include "d_net.h"
|
||||
|
||||
// PLAY
|
||||
//#include "p_tick.h"
|
||||
|
||||
|
||||
|
||||
|
||||
// Header, generated by sound utility.
|
||||
// The utility was written by Dave Taylor.
|
||||
//#include "sounds.h"
|
||||
|
||||
|
||||
|
||||
|
||||
#endif // __DOOMDEF__
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,46 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Put all global tate variables here.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "doomstat.h"
|
||||
#endif
|
||||
#include "doomstat.h"
|
||||
|
||||
|
||||
// Game Mode - identify IWAD as shareware, retail etc.
|
||||
GameMode_t gamemode = indetermined;
|
||||
GameMission_t gamemission = doom;
|
||||
|
||||
// Language.
|
||||
Language_t language = english;
|
||||
|
||||
// Set if homebrew PWAD stuff has been added.
|
||||
boolean modifiedgame;
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,296 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// All the global variables that store the internal state.
|
||||
// Theoretically speaking, the internal state of the engine
|
||||
// should be found by looking at the variables collected
|
||||
// here, and every relevant module will have to include
|
||||
// this header file.
|
||||
// In practice, things are a bit messy.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __D_STATE__
|
||||
#define __D_STATE__
|
||||
|
||||
// We need globally shared data structures,
|
||||
// for defining the global state variables.
|
||||
#include "doomdata.h"
|
||||
#include "d_net.h"
|
||||
|
||||
// We need the playr data structure as well.
|
||||
#include "d_player.h"
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
// ------------------------
|
||||
// Command line parameters.
|
||||
//
|
||||
extern boolean nomonsters; // checkparm of -nomonsters
|
||||
extern boolean respawnparm; // checkparm of -respawn
|
||||
extern boolean fastparm; // checkparm of -fast
|
||||
|
||||
extern boolean devparm; // DEBUG: launched with -devparm
|
||||
|
||||
|
||||
|
||||
// -----------------------------------------------------
|
||||
// Game Mode - identify IWAD as shareware, retail etc.
|
||||
//
|
||||
extern GameMode_t gamemode;
|
||||
extern GameMission_t gamemission;
|
||||
|
||||
// Set if homebrew PWAD stuff has been added.
|
||||
extern boolean modifiedgame;
|
||||
|
||||
|
||||
// -------------------------------------------
|
||||
// Language.
|
||||
extern Language_t language;
|
||||
|
||||
|
||||
// -------------------------------------------
|
||||
// Selected skill type, map etc.
|
||||
//
|
||||
|
||||
// Defaults for menu, methinks.
|
||||
extern skill_t startskill;
|
||||
extern int startepisode;
|
||||
extern int startmap;
|
||||
|
||||
extern boolean autostart;
|
||||
|
||||
// Selected by user.
|
||||
extern skill_t gameskill;
|
||||
extern int gameepisode;
|
||||
extern int gamemap;
|
||||
|
||||
// Nightmare mode flag, single player.
|
||||
extern boolean respawnmonsters;
|
||||
|
||||
// Netgame? Only true if >1 player.
|
||||
extern boolean netgame;
|
||||
|
||||
// Flag: true only if started as net deathmatch.
|
||||
// An enum might handle altdeath/cooperative better.
|
||||
extern boolean deathmatch;
|
||||
|
||||
// -------------------------
|
||||
// Internal parameters for sound rendering.
|
||||
// These have been taken from the DOS version,
|
||||
// but are not (yet) supported with Linux
|
||||
// (e.g. no sound volume adjustment with menu.
|
||||
|
||||
// These are not used, but should be (menu).
|
||||
// From m_menu.c:
|
||||
// Sound FX volume has default, 0 - 15
|
||||
// Music volume has default, 0 - 15
|
||||
// These are multiplied by 8.
|
||||
extern int snd_SfxVolume; // maximum volume for sound
|
||||
extern int snd_MusicVolume; // maximum volume for music
|
||||
|
||||
// Current music/sfx card - index useless
|
||||
// w/o a reference LUT in a sound module.
|
||||
// Ideally, this would use indices found
|
||||
// in: /usr/include/linux/soundcard.h
|
||||
extern int snd_MusicDevice;
|
||||
extern int snd_SfxDevice;
|
||||
// Config file? Same disclaimer as above.
|
||||
extern int snd_DesiredMusicDevice;
|
||||
extern int snd_DesiredSfxDevice;
|
||||
|
||||
|
||||
// -------------------------
|
||||
// Status flags for refresh.
|
||||
//
|
||||
|
||||
// Depending on view size - no status bar?
|
||||
// Note that there is no way to disable the
|
||||
// status bar explicitely.
|
||||
extern boolean statusbaractive;
|
||||
|
||||
extern boolean automapactive; // In AutoMap mode?
|
||||
extern boolean menuactive; // Menu overlayed?
|
||||
extern boolean paused; // Game Pause?
|
||||
|
||||
|
||||
extern boolean viewactive;
|
||||
|
||||
extern boolean nodrawers;
|
||||
extern boolean noblit;
|
||||
|
||||
extern int viewwindowx;
|
||||
extern int viewwindowy;
|
||||
extern int viewheight;
|
||||
extern int viewwidth;
|
||||
extern int scaledviewwidth;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// This one is related to the 3-screen display mode.
|
||||
// ANG90 = left side, ANG270 = right
|
||||
extern int viewangleoffset;
|
||||
|
||||
// Player taking events, and displaying.
|
||||
extern int consoleplayer;
|
||||
extern int displayplayer;
|
||||
|
||||
|
||||
// -------------------------------------
|
||||
// Scores, rating.
|
||||
// Statistics on a given map, for intermission.
|
||||
//
|
||||
extern int totalkills;
|
||||
extern int totalitems;
|
||||
extern int totalsecret;
|
||||
|
||||
// Timer, for scores.
|
||||
extern int levelstarttic; // gametic at level start
|
||||
extern int leveltime; // tics in game play for par
|
||||
|
||||
|
||||
|
||||
// --------------------------------------
|
||||
// DEMO playback/recording related stuff.
|
||||
// No demo, there is a human player in charge?
|
||||
// Disable save/end game?
|
||||
extern boolean usergame;
|
||||
|
||||
//?
|
||||
extern boolean demoplayback;
|
||||
extern boolean demorecording;
|
||||
|
||||
// Quit after playing a demo from cmdline.
|
||||
extern boolean singledemo;
|
||||
|
||||
|
||||
|
||||
|
||||
//?
|
||||
extern gamestate_t gamestate;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//-----------------------------
|
||||
// Internal parameters, fixed.
|
||||
// These are set by the engine, and not changed
|
||||
// according to user inputs. Partly load from
|
||||
// WAD, partly set at startup time.
|
||||
|
||||
|
||||
|
||||
extern int gametic;
|
||||
|
||||
|
||||
// Bookkeeping on players - state.
|
||||
extern player_t players[MAXPLAYERS];
|
||||
|
||||
// Alive? Disconnected?
|
||||
extern boolean playeringame[MAXPLAYERS];
|
||||
|
||||
|
||||
// Player spawn spots for deathmatch.
|
||||
#define MAX_DM_STARTS 10
|
||||
extern mapthing_t deathmatchstarts[MAX_DM_STARTS];
|
||||
extern mapthing_t* deathmatch_p;
|
||||
|
||||
// Player spawn spots.
|
||||
extern mapthing_t playerstarts[MAXPLAYERS];
|
||||
|
||||
// Intermission stats.
|
||||
// Parameters for world map / intermission.
|
||||
extern wbstartstruct_t wminfo;
|
||||
|
||||
|
||||
// LUT of ammunition limits for each kind.
|
||||
// This doubles with BackPack powerup item.
|
||||
extern int maxammo[NUMAMMO];
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------
|
||||
// Internal parameters, used for engine.
|
||||
//
|
||||
|
||||
// File handling stuff.
|
||||
extern char basedefault[1024];
|
||||
extern FILE* debugfile;
|
||||
|
||||
// if true, load all graphics at level load
|
||||
extern boolean precache;
|
||||
|
||||
|
||||
// wipegamestate can be set to -1
|
||||
// to force a wipe on the next draw
|
||||
extern gamestate_t wipegamestate;
|
||||
|
||||
extern int mouseSensitivity;
|
||||
//?
|
||||
// debug flag to cancel adaptiveness
|
||||
extern boolean singletics;
|
||||
|
||||
extern int bodyqueslot;
|
||||
|
||||
|
||||
|
||||
// Needed to store the number of the dummy sky flat.
|
||||
// Used for rendering,
|
||||
// as well as tracking projectiles etc.
|
||||
extern int skyflatnum;
|
||||
|
||||
|
||||
|
||||
// Netgame stuff (buffers and pointers, i.e. indices).
|
||||
|
||||
// This is ???
|
||||
extern doomcom_t* doomcom;
|
||||
|
||||
// This points inside doomcom.
|
||||
extern doomdata_t* netbuffer;
|
||||
|
||||
|
||||
extern ticcmd_t localcmds[BACKUPTICS];
|
||||
extern int rndindex;
|
||||
|
||||
extern int maketic;
|
||||
extern int nettics[MAXNETNODES];
|
||||
|
||||
extern ticcmd_t netcmds[MAXPLAYERS][BACKUPTICS];
|
||||
extern int ticdup;
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,61 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Simple basic typedefs, isolated here to make it easier
|
||||
// separating modules.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __DOOMTYPE__
|
||||
#define __DOOMTYPE__
|
||||
|
||||
|
||||
#ifndef __BYTEBOOL__
|
||||
#define __BYTEBOOL__
|
||||
// Fixed to use builtin bool type with C++.
|
||||
#ifdef __cplusplus
|
||||
typedef bool boolean;
|
||||
#else
|
||||
typedef enum {false, true} boolean;
|
||||
#endif
|
||||
typedef unsigned char byte;
|
||||
#endif
|
||||
|
||||
|
||||
#define MAXCHAR ((char)0x7f)
|
||||
#define MAXSHORT ((short)0x7fff)
|
||||
|
||||
// Max pos 32-bit int.
|
||||
#define MAXINT ((int)0x7fffffff)
|
||||
#define MAXLONG ((long)0x7fffffff)
|
||||
#define MINCHAR ((char)0x80)
|
||||
#define MINSHORT ((short)0x8000)
|
||||
|
||||
// Max negative 32-bit integer.
|
||||
#define MININT ((int)0x80000000)
|
||||
#define MINLONG ((long)0x80000000)
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,72 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Globally defined strings.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "dstrings.h"
|
||||
#endif
|
||||
#include "dstrings.h"
|
||||
|
||||
|
||||
|
||||
char* endmsg[NUM_QUITMESSAGES+1]=
|
||||
{
|
||||
// DOOM1
|
||||
QUITMSG,
|
||||
"please don't leave, there's more\ndemons to toast!",
|
||||
"let's beat it -- this is turning\ninto a bloodbath!",
|
||||
"i wouldn't leave if i were you.\ndos is much worse.",
|
||||
"you're trying to say you like dos\nbetter than me, right?",
|
||||
"don't leave yet -- there's a\ndemon around that corner!",
|
||||
"ya know, next time you come in here\ni'm gonna toast ya.",
|
||||
"go ahead and leave. see if i care."
|
||||
|
||||
// QuitDOOM II messages
|
||||
"you want to quit?\nthen, thou hast lost an eighth!",
|
||||
"don't go now, there's a \ndimensional shambler waiting\nat the dos prompt!",
|
||||
"get outta here and go back\nto your boring programs.",
|
||||
"if i were your boss, i'd \n deathmatch ya in a minute!",
|
||||
"look, bud. you leave now\nand you forfeit your body count!",
|
||||
"just leave. when you come\nback, i'll be waiting with a bat.",
|
||||
"you're lucky i don't smack\nyou for thinking about leaving."
|
||||
|
||||
// FinalDOOM?
|
||||
"fuck you, pussy!\nget the fuck out!",
|
||||
"you quit and i'll jizz\nin your cystholes!",
|
||||
"if you leave, i'll make\nthe lord drink my jizz.",
|
||||
"hey, ron! can we say\n'fuck' in the game?",
|
||||
"i'd leave: this is just\nmore monsters and levels.\nwhat a load.",
|
||||
"suck it down, asshole!\nyou're a fucking wimp!",
|
||||
"don't quit now! we're \nstill spending your money!",
|
||||
|
||||
// Internal debug. Different style, too.
|
||||
"THIS IS NO MESSAGE!\nPage intentionally left blank."
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,66 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// DOOM strings, by language.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __DSTRINGS__
|
||||
#define __DSTRINGS__
|
||||
|
||||
|
||||
// All important printed strings.
|
||||
// Language selection (message strings).
|
||||
// Use -DFRENCH etc.
|
||||
|
||||
#ifdef FRENCH
|
||||
#include "d_french.h"
|
||||
#else
|
||||
#include "d_englsh.h"
|
||||
#endif
|
||||
|
||||
// Misc. other strings.
|
||||
#define SAVEGAMENAME "doomsav"
|
||||
|
||||
|
||||
//
|
||||
// File locations,
|
||||
// relative to current position.
|
||||
// Path names are OS-sensitive.
|
||||
//
|
||||
#define DEVMAPS "devmaps"
|
||||
#define DEVDATA "devdata"
|
||||
|
||||
|
||||
// Not done in french?
|
||||
|
||||
// QuitDOOM messages
|
||||
#define NUM_QUITMESSAGES 22
|
||||
|
||||
extern char* endmsg[];
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,738 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Game completion, final screen animation.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: f_finale.c,v 1.5 1997/02/03 21:26:34 b1 Exp $";
|
||||
|
||||
#include <ctype.h>
|
||||
|
||||
// Functions.
|
||||
#include "i_system.h"
|
||||
#include "m_swap.h"
|
||||
#include "z_zone.h"
|
||||
#include "v_video.h"
|
||||
#include "w_wad.h"
|
||||
#include "s_sound.h"
|
||||
|
||||
// Data.
|
||||
#include "dstrings.h"
|
||||
#include "sounds.h"
|
||||
|
||||
#include "doomstat.h"
|
||||
#include "r_state.h"
|
||||
|
||||
// ?
|
||||
//#include "doomstat.h"
|
||||
//#include "r_local.h"
|
||||
//#include "f_finale.h"
|
||||
|
||||
// Stage of animation:
|
||||
// 0 = text, 1 = art screen, 2 = character cast
|
||||
int finalestage;
|
||||
|
||||
int finalecount;
|
||||
|
||||
#define TEXTSPEED 3
|
||||
#define TEXTWAIT 250
|
||||
|
||||
char* e1text = E1TEXT;
|
||||
char* e2text = E2TEXT;
|
||||
char* e3text = E3TEXT;
|
||||
char* e4text = E4TEXT;
|
||||
|
||||
char* c1text = C1TEXT;
|
||||
char* c2text = C2TEXT;
|
||||
char* c3text = C3TEXT;
|
||||
char* c4text = C4TEXT;
|
||||
char* c5text = C5TEXT;
|
||||
char* c6text = C6TEXT;
|
||||
|
||||
char* p1text = P1TEXT;
|
||||
char* p2text = P2TEXT;
|
||||
char* p3text = P3TEXT;
|
||||
char* p4text = P4TEXT;
|
||||
char* p5text = P5TEXT;
|
||||
char* p6text = P6TEXT;
|
||||
|
||||
char* t1text = T1TEXT;
|
||||
char* t2text = T2TEXT;
|
||||
char* t3text = T3TEXT;
|
||||
char* t4text = T4TEXT;
|
||||
char* t5text = T5TEXT;
|
||||
char* t6text = T6TEXT;
|
||||
|
||||
char* finaletext;
|
||||
char* finaleflat;
|
||||
|
||||
void F_StartCast (void);
|
||||
void F_CastTicker (void);
|
||||
boolean F_CastResponder (event_t *ev);
|
||||
void F_CastDrawer (void);
|
||||
|
||||
//
|
||||
// F_StartFinale
|
||||
//
|
||||
void F_StartFinale (void)
|
||||
{
|
||||
gameaction = ga_nothing;
|
||||
gamestate = GS_FINALE;
|
||||
viewactive = false;
|
||||
automapactive = false;
|
||||
|
||||
// Okay - IWAD dependend stuff.
|
||||
// This has been changed severly, and
|
||||
// some stuff might have changed in the process.
|
||||
switch ( gamemode )
|
||||
{
|
||||
|
||||
// DOOM 1 - E1, E3 or E4, but each nine missions
|
||||
case shareware:
|
||||
case registered:
|
||||
case retail:
|
||||
{
|
||||
S_ChangeMusic(mus_victor, true);
|
||||
|
||||
switch (gameepisode)
|
||||
{
|
||||
case 1:
|
||||
finaleflat = "FLOOR4_8";
|
||||
finaletext = e1text;
|
||||
break;
|
||||
case 2:
|
||||
finaleflat = "SFLR6_1";
|
||||
finaletext = e2text;
|
||||
break;
|
||||
case 3:
|
||||
finaleflat = "MFLR8_4";
|
||||
finaletext = e3text;
|
||||
break;
|
||||
case 4:
|
||||
finaleflat = "MFLR8_3";
|
||||
finaletext = e4text;
|
||||
break;
|
||||
default:
|
||||
// Ouch.
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
// DOOM II and missions packs with E1, M34
|
||||
case commercial:
|
||||
{
|
||||
S_ChangeMusic(mus_read_m, true);
|
||||
|
||||
switch (gamemap)
|
||||
{
|
||||
case 6:
|
||||
finaleflat = "SLIME16";
|
||||
finaletext = c1text;
|
||||
break;
|
||||
case 11:
|
||||
finaleflat = "RROCK14";
|
||||
finaletext = c2text;
|
||||
break;
|
||||
case 20:
|
||||
finaleflat = "RROCK07";
|
||||
finaletext = c3text;
|
||||
break;
|
||||
case 30:
|
||||
finaleflat = "RROCK17";
|
||||
finaletext = c4text;
|
||||
break;
|
||||
case 15:
|
||||
finaleflat = "RROCK13";
|
||||
finaletext = c5text;
|
||||
break;
|
||||
case 31:
|
||||
finaleflat = "RROCK19";
|
||||
finaletext = c6text;
|
||||
break;
|
||||
default:
|
||||
// Ouch.
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
// Indeterminate.
|
||||
default:
|
||||
S_ChangeMusic(mus_read_m, true);
|
||||
finaleflat = "F_SKY1"; // Not used anywhere else.
|
||||
finaletext = c1text; // FIXME - other text, music?
|
||||
break;
|
||||
}
|
||||
|
||||
finalestage = 0;
|
||||
finalecount = 0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
boolean F_Responder (event_t *event)
|
||||
{
|
||||
if (finalestage == 2)
|
||||
return F_CastResponder (event);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// F_Ticker
|
||||
//
|
||||
void F_Ticker (void)
|
||||
{
|
||||
int i;
|
||||
|
||||
// check for skipping
|
||||
if ( (gamemode == commercial)
|
||||
&& ( finalecount > 50) )
|
||||
{
|
||||
// go on to the next level
|
||||
for (i=0 ; i<MAXPLAYERS ; i++)
|
||||
if (players[i].cmd.buttons)
|
||||
break;
|
||||
|
||||
if (i < MAXPLAYERS)
|
||||
{
|
||||
if (gamemap == 30)
|
||||
F_StartCast ();
|
||||
else
|
||||
gameaction = ga_worlddone;
|
||||
}
|
||||
}
|
||||
|
||||
// advance animation
|
||||
finalecount++;
|
||||
|
||||
if (finalestage == 2)
|
||||
{
|
||||
F_CastTicker ();
|
||||
return;
|
||||
}
|
||||
|
||||
if ( gamemode == commercial)
|
||||
return;
|
||||
|
||||
if (!finalestage && finalecount>strlen (finaletext)*TEXTSPEED + TEXTWAIT)
|
||||
{
|
||||
finalecount = 0;
|
||||
finalestage = 1;
|
||||
wipegamestate = -1; // force a wipe
|
||||
if (gameepisode == 3)
|
||||
S_StartMusic (mus_bunny);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// F_TextWrite
|
||||
//
|
||||
|
||||
#include "hu_stuff.h"
|
||||
extern patch_t *hu_font[HU_FONTSIZE];
|
||||
|
||||
|
||||
void F_TextWrite (void)
|
||||
{
|
||||
byte* src;
|
||||
byte* dest;
|
||||
|
||||
int x,y,w;
|
||||
int count;
|
||||
char* ch;
|
||||
int c;
|
||||
int cx;
|
||||
int cy;
|
||||
|
||||
// erase the entire screen to a tiled background
|
||||
src = W_CacheLumpName ( finaleflat , PU_CACHE);
|
||||
dest = screens[0];
|
||||
|
||||
for (y=0 ; y<SCREENHEIGHT ; y++)
|
||||
{
|
||||
for (x=0 ; x<SCREENWIDTH/64 ; x++)
|
||||
{
|
||||
memcpy (dest, src+((y&63)<<6), 64);
|
||||
dest += 64;
|
||||
}
|
||||
if (SCREENWIDTH&63)
|
||||
{
|
||||
memcpy (dest, src+((y&63)<<6), SCREENWIDTH&63);
|
||||
dest += (SCREENWIDTH&63);
|
||||
}
|
||||
}
|
||||
|
||||
V_MarkRect (0, 0, SCREENWIDTH, SCREENHEIGHT);
|
||||
|
||||
// draw some of the text onto the screen
|
||||
cx = 10;
|
||||
cy = 10;
|
||||
ch = finaletext;
|
||||
|
||||
count = (finalecount - 10)/TEXTSPEED;
|
||||
if (count < 0)
|
||||
count = 0;
|
||||
for ( ; count ; count-- )
|
||||
{
|
||||
c = *ch++;
|
||||
if (!c)
|
||||
break;
|
||||
if (c == '\n')
|
||||
{
|
||||
cx = 10;
|
||||
cy += 11;
|
||||
continue;
|
||||
}
|
||||
|
||||
c = toupper(c) - HU_FONTSTART;
|
||||
if (c < 0 || c> HU_FONTSIZE)
|
||||
{
|
||||
cx += 4;
|
||||
continue;
|
||||
}
|
||||
|
||||
w = SHORT (hu_font[c]->width);
|
||||
if (cx+w > SCREENWIDTH)
|
||||
break;
|
||||
V_DrawPatch(cx, cy, 0, hu_font[c]);
|
||||
cx+=w;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//
|
||||
// Final DOOM 2 animation
|
||||
// Casting by id Software.
|
||||
// in order of appearance
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
char *name;
|
||||
mobjtype_t type;
|
||||
} castinfo_t;
|
||||
|
||||
castinfo_t castorder[] = {
|
||||
{CC_ZOMBIE, MT_POSSESSED},
|
||||
{CC_SHOTGUN, MT_SHOTGUY},
|
||||
{CC_HEAVY, MT_CHAINGUY},
|
||||
{CC_IMP, MT_TROOP},
|
||||
{CC_DEMON, MT_SERGEANT},
|
||||
{CC_LOST, MT_SKULL},
|
||||
{CC_CACO, MT_HEAD},
|
||||
{CC_HELL, MT_KNIGHT},
|
||||
{CC_BARON, MT_BRUISER},
|
||||
{CC_ARACH, MT_BABY},
|
||||
{CC_PAIN, MT_PAIN},
|
||||
{CC_REVEN, MT_UNDEAD},
|
||||
{CC_MANCU, MT_FATSO},
|
||||
{CC_ARCH, MT_VILE},
|
||||
{CC_SPIDER, MT_SPIDER},
|
||||
{CC_CYBER, MT_CYBORG},
|
||||
{CC_HERO, MT_PLAYER},
|
||||
|
||||
{NULL,0}
|
||||
};
|
||||
|
||||
int castnum;
|
||||
int casttics;
|
||||
state_t* caststate;
|
||||
boolean castdeath;
|
||||
int castframes;
|
||||
int castonmelee;
|
||||
boolean castattacking;
|
||||
|
||||
|
||||
//
|
||||
// F_StartCast
|
||||
//
|
||||
extern gamestate_t wipegamestate;
|
||||
|
||||
|
||||
void F_StartCast (void)
|
||||
{
|
||||
wipegamestate = -1; // force a screen wipe
|
||||
castnum = 0;
|
||||
caststate = &states[mobjinfo[castorder[castnum].type].seestate];
|
||||
casttics = caststate->tics;
|
||||
castdeath = false;
|
||||
finalestage = 2;
|
||||
castframes = 0;
|
||||
castonmelee = 0;
|
||||
castattacking = false;
|
||||
S_ChangeMusic(mus_evil, true);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// F_CastTicker
|
||||
//
|
||||
void F_CastTicker (void)
|
||||
{
|
||||
int st;
|
||||
int sfx;
|
||||
|
||||
if (--casttics > 0)
|
||||
return; // not time to change state yet
|
||||
|
||||
if (caststate->tics == -1 || caststate->nextstate == S_NULL)
|
||||
{
|
||||
// switch from deathstate to next monster
|
||||
castnum++;
|
||||
castdeath = false;
|
||||
if (castorder[castnum].name == NULL)
|
||||
castnum = 0;
|
||||
if (mobjinfo[castorder[castnum].type].seesound)
|
||||
S_StartSound (NULL, mobjinfo[castorder[castnum].type].seesound);
|
||||
caststate = &states[mobjinfo[castorder[castnum].type].seestate];
|
||||
castframes = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
// just advance to next state in animation
|
||||
if (caststate == &states[S_PLAY_ATK1])
|
||||
goto stopattack; // Oh, gross hack!
|
||||
st = caststate->nextstate;
|
||||
caststate = &states[st];
|
||||
castframes++;
|
||||
|
||||
// sound hacks....
|
||||
switch (st)
|
||||
{
|
||||
case S_PLAY_ATK1: sfx = sfx_dshtgn; break;
|
||||
case S_POSS_ATK2: sfx = sfx_pistol; break;
|
||||
case S_SPOS_ATK2: sfx = sfx_shotgn; break;
|
||||
case S_VILE_ATK2: sfx = sfx_vilatk; break;
|
||||
case S_SKEL_FIST2: sfx = sfx_skeswg; break;
|
||||
case S_SKEL_FIST4: sfx = sfx_skepch; break;
|
||||
case S_SKEL_MISS2: sfx = sfx_skeatk; break;
|
||||
case S_FATT_ATK8:
|
||||
case S_FATT_ATK5:
|
||||
case S_FATT_ATK2: sfx = sfx_firsht; break;
|
||||
case S_CPOS_ATK2:
|
||||
case S_CPOS_ATK3:
|
||||
case S_CPOS_ATK4: sfx = sfx_shotgn; break;
|
||||
case S_TROO_ATK3: sfx = sfx_claw; break;
|
||||
case S_SARG_ATK2: sfx = sfx_sgtatk; break;
|
||||
case S_BOSS_ATK2:
|
||||
case S_BOS2_ATK2:
|
||||
case S_HEAD_ATK2: sfx = sfx_firsht; break;
|
||||
case S_SKULL_ATK2: sfx = sfx_sklatk; break;
|
||||
case S_SPID_ATK2:
|
||||
case S_SPID_ATK3: sfx = sfx_shotgn; break;
|
||||
case S_BSPI_ATK2: sfx = sfx_plasma; break;
|
||||
case S_CYBER_ATK2:
|
||||
case S_CYBER_ATK4:
|
||||
case S_CYBER_ATK6: sfx = sfx_rlaunc; break;
|
||||
case S_PAIN_ATK3: sfx = sfx_sklatk; break;
|
||||
default: sfx = 0; break;
|
||||
}
|
||||
|
||||
if (sfx)
|
||||
S_StartSound (NULL, sfx);
|
||||
}
|
||||
|
||||
if (castframes == 12)
|
||||
{
|
||||
// go into attack frame
|
||||
castattacking = true;
|
||||
if (castonmelee)
|
||||
caststate=&states[mobjinfo[castorder[castnum].type].meleestate];
|
||||
else
|
||||
caststate=&states[mobjinfo[castorder[castnum].type].missilestate];
|
||||
castonmelee ^= 1;
|
||||
if (caststate == &states[S_NULL])
|
||||
{
|
||||
if (castonmelee)
|
||||
caststate=
|
||||
&states[mobjinfo[castorder[castnum].type].meleestate];
|
||||
else
|
||||
caststate=
|
||||
&states[mobjinfo[castorder[castnum].type].missilestate];
|
||||
}
|
||||
}
|
||||
|
||||
if (castattacking)
|
||||
{
|
||||
if (castframes == 24
|
||||
|| caststate == &states[mobjinfo[castorder[castnum].type].seestate] )
|
||||
{
|
||||
stopattack:
|
||||
castattacking = false;
|
||||
castframes = 0;
|
||||
caststate = &states[mobjinfo[castorder[castnum].type].seestate];
|
||||
}
|
||||
}
|
||||
|
||||
casttics = caststate->tics;
|
||||
if (casttics == -1)
|
||||
casttics = 15;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// F_CastResponder
|
||||
//
|
||||
|
||||
boolean F_CastResponder (event_t* ev)
|
||||
{
|
||||
if (ev->type != ev_keydown)
|
||||
return false;
|
||||
|
||||
if (castdeath)
|
||||
return true; // already in dying frames
|
||||
|
||||
// go into death frame
|
||||
castdeath = true;
|
||||
caststate = &states[mobjinfo[castorder[castnum].type].deathstate];
|
||||
casttics = caststate->tics;
|
||||
castframes = 0;
|
||||
castattacking = false;
|
||||
if (mobjinfo[castorder[castnum].type].deathsound)
|
||||
S_StartSound (NULL, mobjinfo[castorder[castnum].type].deathsound);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void F_CastPrint (char* text)
|
||||
{
|
||||
char* ch;
|
||||
int c;
|
||||
int cx;
|
||||
int w;
|
||||
int width;
|
||||
|
||||
// find width
|
||||
ch = text;
|
||||
width = 0;
|
||||
|
||||
while (ch)
|
||||
{
|
||||
c = *ch++;
|
||||
if (!c)
|
||||
break;
|
||||
c = toupper(c) - HU_FONTSTART;
|
||||
if (c < 0 || c> HU_FONTSIZE)
|
||||
{
|
||||
width += 4;
|
||||
continue;
|
||||
}
|
||||
|
||||
w = SHORT (hu_font[c]->width);
|
||||
width += w;
|
||||
}
|
||||
|
||||
// draw it
|
||||
cx = 160-width/2;
|
||||
ch = text;
|
||||
while (ch)
|
||||
{
|
||||
c = *ch++;
|
||||
if (!c)
|
||||
break;
|
||||
c = toupper(c) - HU_FONTSTART;
|
||||
if (c < 0 || c> HU_FONTSIZE)
|
||||
{
|
||||
cx += 4;
|
||||
continue;
|
||||
}
|
||||
|
||||
w = SHORT (hu_font[c]->width);
|
||||
V_DrawPatch(cx, 180, 0, hu_font[c]);
|
||||
cx+=w;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// F_CastDrawer
|
||||
//
|
||||
void V_DrawPatchFlipped (int x, int y, int scrn, patch_t *patch);
|
||||
|
||||
void F_CastDrawer (void)
|
||||
{
|
||||
spritedef_t* sprdef;
|
||||
spriteframe_t* sprframe;
|
||||
int lump;
|
||||
boolean flip;
|
||||
patch_t* patch;
|
||||
|
||||
// erase the entire screen to a background
|
||||
V_DrawPatch (0,0,0, W_CacheLumpName ("BOSSBACK", PU_CACHE));
|
||||
|
||||
F_CastPrint (castorder[castnum].name);
|
||||
|
||||
// draw the current frame in the middle of the screen
|
||||
sprdef = &sprites[caststate->sprite];
|
||||
sprframe = &sprdef->spriteframes[ caststate->frame & FF_FRAMEMASK];
|
||||
lump = sprframe->lump[0];
|
||||
flip = (boolean)sprframe->flip[0];
|
||||
|
||||
patch = W_CacheLumpNum (lump+firstspritelump, PU_CACHE);
|
||||
if (flip)
|
||||
V_DrawPatchFlipped (160,170,0,patch);
|
||||
else
|
||||
V_DrawPatch (160,170,0,patch);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// F_DrawPatchCol
|
||||
//
|
||||
void
|
||||
F_DrawPatchCol
|
||||
( int x,
|
||||
patch_t* patch,
|
||||
int col )
|
||||
{
|
||||
column_t* column;
|
||||
byte* source;
|
||||
byte* dest;
|
||||
byte* desttop;
|
||||
int count;
|
||||
|
||||
column = (column_t *)((byte *)patch + LONG(patch->columnofs[col]));
|
||||
desttop = screens[0]+x;
|
||||
|
||||
// step through the posts in a column
|
||||
while (column->topdelta != 0xff )
|
||||
{
|
||||
source = (byte *)column + 3;
|
||||
dest = desttop + column->topdelta*SCREENWIDTH;
|
||||
count = column->length;
|
||||
|
||||
while (count--)
|
||||
{
|
||||
*dest = *source++;
|
||||
dest += SCREENWIDTH;
|
||||
}
|
||||
column = (column_t *)( (byte *)column + column->length + 4 );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// F_BunnyScroll
|
||||
//
|
||||
void F_BunnyScroll (void)
|
||||
{
|
||||
int scrolled;
|
||||
int x;
|
||||
patch_t* p1;
|
||||
patch_t* p2;
|
||||
char name[10];
|
||||
int stage;
|
||||
static int laststage;
|
||||
|
||||
p1 = W_CacheLumpName ("PFUB2", PU_LEVEL);
|
||||
p2 = W_CacheLumpName ("PFUB1", PU_LEVEL);
|
||||
|
||||
V_MarkRect (0, 0, SCREENWIDTH, SCREENHEIGHT);
|
||||
|
||||
scrolled = 320 - (finalecount-230)/2;
|
||||
if (scrolled > 320)
|
||||
scrolled = 320;
|
||||
if (scrolled < 0)
|
||||
scrolled = 0;
|
||||
|
||||
for ( x=0 ; x<SCREENWIDTH ; x++)
|
||||
{
|
||||
if (x+scrolled < 320)
|
||||
F_DrawPatchCol (x, p1, x+scrolled);
|
||||
else
|
||||
F_DrawPatchCol (x, p2, x+scrolled - 320);
|
||||
}
|
||||
|
||||
if (finalecount < 1130)
|
||||
return;
|
||||
if (finalecount < 1180)
|
||||
{
|
||||
V_DrawPatch ((SCREENWIDTH-13*8)/2,
|
||||
(SCREENHEIGHT-8*8)/2,0, W_CacheLumpName ("END0",PU_CACHE));
|
||||
laststage = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
stage = (finalecount-1180) / 5;
|
||||
if (stage > 6)
|
||||
stage = 6;
|
||||
if (stage > laststage)
|
||||
{
|
||||
S_StartSound (NULL, sfx_pistol);
|
||||
laststage = stage;
|
||||
}
|
||||
|
||||
sprintf (name,"END%i",stage);
|
||||
V_DrawPatch ((SCREENWIDTH-13*8)/2, (SCREENHEIGHT-8*8)/2,0, W_CacheLumpName (name,PU_CACHE));
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// F_Drawer
|
||||
//
|
||||
void F_Drawer (void)
|
||||
{
|
||||
if (finalestage == 2)
|
||||
{
|
||||
F_CastDrawer ();
|
||||
return;
|
||||
}
|
||||
|
||||
if (!finalestage)
|
||||
F_TextWrite ();
|
||||
else
|
||||
{
|
||||
switch (gameepisode)
|
||||
{
|
||||
case 1:
|
||||
if ( gamemode == retail )
|
||||
V_DrawPatch (0,0,0,
|
||||
W_CacheLumpName("CREDIT",PU_CACHE));
|
||||
else
|
||||
V_DrawPatch (0,0,0,
|
||||
W_CacheLumpName("HELP2",PU_CACHE));
|
||||
break;
|
||||
case 2:
|
||||
V_DrawPatch(0,0,0,
|
||||
W_CacheLumpName("VICTORY2",PU_CACHE));
|
||||
break;
|
||||
case 3:
|
||||
F_BunnyScroll ();
|
||||
break;
|
||||
case 4:
|
||||
V_DrawPatch (0,0,0,
|
||||
W_CacheLumpName("ENDPIC",PU_CACHE));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,53 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
//
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __F_FINALE__
|
||||
#define __F_FINALE__
|
||||
|
||||
|
||||
#include "doomtype.h"
|
||||
#include "d_event.h"
|
||||
//
|
||||
// FINALE
|
||||
//
|
||||
|
||||
// Called by main loop.
|
||||
boolean F_Responder (event_t* ev);
|
||||
|
||||
// Called by main loop.
|
||||
void F_Ticker (void);
|
||||
|
||||
// Called by main loop.
|
||||
void F_Drawer (void);
|
||||
|
||||
|
||||
void F_StartFinale (void);
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,302 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Mission begin melt/wipe screen special effect.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
static const char rcsid[] = "$Id: f_wipe.c,v 1.2 1997/02/03 22:45:09 b1 Exp $";
|
||||
|
||||
|
||||
|
||||
#include "z_zone.h"
|
||||
#include "i_video.h"
|
||||
#include "v_video.h"
|
||||
#include "m_random.h"
|
||||
|
||||
#include "doomdef.h"
|
||||
|
||||
#include "f_wipe.h"
|
||||
|
||||
//
|
||||
// SCREEN WIPE PACKAGE
|
||||
//
|
||||
|
||||
// when zero, stop the wipe
|
||||
static boolean go = 0;
|
||||
|
||||
static byte* wipe_scr_start;
|
||||
static byte* wipe_scr_end;
|
||||
static byte* wipe_scr;
|
||||
|
||||
|
||||
void
|
||||
wipe_shittyColMajorXform
|
||||
( short* array,
|
||||
int width,
|
||||
int height )
|
||||
{
|
||||
int x;
|
||||
int y;
|
||||
short* dest;
|
||||
|
||||
dest = (short*) Z_Malloc(width*height*2, PU_STATIC, 0);
|
||||
|
||||
for(y=0;y<height;y++)
|
||||
for(x=0;x<width;x++)
|
||||
dest[x*height+y] = array[y*width+x];
|
||||
|
||||
memcpy(array, dest, width*height*2);
|
||||
|
||||
Z_Free(dest);
|
||||
|
||||
}
|
||||
|
||||
int
|
||||
wipe_initColorXForm
|
||||
( int width,
|
||||
int height,
|
||||
int ticks )
|
||||
{
|
||||
memcpy(wipe_scr, wipe_scr_start, width*height);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
wipe_doColorXForm
|
||||
( int width,
|
||||
int height,
|
||||
int ticks )
|
||||
{
|
||||
boolean changed;
|
||||
byte* w;
|
||||
byte* e;
|
||||
int newval;
|
||||
|
||||
changed = false;
|
||||
w = wipe_scr;
|
||||
e = wipe_scr_end;
|
||||
|
||||
while (w!=wipe_scr+width*height)
|
||||
{
|
||||
if (*w != *e)
|
||||
{
|
||||
if (*w > *e)
|
||||
{
|
||||
newval = *w - ticks;
|
||||
if (newval < *e)
|
||||
*w = *e;
|
||||
else
|
||||
*w = newval;
|
||||
changed = true;
|
||||
}
|
||||
else if (*w < *e)
|
||||
{
|
||||
newval = *w + ticks;
|
||||
if (newval > *e)
|
||||
*w = *e;
|
||||
else
|
||||
*w = newval;
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
w++;
|
||||
e++;
|
||||
}
|
||||
|
||||
return !changed;
|
||||
|
||||
}
|
||||
|
||||
int
|
||||
wipe_exitColorXForm
|
||||
( int width,
|
||||
int height,
|
||||
int ticks )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static int* y;
|
||||
|
||||
int
|
||||
wipe_initMelt
|
||||
( int width,
|
||||
int height,
|
||||
int ticks )
|
||||
{
|
||||
int i, r;
|
||||
|
||||
// copy start screen to main screen
|
||||
memcpy(wipe_scr, wipe_scr_start, width*height);
|
||||
|
||||
// makes this wipe faster (in theory)
|
||||
// to have stuff in column-major format
|
||||
wipe_shittyColMajorXform((short*)wipe_scr_start, width/2, height);
|
||||
wipe_shittyColMajorXform((short*)wipe_scr_end, width/2, height);
|
||||
|
||||
// setup initial column positions
|
||||
// (y<0 => not ready to scroll yet)
|
||||
y = (int *) Z_Malloc(width*sizeof(int), PU_STATIC, 0);
|
||||
y[0] = -(M_Random()%16);
|
||||
for (i=1;i<width;i++)
|
||||
{
|
||||
r = (M_Random()%3) - 1;
|
||||
y[i] = y[i-1] + r;
|
||||
if (y[i] > 0) y[i] = 0;
|
||||
else if (y[i] == -16) y[i] = -15;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
wipe_doMelt
|
||||
( int width,
|
||||
int height,
|
||||
int ticks )
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
int dy;
|
||||
int idx;
|
||||
|
||||
short* s;
|
||||
short* d;
|
||||
boolean done = true;
|
||||
|
||||
width/=2;
|
||||
|
||||
while (ticks--)
|
||||
{
|
||||
for (i=0;i<width;i++)
|
||||
{
|
||||
if (y[i]<0)
|
||||
{
|
||||
y[i]++; done = false;
|
||||
}
|
||||
else if (y[i] < height)
|
||||
{
|
||||
dy = (y[i] < 16) ? y[i]+1 : 8;
|
||||
if (y[i]+dy >= height) dy = height - y[i];
|
||||
s = &((short *)wipe_scr_end)[i*height+y[i]];
|
||||
d = &((short *)wipe_scr)[y[i]*width+i];
|
||||
idx = 0;
|
||||
for (j=dy;j;j--)
|
||||
{
|
||||
d[idx] = *(s++);
|
||||
idx += width;
|
||||
}
|
||||
y[i] += dy;
|
||||
s = &((short *)wipe_scr_start)[i*height];
|
||||
d = &((short *)wipe_scr)[y[i]*width+i];
|
||||
idx = 0;
|
||||
for (j=height-y[i];j;j--)
|
||||
{
|
||||
d[idx] = *(s++);
|
||||
idx += width;
|
||||
}
|
||||
done = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return done;
|
||||
|
||||
}
|
||||
|
||||
int
|
||||
wipe_exitMelt
|
||||
( int width,
|
||||
int height,
|
||||
int ticks )
|
||||
{
|
||||
Z_Free(y);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
wipe_StartScreen
|
||||
( int x,
|
||||
int y,
|
||||
int width,
|
||||
int height )
|
||||
{
|
||||
wipe_scr_start = screens[2];
|
||||
I_ReadScreen(wipe_scr_start);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
wipe_EndScreen
|
||||
( int x,
|
||||
int y,
|
||||
int width,
|
||||
int height )
|
||||
{
|
||||
wipe_scr_end = screens[3];
|
||||
I_ReadScreen(wipe_scr_end);
|
||||
V_DrawBlock(x, y, 0, width, height, wipe_scr_start); // restore start scr.
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
wipe_ScreenWipe
|
||||
( int wipeno,
|
||||
int x,
|
||||
int y,
|
||||
int width,
|
||||
int height,
|
||||
int ticks )
|
||||
{
|
||||
int rc;
|
||||
static int (*wipes[])(int, int, int) =
|
||||
{
|
||||
wipe_initColorXForm, wipe_doColorXForm, wipe_exitColorXForm,
|
||||
wipe_initMelt, wipe_doMelt, wipe_exitMelt
|
||||
};
|
||||
|
||||
void V_MarkRect(int, int, int, int);
|
||||
|
||||
// initial stuff
|
||||
if (!go)
|
||||
{
|
||||
go = 1;
|
||||
// wipe_scr = (byte *) Z_Malloc(width*height, PU_STATIC, 0); // DEBUG
|
||||
wipe_scr = screens[0];
|
||||
(*wipes[wipeno*3])(width, height, ticks);
|
||||
}
|
||||
|
||||
// do a piece of wipe-in
|
||||
V_MarkRect(0, 0, width, height);
|
||||
rc = (*wipes[wipeno*3+1])(width, height, ticks);
|
||||
// V_DrawBlock(x, y, 0, width, height, wipe_scr); // DEBUG
|
||||
|
||||
// final stuff
|
||||
if (rc)
|
||||
{
|
||||
go = 0;
|
||||
(*wipes[wipeno*3+2])(width, height, ticks);
|
||||
}
|
||||
|
||||
return !go;
|
||||
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Mission start screen wipe/melt, special effects.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __F_WIPE_H__
|
||||
#define __F_WIPE_H__
|
||||
|
||||
//
|
||||
// SCREEN WIPE PACKAGE
|
||||
//
|
||||
|
||||
enum
|
||||
{
|
||||
// simple gradual pixel change for 8-bit only
|
||||
wipe_ColorXForm,
|
||||
|
||||
// weird screen melt
|
||||
wipe_Melt,
|
||||
|
||||
wipe_NUMWIPES
|
||||
};
|
||||
|
||||
int
|
||||
wipe_StartScreen
|
||||
( int x,
|
||||
int y,
|
||||
int width,
|
||||
int height );
|
||||
|
||||
|
||||
int
|
||||
wipe_EndScreen
|
||||
( int x,
|
||||
int y,
|
||||
int width,
|
||||
int height );
|
||||
|
||||
|
||||
int
|
||||
wipe_ScreenWipe
|
||||
( int wipeno,
|
||||
int x,
|
||||
int y,
|
||||
int width,
|
||||
int height,
|
||||
int ticks );
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
+1686
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,79 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Duh.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __G_GAME__
|
||||
#define __G_GAME__
|
||||
|
||||
#include "doomdef.h"
|
||||
#include "d_event.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// GAME
|
||||
//
|
||||
void G_DeathMatchSpawnPlayer (int playernum);
|
||||
|
||||
void G_InitNew (skill_t skill, int episode, int map);
|
||||
|
||||
// Can be called by the startup code or M_Responder.
|
||||
// A normal game starts at map 1,
|
||||
// but a warp test can start elsewhere
|
||||
void G_DeferedInitNew (skill_t skill, int episode, int map);
|
||||
|
||||
void G_DeferedPlayDemo (char* demo);
|
||||
|
||||
// Can be called by the startup code or M_Responder,
|
||||
// calls P_SetupLevel or W_EnterWorld.
|
||||
void G_LoadGame (char* name);
|
||||
|
||||
void G_DoLoadGame (void);
|
||||
|
||||
// Called by M_Responder.
|
||||
void G_SaveGame (int slot, char* description);
|
||||
|
||||
// Only called by startup code.
|
||||
void G_RecordDemo (char* name);
|
||||
|
||||
void G_BeginRecording (void);
|
||||
|
||||
void G_PlayDemo (char* name);
|
||||
void G_TimeDemo (char* name);
|
||||
boolean G_CheckDemoStatus (void);
|
||||
|
||||
void G_ExitLevel (void);
|
||||
void G_SecretExitLevel (void);
|
||||
|
||||
void G_WorldDone (void);
|
||||
|
||||
void G_Ticker (void);
|
||||
boolean G_Responder (event_t* ev);
|
||||
|
||||
void G_ScreenShot (void);
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,354 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION: heads-up text and input code
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: hu_lib.c,v 1.3 1997/01/26 07:44:58 b1 Exp $";
|
||||
|
||||
#include <ctype.h>
|
||||
|
||||
#include "doomdef.h"
|
||||
|
||||
#include "v_video.h"
|
||||
#include "m_swap.h"
|
||||
|
||||
#include "hu_lib.h"
|
||||
#include "r_local.h"
|
||||
#include "r_draw.h"
|
||||
|
||||
// boolean : whether the screen is always erased
|
||||
#define noterased viewwindowx
|
||||
|
||||
extern boolean automapactive; // in AM_map.c
|
||||
|
||||
void HUlib_init(void)
|
||||
{
|
||||
}
|
||||
|
||||
void HUlib_clearTextLine(hu_textline_t* t)
|
||||
{
|
||||
t->len = 0;
|
||||
t->l[0] = 0;
|
||||
t->needsupdate = true;
|
||||
}
|
||||
|
||||
void
|
||||
HUlib_initTextLine
|
||||
( hu_textline_t* t,
|
||||
int x,
|
||||
int y,
|
||||
patch_t** f,
|
||||
int sc )
|
||||
{
|
||||
t->x = x;
|
||||
t->y = y;
|
||||
t->f = f;
|
||||
t->sc = sc;
|
||||
HUlib_clearTextLine(t);
|
||||
}
|
||||
|
||||
boolean
|
||||
HUlib_addCharToTextLine
|
||||
( hu_textline_t* t,
|
||||
char ch )
|
||||
{
|
||||
|
||||
if (t->len == HU_MAXLINELENGTH)
|
||||
return false;
|
||||
else
|
||||
{
|
||||
t->l[t->len++] = ch;
|
||||
t->l[t->len] = 0;
|
||||
t->needsupdate = 4;
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
boolean HUlib_delCharFromTextLine(hu_textline_t* t)
|
||||
{
|
||||
|
||||
if (!t->len) return false;
|
||||
else
|
||||
{
|
||||
t->l[--t->len] = 0;
|
||||
t->needsupdate = 4;
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void
|
||||
HUlib_drawTextLine
|
||||
( hu_textline_t* l,
|
||||
boolean drawcursor )
|
||||
{
|
||||
|
||||
int i;
|
||||
int w;
|
||||
int x;
|
||||
unsigned char c;
|
||||
|
||||
// draw the new stuff
|
||||
x = l->x;
|
||||
for (i=0;i<l->len;i++)
|
||||
{
|
||||
c = toupper(l->l[i]);
|
||||
if (c != ' '
|
||||
&& c >= l->sc
|
||||
&& c <= '_')
|
||||
{
|
||||
w = SHORT(l->f[c - l->sc]->width);
|
||||
if (x+w > SCREENWIDTH)
|
||||
break;
|
||||
V_DrawPatchDirect(x, l->y, FG, l->f[c - l->sc]);
|
||||
x += w;
|
||||
}
|
||||
else
|
||||
{
|
||||
x += 4;
|
||||
if (x >= SCREENWIDTH)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// draw the cursor if requested
|
||||
if (drawcursor
|
||||
&& x + SHORT(l->f['_' - l->sc]->width) <= SCREENWIDTH)
|
||||
{
|
||||
V_DrawPatchDirect(x, l->y, FG, l->f['_' - l->sc]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// sorta called by HU_Erase and just better darn get things straight
|
||||
void HUlib_eraseTextLine(hu_textline_t* l)
|
||||
{
|
||||
int lh;
|
||||
int y;
|
||||
int yoffset;
|
||||
static boolean lastautomapactive = true;
|
||||
|
||||
// Only erases when NOT in automap and the screen is reduced,
|
||||
// and the text must either need updating or refreshing
|
||||
// (because of a recent change back from the automap)
|
||||
|
||||
if (!automapactive &&
|
||||
viewwindowx && l->needsupdate)
|
||||
{
|
||||
lh = SHORT(l->f[0]->height) + 1;
|
||||
for (y=l->y,yoffset=y*SCREENWIDTH ; y<l->y+lh ; y++,yoffset+=SCREENWIDTH)
|
||||
{
|
||||
if (y < viewwindowy || y >= viewwindowy + viewheight)
|
||||
R_VideoErase(yoffset, SCREENWIDTH); // erase entire line
|
||||
else
|
||||
{
|
||||
R_VideoErase(yoffset, viewwindowx); // erase left border
|
||||
R_VideoErase(yoffset + viewwindowx + viewwidth, viewwindowx);
|
||||
// erase right border
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
lastautomapactive = automapactive;
|
||||
if (l->needsupdate) l->needsupdate--;
|
||||
|
||||
}
|
||||
|
||||
void
|
||||
HUlib_initSText
|
||||
( hu_stext_t* s,
|
||||
int x,
|
||||
int y,
|
||||
int h,
|
||||
patch_t** font,
|
||||
int startchar,
|
||||
boolean* on )
|
||||
{
|
||||
|
||||
int i;
|
||||
|
||||
s->h = h;
|
||||
s->on = on;
|
||||
s->laston = true;
|
||||
s->cl = 0;
|
||||
for (i=0;i<h;i++)
|
||||
HUlib_initTextLine(&s->l[i],
|
||||
x, y - i*(SHORT(font[0]->height)+1),
|
||||
font, startchar);
|
||||
|
||||
}
|
||||
|
||||
void HUlib_addLineToSText(hu_stext_t* s)
|
||||
{
|
||||
|
||||
int i;
|
||||
|
||||
// add a clear line
|
||||
if (++s->cl == s->h)
|
||||
s->cl = 0;
|
||||
HUlib_clearTextLine(&s->l[s->cl]);
|
||||
|
||||
// everything needs updating
|
||||
for (i=0 ; i<s->h ; i++)
|
||||
s->l[i].needsupdate = 4;
|
||||
|
||||
}
|
||||
|
||||
void
|
||||
HUlib_addMessageToSText
|
||||
( hu_stext_t* s,
|
||||
char* prefix,
|
||||
char* msg )
|
||||
{
|
||||
HUlib_addLineToSText(s);
|
||||
if (prefix)
|
||||
while (*prefix)
|
||||
HUlib_addCharToTextLine(&s->l[s->cl], *(prefix++));
|
||||
|
||||
while (*msg)
|
||||
HUlib_addCharToTextLine(&s->l[s->cl], *(msg++));
|
||||
}
|
||||
|
||||
void HUlib_drawSText(hu_stext_t* s)
|
||||
{
|
||||
int i, idx;
|
||||
hu_textline_t *l;
|
||||
|
||||
if (!*s->on)
|
||||
return; // if not on, don't draw
|
||||
|
||||
// draw everything
|
||||
for (i=0 ; i<s->h ; i++)
|
||||
{
|
||||
idx = s->cl - i;
|
||||
if (idx < 0)
|
||||
idx += s->h; // handle queue of lines
|
||||
|
||||
l = &s->l[idx];
|
||||
|
||||
// need a decision made here on whether to skip the draw
|
||||
HUlib_drawTextLine(l, false); // no cursor, please
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void HUlib_eraseSText(hu_stext_t* s)
|
||||
{
|
||||
|
||||
int i;
|
||||
|
||||
for (i=0 ; i<s->h ; i++)
|
||||
{
|
||||
if (s->laston && !*s->on)
|
||||
s->l[i].needsupdate = 4;
|
||||
HUlib_eraseTextLine(&s->l[i]);
|
||||
}
|
||||
s->laston = *s->on;
|
||||
|
||||
}
|
||||
|
||||
void
|
||||
HUlib_initIText
|
||||
( hu_itext_t* it,
|
||||
int x,
|
||||
int y,
|
||||
patch_t** font,
|
||||
int startchar,
|
||||
boolean* on )
|
||||
{
|
||||
it->lm = 0; // default left margin is start of text
|
||||
it->on = on;
|
||||
it->laston = true;
|
||||
HUlib_initTextLine(&it->l, x, y, font, startchar);
|
||||
}
|
||||
|
||||
|
||||
// The following deletion routines adhere to the left margin restriction
|
||||
void HUlib_delCharFromIText(hu_itext_t* it)
|
||||
{
|
||||
if (it->l.len != it->lm)
|
||||
HUlib_delCharFromTextLine(&it->l);
|
||||
}
|
||||
|
||||
void HUlib_eraseLineFromIText(hu_itext_t* it)
|
||||
{
|
||||
while (it->lm != it->l.len)
|
||||
HUlib_delCharFromTextLine(&it->l);
|
||||
}
|
||||
|
||||
// Resets left margin as well
|
||||
void HUlib_resetIText(hu_itext_t* it)
|
||||
{
|
||||
it->lm = 0;
|
||||
HUlib_clearTextLine(&it->l);
|
||||
}
|
||||
|
||||
void
|
||||
HUlib_addPrefixToIText
|
||||
( hu_itext_t* it,
|
||||
char* str )
|
||||
{
|
||||
while (*str)
|
||||
HUlib_addCharToTextLine(&it->l, *(str++));
|
||||
it->lm = it->l.len;
|
||||
}
|
||||
|
||||
// wrapper function for handling general keyed input.
|
||||
// returns true if it ate the key
|
||||
boolean
|
||||
HUlib_keyInIText
|
||||
( hu_itext_t* it,
|
||||
unsigned char ch )
|
||||
{
|
||||
|
||||
if (ch >= ' ' && ch <= '_')
|
||||
HUlib_addCharToTextLine(&it->l, (char) ch);
|
||||
else
|
||||
if (ch == KEY_BACKSPACE)
|
||||
HUlib_delCharFromIText(it);
|
||||
else
|
||||
if (ch != KEY_ENTER)
|
||||
return false; // did not eat key
|
||||
|
||||
return true; // ate the key
|
||||
|
||||
}
|
||||
|
||||
void HUlib_drawIText(hu_itext_t* it)
|
||||
{
|
||||
|
||||
hu_textline_t *l = &it->l;
|
||||
|
||||
if (!*it->on)
|
||||
return;
|
||||
HUlib_drawTextLine(l, true); // draw the line w/ cursor
|
||||
|
||||
}
|
||||
|
||||
void HUlib_eraseIText(hu_itext_t* it)
|
||||
{
|
||||
if (it->laston && !*it->on)
|
||||
it->l.needsupdate = 4;
|
||||
HUlib_eraseTextLine(&it->l);
|
||||
it->laston = *it->on;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,196 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION: none
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __HULIB__
|
||||
#define __HULIB__
|
||||
|
||||
// We are referring to patches.
|
||||
#include "r_defs.h"
|
||||
|
||||
|
||||
// background and foreground screen numbers
|
||||
// different from other modules.
|
||||
#define BG 1
|
||||
#define FG 0
|
||||
|
||||
// font stuff
|
||||
#define HU_CHARERASE KEY_BACKSPACE
|
||||
|
||||
#define HU_MAXLINES 4
|
||||
#define HU_MAXLINELENGTH 80
|
||||
|
||||
//
|
||||
// Typedefs of widgets
|
||||
//
|
||||
|
||||
// Text Line widget
|
||||
// (parent of Scrolling Text and Input Text widgets)
|
||||
typedef struct
|
||||
{
|
||||
// left-justified position of scrolling text window
|
||||
int x;
|
||||
int y;
|
||||
|
||||
patch_t** f; // font
|
||||
int sc; // start character
|
||||
char l[HU_MAXLINELENGTH+1]; // line of text
|
||||
int len; // current line length
|
||||
|
||||
// whether this line needs to be udpated
|
||||
int needsupdate;
|
||||
|
||||
} hu_textline_t;
|
||||
|
||||
|
||||
|
||||
// Scrolling Text window widget
|
||||
// (child of Text Line widget)
|
||||
typedef struct
|
||||
{
|
||||
hu_textline_t l[HU_MAXLINES]; // text lines to draw
|
||||
int h; // height in lines
|
||||
int cl; // current line number
|
||||
|
||||
// pointer to boolean stating whether to update window
|
||||
boolean* on;
|
||||
boolean laston; // last value of *->on.
|
||||
|
||||
} hu_stext_t;
|
||||
|
||||
|
||||
|
||||
// Input Text Line widget
|
||||
// (child of Text Line widget)
|
||||
typedef struct
|
||||
{
|
||||
hu_textline_t l; // text line to input on
|
||||
|
||||
// left margin past which I am not to delete characters
|
||||
int lm;
|
||||
|
||||
// pointer to boolean stating whether to update window
|
||||
boolean* on;
|
||||
boolean laston; // last value of *->on;
|
||||
|
||||
} hu_itext_t;
|
||||
|
||||
|
||||
//
|
||||
// Widget creation, access, and update routines
|
||||
//
|
||||
|
||||
// initializes heads-up widget library
|
||||
void HUlib_init(void);
|
||||
|
||||
//
|
||||
// textline code
|
||||
//
|
||||
|
||||
// clear a line of text
|
||||
void HUlib_clearTextLine(hu_textline_t *t);
|
||||
|
||||
void HUlib_initTextLine(hu_textline_t *t, int x, int y, patch_t **f, int sc);
|
||||
|
||||
// returns success
|
||||
boolean HUlib_addCharToTextLine(hu_textline_t *t, char ch);
|
||||
|
||||
// returns success
|
||||
boolean HUlib_delCharFromTextLine(hu_textline_t *t);
|
||||
|
||||
// draws tline
|
||||
void HUlib_drawTextLine(hu_textline_t *l, boolean drawcursor);
|
||||
|
||||
// erases text line
|
||||
void HUlib_eraseTextLine(hu_textline_t *l);
|
||||
|
||||
|
||||
//
|
||||
// Scrolling Text window widget routines
|
||||
//
|
||||
|
||||
// ?
|
||||
void
|
||||
HUlib_initSText
|
||||
( hu_stext_t* s,
|
||||
int x,
|
||||
int y,
|
||||
int h,
|
||||
patch_t** font,
|
||||
int startchar,
|
||||
boolean* on );
|
||||
|
||||
// add a new line
|
||||
void HUlib_addLineToSText(hu_stext_t* s);
|
||||
|
||||
// ?
|
||||
void
|
||||
HUlib_addMessageToSText
|
||||
( hu_stext_t* s,
|
||||
char* prefix,
|
||||
char* msg );
|
||||
|
||||
// draws stext
|
||||
void HUlib_drawSText(hu_stext_t* s);
|
||||
|
||||
// erases all stext lines
|
||||
void HUlib_eraseSText(hu_stext_t* s);
|
||||
|
||||
// Input Text Line widget routines
|
||||
void
|
||||
HUlib_initIText
|
||||
( hu_itext_t* it,
|
||||
int x,
|
||||
int y,
|
||||
patch_t** font,
|
||||
int startchar,
|
||||
boolean* on );
|
||||
|
||||
// enforces left margin
|
||||
void HUlib_delCharFromIText(hu_itext_t* it);
|
||||
|
||||
// enforces left margin
|
||||
void HUlib_eraseLineFromIText(hu_itext_t* it);
|
||||
|
||||
// resets line and left margin
|
||||
void HUlib_resetIText(hu_itext_t* it);
|
||||
|
||||
// left of left-margin
|
||||
void
|
||||
HUlib_addPrefixToIText
|
||||
( hu_itext_t* it,
|
||||
char* str );
|
||||
|
||||
// whether eaten
|
||||
boolean
|
||||
HUlib_keyInIText
|
||||
( hu_itext_t* it,
|
||||
unsigned char ch );
|
||||
|
||||
void HUlib_drawIText(hu_itext_t* it);
|
||||
|
||||
// erases all itext lines
|
||||
void HUlib_eraseIText(hu_itext_t* it);
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,759 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION: Heads-up displays
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: hu_stuff.c,v 1.4 1997/02/03 16:47:52 b1 Exp $";
|
||||
|
||||
#include <ctype.h>
|
||||
|
||||
#include "doomdef.h"
|
||||
|
||||
#include "z_zone.h"
|
||||
|
||||
#include "m_swap.h"
|
||||
|
||||
#include "hu_stuff.h"
|
||||
#include "hu_lib.h"
|
||||
#include "w_wad.h"
|
||||
|
||||
#include "s_sound.h"
|
||||
|
||||
#include "doomstat.h"
|
||||
|
||||
// Data.
|
||||
#include "dstrings.h"
|
||||
#include "sounds.h"
|
||||
|
||||
//
|
||||
// Locally used constants, shortcuts.
|
||||
//
|
||||
#define HU_TITLE (mapnames[(gameepisode-1)*9+gamemap-1])
|
||||
#define HU_TITLE2 (mapnames2[gamemap-1])
|
||||
#define HU_TITLEP (mapnamesp[gamemap-1])
|
||||
#define HU_TITLET (mapnamest[gamemap-1])
|
||||
#define HU_TITLEHEIGHT 1
|
||||
#define HU_TITLEX 0
|
||||
#define HU_TITLEY (167 - SHORT(hu_font[0]->height))
|
||||
|
||||
#define HU_INPUTTOGGLE 't'
|
||||
#define HU_INPUTX HU_MSGX
|
||||
#define HU_INPUTY (HU_MSGY + HU_MSGHEIGHT*(SHORT(hu_font[0]->height) +1))
|
||||
#define HU_INPUTWIDTH 64
|
||||
#define HU_INPUTHEIGHT 1
|
||||
|
||||
|
||||
|
||||
char* chat_macros[] =
|
||||
{
|
||||
HUSTR_CHATMACRO0,
|
||||
HUSTR_CHATMACRO1,
|
||||
HUSTR_CHATMACRO2,
|
||||
HUSTR_CHATMACRO3,
|
||||
HUSTR_CHATMACRO4,
|
||||
HUSTR_CHATMACRO5,
|
||||
HUSTR_CHATMACRO6,
|
||||
HUSTR_CHATMACRO7,
|
||||
HUSTR_CHATMACRO8,
|
||||
HUSTR_CHATMACRO9
|
||||
};
|
||||
|
||||
char* player_names[] =
|
||||
{
|
||||
HUSTR_PLRGREEN,
|
||||
HUSTR_PLRINDIGO,
|
||||
HUSTR_PLRBROWN,
|
||||
HUSTR_PLRRED
|
||||
};
|
||||
|
||||
|
||||
char chat_char; // remove later.
|
||||
static player_t* plr;
|
||||
patch_t* hu_font[HU_FONTSIZE];
|
||||
static hu_textline_t w_title;
|
||||
boolean chat_on;
|
||||
static hu_itext_t w_chat;
|
||||
static boolean always_off = false;
|
||||
static char chat_dest[MAXPLAYERS];
|
||||
static hu_itext_t w_inputbuffer[MAXPLAYERS];
|
||||
|
||||
static boolean message_on;
|
||||
boolean message_dontfuckwithme;
|
||||
static boolean message_nottobefuckedwith;
|
||||
|
||||
static hu_stext_t w_message;
|
||||
static int message_counter;
|
||||
|
||||
extern int showMessages;
|
||||
extern boolean automapactive;
|
||||
|
||||
static boolean headsupactive = false;
|
||||
|
||||
//
|
||||
// Builtin map names.
|
||||
// The actual names can be found in DStrings.h.
|
||||
//
|
||||
|
||||
char* mapnames[] = // DOOM shareware/registered/retail (Ultimate) names.
|
||||
{
|
||||
|
||||
HUSTR_E1M1,
|
||||
HUSTR_E1M2,
|
||||
HUSTR_E1M3,
|
||||
HUSTR_E1M4,
|
||||
HUSTR_E1M5,
|
||||
HUSTR_E1M6,
|
||||
HUSTR_E1M7,
|
||||
HUSTR_E1M8,
|
||||
HUSTR_E1M9,
|
||||
|
||||
HUSTR_E2M1,
|
||||
HUSTR_E2M2,
|
||||
HUSTR_E2M3,
|
||||
HUSTR_E2M4,
|
||||
HUSTR_E2M5,
|
||||
HUSTR_E2M6,
|
||||
HUSTR_E2M7,
|
||||
HUSTR_E2M8,
|
||||
HUSTR_E2M9,
|
||||
|
||||
HUSTR_E3M1,
|
||||
HUSTR_E3M2,
|
||||
HUSTR_E3M3,
|
||||
HUSTR_E3M4,
|
||||
HUSTR_E3M5,
|
||||
HUSTR_E3M6,
|
||||
HUSTR_E3M7,
|
||||
HUSTR_E3M8,
|
||||
HUSTR_E3M9,
|
||||
|
||||
HUSTR_E4M1,
|
||||
HUSTR_E4M2,
|
||||
HUSTR_E4M3,
|
||||
HUSTR_E4M4,
|
||||
HUSTR_E4M5,
|
||||
HUSTR_E4M6,
|
||||
HUSTR_E4M7,
|
||||
HUSTR_E4M8,
|
||||
HUSTR_E4M9,
|
||||
|
||||
"NEWLEVEL",
|
||||
"NEWLEVEL",
|
||||
"NEWLEVEL",
|
||||
"NEWLEVEL",
|
||||
"NEWLEVEL",
|
||||
"NEWLEVEL",
|
||||
"NEWLEVEL",
|
||||
"NEWLEVEL",
|
||||
"NEWLEVEL"
|
||||
};
|
||||
|
||||
char* mapnames2[] = // DOOM 2 map names.
|
||||
{
|
||||
HUSTR_1,
|
||||
HUSTR_2,
|
||||
HUSTR_3,
|
||||
HUSTR_4,
|
||||
HUSTR_5,
|
||||
HUSTR_6,
|
||||
HUSTR_7,
|
||||
HUSTR_8,
|
||||
HUSTR_9,
|
||||
HUSTR_10,
|
||||
HUSTR_11,
|
||||
|
||||
HUSTR_12,
|
||||
HUSTR_13,
|
||||
HUSTR_14,
|
||||
HUSTR_15,
|
||||
HUSTR_16,
|
||||
HUSTR_17,
|
||||
HUSTR_18,
|
||||
HUSTR_19,
|
||||
HUSTR_20,
|
||||
|
||||
HUSTR_21,
|
||||
HUSTR_22,
|
||||
HUSTR_23,
|
||||
HUSTR_24,
|
||||
HUSTR_25,
|
||||
HUSTR_26,
|
||||
HUSTR_27,
|
||||
HUSTR_28,
|
||||
HUSTR_29,
|
||||
HUSTR_30,
|
||||
HUSTR_31,
|
||||
HUSTR_32
|
||||
};
|
||||
|
||||
|
||||
char* mapnamesp[] = // Plutonia WAD map names.
|
||||
{
|
||||
PHUSTR_1,
|
||||
PHUSTR_2,
|
||||
PHUSTR_3,
|
||||
PHUSTR_4,
|
||||
PHUSTR_5,
|
||||
PHUSTR_6,
|
||||
PHUSTR_7,
|
||||
PHUSTR_8,
|
||||
PHUSTR_9,
|
||||
PHUSTR_10,
|
||||
PHUSTR_11,
|
||||
|
||||
PHUSTR_12,
|
||||
PHUSTR_13,
|
||||
PHUSTR_14,
|
||||
PHUSTR_15,
|
||||
PHUSTR_16,
|
||||
PHUSTR_17,
|
||||
PHUSTR_18,
|
||||
PHUSTR_19,
|
||||
PHUSTR_20,
|
||||
|
||||
PHUSTR_21,
|
||||
PHUSTR_22,
|
||||
PHUSTR_23,
|
||||
PHUSTR_24,
|
||||
PHUSTR_25,
|
||||
PHUSTR_26,
|
||||
PHUSTR_27,
|
||||
PHUSTR_28,
|
||||
PHUSTR_29,
|
||||
PHUSTR_30,
|
||||
PHUSTR_31,
|
||||
PHUSTR_32
|
||||
};
|
||||
|
||||
|
||||
char *mapnamest[] = // TNT WAD map names.
|
||||
{
|
||||
THUSTR_1,
|
||||
THUSTR_2,
|
||||
THUSTR_3,
|
||||
THUSTR_4,
|
||||
THUSTR_5,
|
||||
THUSTR_6,
|
||||
THUSTR_7,
|
||||
THUSTR_8,
|
||||
THUSTR_9,
|
||||
THUSTR_10,
|
||||
THUSTR_11,
|
||||
|
||||
THUSTR_12,
|
||||
THUSTR_13,
|
||||
THUSTR_14,
|
||||
THUSTR_15,
|
||||
THUSTR_16,
|
||||
THUSTR_17,
|
||||
THUSTR_18,
|
||||
THUSTR_19,
|
||||
THUSTR_20,
|
||||
|
||||
THUSTR_21,
|
||||
THUSTR_22,
|
||||
THUSTR_23,
|
||||
THUSTR_24,
|
||||
THUSTR_25,
|
||||
THUSTR_26,
|
||||
THUSTR_27,
|
||||
THUSTR_28,
|
||||
THUSTR_29,
|
||||
THUSTR_30,
|
||||
THUSTR_31,
|
||||
THUSTR_32
|
||||
};
|
||||
|
||||
|
||||
const char* shiftxform;
|
||||
|
||||
const char french_shiftxform[] =
|
||||
{
|
||||
0,
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
|
||||
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
|
||||
21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
|
||||
31,
|
||||
' ', '!', '"', '#', '$', '%', '&',
|
||||
'"', // shift-'
|
||||
'(', ')', '*', '+',
|
||||
'?', // shift-,
|
||||
'_', // shift--
|
||||
'>', // shift-.
|
||||
'?', // shift-/
|
||||
'0', // shift-0
|
||||
'1', // shift-1
|
||||
'2', // shift-2
|
||||
'3', // shift-3
|
||||
'4', // shift-4
|
||||
'5', // shift-5
|
||||
'6', // shift-6
|
||||
'7', // shift-7
|
||||
'8', // shift-8
|
||||
'9', // shift-9
|
||||
'/',
|
||||
'.', // shift-;
|
||||
'<',
|
||||
'+', // shift-=
|
||||
'>', '?', '@',
|
||||
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
|
||||
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
|
||||
'[', // shift-[
|
||||
'!', // shift-backslash - OH MY GOD DOES WATCOM SUCK
|
||||
']', // shift-]
|
||||
'"', '_',
|
||||
'\'', // shift-`
|
||||
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
|
||||
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
|
||||
'{', '|', '}', '~', 127
|
||||
|
||||
};
|
||||
|
||||
const char english_shiftxform[] =
|
||||
{
|
||||
|
||||
0,
|
||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
|
||||
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
|
||||
21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
|
||||
31,
|
||||
' ', '!', '"', '#', '$', '%', '&',
|
||||
'"', // shift-'
|
||||
'(', ')', '*', '+',
|
||||
'<', // shift-,
|
||||
'_', // shift--
|
||||
'>', // shift-.
|
||||
'?', // shift-/
|
||||
')', // shift-0
|
||||
'!', // shift-1
|
||||
'@', // shift-2
|
||||
'#', // shift-3
|
||||
'$', // shift-4
|
||||
'%', // shift-5
|
||||
'^', // shift-6
|
||||
'&', // shift-7
|
||||
'*', // shift-8
|
||||
'(', // shift-9
|
||||
':',
|
||||
':', // shift-;
|
||||
'<',
|
||||
'+', // shift-=
|
||||
'>', '?', '@',
|
||||
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
|
||||
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
|
||||
'[', // shift-[
|
||||
'!', // shift-backslash - OH MY GOD DOES WATCOM SUCK
|
||||
']', // shift-]
|
||||
'"', '_',
|
||||
'\'', // shift-`
|
||||
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
|
||||
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
|
||||
'{', '|', '}', '~', 127
|
||||
};
|
||||
|
||||
char frenchKeyMap[128]=
|
||||
{
|
||||
0,
|
||||
1,2,3,4,5,6,7,8,9,10,
|
||||
11,12,13,14,15,16,17,18,19,20,
|
||||
21,22,23,24,25,26,27,28,29,30,
|
||||
31,
|
||||
' ','!','"','#','$','%','&','%','(',')','*','+',';','-',':','!',
|
||||
'0','1','2','3','4','5','6','7','8','9',':','M','<','=','>','?',
|
||||
'@','Q','B','C','D','E','F','G','H','I','J','K','L',',','N','O',
|
||||
'P','A','R','S','T','U','V','Z','X','Y','W','^','\\','$','^','_',
|
||||
'@','Q','B','C','D','E','F','G','H','I','J','K','L',',','N','O',
|
||||
'P','A','R','S','T','U','V','Z','X','Y','W','^','\\','$','^',127
|
||||
};
|
||||
|
||||
char ForeignTranslation(unsigned char ch)
|
||||
{
|
||||
return ch < 128 ? frenchKeyMap[ch] : ch;
|
||||
}
|
||||
|
||||
void HU_Init(void)
|
||||
{
|
||||
|
||||
int i;
|
||||
int j;
|
||||
char buffer[9];
|
||||
|
||||
if (french)
|
||||
shiftxform = french_shiftxform;
|
||||
else
|
||||
shiftxform = english_shiftxform;
|
||||
|
||||
// load the heads-up font
|
||||
j = HU_FONTSTART;
|
||||
for (i=0;i<HU_FONTSIZE;i++)
|
||||
{
|
||||
sprintf(buffer, "STCFN%.3d", j++);
|
||||
hu_font[i] = (patch_t *) W_CacheLumpName(buffer, PU_STATIC);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void HU_Stop(void)
|
||||
{
|
||||
headsupactive = false;
|
||||
}
|
||||
|
||||
void HU_Start(void)
|
||||
{
|
||||
|
||||
int i;
|
||||
char* s;
|
||||
|
||||
if (headsupactive)
|
||||
HU_Stop();
|
||||
|
||||
plr = &players[consoleplayer];
|
||||
message_on = false;
|
||||
message_dontfuckwithme = false;
|
||||
message_nottobefuckedwith = false;
|
||||
chat_on = false;
|
||||
|
||||
// create the message widget
|
||||
HUlib_initSText(&w_message,
|
||||
HU_MSGX, HU_MSGY, HU_MSGHEIGHT,
|
||||
hu_font,
|
||||
HU_FONTSTART, &message_on);
|
||||
|
||||
// create the map title widget
|
||||
HUlib_initTextLine(&w_title,
|
||||
HU_TITLEX, HU_TITLEY,
|
||||
hu_font,
|
||||
HU_FONTSTART);
|
||||
|
||||
switch ( gamemode )
|
||||
{
|
||||
case shareware:
|
||||
case registered:
|
||||
case retail:
|
||||
s = HU_TITLE;
|
||||
break;
|
||||
|
||||
/* FIXME
|
||||
case pack_plut:
|
||||
s = HU_TITLEP;
|
||||
break;
|
||||
case pack_tnt:
|
||||
s = HU_TITLET;
|
||||
break;
|
||||
*/
|
||||
|
||||
case commercial:
|
||||
default:
|
||||
s = HU_TITLE2;
|
||||
break;
|
||||
}
|
||||
|
||||
while (*s)
|
||||
HUlib_addCharToTextLine(&w_title, *(s++));
|
||||
|
||||
// create the chat widget
|
||||
HUlib_initIText(&w_chat,
|
||||
HU_INPUTX, HU_INPUTY,
|
||||
hu_font,
|
||||
HU_FONTSTART, &chat_on);
|
||||
|
||||
// create the inputbuffer widgets
|
||||
for (i=0 ; i<MAXPLAYERS ; i++)
|
||||
HUlib_initIText(&w_inputbuffer[i], 0, 0, 0, 0, &always_off);
|
||||
|
||||
headsupactive = true;
|
||||
|
||||
}
|
||||
|
||||
void HU_Drawer(void)
|
||||
{
|
||||
|
||||
HUlib_drawSText(&w_message);
|
||||
HUlib_drawIText(&w_chat);
|
||||
if (automapactive)
|
||||
HUlib_drawTextLine(&w_title, false);
|
||||
|
||||
}
|
||||
|
||||
void HU_Erase(void)
|
||||
{
|
||||
|
||||
HUlib_eraseSText(&w_message);
|
||||
HUlib_eraseIText(&w_chat);
|
||||
HUlib_eraseTextLine(&w_title);
|
||||
|
||||
}
|
||||
|
||||
void HU_Ticker(void)
|
||||
{
|
||||
|
||||
int i, rc;
|
||||
char c;
|
||||
|
||||
// tick down message counter if message is up
|
||||
if (message_counter && !--message_counter)
|
||||
{
|
||||
message_on = false;
|
||||
message_nottobefuckedwith = false;
|
||||
}
|
||||
|
||||
if (showMessages || message_dontfuckwithme)
|
||||
{
|
||||
|
||||
// display message if necessary
|
||||
if ((plr->message && !message_nottobefuckedwith)
|
||||
|| (plr->message && message_dontfuckwithme))
|
||||
{
|
||||
HUlib_addMessageToSText(&w_message, 0, plr->message);
|
||||
plr->message = 0;
|
||||
message_on = true;
|
||||
message_counter = HU_MSGTIMEOUT;
|
||||
message_nottobefuckedwith = message_dontfuckwithme;
|
||||
message_dontfuckwithme = 0;
|
||||
}
|
||||
|
||||
} // else message_on = false;
|
||||
|
||||
// check for incoming chat characters
|
||||
if (netgame)
|
||||
{
|
||||
for (i=0 ; i<MAXPLAYERS; i++)
|
||||
{
|
||||
if (!playeringame[i])
|
||||
continue;
|
||||
if (i != consoleplayer
|
||||
&& (c = players[i].cmd.chatchar))
|
||||
{
|
||||
if (c <= HU_BROADCAST)
|
||||
chat_dest[i] = c;
|
||||
else
|
||||
{
|
||||
if (c >= 'a' && c <= 'z')
|
||||
c = (char) shiftxform[(unsigned char) c];
|
||||
rc = HUlib_keyInIText(&w_inputbuffer[i], c);
|
||||
if (rc && c == KEY_ENTER)
|
||||
{
|
||||
if (w_inputbuffer[i].l.len
|
||||
&& (chat_dest[i] == consoleplayer+1
|
||||
|| chat_dest[i] == HU_BROADCAST))
|
||||
{
|
||||
HUlib_addMessageToSText(&w_message,
|
||||
player_names[i],
|
||||
w_inputbuffer[i].l.l);
|
||||
|
||||
message_nottobefuckedwith = true;
|
||||
message_on = true;
|
||||
message_counter = HU_MSGTIMEOUT;
|
||||
if ( gamemode == commercial )
|
||||
S_StartSound(0, sfx_radio);
|
||||
else
|
||||
S_StartSound(0, sfx_tink);
|
||||
}
|
||||
HUlib_resetIText(&w_inputbuffer[i]);
|
||||
}
|
||||
}
|
||||
players[i].cmd.chatchar = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#define QUEUESIZE 128
|
||||
|
||||
static char chatchars[QUEUESIZE];
|
||||
static int head = 0;
|
||||
static int tail = 0;
|
||||
|
||||
|
||||
void HU_queueChatChar(char c)
|
||||
{
|
||||
if (((head + 1) & (QUEUESIZE-1)) == tail)
|
||||
{
|
||||
plr->message = HUSTR_MSGU;
|
||||
}
|
||||
else
|
||||
{
|
||||
chatchars[head] = c;
|
||||
head = (head + 1) & (QUEUESIZE-1);
|
||||
}
|
||||
}
|
||||
|
||||
char HU_dequeueChatChar(void)
|
||||
{
|
||||
char c;
|
||||
|
||||
if (head != tail)
|
||||
{
|
||||
c = chatchars[tail];
|
||||
tail = (tail + 1) & (QUEUESIZE-1);
|
||||
}
|
||||
else
|
||||
{
|
||||
c = 0;
|
||||
}
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
boolean HU_Responder(event_t *ev)
|
||||
{
|
||||
|
||||
static char lastmessage[HU_MAXLINELENGTH+1];
|
||||
char* macromessage;
|
||||
boolean eatkey = false;
|
||||
static boolean shiftdown = false;
|
||||
static boolean altdown = false;
|
||||
unsigned char c;
|
||||
int i;
|
||||
int numplayers;
|
||||
|
||||
static char destination_keys[MAXPLAYERS] =
|
||||
{
|
||||
HUSTR_KEYGREEN,
|
||||
HUSTR_KEYINDIGO,
|
||||
HUSTR_KEYBROWN,
|
||||
HUSTR_KEYRED
|
||||
};
|
||||
|
||||
static int num_nobrainers = 0;
|
||||
|
||||
numplayers = 0;
|
||||
for (i=0 ; i<MAXPLAYERS ; i++)
|
||||
numplayers += playeringame[i];
|
||||
|
||||
if (ev->data1 == KEY_RSHIFT)
|
||||
{
|
||||
shiftdown = ev->type == ev_keydown;
|
||||
return false;
|
||||
}
|
||||
else if (ev->data1 == KEY_RALT || ev->data1 == KEY_LALT)
|
||||
{
|
||||
altdown = ev->type == ev_keydown;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (ev->type != ev_keydown)
|
||||
return false;
|
||||
|
||||
if (!chat_on)
|
||||
{
|
||||
if (ev->data1 == HU_MSGREFRESH)
|
||||
{
|
||||
message_on = true;
|
||||
message_counter = HU_MSGTIMEOUT;
|
||||
eatkey = true;
|
||||
}
|
||||
else if (netgame && ev->data1 == HU_INPUTTOGGLE)
|
||||
{
|
||||
eatkey = chat_on = true;
|
||||
HUlib_resetIText(&w_chat);
|
||||
HU_queueChatChar(HU_BROADCAST);
|
||||
}
|
||||
else if (netgame && numplayers > 2)
|
||||
{
|
||||
for (i=0; i<MAXPLAYERS ; i++)
|
||||
{
|
||||
if (ev->data1 == destination_keys[i])
|
||||
{
|
||||
if (playeringame[i] && i!=consoleplayer)
|
||||
{
|
||||
eatkey = chat_on = true;
|
||||
HUlib_resetIText(&w_chat);
|
||||
HU_queueChatChar(i+1);
|
||||
break;
|
||||
}
|
||||
else if (i == consoleplayer)
|
||||
{
|
||||
num_nobrainers++;
|
||||
if (num_nobrainers < 3)
|
||||
plr->message = HUSTR_TALKTOSELF1;
|
||||
else if (num_nobrainers < 6)
|
||||
plr->message = HUSTR_TALKTOSELF2;
|
||||
else if (num_nobrainers < 9)
|
||||
plr->message = HUSTR_TALKTOSELF3;
|
||||
else if (num_nobrainers < 32)
|
||||
plr->message = HUSTR_TALKTOSELF4;
|
||||
else
|
||||
plr->message = HUSTR_TALKTOSELF5;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
c = ev->data1;
|
||||
// send a macro
|
||||
if (altdown)
|
||||
{
|
||||
c = c - '0';
|
||||
if (c > 9)
|
||||
return false;
|
||||
// fprintf(stderr, "got here\n");
|
||||
macromessage = chat_macros[c];
|
||||
|
||||
// kill last message with a '\n'
|
||||
HU_queueChatChar(KEY_ENTER); // DEBUG!!!
|
||||
|
||||
// send the macro message
|
||||
while (*macromessage)
|
||||
HU_queueChatChar(*macromessage++);
|
||||
HU_queueChatChar(KEY_ENTER);
|
||||
|
||||
// leave chat mode and notify that it was sent
|
||||
chat_on = false;
|
||||
strcpy(lastmessage, chat_macros[c]);
|
||||
plr->message = lastmessage;
|
||||
eatkey = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (french)
|
||||
c = ForeignTranslation(c);
|
||||
if (shiftdown || (c >= 'a' && c <= 'z'))
|
||||
c = shiftxform[c];
|
||||
eatkey = HUlib_keyInIText(&w_chat, c);
|
||||
if (eatkey)
|
||||
{
|
||||
// static unsigned char buf[20]; // DEBUG
|
||||
HU_queueChatChar(c);
|
||||
|
||||
// sprintf(buf, "KEY: %d => %d", ev->data1, c);
|
||||
// plr->message = buf;
|
||||
}
|
||||
if (c == KEY_ENTER)
|
||||
{
|
||||
chat_on = false;
|
||||
if (w_chat.l.len)
|
||||
{
|
||||
strcpy(lastmessage, w_chat.l.l);
|
||||
plr->message = lastmessage;
|
||||
}
|
||||
}
|
||||
else if (c == KEY_ESCAPE)
|
||||
chat_on = false;
|
||||
}
|
||||
}
|
||||
|
||||
return eatkey;
|
||||
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION: Head up display
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __HU_STUFF_H__
|
||||
#define __HU_STUFF_H__
|
||||
|
||||
#include "d_event.h"
|
||||
|
||||
|
||||
//
|
||||
// Globally visible constants.
|
||||
//
|
||||
#define HU_FONTSTART '!' // the first font characters
|
||||
#define HU_FONTEND '_' // the last font characters
|
||||
|
||||
// Calculate # of glyphs in font.
|
||||
#define HU_FONTSIZE (HU_FONTEND - HU_FONTSTART + 1)
|
||||
|
||||
#define HU_BROADCAST 5
|
||||
|
||||
#define HU_MSGREFRESH KEY_ENTER
|
||||
#define HU_MSGX 0
|
||||
#define HU_MSGY 0
|
||||
#define HU_MSGWIDTH 64 // in characters
|
||||
#define HU_MSGHEIGHT 1 // in lines
|
||||
|
||||
#define HU_MSGTIMEOUT (4*TICRATE)
|
||||
|
||||
//
|
||||
// HEADS UP TEXT
|
||||
//
|
||||
|
||||
void HU_Init(void);
|
||||
void HU_Start(void);
|
||||
|
||||
boolean HU_Responder(event_t* ev);
|
||||
|
||||
void HU_Ticker(void);
|
||||
void HU_Drawer(void);
|
||||
char HU_dequeueChatChar(void);
|
||||
void HU_Erase(void);
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,45 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// System specific network interface stuff.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __I_NET__
|
||||
#define __I_NET__
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
// Called by D_DoomMain.
|
||||
|
||||
|
||||
void I_InitNetwork (void);
|
||||
void I_NetCmd (void);
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,111 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// System interface, sound.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef __I_SOUND__
|
||||
#define __I_SOUND__
|
||||
|
||||
#include "doomdef.h"
|
||||
|
||||
#include "doomstat.h"
|
||||
#include "sounds.h"
|
||||
|
||||
|
||||
|
||||
// Init at program start...
|
||||
void I_InitSound();
|
||||
|
||||
// ... shut down and relase at program termination.
|
||||
void I_ShutdownSound(void);
|
||||
|
||||
|
||||
//
|
||||
// SFX I/O
|
||||
//
|
||||
|
||||
// Initialize channels?
|
||||
void I_SetChannels();
|
||||
|
||||
// Get raw data lump index for sound descriptor.
|
||||
int I_GetSfxLumpNum (sfxinfo_t* sfxinfo );
|
||||
|
||||
|
||||
// Starts a sound in a particular sound channel.
|
||||
int
|
||||
I_StartSound
|
||||
( int id,
|
||||
int vol,
|
||||
int sep,
|
||||
int pitch,
|
||||
int priority );
|
||||
|
||||
|
||||
// Stops a sound channel.
|
||||
void I_StopSound(int handle);
|
||||
|
||||
// Called by S_*() functions
|
||||
// to see if a channel is still playing.
|
||||
// Returns 0 if no longer playing, 1 if playing.
|
||||
int I_SoundIsPlaying(int handle);
|
||||
|
||||
// Updates the volume, separation,
|
||||
// and pitch of a sound channel.
|
||||
void
|
||||
I_UpdateSoundParams
|
||||
( int handle,
|
||||
int vol,
|
||||
int sep,
|
||||
int pitch );
|
||||
|
||||
|
||||
//
|
||||
// MUSIC I/O
|
||||
//
|
||||
void I_InitMusic(void);
|
||||
void I_ShutdownMusic(void);
|
||||
// Volume.
|
||||
void I_SetMusicVolume(int volume);
|
||||
// PAUSE game handling.
|
||||
void I_PauseSong(int handle);
|
||||
void I_ResumeSong(int handle);
|
||||
// Registers a song handle to song data.
|
||||
int I_RegisterSong(void *data);
|
||||
// Called by anything that wishes to start music.
|
||||
// plays a song, and when the song is done,
|
||||
// starts playing it again in an endless loop.
|
||||
// Horrible thing to do, considering.
|
||||
void
|
||||
I_PlaySong
|
||||
( int handle,
|
||||
int looping );
|
||||
// Stops a song over 3 seconds.
|
||||
void I_StopSong(int handle);
|
||||
// See above (register), then think backwards
|
||||
void I_UnRegisterSong(int handle);
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,106 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// System specific interface stuff.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __I_SYSTEM__
|
||||
#define __I_SYSTEM__
|
||||
|
||||
#include "d_ticcmd.h"
|
||||
#include "d_event.h"
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
// Called by DoomMain.
|
||||
void I_Init (void);
|
||||
|
||||
// Called by startup code
|
||||
// to get the ammount of memory to malloc
|
||||
// for the zone management.
|
||||
byte* I_ZoneBase (int *size);
|
||||
|
||||
|
||||
// Called by D_DoomLoop,
|
||||
// returns current time in tics.
|
||||
int I_GetTime (void);
|
||||
|
||||
|
||||
//
|
||||
// Called by D_DoomLoop,
|
||||
// called before processing any tics in a frame
|
||||
// (just after displaying a frame).
|
||||
// Time consuming syncronous operations
|
||||
// are performed here (joystick reading).
|
||||
// Can call D_PostEvent.
|
||||
//
|
||||
void I_StartFrame (void);
|
||||
|
||||
|
||||
//
|
||||
// Called by D_DoomLoop,
|
||||
// called before processing each tic in a frame.
|
||||
// Quick syncronous operations are performed here.
|
||||
// Can call D_PostEvent.
|
||||
void I_StartTic (void);
|
||||
|
||||
// Asynchronous interrupt functions should maintain private queues
|
||||
// that are read by the synchronous functions
|
||||
// to be converted into events.
|
||||
|
||||
// Either returns a null ticcmd,
|
||||
// or calls a loadable driver to build it.
|
||||
// This ticcmd will then be modified by the gameloop
|
||||
// for normal input.
|
||||
ticcmd_t* I_BaseTiccmd (void);
|
||||
|
||||
|
||||
// Called by M_Responder when quit is selected.
|
||||
// Clean exit, displays sell blurb.
|
||||
void I_Quit (void);
|
||||
|
||||
|
||||
// Allocates from low memory under dos,
|
||||
// just mallocs under unix
|
||||
byte* I_AllocLow (int length);
|
||||
|
||||
void I_Tactile (int on, int off, int total);
|
||||
|
||||
|
||||
void I_Error (char *error, ...) __attribute__((noreturn));
|
||||
|
||||
// NULL-terminated list of directories searched for IWADs.
|
||||
char** I_GetWadDirs (void);
|
||||
|
||||
// Directory for the config file and save games.
|
||||
char* I_GetSaveDir (void);
|
||||
|
||||
// True when the player asked for the Doom 1 style game at startup.
|
||||
boolean I_PreferDoom1 (void);
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,61 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// System specific interface stuff.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __I_VIDEO__
|
||||
#define __I_VIDEO__
|
||||
|
||||
|
||||
#include "doomtype.h"
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
// Called by D_DoomMain,
|
||||
// determines the hardware configuration
|
||||
// and sets up the video mode
|
||||
void I_InitGraphics (void);
|
||||
|
||||
|
||||
void I_ShutdownGraphics(void);
|
||||
|
||||
// Takes full 8 bit values.
|
||||
void I_SetPalette (byte* palette);
|
||||
|
||||
void I_UpdateNoBlit (void);
|
||||
void I_FinishUpdate (void);
|
||||
|
||||
// Wait for vertical retrace or pause a bit.
|
||||
void I_WaitVBL(int count);
|
||||
|
||||
void I_ReadScreen (byte* scr);
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
+4670
File diff suppressed because it is too large.
Load diff
+1340
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,56 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: m_argv.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
|
||||
|
||||
|
||||
#include <string.h>
|
||||
|
||||
int myargc;
|
||||
char** myargv;
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// M_CheckParm
|
||||
// Checks for the given parameter
|
||||
// in the program's command line arguments.
|
||||
// Returns the argument number (1 to argc-1)
|
||||
// or 0 if not present
|
||||
int M_CheckParm (char *check)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 1;i<myargc;i++)
|
||||
{
|
||||
if ( !strcasecmp(check, myargv[i]) )
|
||||
return i;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,42 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Nil.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __M_ARGV__
|
||||
#define __M_ARGV__
|
||||
|
||||
//
|
||||
// MISC
|
||||
//
|
||||
extern int myargc;
|
||||
extern char** myargv;
|
||||
|
||||
// Returns the position of the given parameter
|
||||
// in the arg list (0 if not found).
|
||||
int M_CheckParm (char* check);
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,64 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Main loop menu stuff.
|
||||
// Random number LUT.
|
||||
// Default Config File.
|
||||
// PCX Screenshots.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "m_bbox.h"
|
||||
#endif
|
||||
#include "m_bbox.h"
|
||||
|
||||
|
||||
|
||||
|
||||
void M_ClearBox (fixed_t *box)
|
||||
{
|
||||
box[BOXTOP] = box[BOXRIGHT] = MININT;
|
||||
box[BOXBOTTOM] = box[BOXLEFT] = MAXINT;
|
||||
}
|
||||
|
||||
void
|
||||
M_AddToBox
|
||||
( fixed_t* box,
|
||||
fixed_t x,
|
||||
fixed_t y )
|
||||
{
|
||||
if (x<box[BOXLEFT])
|
||||
box[BOXLEFT] = x;
|
||||
else if (x>box[BOXRIGHT])
|
||||
box[BOXRIGHT] = x;
|
||||
if (y<box[BOXBOTTOM])
|
||||
box[BOXBOTTOM] = y;
|
||||
else if (y>box[BOXTOP])
|
||||
box[BOXTOP] = y;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Nil.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __M_BBOX__
|
||||
#define __M_BBOX__
|
||||
|
||||
#include "doomtype.h"
|
||||
|
||||
#include "m_fixed.h"
|
||||
|
||||
|
||||
// Bounding box coordinate storage.
|
||||
enum
|
||||
{
|
||||
BOXTOP,
|
||||
BOXBOTTOM,
|
||||
BOXLEFT,
|
||||
BOXRIGHT
|
||||
}; // bbox coordinates
|
||||
|
||||
// Bounding box functions.
|
||||
void M_ClearBox (fixed_t* box);
|
||||
|
||||
void
|
||||
M_AddToBox
|
||||
( fixed_t* box,
|
||||
fixed_t x,
|
||||
fixed_t y );
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,101 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Cheat sequence checking.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: m_cheat.c,v 1.1 1997/02/03 21:24:34 b1 Exp $";
|
||||
|
||||
#include "m_cheat.h"
|
||||
|
||||
//
|
||||
// CHEAT SEQUENCE PACKAGE
|
||||
//
|
||||
|
||||
static int firsttime = 1;
|
||||
static unsigned char cheat_xlate_table[256];
|
||||
|
||||
|
||||
//
|
||||
// Called in st_stuff module, which handles the input.
|
||||
// Returns a 1 if the cheat was successful, 0 if failed.
|
||||
//
|
||||
int
|
||||
cht_CheckCheat
|
||||
( cheatseq_t* cht,
|
||||
char key )
|
||||
{
|
||||
int i;
|
||||
int rc = 0;
|
||||
|
||||
if (firsttime)
|
||||
{
|
||||
firsttime = 0;
|
||||
for (i=0;i<256;i++) cheat_xlate_table[i] = SCRAMBLE(i);
|
||||
}
|
||||
|
||||
if (!cht->p)
|
||||
cht->p = cht->sequence; // initialize if first time
|
||||
|
||||
if (*cht->p == 0)
|
||||
*(cht->p++) = key;
|
||||
else if
|
||||
(cheat_xlate_table[(unsigned char)key] == *cht->p) cht->p++;
|
||||
else
|
||||
cht->p = cht->sequence;
|
||||
|
||||
if (*cht->p == 1)
|
||||
cht->p++;
|
||||
else if (*cht->p == 0xff) // end of sequence character
|
||||
{
|
||||
cht->p = cht->sequence;
|
||||
rc = 1;
|
||||
}
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
void
|
||||
cht_GetParam
|
||||
( cheatseq_t* cht,
|
||||
char* buffer )
|
||||
{
|
||||
|
||||
unsigned char *p, c;
|
||||
|
||||
p = cht->sequence;
|
||||
while (*(p++) != 1);
|
||||
|
||||
do
|
||||
{
|
||||
c = *p;
|
||||
*(buffer++) = c;
|
||||
*(p++) = 0;
|
||||
}
|
||||
while (c && *p!=0xff );
|
||||
|
||||
if (*p==0xff)
|
||||
*buffer = 0;
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Cheat code checking.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __M_CHEAT__
|
||||
#define __M_CHEAT__
|
||||
|
||||
//
|
||||
// CHEAT SEQUENCE PACKAGE
|
||||
//
|
||||
|
||||
#define SCRAMBLE(a) \
|
||||
((((a)&1)<<7) + (((a)&2)<<5) + ((a)&4) + (((a)&8)<<1) \
|
||||
+ (((a)&16)>>1) + ((a)&32) + (((a)&64)>>5) + (((a)&128)>>7))
|
||||
|
||||
typedef struct
|
||||
{
|
||||
unsigned char* sequence;
|
||||
unsigned char* p;
|
||||
|
||||
} cheatseq_t;
|
||||
|
||||
int
|
||||
cht_CheckCheat
|
||||
( cheatseq_t* cht,
|
||||
char key );
|
||||
|
||||
|
||||
void
|
||||
cht_GetParam
|
||||
( cheatseq_t* cht,
|
||||
char* buffer );
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,87 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Fixed point implementation.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
|
||||
|
||||
#include "stdlib.h"
|
||||
|
||||
#include "doomtype.h"
|
||||
#include "i_system.h"
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "m_fixed.h"
|
||||
#endif
|
||||
#include "m_fixed.h"
|
||||
|
||||
|
||||
|
||||
|
||||
// Fixme. __USE_C_FIXED__ or something.
|
||||
|
||||
fixed_t
|
||||
FixedMul
|
||||
( fixed_t a,
|
||||
fixed_t b )
|
||||
{
|
||||
return ((long long) a * (long long) b) >> FRACBITS;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// FixedDiv, C version.
|
||||
//
|
||||
|
||||
fixed_t
|
||||
FixedDiv
|
||||
( fixed_t a,
|
||||
fixed_t b )
|
||||
{
|
||||
if ( (abs(a)>>14) >= abs(b))
|
||||
return (a^b)<0 ? MININT : MAXINT;
|
||||
return FixedDiv2 (a,b);
|
||||
}
|
||||
|
||||
|
||||
|
||||
fixed_t
|
||||
FixedDiv2
|
||||
( fixed_t a,
|
||||
fixed_t b )
|
||||
{
|
||||
#if 0
|
||||
long long c;
|
||||
c = ((long long)a<<16) / ((long long)b);
|
||||
return (fixed_t) c;
|
||||
#endif
|
||||
|
||||
double c;
|
||||
|
||||
c = ((double)a) / ((double)b) * FRACUNIT;
|
||||
|
||||
if (c >= 2147483648.0 || c < -2147483648.0)
|
||||
I_Error("FixedDiv: divide by zero");
|
||||
return (fixed_t) c;
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Fixed point arithemtics, implementation.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __M_FIXED__
|
||||
#define __M_FIXED__
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
//
|
||||
// Fixed point, 32bit as 16.16.
|
||||
//
|
||||
#define FRACBITS 16
|
||||
#define FRACUNIT (1<<FRACBITS)
|
||||
|
||||
typedef int fixed_t;
|
||||
|
||||
fixed_t FixedMul (fixed_t a, fixed_t b);
|
||||
fixed_t FixedDiv (fixed_t a, fixed_t b);
|
||||
fixed_t FixedDiv2 (fixed_t a, fixed_t b);
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
+1892
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,67 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Menu widget stuff, episode selection and such.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __M_MENU__
|
||||
#define __M_MENU__
|
||||
|
||||
|
||||
|
||||
#include "d_event.h"
|
||||
|
||||
//
|
||||
// MENUS
|
||||
//
|
||||
// Called by main loop,
|
||||
// saves config file and calls I_Quit when user exits.
|
||||
// Even when the menu is not displayed,
|
||||
// this can resize the view and change game parameters.
|
||||
// Does all the real work of the menu interaction.
|
||||
boolean M_Responder (event_t *ev);
|
||||
|
||||
|
||||
// Called by main loop,
|
||||
// only used for menu (skull cursor) animation.
|
||||
void M_Ticker (void);
|
||||
|
||||
// Called by main loop,
|
||||
// draws the menus directly into the screen buffer.
|
||||
void M_Drawer (void);
|
||||
|
||||
// Called by D_DoomMain,
|
||||
// loads the config file.
|
||||
void M_Init (void);
|
||||
|
||||
// Called by intro code to force menu up upon a keypress,
|
||||
// does nothing if menu is already up.
|
||||
void M_StartControlPanel (void);
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,509 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Main loop menu stuff.
|
||||
// Default Config File.
|
||||
// PCX Screenshots.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: m_misc.c,v 1.6 1997/02/03 22:45:10 b1 Exp $";
|
||||
|
||||
#include <sys/stat.h>
|
||||
#include <sys/types.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <ctype.h>
|
||||
|
||||
|
||||
#include "doomdef.h"
|
||||
|
||||
#include "z_zone.h"
|
||||
|
||||
#include "m_swap.h"
|
||||
#include "m_argv.h"
|
||||
|
||||
#include "w_wad.h"
|
||||
|
||||
#include "i_system.h"
|
||||
#include "i_video.h"
|
||||
#include "v_video.h"
|
||||
|
||||
#include "hu_stuff.h"
|
||||
|
||||
// State.
|
||||
#include "doomstat.h"
|
||||
|
||||
// Data.
|
||||
#include "dstrings.h"
|
||||
|
||||
#include "m_misc.h"
|
||||
|
||||
//
|
||||
// M_DrawText
|
||||
// Returns the final X coordinate
|
||||
// HU_Init must have been called to init the font
|
||||
//
|
||||
extern patch_t* hu_font[HU_FONTSIZE];
|
||||
|
||||
int
|
||||
M_DrawText
|
||||
( int x,
|
||||
int y,
|
||||
boolean direct,
|
||||
char* string )
|
||||
{
|
||||
int c;
|
||||
int w;
|
||||
|
||||
while (*string)
|
||||
{
|
||||
c = toupper(*string) - HU_FONTSTART;
|
||||
string++;
|
||||
if (c < 0 || c> HU_FONTSIZE)
|
||||
{
|
||||
x += 4;
|
||||
continue;
|
||||
}
|
||||
|
||||
w = SHORT (hu_font[c]->width);
|
||||
if (x+w > SCREENWIDTH)
|
||||
break;
|
||||
if (direct)
|
||||
V_DrawPatchDirect(x, y, 0, hu_font[c]);
|
||||
else
|
||||
V_DrawPatch(x, y, 0, hu_font[c]);
|
||||
x+=w;
|
||||
}
|
||||
|
||||
return x;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// M_WriteFile
|
||||
//
|
||||
#ifndef O_BINARY
|
||||
#define O_BINARY 0
|
||||
#endif
|
||||
|
||||
boolean
|
||||
M_WriteFile
|
||||
( char const* name,
|
||||
void* source,
|
||||
int length )
|
||||
{
|
||||
int handle;
|
||||
int count;
|
||||
|
||||
handle = open ( name, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
|
||||
|
||||
if (handle == -1)
|
||||
return false;
|
||||
|
||||
count = write (handle, source, length);
|
||||
close (handle);
|
||||
|
||||
if (count < length)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// M_ReadFile
|
||||
//
|
||||
int
|
||||
M_ReadFile
|
||||
( char const* name,
|
||||
byte** buffer )
|
||||
{
|
||||
int handle, count, length;
|
||||
struct stat fileinfo;
|
||||
byte *buf;
|
||||
|
||||
handle = open (name, O_RDONLY | O_BINARY, 0666);
|
||||
if (handle == -1)
|
||||
I_Error ("Couldn't read file %s", name);
|
||||
if (fstat (handle,&fileinfo) == -1)
|
||||
I_Error ("Couldn't read file %s", name);
|
||||
length = fileinfo.st_size;
|
||||
buf = Z_Malloc (length, PU_STATIC, NULL);
|
||||
count = read (handle, buf, length);
|
||||
close (handle);
|
||||
|
||||
if (count < length)
|
||||
I_Error ("Couldn't read file %s", name);
|
||||
|
||||
*buffer = buf;
|
||||
return length;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// DEFAULTS
|
||||
//
|
||||
int usemouse;
|
||||
int usejoystick;
|
||||
|
||||
extern int key_right;
|
||||
extern int key_left;
|
||||
extern int key_up;
|
||||
extern int key_down;
|
||||
|
||||
extern int key_strafeleft;
|
||||
extern int key_straferight;
|
||||
|
||||
extern int key_fire;
|
||||
extern int key_use;
|
||||
extern int key_strafe;
|
||||
extern int key_speed;
|
||||
|
||||
extern int mousebfire;
|
||||
extern int mousebstrafe;
|
||||
extern int mousebforward;
|
||||
|
||||
extern int joybfire;
|
||||
extern int joybstrafe;
|
||||
extern int joybuse;
|
||||
extern int joybspeed;
|
||||
|
||||
extern int viewwidth;
|
||||
extern int viewheight;
|
||||
|
||||
extern int mouseSensitivity;
|
||||
extern int showMessages;
|
||||
|
||||
extern int detailLevel;
|
||||
|
||||
extern int screenblocks;
|
||||
|
||||
extern int showMessages;
|
||||
|
||||
// machine-independent sound params
|
||||
extern int numChannels;
|
||||
|
||||
|
||||
extern char* chat_macros[];
|
||||
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char* name;
|
||||
int* location;
|
||||
int defaultvalue;
|
||||
char** stringlocation;
|
||||
char* stringdefault;
|
||||
} default_t;
|
||||
|
||||
default_t defaults[] =
|
||||
{
|
||||
{"mouse_sensitivity",&mouseSensitivity, 5},
|
||||
{"sfx_volume",&snd_SfxVolume, 8},
|
||||
{"music_volume",&snd_MusicVolume, 8},
|
||||
{"show_messages",&showMessages, 1},
|
||||
|
||||
{"key_right",&key_right, KEY_RIGHTARROW},
|
||||
{"key_left",&key_left, KEY_LEFTARROW},
|
||||
{"key_up",&key_up, KEY_UPARROW},
|
||||
{"key_down",&key_down, KEY_DOWNARROW},
|
||||
{"key_strafeleft",&key_strafeleft, ','},
|
||||
{"key_straferight",&key_straferight, '.'},
|
||||
|
||||
{"key_fire",&key_fire, KEY_RCTRL},
|
||||
{"key_use",&key_use, ' '},
|
||||
{"key_strafe",&key_strafe, KEY_RALT},
|
||||
{"key_speed",&key_speed, KEY_RSHIFT},
|
||||
|
||||
{"use_mouse",&usemouse, 1},
|
||||
{"mouseb_fire",&mousebfire,0},
|
||||
{"mouseb_strafe",&mousebstrafe,1},
|
||||
{"mouseb_forward",&mousebforward,2},
|
||||
|
||||
{"use_joystick",&usejoystick, 0},
|
||||
{"joyb_fire",&joybfire,0},
|
||||
{"joyb_strafe",&joybstrafe,1},
|
||||
{"joyb_use",&joybuse,3},
|
||||
{"joyb_speed",&joybspeed,2},
|
||||
|
||||
{"screenblocks",&screenblocks, 9},
|
||||
{"detaillevel",&detailLevel, 0},
|
||||
|
||||
{"snd_channels",&numChannels, 8},
|
||||
|
||||
|
||||
|
||||
{"usegamma",&usegamma, 0},
|
||||
|
||||
{"chatmacro0", NULL, 0, &chat_macros[0], HUSTR_CHATMACRO0 },
|
||||
{"chatmacro1", NULL, 0, &chat_macros[1], HUSTR_CHATMACRO1 },
|
||||
{"chatmacro2", NULL, 0, &chat_macros[2], HUSTR_CHATMACRO2 },
|
||||
{"chatmacro3", NULL, 0, &chat_macros[3], HUSTR_CHATMACRO3 },
|
||||
{"chatmacro4", NULL, 0, &chat_macros[4], HUSTR_CHATMACRO4 },
|
||||
{"chatmacro5", NULL, 0, &chat_macros[5], HUSTR_CHATMACRO5 },
|
||||
{"chatmacro6", NULL, 0, &chat_macros[6], HUSTR_CHATMACRO6 },
|
||||
{"chatmacro7", NULL, 0, &chat_macros[7], HUSTR_CHATMACRO7 },
|
||||
{"chatmacro8", NULL, 0, &chat_macros[8], HUSTR_CHATMACRO8 },
|
||||
{"chatmacro9", NULL, 0, &chat_macros[9], HUSTR_CHATMACRO9 }
|
||||
|
||||
};
|
||||
|
||||
int numdefaults;
|
||||
char* defaultfile;
|
||||
|
||||
|
||||
//
|
||||
// M_SaveDefaults
|
||||
//
|
||||
void M_SaveDefaults (void)
|
||||
{
|
||||
int i;
|
||||
int v;
|
||||
FILE* f;
|
||||
|
||||
f = fopen (defaultfile, "w");
|
||||
if (!f)
|
||||
return; // can't write the file, but don't complain
|
||||
|
||||
for (i=0 ; i<numdefaults ; i++)
|
||||
{
|
||||
if (defaults[i].location)
|
||||
{
|
||||
v = *defaults[i].location;
|
||||
fprintf (f,"%s\t\t%i\n",defaults[i].name,v);
|
||||
} else {
|
||||
fprintf (f,"%s\t\t\"%s\"\n",defaults[i].name,
|
||||
*defaults[i].stringlocation);
|
||||
}
|
||||
}
|
||||
|
||||
fclose (f);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// M_LoadDefaults
|
||||
//
|
||||
void M_LoadDefaults (void)
|
||||
{
|
||||
int i;
|
||||
int len;
|
||||
FILE* f;
|
||||
char def[80];
|
||||
char strparm[100];
|
||||
char* newstring;
|
||||
int parm;
|
||||
boolean isstring;
|
||||
|
||||
// set everything to base values
|
||||
numdefaults = sizeof(defaults)/sizeof(defaults[0]);
|
||||
for (i=0 ; i<numdefaults ; i++)
|
||||
{
|
||||
if (defaults[i].location)
|
||||
*defaults[i].location = defaults[i].defaultvalue;
|
||||
else
|
||||
*defaults[i].stringlocation = defaults[i].stringdefault;
|
||||
}
|
||||
|
||||
// check for a custom default file
|
||||
i = M_CheckParm ("-config");
|
||||
if (i && i<myargc-1)
|
||||
{
|
||||
defaultfile = myargv[i+1];
|
||||
printf (" default file: %s\n",defaultfile);
|
||||
}
|
||||
else
|
||||
defaultfile = basedefault;
|
||||
|
||||
// read the file in, overriding any set defaults
|
||||
f = fopen (defaultfile, "r");
|
||||
if (f)
|
||||
{
|
||||
while (!feof(f))
|
||||
{
|
||||
isstring = false;
|
||||
if (fscanf (f, "%79s %[^\n]\n", def, strparm) == 2)
|
||||
{
|
||||
if (strparm[0] == '"')
|
||||
{
|
||||
// get a string default
|
||||
isstring = true;
|
||||
len = strlen(strparm);
|
||||
newstring = (char *) malloc(len);
|
||||
strparm[len-1] = 0;
|
||||
strcpy(newstring, strparm+1);
|
||||
}
|
||||
else if (strparm[0] == '0' && strparm[1] == 'x')
|
||||
sscanf(strparm+2, "%x", &parm);
|
||||
else
|
||||
sscanf(strparm, "%i", &parm);
|
||||
for (i=0 ; i<numdefaults ; i++)
|
||||
if (!strcmp(def, defaults[i].name))
|
||||
{
|
||||
if (!isstring && defaults[i].location)
|
||||
*defaults[i].location = parm;
|
||||
else if (isstring && defaults[i].stringlocation)
|
||||
*defaults[i].stringlocation = newstring;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fclose (f);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// SCREEN SHOTS
|
||||
//
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char manufacturer;
|
||||
char version;
|
||||
char encoding;
|
||||
char bits_per_pixel;
|
||||
|
||||
unsigned short xmin;
|
||||
unsigned short ymin;
|
||||
unsigned short xmax;
|
||||
unsigned short ymax;
|
||||
|
||||
unsigned short hres;
|
||||
unsigned short vres;
|
||||
|
||||
unsigned char palette[48];
|
||||
|
||||
char reserved;
|
||||
char color_planes;
|
||||
unsigned short bytes_per_line;
|
||||
unsigned short palette_type;
|
||||
|
||||
char filler[58];
|
||||
unsigned char data; // unbounded
|
||||
} pcx_t;
|
||||
|
||||
|
||||
//
|
||||
// WritePCXfile
|
||||
//
|
||||
void
|
||||
WritePCXfile
|
||||
( char* filename,
|
||||
byte* data,
|
||||
int width,
|
||||
int height,
|
||||
byte* palette )
|
||||
{
|
||||
int i;
|
||||
int length;
|
||||
pcx_t* pcx;
|
||||
byte* pack;
|
||||
|
||||
pcx = Z_Malloc (width*height*2+1000, PU_STATIC, NULL);
|
||||
|
||||
pcx->manufacturer = 0x0a; // PCX id
|
||||
pcx->version = 5; // 256 color
|
||||
pcx->encoding = 1; // uncompressed
|
||||
pcx->bits_per_pixel = 8; // 256 color
|
||||
pcx->xmin = 0;
|
||||
pcx->ymin = 0;
|
||||
pcx->xmax = SHORT(width-1);
|
||||
pcx->ymax = SHORT(height-1);
|
||||
pcx->hres = SHORT(width);
|
||||
pcx->vres = SHORT(height);
|
||||
memset (pcx->palette,0,sizeof(pcx->palette));
|
||||
pcx->color_planes = 1; // chunky image
|
||||
pcx->bytes_per_line = SHORT(width);
|
||||
pcx->palette_type = SHORT(2); // not a grey scale
|
||||
memset (pcx->filler,0,sizeof(pcx->filler));
|
||||
|
||||
|
||||
// pack the image
|
||||
pack = &pcx->data;
|
||||
|
||||
for (i=0 ; i<width*height ; i++)
|
||||
{
|
||||
if ( (*data & 0xc0) != 0xc0)
|
||||
*pack++ = *data++;
|
||||
else
|
||||
{
|
||||
*pack++ = 0xc1;
|
||||
*pack++ = *data++;
|
||||
}
|
||||
}
|
||||
|
||||
// write the palette
|
||||
*pack++ = 0x0c; // palette ID byte
|
||||
for (i=0 ; i<768 ; i++)
|
||||
*pack++ = *palette++;
|
||||
|
||||
// write output file
|
||||
length = pack - (byte *)pcx;
|
||||
M_WriteFile (filename, pcx, length);
|
||||
|
||||
Z_Free (pcx);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// M_ScreenShot
|
||||
//
|
||||
void M_ScreenShot (void)
|
||||
{
|
||||
int i;
|
||||
byte* linear;
|
||||
char lbmname[12];
|
||||
|
||||
// munge planar buffer to linear
|
||||
linear = screens[2];
|
||||
I_ReadScreen (linear);
|
||||
|
||||
// find a file name to save it to
|
||||
strcpy(lbmname,"DOOM00.pcx");
|
||||
|
||||
for (i=0 ; i<=99 ; i++)
|
||||
{
|
||||
lbmname[4] = i/10 + '0';
|
||||
lbmname[5] = i%10 + '0';
|
||||
if (access(lbmname,0) == -1)
|
||||
break; // file doesn't exist
|
||||
}
|
||||
if (i==100)
|
||||
I_Error ("M_ScreenShot: Couldn't create a PCX");
|
||||
|
||||
// save the pcx file
|
||||
WritePCXfile (lbmname, linear,
|
||||
SCREENWIDTH, SCREENHEIGHT,
|
||||
W_CacheLumpName ("PLAYPAL",PU_CACHE));
|
||||
|
||||
players[consoleplayer].message = "screen shot";
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,65 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
//
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __M_MISC__
|
||||
#define __M_MISC__
|
||||
|
||||
|
||||
#include "doomtype.h"
|
||||
//
|
||||
// MISC
|
||||
//
|
||||
|
||||
|
||||
|
||||
boolean
|
||||
M_WriteFile
|
||||
( char const* name,
|
||||
void* source,
|
||||
int length );
|
||||
|
||||
int
|
||||
M_ReadFile
|
||||
( char const* name,
|
||||
byte** buffer );
|
||||
|
||||
void M_ScreenShot (void);
|
||||
|
||||
void M_LoadDefaults (void);
|
||||
|
||||
void M_SaveDefaults (void);
|
||||
|
||||
|
||||
int
|
||||
M_DrawText
|
||||
( int x,
|
||||
int y,
|
||||
boolean direct,
|
||||
char* string );
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,76 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Random number LUT.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char rcsid[] = "$Id: m_random.c,v 1.1 1997/02/03 22:45:11 b1 Exp $";
|
||||
|
||||
|
||||
//
|
||||
// M_Random
|
||||
// Returns a 0-255 number
|
||||
//
|
||||
unsigned char rndtable[256] = {
|
||||
0, 8, 109, 220, 222, 241, 149, 107, 75, 248, 254, 140, 16, 66 ,
|
||||
74, 21, 211, 47, 80, 242, 154, 27, 205, 128, 161, 89, 77, 36 ,
|
||||
95, 110, 85, 48, 212, 140, 211, 249, 22, 79, 200, 50, 28, 188 ,
|
||||
52, 140, 202, 120, 68, 145, 62, 70, 184, 190, 91, 197, 152, 224 ,
|
||||
149, 104, 25, 178, 252, 182, 202, 182, 141, 197, 4, 81, 181, 242 ,
|
||||
145, 42, 39, 227, 156, 198, 225, 193, 219, 93, 122, 175, 249, 0 ,
|
||||
175, 143, 70, 239, 46, 246, 163, 53, 163, 109, 168, 135, 2, 235 ,
|
||||
25, 92, 20, 145, 138, 77, 69, 166, 78, 176, 173, 212, 166, 113 ,
|
||||
94, 161, 41, 50, 239, 49, 111, 164, 70, 60, 2, 37, 171, 75 ,
|
||||
136, 156, 11, 56, 42, 146, 138, 229, 73, 146, 77, 61, 98, 196 ,
|
||||
135, 106, 63, 197, 195, 86, 96, 203, 113, 101, 170, 247, 181, 113 ,
|
||||
80, 250, 108, 7, 255, 237, 129, 226, 79, 107, 112, 166, 103, 241 ,
|
||||
24, 223, 239, 120, 198, 58, 60, 82, 128, 3, 184, 66, 143, 224 ,
|
||||
145, 224, 81, 206, 163, 45, 63, 90, 168, 114, 59, 33, 159, 95 ,
|
||||
28, 139, 123, 98, 125, 196, 15, 70, 194, 253, 54, 14, 109, 226 ,
|
||||
71, 17, 161, 93, 186, 87, 244, 138, 20, 52, 123, 251, 26, 36 ,
|
||||
17, 46, 52, 231, 232, 76, 31, 221, 84, 37, 216, 165, 212, 106 ,
|
||||
197, 242, 98, 43, 39, 175, 254, 145, 190, 84, 118, 222, 187, 136 ,
|
||||
120, 163, 236, 249
|
||||
};
|
||||
|
||||
int rndindex = 0;
|
||||
int prndindex = 0;
|
||||
|
||||
// Which one is deterministic?
|
||||
int P_Random (void)
|
||||
{
|
||||
prndindex = (prndindex+1)&0xff;
|
||||
return rndtable[prndindex];
|
||||
}
|
||||
|
||||
int M_Random (void)
|
||||
{
|
||||
rndindex = (rndindex+1)&0xff;
|
||||
return rndtable[rndindex];
|
||||
}
|
||||
|
||||
void M_ClearRandom (void)
|
||||
{
|
||||
rndindex = prndindex = 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
//
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __M_RANDOM__
|
||||
#define __M_RANDOM__
|
||||
|
||||
|
||||
#include "doomtype.h"
|
||||
|
||||
|
||||
|
||||
// Returns a number from 0 to 255,
|
||||
// from a lookup table.
|
||||
int M_Random (void);
|
||||
|
||||
// As M_Random, but used only by the play simulation.
|
||||
int P_Random (void);
|
||||
|
||||
// Fix randoms for demos.
|
||||
void M_ClearRandom (void);
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,57 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Endianess handling, swapping 16bit and 32bit.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "m_swap.h"
|
||||
#endif
|
||||
#include "m_swap.h"
|
||||
|
||||
|
||||
// Not needed with big endian.
|
||||
#ifndef __BIG_ENDIAN__
|
||||
|
||||
// Swap 16bit, that is, MSB and LSB byte.
|
||||
unsigned short SwapSHORT(unsigned short x)
|
||||
{
|
||||
// No masking with 0xFF should be necessary.
|
||||
return (x>>8) | (x<<8);
|
||||
}
|
||||
|
||||
// Swapping 32bit.
|
||||
unsigned long SwapLONG( unsigned long x)
|
||||
{
|
||||
return
|
||||
(x>>24)
|
||||
| ((x>>8) & 0xff00)
|
||||
| ((x<<8) & 0xff0000)
|
||||
| (x<<24);
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Endianess handling, swapping 16bit and 32bit.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __M_SWAP__
|
||||
#define __M_SWAP__
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
// Endianess handling.
|
||||
// WAD files are stored little endian.
|
||||
#ifdef __BIG_ENDIAN__
|
||||
short SwapSHORT(short);
|
||||
long SwapLONG(long);
|
||||
#define SHORT(x) ((short)SwapSHORT((unsigned short) (x)))
|
||||
#define LONG(x) ((long)SwapLONG((unsigned long) (x)))
|
||||
#else
|
||||
#define SHORT(x) (x)
|
||||
#define LONG(x) (x)
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,335 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION: Ceiling aninmation (lowering, crushing, raising)
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_ceilng.c,v 1.4 1997/02/03 16:47:53 b1 Exp $";
|
||||
|
||||
|
||||
#include "z_zone.h"
|
||||
#include "doomdef.h"
|
||||
#include "p_local.h"
|
||||
|
||||
#include "s_sound.h"
|
||||
|
||||
// State.
|
||||
#include "doomstat.h"
|
||||
#include "r_state.h"
|
||||
|
||||
// Data.
|
||||
#include "sounds.h"
|
||||
|
||||
//
|
||||
// CEILINGS
|
||||
//
|
||||
|
||||
|
||||
ceiling_t* activeceilings[MAXCEILINGS];
|
||||
|
||||
|
||||
//
|
||||
// T_MoveCeiling
|
||||
//
|
||||
|
||||
void T_MoveCeiling (ceiling_t* ceiling)
|
||||
{
|
||||
result_e res;
|
||||
|
||||
switch(ceiling->direction)
|
||||
{
|
||||
case 0:
|
||||
// IN STASIS
|
||||
break;
|
||||
case 1:
|
||||
// UP
|
||||
res = T_MovePlane(ceiling->sector,
|
||||
ceiling->speed,
|
||||
ceiling->topheight,
|
||||
false,1,ceiling->direction);
|
||||
|
||||
if (!(leveltime&7))
|
||||
{
|
||||
switch(ceiling->type)
|
||||
{
|
||||
case silentCrushAndRaise:
|
||||
break;
|
||||
default:
|
||||
S_StartSound((mobj_t *)&ceiling->sector->soundorg,
|
||||
sfx_stnmov);
|
||||
// ?
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (res == pastdest)
|
||||
{
|
||||
switch(ceiling->type)
|
||||
{
|
||||
case raiseToHighest:
|
||||
P_RemoveActiveCeiling(ceiling);
|
||||
break;
|
||||
|
||||
case silentCrushAndRaise:
|
||||
S_StartSound((mobj_t *)&ceiling->sector->soundorg,
|
||||
sfx_pstop);
|
||||
case fastCrushAndRaise:
|
||||
case crushAndRaise:
|
||||
ceiling->direction = -1;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
break;
|
||||
|
||||
case -1:
|
||||
// DOWN
|
||||
res = T_MovePlane(ceiling->sector,
|
||||
ceiling->speed,
|
||||
ceiling->bottomheight,
|
||||
ceiling->crush,1,ceiling->direction);
|
||||
|
||||
if (!(leveltime&7))
|
||||
{
|
||||
switch(ceiling->type)
|
||||
{
|
||||
case silentCrushAndRaise: break;
|
||||
default:
|
||||
S_StartSound((mobj_t *)&ceiling->sector->soundorg,
|
||||
sfx_stnmov);
|
||||
}
|
||||
}
|
||||
|
||||
if (res == pastdest)
|
||||
{
|
||||
switch(ceiling->type)
|
||||
{
|
||||
case silentCrushAndRaise:
|
||||
S_StartSound((mobj_t *)&ceiling->sector->soundorg,
|
||||
sfx_pstop);
|
||||
case crushAndRaise:
|
||||
ceiling->speed = CEILSPEED;
|
||||
case fastCrushAndRaise:
|
||||
ceiling->direction = 1;
|
||||
break;
|
||||
|
||||
case lowerAndCrush:
|
||||
case lowerToFloor:
|
||||
P_RemoveActiveCeiling(ceiling);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
else // ( res != pastdest )
|
||||
{
|
||||
if (res == crushed)
|
||||
{
|
||||
switch(ceiling->type)
|
||||
{
|
||||
case silentCrushAndRaise:
|
||||
case crushAndRaise:
|
||||
case lowerAndCrush:
|
||||
ceiling->speed = CEILSPEED / 8;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// EV_DoCeiling
|
||||
// Move a ceiling up/down and all around!
|
||||
//
|
||||
int
|
||||
EV_DoCeiling
|
||||
( line_t* line,
|
||||
ceiling_e type )
|
||||
{
|
||||
int secnum;
|
||||
int rtn;
|
||||
sector_t* sec;
|
||||
ceiling_t* ceiling;
|
||||
|
||||
secnum = -1;
|
||||
rtn = 0;
|
||||
|
||||
// Reactivate in-stasis ceilings...for certain types.
|
||||
switch(type)
|
||||
{
|
||||
case fastCrushAndRaise:
|
||||
case silentCrushAndRaise:
|
||||
case crushAndRaise:
|
||||
P_ActivateInStasisCeiling(line);
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
|
||||
{
|
||||
sec = §ors[secnum];
|
||||
if (sec->specialdata)
|
||||
continue;
|
||||
|
||||
// new door thinker
|
||||
rtn = 1;
|
||||
ceiling = Z_Malloc (sizeof(*ceiling), PU_LEVSPEC, 0);
|
||||
P_AddThinker (&ceiling->thinker);
|
||||
sec->specialdata = ceiling;
|
||||
ceiling->thinker.function.acp1 = (actionf_p1)T_MoveCeiling;
|
||||
ceiling->sector = sec;
|
||||
ceiling->crush = false;
|
||||
|
||||
switch(type)
|
||||
{
|
||||
case fastCrushAndRaise:
|
||||
ceiling->crush = true;
|
||||
ceiling->topheight = sec->ceilingheight;
|
||||
ceiling->bottomheight = sec->floorheight + (8*FRACUNIT);
|
||||
ceiling->direction = -1;
|
||||
ceiling->speed = CEILSPEED * 2;
|
||||
break;
|
||||
|
||||
case silentCrushAndRaise:
|
||||
case crushAndRaise:
|
||||
ceiling->crush = true;
|
||||
ceiling->topheight = sec->ceilingheight;
|
||||
case lowerAndCrush:
|
||||
case lowerToFloor:
|
||||
ceiling->bottomheight = sec->floorheight;
|
||||
if (type != lowerToFloor)
|
||||
ceiling->bottomheight += 8*FRACUNIT;
|
||||
ceiling->direction = -1;
|
||||
ceiling->speed = CEILSPEED;
|
||||
break;
|
||||
|
||||
case raiseToHighest:
|
||||
ceiling->topheight = P_FindHighestCeilingSurrounding(sec);
|
||||
ceiling->direction = 1;
|
||||
ceiling->speed = CEILSPEED;
|
||||
break;
|
||||
}
|
||||
|
||||
ceiling->tag = sec->tag;
|
||||
ceiling->type = type;
|
||||
P_AddActiveCeiling(ceiling);
|
||||
}
|
||||
return rtn;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Add an active ceiling
|
||||
//
|
||||
void P_AddActiveCeiling(ceiling_t* c)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < MAXCEILINGS;i++)
|
||||
{
|
||||
if (activeceilings[i] == NULL)
|
||||
{
|
||||
activeceilings[i] = c;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Remove a ceiling's thinker
|
||||
//
|
||||
void P_RemoveActiveCeiling(ceiling_t* c)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0;i < MAXCEILINGS;i++)
|
||||
{
|
||||
if (activeceilings[i] == c)
|
||||
{
|
||||
activeceilings[i]->sector->specialdata = NULL;
|
||||
P_RemoveThinker (&activeceilings[i]->thinker);
|
||||
activeceilings[i] = NULL;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Restart a ceiling that's in-stasis
|
||||
//
|
||||
void P_ActivateInStasisCeiling(line_t* line)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0;i < MAXCEILINGS;i++)
|
||||
{
|
||||
if (activeceilings[i]
|
||||
&& (activeceilings[i]->tag == line->tag)
|
||||
&& (activeceilings[i]->direction == 0))
|
||||
{
|
||||
activeceilings[i]->direction = activeceilings[i]->olddirection;
|
||||
activeceilings[i]->thinker.function.acp1
|
||||
= (actionf_p1)T_MoveCeiling;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// EV_CeilingCrushStop
|
||||
// Stop a ceiling from crushing!
|
||||
//
|
||||
int EV_CeilingCrushStop(line_t *line)
|
||||
{
|
||||
int i;
|
||||
int rtn;
|
||||
|
||||
rtn = 0;
|
||||
for (i = 0;i < MAXCEILINGS;i++)
|
||||
{
|
||||
if (activeceilings[i]
|
||||
&& (activeceilings[i]->tag == line->tag)
|
||||
&& (activeceilings[i]->direction != 0))
|
||||
{
|
||||
activeceilings[i]->olddirection = activeceilings[i]->direction;
|
||||
activeceilings[i]->thinker.function.acv = (actionf_v)NULL;
|
||||
activeceilings[i]->direction = 0; // in-stasis
|
||||
rtn = 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return rtn;
|
||||
}
|
||||
@@ -0,0 +1,764 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION: Door animation code (opening/closing)
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_doors.c,v 1.4 1997/02/03 16:47:53 b1 Exp $";
|
||||
|
||||
|
||||
#include "z_zone.h"
|
||||
#include "doomdef.h"
|
||||
#include "p_local.h"
|
||||
|
||||
#include "s_sound.h"
|
||||
|
||||
|
||||
// State.
|
||||
#include "doomstat.h"
|
||||
#include "r_state.h"
|
||||
|
||||
// Data.
|
||||
#include "dstrings.h"
|
||||
#include "sounds.h"
|
||||
|
||||
#if 0
|
||||
//
|
||||
// Sliding door frame information
|
||||
//
|
||||
slidename_t slideFrameNames[MAXSLIDEDOORS] =
|
||||
{
|
||||
{"GDOORF1","GDOORF2","GDOORF3","GDOORF4", // front
|
||||
"GDOORB1","GDOORB2","GDOORB3","GDOORB4"}, // back
|
||||
|
||||
{"\0","\0","\0","\0"}
|
||||
};
|
||||
#endif
|
||||
|
||||
|
||||
//
|
||||
// VERTICAL DOORS
|
||||
//
|
||||
|
||||
//
|
||||
// T_VerticalDoor
|
||||
//
|
||||
void T_VerticalDoor (vldoor_t* door)
|
||||
{
|
||||
result_e res;
|
||||
|
||||
switch(door->direction)
|
||||
{
|
||||
case 0:
|
||||
// WAITING
|
||||
if (!--door->topcountdown)
|
||||
{
|
||||
switch(door->type)
|
||||
{
|
||||
case blazeRaise:
|
||||
door->direction = -1; // time to go back down
|
||||
S_StartSound((mobj_t *)&door->sector->soundorg,
|
||||
sfx_bdcls);
|
||||
break;
|
||||
|
||||
case normal:
|
||||
door->direction = -1; // time to go back down
|
||||
S_StartSound((mobj_t *)&door->sector->soundorg,
|
||||
sfx_dorcls);
|
||||
break;
|
||||
|
||||
case close30ThenOpen:
|
||||
door->direction = 1;
|
||||
S_StartSound((mobj_t *)&door->sector->soundorg,
|
||||
sfx_doropn);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 2:
|
||||
// INITIAL WAIT
|
||||
if (!--door->topcountdown)
|
||||
{
|
||||
switch(door->type)
|
||||
{
|
||||
case raiseIn5Mins:
|
||||
door->direction = 1;
|
||||
door->type = normal;
|
||||
S_StartSound((mobj_t *)&door->sector->soundorg,
|
||||
sfx_doropn);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case -1:
|
||||
// DOWN
|
||||
res = T_MovePlane(door->sector,
|
||||
door->speed,
|
||||
door->sector->floorheight,
|
||||
false,1,door->direction);
|
||||
if (res == pastdest)
|
||||
{
|
||||
switch(door->type)
|
||||
{
|
||||
case blazeRaise:
|
||||
case blazeClose:
|
||||
door->sector->specialdata = NULL;
|
||||
P_RemoveThinker (&door->thinker); // unlink and free
|
||||
S_StartSound((mobj_t *)&door->sector->soundorg,
|
||||
sfx_bdcls);
|
||||
break;
|
||||
|
||||
case normal:
|
||||
case close:
|
||||
door->sector->specialdata = NULL;
|
||||
P_RemoveThinker (&door->thinker); // unlink and free
|
||||
break;
|
||||
|
||||
case close30ThenOpen:
|
||||
door->direction = 0;
|
||||
door->topcountdown = 35*30;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (res == crushed)
|
||||
{
|
||||
switch(door->type)
|
||||
{
|
||||
case blazeClose:
|
||||
case close: // DO NOT GO BACK UP!
|
||||
break;
|
||||
|
||||
default:
|
||||
door->direction = 1;
|
||||
S_StartSound((mobj_t *)&door->sector->soundorg,
|
||||
sfx_doropn);
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 1:
|
||||
// UP
|
||||
res = T_MovePlane(door->sector,
|
||||
door->speed,
|
||||
door->topheight,
|
||||
false,1,door->direction);
|
||||
|
||||
if (res == pastdest)
|
||||
{
|
||||
switch(door->type)
|
||||
{
|
||||
case blazeRaise:
|
||||
case normal:
|
||||
door->direction = 0; // wait at top
|
||||
door->topcountdown = door->topwait;
|
||||
break;
|
||||
|
||||
case close30ThenOpen:
|
||||
case blazeOpen:
|
||||
case open:
|
||||
door->sector->specialdata = NULL;
|
||||
P_RemoveThinker (&door->thinker); // unlink and free
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// EV_DoLockedDoor
|
||||
// Move a locked door up/down
|
||||
//
|
||||
|
||||
int
|
||||
EV_DoLockedDoor
|
||||
( line_t* line,
|
||||
vldoor_e type,
|
||||
mobj_t* thing )
|
||||
{
|
||||
player_t* p;
|
||||
|
||||
p = thing->player;
|
||||
|
||||
if (!p)
|
||||
return 0;
|
||||
|
||||
switch(line->special)
|
||||
{
|
||||
case 99: // Blue Lock
|
||||
case 133:
|
||||
if ( !p )
|
||||
return 0;
|
||||
if (!p->cards[it_bluecard] && !p->cards[it_blueskull])
|
||||
{
|
||||
p->message = PD_BLUEO;
|
||||
S_StartSound(NULL,sfx_oof);
|
||||
return 0;
|
||||
}
|
||||
break;
|
||||
|
||||
case 134: // Red Lock
|
||||
case 135:
|
||||
if ( !p )
|
||||
return 0;
|
||||
if (!p->cards[it_redcard] && !p->cards[it_redskull])
|
||||
{
|
||||
p->message = PD_REDO;
|
||||
S_StartSound(NULL,sfx_oof);
|
||||
return 0;
|
||||
}
|
||||
break;
|
||||
|
||||
case 136: // Yellow Lock
|
||||
case 137:
|
||||
if ( !p )
|
||||
return 0;
|
||||
if (!p->cards[it_yellowcard] &&
|
||||
!p->cards[it_yellowskull])
|
||||
{
|
||||
p->message = PD_YELLOWO;
|
||||
S_StartSound(NULL,sfx_oof);
|
||||
return 0;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return EV_DoDoor(line,type);
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
EV_DoDoor
|
||||
( line_t* line,
|
||||
vldoor_e type )
|
||||
{
|
||||
int secnum,rtn;
|
||||
sector_t* sec;
|
||||
vldoor_t* door;
|
||||
|
||||
secnum = -1;
|
||||
rtn = 0;
|
||||
|
||||
while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
|
||||
{
|
||||
sec = §ors[secnum];
|
||||
if (sec->specialdata)
|
||||
continue;
|
||||
|
||||
|
||||
// new door thinker
|
||||
rtn = 1;
|
||||
door = Z_Malloc (sizeof(*door), PU_LEVSPEC, 0);
|
||||
P_AddThinker (&door->thinker);
|
||||
sec->specialdata = door;
|
||||
|
||||
door->thinker.function.acp1 = (actionf_p1) T_VerticalDoor;
|
||||
door->sector = sec;
|
||||
door->type = type;
|
||||
door->topwait = VDOORWAIT;
|
||||
door->speed = VDOORSPEED;
|
||||
|
||||
switch(type)
|
||||
{
|
||||
case blazeClose:
|
||||
door->topheight = P_FindLowestCeilingSurrounding(sec);
|
||||
door->topheight -= 4*FRACUNIT;
|
||||
door->direction = -1;
|
||||
door->speed = VDOORSPEED * 4;
|
||||
S_StartSound((mobj_t *)&door->sector->soundorg,
|
||||
sfx_bdcls);
|
||||
break;
|
||||
|
||||
case close:
|
||||
door->topheight = P_FindLowestCeilingSurrounding(sec);
|
||||
door->topheight -= 4*FRACUNIT;
|
||||
door->direction = -1;
|
||||
S_StartSound((mobj_t *)&door->sector->soundorg,
|
||||
sfx_dorcls);
|
||||
break;
|
||||
|
||||
case close30ThenOpen:
|
||||
door->topheight = sec->ceilingheight;
|
||||
door->direction = -1;
|
||||
S_StartSound((mobj_t *)&door->sector->soundorg,
|
||||
sfx_dorcls);
|
||||
break;
|
||||
|
||||
case blazeRaise:
|
||||
case blazeOpen:
|
||||
door->direction = 1;
|
||||
door->topheight = P_FindLowestCeilingSurrounding(sec);
|
||||
door->topheight -= 4*FRACUNIT;
|
||||
door->speed = VDOORSPEED * 4;
|
||||
if (door->topheight != sec->ceilingheight)
|
||||
S_StartSound((mobj_t *)&door->sector->soundorg,
|
||||
sfx_bdopn);
|
||||
break;
|
||||
|
||||
case normal:
|
||||
case open:
|
||||
door->direction = 1;
|
||||
door->topheight = P_FindLowestCeilingSurrounding(sec);
|
||||
door->topheight -= 4*FRACUNIT;
|
||||
if (door->topheight != sec->ceilingheight)
|
||||
S_StartSound((mobj_t *)&door->sector->soundorg,
|
||||
sfx_doropn);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
return rtn;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// EV_VerticalDoor : open a door manually, no tag value
|
||||
//
|
||||
void
|
||||
EV_VerticalDoor
|
||||
( line_t* line,
|
||||
mobj_t* thing )
|
||||
{
|
||||
player_t* player;
|
||||
int secnum;
|
||||
sector_t* sec;
|
||||
vldoor_t* door;
|
||||
int side;
|
||||
|
||||
side = 0; // only front sides can be used
|
||||
|
||||
// Check for locks
|
||||
player = thing->player;
|
||||
|
||||
switch(line->special)
|
||||
{
|
||||
case 26: // Blue Lock
|
||||
case 32:
|
||||
if ( !player )
|
||||
return;
|
||||
|
||||
if (!player->cards[it_bluecard] && !player->cards[it_blueskull])
|
||||
{
|
||||
player->message = PD_BLUEK;
|
||||
S_StartSound(NULL,sfx_oof);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
|
||||
case 27: // Yellow Lock
|
||||
case 34:
|
||||
if ( !player )
|
||||
return;
|
||||
|
||||
if (!player->cards[it_yellowcard] &&
|
||||
!player->cards[it_yellowskull])
|
||||
{
|
||||
player->message = PD_YELLOWK;
|
||||
S_StartSound(NULL,sfx_oof);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
|
||||
case 28: // Red Lock
|
||||
case 33:
|
||||
if ( !player )
|
||||
return;
|
||||
|
||||
if (!player->cards[it_redcard] && !player->cards[it_redskull])
|
||||
{
|
||||
player->message = PD_REDK;
|
||||
S_StartSound(NULL,sfx_oof);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
// if the sector has an active thinker, use it
|
||||
sec = sides[ line->sidenum[side^1]] .sector;
|
||||
secnum = sec-sectors;
|
||||
|
||||
if (sec->specialdata)
|
||||
{
|
||||
door = sec->specialdata;
|
||||
switch(line->special)
|
||||
{
|
||||
case 1: // ONLY FOR "RAISE" DOORS, NOT "OPEN"s
|
||||
case 26:
|
||||
case 27:
|
||||
case 28:
|
||||
case 117:
|
||||
if (door->direction == -1)
|
||||
door->direction = 1; // go back up
|
||||
else
|
||||
{
|
||||
if (!thing->player)
|
||||
return; // JDC: bad guys never close doors
|
||||
|
||||
door->direction = -1; // start going down immediately
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// for proper sound
|
||||
switch(line->special)
|
||||
{
|
||||
case 117: // BLAZING DOOR RAISE
|
||||
case 118: // BLAZING DOOR OPEN
|
||||
S_StartSound((mobj_t *)&sec->soundorg,sfx_bdopn);
|
||||
break;
|
||||
|
||||
case 1: // NORMAL DOOR SOUND
|
||||
case 31:
|
||||
S_StartSound((mobj_t *)&sec->soundorg,sfx_doropn);
|
||||
break;
|
||||
|
||||
default: // LOCKED DOOR SOUND
|
||||
S_StartSound((mobj_t *)&sec->soundorg,sfx_doropn);
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
// new door thinker
|
||||
door = Z_Malloc (sizeof(*door), PU_LEVSPEC, 0);
|
||||
P_AddThinker (&door->thinker);
|
||||
sec->specialdata = door;
|
||||
door->thinker.function.acp1 = (actionf_p1) T_VerticalDoor;
|
||||
door->sector = sec;
|
||||
door->direction = 1;
|
||||
door->speed = VDOORSPEED;
|
||||
door->topwait = VDOORWAIT;
|
||||
|
||||
switch(line->special)
|
||||
{
|
||||
case 1:
|
||||
case 26:
|
||||
case 27:
|
||||
case 28:
|
||||
door->type = normal;
|
||||
break;
|
||||
|
||||
case 31:
|
||||
case 32:
|
||||
case 33:
|
||||
case 34:
|
||||
door->type = open;
|
||||
line->special = 0;
|
||||
break;
|
||||
|
||||
case 117: // blazing door raise
|
||||
door->type = blazeRaise;
|
||||
door->speed = VDOORSPEED*4;
|
||||
break;
|
||||
case 118: // blazing door open
|
||||
door->type = blazeOpen;
|
||||
line->special = 0;
|
||||
door->speed = VDOORSPEED*4;
|
||||
break;
|
||||
}
|
||||
|
||||
// find the top and bottom of the movement range
|
||||
door->topheight = P_FindLowestCeilingSurrounding(sec);
|
||||
door->topheight -= 4*FRACUNIT;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Spawn a door that closes after 30 seconds
|
||||
//
|
||||
void P_SpawnDoorCloseIn30 (sector_t* sec)
|
||||
{
|
||||
vldoor_t* door;
|
||||
|
||||
door = Z_Malloc ( sizeof(*door), PU_LEVSPEC, 0);
|
||||
|
||||
P_AddThinker (&door->thinker);
|
||||
|
||||
sec->specialdata = door;
|
||||
sec->special = 0;
|
||||
|
||||
door->thinker.function.acp1 = (actionf_p1)T_VerticalDoor;
|
||||
door->sector = sec;
|
||||
door->direction = 0;
|
||||
door->type = normal;
|
||||
door->speed = VDOORSPEED;
|
||||
door->topcountdown = 30 * 35;
|
||||
}
|
||||
|
||||
//
|
||||
// Spawn a door that opens after 5 minutes
|
||||
//
|
||||
void
|
||||
P_SpawnDoorRaiseIn5Mins
|
||||
( sector_t* sec,
|
||||
int secnum )
|
||||
{
|
||||
vldoor_t* door;
|
||||
|
||||
door = Z_Malloc ( sizeof(*door), PU_LEVSPEC, 0);
|
||||
|
||||
P_AddThinker (&door->thinker);
|
||||
|
||||
sec->specialdata = door;
|
||||
sec->special = 0;
|
||||
|
||||
door->thinker.function.acp1 = (actionf_p1)T_VerticalDoor;
|
||||
door->sector = sec;
|
||||
door->direction = 2;
|
||||
door->type = raiseIn5Mins;
|
||||
door->speed = VDOORSPEED;
|
||||
door->topheight = P_FindLowestCeilingSurrounding(sec);
|
||||
door->topheight -= 4*FRACUNIT;
|
||||
door->topwait = VDOORWAIT;
|
||||
door->topcountdown = 5 * 60 * 35;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// UNUSED
|
||||
// Separate into p_slidoor.c?
|
||||
|
||||
#if 0 // ABANDONED TO THE MISTS OF TIME!!!
|
||||
//
|
||||
// EV_SlidingDoor : slide a door horizontally
|
||||
// (animate midtexture, then set noblocking line)
|
||||
//
|
||||
|
||||
|
||||
slideframe_t slideFrames[MAXSLIDEDOORS];
|
||||
|
||||
void P_InitSlidingDoorFrames(void)
|
||||
{
|
||||
int i;
|
||||
int f1;
|
||||
int f2;
|
||||
int f3;
|
||||
int f4;
|
||||
|
||||
// DOOM II ONLY...
|
||||
if ( gamemode != commercial)
|
||||
return;
|
||||
|
||||
for (i = 0;i < MAXSLIDEDOORS; i++)
|
||||
{
|
||||
if (!slideFrameNames[i].frontFrame1[0])
|
||||
break;
|
||||
|
||||
f1 = R_TextureNumForName(slideFrameNames[i].frontFrame1);
|
||||
f2 = R_TextureNumForName(slideFrameNames[i].frontFrame2);
|
||||
f3 = R_TextureNumForName(slideFrameNames[i].frontFrame3);
|
||||
f4 = R_TextureNumForName(slideFrameNames[i].frontFrame4);
|
||||
|
||||
slideFrames[i].frontFrames[0] = f1;
|
||||
slideFrames[i].frontFrames[1] = f2;
|
||||
slideFrames[i].frontFrames[2] = f3;
|
||||
slideFrames[i].frontFrames[3] = f4;
|
||||
|
||||
f1 = R_TextureNumForName(slideFrameNames[i].backFrame1);
|
||||
f2 = R_TextureNumForName(slideFrameNames[i].backFrame2);
|
||||
f3 = R_TextureNumForName(slideFrameNames[i].backFrame3);
|
||||
f4 = R_TextureNumForName(slideFrameNames[i].backFrame4);
|
||||
|
||||
slideFrames[i].backFrames[0] = f1;
|
||||
slideFrames[i].backFrames[1] = f2;
|
||||
slideFrames[i].backFrames[2] = f3;
|
||||
slideFrames[i].backFrames[3] = f4;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Return index into "slideFrames" array
|
||||
// for which door type to use
|
||||
//
|
||||
int P_FindSlidingDoorType(line_t* line)
|
||||
{
|
||||
int i;
|
||||
int val;
|
||||
|
||||
for (i = 0;i < MAXSLIDEDOORS;i++)
|
||||
{
|
||||
val = sides[line->sidenum[0]].midtexture;
|
||||
if (val == slideFrames[i].frontFrames[0])
|
||||
return i;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
void T_SlidingDoor (slidedoor_t* door)
|
||||
{
|
||||
switch(door->status)
|
||||
{
|
||||
case sd_opening:
|
||||
if (!door->timer--)
|
||||
{
|
||||
if (++door->frame == SNUMFRAMES)
|
||||
{
|
||||
// IF DOOR IS DONE OPENING...
|
||||
sides[door->line->sidenum[0]].midtexture = 0;
|
||||
sides[door->line->sidenum[1]].midtexture = 0;
|
||||
door->line->flags &= ML_BLOCKING^0xff;
|
||||
|
||||
if (door->type == sdt_openOnly)
|
||||
{
|
||||
door->frontsector->specialdata = NULL;
|
||||
P_RemoveThinker (&door->thinker);
|
||||
break;
|
||||
}
|
||||
|
||||
door->timer = SDOORWAIT;
|
||||
door->status = sd_waiting;
|
||||
}
|
||||
else
|
||||
{
|
||||
// IF DOOR NEEDS TO ANIMATE TO NEXT FRAME...
|
||||
door->timer = SWAITTICS;
|
||||
|
||||
sides[door->line->sidenum[0]].midtexture =
|
||||
slideFrames[door->whichDoorIndex].
|
||||
frontFrames[door->frame];
|
||||
sides[door->line->sidenum[1]].midtexture =
|
||||
slideFrames[door->whichDoorIndex].
|
||||
backFrames[door->frame];
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case sd_waiting:
|
||||
// IF DOOR IS DONE WAITING...
|
||||
if (!door->timer--)
|
||||
{
|
||||
// CAN DOOR CLOSE?
|
||||
if (door->frontsector->thinglist != NULL ||
|
||||
door->backsector->thinglist != NULL)
|
||||
{
|
||||
door->timer = SDOORWAIT;
|
||||
break;
|
||||
}
|
||||
|
||||
//door->frame = SNUMFRAMES-1;
|
||||
door->status = sd_closing;
|
||||
door->timer = SWAITTICS;
|
||||
}
|
||||
break;
|
||||
|
||||
case sd_closing:
|
||||
if (!door->timer--)
|
||||
{
|
||||
if (--door->frame < 0)
|
||||
{
|
||||
// IF DOOR IS DONE CLOSING...
|
||||
door->line->flags |= ML_BLOCKING;
|
||||
door->frontsector->specialdata = NULL;
|
||||
P_RemoveThinker (&door->thinker);
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
// IF DOOR NEEDS TO ANIMATE TO NEXT FRAME...
|
||||
door->timer = SWAITTICS;
|
||||
|
||||
sides[door->line->sidenum[0]].midtexture =
|
||||
slideFrames[door->whichDoorIndex].
|
||||
frontFrames[door->frame];
|
||||
sides[door->line->sidenum[1]].midtexture =
|
||||
slideFrames[door->whichDoorIndex].
|
||||
backFrames[door->frame];
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
void
|
||||
EV_SlidingDoor
|
||||
( line_t* line,
|
||||
mobj_t* thing )
|
||||
{
|
||||
sector_t* sec;
|
||||
slidedoor_t* door;
|
||||
|
||||
// DOOM II ONLY...
|
||||
if (gamemode != commercial)
|
||||
return;
|
||||
|
||||
// Make sure door isn't already being animated
|
||||
sec = line->frontsector;
|
||||
door = NULL;
|
||||
if (sec->specialdata)
|
||||
{
|
||||
if (!thing->player)
|
||||
return;
|
||||
|
||||
door = sec->specialdata;
|
||||
if (door->type == sdt_openAndClose)
|
||||
{
|
||||
if (door->status == sd_waiting)
|
||||
door->status = sd_closing;
|
||||
}
|
||||
else
|
||||
return;
|
||||
}
|
||||
|
||||
// Init sliding door vars
|
||||
if (!door)
|
||||
{
|
||||
door = Z_Malloc (sizeof(*door), PU_LEVSPEC, 0);
|
||||
P_AddThinker (&door->thinker);
|
||||
sec->specialdata = door;
|
||||
|
||||
door->type = sdt_openAndClose;
|
||||
door->status = sd_opening;
|
||||
door->whichDoorIndex = P_FindSlidingDoorType(line);
|
||||
|
||||
if (door->whichDoorIndex < 0)
|
||||
I_Error("EV_SlidingDoor: Can't use texture for sliding door!");
|
||||
|
||||
door->frontsector = sec;
|
||||
door->backsector = line->backsector;
|
||||
door->thinker.function = T_SlidingDoor;
|
||||
door->timer = SWAITTICS;
|
||||
door->frame = 0;
|
||||
door->line = line;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
+2008
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,555 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Floor animation: raising stairs.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_floor.c,v 1.4 1997/02/03 16:47:54 b1 Exp $";
|
||||
|
||||
|
||||
#include "z_zone.h"
|
||||
#include "doomdef.h"
|
||||
#include "p_local.h"
|
||||
|
||||
#include "s_sound.h"
|
||||
|
||||
// State.
|
||||
#include "doomstat.h"
|
||||
#include "r_state.h"
|
||||
// Data.
|
||||
#include "sounds.h"
|
||||
|
||||
|
||||
//
|
||||
// FLOORS
|
||||
//
|
||||
|
||||
//
|
||||
// Move a plane (floor or ceiling) and check for crushing
|
||||
//
|
||||
result_e
|
||||
T_MovePlane
|
||||
( sector_t* sector,
|
||||
fixed_t speed,
|
||||
fixed_t dest,
|
||||
boolean crush,
|
||||
int floorOrCeiling,
|
||||
int direction )
|
||||
{
|
||||
boolean flag;
|
||||
fixed_t lastpos;
|
||||
|
||||
switch(floorOrCeiling)
|
||||
{
|
||||
case 0:
|
||||
// FLOOR
|
||||
switch(direction)
|
||||
{
|
||||
case -1:
|
||||
// DOWN
|
||||
if (sector->floorheight - speed < dest)
|
||||
{
|
||||
lastpos = sector->floorheight;
|
||||
sector->floorheight = dest;
|
||||
flag = P_ChangeSector(sector,crush);
|
||||
if (flag == true)
|
||||
{
|
||||
sector->floorheight =lastpos;
|
||||
P_ChangeSector(sector,crush);
|
||||
//return crushed;
|
||||
}
|
||||
return pastdest;
|
||||
}
|
||||
else
|
||||
{
|
||||
lastpos = sector->floorheight;
|
||||
sector->floorheight -= speed;
|
||||
flag = P_ChangeSector(sector,crush);
|
||||
if (flag == true)
|
||||
{
|
||||
sector->floorheight = lastpos;
|
||||
P_ChangeSector(sector,crush);
|
||||
return crushed;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 1:
|
||||
// UP
|
||||
if (sector->floorheight + speed > dest)
|
||||
{
|
||||
lastpos = sector->floorheight;
|
||||
sector->floorheight = dest;
|
||||
flag = P_ChangeSector(sector,crush);
|
||||
if (flag == true)
|
||||
{
|
||||
sector->floorheight = lastpos;
|
||||
P_ChangeSector(sector,crush);
|
||||
//return crushed;
|
||||
}
|
||||
return pastdest;
|
||||
}
|
||||
else
|
||||
{
|
||||
// COULD GET CRUSHED
|
||||
lastpos = sector->floorheight;
|
||||
sector->floorheight += speed;
|
||||
flag = P_ChangeSector(sector,crush);
|
||||
if (flag == true)
|
||||
{
|
||||
if (crush == true)
|
||||
return crushed;
|
||||
sector->floorheight = lastpos;
|
||||
P_ChangeSector(sector,crush);
|
||||
return crushed;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
case 1:
|
||||
// CEILING
|
||||
switch(direction)
|
||||
{
|
||||
case -1:
|
||||
// DOWN
|
||||
if (sector->ceilingheight - speed < dest)
|
||||
{
|
||||
lastpos = sector->ceilingheight;
|
||||
sector->ceilingheight = dest;
|
||||
flag = P_ChangeSector(sector,crush);
|
||||
|
||||
if (flag == true)
|
||||
{
|
||||
sector->ceilingheight = lastpos;
|
||||
P_ChangeSector(sector,crush);
|
||||
//return crushed;
|
||||
}
|
||||
return pastdest;
|
||||
}
|
||||
else
|
||||
{
|
||||
// COULD GET CRUSHED
|
||||
lastpos = sector->ceilingheight;
|
||||
sector->ceilingheight -= speed;
|
||||
flag = P_ChangeSector(sector,crush);
|
||||
|
||||
if (flag == true)
|
||||
{
|
||||
if (crush == true)
|
||||
return crushed;
|
||||
sector->ceilingheight = lastpos;
|
||||
P_ChangeSector(sector,crush);
|
||||
return crushed;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case 1:
|
||||
// UP
|
||||
if (sector->ceilingheight + speed > dest)
|
||||
{
|
||||
lastpos = sector->ceilingheight;
|
||||
sector->ceilingheight = dest;
|
||||
flag = P_ChangeSector(sector,crush);
|
||||
if (flag == true)
|
||||
{
|
||||
sector->ceilingheight = lastpos;
|
||||
P_ChangeSector(sector,crush);
|
||||
//return crushed;
|
||||
}
|
||||
return pastdest;
|
||||
}
|
||||
else
|
||||
{
|
||||
lastpos = sector->ceilingheight;
|
||||
sector->ceilingheight += speed;
|
||||
flag = P_ChangeSector(sector,crush);
|
||||
// UNUSED
|
||||
#if 0
|
||||
if (flag == true)
|
||||
{
|
||||
sector->ceilingheight = lastpos;
|
||||
P_ChangeSector(sector,crush);
|
||||
return crushed;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
}
|
||||
return ok;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// MOVE A FLOOR TO IT'S DESTINATION (UP OR DOWN)
|
||||
//
|
||||
void T_MoveFloor(floormove_t* floor)
|
||||
{
|
||||
result_e res;
|
||||
|
||||
res = T_MovePlane(floor->sector,
|
||||
floor->speed,
|
||||
floor->floordestheight,
|
||||
floor->crush,0,floor->direction);
|
||||
|
||||
if (!(leveltime&7))
|
||||
S_StartSound((mobj_t *)&floor->sector->soundorg,
|
||||
sfx_stnmov);
|
||||
|
||||
if (res == pastdest)
|
||||
{
|
||||
floor->sector->specialdata = NULL;
|
||||
|
||||
if (floor->direction == 1)
|
||||
{
|
||||
switch(floor->type)
|
||||
{
|
||||
case donutRaise:
|
||||
floor->sector->special = floor->newspecial;
|
||||
floor->sector->floorpic = floor->texture;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (floor->direction == -1)
|
||||
{
|
||||
switch(floor->type)
|
||||
{
|
||||
case lowerAndChange:
|
||||
floor->sector->special = floor->newspecial;
|
||||
floor->sector->floorpic = floor->texture;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
P_RemoveThinker(&floor->thinker);
|
||||
|
||||
S_StartSound((mobj_t *)&floor->sector->soundorg,
|
||||
sfx_pstop);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//
|
||||
// HANDLE FLOOR TYPES
|
||||
//
|
||||
int
|
||||
EV_DoFloor
|
||||
( line_t* line,
|
||||
floor_e floortype )
|
||||
{
|
||||
int secnum;
|
||||
int rtn;
|
||||
int i;
|
||||
sector_t* sec;
|
||||
floormove_t* floor;
|
||||
|
||||
secnum = -1;
|
||||
rtn = 0;
|
||||
while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
|
||||
{
|
||||
sec = §ors[secnum];
|
||||
|
||||
// ALREADY MOVING? IF SO, KEEP GOING...
|
||||
if (sec->specialdata)
|
||||
continue;
|
||||
|
||||
// new floor thinker
|
||||
rtn = 1;
|
||||
floor = Z_Malloc (sizeof(*floor), PU_LEVSPEC, 0);
|
||||
P_AddThinker (&floor->thinker);
|
||||
sec->specialdata = floor;
|
||||
floor->thinker.function.acp1 = (actionf_p1) T_MoveFloor;
|
||||
floor->type = floortype;
|
||||
floor->crush = false;
|
||||
|
||||
switch(floortype)
|
||||
{
|
||||
case lowerFloor:
|
||||
floor->direction = -1;
|
||||
floor->sector = sec;
|
||||
floor->speed = FLOORSPEED;
|
||||
floor->floordestheight =
|
||||
P_FindHighestFloorSurrounding(sec);
|
||||
break;
|
||||
|
||||
case lowerFloorToLowest:
|
||||
floor->direction = -1;
|
||||
floor->sector = sec;
|
||||
floor->speed = FLOORSPEED;
|
||||
floor->floordestheight =
|
||||
P_FindLowestFloorSurrounding(sec);
|
||||
break;
|
||||
|
||||
case turboLower:
|
||||
floor->direction = -1;
|
||||
floor->sector = sec;
|
||||
floor->speed = FLOORSPEED * 4;
|
||||
floor->floordestheight =
|
||||
P_FindHighestFloorSurrounding(sec);
|
||||
if (floor->floordestheight != sec->floorheight)
|
||||
floor->floordestheight += 8*FRACUNIT;
|
||||
break;
|
||||
|
||||
case raiseFloorCrush:
|
||||
floor->crush = true;
|
||||
case raiseFloor:
|
||||
floor->direction = 1;
|
||||
floor->sector = sec;
|
||||
floor->speed = FLOORSPEED;
|
||||
floor->floordestheight =
|
||||
P_FindLowestCeilingSurrounding(sec);
|
||||
if (floor->floordestheight > sec->ceilingheight)
|
||||
floor->floordestheight = sec->ceilingheight;
|
||||
floor->floordestheight -= (8*FRACUNIT)*
|
||||
(floortype == raiseFloorCrush);
|
||||
break;
|
||||
|
||||
case raiseFloorTurbo:
|
||||
floor->direction = 1;
|
||||
floor->sector = sec;
|
||||
floor->speed = FLOORSPEED*4;
|
||||
floor->floordestheight =
|
||||
P_FindNextHighestFloor(sec,sec->floorheight);
|
||||
break;
|
||||
|
||||
case raiseFloorToNearest:
|
||||
floor->direction = 1;
|
||||
floor->sector = sec;
|
||||
floor->speed = FLOORSPEED;
|
||||
floor->floordestheight =
|
||||
P_FindNextHighestFloor(sec,sec->floorheight);
|
||||
break;
|
||||
|
||||
case raiseFloor24:
|
||||
floor->direction = 1;
|
||||
floor->sector = sec;
|
||||
floor->speed = FLOORSPEED;
|
||||
floor->floordestheight = floor->sector->floorheight +
|
||||
24 * FRACUNIT;
|
||||
break;
|
||||
case raiseFloor512:
|
||||
floor->direction = 1;
|
||||
floor->sector = sec;
|
||||
floor->speed = FLOORSPEED;
|
||||
floor->floordestheight = floor->sector->floorheight +
|
||||
512 * FRACUNIT;
|
||||
break;
|
||||
|
||||
case raiseFloor24AndChange:
|
||||
floor->direction = 1;
|
||||
floor->sector = sec;
|
||||
floor->speed = FLOORSPEED;
|
||||
floor->floordestheight = floor->sector->floorheight +
|
||||
24 * FRACUNIT;
|
||||
sec->floorpic = line->frontsector->floorpic;
|
||||
sec->special = line->frontsector->special;
|
||||
break;
|
||||
|
||||
case raiseToTexture:
|
||||
{
|
||||
int minsize = MAXINT;
|
||||
side_t* side;
|
||||
|
||||
floor->direction = 1;
|
||||
floor->sector = sec;
|
||||
floor->speed = FLOORSPEED;
|
||||
for (i = 0; i < sec->linecount; i++)
|
||||
{
|
||||
if (twoSided (secnum, i) )
|
||||
{
|
||||
side = getSide(secnum,i,0);
|
||||
if (side->bottomtexture >= 0)
|
||||
if (textureheight[side->bottomtexture] <
|
||||
minsize)
|
||||
minsize =
|
||||
textureheight[side->bottomtexture];
|
||||
side = getSide(secnum,i,1);
|
||||
if (side->bottomtexture >= 0)
|
||||
if (textureheight[side->bottomtexture] <
|
||||
minsize)
|
||||
minsize =
|
||||
textureheight[side->bottomtexture];
|
||||
}
|
||||
}
|
||||
floor->floordestheight =
|
||||
floor->sector->floorheight + minsize;
|
||||
}
|
||||
break;
|
||||
|
||||
case lowerAndChange:
|
||||
floor->direction = -1;
|
||||
floor->sector = sec;
|
||||
floor->speed = FLOORSPEED;
|
||||
floor->floordestheight =
|
||||
P_FindLowestFloorSurrounding(sec);
|
||||
floor->texture = sec->floorpic;
|
||||
|
||||
for (i = 0; i < sec->linecount; i++)
|
||||
{
|
||||
if ( twoSided(secnum, i) )
|
||||
{
|
||||
if (getSide(secnum,i,0)->sector-sectors == secnum)
|
||||
{
|
||||
sec = getSector(secnum,i,1);
|
||||
|
||||
if (sec->floorheight == floor->floordestheight)
|
||||
{
|
||||
floor->texture = sec->floorpic;
|
||||
floor->newspecial = sec->special;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
sec = getSector(secnum,i,0);
|
||||
|
||||
if (sec->floorheight == floor->floordestheight)
|
||||
{
|
||||
floor->texture = sec->floorpic;
|
||||
floor->newspecial = sec->special;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return rtn;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// BUILD A STAIRCASE!
|
||||
//
|
||||
int
|
||||
EV_BuildStairs
|
||||
( line_t* line,
|
||||
stair_e type )
|
||||
{
|
||||
int secnum;
|
||||
int height;
|
||||
int i;
|
||||
int newsecnum;
|
||||
int texture;
|
||||
int ok;
|
||||
int rtn;
|
||||
|
||||
sector_t* sec;
|
||||
sector_t* tsec;
|
||||
|
||||
floormove_t* floor;
|
||||
|
||||
fixed_t stairsize;
|
||||
fixed_t speed;
|
||||
|
||||
secnum = -1;
|
||||
rtn = 0;
|
||||
while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
|
||||
{
|
||||
sec = §ors[secnum];
|
||||
|
||||
// ALREADY MOVING? IF SO, KEEP GOING...
|
||||
if (sec->specialdata)
|
||||
continue;
|
||||
|
||||
// new floor thinker
|
||||
rtn = 1;
|
||||
floor = Z_Malloc (sizeof(*floor), PU_LEVSPEC, 0);
|
||||
P_AddThinker (&floor->thinker);
|
||||
sec->specialdata = floor;
|
||||
floor->thinker.function.acp1 = (actionf_p1) T_MoveFloor;
|
||||
floor->direction = 1;
|
||||
floor->sector = sec;
|
||||
switch(type)
|
||||
{
|
||||
case build8:
|
||||
speed = FLOORSPEED/4;
|
||||
stairsize = 8*FRACUNIT;
|
||||
break;
|
||||
case turbo16:
|
||||
speed = FLOORSPEED*4;
|
||||
stairsize = 16*FRACUNIT;
|
||||
break;
|
||||
}
|
||||
floor->speed = speed;
|
||||
height = sec->floorheight + stairsize;
|
||||
floor->floordestheight = height;
|
||||
|
||||
texture = sec->floorpic;
|
||||
|
||||
// Find next sector to raise
|
||||
// 1. Find 2-sided line with same sector side[0]
|
||||
// 2. Other side is the next sector to raise
|
||||
do
|
||||
{
|
||||
ok = 0;
|
||||
for (i = 0;i < sec->linecount;i++)
|
||||
{
|
||||
if ( !((sec->lines[i])->flags & ML_TWOSIDED) )
|
||||
continue;
|
||||
|
||||
tsec = (sec->lines[i])->frontsector;
|
||||
newsecnum = tsec-sectors;
|
||||
|
||||
if (secnum != newsecnum)
|
||||
continue;
|
||||
|
||||
tsec = (sec->lines[i])->backsector;
|
||||
newsecnum = tsec - sectors;
|
||||
|
||||
if (tsec->floorpic != texture)
|
||||
continue;
|
||||
|
||||
height += stairsize;
|
||||
|
||||
if (tsec->specialdata)
|
||||
continue;
|
||||
|
||||
sec = tsec;
|
||||
secnum = newsecnum;
|
||||
floor = Z_Malloc (sizeof(*floor), PU_LEVSPEC, 0);
|
||||
|
||||
P_AddThinker (&floor->thinker);
|
||||
|
||||
sec->specialdata = floor;
|
||||
floor->thinker.function.acp1 = (actionf_p1) T_MoveFloor;
|
||||
floor->direction = 1;
|
||||
floor->sector = sec;
|
||||
floor->speed = speed;
|
||||
floor->floordestheight = height;
|
||||
ok = 1;
|
||||
break;
|
||||
}
|
||||
} while(ok);
|
||||
}
|
||||
return rtn;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,918 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Handling interactions (i.e., collisions).
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_inter.c,v 1.4 1997/02/03 22:45:11 b1 Exp $";
|
||||
|
||||
|
||||
// Data.
|
||||
#include "doomdef.h"
|
||||
#include "dstrings.h"
|
||||
#include "sounds.h"
|
||||
|
||||
#include "doomstat.h"
|
||||
|
||||
#include "m_random.h"
|
||||
#include "i_system.h"
|
||||
|
||||
#include "am_map.h"
|
||||
|
||||
#include "p_local.h"
|
||||
|
||||
#include "s_sound.h"
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation "p_inter.h"
|
||||
#endif
|
||||
#include "p_inter.h"
|
||||
|
||||
|
||||
#define BONUSADD 6
|
||||
|
||||
|
||||
|
||||
|
||||
// a weapon is found with two clip loads,
|
||||
// a big item has five clip loads
|
||||
int maxammo[NUMAMMO] = {200, 50, 300, 50};
|
||||
int clipammo[NUMAMMO] = {10, 4, 20, 1};
|
||||
|
||||
|
||||
//
|
||||
// GET STUFF
|
||||
//
|
||||
|
||||
//
|
||||
// P_GiveAmmo
|
||||
// Num is the number of clip loads,
|
||||
// not the individual count (0= 1/2 clip).
|
||||
// Returns false if the ammo can't be picked up at all
|
||||
//
|
||||
|
||||
boolean
|
||||
P_GiveAmmo
|
||||
( player_t* player,
|
||||
ammotype_t ammo,
|
||||
int num )
|
||||
{
|
||||
int oldammo;
|
||||
|
||||
if (ammo == am_noammo)
|
||||
return false;
|
||||
|
||||
if (ammo < 0 || ammo > NUMAMMO)
|
||||
I_Error ("P_GiveAmmo: bad type %i", ammo);
|
||||
|
||||
if ( player->ammo[ammo] == player->maxammo[ammo] )
|
||||
return false;
|
||||
|
||||
if (num)
|
||||
num *= clipammo[ammo];
|
||||
else
|
||||
num = clipammo[ammo]/2;
|
||||
|
||||
if (gameskill == sk_baby
|
||||
|| gameskill == sk_nightmare)
|
||||
{
|
||||
// give double ammo in trainer mode,
|
||||
// you'll need in nightmare
|
||||
num <<= 1;
|
||||
}
|
||||
|
||||
|
||||
oldammo = player->ammo[ammo];
|
||||
player->ammo[ammo] += num;
|
||||
|
||||
if (player->ammo[ammo] > player->maxammo[ammo])
|
||||
player->ammo[ammo] = player->maxammo[ammo];
|
||||
|
||||
// If non zero ammo,
|
||||
// don't change up weapons,
|
||||
// player was lower on purpose.
|
||||
if (oldammo)
|
||||
return true;
|
||||
|
||||
// We were down to zero,
|
||||
// so select a new weapon.
|
||||
// Preferences are not user selectable.
|
||||
switch (ammo)
|
||||
{
|
||||
case am_clip:
|
||||
if (player->readyweapon == wp_fist)
|
||||
{
|
||||
if (player->weaponowned[wp_chaingun])
|
||||
player->pendingweapon = wp_chaingun;
|
||||
else
|
||||
player->pendingweapon = wp_pistol;
|
||||
}
|
||||
break;
|
||||
|
||||
case am_shell:
|
||||
if (player->readyweapon == wp_fist
|
||||
|| player->readyweapon == wp_pistol)
|
||||
{
|
||||
if (player->weaponowned[wp_shotgun])
|
||||
player->pendingweapon = wp_shotgun;
|
||||
}
|
||||
break;
|
||||
|
||||
case am_cell:
|
||||
if (player->readyweapon == wp_fist
|
||||
|| player->readyweapon == wp_pistol)
|
||||
{
|
||||
if (player->weaponowned[wp_plasma])
|
||||
player->pendingweapon = wp_plasma;
|
||||
}
|
||||
break;
|
||||
|
||||
case am_misl:
|
||||
if (player->readyweapon == wp_fist)
|
||||
{
|
||||
if (player->weaponowned[wp_missile])
|
||||
player->pendingweapon = wp_missile;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_GiveWeapon
|
||||
// The weapon name may have a MF_DROPPED flag ored in.
|
||||
//
|
||||
boolean
|
||||
P_GiveWeapon
|
||||
( player_t* player,
|
||||
weapontype_t weapon,
|
||||
boolean dropped )
|
||||
{
|
||||
boolean gaveammo;
|
||||
boolean gaveweapon;
|
||||
|
||||
if (netgame
|
||||
&& (deathmatch!=2)
|
||||
&& !dropped )
|
||||
{
|
||||
// leave placed weapons forever on net games
|
||||
if (player->weaponowned[weapon])
|
||||
return false;
|
||||
|
||||
player->bonuscount += BONUSADD;
|
||||
player->weaponowned[weapon] = true;
|
||||
|
||||
if (deathmatch)
|
||||
P_GiveAmmo (player, weaponinfo[weapon].ammo, 5);
|
||||
else
|
||||
P_GiveAmmo (player, weaponinfo[weapon].ammo, 2);
|
||||
player->pendingweapon = weapon;
|
||||
|
||||
if (player == &players[consoleplayer])
|
||||
S_StartSound (NULL, sfx_wpnup);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (weaponinfo[weapon].ammo != am_noammo)
|
||||
{
|
||||
// give one clip with a dropped weapon,
|
||||
// two clips with a found weapon
|
||||
if (dropped)
|
||||
gaveammo = P_GiveAmmo (player, weaponinfo[weapon].ammo, 1);
|
||||
else
|
||||
gaveammo = P_GiveAmmo (player, weaponinfo[weapon].ammo, 2);
|
||||
}
|
||||
else
|
||||
gaveammo = false;
|
||||
|
||||
if (player->weaponowned[weapon])
|
||||
gaveweapon = false;
|
||||
else
|
||||
{
|
||||
gaveweapon = true;
|
||||
player->weaponowned[weapon] = true;
|
||||
player->pendingweapon = weapon;
|
||||
}
|
||||
|
||||
return (gaveweapon || gaveammo);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_GiveBody
|
||||
// Returns false if the body isn't needed at all
|
||||
//
|
||||
boolean
|
||||
P_GiveBody
|
||||
( player_t* player,
|
||||
int num )
|
||||
{
|
||||
if (player->health >= MAXHEALTH)
|
||||
return false;
|
||||
|
||||
player->health += num;
|
||||
if (player->health > MAXHEALTH)
|
||||
player->health = MAXHEALTH;
|
||||
player->mo->health = player->health;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_GiveArmor
|
||||
// Returns false if the armor is worse
|
||||
// than the current armor.
|
||||
//
|
||||
boolean
|
||||
P_GiveArmor
|
||||
( player_t* player,
|
||||
int armortype )
|
||||
{
|
||||
int hits;
|
||||
|
||||
hits = armortype*100;
|
||||
if (player->armorpoints >= hits)
|
||||
return false; // don't pick up
|
||||
|
||||
player->armortype = armortype;
|
||||
player->armorpoints = hits;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_GiveCard
|
||||
//
|
||||
void
|
||||
P_GiveCard
|
||||
( player_t* player,
|
||||
card_t card )
|
||||
{
|
||||
if (player->cards[card])
|
||||
return;
|
||||
|
||||
player->bonuscount = BONUSADD;
|
||||
player->cards[card] = 1;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_GivePower
|
||||
//
|
||||
boolean
|
||||
P_GivePower
|
||||
( player_t* player,
|
||||
int /*powertype_t*/ power )
|
||||
{
|
||||
if (power == pw_invulnerability)
|
||||
{
|
||||
player->powers[power] = INVULNTICS;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (power == pw_invisibility)
|
||||
{
|
||||
player->powers[power] = INVISTICS;
|
||||
player->mo->flags |= MF_SHADOW;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (power == pw_infrared)
|
||||
{
|
||||
player->powers[power] = INFRATICS;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (power == pw_ironfeet)
|
||||
{
|
||||
player->powers[power] = IRONTICS;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (power == pw_strength)
|
||||
{
|
||||
P_GiveBody (player, 100);
|
||||
player->powers[power] = 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (player->powers[power])
|
||||
return false; // already got it
|
||||
|
||||
player->powers[power] = 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_TouchSpecialThing
|
||||
//
|
||||
void
|
||||
P_TouchSpecialThing
|
||||
( mobj_t* special,
|
||||
mobj_t* toucher )
|
||||
{
|
||||
player_t* player;
|
||||
int i;
|
||||
fixed_t delta;
|
||||
int sound;
|
||||
|
||||
delta = special->z - toucher->z;
|
||||
|
||||
if (delta > toucher->height
|
||||
|| delta < -8*FRACUNIT)
|
||||
{
|
||||
// out of reach
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
sound = sfx_itemup;
|
||||
player = toucher->player;
|
||||
|
||||
// Dead thing touching.
|
||||
// Can happen with a sliding player corpse.
|
||||
if (toucher->health <= 0)
|
||||
return;
|
||||
|
||||
// Identify by sprite.
|
||||
switch (special->sprite)
|
||||
{
|
||||
// armor
|
||||
case SPR_ARM1:
|
||||
if (!P_GiveArmor (player, 1))
|
||||
return;
|
||||
player->message = GOTARMOR;
|
||||
break;
|
||||
|
||||
case SPR_ARM2:
|
||||
if (!P_GiveArmor (player, 2))
|
||||
return;
|
||||
player->message = GOTMEGA;
|
||||
break;
|
||||
|
||||
// bonus items
|
||||
case SPR_BON1:
|
||||
player->health++; // can go over 100%
|
||||
if (player->health > 200)
|
||||
player->health = 200;
|
||||
player->mo->health = player->health;
|
||||
player->message = GOTHTHBONUS;
|
||||
break;
|
||||
|
||||
case SPR_BON2:
|
||||
player->armorpoints++; // can go over 100%
|
||||
if (player->armorpoints > 200)
|
||||
player->armorpoints = 200;
|
||||
if (!player->armortype)
|
||||
player->armortype = 1;
|
||||
player->message = GOTARMBONUS;
|
||||
break;
|
||||
|
||||
case SPR_SOUL:
|
||||
player->health += 100;
|
||||
if (player->health > 200)
|
||||
player->health = 200;
|
||||
player->mo->health = player->health;
|
||||
player->message = GOTSUPER;
|
||||
sound = sfx_getpow;
|
||||
break;
|
||||
|
||||
case SPR_MEGA:
|
||||
if (gamemode != commercial)
|
||||
return;
|
||||
player->health = 200;
|
||||
player->mo->health = player->health;
|
||||
P_GiveArmor (player,2);
|
||||
player->message = GOTMSPHERE;
|
||||
sound = sfx_getpow;
|
||||
break;
|
||||
|
||||
// cards
|
||||
// leave cards for everyone
|
||||
case SPR_BKEY:
|
||||
if (!player->cards[it_bluecard])
|
||||
player->message = GOTBLUECARD;
|
||||
P_GiveCard (player, it_bluecard);
|
||||
if (!netgame)
|
||||
break;
|
||||
return;
|
||||
|
||||
case SPR_YKEY:
|
||||
if (!player->cards[it_yellowcard])
|
||||
player->message = GOTYELWCARD;
|
||||
P_GiveCard (player, it_yellowcard);
|
||||
if (!netgame)
|
||||
break;
|
||||
return;
|
||||
|
||||
case SPR_RKEY:
|
||||
if (!player->cards[it_redcard])
|
||||
player->message = GOTREDCARD;
|
||||
P_GiveCard (player, it_redcard);
|
||||
if (!netgame)
|
||||
break;
|
||||
return;
|
||||
|
||||
case SPR_BSKU:
|
||||
if (!player->cards[it_blueskull])
|
||||
player->message = GOTBLUESKUL;
|
||||
P_GiveCard (player, it_blueskull);
|
||||
if (!netgame)
|
||||
break;
|
||||
return;
|
||||
|
||||
case SPR_YSKU:
|
||||
if (!player->cards[it_yellowskull])
|
||||
player->message = GOTYELWSKUL;
|
||||
P_GiveCard (player, it_yellowskull);
|
||||
if (!netgame)
|
||||
break;
|
||||
return;
|
||||
|
||||
case SPR_RSKU:
|
||||
if (!player->cards[it_redskull])
|
||||
player->message = GOTREDSKULL;
|
||||
P_GiveCard (player, it_redskull);
|
||||
if (!netgame)
|
||||
break;
|
||||
return;
|
||||
|
||||
// medikits, heals
|
||||
case SPR_STIM:
|
||||
if (!P_GiveBody (player, 10))
|
||||
return;
|
||||
player->message = GOTSTIM;
|
||||
break;
|
||||
|
||||
case SPR_MEDI:
|
||||
if (!P_GiveBody (player, 25))
|
||||
return;
|
||||
|
||||
if (player->health < 25)
|
||||
player->message = GOTMEDINEED;
|
||||
else
|
||||
player->message = GOTMEDIKIT;
|
||||
break;
|
||||
|
||||
|
||||
// power ups
|
||||
case SPR_PINV:
|
||||
if (!P_GivePower (player, pw_invulnerability))
|
||||
return;
|
||||
player->message = GOTINVUL;
|
||||
sound = sfx_getpow;
|
||||
break;
|
||||
|
||||
case SPR_PSTR:
|
||||
if (!P_GivePower (player, pw_strength))
|
||||
return;
|
||||
player->message = GOTBERSERK;
|
||||
if (player->readyweapon != wp_fist)
|
||||
player->pendingweapon = wp_fist;
|
||||
sound = sfx_getpow;
|
||||
break;
|
||||
|
||||
case SPR_PINS:
|
||||
if (!P_GivePower (player, pw_invisibility))
|
||||
return;
|
||||
player->message = GOTINVIS;
|
||||
sound = sfx_getpow;
|
||||
break;
|
||||
|
||||
case SPR_SUIT:
|
||||
if (!P_GivePower (player, pw_ironfeet))
|
||||
return;
|
||||
player->message = GOTSUIT;
|
||||
sound = sfx_getpow;
|
||||
break;
|
||||
|
||||
case SPR_PMAP:
|
||||
if (!P_GivePower (player, pw_allmap))
|
||||
return;
|
||||
player->message = GOTMAP;
|
||||
sound = sfx_getpow;
|
||||
break;
|
||||
|
||||
case SPR_PVIS:
|
||||
if (!P_GivePower (player, pw_infrared))
|
||||
return;
|
||||
player->message = GOTVISOR;
|
||||
sound = sfx_getpow;
|
||||
break;
|
||||
|
||||
// ammo
|
||||
case SPR_CLIP:
|
||||
if (special->flags & MF_DROPPED)
|
||||
{
|
||||
if (!P_GiveAmmo (player,am_clip,0))
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!P_GiveAmmo (player,am_clip,1))
|
||||
return;
|
||||
}
|
||||
player->message = GOTCLIP;
|
||||
break;
|
||||
|
||||
case SPR_AMMO:
|
||||
if (!P_GiveAmmo (player, am_clip,5))
|
||||
return;
|
||||
player->message = GOTCLIPBOX;
|
||||
break;
|
||||
|
||||
case SPR_ROCK:
|
||||
if (!P_GiveAmmo (player, am_misl,1))
|
||||
return;
|
||||
player->message = GOTROCKET;
|
||||
break;
|
||||
|
||||
case SPR_BROK:
|
||||
if (!P_GiveAmmo (player, am_misl,5))
|
||||
return;
|
||||
player->message = GOTROCKBOX;
|
||||
break;
|
||||
|
||||
case SPR_CELL:
|
||||
if (!P_GiveAmmo (player, am_cell,1))
|
||||
return;
|
||||
player->message = GOTCELL;
|
||||
break;
|
||||
|
||||
case SPR_CELP:
|
||||
if (!P_GiveAmmo (player, am_cell,5))
|
||||
return;
|
||||
player->message = GOTCELLBOX;
|
||||
break;
|
||||
|
||||
case SPR_SHEL:
|
||||
if (!P_GiveAmmo (player, am_shell,1))
|
||||
return;
|
||||
player->message = GOTSHELLS;
|
||||
break;
|
||||
|
||||
case SPR_SBOX:
|
||||
if (!P_GiveAmmo (player, am_shell,5))
|
||||
return;
|
||||
player->message = GOTSHELLBOX;
|
||||
break;
|
||||
|
||||
case SPR_BPAK:
|
||||
if (!player->backpack)
|
||||
{
|
||||
for (i=0 ; i<NUMAMMO ; i++)
|
||||
player->maxammo[i] *= 2;
|
||||
player->backpack = true;
|
||||
}
|
||||
for (i=0 ; i<NUMAMMO ; i++)
|
||||
P_GiveAmmo (player, i, 1);
|
||||
player->message = GOTBACKPACK;
|
||||
break;
|
||||
|
||||
// weapons
|
||||
case SPR_BFUG:
|
||||
if (!P_GiveWeapon (player, wp_bfg, false) )
|
||||
return;
|
||||
player->message = GOTBFG9000;
|
||||
sound = sfx_wpnup;
|
||||
break;
|
||||
|
||||
case SPR_MGUN:
|
||||
if (!P_GiveWeapon (player, wp_chaingun, special->flags&MF_DROPPED) )
|
||||
return;
|
||||
player->message = GOTCHAINGUN;
|
||||
sound = sfx_wpnup;
|
||||
break;
|
||||
|
||||
case SPR_CSAW:
|
||||
if (!P_GiveWeapon (player, wp_chainsaw, false) )
|
||||
return;
|
||||
player->message = GOTCHAINSAW;
|
||||
sound = sfx_wpnup;
|
||||
break;
|
||||
|
||||
case SPR_LAUN:
|
||||
if (!P_GiveWeapon (player, wp_missile, false) )
|
||||
return;
|
||||
player->message = GOTLAUNCHER;
|
||||
sound = sfx_wpnup;
|
||||
break;
|
||||
|
||||
case SPR_PLAS:
|
||||
if (!P_GiveWeapon (player, wp_plasma, false) )
|
||||
return;
|
||||
player->message = GOTPLASMA;
|
||||
sound = sfx_wpnup;
|
||||
break;
|
||||
|
||||
case SPR_SHOT:
|
||||
if (!P_GiveWeapon (player, wp_shotgun, special->flags&MF_DROPPED ) )
|
||||
return;
|
||||
player->message = GOTSHOTGUN;
|
||||
sound = sfx_wpnup;
|
||||
break;
|
||||
|
||||
case SPR_SGN2:
|
||||
if (!P_GiveWeapon (player, wp_supershotgun, special->flags&MF_DROPPED ) )
|
||||
return;
|
||||
player->message = GOTSHOTGUN2;
|
||||
sound = sfx_wpnup;
|
||||
break;
|
||||
|
||||
default:
|
||||
I_Error ("P_SpecialThing: Unknown gettable thing");
|
||||
}
|
||||
|
||||
if (special->flags & MF_COUNTITEM)
|
||||
player->itemcount++;
|
||||
P_RemoveMobj (special);
|
||||
player->bonuscount += BONUSADD;
|
||||
if (player == &players[consoleplayer])
|
||||
S_StartSound (NULL, sound);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// KillMobj
|
||||
//
|
||||
void
|
||||
P_KillMobj
|
||||
( mobj_t* source,
|
||||
mobj_t* target )
|
||||
{
|
||||
mobjtype_t item;
|
||||
mobj_t* mo;
|
||||
|
||||
target->flags &= ~(MF_SHOOTABLE|MF_FLOAT|MF_SKULLFLY);
|
||||
|
||||
if (target->type != MT_SKULL)
|
||||
target->flags &= ~MF_NOGRAVITY;
|
||||
|
||||
target->flags |= MF_CORPSE|MF_DROPOFF;
|
||||
target->height >>= 2;
|
||||
|
||||
if (source && source->player)
|
||||
{
|
||||
// count for intermission
|
||||
if (target->flags & MF_COUNTKILL)
|
||||
source->player->killcount++;
|
||||
|
||||
if (target->player)
|
||||
source->player->frags[target->player-players]++;
|
||||
}
|
||||
else if (!netgame && (target->flags & MF_COUNTKILL) )
|
||||
{
|
||||
// count all monster deaths,
|
||||
// even those caused by other monsters
|
||||
players[0].killcount++;
|
||||
}
|
||||
|
||||
if (target->player)
|
||||
{
|
||||
// count environment kills against you
|
||||
if (!source)
|
||||
target->player->frags[target->player-players]++;
|
||||
|
||||
target->flags &= ~MF_SOLID;
|
||||
target->player->playerstate = PST_DEAD;
|
||||
P_DropWeapon (target->player);
|
||||
|
||||
if (target->player == &players[consoleplayer]
|
||||
&& automapactive)
|
||||
{
|
||||
// don't die in auto map,
|
||||
// switch view prior to dying
|
||||
AM_Stop ();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if (target->health < -target->info->spawnhealth
|
||||
&& target->info->xdeathstate)
|
||||
{
|
||||
P_SetMobjState (target, target->info->xdeathstate);
|
||||
}
|
||||
else
|
||||
P_SetMobjState (target, target->info->deathstate);
|
||||
target->tics -= P_Random()&3;
|
||||
|
||||
if (target->tics < 1)
|
||||
target->tics = 1;
|
||||
|
||||
// I_StartSound (&actor->r, actor->info->deathsound);
|
||||
|
||||
|
||||
// Drop stuff.
|
||||
// This determines the kind of object spawned
|
||||
// during the death frame of a thing.
|
||||
switch (target->type)
|
||||
{
|
||||
case MT_WOLFSS:
|
||||
case MT_POSSESSED:
|
||||
item = MT_CLIP;
|
||||
break;
|
||||
|
||||
case MT_SHOTGUY:
|
||||
item = MT_SHOTGUN;
|
||||
break;
|
||||
|
||||
case MT_CHAINGUY:
|
||||
item = MT_CHAINGUN;
|
||||
break;
|
||||
|
||||
default:
|
||||
return;
|
||||
}
|
||||
|
||||
mo = P_SpawnMobj (target->x,target->y,ONFLOORZ, item);
|
||||
mo->flags |= MF_DROPPED; // special versions of items
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_DamageMobj
|
||||
// Damages both enemies and players
|
||||
// "inflictor" is the thing that caused the damage
|
||||
// creature or missile, can be NULL (slime, etc)
|
||||
// "source" is the thing to target after taking damage
|
||||
// creature or NULL
|
||||
// Source and inflictor are the same for melee attacks.
|
||||
// Source can be NULL for slime, barrel explosions
|
||||
// and other environmental stuff.
|
||||
//
|
||||
void
|
||||
P_DamageMobj
|
||||
( mobj_t* target,
|
||||
mobj_t* inflictor,
|
||||
mobj_t* source,
|
||||
int damage )
|
||||
{
|
||||
unsigned ang;
|
||||
int saved;
|
||||
player_t* player;
|
||||
fixed_t thrust;
|
||||
int temp;
|
||||
|
||||
if ( !(target->flags & MF_SHOOTABLE) )
|
||||
return; // shouldn't happen...
|
||||
|
||||
if (target->health <= 0)
|
||||
return;
|
||||
|
||||
if ( target->flags & MF_SKULLFLY )
|
||||
{
|
||||
target->momx = target->momy = target->momz = 0;
|
||||
}
|
||||
|
||||
player = target->player;
|
||||
if (player && gameskill == sk_baby)
|
||||
damage >>= 1; // take half damage in trainer mode
|
||||
|
||||
|
||||
// Some close combat weapons should not
|
||||
// inflict thrust and push the victim out of reach,
|
||||
// thus kick away unless using the chainsaw.
|
||||
if (inflictor
|
||||
&& !(target->flags & MF_NOCLIP)
|
||||
&& (!source
|
||||
|| !source->player
|
||||
|| source->player->readyweapon != wp_chainsaw))
|
||||
{
|
||||
ang = R_PointToAngle2 ( inflictor->x,
|
||||
inflictor->y,
|
||||
target->x,
|
||||
target->y);
|
||||
|
||||
thrust = damage*(FRACUNIT>>3)*100/target->info->mass;
|
||||
|
||||
// make fall forwards sometimes
|
||||
if ( damage < 40
|
||||
&& damage > target->health
|
||||
&& target->z - inflictor->z > 64*FRACUNIT
|
||||
&& (P_Random ()&1) )
|
||||
{
|
||||
ang += ANG180;
|
||||
thrust *= 4;
|
||||
}
|
||||
|
||||
ang >>= ANGLETOFINESHIFT;
|
||||
target->momx += FixedMul (thrust, finecosine[ang]);
|
||||
target->momy += FixedMul (thrust, finesine[ang]);
|
||||
}
|
||||
|
||||
// player specific
|
||||
if (player)
|
||||
{
|
||||
// end of game hell hack
|
||||
if (target->subsector->sector->special == 11
|
||||
&& damage >= target->health)
|
||||
{
|
||||
damage = target->health - 1;
|
||||
}
|
||||
|
||||
|
||||
// Below certain threshold,
|
||||
// ignore damage in GOD mode, or with INVUL power.
|
||||
if ( damage < 1000
|
||||
&& ( (player->cheats&CF_GODMODE)
|
||||
|| player->powers[pw_invulnerability] ) )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (player->armortype)
|
||||
{
|
||||
if (player->armortype == 1)
|
||||
saved = damage/3;
|
||||
else
|
||||
saved = damage/2;
|
||||
|
||||
if (player->armorpoints <= saved)
|
||||
{
|
||||
// armor is used up
|
||||
saved = player->armorpoints;
|
||||
player->armortype = 0;
|
||||
}
|
||||
player->armorpoints -= saved;
|
||||
damage -= saved;
|
||||
}
|
||||
player->health -= damage; // mirror mobj health here for Dave
|
||||
if (player->health < 0)
|
||||
player->health = 0;
|
||||
|
||||
player->attacker = source;
|
||||
player->damagecount += damage; // add damage after armor / invuln
|
||||
|
||||
if (player->damagecount > 100)
|
||||
player->damagecount = 100; // teleport stomp does 10k points...
|
||||
|
||||
temp = damage < 100 ? damage : 100;
|
||||
|
||||
if (player == &players[consoleplayer])
|
||||
I_Tactile (40,10,40+temp*2);
|
||||
}
|
||||
|
||||
// do the damage
|
||||
target->health -= damage;
|
||||
if (target->health <= 0)
|
||||
{
|
||||
P_KillMobj (source, target);
|
||||
return;
|
||||
}
|
||||
|
||||
if ( (P_Random () < target->info->painchance)
|
||||
&& !(target->flags&MF_SKULLFLY) )
|
||||
{
|
||||
target->flags |= MF_JUSTHIT; // fight back!
|
||||
|
||||
P_SetMobjState (target, target->info->painstate);
|
||||
}
|
||||
|
||||
target->reactiontime = 0; // we're awake now...
|
||||
|
||||
if ( (!target->threshold || target->type == MT_VILE)
|
||||
&& source && source != target
|
||||
&& source->type != MT_VILE)
|
||||
{
|
||||
// if not intent on another player,
|
||||
// chase after this one
|
||||
target->target = source;
|
||||
target->threshold = BASETHRESHOLD;
|
||||
if (target->state == &states[target->info->spawnstate]
|
||||
&& target->info->seestate != S_NULL)
|
||||
P_SetMobjState (target, target->info->seestate);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
//
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __P_INTER__
|
||||
#define __P_INTER__
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
boolean P_GivePower(player_t*, int);
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,357 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Handle Sector base lighting effects.
|
||||
// Muzzle flash?
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_lights.c,v 1.5 1997/02/03 22:45:11 b1 Exp $";
|
||||
|
||||
|
||||
#include "z_zone.h"
|
||||
#include "m_random.h"
|
||||
|
||||
#include "doomdef.h"
|
||||
#include "p_local.h"
|
||||
|
||||
|
||||
// State.
|
||||
#include "r_state.h"
|
||||
|
||||
//
|
||||
// FIRELIGHT FLICKER
|
||||
//
|
||||
|
||||
//
|
||||
// T_FireFlicker
|
||||
//
|
||||
void T_FireFlicker (fireflicker_t* flick)
|
||||
{
|
||||
int amount;
|
||||
|
||||
if (--flick->count)
|
||||
return;
|
||||
|
||||
amount = (P_Random()&3)*16;
|
||||
|
||||
if (flick->sector->lightlevel - amount < flick->minlight)
|
||||
flick->sector->lightlevel = flick->minlight;
|
||||
else
|
||||
flick->sector->lightlevel = flick->maxlight - amount;
|
||||
|
||||
flick->count = 4;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_SpawnFireFlicker
|
||||
//
|
||||
void P_SpawnFireFlicker (sector_t* sector)
|
||||
{
|
||||
fireflicker_t* flick;
|
||||
|
||||
// Note that we are resetting sector attributes.
|
||||
// Nothing special about it during gameplay.
|
||||
sector->special = 0;
|
||||
|
||||
flick = Z_Malloc ( sizeof(*flick), PU_LEVSPEC, 0);
|
||||
|
||||
P_AddThinker (&flick->thinker);
|
||||
|
||||
flick->thinker.function.acp1 = (actionf_p1) T_FireFlicker;
|
||||
flick->sector = sector;
|
||||
flick->maxlight = sector->lightlevel;
|
||||
flick->minlight = P_FindMinSurroundingLight(sector,sector->lightlevel)+16;
|
||||
flick->count = 4;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// BROKEN LIGHT FLASHING
|
||||
//
|
||||
|
||||
|
||||
//
|
||||
// T_LightFlash
|
||||
// Do flashing lights.
|
||||
//
|
||||
void T_LightFlash (lightflash_t* flash)
|
||||
{
|
||||
if (--flash->count)
|
||||
return;
|
||||
|
||||
if (flash->sector->lightlevel == flash->maxlight)
|
||||
{
|
||||
flash-> sector->lightlevel = flash->minlight;
|
||||
flash->count = (P_Random()&flash->mintime)+1;
|
||||
}
|
||||
else
|
||||
{
|
||||
flash-> sector->lightlevel = flash->maxlight;
|
||||
flash->count = (P_Random()&flash->maxtime)+1;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_SpawnLightFlash
|
||||
// After the map has been loaded, scan each sector
|
||||
// for specials that spawn thinkers
|
||||
//
|
||||
void P_SpawnLightFlash (sector_t* sector)
|
||||
{
|
||||
lightflash_t* flash;
|
||||
|
||||
// nothing special about it during gameplay
|
||||
sector->special = 0;
|
||||
|
||||
flash = Z_Malloc ( sizeof(*flash), PU_LEVSPEC, 0);
|
||||
|
||||
P_AddThinker (&flash->thinker);
|
||||
|
||||
flash->thinker.function.acp1 = (actionf_p1) T_LightFlash;
|
||||
flash->sector = sector;
|
||||
flash->maxlight = sector->lightlevel;
|
||||
|
||||
flash->minlight = P_FindMinSurroundingLight(sector,sector->lightlevel);
|
||||
flash->maxtime = 64;
|
||||
flash->mintime = 7;
|
||||
flash->count = (P_Random()&flash->maxtime)+1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// STROBE LIGHT FLASHING
|
||||
//
|
||||
|
||||
|
||||
//
|
||||
// T_StrobeFlash
|
||||
//
|
||||
void T_StrobeFlash (strobe_t* flash)
|
||||
{
|
||||
if (--flash->count)
|
||||
return;
|
||||
|
||||
if (flash->sector->lightlevel == flash->minlight)
|
||||
{
|
||||
flash-> sector->lightlevel = flash->maxlight;
|
||||
flash->count = flash->brighttime;
|
||||
}
|
||||
else
|
||||
{
|
||||
flash-> sector->lightlevel = flash->minlight;
|
||||
flash->count =flash->darktime;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_SpawnStrobeFlash
|
||||
// After the map has been loaded, scan each sector
|
||||
// for specials that spawn thinkers
|
||||
//
|
||||
void
|
||||
P_SpawnStrobeFlash
|
||||
( sector_t* sector,
|
||||
int fastOrSlow,
|
||||
int inSync )
|
||||
{
|
||||
strobe_t* flash;
|
||||
|
||||
flash = Z_Malloc ( sizeof(*flash), PU_LEVSPEC, 0);
|
||||
|
||||
P_AddThinker (&flash->thinker);
|
||||
|
||||
flash->sector = sector;
|
||||
flash->darktime = fastOrSlow;
|
||||
flash->brighttime = STROBEBRIGHT;
|
||||
flash->thinker.function.acp1 = (actionf_p1) T_StrobeFlash;
|
||||
flash->maxlight = sector->lightlevel;
|
||||
flash->minlight = P_FindMinSurroundingLight(sector, sector->lightlevel);
|
||||
|
||||
if (flash->minlight == flash->maxlight)
|
||||
flash->minlight = 0;
|
||||
|
||||
// nothing special about it during gameplay
|
||||
sector->special = 0;
|
||||
|
||||
if (!inSync)
|
||||
flash->count = (P_Random()&7)+1;
|
||||
else
|
||||
flash->count = 1;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Start strobing lights (usually from a trigger)
|
||||
//
|
||||
void EV_StartLightStrobing(line_t* line)
|
||||
{
|
||||
int secnum;
|
||||
sector_t* sec;
|
||||
|
||||
secnum = -1;
|
||||
while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
|
||||
{
|
||||
sec = §ors[secnum];
|
||||
if (sec->specialdata)
|
||||
continue;
|
||||
|
||||
P_SpawnStrobeFlash (sec,SLOWDARK, 0);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// TURN LINE'S TAG LIGHTS OFF
|
||||
//
|
||||
void EV_TurnTagLightsOff(line_t* line)
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
int min;
|
||||
sector_t* sector;
|
||||
sector_t* tsec;
|
||||
line_t* templine;
|
||||
|
||||
sector = sectors;
|
||||
|
||||
for (j = 0;j < numsectors; j++, sector++)
|
||||
{
|
||||
if (sector->tag == line->tag)
|
||||
{
|
||||
min = sector->lightlevel;
|
||||
for (i = 0;i < sector->linecount; i++)
|
||||
{
|
||||
templine = sector->lines[i];
|
||||
tsec = getNextSector(templine,sector);
|
||||
if (!tsec)
|
||||
continue;
|
||||
if (tsec->lightlevel < min)
|
||||
min = tsec->lightlevel;
|
||||
}
|
||||
sector->lightlevel = min;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// TURN LINE'S TAG LIGHTS ON
|
||||
//
|
||||
void
|
||||
EV_LightTurnOn
|
||||
( line_t* line,
|
||||
int bright )
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
sector_t* sector;
|
||||
sector_t* temp;
|
||||
line_t* templine;
|
||||
|
||||
sector = sectors;
|
||||
|
||||
for (i=0;i<numsectors;i++, sector++)
|
||||
{
|
||||
if (sector->tag == line->tag)
|
||||
{
|
||||
// bright = 0 means to search
|
||||
// for highest light level
|
||||
// surrounding sector
|
||||
if (!bright)
|
||||
{
|
||||
for (j = 0;j < sector->linecount; j++)
|
||||
{
|
||||
templine = sector->lines[j];
|
||||
temp = getNextSector(templine,sector);
|
||||
|
||||
if (!temp)
|
||||
continue;
|
||||
|
||||
if (temp->lightlevel > bright)
|
||||
bright = temp->lightlevel;
|
||||
}
|
||||
}
|
||||
sector-> lightlevel = bright;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Spawn glowing light
|
||||
//
|
||||
|
||||
void T_Glow(glow_t* g)
|
||||
{
|
||||
switch(g->direction)
|
||||
{
|
||||
case -1:
|
||||
// DOWN
|
||||
g->sector->lightlevel -= GLOWSPEED;
|
||||
if (g->sector->lightlevel <= g->minlight)
|
||||
{
|
||||
g->sector->lightlevel += GLOWSPEED;
|
||||
g->direction = 1;
|
||||
}
|
||||
break;
|
||||
|
||||
case 1:
|
||||
// UP
|
||||
g->sector->lightlevel += GLOWSPEED;
|
||||
if (g->sector->lightlevel >= g->maxlight)
|
||||
{
|
||||
g->sector->lightlevel -= GLOWSPEED;
|
||||
g->direction = -1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void P_SpawnGlowingLight(sector_t* sector)
|
||||
{
|
||||
glow_t* g;
|
||||
|
||||
g = Z_Malloc( sizeof(*g), PU_LEVSPEC, 0);
|
||||
|
||||
P_AddThinker(&g->thinker);
|
||||
|
||||
g->sector = sector;
|
||||
g->minlight = P_FindMinSurroundingLight(sector,sector->lightlevel);
|
||||
g->maxlight = sector->lightlevel;
|
||||
g->thinker.function.acp1 = (actionf_p1) T_Glow;
|
||||
g->direction = -1;
|
||||
|
||||
sector->special = 0;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,289 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Play functions, animation, global header.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __P_LOCAL__
|
||||
#define __P_LOCAL__
|
||||
|
||||
#ifndef __R_LOCAL__
|
||||
#include "r_local.h"
|
||||
#endif
|
||||
|
||||
#define FLOATSPEED (FRACUNIT*4)
|
||||
|
||||
|
||||
#define MAXHEALTH 100
|
||||
#define VIEWHEIGHT (41*FRACUNIT)
|
||||
|
||||
// mapblocks are used to check movement
|
||||
// against lines and things
|
||||
#define MAPBLOCKUNITS 128
|
||||
#define MAPBLOCKSIZE (MAPBLOCKUNITS*FRACUNIT)
|
||||
#define MAPBLOCKSHIFT (FRACBITS+7)
|
||||
#define MAPBMASK (MAPBLOCKSIZE-1)
|
||||
#define MAPBTOFRAC (MAPBLOCKSHIFT-FRACBITS)
|
||||
|
||||
|
||||
// player radius for movement checking
|
||||
#define PLAYERRADIUS 16*FRACUNIT
|
||||
|
||||
// MAXRADIUS is for precalculated sector block boxes
|
||||
// the spider demon is larger,
|
||||
// but we do not have any moving sectors nearby
|
||||
#define MAXRADIUS 32*FRACUNIT
|
||||
|
||||
#define GRAVITY FRACUNIT
|
||||
#define MAXMOVE (30*FRACUNIT)
|
||||
|
||||
#define USERANGE (64*FRACUNIT)
|
||||
#define MELEERANGE (64*FRACUNIT)
|
||||
#define MISSILERANGE (32*64*FRACUNIT)
|
||||
|
||||
// follow a player exlusively for 3 seconds
|
||||
#define BASETHRESHOLD 100
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_TICK
|
||||
//
|
||||
|
||||
// both the head and tail of the thinker list
|
||||
extern thinker_t thinkercap;
|
||||
|
||||
|
||||
void P_InitThinkers (void);
|
||||
void P_AddThinker (thinker_t* thinker);
|
||||
void P_RemoveThinker (thinker_t* thinker);
|
||||
|
||||
|
||||
//
|
||||
// P_PSPR
|
||||
//
|
||||
void P_SetupPsprites (player_t* curplayer);
|
||||
void P_MovePsprites (player_t* curplayer);
|
||||
void P_DropWeapon (player_t* player);
|
||||
|
||||
|
||||
//
|
||||
// P_USER
|
||||
//
|
||||
void P_PlayerThink (player_t* player);
|
||||
|
||||
|
||||
//
|
||||
// P_MOBJ
|
||||
//
|
||||
#define ONFLOORZ MININT
|
||||
#define ONCEILINGZ MAXINT
|
||||
|
||||
// Time interval for item respawning.
|
||||
#define ITEMQUESIZE 128
|
||||
|
||||
extern mapthing_t itemrespawnque[ITEMQUESIZE];
|
||||
extern int itemrespawntime[ITEMQUESIZE];
|
||||
extern int iquehead;
|
||||
extern int iquetail;
|
||||
|
||||
|
||||
void P_RespawnSpecials (void);
|
||||
|
||||
mobj_t*
|
||||
P_SpawnMobj
|
||||
( fixed_t x,
|
||||
fixed_t y,
|
||||
fixed_t z,
|
||||
mobjtype_t type );
|
||||
|
||||
void P_RemoveMobj (mobj_t* th);
|
||||
boolean P_SetMobjState (mobj_t* mobj, statenum_t state);
|
||||
void P_MobjThinker (mobj_t* mobj);
|
||||
|
||||
void P_SpawnPuff (fixed_t x, fixed_t y, fixed_t z);
|
||||
void P_SpawnBlood (fixed_t x, fixed_t y, fixed_t z, int damage);
|
||||
mobj_t* P_SpawnMissile (mobj_t* source, mobj_t* dest, mobjtype_t type);
|
||||
void P_SpawnPlayerMissile (mobj_t* source, mobjtype_t type);
|
||||
|
||||
|
||||
//
|
||||
// P_ENEMY
|
||||
//
|
||||
void P_NoiseAlert (mobj_t* target, mobj_t* emmiter);
|
||||
|
||||
|
||||
//
|
||||
// P_MAPUTL
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
fixed_t x;
|
||||
fixed_t y;
|
||||
fixed_t dx;
|
||||
fixed_t dy;
|
||||
|
||||
} divline_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
fixed_t frac; // along trace line
|
||||
boolean isaline;
|
||||
union {
|
||||
mobj_t* thing;
|
||||
line_t* line;
|
||||
} d;
|
||||
} intercept_t;
|
||||
|
||||
#define MAXINTERCEPTS 1024
|
||||
|
||||
extern intercept_t intercepts[MAXINTERCEPTS];
|
||||
extern intercept_t* intercept_p;
|
||||
|
||||
typedef boolean (*traverser_t) (intercept_t *in);
|
||||
|
||||
fixed_t P_AproxDistance (fixed_t dx, fixed_t dy);
|
||||
int P_PointOnLineSide (fixed_t x, fixed_t y, line_t* line);
|
||||
int P_PointOnDivlineSide (fixed_t x, fixed_t y, divline_t* line);
|
||||
void P_MakeDivline (line_t* li, divline_t* dl);
|
||||
fixed_t P_InterceptVector (divline_t* v2, divline_t* v1);
|
||||
int P_BoxOnLineSide (fixed_t* tmbox, line_t* ld);
|
||||
|
||||
extern fixed_t opentop;
|
||||
extern fixed_t openbottom;
|
||||
extern fixed_t openrange;
|
||||
extern fixed_t lowfloor;
|
||||
|
||||
void P_LineOpening (line_t* linedef);
|
||||
|
||||
boolean P_BlockLinesIterator (int x, int y, boolean(*func)(line_t*) );
|
||||
boolean P_BlockThingsIterator (int x, int y, boolean(*func)(mobj_t*) );
|
||||
|
||||
#define PT_ADDLINES 1
|
||||
#define PT_ADDTHINGS 2
|
||||
#define PT_EARLYOUT 4
|
||||
|
||||
extern divline_t trace;
|
||||
|
||||
boolean
|
||||
P_PathTraverse
|
||||
( fixed_t x1,
|
||||
fixed_t y1,
|
||||
fixed_t x2,
|
||||
fixed_t y2,
|
||||
int flags,
|
||||
boolean (*trav) (intercept_t *));
|
||||
|
||||
void P_UnsetThingPosition (mobj_t* thing);
|
||||
void P_SetThingPosition (mobj_t* thing);
|
||||
|
||||
|
||||
//
|
||||
// P_MAP
|
||||
//
|
||||
|
||||
// If "floatok" true, move would be ok
|
||||
// if within "tmfloorz - tmceilingz".
|
||||
extern boolean floatok;
|
||||
extern fixed_t tmfloorz;
|
||||
extern fixed_t tmceilingz;
|
||||
|
||||
|
||||
extern line_t* ceilingline;
|
||||
|
||||
boolean P_CheckPosition (mobj_t *thing, fixed_t x, fixed_t y);
|
||||
boolean P_TryMove (mobj_t* thing, fixed_t x, fixed_t y);
|
||||
boolean P_TeleportMove (mobj_t* thing, fixed_t x, fixed_t y);
|
||||
void P_SlideMove (mobj_t* mo);
|
||||
boolean P_CheckSight (mobj_t* t1, mobj_t* t2);
|
||||
void P_UseLines (player_t* player);
|
||||
|
||||
boolean P_ChangeSector (sector_t* sector, boolean crunch);
|
||||
|
||||
extern mobj_t* linetarget; // who got hit (or NULL)
|
||||
|
||||
fixed_t
|
||||
P_AimLineAttack
|
||||
( mobj_t* t1,
|
||||
angle_t angle,
|
||||
fixed_t distance );
|
||||
|
||||
void
|
||||
P_LineAttack
|
||||
( mobj_t* t1,
|
||||
angle_t angle,
|
||||
fixed_t distance,
|
||||
fixed_t slope,
|
||||
int damage );
|
||||
|
||||
void
|
||||
P_RadiusAttack
|
||||
( mobj_t* spot,
|
||||
mobj_t* source,
|
||||
int damage );
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_SETUP
|
||||
//
|
||||
extern byte* rejectmatrix; // for fast sight rejection
|
||||
extern short* blockmaplump; // offsets in blockmap are from here
|
||||
extern short* blockmap;
|
||||
extern int bmapwidth;
|
||||
extern int bmapheight; // in mapblocks
|
||||
extern fixed_t bmaporgx;
|
||||
extern fixed_t bmaporgy; // origin of block map
|
||||
extern mobj_t** blocklinks; // for thing chains
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_INTER
|
||||
//
|
||||
extern int maxammo[NUMAMMO];
|
||||
extern int clipammo[NUMAMMO];
|
||||
|
||||
void
|
||||
P_TouchSpecialThing
|
||||
( mobj_t* special,
|
||||
mobj_t* toucher );
|
||||
|
||||
void
|
||||
P_DamageMobj
|
||||
( mobj_t* target,
|
||||
mobj_t* inflictor,
|
||||
mobj_t* source,
|
||||
int damage );
|
||||
|
||||
|
||||
//
|
||||
// P_SPEC
|
||||
//
|
||||
#include "p_spec.h"
|
||||
|
||||
|
||||
#endif // __P_LOCAL__
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
+1339
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,883 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Movement/collision utility functions,
|
||||
// as used by function in p_map.c.
|
||||
// BLOCKMAP Iterator functions,
|
||||
// and some PIT_* functions to use for iteration.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_maputl.c,v 1.5 1997/02/03 22:45:11 b1 Exp $";
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
|
||||
#include "m_bbox.h"
|
||||
|
||||
#include "doomdef.h"
|
||||
#include "p_local.h"
|
||||
|
||||
|
||||
// State.
|
||||
#include "r_state.h"
|
||||
|
||||
//
|
||||
// P_AproxDistance
|
||||
// Gives an estimation of distance (not exact)
|
||||
//
|
||||
|
||||
fixed_t
|
||||
P_AproxDistance
|
||||
( fixed_t dx,
|
||||
fixed_t dy )
|
||||
{
|
||||
dx = abs(dx);
|
||||
dy = abs(dy);
|
||||
if (dx < dy)
|
||||
return dx+dy-(dx>>1);
|
||||
return dx+dy-(dy>>1);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_PointOnLineSide
|
||||
// Returns 0 or 1
|
||||
//
|
||||
int
|
||||
P_PointOnLineSide
|
||||
( fixed_t x,
|
||||
fixed_t y,
|
||||
line_t* line )
|
||||
{
|
||||
fixed_t dx;
|
||||
fixed_t dy;
|
||||
fixed_t left;
|
||||
fixed_t right;
|
||||
|
||||
if (!line->dx)
|
||||
{
|
||||
if (x <= line->v1->x)
|
||||
return line->dy > 0;
|
||||
|
||||
return line->dy < 0;
|
||||
}
|
||||
if (!line->dy)
|
||||
{
|
||||
if (y <= line->v1->y)
|
||||
return line->dx < 0;
|
||||
|
||||
return line->dx > 0;
|
||||
}
|
||||
|
||||
dx = (x - line->v1->x);
|
||||
dy = (y - line->v1->y);
|
||||
|
||||
left = FixedMul ( line->dy>>FRACBITS , dx );
|
||||
right = FixedMul ( dy , line->dx>>FRACBITS );
|
||||
|
||||
if (right < left)
|
||||
return 0; // front side
|
||||
return 1; // back side
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_BoxOnLineSide
|
||||
// Considers the line to be infinite
|
||||
// Returns side 0 or 1, -1 if box crosses the line.
|
||||
//
|
||||
int
|
||||
P_BoxOnLineSide
|
||||
( fixed_t* tmbox,
|
||||
line_t* ld )
|
||||
{
|
||||
int p1;
|
||||
int p2;
|
||||
|
||||
switch (ld->slopetype)
|
||||
{
|
||||
case ST_HORIZONTAL:
|
||||
p1 = tmbox[BOXTOP] > ld->v1->y;
|
||||
p2 = tmbox[BOXBOTTOM] > ld->v1->y;
|
||||
if (ld->dx < 0)
|
||||
{
|
||||
p1 ^= 1;
|
||||
p2 ^= 1;
|
||||
}
|
||||
break;
|
||||
|
||||
case ST_VERTICAL:
|
||||
p1 = tmbox[BOXRIGHT] < ld->v1->x;
|
||||
p2 = tmbox[BOXLEFT] < ld->v1->x;
|
||||
if (ld->dy < 0)
|
||||
{
|
||||
p1 ^= 1;
|
||||
p2 ^= 1;
|
||||
}
|
||||
break;
|
||||
|
||||
case ST_POSITIVE:
|
||||
p1 = P_PointOnLineSide (tmbox[BOXLEFT], tmbox[BOXTOP], ld);
|
||||
p2 = P_PointOnLineSide (tmbox[BOXRIGHT], tmbox[BOXBOTTOM], ld);
|
||||
break;
|
||||
|
||||
case ST_NEGATIVE:
|
||||
p1 = P_PointOnLineSide (tmbox[BOXRIGHT], tmbox[BOXTOP], ld);
|
||||
p2 = P_PointOnLineSide (tmbox[BOXLEFT], tmbox[BOXBOTTOM], ld);
|
||||
break;
|
||||
}
|
||||
|
||||
if (p1 == p2)
|
||||
return p1;
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_PointOnDivlineSide
|
||||
// Returns 0 or 1.
|
||||
//
|
||||
int
|
||||
P_PointOnDivlineSide
|
||||
( fixed_t x,
|
||||
fixed_t y,
|
||||
divline_t* line )
|
||||
{
|
||||
fixed_t dx;
|
||||
fixed_t dy;
|
||||
fixed_t left;
|
||||
fixed_t right;
|
||||
|
||||
if (!line->dx)
|
||||
{
|
||||
if (x <= line->x)
|
||||
return line->dy > 0;
|
||||
|
||||
return line->dy < 0;
|
||||
}
|
||||
if (!line->dy)
|
||||
{
|
||||
if (y <= line->y)
|
||||
return line->dx < 0;
|
||||
|
||||
return line->dx > 0;
|
||||
}
|
||||
|
||||
dx = (x - line->x);
|
||||
dy = (y - line->y);
|
||||
|
||||
// try to quickly decide by looking at sign bits
|
||||
if ( (line->dy ^ line->dx ^ dx ^ dy)&0x80000000 )
|
||||
{
|
||||
if ( (line->dy ^ dx) & 0x80000000 )
|
||||
return 1; // (left is negative)
|
||||
return 0;
|
||||
}
|
||||
|
||||
left = FixedMul ( line->dy>>8, dx>>8 );
|
||||
right = FixedMul ( dy>>8 , line->dx>>8 );
|
||||
|
||||
if (right < left)
|
||||
return 0; // front side
|
||||
return 1; // back side
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_MakeDivline
|
||||
//
|
||||
void
|
||||
P_MakeDivline
|
||||
( line_t* li,
|
||||
divline_t* dl )
|
||||
{
|
||||
dl->x = li->v1->x;
|
||||
dl->y = li->v1->y;
|
||||
dl->dx = li->dx;
|
||||
dl->dy = li->dy;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_InterceptVector
|
||||
// Returns the fractional intercept point
|
||||
// along the first divline.
|
||||
// This is only called by the addthings
|
||||
// and addlines traversers.
|
||||
//
|
||||
fixed_t
|
||||
P_InterceptVector
|
||||
( divline_t* v2,
|
||||
divline_t* v1 )
|
||||
{
|
||||
#if 1
|
||||
fixed_t frac;
|
||||
fixed_t num;
|
||||
fixed_t den;
|
||||
|
||||
den = FixedMul (v1->dy>>8,v2->dx) - FixedMul(v1->dx>>8,v2->dy);
|
||||
|
||||
if (den == 0)
|
||||
return 0;
|
||||
// I_Error ("P_InterceptVector: parallel");
|
||||
|
||||
num =
|
||||
FixedMul ( (v1->x - v2->x)>>8 ,v1->dy )
|
||||
+FixedMul ( (v2->y - v1->y)>>8, v1->dx );
|
||||
|
||||
frac = FixedDiv (num , den);
|
||||
|
||||
return frac;
|
||||
#else // UNUSED, float debug.
|
||||
float frac;
|
||||
float num;
|
||||
float den;
|
||||
float v1x;
|
||||
float v1y;
|
||||
float v1dx;
|
||||
float v1dy;
|
||||
float v2x;
|
||||
float v2y;
|
||||
float v2dx;
|
||||
float v2dy;
|
||||
|
||||
v1x = (float)v1->x/FRACUNIT;
|
||||
v1y = (float)v1->y/FRACUNIT;
|
||||
v1dx = (float)v1->dx/FRACUNIT;
|
||||
v1dy = (float)v1->dy/FRACUNIT;
|
||||
v2x = (float)v2->x/FRACUNIT;
|
||||
v2y = (float)v2->y/FRACUNIT;
|
||||
v2dx = (float)v2->dx/FRACUNIT;
|
||||
v2dy = (float)v2->dy/FRACUNIT;
|
||||
|
||||
den = v1dy*v2dx - v1dx*v2dy;
|
||||
|
||||
if (den == 0)
|
||||
return 0; // parallel
|
||||
|
||||
num = (v1x - v2x)*v1dy + (v2y - v1y)*v1dx;
|
||||
frac = num / den;
|
||||
|
||||
return frac*FRACUNIT;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_LineOpening
|
||||
// Sets opentop and openbottom to the window
|
||||
// through a two sided line.
|
||||
// OPTIMIZE: keep this precalculated
|
||||
//
|
||||
fixed_t opentop;
|
||||
fixed_t openbottom;
|
||||
fixed_t openrange;
|
||||
fixed_t lowfloor;
|
||||
|
||||
|
||||
void P_LineOpening (line_t* linedef)
|
||||
{
|
||||
sector_t* front;
|
||||
sector_t* back;
|
||||
|
||||
if (linedef->sidenum[1] == -1)
|
||||
{
|
||||
// single sided line
|
||||
openrange = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
front = linedef->frontsector;
|
||||
back = linedef->backsector;
|
||||
|
||||
if (front->ceilingheight < back->ceilingheight)
|
||||
opentop = front->ceilingheight;
|
||||
else
|
||||
opentop = back->ceilingheight;
|
||||
|
||||
if (front->floorheight > back->floorheight)
|
||||
{
|
||||
openbottom = front->floorheight;
|
||||
lowfloor = back->floorheight;
|
||||
}
|
||||
else
|
||||
{
|
||||
openbottom = back->floorheight;
|
||||
lowfloor = front->floorheight;
|
||||
}
|
||||
|
||||
openrange = opentop - openbottom;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// THING POSITION SETTING
|
||||
//
|
||||
|
||||
|
||||
//
|
||||
// P_UnsetThingPosition
|
||||
// Unlinks a thing from block map and sectors.
|
||||
// On each position change, BLOCKMAP and other
|
||||
// lookups maintaining lists ot things inside
|
||||
// these structures need to be updated.
|
||||
//
|
||||
void P_UnsetThingPosition (mobj_t* thing)
|
||||
{
|
||||
int blockx;
|
||||
int blocky;
|
||||
|
||||
if ( ! (thing->flags & MF_NOSECTOR) )
|
||||
{
|
||||
// inert things don't need to be in blockmap?
|
||||
// unlink from subsector
|
||||
if (thing->snext)
|
||||
thing->snext->sprev = thing->sprev;
|
||||
|
||||
if (thing->sprev)
|
||||
thing->sprev->snext = thing->snext;
|
||||
else
|
||||
thing->subsector->sector->thinglist = thing->snext;
|
||||
}
|
||||
|
||||
if ( ! (thing->flags & MF_NOBLOCKMAP) )
|
||||
{
|
||||
// inert things don't need to be in blockmap
|
||||
// unlink from block map
|
||||
if (thing->bnext)
|
||||
thing->bnext->bprev = thing->bprev;
|
||||
|
||||
if (thing->bprev)
|
||||
thing->bprev->bnext = thing->bnext;
|
||||
else
|
||||
{
|
||||
blockx = (thing->x - bmaporgx)>>MAPBLOCKSHIFT;
|
||||
blocky = (thing->y - bmaporgy)>>MAPBLOCKSHIFT;
|
||||
|
||||
if (blockx>=0 && blockx < bmapwidth
|
||||
&& blocky>=0 && blocky <bmapheight)
|
||||
{
|
||||
blocklinks[blocky*bmapwidth+blockx] = thing->bnext;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_SetThingPosition
|
||||
// Links a thing into both a block and a subsector
|
||||
// based on it's x y.
|
||||
// Sets thing->subsector properly
|
||||
//
|
||||
void
|
||||
P_SetThingPosition (mobj_t* thing)
|
||||
{
|
||||
subsector_t* ss;
|
||||
sector_t* sec;
|
||||
int blockx;
|
||||
int blocky;
|
||||
mobj_t** link;
|
||||
|
||||
|
||||
// link into subsector
|
||||
ss = R_PointInSubsector (thing->x,thing->y);
|
||||
thing->subsector = ss;
|
||||
|
||||
if ( ! (thing->flags & MF_NOSECTOR) )
|
||||
{
|
||||
// invisible things don't go into the sector links
|
||||
sec = ss->sector;
|
||||
|
||||
thing->sprev = NULL;
|
||||
thing->snext = sec->thinglist;
|
||||
|
||||
if (sec->thinglist)
|
||||
sec->thinglist->sprev = thing;
|
||||
|
||||
sec->thinglist = thing;
|
||||
}
|
||||
|
||||
|
||||
// link into blockmap
|
||||
if ( ! (thing->flags & MF_NOBLOCKMAP) )
|
||||
{
|
||||
// inert things don't need to be in blockmap
|
||||
blockx = (thing->x - bmaporgx)>>MAPBLOCKSHIFT;
|
||||
blocky = (thing->y - bmaporgy)>>MAPBLOCKSHIFT;
|
||||
|
||||
if (blockx>=0
|
||||
&& blockx < bmapwidth
|
||||
&& blocky>=0
|
||||
&& blocky < bmapheight)
|
||||
{
|
||||
link = &blocklinks[blocky*bmapwidth+blockx];
|
||||
thing->bprev = NULL;
|
||||
thing->bnext = *link;
|
||||
if (*link)
|
||||
(*link)->bprev = thing;
|
||||
|
||||
*link = thing;
|
||||
}
|
||||
else
|
||||
{
|
||||
// thing is off the map
|
||||
thing->bnext = thing->bprev = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// BLOCK MAP ITERATORS
|
||||
// For each line/thing in the given mapblock,
|
||||
// call the passed PIT_* function.
|
||||
// If the function returns false,
|
||||
// exit with false without checking anything else.
|
||||
//
|
||||
|
||||
|
||||
//
|
||||
// P_BlockLinesIterator
|
||||
// The validcount flags are used to avoid checking lines
|
||||
// that are marked in multiple mapblocks,
|
||||
// so increment validcount before the first call
|
||||
// to P_BlockLinesIterator, then make one or more calls
|
||||
// to it.
|
||||
//
|
||||
boolean
|
||||
P_BlockLinesIterator
|
||||
( int x,
|
||||
int y,
|
||||
boolean(*func)(line_t*) )
|
||||
{
|
||||
int offset;
|
||||
short* list;
|
||||
line_t* ld;
|
||||
|
||||
if (x<0
|
||||
|| y<0
|
||||
|| x>=bmapwidth
|
||||
|| y>=bmapheight)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
offset = y*bmapwidth+x;
|
||||
|
||||
offset = *(blockmap+offset);
|
||||
|
||||
for ( list = blockmaplump+offset ; *list != -1 ; list++)
|
||||
{
|
||||
ld = &lines[*list];
|
||||
|
||||
if (ld->validcount == validcount)
|
||||
continue; // line has already been checked
|
||||
|
||||
ld->validcount = validcount;
|
||||
|
||||
if ( !func(ld) )
|
||||
return false;
|
||||
}
|
||||
return true; // everything was checked
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_BlockThingsIterator
|
||||
//
|
||||
boolean
|
||||
P_BlockThingsIterator
|
||||
( int x,
|
||||
int y,
|
||||
boolean(*func)(mobj_t*) )
|
||||
{
|
||||
mobj_t* mobj;
|
||||
|
||||
if ( x<0
|
||||
|| y<0
|
||||
|| x>=bmapwidth
|
||||
|| y>=bmapheight)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
for (mobj = blocklinks[y*bmapwidth+x] ;
|
||||
mobj ;
|
||||
mobj = mobj->bnext)
|
||||
{
|
||||
if (!func( mobj ) )
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// INTERCEPT ROUTINES
|
||||
//
|
||||
intercept_t intercepts[MAXINTERCEPTS];
|
||||
intercept_t* intercept_p;
|
||||
|
||||
divline_t trace;
|
||||
boolean earlyout;
|
||||
int ptflags;
|
||||
|
||||
//
|
||||
// PIT_AddLineIntercepts.
|
||||
// Looks for lines in the given block
|
||||
// that intercept the given trace
|
||||
// to add to the intercepts list.
|
||||
//
|
||||
// A line is crossed if its endpoints
|
||||
// are on opposite sides of the trace.
|
||||
// Returns true if earlyout and a solid line hit.
|
||||
//
|
||||
boolean
|
||||
PIT_AddLineIntercepts (line_t* ld)
|
||||
{
|
||||
int s1;
|
||||
int s2;
|
||||
fixed_t frac;
|
||||
divline_t dl;
|
||||
|
||||
// avoid precision problems with two routines
|
||||
if ( trace.dx > FRACUNIT*16
|
||||
|| trace.dy > FRACUNIT*16
|
||||
|| trace.dx < -FRACUNIT*16
|
||||
|| trace.dy < -FRACUNIT*16)
|
||||
{
|
||||
s1 = P_PointOnDivlineSide (ld->v1->x, ld->v1->y, &trace);
|
||||
s2 = P_PointOnDivlineSide (ld->v2->x, ld->v2->y, &trace);
|
||||
}
|
||||
else
|
||||
{
|
||||
s1 = P_PointOnLineSide (trace.x, trace.y, ld);
|
||||
s2 = P_PointOnLineSide (trace.x+trace.dx, trace.y+trace.dy, ld);
|
||||
}
|
||||
|
||||
if (s1 == s2)
|
||||
return true; // line isn't crossed
|
||||
|
||||
// hit the line
|
||||
P_MakeDivline (ld, &dl);
|
||||
frac = P_InterceptVector (&trace, &dl);
|
||||
|
||||
if (frac < 0)
|
||||
return true; // behind source
|
||||
|
||||
// try to early out the check
|
||||
if (earlyout
|
||||
&& frac < FRACUNIT
|
||||
&& !ld->backsector)
|
||||
{
|
||||
return false; // stop checking
|
||||
}
|
||||
|
||||
|
||||
intercept_p->frac = frac;
|
||||
intercept_p->isaline = true;
|
||||
intercept_p->d.line = ld;
|
||||
intercept_p++;
|
||||
|
||||
return true; // continue
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// PIT_AddThingIntercepts
|
||||
//
|
||||
boolean PIT_AddThingIntercepts (mobj_t* thing)
|
||||
{
|
||||
fixed_t x1;
|
||||
fixed_t y1;
|
||||
fixed_t x2;
|
||||
fixed_t y2;
|
||||
|
||||
int s1;
|
||||
int s2;
|
||||
|
||||
boolean tracepositive;
|
||||
|
||||
divline_t dl;
|
||||
|
||||
fixed_t frac;
|
||||
|
||||
tracepositive = (trace.dx ^ trace.dy)>0;
|
||||
|
||||
// check a corner to corner crossection for hit
|
||||
if (tracepositive)
|
||||
{
|
||||
x1 = thing->x - thing->radius;
|
||||
y1 = thing->y + thing->radius;
|
||||
|
||||
x2 = thing->x + thing->radius;
|
||||
y2 = thing->y - thing->radius;
|
||||
}
|
||||
else
|
||||
{
|
||||
x1 = thing->x - thing->radius;
|
||||
y1 = thing->y - thing->radius;
|
||||
|
||||
x2 = thing->x + thing->radius;
|
||||
y2 = thing->y + thing->radius;
|
||||
}
|
||||
|
||||
s1 = P_PointOnDivlineSide (x1, y1, &trace);
|
||||
s2 = P_PointOnDivlineSide (x2, y2, &trace);
|
||||
|
||||
if (s1 == s2)
|
||||
return true; // line isn't crossed
|
||||
|
||||
dl.x = x1;
|
||||
dl.y = y1;
|
||||
dl.dx = x2-x1;
|
||||
dl.dy = y2-y1;
|
||||
|
||||
frac = P_InterceptVector (&trace, &dl);
|
||||
|
||||
if (frac < 0)
|
||||
return true; // behind source
|
||||
|
||||
intercept_p->frac = frac;
|
||||
intercept_p->isaline = false;
|
||||
intercept_p->d.thing = thing;
|
||||
intercept_p++;
|
||||
|
||||
return true; // keep going
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_TraverseIntercepts
|
||||
// Returns true if the traverser function returns true
|
||||
// for all lines.
|
||||
//
|
||||
boolean
|
||||
P_TraverseIntercepts
|
||||
( traverser_t func,
|
||||
fixed_t maxfrac )
|
||||
{
|
||||
int count;
|
||||
fixed_t dist;
|
||||
intercept_t* scan;
|
||||
intercept_t* in;
|
||||
|
||||
count = intercept_p - intercepts;
|
||||
|
||||
in = 0; // shut up compiler warning
|
||||
|
||||
while (count--)
|
||||
{
|
||||
dist = MAXINT;
|
||||
for (scan = intercepts ; scan<intercept_p ; scan++)
|
||||
{
|
||||
if (scan->frac < dist)
|
||||
{
|
||||
dist = scan->frac;
|
||||
in = scan;
|
||||
}
|
||||
}
|
||||
|
||||
if (dist > maxfrac)
|
||||
return true; // checked everything in range
|
||||
|
||||
#if 0 // UNUSED
|
||||
{
|
||||
// don't check these yet, there may be others inserted
|
||||
in = scan = intercepts;
|
||||
for ( scan = intercepts ; scan<intercept_p ; scan++)
|
||||
if (scan->frac > maxfrac)
|
||||
*in++ = *scan;
|
||||
intercept_p = in;
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
|
||||
if ( !func (in) )
|
||||
return false; // don't bother going farther
|
||||
|
||||
in->frac = MAXINT;
|
||||
}
|
||||
|
||||
return true; // everything was traversed
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_PathTraverse
|
||||
// Traces a line from x1,y1 to x2,y2,
|
||||
// calling the traverser function for each.
|
||||
// Returns true if the traverser function returns true
|
||||
// for all lines.
|
||||
//
|
||||
boolean
|
||||
P_PathTraverse
|
||||
( fixed_t x1,
|
||||
fixed_t y1,
|
||||
fixed_t x2,
|
||||
fixed_t y2,
|
||||
int flags,
|
||||
boolean (*trav) (intercept_t *))
|
||||
{
|
||||
fixed_t xt1;
|
||||
fixed_t yt1;
|
||||
fixed_t xt2;
|
||||
fixed_t yt2;
|
||||
|
||||
fixed_t xstep;
|
||||
fixed_t ystep;
|
||||
|
||||
fixed_t partial;
|
||||
|
||||
fixed_t xintercept;
|
||||
fixed_t yintercept;
|
||||
|
||||
int mapx;
|
||||
int mapy;
|
||||
|
||||
int mapxstep;
|
||||
int mapystep;
|
||||
|
||||
int count;
|
||||
|
||||
earlyout = flags & PT_EARLYOUT;
|
||||
|
||||
validcount++;
|
||||
intercept_p = intercepts;
|
||||
|
||||
if ( ((x1-bmaporgx)&(MAPBLOCKSIZE-1)) == 0)
|
||||
x1 += FRACUNIT; // don't side exactly on a line
|
||||
|
||||
if ( ((y1-bmaporgy)&(MAPBLOCKSIZE-1)) == 0)
|
||||
y1 += FRACUNIT; // don't side exactly on a line
|
||||
|
||||
trace.x = x1;
|
||||
trace.y = y1;
|
||||
trace.dx = x2 - x1;
|
||||
trace.dy = y2 - y1;
|
||||
|
||||
x1 -= bmaporgx;
|
||||
y1 -= bmaporgy;
|
||||
xt1 = x1>>MAPBLOCKSHIFT;
|
||||
yt1 = y1>>MAPBLOCKSHIFT;
|
||||
|
||||
x2 -= bmaporgx;
|
||||
y2 -= bmaporgy;
|
||||
xt2 = x2>>MAPBLOCKSHIFT;
|
||||
yt2 = y2>>MAPBLOCKSHIFT;
|
||||
|
||||
if (xt2 > xt1)
|
||||
{
|
||||
mapxstep = 1;
|
||||
partial = FRACUNIT - ((x1>>MAPBTOFRAC)&(FRACUNIT-1));
|
||||
ystep = FixedDiv (y2-y1,abs(x2-x1));
|
||||
}
|
||||
else if (xt2 < xt1)
|
||||
{
|
||||
mapxstep = -1;
|
||||
partial = (x1>>MAPBTOFRAC)&(FRACUNIT-1);
|
||||
ystep = FixedDiv (y2-y1,abs(x2-x1));
|
||||
}
|
||||
else
|
||||
{
|
||||
mapxstep = 0;
|
||||
partial = FRACUNIT;
|
||||
ystep = 256*FRACUNIT;
|
||||
}
|
||||
|
||||
yintercept = (y1>>MAPBTOFRAC) + FixedMul (partial, ystep);
|
||||
|
||||
|
||||
if (yt2 > yt1)
|
||||
{
|
||||
mapystep = 1;
|
||||
partial = FRACUNIT - ((y1>>MAPBTOFRAC)&(FRACUNIT-1));
|
||||
xstep = FixedDiv (x2-x1,abs(y2-y1));
|
||||
}
|
||||
else if (yt2 < yt1)
|
||||
{
|
||||
mapystep = -1;
|
||||
partial = (y1>>MAPBTOFRAC)&(FRACUNIT-1);
|
||||
xstep = FixedDiv (x2-x1,abs(y2-y1));
|
||||
}
|
||||
else
|
||||
{
|
||||
mapystep = 0;
|
||||
partial = FRACUNIT;
|
||||
xstep = 256*FRACUNIT;
|
||||
}
|
||||
xintercept = (x1>>MAPBTOFRAC) + FixedMul (partial, xstep);
|
||||
|
||||
// Step through map blocks.
|
||||
// Count is present to prevent a round off error
|
||||
// from skipping the break.
|
||||
mapx = xt1;
|
||||
mapy = yt1;
|
||||
|
||||
for (count = 0 ; count < 64 ; count++)
|
||||
{
|
||||
if (flags & PT_ADDLINES)
|
||||
{
|
||||
if (!P_BlockLinesIterator (mapx, mapy,PIT_AddLineIntercepts))
|
||||
return false; // early out
|
||||
}
|
||||
|
||||
if (flags & PT_ADDTHINGS)
|
||||
{
|
||||
if (!P_BlockThingsIterator (mapx, mapy,PIT_AddThingIntercepts))
|
||||
return false; // early out
|
||||
}
|
||||
|
||||
if (mapx == xt2
|
||||
&& mapy == yt2)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
if ( (yintercept >> FRACBITS) == mapy)
|
||||
{
|
||||
yintercept += ystep;
|
||||
mapx += mapxstep;
|
||||
}
|
||||
else if ( (xintercept >> FRACBITS) == mapx)
|
||||
{
|
||||
xintercept += xstep;
|
||||
mapy += mapystep;
|
||||
}
|
||||
|
||||
}
|
||||
// go through the sorted list
|
||||
return P_TraverseIntercepts ( trav, FRACUNIT );
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,988 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Moving object handling. Spawn functions.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_mobj.c,v 1.5 1997/02/03 22:45:12 b1 Exp $";
|
||||
|
||||
#include "i_system.h"
|
||||
#include "z_zone.h"
|
||||
#include "m_random.h"
|
||||
|
||||
#include "doomdef.h"
|
||||
#include "p_local.h"
|
||||
#include "sounds.h"
|
||||
|
||||
#include "st_stuff.h"
|
||||
#include "hu_stuff.h"
|
||||
|
||||
#include "s_sound.h"
|
||||
|
||||
#include "doomstat.h"
|
||||
|
||||
|
||||
void G_PlayerReborn (int player);
|
||||
void P_SpawnMapThing (mapthing_t* mthing);
|
||||
|
||||
|
||||
//
|
||||
// P_SetMobjState
|
||||
// Returns true if the mobj is still present.
|
||||
//
|
||||
int test;
|
||||
|
||||
boolean
|
||||
P_SetMobjState
|
||||
( mobj_t* mobj,
|
||||
statenum_t state )
|
||||
{
|
||||
state_t* st;
|
||||
|
||||
do
|
||||
{
|
||||
if (state == S_NULL)
|
||||
{
|
||||
mobj->state = (state_t *) S_NULL;
|
||||
P_RemoveMobj (mobj);
|
||||
return false;
|
||||
}
|
||||
|
||||
st = &states[state];
|
||||
mobj->state = st;
|
||||
mobj->tics = st->tics;
|
||||
mobj->sprite = st->sprite;
|
||||
mobj->frame = st->frame;
|
||||
|
||||
// Modified handling.
|
||||
// Call action functions when the state is set
|
||||
if (st->action.acp1)
|
||||
st->action.acp1(mobj);
|
||||
|
||||
state = st->nextstate;
|
||||
} while (!mobj->tics);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_ExplodeMissile
|
||||
//
|
||||
void P_ExplodeMissile (mobj_t* mo)
|
||||
{
|
||||
mo->momx = mo->momy = mo->momz = 0;
|
||||
|
||||
P_SetMobjState (mo, mobjinfo[mo->type].deathstate);
|
||||
|
||||
mo->tics -= P_Random()&3;
|
||||
|
||||
if (mo->tics < 1)
|
||||
mo->tics = 1;
|
||||
|
||||
mo->flags &= ~MF_MISSILE;
|
||||
|
||||
if (mo->info->deathsound)
|
||||
S_StartSound (mo, mo->info->deathsound);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_XYMovement
|
||||
//
|
||||
#define STOPSPEED 0x1000
|
||||
#define FRICTION 0xe800
|
||||
|
||||
void P_XYMovement (mobj_t* mo)
|
||||
{
|
||||
fixed_t ptryx;
|
||||
fixed_t ptryy;
|
||||
player_t* player;
|
||||
fixed_t xmove;
|
||||
fixed_t ymove;
|
||||
|
||||
if (!mo->momx && !mo->momy)
|
||||
{
|
||||
if (mo->flags & MF_SKULLFLY)
|
||||
{
|
||||
// the skull slammed into something
|
||||
mo->flags &= ~MF_SKULLFLY;
|
||||
mo->momx = mo->momy = mo->momz = 0;
|
||||
|
||||
P_SetMobjState (mo, mo->info->spawnstate);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
player = mo->player;
|
||||
|
||||
if (mo->momx > MAXMOVE)
|
||||
mo->momx = MAXMOVE;
|
||||
else if (mo->momx < -MAXMOVE)
|
||||
mo->momx = -MAXMOVE;
|
||||
|
||||
if (mo->momy > MAXMOVE)
|
||||
mo->momy = MAXMOVE;
|
||||
else if (mo->momy < -MAXMOVE)
|
||||
mo->momy = -MAXMOVE;
|
||||
|
||||
xmove = mo->momx;
|
||||
ymove = mo->momy;
|
||||
|
||||
do
|
||||
{
|
||||
if (xmove > MAXMOVE/2 || ymove > MAXMOVE/2)
|
||||
{
|
||||
ptryx = mo->x + xmove/2;
|
||||
ptryy = mo->y + ymove/2;
|
||||
xmove >>= 1;
|
||||
ymove >>= 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
ptryx = mo->x + xmove;
|
||||
ptryy = mo->y + ymove;
|
||||
xmove = ymove = 0;
|
||||
}
|
||||
|
||||
if (!P_TryMove (mo, ptryx, ptryy))
|
||||
{
|
||||
// blocked move
|
||||
if (mo->player)
|
||||
{ // try to slide along it
|
||||
P_SlideMove (mo);
|
||||
}
|
||||
else if (mo->flags & MF_MISSILE)
|
||||
{
|
||||
// explode a missile
|
||||
if (ceilingline &&
|
||||
ceilingline->backsector &&
|
||||
ceilingline->backsector->ceilingpic == skyflatnum)
|
||||
{
|
||||
// Hack to prevent missiles exploding
|
||||
// against the sky.
|
||||
// Does not handle sky floors.
|
||||
P_RemoveMobj (mo);
|
||||
return;
|
||||
}
|
||||
P_ExplodeMissile (mo);
|
||||
}
|
||||
else
|
||||
mo->momx = mo->momy = 0;
|
||||
}
|
||||
} while (xmove || ymove);
|
||||
|
||||
// slow down
|
||||
if (player && player->cheats & CF_NOMOMENTUM)
|
||||
{
|
||||
// debug option for no sliding at all
|
||||
mo->momx = mo->momy = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
if (mo->flags & (MF_MISSILE | MF_SKULLFLY) )
|
||||
return; // no friction for missiles ever
|
||||
|
||||
if (mo->z > mo->floorz)
|
||||
return; // no friction when airborne
|
||||
|
||||
if (mo->flags & MF_CORPSE)
|
||||
{
|
||||
// do not stop sliding
|
||||
// if halfway off a step with some momentum
|
||||
if (mo->momx > FRACUNIT/4
|
||||
|| mo->momx < -FRACUNIT/4
|
||||
|| mo->momy > FRACUNIT/4
|
||||
|| mo->momy < -FRACUNIT/4)
|
||||
{
|
||||
if (mo->floorz != mo->subsector->sector->floorheight)
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (mo->momx > -STOPSPEED
|
||||
&& mo->momx < STOPSPEED
|
||||
&& mo->momy > -STOPSPEED
|
||||
&& mo->momy < STOPSPEED
|
||||
&& (!player
|
||||
|| (player->cmd.forwardmove== 0
|
||||
&& player->cmd.sidemove == 0 ) ) )
|
||||
{
|
||||
// if in a walking frame, stop moving
|
||||
if ( player&&(unsigned)((player->mo->state - states)- S_PLAY_RUN1) < 4)
|
||||
P_SetMobjState (player->mo, S_PLAY);
|
||||
|
||||
mo->momx = 0;
|
||||
mo->momy = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
mo->momx = FixedMul (mo->momx, FRICTION);
|
||||
mo->momy = FixedMul (mo->momy, FRICTION);
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// P_ZMovement
|
||||
//
|
||||
void P_ZMovement (mobj_t* mo)
|
||||
{
|
||||
fixed_t dist;
|
||||
fixed_t delta;
|
||||
|
||||
// check for smooth step up
|
||||
if (mo->player && mo->z < mo->floorz)
|
||||
{
|
||||
mo->player->viewheight -= mo->floorz-mo->z;
|
||||
|
||||
mo->player->deltaviewheight
|
||||
= (VIEWHEIGHT - mo->player->viewheight)>>3;
|
||||
}
|
||||
|
||||
// adjust height
|
||||
mo->z += mo->momz;
|
||||
|
||||
if ( mo->flags & MF_FLOAT
|
||||
&& mo->target)
|
||||
{
|
||||
// float down towards target if too close
|
||||
if ( !(mo->flags & MF_SKULLFLY)
|
||||
&& !(mo->flags & MF_INFLOAT) )
|
||||
{
|
||||
dist = P_AproxDistance (mo->x - mo->target->x,
|
||||
mo->y - mo->target->y);
|
||||
|
||||
delta =(mo->target->z + (mo->height>>1)) - mo->z;
|
||||
|
||||
if (delta<0 && dist < -(delta*3) )
|
||||
mo->z -= FLOATSPEED;
|
||||
else if (delta>0 && dist < (delta*3) )
|
||||
mo->z += FLOATSPEED;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// clip movement
|
||||
if (mo->z <= mo->floorz)
|
||||
{
|
||||
// hit the floor
|
||||
|
||||
// Note (id):
|
||||
// somebody left this after the setting momz to 0,
|
||||
// kinda useless there.
|
||||
if (mo->flags & MF_SKULLFLY)
|
||||
{
|
||||
// the skull slammed into something
|
||||
mo->momz = -mo->momz;
|
||||
}
|
||||
|
||||
if (mo->momz < 0)
|
||||
{
|
||||
if (mo->player
|
||||
&& mo->momz < -GRAVITY*8)
|
||||
{
|
||||
// Squat down.
|
||||
// Decrease viewheight for a moment
|
||||
// after hitting the ground (hard),
|
||||
// and utter appropriate sound.
|
||||
mo->player->deltaviewheight = mo->momz>>3;
|
||||
S_StartSound (mo, sfx_oof);
|
||||
}
|
||||
mo->momz = 0;
|
||||
}
|
||||
mo->z = mo->floorz;
|
||||
|
||||
if ( (mo->flags & MF_MISSILE)
|
||||
&& !(mo->flags & MF_NOCLIP) )
|
||||
{
|
||||
P_ExplodeMissile (mo);
|
||||
return;
|
||||
}
|
||||
}
|
||||
else if (! (mo->flags & MF_NOGRAVITY) )
|
||||
{
|
||||
if (mo->momz == 0)
|
||||
mo->momz = -GRAVITY*2;
|
||||
else
|
||||
mo->momz -= GRAVITY;
|
||||
}
|
||||
|
||||
if (mo->z + mo->height > mo->ceilingz)
|
||||
{
|
||||
// hit the ceiling
|
||||
if (mo->momz > 0)
|
||||
mo->momz = 0;
|
||||
{
|
||||
mo->z = mo->ceilingz - mo->height;
|
||||
}
|
||||
|
||||
if (mo->flags & MF_SKULLFLY)
|
||||
{ // the skull slammed into something
|
||||
mo->momz = -mo->momz;
|
||||
}
|
||||
|
||||
if ( (mo->flags & MF_MISSILE)
|
||||
&& !(mo->flags & MF_NOCLIP) )
|
||||
{
|
||||
P_ExplodeMissile (mo);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_NightmareRespawn
|
||||
//
|
||||
void
|
||||
P_NightmareRespawn (mobj_t* mobj)
|
||||
{
|
||||
fixed_t x;
|
||||
fixed_t y;
|
||||
fixed_t z;
|
||||
subsector_t* ss;
|
||||
mobj_t* mo;
|
||||
mapthing_t* mthing;
|
||||
|
||||
x = mobj->spawnpoint.x << FRACBITS;
|
||||
y = mobj->spawnpoint.y << FRACBITS;
|
||||
|
||||
// somthing is occupying it's position?
|
||||
if (!P_CheckPosition (mobj, x, y) )
|
||||
return; // no respwan
|
||||
|
||||
// spawn a teleport fog at old spot
|
||||
// because of removal of the body?
|
||||
mo = P_SpawnMobj (mobj->x,
|
||||
mobj->y,
|
||||
mobj->subsector->sector->floorheight , MT_TFOG);
|
||||
// initiate teleport sound
|
||||
S_StartSound (mo, sfx_telept);
|
||||
|
||||
// spawn a teleport fog at the new spot
|
||||
ss = R_PointInSubsector (x,y);
|
||||
|
||||
mo = P_SpawnMobj (x, y, ss->sector->floorheight , MT_TFOG);
|
||||
|
||||
S_StartSound (mo, sfx_telept);
|
||||
|
||||
// spawn the new monster
|
||||
mthing = &mobj->spawnpoint;
|
||||
|
||||
// spawn it
|
||||
if (mobj->info->flags & MF_SPAWNCEILING)
|
||||
z = ONCEILINGZ;
|
||||
else
|
||||
z = ONFLOORZ;
|
||||
|
||||
// inherit attributes from deceased one
|
||||
mo = P_SpawnMobj (x,y,z, mobj->type);
|
||||
mo->spawnpoint = mobj->spawnpoint;
|
||||
mo->angle = ANG45 * (mthing->angle/45);
|
||||
|
||||
if (mthing->options & MTF_AMBUSH)
|
||||
mo->flags |= MF_AMBUSH;
|
||||
|
||||
mo->reactiontime = 18;
|
||||
|
||||
// remove the old monster,
|
||||
P_RemoveMobj (mobj);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_MobjThinker
|
||||
//
|
||||
void P_MobjThinker (mobj_t* mobj)
|
||||
{
|
||||
// momentum movement
|
||||
if (mobj->momx
|
||||
|| mobj->momy
|
||||
|| (mobj->flags&MF_SKULLFLY) )
|
||||
{
|
||||
P_XYMovement (mobj);
|
||||
|
||||
// FIXME: decent NOP/NULL/Nil function pointer please.
|
||||
if (mobj->thinker.function.acv == (actionf_v) (-1))
|
||||
return; // mobj was removed
|
||||
}
|
||||
if ( (mobj->z != mobj->floorz)
|
||||
|| mobj->momz )
|
||||
{
|
||||
P_ZMovement (mobj);
|
||||
|
||||
// FIXME: decent NOP/NULL/Nil function pointer please.
|
||||
if (mobj->thinker.function.acv == (actionf_v) (-1))
|
||||
return; // mobj was removed
|
||||
}
|
||||
|
||||
|
||||
// cycle through states,
|
||||
// calling action functions at transitions
|
||||
if (mobj->tics != -1)
|
||||
{
|
||||
mobj->tics--;
|
||||
|
||||
// you can cycle through multiple states in a tic
|
||||
if (!mobj->tics)
|
||||
if (!P_SetMobjState (mobj, mobj->state->nextstate) )
|
||||
return; // freed itself
|
||||
}
|
||||
else
|
||||
{
|
||||
// check for nightmare respawn
|
||||
if (! (mobj->flags & MF_COUNTKILL) )
|
||||
return;
|
||||
|
||||
if (!respawnmonsters)
|
||||
return;
|
||||
|
||||
mobj->movecount++;
|
||||
|
||||
if (mobj->movecount < 12*35)
|
||||
return;
|
||||
|
||||
if ( leveltime&31 )
|
||||
return;
|
||||
|
||||
if (P_Random () > 4)
|
||||
return;
|
||||
|
||||
P_NightmareRespawn (mobj);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_SpawnMobj
|
||||
//
|
||||
mobj_t*
|
||||
P_SpawnMobj
|
||||
( fixed_t x,
|
||||
fixed_t y,
|
||||
fixed_t z,
|
||||
mobjtype_t type )
|
||||
{
|
||||
mobj_t* mobj;
|
||||
state_t* st;
|
||||
mobjinfo_t* info;
|
||||
|
||||
mobj = Z_Malloc (sizeof(*mobj), PU_LEVEL, NULL);
|
||||
memset (mobj, 0, sizeof (*mobj));
|
||||
info = &mobjinfo[type];
|
||||
|
||||
mobj->type = type;
|
||||
mobj->info = info;
|
||||
mobj->x = x;
|
||||
mobj->y = y;
|
||||
mobj->radius = info->radius;
|
||||
mobj->height = info->height;
|
||||
mobj->flags = info->flags;
|
||||
mobj->health = info->spawnhealth;
|
||||
|
||||
if (gameskill != sk_nightmare)
|
||||
mobj->reactiontime = info->reactiontime;
|
||||
|
||||
mobj->lastlook = P_Random () % MAXPLAYERS;
|
||||
// do not set the state with P_SetMobjState,
|
||||
// because action routines can not be called yet
|
||||
st = &states[info->spawnstate];
|
||||
|
||||
mobj->state = st;
|
||||
mobj->tics = st->tics;
|
||||
mobj->sprite = st->sprite;
|
||||
mobj->frame = st->frame;
|
||||
|
||||
// set subsector and/or block links
|
||||
P_SetThingPosition (mobj);
|
||||
|
||||
mobj->floorz = mobj->subsector->sector->floorheight;
|
||||
mobj->ceilingz = mobj->subsector->sector->ceilingheight;
|
||||
|
||||
if (z == ONFLOORZ)
|
||||
mobj->z = mobj->floorz;
|
||||
else if (z == ONCEILINGZ)
|
||||
mobj->z = mobj->ceilingz - mobj->info->height;
|
||||
else
|
||||
mobj->z = z;
|
||||
|
||||
mobj->thinker.function.acp1 = (actionf_p1)P_MobjThinker;
|
||||
|
||||
P_AddThinker (&mobj->thinker);
|
||||
|
||||
return mobj;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_RemoveMobj
|
||||
//
|
||||
mapthing_t itemrespawnque[ITEMQUESIZE];
|
||||
int itemrespawntime[ITEMQUESIZE];
|
||||
int iquehead;
|
||||
int iquetail;
|
||||
|
||||
|
||||
void P_RemoveMobj (mobj_t* mobj)
|
||||
{
|
||||
if ((mobj->flags & MF_SPECIAL)
|
||||
&& !(mobj->flags & MF_DROPPED)
|
||||
&& (mobj->type != MT_INV)
|
||||
&& (mobj->type != MT_INS))
|
||||
{
|
||||
itemrespawnque[iquehead] = mobj->spawnpoint;
|
||||
itemrespawntime[iquehead] = leveltime;
|
||||
iquehead = (iquehead+1)&(ITEMQUESIZE-1);
|
||||
|
||||
// lose one off the end?
|
||||
if (iquehead == iquetail)
|
||||
iquetail = (iquetail+1)&(ITEMQUESIZE-1);
|
||||
}
|
||||
|
||||
// unlink from sector and block lists
|
||||
P_UnsetThingPosition (mobj);
|
||||
|
||||
// stop any playing sound
|
||||
S_StopSound (mobj);
|
||||
|
||||
// free block
|
||||
P_RemoveThinker ((thinker_t*)mobj);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_RespawnSpecials
|
||||
//
|
||||
void P_RespawnSpecials (void)
|
||||
{
|
||||
fixed_t x;
|
||||
fixed_t y;
|
||||
fixed_t z;
|
||||
|
||||
subsector_t* ss;
|
||||
mobj_t* mo;
|
||||
mapthing_t* mthing;
|
||||
|
||||
int i;
|
||||
|
||||
// only respawn items in deathmatch
|
||||
if (deathmatch != 2)
|
||||
return; //
|
||||
|
||||
// nothing left to respawn?
|
||||
if (iquehead == iquetail)
|
||||
return;
|
||||
|
||||
// wait at least 30 seconds
|
||||
if (leveltime - itemrespawntime[iquetail] < 30*35)
|
||||
return;
|
||||
|
||||
mthing = &itemrespawnque[iquetail];
|
||||
|
||||
x = mthing->x << FRACBITS;
|
||||
y = mthing->y << FRACBITS;
|
||||
|
||||
// spawn a teleport fog at the new spot
|
||||
ss = R_PointInSubsector (x,y);
|
||||
mo = P_SpawnMobj (x, y, ss->sector->floorheight , MT_IFOG);
|
||||
S_StartSound (mo, sfx_itmbk);
|
||||
|
||||
// find which type to spawn
|
||||
for (i=0 ; i< NUMMOBJTYPES ; i++)
|
||||
{
|
||||
if (mthing->type == mobjinfo[i].doomednum)
|
||||
break;
|
||||
}
|
||||
|
||||
// spawn it
|
||||
if (mobjinfo[i].flags & MF_SPAWNCEILING)
|
||||
z = ONCEILINGZ;
|
||||
else
|
||||
z = ONFLOORZ;
|
||||
|
||||
mo = P_SpawnMobj (x,y,z, i);
|
||||
mo->spawnpoint = *mthing;
|
||||
mo->angle = ANG45 * (mthing->angle/45);
|
||||
|
||||
// pull it from the que
|
||||
iquetail = (iquetail+1)&(ITEMQUESIZE-1);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_SpawnPlayer
|
||||
// Called when a player is spawned on the level.
|
||||
// Most of the player structure stays unchanged
|
||||
// between levels.
|
||||
//
|
||||
void P_SpawnPlayer (mapthing_t* mthing)
|
||||
{
|
||||
player_t* p;
|
||||
fixed_t x;
|
||||
fixed_t y;
|
||||
fixed_t z;
|
||||
|
||||
mobj_t* mobj;
|
||||
|
||||
int i;
|
||||
|
||||
// not playing?
|
||||
if (!playeringame[mthing->type-1])
|
||||
return;
|
||||
|
||||
p = &players[mthing->type-1];
|
||||
|
||||
if (p->playerstate == PST_REBORN)
|
||||
G_PlayerReborn (mthing->type-1);
|
||||
|
||||
x = mthing->x << FRACBITS;
|
||||
y = mthing->y << FRACBITS;
|
||||
z = ONFLOORZ;
|
||||
mobj = P_SpawnMobj (x,y,z, MT_PLAYER);
|
||||
|
||||
// set color translations for player sprites
|
||||
if (mthing->type > 1)
|
||||
mobj->flags |= (mthing->type-1)<<MF_TRANSSHIFT;
|
||||
|
||||
mobj->angle = ANG45 * (mthing->angle/45);
|
||||
mobj->player = p;
|
||||
mobj->health = p->health;
|
||||
|
||||
p->mo = mobj;
|
||||
p->playerstate = PST_LIVE;
|
||||
p->refire = 0;
|
||||
p->message = NULL;
|
||||
p->damagecount = 0;
|
||||
p->bonuscount = 0;
|
||||
p->extralight = 0;
|
||||
p->fixedcolormap = 0;
|
||||
p->viewheight = VIEWHEIGHT;
|
||||
|
||||
// setup gun psprite
|
||||
P_SetupPsprites (p);
|
||||
|
||||
// give all cards in death match mode
|
||||
if (deathmatch)
|
||||
for (i=0 ; i<NUMCARDS ; i++)
|
||||
p->cards[i] = true;
|
||||
|
||||
if (mthing->type-1 == consoleplayer)
|
||||
{
|
||||
// wake up the status bar
|
||||
ST_Start ();
|
||||
// wake up the heads up text
|
||||
HU_Start ();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_SpawnMapThing
|
||||
// The fields of the mapthing should
|
||||
// already be in host byte order.
|
||||
//
|
||||
void P_SpawnMapThing (mapthing_t* mthing)
|
||||
{
|
||||
int i;
|
||||
int bit;
|
||||
mobj_t* mobj;
|
||||
fixed_t x;
|
||||
fixed_t y;
|
||||
fixed_t z;
|
||||
|
||||
// count deathmatch start positions
|
||||
if (mthing->type == 11)
|
||||
{
|
||||
if (deathmatch_p < &deathmatchstarts[10])
|
||||
{
|
||||
memcpy (deathmatch_p, mthing, sizeof(*mthing));
|
||||
deathmatch_p++;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// check for players specially
|
||||
if (mthing->type <= 4)
|
||||
{
|
||||
// save spots for respawning in network games
|
||||
playerstarts[mthing->type-1] = *mthing;
|
||||
if (!deathmatch)
|
||||
P_SpawnPlayer (mthing);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
// check for apropriate skill level
|
||||
if (!netgame && (mthing->options & 16) )
|
||||
return;
|
||||
|
||||
if (gameskill == sk_baby)
|
||||
bit = 1;
|
||||
else if (gameskill == sk_nightmare)
|
||||
bit = 4;
|
||||
else
|
||||
bit = 1<<(gameskill-1);
|
||||
|
||||
if (!(mthing->options & bit) )
|
||||
return;
|
||||
|
||||
// find which type to spawn
|
||||
for (i=0 ; i< NUMMOBJTYPES ; i++)
|
||||
if (mthing->type == mobjinfo[i].doomednum)
|
||||
break;
|
||||
|
||||
if (i==NUMMOBJTYPES)
|
||||
I_Error ("P_SpawnMapThing: Unknown type %i at (%i, %i)",
|
||||
mthing->type,
|
||||
mthing->x, mthing->y);
|
||||
|
||||
// don't spawn keycards and players in deathmatch
|
||||
if (deathmatch && mobjinfo[i].flags & MF_NOTDMATCH)
|
||||
return;
|
||||
|
||||
// don't spawn any monsters if -nomonsters
|
||||
if (nomonsters
|
||||
&& ( i == MT_SKULL
|
||||
|| (mobjinfo[i].flags & MF_COUNTKILL)) )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// spawn it
|
||||
x = mthing->x << FRACBITS;
|
||||
y = mthing->y << FRACBITS;
|
||||
|
||||
if (mobjinfo[i].flags & MF_SPAWNCEILING)
|
||||
z = ONCEILINGZ;
|
||||
else
|
||||
z = ONFLOORZ;
|
||||
|
||||
mobj = P_SpawnMobj (x,y,z, i);
|
||||
mobj->spawnpoint = *mthing;
|
||||
|
||||
if (mobj->tics > 0)
|
||||
mobj->tics = 1 + (P_Random () % mobj->tics);
|
||||
if (mobj->flags & MF_COUNTKILL)
|
||||
totalkills++;
|
||||
if (mobj->flags & MF_COUNTITEM)
|
||||
totalitems++;
|
||||
|
||||
mobj->angle = ANG45 * (mthing->angle/45);
|
||||
if (mthing->options & MTF_AMBUSH)
|
||||
mobj->flags |= MF_AMBUSH;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// GAME SPAWN FUNCTIONS
|
||||
//
|
||||
|
||||
|
||||
//
|
||||
// P_SpawnPuff
|
||||
//
|
||||
extern fixed_t attackrange;
|
||||
|
||||
void
|
||||
P_SpawnPuff
|
||||
( fixed_t x,
|
||||
fixed_t y,
|
||||
fixed_t z )
|
||||
{
|
||||
mobj_t* th;
|
||||
|
||||
z += ((P_Random()-P_Random())<<10);
|
||||
|
||||
th = P_SpawnMobj (x,y,z, MT_PUFF);
|
||||
th->momz = FRACUNIT;
|
||||
th->tics -= P_Random()&3;
|
||||
|
||||
if (th->tics < 1)
|
||||
th->tics = 1;
|
||||
|
||||
// don't make punches spark on the wall
|
||||
if (attackrange == MELEERANGE)
|
||||
P_SetMobjState (th, S_PUFF3);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_SpawnBlood
|
||||
//
|
||||
void
|
||||
P_SpawnBlood
|
||||
( fixed_t x,
|
||||
fixed_t y,
|
||||
fixed_t z,
|
||||
int damage )
|
||||
{
|
||||
mobj_t* th;
|
||||
|
||||
z += ((P_Random()-P_Random())<<10);
|
||||
th = P_SpawnMobj (x,y,z, MT_BLOOD);
|
||||
th->momz = FRACUNIT*2;
|
||||
th->tics -= P_Random()&3;
|
||||
|
||||
if (th->tics < 1)
|
||||
th->tics = 1;
|
||||
|
||||
if (damage <= 12 && damage >= 9)
|
||||
P_SetMobjState (th,S_BLOOD2);
|
||||
else if (damage < 9)
|
||||
P_SetMobjState (th,S_BLOOD3);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_CheckMissileSpawn
|
||||
// Moves the missile forward a bit
|
||||
// and possibly explodes it right there.
|
||||
//
|
||||
void P_CheckMissileSpawn (mobj_t* th)
|
||||
{
|
||||
th->tics -= P_Random()&3;
|
||||
if (th->tics < 1)
|
||||
th->tics = 1;
|
||||
|
||||
// move a little forward so an angle can
|
||||
// be computed if it immediately explodes
|
||||
th->x += (th->momx>>1);
|
||||
th->y += (th->momy>>1);
|
||||
th->z += (th->momz>>1);
|
||||
|
||||
if (!P_TryMove (th, th->x, th->y))
|
||||
P_ExplodeMissile (th);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_SpawnMissile
|
||||
//
|
||||
mobj_t*
|
||||
P_SpawnMissile
|
||||
( mobj_t* source,
|
||||
mobj_t* dest,
|
||||
mobjtype_t type )
|
||||
{
|
||||
mobj_t* th;
|
||||
angle_t an;
|
||||
int dist;
|
||||
|
||||
th = P_SpawnMobj (source->x,
|
||||
source->y,
|
||||
source->z + 4*8*FRACUNIT, type);
|
||||
|
||||
if (th->info->seesound)
|
||||
S_StartSound (th, th->info->seesound);
|
||||
|
||||
th->target = source; // where it came from
|
||||
an = R_PointToAngle2 (source->x, source->y, dest->x, dest->y);
|
||||
|
||||
// fuzzy player
|
||||
if (dest->flags & MF_SHADOW)
|
||||
an += (P_Random()-P_Random())<<20;
|
||||
|
||||
th->angle = an;
|
||||
an >>= ANGLETOFINESHIFT;
|
||||
th->momx = FixedMul (th->info->speed, finecosine[an]);
|
||||
th->momy = FixedMul (th->info->speed, finesine[an]);
|
||||
|
||||
dist = P_AproxDistance (dest->x - source->x, dest->y - source->y);
|
||||
dist = dist / th->info->speed;
|
||||
|
||||
if (dist < 1)
|
||||
dist = 1;
|
||||
|
||||
th->momz = (dest->z - source->z) / dist;
|
||||
P_CheckMissileSpawn (th);
|
||||
|
||||
return th;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_SpawnPlayerMissile
|
||||
// Tries to aim at a nearby monster
|
||||
//
|
||||
void
|
||||
P_SpawnPlayerMissile
|
||||
( mobj_t* source,
|
||||
mobjtype_t type )
|
||||
{
|
||||
mobj_t* th;
|
||||
angle_t an;
|
||||
|
||||
fixed_t x;
|
||||
fixed_t y;
|
||||
fixed_t z;
|
||||
fixed_t slope;
|
||||
|
||||
// see which target is to be aimed at
|
||||
an = source->angle;
|
||||
slope = P_AimLineAttack (source, an, 16*64*FRACUNIT);
|
||||
|
||||
if (!linetarget)
|
||||
{
|
||||
an += 1<<26;
|
||||
slope = P_AimLineAttack (source, an, 16*64*FRACUNIT);
|
||||
|
||||
if (!linetarget)
|
||||
{
|
||||
an -= 2<<26;
|
||||
slope = P_AimLineAttack (source, an, 16*64*FRACUNIT);
|
||||
}
|
||||
|
||||
if (!linetarget)
|
||||
{
|
||||
an = source->angle;
|
||||
slope = 0;
|
||||
}
|
||||
}
|
||||
|
||||
x = source->x;
|
||||
y = source->y;
|
||||
z = source->z + 4*8*FRACUNIT;
|
||||
|
||||
th = P_SpawnMobj (x,y,z, type);
|
||||
|
||||
if (th->info->seesound)
|
||||
S_StartSound (th, th->info->seesound);
|
||||
|
||||
th->target = source;
|
||||
th->angle = an;
|
||||
th->momx = FixedMul( th->info->speed,
|
||||
finecosine[an>>ANGLETOFINESHIFT]);
|
||||
th->momy = FixedMul( th->info->speed,
|
||||
finesine[an>>ANGLETOFINESHIFT]);
|
||||
th->momz = FixedMul( th->info->speed, slope);
|
||||
|
||||
P_CheckMissileSpawn (th);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,295 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Map Objects, MObj, definition and handling.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __P_MOBJ__
|
||||
#define __P_MOBJ__
|
||||
|
||||
// Basics.
|
||||
#include "tables.h"
|
||||
#include "m_fixed.h"
|
||||
|
||||
// We need the thinker_t stuff.
|
||||
#include "d_think.h"
|
||||
|
||||
// We need the WAD data structure for Map things,
|
||||
// from the THINGS lump.
|
||||
#include "doomdata.h"
|
||||
|
||||
// States are tied to finite states are
|
||||
// tied to animation frames.
|
||||
// Needs precompiled tables/data structures.
|
||||
#include "info.h"
|
||||
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
//
|
||||
// NOTES: mobj_t
|
||||
//
|
||||
// mobj_ts are used to tell the refresh where to draw an image,
|
||||
// tell the world simulation when objects are contacted,
|
||||
// and tell the sound driver how to position a sound.
|
||||
//
|
||||
// The refresh uses the next and prev links to follow
|
||||
// lists of things in sectors as they are being drawn.
|
||||
// The sprite, frame, and angle elements determine which patch_t
|
||||
// is used to draw the sprite if it is visible.
|
||||
// The sprite and frame values are allmost allways set
|
||||
// from state_t structures.
|
||||
// The statescr.exe utility generates the states.h and states.c
|
||||
// files that contain the sprite/frame numbers from the
|
||||
// statescr.txt source file.
|
||||
// The xyz origin point represents a point at the bottom middle
|
||||
// of the sprite (between the feet of a biped).
|
||||
// This is the default origin position for patch_ts grabbed
|
||||
// with lumpy.exe.
|
||||
// A walking creature will have its z equal to the floor
|
||||
// it is standing on.
|
||||
//
|
||||
// The sound code uses the x,y, and subsector fields
|
||||
// to do stereo positioning of any sound effited by the mobj_t.
|
||||
//
|
||||
// The play simulation uses the blocklinks, x,y,z, radius, height
|
||||
// to determine when mobj_ts are touching each other,
|
||||
// touching lines in the map, or hit by trace lines (gunshots,
|
||||
// lines of sight, etc).
|
||||
// The mobj_t->flags element has various bit flags
|
||||
// used by the simulation.
|
||||
//
|
||||
// Every mobj_t is linked into a single sector
|
||||
// based on its origin coordinates.
|
||||
// The subsector_t is found with R_PointInSubsector(x,y),
|
||||
// and the sector_t can be found with subsector->sector.
|
||||
// The sector links are only used by the rendering code,
|
||||
// the play simulation does not care about them at all.
|
||||
//
|
||||
// Any mobj_t that needs to be acted upon by something else
|
||||
// in the play world (block movement, be shot, etc) will also
|
||||
// need to be linked into the blockmap.
|
||||
// If the thing has the MF_NOBLOCK flag set, it will not use
|
||||
// the block links. It can still interact with other things,
|
||||
// but only as the instigator (missiles will run into other
|
||||
// things, but nothing can run into a missile).
|
||||
// Each block in the grid is 128*128 units, and knows about
|
||||
// every line_t that it contains a piece of, and every
|
||||
// interactable mobj_t that has its origin contained.
|
||||
//
|
||||
// A valid mobj_t is a mobj_t that has the proper subsector_t
|
||||
// filled in for its xy coordinates and is linked into the
|
||||
// sector from which the subsector was made, or has the
|
||||
// MF_NOSECTOR flag set (the subsector_t needs to be valid
|
||||
// even if MF_NOSECTOR is set), and is linked into a blockmap
|
||||
// block or has the MF_NOBLOCKMAP flag set.
|
||||
// Links should only be modified by the P_[Un]SetThingPosition()
|
||||
// functions.
|
||||
// Do not change the MF_NO? flags while a thing is valid.
|
||||
//
|
||||
// Any questions?
|
||||
//
|
||||
|
||||
//
|
||||
// Misc. mobj flags
|
||||
//
|
||||
typedef enum
|
||||
{
|
||||
// Call P_SpecialThing when touched.
|
||||
MF_SPECIAL = 1,
|
||||
// Blocks.
|
||||
MF_SOLID = 2,
|
||||
// Can be hit.
|
||||
MF_SHOOTABLE = 4,
|
||||
// Don't use the sector links (invisible but touchable).
|
||||
MF_NOSECTOR = 8,
|
||||
// Don't use the blocklinks (inert but displayable)
|
||||
MF_NOBLOCKMAP = 16,
|
||||
|
||||
// Not to be activated by sound, deaf monster.
|
||||
MF_AMBUSH = 32,
|
||||
// Will try to attack right back.
|
||||
MF_JUSTHIT = 64,
|
||||
// Will take at least one step before attacking.
|
||||
MF_JUSTATTACKED = 128,
|
||||
// On level spawning (initial position),
|
||||
// hang from ceiling instead of stand on floor.
|
||||
MF_SPAWNCEILING = 256,
|
||||
// Don't apply gravity (every tic),
|
||||
// that is, object will float, keeping current height
|
||||
// or changing it actively.
|
||||
MF_NOGRAVITY = 512,
|
||||
|
||||
// Movement flags.
|
||||
// This allows jumps from high places.
|
||||
MF_DROPOFF = 0x400,
|
||||
// For players, will pick up items.
|
||||
MF_PICKUP = 0x800,
|
||||
// Player cheat. ???
|
||||
MF_NOCLIP = 0x1000,
|
||||
// Player: keep info about sliding along walls.
|
||||
MF_SLIDE = 0x2000,
|
||||
// Allow moves to any height, no gravity.
|
||||
// For active floaters, e.g. cacodemons, pain elementals.
|
||||
MF_FLOAT = 0x4000,
|
||||
// Don't cross lines
|
||||
// ??? or look at heights on teleport.
|
||||
MF_TELEPORT = 0x8000,
|
||||
// Don't hit same species, explode on block.
|
||||
// Player missiles as well as fireballs of various kinds.
|
||||
MF_MISSILE = 0x10000,
|
||||
// Dropped by a demon, not level spawned.
|
||||
// E.g. ammo clips dropped by dying former humans.
|
||||
MF_DROPPED = 0x20000,
|
||||
// Use fuzzy draw (shadow demons or spectres),
|
||||
// temporary player invisibility powerup.
|
||||
MF_SHADOW = 0x40000,
|
||||
// Flag: don't bleed when shot (use puff),
|
||||
// barrels and shootable furniture shall not bleed.
|
||||
MF_NOBLOOD = 0x80000,
|
||||
// Don't stop moving halfway off a step,
|
||||
// that is, have dead bodies slide down all the way.
|
||||
MF_CORPSE = 0x100000,
|
||||
// Floating to a height for a move, ???
|
||||
// don't auto float to target's height.
|
||||
MF_INFLOAT = 0x200000,
|
||||
|
||||
// On kill, count this enemy object
|
||||
// towards intermission kill total.
|
||||
// Happy gathering.
|
||||
MF_COUNTKILL = 0x400000,
|
||||
|
||||
// On picking up, count this item object
|
||||
// towards intermission item total.
|
||||
MF_COUNTITEM = 0x800000,
|
||||
|
||||
// Special handling: skull in flight.
|
||||
// Neither a cacodemon nor a missile.
|
||||
MF_SKULLFLY = 0x1000000,
|
||||
|
||||
// Don't spawn this object
|
||||
// in death match mode (e.g. key cards).
|
||||
MF_NOTDMATCH = 0x2000000,
|
||||
|
||||
// Player sprites in multiplayer modes are modified
|
||||
// using an internal color lookup table for re-indexing.
|
||||
// If 0x4 0x8 or 0xc,
|
||||
// use a translation table for player colormaps
|
||||
MF_TRANSLATION = 0xc000000,
|
||||
// Hmm ???.
|
||||
MF_TRANSSHIFT = 26
|
||||
|
||||
} mobjflag_t;
|
||||
|
||||
|
||||
// Map Object definition.
|
||||
typedef struct mobj_s
|
||||
{
|
||||
// List: thinker links.
|
||||
thinker_t thinker;
|
||||
|
||||
// Info for drawing: position.
|
||||
fixed_t x;
|
||||
fixed_t y;
|
||||
fixed_t z;
|
||||
|
||||
// More list: links in sector (if needed)
|
||||
struct mobj_s* snext;
|
||||
struct mobj_s* sprev;
|
||||
|
||||
//More drawing info: to determine current sprite.
|
||||
angle_t angle; // orientation
|
||||
spritenum_t sprite; // used to find patch_t and flip value
|
||||
int frame; // might be ORed with FF_FULLBRIGHT
|
||||
|
||||
// Interaction info, by BLOCKMAP.
|
||||
// Links in blocks (if needed).
|
||||
struct mobj_s* bnext;
|
||||
struct mobj_s* bprev;
|
||||
|
||||
struct subsector_s* subsector;
|
||||
|
||||
// The closest interval over all contacted Sectors.
|
||||
fixed_t floorz;
|
||||
fixed_t ceilingz;
|
||||
|
||||
// For movement checking.
|
||||
fixed_t radius;
|
||||
fixed_t height;
|
||||
|
||||
// Momentums, used to update position.
|
||||
fixed_t momx;
|
||||
fixed_t momy;
|
||||
fixed_t momz;
|
||||
|
||||
// If == validcount, already checked.
|
||||
int validcount;
|
||||
|
||||
mobjtype_t type;
|
||||
mobjinfo_t* info; // &mobjinfo[mobj->type]
|
||||
|
||||
int tics; // state tic counter
|
||||
state_t* state;
|
||||
int flags;
|
||||
int health;
|
||||
|
||||
// Movement direction, movement generation (zig-zagging).
|
||||
int movedir; // 0-7
|
||||
int movecount; // when 0, select a new dir
|
||||
|
||||
// Thing being chased/attacked (or NULL),
|
||||
// also the originator for missiles.
|
||||
struct mobj_s* target;
|
||||
|
||||
// Reaction time: if non 0, don't attack yet.
|
||||
// Used by player to freeze a bit after teleporting.
|
||||
int reactiontime;
|
||||
|
||||
// If >0, the target will be chased
|
||||
// no matter what (even if shot)
|
||||
int threshold;
|
||||
|
||||
// Additional info record for player avatars only.
|
||||
// Only valid if type == MT_PLAYER
|
||||
struct player_s* player;
|
||||
|
||||
// Player number last looked for.
|
||||
int lastlook;
|
||||
|
||||
// For nightmare respawn.
|
||||
mapthing_t spawnpoint;
|
||||
|
||||
// Thing being chased/attacked for tracers.
|
||||
struct mobj_s* tracer;
|
||||
|
||||
} mobj_t;
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,314 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Plats (i.e. elevator platforms) code, raising/lowering.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_plats.c,v 1.5 1997/02/03 22:45:12 b1 Exp $";
|
||||
|
||||
|
||||
#include "i_system.h"
|
||||
#include "z_zone.h"
|
||||
#include "m_random.h"
|
||||
|
||||
#include "doomdef.h"
|
||||
#include "p_local.h"
|
||||
|
||||
#include "s_sound.h"
|
||||
|
||||
// State.
|
||||
#include "doomstat.h"
|
||||
#include "r_state.h"
|
||||
|
||||
// Data.
|
||||
#include "sounds.h"
|
||||
|
||||
|
||||
plat_t* activeplats[MAXPLATS];
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Move a plat up and down
|
||||
//
|
||||
void T_PlatRaise(plat_t* plat)
|
||||
{
|
||||
result_e res;
|
||||
|
||||
switch(plat->status)
|
||||
{
|
||||
case up:
|
||||
res = T_MovePlane(plat->sector,
|
||||
plat->speed,
|
||||
plat->high,
|
||||
plat->crush,0,1);
|
||||
|
||||
if (plat->type == raiseAndChange
|
||||
|| plat->type == raiseToNearestAndChange)
|
||||
{
|
||||
if (!(leveltime&7))
|
||||
S_StartSound((mobj_t *)&plat->sector->soundorg,
|
||||
sfx_stnmov);
|
||||
}
|
||||
|
||||
|
||||
if (res == crushed && (!plat->crush))
|
||||
{
|
||||
plat->count = plat->wait;
|
||||
plat->status = down;
|
||||
S_StartSound((mobj_t *)&plat->sector->soundorg,
|
||||
sfx_pstart);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (res == pastdest)
|
||||
{
|
||||
plat->count = plat->wait;
|
||||
plat->status = waiting;
|
||||
S_StartSound((mobj_t *)&plat->sector->soundorg,
|
||||
sfx_pstop);
|
||||
|
||||
switch(plat->type)
|
||||
{
|
||||
case blazeDWUS:
|
||||
case downWaitUpStay:
|
||||
P_RemoveActivePlat(plat);
|
||||
break;
|
||||
|
||||
case raiseAndChange:
|
||||
case raiseToNearestAndChange:
|
||||
P_RemoveActivePlat(plat);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case down:
|
||||
res = T_MovePlane(plat->sector,plat->speed,plat->low,false,0,-1);
|
||||
|
||||
if (res == pastdest)
|
||||
{
|
||||
plat->count = plat->wait;
|
||||
plat->status = waiting;
|
||||
S_StartSound((mobj_t *)&plat->sector->soundorg,sfx_pstop);
|
||||
}
|
||||
break;
|
||||
|
||||
case waiting:
|
||||
if (!--plat->count)
|
||||
{
|
||||
if (plat->sector->floorheight == plat->low)
|
||||
plat->status = up;
|
||||
else
|
||||
plat->status = down;
|
||||
S_StartSound((mobj_t *)&plat->sector->soundorg,sfx_pstart);
|
||||
}
|
||||
case in_stasis:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Do Platforms
|
||||
// "amount" is only used for SOME platforms.
|
||||
//
|
||||
int
|
||||
EV_DoPlat
|
||||
( line_t* line,
|
||||
plattype_e type,
|
||||
int amount )
|
||||
{
|
||||
plat_t* plat;
|
||||
int secnum;
|
||||
int rtn;
|
||||
sector_t* sec;
|
||||
|
||||
secnum = -1;
|
||||
rtn = 0;
|
||||
|
||||
|
||||
// Activate all <type> plats that are in_stasis
|
||||
switch(type)
|
||||
{
|
||||
case perpetualRaise:
|
||||
P_ActivateInStasis(line->tag);
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
while ((secnum = P_FindSectorFromLineTag(line,secnum)) >= 0)
|
||||
{
|
||||
sec = §ors[secnum];
|
||||
|
||||
if (sec->specialdata)
|
||||
continue;
|
||||
|
||||
// Find lowest & highest floors around sector
|
||||
rtn = 1;
|
||||
plat = Z_Malloc( sizeof(*plat), PU_LEVSPEC, 0);
|
||||
P_AddThinker(&plat->thinker);
|
||||
|
||||
plat->type = type;
|
||||
plat->sector = sec;
|
||||
plat->sector->specialdata = plat;
|
||||
plat->thinker.function.acp1 = (actionf_p1) T_PlatRaise;
|
||||
plat->crush = false;
|
||||
plat->tag = line->tag;
|
||||
|
||||
switch(type)
|
||||
{
|
||||
case raiseToNearestAndChange:
|
||||
plat->speed = PLATSPEED/2;
|
||||
sec->floorpic = sides[line->sidenum[0]].sector->floorpic;
|
||||
plat->high = P_FindNextHighestFloor(sec,sec->floorheight);
|
||||
plat->wait = 0;
|
||||
plat->status = up;
|
||||
// NO MORE DAMAGE, IF APPLICABLE
|
||||
sec->special = 0;
|
||||
|
||||
S_StartSound((mobj_t *)&sec->soundorg,sfx_stnmov);
|
||||
break;
|
||||
|
||||
case raiseAndChange:
|
||||
plat->speed = PLATSPEED/2;
|
||||
sec->floorpic = sides[line->sidenum[0]].sector->floorpic;
|
||||
plat->high = sec->floorheight + amount*FRACUNIT;
|
||||
plat->wait = 0;
|
||||
plat->status = up;
|
||||
|
||||
S_StartSound((mobj_t *)&sec->soundorg,sfx_stnmov);
|
||||
break;
|
||||
|
||||
case downWaitUpStay:
|
||||
plat->speed = PLATSPEED * 4;
|
||||
plat->low = P_FindLowestFloorSurrounding(sec);
|
||||
|
||||
if (plat->low > sec->floorheight)
|
||||
plat->low = sec->floorheight;
|
||||
|
||||
plat->high = sec->floorheight;
|
||||
plat->wait = 35*PLATWAIT;
|
||||
plat->status = down;
|
||||
S_StartSound((mobj_t *)&sec->soundorg,sfx_pstart);
|
||||
break;
|
||||
|
||||
case blazeDWUS:
|
||||
plat->speed = PLATSPEED * 8;
|
||||
plat->low = P_FindLowestFloorSurrounding(sec);
|
||||
|
||||
if (plat->low > sec->floorheight)
|
||||
plat->low = sec->floorheight;
|
||||
|
||||
plat->high = sec->floorheight;
|
||||
plat->wait = 35*PLATWAIT;
|
||||
plat->status = down;
|
||||
S_StartSound((mobj_t *)&sec->soundorg,sfx_pstart);
|
||||
break;
|
||||
|
||||
case perpetualRaise:
|
||||
plat->speed = PLATSPEED;
|
||||
plat->low = P_FindLowestFloorSurrounding(sec);
|
||||
|
||||
if (plat->low > sec->floorheight)
|
||||
plat->low = sec->floorheight;
|
||||
|
||||
plat->high = P_FindHighestFloorSurrounding(sec);
|
||||
|
||||
if (plat->high < sec->floorheight)
|
||||
plat->high = sec->floorheight;
|
||||
|
||||
plat->wait = 35*PLATWAIT;
|
||||
plat->status = P_Random()&1;
|
||||
|
||||
S_StartSound((mobj_t *)&sec->soundorg,sfx_pstart);
|
||||
break;
|
||||
}
|
||||
P_AddActivePlat(plat);
|
||||
}
|
||||
return rtn;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void P_ActivateInStasis(int tag)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0;i < MAXPLATS;i++)
|
||||
if (activeplats[i]
|
||||
&& (activeplats[i])->tag == tag
|
||||
&& (activeplats[i])->status == in_stasis)
|
||||
{
|
||||
(activeplats[i])->status = (activeplats[i])->oldstatus;
|
||||
(activeplats[i])->thinker.function.acp1
|
||||
= (actionf_p1) T_PlatRaise;
|
||||
}
|
||||
}
|
||||
|
||||
void EV_StopPlat(line_t* line)
|
||||
{
|
||||
int j;
|
||||
|
||||
for (j = 0;j < MAXPLATS;j++)
|
||||
if (activeplats[j]
|
||||
&& ((activeplats[j])->status != in_stasis)
|
||||
&& ((activeplats[j])->tag == line->tag))
|
||||
{
|
||||
(activeplats[j])->oldstatus = (activeplats[j])->status;
|
||||
(activeplats[j])->status = in_stasis;
|
||||
(activeplats[j])->thinker.function.acv = (actionf_v)NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void P_AddActivePlat(plat_t* plat)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0;i < MAXPLATS;i++)
|
||||
if (activeplats[i] == NULL)
|
||||
{
|
||||
activeplats[i] = plat;
|
||||
return;
|
||||
}
|
||||
I_Error ("P_AddActivePlat: no more plats!");
|
||||
}
|
||||
|
||||
void P_RemoveActivePlat(plat_t* plat)
|
||||
{
|
||||
int i;
|
||||
for (i = 0;i < MAXPLATS;i++)
|
||||
if (plat == activeplats[i])
|
||||
{
|
||||
(activeplats[i])->sector->specialdata = NULL;
|
||||
P_RemoveThinker(&(activeplats[i])->thinker);
|
||||
activeplats[i] = NULL;
|
||||
|
||||
return;
|
||||
}
|
||||
I_Error ("P_RemoveActivePlat: can't find plat!");
|
||||
}
|
||||
@@ -0,0 +1,879 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Weapon sprite animation, weapon objects.
|
||||
// Action functions for weapons.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_pspr.c,v 1.5 1997/02/03 22:45:12 b1 Exp $";
|
||||
|
||||
#include "doomdef.h"
|
||||
#include "d_event.h"
|
||||
|
||||
|
||||
#include "m_random.h"
|
||||
#include "p_local.h"
|
||||
#include "s_sound.h"
|
||||
|
||||
// State.
|
||||
#include "doomstat.h"
|
||||
|
||||
// Data.
|
||||
#include "sounds.h"
|
||||
|
||||
#include "p_pspr.h"
|
||||
|
||||
#define LOWERSPEED FRACUNIT*6
|
||||
#define RAISESPEED FRACUNIT*6
|
||||
|
||||
#define WEAPONBOTTOM 128*FRACUNIT
|
||||
#define WEAPONTOP 32*FRACUNIT
|
||||
|
||||
|
||||
// plasma cells for a bfg attack
|
||||
#define BFGCELLS 40
|
||||
|
||||
|
||||
//
|
||||
// P_SetPsprite
|
||||
//
|
||||
void
|
||||
P_SetPsprite
|
||||
( player_t* player,
|
||||
int position,
|
||||
statenum_t stnum )
|
||||
{
|
||||
pspdef_t* psp;
|
||||
state_t* state;
|
||||
|
||||
psp = &player->psprites[position];
|
||||
|
||||
do
|
||||
{
|
||||
if (!stnum)
|
||||
{
|
||||
// object removed itself
|
||||
psp->state = NULL;
|
||||
break;
|
||||
}
|
||||
|
||||
state = &states[stnum];
|
||||
psp->state = state;
|
||||
psp->tics = state->tics; // could be 0
|
||||
|
||||
if (state->misc1)
|
||||
{
|
||||
// coordinate set
|
||||
psp->sx = state->misc1 << FRACBITS;
|
||||
psp->sy = state->misc2 << FRACBITS;
|
||||
}
|
||||
|
||||
// Call action routine.
|
||||
// Modified handling.
|
||||
if (state->action.acp2)
|
||||
{
|
||||
state->action.acp2(player, psp);
|
||||
if (!psp->state)
|
||||
break;
|
||||
}
|
||||
|
||||
stnum = psp->state->nextstate;
|
||||
|
||||
} while (!psp->tics);
|
||||
// an initial state of 0 could cycle through
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_CalcSwing
|
||||
//
|
||||
fixed_t swingx;
|
||||
fixed_t swingy;
|
||||
|
||||
void P_CalcSwing (player_t* player)
|
||||
{
|
||||
fixed_t swing;
|
||||
int angle;
|
||||
|
||||
// OPTIMIZE: tablify this.
|
||||
// A LUT would allow for different modes,
|
||||
// and add flexibility.
|
||||
|
||||
swing = player->bob;
|
||||
|
||||
angle = (FINEANGLES/70*leveltime)&FINEMASK;
|
||||
swingx = FixedMul ( swing, finesine[angle]);
|
||||
|
||||
angle = (FINEANGLES/70*leveltime+FINEANGLES/2)&FINEMASK;
|
||||
swingy = -FixedMul ( swingx, finesine[angle]);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_BringUpWeapon
|
||||
// Starts bringing the pending weapon up
|
||||
// from the bottom of the screen.
|
||||
// Uses player
|
||||
//
|
||||
void P_BringUpWeapon (player_t* player)
|
||||
{
|
||||
statenum_t newstate;
|
||||
|
||||
if (player->pendingweapon == wp_nochange)
|
||||
player->pendingweapon = player->readyweapon;
|
||||
|
||||
if (player->pendingweapon == wp_chainsaw)
|
||||
S_StartSound (player->mo, sfx_sawup);
|
||||
|
||||
newstate = weaponinfo[player->pendingweapon].upstate;
|
||||
|
||||
player->pendingweapon = wp_nochange;
|
||||
player->psprites[ps_weapon].sy = WEAPONBOTTOM;
|
||||
|
||||
P_SetPsprite (player, ps_weapon, newstate);
|
||||
}
|
||||
|
||||
//
|
||||
// P_CheckAmmo
|
||||
// Returns true if there is enough ammo to shoot.
|
||||
// If not, selects the next weapon to use.
|
||||
//
|
||||
boolean P_CheckAmmo (player_t* player)
|
||||
{
|
||||
ammotype_t ammo;
|
||||
int count;
|
||||
|
||||
ammo = weaponinfo[player->readyweapon].ammo;
|
||||
|
||||
// Minimal amount for one shot varies.
|
||||
if (player->readyweapon == wp_bfg)
|
||||
count = BFGCELLS;
|
||||
else if (player->readyweapon == wp_supershotgun)
|
||||
count = 2; // Double barrel.
|
||||
else
|
||||
count = 1; // Regular.
|
||||
|
||||
// Some do not need ammunition anyway.
|
||||
// Return if current ammunition sufficient.
|
||||
if (ammo == am_noammo || player->ammo[ammo] >= count)
|
||||
return true;
|
||||
|
||||
// Out of ammo, pick a weapon to change to.
|
||||
// Preferences are set here.
|
||||
do
|
||||
{
|
||||
if (player->weaponowned[wp_plasma]
|
||||
&& player->ammo[am_cell]
|
||||
&& (gamemode != shareware) )
|
||||
{
|
||||
player->pendingweapon = wp_plasma;
|
||||
}
|
||||
else if (player->weaponowned[wp_supershotgun]
|
||||
&& player->ammo[am_shell]>2
|
||||
&& (gamemode == commercial) )
|
||||
{
|
||||
player->pendingweapon = wp_supershotgun;
|
||||
}
|
||||
else if (player->weaponowned[wp_chaingun]
|
||||
&& player->ammo[am_clip])
|
||||
{
|
||||
player->pendingweapon = wp_chaingun;
|
||||
}
|
||||
else if (player->weaponowned[wp_shotgun]
|
||||
&& player->ammo[am_shell])
|
||||
{
|
||||
player->pendingweapon = wp_shotgun;
|
||||
}
|
||||
else if (player->ammo[am_clip])
|
||||
{
|
||||
player->pendingweapon = wp_pistol;
|
||||
}
|
||||
else if (player->weaponowned[wp_chainsaw])
|
||||
{
|
||||
player->pendingweapon = wp_chainsaw;
|
||||
}
|
||||
else if (player->weaponowned[wp_missile]
|
||||
&& player->ammo[am_misl])
|
||||
{
|
||||
player->pendingweapon = wp_missile;
|
||||
}
|
||||
else if (player->weaponowned[wp_bfg]
|
||||
&& player->ammo[am_cell]>40
|
||||
&& (gamemode != shareware) )
|
||||
{
|
||||
player->pendingweapon = wp_bfg;
|
||||
}
|
||||
else
|
||||
{
|
||||
// If everything fails.
|
||||
player->pendingweapon = wp_fist;
|
||||
}
|
||||
|
||||
} while (player->pendingweapon == wp_nochange);
|
||||
|
||||
// Now set appropriate weapon overlay.
|
||||
P_SetPsprite (player,
|
||||
ps_weapon,
|
||||
weaponinfo[player->readyweapon].downstate);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_FireWeapon.
|
||||
//
|
||||
void P_FireWeapon (player_t* player)
|
||||
{
|
||||
statenum_t newstate;
|
||||
|
||||
if (!P_CheckAmmo (player))
|
||||
return;
|
||||
|
||||
P_SetMobjState (player->mo, S_PLAY_ATK1);
|
||||
newstate = weaponinfo[player->readyweapon].atkstate;
|
||||
P_SetPsprite (player, ps_weapon, newstate);
|
||||
P_NoiseAlert (player->mo, player->mo);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_DropWeapon
|
||||
// Player died, so put the weapon away.
|
||||
//
|
||||
void P_DropWeapon (player_t* player)
|
||||
{
|
||||
P_SetPsprite (player,
|
||||
ps_weapon,
|
||||
weaponinfo[player->readyweapon].downstate);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// A_WeaponReady
|
||||
// The player can fire the weapon
|
||||
// or change to another weapon at this time.
|
||||
// Follows after getting weapon up,
|
||||
// or after previous attack/fire sequence.
|
||||
//
|
||||
void
|
||||
A_WeaponReady
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
statenum_t newstate;
|
||||
int angle;
|
||||
|
||||
// get out of attack state
|
||||
if (player->mo->state == &states[S_PLAY_ATK1]
|
||||
|| player->mo->state == &states[S_PLAY_ATK2] )
|
||||
{
|
||||
P_SetMobjState (player->mo, S_PLAY);
|
||||
}
|
||||
|
||||
if (player->readyweapon == wp_chainsaw
|
||||
&& psp->state == &states[S_SAW])
|
||||
{
|
||||
S_StartSound (player->mo, sfx_sawidl);
|
||||
}
|
||||
|
||||
// check for change
|
||||
// if player is dead, put the weapon away
|
||||
if (player->pendingweapon != wp_nochange || !player->health)
|
||||
{
|
||||
// change weapon
|
||||
// (pending weapon should allready be validated)
|
||||
newstate = weaponinfo[player->readyweapon].downstate;
|
||||
P_SetPsprite (player, ps_weapon, newstate);
|
||||
return;
|
||||
}
|
||||
|
||||
// check for fire
|
||||
// the missile launcher and bfg do not auto fire
|
||||
if (player->cmd.buttons & BT_ATTACK)
|
||||
{
|
||||
if ( !player->attackdown
|
||||
|| (player->readyweapon != wp_missile
|
||||
&& player->readyweapon != wp_bfg) )
|
||||
{
|
||||
player->attackdown = true;
|
||||
P_FireWeapon (player);
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
player->attackdown = false;
|
||||
|
||||
// bob the weapon based on movement speed
|
||||
angle = (128*leveltime)&FINEMASK;
|
||||
psp->sx = FRACUNIT + FixedMul (player->bob, finecosine[angle]);
|
||||
angle &= FINEANGLES/2-1;
|
||||
psp->sy = WEAPONTOP + FixedMul (player->bob, finesine[angle]);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// A_ReFire
|
||||
// The player can re-fire the weapon
|
||||
// without lowering it entirely.
|
||||
//
|
||||
void A_ReFire
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
|
||||
// check for fire
|
||||
// (if a weaponchange is pending, let it go through instead)
|
||||
if ( (player->cmd.buttons & BT_ATTACK)
|
||||
&& player->pendingweapon == wp_nochange
|
||||
&& player->health)
|
||||
{
|
||||
player->refire++;
|
||||
P_FireWeapon (player);
|
||||
}
|
||||
else
|
||||
{
|
||||
player->refire = 0;
|
||||
P_CheckAmmo (player);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
A_CheckReload
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
P_CheckAmmo (player);
|
||||
#if 0
|
||||
if (player->ammo[am_shell]<2)
|
||||
P_SetPsprite (player, ps_weapon, S_DSNR1);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// A_Lower
|
||||
// Lowers current weapon,
|
||||
// and changes weapon at bottom.
|
||||
//
|
||||
void
|
||||
A_Lower
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
psp->sy += LOWERSPEED;
|
||||
|
||||
// Is already down.
|
||||
if (psp->sy < WEAPONBOTTOM )
|
||||
return;
|
||||
|
||||
// Player is dead.
|
||||
if (player->playerstate == PST_DEAD)
|
||||
{
|
||||
psp->sy = WEAPONBOTTOM;
|
||||
|
||||
// don't bring weapon back up
|
||||
return;
|
||||
}
|
||||
|
||||
// The old weapon has been lowered off the screen,
|
||||
// so change the weapon and start raising it
|
||||
if (!player->health)
|
||||
{
|
||||
// Player is dead, so keep the weapon off screen.
|
||||
P_SetPsprite (player, ps_weapon, S_NULL);
|
||||
return;
|
||||
}
|
||||
|
||||
player->readyweapon = player->pendingweapon;
|
||||
|
||||
P_BringUpWeapon (player);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// A_Raise
|
||||
//
|
||||
void
|
||||
A_Raise
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
statenum_t newstate;
|
||||
|
||||
psp->sy -= RAISESPEED;
|
||||
|
||||
if (psp->sy > WEAPONTOP )
|
||||
return;
|
||||
|
||||
psp->sy = WEAPONTOP;
|
||||
|
||||
// The weapon has been raised all the way,
|
||||
// so change to the ready state.
|
||||
newstate = weaponinfo[player->readyweapon].readystate;
|
||||
|
||||
P_SetPsprite (player, ps_weapon, newstate);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// A_GunFlash
|
||||
//
|
||||
void
|
||||
A_GunFlash
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
P_SetMobjState (player->mo, S_PLAY_ATK2);
|
||||
P_SetPsprite (player,ps_flash,weaponinfo[player->readyweapon].flashstate);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// WEAPON ATTACKS
|
||||
//
|
||||
|
||||
|
||||
//
|
||||
// A_Punch
|
||||
//
|
||||
void
|
||||
A_Punch
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
angle_t angle;
|
||||
int damage;
|
||||
int slope;
|
||||
|
||||
damage = (P_Random ()%10+1)<<1;
|
||||
|
||||
if (player->powers[pw_strength])
|
||||
damage *= 10;
|
||||
|
||||
angle = player->mo->angle;
|
||||
angle += (P_Random()-P_Random())<<18;
|
||||
slope = P_AimLineAttack (player->mo, angle, MELEERANGE);
|
||||
P_LineAttack (player->mo, angle, MELEERANGE, slope, damage);
|
||||
|
||||
// turn to face target
|
||||
if (linetarget)
|
||||
{
|
||||
S_StartSound (player->mo, sfx_punch);
|
||||
player->mo->angle = R_PointToAngle2 (player->mo->x,
|
||||
player->mo->y,
|
||||
linetarget->x,
|
||||
linetarget->y);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// A_Saw
|
||||
//
|
||||
void
|
||||
A_Saw
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
angle_t angle;
|
||||
int damage;
|
||||
int slope;
|
||||
|
||||
damage = 2*(P_Random ()%10+1);
|
||||
angle = player->mo->angle;
|
||||
angle += (P_Random()-P_Random())<<18;
|
||||
|
||||
// use meleerange + 1 se the puff doesn't skip the flash
|
||||
slope = P_AimLineAttack (player->mo, angle, MELEERANGE+1);
|
||||
P_LineAttack (player->mo, angle, MELEERANGE+1, slope, damage);
|
||||
|
||||
if (!linetarget)
|
||||
{
|
||||
S_StartSound (player->mo, sfx_sawful);
|
||||
return;
|
||||
}
|
||||
S_StartSound (player->mo, sfx_sawhit);
|
||||
|
||||
// turn to face target
|
||||
angle = R_PointToAngle2 (player->mo->x, player->mo->y,
|
||||
linetarget->x, linetarget->y);
|
||||
if (angle - player->mo->angle > ANG180)
|
||||
{
|
||||
if (angle - player->mo->angle < -ANG90/20)
|
||||
player->mo->angle = angle + ANG90/21;
|
||||
else
|
||||
player->mo->angle -= ANG90/20;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (angle - player->mo->angle > ANG90/20)
|
||||
player->mo->angle = angle - ANG90/21;
|
||||
else
|
||||
player->mo->angle += ANG90/20;
|
||||
}
|
||||
player->mo->flags |= MF_JUSTATTACKED;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// A_FireMissile
|
||||
//
|
||||
void
|
||||
A_FireMissile
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
player->ammo[weaponinfo[player->readyweapon].ammo]--;
|
||||
P_SpawnPlayerMissile (player->mo, MT_ROCKET);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// A_FireBFG
|
||||
//
|
||||
void
|
||||
A_FireBFG
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
player->ammo[weaponinfo[player->readyweapon].ammo] -= BFGCELLS;
|
||||
P_SpawnPlayerMissile (player->mo, MT_BFG);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// A_FirePlasma
|
||||
//
|
||||
void
|
||||
A_FirePlasma
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
player->ammo[weaponinfo[player->readyweapon].ammo]--;
|
||||
|
||||
P_SetPsprite (player,
|
||||
ps_flash,
|
||||
weaponinfo[player->readyweapon].flashstate+(P_Random ()&1) );
|
||||
|
||||
P_SpawnPlayerMissile (player->mo, MT_PLASMA);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_BulletSlope
|
||||
// Sets a slope so a near miss is at aproximately
|
||||
// the height of the intended target
|
||||
//
|
||||
fixed_t bulletslope;
|
||||
|
||||
|
||||
void P_BulletSlope (mobj_t* mo)
|
||||
{
|
||||
angle_t an;
|
||||
|
||||
// see which target is to be aimed at
|
||||
an = mo->angle;
|
||||
bulletslope = P_AimLineAttack (mo, an, 16*64*FRACUNIT);
|
||||
|
||||
if (!linetarget)
|
||||
{
|
||||
an += 1<<26;
|
||||
bulletslope = P_AimLineAttack (mo, an, 16*64*FRACUNIT);
|
||||
if (!linetarget)
|
||||
{
|
||||
an -= 2<<26;
|
||||
bulletslope = P_AimLineAttack (mo, an, 16*64*FRACUNIT);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_GunShot
|
||||
//
|
||||
void
|
||||
P_GunShot
|
||||
( mobj_t* mo,
|
||||
boolean accurate )
|
||||
{
|
||||
angle_t angle;
|
||||
int damage;
|
||||
|
||||
damage = 5*(P_Random ()%3+1);
|
||||
angle = mo->angle;
|
||||
|
||||
if (!accurate)
|
||||
angle += (P_Random()-P_Random())<<18;
|
||||
|
||||
P_LineAttack (mo, angle, MISSILERANGE, bulletslope, damage);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// A_FirePistol
|
||||
//
|
||||
void
|
||||
A_FirePistol
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
S_StartSound (player->mo, sfx_pistol);
|
||||
|
||||
P_SetMobjState (player->mo, S_PLAY_ATK2);
|
||||
player->ammo[weaponinfo[player->readyweapon].ammo]--;
|
||||
|
||||
P_SetPsprite (player,
|
||||
ps_flash,
|
||||
weaponinfo[player->readyweapon].flashstate);
|
||||
|
||||
P_BulletSlope (player->mo);
|
||||
P_GunShot (player->mo, !player->refire);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// A_FireShotgun
|
||||
//
|
||||
void
|
||||
A_FireShotgun
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
int i;
|
||||
|
||||
S_StartSound (player->mo, sfx_shotgn);
|
||||
P_SetMobjState (player->mo, S_PLAY_ATK2);
|
||||
|
||||
player->ammo[weaponinfo[player->readyweapon].ammo]--;
|
||||
|
||||
P_SetPsprite (player,
|
||||
ps_flash,
|
||||
weaponinfo[player->readyweapon].flashstate);
|
||||
|
||||
P_BulletSlope (player->mo);
|
||||
|
||||
for (i=0 ; i<7 ; i++)
|
||||
P_GunShot (player->mo, false);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// A_FireShotgun2
|
||||
//
|
||||
void
|
||||
A_FireShotgun2
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
int i;
|
||||
angle_t angle;
|
||||
int damage;
|
||||
|
||||
|
||||
S_StartSound (player->mo, sfx_dshtgn);
|
||||
P_SetMobjState (player->mo, S_PLAY_ATK2);
|
||||
|
||||
player->ammo[weaponinfo[player->readyweapon].ammo]-=2;
|
||||
|
||||
P_SetPsprite (player,
|
||||
ps_flash,
|
||||
weaponinfo[player->readyweapon].flashstate);
|
||||
|
||||
P_BulletSlope (player->mo);
|
||||
|
||||
for (i=0 ; i<20 ; i++)
|
||||
{
|
||||
damage = 5*(P_Random ()%3+1);
|
||||
angle = player->mo->angle;
|
||||
angle += (P_Random()-P_Random())<<19;
|
||||
P_LineAttack (player->mo,
|
||||
angle,
|
||||
MISSILERANGE,
|
||||
bulletslope + ((P_Random()-P_Random())<<5), damage);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// A_FireCGun
|
||||
//
|
||||
void
|
||||
A_FireCGun
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
S_StartSound (player->mo, sfx_pistol);
|
||||
|
||||
if (!player->ammo[weaponinfo[player->readyweapon].ammo])
|
||||
return;
|
||||
|
||||
P_SetMobjState (player->mo, S_PLAY_ATK2);
|
||||
player->ammo[weaponinfo[player->readyweapon].ammo]--;
|
||||
|
||||
P_SetPsprite (player,
|
||||
ps_flash,
|
||||
weaponinfo[player->readyweapon].flashstate
|
||||
+ psp->state
|
||||
- &states[S_CHAIN1] );
|
||||
|
||||
P_BulletSlope (player->mo);
|
||||
|
||||
P_GunShot (player->mo, !player->refire);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// ?
|
||||
//
|
||||
void A_Light0 (player_t *player, pspdef_t *psp)
|
||||
{
|
||||
player->extralight = 0;
|
||||
}
|
||||
|
||||
void A_Light1 (player_t *player, pspdef_t *psp)
|
||||
{
|
||||
player->extralight = 1;
|
||||
}
|
||||
|
||||
void A_Light2 (player_t *player, pspdef_t *psp)
|
||||
{
|
||||
player->extralight = 2;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// A_BFGSpray
|
||||
// Spawn a BFG explosion on every monster in view
|
||||
//
|
||||
void A_BFGSpray (mobj_t* mo)
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
int damage;
|
||||
angle_t an;
|
||||
|
||||
// offset angles from its attack angle
|
||||
for (i=0 ; i<40 ; i++)
|
||||
{
|
||||
an = mo->angle - ANG90/2 + ANG90/40*i;
|
||||
|
||||
// mo->target is the originator (player)
|
||||
// of the missile
|
||||
P_AimLineAttack (mo->target, an, 16*64*FRACUNIT);
|
||||
|
||||
if (!linetarget)
|
||||
continue;
|
||||
|
||||
P_SpawnMobj (linetarget->x,
|
||||
linetarget->y,
|
||||
linetarget->z + (linetarget->height>>2),
|
||||
MT_EXTRABFG);
|
||||
|
||||
damage = 0;
|
||||
for (j=0;j<15;j++)
|
||||
damage += (P_Random()&7) + 1;
|
||||
|
||||
P_DamageMobj (linetarget, mo->target,mo->target, damage);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// A_BFGsound
|
||||
//
|
||||
void
|
||||
A_BFGsound
|
||||
( player_t* player,
|
||||
pspdef_t* psp )
|
||||
{
|
||||
S_StartSound (player->mo, sfx_bfg);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_SetupPsprites
|
||||
// Called at start of level for each player.
|
||||
//
|
||||
void P_SetupPsprites (player_t* player)
|
||||
{
|
||||
int i;
|
||||
|
||||
// remove all psprites
|
||||
for (i=0 ; i<NUMPSPRITES ; i++)
|
||||
player->psprites[i].state = NULL;
|
||||
|
||||
// spawn the gun
|
||||
player->pendingweapon = player->readyweapon;
|
||||
P_BringUpWeapon (player);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_MovePsprites
|
||||
// Called every tic by player thinking routine.
|
||||
//
|
||||
void P_MovePsprites (player_t* player)
|
||||
{
|
||||
int i;
|
||||
pspdef_t* psp;
|
||||
state_t* state;
|
||||
|
||||
psp = &player->psprites[0];
|
||||
for (i=0 ; i<NUMPSPRITES ; i++, psp++)
|
||||
{
|
||||
// a null state means not active
|
||||
if ( (state = psp->state) )
|
||||
{
|
||||
// drop tic count and possibly change state
|
||||
|
||||
// a -1 tic count never changes
|
||||
if (psp->tics != -1)
|
||||
{
|
||||
psp->tics--;
|
||||
if (!psp->tics)
|
||||
P_SetPsprite (player, i, psp->state->nextstate);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
player->psprites[ps_flash].sx = player->psprites[ps_weapon].sx;
|
||||
player->psprites[ps_flash].sy = player->psprites[ps_weapon].sy;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Sprite animation.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __P_PSPR__
|
||||
#define __P_PSPR__
|
||||
|
||||
// Basic data types.
|
||||
// Needs fixed point, and BAM angles.
|
||||
#include "m_fixed.h"
|
||||
#include "tables.h"
|
||||
|
||||
|
||||
//
|
||||
// Needs to include the precompiled
|
||||
// sprite animation tables.
|
||||
// Header generated by multigen utility.
|
||||
// This includes all the data for thing animation,
|
||||
// i.e. the Thing Atrributes table
|
||||
// and the Frame Sequence table.
|
||||
#include "info.h"
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
//
|
||||
// Frame flags:
|
||||
// handles maximum brightness (torches, muzzle flare, light sources)
|
||||
//
|
||||
#define FF_FULLBRIGHT 0x8000 // flag in thing->frame
|
||||
#define FF_FRAMEMASK 0x7fff
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Overlay psprites are scaled shapes
|
||||
// drawn directly on the view screen,
|
||||
// coordinates are given for a 320*200 view screen.
|
||||
//
|
||||
typedef enum
|
||||
{
|
||||
ps_weapon,
|
||||
ps_flash,
|
||||
NUMPSPRITES
|
||||
|
||||
} psprnum_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
state_t* state; // a NULL state means not active
|
||||
int tics;
|
||||
fixed_t sx;
|
||||
fixed_t sy;
|
||||
|
||||
} pspdef_t;
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,588 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Archiving: SaveGame I/O.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_tick.c,v 1.4 1997/02/03 16:47:55 b1 Exp $";
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#include "i_system.h"
|
||||
#include "z_zone.h"
|
||||
#include "p_local.h"
|
||||
|
||||
// State.
|
||||
#include "doomstat.h"
|
||||
#include "r_state.h"
|
||||
|
||||
byte* save_p;
|
||||
|
||||
|
||||
// Pads save_p to a 4-byte boundary
|
||||
// so that the load/save works on SGI&Gecko.
|
||||
#define PADSAVEP() save_p += (4 - ((intptr_t) save_p & 3)) & 3
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_ArchivePlayers
|
||||
//
|
||||
void P_ArchivePlayers (void)
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
player_t* dest;
|
||||
|
||||
for (i=0 ; i<MAXPLAYERS ; i++)
|
||||
{
|
||||
if (!playeringame[i])
|
||||
continue;
|
||||
|
||||
PADSAVEP();
|
||||
|
||||
dest = (player_t *)save_p;
|
||||
memcpy (dest,&players[i],sizeof(player_t));
|
||||
save_p += sizeof(player_t);
|
||||
for (j=0 ; j<NUMPSPRITES ; j++)
|
||||
{
|
||||
if (dest->psprites[j].state)
|
||||
{
|
||||
dest->psprites[j].state
|
||||
= (state_t *)(dest->psprites[j].state-states);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_UnArchivePlayers
|
||||
//
|
||||
void P_UnArchivePlayers (void)
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
|
||||
for (i=0 ; i<MAXPLAYERS ; i++)
|
||||
{
|
||||
if (!playeringame[i])
|
||||
continue;
|
||||
|
||||
PADSAVEP();
|
||||
|
||||
memcpy (&players[i],save_p, sizeof(player_t));
|
||||
save_p += sizeof(player_t);
|
||||
|
||||
// will be set when unarc thinker
|
||||
players[i].mo = NULL;
|
||||
players[i].message = NULL;
|
||||
players[i].attacker = NULL;
|
||||
|
||||
for (j=0 ; j<NUMPSPRITES ; j++)
|
||||
{
|
||||
if (players[i]. psprites[j].state)
|
||||
{
|
||||
players[i]. psprites[j].state
|
||||
= &states[ (intptr_t)players[i].psprites[j].state ];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_ArchiveWorld
|
||||
//
|
||||
void P_ArchiveWorld (void)
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
sector_t* sec;
|
||||
line_t* li;
|
||||
side_t* si;
|
||||
short* put;
|
||||
|
||||
put = (short *)save_p;
|
||||
|
||||
// do sectors
|
||||
for (i=0, sec = sectors ; i<numsectors ; i++,sec++)
|
||||
{
|
||||
*put++ = sec->floorheight >> FRACBITS;
|
||||
*put++ = sec->ceilingheight >> FRACBITS;
|
||||
*put++ = sec->floorpic;
|
||||
*put++ = sec->ceilingpic;
|
||||
*put++ = sec->lightlevel;
|
||||
*put++ = sec->special; // needed?
|
||||
*put++ = sec->tag; // needed?
|
||||
}
|
||||
|
||||
|
||||
// do lines
|
||||
for (i=0, li = lines ; i<numlines ; i++,li++)
|
||||
{
|
||||
*put++ = li->flags;
|
||||
*put++ = li->special;
|
||||
*put++ = li->tag;
|
||||
for (j=0 ; j<2 ; j++)
|
||||
{
|
||||
if (li->sidenum[j] == -1)
|
||||
continue;
|
||||
|
||||
si = &sides[li->sidenum[j]];
|
||||
|
||||
*put++ = si->textureoffset >> FRACBITS;
|
||||
*put++ = si->rowoffset >> FRACBITS;
|
||||
*put++ = si->toptexture;
|
||||
*put++ = si->bottomtexture;
|
||||
*put++ = si->midtexture;
|
||||
}
|
||||
}
|
||||
|
||||
save_p = (byte *)put;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_UnArchiveWorld
|
||||
//
|
||||
void P_UnArchiveWorld (void)
|
||||
{
|
||||
int i;
|
||||
int j;
|
||||
sector_t* sec;
|
||||
line_t* li;
|
||||
side_t* si;
|
||||
short* get;
|
||||
|
||||
get = (short *)save_p;
|
||||
|
||||
// do sectors
|
||||
for (i=0, sec = sectors ; i<numsectors ; i++,sec++)
|
||||
{
|
||||
sec->floorheight = *get++ << FRACBITS;
|
||||
sec->ceilingheight = *get++ << FRACBITS;
|
||||
sec->floorpic = *get++;
|
||||
sec->ceilingpic = *get++;
|
||||
sec->lightlevel = *get++;
|
||||
sec->special = *get++; // needed?
|
||||
sec->tag = *get++; // needed?
|
||||
sec->specialdata = 0;
|
||||
sec->soundtarget = 0;
|
||||
}
|
||||
|
||||
// do lines
|
||||
for (i=0, li = lines ; i<numlines ; i++,li++)
|
||||
{
|
||||
li->flags = *get++;
|
||||
li->special = *get++;
|
||||
li->tag = *get++;
|
||||
for (j=0 ; j<2 ; j++)
|
||||
{
|
||||
if (li->sidenum[j] == -1)
|
||||
continue;
|
||||
si = &sides[li->sidenum[j]];
|
||||
si->textureoffset = *get++ << FRACBITS;
|
||||
si->rowoffset = *get++ << FRACBITS;
|
||||
si->toptexture = *get++;
|
||||
si->bottomtexture = *get++;
|
||||
si->midtexture = *get++;
|
||||
}
|
||||
}
|
||||
save_p = (byte *)get;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Thinkers
|
||||
//
|
||||
typedef enum
|
||||
{
|
||||
tc_end,
|
||||
tc_mobj
|
||||
|
||||
} thinkerclass_t;
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_ArchiveThinkers
|
||||
//
|
||||
void P_ArchiveThinkers (void)
|
||||
{
|
||||
thinker_t* th;
|
||||
mobj_t* mobj;
|
||||
|
||||
// save off the current thinkers
|
||||
for (th = thinkercap.next ; th != &thinkercap ; th=th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_MobjThinker)
|
||||
{
|
||||
*save_p++ = tc_mobj;
|
||||
PADSAVEP();
|
||||
mobj = (mobj_t *)save_p;
|
||||
memcpy (mobj, th, sizeof(*mobj));
|
||||
save_p += sizeof(*mobj);
|
||||
mobj->state = (state_t *)(mobj->state - states);
|
||||
|
||||
if (mobj->player)
|
||||
mobj->player = (player_t *)((mobj->player-players) + 1);
|
||||
continue;
|
||||
}
|
||||
|
||||
// I_Error ("P_ArchiveThinkers: Unknown thinker function");
|
||||
}
|
||||
|
||||
// add a terminating marker
|
||||
*save_p++ = tc_end;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_UnArchiveThinkers
|
||||
//
|
||||
void P_UnArchiveThinkers (void)
|
||||
{
|
||||
byte tclass;
|
||||
thinker_t* currentthinker;
|
||||
thinker_t* next;
|
||||
mobj_t* mobj;
|
||||
|
||||
// remove all the current thinkers
|
||||
currentthinker = thinkercap.next;
|
||||
while (currentthinker != &thinkercap)
|
||||
{
|
||||
next = currentthinker->next;
|
||||
|
||||
if (currentthinker->function.acp1 == (actionf_p1)P_MobjThinker)
|
||||
P_RemoveMobj ((mobj_t *)currentthinker);
|
||||
else
|
||||
Z_Free (currentthinker);
|
||||
|
||||
currentthinker = next;
|
||||
}
|
||||
P_InitThinkers ();
|
||||
|
||||
// read in saved thinkers
|
||||
while (1)
|
||||
{
|
||||
tclass = *save_p++;
|
||||
switch (tclass)
|
||||
{
|
||||
case tc_end:
|
||||
return; // end of list
|
||||
|
||||
case tc_mobj:
|
||||
PADSAVEP();
|
||||
mobj = Z_Malloc (sizeof(*mobj), PU_LEVEL, NULL);
|
||||
memcpy (mobj, save_p, sizeof(*mobj));
|
||||
save_p += sizeof(*mobj);
|
||||
mobj->state = &states[(intptr_t)mobj->state];
|
||||
mobj->target = NULL;
|
||||
if (mobj->player)
|
||||
{
|
||||
mobj->player = &players[(intptr_t)mobj->player-1];
|
||||
mobj->player->mo = mobj;
|
||||
}
|
||||
P_SetThingPosition (mobj);
|
||||
mobj->info = &mobjinfo[mobj->type];
|
||||
mobj->floorz = mobj->subsector->sector->floorheight;
|
||||
mobj->ceilingz = mobj->subsector->sector->ceilingheight;
|
||||
mobj->thinker.function.acp1 = (actionf_p1)P_MobjThinker;
|
||||
P_AddThinker (&mobj->thinker);
|
||||
break;
|
||||
|
||||
default:
|
||||
I_Error ("Unknown tclass %i in savegame",tclass);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_ArchiveSpecials
|
||||
//
|
||||
enum
|
||||
{
|
||||
tc_ceiling,
|
||||
tc_door,
|
||||
tc_floor,
|
||||
tc_plat,
|
||||
tc_flash,
|
||||
tc_strobe,
|
||||
tc_glow,
|
||||
tc_endspecials
|
||||
|
||||
} specials_e;
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Things to handle:
|
||||
//
|
||||
// T_MoveCeiling, (ceiling_t: sector_t * swizzle), - active list
|
||||
// T_VerticalDoor, (vldoor_t: sector_t * swizzle),
|
||||
// T_MoveFloor, (floormove_t: sector_t * swizzle),
|
||||
// T_LightFlash, (lightflash_t: sector_t * swizzle),
|
||||
// T_StrobeFlash, (strobe_t: sector_t *),
|
||||
// T_Glow, (glow_t: sector_t *),
|
||||
// T_PlatRaise, (plat_t: sector_t *), - active list
|
||||
//
|
||||
void P_ArchiveSpecials (void)
|
||||
{
|
||||
thinker_t* th;
|
||||
ceiling_t* ceiling;
|
||||
vldoor_t* door;
|
||||
floormove_t* floor;
|
||||
plat_t* plat;
|
||||
lightflash_t* flash;
|
||||
strobe_t* strobe;
|
||||
glow_t* glow;
|
||||
int i;
|
||||
|
||||
// save off the current thinkers
|
||||
for (th = thinkercap.next ; th != &thinkercap ; th=th->next)
|
||||
{
|
||||
if (th->function.acv == (actionf_v)NULL)
|
||||
{
|
||||
for (i = 0; i < MAXCEILINGS;i++)
|
||||
if (activeceilings[i] == (ceiling_t *)th)
|
||||
break;
|
||||
|
||||
if (i<MAXCEILINGS)
|
||||
{
|
||||
*save_p++ = tc_ceiling;
|
||||
PADSAVEP();
|
||||
ceiling = (ceiling_t *)save_p;
|
||||
memcpy (ceiling, th, sizeof(*ceiling));
|
||||
save_p += sizeof(*ceiling);
|
||||
ceiling->sector = (sector_t *)(ceiling->sector - sectors);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (th->function.acp1 == (actionf_p1)T_MoveCeiling)
|
||||
{
|
||||
*save_p++ = tc_ceiling;
|
||||
PADSAVEP();
|
||||
ceiling = (ceiling_t *)save_p;
|
||||
memcpy (ceiling, th, sizeof(*ceiling));
|
||||
save_p += sizeof(*ceiling);
|
||||
ceiling->sector = (sector_t *)(ceiling->sector - sectors);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (th->function.acp1 == (actionf_p1)T_VerticalDoor)
|
||||
{
|
||||
*save_p++ = tc_door;
|
||||
PADSAVEP();
|
||||
door = (vldoor_t *)save_p;
|
||||
memcpy (door, th, sizeof(*door));
|
||||
save_p += sizeof(*door);
|
||||
door->sector = (sector_t *)(door->sector - sectors);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (th->function.acp1 == (actionf_p1)T_MoveFloor)
|
||||
{
|
||||
*save_p++ = tc_floor;
|
||||
PADSAVEP();
|
||||
floor = (floormove_t *)save_p;
|
||||
memcpy (floor, th, sizeof(*floor));
|
||||
save_p += sizeof(*floor);
|
||||
floor->sector = (sector_t *)(floor->sector - sectors);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (th->function.acp1 == (actionf_p1)T_PlatRaise)
|
||||
{
|
||||
*save_p++ = tc_plat;
|
||||
PADSAVEP();
|
||||
plat = (plat_t *)save_p;
|
||||
memcpy (plat, th, sizeof(*plat));
|
||||
save_p += sizeof(*plat);
|
||||
plat->sector = (sector_t *)(plat->sector - sectors);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (th->function.acp1 == (actionf_p1)T_LightFlash)
|
||||
{
|
||||
*save_p++ = tc_flash;
|
||||
PADSAVEP();
|
||||
flash = (lightflash_t *)save_p;
|
||||
memcpy (flash, th, sizeof(*flash));
|
||||
save_p += sizeof(*flash);
|
||||
flash->sector = (sector_t *)(flash->sector - sectors);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (th->function.acp1 == (actionf_p1)T_StrobeFlash)
|
||||
{
|
||||
*save_p++ = tc_strobe;
|
||||
PADSAVEP();
|
||||
strobe = (strobe_t *)save_p;
|
||||
memcpy (strobe, th, sizeof(*strobe));
|
||||
save_p += sizeof(*strobe);
|
||||
strobe->sector = (sector_t *)(strobe->sector - sectors);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (th->function.acp1 == (actionf_p1)T_Glow)
|
||||
{
|
||||
*save_p++ = tc_glow;
|
||||
PADSAVEP();
|
||||
glow = (glow_t *)save_p;
|
||||
memcpy (glow, th, sizeof(*glow));
|
||||
save_p += sizeof(*glow);
|
||||
glow->sector = (sector_t *)(glow->sector - sectors);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// add a terminating marker
|
||||
*save_p++ = tc_endspecials;
|
||||
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_UnArchiveSpecials
|
||||
//
|
||||
void P_UnArchiveSpecials (void)
|
||||
{
|
||||
byte tclass;
|
||||
ceiling_t* ceiling;
|
||||
vldoor_t* door;
|
||||
floormove_t* floor;
|
||||
plat_t* plat;
|
||||
lightflash_t* flash;
|
||||
strobe_t* strobe;
|
||||
glow_t* glow;
|
||||
|
||||
|
||||
// read in saved thinkers
|
||||
while (1)
|
||||
{
|
||||
tclass = *save_p++;
|
||||
switch (tclass)
|
||||
{
|
||||
case tc_endspecials:
|
||||
return; // end of list
|
||||
|
||||
case tc_ceiling:
|
||||
PADSAVEP();
|
||||
ceiling = Z_Malloc (sizeof(*ceiling), PU_LEVEL, NULL);
|
||||
memcpy (ceiling, save_p, sizeof(*ceiling));
|
||||
save_p += sizeof(*ceiling);
|
||||
ceiling->sector = §ors[(intptr_t)ceiling->sector];
|
||||
ceiling->sector->specialdata = ceiling;
|
||||
|
||||
if (ceiling->thinker.function.acp1)
|
||||
ceiling->thinker.function.acp1 = (actionf_p1)T_MoveCeiling;
|
||||
|
||||
P_AddThinker (&ceiling->thinker);
|
||||
P_AddActiveCeiling(ceiling);
|
||||
break;
|
||||
|
||||
case tc_door:
|
||||
PADSAVEP();
|
||||
door = Z_Malloc (sizeof(*door), PU_LEVEL, NULL);
|
||||
memcpy (door, save_p, sizeof(*door));
|
||||
save_p += sizeof(*door);
|
||||
door->sector = §ors[(intptr_t)door->sector];
|
||||
door->sector->specialdata = door;
|
||||
door->thinker.function.acp1 = (actionf_p1)T_VerticalDoor;
|
||||
P_AddThinker (&door->thinker);
|
||||
break;
|
||||
|
||||
case tc_floor:
|
||||
PADSAVEP();
|
||||
floor = Z_Malloc (sizeof(*floor), PU_LEVEL, NULL);
|
||||
memcpy (floor, save_p, sizeof(*floor));
|
||||
save_p += sizeof(*floor);
|
||||
floor->sector = §ors[(intptr_t)floor->sector];
|
||||
floor->sector->specialdata = floor;
|
||||
floor->thinker.function.acp1 = (actionf_p1)T_MoveFloor;
|
||||
P_AddThinker (&floor->thinker);
|
||||
break;
|
||||
|
||||
case tc_plat:
|
||||
PADSAVEP();
|
||||
plat = Z_Malloc (sizeof(*plat), PU_LEVEL, NULL);
|
||||
memcpy (plat, save_p, sizeof(*plat));
|
||||
save_p += sizeof(*plat);
|
||||
plat->sector = §ors[(intptr_t)plat->sector];
|
||||
plat->sector->specialdata = plat;
|
||||
|
||||
if (plat->thinker.function.acp1)
|
||||
plat->thinker.function.acp1 = (actionf_p1)T_PlatRaise;
|
||||
|
||||
P_AddThinker (&plat->thinker);
|
||||
P_AddActivePlat(plat);
|
||||
break;
|
||||
|
||||
case tc_flash:
|
||||
PADSAVEP();
|
||||
flash = Z_Malloc (sizeof(*flash), PU_LEVEL, NULL);
|
||||
memcpy (flash, save_p, sizeof(*flash));
|
||||
save_p += sizeof(*flash);
|
||||
flash->sector = §ors[(intptr_t)flash->sector];
|
||||
flash->thinker.function.acp1 = (actionf_p1)T_LightFlash;
|
||||
P_AddThinker (&flash->thinker);
|
||||
break;
|
||||
|
||||
case tc_strobe:
|
||||
PADSAVEP();
|
||||
strobe = Z_Malloc (sizeof(*strobe), PU_LEVEL, NULL);
|
||||
memcpy (strobe, save_p, sizeof(*strobe));
|
||||
save_p += sizeof(*strobe);
|
||||
strobe->sector = §ors[(intptr_t)strobe->sector];
|
||||
strobe->thinker.function.acp1 = (actionf_p1)T_StrobeFlash;
|
||||
P_AddThinker (&strobe->thinker);
|
||||
break;
|
||||
|
||||
case tc_glow:
|
||||
PADSAVEP();
|
||||
glow = Z_Malloc (sizeof(*glow), PU_LEVEL, NULL);
|
||||
memcpy (glow, save_p, sizeof(*glow));
|
||||
save_p += sizeof(*glow);
|
||||
glow->sector = §ors[(intptr_t)glow->sector];
|
||||
glow->thinker.function.acp1 = (actionf_p1)T_Glow;
|
||||
P_AddThinker (&glow->thinker);
|
||||
break;
|
||||
|
||||
default:
|
||||
I_Error ("P_UnarchiveSpecials:Unknown tclass %i "
|
||||
"in savegame",tclass);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -0,0 +1,51 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Savegame I/O, archiving, persistence.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __P_SAVEG__
|
||||
#define __P_SAVEG__
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
// Persistent storage/archiving.
|
||||
// These are the load / save game routines.
|
||||
void P_ArchivePlayers (void);
|
||||
void P_UnArchivePlayers (void);
|
||||
void P_ArchiveWorld (void);
|
||||
void P_UnArchiveWorld (void);
|
||||
void P_ArchiveThinkers (void);
|
||||
void P_UnArchiveThinkers (void);
|
||||
void P_ArchiveSpecials (void);
|
||||
void P_UnArchiveSpecials (void);
|
||||
|
||||
extern byte* save_p;
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,708 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Do all the WAD I/O, get map description,
|
||||
// set up initial state and misc. LUTs.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_setup.c,v 1.5 1997/02/03 22:45:12 b1 Exp $";
|
||||
|
||||
|
||||
#include <math.h>
|
||||
|
||||
#include "z_zone.h"
|
||||
|
||||
#include "m_swap.h"
|
||||
#include "m_bbox.h"
|
||||
|
||||
#include "g_game.h"
|
||||
|
||||
#include "i_system.h"
|
||||
#include "w_wad.h"
|
||||
|
||||
#include "doomdef.h"
|
||||
#include "p_local.h"
|
||||
|
||||
#include "s_sound.h"
|
||||
|
||||
#include "doomstat.h"
|
||||
|
||||
|
||||
void P_SpawnMapThing (mapthing_t* mthing);
|
||||
|
||||
|
||||
//
|
||||
// MAP related Lookup tables.
|
||||
// Store VERTEXES, LINEDEFS, SIDEDEFS, etc.
|
||||
//
|
||||
int numvertexes;
|
||||
vertex_t* vertexes;
|
||||
|
||||
int numsegs;
|
||||
seg_t* segs;
|
||||
|
||||
int numsectors;
|
||||
sector_t* sectors;
|
||||
|
||||
int numsubsectors;
|
||||
subsector_t* subsectors;
|
||||
|
||||
int numnodes;
|
||||
node_t* nodes;
|
||||
|
||||
int numlines;
|
||||
line_t* lines;
|
||||
|
||||
int numsides;
|
||||
side_t* sides;
|
||||
|
||||
|
||||
// BLOCKMAP
|
||||
// Created from axis aligned bounding box
|
||||
// of the map, a rectangular array of
|
||||
// blocks of size ...
|
||||
// Used to speed up collision detection
|
||||
// by spatial subdivision in 2D.
|
||||
//
|
||||
// Blockmap size.
|
||||
int bmapwidth;
|
||||
int bmapheight; // size in mapblocks
|
||||
short* blockmap; // int for larger maps
|
||||
// offsets in blockmap are from here
|
||||
short* blockmaplump;
|
||||
// origin of block map
|
||||
fixed_t bmaporgx;
|
||||
fixed_t bmaporgy;
|
||||
// for thing chains
|
||||
mobj_t** blocklinks;
|
||||
|
||||
|
||||
// REJECT
|
||||
// For fast sight rejection.
|
||||
// Speeds up enemy AI by skipping detailed
|
||||
// LineOf Sight calculation.
|
||||
// Without special effect, this could be
|
||||
// used as a PVS lookup as well.
|
||||
//
|
||||
byte* rejectmatrix;
|
||||
|
||||
|
||||
// Maintain single and multi player starting spots.
|
||||
#define MAX_DEATHMATCH_STARTS 10
|
||||
|
||||
mapthing_t deathmatchstarts[MAX_DEATHMATCH_STARTS];
|
||||
mapthing_t* deathmatch_p;
|
||||
mapthing_t playerstarts[MAXPLAYERS];
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_LoadVertexes
|
||||
//
|
||||
void P_LoadVertexes (int lump)
|
||||
{
|
||||
byte* data;
|
||||
int i;
|
||||
mapvertex_t* ml;
|
||||
vertex_t* li;
|
||||
|
||||
// Determine number of lumps:
|
||||
// total lump length / vertex record length.
|
||||
numvertexes = W_LumpLength (lump) / sizeof(mapvertex_t);
|
||||
|
||||
// Allocate zone memory for buffer.
|
||||
vertexes = Z_Malloc (numvertexes*sizeof(vertex_t),PU_LEVEL,0);
|
||||
|
||||
// Load data into cache.
|
||||
data = W_CacheLumpNum (lump,PU_STATIC);
|
||||
|
||||
ml = (mapvertex_t *)data;
|
||||
li = vertexes;
|
||||
|
||||
// Copy and convert vertex coordinates,
|
||||
// internal representation as fixed.
|
||||
for (i=0 ; i<numvertexes ; i++, li++, ml++)
|
||||
{
|
||||
li->x = SHORT(ml->x)<<FRACBITS;
|
||||
li->y = SHORT(ml->y)<<FRACBITS;
|
||||
}
|
||||
|
||||
// Free buffer memory.
|
||||
Z_Free (data);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_LoadSegs
|
||||
//
|
||||
void P_LoadSegs (int lump)
|
||||
{
|
||||
byte* data;
|
||||
int i;
|
||||
mapseg_t* ml;
|
||||
seg_t* li;
|
||||
line_t* ldef;
|
||||
int linedef;
|
||||
int side;
|
||||
|
||||
numsegs = W_LumpLength (lump) / sizeof(mapseg_t);
|
||||
segs = Z_Malloc (numsegs*sizeof(seg_t),PU_LEVEL,0);
|
||||
memset (segs, 0, numsegs*sizeof(seg_t));
|
||||
data = W_CacheLumpNum (lump,PU_STATIC);
|
||||
|
||||
ml = (mapseg_t *)data;
|
||||
li = segs;
|
||||
for (i=0 ; i<numsegs ; i++, li++, ml++)
|
||||
{
|
||||
li->v1 = &vertexes[SHORT(ml->v1)];
|
||||
li->v2 = &vertexes[SHORT(ml->v2)];
|
||||
|
||||
li->angle = (SHORT(ml->angle))<<16;
|
||||
li->offset = (SHORT(ml->offset))<<16;
|
||||
linedef = SHORT(ml->linedef);
|
||||
ldef = &lines[linedef];
|
||||
li->linedef = ldef;
|
||||
side = SHORT(ml->side);
|
||||
li->sidedef = &sides[ldef->sidenum[side]];
|
||||
li->frontsector = sides[ldef->sidenum[side]].sector;
|
||||
if (ldef-> flags & ML_TWOSIDED)
|
||||
li->backsector = sides[ldef->sidenum[side^1]].sector;
|
||||
else
|
||||
li->backsector = 0;
|
||||
}
|
||||
|
||||
Z_Free (data);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_LoadSubsectors
|
||||
//
|
||||
void P_LoadSubsectors (int lump)
|
||||
{
|
||||
byte* data;
|
||||
int i;
|
||||
mapsubsector_t* ms;
|
||||
subsector_t* ss;
|
||||
|
||||
numsubsectors = W_LumpLength (lump) / sizeof(mapsubsector_t);
|
||||
subsectors = Z_Malloc (numsubsectors*sizeof(subsector_t),PU_LEVEL,0);
|
||||
data = W_CacheLumpNum (lump,PU_STATIC);
|
||||
|
||||
ms = (mapsubsector_t *)data;
|
||||
memset (subsectors,0, numsubsectors*sizeof(subsector_t));
|
||||
ss = subsectors;
|
||||
|
||||
for (i=0 ; i<numsubsectors ; i++, ss++, ms++)
|
||||
{
|
||||
ss->numlines = SHORT(ms->numsegs);
|
||||
ss->firstline = SHORT(ms->firstseg);
|
||||
}
|
||||
|
||||
Z_Free (data);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_LoadSectors
|
||||
//
|
||||
void P_LoadSectors (int lump)
|
||||
{
|
||||
byte* data;
|
||||
int i;
|
||||
mapsector_t* ms;
|
||||
sector_t* ss;
|
||||
|
||||
numsectors = W_LumpLength (lump) / sizeof(mapsector_t);
|
||||
sectors = Z_Malloc (numsectors*sizeof(sector_t),PU_LEVEL,0);
|
||||
memset (sectors, 0, numsectors*sizeof(sector_t));
|
||||
data = W_CacheLumpNum (lump,PU_STATIC);
|
||||
|
||||
ms = (mapsector_t *)data;
|
||||
ss = sectors;
|
||||
for (i=0 ; i<numsectors ; i++, ss++, ms++)
|
||||
{
|
||||
ss->floorheight = SHORT(ms->floorheight)<<FRACBITS;
|
||||
ss->ceilingheight = SHORT(ms->ceilingheight)<<FRACBITS;
|
||||
ss->floorpic = R_FlatNumForName(ms->floorpic);
|
||||
ss->ceilingpic = R_FlatNumForName(ms->ceilingpic);
|
||||
ss->lightlevel = SHORT(ms->lightlevel);
|
||||
ss->special = SHORT(ms->special);
|
||||
ss->tag = SHORT(ms->tag);
|
||||
ss->thinglist = NULL;
|
||||
}
|
||||
|
||||
Z_Free (data);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_LoadNodes
|
||||
//
|
||||
void P_LoadNodes (int lump)
|
||||
{
|
||||
byte* data;
|
||||
int i;
|
||||
int j;
|
||||
int k;
|
||||
mapnode_t* mn;
|
||||
node_t* no;
|
||||
|
||||
numnodes = W_LumpLength (lump) / sizeof(mapnode_t);
|
||||
nodes = Z_Malloc (numnodes*sizeof(node_t),PU_LEVEL,0);
|
||||
data = W_CacheLumpNum (lump,PU_STATIC);
|
||||
|
||||
mn = (mapnode_t *)data;
|
||||
no = nodes;
|
||||
|
||||
for (i=0 ; i<numnodes ; i++, no++, mn++)
|
||||
{
|
||||
no->x = SHORT(mn->x)<<FRACBITS;
|
||||
no->y = SHORT(mn->y)<<FRACBITS;
|
||||
no->dx = SHORT(mn->dx)<<FRACBITS;
|
||||
no->dy = SHORT(mn->dy)<<FRACBITS;
|
||||
for (j=0 ; j<2 ; j++)
|
||||
{
|
||||
no->children[j] = SHORT(mn->children[j]);
|
||||
for (k=0 ; k<4 ; k++)
|
||||
no->bbox[j][k] = SHORT(mn->bbox[j][k])<<FRACBITS;
|
||||
}
|
||||
}
|
||||
|
||||
Z_Free (data);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_LoadThings
|
||||
//
|
||||
void P_LoadThings (int lump)
|
||||
{
|
||||
byte* data;
|
||||
int i;
|
||||
mapthing_t* mt;
|
||||
int numthings;
|
||||
boolean spawn;
|
||||
|
||||
data = W_CacheLumpNum (lump,PU_STATIC);
|
||||
numthings = W_LumpLength (lump) / sizeof(mapthing_t);
|
||||
|
||||
mt = (mapthing_t *)data;
|
||||
for (i=0 ; i<numthings ; i++, mt++)
|
||||
{
|
||||
spawn = true;
|
||||
|
||||
// Do not spawn cool, new monsters if !commercial
|
||||
if ( gamemode != commercial)
|
||||
{
|
||||
switch(mt->type)
|
||||
{
|
||||
case 68: // Arachnotron
|
||||
case 64: // Archvile
|
||||
case 88: // Boss Brain
|
||||
case 89: // Boss Shooter
|
||||
case 69: // Hell Knight
|
||||
case 67: // Mancubus
|
||||
case 71: // Pain Elemental
|
||||
case 65: // Former Human Commando
|
||||
case 66: // Revenant
|
||||
case 84: // Wolf SS
|
||||
spawn = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (spawn == false)
|
||||
break;
|
||||
|
||||
// Do spawn all other stuff.
|
||||
mt->x = SHORT(mt->x);
|
||||
mt->y = SHORT(mt->y);
|
||||
mt->angle = SHORT(mt->angle);
|
||||
mt->type = SHORT(mt->type);
|
||||
mt->options = SHORT(mt->options);
|
||||
|
||||
P_SpawnMapThing (mt);
|
||||
}
|
||||
|
||||
Z_Free (data);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_LoadLineDefs
|
||||
// Also counts secret lines for intermissions.
|
||||
//
|
||||
void P_LoadLineDefs (int lump)
|
||||
{
|
||||
byte* data;
|
||||
int i;
|
||||
maplinedef_t* mld;
|
||||
line_t* ld;
|
||||
vertex_t* v1;
|
||||
vertex_t* v2;
|
||||
|
||||
numlines = W_LumpLength (lump) / sizeof(maplinedef_t);
|
||||
lines = Z_Malloc (numlines*sizeof(line_t),PU_LEVEL,0);
|
||||
memset (lines, 0, numlines*sizeof(line_t));
|
||||
data = W_CacheLumpNum (lump,PU_STATIC);
|
||||
|
||||
mld = (maplinedef_t *)data;
|
||||
ld = lines;
|
||||
for (i=0 ; i<numlines ; i++, mld++, ld++)
|
||||
{
|
||||
ld->flags = SHORT(mld->flags);
|
||||
ld->special = SHORT(mld->special);
|
||||
ld->tag = SHORT(mld->tag);
|
||||
v1 = ld->v1 = &vertexes[SHORT(mld->v1)];
|
||||
v2 = ld->v2 = &vertexes[SHORT(mld->v2)];
|
||||
ld->dx = v2->x - v1->x;
|
||||
ld->dy = v2->y - v1->y;
|
||||
|
||||
if (!ld->dx)
|
||||
ld->slopetype = ST_VERTICAL;
|
||||
else if (!ld->dy)
|
||||
ld->slopetype = ST_HORIZONTAL;
|
||||
else
|
||||
{
|
||||
if (FixedDiv (ld->dy , ld->dx) > 0)
|
||||
ld->slopetype = ST_POSITIVE;
|
||||
else
|
||||
ld->slopetype = ST_NEGATIVE;
|
||||
}
|
||||
|
||||
if (v1->x < v2->x)
|
||||
{
|
||||
ld->bbox[BOXLEFT] = v1->x;
|
||||
ld->bbox[BOXRIGHT] = v2->x;
|
||||
}
|
||||
else
|
||||
{
|
||||
ld->bbox[BOXLEFT] = v2->x;
|
||||
ld->bbox[BOXRIGHT] = v1->x;
|
||||
}
|
||||
|
||||
if (v1->y < v2->y)
|
||||
{
|
||||
ld->bbox[BOXBOTTOM] = v1->y;
|
||||
ld->bbox[BOXTOP] = v2->y;
|
||||
}
|
||||
else
|
||||
{
|
||||
ld->bbox[BOXBOTTOM] = v2->y;
|
||||
ld->bbox[BOXTOP] = v1->y;
|
||||
}
|
||||
|
||||
ld->sidenum[0] = SHORT(mld->sidenum[0]);
|
||||
ld->sidenum[1] = SHORT(mld->sidenum[1]);
|
||||
|
||||
if (ld->sidenum[0] != -1)
|
||||
ld->frontsector = sides[ld->sidenum[0]].sector;
|
||||
else
|
||||
ld->frontsector = 0;
|
||||
|
||||
if (ld->sidenum[1] != -1)
|
||||
ld->backsector = sides[ld->sidenum[1]].sector;
|
||||
else
|
||||
ld->backsector = 0;
|
||||
}
|
||||
|
||||
Z_Free (data);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_LoadSideDefs
|
||||
//
|
||||
void P_LoadSideDefs (int lump)
|
||||
{
|
||||
byte* data;
|
||||
int i;
|
||||
mapsidedef_t* msd;
|
||||
side_t* sd;
|
||||
|
||||
numsides = W_LumpLength (lump) / sizeof(mapsidedef_t);
|
||||
sides = Z_Malloc (numsides*sizeof(side_t),PU_LEVEL,0);
|
||||
memset (sides, 0, numsides*sizeof(side_t));
|
||||
data = W_CacheLumpNum (lump,PU_STATIC);
|
||||
|
||||
msd = (mapsidedef_t *)data;
|
||||
sd = sides;
|
||||
for (i=0 ; i<numsides ; i++, msd++, sd++)
|
||||
{
|
||||
sd->textureoffset = SHORT(msd->textureoffset)<<FRACBITS;
|
||||
sd->rowoffset = SHORT(msd->rowoffset)<<FRACBITS;
|
||||
sd->toptexture = R_TextureNumForName(msd->toptexture);
|
||||
sd->bottomtexture = R_TextureNumForName(msd->bottomtexture);
|
||||
sd->midtexture = R_TextureNumForName(msd->midtexture);
|
||||
sd->sector = §ors[SHORT(msd->sector)];
|
||||
}
|
||||
|
||||
Z_Free (data);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_LoadBlockMap
|
||||
//
|
||||
void P_LoadBlockMap (int lump)
|
||||
{
|
||||
int i;
|
||||
int count;
|
||||
|
||||
blockmaplump = W_CacheLumpNum (lump,PU_LEVEL);
|
||||
blockmap = blockmaplump+4;
|
||||
count = W_LumpLength (lump)/2;
|
||||
|
||||
for (i=0 ; i<count ; i++)
|
||||
blockmaplump[i] = SHORT(blockmaplump[i]);
|
||||
|
||||
bmaporgx = blockmaplump[0]<<FRACBITS;
|
||||
bmaporgy = blockmaplump[1]<<FRACBITS;
|
||||
bmapwidth = blockmaplump[2];
|
||||
bmapheight = blockmaplump[3];
|
||||
|
||||
// clear out mobj chains
|
||||
count = sizeof(*blocklinks)* bmapwidth*bmapheight;
|
||||
blocklinks = Z_Malloc (count,PU_LEVEL, 0);
|
||||
memset (blocklinks, 0, count);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_GroupLines
|
||||
// Builds sector line lists and subsector sector numbers.
|
||||
// Finds block bounding boxes for sectors.
|
||||
//
|
||||
void P_GroupLines (void)
|
||||
{
|
||||
line_t** linebuffer;
|
||||
int i;
|
||||
int j;
|
||||
int total;
|
||||
line_t* li;
|
||||
sector_t* sector;
|
||||
subsector_t* ss;
|
||||
seg_t* seg;
|
||||
fixed_t bbox[4];
|
||||
int block;
|
||||
|
||||
// look up sector number for each subsector
|
||||
ss = subsectors;
|
||||
for (i=0 ; i<numsubsectors ; i++, ss++)
|
||||
{
|
||||
seg = &segs[ss->firstline];
|
||||
ss->sector = seg->sidedef->sector;
|
||||
}
|
||||
|
||||
// count number of lines in each sector
|
||||
li = lines;
|
||||
total = 0;
|
||||
for (i=0 ; i<numlines ; i++, li++)
|
||||
{
|
||||
total++;
|
||||
li->frontsector->linecount++;
|
||||
|
||||
if (li->backsector && li->backsector != li->frontsector)
|
||||
{
|
||||
li->backsector->linecount++;
|
||||
total++;
|
||||
}
|
||||
}
|
||||
|
||||
// build line tables for each sector
|
||||
linebuffer = Z_Malloc (total*sizeof(*linebuffer), PU_LEVEL, 0);
|
||||
sector = sectors;
|
||||
for (i=0 ; i<numsectors ; i++, sector++)
|
||||
{
|
||||
M_ClearBox (bbox);
|
||||
sector->lines = linebuffer;
|
||||
li = lines;
|
||||
for (j=0 ; j<numlines ; j++, li++)
|
||||
{
|
||||
if (li->frontsector == sector || li->backsector == sector)
|
||||
{
|
||||
*linebuffer++ = li;
|
||||
M_AddToBox (bbox, li->v1->x, li->v1->y);
|
||||
M_AddToBox (bbox, li->v2->x, li->v2->y);
|
||||
}
|
||||
}
|
||||
if (linebuffer - sector->lines != sector->linecount)
|
||||
I_Error ("P_GroupLines: miscounted");
|
||||
|
||||
// set the degenmobj_t to the middle of the bounding box
|
||||
sector->soundorg.x = (bbox[BOXRIGHT]+bbox[BOXLEFT])/2;
|
||||
sector->soundorg.y = (bbox[BOXTOP]+bbox[BOXBOTTOM])/2;
|
||||
|
||||
// adjust bounding box to map blocks
|
||||
block = (bbox[BOXTOP]-bmaporgy+MAXRADIUS)>>MAPBLOCKSHIFT;
|
||||
block = block >= bmapheight ? bmapheight-1 : block;
|
||||
sector->blockbox[BOXTOP]=block;
|
||||
|
||||
block = (bbox[BOXBOTTOM]-bmaporgy-MAXRADIUS)>>MAPBLOCKSHIFT;
|
||||
block = block < 0 ? 0 : block;
|
||||
sector->blockbox[BOXBOTTOM]=block;
|
||||
|
||||
block = (bbox[BOXRIGHT]-bmaporgx+MAXRADIUS)>>MAPBLOCKSHIFT;
|
||||
block = block >= bmapwidth ? bmapwidth-1 : block;
|
||||
sector->blockbox[BOXRIGHT]=block;
|
||||
|
||||
block = (bbox[BOXLEFT]-bmaporgx-MAXRADIUS)>>MAPBLOCKSHIFT;
|
||||
block = block < 0 ? 0 : block;
|
||||
sector->blockbox[BOXLEFT]=block;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_SetupLevel
|
||||
//
|
||||
void
|
||||
P_SetupLevel
|
||||
( int episode,
|
||||
int map,
|
||||
int playermask,
|
||||
skill_t skill)
|
||||
{
|
||||
int i;
|
||||
char lumpname[9];
|
||||
int lumpnum;
|
||||
|
||||
totalkills = totalitems = totalsecret = wminfo.maxfrags = 0;
|
||||
wminfo.partime = 180;
|
||||
for (i=0 ; i<MAXPLAYERS ; i++)
|
||||
{
|
||||
players[i].killcount = players[i].secretcount
|
||||
= players[i].itemcount = 0;
|
||||
}
|
||||
|
||||
// Initial height of PointOfView
|
||||
// will be set by player think.
|
||||
players[consoleplayer].viewz = 1;
|
||||
|
||||
// Make sure all sounds are stopped before Z_FreeTags.
|
||||
S_Start ();
|
||||
|
||||
|
||||
#if 0 // UNUSED
|
||||
if (debugfile)
|
||||
{
|
||||
Z_FreeTags (PU_LEVEL, MAXINT);
|
||||
Z_FileDumpHeap (debugfile);
|
||||
}
|
||||
else
|
||||
#endif
|
||||
Z_FreeTags (PU_LEVEL, PU_PURGELEVEL-1);
|
||||
|
||||
|
||||
// UNUSED W_Profile ();
|
||||
P_InitThinkers ();
|
||||
|
||||
// if working with a devlopment map, reload it
|
||||
W_Reload ();
|
||||
|
||||
// find map name
|
||||
if ( gamemode == commercial)
|
||||
{
|
||||
if (map<10)
|
||||
sprintf (lumpname,"map0%i", map);
|
||||
else
|
||||
sprintf (lumpname,"map%i", map);
|
||||
}
|
||||
else
|
||||
{
|
||||
lumpname[0] = 'E';
|
||||
lumpname[1] = '0' + episode;
|
||||
lumpname[2] = 'M';
|
||||
lumpname[3] = '0' + map;
|
||||
lumpname[4] = 0;
|
||||
}
|
||||
|
||||
lumpnum = W_GetNumForName (lumpname);
|
||||
|
||||
leveltime = 0;
|
||||
|
||||
// note: most of this ordering is important
|
||||
P_LoadBlockMap (lumpnum+ML_BLOCKMAP);
|
||||
P_LoadVertexes (lumpnum+ML_VERTEXES);
|
||||
P_LoadSectors (lumpnum+ML_SECTORS);
|
||||
P_LoadSideDefs (lumpnum+ML_SIDEDEFS);
|
||||
|
||||
P_LoadLineDefs (lumpnum+ML_LINEDEFS);
|
||||
P_LoadSubsectors (lumpnum+ML_SSECTORS);
|
||||
P_LoadNodes (lumpnum+ML_NODES);
|
||||
P_LoadSegs (lumpnum+ML_SEGS);
|
||||
|
||||
rejectmatrix = W_CacheLumpNum (lumpnum+ML_REJECT,PU_LEVEL);
|
||||
P_GroupLines ();
|
||||
|
||||
bodyqueslot = 0;
|
||||
deathmatch_p = deathmatchstarts;
|
||||
P_LoadThings (lumpnum+ML_THINGS);
|
||||
|
||||
// if deathmatch, randomly spawn the active players
|
||||
if (deathmatch)
|
||||
{
|
||||
for (i=0 ; i<MAXPLAYERS ; i++)
|
||||
if (playeringame[i])
|
||||
{
|
||||
players[i].mo = NULL;
|
||||
G_DeathMatchSpawnPlayer (i);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// clear special respawning que
|
||||
iquehead = iquetail = 0;
|
||||
|
||||
// set up world state
|
||||
P_SpawnSpecials ();
|
||||
|
||||
// build subsector connect matrix
|
||||
// UNUSED P_ConnectSubsectors ();
|
||||
|
||||
// preload graphics
|
||||
if (precache)
|
||||
R_PrecacheLevel ();
|
||||
|
||||
//printf ("free memory: 0x%x\n", Z_FreeMemory());
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_Init
|
||||
//
|
||||
void P_Init (void)
|
||||
{
|
||||
P_InitSwitchList ();
|
||||
P_InitPicAnims ();
|
||||
R_InitSprites (sprnames);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Setup a game, startup stuff.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __P_SETUP__
|
||||
#define __P_SETUP__
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
// NOT called by W_Ticker. Fixme.
|
||||
void
|
||||
P_SetupLevel
|
||||
( int episode,
|
||||
int map,
|
||||
int playermask,
|
||||
skill_t skill);
|
||||
|
||||
// Called by startup code.
|
||||
void P_Init (void);
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,349 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// LineOfSight/Visibility checks, uses REJECT Lookup Table.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_sight.c,v 1.3 1997/01/28 22:08:28 b1 Exp $";
|
||||
|
||||
|
||||
#include "doomdef.h"
|
||||
|
||||
#include "i_system.h"
|
||||
#include "p_local.h"
|
||||
|
||||
// State.
|
||||
#include "r_state.h"
|
||||
|
||||
//
|
||||
// P_CheckSight
|
||||
//
|
||||
fixed_t sightzstart; // eye z of looker
|
||||
fixed_t topslope;
|
||||
fixed_t bottomslope; // slopes to top and bottom of target
|
||||
|
||||
divline_t strace; // from t1 to t2
|
||||
fixed_t t2x;
|
||||
fixed_t t2y;
|
||||
|
||||
int sightcounts[2];
|
||||
|
||||
|
||||
//
|
||||
// P_DivlineSide
|
||||
// Returns side 0 (front), 1 (back), or 2 (on).
|
||||
//
|
||||
int
|
||||
P_DivlineSide
|
||||
( fixed_t x,
|
||||
fixed_t y,
|
||||
divline_t* node )
|
||||
{
|
||||
fixed_t dx;
|
||||
fixed_t dy;
|
||||
fixed_t left;
|
||||
fixed_t right;
|
||||
|
||||
if (!node->dx)
|
||||
{
|
||||
if (x==node->x)
|
||||
return 2;
|
||||
|
||||
if (x <= node->x)
|
||||
return node->dy > 0;
|
||||
|
||||
return node->dy < 0;
|
||||
}
|
||||
|
||||
if (!node->dy)
|
||||
{
|
||||
if (x==node->y)
|
||||
return 2;
|
||||
|
||||
if (y <= node->y)
|
||||
return node->dx < 0;
|
||||
|
||||
return node->dx > 0;
|
||||
}
|
||||
|
||||
dx = (x - node->x);
|
||||
dy = (y - node->y);
|
||||
|
||||
left = (node->dy>>FRACBITS) * (dx>>FRACBITS);
|
||||
right = (dy>>FRACBITS) * (node->dx>>FRACBITS);
|
||||
|
||||
if (right < left)
|
||||
return 0; // front side
|
||||
|
||||
if (left == right)
|
||||
return 2;
|
||||
return 1; // back side
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_InterceptVector2
|
||||
// Returns the fractional intercept point
|
||||
// along the first divline.
|
||||
// This is only called by the addthings and addlines traversers.
|
||||
//
|
||||
fixed_t
|
||||
P_InterceptVector2
|
||||
( divline_t* v2,
|
||||
divline_t* v1 )
|
||||
{
|
||||
fixed_t frac;
|
||||
fixed_t num;
|
||||
fixed_t den;
|
||||
|
||||
den = FixedMul (v1->dy>>8,v2->dx) - FixedMul(v1->dx>>8,v2->dy);
|
||||
|
||||
if (den == 0)
|
||||
return 0;
|
||||
// I_Error ("P_InterceptVector: parallel");
|
||||
|
||||
num = FixedMul ( (v1->x - v2->x)>>8 ,v1->dy) +
|
||||
FixedMul ( (v2->y - v1->y)>>8 , v1->dx);
|
||||
frac = FixedDiv (num , den);
|
||||
|
||||
return frac;
|
||||
}
|
||||
|
||||
//
|
||||
// P_CrossSubsector
|
||||
// Returns true
|
||||
// if strace crosses the given subsector successfully.
|
||||
//
|
||||
boolean P_CrossSubsector (int num)
|
||||
{
|
||||
seg_t* seg;
|
||||
line_t* line;
|
||||
int s1;
|
||||
int s2;
|
||||
int count;
|
||||
subsector_t* sub;
|
||||
sector_t* front;
|
||||
sector_t* back;
|
||||
fixed_t opentop;
|
||||
fixed_t openbottom;
|
||||
divline_t divl;
|
||||
vertex_t* v1;
|
||||
vertex_t* v2;
|
||||
fixed_t frac;
|
||||
fixed_t slope;
|
||||
|
||||
#ifdef RANGECHECK
|
||||
if (num>=numsubsectors)
|
||||
I_Error ("P_CrossSubsector: ss %i with numss = %i",
|
||||
num,
|
||||
numsubsectors);
|
||||
#endif
|
||||
|
||||
sub = &subsectors[num];
|
||||
|
||||
// check lines
|
||||
count = sub->numlines;
|
||||
seg = &segs[sub->firstline];
|
||||
|
||||
for ( ; count ; seg++, count--)
|
||||
{
|
||||
line = seg->linedef;
|
||||
|
||||
// allready checked other side?
|
||||
if (line->validcount == validcount)
|
||||
continue;
|
||||
|
||||
line->validcount = validcount;
|
||||
|
||||
v1 = line->v1;
|
||||
v2 = line->v2;
|
||||
s1 = P_DivlineSide (v1->x,v1->y, &strace);
|
||||
s2 = P_DivlineSide (v2->x, v2->y, &strace);
|
||||
|
||||
// line isn't crossed?
|
||||
if (s1 == s2)
|
||||
continue;
|
||||
|
||||
divl.x = v1->x;
|
||||
divl.y = v1->y;
|
||||
divl.dx = v2->x - v1->x;
|
||||
divl.dy = v2->y - v1->y;
|
||||
s1 = P_DivlineSide (strace.x, strace.y, &divl);
|
||||
s2 = P_DivlineSide (t2x, t2y, &divl);
|
||||
|
||||
// line isn't crossed?
|
||||
if (s1 == s2)
|
||||
continue;
|
||||
|
||||
// stop because it is not two sided anyway
|
||||
// might do this after updating validcount?
|
||||
if ( !(line->flags & ML_TWOSIDED) )
|
||||
return false;
|
||||
|
||||
// crosses a two sided line
|
||||
front = seg->frontsector;
|
||||
back = seg->backsector;
|
||||
|
||||
// no wall to block sight with?
|
||||
if (front->floorheight == back->floorheight
|
||||
&& front->ceilingheight == back->ceilingheight)
|
||||
continue;
|
||||
|
||||
// possible occluder
|
||||
// because of ceiling height differences
|
||||
if (front->ceilingheight < back->ceilingheight)
|
||||
opentop = front->ceilingheight;
|
||||
else
|
||||
opentop = back->ceilingheight;
|
||||
|
||||
// because of ceiling height differences
|
||||
if (front->floorheight > back->floorheight)
|
||||
openbottom = front->floorheight;
|
||||
else
|
||||
openbottom = back->floorheight;
|
||||
|
||||
// quick test for totally closed doors
|
||||
if (openbottom >= opentop)
|
||||
return false; // stop
|
||||
|
||||
frac = P_InterceptVector2 (&strace, &divl);
|
||||
|
||||
if (front->floorheight != back->floorheight)
|
||||
{
|
||||
slope = FixedDiv (openbottom - sightzstart , frac);
|
||||
if (slope > bottomslope)
|
||||
bottomslope = slope;
|
||||
}
|
||||
|
||||
if (front->ceilingheight != back->ceilingheight)
|
||||
{
|
||||
slope = FixedDiv (opentop - sightzstart , frac);
|
||||
if (slope < topslope)
|
||||
topslope = slope;
|
||||
}
|
||||
|
||||
if (topslope <= bottomslope)
|
||||
return false; // stop
|
||||
}
|
||||
// passed the subsector ok
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_CrossBSPNode
|
||||
// Returns true
|
||||
// if strace crosses the given node successfully.
|
||||
//
|
||||
boolean P_CrossBSPNode (int bspnum)
|
||||
{
|
||||
node_t* bsp;
|
||||
int side;
|
||||
|
||||
if (bspnum & NF_SUBSECTOR)
|
||||
{
|
||||
if (bspnum == -1)
|
||||
return P_CrossSubsector (0);
|
||||
else
|
||||
return P_CrossSubsector (bspnum&(~NF_SUBSECTOR));
|
||||
}
|
||||
|
||||
bsp = &nodes[bspnum];
|
||||
|
||||
// decide which side the start point is on
|
||||
side = P_DivlineSide (strace.x, strace.y, (divline_t *)bsp);
|
||||
if (side == 2)
|
||||
side = 0; // an "on" should cross both sides
|
||||
|
||||
// cross the starting side
|
||||
if (!P_CrossBSPNode (bsp->children[side]) )
|
||||
return false;
|
||||
|
||||
// the partition plane is crossed here
|
||||
if (side == P_DivlineSide (t2x, t2y,(divline_t *)bsp))
|
||||
{
|
||||
// the line doesn't touch the other side
|
||||
return true;
|
||||
}
|
||||
|
||||
// cross the ending side
|
||||
return P_CrossBSPNode (bsp->children[side^1]);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// P_CheckSight
|
||||
// Returns true
|
||||
// if a straight line between t1 and t2 is unobstructed.
|
||||
// Uses REJECT.
|
||||
//
|
||||
boolean
|
||||
P_CheckSight
|
||||
( mobj_t* t1,
|
||||
mobj_t* t2 )
|
||||
{
|
||||
int s1;
|
||||
int s2;
|
||||
int pnum;
|
||||
int bytenum;
|
||||
int bitnum;
|
||||
|
||||
// First check for trivial rejection.
|
||||
|
||||
// Determine subsector entries in REJECT table.
|
||||
s1 = (t1->subsector->sector - sectors);
|
||||
s2 = (t2->subsector->sector - sectors);
|
||||
pnum = s1*numsectors + s2;
|
||||
bytenum = pnum>>3;
|
||||
bitnum = 1 << (pnum&7);
|
||||
|
||||
// Check in REJECT table.
|
||||
if (rejectmatrix[bytenum]&bitnum)
|
||||
{
|
||||
sightcounts[0]++;
|
||||
|
||||
// can't possibly be connected
|
||||
return false;
|
||||
}
|
||||
|
||||
// An unobstructed LOS is possible.
|
||||
// Now look from eyes of t1 to any part of t2.
|
||||
sightcounts[1]++;
|
||||
|
||||
validcount++;
|
||||
|
||||
sightzstart = t1->z + t1->height - (t1->height>>2);
|
||||
topslope = (t2->z+t2->height) - sightzstart;
|
||||
bottomslope = (t2->z) - sightzstart;
|
||||
|
||||
strace.x = t1->x;
|
||||
strace.y = t1->y;
|
||||
t2x = t2->x;
|
||||
t2y = t2->y;
|
||||
strace.dx = t2->x - t1->x;
|
||||
strace.dy = t2->y - t1->y;
|
||||
|
||||
// the head node is the last node output
|
||||
return P_CrossBSPNode (numnodes-1);
|
||||
}
|
||||
|
||||
|
||||
+1362
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,645 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION: none
|
||||
// Implements special effects:
|
||||
// Texture animation, height or lighting changes
|
||||
// according to adjacent sectors, respective
|
||||
// utility functions, etc.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __P_SPEC__
|
||||
#define __P_SPEC__
|
||||
|
||||
|
||||
//
|
||||
// End-level timer (-TIMER option)
|
||||
//
|
||||
extern boolean levelTimer;
|
||||
extern int levelTimeCount;
|
||||
|
||||
|
||||
// Define values for map objects
|
||||
#define MO_TELEPORTMAN 14
|
||||
|
||||
|
||||
// at game start
|
||||
void P_InitPicAnims (void);
|
||||
|
||||
// at map load
|
||||
void P_SpawnSpecials (void);
|
||||
|
||||
// every tic
|
||||
void P_UpdateSpecials (void);
|
||||
|
||||
// when needed
|
||||
boolean
|
||||
P_UseSpecialLine
|
||||
( mobj_t* thing,
|
||||
line_t* line,
|
||||
int side );
|
||||
|
||||
void
|
||||
P_ShootSpecialLine
|
||||
( mobj_t* thing,
|
||||
line_t* line );
|
||||
|
||||
void
|
||||
P_CrossSpecialLine
|
||||
( int linenum,
|
||||
int side,
|
||||
mobj_t* thing );
|
||||
|
||||
void P_PlayerInSpecialSector (player_t* player);
|
||||
|
||||
int
|
||||
twoSided
|
||||
( int sector,
|
||||
int line );
|
||||
|
||||
sector_t*
|
||||
getSector
|
||||
( int currentSector,
|
||||
int line,
|
||||
int side );
|
||||
|
||||
side_t*
|
||||
getSide
|
||||
( int currentSector,
|
||||
int line,
|
||||
int side );
|
||||
|
||||
fixed_t P_FindLowestFloorSurrounding(sector_t* sec);
|
||||
fixed_t P_FindHighestFloorSurrounding(sector_t* sec);
|
||||
|
||||
fixed_t
|
||||
P_FindNextHighestFloor
|
||||
( sector_t* sec,
|
||||
int currentheight );
|
||||
|
||||
fixed_t P_FindLowestCeilingSurrounding(sector_t* sec);
|
||||
fixed_t P_FindHighestCeilingSurrounding(sector_t* sec);
|
||||
|
||||
int
|
||||
P_FindSectorFromLineTag
|
||||
( line_t* line,
|
||||
int start );
|
||||
|
||||
int
|
||||
P_FindMinSurroundingLight
|
||||
( sector_t* sector,
|
||||
int max );
|
||||
|
||||
sector_t*
|
||||
getNextSector
|
||||
( line_t* line,
|
||||
sector_t* sec );
|
||||
|
||||
|
||||
//
|
||||
// SPECIAL
|
||||
//
|
||||
int EV_DoDonut(line_t* line);
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_LIGHTS
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
thinker_t thinker;
|
||||
sector_t* sector;
|
||||
int count;
|
||||
int maxlight;
|
||||
int minlight;
|
||||
|
||||
} fireflicker_t;
|
||||
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
thinker_t thinker;
|
||||
sector_t* sector;
|
||||
int count;
|
||||
int maxlight;
|
||||
int minlight;
|
||||
int maxtime;
|
||||
int mintime;
|
||||
|
||||
} lightflash_t;
|
||||
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
thinker_t thinker;
|
||||
sector_t* sector;
|
||||
int count;
|
||||
int minlight;
|
||||
int maxlight;
|
||||
int darktime;
|
||||
int brighttime;
|
||||
|
||||
} strobe_t;
|
||||
|
||||
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
thinker_t thinker;
|
||||
sector_t* sector;
|
||||
int minlight;
|
||||
int maxlight;
|
||||
int direction;
|
||||
|
||||
} glow_t;
|
||||
|
||||
|
||||
#define GLOWSPEED 8
|
||||
#define STROBEBRIGHT 5
|
||||
#define FASTDARK 15
|
||||
#define SLOWDARK 35
|
||||
|
||||
void P_SpawnFireFlicker (sector_t* sector);
|
||||
void T_LightFlash (lightflash_t* flash);
|
||||
void P_SpawnLightFlash (sector_t* sector);
|
||||
void T_StrobeFlash (strobe_t* flash);
|
||||
|
||||
void
|
||||
P_SpawnStrobeFlash
|
||||
( sector_t* sector,
|
||||
int fastOrSlow,
|
||||
int inSync );
|
||||
|
||||
void EV_StartLightStrobing(line_t* line);
|
||||
void EV_TurnTagLightsOff(line_t* line);
|
||||
|
||||
void
|
||||
EV_LightTurnOn
|
||||
( line_t* line,
|
||||
int bright );
|
||||
|
||||
void T_Glow(glow_t* g);
|
||||
void P_SpawnGlowingLight(sector_t* sector);
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_SWITCH
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
char name1[9];
|
||||
char name2[9];
|
||||
short episode;
|
||||
|
||||
} switchlist_t;
|
||||
|
||||
|
||||
typedef enum
|
||||
{
|
||||
top,
|
||||
middle,
|
||||
bottom
|
||||
|
||||
} bwhere_e;
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
line_t* line;
|
||||
bwhere_e where;
|
||||
int btexture;
|
||||
int btimer;
|
||||
mobj_t* soundorg;
|
||||
|
||||
} button_t;
|
||||
|
||||
|
||||
|
||||
|
||||
// max # of wall switches in a level
|
||||
#define MAXSWITCHES 50
|
||||
|
||||
// 4 players, 4 buttons each at once, max.
|
||||
#define MAXBUTTONS 64
|
||||
|
||||
// 1 second, in ticks.
|
||||
#define BUTTONTIME 35
|
||||
|
||||
extern button_t buttonlist[MAXBUTTONS];
|
||||
|
||||
void
|
||||
P_ChangeSwitchTexture
|
||||
( line_t* line,
|
||||
int useAgain );
|
||||
|
||||
void P_InitSwitchList(void);
|
||||
|
||||
|
||||
//
|
||||
// P_PLATS
|
||||
//
|
||||
typedef enum
|
||||
{
|
||||
up,
|
||||
down,
|
||||
waiting,
|
||||
in_stasis
|
||||
|
||||
} plat_e;
|
||||
|
||||
|
||||
|
||||
typedef enum
|
||||
{
|
||||
perpetualRaise,
|
||||
downWaitUpStay,
|
||||
raiseAndChange,
|
||||
raiseToNearestAndChange,
|
||||
blazeDWUS
|
||||
|
||||
} plattype_e;
|
||||
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
thinker_t thinker;
|
||||
sector_t* sector;
|
||||
fixed_t speed;
|
||||
fixed_t low;
|
||||
fixed_t high;
|
||||
int wait;
|
||||
int count;
|
||||
plat_e status;
|
||||
plat_e oldstatus;
|
||||
boolean crush;
|
||||
int tag;
|
||||
plattype_e type;
|
||||
|
||||
} plat_t;
|
||||
|
||||
|
||||
|
||||
#define PLATWAIT 3
|
||||
#define PLATSPEED FRACUNIT
|
||||
#define MAXPLATS 512
|
||||
|
||||
|
||||
extern plat_t* activeplats[MAXPLATS];
|
||||
|
||||
void T_PlatRaise(plat_t* plat);
|
||||
|
||||
int
|
||||
EV_DoPlat
|
||||
( line_t* line,
|
||||
plattype_e type,
|
||||
int amount );
|
||||
|
||||
void P_AddActivePlat(plat_t* plat);
|
||||
void P_RemoveActivePlat(plat_t* plat);
|
||||
void EV_StopPlat(line_t* line);
|
||||
void P_ActivateInStasis(int tag);
|
||||
|
||||
|
||||
//
|
||||
// P_DOORS
|
||||
//
|
||||
typedef enum
|
||||
{
|
||||
normal,
|
||||
close30ThenOpen,
|
||||
close,
|
||||
open,
|
||||
raiseIn5Mins,
|
||||
blazeRaise,
|
||||
blazeOpen,
|
||||
blazeClose
|
||||
|
||||
} vldoor_e;
|
||||
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
thinker_t thinker;
|
||||
vldoor_e type;
|
||||
sector_t* sector;
|
||||
fixed_t topheight;
|
||||
fixed_t speed;
|
||||
|
||||
// 1 = up, 0 = waiting at top, -1 = down
|
||||
int direction;
|
||||
|
||||
// tics to wait at the top
|
||||
int topwait;
|
||||
// (keep in case a door going down is reset)
|
||||
// when it reaches 0, start going down
|
||||
int topcountdown;
|
||||
|
||||
} vldoor_t;
|
||||
|
||||
|
||||
|
||||
#define VDOORSPEED FRACUNIT*2
|
||||
#define VDOORWAIT 150
|
||||
|
||||
void
|
||||
EV_VerticalDoor
|
||||
( line_t* line,
|
||||
mobj_t* thing );
|
||||
|
||||
int
|
||||
EV_DoDoor
|
||||
( line_t* line,
|
||||
vldoor_e type );
|
||||
|
||||
int
|
||||
EV_DoLockedDoor
|
||||
( line_t* line,
|
||||
vldoor_e type,
|
||||
mobj_t* thing );
|
||||
|
||||
void T_VerticalDoor (vldoor_t* door);
|
||||
void P_SpawnDoorCloseIn30 (sector_t* sec);
|
||||
|
||||
void
|
||||
P_SpawnDoorRaiseIn5Mins
|
||||
( sector_t* sec,
|
||||
int secnum );
|
||||
|
||||
|
||||
|
||||
#if 0 // UNUSED
|
||||
//
|
||||
// Sliding doors...
|
||||
//
|
||||
typedef enum
|
||||
{
|
||||
sd_opening,
|
||||
sd_waiting,
|
||||
sd_closing
|
||||
|
||||
} sd_e;
|
||||
|
||||
|
||||
|
||||
typedef enum
|
||||
{
|
||||
sdt_openOnly,
|
||||
sdt_closeOnly,
|
||||
sdt_openAndClose
|
||||
|
||||
} sdt_e;
|
||||
|
||||
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
thinker_t thinker;
|
||||
sdt_e type;
|
||||
line_t* line;
|
||||
int frame;
|
||||
int whichDoorIndex;
|
||||
int timer;
|
||||
sector_t* frontsector;
|
||||
sector_t* backsector;
|
||||
sd_e status;
|
||||
|
||||
} slidedoor_t;
|
||||
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char frontFrame1[9];
|
||||
char frontFrame2[9];
|
||||
char frontFrame3[9];
|
||||
char frontFrame4[9];
|
||||
char backFrame1[9];
|
||||
char backFrame2[9];
|
||||
char backFrame3[9];
|
||||
char backFrame4[9];
|
||||
|
||||
} slidename_t;
|
||||
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int frontFrames[4];
|
||||
int backFrames[4];
|
||||
|
||||
} slideframe_t;
|
||||
|
||||
|
||||
|
||||
// how many frames of animation
|
||||
#define SNUMFRAMES 4
|
||||
|
||||
#define SDOORWAIT 35*3
|
||||
#define SWAITTICS 4
|
||||
|
||||
// how many diff. types of anims
|
||||
#define MAXSLIDEDOORS 5
|
||||
|
||||
void P_InitSlidingDoorFrames(void);
|
||||
|
||||
void
|
||||
EV_SlidingDoor
|
||||
( line_t* line,
|
||||
mobj_t* thing );
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_CEILNG
|
||||
//
|
||||
typedef enum
|
||||
{
|
||||
lowerToFloor,
|
||||
raiseToHighest,
|
||||
lowerAndCrush,
|
||||
crushAndRaise,
|
||||
fastCrushAndRaise,
|
||||
silentCrushAndRaise
|
||||
|
||||
} ceiling_e;
|
||||
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
thinker_t thinker;
|
||||
ceiling_e type;
|
||||
sector_t* sector;
|
||||
fixed_t bottomheight;
|
||||
fixed_t topheight;
|
||||
fixed_t speed;
|
||||
boolean crush;
|
||||
|
||||
// 1 = up, 0 = waiting, -1 = down
|
||||
int direction;
|
||||
|
||||
// ID
|
||||
int tag;
|
||||
int olddirection;
|
||||
|
||||
} ceiling_t;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#define CEILSPEED FRACUNIT
|
||||
#define CEILWAIT 150
|
||||
#define MAXCEILINGS 512
|
||||
|
||||
extern ceiling_t* activeceilings[MAXCEILINGS];
|
||||
|
||||
int
|
||||
EV_DoCeiling
|
||||
( line_t* line,
|
||||
ceiling_e type );
|
||||
|
||||
void T_MoveCeiling (ceiling_t* ceiling);
|
||||
void P_AddActiveCeiling(ceiling_t* c);
|
||||
void P_RemoveActiveCeiling(ceiling_t* c);
|
||||
int EV_CeilingCrushStop(line_t* line);
|
||||
void P_ActivateInStasisCeiling(line_t* line);
|
||||
|
||||
|
||||
//
|
||||
// P_FLOOR
|
||||
//
|
||||
typedef enum
|
||||
{
|
||||
// lower floor to highest surrounding floor
|
||||
lowerFloor,
|
||||
|
||||
// lower floor to lowest surrounding floor
|
||||
lowerFloorToLowest,
|
||||
|
||||
// lower floor to highest surrounding floor VERY FAST
|
||||
turboLower,
|
||||
|
||||
// raise floor to lowest surrounding CEILING
|
||||
raiseFloor,
|
||||
|
||||
// raise floor to next highest surrounding floor
|
||||
raiseFloorToNearest,
|
||||
|
||||
// raise floor to shortest height texture around it
|
||||
raiseToTexture,
|
||||
|
||||
// lower floor to lowest surrounding floor
|
||||
// and change floorpic
|
||||
lowerAndChange,
|
||||
|
||||
raiseFloor24,
|
||||
raiseFloor24AndChange,
|
||||
raiseFloorCrush,
|
||||
|
||||
// raise to next highest floor, turbo-speed
|
||||
raiseFloorTurbo,
|
||||
donutRaise,
|
||||
raiseFloor512
|
||||
|
||||
} floor_e;
|
||||
|
||||
|
||||
|
||||
|
||||
typedef enum
|
||||
{
|
||||
build8, // slowly build by 8
|
||||
turbo16 // quickly build by 16
|
||||
|
||||
} stair_e;
|
||||
|
||||
|
||||
|
||||
typedef struct
|
||||
{
|
||||
thinker_t thinker;
|
||||
floor_e type;
|
||||
boolean crush;
|
||||
sector_t* sector;
|
||||
int direction;
|
||||
int newspecial;
|
||||
short texture;
|
||||
fixed_t floordestheight;
|
||||
fixed_t speed;
|
||||
|
||||
} floormove_t;
|
||||
|
||||
|
||||
|
||||
#define FLOORSPEED FRACUNIT
|
||||
|
||||
typedef enum
|
||||
{
|
||||
ok,
|
||||
crushed,
|
||||
pastdest
|
||||
|
||||
} result_e;
|
||||
|
||||
result_e
|
||||
T_MovePlane
|
||||
( sector_t* sector,
|
||||
fixed_t speed,
|
||||
fixed_t dest,
|
||||
boolean crush,
|
||||
int floorOrCeiling,
|
||||
int direction );
|
||||
|
||||
int
|
||||
EV_BuildStairs
|
||||
( line_t* line,
|
||||
stair_e type );
|
||||
|
||||
int
|
||||
EV_DoFloor
|
||||
( line_t* line,
|
||||
floor_e floortype );
|
||||
|
||||
void T_MoveFloor( floormove_t* floor);
|
||||
|
||||
//
|
||||
// P_TELEPT
|
||||
//
|
||||
int
|
||||
EV_Teleport
|
||||
( line_t* line,
|
||||
int side,
|
||||
mobj_t* thing );
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,654 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Switches, buttons. Two-state animation. Exits.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_switch.c,v 1.3 1997/01/28 22:08:29 b1 Exp $";
|
||||
|
||||
|
||||
#include "i_system.h"
|
||||
#include "doomdef.h"
|
||||
#include "p_local.h"
|
||||
|
||||
#include "g_game.h"
|
||||
|
||||
#include "s_sound.h"
|
||||
|
||||
// Data.
|
||||
#include "sounds.h"
|
||||
|
||||
// State.
|
||||
#include "doomstat.h"
|
||||
#include "r_state.h"
|
||||
|
||||
|
||||
//
|
||||
// CHANGE THE TEXTURE OF A WALL SWITCH TO ITS OPPOSITE
|
||||
//
|
||||
switchlist_t alphSwitchList[] =
|
||||
{
|
||||
// Doom shareware episode 1 switches
|
||||
{"SW1BRCOM", "SW2BRCOM", 1},
|
||||
{"SW1BRN1", "SW2BRN1", 1},
|
||||
{"SW1BRN2", "SW2BRN2", 1},
|
||||
{"SW1BRNGN", "SW2BRNGN", 1},
|
||||
{"SW1BROWN", "SW2BROWN", 1},
|
||||
{"SW1COMM", "SW2COMM", 1},
|
||||
{"SW1COMP", "SW2COMP", 1},
|
||||
{"SW1DIRT", "SW2DIRT", 1},
|
||||
{"SW1EXIT", "SW2EXIT", 1},
|
||||
{"SW1GRAY", "SW2GRAY", 1},
|
||||
{"SW1GRAY1", "SW2GRAY1", 1},
|
||||
{"SW1METAL", "SW2METAL", 1},
|
||||
{"SW1PIPE", "SW2PIPE", 1},
|
||||
{"SW1SLAD", "SW2SLAD", 1},
|
||||
{"SW1STARG", "SW2STARG", 1},
|
||||
{"SW1STON1", "SW2STON1", 1},
|
||||
{"SW1STON2", "SW2STON2", 1},
|
||||
{"SW1STONE", "SW2STONE", 1},
|
||||
{"SW1STRTN", "SW2STRTN", 1},
|
||||
|
||||
// Doom registered episodes 2&3 switches
|
||||
{"SW1BLUE", "SW2BLUE", 2},
|
||||
{"SW1CMT", "SW2CMT", 2},
|
||||
{"SW1GARG", "SW2GARG", 2},
|
||||
{"SW1GSTON", "SW2GSTON", 2},
|
||||
{"SW1HOT", "SW2HOT", 2},
|
||||
{"SW1LION", "SW2LION", 2},
|
||||
{"SW1SATYR", "SW2SATYR", 2},
|
||||
{"SW1SKIN", "SW2SKIN", 2},
|
||||
{"SW1VINE", "SW2VINE", 2},
|
||||
{"SW1WOOD", "SW2WOOD", 2},
|
||||
|
||||
// Doom II switches
|
||||
{"SW1PANEL", "SW2PANEL", 3},
|
||||
{"SW1ROCK", "SW2ROCK", 3},
|
||||
{"SW1MET2", "SW2MET2", 3},
|
||||
{"SW1WDMET", "SW2WDMET", 3},
|
||||
{"SW1BRIK", "SW2BRIK", 3},
|
||||
{"SW1MOD1", "SW2MOD1", 3},
|
||||
{"SW1ZIM", "SW2ZIM", 3},
|
||||
{"SW1STON6", "SW2STON6", 3},
|
||||
{"SW1TEK", "SW2TEK", 3},
|
||||
{"SW1MARB", "SW2MARB", 3},
|
||||
{"SW1SKULL", "SW2SKULL", 3},
|
||||
|
||||
{"\0", "\0", 0}
|
||||
};
|
||||
|
||||
int switchlist[MAXSWITCHES * 2];
|
||||
int numswitches;
|
||||
button_t buttonlist[MAXBUTTONS];
|
||||
|
||||
//
|
||||
// P_InitSwitchList
|
||||
// Only called at game initialization.
|
||||
//
|
||||
void P_InitSwitchList(void)
|
||||
{
|
||||
int i;
|
||||
int index;
|
||||
int episode;
|
||||
|
||||
episode = 1;
|
||||
|
||||
if (gamemode == registered)
|
||||
episode = 2;
|
||||
else
|
||||
if ( gamemode == commercial )
|
||||
episode = 3;
|
||||
|
||||
for (index = 0,i = 0;i < MAXSWITCHES;i++)
|
||||
{
|
||||
if (!alphSwitchList[i].episode)
|
||||
{
|
||||
numswitches = index/2;
|
||||
switchlist[index] = -1;
|
||||
break;
|
||||
}
|
||||
|
||||
if (alphSwitchList[i].episode <= episode)
|
||||
{
|
||||
#if 0 // UNUSED - debug?
|
||||
int value;
|
||||
|
||||
if (R_CheckTextureNumForName(alphSwitchList[i].name1) < 0)
|
||||
{
|
||||
I_Error("Can't find switch texture '%s'!",
|
||||
alphSwitchList[i].name1);
|
||||
continue;
|
||||
}
|
||||
|
||||
value = R_TextureNumForName(alphSwitchList[i].name1);
|
||||
#endif
|
||||
switchlist[index++] = R_TextureNumForName(alphSwitchList[i].name1);
|
||||
switchlist[index++] = R_TextureNumForName(alphSwitchList[i].name2);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Start a button counting down till it turns off.
|
||||
//
|
||||
void
|
||||
P_StartButton
|
||||
( line_t* line,
|
||||
bwhere_e w,
|
||||
int texture,
|
||||
int time )
|
||||
{
|
||||
int i;
|
||||
|
||||
// See if button is already pressed
|
||||
for (i = 0;i < MAXBUTTONS;i++)
|
||||
{
|
||||
if (buttonlist[i].btimer
|
||||
&& buttonlist[i].line == line)
|
||||
{
|
||||
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
for (i = 0;i < MAXBUTTONS;i++)
|
||||
{
|
||||
if (!buttonlist[i].btimer)
|
||||
{
|
||||
buttonlist[i].line = line;
|
||||
buttonlist[i].where = w;
|
||||
buttonlist[i].btexture = texture;
|
||||
buttonlist[i].btimer = time;
|
||||
buttonlist[i].soundorg = (mobj_t *)&line->frontsector->soundorg;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
I_Error("P_StartButton: no button slots left!");
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Function that changes wall texture.
|
||||
// Tell it if switch is ok to use again (1=yes, it's a button).
|
||||
//
|
||||
void
|
||||
P_ChangeSwitchTexture
|
||||
( line_t* line,
|
||||
int useAgain )
|
||||
{
|
||||
int texTop;
|
||||
int texMid;
|
||||
int texBot;
|
||||
int i;
|
||||
int sound;
|
||||
|
||||
if (!useAgain)
|
||||
line->special = 0;
|
||||
|
||||
texTop = sides[line->sidenum[0]].toptexture;
|
||||
texMid = sides[line->sidenum[0]].midtexture;
|
||||
texBot = sides[line->sidenum[0]].bottomtexture;
|
||||
|
||||
sound = sfx_swtchn;
|
||||
|
||||
// EXIT SWITCH?
|
||||
if (line->special == 11)
|
||||
sound = sfx_swtchx;
|
||||
|
||||
for (i = 0;i < numswitches*2;i++)
|
||||
{
|
||||
if (switchlist[i] == texTop)
|
||||
{
|
||||
S_StartSound(buttonlist->soundorg,sound);
|
||||
sides[line->sidenum[0]].toptexture = switchlist[i^1];
|
||||
|
||||
if (useAgain)
|
||||
P_StartButton(line,top,switchlist[i],BUTTONTIME);
|
||||
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (switchlist[i] == texMid)
|
||||
{
|
||||
S_StartSound(buttonlist->soundorg,sound);
|
||||
sides[line->sidenum[0]].midtexture = switchlist[i^1];
|
||||
|
||||
if (useAgain)
|
||||
P_StartButton(line, middle,switchlist[i],BUTTONTIME);
|
||||
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (switchlist[i] == texBot)
|
||||
{
|
||||
S_StartSound(buttonlist->soundorg,sound);
|
||||
sides[line->sidenum[0]].bottomtexture = switchlist[i^1];
|
||||
|
||||
if (useAgain)
|
||||
P_StartButton(line, bottom,switchlist[i],BUTTONTIME);
|
||||
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_UseSpecialLine
|
||||
// Called when a thing uses a special line.
|
||||
// Only the front sides of lines are usable.
|
||||
//
|
||||
boolean
|
||||
P_UseSpecialLine
|
||||
( mobj_t* thing,
|
||||
line_t* line,
|
||||
int side )
|
||||
{
|
||||
|
||||
// Err...
|
||||
// Use the back sides of VERY SPECIAL lines...
|
||||
if (side)
|
||||
{
|
||||
switch(line->special)
|
||||
{
|
||||
case 124:
|
||||
// Sliding door open&close
|
||||
// UNUSED?
|
||||
break;
|
||||
|
||||
default:
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Switches that other things can activate.
|
||||
if (!thing->player)
|
||||
{
|
||||
// never open secret doors
|
||||
if (line->flags & ML_SECRET)
|
||||
return false;
|
||||
|
||||
switch(line->special)
|
||||
{
|
||||
case 1: // MANUAL DOOR RAISE
|
||||
case 32: // MANUAL BLUE
|
||||
case 33: // MANUAL RED
|
||||
case 34: // MANUAL YELLOW
|
||||
break;
|
||||
|
||||
default:
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// do something
|
||||
switch (line->special)
|
||||
{
|
||||
// MANUALS
|
||||
case 1: // Vertical Door
|
||||
case 26: // Blue Door/Locked
|
||||
case 27: // Yellow Door /Locked
|
||||
case 28: // Red Door /Locked
|
||||
|
||||
case 31: // Manual door open
|
||||
case 32: // Blue locked door open
|
||||
case 33: // Red locked door open
|
||||
case 34: // Yellow locked door open
|
||||
|
||||
case 117: // Blazing door raise
|
||||
case 118: // Blazing door open
|
||||
EV_VerticalDoor (line, thing);
|
||||
break;
|
||||
|
||||
//UNUSED - Door Slide Open&Close
|
||||
// case 124:
|
||||
// EV_SlidingDoor (line, thing);
|
||||
// break;
|
||||
|
||||
// SWITCHES
|
||||
case 7:
|
||||
// Build Stairs
|
||||
if (EV_BuildStairs(line,build8))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 9:
|
||||
// Change Donut
|
||||
if (EV_DoDonut(line))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 11:
|
||||
// Exit level
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
G_ExitLevel ();
|
||||
break;
|
||||
|
||||
case 14:
|
||||
// Raise Floor 32 and change texture
|
||||
if (EV_DoPlat(line,raiseAndChange,32))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 15:
|
||||
// Raise Floor 24 and change texture
|
||||
if (EV_DoPlat(line,raiseAndChange,24))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 18:
|
||||
// Raise Floor to next highest floor
|
||||
if (EV_DoFloor(line, raiseFloorToNearest))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 20:
|
||||
// Raise Plat next highest floor and change texture
|
||||
if (EV_DoPlat(line,raiseToNearestAndChange,0))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 21:
|
||||
// PlatDownWaitUpStay
|
||||
if (EV_DoPlat(line,downWaitUpStay,0))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 23:
|
||||
// Lower Floor to Lowest
|
||||
if (EV_DoFloor(line,lowerFloorToLowest))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 29:
|
||||
// Raise Door
|
||||
if (EV_DoDoor(line,normal))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 41:
|
||||
// Lower Ceiling to Floor
|
||||
if (EV_DoCeiling(line,lowerToFloor))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 71:
|
||||
// Turbo Lower Floor
|
||||
if (EV_DoFloor(line,turboLower))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 49:
|
||||
// Ceiling Crush And Raise
|
||||
if (EV_DoCeiling(line,crushAndRaise))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 50:
|
||||
// Close Door
|
||||
if (EV_DoDoor(line,close))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 51:
|
||||
// Secret EXIT
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
G_SecretExitLevel ();
|
||||
break;
|
||||
|
||||
case 55:
|
||||
// Raise Floor Crush
|
||||
if (EV_DoFloor(line,raiseFloorCrush))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 101:
|
||||
// Raise Floor
|
||||
if (EV_DoFloor(line,raiseFloor))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 102:
|
||||
// Lower Floor to Surrounding floor height
|
||||
if (EV_DoFloor(line,lowerFloor))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 103:
|
||||
// Open Door
|
||||
if (EV_DoDoor(line,open))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 111:
|
||||
// Blazing Door Raise (faster than TURBO!)
|
||||
if (EV_DoDoor (line,blazeRaise))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 112:
|
||||
// Blazing Door Open (faster than TURBO!)
|
||||
if (EV_DoDoor (line,blazeOpen))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 113:
|
||||
// Blazing Door Close (faster than TURBO!)
|
||||
if (EV_DoDoor (line,blazeClose))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 122:
|
||||
// Blazing PlatDownWaitUpStay
|
||||
if (EV_DoPlat(line,blazeDWUS,0))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 127:
|
||||
// Build Stairs Turbo 16
|
||||
if (EV_BuildStairs(line,turbo16))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 131:
|
||||
// Raise Floor Turbo
|
||||
if (EV_DoFloor(line,raiseFloorTurbo))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 133:
|
||||
// BlzOpenDoor BLUE
|
||||
case 135:
|
||||
// BlzOpenDoor RED
|
||||
case 137:
|
||||
// BlzOpenDoor YELLOW
|
||||
if (EV_DoLockedDoor (line,blazeOpen,thing))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
case 140:
|
||||
// Raise Floor 512
|
||||
if (EV_DoFloor(line,raiseFloor512))
|
||||
P_ChangeSwitchTexture(line,0);
|
||||
break;
|
||||
|
||||
// BUTTONS
|
||||
case 42:
|
||||
// Close Door
|
||||
if (EV_DoDoor(line,close))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 43:
|
||||
// Lower Ceiling to Floor
|
||||
if (EV_DoCeiling(line,lowerToFloor))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 45:
|
||||
// Lower Floor to Surrounding floor height
|
||||
if (EV_DoFloor(line,lowerFloor))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 60:
|
||||
// Lower Floor to Lowest
|
||||
if (EV_DoFloor(line,lowerFloorToLowest))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 61:
|
||||
// Open Door
|
||||
if (EV_DoDoor(line,open))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 62:
|
||||
// PlatDownWaitUpStay
|
||||
if (EV_DoPlat(line,downWaitUpStay,1))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 63:
|
||||
// Raise Door
|
||||
if (EV_DoDoor(line,normal))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 64:
|
||||
// Raise Floor to ceiling
|
||||
if (EV_DoFloor(line,raiseFloor))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 66:
|
||||
// Raise Floor 24 and change texture
|
||||
if (EV_DoPlat(line,raiseAndChange,24))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 67:
|
||||
// Raise Floor 32 and change texture
|
||||
if (EV_DoPlat(line,raiseAndChange,32))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 65:
|
||||
// Raise Floor Crush
|
||||
if (EV_DoFloor(line,raiseFloorCrush))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 68:
|
||||
// Raise Plat to next highest floor and change texture
|
||||
if (EV_DoPlat(line,raiseToNearestAndChange,0))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 69:
|
||||
// Raise Floor to next highest floor
|
||||
if (EV_DoFloor(line, raiseFloorToNearest))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 70:
|
||||
// Turbo Lower Floor
|
||||
if (EV_DoFloor(line,turboLower))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 114:
|
||||
// Blazing Door Raise (faster than TURBO!)
|
||||
if (EV_DoDoor (line,blazeRaise))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 115:
|
||||
// Blazing Door Open (faster than TURBO!)
|
||||
if (EV_DoDoor (line,blazeOpen))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 116:
|
||||
// Blazing Door Close (faster than TURBO!)
|
||||
if (EV_DoDoor (line,blazeClose))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 123:
|
||||
// Blazing PlatDownWaitUpStay
|
||||
if (EV_DoPlat(line,blazeDWUS,0))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 132:
|
||||
// Raise Floor Turbo
|
||||
if (EV_DoFloor(line,raiseFloorTurbo))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 99:
|
||||
// BlzOpenDoor BLUE
|
||||
case 134:
|
||||
// BlzOpenDoor RED
|
||||
case 136:
|
||||
// BlzOpenDoor YELLOW
|
||||
if (EV_DoLockedDoor (line,blazeOpen,thing))
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 138:
|
||||
// Light Turn On
|
||||
EV_LightTurnOn(line,255);
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
case 139:
|
||||
// Light Turn Off
|
||||
EV_LightTurnOn(line,35);
|
||||
P_ChangeSwitchTexture(line,1);
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,132 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Teleportation.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_telept.c,v 1.3 1997/01/28 22:08:29 b1 Exp $";
|
||||
|
||||
|
||||
|
||||
#include "doomdef.h"
|
||||
|
||||
#include "s_sound.h"
|
||||
|
||||
#include "p_local.h"
|
||||
|
||||
|
||||
// Data.
|
||||
#include "sounds.h"
|
||||
|
||||
// State.
|
||||
#include "r_state.h"
|
||||
|
||||
|
||||
|
||||
//
|
||||
// TELEPORTATION
|
||||
//
|
||||
int
|
||||
EV_Teleport
|
||||
( line_t* line,
|
||||
int side,
|
||||
mobj_t* thing )
|
||||
{
|
||||
int i;
|
||||
int tag;
|
||||
mobj_t* m;
|
||||
mobj_t* fog;
|
||||
unsigned an;
|
||||
thinker_t* thinker;
|
||||
sector_t* sector;
|
||||
fixed_t oldx;
|
||||
fixed_t oldy;
|
||||
fixed_t oldz;
|
||||
|
||||
// don't teleport missiles
|
||||
if (thing->flags & MF_MISSILE)
|
||||
return 0;
|
||||
|
||||
// Don't teleport if hit back of line,
|
||||
// so you can get out of teleporter.
|
||||
if (side == 1)
|
||||
return 0;
|
||||
|
||||
|
||||
tag = line->tag;
|
||||
for (i = 0; i < numsectors; i++)
|
||||
{
|
||||
if (sectors[ i ].tag == tag )
|
||||
{
|
||||
thinker = thinkercap.next;
|
||||
for (thinker = thinkercap.next;
|
||||
thinker != &thinkercap;
|
||||
thinker = thinker->next)
|
||||
{
|
||||
// not a mobj
|
||||
if (thinker->function.acp1 != (actionf_p1)P_MobjThinker)
|
||||
continue;
|
||||
|
||||
m = (mobj_t *)thinker;
|
||||
|
||||
// not a teleportman
|
||||
if (m->type != MT_TELEPORTMAN )
|
||||
continue;
|
||||
|
||||
sector = m->subsector->sector;
|
||||
// wrong sector
|
||||
if (sector-sectors != i )
|
||||
continue;
|
||||
|
||||
oldx = thing->x;
|
||||
oldy = thing->y;
|
||||
oldz = thing->z;
|
||||
|
||||
if (!P_TeleportMove (thing, m->x, m->y))
|
||||
return 0;
|
||||
|
||||
thing->z = thing->floorz; //fixme: not needed?
|
||||
if (thing->player)
|
||||
thing->player->viewz = thing->z+thing->player->viewheight;
|
||||
|
||||
// spawn teleport fog at source and destination
|
||||
fog = P_SpawnMobj (oldx, oldy, oldz, MT_TFOG);
|
||||
S_StartSound (fog, sfx_telept);
|
||||
an = m->angle >> ANGLETOFINESHIFT;
|
||||
fog = P_SpawnMobj (m->x+20*finecosine[an], m->y+20*finesine[an]
|
||||
, thing->z, MT_TFOG);
|
||||
|
||||
// emit sound, where?
|
||||
S_StartSound (fog, sfx_telept);
|
||||
|
||||
// don't move for a bit
|
||||
if (thing->player)
|
||||
thing->reactiontime = 18;
|
||||
|
||||
thing->angle = m->angle;
|
||||
thing->momx = thing->momy = thing->momz = 0;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,158 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Archiving: SaveGame I/O.
|
||||
// Thinker, Ticker.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_tick.c,v 1.4 1997/02/03 16:47:55 b1 Exp $";
|
||||
|
||||
#include "z_zone.h"
|
||||
#include "p_local.h"
|
||||
|
||||
#include "doomstat.h"
|
||||
|
||||
|
||||
int leveltime;
|
||||
|
||||
//
|
||||
// THINKERS
|
||||
// All thinkers should be allocated by Z_Malloc
|
||||
// so they can be operated on uniformly.
|
||||
// The actual structures will vary in size,
|
||||
// but the first element must be thinker_t.
|
||||
//
|
||||
|
||||
|
||||
|
||||
// Both the head and tail of the thinker list.
|
||||
thinker_t thinkercap;
|
||||
|
||||
|
||||
//
|
||||
// P_InitThinkers
|
||||
//
|
||||
void P_InitThinkers (void)
|
||||
{
|
||||
thinkercap.prev = thinkercap.next = &thinkercap;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_AddThinker
|
||||
// Adds a new thinker at the end of the list.
|
||||
//
|
||||
void P_AddThinker (thinker_t* thinker)
|
||||
{
|
||||
thinkercap.prev->next = thinker;
|
||||
thinker->next = &thinkercap;
|
||||
thinker->prev = thinkercap.prev;
|
||||
thinkercap.prev = thinker;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_RemoveThinker
|
||||
// Deallocation is lazy -- it will not actually be freed
|
||||
// until its thinking turn comes up.
|
||||
//
|
||||
void P_RemoveThinker (thinker_t* thinker)
|
||||
{
|
||||
// FIXME: NOP.
|
||||
thinker->function.acv = (actionf_v)(-1);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_AllocateThinker
|
||||
// Allocates memory and adds a new thinker at the end of the list.
|
||||
//
|
||||
void P_AllocateThinker (thinker_t* thinker)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_RunThinkers
|
||||
//
|
||||
void P_RunThinkers (void)
|
||||
{
|
||||
thinker_t* currentthinker;
|
||||
|
||||
currentthinker = thinkercap.next;
|
||||
while (currentthinker != &thinkercap)
|
||||
{
|
||||
if ( currentthinker->function.acv == (actionf_v)(-1) )
|
||||
{
|
||||
// time to remove it
|
||||
currentthinker->next->prev = currentthinker->prev;
|
||||
currentthinker->prev->next = currentthinker->next;
|
||||
Z_Free (currentthinker);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (currentthinker->function.acp1)
|
||||
currentthinker->function.acp1 (currentthinker);
|
||||
}
|
||||
currentthinker = currentthinker->next;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_Ticker
|
||||
//
|
||||
|
||||
void P_Ticker (void)
|
||||
{
|
||||
int i;
|
||||
|
||||
// run the tic
|
||||
if (paused)
|
||||
return;
|
||||
|
||||
// pause if in menu and at least one tic has been run
|
||||
if ( !netgame
|
||||
&& menuactive
|
||||
&& !demoplayback
|
||||
&& players[consoleplayer].viewz != 1)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
for (i=0 ; i<MAXPLAYERS ; i++)
|
||||
if (playeringame[i])
|
||||
P_PlayerThink (&players[i]);
|
||||
|
||||
P_RunThinkers ();
|
||||
P_UpdateSpecials ();
|
||||
P_RespawnSpecials ();
|
||||
|
||||
// for par times
|
||||
leveltime++;
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// ?
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __P_TICK__
|
||||
#define __P_TICK__
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
// Called by C_Ticker,
|
||||
// can call G_PlayerExited.
|
||||
// Carries out all thinking of monsters and players.
|
||||
void P_Ticker (void);
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,386 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Player related stuff.
|
||||
// Bobbing POV/weapon, movement.
|
||||
// Pending weapon.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: p_user.c,v 1.3 1997/01/28 22:08:29 b1 Exp $";
|
||||
|
||||
|
||||
#include "doomdef.h"
|
||||
#include "d_event.h"
|
||||
|
||||
#include "p_local.h"
|
||||
|
||||
#include "doomstat.h"
|
||||
|
||||
|
||||
|
||||
// Index of the special effects (INVUL inverse) map.
|
||||
#define INVERSECOLORMAP 32
|
||||
|
||||
|
||||
//
|
||||
// Movement.
|
||||
//
|
||||
|
||||
// 16 pixels of bob
|
||||
#define MAXBOB 0x100000
|
||||
|
||||
boolean onground;
|
||||
|
||||
|
||||
//
|
||||
// P_Thrust
|
||||
// Moves the given origin along a given angle.
|
||||
//
|
||||
void
|
||||
P_Thrust
|
||||
( player_t* player,
|
||||
angle_t angle,
|
||||
fixed_t move )
|
||||
{
|
||||
angle >>= ANGLETOFINESHIFT;
|
||||
|
||||
player->mo->momx += FixedMul(move,finecosine[angle]);
|
||||
player->mo->momy += FixedMul(move,finesine[angle]);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_CalcHeight
|
||||
// Calculate the walking / running height adjustment
|
||||
//
|
||||
void P_CalcHeight (player_t* player)
|
||||
{
|
||||
int angle;
|
||||
fixed_t bob;
|
||||
|
||||
// Regular movement bobbing
|
||||
// (needs to be calculated for gun swing
|
||||
// even if not on ground)
|
||||
// OPTIMIZE: tablify angle
|
||||
// Note: a LUT allows for effects
|
||||
// like a ramp with low health.
|
||||
player->bob =
|
||||
FixedMul (player->mo->momx, player->mo->momx)
|
||||
+ FixedMul (player->mo->momy,player->mo->momy);
|
||||
|
||||
player->bob >>= 2;
|
||||
|
||||
if (player->bob>MAXBOB)
|
||||
player->bob = MAXBOB;
|
||||
|
||||
if ((player->cheats & CF_NOMOMENTUM) || !onground)
|
||||
{
|
||||
player->viewz = player->mo->z + VIEWHEIGHT;
|
||||
|
||||
if (player->viewz > player->mo->ceilingz-4*FRACUNIT)
|
||||
player->viewz = player->mo->ceilingz-4*FRACUNIT;
|
||||
|
||||
player->viewz = player->mo->z + player->viewheight;
|
||||
return;
|
||||
}
|
||||
|
||||
angle = (FINEANGLES/20*leveltime)&FINEMASK;
|
||||
bob = FixedMul ( player->bob/2, finesine[angle]);
|
||||
|
||||
|
||||
// move viewheight
|
||||
if (player->playerstate == PST_LIVE)
|
||||
{
|
||||
player->viewheight += player->deltaviewheight;
|
||||
|
||||
if (player->viewheight > VIEWHEIGHT)
|
||||
{
|
||||
player->viewheight = VIEWHEIGHT;
|
||||
player->deltaviewheight = 0;
|
||||
}
|
||||
|
||||
if (player->viewheight < VIEWHEIGHT/2)
|
||||
{
|
||||
player->viewheight = VIEWHEIGHT/2;
|
||||
if (player->deltaviewheight <= 0)
|
||||
player->deltaviewheight = 1;
|
||||
}
|
||||
|
||||
if (player->deltaviewheight)
|
||||
{
|
||||
player->deltaviewheight += FRACUNIT/4;
|
||||
if (!player->deltaviewheight)
|
||||
player->deltaviewheight = 1;
|
||||
}
|
||||
}
|
||||
player->viewz = player->mo->z + player->viewheight + bob;
|
||||
|
||||
if (player->viewz > player->mo->ceilingz-4*FRACUNIT)
|
||||
player->viewz = player->mo->ceilingz-4*FRACUNIT;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_MovePlayer
|
||||
//
|
||||
void P_MovePlayer (player_t* player)
|
||||
{
|
||||
ticcmd_t* cmd;
|
||||
|
||||
cmd = &player->cmd;
|
||||
|
||||
player->mo->angle += (cmd->angleturn<<16);
|
||||
|
||||
// Do not let the player control movement
|
||||
// if not onground.
|
||||
onground = (player->mo->z <= player->mo->floorz);
|
||||
|
||||
if (cmd->forwardmove && onground)
|
||||
P_Thrust (player, player->mo->angle, cmd->forwardmove*2048);
|
||||
|
||||
if (cmd->sidemove && onground)
|
||||
P_Thrust (player, player->mo->angle-ANG90, cmd->sidemove*2048);
|
||||
|
||||
if ( (cmd->forwardmove || cmd->sidemove)
|
||||
&& player->mo->state == &states[S_PLAY] )
|
||||
{
|
||||
P_SetMobjState (player->mo, S_PLAY_RUN1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_DeathThink
|
||||
// Fall on your face when dying.
|
||||
// Decrease POV height to floor height.
|
||||
//
|
||||
#define ANG5 (ANG90/18)
|
||||
|
||||
void P_DeathThink (player_t* player)
|
||||
{
|
||||
angle_t angle;
|
||||
angle_t delta;
|
||||
|
||||
P_MovePsprites (player);
|
||||
|
||||
// fall to the ground
|
||||
if (player->viewheight > 6*FRACUNIT)
|
||||
player->viewheight -= FRACUNIT;
|
||||
|
||||
if (player->viewheight < 6*FRACUNIT)
|
||||
player->viewheight = 6*FRACUNIT;
|
||||
|
||||
player->deltaviewheight = 0;
|
||||
onground = (player->mo->z <= player->mo->floorz);
|
||||
P_CalcHeight (player);
|
||||
|
||||
if (player->attacker && player->attacker != player->mo)
|
||||
{
|
||||
angle = R_PointToAngle2 (player->mo->x,
|
||||
player->mo->y,
|
||||
player->attacker->x,
|
||||
player->attacker->y);
|
||||
|
||||
delta = angle - player->mo->angle;
|
||||
|
||||
if (delta < ANG5 || delta > (unsigned)-ANG5)
|
||||
{
|
||||
// Looking at killer,
|
||||
// so fade damage flash down.
|
||||
player->mo->angle = angle;
|
||||
|
||||
if (player->damagecount)
|
||||
player->damagecount--;
|
||||
}
|
||||
else if (delta < ANG180)
|
||||
player->mo->angle += ANG5;
|
||||
else
|
||||
player->mo->angle -= ANG5;
|
||||
}
|
||||
else if (player->damagecount)
|
||||
player->damagecount--;
|
||||
|
||||
|
||||
if (player->cmd.buttons & BT_USE)
|
||||
player->playerstate = PST_REBORN;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// P_PlayerThink
|
||||
//
|
||||
void P_PlayerThink (player_t* player)
|
||||
{
|
||||
ticcmd_t* cmd;
|
||||
weapontype_t newweapon;
|
||||
|
||||
// fixme: do this in the cheat code
|
||||
if (player->cheats & CF_NOCLIP)
|
||||
player->mo->flags |= MF_NOCLIP;
|
||||
else
|
||||
player->mo->flags &= ~MF_NOCLIP;
|
||||
|
||||
// chain saw run forward
|
||||
cmd = &player->cmd;
|
||||
if (player->mo->flags & MF_JUSTATTACKED)
|
||||
{
|
||||
cmd->angleturn = 0;
|
||||
cmd->forwardmove = 0xc800/512;
|
||||
cmd->sidemove = 0;
|
||||
player->mo->flags &= ~MF_JUSTATTACKED;
|
||||
}
|
||||
|
||||
|
||||
if (player->playerstate == PST_DEAD)
|
||||
{
|
||||
P_DeathThink (player);
|
||||
return;
|
||||
}
|
||||
|
||||
// Move around.
|
||||
// Reactiontime is used to prevent movement
|
||||
// for a bit after a teleport.
|
||||
if (player->mo->reactiontime)
|
||||
player->mo->reactiontime--;
|
||||
else
|
||||
P_MovePlayer (player);
|
||||
|
||||
P_CalcHeight (player);
|
||||
|
||||
if (player->mo->subsector->sector->special)
|
||||
P_PlayerInSpecialSector (player);
|
||||
|
||||
// Check for weapon change.
|
||||
|
||||
// A special event has no other buttons.
|
||||
if (cmd->buttons & BT_SPECIAL)
|
||||
cmd->buttons = 0;
|
||||
|
||||
if (cmd->buttons & BT_CHANGE)
|
||||
{
|
||||
// The actual changing of the weapon is done
|
||||
// when the weapon psprite can do it
|
||||
// (read: not in the middle of an attack).
|
||||
newweapon = (cmd->buttons&BT_WEAPONMASK)>>BT_WEAPONSHIFT;
|
||||
|
||||
if (newweapon == wp_fist
|
||||
&& player->weaponowned[wp_chainsaw]
|
||||
&& !(player->readyweapon == wp_chainsaw
|
||||
&& player->powers[pw_strength]))
|
||||
{
|
||||
newweapon = wp_chainsaw;
|
||||
}
|
||||
|
||||
if ( (gamemode == commercial)
|
||||
&& newweapon == wp_shotgun
|
||||
&& player->weaponowned[wp_supershotgun]
|
||||
&& player->readyweapon != wp_supershotgun)
|
||||
{
|
||||
newweapon = wp_supershotgun;
|
||||
}
|
||||
|
||||
|
||||
if (player->weaponowned[newweapon]
|
||||
&& newweapon != player->readyweapon)
|
||||
{
|
||||
// Do not go to plasma or BFG in shareware,
|
||||
// even if cheated.
|
||||
if ((newweapon != wp_plasma
|
||||
&& newweapon != wp_bfg)
|
||||
|| (gamemode != shareware) )
|
||||
{
|
||||
player->pendingweapon = newweapon;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// check for use
|
||||
if (cmd->buttons & BT_USE)
|
||||
{
|
||||
if (!player->usedown)
|
||||
{
|
||||
P_UseLines (player);
|
||||
player->usedown = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
player->usedown = false;
|
||||
|
||||
// cycle psprites
|
||||
P_MovePsprites (player);
|
||||
|
||||
// Counters, time dependend power ups.
|
||||
|
||||
// Strength counts up to diminish fade.
|
||||
if (player->powers[pw_strength])
|
||||
player->powers[pw_strength]++;
|
||||
|
||||
if (player->powers[pw_invulnerability])
|
||||
player->powers[pw_invulnerability]--;
|
||||
|
||||
if (player->powers[pw_invisibility])
|
||||
if (! --player->powers[pw_invisibility] )
|
||||
player->mo->flags &= ~MF_SHADOW;
|
||||
|
||||
if (player->powers[pw_infrared])
|
||||
player->powers[pw_infrared]--;
|
||||
|
||||
if (player->powers[pw_ironfeet])
|
||||
player->powers[pw_ironfeet]--;
|
||||
|
||||
if (player->damagecount)
|
||||
player->damagecount--;
|
||||
|
||||
if (player->bonuscount)
|
||||
player->bonuscount--;
|
||||
|
||||
|
||||
// Handling colormaps.
|
||||
if (player->powers[pw_invulnerability])
|
||||
{
|
||||
if (player->powers[pw_invulnerability] > 4*32
|
||||
|| (player->powers[pw_invulnerability]&8) )
|
||||
player->fixedcolormap = INVERSECOLORMAP;
|
||||
else
|
||||
player->fixedcolormap = 0;
|
||||
}
|
||||
else if (player->powers[pw_infrared])
|
||||
{
|
||||
if (player->powers[pw_infrared] > 4*32
|
||||
|| (player->powers[pw_infrared]&8) )
|
||||
{
|
||||
// almost full bright
|
||||
player->fixedcolormap = 1;
|
||||
}
|
||||
else
|
||||
player->fixedcolormap = 0;
|
||||
}
|
||||
else
|
||||
player->fixedcolormap = 0;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,580 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// BSP traversal, handling of LineSegs for rendering.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: r_bsp.c,v 1.4 1997/02/03 22:45:12 b1 Exp $";
|
||||
|
||||
|
||||
#include "doomdef.h"
|
||||
|
||||
#include "m_bbox.h"
|
||||
|
||||
#include "i_system.h"
|
||||
|
||||
#include "r_main.h"
|
||||
#include "r_plane.h"
|
||||
#include "r_things.h"
|
||||
|
||||
// State.
|
||||
#include "doomstat.h"
|
||||
#include "r_state.h"
|
||||
|
||||
//#include "r_local.h"
|
||||
|
||||
|
||||
|
||||
seg_t* curline;
|
||||
side_t* sidedef;
|
||||
line_t* linedef;
|
||||
sector_t* frontsector;
|
||||
sector_t* backsector;
|
||||
|
||||
drawseg_t drawsegs[MAXDRAWSEGS];
|
||||
drawseg_t* ds_p;
|
||||
|
||||
|
||||
void
|
||||
R_StoreWallRange
|
||||
( int start,
|
||||
int stop );
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_ClearDrawSegs
|
||||
//
|
||||
void R_ClearDrawSegs (void)
|
||||
{
|
||||
ds_p = drawsegs;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// ClipWallSegment
|
||||
// Clips the given range of columns
|
||||
// and includes it in the new clip list.
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
int first;
|
||||
int last;
|
||||
|
||||
} cliprange_t;
|
||||
|
||||
|
||||
#define MAXSEGS 256
|
||||
|
||||
// newend is one past the last valid seg
|
||||
cliprange_t* newend;
|
||||
cliprange_t solidsegs[MAXSEGS];
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_ClipSolidWallSegment
|
||||
// Does handle solid walls,
|
||||
// e.g. single sided LineDefs (middle texture)
|
||||
// that entirely block the view.
|
||||
//
|
||||
void
|
||||
R_ClipSolidWallSegment
|
||||
( int first,
|
||||
int last )
|
||||
{
|
||||
cliprange_t* next;
|
||||
cliprange_t* start;
|
||||
|
||||
// Find the first range that touches the range
|
||||
// (adjacent pixels are touching).
|
||||
start = solidsegs;
|
||||
while (start->last < first-1)
|
||||
start++;
|
||||
|
||||
if (first < start->first)
|
||||
{
|
||||
if (last < start->first-1)
|
||||
{
|
||||
// Post is entirely visible (above start),
|
||||
// so insert a new clippost.
|
||||
R_StoreWallRange (first, last);
|
||||
next = newend;
|
||||
newend++;
|
||||
|
||||
while (next != start)
|
||||
{
|
||||
*next = *(next-1);
|
||||
next--;
|
||||
}
|
||||
next->first = first;
|
||||
next->last = last;
|
||||
return;
|
||||
}
|
||||
|
||||
// There is a fragment above *start.
|
||||
R_StoreWallRange (first, start->first - 1);
|
||||
// Now adjust the clip size.
|
||||
start->first = first;
|
||||
}
|
||||
|
||||
// Bottom contained in start?
|
||||
if (last <= start->last)
|
||||
return;
|
||||
|
||||
next = start;
|
||||
while (last >= (next+1)->first-1)
|
||||
{
|
||||
// There is a fragment between two posts.
|
||||
R_StoreWallRange (next->last + 1, (next+1)->first - 1);
|
||||
next++;
|
||||
|
||||
if (last <= next->last)
|
||||
{
|
||||
// Bottom is contained in next.
|
||||
// Adjust the clip size.
|
||||
start->last = next->last;
|
||||
goto crunch;
|
||||
}
|
||||
}
|
||||
|
||||
// There is a fragment after *next.
|
||||
R_StoreWallRange (next->last + 1, last);
|
||||
// Adjust the clip size.
|
||||
start->last = last;
|
||||
|
||||
// Remove start+1 to next from the clip list,
|
||||
// because start now covers their area.
|
||||
crunch:
|
||||
if (next == start)
|
||||
{
|
||||
// Post just extended past the bottom of one post.
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
while (next++ != newend)
|
||||
{
|
||||
// Remove a post.
|
||||
*++start = *next;
|
||||
}
|
||||
|
||||
newend = start+1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_ClipPassWallSegment
|
||||
// Clips the given range of columns,
|
||||
// but does not includes it in the clip list.
|
||||
// Does handle windows,
|
||||
// e.g. LineDefs with upper and lower texture.
|
||||
//
|
||||
void
|
||||
R_ClipPassWallSegment
|
||||
( int first,
|
||||
int last )
|
||||
{
|
||||
cliprange_t* start;
|
||||
|
||||
// Find the first range that touches the range
|
||||
// (adjacent pixels are touching).
|
||||
start = solidsegs;
|
||||
while (start->last < first-1)
|
||||
start++;
|
||||
|
||||
if (first < start->first)
|
||||
{
|
||||
if (last < start->first-1)
|
||||
{
|
||||
// Post is entirely visible (above start).
|
||||
R_StoreWallRange (first, last);
|
||||
return;
|
||||
}
|
||||
|
||||
// There is a fragment above *start.
|
||||
R_StoreWallRange (first, start->first - 1);
|
||||
}
|
||||
|
||||
// Bottom contained in start?
|
||||
if (last <= start->last)
|
||||
return;
|
||||
|
||||
while (last >= (start+1)->first-1)
|
||||
{
|
||||
// There is a fragment between two posts.
|
||||
R_StoreWallRange (start->last + 1, (start+1)->first - 1);
|
||||
start++;
|
||||
|
||||
if (last <= start->last)
|
||||
return;
|
||||
}
|
||||
|
||||
// There is a fragment after *next.
|
||||
R_StoreWallRange (start->last + 1, last);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_ClearClipSegs
|
||||
//
|
||||
void R_ClearClipSegs (void)
|
||||
{
|
||||
solidsegs[0].first = -0x7fffffff;
|
||||
solidsegs[0].last = -1;
|
||||
solidsegs[1].first = viewwidth;
|
||||
solidsegs[1].last = 0x7fffffff;
|
||||
newend = solidsegs+2;
|
||||
}
|
||||
|
||||
//
|
||||
// R_AddLine
|
||||
// Clips the given segment
|
||||
// and adds any visible pieces to the line list.
|
||||
//
|
||||
void R_AddLine (seg_t* line)
|
||||
{
|
||||
int x1;
|
||||
int x2;
|
||||
angle_t angle1;
|
||||
angle_t angle2;
|
||||
angle_t span;
|
||||
angle_t tspan;
|
||||
|
||||
curline = line;
|
||||
|
||||
// OPTIMIZE: quickly reject orthogonal back sides.
|
||||
angle1 = R_PointToAngle (line->v1->x, line->v1->y);
|
||||
angle2 = R_PointToAngle (line->v2->x, line->v2->y);
|
||||
|
||||
// Clip to view edges.
|
||||
// OPTIMIZE: make constant out of 2*clipangle (FIELDOFVIEW).
|
||||
span = angle1 - angle2;
|
||||
|
||||
// Back side? I.e. backface culling?
|
||||
if (span >= ANG180)
|
||||
return;
|
||||
|
||||
// Global angle needed by segcalc.
|
||||
rw_angle1 = angle1;
|
||||
angle1 -= viewangle;
|
||||
angle2 -= viewangle;
|
||||
|
||||
tspan = angle1 + clipangle;
|
||||
if (tspan > 2*clipangle)
|
||||
{
|
||||
tspan -= 2*clipangle;
|
||||
|
||||
// Totally off the left edge?
|
||||
if (tspan >= span)
|
||||
return;
|
||||
|
||||
angle1 = clipangle;
|
||||
}
|
||||
tspan = clipangle - angle2;
|
||||
if (tspan > 2*clipangle)
|
||||
{
|
||||
tspan -= 2*clipangle;
|
||||
|
||||
// Totally off the left edge?
|
||||
if (tspan >= span)
|
||||
return;
|
||||
angle2 = -clipangle;
|
||||
}
|
||||
|
||||
// The seg is in the view range,
|
||||
// but not necessarily visible.
|
||||
angle1 = (angle1+ANG90)>>ANGLETOFINESHIFT;
|
||||
angle2 = (angle2+ANG90)>>ANGLETOFINESHIFT;
|
||||
x1 = viewangletox[angle1];
|
||||
x2 = viewangletox[angle2];
|
||||
|
||||
// Does not cross a pixel?
|
||||
if (x1 == x2)
|
||||
return;
|
||||
|
||||
backsector = line->backsector;
|
||||
|
||||
// Single sided line?
|
||||
if (!backsector)
|
||||
goto clipsolid;
|
||||
|
||||
// Closed door.
|
||||
if (backsector->ceilingheight <= frontsector->floorheight
|
||||
|| backsector->floorheight >= frontsector->ceilingheight)
|
||||
goto clipsolid;
|
||||
|
||||
// Window.
|
||||
if (backsector->ceilingheight != frontsector->ceilingheight
|
||||
|| backsector->floorheight != frontsector->floorheight)
|
||||
goto clippass;
|
||||
|
||||
// Reject empty lines used for triggers
|
||||
// and special events.
|
||||
// Identical floor and ceiling on both sides,
|
||||
// identical light levels on both sides,
|
||||
// and no middle texture.
|
||||
if (backsector->ceilingpic == frontsector->ceilingpic
|
||||
&& backsector->floorpic == frontsector->floorpic
|
||||
&& backsector->lightlevel == frontsector->lightlevel
|
||||
&& curline->sidedef->midtexture == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
clippass:
|
||||
R_ClipPassWallSegment (x1, x2-1);
|
||||
return;
|
||||
|
||||
clipsolid:
|
||||
R_ClipSolidWallSegment (x1, x2-1);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// R_CheckBBox
|
||||
// Checks BSP node/subtree bounding box.
|
||||
// Returns true
|
||||
// if some part of the bbox might be visible.
|
||||
//
|
||||
int checkcoord[12][4] =
|
||||
{
|
||||
{3,0,2,1},
|
||||
{3,0,2,0},
|
||||
{3,1,2,0},
|
||||
{0},
|
||||
{2,0,2,1},
|
||||
{0,0,0,0},
|
||||
{3,1,3,0},
|
||||
{0},
|
||||
{2,0,3,1},
|
||||
{2,1,3,1},
|
||||
{2,1,3,0}
|
||||
};
|
||||
|
||||
|
||||
boolean R_CheckBBox (fixed_t* bspcoord)
|
||||
{
|
||||
int boxx;
|
||||
int boxy;
|
||||
int boxpos;
|
||||
|
||||
fixed_t x1;
|
||||
fixed_t y1;
|
||||
fixed_t x2;
|
||||
fixed_t y2;
|
||||
|
||||
angle_t angle1;
|
||||
angle_t angle2;
|
||||
angle_t span;
|
||||
angle_t tspan;
|
||||
|
||||
cliprange_t* start;
|
||||
|
||||
int sx1;
|
||||
int sx2;
|
||||
|
||||
// Find the corners of the box
|
||||
// that define the edges from current viewpoint.
|
||||
if (viewx <= bspcoord[BOXLEFT])
|
||||
boxx = 0;
|
||||
else if (viewx < bspcoord[BOXRIGHT])
|
||||
boxx = 1;
|
||||
else
|
||||
boxx = 2;
|
||||
|
||||
if (viewy >= bspcoord[BOXTOP])
|
||||
boxy = 0;
|
||||
else if (viewy > bspcoord[BOXBOTTOM])
|
||||
boxy = 1;
|
||||
else
|
||||
boxy = 2;
|
||||
|
||||
boxpos = (boxy<<2)+boxx;
|
||||
if (boxpos == 5)
|
||||
return true;
|
||||
|
||||
x1 = bspcoord[checkcoord[boxpos][0]];
|
||||
y1 = bspcoord[checkcoord[boxpos][1]];
|
||||
x2 = bspcoord[checkcoord[boxpos][2]];
|
||||
y2 = bspcoord[checkcoord[boxpos][3]];
|
||||
|
||||
// check clip list for an open space
|
||||
angle1 = R_PointToAngle (x1, y1) - viewangle;
|
||||
angle2 = R_PointToAngle (x2, y2) - viewangle;
|
||||
|
||||
span = angle1 - angle2;
|
||||
|
||||
// Sitting on a line?
|
||||
if (span >= ANG180)
|
||||
return true;
|
||||
|
||||
tspan = angle1 + clipangle;
|
||||
|
||||
if (tspan > 2*clipangle)
|
||||
{
|
||||
tspan -= 2*clipangle;
|
||||
|
||||
// Totally off the left edge?
|
||||
if (tspan >= span)
|
||||
return false;
|
||||
|
||||
angle1 = clipangle;
|
||||
}
|
||||
tspan = clipangle - angle2;
|
||||
if (tspan > 2*clipangle)
|
||||
{
|
||||
tspan -= 2*clipangle;
|
||||
|
||||
// Totally off the left edge?
|
||||
if (tspan >= span)
|
||||
return false;
|
||||
|
||||
angle2 = -clipangle;
|
||||
}
|
||||
|
||||
|
||||
// Find the first clippost
|
||||
// that touches the source post
|
||||
// (adjacent pixels are touching).
|
||||
angle1 = (angle1+ANG90)>>ANGLETOFINESHIFT;
|
||||
angle2 = (angle2+ANG90)>>ANGLETOFINESHIFT;
|
||||
sx1 = viewangletox[angle1];
|
||||
sx2 = viewangletox[angle2];
|
||||
|
||||
// Does not cross a pixel.
|
||||
if (sx1 == sx2)
|
||||
return false;
|
||||
sx2--;
|
||||
|
||||
start = solidsegs;
|
||||
while (start->last < sx2)
|
||||
start++;
|
||||
|
||||
if (sx1 >= start->first
|
||||
&& sx2 <= start->last)
|
||||
{
|
||||
// The clippost contains the new span.
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_Subsector
|
||||
// Determine floor/ceiling planes.
|
||||
// Add sprites of things in sector.
|
||||
// Draw one or more line segments.
|
||||
//
|
||||
void R_Subsector (int num)
|
||||
{
|
||||
int count;
|
||||
seg_t* line;
|
||||
subsector_t* sub;
|
||||
|
||||
#ifdef RANGECHECK
|
||||
if (num>=numsubsectors)
|
||||
I_Error ("R_Subsector: ss %i with numss = %i",
|
||||
num,
|
||||
numsubsectors);
|
||||
#endif
|
||||
|
||||
sscount++;
|
||||
sub = &subsectors[num];
|
||||
frontsector = sub->sector;
|
||||
count = sub->numlines;
|
||||
line = &segs[sub->firstline];
|
||||
|
||||
if (frontsector->floorheight < viewz)
|
||||
{
|
||||
floorplane = R_FindPlane (frontsector->floorheight,
|
||||
frontsector->floorpic,
|
||||
frontsector->lightlevel);
|
||||
}
|
||||
else
|
||||
floorplane = NULL;
|
||||
|
||||
if (frontsector->ceilingheight > viewz
|
||||
|| frontsector->ceilingpic == skyflatnum)
|
||||
{
|
||||
ceilingplane = R_FindPlane (frontsector->ceilingheight,
|
||||
frontsector->ceilingpic,
|
||||
frontsector->lightlevel);
|
||||
}
|
||||
else
|
||||
ceilingplane = NULL;
|
||||
|
||||
R_AddSprites (frontsector);
|
||||
|
||||
while (count--)
|
||||
{
|
||||
R_AddLine (line);
|
||||
line++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// RenderBSPNode
|
||||
// Renders all subsectors below a given node,
|
||||
// traversing subtree recursively.
|
||||
// Just call with BSP root.
|
||||
void R_RenderBSPNode (int bspnum)
|
||||
{
|
||||
node_t* bsp;
|
||||
int side;
|
||||
|
||||
// Found a subsector?
|
||||
if (bspnum & NF_SUBSECTOR)
|
||||
{
|
||||
if (bspnum == -1)
|
||||
R_Subsector (0);
|
||||
else
|
||||
R_Subsector (bspnum&(~NF_SUBSECTOR));
|
||||
return;
|
||||
}
|
||||
|
||||
bsp = &nodes[bspnum];
|
||||
|
||||
// Decide which side the view point is on.
|
||||
side = R_PointOnSide (viewx, viewy, bsp);
|
||||
|
||||
// Recursively divide front space.
|
||||
R_RenderBSPNode (bsp->children[side]);
|
||||
|
||||
// Possibly divide back space.
|
||||
if (R_CheckBBox (bsp->bbox[side^1]))
|
||||
R_RenderBSPNode (bsp->children[side^1]);
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,72 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Refresh module, BSP traversal and handling.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __R_BSP__
|
||||
#define __R_BSP__
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
extern seg_t* curline;
|
||||
extern side_t* sidedef;
|
||||
extern line_t* linedef;
|
||||
extern sector_t* frontsector;
|
||||
extern sector_t* backsector;
|
||||
|
||||
extern int rw_x;
|
||||
extern int rw_stopx;
|
||||
|
||||
extern boolean segtextured;
|
||||
|
||||
// false if the back side is the same plane
|
||||
extern boolean markfloor;
|
||||
extern boolean markceiling;
|
||||
|
||||
extern boolean skymap;
|
||||
|
||||
extern drawseg_t drawsegs[MAXDRAWSEGS];
|
||||
extern drawseg_t* ds_p;
|
||||
|
||||
extern lighttable_t** hscalelight;
|
||||
extern lighttable_t** vscalelight;
|
||||
extern lighttable_t** dscalelight;
|
||||
|
||||
|
||||
typedef void (*drawfunc_t) (int start, int stop);
|
||||
|
||||
|
||||
// BSP?
|
||||
void R_ClearClipSegs (void);
|
||||
void R_ClearDrawSegs (void);
|
||||
|
||||
|
||||
void R_RenderBSPNode (int bspnum);
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,848 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
// Revision 1.3 1997/01/29 20:10
|
||||
// DESCRIPTION:
|
||||
// Preparation of data for rendering,
|
||||
// generation of lookups, caching, retrieval by name.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
static const char
|
||||
rcsid[] = "$Id: r_data.c,v 1.4 1997/02/03 16:47:55 b1 Exp $";
|
||||
|
||||
#include "i_system.h"
|
||||
#include "z_zone.h"
|
||||
|
||||
#include "m_swap.h"
|
||||
|
||||
#include "w_wad.h"
|
||||
|
||||
#include "doomdef.h"
|
||||
#include "r_local.h"
|
||||
#include "p_local.h"
|
||||
|
||||
#include "doomstat.h"
|
||||
#include "r_sky.h"
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
|
||||
#include "r_data.h"
|
||||
|
||||
//
|
||||
// Graphics.
|
||||
// DOOM graphics for walls and sprites
|
||||
// is stored in vertical runs of opaque pixels (posts).
|
||||
// A column is composed of zero or more posts,
|
||||
// a patch or sprite is composed of zero or more columns.
|
||||
//
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Texture definition.
|
||||
// Each texture is composed of one or more patches,
|
||||
// with patches being lumps stored in the WAD.
|
||||
// The lumps are referenced by number, and patched
|
||||
// into the rectangular texture space using origin
|
||||
// and possibly other attributes.
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
short originx;
|
||||
short originy;
|
||||
short patch;
|
||||
short stepdir;
|
||||
short colormap;
|
||||
} mappatch_t;
|
||||
|
||||
|
||||
//
|
||||
// Texture definition.
|
||||
// A DOOM wall texture is a list of patches
|
||||
// which are to be combined in a predefined order.
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
char name[8];
|
||||
boolean masked;
|
||||
short width;
|
||||
short height;
|
||||
int columndirectory; // OBSOLETE
|
||||
short patchcount;
|
||||
mappatch_t patches[1];
|
||||
} maptexture_t;
|
||||
|
||||
|
||||
// A single patch from a texture definition,
|
||||
// basically a rectangular area within
|
||||
// the texture rectangle.
|
||||
typedef struct
|
||||
{
|
||||
// Block origin (allways UL),
|
||||
// which has allready accounted
|
||||
// for the internal origin of the patch.
|
||||
int originx;
|
||||
int originy;
|
||||
int patch;
|
||||
} texpatch_t;
|
||||
|
||||
|
||||
// A maptexturedef_t describes a rectangular texture,
|
||||
// which is composed of one or more mappatch_t structures
|
||||
// that arrange graphic patches.
|
||||
typedef struct
|
||||
{
|
||||
// Keep name for switch changing, etc.
|
||||
char name[8];
|
||||
short width;
|
||||
short height;
|
||||
|
||||
// All the patches[patchcount]
|
||||
// are drawn back to front into the cached texture.
|
||||
short patchcount;
|
||||
texpatch_t patches[1];
|
||||
|
||||
} texture_t;
|
||||
|
||||
|
||||
|
||||
int firstflat;
|
||||
int lastflat;
|
||||
int numflats;
|
||||
|
||||
int firstpatch;
|
||||
int lastpatch;
|
||||
int numpatches;
|
||||
|
||||
int firstspritelump;
|
||||
int lastspritelump;
|
||||
int numspritelumps;
|
||||
|
||||
int numtextures;
|
||||
texture_t** textures;
|
||||
|
||||
|
||||
int* texturewidthmask;
|
||||
// needed for texture pegging
|
||||
fixed_t* textureheight;
|
||||
int* texturecompositesize;
|
||||
short** texturecolumnlump;
|
||||
unsigned short** texturecolumnofs;
|
||||
byte** texturecomposite;
|
||||
|
||||
// for global animation
|
||||
int* flattranslation;
|
||||
int* texturetranslation;
|
||||
|
||||
// needed for pre rendering
|
||||
fixed_t* spritewidth;
|
||||
fixed_t* spriteoffset;
|
||||
fixed_t* spritetopoffset;
|
||||
|
||||
lighttable_t *colormaps;
|
||||
|
||||
|
||||
//
|
||||
// MAPTEXTURE_T CACHING
|
||||
// When a texture is first needed,
|
||||
// it counts the number of composite columns
|
||||
// required in the texture and allocates space
|
||||
// for a column directory and any new columns.
|
||||
// The directory will simply point inside other patches
|
||||
// if there is only one patch in a given column,
|
||||
// but any columns with multiple patches
|
||||
// will have new column_ts generated.
|
||||
//
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_DrawColumnInCache
|
||||
// Clip and draw a column
|
||||
// from a patch into a cached post.
|
||||
//
|
||||
void
|
||||
R_DrawColumnInCache
|
||||
( column_t* patch,
|
||||
byte* cache,
|
||||
int originy,
|
||||
int cacheheight )
|
||||
{
|
||||
int count;
|
||||
int position;
|
||||
byte* source;
|
||||
byte* dest;
|
||||
|
||||
dest = (byte *)cache + 3;
|
||||
|
||||
while (patch->topdelta != 0xff)
|
||||
{
|
||||
source = (byte *)patch + 3;
|
||||
count = patch->length;
|
||||
position = originy + patch->topdelta;
|
||||
|
||||
if (position < 0)
|
||||
{
|
||||
count += position;
|
||||
position = 0;
|
||||
}
|
||||
|
||||
if (position + count > cacheheight)
|
||||
count = cacheheight - position;
|
||||
|
||||
if (count > 0)
|
||||
memcpy (cache + position, source, count);
|
||||
|
||||
patch = (column_t *)( (byte *)patch + patch->length + 4);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_GenerateComposite
|
||||
// Using the texture definition,
|
||||
// the composite texture is created from the patches,
|
||||
// and each column is cached.
|
||||
//
|
||||
void R_GenerateComposite (int texnum)
|
||||
{
|
||||
byte* block;
|
||||
texture_t* texture;
|
||||
texpatch_t* patch;
|
||||
patch_t* realpatch;
|
||||
int x;
|
||||
int x1;
|
||||
int x2;
|
||||
int i;
|
||||
column_t* patchcol;
|
||||
short* collump;
|
||||
unsigned short* colofs;
|
||||
|
||||
texture = textures[texnum];
|
||||
|
||||
block = Z_Malloc (texturecompositesize[texnum],
|
||||
PU_STATIC,
|
||||
&texturecomposite[texnum]);
|
||||
|
||||
collump = texturecolumnlump[texnum];
|
||||
colofs = texturecolumnofs[texnum];
|
||||
|
||||
// Composite the columns together.
|
||||
patch = texture->patches;
|
||||
|
||||
for (i=0 , patch = texture->patches;
|
||||
i<texture->patchcount;
|
||||
i++, patch++)
|
||||
{
|
||||
realpatch = W_CacheLumpNum (patch->patch, PU_CACHE);
|
||||
x1 = patch->originx;
|
||||
x2 = x1 + SHORT(realpatch->width);
|
||||
|
||||
if (x1<0)
|
||||
x = 0;
|
||||
else
|
||||
x = x1;
|
||||
|
||||
if (x2 > texture->width)
|
||||
x2 = texture->width;
|
||||
|
||||
for ( ; x<x2 ; x++)
|
||||
{
|
||||
// Column does not have multiple patches?
|
||||
if (collump[x] >= 0)
|
||||
continue;
|
||||
|
||||
patchcol = (column_t *)((byte *)realpatch
|
||||
+ LONG(realpatch->columnofs[x-x1]));
|
||||
R_DrawColumnInCache (patchcol,
|
||||
block + colofs[x],
|
||||
patch->originy,
|
||||
texture->height);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Now that the texture has been built in column cache,
|
||||
// it is purgable from zone memory.
|
||||
Z_ChangeTag (block, PU_CACHE);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_GenerateLookup
|
||||
//
|
||||
void R_GenerateLookup (int texnum)
|
||||
{
|
||||
texture_t* texture;
|
||||
byte* patchcount; // patchcount[texture->width]
|
||||
texpatch_t* patch;
|
||||
patch_t* realpatch;
|
||||
int x;
|
||||
int x1;
|
||||
int x2;
|
||||
int i;
|
||||
short* collump;
|
||||
unsigned short* colofs;
|
||||
|
||||
texture = textures[texnum];
|
||||
|
||||
// Composited texture not created yet.
|
||||
texturecomposite[texnum] = 0;
|
||||
|
||||
texturecompositesize[texnum] = 0;
|
||||
collump = texturecolumnlump[texnum];
|
||||
colofs = texturecolumnofs[texnum];
|
||||
|
||||
// Now count the number of columns
|
||||
// that are covered by more than one patch.
|
||||
// Fill in the lump / offset, so columns
|
||||
// with only a single patch are all done.
|
||||
patchcount = (byte *)alloca (texture->width);
|
||||
memset (patchcount, 0, texture->width);
|
||||
patch = texture->patches;
|
||||
|
||||
for (i=0 , patch = texture->patches;
|
||||
i<texture->patchcount;
|
||||
i++, patch++)
|
||||
{
|
||||
realpatch = W_CacheLumpNum (patch->patch, PU_CACHE);
|
||||
x1 = patch->originx;
|
||||
x2 = x1 + SHORT(realpatch->width);
|
||||
|
||||
if (x1 < 0)
|
||||
x = 0;
|
||||
else
|
||||
x = x1;
|
||||
|
||||
if (x2 > texture->width)
|
||||
x2 = texture->width;
|
||||
for ( ; x<x2 ; x++)
|
||||
{
|
||||
patchcount[x]++;
|
||||
collump[x] = patch->patch;
|
||||
colofs[x] = LONG(realpatch->columnofs[x-x1])+3;
|
||||
}
|
||||
}
|
||||
|
||||
for (x=0 ; x<texture->width ; x++)
|
||||
{
|
||||
if (!patchcount[x])
|
||||
{
|
||||
printf ("R_GenerateLookup: column without a patch (%s)\n",
|
||||
texture->name);
|
||||
return;
|
||||
}
|
||||
// I_Error ("R_GenerateLookup: column without a patch");
|
||||
|
||||
if (patchcount[x] > 1)
|
||||
{
|
||||
// Use the cached block.
|
||||
collump[x] = -1;
|
||||
colofs[x] = texturecompositesize[texnum];
|
||||
|
||||
if (texturecompositesize[texnum] > 0x10000-texture->height)
|
||||
{
|
||||
I_Error ("R_GenerateLookup: texture %i is >64k",
|
||||
texnum);
|
||||
}
|
||||
|
||||
texturecompositesize[texnum] += texture->height;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_GetColumn
|
||||
//
|
||||
byte*
|
||||
R_GetColumn
|
||||
( int tex,
|
||||
int col )
|
||||
{
|
||||
int lump;
|
||||
int ofs;
|
||||
|
||||
col &= texturewidthmask[tex];
|
||||
lump = texturecolumnlump[tex][col];
|
||||
ofs = texturecolumnofs[tex][col];
|
||||
|
||||
if (lump > 0)
|
||||
return (byte *)W_CacheLumpNum(lump,PU_CACHE)+ofs;
|
||||
|
||||
if (!texturecomposite[tex])
|
||||
R_GenerateComposite (tex);
|
||||
|
||||
return texturecomposite[tex] + ofs;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_InitTextures
|
||||
// Initializes the texture list
|
||||
// with the textures from the world map.
|
||||
//
|
||||
void R_InitTextures (void)
|
||||
{
|
||||
maptexture_t* mtexture;
|
||||
texture_t* texture;
|
||||
mappatch_t* mpatch;
|
||||
texpatch_t* patch;
|
||||
|
||||
int i;
|
||||
int j;
|
||||
|
||||
int* maptex;
|
||||
int* maptex2;
|
||||
int* maptex1;
|
||||
|
||||
char name[9];
|
||||
char* names;
|
||||
char* name_p;
|
||||
|
||||
int* patchlookup;
|
||||
|
||||
int totalwidth;
|
||||
int nummappatches;
|
||||
int offset;
|
||||
int maxoff;
|
||||
int maxoff2;
|
||||
int numtextures1;
|
||||
int numtextures2;
|
||||
|
||||
int* directory;
|
||||
|
||||
int temp1;
|
||||
int temp2;
|
||||
int temp3;
|
||||
|
||||
|
||||
// Load the patch names from pnames.lmp.
|
||||
name[8] = 0;
|
||||
names = W_CacheLumpName ("PNAMES", PU_STATIC);
|
||||
nummappatches = LONG ( *((int *)names) );
|
||||
name_p = names+4;
|
||||
patchlookup = alloca (nummappatches*sizeof(*patchlookup));
|
||||
|
||||
for (i=0 ; i<nummappatches ; i++)
|
||||
{
|
||||
strncpy (name,name_p+i*8, 8);
|
||||
patchlookup[i] = W_CheckNumForName (name);
|
||||
}
|
||||
Z_Free (names);
|
||||
|
||||
// Load the map texture definitions from textures.lmp.
|
||||
// The data is contained in one or two lumps,
|
||||
// TEXTURE1 for shareware, plus TEXTURE2 for commercial.
|
||||
maptex = maptex1 = W_CacheLumpName ("TEXTURE1", PU_STATIC);
|
||||
numtextures1 = LONG(*maptex);
|
||||
maxoff = W_LumpLength (W_GetNumForName ("TEXTURE1"));
|
||||
directory = maptex+1;
|
||||
|
||||
if (W_CheckNumForName ("TEXTURE2") != -1)
|
||||
{
|
||||
maptex2 = W_CacheLumpName ("TEXTURE2", PU_STATIC);
|
||||
numtextures2 = LONG(*maptex2);
|
||||
maxoff2 = W_LumpLength (W_GetNumForName ("TEXTURE2"));
|
||||
}
|
||||
else
|
||||
{
|
||||
maptex2 = NULL;
|
||||
numtextures2 = 0;
|
||||
maxoff2 = 0;
|
||||
}
|
||||
numtextures = numtextures1 + numtextures2;
|
||||
|
||||
textures = Z_Malloc (numtextures*sizeof(*textures), PU_STATIC, 0);
|
||||
texturecolumnlump = Z_Malloc (numtextures*sizeof(*texturecolumnlump), PU_STATIC, 0);
|
||||
texturecolumnofs = Z_Malloc (numtextures*sizeof(*texturecolumnofs), PU_STATIC, 0);
|
||||
texturecomposite = Z_Malloc (numtextures*sizeof(*texturecomposite), PU_STATIC, 0);
|
||||
texturecompositesize = Z_Malloc (numtextures*sizeof(*texturecompositesize), PU_STATIC, 0);
|
||||
texturewidthmask = Z_Malloc (numtextures*sizeof(*texturewidthmask), PU_STATIC, 0);
|
||||
textureheight = Z_Malloc (numtextures*sizeof(*textureheight), PU_STATIC, 0);
|
||||
|
||||
totalwidth = 0;
|
||||
|
||||
// Really complex printing shit...
|
||||
temp1 = W_GetNumForName ("S_START"); // P_???????
|
||||
temp2 = W_GetNumForName ("S_END") - 1;
|
||||
temp3 = ((temp2-temp1+63)/64) + ((numtextures+63)/64);
|
||||
printf("[");
|
||||
for (i = 0; i < temp3; i++)
|
||||
printf(" ");
|
||||
printf(" ]");
|
||||
for (i = 0; i < temp3; i++)
|
||||
printf("\x8");
|
||||
printf("\x8\x8\x8\x8\x8\x8\x8\x8\x8\x8");
|
||||
|
||||
for (i=0 ; i<numtextures ; i++, directory++)
|
||||
{
|
||||
if (!(i&63))
|
||||
printf (".");
|
||||
|
||||
if (i == numtextures1)
|
||||
{
|
||||
// Start looking in second texture file.
|
||||
maptex = maptex2;
|
||||
maxoff = maxoff2;
|
||||
directory = maptex+1;
|
||||
}
|
||||
|
||||
offset = LONG(*directory);
|
||||
|
||||
if (offset > maxoff)
|
||||
I_Error ("R_InitTextures: bad texture directory");
|
||||
|
||||
mtexture = (maptexture_t *) ( (byte *)maptex + offset);
|
||||
|
||||
texture = textures[i] =
|
||||
Z_Malloc (sizeof(texture_t)
|
||||
+ sizeof(texpatch_t)*(SHORT(mtexture->patchcount)-1),
|
||||
PU_STATIC, 0);
|
||||
|
||||
texture->width = SHORT(mtexture->width);
|
||||
texture->height = SHORT(mtexture->height);
|
||||
texture->patchcount = SHORT(mtexture->patchcount);
|
||||
|
||||
memcpy (texture->name, mtexture->name, sizeof(texture->name));
|
||||
mpatch = &mtexture->patches[0];
|
||||
patch = &texture->patches[0];
|
||||
|
||||
for (j=0 ; j<texture->patchcount ; j++, mpatch++, patch++)
|
||||
{
|
||||
patch->originx = SHORT(mpatch->originx);
|
||||
patch->originy = SHORT(mpatch->originy);
|
||||
patch->patch = patchlookup[SHORT(mpatch->patch)];
|
||||
if (patch->patch == -1)
|
||||
{
|
||||
I_Error ("R_InitTextures: Missing patch in texture %s",
|
||||
texture->name);
|
||||
}
|
||||
}
|
||||
texturecolumnlump[i] = Z_Malloc (texture->width*2, PU_STATIC,0);
|
||||
texturecolumnofs[i] = Z_Malloc (texture->width*2, PU_STATIC,0);
|
||||
|
||||
j = 1;
|
||||
while (j*2 <= texture->width)
|
||||
j<<=1;
|
||||
|
||||
texturewidthmask[i] = j-1;
|
||||
textureheight[i] = texture->height<<FRACBITS;
|
||||
|
||||
totalwidth += texture->width;
|
||||
}
|
||||
|
||||
Z_Free (maptex1);
|
||||
if (maptex2)
|
||||
Z_Free (maptex2);
|
||||
|
||||
// Precalculate whatever possible.
|
||||
for (i=0 ; i<numtextures ; i++)
|
||||
R_GenerateLookup (i);
|
||||
|
||||
// Create translation table for global animation.
|
||||
texturetranslation = Z_Malloc ((numtextures+1)*sizeof(*texturetranslation), PU_STATIC, 0);
|
||||
|
||||
for (i=0 ; i<numtextures ; i++)
|
||||
texturetranslation[i] = i;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_InitFlats
|
||||
//
|
||||
void R_InitFlats (void)
|
||||
{
|
||||
int i;
|
||||
|
||||
firstflat = W_GetNumForName ("F_START") + 1;
|
||||
lastflat = W_GetNumForName ("F_END") - 1;
|
||||
numflats = lastflat - firstflat + 1;
|
||||
|
||||
// Create translation table for global animation.
|
||||
flattranslation = Z_Malloc ((numflats+1)*sizeof(*flattranslation), PU_STATIC, 0);
|
||||
|
||||
for (i=0 ; i<numflats ; i++)
|
||||
flattranslation[i] = i;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// R_InitSpriteLumps
|
||||
// Finds the width and hoffset of all sprites in the wad,
|
||||
// so the sprite does not need to be cached completely
|
||||
// just for having the header info ready during rendering.
|
||||
//
|
||||
void R_InitSpriteLumps (void)
|
||||
{
|
||||
int i;
|
||||
patch_t *patch;
|
||||
|
||||
firstspritelump = W_GetNumForName ("S_START") + 1;
|
||||
lastspritelump = W_GetNumForName ("S_END") - 1;
|
||||
|
||||
numspritelumps = lastspritelump - firstspritelump + 1;
|
||||
spritewidth = Z_Malloc (numspritelumps*sizeof(*spritewidth), PU_STATIC, 0);
|
||||
spriteoffset = Z_Malloc (numspritelumps*sizeof(*spriteoffset), PU_STATIC, 0);
|
||||
spritetopoffset = Z_Malloc (numspritelumps*sizeof(*spritetopoffset), PU_STATIC, 0);
|
||||
|
||||
for (i=0 ; i< numspritelumps ; i++)
|
||||
{
|
||||
if (!(i&63))
|
||||
printf (".");
|
||||
|
||||
patch = W_CacheLumpNum (firstspritelump+i, PU_CACHE);
|
||||
spritewidth[i] = SHORT(patch->width)<<FRACBITS;
|
||||
spriteoffset[i] = SHORT(patch->leftoffset)<<FRACBITS;
|
||||
spritetopoffset[i] = SHORT(patch->topoffset)<<FRACBITS;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_InitColormaps
|
||||
//
|
||||
void R_InitColormaps (void)
|
||||
{
|
||||
int lump, length;
|
||||
|
||||
// Load in the light tables,
|
||||
// 256 byte align tables.
|
||||
lump = W_GetNumForName("COLORMAP");
|
||||
length = W_LumpLength (lump) + 255;
|
||||
colormaps = Z_Malloc (length, PU_STATIC, 0);
|
||||
colormaps = (byte *)( ((uintptr_t)colormaps + 255)&~(uintptr_t)0xff);
|
||||
W_ReadLump (lump,colormaps);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_InitData
|
||||
// Locates all the lumps
|
||||
// that will be used by all views
|
||||
// Must be called after W_Init.
|
||||
//
|
||||
void R_InitData (void)
|
||||
{
|
||||
R_InitTextures ();
|
||||
printf ("\nInitTextures");
|
||||
R_InitFlats ();
|
||||
printf ("\nInitFlats");
|
||||
R_InitSpriteLumps ();
|
||||
printf ("\nInitSprites");
|
||||
R_InitColormaps ();
|
||||
printf ("\nInitColormaps");
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_FlatNumForName
|
||||
// Retrieval, get a flat number for a flat name.
|
||||
//
|
||||
int R_FlatNumForName (char* name)
|
||||
{
|
||||
int i;
|
||||
char namet[9];
|
||||
|
||||
i = W_CheckNumForName (name);
|
||||
|
||||
if (i == -1)
|
||||
{
|
||||
namet[8] = 0;
|
||||
memcpy (namet, name,8);
|
||||
I_Error ("R_FlatNumForName: %s not found",namet);
|
||||
}
|
||||
return i - firstflat;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_CheckTextureNumForName
|
||||
// Check whether texture is available.
|
||||
// Filter out NoTexture indicator.
|
||||
//
|
||||
int R_CheckTextureNumForName (char *name)
|
||||
{
|
||||
int i;
|
||||
|
||||
// "NoTexture" marker.
|
||||
if (name[0] == '-')
|
||||
return 0;
|
||||
|
||||
for (i=0 ; i<numtextures ; i++)
|
||||
if (!strncasecmp (textures[i]->name, name, 8) )
|
||||
return i;
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_TextureNumForName
|
||||
// Calls R_CheckTextureNumForName,
|
||||
// aborts with error message.
|
||||
//
|
||||
int R_TextureNumForName (char* name)
|
||||
{
|
||||
int i;
|
||||
|
||||
i = R_CheckTextureNumForName (name);
|
||||
|
||||
if (i==-1)
|
||||
{
|
||||
I_Error ("R_TextureNumForName: %s not found",
|
||||
name);
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// R_PrecacheLevel
|
||||
// Preloads all relevant graphics for the level.
|
||||
//
|
||||
int flatmemory;
|
||||
int texturememory;
|
||||
int spritememory;
|
||||
|
||||
void R_PrecacheLevel (void)
|
||||
{
|
||||
char* flatpresent;
|
||||
char* texturepresent;
|
||||
char* spritepresent;
|
||||
|
||||
int i;
|
||||
int j;
|
||||
int k;
|
||||
int lump;
|
||||
|
||||
texture_t* texture;
|
||||
thinker_t* th;
|
||||
spriteframe_t* sf;
|
||||
|
||||
if (demoplayback)
|
||||
return;
|
||||
|
||||
// Precache flats.
|
||||
flatpresent = alloca(numflats);
|
||||
memset (flatpresent,0,numflats);
|
||||
|
||||
for (i=0 ; i<numsectors ; i++)
|
||||
{
|
||||
flatpresent[sectors[i].floorpic] = 1;
|
||||
flatpresent[sectors[i].ceilingpic] = 1;
|
||||
}
|
||||
|
||||
flatmemory = 0;
|
||||
|
||||
for (i=0 ; i<numflats ; i++)
|
||||
{
|
||||
if (flatpresent[i])
|
||||
{
|
||||
lump = firstflat + i;
|
||||
flatmemory += lumpinfo[lump].size;
|
||||
W_CacheLumpNum(lump, PU_CACHE);
|
||||
}
|
||||
}
|
||||
|
||||
// Precache textures.
|
||||
texturepresent = alloca(numtextures);
|
||||
memset (texturepresent,0, numtextures);
|
||||
|
||||
for (i=0 ; i<numsides ; i++)
|
||||
{
|
||||
texturepresent[sides[i].toptexture] = 1;
|
||||
texturepresent[sides[i].midtexture] = 1;
|
||||
texturepresent[sides[i].bottomtexture] = 1;
|
||||
}
|
||||
|
||||
// Sky texture is always present.
|
||||
// Note that F_SKY1 is the name used to
|
||||
// indicate a sky floor/ceiling as a flat,
|
||||
// while the sky texture is stored like
|
||||
// a wall texture, with an episode dependend
|
||||
// name.
|
||||
texturepresent[skytexture] = 1;
|
||||
|
||||
texturememory = 0;
|
||||
for (i=0 ; i<numtextures ; i++)
|
||||
{
|
||||
if (!texturepresent[i])
|
||||
continue;
|
||||
|
||||
texture = textures[i];
|
||||
|
||||
for (j=0 ; j<texture->patchcount ; j++)
|
||||
{
|
||||
lump = texture->patches[j].patch;
|
||||
texturememory += lumpinfo[lump].size;
|
||||
W_CacheLumpNum(lump , PU_CACHE);
|
||||
}
|
||||
}
|
||||
|
||||
// Precache sprites.
|
||||
spritepresent = alloca(numsprites);
|
||||
memset (spritepresent,0, numsprites);
|
||||
|
||||
for (th = thinkercap.next ; th != &thinkercap ; th=th->next)
|
||||
{
|
||||
if (th->function.acp1 == (actionf_p1)P_MobjThinker)
|
||||
spritepresent[((mobj_t *)th)->sprite] = 1;
|
||||
}
|
||||
|
||||
spritememory = 0;
|
||||
for (i=0 ; i<numsprites ; i++)
|
||||
{
|
||||
if (!spritepresent[i])
|
||||
continue;
|
||||
|
||||
for (j=0 ; j<sprites[i].numframes ; j++)
|
||||
{
|
||||
sf = &sprites[i].spriteframes[j];
|
||||
for (k=0 ; k<8 ; k++)
|
||||
{
|
||||
lump = firstspritelump + sf->lump[k];
|
||||
spritememory += lumpinfo[lump].size;
|
||||
W_CacheLumpNum(lump , PU_CACHE);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Refresh module, data I/O, caching, retrieval of graphics
|
||||
// by name.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __R_DATA__
|
||||
#define __R_DATA__
|
||||
|
||||
#include "r_defs.h"
|
||||
#include "r_state.h"
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
// Retrieve column data for span blitting.
|
||||
byte*
|
||||
R_GetColumn
|
||||
( int tex,
|
||||
int col );
|
||||
|
||||
|
||||
// I/O, setting up the stuff.
|
||||
void R_InitData (void);
|
||||
void R_PrecacheLevel (void);
|
||||
|
||||
|
||||
// Retrieval.
|
||||
// Floor/ceiling opaque texture tiles,
|
||||
// lookup by name. For animation?
|
||||
int R_FlatNumForName (char* name);
|
||||
|
||||
|
||||
// Called by P_Ticker for switches and animations,
|
||||
// returns the texture number for the texture name.
|
||||
int R_TextureNumForName (char *name);
|
||||
int R_CheckTextureNumForName (char *name);
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -0,0 +1,490 @@
|
||||
// Emacs style mode select -*- C++ -*-
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Id:$
|
||||
//
|
||||
// Copyright (C) 1993-1996 by id Software, Inc.
|
||||
//
|
||||
// This source is available for distribution and/or modification
|
||||
// only under the terms of the DOOM Source Code License as
|
||||
// published by id Software. All rights reserved.
|
||||
//
|
||||
// The source is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
||||
// for more details.
|
||||
//
|
||||
// DESCRIPTION:
|
||||
// Refresh/rendering module, shared data struct definitions.
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __R_DEFS__
|
||||
#define __R_DEFS__
|
||||
|
||||
|
||||
// Screenwidth.
|
||||
#include "doomdef.h"
|
||||
|
||||
// Some more or less basic data types
|
||||
// we depend on.
|
||||
#include "m_fixed.h"
|
||||
|
||||
// We rely on the thinker data struct
|
||||
// to handle sound origins in sectors.
|
||||
#include "d_think.h"
|
||||
// SECTORS do store MObjs anyway.
|
||||
#include "p_mobj.h"
|
||||
|
||||
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
// Silhouette, needed for clipping Segs (mainly)
|
||||
// and sprites representing things.
|
||||
#define SIL_NONE 0
|
||||
#define SIL_BOTTOM 1
|
||||
#define SIL_TOP 2
|
||||
#define SIL_BOTH 3
|
||||
|
||||
#define MAXDRAWSEGS 2048
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// INTERNAL MAP TYPES
|
||||
// used by play and refresh
|
||||
//
|
||||
|
||||
//
|
||||
// Your plain vanilla vertex.
|
||||
// Note: transformed values not buffered locally,
|
||||
// like some DOOM-alikes ("wt", "WebView") did.
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
fixed_t x;
|
||||
fixed_t y;
|
||||
|
||||
} vertex_t;
|
||||
|
||||
|
||||
// Forward of LineDefs, for Sectors.
|
||||
struct line_s;
|
||||
|
||||
// Each sector has a degenmobj_t in its center
|
||||
// for sound origin purposes.
|
||||
// I suppose this does not handle sound from
|
||||
// moving objects (doppler), because
|
||||
// position is prolly just buffered, not
|
||||
// updated.
|
||||
typedef struct
|
||||
{
|
||||
thinker_t thinker; // not used for anything
|
||||
fixed_t x;
|
||||
fixed_t y;
|
||||
fixed_t z;
|
||||
|
||||
} degenmobj_t;
|
||||
|
||||
//
|
||||
// The SECTORS record, at runtime.
|
||||
// Stores things/mobjs.
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
fixed_t floorheight;
|
||||
fixed_t ceilingheight;
|
||||
short floorpic;
|
||||
short ceilingpic;
|
||||
short lightlevel;
|
||||
short special;
|
||||
short tag;
|
||||
|
||||
// 0 = untraversed, 1,2 = sndlines -1
|
||||
int soundtraversed;
|
||||
|
||||
// thing that made a sound (or null)
|
||||
mobj_t* soundtarget;
|
||||
|
||||
// mapblock bounding box for height changes
|
||||
int blockbox[4];
|
||||
|
||||
// origin for any sounds played by the sector
|
||||
degenmobj_t soundorg;
|
||||
|
||||
// if == validcount, already checked
|
||||
int validcount;
|
||||
|
||||
// list of mobjs in sector
|
||||
mobj_t* thinglist;
|
||||
|
||||
// thinker_t for reversable actions
|
||||
void* specialdata;
|
||||
|
||||
int linecount;
|
||||
struct line_s** lines; // [linecount] size
|
||||
|
||||
} sector_t;
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// The SideDef.
|
||||
//
|
||||
|
||||
typedef struct
|
||||
{
|
||||
// add this to the calculated texture column
|
||||
fixed_t textureoffset;
|
||||
|
||||
// add this to the calculated texture top
|
||||
fixed_t rowoffset;
|
||||
|
||||
// Texture indices.
|
||||
// We do not maintain names here.
|
||||
short toptexture;
|
||||
short bottomtexture;
|
||||
short midtexture;
|
||||
|
||||
// Sector the SideDef is facing.
|
||||
sector_t* sector;
|
||||
|
||||
} side_t;
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Move clipping aid for LineDefs.
|
||||
//
|
||||
typedef enum
|
||||
{
|
||||
ST_HORIZONTAL,
|
||||
ST_VERTICAL,
|
||||
ST_POSITIVE,
|
||||
ST_NEGATIVE
|
||||
|
||||
} slopetype_t;
|
||||
|
||||
|
||||
|
||||
typedef struct line_s
|
||||
{
|
||||
// Vertices, from v1 to v2.
|
||||
vertex_t* v1;
|
||||
vertex_t* v2;
|
||||
|
||||
// Precalculated v2 - v1 for side checking.
|
||||
fixed_t dx;
|
||||
fixed_t dy;
|
||||
|
||||
// Animation related.
|
||||
short flags;
|
||||
short special;
|
||||
short tag;
|
||||
|
||||
// Visual appearance: SideDefs.
|
||||
// sidenum[1] will be -1 if one sided
|
||||
short sidenum[2];
|
||||
|
||||
// Neat. Another bounding box, for the extent
|
||||
// of the LineDef.
|
||||
fixed_t bbox[4];
|
||||
|
||||
// To aid move clipping.
|
||||
slopetype_t slopetype;
|
||||
|
||||
// Front and back sector.
|
||||
// Note: redundant? Can be retrieved from SideDefs.
|
||||
sector_t* frontsector;
|
||||
sector_t* backsector;
|
||||
|
||||
// if == validcount, already checked
|
||||
int validcount;
|
||||
|
||||
// thinker_t for reversable actions
|
||||
void* specialdata;
|
||||
} line_t;
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// A SubSector.
|
||||
// References a Sector.
|
||||
// Basically, this is a list of LineSegs,
|
||||
// indicating the visible walls that define
|
||||
// (all or some) sides of a convex BSP leaf.
|
||||
//
|
||||
typedef struct subsector_s
|
||||
{
|
||||
sector_t* sector;
|
||||
short numlines;
|
||||
short firstline;
|
||||
|
||||
} subsector_t;
|
||||
|
||||
|
||||
|
||||
//
|
||||
// The LineSeg.
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
vertex_t* v1;
|
||||
vertex_t* v2;
|
||||
|
||||
fixed_t offset;
|
||||
|
||||
angle_t angle;
|
||||
|
||||
side_t* sidedef;
|
||||
line_t* linedef;
|
||||
|
||||
// Sector references.
|
||||
// Could be retrieved from linedef, too.
|
||||
// backsector is NULL for one sided lines
|
||||
sector_t* frontsector;
|
||||
sector_t* backsector;
|
||||
|
||||
} seg_t;
|
||||
|
||||
|
||||
|
||||
//
|
||||
// BSP node.
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
// Partition line.
|
||||
fixed_t x;
|
||||
fixed_t y;
|
||||
fixed_t dx;
|
||||
fixed_t dy;
|
||||
|
||||
// Bounding box for each child.
|
||||
fixed_t bbox[2][4];
|
||||
|
||||
// If NF_SUBSECTOR its a subsector.
|
||||
unsigned short children[2];
|
||||
|
||||
} node_t;
|
||||
|
||||
|
||||
|
||||
|
||||
// posts are runs of non masked source pixels
|
||||
typedef struct
|
||||
{
|
||||
byte topdelta; // -1 is the last post in a column
|
||||
byte length; // length data bytes follows
|
||||
} post_t;
|
||||
|
||||
// column_t is a list of 0 or more post_t, (byte)-1 terminated
|
||||
typedef post_t column_t;
|
||||
|
||||
|
||||
|
||||
// PC direct to screen pointers
|
||||
//B UNUSED - keep till detailshift in r_draw.c resolved
|
||||
//extern byte* destview;
|
||||
//extern byte* destscreen;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// OTHER TYPES
|
||||
//
|
||||
|
||||
// This could be wider for >8 bit display.
|
||||
// Indeed, true color support is posibble
|
||||
// precalculating 24bpp lightmap/colormap LUT.
|
||||
// from darkening PLAYPAL to all black.
|
||||
// Could even us emore than 32 levels.
|
||||
typedef byte lighttable_t;
|
||||
|
||||
|
||||
|
||||
|
||||
//
|
||||
// ?
|
||||
//
|
||||
typedef struct drawseg_s
|
||||
{
|
||||
seg_t* curline;
|
||||
int x1;
|
||||
int x2;
|
||||
|
||||
fixed_t scale1;
|
||||
fixed_t scale2;
|
||||
fixed_t scalestep;
|
||||
|
||||
// 0=none, 1=bottom, 2=top, 3=both
|
||||
int silhouette;
|
||||
|
||||
// do not clip sprites above this
|
||||
fixed_t bsilheight;
|
||||
|
||||
// do not clip sprites below this
|
||||
fixed_t tsilheight;
|
||||
|
||||
// Pointers to lists for sprite clipping,
|
||||
// all three adjusted so [x1] is first value.
|
||||
short* sprtopclip;
|
||||
short* sprbottomclip;
|
||||
short* maskedtexturecol;
|
||||
|
||||
} drawseg_t;
|
||||
|
||||
|
||||
|
||||
// Patches.
|
||||
// A patch holds one or more columns.
|
||||
// Patches are used for sprites and all masked pictures,
|
||||
// and we compose textures from the TEXTURE1/2 lists
|
||||
// of patches.
|
||||
typedef struct
|
||||
{
|
||||
short width; // bounding box size
|
||||
short height;
|
||||
short leftoffset; // pixels to the left of origin
|
||||
short topoffset; // pixels below the origin
|
||||
int columnofs[8]; // only [width] used
|
||||
// the [0] is &columnofs[width]
|
||||
} patch_t;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// A vissprite_t is a thing
|
||||
// that will be drawn during a refresh.
|
||||
// I.e. a sprite object that is partly visible.
|
||||
typedef struct vissprite_s
|
||||
{
|
||||
// Doubly linked list.
|
||||
struct vissprite_s* prev;
|
||||
struct vissprite_s* next;
|
||||
|
||||
int x1;
|
||||
int x2;
|
||||
|
||||
// for line side calculation
|
||||
fixed_t gx;
|
||||
fixed_t gy;
|
||||
|
||||
// global bottom / top for silhouette clipping
|
||||
fixed_t gz;
|
||||
fixed_t gzt;
|
||||
|
||||
// horizontal position of x1
|
||||
fixed_t startfrac;
|
||||
|
||||
fixed_t scale;
|
||||
|
||||
// negative if flipped
|
||||
fixed_t xiscale;
|
||||
|
||||
fixed_t texturemid;
|
||||
int patch;
|
||||
|
||||
// for color translation and shadow draw,
|
||||
// maxbright frames as well
|
||||
lighttable_t* colormap;
|
||||
|
||||
int mobjflags;
|
||||
|
||||
} vissprite_t;
|
||||
|
||||
|
||||
//
|
||||
// Sprites are patches with a special naming convention
|
||||
// so they can be recognized by R_InitSprites.
|
||||
// The base name is NNNNFx or NNNNFxFx, with
|
||||
// x indicating the rotation, x = 0, 1-7.
|
||||
// The sprite and frame specified by a thing_t
|
||||
// is range checked at run time.
|
||||
// A sprite is a patch_t that is assumed to represent
|
||||
// a three dimensional object and may have multiple
|
||||
// rotations pre drawn.
|
||||
// Horizontal flipping is used to save space,
|
||||
// thus NNNNF2F5 defines a mirrored patch.
|
||||
// Some sprites will only have one picture used
|
||||
// for all views: NNNNF0
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
// If false use 0 for any position.
|
||||
// Note: as eight entries are available,
|
||||
// we might as well insert the same name eight times.
|
||||
boolean rotate;
|
||||
|
||||
// Lump to use for view angles 0-7.
|
||||
short lump[8];
|
||||
|
||||
// Flip bit (1 = flip) to use for view angles 0-7.
|
||||
byte flip[8];
|
||||
|
||||
} spriteframe_t;
|
||||
|
||||
|
||||
|
||||
//
|
||||
// A sprite definition:
|
||||
// a number of animation frames.
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
int numframes;
|
||||
spriteframe_t* spriteframes;
|
||||
|
||||
} spritedef_t;
|
||||
|
||||
|
||||
|
||||
//
|
||||
// Now what is a visplane, anyway?
|
||||
//
|
||||
typedef struct
|
||||
{
|
||||
fixed_t height;
|
||||
int picnum;
|
||||
int lightlevel;
|
||||
int minx;
|
||||
int maxx;
|
||||
|
||||
// leave pads for [minx-1]/[maxx+1]
|
||||
|
||||
byte pad1;
|
||||
// Here lies the rub for all
|
||||
// dynamic resize/change of resolution.
|
||||
byte top[SCREENWIDTH];
|
||||
byte pad2;
|
||||
byte pad3;
|
||||
// See above.
|
||||
byte bottom[SCREENWIDTH];
|
||||
byte pad4;
|
||||
|
||||
} visplane_t;
|
||||
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
//-----------------------------------------------------------------------------
|
||||
//
|
||||
// $Log:$
|
||||
//
|
||||
//-----------------------------------------------------------------------------
|
||||
Loaded 100 of 175 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user