mirror of
https://github.com/ZDoom/Raze.git
synced 2024-12-16 07:31:23 +00:00
d9867cfaaf
git-svn-id: https://svn.eduke32.com/eduke32@1105 1a8010ca-5511-0410-912e-c29ae57300e0
5081 lines
238 KiB
Text
5081 lines
238 KiB
Text
// "Build Engine & Tools" Copyright (c) 1993-1997 Ken Silverman
|
|
// Ken Silverman's official web site: "http://www.advsys.net/ken"
|
|
// See the included license file "BUILDLIC.TXT" for license info.
|
|
|
|
BUILD engine Notes (8/14/95):
|
|
|
|
BUILD programmed by Ken Silverman
|
|
|
|
ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
|
|
³ GAME KEYS: ³
|
|
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
|
|
ESC = Quit
|
|
Mouse = Movement
|
|
Arrows = Movement
|
|
Lt. Enter = Single-player: Play back game.
|
|
Multi-player: View from other player's eyes.
|
|
Rt. Enter = Switch between 3D / 2D modes
|
|
Lt. +/- = Zoom in 2D mode
|
|
A/Z = Move up and down
|
|
Left-Ctrl = Shoot
|
|
1/2 = Select weapon
|
|
Left-Shift = Run
|
|
T = Reset Timing (sets totalclock = 0)
|
|
V = Change visibility. In BUILD.H there is a visiblity variable.
|
|
It is initialized to 13. It can range from around 8 (darker)
|
|
to about 15 (lighter).
|
|
P = Change parallaxing sky mode. (0, 1, and 2 (Default = 2)
|
|
F12 = Screen capture (saves image as a *.BMP file, starting as file
|
|
name CAPTUR00.BMP and incrementing by 1 each time F12 is
|
|
pressed.
|
|
|
|
ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
|
|
³ BUILD EDITOR INTRODUCTION: ³
|
|
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
|
|
|
|
There are 2 modes in the BUILD editor:
|
|
3D EDIT MODE (Same as PLAY MODE but with a mouse cursor)
|
|
2D EDIT MODE (The overhead map of the board with an arrow showing your
|
|
position and angle and a mouse cursor)
|
|
|
|
It is essential that you use both editor modes:
|
|
|
|
Use the 3D EDIT MODE to change the attributes of a sector, wall, or sprite
|
|
such as:
|
|
|
|
Tile number - Tells which picture in the artwork file goes on the
|
|
object. Press V to change.
|
|
Shade - The shade of the object. Press -/+ to change.
|
|
Repeating - The "smooshiness" of a wall. Also for sprites. Press
|
|
keypad 2,4,6,8 to change.
|
|
Panning - The starting offset into the tile graphics. Press
|
|
Shift + keypad 2,4,6,8 to change.
|
|
Height - For ceilings, floors, and sprites. Press PGUP or PGDN
|
|
to change.
|
|
and there are a few other special attributes.
|
|
|
|
Use the 2D EDIT MODE to add, delete, or change the shape of sectors.
|
|
|
|
To switch between the two EDIT MODES, press the keypad enter key.
|
|
|
|
ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
|
|
³ 3D EDIT MODE KEYS: ³
|
|
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
|
|
ESC = Quit
|
|
keypad ENTER = Flip to the 2D overhead editor
|
|
|
|
Mouse = Move mouse cursor
|
|
Arrows = Move you in the appropriate directions
|
|
Caps Lock = There are 3 different Z coordinate modes in BUILD.
|
|
Mode 0: Game mode (default)
|
|
Mode 1: Height lock mode
|
|
Mode 2: Float mode
|
|
Press Caps Lock to switch between the 3 modes.
|
|
A and Z move up and down for all 3 modes.
|
|
|
|
|
|
Note: For the following keys, it is important to move the mouse cursor to
|
|
the right position before using them. Also, if you hold down the first mouse
|
|
button, then the item under the mouse cursor will be locked as the
|
|
highlighted object while the button is held down. This is useful for the
|
|
PGUP/DN keys, when different objects come into view even without moving your
|
|
coordinates or the mouse cursor.
|
|
There are 4 basic types of objects that can be worked with in this part
|
|
of the editor: WALLS, CEILINGS, FLOORS, and SPRITES.
|
|
|
|
PGUP/DN = Raise or Lower a ceiling or floor. (If a wall is selected,
|
|
the ceiling of that sector will move) Also, if you did a
|
|
sector highlight in 2D EDIT MODE, you can raise / lower
|
|
multiple sectors at a time.
|
|
Ctrl-PGUP/DN = For sprites only, puts sprites exactly on the floor or exactly
|
|
on the ceiling.
|
|
|
|
V = Tile selection - use arrow keys to move around. Press ENTER
|
|
to change the object to the highlighted piece of artwork, or
|
|
press ESC to cancel without changes made.
|
|
ALT-V = Height selection - works just like V, but this selects the
|
|
groudraw height map.
|
|
|
|
2,4,6,8 (keypad) = Repeat values (smooshiness of the sizes of pixels) -
|
|
think of these keys as arrow keys controlling the bottom
|
|
right corner of the bitmap. Normally, this is used for walls
|
|
and sprites. If you select a floor or ceiling, all the walls
|
|
in that sector will be affected. Perhaps this can be used
|
|
to make sprites grow and shrink as they get healthy or hurt.
|
|
Shift +
|
|
2,4,6,8 (keypad) = Panning values (offset into the tile) - These keys are
|
|
useful when the you want a long wall to look continuous when
|
|
they normally would not look continuous.
|
|
/ = Use this key to reset the panning values (if you're lost!)
|
|
5 (keypad) = If you hold down this key down in addition to the 2,4,6,8
|
|
keys (keypad),the values will align at multiples of 8.
|
|
.> = This key attempts to match up all the tiles along a wall. It
|
|
scans along the walls towards the right as long as the picture
|
|
number of the next wall is the same as the original picture
|
|
number. Note that some walls may not work right, especially
|
|
floor / ceiling steps.
|
|
|
|
F = Flip an object. For sprites and walls, this flips the object
|
|
x-wise. For ceilings and floors, the objects are flipped in
|
|
8 possible ways. Just keep pressing 'F' to go through
|
|
the 8 ways.
|
|
ALT-F = When you use relative alignment mode on ceiling and floor
|
|
textures, you can press Alt-F on the ceiling or floor to
|
|
choose a new wall to align to. It actually rotates the walls
|
|
of a sector by 1.
|
|
O = Wall orientation (whether it starts from the top or bottom)
|
|
Normally, walls are oriented from the top. For example, if
|
|
you hold down 2/8 on the keypad in 3D EDIT MODE, the wall
|
|
always starts from the top. Orientation works differently
|
|
for white lines and red lines, so if a wall doesn't look
|
|
right, just press 'O' anyway to see if it get fixed.
|
|
|
|
COPY & PASTE
|
|
TAB = COPY. Copy the attibutes of the highlighted objects into a
|
|
temporary place. The attributes it remembers are:
|
|
tile, shade, x-repeat, y-repeat, and cstat values.
|
|
Left ENTER = PASTE. Paste the stored attributes over the highlighted
|
|
object. Whenever you press ENTER, the y-repeat values stay
|
|
the same, and the x-repeat values are adjusted so the pixels
|
|
of the bitmaps have a square-aspect ratio.
|
|
Ctrl+L.ENTER = Left ENTER with the ctrl key will paste the attribtues to
|
|
every wall in a loop (if a wall is highlighted).
|
|
Shft+L.ENTER = Left ENTER with the shift key also pressed copies the shade
|
|
only.
|
|
Ctrl+Shft+L.ENTER = Auto-shade a sector. First make any wall of the loop
|
|
as light as the lightest shade you want. Then make any other
|
|
wall of the loop as dark as the darkest shade you want.
|
|
Finally press Ctrl-Shift Enter on the wall that should be
|
|
lightest. Now the loop should be smoothly shaded. If it
|
|
is not smoothly shaded, you may need to insert more points
|
|
on the walls.
|
|
|
|
SECTOR FLAGS:
|
|
|
|
P = Make the ceiling of the given sector have a Parallaxing sky
|
|
or just a normal ceiling.
|
|
G = Make the floor of the given sector have a Groudraw
|
|
(floor with height mapping). I do not recommend using this
|
|
attribute very extensively yet. (See the H key for selecting
|
|
the height map)
|
|
E = An option for ceilings and floors. If for some reason, you
|
|
want a tile to be smooshed into the normal 64*64 area, press
|
|
E to unExpand the tile. Press E again, and the tile will be
|
|
expanded, so the pixel size is the same as the normal 64*64
|
|
ceiling/floor.
|
|
R = Relative alignment - switch between relative alignment mode
|
|
and normal mode. Allows floor / ceiling textures to align
|
|
to the first 2 points of a sector. Textures will rotate/pan
|
|
with moving sectors properly. Notice that bit 6 of both
|
|
sector[].ceilingstat and sector[].floorstat are relative
|
|
alignment bits.
|
|
|
|
WALL FLAGS:
|
|
|
|
B = Make an invisible wall, such as a window, block you from
|
|
going through. Since the wall is invisible, you can also
|
|
highlight the ceiling right above the window or floor
|
|
right below the window. You can block either the front or
|
|
the back of the window. If you block the back only, you
|
|
will be able to go onto the window sill.
|
|
T = Press to make a maskable wall 50/50 transluscent. Press T
|
|
again to put the masked wall back to normal mode.
|
|
M = Make a maskable wall. Press in the same place you press 'B'.
|
|
The masking wall takes all its attributes from the front of
|
|
the wall, so it must have the same repeat, panning, and cstat
|
|
values as the walls above or below it (if you have a step).
|
|
The masking picture number is stored in overpicnum. Also,
|
|
the masking walls is also automatically added the the other
|
|
side of the wall, with the picture flipped. (see the 'F'
|
|
key descripte above)
|
|
Shift + M = Make a maskable wall just like 'M' described above, but only
|
|
on the front side.
|
|
|
|
1 = Make a 1-way wall.
|
|
2 = Some walls have two different sections. One step on the
|
|
ceiling and one step on the floor. Normally they always
|
|
have the same attributes. It is possible though, to give
|
|
both the top and bottom different attributes by pressing 2 on
|
|
that wall. 2 simply makes the bottom wall's attributes
|
|
separately editable. Press 2 on either the top or bottom
|
|
wall.
|
|
O = Wall orientation (whether it starts from the top or bottom)
|
|
Normally, walls are oriented from the top. For example, if
|
|
you hold down 2/8 on the keypad in 3D EDIT MODE, the wall
|
|
always starts from the top. Orientation works differently
|
|
for white lines and red lines, so if a wall doesn't look
|
|
right, just press 'O' anyway to see if it get fixed.
|
|
H = Toggle hitscan pass through bit. Default is pass through.
|
|
|
|
SPRITE FLAGS:
|
|
|
|
B = When the mouse cursor is on a sprite, this makes a sprite
|
|
block you from walking through. Also makes the sprite
|
|
sensitive to hitscan. Sprites with the 'B' attribute will
|
|
appear pink in 2D EDIT MODE
|
|
T = Press to make a sprite 50/50 transluscent. Press T again
|
|
to put sprite back to normal mode.
|
|
|
|
ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
|
|
³ 2D EDIT MODE KEYS: ³
|
|
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
|
|
ESC = Show a menu that says, "(N)ew, (L)oad, (S)ave, (Q)uit"
|
|
Press ESC again to cancel the menu.
|
|
keypad ENTER = Flip back to the 3D edit mode
|
|
|
|
Mouse = Move mouse cursor
|
|
Left mouse button = If you hold down the left mouse button, you can drag
|
|
existing points. To drag multiple points you can use
|
|
the right shift key to first select a rectangular
|
|
region of points to highlight, then just drag any of
|
|
the highlighted points and the rest move with it.
|
|
Right mouse button = Moves the player's positions to the mouse cursor.
|
|
This is useful when you accidently get stuck somewhere
|
|
in the board, or when you need to edit some part of
|
|
a sector that is hard to access.
|
|
Right Shift = Select a bunch of points for use with dragging around.
|
|
Selects all points inside a box. (Use the left mouse
|
|
button to drag)
|
|
Ctrl+Right Shift = Select a bunch of points for use with dragging around.
|
|
Selects all points on a loop. (Use the left mouse
|
|
button to drag)
|
|
Right Alt = Select a bunch of sectors for either duplication or
|
|
dragging around. (see left mouse button for
|
|
dragging and the insert key for duplication).
|
|
|
|
Arrows = Move player position in the appropriate directions.
|
|
The player will be clipped. To jump to a different part
|
|
of the board, use the right mouse button.
|
|
Space = Press the space bar when drawing new sectors. There
|
|
are several ways of drawing new sectors. The following
|
|
three ways of drawing sectors can all be done by only
|
|
using the space bar. The computer is smart enough to
|
|
decide which method you are using.
|
|
|
|
1. Drawing a FULL LOOP - that is, whenever the new
|
|
sector meets the old sector, draw over that line
|
|
again. In full loop mode the new sector must not
|
|
already be in another sector. The loop is done
|
|
when you press the space bar at the first point
|
|
again.
|
|
2. SPLITTING a sector - press space bar to draw points
|
|
at which you want to split a sector. The computer
|
|
knows you are done splitting when you end at
|
|
another point that's on the edge of the sector you
|
|
are splitting.
|
|
3. Drawing a sector COMPLETELY INSIDE another sector.
|
|
(for example, columns) To do this, just press space
|
|
bar at every point in the loop. The loop is done
|
|
when you press the space bar at the first point
|
|
again.
|
|
Backspace = When plotting points with the space bar, you can use
|
|
backspace to get rid of the last point plotted. You
|
|
can press the backspace to get rid of all the points
|
|
if you didn't want to start a sector at all.
|
|
|
|
Insert = Inserts a new point at the midpoint of the highlighted
|
|
line. Then you can drag the point to wherever you like.
|
|
(If you insert on a red line, the point will be inserted
|
|
on both sides of the sector line.)
|
|
If a bunch of sectors are selected (see right ALT) then
|
|
instead of inserted points, the selected sector bunch
|
|
will be duplicated (stamped). Don't forget to drag
|
|
the selected sectors after stamping.
|
|
|
|
Delete = Use this to delete sprites (blue circles). To delete
|
|
points of a sector border, don't press delete. Instead,
|
|
drag the point into one of its 2 neighbor points on the
|
|
sector. This is easist done if grid locking is on
|
|
(mouse cursor is pink). If 2 neighbor points are equal,
|
|
one will automatically be deleted.
|
|
Right Ctrl-Delete = This deletes the whole sector that the mouse cursor is
|
|
in. Note the right ctrl for protection.
|
|
(Note: to delete a point of a sector, just drag that point into the next
|
|
point and it will automatically be deleted. You should do this with
|
|
grid-locking on)
|
|
J = Use to join two neighboring sectors. Press J when mouse
|
|
cursor is over the first sector. Then press J again
|
|
when the mouse cursor is over the neighboring sector.
|
|
The attributes of the combined sector will be taken from
|
|
the first sector selected.
|
|
ALT-S = When you have a white loop inside a sector, you can
|
|
press ALT-S on it (highlight any of its lines) to turn
|
|
the whole loop red.
|
|
S = Places a sprite at the location under the mouse cursor.
|
|
A sprite looks like a blue circle in the overhead map.
|
|
|
|
B = Blocks / unblocks you from going through a wall or
|
|
sprites. A blocked wall or sprite will appear pink
|
|
in 2D EDIT MODE. See the description for 'B' in
|
|
the 3D EDIT MODE section for more details.
|
|
|
|
C = Turn a line into a circle defined by short line
|
|
segments. First press 'C' on a highlighted wall. Then
|
|
move the mouse to the right place and press '+' or '-'
|
|
if you want to change the number of points on the
|
|
circle. Press 'C' again to cancel the circle drawing or
|
|
press the Space bar to actually change the map.
|
|
+/- = Increase / Decrease the number of points on the circle.
|
|
|
|
T = Type in a LO-tag for a sector. Move the mouse cursor to
|
|
the inside of a sector that you want to tag first.
|
|
ALT-T = Just like 'T' but for walls and sprites.
|
|
H = Type in a HI-tag for a sector. Move the mouse cursor to
|
|
the inside of a sector that you want to tag first.
|
|
ALT-H = Just like 'H' but for walls and sprites.
|
|
E = Change a sprite's status list number.
|
|
< and > = Changes angle of sprite. Move the mouse cursor to a
|
|
sprite first. You can hold down shift with the < and >
|
|
to get more precise angles. If you did a sector
|
|
highlight, then the selected sector will be rotated
|
|
instead.
|
|
CTRL-T = Turn tag boxes on/off.
|
|
|
|
TAB = Move the mouse cursor to the inside of a sector that you
|
|
you want to see the attributes of. It will show them
|
|
at the bottom of the status bar. To clear it, press
|
|
TAB again at somewhere in the board that is not part
|
|
of any sector. This is a useful key for debugging.
|
|
ALT-TAB = Works just like TAB, but here, you can see the
|
|
attributes of highlighted walls or sprites. For red
|
|
lines, the side the mouse cursor is on the line affects
|
|
which line is highlighted, since red lines are actually
|
|
defined as 2 walls (1 wall for each sector).
|
|
|
|
Scroll Lock = Set starting position (brown arrow) to your current
|
|
position (white arrow).
|
|
|
|
A,Z = Zoom in and out. This is useful for choosing whether
|
|
you want to edit finely or not.
|
|
G = Change grid resolution. The grid resolution cycles
|
|
through this sequence:
|
|
(off, 1x, 2x, 4x (default), 8x, 16x)
|
|
L = Turns grid locking on or off. If the mouse cursor is
|
|
pink then grid locking is on. If it is white then
|
|
grid locking is off. There is no grid locking
|
|
if the grid is turned off. Also, grid locking will
|
|
lock to nearby points.
|
|
|
|
ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
|
|
³ EDITART KEYS: ³
|
|
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
|
|
|
|
---- Keys you will need to know if you want to select from a section of
|
|
a 320*200*256 picture file (.BMP and .PCX only) and put it into the BUILD
|
|
engine.
|
|
|
|
U - Use this to import a section of a 320*200*256 .BMP, .PCX, or .GIF.
|
|
³ Enter - Convert the image that is inside the rectangular selection
|
|
³ rectangle to the BUILD palette.
|
|
³ Space - Convert the image that is inside the rectangular selection
|
|
³ rectangle without remapping the palette.
|
|
³ P - If in the picture selecting screen (after pressing U and loading
|
|
³ the picture), you press P, then the palette of BUILD can be
|
|
ÀÄÄ replaced by the palette of the displayed picture.
|
|
PGUP/PGDN - Select tile to edit (4096 tile maximum right now).
|
|
G - GOTO a tile by typing in the tile number.
|
|
S - Re-size tile. The X and Y sizes can be any unsigned short integer.
|
|
X ranges from 0 to 1024, and Y ranges from 0 to 240.
|
|
Delete - short cut key to set both the X and Y sizes to 0.
|
|
+,- Change the animation setting. (Default: NoAnm = 0.)
|
|
To change the animation type, press - when the value is 0.
|
|
Ex: If you want an object to have 4 tiles of animation, you can
|
|
animate it in 4 different sequences: (0 is the current tile)
|
|
NoAnm=4 sequence: 0,0,0,0,0,0,0,0,0,0,0,... (no animation)
|
|
Oscis=4 sequence: 0,1,2,3,2,1,0,1,2,3,2,... (oscillate)
|
|
AnmFD=4 sequence: 0,1,2,3,0,1,2,3,0,1,2,... (forwards)
|
|
AnmBK=4 sequence: 0,-1,-2,-3,0,-1,-2,-3,... (backwards)
|
|
A - Set the animation speed of the tile. Press + and - to change the
|
|
animation speed. There are 16 different animation speeds. The
|
|
animation speed set here set the speed for BUILD and your GAME also.
|
|
(Speed is proportional to (totalclock>>animspeed))
|
|
~' - This key (located just above the TAB key) allows you to center a
|
|
sprite. Simply use the arrow keys to get to the desired position.
|
|
N - Name a tile. Naming a tile simply changes the #define statement in
|
|
NAMES.H. You should include NAMES.H when compiling so you can easily
|
|
refer to sprites by name rather than by number.
|
|
O - Optimize the size of an individual piece of artwork. Use this for
|
|
tiles with invisible pixels on the sides.
|
|
V - View and select a tile to edit.
|
|
³ Space - To swap 2 tiles simply press space bar on the first tile,
|
|
³ then space bar on the second.
|
|
³ 1,2,3 - To swap a group of tiles, press 1 on the first tile,
|
|
³ press 2 to remember the region between where you pressed
|
|
³ 1 and 2. Press 3 at the place to where you want to swap
|
|
ÀÄÄ all the tiles.
|
|
ALT+U- Re-grab artwork from original pictures according to the CAPFIL.TXT
|
|
file. If you press ALT-U in the main screen, everything will be
|
|
re-grabbed. If you press ALT-U in 'V' mode, then you should first
|
|
select the range by pressing '1' and '2' on the range boundaries.
|
|
ALT+R- Generate a Tile frequency report by scanning all maps in directory.
|
|
Use in 'V' mode only.
|
|
F12 - Screen capture (saves image as a *.BMP file, starting as file
|
|
name CAPTUR00.BMP and incrementing by 1 each time F12 is
|
|
pressed.
|
|
|
|
ESC - Quit.
|
|
|
|
|
|
|
|
---- Extra features: (if you actually want to do the artwork in EDITART
|
|
or if you want to touch-up some imported art.)
|
|
|
|
C - Change all pixels on the tile having the same color under the
|
|
graphics cursor to to selected color.
|
|
Arrows / Mouse - Move graphics cursor.
|
|
Shift + Arrows - Select color. (on bottom right corner of screen)
|
|
Space - Plot a pixel with the selected color.
|
|
T - Turn drawing trail on / off.
|
|
Tab - Select the color under the graphics cursor.
|
|
BACKSPACE - Set the color to color 255 (transparent color).
|
|
F - Floodfill a region with the current color and with the current
|
|
color as a boundary.
|
|
M,P - Use M to back up a tile into a temporary buffer in memory and P
|
|
to restore it. It may be wise to press M before a floodfill (F)
|
|
(because sometimes you miss encapsulating the region by 1 pixel,
|
|
and the whole picture gets killed, etc...)
|
|
J - Randomly plots dots of current color over any pixels having the
|
|
same color as the color under the tile cursor.
|
|
[ - Random antialias of colors in color band under graphics cursor.
|
|
] - Non-random antialias of colors in color band under graphics cursor.
|
|
; - 3-Dimentionalize an image. Makes colors in different rows of the
|
|
color bar either appear to stick out or stick in to the wall.
|
|
' - 3-Dimentionalize the other way.
|
|
R - Rotate the tile in a specified direction.
|
|
|
|
1 - Mark the first corner of a rectangle for a copy/paste operation.
|
|
2 - Mark the other corner of a rectangle for a copy/paste operation.
|
|
3 - Paste the selected rectangle (Note: You must press 1 and 2 in that
|
|
order first before pressing 3. Pretty simple 1-2-3 for copy&paste)
|
|
|
|
4 - Flip the copied rectangular region x-wise.
|
|
5 - Flip the copied rectangular region y-wise.
|
|
6 - Swap the x and y coordinates of the copied rectangular region.
|
|
|
|
,.<> - Change the shade of the selected region.
|
|
\ - Move the cursor to the center or the tile.
|
|
| - Get the coordinates of the cursor.
|
|
|
|
ÉÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍ»
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÈÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊͼ
|
|
|
|
ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
|
|
³ IMPORTANT ENGINE FUNCTIONS: ³
|
|
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
|
|
|
|
initengine(char vidoption, long xdim, long ydim)
|
|
Sets up interrupt vectors for keyboard, and initializes many variables
|
|
for the BUILD engine. You should call this once before any other
|
|
functions of the BUILD engine are used.
|
|
|
|
vidoption can be anywhere from 0-6
|
|
xdim,ydim can be any mode x resolution if vidoption = 0
|
|
xdim,ydim can be any vesa resolution if vidoption = 1
|
|
xdim,ydim must be 320*200 for any other mode.
|
|
(see graphics mode selection in my setup program)
|
|
uninitengine();
|
|
Restores interrupt vectors for keyboard and timer, and frees
|
|
buffers. You should call this once at the end of the program
|
|
before quitting to dos.
|
|
loadboard(char *filename, long *posx, long *posy, long *posz, short *ang, short *cursectnum)
|
|
Loads the given board file into memory for the BUILD engine.
|
|
Returns -1 if file not found. If no extension is given, .MAP will
|
|
be appended to the filename.
|
|
saveboard(char *filename, long *posx, long *posy, long *posz, short *ang, short *cursectnum)
|
|
Saves the given board from memory inro the specified filename.
|
|
Returns -1 if unable to save. If no extension is given, .MAP will
|
|
be appended to the filename.
|
|
loadpics(char *filename);
|
|
Loads the given artwork file into memory for the BUILD engine.
|
|
Returns -1 if file not found. If no extension is given, .ART will
|
|
be appended to the filename.
|
|
setgamemode();
|
|
This function sets the video mode to 320*200*256color graphics.
|
|
Since BUILD supports several different modes including mode x,
|
|
mode 13h, and other special modes, I don't expect you to write
|
|
any graphics output functions. (Soon I have all the necessary
|
|
functions) If for some reason, you use your own graphics mode,
|
|
you must call this function again before using the BUILD drawing
|
|
functions.
|
|
|
|
drawrooms(long posx, long posy, long posz, short ang, long horiz, short cursectnum)
|
|
This function draws the 3D screen to the current drawing page,
|
|
which is not yet shown. This way, you can overwrite some things
|
|
over the 3D screen such as a gun. Be sure to call the drawmasks()
|
|
function soon after you call the drawrooms() function. To view
|
|
the screen, use the nextpage() function. The nextpage() function
|
|
should always be called sometime after each draw3dscreen()
|
|
function.
|
|
drawmasks();
|
|
This function draws all the sprites and masked walls to the current
|
|
drawing page which is not yet shown. The reason I have the drawing
|
|
split up into these 2 routines is so you can animate just the
|
|
sprites that are about to be drawn instead of having to animate
|
|
all the sprites on the whole board. Drawrooms() prepares these
|
|
variables: spritex[], spritey[], spritepicnum[], thesprite[],
|
|
and spritesortcnt. Spritesortcnt is the number of sprites about
|
|
to be drawn to the page. To change the sprite's picnum, simply
|
|
modify the spritepicnum array If you want to change other parts
|
|
of the sprite structure, then you can use the thesprite array to
|
|
get an index to the actual sprite number.
|
|
|
|
engineinput();
|
|
This function allows the engine to adjust your position depending
|
|
on the status of the arrow keys, and other control keys. It
|
|
handles timing and clipping.
|
|
nextpage();
|
|
After a screen is prepared, use this function to view the screen.
|
|
|
|
draw2dscreen(long posxe, long posye, short ange, long zoome,
|
|
short gride)
|
|
Draws the 2d screen - this function is a direct replacement
|
|
for the drawrooms() and drawmasks() functions. Be sure
|
|
to call either qsetmode640350() or qsetmode640480()
|
|
first. When switching back to 3d mode, be sure to call
|
|
qsetmode320200().
|
|
IMPORTANT NOTES:
|
|
1. The overwritesprite function should only be called in
|
|
3D mode. If you do this in 2D mode, junk will be
|
|
written to the 2D screen and a crash is possible.
|
|
2. When you switch back to 3D mode, you should call the
|
|
permanentwritesprite functions to draw the status bar,
|
|
or whatever else you have to draw.
|
|
3. You must call the nextpage() function in both 2D and
|
|
3D modes.
|
|
qsetmode320200();
|
|
Set to the game mode and load palette (320*200*256)
|
|
qsetmode640350();
|
|
Set to the 2D map mode #1 (640*350*16)
|
|
qsetmode640480();
|
|
Set to the 2D map mode #2 (640*480*16)
|
|
|
|
doanimations(long numtics);
|
|
This function animates anything you use setanimation for (like doors).
|
|
You should call it for every frame. Pass the number of tics (lockspeed)
|
|
as a parameter to it to tell how much everything should animate.
|
|
|
|
kenchaintimer(void (__interrupt __far *datimerchainaddress)(),
|
|
short dachainpersecond)
|
|
This function makes the engine's timerhandler chain to another timer
|
|
handler at any specified interrupt rate. This function forces IRQ0 to
|
|
point to my engine's timerhandler. Clockspeed and totalclock will
|
|
be fixed at counting 120 per second regardless of the chaining interrupt
|
|
rate. If you call this function with a NULL pointer, then the engine's
|
|
timerhandler will not chain anymore.
|
|
|
|
Here's how you should structure your code if you use this function:
|
|
|
|
main()
|
|
{
|
|
initengine();
|
|
|
|
musicon(); //Turn music on after engine
|
|
kenchaintimer(yourtimerhandleraddress,yourtimerrate);
|
|
//When IRQ0 goes off, it will now go to
|
|
//Ken's timer handler. Then, Ken's timer
|
|
(main loop) //handler will make yourtimerhandler
|
|
//interrupt yourtimerrate times per second
|
|
|
|
kenchaintimer(0,0); //Stop chaining BEFORE music handler dies!
|
|
musicoff();
|
|
|
|
uninitengine();
|
|
}
|
|
|
|
ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
|
|
³ OTHER ENGINE FUNCTIONS: ³
|
|
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
|
|
|
|
overwritesprite (long thex, long they, short tilenum,
|
|
signed char shade, char orientation, char dapalnum)
|
|
|
|
Use this function to draw any sprites that must be drawn to the screen
|
|
for every single frame, such as a gun or a menu system.
|
|
|
|
If Bit 0 of orientation = 0: (thex, they) is top-left corner
|
|
If Bit 0 of orientation = 1: (thex, they) is middle
|
|
If Bit 1 of orientation = 0: no relation to viewing window
|
|
If Bit 1 of orientation = 1: scale and clip to viewing window
|
|
If Bit 2 of orientation = 0: normal
|
|
If Bit 2 of orientation = 1: 50/50 transluscent!
|
|
If Bit 3 of orientation = 0: normal
|
|
If Bit 3 of orientation = 1: x-flipped
|
|
If Bit 4 of orientation = 0: normal
|
|
If Bit 4 of orientation = 1: y-flipped
|
|
|
|
* If it works at full screen, simply set bit 1 of orientation
|
|
to 1, and it should automatically scale properly!
|
|
|
|
Use this function to write sprites over the 3d view. For example,
|
|
you can make a menu system with this function. Be sure
|
|
that you call this function for every single frame after the 3d
|
|
view is drawn or else it will be flashed on for only 1 frame.
|
|
If you want x and y to be the top left corner, set the orientation
|
|
to 0. If you want x and y to be the middle of the sprite, set the
|
|
orientation to 1. The reason I included the orienation = 1 option
|
|
is so that if you want a sprite centered and the size of the tile
|
|
changes, you don't need to recompile and guess where the new top
|
|
left corner is. Oh yeah, and I forget to mention that if shade is
|
|
greater than 32, than overwritesprite does transluscence. (Try it
|
|
out!) This function will clip the sprite to the startumost and
|
|
startdmost arrays. Dapalnum refers to a palette lookup list
|
|
(normally 0).
|
|
|
|
rotatesprite (long sx, long sy, long z, short a, short picnum,
|
|
signed char dashade, char dapalnum, char dastat,
|
|
long cx1, long cy1, long cx2, long cy2)
|
|
(sx, sy) is the center of the sprite to draw defined as
|
|
screen coordinates shifted up by 16.
|
|
(z) is the zoom. Normal zoom is 65536.
|
|
Ex: 131072 is zoomed in 2X and 32768 is zoomed out 2X.
|
|
(a) is the angle (0 is straight up)
|
|
(picnum) is the tile number
|
|
(dashade) is 0 normally but can be any standard shade up to 31 or 63.
|
|
(dapalnum) can be from 0-255.
|
|
if ((dastat&1) == 0) - no transluscence
|
|
if ((dastat&1) != 0) - transluscence
|
|
if ((dastat&2) == 0) - don't scale to setview's viewing window
|
|
if ((dastat&2) != 0) - scale to setview's viewing window (windowx1,etc.)
|
|
if ((dastat&4) == 0) - nuttin' special
|
|
if ((dastat&4) != 0) - y-flip image
|
|
if ((dastat&8) == 0) - clip to startumost/startdmost
|
|
if ((dastat&8) != 0) - don't clip to startumost/startdmost
|
|
if ((dastat&16) == 0) - use Editart center as point passed
|
|
if ((dastat&16) != 0) - force point passed to be top-left corner
|
|
if ((dastat&32) == 0) - nuttin' special
|
|
if ((dastat&32) != 0) - use reverse transluscence
|
|
if ((dastat&64) == 0) - masked drawing (check 255's) (slower)
|
|
if ((dastat&64) != 0) - draw everything (don't check 255's) (faster)
|
|
|
|
Note: As a special case, if both ((dastat&2) != 0) and ((dastat&8) != 0)
|
|
then rotatesprite will scale to the full screen (0,0,xdim-1,ydim-1)
|
|
rather than setview's viewing window. (windowx1,windowy1,etc.) This
|
|
case is useful for status bars, etc.
|
|
|
|
Ex: rotatesprite(160L<<16,100L<<16,65536,totalclock<<4,
|
|
DEMOSIGN,2,50L,50L,270L,150L);
|
|
This example will draw the DEMOSIGN tile in the center of the
|
|
screen and rotate about once per second. The sprite will only
|
|
get drawn inside the rectangle from (50,50) to (270,150)
|
|
|
|
permanentwritesprite (long thex, long they, short tilenum, signed char shade,
|
|
long cx1, long cy1, long cx2, long cy2, char dapalnum)
|
|
- Added permanentwritesprite function for status bars or other
|
|
sections of the screen that will not be overwritten by the
|
|
engine. The format of this function is like overwritesprite
|
|
except that the x and y are always top left corner, no
|
|
orientation variable, and no translucence.
|
|
The 4 last parameters (cx1, cy1) - (cx2, cy2) define a
|
|
rectangular clipping window of where permanentwritesprite
|
|
can draw to. Dapalnum refers to a palette lookup list
|
|
(normally 0).
|
|
|
|
printext(long x, long y, char buffer[42], short tilenum, char invisiblecol);
|
|
Use this function to print text anywhere on the screen from a font
|
|
that you can create in EDITART. Please see my example font in
|
|
TILES.ART to see how I lay out the user-defined font. X ranges
|
|
from 0-319. Y ranges from 0-199. The buffer is the string to
|
|
print. Tilenum specifies which font to use. Invisiblecol tells
|
|
printext what color to draw the transparent pixels. If
|
|
invisiblecol is 255 then the transpararent pixels are still
|
|
transparent.
|
|
printnum(long x, long y, long num, short tilenum, char invisiblecol);
|
|
Printnum is a function call that will print a long integer (num)
|
|
starting at top left corner x, y. Please look at the documentation
|
|
for printext, since internally, printnum simply prepares a buffer
|
|
and calls the printext function.
|
|
|
|
setvmode(long videomode);
|
|
If you look at the top of GAME.C, you will see something like this:
|
|
#pragma aux setvmode =\... This is how you do in-line assembler in
|
|
WATCOM C. All this function is doing is setting the video mode.
|
|
showengineinfo();
|
|
Use this function after setting to text mode to view some statics
|
|
about the engine, such as frame rate.
|
|
resettiming();
|
|
Resets timing, such as setting totalclock = 0. Also resets other
|
|
timers. This is for use with the showengineinfo function above.
|
|
|
|
ksqrt(long num); returns (long)square root
|
|
A square root function optimized for integers. Use this function
|
|
only if you want to.
|
|
krand()
|
|
This simply returns a random number. You can easily set the random
|
|
seed by externing the randomseed variable as a long. This is useful
|
|
for keeping the random seed the same on multiple computers when playing
|
|
multi-player mode.
|
|
|
|
getangle(long xvect,long yvect); returns (short)angle;
|
|
Use this function call to determine the angle between two points.
|
|
For example, if you want a monster to shoot a bullet towards you,
|
|
you would get the bullet's angle this way:
|
|
sprite[bullet].ang = getangle(posx-sprite[monst].x,posy-sprite[monst].y);
|
|
|
|
lastwall(short point);
|
|
Use this function as a reverse function of wall[].point2. In order
|
|
to save memory, my walls are only on a single linked list.
|
|
|
|
rotatepoint(long xpivot, long ypivot, long x, long y,
|
|
short daang, long *x2, long *y2);
|
|
This function is a very convenient and fast math helper function.
|
|
Rotate points easily with this function without having to juggle your
|
|
cosines and sines. Simply pass it:
|
|
|
|
Input: 1. Pivot point (xpivot,ypivot)
|
|
2. Original point (x,y)
|
|
3. Angle to rotate (0 = nothing, 512 = 90ø CW, etc.)
|
|
Output: 4. Rotated point (*x2,*y2)
|
|
|
|
clipmove(long *x, long *y, long *z, short *sectnum, long xvect, long yvect,
|
|
long walldist, long ceildist, long flordist, char cliptype)
|
|
Moves any object (x, y, z) in any direction at any velocity and will
|
|
make sure the object will stay a certain distance from walls (walldist)
|
|
Pass the pointers of the starting position (x, y, z). Then
|
|
pass the starting position's sector number as a pointer also.
|
|
Also these values will be modified accordingly. Pass the
|
|
direction and velocity by using a vector (xvect, yvect).
|
|
If you don't fully understand these equations, please call me.
|
|
xvect = velocity * cos(angle)
|
|
yvect = velocity * sin(angle)
|
|
Walldist tells how close the object can get to a wall. I use
|
|
128L as my default. If you increase walldist all of a sudden
|
|
for a certain object, the object might leak through a wall, so
|
|
don't do that!
|
|
If cliptype is 0, then the clipping is normal (Use 0 to clip you
|
|
and monsters). If the cliptype is 1, then the object is clipped to
|
|
the same things that hitscan is clipped to (use 1 for all bullets).
|
|
|
|
Clipmove can either return 0 (touched nothing)
|
|
32768+wallnum (wall first touched)
|
|
49152+spritenum (sprite first touched)
|
|
|
|
getzrange(long x, long y, long z, short sectnum,
|
|
long *ceilz, long *ceilhit,
|
|
long *florz, long *florhit,
|
|
long walldist, char cliptype)
|
|
|
|
Use this in conjunction with clipmove. This function will keep the
|
|
player from falling off cliffs when you're too close to the edge. This
|
|
function finds the highest and lowest z coordinates that your clipping
|
|
BOX can get to. It must search for all sectors (and sprites) that go
|
|
into your clipping box. This method is better than using
|
|
sector[cursectnum].ceilingz and sector[cursectnum].floorz because this
|
|
searches the whole clipping box for objects, not just 1 point.
|
|
Pass x, y, z, sector normally. Walldist can be 128. Cliptype can be
|
|
0, 1, or 2. (just like movesprite and clipmove) This function returns
|
|
the z extents in ceilz and florz. It will return the object hit in ceilhit
|
|
and florhit.
|
|
Ceilhit and florhit will also be either:
|
|
16384+sector (sector first touched) or
|
|
49152+spritenum (sprite first touched)
|
|
|
|
updatesector(long x, long y, §num);
|
|
This function updates the sector number according to the x and y values
|
|
passed to it. Be careful when you use this function with sprites because
|
|
remember that the sprite's sector number should not be modified directly.
|
|
If you want to update a sprite's sector, I recomment using the setsprite
|
|
function described below.
|
|
|
|
inside(long x, long y, short sectnum);
|
|
Tests to see whether the overhead point (x, y) is inside sector (sectnum)
|
|
Returns either 0 or 1, where 1 means it is inside, and 0 means it is not.
|
|
|
|
copytilepiece(long tilenume1, long sourcex1, long sourcey1,
|
|
long xsiz, long ysiz,
|
|
long tilenume2, long destx1, long desty1)
|
|
|
|
This function simply copies any section of a source tile
|
|
to any part of a destination tile. It will automatically
|
|
skip transparent pixels. It will wrap-around in the
|
|
source but not the destination. If for some reason
|
|
the destination tile gets removed from the cache, the
|
|
destination tile will be reset to original form. This
|
|
is why I had to add this second function:
|
|
|
|
allocatepermanenttile(short tilenume, long xsiz, long ysiz)
|
|
This function allocates a place on the cache as permanent.
|
|
Right now, I reset the cache every time you call this
|
|
function so I would recommend calling this function
|
|
right after loadpics.
|
|
|
|
makepalookup(long palnum, char *remapbuf,
|
|
signed char r, signed char g, signed char b,
|
|
char dastat)
|
|
This function allows different shirt colors for sprites. First prepare
|
|
remapbuf, which is a 256 byte buffer of chars which the colors to remap.
|
|
Palnum can be anywhere from 1-15. Since 0 is where the normal palette is
|
|
stored, it is a bad idea to call this function with palnum=0.
|
|
In BUILD.H notice I added a new variable, spritepal[MAXSPRITES].
|
|
Usually the value of this is 0 for the default palette. But if you
|
|
change it to the palnum in the code between drawrooms() and drawmasks
|
|
then the sprite will be drawn with that remapped palette. The last 3
|
|
parameters are the color that the palette fades to as you get further
|
|
away. This color is normally black (0,0,0). White would be (63,63,63).
|
|
if ((dastat&1) == 0) then makepalookup will allocate & deallocate
|
|
the memory block for use but will not waste the time creating a palookup
|
|
table (assuming you will create one yourself)
|
|
|
|
copytilepiece(long walnume1, long x1, long y1, long xsiz, long ysiz,
|
|
long walnume2, long x2, long y2, char shadeoffs);
|
|
Copies section of tile 1 (walnume1) with top-left corner (x1,y1) and
|
|
rectangular size (xsiz, ysiz) to top-left corner (x2, y2) of tile 2
|
|
(walnume). You can animate tiles with this function. For example, with
|
|
this function, you can make a slot machine like in Ken's Labyrinth or an
|
|
electronic sign with text sliding from right to left.
|
|
|
|
loadtile(short tilenume);
|
|
This function will load the tile, tilenum, into the artwork cache. A
|
|
tile is not in the cache if (waloff[tilenum] == -1). If
|
|
(waloff[tilenum] >= 0) then it is in the cache, and you don't need to call
|
|
this function.
|
|
|
|
precache();
|
|
This function will go through the tilenums of all sectors, walls, and
|
|
sprites and call loadtile() on them. This function will not cache in some
|
|
tiles of animations since their tilenums may not all be in the structures.
|
|
|
|
hitscan(long xstart, long ystart, long zstart, short startsectnum,
|
|
long vectorx, long vectory, long vectorz,
|
|
short *hitsect, short *hitwall, short *hitsprite,
|
|
long *hitx, long *hity, long *hitz);
|
|
|
|
Pass the starting 3D position:
|
|
(xstart, ystart, zstart, startsectnum)
|
|
Then pass the 3D angle to shoot (defined as a 3D vector):
|
|
(vectorx, vectory, vectorz)
|
|
Then set up the return values for the object hit:
|
|
(hitsect, hitwall, hitsprite)
|
|
and the exact 3D point where the ray hits:
|
|
(hitx, hity, hitz)
|
|
|
|
How to determine what was hit:
|
|
* Hitsect is always equal to the sector that was hit (always >= 0).
|
|
|
|
* If the ray hits a sprite then:
|
|
hitsect = thesectornumber
|
|
hitsprite = thespritenumber
|
|
hitwall = -1
|
|
|
|
* If the ray hits a wall then:
|
|
hitsect = thesectornumber
|
|
hitsprite = -1
|
|
hitwall = thewallnumber
|
|
|
|
* If the ray hits the ceiling of a sector then:
|
|
hitsect = thesectornumber
|
|
hitsprite = -1
|
|
hitwall = -1
|
|
vectorz < 0
|
|
(If vectorz < 0 then you're shooting upward which means
|
|
that you couldn't have hit a floor)
|
|
|
|
* If the ray hits the floor of a sector then:
|
|
hitsect = thesectornumber
|
|
hitsprite = -1
|
|
hitwall = -1
|
|
vectorz > 0
|
|
(If vectorz > 0 then you're shooting downard which means
|
|
that you couldn't have hit a ceiling)
|
|
|
|
neartag(long x, long y, long z, short sectnum, short ang, //Starting position & angle
|
|
short *neartagsector, //Returns near sector if sector[].tag != 0
|
|
short *neartagwall, //Returns near wall if wall[].tag != 0
|
|
short *neartagsprite, //Returns near sprite if sprite[].tag != 0
|
|
long *neartaghitdist, //Returns actual distance to object (scale: 1024=largest grid size)
|
|
long neartagrange, //Choose maximum distance to scan (scale: 1024=largest grid size)
|
|
char tagsearch) //1-lotag only, 2-hitag only, 3-lotag&hitag
|
|
Neartag works sort of like hitscan, but is optimized to
|
|
scan only close objects and scan only objects with
|
|
tags != 0. Neartag is perfect for the first line of your space bar code.
|
|
It will tell you what door you want to open or what switch you want to
|
|
flip.
|
|
|
|
cansee(long x1, long y1, long z1, short sectnum1,
|
|
long x2, long y2, long z2, short sectnum2); returns 0 or 1
|
|
This function determines whether or not two 3D points can "see" each
|
|
other or not. All you do is pass it the coordinates of a 3D line defined
|
|
by two 3D points (with their respective sectors) The function will return
|
|
a 1 if the points can see each other or a 0 if there is something blocking
|
|
the two points from seeing each other. This is how I determine whether a
|
|
monster can see you or not. Try playing DOOM1.DAT to fully enjoy this
|
|
great function!
|
|
|
|
setanimation(long *animptr, long thegoal, long thevel);
|
|
This is a function for your convenience that will animate a long
|
|
variable, such as sector[].floorz for platforms, or sector[].ceilingz
|
|
for doors. All you do is pass it the long pointer into memory, specifying
|
|
which long variable is to be animated; you also pass the goal (long value
|
|
to animate towards), and the velocity at which the variable is animated.
|
|
Velocity = 128 is a normal speed door. You may also modify the animation
|
|
arrays directly if you wish:
|
|
|
|
The animation arrays are as follows:
|
|
long *animateptr[MAXANIMATES], animategoal[MAXANIMATES];
|
|
long animatevel[MAXANIMATES], animatecnt;
|
|
|
|
getanimationgoal(long animptr);
|
|
Check to see if a certain variable in memory is already being animated
|
|
by the engine. If so, an index into the animation arrays is returned,
|
|
else -1 is returned. This is function is useful when you are press
|
|
space bar near a door, and it is already animating, you simply want
|
|
to reverse its direction.
|
|
|
|
dragpoint(short wallnum, long newx, long newy);
|
|
This function will drag a point in the exact same way a point is dragged
|
|
in 2D EDIT MODE using the left mouse button. Simply pass it which wall
|
|
to drag and then pass the new x and y coordinates for that point.
|
|
Please use this function because if you don't and try to drag points
|
|
yourself, I can guarantee that it won't work as well as mine and you
|
|
will get confused. Note: Every wall of course has 2 points. When you
|
|
pass a wall number to this function, you are actually passing 1 point,
|
|
the left side of the wall (given that you are in the sector of that wall)
|
|
Got it?
|
|
|
|
nextsectorneighborz(short sectnum, long thez, short topbottom, short direction);
|
|
This function searches z-coordinates of neighboring sectors to find the
|
|
closest (next) ceiling starting at the given z-coordinate (thez).
|
|
For example, if you want to find the goal z-coordinate when opening a
|
|
door, you might want the door to stop at the next closest neighboring
|
|
ceiling z-coordinate. You can get the z-coordinate this way:
|
|
|
|
newz = sector[nextsectorneighborz(sectnum,startz,-1,-1)].ceilingz
|
|
|
|
topbottom (3rd parameter) -1 = search ceilings
|
|
1 = search floors
|
|
direction (4th parameter) -1 = search upwards
|
|
1 = search downwards
|
|
|
|
screencapture(char *filename)
|
|
Capture the screen and save it as a .BMP file. I don't know why my
|
|
.BMP format isn't compatible with other programs.
|
|
|
|
ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
|
|
³ SPRITE FUNCTIONS: ³
|
|
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
|
|
|
|
insertsprite(short sectnum, short statnum); //returns (short)spritenum;
|
|
Whenever you insert a sprite, you must pass it the sector
|
|
number, and a status number (statnum). The status number can be any
|
|
number from 0 to MAXSTATUS-1. Insertsprite works like a memory
|
|
allocation function and returns the sprite number.
|
|
|
|
deletesprite(short spritenum);
|
|
Deletes the sprite.
|
|
|
|
changespritesect(short spritenum, short newsectnum);
|
|
Changes the sector of sprite (spritenum) to the
|
|
newsector (newsectnum). This function may become
|
|
internal to the engine in the movesprite function. But
|
|
this function is necessary since all the sectors have
|
|
their own doubly-linked lists of sprites.
|
|
|
|
changespritestat(short spritenum, short newstatnum);
|
|
Changes the status of sprite (spritenum) to status
|
|
(newstatus). Newstatus can be any number from 0 to MAXSTATUS-1.
|
|
You can use this function to put a monster on a list of active sprites
|
|
when it first sees you.
|
|
|
|
setsprite(short spritenum, long newx, long newy, long newz);
|
|
This function simply sets the sprite's position to a specified
|
|
coordinate (newx, newy, newz) without any checking to see
|
|
whether the position is valid or not. You could directly
|
|
modify the sprite[].x, sprite[].y, and sprite[].z values, but
|
|
if you use my function, the sprite is guaranteed to be in the
|
|
right sector.
|
|
|
|
movesprite(short spritenum, long xchange, long ychange, long zchange,
|
|
long ceildist, long flordist, char cliptype, long numtics)
|
|
This function moves the sprite given by spritenum by the 3
|
|
increments, xchange, ychange, and zchange. If cliptype is 0, then
|
|
the clipping is normal (Use 0 to clip you and monsters). If the
|
|
cliptype is 1, then the object is clipped to the same things that
|
|
hitscan is clipped to (use 1 for all bullets).
|
|
Movesprite can either return 0 (touched nothing)
|
|
16384+sectnum (ceiling/floor first touched)
|
|
32768+wallnum (wall first touched)
|
|
49152+spritenum (sprite first touched)
|
|
|
|
getspritescreencoord(short spritesortnum, long *scrx, long *scry)
|
|
This function returns the actual screen coordinates of a sprite. It
|
|
is useful for locking on to a target. Use this function between
|
|
drawrooms and drawmasks. Note that spritesortnum is the index into the
|
|
spritesortcnt arrays, NOT the normal sprite arrays. Scrx and scry are
|
|
actual screen coordinates ranging from 0-319 and 0-199 respectively.
|
|
|
|
ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
|
|
³ MULTIPLAYER FUNCTIONS (multi.obj) ³
|
|
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
|
|
|
|
initmultiplayers(char option[4], char option[5], char priority);
|
|
Call this right after initengine. Pass option[4] and option[5]
|
|
exactly the way I have it written here. (option[4] is the COM1-COM4,
|
|
network option and option[5] is the com speed selection option)
|
|
Priority can be used to decide who becomes master. Lower is more
|
|
towards the master.
|
|
|
|
uninitmultiplayers();
|
|
Call this right before uninitengine.
|
|
|
|
sendlogon();
|
|
Use this function after everything's initialized, but before you
|
|
go into the main game loop. Right after you call sendlogon(), you
|
|
should run a loop that will wait until a specified number of players.
|
|
Here's some example code:
|
|
|
|
sendlogon();
|
|
while (numplayers < waitplayers)
|
|
{
|
|
getpackets();
|
|
}
|
|
screenpeek = myconnectindex;
|
|
|
|
Getpackets reserves the packet header range from 200-255. If you
|
|
keep calling getpackets after sendlogon, the numplayers variable will
|
|
automatically be incremented when other people log on.
|
|
|
|
sendlogoff();
|
|
Call this before leaving, before uninitializing the multiplayer
|
|
code.
|
|
|
|
sendpacket (short otherconnectindex, char *bufptr, short bufleng)
|
|
For COM(modem) communications, the otherconnectindex doesn't matter.
|
|
For network communcations, you can specify which computer to send
|
|
to by setting otherconnectindex to the proper index number. You
|
|
can also do a broadcast by setting otherconnectindex to -1.
|
|
Also pass the buffer and length parameters.
|
|
|
|
short getpacket (short *otherconnectindex, char *bufptr) returns bufleng
|
|
When using getpacket, first check the value it returns.
|
|
If the value is 0, then the buffer length is 0 which means there
|
|
are no packets available. If the buffer length is greater than
|
|
0, then use that value as the length of the buffer. Getpacket also
|
|
tells you what computer the message was received from -
|
|
(otherconnectindex).
|
|
|
|
ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
|
|
³ DIGITIZED SOUND FUNCTIONS: ³
|
|
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
|
|
Note: If you want to write your own digitized sound driver, simply delete
|
|
these functions from GAME.C.
|
|
|
|
initsb();
|
|
Initializes the digitized sound routines. You need to call this
|
|
only once at the beginning of the program. Currently, the
|
|
sample rate is 11,025 Hz.
|
|
|
|
wsay(char *filename, long freq, char volume);
|
|
Play the sound file at the given frequency and volume. If you
|
|
set freq = 4096, the sound will play at normal frequency (given
|
|
the sound was also recorded at 11025 Hz) To play the sound an
|
|
octave higher, for example, set freq = 8192. Volume ranges from
|
|
0 (silent) to 255 (full volume). Ex: wsay("blowup.wav",4096L,255);
|
|
|
|
uninitsb();
|
|
Turns the speaker off, so sounds don't continue playing while
|
|
your back in DOS.
|
|
|
|
ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
|
|
³ MUSIC FUNCTIONS: ³
|
|
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
|
|
Note: If you want to write your own music driver, simply delete these
|
|
functions from GAME.C. The BUILD engine uses interrupt vector 0x8 (IRQ0)
|
|
and that may complicate things. If you like my music, perhaps I can send
|
|
you my MIDI sequencer program (It requires MPU-401, and TSENG-ET4000 SVGA,
|
|
but could be standardized if there's enough demand).
|
|
|
|
loadmusic(char *filename);
|
|
Loads the given song into memory. Be sure INSTS.DAT is in the
|
|
current directory. If no extension is given, then .KSM will be
|
|
appended to the filename. You should use this function only when
|
|
the music is off.
|
|
musicon();
|
|
Enable the playing of music. Use this only after loadmusic has
|
|
been called.
|
|
musicoff();
|
|
Disable the playing of music. Be sure to call this before quitting
|
|
to DOS.
|
|
|
|
ÉÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍËÍ»
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÌÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎÍÎ͹
|
|
ÈÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊÍÊͼ
|
|
|
|
ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
|
|
³ BUILD Revision History: ³
|
|
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
|
|
2/6/94 - Added this revision thing.
|
|
- Setup program.
|
|
- A faster new mode for standard VGAs called chain mode.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
2/8/94 - Fixed chain mode with groudraws.
|
|
- Added sector joining in 2D EDIT MODE - press J on first sector.
|
|
Then press J again on sector to join with. Attributes will be
|
|
taken from first sector. Possible bugs.
|
|
- Improved controls for slower computers.
|
|
- Made timer interrupt rate 120/second instead of 240/second.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
2/9/94 - Started to work on status bar in 2D EDIT MODE.
|
|
- Added special optimization for the Western Digitial (Paradise)
|
|
chipset just like with TSENG ET4000.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
2/10/94 - Added a door attribute to sectors. To make a sector a door,
|
|
press "D" on the ceiling of the sector in 3D EDIT MODE. For
|
|
the door to work, the ceiling of the door sector must be a
|
|
tiny bit lower than lowest neighboring ceiling. To open/close
|
|
the door, you may press the space bar. Note: Space Bar is also
|
|
used for copy and paste in 3D EDIT MODE. You may have to go
|
|
into game mode to test out the doors for now.
|
|
- Added a wall orientation attribute to walls. This attribute is
|
|
used especially in conjunction with doors. So far, you have
|
|
been working with walls that are start from the top. For
|
|
example, if you hold down 2/8 on the keypad in 3D EDIT MODE,
|
|
the wall always starts from the top. But for doors, you
|
|
sometimes need walls to start from the bottom. To do this,
|
|
press "O" (for orientation) on the wall, and it will now
|
|
start from the bottom.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
2/12/94 - Fixed some bugs for sprites. Sprites don't disappear anymore.
|
|
Now you will pick up all sprites when running over them.
|
|
Monsters will not stop shooting anymore.
|
|
- Made the sound blaster sounds have a 1-sound cache. That is, if
|
|
the same sound is to be played several times in a row, it will
|
|
only be loaded once.
|
|
- Added *.GIF format support to EDITART for 320*200 size images.
|
|
- Changed the PASTE key in 3D EDIT MODE from Space bar to Left
|
|
Enter because the Space bar conflicted with opening doors.
|
|
- Added music as an option in the setup program. To run the music,
|
|
you need INSTS.DAT and a song file with a .KSM extension.
|
|
- Split the editor from the game.
|
|
BUILD is now the map editor - you don't need BUILD.C anymore.
|
|
GAME is now the actual game that you will be programming.
|
|
I am giving you GAME.C to work with. Its code is simpler
|
|
than before because there are no more editing function
|
|
calls in it.
|
|
- Sprites move in a straight line now until they hit walls. When
|
|
they hit walls, they pick a new angle to travel in.
|
|
- Remember that tiny little guy with the "Al" on his shirt?
|
|
Next time you're in DOOM1.DAT, try shooting him. Then look
|
|
at the code in GAME.C.
|
|
- In EDITART, when you press, "u", you now select filenames with
|
|
the arrow keys and enter rather than having to type in
|
|
the exact filename.
|
|
- Board maps now have extension .MAP and artwork files now have
|
|
extension .ART to help distinguish between the different types
|
|
of files.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
2/22/94 - Fixed small bug with EDITART not loading right when names.h
|
|
existed with no names defined.
|
|
- You can now edit new boards by typing:
|
|
BUILD <file that doesn't exist> like "BUILD NEWBOARD"
|
|
- Added ALT-S in 2D EDIT Mode to change a whole white loop inside a
|
|
sector to a red loop.
|
|
- When viewing the tiles (pressing "v") you can now use PGUP/PGDN.
|
|
- Added a message bar in 2D EDIT Mode.
|
|
- Added TAB and L.ALT-TAB keys to view all the attributes of a
|
|
sector, wall, or sprite (see above documentation).
|
|
- Debugged and bullet-proofed ALT-S.
|
|
- Fixed a bug that doesn't allow you to drag points with number
|
|
greater than 1023. (There can actually be 4096 walls and 1024
|
|
sectors, and 4096 sprites currently, an easy thing to increase)
|
|
- Changed overwritesprite function paramaters. If you are using it
|
|
in your c file, you must change it! Now it looks like this:
|
|
|
|
overwritesprite (long x, long y, short tilenum, char shade,
|
|
char orientation);
|
|
|
|
If orientation = 0: x and y are the top left corner.
|
|
If orientation = 1: x and y are the middle (like before).
|
|
- Added permanentwritesprite function for status bars or other
|
|
sections of the screen that will not be overwritten by the
|
|
engine. When using this function, you may want to modify the
|
|
STARTUMOST / STARTDMOST arrays. The format of this function is
|
|
like overwritesprite except that the x and y are always top
|
|
left corner, no orientation variable, and no translucence.
|
|
|
|
permanentwritesprite (long x, long y, short tilenum, char shade);
|
|
|
|
- Added an attribute to the printext and printnum functions. Please
|
|
change these function if you use them in your program. The
|
|
current formats are:
|
|
|
|
printext(long x, long y, char buffer[42], short tilenum,
|
|
char invisiblecol)
|
|
printnum(long x, long y, long num, short tilenum,
|
|
char invisiblecol);
|
|
|
|
Invisiblecol tells printext what color to draw the transparent
|
|
pixels. If invisiblecol is 255 then the transpararent pixels are
|
|
still transparent.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
2/26/94 - Completely reprogrammed EDITART.
|
|
IMPORTANT: PLEASE RUN CONVART.EXE ON ALL ARTWORK FILES! (If you have not
|
|
already). It will convert PICS.ART in the old format to
|
|
TILES.ART in the new format, so you may have to do some
|
|
renaming when converting artwork and also rename the loadpics
|
|
line in your C file. BUILD WILL NOT RUN UNLESS YOU DO THIS!
|
|
With the new artwork file, the tiles can now be any size from
|
|
1*1 to 1024*240 and they no longer have to be powers of 2.
|
|
This feature allows parallaxing skies that are 1024 pixels wide
|
|
to cover all 360ø, or 320 pixel wide status bars. It can also
|
|
be used to display 320*200 title screens.
|
|
- When pressing 'U' in EDITART, you can now change directories
|
|
and the current loading directory will be remembered.
|
|
- When pressing 'U' in EDITART, you can press the mouse button to
|
|
readjust the size of the tile.
|
|
- When pressing 'U' in EDITART, press ENTER for an automatic
|
|
palette conversion or press SPACE BAR for no conversion.
|
|
- Walls that are Blocked ('B') in BUILD are now shown in pink.
|
|
If the wall does not show pink in your board, just press
|
|
'B' twice to permanently fix it.
|
|
- Made smooshiness values easier to work with. Hold down 5 on the
|
|
keypad with 2/4/6/8 to align the walls to multiples of the
|
|
tile that is used. Also, when you do Tab and L.Enter for
|
|
Copy&Paste, the y-repeat values stay the same, and the
|
|
x-repeat values are adjusted so the pixels of the bitmaps
|
|
have a square-aspect ratio.
|
|
- Added masked walls. But since they don't quite work perfectly
|
|
yet, and they are extremely hard to edit now, so for now, just
|
|
enjoy the technologiy in DOOM1.MAP. Don't worry - you'll get
|
|
your hands on this soon!
|
|
- Fixed the "earthquake" effect on really high walls. The walls
|
|
will not move up and down, but the pixel fuzzyness bug is
|
|
still in there.
|
|
- Put door variables and tile information into BUILD.H for you to
|
|
play around with.
|
|
- Made walls, ceilings, and floors also work with the animation
|
|
attribute in EDITART.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
3/2/94 - Made power of 2 size tiles work with ceilings & floors.
|
|
- When using different size ceilings & floors, made an option in
|
|
3D EDIT MODE. If you want a tile to be smooshed into the normal
|
|
64*64 area, press 'E' to unExpand the tile.
|
|
- Groudraws now look more cubical than before. (But be careful of
|
|
crashing with them for now)
|
|
- IMPORTANT: Changed the Board format. If you tried running BUILD
|
|
before reading this, and it didn't work, shame on you! You
|
|
should always look at the history section of BUILD.TXT first!
|
|
Since from now on, I am writing Board/Art converters, I am
|
|
giving you CONVMAP.EXE to convert maps. You can type either:
|
|
C:\BUILD>convmap house.map
|
|
to convert an individual map or:
|
|
C:\BUILD>for %i in (*.map) do convmap %i
|
|
to convert all the maps in a directory.
|
|
|
|
- IMPORTANT: Sprites are now on 2 different sets of doubly-linked
|
|
lists. The big advantage of this method is that when sprites
|
|
are deleted, there can be holes in the sprite list with
|
|
no slow down. Before I used to have linked lists for each
|
|
sector pointing to all the sprites in it. Well, I have updated
|
|
that and added more linked lists that tell whether sprites
|
|
are active or inactive (not a fun thing to progam) But not
|
|
to worry, you don't have to deal with changing the linked
|
|
lists, thanks to my very easy function calls. YOU WILL
|
|
HAVE TO CHANGE YOUR CODE TO SUPPORT THE NEW LINKED LISTS.
|
|
You should know how to search through each list. See BUILD.H
|
|
for a detailed description of how the linked lists work, and
|
|
see the top of this file for description of the new sprite
|
|
function calls.
|
|
|
|
insertsprite(short sectnum, short statnum);
|
|
deletesprite(short spritenum);
|
|
changespritesect(short spritenum, short newsectnum);
|
|
changespritestat(short spritenum, short newstatnum);
|
|
|
|
In your code, you will have to change the following:
|
|
firstsprite[spritenum] --> headspritesect[spritenum]
|
|
sprite[spritenum].point2 --> nextspritesect[spritenum]
|
|
|
|
Also, you should change the part of your main loop that scans
|
|
through all the active sprites to look more like this:
|
|
|
|
|
|
i = headspritestat[1]; //head of active sprite list
|
|
while (i != -1)
|
|
{
|
|
nexti = nextspritestat[i]; //back up next sprite in case current
|
|
//one is deleted.
|
|
|
|
//your code goes here (use i as the sprite number)
|
|
|
|
spriteisdeletedskip:
|
|
i = nexti; //go to next sprite
|
|
}
|
|
|
|
|
|
|
|
- Added tagging (naming) to any sector, sprite, or wall. That means
|
|
you can change a tag in the BUILD editor by pressing T with the
|
|
mouse cursor on the highlighted sector. And in GAME.C, you
|
|
can access the tag this way:
|
|
sector[sectnum].tag;
|
|
sprite[spritenum].tag;
|
|
wall[wallnum].tag;
|
|
Note: All 3 types of tags are long integers, but in BUILD.C
|
|
you can only make them short integers. I am planning to
|
|
let you use the upper 16 bits of the tag byte as use for
|
|
you only. (like permanently unreserved bits)
|
|
- Added serial link. But it doesn't work very well yet. You
|
|
may have to try going into GAME several times before it works.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
3/15/94 - Fixed maskable walls - now sort out with sprite better. Easier
|
|
to edit. Simply press 'M' at a place where a maskable wall
|
|
should be (like where you normally press 'B' for blocking)
|
|
- Can flip walls, masked walls, and sprites x-wise by pressing
|
|
'F' in 3D EDIT MODE. Also, it is possible to save space in
|
|
sprite rotations, by flipping it x-wise by programming one of
|
|
the bits in sprite[].cstat.
|
|
- A few other minor things, but I forgot what they were.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
3/19/94 - Fixed one of the many crashing bugs.
|
|
For Duke Nukem III team:
|
|
CITY.MAP will not crash anymore with new version. The
|
|
reason it crashed was because in your TILES.ART, you had
|
|
either ANMFD:0, ANMBK:0, or OSCI:0. That caused a MOD 0
|
|
in my animation routine. I bullet-proofed that. How about
|
|
fixing tiles #34, #112, or #114 in your TILES.ART.
|
|
- Wrote divide by zero handler. Now if there is a divide by zero,
|
|
BUILD goes back into text mode and fills the screen with
|
|
/0/0/0/0/..., then gives a DOS prompt. (In other words, you
|
|
don't have to type "MODE CO80" anymore for /0 crashes)
|
|
- Optimized routines in assembly for 486's using my great new
|
|
Intel 32-bit optimizing techniques book that dad got for me.
|
|
- Fixed ALT-S in BUILD so ANY white loop can be converted into a
|
|
red loop except for the 1 and only 1 outermost white loop.
|
|
- FINALLY! Splitsector bug is fixed! You can now split a very
|
|
complicated sector with tons of sectors inside it or with
|
|
plenty of sprites. Also sprites will not get deleted
|
|
spontaneously with split sector any more.
|
|
- Ctrl-Enter in 3D EDIT MODE is like the normal Enter paste key,
|
|
but Ctrl-Enter pastes the attributes to an entire loop of
|
|
walls (if a wall is highlighted).
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
3/22/94 - Added doors that open left and right. See sector[].tag #9 in the top
|
|
of this file for details - also look at my board, NUKELAND.MAP,
|
|
in BUILD to see how to make this type of door.
|
|
- Increased the number of status lists. You may recall my active /
|
|
inactive sprite lists called headspritestat, prevspritestat,
|
|
and nextspritestat. Don't worry - you will NOT have to
|
|
change any of your code. The only thing I changed is now
|
|
you can have 1024 different lists of sprites rather than just
|
|
2 lists if you want to use them. For example, you might want
|
|
to run through all the brown monsters on the board. Instead
|
|
of putting all different types of monsters on the active
|
|
list, it is faster to have a separate list just for brown
|
|
monsters. Use your imagination!
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
3/31/94 - Fixed some palette problems with EDITART. Now when you press 'P'
|
|
in 'U' mode, the palette of all the existing tiles are
|
|
converted to the new palette. Also the text colors should
|
|
be similar colors on different palettes now.
|
|
- Changed bit 0 of sprite[].cstat to the hitscan checking / ignoring
|
|
bit. You should set this bit to 1 for monsters, 0 for
|
|
bullets, 0 for pick-upable objects like coins, and 1 for
|
|
objects like columns. Right now, (Since it's not in the
|
|
BUILD editor), you must set these bits in your code right
|
|
after you load the board.
|
|
- I did not document the neartagsector, neartagwall, and
|
|
neartagsprite very well, so if you don't know how to use
|
|
them alreay, please read on. These 3 variables are modified
|
|
by the engine every time you call draw3dscreen(). These
|
|
variables are usually -1. These variables will be >= 0 if
|
|
all of these cases are true:
|
|
1. You are looking at a wall, sprite, or sector.
|
|
2. You are close enough to the wall, sprite, or sector
|
|
to be able to use the action key with it.
|
|
3. The tag of the wall, sprite, or sector is greater or
|
|
equal to 1.
|
|
As you can see, neartagsector makes a perfect variable for
|
|
detecting whether or not you are opening a door. You can
|
|
also use neartagwall for switches on walls. Also, you can
|
|
use neartagsprite for sprites that are switches.
|
|
- PROGRAMMERS: PLEASE MAKE THESE EASY CODE MODIFICATIONS:
|
|
I reversed the way variables are stored in BUILD.H.
|
|
Now the variables will be local to the ENGINE and externed
|
|
to GAME. Before they were local to GAME and externed to the
|
|
engine. All you have to do is this:
|
|
1. You can remove the #define MAIN if you want to.
|
|
2. Delete the externs declarations that I used to have
|
|
in the beginning of GAME.C, because I put them in
|
|
BUILD.H. I will try not to put externs in the GAME
|
|
in the future to save you the time of copying and
|
|
pasting code. Here is a list of externs I moved:
|
|
|
|
EXTERN short neartagsector, neartagwall, neartagsprite;
|
|
EXTERN long *animateptr[MAXANIMATES], animategoal[MAXANIMATES];
|
|
EXTERN long animatevel[MAXANIMATES], animatecnt;
|
|
EXTERN short tilesizx[MAXTILES], tilesizy[MAXTILES];
|
|
EXTERN long numtiles, picanm[MAXTILES], waloff[MAXTILES];
|
|
- Added a global parallaxing sky type variable. Now I have 3
|
|
different types of parallaxing skies. Here they are:
|
|
|
|
0 - Totally flat parallaxing sky.
|
|
1 - X-only stretching parallaxing sky (This is what DOOM uses).
|
|
2 - X- and Y- stretching parallaxing sky. (This is what BUILD
|
|
uses by default)
|
|
A good place to set the parallaxing sky is right after you
|
|
call initengine().
|
|
- Added local tile selection to the BUILD editor. This means
|
|
that when you press V on a sprite, you will see only the
|
|
sprites that are on the level so far. If you want to use
|
|
a sprite that is not already used on the current board, press
|
|
V again and you will be able to select from the huge list
|
|
that you are used to from before. The local tile list will
|
|
be sorted according to how much each tile is used on the
|
|
current board. Note that the local tile list will be
|
|
different depending where the mouse cursor was left when you
|
|
pressed V (or H).
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/4/94 - Changed the way ART files work. YOU MUST READ THIS:
|
|
There are some two easy things that you must do 2 things before
|
|
you can use the new engine:
|
|
|
|
1. Type CONVART1.EXE to convert your ARTWORK to the new
|
|
format. (If I forgot to send this file to you, please call
|
|
and torture me.) Now, instead of everything being stored
|
|
in one huge file, TILES.ART, I am splitting the artwork into
|
|
several files each holding 256 tiles in it. This will allow
|
|
you to make infinitely large artwork files in EDITART.
|
|
|
|
2. In GAME.C, you must change the line,
|
|
loadpics("tiles.art");
|
|
to:
|
|
loadpics("tiles000.art");
|
|
All you have to give loadpics is the first filename of your
|
|
artwork, and the engine will automatically know how to
|
|
modify the 3 digits at the end and load all the artwork
|
|
files properly.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/5/94 - Fixed the "fuzzy" pixels on high walls. Now you make walls as
|
|
high as skyscrapers, and when you look at it up close, the
|
|
pixels will still look like perfect rectangles. Note: This
|
|
fix may require you to press 'O' in 3D EDIT MODE to put
|
|
your boards back to normal.
|
|
- When you pressed ENTER on weird-sized tiles, sometimes in the old
|
|
version the pixels would not be square aspect ratio. Now
|
|
when you press ENTER, they will be.
|
|
- You can now set the starting position in 2D EDIT MODE with the
|
|
Scroll Lock key. The starting position will look like a
|
|
brown arrow, and your current position will look like a
|
|
white arrow. Now you don't have to keep returning to start
|
|
when you save your board.
|
|
- Added some new things to the structures - guess what this means?
|
|
CONVMAP3! THE NEW OBJ'S and BUILD will NOT work until you
|
|
run CONVMAP3. (Please call if I forgot to give
|
|
you this file)
|
|
Notice that I added these things to the structures:
|
|
|
|
sectortype:
|
|
bit 2 of ceilingstat&floorstat:
|
|
1 = North/South panning, 0 = East/West panning
|
|
char ceilingpanning, floorpanning;
|
|
walltype:
|
|
bit 6 of cstat
|
|
1 = Vertical panning, 0 = Horizontal panning
|
|
char panning;
|
|
short overpicnum;
|
|
spritetype:
|
|
char *extra;
|
|
|
|
Now an explanation of each:
|
|
To the sector structure, I added the capability to pan
|
|
the floors and ceilings. Usually ceilingpanning and
|
|
floorpanning are set to 0. For example, a good way to make
|
|
an earthquake would be to randomly increment or decrement
|
|
to panning values. To allow you to pan the ceilings or
|
|
floors at any of the standard 90 degree angles, I made
|
|
bit 2 of sectortype's ceilingstat/floorstat byte choose
|
|
whether the ceilingpanning/floorpanning byte should move
|
|
the ceiling/floor North/South or East/West.
|
|
To the wall structure, I added panning also. Bit 6
|
|
of cstat and the panning values work in the same as the
|
|
ceilings and floors.
|
|
To the sprite structure, I added only 1 variable.
|
|
The "extra" pointer is intended for your use only, so you
|
|
can have the sprite's structure extended if you so desire.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/6/94 - In 2D EDIT MODE, you can now press ESC to get a message in the
|
|
message bar that says this:
|
|
|
|
(N)ew, (L)oad, (S)ave, (Q)uit
|
|
|
|
And it all works too. (Press ESC to cancel)
|
|
Loading lets you select the file just like 'U' in EDITART.
|
|
- The old version of BUILD had the coordinate system all screwed
|
|
up in 2D EDIT MODE. I fixed this. Included with
|
|
CONVMAP3.EXE is a conversion utility that will make your
|
|
boards have the same orientation as in the older BUILD
|
|
editors. If you don't care if the whole map gets rotated
|
|
in the 2D editor, then press N.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/7/94 - Changed the way Orientation works ('O' in 3D EDIT MODE)
|
|
|
|
Now, when you draw a normal door in BUILD, you do NOT have to
|
|
press 'O' everywhere to make the walls of the door move right.
|
|
Now, the default is that everything moves right. Here's a
|
|
detailed description of how the new orientation works:
|
|
|
|
For white lines (no neighboring sector):
|
|
|
|
orientation = 0 (default) means picture is aligned with
|
|
sector[].ceilingz.
|
|
orientation = 1 means picture aligned with sector[].floorz.
|
|
|
|
For red lines (has a neighboring sector):
|
|
|
|
orientation = 0 (default) means picture is aligned with
|
|
either the ceilingz or floorz of the next sector.
|
|
orientation = 1 means picture aligned with
|
|
sector[].ceilingz.
|
|
|
|
Don't worry if you don't understand the detailed description.
|
|
Just know that it's better this way. I have included the
|
|
proper conversions in CONVMAP3.EXE.
|
|
- Added wall&ceiling x-panning keys to the 3D EDIT MODE. Press
|
|
the , or . keys to pan a wall or ceiling left or right. You
|
|
can hold down the 5 key on the keypad to align at every eighth
|
|
panning value. (Just like with 2,4,6,8).
|
|
- Made TAB&ENTER in 3D EDIT MODE also copy the CSTAT byte of
|
|
the wall's attributes. This means that attributes such as
|
|
the block attribute, 1-way wall attribute, orientation,
|
|
and x-flipping attribute are also copied & pasted.
|
|
- Added a new function, cansee.
|
|
|
|
cansee(long x1, long y1, long z1, short sectnum1,
|
|
long x2, long y2, long z2, short sectnum2)
|
|
|
|
All you do is pass it the coordinates of a 3D line
|
|
and the respective sectors of each point of the line.
|
|
The function will return a 1 if the points can see each
|
|
other or a 0 if there is something blocking the two points
|
|
from seeing each other. This is how I determine whether
|
|
a monster can see you or not. Try playing DOOM1.DAT with
|
|
digitized sound enabled to fully enjoy this great new
|
|
function!
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/12/94 - Fixed HITSCAN function. Since it works a little differently
|
|
and the parameters are different, let me describe how the
|
|
new hitscan works:
|
|
|
|
hitscan(long xstart, long ystart, long zstart, short startsectnum,
|
|
long vectorx, long vectory, long vectorz,
|
|
short *hitsect, short *hitwall, short *hitsprite,
|
|
long *hitx, long *hity, long *hitz);
|
|
|
|
Pass the starting 3D position:
|
|
(xstart, ystart, zstart, startsectnum)
|
|
Then pass the 3D angle to shoot (defined as a 3D vector):
|
|
(vectorx, vectory, vectorz)
|
|
Then set up the return values for the object hit:
|
|
(hitsect, hitwall, hitsprite)
|
|
and the exact 3D point where the ray hits:
|
|
(hitx, hity, hitz)
|
|
|
|
How to determine what was hit:
|
|
* Hitsect is always equal to the sector that was hit
|
|
(always >= 0).
|
|
|
|
* If the ray hits a sprite then:
|
|
hitsect = thesectornumber
|
|
hitsprite = thespritenumber
|
|
hitwall = -1
|
|
|
|
* If the ray hits a wall then:
|
|
hitsect = thesectornumber
|
|
hitsprite = -1
|
|
hitwall = thewallnumber
|
|
|
|
* If the ray hits the ceiling of a sector then:
|
|
hitsect = thesectornumber
|
|
hitsprite = -1
|
|
hitwall = -1
|
|
vectorz < 0
|
|
(If vectorz < 0 then you're shooting upward which means
|
|
that you couldn't have hit a floor)
|
|
|
|
* If the ray hits the floor of a sector then:
|
|
hitsect = thesectornumber
|
|
hitsprite = -1
|
|
hitwall = -1
|
|
vectorz > 0
|
|
(If vectorz > 0 then you're shooting downard which means
|
|
that you couldn't have hit a ceiling)
|
|
|
|
- Added a position window to the bottom of the menu in 2D EDIT
|
|
MODE. It shows the posx, posy, and ang variables.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/14/94 - Overwritesprite now clips to the startumost / startdmost arrays.
|
|
Now the only way to write to the status bar is with
|
|
the permanentwritesprite function.
|
|
|
|
- ATTENTION PROGRAMMERS! I Split draw3dscreen() into 2 separate
|
|
function calls.
|
|
|
|
old: draw3dscreen(); //Draws walls, ceilings, floors, p-skies
|
|
// groudraws, sprites, and masked walls.
|
|
|
|
new: drawrooms(); //Draws walls, ceilings, floors, p-skies
|
|
// and groudraws.
|
|
drawmasks(); //Draws sprites and masked walls.
|
|
|
|
The reason I split draw3dscreen was so you could manipulate only
|
|
the sprites that the engine is going to draw to the screen
|
|
before the sprites are actually drawn.
|
|
|
|
- I think I may have fixed that darn sector line bug! Before, the
|
|
bug usually appeared when you were on a (red) sector line where
|
|
the ceiling and floor of the sector were very far from each
|
|
other. This overflowed some really high positive values into
|
|
the negative range and vice versa.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/18/94 - Wall clipping now works much better! (You can still VERY RARELY
|
|
sneak through walls, however)
|
|
ATTENTION PROGRAMMERS:
|
|
MOVESPRITE and CLIPMOVE have been changed. They now look
|
|
like this:
|
|
|
|
clipmove (long *x, long *y, long *z, short *sectnum,
|
|
long xvect, long yvect, long walldist,
|
|
char cliptype);
|
|
|
|
movesprite(short spritenum,
|
|
long xchange, long ychange, long zchange,
|
|
long walldist, char cliptype);
|
|
|
|
To use the new clipmove:
|
|
Pass the pointers of the starting position (x, y, z). Then
|
|
pass the starting position's sector number as a pointer also.
|
|
Also these values will be modified accordingly. Pass the
|
|
direction and velocity by using a vector (xvect, yvect).
|
|
If you don't fully understand these equations, please call me.
|
|
xvect = velocity * cos(angle)
|
|
yvect = velocity * sin(angle)
|
|
Walldist tells how close the object can get to a wall. I use
|
|
128L as my default. If you increase walldist all of a sudden
|
|
for a certain object, the object might leak through a wall, so
|
|
don't do that!
|
|
|
|
To use the new movesprite:
|
|
Works like before, but you also pass walldist (How close the
|
|
sprite can get to a wall)
|
|
|
|
- New function for sprites:
|
|
setsprite(short spritenum, long newx, long newy, long newz);
|
|
|
|
This function simply sets the sprite's position to a specified
|
|
coordinate (newx, newy, newz) without any checking to see
|
|
whether the position is valid or not. You could directly
|
|
modify the sprite[].x, sprite[].y, and sprite[].z values, but
|
|
if you use my function, the sprite is guaranteed to be in the
|
|
right sector.
|
|
|
|
- You can now change the angle in 2D EDIT MODE with the
|
|
< and > keys. Move the mouse cursor to a sprite first.
|
|
Hold down shift with the < and > to get more precise angles.
|
|
- You can now press 'B' on sprites in 3D EDIT MODE. This in effect
|
|
is xoring bit 0 of sprite[].cstat, which will not only be
|
|
sensitive to hitscan, but will also block you from walking
|
|
through the sprite. Sprites with the 'B' attribute will
|
|
appear pink in 2D EDIT MODE.
|
|
- You can now edit the Hi 16 bits of the tag in 2D EDIT MODE.
|
|
Just like T and ALT-T, you press H and ALT-H to edit the high
|
|
16-bits. When a structure's attributes are displayed, the tag
|
|
will be displayed as 2 unsigned shorts. The first number
|
|
represents the hi 16 bits and the second number represents the
|
|
lo 16 bits.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/23/94 - Added 'G' in Editart to GOTO a tile by typing in the tile number.
|
|
- Changed the way masking walls work a little bit. Now the
|
|
masking walls use the picture wall[].overpicnum rather than
|
|
wall[].picnum.
|
|
- Made hitscan hit maskable walls.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/24/94 - Made palette.dat support any number of shades up to 64. There
|
|
is no change to the palette.dat format. The palette.dat
|
|
format is:
|
|
|
|
First the palette (768 bytes) Values range from 0-63
|
|
Then the lookup shades (256 * number_of_shades) The
|
|
shades are stored in groups of 256 bytes.
|
|
|
|
- If you use Mark Dochtermann's palette program, then you can
|
|
convert his data files (such as palette.pal and colormap.lmp)
|
|
to my palette format, palette.dat, with my great Qbasic
|
|
program, PALMP.BAS. To run it, first copy the basic program
|
|
into the same directory as the 2 source palette files are in.
|
|
Then type: "QBASIC PALMP" and then press SHIFT+F5 (to run it).
|
|
|
|
- Added a global variable, HORIZ. Horiz usually equals 100.
|
|
Modifying horiz will move the whole screen up / down. I
|
|
added 2 keys, +/- in my own game.c to demonstrate this. You
|
|
can use this variable for looking up and down if you want.
|
|
(Even though this is not "truly" looking up and down, if
|
|
you're lucky, you might be able to fake out some people!)
|
|
|
|
- New Key in 3D EDIT MODE, the forward slash. Use / with the
|
|
tile panning keys (, and .) to flip the horizontal / vertical
|
|
orientation bits for walls, ceilings or floors.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/28/94 - NEW BOARD VERSION! You must run CONVMAP4.EXE on all your boards.
|
|
Here's what I changed in the structures:
|
|
|
|
Sectors:
|
|
I got rid of:
|
|
char sector[].ceilingpanning, sector[].floorpanning;
|
|
sector[].ceilingstat/floorstat bit 2 zeroed out
|
|
and added:
|
|
char sector[].ceilingxpanning, sector[].ceilingypanning;
|
|
char sector[].floorgxpanning, sector[].floorypanning;
|
|
|
|
Walls:
|
|
|
|
I got rid of:
|
|
char wall[].panning;
|
|
wall[].cstat bit 6 zeroed out
|
|
and added:
|
|
char wall[].xpanning;
|
|
char wall[].ypanning;
|
|
|
|
Sprites:
|
|
|
|
I got rid of:
|
|
short sprite[].vel;
|
|
and added:
|
|
short sprite[].xvel;
|
|
short sprite[].yvel;
|
|
The reason I did this was so sprites could be moved in
|
|
different directions than sprite[].ang. Please make
|
|
use of both xvel and yvel. Here's the equation I would
|
|
use to convert from the old to new. For example:
|
|
|
|
old:
|
|
sprite[i].vel = 256;
|
|
new:
|
|
sprite[i].xvel = (sintable[(sprite[i].ang+512)&2047]>>6);
|
|
sprite[i].yvel = (sintable[sprite[i].ang&2047]>>6);
|
|
|
|
The reason I am shifting the sines right by 6 is becuase
|
|
my sintable ranges from -16384 to 16384. Dividing by
|
|
64 gives a maximum range of -256 to 256.
|
|
|
|
CONVMAP4.EXE also attempts to convert the masked walls so
|
|
overpicnum is the masked wall's picnum.
|
|
|
|
- Changed 3D EDIT MODE panning keys:
|
|
Since panning is now all 4 directions, I got rid of the
|
|
, and . keys and put the keys on the keypad using 2,4,6,8.
|
|
Usually 2,4,6,8 are for x- and y-repeats, but if you hold
|
|
down either shift key, then they act as x- and y- panning
|
|
values.
|
|
The / key now resets the panning values to 0.
|
|
|
|
- Please read the updated descriptions of how to make masking walls
|
|
in the 3D EDIT MODE KEYS in the top of build.txt. See
|
|
the 'M' and 'Shift + M' keys.
|
|
|
|
- Also look at the top of this file for a description of dragpoint(), a
|
|
great new function that makes it easy to morph sectors.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/29/94 - Added some minor keys to 3D EDIT MODE. Alt. +/- change the
|
|
visibility variable. It ranges from 5 (darkest) to 17
|
|
(lightest) and it starts at 13.
|
|
|
|
- Made 1-way walls have more options. Now, for example, you can
|
|
make rectangular switches on walls. Please look at my
|
|
nukeland.map for an example of how to do switches. (The
|
|
switches are close to start - just go through the door and
|
|
bear left.)
|
|
|
|
- For those who asked, here's how some sample bobbing code:
|
|
First, calculate the distance actually moved - because if you
|
|
are not moving then you shouldn't bob:
|
|
|
|
CODE:
|
|
oposx = posx; oposy = posy;
|
|
clipmove(&posx,&posy,&posz,&cursectnum,xvect,yvect,128L);
|
|
dist = ksqrt((posx-oposx)*(posx-oposx)+(posy-oposy)*(posy-oposy));
|
|
|
|
Then modify the horizon value by multiplying the distance
|
|
actually moved by a sine wave. (default is horiz = 100).
|
|
|
|
CODE:
|
|
horiz = 100 + ((dist*sintable[(totalclock<<5)&2047])>>19);
|
|
|
|
- Remember that moving block in the slime in NUKELAND.MAP? It
|
|
works a lot better now. I am now modifying the floor panning
|
|
values to make the floor match up correctly with the block.
|
|
|
|
- Fixed the screen capturing (F12) to save captures as PCX files.
|
|
This is for BUILD, GAME, and EDITART.
|
|
|
|
- Fixed bug in EDITART when you press 'U' on a blank tile. It
|
|
should not crash any more.
|
|
|
|
- Made Tab & Enter a little smarter in copying the right attributes
|
|
to different types of objects.
|
|
|
|
- Added ceiling / floor 90ø rotation attributes. All 8
|
|
rotations are possible. 3 bits have been added to both
|
|
the sector[].ceilingstat and sector[].floorstat flags.
|
|
If you look in BUILD.H, you will see the new flags
|
|
descriptions. You can use the 'F' key in 3D EDIT MODE on
|
|
a ceiling or floor to change the rotation.
|
|
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/30/94 - ATTENTION PROGRAMMERS:
|
|
I removed the function, getsector, and added a more expandable
|
|
function, updatesector. Also, updatesector is smart enough
|
|
to check to see if you are in the same sector OR neighboring
|
|
sectors first before going through every single sector.
|
|
Getsector used to go though all the sectors every time you
|
|
crossed a sector line.
|
|
|
|
getsector(); (no arguments, returns nothing - REMOVED)
|
|
* used to make sure that CURSECTNUM matched up with
|
|
the right sector according to the POSX and POSY values.
|
|
updatesector(posx,posy,&cursectnum);
|
|
* the new way of writing getsector. You can do a
|
|
search&replace on your code. Be careful when you use this
|
|
function with sprites because remember that the sprite's
|
|
sector number should not be modified directly. For example,
|
|
you might want to code it this way:
|
|
|
|
tempsectnum = sprite[i].sectnum;
|
|
updatesector(sprite[i].x,sprite[i].y,&tempsectnum);
|
|
if (tempsectnum != sprite[i].sectnum)
|
|
changespritesect(i,tempsectnum);
|
|
|
|
Actually, I think the setsprite function is better for
|
|
updating a sprite's sector number.
|
|
|
|
- Added swinging doors! Look at NUKELAND.MAP in my GAME.EXE for
|
|
an example. For swinging doors, I used a new math-helper
|
|
function, rotatepoint.
|
|
|
|
rotatepoint(long xpivot, long ypivot,
|
|
long x, long y,
|
|
short deltaang,
|
|
long *x2, long *y2);
|
|
|
|
Rotatepoint will rotate point(x,y) around point(xpivot,ypivot)
|
|
by the deltang value. The resultant point will be s
|
|
|
|
- Fixed crashing bug in BUILD when a wall's tile doesn't exist.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/02/94 - I improved the pre-level check on the swinging doors, so now
|
|
you can have multiple doors in a sector that open any way.
|
|
This is how I do my double swinging doors (demonstrated in
|
|
NUKELAND.MAP)
|
|
|
|
- I added a revolving door! See NUKELAND.MAP for an example. (The
|
|
revolving door is beyond the bouncing platforms in the slime
|
|
pit)
|
|
|
|
- Fixed bug with joining sectors in 2D EDIT MODE. The sprites
|
|
don't get deleted any more.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/04/94 - Optimized the masked walls.
|
|
|
|
- Cleaned up the sprite drawing code (and many bugs that that came
|
|
along with it.)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/05/94 - Made cylindrical walls with any number of points VERY easy to
|
|
make in BUILD. Here's how you do it: Highlight a wall and
|
|
press 'C' on it. Then move the mouse to the proper position
|
|
to make a nice circle. You can press '+' or '-' to change
|
|
the number of points on the circle. Press 'C' again to cancel
|
|
or press space bar to actually change the map.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/07/94 - Made a fully-operational subway! Look at subway.map.
|
|
|
|
- Made a new type of door - a sliding door where the door doesn't
|
|
get "x-smooshed" when it is opened. (See description of
|
|
sector tag 16 & wall tag 6)
|
|
|
|
- Also note that I my first subroutine in game.c! It is:
|
|
operatesector(short dasector)
|
|
All the door code is now in this function (with a few
|
|
exceptions, such as parts of the swinging doors and revolving
|
|
door)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/08/94 - Made EDITART and BUILD support different tile sizes in 'V' mode.
|
|
Here are the three possible sizes:
|
|
0. 64*64 - 5*3 grid - views 15 tiles (old default)
|
|
1. 32*32 - 10*6 grid - views 60 tiles (new default)
|
|
2. 16*16 - 20*12 grid - views 240 tiles
|
|
Press the '*' and '/' keys in 'V' mode if you want to change
|
|
the grid resolution.
|
|
|
|
- Added/fixed up a new key in 3D EDIT MODE, the dot key (. or >)
|
|
This key attempts to match up all the tiles along a wall. It
|
|
scans along the walls towards the right as long as the picture
|
|
number of the next wall is the same as the original picture
|
|
number. Note that some walls may not work right, especially
|
|
floor / ceiling steps.
|
|
|
|
- Made 2D EDIT MODE default to this when inserting sprites:
|
|
1. Sprite clipping = on for sprites taller than 32 pixels
|
|
2. Sprite clipping = off for sprites shorter than 32 pixels.
|
|
|
|
- Fixed sprite clipping with Z-coordinates
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/10/94 - Fixed some sprite dragging bugs
|
|
|
|
- Made neartag? maximum sensing distance a global variable called
|
|
neartagdist. See build.h.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/11/94 - Added sector / groups of sectors selection. When selecting
|
|
sectors, hold down the right ALT key. It works just like
|
|
right shift. You must completely surround any sector you
|
|
wish to select. Once selected, you can drag the mess of
|
|
sectors with the mouse. This is great for separating sectors
|
|
from each other.
|
|
|
|
- Added sector duplication. First select a bunch of sectors. Then
|
|
press the insert key. (with the select sectors flashing) Then
|
|
This duplication is like stamping. So, you must drag
|
|
the sector bunch somewhere else after stamping to see your
|
|
great accomplishments.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/12/94 - Added group-sector PGUP / PGDN. Here's a neat trick that will
|
|
let you move a whole section of a board up / down quickly.
|
|
First you select a bunch of sectors with the right ALT key in
|
|
2D mode. Then flip to 3D mode and if you press PGUP / PGDN
|
|
on any of the highlighted sectors, the rest of the highlighted
|
|
sectors will move also.
|
|
|
|
- Added group-sector rotation. Once you do a sector select (right
|
|
ALT), you can press the , or . keys to rotate the selected
|
|
sectors. Hold down the shift key with the keys to get fine
|
|
angle rotation (WARNING: You will get distortion with fine
|
|
angle rotation in this version)
|
|
|
|
- Added sector count and wall count information at the bottom of
|
|
the 2D edit mode status bar.
|
|
|
|
- Fixed some stupid bug that you probably wouldn't have found if
|
|
you made boards with BUILD for the rest of your life.
|
|
|
|
- You can now press 'B' to block / unblock a wall or sprite in
|
|
2D edit mode.
|
|
|
|
- Made Ctrl-Shift Enter auto-shade a sector. First make any
|
|
wall of the loop as light as the lightest shade you want.
|
|
Then make any other wall of the loop as dark as the darkest
|
|
shade you want. Finally press Ctrl-Shift Enter on the wall
|
|
that should be lightest. Now the loop should be smoothly
|
|
shaded. If it is not smoothly shaded, you may need to insert
|
|
more points on the walls.
|
|
|
|
- Fixed my .PCX format bug. My screen captures now load properly
|
|
in Deluxe programs.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/13/94 - Made my serial code in Game.c work better. I fixed the bullet
|
|
shooting and made all types of doors work. Unfortunately, you
|
|
still may have to run at slower COM speeds.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/14/94 - Fixed deadly bug with sector copy & sprites.
|
|
|
|
- Added hitscan sensitivity bit. It is bit 6 (64) of wall[].cstat.
|
|
In 3D edit mode, you can press 'H' to toggle the bit. (H used
|
|
to be like 'V' for choosing height tile numbers for groudraws -
|
|
I change the 'H' key to Alt-V since I don't think anybody was
|
|
using it anyway) By default, hitscan CAN go through maskable
|
|
walls. If a hitscan is set to not go through a maskable wall,
|
|
The wall will appear BRIGHT pink in 2D edit mode.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/15/94 - Made more subroutines in game.c and moved documentation from the
|
|
end of game.c into this text file. Added some more comments
|
|
also. Game.c is so much easier to read now! The main loop is
|
|
less than 50 lines long!
|
|
|
|
- Made some optimizations to my serial code now that everything
|
|
is in functions.
|
|
|
|
- ATTENTION PROGRAMMERS:
|
|
I added one new paramater (cliptype) to both the movesprite
|
|
and clipmove functions. If the new parameter is a 0, then
|
|
the clipping is normal (Use 0 to clip you and monsters).
|
|
If the new parameter is a 1, then the object is clipped to
|
|
the same things that hitscan is clipped to (use 1 for all
|
|
bullets).
|
|
See the above documentation for a detailed description of the
|
|
parameters. (Remember that I moved the documentation from
|
|
GAME.C into the middle BUILD.TXT)
|
|
Finally, you can have sprites and bullets going where you
|
|
want them to go!
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/18/94 - Added support for the Spaceplayer (6-degree of freedom Space ball)
|
|
Try out the SETUP program now.
|
|
|
|
- Fixed some bugs with the 'E' key in 3D EDIT MODE. As long as both
|
|
dimensions of the tile are powers of 2, then the picture should
|
|
be visible. It should not be a solid color with a few weird
|
|
lines any more.
|
|
|
|
- Fixed some bugs with the Z control in 3D EDIT MODE. In normal
|
|
operation, BUILD attempts to keep your Z constant even if
|
|
you cross sector lines. Then I added a special new mode that
|
|
locks your heightofffloor to a certain value. You Z will
|
|
change instantly if you cross sector lines. To use this mode,
|
|
press the Caps Lock key. Press Caps Lock key again for normal
|
|
operation.
|
|
|
|
- ATTENTION PROGRAMMERS! I put all of engineinput into GAME.C
|
|
This means you have absolutely total control of the Z's. (The
|
|
only thing left is some key code I still have in my timer
|
|
handler)
|
|
|
|
OK, now read carefully! Here's how to convert to the new OBJ's:
|
|
|
|
1. First of all, the Spaceball code is now also in game.c.
|
|
A. You will need to put this line in game.c:
|
|
include "spw_int.h"
|
|
B. And make sure to add spwint.obj your makefile.
|
|
2. Heightoffceiling, heightofffloor, and gravity have been
|
|
removed from BUILD.H. If you still want to use them
|
|
then you should defined them as globals in your own code.
|
|
3. You should go through every single key of my gameinput()
|
|
function in game.c and copy any code you want.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/23/94 - GREAT NEW STUFF!
|
|
|
|
Be sure to check out GAME.EXE and try out these new keys!
|
|
|
|
Rt. Enter = Switch between 3D / 2D modes
|
|
Lt. +/- = Zoom in 2D mode
|
|
|
|
Added 2D map display with auto-mapping! The 2D maps use a
|
|
higher resolution 16-color mode. You have a choice of either
|
|
using a 640*350*16 screen or a 640*480*16 screen with a 144-high
|
|
status bar (remember that 640*480*16 cannot fit in 256K with 2
|
|
screen pages so I have to cheat with a status bar).
|
|
|
|
NEW FUNCTIONS:
|
|
|
|
draw2dscreen(long posxe, long posye, short ange, long zoome,
|
|
short gride)
|
|
Draws the 2d screen - this function is a direct replacement
|
|
for the drawrooms() and drawmasks() functions. Be sure
|
|
to call either qsetmode640350() or qsetmode640480()
|
|
first. When switching back to 3d mode, be sure to call
|
|
qsetmode320200().
|
|
|
|
IMPORTANT NOTES:
|
|
1. The overwritesprite function should only be called in
|
|
3D mode. If you do this in 2D mode, junk will be
|
|
written to the 2D screen and a crash is possible.
|
|
2. When you switch back to 3D mode, you should call the
|
|
permanentwritesprite functions to draw the status bar,
|
|
or whatever else you have to draw.
|
|
3. You must call the nextpage() function in both 2D and
|
|
3D modes.
|
|
|
|
qsetmode320200();
|
|
Set to the game mode and load palette (320*200*256)
|
|
qsetmode640350();
|
|
Set to the 2D map mode #1 (640*350*16)
|
|
qsetmode640480();
|
|
Set to the 2D map mode #2 (640*480*16)
|
|
|
|
NEW VARIABLES (see description in build.h):
|
|
|
|
EXTERN char show2dwall[MAXWALLS>>3];
|
|
EXTERN char show2dsprite[MAXSPRITES>>3];
|
|
EXTERN char automapping;
|
|
|
|
- Added parallaxing floors! Works like the parallaxing skies, but
|
|
the other side. In 3D EDIT MODE, press P on ceiling for
|
|
parallaxing sky, or press P on floor for parallaxing floor.
|
|
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/24/94 - There is a new function that I forgot to document in the last
|
|
version. Oops!
|
|
|
|
doanimations() is this function.
|
|
It's not really new, but I split it off of the
|
|
drawrooms/drawmasks functions. This function animates anything
|
|
that you use setanimation with. Please stick it in your code
|
|
somewhere after you draw the screen.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/26/94 - You can now do TRANSLUSCENT sprites! I am using bit 1 of
|
|
sprite[].cstat to detemine whether or not the sprite is
|
|
transluscent or not. In 3D EDIT MODE, you can press 'T' to
|
|
toggle the transluscence bit.
|
|
IMPORTANT: Transluscence WILL NOT WORK until you run my
|
|
TRANSPAL.EXE program. On the command line, simply type:
|
|
C:\BUILD>transpal [filename]
|
|
If you do not specify a filename, the default will be
|
|
palette.dat. If your palette.dat file is now around 40K long,
|
|
then you are ready for transluscence!
|
|
|
|
- Added TRANSLUSCENCE to masked walls. See bit 7 of wall[].cstat.
|
|
Press 'T' on wall to toggle the transluscence bit.
|
|
|
|
- In this BUILD update, I have collected many different palettes
|
|
for comparison purposes. Try running TRANSPAL.EXE on each of
|
|
them and see for yourself which palettes work the best with
|
|
transluscence!
|
|
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/29/94 - ATTENTION PROGRAMMERS: I completely rewrote the neartag code.
|
|
Here's what you have to do to convert your game.c files:
|
|
|
|
1. You should move the neartag variables that I used to
|
|
have in BUILD.H into your C code.
|
|
2. You must call the neartag function yourself if you want
|
|
to see if you're near a tagged object. Neartag is NOT
|
|
automatically updated by the engine any more.
|
|
3. I highly recommend that you put your neartag function
|
|
call at the first line in your space bar code. This way,
|
|
you can optimize the neartag calculations by only doing
|
|
them when you press the space bar. (Exception: For
|
|
ladders, I think you'll have to call neartag every single
|
|
frame)
|
|
|
|
Here's a description of the new neartag function:
|
|
Neartag works sort of like hitscan, but is optimized to
|
|
scan only close objects and scan only objects with
|
|
tags != 0.
|
|
|
|
neartag(long x, long y, long z, short sectnum, short ang, //Starting position & angle
|
|
short *neartagsector, //Returns near sector if sector[].tag != 0
|
|
short *neartagwall, //Returns near wall if wall[].tag != 0
|
|
short *neartagsprite, //Returns near sprite if sprite[].tag != 0
|
|
long *neartaghitdist, //Returns actual distance to object (scale: 1024=largest grid size)
|
|
long neartagrange) //Choose maximum distance to scan (scale: 1024=largest grid size)
|
|
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/31/94 - Added a function to get a sprite's screen coordinates. I put
|
|
some sample code in my GAME in the analyzesprites function.
|
|
Simply hold down the CAPS LOCK key in my GAME.EXE, and the
|
|
screen will be centered around the sprite closest to the
|
|
center of the screen.
|
|
|
|
Here's a new function in the engine I used to do this:
|
|
|
|
getspritescreencoord(short spritesortnum, long *scrx, long *scry)
|
|
|
|
Note that spritesortnum is the index into the spritesortcnt
|
|
arrays, NOT the normal sprite arrays. Scrx and scry are actual
|
|
screen coordinates ranging from 0-319 and 0-199 respectively.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/6/94 - Made EDITART support sprite centering and animation speed.
|
|
|
|
Now when you press 'A' in EDITART, the animation speed is
|
|
actually saved to disk and runs the same speed in BUILD
|
|
and your GAME. Press + and - to change the animation speed.
|
|
There are 16 different animation speeds.
|
|
(Speed is proportional to (totalclock>>animspeed))
|
|
|
|
To center a sprite, press the weird ~` key (located just above
|
|
the TAB key). You will see some cross hairs. Simply use
|
|
the arrow keys to the desired position.
|
|
|
|
For both the 'A' and ~` keys, you can press Enter to accept
|
|
the new values or ESC to cancel.
|
|
|
|
- Added a variable to BUILD.H, lockclock. Lockclock is to
|
|
totalclock as lockspeed is to clockspeed.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/7/94 - Made 3 different Z coordinate modes in BUILD.
|
|
|
|
Mode 0: Game mode (default)
|
|
Mode 1: Height lock mode
|
|
Mode 2: Float mode
|
|
|
|
Press Caps Lock to switch between the 3 modes.
|
|
A and Z move up and down for all 3 modes.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/10/94 - Added a new function that should solve all your sound problems.
|
|
|
|
kenchaintimer(void (__interrupt __far *datimerchainaddress)(),
|
|
short dachainpersecond)
|
|
|
|
Please look at the IMPORTANT ENGINE FUNCTIONS section above for
|
|
a full description.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/20/94 - Got rid of the comsend / comgetchar functions. Replaced them
|
|
with sendpacket and getpacket.
|
|
|
|
- Added network support.
|
|
|
|
- Got rid of qsetmode320200(). Just replace it with setgamemode().
|
|
The 2 are exactly the same.
|
|
|
|
- Got rid of clockspeed variables. Just replace it with lockspeed.
|
|
|
|
- Adjusted my z directions of shooting depending on the horizon.
|
|
You may want to readjust your code for this.
|
|
|
|
- You now pass the number of tics as a long to doanimations.
|
|
doanimations(long numtics);
|
|
|
|
- FIXED DEADLY BUG! This may have been causing bigtime crash-city
|
|
bugs! The problem was with show2dsprite and show2dwall. In
|
|
my engine.c I forgot that they were BIT arrays, not BYTE arrays.
|
|
When I initialized the arrays to 0, I initialized 8 times the
|
|
length, possibly overwriting your precious data! I initialize
|
|
these arrays in the initengine and loadboard functions.
|
|
|
|
- ATTENTION PROGRAMMERS: In order to get rid of the posx, posy,
|
|
posz, ang, posz, and horiz variables from BUILD.H, I added some
|
|
parameters to a few functions. YOU MUST REWRITE YOUR CODE
|
|
TO SUPPORT THESE:
|
|
loadboard(char *filename, long *posx, long *posy, long *posz,
|
|
short *ang, short *cursectnum)
|
|
saveboard(char *filename, long *posx, long *posy, long *posz,
|
|
short *ang, short *cursectnum)
|
|
drawrooms(long posx, long posy, long posz,
|
|
short ang, long horiz, short *cursectnum)
|
|
|
|
THESE VARIABLES SHOULD BE MOVED INTO GAME.C:
|
|
long posx, posy, posz, horiz;
|
|
short ang, cursectnum;
|
|
long hvel;
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/22/94 - ATTENTION PROGRAMMERS: Added 1 parameter to movesprite, the
|
|
number of tics (such as lockspeed).
|
|
|
|
movesprite(short spritenum, long xchange, long ychange,
|
|
long zchange, long walldist,
|
|
char cliptype, long numtics)
|
|
|
|
- ATTENTION PROGRAMMERS: At one time, I used to have 4 timing
|
|
variable in the engine. (totalclock, clockspeed,
|
|
lockclock, lockspeed). I got rid of all of them except
|
|
totalclock. If you want to use the other 3 variables, you
|
|
must simulate them yourself. Here's how you do it:
|
|
|
|
Step 1. Define clockspeed, lockclock, and lockspeed as global
|
|
longs in your code.
|
|
|
|
Step 2. Be sure to zero out all 3 variables just before
|
|
starting to play each level. (You could zero out
|
|
totalclock also.)
|
|
|
|
Step 3. Right after every time you call the nextpage()
|
|
function, insert this code line for line:
|
|
|
|
lockspeed = totalclock-lockclock;
|
|
lockclock += lockspeed;
|
|
clockspeed = lockspeed;
|
|
|
|
You really don't need clockspeed if you have lockspeed.
|
|
You should replace all clockspeed's with lockspeed's.
|
|
Before, I had both because both totalclock and clockspeed used
|
|
to be incremented in the timer handler and could be changed
|
|
at any time.
|
|
|
|
- I added my own optional random function, krand() which returns
|
|
a pseudo-random number as a long from 0 to 65535. Notice that
|
|
I put a randomseed variable in BUILD.H called randomseed.
|
|
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/24/94 - I just want to try to explain how all of my multiplayer code
|
|
works. Theory: Think of the whole program as 2 functions:
|
|
|
|
Function 1. Draw the screen (could be 2D / 3D)
|
|
Function 2. Move things. (sprites, walls, sectors, and you!)
|
|
|
|
My communications in GAME.C work on a MASTER/SLAVE
|
|
system where it would be nice if the faster computer was the
|
|
MASTER. (Right now, the first computer in is the MASTER).
|
|
The big trick to keeping everything in sync (and I do mean
|
|
everything- even moving platforms, revolving doors, & subways)
|
|
is to call function #2 with the exact same parameters as input
|
|
on all computers the same number of times and in the same
|
|
order. Now this might seem like a lot of information but it
|
|
really isn't! Let me explain the role of the MASTER and SLAVE:
|
|
|
|
The MASTER's job:
|
|
1. Read in own input changes
|
|
2. Read in any slave player input changes
|
|
(getpackets function - reads in foreign vel, svel,
|
|
angvel, & the bits)
|
|
|
|
3. Just before calling the movethings function, send the
|
|
input to the movethings function:
|
|
A. Master's tic cnt (synctics)
|
|
B. Every player's velocities (syncvel, svel, angvel)
|
|
C. Every player's status bits (Space, Ctrl, Shift, etc.)
|
|
4. Call the movethings function
|
|
5. Draw screen
|
|
|
|
The SLAVE's job:
|
|
1. Read in own input changes
|
|
2. Send own input changes to master.
|
|
3. Read in all master movethings input parameters and
|
|
call movethings function for each packet. This may
|
|
mean calling the movethings function more than once
|
|
between calling the drawscreen functions. This is
|
|
waste, but it's the price you have to pay to keep
|
|
things in sync.
|
|
4. Draw screen
|
|
|
|
|
|
You may ask how do monsters stay in sync even if you are
|
|
not sending any monster information over the line. The
|
|
answer to this is simple.
|
|
1. You make sure that a random seed starts the same on
|
|
both computers.
|
|
2. Only call the rand() or krand() function in the
|
|
movethings function.
|
|
|
|
Before you try my demo, I wanted to say that, I have
|
|
ABSOLUTELY NO ERROR CORRECTION in my code at this point. It
|
|
is most certainly my next project. For serial link, I would
|
|
recommend a rate of about 14400 baud. In the future, I think
|
|
I can optimize the code enough to work at rates as low at 2400
|
|
baud! Let me explain how well certain setups should work
|
|
without error correction:
|
|
Ken's guesses on how badly it will crash WITH NO ERROR
|
|
CORRECTION (Build the way it is now):
|
|
|
|
1. Serial link using 8250 chips - out of sync after 15
|
|
seconds because a few bytes were missed.
|
|
2. Serial link using 16550 chips - out of sync after 10
|
|
minutes because 16550 chips have a 16 byte FIFO and
|
|
therefore don't lose bytes as often as the 8250.
|
|
3. Modem - out of sync after less than 5 seconds.
|
|
4. Network - out of sync after 1 minute. Networks love to
|
|
lose full packets here and there.
|
|
|
|
I will be working on error correction for all of the above
|
|
situations. Any error correction techniques I use will be
|
|
internal to the engine and completely transparent to you (so
|
|
you can start coding now!) If the demo actually works multi-
|
|
player, then you may want to look at my GAME keys at the top
|
|
of this file again. There are some significant changes.
|
|
|
|
* I replaced the old COM functions section at the top of
|
|
BUILD.TXT with a COMMUNICATIONS FUNCTIONS section. Please
|
|
look through it for descriptions of at least these 2
|
|
functions:
|
|
|
|
sendpacket(short otherconnectnum, char *bufptr, short bufleng)
|
|
getpacket(short *otherconnectnum, char *bufptr)
|
|
|
|
* Another rule to keep in mind while testing: (as if there
|
|
aren't enough already) Always make sure you have the
|
|
same EXE's and MAP'S or else the games will get out of sync.
|
|
|
|
* Connection numbers and Index numbers:
|
|
For networks, each computer has a given connection number.
|
|
Connection numbers range from 1 to 100. Player number 1
|
|
might have connection number 5 and player number 2 might have
|
|
connection number 17. Since a player's connection number
|
|
can be anything between 1 and 100, I don't want you to
|
|
allocate 100 of every variable such as posx[100]. My
|
|
solution was to make index numbers. So in this case:
|
|
|
|
connectnum[0] = 5; connectindex[5] = 0;
|
|
connectnum[1] = 17; connectindex[17] = 1;
|
|
|
|
* Now I'll will describe some new variables at the top of GAME.C
|
|
|
|
myconnectnum - connection number of your computer
|
|
myconnectindex - index number of your computer
|
|
masterconnectnum - connection number of the MASTER computer
|
|
screenpeek - index number of which player's eyes you are
|
|
looking through.
|
|
numplayers - if numplayers >= 2 then multiplayer mode is
|
|
enabled, else single player game.
|
|
|
|
connecthead, connectpoint2[MAXPLAYERS] - These 2 variables
|
|
form a linked list of all the index numbers.
|
|
Here's some example code that traverses the list of
|
|
players:
|
|
|
|
p = connecthead;
|
|
while (p != -1)
|
|
{
|
|
printf("Player index %d has connection number %d\n",p,connectnum[p]);
|
|
p = connectpoint2[p];
|
|
}
|
|
|
|
* These variables are used to record / playback a demo. (This
|
|
is like POSCAPT.DAT, but with everything in sync!) In my
|
|
GAME, i single player mode, I have it so if you press the
|
|
Left ENTER, then it will playback everything. These are
|
|
the only variables necessary to store a demo run:
|
|
|
|
static long reccnt; //Number of frames
|
|
static short recsyncvel[16384]; //Vel for each frame
|
|
static short recsyncsvel[16384]; //Svel for each frame
|
|
static short recsyncangvel[16384]; //Angvel for each frame
|
|
static short recsyncbits[16384]; //Bits for each frame
|
|
static short recsynctics[16384]; //Tics for each frame
|
|
|
|
* These variables are used for communications syncing:
|
|
|
|
static short syncvel[MAXPLAYERS+1]; //Vel of each player
|
|
static short syncsvel[MAXPLAYERS+1]; //Svel of each player
|
|
static short syncangvel[MAXPLAYERS+1]; //Angvel of each player
|
|
static short syncbits[MAXPLAYERS+1]; //Bits for each player
|
|
static short synctics; //Number of tics of MASTER ONLY
|
|
|
|
* Unless I suddenly make BUILD a 6-degree of freedom engine
|
|
tomorrow, this should be the most difficult update in a long
|
|
time! Good Luck in programming! I'm sure I left a lot of
|
|
things out, so I'll be expecting plenty of phone calls!
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/27/94 - I scaled the vel, svel and angvel variabile down 1 bit so they
|
|
fit into a signed char. (Before they ranged from -256 to 256)
|
|
Now they range from (-128 to 127).
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/28/94 - Optimized the size of my COM(modem)/network packets in game.c.
|
|
I made the tics into a char. I also use some new buffers called
|
|
osyncvel, osyncsvel, osyncangvel, and osyncbits. Now I send
|
|
extra byte with bit fields that tell whether I need to update
|
|
the syncvel, syncsvel, syncangvel, or syncbits variables. If
|
|
the bit field of the extra byte is off then I don't send the
|
|
byte(s) it represents. You can now play my GAME at 4800 baud.
|
|
|
|
static signed char syncvel[MAXPLAYERS+1], osyncvel[MAXPLAYERS+1];
|
|
static signed char syncsvel[MAXPLAYERS+1], osyncsvel[MAXPLAYERS+1];
|
|
static signed char syncangvel[MAXPLAYERS+1], osyncangvel[MAXPLAYERS+1];
|
|
static short syncbits[MAXPLAYERS+1], osyncbits[MAXPLAYERS+1];
|
|
static unsigned char synctics;
|
|
|
|
- There was an crashing error with transluscence palette on low
|
|
memory configurations. When you exit the BUILD editor,
|
|
you normally get some numbers like this.
|
|
Memory status: 788979(788979) bytes
|
|
If the first number (art memory cache size) was less than the
|
|
second number (art file size), then the whole art file did
|
|
not fit in memory. The reason for the crashing was because
|
|
loadpics() sucks all memory up to the size of the art file.
|
|
The 64K transluscent palette is malloc'd when you call the
|
|
setgamemode() function for the first time. The was no memory
|
|
left to allocate the palette. I fixed this by making the
|
|
transluscent palette take 64K of the art memory cache if
|
|
it could not malloc the 64K.
|
|
|
|
- I programmed some error correction for the COM(modem). Here is
|
|
my new of Ken's guesses on how badly it will crash (assuming
|
|
that it will always crash eventually.) You will be seeing new
|
|
and better correction methods in the future.
|
|
|
|
ERROR CORRECTION METHOD #1:
|
|
1. Serial link using 8250 chips - out of sync after 5 minutes.
|
|
2. Serial link using 16550 chips - out of sync after 10 minutes.
|
|
3. Modem - out of sync after 3 minutes - try it!
|
|
4. Network - out of sync after 1 minute. Networks love to
|
|
lose full packets here and there. (not changed)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/29/94 - Added some code to my GAME.C that will let you type in messages
|
|
and send them to all remote players. Press Tab (or T for
|
|
those people who play that other, very bad, game too much)
|
|
to start typing in a message. Press either Enter key to send
|
|
the message to the other player.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/30/94 - ATTENTION PROGRAMMERS: I changed the values that clipmove and
|
|
movesprite return! Here's how they work now:
|
|
If you did not hit anything, then they return 0.
|
|
Movesprite only: If the object hits a ceiling / floor
|
|
then movesprite returns 16384+(sectornum hit).
|
|
If the first object you hit before sliding was a wall,
|
|
then they return the 32768+(wallnum hit).
|
|
If the first object you hit before sliding was a sprite,
|
|
then they return the 49152+(spritenum hit).
|
|
|
|
Be careful when adding these changes to your code since the
|
|
return value are sort of reversed:
|
|
|
|
return values: º Hit nothing: ³ Hit something:
|
|
ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÎÍÍÍÍÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ
|
|
Old functions: º 1 ³ 0
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ×ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ-
|
|
º ³ 16384+sectnum (Movesprite only)
|
|
New functions: º 0 ³ or 32768+wallnum
|
|
º ³ or 49152+spritenum
|
|
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/1/94 - Made getangle always return an angle from 0 to 2047. Before I
|
|
forgot to and it 2047 and sometimes the angle was negative.
|
|
|
|
- Made overwritesprite when using the centering option be sensitive
|
|
to the Editart centering tool. (The ~` key.)
|
|
|
|
- Made Ctrl+Rt.Shift highlight points on a loop rather than points
|
|
inside a rectangle.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/2/94 - Added some neat features to my GAME.C to make multi-player mode
|
|
even more fun. I added a portable bowling ball/bomb-thrower.
|
|
kills instantly! (similar to rocket launcher) I also added
|
|
water fountains. If you hold the space bar down on them,
|
|
you slowly get more life.
|
|
|
|
- O.K. I think I actually got the syncronization working perfectly
|
|
for COM(modem) play. I haven't had all day to test it out yet!
|
|
(Still no error correction with networks)
|
|
|
|
Here are some steps in playing over the modem:
|
|
1. Be sure that both people have the exact same version of
|
|
the EXEs, ART, and MAPs.
|
|
2. Then go into SETUP and set the COM port to the com port
|
|
of your modem. Even though 9600 baud should work, I
|
|
would recommend going at 4800 baud because:
|
|
A. It works fine at 4800 baud so there is really
|
|
no need to go any faster.
|
|
B. Fewer errors over the modem so less time
|
|
spent re-sending packets.
|
|
3. Then type: MODEM [mapname] (must be same mapname!)
|
|
This will bring you into my terminal program. You can
|
|
set the modem initialization string in MODEM.BAT by
|
|
changing the first command line option of the TERM
|
|
line. Please disable modem compression and
|
|
correction for least jerky play. Then connect with
|
|
the other modem using various methods, such as one
|
|
person typing ATA and the other typing ATD or one
|
|
person typing ATS0=1 and the other typing
|
|
ATDT(phone #).
|
|
4. Wait through the beeps and buzzes until it says CONNECT
|
|
on the bottom window.
|
|
5. If you can now chat with each other then things are
|
|
going well. When the first person presses ESC, both
|
|
computers will automatically quit to DOS and go right
|
|
into the GAME.
|
|
6. Play!
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/5/94 - Serial moder over COM(modem) should work perfectly now.
|
|
|
|
- Added scaredfallz to BUILD.H. It is a global variable that
|
|
tells monsters what height is too high to fall through. You
|
|
can set cliptype parameter to 2 for movesprite and clipmove.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/6/94 - Fixed clipping bug that used to let you go through certain concave
|
|
corners.
|
|
|
|
- Added new function which works well with clipmove. Ever notice
|
|
was when you're at the edge of a cliff and you go just a tiny
|
|
bit over, you fall, but shouldn't yet? Unlike what you have
|
|
been doing, this new function finds the highest and lowest z
|
|
coordinates that your clipping BOX can get to. It must search
|
|
for all sectors (and sprites) that go into your clipping box.
|
|
Currently, you were searching the z's at the center point only
|
|
by simply using the sector[].ceilingz and sector[].floorz
|
|
variables.
|
|
|
|
getzrange(long x, long y, long z, short sectnum,
|
|
long *ceilz, long *florz,
|
|
long walldist, char cliptype)
|
|
|
|
Pass x, y, z, sector normally. Walldist can be 128. Cliptype
|
|
can be 0, 1, or 2. (just like movesprite and clipmove)
|
|
This function returnes the 2 z maxes in ceilz and florz.
|
|
See GAME.C for an example.
|
|
|
|
- Fixed bug with weird vertical lines in transluscent masked walls
|
|
in chain mode.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/10/94 - Made screen capture (F12) work in 2D modes also. It always
|
|
saves to a 256 color PCX file.
|
|
|
|
- Made screen re-sizeable. Use this easy new function to re-size
|
|
the screen:
|
|
|
|
setview(long scrx1, long scry1, long scrx2, long scry2);
|
|
|
|
It is TOO easy to use. You simply pass is the Upper-left hand
|
|
corner and the bottom-right corner in screen coordinates of the
|
|
rectangular region you want the engine to draw to. The engine
|
|
automatically centers the horizon at the middle of the window and
|
|
scales everything properly.
|
|
|
|
Notes:
|
|
- Since the engine does extra scaling calculations for
|
|
window sizes that are not 320 pixels wide, I do not
|
|
recommend making the default mode with a window size
|
|
just under 320 pixels wide since the engine can
|
|
actually run a little slower. (such as 312-319
|
|
pixels wide) Keep them 320 wide.
|
|
- Feel free to modify the startumost / startdmost arrays
|
|
AFTER a setview call if you want weird window shapes.
|
|
Keep in mind that startumost[0] and startdmost[0] are
|
|
always refer to the left edge of the viewing window.
|
|
(NOT left edge of screen.)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/19/94 - Finally got around to writing the number-of-tiles-per-file
|
|
resizer. Simply type rsizeart. All instructions will be
|
|
displayed when running the program before the actual
|
|
conversion.
|
|
|
|
- Fixed a few bugs in Editart. I hope I fixed those evil bugs that
|
|
rarely come by. I'm pretty sure I fixed the bug that made the
|
|
screen go blank in 'V' mode, and the bug where a few pixels
|
|
in the top left corners of tiles sometimes get overwritten.
|
|
|
|
- Added a key in Build 2D edit mode. Press 'E' on a sprite to
|
|
change its status list number.
|
|
|
|
- Fixed those lousy Editart subdirectory colors in 'U' for those
|
|
teams with great color palettes, but don't have my ugly shade
|
|
of pink.
|
|
|
|
- Fixed bug with non-200 high P-skies. The p-skies are now (by
|
|
default) centered on the horizon no matter what the height is.
|
|
|
|
- Added multiple size PCX and GIF support in Editart. You can now
|
|
load pictures up to 1024*256. (That's all that can fit in VGA
|
|
video memory) If you need to load a bigger picture than that,
|
|
it will be chopped off at the bottom, but will still load the
|
|
top piece.
|
|
|
|
- I know that I have introduced some wonderful new bugs with the
|
|
sprite drawing. I know why they're happening, but I am
|
|
looking for a good solution so as to not make you change
|
|
any code. I will put another upload with these bugs fixed
|
|
soon.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/20/94 - Added TRUE ornamented walls. Right now the actual ornamentation
|
|
must be programmed by you with 2 simple functions:
|
|
|
|
copytilepiece(long tilenume1, long sourcex1, long sourcey1,
|
|
long xsiz, long ysiz,
|
|
long tilenume2, long destx1, long desty1)
|
|
|
|
* This function simply copies any section of a source tile
|
|
to any part of a destination tile. It will automatically
|
|
skip transparent pixels. It will wrap-around in the
|
|
source but not the destination. If for some reason
|
|
the destination tile gets removed from the cache, the
|
|
destination tile will be reset to original form. This
|
|
is why I had to add this second function:
|
|
|
|
allocatepermanenttile(short tilenume, long xsiz, long ysiz)
|
|
|
|
* This function allocates a place on the cache as permanent.
|
|
Right now, I reset the cache every time you call this
|
|
function so I would recommend calling this function
|
|
right after loadpics.
|
|
|
|
I have an example of both of these functions in GAME.C. Try
|
|
playing GAME DOOM1.MAP and go into the secret room with
|
|
the pictures of Ken. Shoot some walls there. The pictures
|
|
with Ken and the Explosion over it were done with
|
|
copytilepiece and allocated permanently at tile 4095. A
|
|
good idea for allocating permanent tiles would be to start
|
|
at 4095 and decrement. You can also allocate a permanent
|
|
tile over the original tile itself.
|
|
|
|
- Tile panning matching keys work a lot better. They now work
|
|
well with bottom steps. Also, it works well with matching
|
|
up windows.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/25/94 - A week ago, I uploaded a version of BUILD which unfortunately
|
|
had more bugs than the previous version. This upload should
|
|
have those bugs fixed - especially the sprite bugs. (I hope)
|
|
|
|
- I think I may actually have the sprite feet behind stairs bug
|
|
working perfectly.
|
|
|
|
- The engine should now be even faster the before last week. (A
|
|
week ago, I temporarily changed the parallaxing sky algorithm,
|
|
making the engine slower in those areas)
|
|
|
|
- Added a variable, parallaxyoffs in BUILD.H. It defaults to 0.
|
|
If you set it to 100, then all parallaxing skies will be
|
|
properly moved 100 pixels higher.
|
|
|
|
- Fixed some weird drawing bug related to parallaxing skies and
|
|
sprites.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/26/94 - Made sprite's sectors dependent on the z coordinates in the BUILD
|
|
editor. (Helpful if you use overlapping in your maps)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/29/94 - Made precache function. Simply call:
|
|
precache() (no parameters)
|
|
right after you call loadboard(?,?,...) and it will load
|
|
all tiles in the current board into the cache. Note that
|
|
animations of sprites after the first one will not be
|
|
precached. I have included my precacheing code at the
|
|
end of game.c for those interested in making the precaching
|
|
fancy.
|
|
|
|
- Fixed bug in editart which made it sometimes save the art files
|
|
and names.h in the wrong directory (the last directory you
|
|
were in when you were in 'U' mode). You may want to search
|
|
your artwork directories to see if you were a victim of this
|
|
bug.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/30/94 - Made Ctrl-Enter paste parallaxing sky tiles to all neighboring
|
|
parallaxing sky areas also.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/31/94 - Fixed (most) crashing bugs - Doesn't even crash on the highest
|
|
skyscrapers now! Since I can never be SURE that the crashing
|
|
is gone, I need you to test it for me - compare the number
|
|
of times it crashes per second since the last version. It
|
|
should be much better.
|
|
|
|
- Fixed sector line bug! Get close to a step, hold down Shift+Z
|
|
and the edges of the step will NOT jitter like before AND you
|
|
will not get random walls going through the screen.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/1/94 - Got rid of the OLD transluscent stuff from overwritesprite and
|
|
permanentwritesprite. (Before it used the 8K shading table
|
|
which didn't work very well)
|
|
|
|
- Added new true 50/50 transluscence option to overwritesprite.
|
|
See bit 2 in the next comment.
|
|
|
|
- Fixed overwritesprite so it works with different screen sizes.
|
|
You don't need to do any scaling calculations! Should be
|
|
compatible with old function. Added new bit 1 to orientation
|
|
parameter to determine whether or not the sprite should be
|
|
scaled and clipped to the viewing window.
|
|
|
|
overwritesprite (long thex, long they, short tilenum,
|
|
signed char shade, char orientation)
|
|
|
|
If Bit 0 of orientation = 0: (thex, they) is top-left corner
|
|
If Bit 0 of orientation = 1: (thex, they) is middle
|
|
If Bit 1 of orientation = 0: no relation to viewing window
|
|
If Bit 1 of orientation = 1: scale and clip to viewing window
|
|
If Bit 2 of orientation = 0: normal
|
|
If Bit 2 of orientation = 1: 50/50 transluscent!
|
|
|
|
* If it works at full screen, simply set bit 1 of orientation
|
|
to 1, and it should automatically scale properly!
|
|
|
|
- Made it so 2/4/6/8 keys in 3D EDIT MODE now only move the objects
|
|
1 step rather than continuously, giving more control over the
|
|
repeat/panning values of things.
|
|
|
|
- Made the / key not only reset the repeats of walls, but also for
|
|
sprites. It will set both repeats of the sprite to the default
|
|
size of 64. If you hold down shift with / on a sprite, it
|
|
will give the sprite a square aspect ratio by setting the
|
|
xrepeat to equal the yrepeat value.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/2/94 - Doubled the board size from: (0 to 65536, 0 to 65536) to
|
|
(-65536 to 65536, -65536 to 65536) Notice that the grid in
|
|
2D EDIT MODE is much bigger than before. Since it is very easy
|
|
to double the maximum board size, just tell me if you need
|
|
a larger board. The only bad thing about allowing larger
|
|
boards is that the map designer is more likely to make some
|
|
sectors too large and cause overflow bugs. 32 bits can only
|
|
go so far you know!
|
|
|
|
- I think I MAY have fixed a bug in BUILD that used to make it crash
|
|
when quitting. It had something to do with the vertical grid
|
|
lines in 2D EDIT MODE when zoomed way in around the upper left
|
|
corner of the map (I think).
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/3/94 - Optimized Editart loading and saving.
|
|
|
|
- Made 'V' screen in Editart 320*400 instead of 320*200.
|
|
|
|
- Before I said I fixed the bug in EDITART where a few pixels in the
|
|
top left corners of tiles sometimes got overwritten. Well I
|
|
lied. This time I really fixed it. (I hope)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/7/94 - Made x&y repeats, x&y pannings easier to adjust. It now works
|
|
like the default keyboard handler. It moves once when you
|
|
first press the key. A little later, it starts to move fast.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/11/94 - Added great new sprite rotation function which works like
|
|
overwritesprite (like 2DRAW sprites)
|
|
|
|
rotatesprite(long sx, long sy, long z, short a, short picnum)
|
|
|
|
(sx, sy) is the center of the sprite to draw defined as
|
|
screen coordinates shifted up by 16.
|
|
(z) is the zoom. Normal size is 65536.
|
|
Ex: 131072 is zoomed in 2X and 32768 is zoomed out 2X.
|
|
(a) is the angle (0 is straight up)
|
|
(picnum) is the tile number
|
|
|
|
Ex: rotatesprite(160L<<16,100L<<16,65536,lockclock<<4,DEMOSIGN);
|
|
This example will draw the DEMOSIGN tile in the center of the
|
|
screen and rotate about once per second.
|
|
|
|
Rotatesprite clips to the same area as overwritesprite but does
|
|
not scale or do transluscence yet.
|
|
|
|
- Please look at the new permanentwritesprite documentation at the
|
|
top of this file!
|
|
|
|
- Network should now work again - It now works great on my network
|
|
with 3 players! It may possibly also work with 4 or 5 players
|
|
too, but I didn't feel like running between 2 rooms to test it!
|
|
I never thought the day would come when I would get NET, COM,
|
|
and MODEM all working respectably!
|
|
|
|
- Changed setup program so you can select 2, 3, 4, or 5 players in
|
|
a network game. (The 5 is just to annoy people who like that
|
|
other lousy game)
|
|
|
|
- ATTENTION BUILDERS! Added TILE MOVING to EDITART! For now, it
|
|
will only work WITHIN THE SAME ART FILE. Do the tile moving
|
|
all in 'V' mode. Here are the new keys in 'V' mode:
|
|
|
|
To swap 2 tiles:
|
|
Simply press space bar on the first tile, then space
|
|
bar on the second.
|
|
To swap a group of tiles:
|
|
Press 1 on the first tile, press 2 to remember the region
|
|
between where you pressed 1 and 2. Press 3 at the
|
|
place to where you want to swap all the tiles.
|
|
|
|
Don't forget that this is all SWAPPING, tiles will (should)
|
|
NOT be overwritten using these keys.
|
|
|
|
- ATTENTION PROGRAMMERS! Added ceildist and flordist parameters to
|
|
both clipmove and movesprite. I always had them all set to
|
|
(4<<8) by default.
|
|
|
|
clipmove(long *x, long *y, long *z, short *sectnum,
|
|
long xvect, long yvect,
|
|
long walldist, long ceildist, long flordist,
|
|
char cliptype)
|
|
|
|
movesprite(short spritenum, long xchange, long ychange, long zchange,
|
|
long walldist, long ceildist, long flordist,
|
|
char cliptype, long numtics)
|
|
|
|
- Moved some com/network code from the getpackets function in game
|
|
into the engine.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/15/94 - Fixed some network initialization code and it now works with 4
|
|
players. (I tested it.)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/16/94 - Added different shirt color support. Here's how you do it:
|
|
|
|
allocatespritepalookup(long palnum, char *remapbuf)
|
|
|
|
See more documentation of allocatespritepalookup at the top of
|
|
this file.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/18/94 - I made it so you can redefine the keys in the setup program under
|
|
the input devices menu.
|
|
|
|
- ATTENTION EVERYONE - for this new version, you MUST go into my
|
|
new SETUP program, and SAVE CHANGES AND QUIT once. The arrow
|
|
key code will not work if you don't do this! If you are
|
|
one of those people who actually read BUILD.TXT, give yourself
|
|
1 point. I wonder who will get "caught" for not reading this!
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/22/94 - Added pixel height and wall length information to 2D EDIT MODE
|
|
when you press Tab or Alt-Tab on a sector or wall.
|
|
|
|
- Now show the actual number of sprites in 2D EDIT MODE.
|
|
|
|
- Improved digitized sound routines. Just thought I'd mention it.
|
|
|
|
- Added a "save As" feature to 2D EDIT MODE.
|
|
|
|
- Now show all lo and hi tags in 2D EDIT MODE on the map itself!
|
|
Note that position of the sector tag's text is put at the
|
|
average point of all the points of the sector, so if you have
|
|
a weird shape tagged sector, the text might show up at an
|
|
inconvenient place.
|
|
|
|
- You can turn the tag boxes on or off by pressing CTRL-T or by
|
|
zooming out.
|
|
|
|
- ATTENTION EVERYONE - for the new BUILD.EXE and OBJ's, you will
|
|
need to copy my new TABLES.DAT over your old one. Also, you
|
|
must go into SETUP and SAVE&QUIT. I have split the TABLES.DAT
|
|
file into 2 separate files. They are:
|
|
|
|
TABLES.DAT - 10880 bytes - sin tables, fonts, etc.
|
|
SETUP.DAT - 23 bytes - (6 options) + (17 custom keys)
|
|
|
|
The SETUP.DAT file is the only file SETUP.EXE accesses now.
|
|
This means that from now on, if I want to add something to
|
|
TABLES.DAT, you won't have to go into the setup program and reset
|
|
the options again.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/24/94 - Relative alignment now fully works with ROTATION! Relative
|
|
alignment will allow ceilings and floors to align with the
|
|
first 2 points of a sector. This will relieve you of
|
|
programming special ceiling and floor panning code for moving
|
|
sectors.
|
|
In 3D EDIT MODE, simply press 'R' on a ceiling / floor to switch
|
|
between relative alignment mode and normal mode. Notice that
|
|
bit 6 of both sector[].ceilingstat and sector[].floorstat are
|
|
relative alignment bits.
|
|
I have an example of relative alignment in nukeland.map in the
|
|
high blue room off the main octagonal room. Also note that my
|
|
subways and dragsectors now use relative alignment for panning.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/25/94 - I added a new parameter to printext256 and printext16. I need
|
|
to document this stuff!
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/27/94 - Made it so you can't shrink sprites so much you can't grab them
|
|
any more in 3D EDIT MODE.
|
|
|
|
- Added (G)oto feature into Build 'V' mode. Simply press G, type
|
|
the tile number and it will go there.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
9/7/94 - Fixed relative alignment bugs I noticed. My subway.map won't
|
|
crash anymore and the relatively aligned ceilings and floors
|
|
should not pan crazily anymore when looking from a far
|
|
distance.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
9/9/94 - ATTENTION PROGRAMMERS: I added a new parameter to
|
|
overwritesprite. Dapalnum can be from 0-15 depending on
|
|
what palette lookup table is being used. Dapalnum is normally
|
|
0. Overwritesprite now looks like this:
|
|
|
|
overwritesprite (long thex, long they, short tilenum,
|
|
signed char shade, char orientation, char dapalnum)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
9/13/94 - ATTENTION PROGRAMMERS: I changed the last parameter of drawrooms
|
|
(sector number) to be passed as a value, NOT a pointer anymore.
|
|
|
|
drawrooms(long daposx, long daposy, long daposz,
|
|
short daang, long dahoriz, short dacursectnum)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
9/15/94 - ATTENTION PROGRAMMERS: I took out the COM(modem)/network code
|
|
from my engine.obj and put it into a separate .obj called
|
|
multi.obj. (I also removed the sound from my engine and stuck
|
|
it in kdmeng.obj) Please include it in your makefile. Here is
|
|
a list of ALL of the variables and functions you will need to
|
|
know to program for multiple players:
|
|
|
|
VARIABLES: (You should extern these in your game.c)
|
|
extern short numplayers, myconnectindex;
|
|
extern short connecthead, connectpoint2[MAXPLAYERS];
|
|
extern long *lastpacket2clock;
|
|
|
|
FUNCTIONS:
|
|
initmultiplayers(option[4],option[5]);
|
|
uninitmultiplayers();
|
|
|
|
sendlogon();
|
|
sendlogoff();
|
|
|
|
sendpacket(connecthead,tempbuf,j);
|
|
sendpacket(-1,tempbuf,j);
|
|
leng = getpacket(&otherconnectindex,tempbuf);
|
|
|
|
Please see detailed descriptions of these functions at the top
|
|
of this file.
|
|
|
|
- Multiplayer code is now MUCH cleaner!
|
|
|
|
- Please try my game on your networks again! My game now works
|
|
perfectly with 3 players on a network that used to crash at
|
|
the DOS4GW prompt just a week ago! My game needs only IPX,
|
|
no server to run.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
9/16/94 - ATTENTION PROGRAMMERS: CONVMAP5!!! YOU MUST RUN CONVMAP5 ON
|
|
ALL OF YOUR MAPS IF YOU WANT THEM TO WORK WITH THE NEW
|
|
BUILD.EXE OR OBJ'S! Following are the exact changes I made
|
|
to the new map format:
|
|
|
|
* Added numextras
|
|
* Added sector[].ceilingpal
|
|
* Added sector[].floorpal
|
|
* Added sector[].visibility
|
|
* Split sector[].tag to sector[].lotag and sector[].hitag
|
|
* Added sector[].extra
|
|
* Expanded wall[].cstat to a short
|
|
* Split wall[].tag to wall[].lotag and wall[].hitag
|
|
* Added wall[].extra
|
|
* Split sprite[].tag to sprite[].lotag and sprite[].hitag
|
|
* Got rid of sprite[].extra (the void * mess)
|
|
* Added sprite[].extra
|
|
|
|
The only thing programmers have to worry about when converting
|
|
are the tags. I split them into lo and hi tags.
|
|
(See BUILD.H for new structure formats)
|
|
|
|
I got rid of the (void *)extra thing from the sprite
|
|
structure. I know I may have made some promises it
|
|
wouldn't change and it was for your use only, but what
|
|
can I say - it's not needed anymore (in other words,
|
|
if you're already using it, TOUGH LUCK). I have my
|
|
own, new, method for extending sector, wall, or
|
|
sprite structures. You will be able to extend any
|
|
structure as much as you want AND be able to edit it
|
|
all in the BUILD editor to be saved in the permanent
|
|
map format. Notice I added a (short)extra to all 3
|
|
main structures. They default to -1. But if they
|
|
are >= 0 then they form a linked list out of the
|
|
extra structure. NOTE: THIS EXTRA STUFF IS NOT
|
|
PROGRAMMED YET! I'm just mentioning it becuase the
|
|
new map format has this extendability. I'll try to
|
|
get it done soon though. (9/21/94) - Actually just
|
|
ignore the fact that this paragraph ever existed.
|
|
I'm just keeping it here for history purposes.
|
|
|
|
- Renamed my allocatespritepalookup function to makepalookup since
|
|
it now also applies to walls, ceilings, floors, p-skies and
|
|
masked walls.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
9/20/94 - Added rotated sprites. These new rotated sprites rotate in the
|
|
same way as masked walls. Sounds like a waste since the
|
|
engine already has masked walls? NOT AT ALL! With rotated
|
|
sprites, you can EASILY do TRUE ornamented walls FULLY inside
|
|
the BUILD editor with even MORE versatility than that other
|
|
game out there. For example, you can place the ornamentation
|
|
anywhere on the wall, with sizing control using 2,4,6,8 on the
|
|
keypad, and even ornament with transluscence! In 3D EDIT
|
|
MODE, simply press 'R' on a sprite to make it a rotated
|
|
sprite (Programmers see bit 4 of sprite[].cstat)
|
|
|
|
- Fixed crashing bug with sector (Rt. ALT) copy/paste in 2D EDIT
|
|
MODE.
|
|
|
|
- You can now copy groups of sectors from 1 map to another! Here's
|
|
how you do it:
|
|
|
|
Step 1: Capture a bunch of sectors with the Rt. ALT selection
|
|
tool.
|
|
Step 2: With the sectors still highlighted, you can now load
|
|
another map and the highlighted sectors will
|
|
automatically be inserted into the new map. (They
|
|
will still be highlighted)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
9/21/94 - Fixed bug with cursectnum not always being right after loading
|
|
the board. I now check it and make sure it's right when
|
|
saving in BUILD now.
|
|
|
|
- Added 'O' key in 2D/3D EDIT MODES. It will push a rotated sprite
|
|
backwards (using hitscan) into the first wall and
|
|
automatically adjust the angle to make the sprite appear
|
|
as if it was part of the wall.
|
|
|
|
- You can now press 'S' to insert a sprite in 3D EDIT MODE. Press
|
|
'S' on a ceiling or floor.
|
|
|
|
- You can now press delete to delete a sprite in 3D EDIT MODE.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
9/22/94 - Programmed Nick & Peter's BUILD stub to their EXACT
|
|
specifications. See WSTUB.C for code & documentation.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
9/27/94 - Fixed Rt. Alt block copying nextsector1 pointer bug.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
9/29/94 - Added special bitmapped effect which I either call lava or
|
|
boiling slime. See my initlava and movelava functions
|
|
inside GAME.C.
|
|
|
|
- I added a bit array call gotpic. The engine will set the
|
|
respective gotpic bit for each picnum drawn to the screen,
|
|
including ceilings, floors, walls, sprites, masked walls -
|
|
even overwritesprites, etc. This array is mainly for
|
|
making the game only calculate special bitmapped effects
|
|
when that certain picnum is on the screen.
|
|
|
|
Note 1: The engine does NOT automatically clear the gotpic
|
|
bits for you. If you want to test gotpic for a certain
|
|
picnum, you should clear it if you want to test it again.
|
|
|
|
Note 2: It is not necessary to use permanentwritesprite
|
|
for bitmapped special effects - after all, if you see it,
|
|
it MUST be in the cache.
|
|
|
|
Added to BUILD.H:
|
|
EXTERN char gotpic[MAXTILES>>3];
|
|
|
|
Example code in GAME.C:
|
|
if ((gotpic[SLIME>>3]&(1<<(SLIME&7))) > 0) //test bit
|
|
{
|
|
gotpic[SLIME>>3] &= ~(1<<(SLIME&7)); //clear bit
|
|
|
|
if (waloff[SLIME] != -1) //if in cache
|
|
movelava((char *)waloff[SLIME]); //calculate!
|
|
}
|
|
|
|
- Added what some people call gamma correction. I think
|
|
brightness is a better description though.
|
|
|
|
setbrightness(char brightness);
|
|
|
|
Simply call this function where brightness ranges from
|
|
0 to 4. Brightness defaults to 0. Levels 1-4 are all brighter
|
|
than 0. If you switch between 2D & 3D modes, the engine will
|
|
remember the current brightness level.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
9/30/94 - Added a few keys to fake a multiplayer game all on 1 computer.
|
|
In my game, press Insert to add a new player at the starting
|
|
position, and Delete to delete the last player. Press
|
|
scroll lock to get control of the other players. In the same
|
|
way Lt. Enter lets you view other players, Scroll lock will
|
|
let you control other players (single player game only)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
10/2/94 - Moved all doanimations code from engine into game.c. If you
|
|
are using the doanimations code, here's exactly what you
|
|
need to do to make it work with your code again:
|
|
|
|
Step 1: Copy these 3 functions which you should find at
|
|
the end of my Game.c:
|
|
|
|
doanimations(long numtics)
|
|
getanimationgoal(long animptr)
|
|
setanimation(long *animptr, long thegoal, long thevel)
|
|
|
|
Step 2: Move these variables out of BUILD.H and into your
|
|
game.c:
|
|
|
|
#define MAXANIMATES 512
|
|
static long *animateptr[MAXANIMATES], animategoal[MAXANIMATES];
|
|
static long animatevel[MAXANIMATES], animatecnt = 0;
|
|
|
|
* If you copied my door code, you will probably have to convert
|
|
some parameters to longs. (oops!)
|
|
|
|
- Got rid of printnum from the engine. It is an outdated function.
|
|
Use either printext256 or printext16 instead.
|
|
|
|
- Added y-flipping for both normal and rotated sprites. (see bit
|
|
3 of sprite[].cstat in BUILD.H.
|
|
|
|
- Added y-flipping for walls. (see bit 8 of wall[].cstat in
|
|
BUILD.H.
|
|
|
|
- Fixed bug with initialization of Master and Slave for
|
|
COM(Modem) only. If both computers went in at the same
|
|
time, it used to sometimes think both were Masters.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
10/4/94 - Alt-C in 3D EDIT MODE changes all picnums on the whole map
|
|
from the picnum in tab to the picnum under the mouse cursor.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
10/6/94 - Fixed y-flipping bug on walls and masked walls.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
10/16/94 - Fixed bug in editart that didn't convert the maps right after
|
|
swapping tiles.
|
|
|
|
- Added excellent function to my multi.obj.
|
|
|
|
long getoutputcirclesize();
|
|
This function returns the number of bytes that have not
|
|
yet been copied. If there are still more than say, 16 bytes,
|
|
then you may be sending too many bytes per second. This can
|
|
happen if the frame rate of a computer is faster than the
|
|
speed of the serial mode (Ex: Try 2400 baud with a Pentium 90!)
|
|
this function will tell you how many bytes are left to copy
|
|
In other words, if getoutputcirclesize() < 16 then it is safe
|
|
to send a packet. If you already have serial mode working
|
|
all you have to do to update your code is to copy the lines
|
|
in my sync() function the deal with the getoutputcirclesize
|
|
function. Everything else in sync() and getpackets() is
|
|
pretty much the same.
|
|
|
|
- Programmed some example code in my game that will allow players
|
|
to change masters and slaves during the game without losing
|
|
sync. Simply press 'M' in my multiplayer game, and that
|
|
computer will become the master! It is interesting how
|
|
the frame rate and controllability changes.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
10/31/94 - Added basic scripting to EDITART. Don't expect it to be
|
|
everything you ever dreamed of (yet).
|
|
|
|
Scripts are saved in a file called CAPFIL.TXT. You can edit the
|
|
text file, but be careful not to screw it up too badly (such
|
|
as extra commas, spaces in weird places, etc.) since I am
|
|
parsing it in EDITART.
|
|
|
|
Whenever you select a box in 'U' mode, a line will be appended to
|
|
the CAPFIL.TXT file.
|
|
|
|
WRITING THE CAPFIL.TXT FILE:
|
|
In 'U' mode, you can press 'O' instead of ENTER to select a tile.
|
|
What 'O' does that is different from ENTER is that it takes
|
|
the center point of the highlighted rectangle, and searches
|
|
outward until a total rectangle of transparent pixels (255)
|
|
is reached. This is useful for grabbing sprites - not only
|
|
will you not have fine adjust to the exact borders of a
|
|
sprite now, but when you re-grab from the pcx's you can
|
|
change the size of the sprite freely.
|
|
|
|
READING THE CAPFIL.TXT FILE:
|
|
There are 2 ways to re-grab from the CAPFIL.TXT file. If you
|
|
press ALT-U in the main screen, everything will be re-grabbed.
|
|
If you press ALT-U in 'V' mode, then you should first select
|
|
the range by pressing '1' and '2' on the range boundaries.
|
|
|
|
Format of CAPFIL.TXT lines:
|
|
Tile #, Full path/file name, x1, y1, xsize, ysize
|
|
|
|
Note: If xsize and ysize are 0, then that means you did
|
|
an 'O' grab and EDITART will search from point (x1, y1)
|
|
when you do a re-grab.
|
|
|
|
Example CAPFIL.TXT file:
|
|
31,D:\CAPTUR00.PCX,220,98,64,64
|
|
110,D:\CAPTUR00.PCX,49,72,0,0
|
|
|
|
The first line says that tile #31 is a 64*64 tile and the
|
|
second line says that tile #110 is unknown size tile (grabbed
|
|
with the 'O' key)
|
|
|
|
Note: You can only do 1 grab per tile with my scripting system.
|
|
You may have done your parallaxing skies with several grabs.
|
|
If so then try to make the tile into 1 large PCX and do 1
|
|
grab. (The largest grabbing size right now is 1024*256)
|
|
|
|
-------------------------------------------------------------------
|
|
|
|
- Made Editart's screen capture (F12) save to PCX's the exact size
|
|
of the tile and not include the status bar at the bottom. It
|
|
will also save large tiles to large PCX's - Now it's easy and
|
|
lossless to extract a tile from Editart!
|
|
|
|
- ATTENTION PROGRAMMES! Added 2 new parameters to getzrange for
|
|
returning the objects hit on top and bottom.
|
|
(sectors / sprites) See my updated documentation at the top
|
|
of this file.
|
|
|
|
- Fixed clipping bugs with sprites near sector lines. (I hope)
|
|
|
|
- Got 3D Red-Blue glasses mode working for all VGA cards. First
|
|
set the graphics mode to red-blue mode in the setup program.
|
|
The left eye is red and the right eye is blue. There are
|
|
4 keys that let you adjust the 3D view:
|
|
[,] = Adjust width between eyes (3D width)
|
|
Shift [,] = Adjust width of parallax (2D width)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
11/1/94 - Guess what? I turned 19 today. Doesn't that just suck. Now,
|
|
if you play my build game on my birthday, all the extemely
|
|
evil and scary brown monsters will be replaced with super
|
|
happy fun dogs that throw smiley red jelly coconuts at you.
|
|
Also, my incredibly evil and scary music will be replaced
|
|
with super happy music. Actually this whole paragraph is
|
|
a joke (except for the birthday part).
|
|
|
|
- Made centering work with rotated sprites.
|
|
|
|
- Fix centering with x and y flipped sprites.
|
|
|
|
- Rotated sprites now get chopped off by the ceiling or floor in
|
|
the same way normal sprites get chopped. Sprites do not get
|
|
chopped if there is a parallaxing sky / floor.
|
|
|
|
- Made Shift + F12 is BUILD 2D mode inverse black and white.
|
|
|
|
- If SETUP.DAT is not found then default options are loaded
|
|
instead of quitting to DOS.
|
|
|
|
- ATTENTION PROGRAMMERS! Added 3 parameters to makepalookup that
|
|
allow you to do FOG effects. The first 2 parameters are the
|
|
same as before. The last 3 are the color that the palette
|
|
fades to as you get further away. Before, this color was
|
|
always black (0,0,0). White would be (63,63,63).
|
|
|
|
makepalookup(long palnum, char *remapbuf,
|
|
char redvalue, char greenvalue, char bluevalue)
|
|
|
|
- ATTENTION PROGRAMMERS! Moved 2 things into BUILD.H. Please
|
|
make sure to update it:
|
|
|
|
#define MAXPALOOKUPS 256
|
|
and
|
|
EXTERN char *palookup[MAXPALOOKUPS];
|
|
|
|
The palookup array is an array of pointers that point to the
|
|
first byte of each 8K palette lookup table. All 256 pointers
|
|
are initialized to NULL by initengine() except for palookup[0]
|
|
which is the default 8K palette. This will allow you to modify
|
|
the palette lookup table directly for non-snowy fading effects,
|
|
etc. Each palette lookup table has 32 shades. Each shade has
|
|
256 bytes. Shade 0 is closest (actual palette brightness) and
|
|
shade 31 is farthest (dark usually). (256*32 = 8192 or 8K)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
11/3/94 - Now show white lines in 'V' mode of EDITART at ART file tile
|
|
boundaries.
|
|
|
|
- Added Insert and Delete commands to EDITART! These Insert and
|
|
Delete keys WILL shift all tiles after the one being inserted
|
|
or deleted just like a regular text editor. To insert or
|
|
delete tiles, simply go the 'V' screen in EDITART and bang
|
|
away! Don't worry these keys are fully multi-tile file
|
|
compatible (unlike swapping right now).
|
|
You will notice that the white line boundaries that
|
|
I just added will actually move if you press Insert or Delete.
|
|
This changes the number of tiles per art file. But that's
|
|
ok. If the art files ever get too unbalanced, you can run
|
|
the RSIZEART.EXE utility to fix it.
|
|
Ken's lesson of the day: For the final release of your
|
|
games, you only need 1 art file. The reason I spent my time
|
|
programming multiple art files was because of EDITART.
|
|
Since EDITART need to READ & WRITE to the art files, it must
|
|
hold a whole art file in memory at a time. Since Build and
|
|
Game only READ the art files, a caching system can be made
|
|
and only 1 art file is necessary even for lo-memory systems.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
11/4/94 - ATTENTION MAP DESIGNERS! Added a long-awaited feature to BUILD
|
|
which I call "loop joining". Have you ever gotten this
|
|
frustrating message in 2D EDIT MODE before?
|
|
|
|
"You can't split sector by connecting different loops."
|
|
|
|
Well, you're not going to see it any more because I fixed
|
|
it! Yup. You can now split a sector along a line connecting
|
|
different loops of the sector.
|
|
|
|
Try this - Convert the sector on the left to the sector
|
|
on the right:
|
|
|
|
Split #1 Split #2
|
|
ÚÄÄÄÄÄÄÄ¿ ÚÄÄÄÂÄÄÄ¿ ÚÄÄÄÂÄÄÄ¿
|
|
³ ÚÄÄÄ¿ ³ ³ ÚÄÁÄ¿ ³ ³ ÚÄÁÄ¿ ³
|
|
³ ³ ³ ³ ³ ³ ³ ³ ³ ³ ³ ³
|
|
³ ÀÄÄÄÙ ³ ³ ÀÄÄÄÙ ³ ³ ÀÄÂÄÙ ³
|
|
ÀÄÄÄÄÄÄÄÙ ÀÄÄÄÄÄÄÄÙ ÀÄÄÄÁÄÄÄÙ
|
|
(Given) (Half done) (Result)
|
|
(1 sector) (Still 1 sector) (2 sectors)
|
|
|
|
Before the only was to do this was to delete all the
|
|
sectors and then redraw them again.
|
|
|
|
I'm sure loop joining has its share of tricks, as most
|
|
BUILD functions do, so you may want to spend some time just
|
|
playing around with this new function.
|
|
|
|
- Removed my own profiler stuff - Hline calculations, etc. code.
|
|
Watcom's sampler and profiler is much better anyway.
|
|
|
|
- Fixed neartag divide by zero bug with walls (I hope).
|
|
Anyone calling neartag for every player per movethings?
|
|
I would try not to - How much is that unnoticable extra 0.02
|
|
frames per second worth to you anyway?
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
11/9/94 - Added new array to BUILD.H called gotsector. It works a lot
|
|
like the gotpic array, but this array determines which sectors
|
|
were considered during the drawrooms function. Note that
|
|
gotsector, unlike gotpic IS cleared to 0 during every call
|
|
to drawrooms.
|
|
|
|
- Fixed Editart 'U' mode mouse control bug. I typed too fast this
|
|
time.
|
|
|
|
- Fixed Build split sector bug of accidently deleting sprites. It
|
|
should not delete any sprites when splitting sectors now.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
11/15/94 - ATTENTION PROGRAMMERS!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
I moved ALL my timer code and arrow key code into GAME.C.
|
|
Here are the exact instructions that you need to follow to
|
|
upgrade your code to the new obj's:
|
|
|
|
1. From the end of my GAME.C, take the code from these 4
|
|
functions:
|
|
|
|
---> inittimer();
|
|
---> uninittimer();
|
|
---> void __interrupt __far timerhandler();
|
|
---> keytimerstuff();
|
|
|
|
2. After each initengine, call inittimer right AFTER:
|
|
|
|
initengine();
|
|
---> inittimer();
|
|
|
|
After each uninitengine, call uninittimer right BEFORE:
|
|
|
|
---> uninittimer();
|
|
uninitengine();
|
|
|
|
3. You may need to include this (if not already included):
|
|
|
|
---> #include <dos.h>
|
|
|
|
4. Add these 2 lines to declare the timerhandler:
|
|
|
|
---> void (__interrupt __far *oldtimerhandler)();
|
|
---> void __interrupt __far timerhandler(void);
|
|
|
|
5. Since BUILD.H NO LONGER has vel, svel, and angvel, you
|
|
must add the following line to your game:
|
|
(These variables are modified inside keytimerstuff())
|
|
|
|
---> static long vel, svel, angvel;
|
|
|
|
6. Let me list some variables that I recently removed from my
|
|
GAME. This may or may not affect you:
|
|
|
|
oposx[], oposy[], oang[], etc.. - GONE!
|
|
lastpacket2clock - GONE!
|
|
lastsynctics - GONE!
|
|
drawscreen's smoothratio parameter & related code - GONE!
|
|
kenchaintimer - GONE! (Don't think anybody was using it
|
|
because it didn't solve sound compatibility problems)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
11/16/94 - Made swinging door clipping work MUCH better! It is much more
|
|
difficult to "sneak" through the door now. With the swinging
|
|
door clipping working much better, I made it possible to open
|
|
doors even if you are in the same sector as the door itself.
|
|
Now you won't have to stand back a certain distance to open
|
|
the doors. (It is much less annoying this way) Since neartag
|
|
does not normally scan cursectnum's sector tags, you will
|
|
need to check cursectnum's tags yourself (if you so desire)
|
|
|
|
Example: (extracted from my GAME.C)
|
|
|
|
neartag(posx[snum],posy[snum],posz[snum],cursectnum[snum],
|
|
ang[snum],&neartagsector,&neartagwall,&neartagsprite,
|
|
&neartaghitdist,1024L);
|
|
if (neartagsector == -1) //If no neartagsector found...
|
|
{
|
|
i = cursectnum[snum]; //Test current sector for tagging
|
|
if ((sector[i].lotag|sector[i].hitag) != 0)
|
|
neartagsector = i; //Cursectnum is the neartagsector!
|
|
}
|
|
|
|
- Improved my gamma correction algorithm. Since it now uses a new
|
|
1K at the end of my TABLES.DAT, be sure to update all your
|
|
TABLES.DAT files! My new gamma correction supports 16 levels
|
|
of brightness (0-15). You need not change any code in your
|
|
game if you already have gamma correction programmed.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
11/17/94 - Made swinging door clipping code work even better. The bug was:
|
|
it only tested the clipping if you were in the same sector as
|
|
the door. So I put this handy little function in GAME.C which
|
|
simply tests if 2 sectors are neighbors or not:
|
|
testneighborsectors(short sect1, short sect2)
|
|
Check it out!
|
|
|
|
- Rewrote my clipinsidebox function. You probably don't use this
|
|
function, but if you copied my swinging door code, then you
|
|
will need to update this. Clipinsidebox is used for clipping
|
|
to determine whether a player or sprite is too close to a
|
|
wall.
|
|
|
|
clipinsidebox(long x, long y, short wallnum, long walldist)
|
|
X and y are the position of the sprite or player. Wallnum
|
|
is the wall to test, and walldist is the fatness of the sprite
|
|
or player (same as clipmove). It returns a 1 if the sprite or
|
|
player's clipping square intersects the wall or 0 if not.
|
|
|
|
Example - You can test all 4 walls of a swinging door and make
|
|
sure the door doesn't run you over:
|
|
|
|
short swingwall[4]; //4 wall indeces of a swinging door
|
|
for (i=0;i<4;i++)
|
|
if (clipinsidebox(posx,posy,swingwall[i],128L) == 1)
|
|
{
|
|
//Swinging door swung into player, so move door back to
|
|
//its old position / inverse swinging direction.
|
|
|
|
break;
|
|
}
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
11/22/94 - Made build posx, posy, posz, ang, cursectnum, and horiz variables
|
|
nonstatic.
|
|
|
|
- Made hi-res screen capture work.
|
|
|
|
- Fixed some of those evil view-clipping bugs with rotated sprites
|
|
on red sector lines. I think it should work with rotated
|
|
sprites on horizontal or vertical red lines. I'm not sure
|
|
about weird angled lines.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
11/23/94 - ATTENTION PROGRAMMERS: Made parallaxing skies tileable in any
|
|
equal size chunk where the chunk x size is a power of 2
|
|
from 16-1024. You can now make a 2048 wide parallaxing sky
|
|
with 2 chunks of 1024 (gobble gobble).
|
|
|
|
These lines were added to BUILD.H:
|
|
|
|
#define MAXPSKYTILES 256
|
|
EXTERN short pskyoff[MAXPSKYTILES], pskybits;
|
|
|
|
pskyoff[MAXPSKYTILES] is an array of OFFSETS of each tile
|
|
from the picnum of the parallaxing sky.
|
|
|
|
pskybits is NOT the actual number of tiles, but the
|
|
log (base 2) of the number of tiles. Look at this table:
|
|
|
|
For 1 tile, pskybits = 0
|
|
For 2 tiles, pskybits = 1
|
|
For 4 tiles, pskybits = 2
|
|
For 8 tiles, pskybits = 3
|
|
For 16 tiles, pskybits = 4
|
|
etc.
|
|
|
|
|
|
I know that most teams have a 1024 wide parallaxing sky that
|
|
wraps all the way around. Don't worry - this is the
|
|
default now. When initengine is called, the variables
|
|
default to this:
|
|
|
|
pskyoff[0] = 0;
|
|
pskybits = 0;
|
|
|
|
You may have used a 512 wide parallaxing sky (like in my game)
|
|
that repeated every 180 degrees. To make this work with
|
|
the new version, set these variables like this right after
|
|
initengine is called:
|
|
|
|
pskyoff[0] = 0;
|
|
pskyoff[1] = 0;
|
|
pskybits = 1;
|
|
|
|
Note that both pskyoff variables are 0 here. This will
|
|
make the parallaxing sky repeat.
|
|
|
|
With the new tiling, you can save memory by making small
|
|
chuck sizes, such as 64 or 128, and repeating certain
|
|
sections.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
11/25/94 - Fixed some really stupid keyboard problem in Build.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
11/29/94 - Added FLOOR SPRITES!!! Here are some things that floor sprites
|
|
can do for you:
|
|
|
|
* Make bridges and balconies
|
|
* Use them for ceiling and floor ornamentation
|
|
* Use them in place of a rotating sector - modifying 1 angle
|
|
is much faster than rotating tons of points.
|
|
* Weapon such as a spinning saw blade or, of course, a smiley
|
|
red jelly coconut. (?)
|
|
* How about a "walking" hole like in Ken's Labyrinth
|
|
* You could throw a footstep on the floor every time you make a
|
|
step. The steps would go away after awhile. Maybe if you
|
|
step in mud, the next 16 or so footsteps will be plotted.
|
|
* You could even fake radial shading with a transluscent floor
|
|
sprite. (Transluscent floor sprites not yet programmed)
|
|
|
|
Just imagine all the great stuff you can do with floor
|
|
sprites combined with wall sprites! I can't wait to see what
|
|
you all come up with!
|
|
|
|
ÚÄÄ To clear some confusion, and to shorten conversations, let
|
|
³ me give official names to my 3 kinds of sprites:
|
|
³
|
|
³ Normal stupid sprites - "FACE SPRITES"
|
|
³ Rotated / masked wall sprites - "WALL SPRITES"
|
|
³ New ceiling & floor sprites - "FLOOR SPRITES"
|
|
³
|
|
³ Also let me clear up the 2 kinds of clipping:
|
|
³
|
|
³ Clipping when moving something - "MOVEMENT CLIPPING"
|
|
ÀÄÄ Clipping when drawing something - "VIEW CLIPPING"
|
|
|
|
To make a floor sprite in BUILD, simply press 'R' on any
|
|
sprite until it becomes a floor sprite. The xrepeat and
|
|
yrepeat values should work perfectly with floor sprites.
|
|
Floor sprites can be rotated at any of 2048 degrees, using
|
|
the sprite[].ang. Press < / > for course angle adjustment
|
|
or < / > with shift for fine angle adjustment. Also, you
|
|
can press 'F' on a floor sprite to flip it over like a
|
|
mirror. I am using another bit in sprite[].cstat to determine
|
|
the type of sprite. See the documentation in BUILD.H.
|
|
|
|
Now for the bad news:
|
|
|
|
* Floor sprite textures have similar restrictions as normal
|
|
ceilings and floors - both dimensions must be a power of 2.
|
|
This will most likely not change.
|
|
|
|
And some known problems which I will have to fix:
|
|
* Transluscence doesn't work yet
|
|
* Sorting with other sprites
|
|
* View clipping with walls
|
|
* Doesn't work too well in hi-res mode
|
|
|
|
See NUKELAND.MAP for some examples of floor sprites. I have both
|
|
a bridge and a balcony on the level. Please find them!
|
|
Remember that floor sprites don't work in mode x or hi-res
|
|
mode YET!
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
11/30/94 - Made WALL SPRITE and FLOOR SPRITE correctly do movement clipping.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
12/1/94 - Made new map called BRIDGES.MAP. It is excellent! It has 3
|
|
bridges all crossing each other. Enjoy!
|
|
|
|
- For Editart, I added re-centering after delete and / to reset
|
|
centering while in centering mode.
|
|
|
|
- Debugged more of the floor sprite stuff.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
12/2/94 - Made transluscence with floor sprites work. Check out my fake
|
|
radial shading under the lights of SUBWAY.MAP.
|
|
|
|
- Optimized floor sprites in assembler. Transluscent floor sprites
|
|
are a bit slower than normal floor sprites.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
12/6/94 - Made a special 1-way mode for WALL and FLOOR sprites
|
|
(not FACE sprites). In BUILD 3D mode, you can press '1' on
|
|
a wall or floor sprite to make it only draw if you are on
|
|
1 side of it. This method of back-face culling will not only
|
|
make non-masking objects with thickness draw twice as fast,
|
|
but will also make fewer drawing bugs due to sprite drawing
|
|
order. Try out my BRIDGES.MAP. There's a new section at the
|
|
top and it's not another "ugly Ken's face n' slime" room.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
12/8/94 - Editart and Build now capture with capt#### rather than captur##
|
|
allowing 10000 captured pictures.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
12/23/94 - Increased Maximum number of walls to 8192.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
12/28/94 - Made BUILD stub keys F5-F8 work in 3D mode also. See top
|
|
of BSTUB.C for full documentation of some new useful
|
|
variables that can be used inside the stub:
|
|
|
|
extern long qsetmode;
|
|
extern short searchsector, searchwall, searchstat;
|
|
|
|
In 3D mode, F5 and F6 do the exact same thing and F7 and F8
|
|
do the exact same thing (you don't need the extra key to
|
|
distinguish between sectors, walls and sprites, since the
|
|
mouse cursor can only be on 1 of the 3 objects in 3D mode.
|
|
|
|
Note: Since F5-F8 are called in 3D mode, you must be sure
|
|
NOT to use any 2D routines during those calls! This means
|
|
you will have to put the 3D/2D case check in all six
|
|
subroutines:
|
|
ExtShowSectorData, ExtShowWallData, ExtShowSpriteData,
|
|
ExtEditSectorData, ExtEditWallData, ExtEditSpriteData
|
|
|
|
- KEN'S PROPOSAL (NOT YET DONE) I am thinking of making a new
|
|
(and maybe final) map format. But before I do it, I am going
|
|
to ask all of you for any suggestions on new fields to add to
|
|
my 3 big structures (sector, wall, sprite):
|
|
|
|
Here are a few things already on my list to add:
|
|
|
|
* char sprite[].clipdist - THIS IS FOR SURE
|
|
This will be a sprite's clipping distance. My default
|
|
walldist is 128. With this field, you will finally be
|
|
able to make a unique fatness for each sprite with no
|
|
clipping bugs. I will probably shift this field up 2-4
|
|
bits to give it a range of more than just 0-255.
|
|
|
|
* char wall[].pal, sprite[].pal - PRETTY SURE
|
|
It should have been this way the whole time. Currently
|
|
the wall's palookup number is sector[].floorpal. While
|
|
it may save some memory, It has too many limitations.
|
|
I can make my map converter automatically convert all
|
|
walls of a sector to equal the sector[].floorpal so
|
|
don't worry about that type of conversion. If I do
|
|
this, I can get rid of the spritepal[] hack.
|
|
|
|
* I have decided that the sector[].extra, wall[].extra, and
|
|
sprite[].extra will remain in the structures as little
|
|
gifts for your use only. That's right! ALL YOURS!
|
|
ENJOY!!!
|
|
|
|
* char sprite[].xoffset, sprite[].yoffset - NOT SURE YET
|
|
Some have asked for monster animations using the same
|
|
frame at 2 different times of an animation sequence having
|
|
different centers.
|
|
These will be signed chars. I'm not sure whether to
|
|
make these offsets as offsets to the centering information
|
|
from Editart or just make them the absolute offsets where
|
|
Editart's data is the default offset. I wonder if there's
|
|
a better way to do this without having to waste 8K.
|
|
|
|
* Do I have your permission to remove nextsector2 and
|
|
nextwall2? Anybody using them? If so, can you use the
|
|
extra variable instead? This will save 16K since both
|
|
are shorts. (MAXWALLS*short + MAXWALLS*short = 16384)
|
|
They were originally intended for 2 stories
|
|
but it would be totally ridiculous for me even to think
|
|
about programming that now. Besides, you can use wall
|
|
and floor sprites to fake 2 story areas. KEN PROMISE:
|
|
I will fix those darn view-clipping bugs eventually!
|
|
|
|
|
|
Please send any comments/suggestions to my internet address
|
|
(kjs@lems.brown.edu) I will consider each suggestion
|
|
carefully, because everything you suggest now won't have
|
|
to be an ugly hack like spritepal[] later.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
1/1/95 - ÛÛÛÛÛ ÛÛÛÛÛÛ ÛÛÜ ÛÛ ÛÛ ÛÛ ÛÛ ÛÛ ÛÛÛÛÛÛ ÛÛÛÛÛÛ ÛÛÛÛÛÛ ÛÛ
|
|
ÛÛ ÛÛ ÛÛ ÛÛÛÜ ÛÛ ÛÛ ÛÛ ÛÛÛÜÜÛÛÛ ÛÛ ÛÛ ÛÛ ÛÛ ÛÛ ÛÛ
|
|
ÛÛ ÛÛ ÛÛ ÛÛÛÛÛÛÛ ÛÛÜ ÜÛÛ ÛÛßÛÛßÛÛ ÛÛÛÛÛÛ ÛÛÛÛÛÛ ÛÛÛÛÛÛ ÛÛ
|
|
ÛÛ ÛÛ ÛÛ ÛÛ ßÛÛÛ ÛÛÛÛÛ ÛÛ ÛÛ ÛÛ ÛÛ ÛÛ ÛÛ ÛÛ
|
|
ÛÛÛÛÛ ÛÛÛÛÛÛ ÛÛ ßÛÛ ßÛß ÛÛ ÛÛ ÛÛ ÛÛ ÛÛ ÛÛÛÛÛÛ ÛÛ
|
|
|
|
CONVMAP6! Here is what I changed in the structures:
|
|
|
|
* Added wall[].pal, sprite[].pal
|
|
* Added sprite[].clipdist
|
|
* Expanded sprite[].cstat to a short
|
|
* Added sprite[].xoffset, sprite[].yoffset
|
|
* Removed wall[].nextsector2, wall[].nextwall2
|
|
* Renamed wall[].nextsector1 to just wall[].nextsector
|
|
* Renamed wall[].nextwall1 to just wall[].nextwall
|
|
* Scrapped numextras and extratype structure - Don't confuse
|
|
this with sector[].extra, wall[].extra, sprite[].extra
|
|
which ARE in map version 6.
|
|
|
|
Probably the only change above that will affect programmers is
|
|
getting rid of the '1' in wall[].nextsector1&wall[].nextwall1.
|
|
All the following changes were possible because of the new
|
|
map format.
|
|
|
|
- Got rid of the spritepal array in BUILD.H. With my grea
|
|
new map version 6, you can simply modify sprite[].pal!
|
|
|
|
- Made all .pal fields editable in 3D EDIT MODE. Press ALT-P
|
|
and simply edit the number as you would in 2D mode.
|
|
|
|
- Made sprite[].xoffset and sprite[].yoffset work as
|
|
offsets to the offsets that are already in EDITART.
|
|
Simple addition. They should work for all 3 types
|
|
of sprites.
|
|
|
|
- Made BUILD Tab&Enter also copy tags&extra if copying similar
|
|
structures. Also fixed some other attributes when
|
|
copying between structure types.
|
|
|
|
- Made sprites highlighted with Rt. Shift duplicate and stamp
|
|
when the insert key is pressed in 2D EDIT MODE.
|
|
|
|
- Made sprite[].clipdist work as the FACE SPRITE'S clipping
|
|
fatness. NOTE: Sprite[].clipdist is shifted up 2 to
|
|
allow a range from 0-1020, so if the sprite[].clipdist
|
|
is set to 32, then the clipping radius is actually 128.
|
|
|
|
- Removed the walldist parameter from movesprite. Movesprite
|
|
now just uses the sprite[spritenum].clipdist field of
|
|
whatever sprite is passed (shifted up 2).
|
|
|
|
movesprite(short spritenum, long xchange, long ychange,
|
|
long zchange, long ceildist, long flordist,
|
|
char cliptype, long numtics)
|
|
|
|
If you use clipmove or getzrange, you should check that you
|
|
are passing the correct walldist parameters. I'm saying
|
|
you may want to change some of the 128s to
|
|
(sprite[spritenum].clipdist<<2).
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
1/3/95 - Made startumost[], startdmost[] into shorts.
|
|
|
|
- Optimized and fixed gamma correction in Stereo Red-Blue mode.
|
|
|
|
- Made weapons or anything using overwritesprite in Stereo Red-Blue
|
|
mode be at screen depth.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
1/4/95 - Not that anybody would care (except for some crazed mega-hackers)
|
|
but I am just mentioning the fact that I did this:
|
|
|
|
animateoffs(short tilenum, short fakevar);
|
|
where fakevar is sectnum+0
|
|
or wallnum+16384
|
|
or spritenum+32768
|
|
or 49152 (just ignore-it's for rotatesprite)
|
|
|
|
Also: I changed one: "mov al, 0" instruction into an
|
|
"xor al, al", a net savings of
|
|
ONE LOUSY BYTE! Let's not get TOO
|
|
excited! (By the way, just kidding)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
1/5/95 - Fixed the sprite centering with x-flipped FACE SPRITES.
|
|
|
|
- Found a bug with my swinging door clipping code. There are 2
|
|
types of swinging doors, forwards (opens CCW) and
|
|
backwards (opens CW). The bug was that you could sneak
|
|
through a backwards door from the back side. Well, I fixed
|
|
it, so now I challenge you to sneak through my swinging doors
|
|
now! If you are using my swinging door code, please make
|
|
these changes which you should find in my new GAME.C:
|
|
|
|
1. Changed declaration at beginning of GAME.C:
|
|
static short swingwall[32][5];
|
|
|
|
2. Added new line in prepareboard:
|
|
swingwall[swingcnt][4] = lastwall(swingwall[swingcnt][3]);
|
|
|
|
3. Modified some stuff in tagcode:
|
|
//swingangopendir is -1 if forwards, 1 is backwards
|
|
l = (swingangopendir[i] > 0);
|
|
for(k=l+3;k>=l;k--)
|
|
if...
|
|
|
|
- Here are some more functions that have been in the engine for
|
|
a while, but I forgot to document...
|
|
precache, loadtile, lastwall, rotatepoint
|
|
They are now documented at the top of this file.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
1/6/95 - Optimized loading/saving of maps by using fewer read/write calls.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
1/14/95 - Fixed evil crashing bug that I accidently introduced in the
|
|
1/3/95 version of Build. This crashing bug happened mostly
|
|
in tall rooms with lots of FACE SPRITES. It used to crash
|
|
very infrequently when you were standing almost exactly, but
|
|
NOT on the same x & y coordinates of a FACE SPRITE where the
|
|
z-distance was high.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
1/15/95 - Fixed up network code so now you can miss 4 packets in row safely
|
|
over the network rather than just 2.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
1/16/95 - Added strafe left / strafe right keys to my SETUP.DAT file and
|
|
char keys[19] array. If you actually use my keys array for
|
|
custom keys, here's what to do: I inserted the new strafing
|
|
keys at keys[12] & keys[13], so just add 2 to any keys with
|
|
an index >= 12.
|
|
|
|
- Made the sprites in 2D EDIT MODE of Build highlight properly
|
|
again.
|
|
|
|
- Added another parameter to permanentwritesprite, palookup number:
|
|
|
|
permanentwritesprite(long thex, long they, short tilenum,
|
|
signed char shade, long cx1, long cy1,
|
|
long cx2, long cy2, char dapalnum);
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
1/17/95 - You can now select a bunch of sprites in 2D EDIT MODE with
|
|
Rt. shift, then go to 3D mode and change the z's of all the
|
|
highlighted sprites.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
1/20/95 - Made Tab&Enter in 3D EDIT MODE copy .pal also whenever .shade is
|
|
normally copied. Shift+Enter will now copy just
|
|
.pal and .shade.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
1/21/95 - Made Splitsector work with overlapping better.
|
|
|
|
- In Editart 'U' mode, it now goes automatically to the PCX and
|
|
coordinates of a tile if it is already in capfil.txt.
|
|
|
|
- In Editart, made capt????.PCX not get overwritten if they already
|
|
exist.
|
|
|
|
- Fixed Build tab on masked walls.
|
|
|
|
- Made zmode and kensplayerheight variables public in BUILD/BSTUB
|
|
so you can now compile BUILD to start out with your own
|
|
preferred settings. Kensplayerheight defaults to 32 and
|
|
zmode defaults to 0. You can over-ride these settings in
|
|
the new ExtInit function.
|
|
|
|
- Made Editart tiles much easier to center by showing all tiles
|
|
in the center of the screen instead of at the top-left corner.
|
|
(Editart will not allow you to center tiles larger than
|
|
320*200 right now)
|
|
|
|
- Made 'O' (optimize) key in Editart automatically preserve
|
|
the centering information.
|
|
|
|
- ATTENTION BSTUB PROGRAMMERS! Added ExtInit, ExtUnInit, and
|
|
ExtCheckKeys to BSTUB.C. Please just copy mine into your
|
|
current BSTUB. ExtInit and ExtUnInit are called only once.
|
|
ExtInit is called before loadpics() and after initengine().
|
|
ExtCheckKeys() is called just before nextpage in both 2D
|
|
and 3D modes. In 3D mode, you must call editinput inside
|
|
ExtCheckKeys just like my example in BSTUB.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
1/24/95 - Fixed vertical line chained mode bug with permanentwritesprites.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
1/31/95 - Fixed parallaxing sky tiling bug.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
2/1/95 - Fixed network crashing bug when call interrupt 0x1c. You call
|
|
this interrupt when you chain to the old timer handler. Now
|
|
|
|
- Rewrote multiplayer code in game.c a bit. Moved both sync()
|
|
and getpackets() into the main program. The master code and
|
|
single player game code are now the same. Slaves need to
|
|
drawscreen and send packets only when a packet is received
|
|
from the master. Got rid of fake sync[MAXPLAYERS] slot by
|
|
using a local sync buffers. Rewrote checkmasterslaveswitch().
|
|
If you don't get what I did, it doesn't matter because you
|
|
already have working network code!
|
|
|
|
- Added new key in EDITART 'V' mode. Press ALT-R to generate
|
|
a tile frequency report. It will scan all MAP files in the
|
|
same directory as the ART files. The frequency count will
|
|
show up as text in the top-left corner of the boxes in
|
|
'V' mode. Press ALT-R again to turn off text.
|
|
|
|
- Perfected NCOPY! Copies about 150K / second which is 10 times
|
|
faster than a 115200bps serial cable. Since NCOPY already
|
|
links with multi.obj, it should not be too difficult to make
|
|
joining work in the middle of a network game. Please wait
|
|
until I make some sample code for you!
|
|
Receiver types: NCOPY (Ex: "NCOPY")
|
|
Sender types: NCOPY [filespec] (Ex: "NCOPY *.ART")
|
|
|
|
Ken's formula:
|
|
NCOPY + Loading&Saving GAMES = joining in middle
|
|
of network game!
|
|
|
|
- Made a DOOM to BUILD converter. Right now it only converts
|
|
ceilings, floors, and walls now, and some of the wall
|
|
textures are screwed up. Just because I converted some
|
|
lousy stinkin' maps DOES NOT MEAN I AM GOING TO PROGRAM DOOM!
|
|
Unfortunately, the converter is programmed in QuickBasic right
|
|
now, it won't compile, and I didn't feel like putting up the
|
|
7 MEG converted ART file up. When I convert it to C, I'll
|
|
upload it for all!
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
2/7/95 - Fixed overwritesprite bugs with translucence in chained mode
|
|
and above top of screen.
|
|
|
|
- Made bit 3 of overwritesprite x-flip the picture if set.
|
|
|
|
- Optimized various parts of engine.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
2/8/95 - Fixed shading of all sprite types so they match perfectly with
|
|
their surroundings. Floor sprites now shade in the exact same
|
|
way as ceilings and floors. (Before, the whole floor sprite
|
|
had the same shade throughout)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
2/9/95 - Started on loading and saving game code so I could give some
|
|
sample code for joining network games, but none of it works
|
|
yet, so just ignore it for now!
|
|
|
|
- Added frame rate in BSTUB.C. It averages the last 16 frames.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
2/16/95 - Added another bit to sprite[].cstat for y-centering control. If
|
|
bit 7 is set then the sprite's center will be the actual
|
|
center rather then at the default position which is at the
|
|
bottom of the sprite. If you use this centering bit,
|
|
you finally get "WYSIWYG" centering contol in EDITART.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
2/24/95 - Made floor sprites now support any x size by a power of 2 y size.
|
|
(That's better than before!) These are the same restrictions
|
|
on walls.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
2/25/95 - Got loading / saving code to work with my game. Press Ctrl-L to
|
|
load game and Ctrl-S to save game. Saved games are called
|
|
SAVE0000.GAME and are about 300K. Don't worry about the large
|
|
sizes of the saved game files since they can be easily
|
|
compressed to less than 50K.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
2/26/95 - I Finally made my multiplayer code run with fast frame rates AND
|
|
pefect controls on ALL computers of a multiplayer game. I am
|
|
now sending keystrokes of all computers at a constant rate of
|
|
40 times per second. All computers interpolate between frames
|
|
to get screen frame rates of higher or lower than 40 fps
|
|
(even in single player mode).
|
|
|
|
Here are the exact steps you will need to follow if you want to
|
|
update your code:
|
|
|
|
1. WHAT'S THE FAKETIMERHANDLER()?
|
|
|
|
To send packets exactly 40 times a second, it would
|
|
sure be nice to send them right from the timer interrupt
|
|
handler. Too bad network packets just won't get sent
|
|
from the interrupt handler. (It may work from the
|
|
interrupt handler in Serial/Modem mode) So the solution
|
|
is to make a "fake" timer handler that must be called
|
|
at least 40 times a second even on the slowest computer.
|
|
Throughout my engine, I call faketimerhandler(). If you
|
|
have any slow parts in your game code, you may want to
|
|
called faketimerhandler() also.
|
|
Besides the very first few lines, the rest of the code
|
|
was taken directly from my old sync and getpackets
|
|
functions.
|
|
|
|
2. BYE BYE SYNCTICS!
|
|
|
|
Now that all computers are calling movethings a
|
|
constant number of times a second, you don't need any
|
|
synctics variables anymore. You can convert all the
|
|
synctics variables to a define such as:
|
|
"#define TICSPERFRAME 3"
|
|
Doing this will guarantee that a game runs the same on
|
|
all speed computers.
|
|
|
|
3. FRAME INTERPOLATION (optional):
|
|
|
|
static long ototalclock = 0, gotlastpacketclock = 0;
|
|
static long oposx[MAXPLAYERS], cposx[MAXPLAYERS];
|
|
static long oposy[MAXPLAYERS], cposy[MAXPLAYERS];
|
|
static long oposz[MAXPLAYERS], cposz[MAXPLAYERS];
|
|
static long ohoriz[MAXPLAYERS], choriz[MAXPLAYERS];
|
|
static long ozoom[MAXPLAYERS], czoom[MAXPLAYERS];
|
|
static short oang[MAXPLAYERS], cang[MAXPLAYERS];
|
|
|
|
Add to prepareboard:
|
|
for(i=connecthead;i>=0;i=connectpoint2[i])
|
|
{
|
|
oposx[i] = posx[i];
|
|
oposy[i] = (etc.)
|
|
}
|
|
ototalclock = 0;
|
|
gotlastpacketclock = 0;
|
|
|
|
Even though you may be getting more than 40fps, you will
|
|
only be seeing 40fps unless you interpolate between frames.
|
|
The oposx[], etc. variables back up the last posx[], etc.
|
|
variables so you can interpolate your actually drawing
|
|
position as some fraction between the two. This fraction
|
|
is smoothratio.
|
|
See beginning of drawscreen code. Here's where I actually
|
|
calculate the interpolated position to draw the screen.
|
|
|
|
for(i=connecthead;i>=0;i=connectpoint2[i])
|
|
{
|
|
cposx[i] = oposx[i]+mulscale(posx[i]-oposx[i],smoothratio,16);
|
|
cposy[i] = oposy[i]+mulscale(posy[i]-oposy[i],smoothratio,16);
|
|
cposz[i] = oposz[i]+mulscale(posz[i]-oposz[i],smoothratio,16);
|
|
choriz[i] = ohoriz[i]+mulscale(horiz[i]-ohoriz[i],smoothratio,16);
|
|
czoom[i] = ozoom[i]+mulscale(zoom[i]-ozoom[i],smoothratio,16);
|
|
cang[i] = oang[i]+mulscale(((ang[i]+1024-oang[i])&2047)-1024,smoothratio,16);
|
|
}
|
|
|
|
Draw the screen using cposx[], etc. instead of posx[], etc.
|
|
|
|
#pragma aux mulscale =\
|
|
"imul ebx",\
|
|
"shrd eax, edx, cl",\
|
|
parm [eax][ebx][ecx]\
|
|
modify [edx]\
|
|
|
|
It reads: eax = (eax*ebx)>>cl. Unlike C, this will
|
|
not overflow even if eax*ebx > 2^31, making full use of
|
|
the 64-bit result of the imul instruction.
|
|
|
|
4. MOVETHINGS FIFO:
|
|
|
|
static long movefifoplc, movefifoend;
|
|
static signed char baksyncvel[64][MAXPLAYERS];
|
|
static signed char baksyncsvel[64][MAXPLAYERS];
|
|
static signed char baksyncangvel[64][MAXPLAYERS];
|
|
static short baksyncbits[64][MAXPLAYERS];
|
|
|
|
Add to prepareboard: movefifoplc = 0; movefifoend = 0;
|
|
|
|
It is bad to call movethings inside faketimerhandler
|
|
because you don't want things to move while you're drawing
|
|
the screen. To solve this, I made movethings just save
|
|
away the parameters it was called with using a circular
|
|
buffer, and when I'm actually ready to DO the movement code,
|
|
I call domovethings.
|
|
Rename movethings to domovethings and see my new
|
|
movethings. This code is all for the fifo.
|
|
|
|
Put this line in movethings:
|
|
gotlastpacketclock = totalclock;
|
|
|
|
At the top of domovethings, copy my code for loading off
|
|
of the fifo. Also set oposx[] = posx[], etc. here.
|
|
|
|
5. You may want to add a global variable that controls whether
|
|
you are in continuous packet sending mode or not. Only
|
|
in the main loop should ready2send be != 0.
|
|
static long ready2send = 0;
|
|
|
|
6. The new main loop can be as short as this, with no case
|
|
checking for masters and slaves.
|
|
|
|
ready2send = 1;
|
|
while (keystatus[1] == 0) //Main loop starts here
|
|
{
|
|
//Actaully move everything here.
|
|
while (movefifoplc != movefifoend) domovethings();
|
|
|
|
//Second parameter is for frame interpolation,
|
|
//A fraction that ranges from 0-65536.
|
|
drawscreen(screenpeek,(totalclock-gotlastpacketclock)*(65536/TICSPERFRAME));
|
|
}
|
|
ready2send = 0;
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
3/6/95 - New key in BUILD. Now when you use relative alignment mode on
|
|
ceiling and floor textures, you can press Alt-F on the ceiling
|
|
or floor to choose a new wall to align to. It actually
|
|
rotates the walls of a sector by 1.
|
|
|
|
- Fixed screen capture PCX saving bug in both EDITART and BUILD.
|
|
|
|
- Added a parameter to screencapture, a filename.
|
|
screencapture(char *filename)
|
|
Ex: screencapture("captxxxx.pcx");
|
|
Please specify the full filename. Screencapture will modify
|
|
the 4 x's of the string to be a number starting at 0000.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
3/8/95 - Made my rotatesprite function use Editart centering information.
|
|
The center is the pivot point of rotation.
|
|
|
|
- Added y-flipping to overwritesprite. See above documentation.
|
|
|
|
- Added 2 new parameters to rotatesprite, shade and pal
|
|
|
|
rotatesprite (long sx, long sy, long z, short a,
|
|
short picnum, signed char shade, char pal);
|
|
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
3/10/95 - Fixed sprite showing through closed sectors bug.
|
|
|
|
- Made it possible to draw the overhead map in 3D mode by adding
|
|
a line drawing function in 3D mode called drawline256. It
|
|
draws a line clipped to the viewing rectangle last set in
|
|
setview(). Here are the parameters:
|
|
|
|
drawline256(long x1, long y1, long x2, long y2, char col);
|
|
|
|
Note: The coordinates are all shifted up 12.
|
|
Example: drawline256(0L,0L,319L<<12,199L<<12,31);
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
3/11/95 - Made drawline256 draw in a cleaner way, making use of the full
|
|
12 bits of precision.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
3/14/95 - Optimized / cleaned up parts of hitscan, neartag, cansee.
|
|
Gee, I hope they all still work!
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
3/18/95 - I'm back in RI!
|
|
|
|
- Fixed recently added movesprite z parameter bug that may have
|
|
done strange things with monsters, such as stuck in sectors
|
|
I thought the following expression: !(cstat&128)
|
|
would be true if bit 7 was a 0, but I WAS WRONG!
|
|
Get this straight:
|
|
! - logical NOT, returns 0 if != 0 else 1 (!2457=0, !0=1)
|
|
~ - bitwise NOT, xor's it with 0xffffffff (~0x5f=0xa0)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
3/21/95 - Gave access to some more variables in BSTUB.
|
|
|
|
- Made clipmove return a valid sector even if you're not between
|
|
its ceiling and floor. If you use overlapping sectors,
|
|
clipmove will find the sector closest to your z.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
3/28/95 - Optimized transluscence for masked walls and wall sprites.
|
|
|
|
- Today is the day I declare my serial/modem error correction code
|
|
perfect! Sure, I may have bragged over and over again about
|
|
how perfect my correction method is each time, but this time
|
|
I mean it. This is ship-it quality error correction. The old
|
|
method had a few dark, evil, and ugly bugs that sometimes
|
|
totally screwed up bigtime.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/5/95 - Got Master/Slave switching to stay in sync again with new
|
|
multiplayer code. Right after the master sends a packet
|
|
where a switch is made, I disable the master from sending
|
|
any more packets by setting ready2send to 0. Ready2send
|
|
will be set back to 1 only after the actual switch in
|
|
checkmasterslaveswitch. Here's what I added to movethings:
|
|
|
|
//Do this for Master/Slave switching
|
|
for(i=connectpoint2[connecthead];i>=0;i=connectpoint2[i])
|
|
if (syncbits[i]&512) ready2send = 0;
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/10/95 - Optimized continuous setview calls between 2 different window
|
|
sizes.
|
|
|
|
- ATTENTION PROGRAMMERS: Moved movesprite code into game.c. It
|
|
no longer exists in the engine. It is a "cover-up" function
|
|
and it should be yours.
|
|
|
|
- Added a circular keyboard buffer to my keyboard handler. It is
|
|
fully compatible with the keystatus arrays. Use this buffer
|
|
for typing in messages or cheat codes. If you do not use this
|
|
buffer (or you wrote your own interrupt handler), you will miss
|
|
keys and it is very annoying.
|
|
|
|
I added these variables to build.h:
|
|
|
|
#define KEYFIFOSIZ 64
|
|
EXTERN volatile char keyfifo[KEYFIFOSIZ],
|
|
keyfifoplc, keyfifoend;
|
|
|
|
Every time a key is pressed and released, I add 2 bytes to the
|
|
circular buffer. The first byte is the scan code. The second
|
|
byte is a 1 for key pressed or 0 for key released. You can
|
|
ignore the key releases if you wish. You must read 2 bytes at
|
|
a time from this buffer.
|
|
(scancode,keystat),(scancode,keystat),...
|
|
|
|
Here's how you read the keyboard fifo:
|
|
while (keyfifoplc != keyfifoend) //More characters to read
|
|
{
|
|
ch = keyfifo[keyfifoplc];
|
|
keystate = keyfifo[(keyfifoplc+1)&(KEYFIFOSIZ-1)];
|
|
//Increment buffer pointer
|
|
keyfifoplc = ((keyfifoplc+2)&(KEYFIFOSIZ-1));
|
|
|
|
printf("Scancode: %d, status: %d\n",ch,keystate);
|
|
}
|
|
|
|
The interrupt handler does the same as above but writes and
|
|
increments using keyfifoend as the index.
|
|
You can easily clear the buffer this way:
|
|
keyfifoplc = keyfifoend
|
|
|
|
- Made clipmove/getzrange not clip on the back side of a 1-sided
|
|
wall/floor sprite. It makes the clipping a little faster
|
|
and seems to fix a few minor clipping bugs. Don't get too
|
|
excited.
|
|
|
|
- Fixed getzrange's ceilz/florz mismatch with floor sprites against
|
|
normal ceilings and floors.
|
|
|
|
- Made Build default to y-centered centering mode when sprites
|
|
are inserted (bit 7 of sprite[].cstat)
|
|
|
|
- Fixed clipmove bugs with y-centered centering mode.
|
|
|
|
- Made it so you don't get stuck sliding along multiple properly
|
|
aligned wall/floor sprites.
|
|
|
|
- Please update to my new tables.dat.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/11/95 - Optimized parts of clipmove / getzrange. Is it faster? Did I
|
|
make more bugs?
|
|
|
|
- Made the movesprite code in GAME.C now use getzrange. This
|
|
allows sprites to walk on floor sprites and bombs roll across
|
|
bridges. I will include the original movesprite code that
|
|
came from the engine in case you want to start with things
|
|
the way they used to be.
|
|
|
|
- Made ornamentation in BUILD 3D mode much easier. Now you can
|
|
press 'S' to insert a sprite on walls (not just ceilings
|
|
and floors). When you insert a sprite on a wall, it will
|
|
automatically be set to a wall sprite at the wall's angle.
|
|
Also it will be 1-sided with blocking off (The optimal
|
|
options for a decorative sprite on a wall).
|
|
|
|
- Added ALT-D to BUILD 3D mode. It lets you type in clipdist
|
|
for sprites. It works in the same way as ALT-P for palookup
|
|
changing.
|
|
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/15/95 - Fixed return value bug in setanimation and cleaned up these 3
|
|
functions: doanimations, getanimationgoal, setanimation.
|
|
Since they are now in game.c, you will need to copy them to
|
|
update.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/16/95 - Fixed hitscan not passing through loops bug.
|
|
|
|
- Fixed hitscan so it hits wall and floor sprites in the right
|
|
places.
|
|
|
|
- ATTENTION PROGRAMMERS!!! Made bit 8 of sprite[].cstat the
|
|
hitscan clipping bit. It works like the hitscan bit for walls.
|
|
Note that both the wall and sprite cstat variables now have
|
|
2 separate bits for clipping, where:
|
|
1 is for use with the clipmove/getzrange function and
|
|
1 is for use with the hitscan function only.
|
|
Before, hitscan used to use 1 bit for all sprite clipping.
|
|
In your maps, the sprite hitscan bits are all zeros. That's bad!
|
|
To make things work like they used to, the sprite hitscan bit
|
|
must be set equal to the old sprite blocking bit. So I was nice
|
|
enough to make a program, FIXSPRBT.EXE, which will do just that.
|
|
|
|
PLEASE RUN FIXSPRBT.EXE ON ALL YOUR MAPS. You don't HAVE to
|
|
run it on all your maps since the map format hasn't changed, but
|
|
it will save you annoying attribute setting time if you do.
|
|
|
|
- Did a few things to make these blocking bits easier to edit:
|
|
Since H and ALT-H were already used, I made CTRL-H toggle the
|
|
hitscan bit for both walls and sprites in 2D mode. B toggles
|
|
the blocking bit. B also now sets the hitscan bit to its
|
|
default value when you press it. For sprites, the hitscan bit
|
|
default is equal to the clipmove bit. For walls, the hitscan
|
|
bit default is always 0.
|
|
|
|
- Added new map mode! Check it out in my game. I now have 3 map
|
|
modes. Not that this really matters to you game programmers, but
|
|
this is how my game works:
|
|
dimensionmode[snum] == 1 3D MODE + junky line map
|
|
dimensionmode[snum] == 2 SUPER MAP!
|
|
dimensionmode[snum] == 3 3D MODE
|
|
|
|
I added show2dsector to BUILD.H which controls which works
|
|
like the other show2d... bit arrays. It tells which sectors
|
|
to show.
|
|
EXTERN char show2dsector[MAXSECTORS>>3];
|
|
|
|
I rewrote parts of drawoverheadmap to accommodate this new
|
|
mode - so it would be nice if you updated to my new code.
|
|
|
|
Added a new function that clears full screen to a specified
|
|
color:
|
|
clearview(0L);
|
|
|
|
Oh and did I forget to mention the big function! Parameters
|
|
are the exact same my drawoverheadmap function:
|
|
drawmapview(cposx,cposy,czoom,cang);
|
|
|
|
Note: The new map mode right now is slowed down bigtime by
|
|
the face sprites using the rotatesprite function. The
|
|
rotatesprite right now is using a worse than awful
|
|
algorithm. When I optimize rotatesprite, the frame rate
|
|
of the new map mode will fly!
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/18/95 - Added default sprite cstat variable when you insert new sprites.
|
|
Set it to 0 if you hate the new centering mode in ExtInit
|
|
or 128 if you like the new centering mode.
|
|
Add this line to your Bstub if you wish:
|
|
extern short defaultspritecstat;
|
|
|
|
- If a wall & sprite are same distance away using hitscan, hitscan
|
|
now chooses the sprite.
|
|
|
|
- Optimized rotatesprite.
|
|
|
|
- ATTENTION PROGRAMMERS: Added new paramater at end of
|
|
rotatesprite: A char where the first bit tells it to use
|
|
transluscence mode or not.
|
|
|
|
rotatesprite(long sx, long sy, long z, short a, short picnum,
|
|
signed char dashade, char dapalnum, char dastat)
|
|
|
|
if ((dastat&1) == 0) - no transluscence
|
|
if ((dastat&1) != 0) - transluscence
|
|
|
|
- Cleaned up drawmapview further by making ALL floor sprite draw
|
|
with the texture in the right place and made the polygon
|
|
filling algorithm use higher screen coordinate precision.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/19/95 - Added parameter to makepalookup:
|
|
|
|
makepalookup(long palnum, char *remapbuf,
|
|
signed char r, signed char g, signed char b,
|
|
char dastat)
|
|
|
|
if ((dastat&1) == 0) then makepalookup will allocate & deallocate
|
|
the memory block for use but will not waste the time creating
|
|
a palookup table (assuming you will create one yourself)
|
|
if ((dastat&1) != 0) then makepalookup will allocate & deallocate
|
|
the memory block AND create a palookup table using the rgb
|
|
values you pass.
|
|
|
|
- Made my ceiling&floor update the self-modified palookup pointers
|
|
when palookup[sector[].?pal] changes, not just when
|
|
sector[].?pal] changes. Watching for changing pointers rather
|
|
than changing indeces should solve the problem with screwy
|
|
palookup selection for ceilings&floors. Ignore what I said
|
|
before. You should now be able to change palookup pointers
|
|
freely.
|
|
|
|
- Optimized relative alignment. It should be the same speed as
|
|
all other ceilings & floors now.
|
|
|
|
- Warning: Since I added the new bit in sprite[].cstat, there are
|
|
now 9 bits in use. Make sure to treat it as a short. In my
|
|
code, I had some bugs where I did this:
|
|
sprite[].cstat &= (255-4); BAD! Cstat's a short! Please
|
|
check your code and make sure you clear the bits this way:
|
|
sprite[].cstat &= ~4;
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/21/95 - Fixed bug with flipping textures on ceilings & floors. In
|
|
BUIL0419.ZIP I had a bug whenever a ceiling or floor texture
|
|
had bit 4 set. It drew the texture backwards. Well, I
|
|
fixed it. Hope you didn't "Build" on this bug!
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/22/95 - Fixed really really stupid hitscan returning sector < 0 bug. If
|
|
you were calling hitscan from the top-left triangular region
|
|
of the board it stupidly returned a -1 for the sector. Well,
|
|
I fixed it.
|
|
|
|
- ATTENTION EVERYBODY!!! Moved setup.dat loading from the engine
|
|
into GAME.C and BSTUB.C. If you copy this code from game.c
|
|
into your game / bstub, they will work like it used to:
|
|
|
|
----- NEW GLOBAL VARIABLES: -----
|
|
|
|
#define NUMOPTIONS 8
|
|
#define NUMKEYS 19
|
|
static long chainxres[4] = {256,320,360,400};
|
|
static long chainyres[11] = {200,240,256,270,300,350,
|
|
360,400,480,512,540};
|
|
static long vesares[7][2] = {320,200,640,400,640,480,
|
|
800,600,1024,768,
|
|
1280,1024,1600,1200};
|
|
static char option[NUMOPTIONS] = {0,0,0,0,0,0,1,0};
|
|
static char keys[NUMKEYS] =
|
|
{
|
|
0xc8,0xd0,0xcb,0xcd,0x2a,0x9d,0x1d,0x39,
|
|
0x1e,0x2c,0xd1,0xc9,0x47,0x49,
|
|
0x9c,0x1c,0xd,0xc,0xf,
|
|
};
|
|
|
|
----- Put this where you call initengine -----
|
|
|
|
long fil;
|
|
|
|
if ((fil = open("setup.dat",O_BINARY|O_RDWR,S_IREAD)) != -1)
|
|
{
|
|
read(fil,&option[0],NUMOPTIONS);
|
|
read(fil,&keys[0],NUMKEYS);
|
|
close(fil);
|
|
}
|
|
if (option[3] != 0) moustat = initmouse();
|
|
|
|
switch(option[0])
|
|
{
|
|
case 0: initengine(0,chainxres[option[6]&15],chainyres[option[6]>>4]); break;
|
|
case 1: initengine(1,vesares[option[6]&15][0],vesares[option[6]&15][1]); break;
|
|
case 2: initengine(2,320L,200L); break;
|
|
case 3: initengine(3,320L,200L); break;
|
|
case 4: initengine(4,320L,200L); break;
|
|
case 5: initengine(5,320L,200L); break;
|
|
case 6: initengine(6,320L,200L); break;
|
|
}
|
|
|
|
----- That's it! -----
|
|
|
|
Initengine now has 3 parameters:
|
|
initengine(char davidoption, long daxdim, long daydim)
|
|
See revised initengine description at the top of this file.
|
|
|
|
Now that engine.c doesn't use setup.dat, you can use your
|
|
own setup program.
|
|
|
|
Don't forget to update BSTUB!
|
|
|
|
NOTE!!! While MY setup program allows you select many different
|
|
video modes, no new modes are supported yet in BUILD!
|
|
(It's on my list.)
|
|
|
|
|
|
- Fixed keyboard repeating.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/26/95 - Hi-res now works in all modes! The code I gave in the 4/22/95
|
|
description is still perfectly valid, so please copy it if
|
|
you haven't already looked at it. Here are some important
|
|
new variables I put in BUILD.H:
|
|
|
|
EXTERN char vidoption;
|
|
EXTERN long xdim, ydim, ylookup[MAXYDIM+1];
|
|
|
|
Vidoption is simply the first parameter you pass to
|
|
initengine. Xdim and Ydim are the screen sizes you pass to
|
|
initengine, such as 320*200 or 640*480.
|
|
Ylookup is a lookup table that works like this:
|
|
If (vidoption == 0) ylookup[i] = ((i*xdim)>>2);
|
|
if (vidoption != 0) ylookup[i] = i*xdim;
|
|
There is 1 exception: If you are using a chained mode which
|
|
can only fit only 1 viewing page, then the engine actually
|
|
does a screen-buffer mode and blits to the chained screen
|
|
so for this case, ylookup[i] = i*xdim.
|
|
|
|
- Added bit to the dastat parameter of rotatesprite.
|
|
if ((dastat&2) != 0) - align to screen size so the gun or
|
|
whatever is always over the same relative spot of the screen.
|
|
Works like bit 2 of the flags parameter in overwritesprite.
|
|
|
|
- Added pixel writing and reading that will work in all BUILD
|
|
graphics modes. They work just like you think they should.
|
|
|
|
plotpixel(long x, long y, char col);
|
|
char getpixel(long x, long y);
|
|
|
|
Please do not overuse these functions! They are NOT intended
|
|
for fast drawing!
|
|
|
|
- Changed tables.dat so parallaxing skies at high resolutions
|
|
work accurately.
|
|
|
|
- I made bit 15 of sprite[].cstat the invisible bit. If it is
|
|
set, then the sprite won't even be considered for sorting and
|
|
there is absolutely no speed loss due to its existence. It is
|
|
faster to use this bit then manually set thesprite[] to -1.
|
|
|
|
Since drawrooms collects the list of sprites drawmasks is about
|
|
to sort, make sure the bit is set before drawrooms. If you use
|
|
frame interpolation, you usually want to tell drawmasks somehow
|
|
to not draw yourself. Before you used to use the
|
|
thesprite[] = -1 trick. Now you do it like this:
|
|
|
|
sprite[i].cstat |= 0x8000; //Set invisible bit
|
|
drawrooms(posx,posy,etc.);
|
|
sprite[i].cstat &= ~0x8000; //Restore invisible bit
|
|
|
|
- Fixed distance overflow bug (the one that showed garbage
|
|
textures if a wall was really far away).
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/27/95 - Made an example board, MONWALK.MAP, where monsters walk along
|
|
a bridge with no railing, onto a sector, and even up and down
|
|
a stairway without falling off it. If you shoot a brown so
|
|
it's almost dead, it will turn transluscent. If it's
|
|
transluscent, it won't shoot bullets. It is much easier to
|
|
test the monsters' walking when they don't shoot!
|
|
|
|
- Try my new and improved fake network player mode! Each fake
|
|
network player now gets their own window. Use insert and
|
|
delete to add or remove players. Use Scroll lock to switch
|
|
which window you control. If you have a Pentium, I would
|
|
recommend trying this out in 640*480 mode.
|
|
|
|
- Noticed a bug with my movesprite code:
|
|
For clipmove, I was getting the z-coordinate right, but for
|
|
getzrange I forgot to subtract half the sprite's height if
|
|
the sprite was using the real centered centering mode.
|
|
|
|
These lines set daz to the actual center of sprite i no matter
|
|
what centering mode is used:
|
|
|
|
daz = sprite[i].z;
|
|
if ((sprite[i].cstat&128) == 0)
|
|
daz -= ((tilesizy[sprite[i].picnum]*sprite[i].yrepeat)<<1);
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
4/28/95 - ATTENTION PROGRAMMERS! When a tile is not in the cache:
|
|
Before it used to be this:
|
|
|
|
if (waloff[tilenum] == -1) loadtile(tilenum);
|
|
or
|
|
if (waloff[tilenum] < 0) loadtile(tilenum);
|
|
|
|
Now it's this:
|
|
|
|
if (waloff[tilenum] == 0) loadtile(tilenum);
|
|
|
|
PLEASE MODIFY YOUR CODE IF YOU USE WALOFF!
|
|
|
|
Windows can allocate memory with addresses so high, they
|
|
are negative. That makes the (waloff[tilenum] < 0)
|
|
method totally stupid and attempt to reload from disk
|
|
the tile constantly! I can think of 3 reasons why I
|
|
originally designed my system in this fashion:
|
|
mestupid, mestinx, and merottts.
|
|
|
|
- Fixed visibility for different screen sizes.
|
|
|
|
- ATTENTION PROGRAMMERS! Now multiply by visibility rather than
|
|
shift right by visiblity so you get a broader range of
|
|
visibility. If you want the visiblity to work like before,
|
|
use this conversion table:
|
|
|
|
Old visibility New visibility
|
|
8 -> 16384
|
|
9 -> 8192
|
|
10 -> 4096
|
|
11 -> 2048
|
|
12 -> 1024
|
|
13 -> 512
|
|
14 -> 256
|
|
15 -> 128
|
|
|
|
- Made Alt-F make the selected wall the first wall of a sector.
|
|
This is useful for quick relative alignment adjustments.
|
|
Alt-F for 2D and 3D modes may not work for sectors with loops
|
|
inside of them.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/1/95 - Optimized horizontal line setup code from 9 multiplies to
|
|
7 multiplies.
|
|
|
|
- Fixed dark vertical lines in parallaxing skies bug I recently
|
|
introduced.
|
|
|
|
- Optimized horizontal line assembly code so it doesn't use the
|
|
awful SHLD instruction any more. This is a good speed
|
|
improvement for Pentiums only.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/2/95 - Added some code to my GAME.C which detects when a computer gets
|
|
out of sync in a multiplayer game. It's not as easy as you
|
|
may think with all the faketimerhandler and fifo crap. If
|
|
you want to put this code in your game, search all areas in
|
|
my code with the keyword "syncval".
|
|
|
|
- Fixed palookup crashing bug.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/6/95 - Moved windowx1, windowy1, windowx2, windowy2 variables into
|
|
BUILD.H. They are the exact parameters you passed to the
|
|
last setview call. Please DO NOT modify them directly.
|
|
Use setview to modify them.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/10/95 - Fixed makepalookup bug when shading to non 0.
|
|
|
|
- Fixed palookup pointer setting bug.
|
|
|
|
- ATTENTION PROGRAMMERS! I made a new cacheing system which allows
|
|
any type of object to be allocated in my cache, such as
|
|
artwork tiles and sounds or whatever else you may want to
|
|
put on the cache. This may or may not affect you. If you
|
|
haven't been hacking into my code, then you shouldn't have to
|
|
change your code. The cacheing routines have been moved into
|
|
a separate module, cache1d.obj. If you link engine.obj, then
|
|
you must also link cache1d.obj. Please update your makefiles.
|
|
|
|
For anybody who may want to re-write my cacheing system, here's
|
|
how it now works: (I have only 3 functions in cache1d.obj
|
|
right now, initcache, uninitcache, and allocache)
|
|
|
|
Allocate a nice BIG buffer, like from 1MB-4MB and
|
|
call initcache(long cachestart, long cachesize) where
|
|
|
|
cachestart = (long)(pointer to start of BIG buffer)
|
|
cachesize = length of BIG buffer
|
|
|
|
Ex: initcache(FP_OFF(pic),cachesize);
|
|
|
|
Loadpics calls this function for you so you don't normally
|
|
need to call it.
|
|
|
|
call allocache(long ptr, long siz) whenever you need to
|
|
allocate a temporary buffer, where
|
|
|
|
ptr = (long)(pointer to (4-byte pointer to thing))\
|
|
siz = number of bytes
|
|
|
|
Ex: if (waloff[tilenume] == 0)
|
|
allocache((long)&waloff[tilenume],walsiz[tilenume]);
|
|
|
|
Allocache is totally tile independent. To allocate a sound
|
|
on the cache, you can call allocache.
|
|
|
|
There are 3 functions in the engine which help manage the
|
|
cache for you: loadpics - calls initcache
|
|
loadtile - calls allocache
|
|
allocatepermanenttile - special function
|
|
that allocates permanent memory
|
|
from the cache.
|
|
|
|
- Fixed clipmove crashing bug when passing a sectnum < 0. Whenever
|
|
you moved in BUILD and you weren't in a valid sector, memory
|
|
was getting trashed.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/12/95 - Added ExtPreCheckKeys(void) to BSTUB.C. It is called before
|
|
drawrooms / drawmasks in 3D mode, whereas ExtCheckKeys(void)
|
|
is called after drawrooms / drawmasks (and before nextpage).
|
|
|
|
- Added bit to flags of rotatesprite to allow x-flipping. See
|
|
updated documentation.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/17/95 - Added aspect ratio for those weird modes like 320*400, etc.
|
|
You could call setaspect to properly adjust a mode that is
|
|
not exactly correct, or for special effect that stretch
|
|
the screen.
|
|
|
|
In ENGINE.OBJ, I added a function, setaspect(long daaspect),
|
|
where you pass the Y/X aspect ratio scaled up 16 bits, so
|
|
65536 would be normal. You don't need to call this if you
|
|
don't want to. By default, in setview, I call setaspect
|
|
with these parameters:
|
|
|
|
setaspect(divscale16(ydim*320,xdim*200));
|
|
(also written as:)
|
|
setaspect(((ydim*320)<<16)/(xdim*200));
|
|
|
|
Note that in 320*200 mode the value passed would be 65536
|
|
which is a 1:1 aspect ratio.
|
|
|
|
In BUILD.H, I added yxaspect and xyaspect.
|
|
|
|
When you call setaspect(daaspect),
|
|
|
|
yxaspect = daaspect;
|
|
xyaspect = (1<<32) / yxaspect; //reciprocal
|
|
and other internal variables, so DON'T MODIFY YXASPECT
|
|
AND XYASPECT DIRECTLY!
|
|
|
|
Since drawmapview is also affect by the aspect ratio, you
|
|
will need to make sure drawoverheadmap is affected so
|
|
the map modes match up. Please look at and copy my updated
|
|
drawoverheadmap function into your GAME.C if you use it.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/18/95 - Revised caching system so it supports locking.
|
|
Here are the new parameters to allocache:
|
|
|
|
allocache(long *bufptr, long bufsiz, char *lockptr)
|
|
*bufptr = pointer to 4-byte pointer to buffer
|
|
bufsiz = number of bytes to allocate
|
|
*lockptr = pointer to 1-byte locking char. 1=locked, 0=not
|
|
|
|
And uninitcache works a little differently too:
|
|
Call uninitcache(0) to remove all UNLOCKED items or
|
|
Call uninitcache(1) to remove ALL items.
|
|
After calling uninitcache, you do not need to call
|
|
initcache to use the cache again.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/21/95 - Made changespritesect and changespritestat return 0 instead of -1
|
|
when changing to same value.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/25/95 - Added relative visibility for sectors. In 3D EDIT MODE, use
|
|
ALT+(keyp.)+/- to change an individual sector's visibility.
|
|
Press Shift in addition for fine visibility changine. By
|
|
default you change it by 16. Press CTRL+ALT+(keyp.)+/- to
|
|
change the global visibility. The global visibility is not
|
|
saved in the map.
|
|
|
|
- Can now delete many sectors at a time. Select sectors with the
|
|
rt. Alt. Then press Ctrl-delete on any highlighted sector to
|
|
delete all the highlighted sectors.
|
|
|
|
- Fixed build sometimes not saving when quitting from 2D mode bug.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/27/95 - Fixed bugs in network work that should make it miss packets
|
|
much less often than before.
|
|
|
|
- Fixed bug in ncopy so it shouldn't halt or crash anymore.
|
|
|
|
- Added spritecstat[] the thesprite arrays. Please use my
|
|
thesprite arrays rather than modifying the sprite directly
|
|
since hitscan and clipmove use bits 4 and 8 of sprite[].cstat.
|
|
|
|
- ATTENTION PROGRAMMERS: Added 1 parameter to neartag that will
|
|
allow you to search only lotags or only hitags. See updated
|
|
documentation above.
|
|
|
|
neartag (long xs, long ys, long zs, short sectnum, short ange,
|
|
short *neartagsector, short *neartagwall, short *neartagsprite,
|
|
long *neartaghitdist, long neartagrange, char tagsearch)
|
|
|
|
If tagsearch = 1, neartag searches lotag only
|
|
If tagsearch = 2, neartag searches hitag only
|
|
If tagsearch = 3, neartag searches lotag&hitag
|
|
|
|
Neartag used to always search both lotag&hitag.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
5/30/95 - Added ExtAnalyzeSprites(void) to BSTUB and a spriteshade array
|
|
to BUILD.H.
|
|
|
|
- Made circle drawing in 2D EDIT MODE work better at large sizes.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/5/95 - Added shareware / registered artwork version control to EDITART.
|
|
In 'V' mode, when you press ALT-R to get a report of tile
|
|
frequencies of tiles on all the maps in the current directory,
|
|
you can toggle the shareware/registered bit with the space bar.
|
|
This bit is saved in the top bit of the picanm bits so it is
|
|
stored permanently in the art file. Press ALT-D in this mode
|
|
to automatically delete all registered tiles. Please before
|
|
you do the deleting phase, copy all artwork to a temporary
|
|
directory!!! It is safe, however, the toggle the new bit in
|
|
the full version.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/7/95 - Made 3 main structures defined with typedef so struct prefix
|
|
is no longer needed with sectortype, walltype, and spritetype.
|
|
|
|
- Added new function to engine:
|
|
|
|
short sectorofwall(short dawall);
|
|
|
|
It returns the sector of a given wall. It is well optimized
|
|
including sector[sector[].nextwall].nextsector if a red wall
|
|
and a binary search on the sector[].wallptr's if it is a
|
|
white wall. On average, sectorofwall should have to scan
|
|
through only 10 different sector indeces to find the right
|
|
sector (not 1024!).
|
|
|
|
- ATTENTION PROGRAMMERS! Made all the separate thesprite arrays
|
|
into a single array of sprite structures call tsprite. See
|
|
BUILD.H!!! This means:
|
|
|
|
spritepicnum[i] is now tsprite[i].picnum
|
|
spritex[i] is now tsprite[i].x
|
|
spritey[i] is now tsprite[i].y
|
|
spritez[i] is now tsprite[i].z
|
|
spriteshade[i] is now tsprite[i].shade
|
|
spritecstat[i] is now tsprite[i].cstat
|
|
spritepal[i] is now tsprite[i].pal
|
|
thesprite[i] is now tsprite[i].owner <<<============
|
|
|
|
Everything above is straight forward, except for thesprite,
|
|
which has been renamed to owner.
|
|
|
|
All other tsprite parameters, such as .xrepeat, .yoffset,
|
|
etc. can also be modified without changing the real
|
|
sprite structure so the game won't out of sync.
|
|
|
|
- Made tsprite[].statnum be a priority variable for sorting sprites
|
|
that are the exact same distance from you. I think higher
|
|
means more in front.
|
|
|
|
- Made clipmove allow you to cross any red sector line when the z's
|
|
of the next sector are farther apart. This may solve clipping
|
|
bugs such as when you're in water. You may be able to remove
|
|
some work-arounds you may have programmed previously.
|
|
|
|
- NEW FILE GROUPING SYSTEM!!!
|
|
My system will first search for the stand-alone file in the
|
|
directory. If it doesn't find it, then it will search for it
|
|
in the group file. If it still doesn't find it then -1 city.
|
|
Use KGROUP.EXE to create a grouped file from a lot of other
|
|
files. Type KGROUP [grouped filename][filespec][filespec][...]
|
|
For example this line will create the new grouped file,
|
|
stuff.dat, including all the following files specified:
|
|
kgroup stuff.dat *.art *.map tables.dat palette.dat
|
|
Feel free to make your own batch files. If there is demand,
|
|
I can make kgroup support appending, replacing, and extraction.
|
|
|
|
Here is the file format of a grouped file:
|
|
ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
|
|
³ 12 bytes - File grouping ID ³
|
|
³ 4 bytes - Number of files ³
|
|
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
|
|
³For each file: (16 bytes per file) ³
|
|
³ 12 bytes - Filename with extension (13th byte would be a 0) ³
|
|
³ 4 bytes - Length of file ³
|
|
ÃÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´
|
|
³ Pure, raw file data, ordered just like you think it would be ³
|
|
ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
|
|
There just couldn't be a simpler format. This format is so
|
|
hacker happy that when you view it in a hex editor, all the
|
|
filenames line up perfectly since they're multiples of 16.
|
|
Anybody who can't figure this out, of course, not only rots,
|
|
but is probably one of those really stupid people who would
|
|
actually "pay" to get the full version of a game.
|
|
|
|
The engine currently supports grouping for:
|
|
*.ART, *.MAP, TABLES.DAT and PALETTE.DAT. If you want
|
|
to group your own files, you will have to use my loading
|
|
routines rather than the standard ones for those files. My
|
|
file routines are basically an extra layer around the standard
|
|
lo-level functions. Look at these 5 routines I currently
|
|
support:
|
|
|
|
Welcome to the K-routines!
|
|
open -> kopen4load(char *filename)
|
|
read -> kread(long handle, void *buffer, long leng)
|
|
lseek -> klseek(long handle, long offset, long whence)
|
|
filelength -> kfilelength(long handle)
|
|
close -> kclose(long handle)
|
|
|
|
Note that you only pass the filename to my kopen4load function.
|
|
|
|
Here are 2 other routines that you MUST use, whether you like
|
|
my file grouping system or not:
|
|
|
|
initgroupfile(char *groupfilename)
|
|
Call this with the name of your grouped file before
|
|
any possible file loading will the k-routines. Note that
|
|
tables.dat uses the k-routines and it is in initengine().
|
|
Please don't give your grouped filename an extension that
|
|
starts with W, ends with D, and has a vowel in between.
|
|
And don't even bother to write your own file grouping
|
|
system because even if you do, people still have to write
|
|
their own new utilities to read the ART and MAP files.
|
|
|
|
uninitgroupfile()
|
|
Call before quitting to DOS.
|
|
------------------------------------------------------
|
|
- ATTENTION PROGRAMMERS! Changed kopen4load from:
|
|
|
|
kopen4load(char *filename)
|
|
to:
|
|
kopen4load(char *filename, char searchfirst)
|
|
|
|
where:
|
|
if searchfirst = 0 then search stand alone first then group file
|
|
if searchfirst = 1 then search group file only
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/12/95 - Tracked down an OUT OF SYNC bug with my multiplayer code!
|
|
In my GAME.C, the way I had my sync arrays organized were
|
|
wrong. The problem was that if faketimerhandler was
|
|
called during domovethings, the sync arrays may have been
|
|
changed, getting the game out of sync. The solution is
|
|
to keep the sync arrays in domovethings totally separate
|
|
from the sync arrays in faketimerhandler. I split my sync
|
|
arrays into 2 separate arrays, sync and fsync, where fsync
|
|
and osync are for use BEFORE the FIFO only (such as
|
|
faketimerhandler and getpackets), and sync is used AFTER
|
|
the FIFO only (such as domovethings). PLEASE SPLIT YOUR
|
|
SYNC ARRAYS AS I DESCRIBED!
|
|
|
|
- The OUT OF SYNC message doesn't flicker any more. See the
|
|
section of code in GAME.C where I set syncstat.
|
|
|
|
- Fixed up a waitforeverybody function for network games which
|
|
waits for everybody to be at a certain part of the game.
|
|
Waitforeverybody also uses getpackets message number 5.
|
|
|
|
- Added new clipping function that will push players away from
|
|
walls that are too close. It solves A LOT of movement
|
|
clipping problems. It can be pretty darn slow if it detects
|
|
that you're too close to a wall, so I'd recommend using it
|
|
only for players.
|
|
|
|
pushmove (long *x, long *y, long *z, short *sectnum,
|
|
long walldist, long ceildist, long flordist, char cliptype)
|
|
|
|
The parameters are exactly the same as clipmove but with no
|
|
xvect or yvect. Pushmove returns either a 0 or -1. If
|
|
it returns a -1, then that means that it could not push
|
|
the player away from the offending wall after 256 tries.
|
|
When this happens, then you should kill the player
|
|
instantly, because this only happens when the player is
|
|
getting smooshed.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/13/95 - Made clipinsidebox and clipinsideboxline return 0 if line doesn't
|
|
intersect box, 1 if line intersects box and center of box
|
|
is in front of line, or 2 if line intersects box and center
|
|
of box is behind line.
|
|
|
|
- Cansee should now work properly with overlapping.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/19/95 - ATTENTION! Remove work-arounds!!! Found nasty getzrange bug.
|
|
Getzrange used to let you fall through red sector line cracks
|
|
when you were near more multiple red sector line sharing the
|
|
same 2 sectors. Sound familiar anybody?
|
|
|
|
- Made pushmove return the sector of whatever x and y end up in.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/22/95 - I included cache1d.c renamed to cache1d.txt in this upload.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/26/95 - Made face and wall sprites of clipmove, getzrange, hitscan, and
|
|
neartag sensitive to the y-offset that you set in Editart.
|
|
|
|
- Made one sprite sorting case work perfectly: where multiple
|
|
sprites have the same x and y location (and priority). The
|
|
sorting still doesn't work perfectly, but this one case can
|
|
solve many of the current sprite sorting bugs, such as
|
|
inserting a floor sprite of blood below a dead body.
|
|
|
|
- Fixed some sprite drawing clipping bugs for wall and floor
|
|
sprites. Now, wall sprites and floor sprites should not
|
|
show through walls, ceilings, or floors when they're not
|
|
supposed to. Also, I fixed a case where wall sprites
|
|
disappeared when they happened to be between 2 white walls
|
|
that clipped it.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/27/95 - Fixed even more sprite drawing clipping bugs for wall sprites.
|
|
|
|
- BONUS!!! Wall sprites now clip to white walls! (not red walls)
|
|
If you ornament a wall, make sure that neither endpoint of the
|
|
wall sprite is behind the wall or else it will get clipped.
|
|
Please run lookatme.map from my game.exe which demonstrates
|
|
some of the things you can do in build now without bugs.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
6/30/95 - Made drawline256 clip with startumost/startdmost.
|
|
|
|
- Moved keyboard handler into GAME.C. Here's what you need to do
|
|
to use my keyboard handler (see my GAME.C):
|
|
|
|
1. Some global variables:
|
|
|
|
#define KEYFIFOSIZ 64
|
|
void (__interrupt __far *oldkeyhandler)();
|
|
void __interrupt __far keyhandler(void);
|
|
volatile char keystatus[256], keyfifo[KEYFIFOSIZ];
|
|
volatile char keyfifoplc, keyfifoend;
|
|
volatile char readch, oldreadch, extended, keytemp;
|
|
|
|
2. initkeys()
|
|
|
|
3. uninitkeys()
|
|
|
|
4. keyhandler()
|
|
|
|
5. Make sure to call initkeys and uninitkeys. A good place
|
|
would be next to where you call inittimer / uninittimer.
|
|
|
|
I didn't put my keyboard handler into BSTUB since I am using
|
|
keystatus throughout build.obj. Besides I didn't want to anybody
|
|
too bad of a headache for one upload.
|
|
|
|
- Did you know that screencapture inverses black and white if you
|
|
hold either shift key down? This option is useful for
|
|
printing out board maps. Since I don't own the keyboard
|
|
any more, I had to make screencapture take inverseit as the
|
|
second parameter.
|
|
|
|
screencapture(char *filename, char inverseit);
|
|
|
|
Ex: screencapture("captxxxx.pcx",keystatus[0x2a]|keystatus[0x36]);
|
|
|
|
If (inverseit == 0) then nuttin' special
|
|
If (inverseit == 1) then super-reverso blacko-whiteo mode!
|
|
|
|
I also had to move the stereo adjustment keys into game.c
|
|
Just search for the "stereo" keyword in GAME.C. It'll take
|
|
through all the necessary places.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/5/95 - Moved my keytimerstuff from my timerhandler into getinput.
|
|
(which is where it should be)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/10/95 - Added a loadtilelockmode variable to BUILD.H. It's a global
|
|
variable that makes future loadtile calls allocate their
|
|
buffers on the cache as unlocked (0-default) or locked (1).
|
|
I decided to make this a global variable rather than a
|
|
parameter to save some people from rewriting code.
|
|
|
|
EXTERN char loadtilelockmode;
|
|
|
|
- Made my 2D EDIT MODE space bar code clear out new sectors and
|
|
wall structures to 0. (except for the extras which are -1)
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/20/95 - I forgot to documenent rotatesprite bit 3, which controls
|
|
whether or not the sprite will be clipped to the startumost
|
|
/startdmost arrays. If the bit is a 1, then the sprite will
|
|
not be clipped. This mode is useful for doing status bars
|
|
at variable resolutions. What you do is instead of calling
|
|
permanentwritesprite, you call rotatesprite with the scaling
|
|
bit and startumost/startdmost clipping bit off. For non
|
|
screen-buffer modes, be sure to call rotatesprite for each
|
|
page of the mode. Use the numpages variable in BUILD.H to
|
|
get the number of video pages used.
|
|
|
|
- Added clipping box parameters to rotatesprite: Here is the
|
|
prototype now:
|
|
|
|
rotatesprite (long sx, long sy, long z, short a, short picnum,
|
|
signed char dashade, char dapalnum, char dastat,
|
|
long cx1, long cy1, long cx2, long cy2)
|
|
|
|
For your information, rotatesprite used to choose default
|
|
clipping box sizes using this code:
|
|
|
|
if ((dastat&8) == 0)
|
|
{ //0,0,xdim-1,ydim-1
|
|
cx1 = windowx1; cy1 = windowy1;
|
|
cx2 = windowx2; cy2 = windowy2;
|
|
}
|
|
else
|
|
{
|
|
cx1 = 0; cy1 = 0;
|
|
cx2 = xdim-1; cy2 = ydim-1;
|
|
}
|
|
|
|
Now both permanentwritesprite and overwrite can both be
|
|
replaced with rotatesprite which now does everything.
|
|
To replace permanentwritesprite, you must make sure to
|
|
draw to all the pages in numpages.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/27/95 - Fixed recently introduced build 3D mode bug when you press the
|
|
L.ENTER key on a blank map. Also made sectorofwall return -1
|
|
if an invalid wall is passed to it.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/28/95 - Added a function to my game that shows only the local area of
|
|
the map by scanning through the nextsectors of walls and
|
|
setting the show2dsector, show2dwall, and show2dsprite
|
|
arrays properly. You should call this function any time
|
|
(show2dsector[cursectnum>>3] & (1<<(cursectnum&7))) == 0)
|
|
That means it's not showing the sector you're currently
|
|
in. You should also manipulate show2dsprite any time you
|
|
insert or warp a sprite.
|
|
|
|
- You know the one thing in my engine that doesn't work in chained
|
|
mode? Well I fixed it!
|
|
|
|
- Fixed a bug which made it print out of sync when it really
|
|
wasn't (This bug probably only affecting my game.) In
|
|
getsyncstat, I was calling updatecrc16() with things other
|
|
than chars, making it index invalid parts of the crctable
|
|
array.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
7/30/95 - Reduced some overhead memory:
|
|
* Removed walsiz[] array. (16K saved). If you ACTUALLY used
|
|
this array, you can multiply tilesizx[]*tilesizy[] instead.
|
|
* Made sqr table from longs to shorts with same precision.
|
|
* Removed tantable. (4K saved)
|
|
* Reduced internal constant, MAXWALLSB, from 4096 to 2048
|
|
(96K saved).
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/1/95 - Added another bit to rotatesprite for top-left corner mode and
|
|
made documentation of the stat bits more clear.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/3/95 - Fixed a bug with rotatesprite so it now scales perfectly to the
|
|
full screen view when enabling bits 2 and 8 of the stat field.
|
|
This means that with rotatesprite, you can easily get your
|
|
status bars, etc., to work at any resolution.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/4/95 - New Doom->Build update! You can now convert doors and lots of
|
|
other weird things. Fixed more conversion bugs. Sprites now
|
|
convert properly in doom-artwork mode. You can now convert
|
|
PWADS.
|
|
|
|
- Added some wacky aspect ratio keys to 3D EDIT MODE of BUILD.
|
|
Use Rt.Ctrl Rt.Alt Lt.- or Rt.Ctrl Rt.Alt Lt.= to select.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/12/95 - Added parameter to initmultiplayers to allow who becomes
|
|
master at the start of a multiplayer game.
|
|
|
|
- Added parallaxyscale variable to BUILD.H which control the ratio
|
|
at which the parallaxing skies scroll in relation to the
|
|
horizon. Default is 65536. With lower values, you don't
|
|
need as much artwork and can look higher, but I like 65536
|
|
because it is the correct projection.
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/13/95 - Had MAJOR bug with my searchmap function. If you use it, please
|
|
re-copy from my game.c
|
|
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ
|
|
8/14/95 - Fixed some EVIL bugs with Rt.ALT sector copying. It shouldn't
|
|
screw up your maps anymore! And if you have maps that were
|
|
screwed up with it, you can try my new map correcting key,
|
|
L.Ctrl+L.Shift+L.Enter. This key will not affect an already
|
|
perfect map. However it can SOMETIMES clean up a map that
|
|
was screwed up. I take no responsibility if it screws up
|
|
your map even more, so please check them before saving!
|