![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to build.txt CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Witchaven I] / src|
Return to build.txt CVS log | Up to [Witchaven I] / src |
1.1 root 1: BUILD engine Notes (7/20/95):
2:
3: ���������������������������������������������������������������������������Ŀ
4: � IMPORTANT ENGINE FUNCTIONS: �
5: �����������������������������������������������������������������������������
6:
7: initengine(char vidoption, long xdim, long ydim)
8: Sets up interrupt vectors for keyboard, and initializes many variables
9: for the BUILD engine. You should call this once before any other
10: functions of the BUILD engine are used.
11:
12: vidoption can be anywhere from 0-6
13: xdim,ydim can be any mode x resolution if vidoption = 0
14: xdim,ydim can be any vesa resolution if vidoption = 1
15: xdim,ydim must be 320*200 for any other mode.
16: (see graphics mode selection in my setup program)
17: uninitengine();
18: Restores interrupt vectors for keyboard and timer, and frees
19: buffers. You should call this once at the end of the program
20: before quitting to dos.
21: loadboard(char *filename, long *posx, long *posy, long *posz, short *ang, short *cursectnum)
22: Loads the given board file into memory for the BUILD engine.
23: Returns -1 if file not found. If no extension is given, .MAP will
24: be appended to the filename.
25: saveboard(char *filename, long *posx, long *posy, long *posz, short *ang, short *cursectnum)
26: Saves the given board from memory inro the specified filename.
27: Returns -1 if unable to save. If no extension is given, .MAP will
28: be appended to the filename.
29: loadpics(char *filename);
30: Loads the given artwork file into memory for the BUILD engine.
31: Returns -1 if file not found. If no extension is given, .ART will
32: be appended to the filename.
33: setgamemode();
34: This function sets the video mode to 320*200*256color graphics.
35: Since BUILD supports several different modes including mode x,
36: mode 13h, and other special modes, I don't expect you to write
37: any graphics output functions. (Soon I have all the necessary
38: functions) If for some reason, you use your own graphics mode,
39: you must call this function again before using the BUILD drawing
40: functions.
41:
42: drawrooms(long posx, long posy, long posz, short ang, long horiz, short cursectnum)
43: This function draws the 3D screen to the current drawing page,
44: which is not yet shown. This way, you can overwrite some things
45: over the 3D screen such as a gun. Be sure to call the drawmasks()
46: function soon after you call the drawrooms() function. To view
47: the screen, use the nextpage() function. The nextpage() function
48: should always be called sometime after each draw3dscreen()
49: function.
50: drawmasks();
51: This function draws all the sprites and masked walls to the current
52: drawing page which is not yet shown. The reason I have the drawing
53: split up into these 2 routines is so you can animate just the
54: sprites that are about to be drawn instead of having to animate
55: all the sprites on the whole board. Drawrooms() prepares these
56: variables: spritex[], spritey[], spritepicnum[], thesprite[],
57: and spritesortcnt. Spritesortcnt is the number of sprites about
58: to be drawn to the page. To change the sprite's picnum, simply
59: modify the spritepicnum array If you want to change other parts
60: of the sprite structure, then you can use the thesprite array to
61: get an index to the actual sprite number.
62:
63: engineinput();
64: This function allows the engine to adjust your position depending
65: on the status of the arrow keys, and other control keys. It
66: handles timing and clipping.
67: nextpage();
68: After a screen is prepared, use this function to view the screen.
69:
70: draw2dscreen(long posxe, long posye, short ange, long zoome,
71: short gride)
72: Draws the 2d screen - this function is a direct replacement
73: for the drawrooms() and drawmasks() functions. Be sure
74: to call either qsetmode640350() or qsetmode640480()
75: first. When switching back to 3d mode, be sure to call
76: qsetmode320200().
77: IMPORTANT NOTES:
78: 1. The overwritesprite function should only be called in
79: 3D mode. If you do this in 2D mode, junk will be
80: written to the 2D screen and a crash is possible.
81: 2. When you switch back to 3D mode, you should call the
82: permanentwritesprite functions to draw the status bar,
83: or whatever else you have to draw.
84: 3. You must call the nextpage() function in both 2D and
85: 3D modes.
86: qsetmode320200();
87: Set to the game mode and load palette (320*200*256)
88: qsetmode640350();
89: Set to the 2D map mode #1 (640*350*16)
90: qsetmode640480();
91: Set to the 2D map mode #2 (640*480*16)
92:
93: doanimations(long numtics);
94: This function animates anything you use setanimation for (like doors).
95: You should call it for every frame. Pass the number of tics (lockspeed)
96: as a parameter to it to tell how much everything should animate.
97:
98: kenchaintimer(void (__interrupt __far *datimerchainaddress)(),
99: short dachainpersecond)
100: This function makes the engine's timerhandler chain to another timer
101: handler at any specified interrupt rate. This function forces IRQ0 to
102: point to my engine's timerhandler. Clockspeed and totalclock will
103: be fixed at counting 120 per second regardless of the chaining interrupt
104: rate. If you call this function with a NULL pointer, then the engine's
105: timerhandler will not chain anymore.
106:
107: Here's how you should structure your code if you use this function:
108:
109: main()
110: {
111: initengine();
112:
113: musicon(); //Turn music on after engine
114: kenchaintimer(yourtimerhandleraddress,yourtimerrate);
115: //When IRQ0 goes off, it will now go to
116: //Ken's timer handler. Then, Ken's timer
117: (main loop) //handler will make yourtimerhandler
118: //interrupt yourtimerrate times per second
119:
120: kenchaintimer(0,0); //Stop chaining BEFORE music handler dies!
121: musicoff();
122:
123: uninitengine();
124: }
125:
126: ���������������������������������������������������������������������������Ŀ
127: � OTHER ENGINE FUNCTIONS: �
128: �����������������������������������������������������������������������������
129:
130: overwritesprite (long thex, long they, short tilenum,
131: signed char shade, char orientation, char dapalnum)
132:
133: Use this function to draw any sprites that must be drawn to the screen
134: for every single frame, such as a gun or a menu system.
135:
136: If Bit 0 of orientation = 0: (thex, they) is top-left corner
137: If Bit 0 of orientation = 1: (thex, they) is middle
138: If Bit 1 of orientation = 0: no relation to viewing window
139: If Bit 1 of orientation = 1: scale and clip to viewing window
140: If Bit 2 of orientation = 0: normal
141: If Bit 2 of orientation = 1: 50/50 transluscent!
142: If Bit 3 of orientation = 0: normal
143: If Bit 3 of orientation = 1: x-flipped
144: If Bit 4 of orientation = 0: normal
145: If Bit 4 of orientation = 1: y-flipped
146:
147: * If it works at full screen, simply set bit 1 of orientation
148: to 1, and it should automatically scale properly!
149:
150: Use this function to write sprites over the 3d view. For example,
151: you can make a menu system with this function. Be sure
152: that you call this function for every single frame after the 3d
153: view is drawn or else it will be flashed on for only 1 frame.
154: If you want x and y to be the top left corner, set the orientation
155: to 0. If you want x and y to be the middle of the sprite, set the
156: orientation to 1. The reason I included the orienation = 1 option
157: is so that if you want a sprite centered and the size of the tile
158: changes, you don't need to recompile and guess where the new top
159: left corner is. Oh yeah, and I forget to mention that if shade is
160: greater than 32, than overwritesprite does transluscence. (Try it
161: out!) This function will clip the sprite to the startumost and
162: startdmost arrays. Dapalnum refers to a palette lookup list
163: (normally 0).
164:
165: rotatesprite(long sx, long sy, long z, short a, short picnum,
166: signed char dashade, char dapalnum, char dastat)
167: (sx, sy) is the center of the sprite to draw defined as
168: screen coordinates shifted up by 16.
169: (z) is the zoom. Normal size is 65536.
170: Ex: 131072 is zoomed in 2X and 32768 is zoomed out 2X.
171: (a) is the angle (0 is straight up)
172: (picnum) is the tile number
173: if ((dastat&1) == 0) - no transluscence
174: if ((dastat&1) != 0) - transluscence
175: if ((dastat&2) == 0) - don't scale to viewing window
176: if ((dastat&2) != 0) - scale to viewing window
177: if ((dastat&4) == 0) - nuttin' special
178: if ((dastat&4) != 0) - x-flip image
179: if ((dastat&8) == 0) - clip to startumost/startdmost
180: if ((dastat&8) != 0) - don't clip to startumost/startdmost
181:
182: Ex: rotatesprite(160L<<16,100L<<16,65536,totalclock<<4,DEMOSIGN,2);
183: This example will draw the DEMOSIGN tile in the center of the
184: screen and rotate about once per second.
185:
186: permanentwritesprite (long thex, long they, short tilenum, signed char shade,
187: long cx1, long cy1, long cx2, long cy2, char dapalnum)
188: - Added permanentwritesprite function for status bars or other
189: sections of the screen that will not be overwritten by the
190: engine. The format of this function is like overwritesprite
191: except that the x and y are always top left corner, no
192: orientation variable, and no translucence.
193: The 4 last parameters (cx1, cy1) - (cx2, cy2) define a
194: rectangular clipping window of where permanentwritesprite
195: can draw to. Dapalnum refers to a palette lookup list
196: (normally 0).
197:
198: printext(long x, long y, char buffer[42], short tilenum, char invisiblecol);
199: Use this function to print text anywhere on the screen from a font
200: that you can create in EDITART. Please see my example font in
201: TILES.ART to see how I lay out the user-defined font. X ranges
202: from 0-319. Y ranges from 0-199. The buffer is the string to
203: print. Tilenum specifies which font to use. Invisiblecol tells
204: printext what color to draw the transparent pixels. If
205: invisiblecol is 255 then the transpararent pixels are still
206: transparent.
207: printnum(long x, long y, long num, short tilenum, char invisiblecol);
208: Printnum is a function call that will print a long integer (num)
209: starting at top left corner x, y. Please look at the documentation
210: for printext, since internally, printnum simply prepares a buffer
211: and calls the printext function.
212:
213: setvmode(long videomode);
214: If you look at the top of GAME.C, you will see something like this:
215: #pragma aux setvmode =\... This is how you do in-line assembler in
216: WATCOM C. All this function is doing is setting the video mode.
217: showengineinfo();
218: Use this function after setting to text mode to view some statics
219: about the engine, such as frame rate.
220: resettiming();
221: Resets timing, such as setting totalclock = 0. Also resets other
222: timers. This is for use with the showengineinfo function above.
223:
224: ksqrt(long num); returns (long)square root
225: A square root function optimized for integers. Use this function
226: only if you want to.
227: krand()
228: This simply returns a random number. You can easily set the random
229: seed by externing the randomseed variable as a long. This is useful
230: for keeping the random seed the same on multiple computers when playing
231: multi-player mode.
232:
233: getangle(long xvect,long yvect); returns (short)angle;
234: Use this function call to determine the angle between two points.
235: For example, if you want a monster to shoot a bullet towards you,
236: you would get the bullet's angle this way:
237: sprite[bullet].ang = getangle(posx-sprite[monst].x,posy-sprite[monst].y);
238:
239: lastwall(short point);
240: Use this function as a reverse function of wall[].point2. In order
241: to save memory, my walls are only on a single linked list.
242:
243: rotatepoint(long xpivot, long ypivot, long x, long y,
244: short daang, long *x2, long *y2);
245: This function is a very convenient and fast math helper function.
246: Rotate points easily with this function without having to juggle your
247: cosines and sines. Simply pass it:
248:
249: Input: 1. Pivot point (xpivot,ypivot)
250: 2. Original point (x,y)
251: 3. Angle to rotate (0 = nothing, 512 = 90� CW, etc.)
252: Output: 4. Rotated point (*x2,*y2)
253:
254: clipmove(long *x, long *y, long *z, short *sectnum, long xvect, long yvect,
255: long walldist, long ceildist, long flordist, char cliptype)
256: Moves any object (x, y, z) in any direction at any velocity and will
257: make sure the object will stay a certain distance from walls (walldist)
258: Pass the pointers of the starting position (x, y, z). Then
259: pass the starting position's sector number as a pointer also.
260: Also these values will be modified accordingly. Pass the
261: direction and velocity by using a vector (xvect, yvect).
262: If you don't fully understand these equations, please call me.
263: xvect = velocity * cos(angle)
264: yvect = velocity * sin(angle)
265: Walldist tells how close the object can get to a wall. I use
266: 128L as my default. If you increase walldist all of a sudden
267: for a certain object, the object might leak through a wall, so
268: don't do that!
269: If cliptype is 0, then the clipping is normal (Use 0 to clip you
270: and monsters). If the cliptype is 1, then the object is clipped to
271: the same things that hitscan is clipped to (use 1 for all bullets).
272:
273: Clipmove can either return 0 (touched nothing)
274: 32768+wallnum (wall first touched)
275: 49152+spritenum (sprite first touched)
276:
277: getzrange(long x, long y, long z, short sectnum,
278: long *ceilz, long *ceilhit,
279: long *florz, long *florhit,
280: long walldist, char cliptype)
281:
282: Use this in conjunction with clipmove. This function will keep the
283: player from falling off cliffs when you're too close to the edge. This
284: function finds the highest and lowest z coordinates that your clipping
285: BOX can get to. It must search for all sectors (and sprites) that go
286: into your clipping box. This method is better than using
287: sector[cursectnum].ceilingz and sector[cursectnum].floorz because this
288: searches the whole clipping box for objects, not just 1 point.
289: Pass x, y, z, sector normally. Walldist can be 128. Cliptype can be
290: 0, 1, or 2. (just like movesprite and clipmove) This function returns
291: the z extents in ceilz and florz. It will return the object hit in ceilhit
292: and florhit.
293: Ceilhit and florhit will also be either:
294: 16384+sector (sector first touched) or
295: 49152+spritenum (sprite first touched)
296:
297: updatesector(long x, long y, §num);
298: This function updates the sector number according to the x and y values
299: passed to it. Be careful when you use this function with sprites because
300: remember that the sprite's sector number should not be modified directly.
301: If you want to update a sprite's sector, I recomment using the setsprite
302: function described below.
303:
304: inside(long x, long y, short sectnum);
305: Tests to see whether the overhead point (x, y) is inside sector (sectnum)
306: Returns either 0 or 1, where 1 means it is inside, and 0 means it is not.
307:
308: copytilepiece(long tilenume1, long sourcex1, long sourcey1,
309: long xsiz, long ysiz,
310: long tilenume2, long destx1, long desty1)
311:
312: This function simply copies any section of a source tile
313: to any part of a destination tile. It will automatically
314: skip transparent pixels. It will wrap-around in the
315: source but not the destination. If for some reason
316: the destination tile gets removed from the cache, the
317: destination tile will be reset to original form. This
318: is why I had to add this second function:
319:
320: allocatepermanenttile(short tilenume, long xsiz, long ysiz)
321: This function allocates a place on the cache as permanent.
322: Right now, I reset the cache every time you call this
323: function so I would recommend calling this function
324: right after loadpics.
325:
326: makepalookup(long palnum, char *remapbuf,
327: signed char r, signed char g, signed char b,
328: char dastat)
329: This function allows different shirt colors for sprites. First prepare
330: remapbuf, which is a 256 byte buffer of chars which the colors to remap.
331: Palnum can be anywhere from 1-15. Since 0 is where the normal palette is
332: stored, it is a bad idea to call this function with palnum=0.
333: In BUILD.H notice I added a new variable, spritepal[MAXSPRITES].
334: Usually the value of this is 0 for the default palette. But if you
335: change it to the palnum in the code between drawrooms() and drawmasks
336: then the sprite will be drawn with that remapped palette. The last 3
337: parameters are the color that the palette fades to as you get further
338: away. This color is normally black (0,0,0). White would be (63,63,63).
339: if ((dastat&1) == 0) then makepalookup will allocate & deallocate
340: the memory block for use but will not waste the time creating a palookup
341: table (assuming you will create one yourself)
342:
343: copytilepiece(long walnume1, long x1, long y1, long xsiz, long ysiz,
344: long walnume2, long x2, long y2, char shadeoffs);
345: Copies section of tile 1 (walnume1) with top-left corner (x1,y1) and
346: rectangular size (xsiz, ysiz) to top-left corner (x2, y2) of tile 2
347: (walnume). You can animate tiles with this function. For example, with
348: this function, you can make a slot machine like in Ken's Labyrinth or an
349: electronic sign with text sliding from right to left.
350:
351: loadtile(short tilenume);
352: This function will load the tile, tilenum, into the artwork cache. A
353: tile is not in the cache if (waloff[tilenum] == -1). If
354: (waloff[tilenum] >= 0) then it is in the cache, and you don't need to call
355: this function.
356:
357: precache();
358: This function will go through the tilenums of all sectors, walls, and
359: sprites and call loadtile() on them. This function will not cache in some
360: tiles of animations since their tilenums may not all be in the structures.
361:
362: hitscan(long xstart, long ystart, long zstart, short startsectnum,
363: long vectorx, long vectory, long vectorz,
364: short *hitsect, short *hitwall, short *hitsprite,
365: long *hitx, long *hity, long *hitz);
366:
367: Pass the starting 3D position:
368: (xstart, ystart, zstart, startsectnum)
369: Then pass the 3D angle to shoot (defined as a 3D vector):
370: (vectorx, vectory, vectorz)
371: Then set up the return values for the object hit:
372: (hitsect, hitwall, hitsprite)
373: and the exact 3D point where the ray hits:
374: (hitx, hity, hitz)
375:
376: How to determine what was hit:
377: * Hitsect is always equal to the sector that was hit (always >= 0).
378:
379: * If the ray hits a sprite then:
380: hitsect = thesectornumber
381: hitsprite = thespritenumber
382: hitwall = -1
383:
384: * If the ray hits a wall then:
385: hitsect = thesectornumber
386: hitsprite = -1
387: hitwall = thewallnumber
388:
389: * If the ray hits the ceiling of a sector then:
390: hitsect = thesectornumber
391: hitsprite = -1
392: hitwall = -1
393: vectorz < 0
394: (If vectorz < 0 then you're shooting upward which means
395: that you couldn't have hit a floor)
396:
397: * If the ray hits the floor of a sector then:
398: hitsect = thesectornumber
399: hitsprite = -1
400: hitwall = -1
401: vectorz > 0
402: (If vectorz > 0 then you're shooting downard which means
403: that you couldn't have hit a ceiling)
404:
405: neartag(long x, long y, long z, short sectnum, short ang, //Starting position & angle
406: short *neartagsector, //Returns near sector if sector[].tag != 0
407: short *neartagwall, //Returns near wall if wall[].tag != 0
408: short *neartagsprite, //Returns near sprite if sprite[].tag != 0
409: long *neartaghitdist, //Returns actual distance to object (scale: 1024=largest grid size)
410: long neartagrange, //Choose maximum distance to scan (scale: 1024=largest grid size)
411: char tagsearch) //1-lotag only, 2-hitag only, 3-lotag&hitag
412: Neartag works sort of like hitscan, but is optimized to
413: scan only close objects and scan only objects with
414: tags != 0. Neartag is perfect for the first line of your space bar code.
415: It will tell you what door you want to open or what switch you want to
416: flip.
417:
418: cansee(long x1, long y1, long z1, short sectnum1,
419: long x2, long y2, long z2, short sectnum2); returns 0 or 1
420: This function determines whether or not two 3D points can "see" each
421: other or not. All you do is pass it the coordinates of a 3D line defined
422: by two 3D points (with their respective sectors) The function will return
423: a 1 if the points can see each other or a 0 if there is something blocking
424: the two points from seeing each other. This is how I determine whether a
425: monster can see you or not. Try playing DOOM1.DAT to fully enjoy this
426: great function!
427:
428: setanimation(long *animptr, long thegoal, long thevel);
429: This is a function for your convenience that will animate a long
430: variable, such as sector[].floorz for platforms, or sector[].ceilingz
431: for doors. All you do is pass it the long pointer into memory, specifying
432: which long variable is to be animated; you also pass the goal (long value
433: to animate towards), and the velocity at which the variable is animated.
434: Velocity = 128 is a normal speed door. You may also modify the animation
435: arrays directly if you wish:
436:
437: The animation arrays are as follows:
438: long *animateptr[MAXANIMATES], animategoal[MAXANIMATES];
439: long animatevel[MAXANIMATES], animatecnt;
440:
441: getanimationgoal(long animptr);
442: Check to see if a certain variable in memory is already being animated
443: by the engine. If so, an index into the animation arrays is returned,
444: else -1 is returned. This is function is useful when you are press
445: space bar near a door, and it is already animating, you simply want
446: to reverse its direction.
447:
448: dragpoint(short wallnum, long newx, long newy);
449: This function will drag a point in the exact same way a point is dragged
450: in 2D EDIT MODE using the left mouse button. Simply pass it which wall
451: to drag and then pass the new x and y coordinates for that point.
452: Please use this function because if you don't and try to drag points
453: yourself, I can guarantee that it won't work as well as mine and you
454: will get confused. Note: Every wall of course has 2 points. When you
455: pass a wall number to this function, you are actually passing 1 point,
456: the left side of the wall (given that you are in the sector of that wall)
457: Got it?
458:
459: nextsectorneighborz(short sectnum, long thez, short topbottom, short direction);
460: This function searches z-coordinates of neighboring sectors to find the
461: closest (next) ceiling starting at the given z-coordinate (thez).
462: For example, if you want to find the goal z-coordinate when opening a
463: door, you might want the door to stop at the next closest neighboring
464: ceiling z-coordinate. You can get the z-coordinate this way:
465:
466: newz = sector[nextsectorneighborz(sectnum,startz,-1,-1)].ceilingz
467:
468: topbottom (3rd parameter) -1 = search ceilings
469: 1 = search floors
470: direction (4th parameter) -1 = search upwards
471: 1 = search downwards
472:
473: screencapture(char *filename)
474: Capture the screen and save it as a .BMP file. I don't know why my
475: .BMP format isn't compatible with other programs.
476:
477: ���������������������������������������������������������������������������Ŀ
478: � SPRITE FUNCTIONS: �
479: �����������������������������������������������������������������������������
480:
481: insertsprite(short sectnum, short statnum); //returns (short)spritenum;
482: Whenever you insert a sprite, you must pass it the sector
483: number, and a status number (statnum). The status number can be any
484: number from 0 to MAXSTATUS-1. Insertsprite works like a memory
485: allocation function and returns the sprite number.
486:
487: deletesprite(short spritenum);
488: Deletes the sprite.
489:
490: changespritesect(short spritenum, short newsectnum);
491: Changes the sector of sprite (spritenum) to the
492: newsector (newsectnum). This function may become
493: internal to the engine in the movesprite function. But
494: this function is necessary since all the sectors have
495: their own doubly-linked lists of sprites.
496:
497: changespritestat(short spritenum, short newstatnum);
498: Changes the status of sprite (spritenum) to status
499: (newstatus). Newstatus can be any number from 0 to MAXSTATUS-1.
500: You can use this function to put a monster on a list of active sprites
501: when it first sees you.
502:
503: setsprite(short spritenum, long newx, long newy, long newz);
504: This function simply sets the sprite's position to a specified
505: coordinate (newx, newy, newz) without any checking to see
506: whether the position is valid or not. You could directly
507: modify the sprite[].x, sprite[].y, and sprite[].z values, but
508: if you use my function, the sprite is guaranteed to be in the
509: right sector.
510:
511: movesprite(short spritenum, long xchange, long ychange, long zchange,
512: long ceildist, long flordist, char cliptype, long numtics)
513: This function moves the sprite given by spritenum by the 3
514: increments, xchange, ychange, and zchange. If cliptype is 0, then
515: the clipping is normal (Use 0 to clip you and monsters). If the
516: cliptype is 1, then the object is clipped to the same things that
517: hitscan is clipped to (use 1 for all bullets).
518: Movesprite can either return 0 (touched nothing)
519: 16384+sectnum (ceiling/floor first touched)
520: 32768+wallnum (wall first touched)
521: 49152+spritenum (sprite first touched)
522:
523: getspritescreencoord(short spritesortnum, long *scrx, long *scry)
524: This function returns the actual screen coordinates of a sprite. It
525: is useful for locking on to a target. Use this function between
526: drawrooms and drawmasks. Note that spritesortnum is the index into the
527: spritesortcnt arrays, NOT the normal sprite arrays. Scrx and scry are
528: actual screen coordinates ranging from 0-319 and 0-199 respectively.
529:
530: ���������������������������������������������������������������������������Ŀ
531: � MULTIPLAYER FUNCTIONS (multi.obj) �
532: �����������������������������������������������������������������������������
533:
534: initmultiplayers(option[4],option[5]);
535: Call this right after initengine. Pass option[4] and option[5]
536: exactly the way I have it written here. (option[4] is the COM1-COM4,
537: network option and option[5] is the com speed selection option)
538:
539: uninitmultiplayers();
540: Call this right before uninitengine.
541:
542: sendlogon();
543: Use this function after everything's initialized, but before you
544: go into the main game loop. Right after you call sendlogon(), you
545: should run a loop that will wait until a specified number of players.
546: Here's some example code:
547:
548: sendlogon();
549: while (numplayers < waitplayers)
550: {
551: getpackets();
552: }
553: screenpeek = myconnectindex;
554:
555: Getpackets reserves the packet header range from 200-255. If you
556: keep calling getpackets after sendlogon, the numplayers variable will
557: automatically be incremented when other people log on.
558:
559: sendlogoff();
560: Call this before leaving, before uninitializing the multiplayer
561: code.
562:
563: sendpacket (short otherconnectindex, char *bufptr, short bufleng)
564: For COM(modem) communications, the otherconnectindex doesn't matter.
565: For network communcations, you can specify which computer to send
566: to by setting otherconnectindex to the proper index number. You
567: can also do a broadcast by setting otherconnectindex to -1.
568: Also pass the buffer and length parameters.
569:
570: short getpacket (short *otherconnectindex, char *bufptr) returns bufleng
571: When using getpacket, first check the value it returns.
572: If the value is 0, then the buffer length is 0 which means there
573: are no packets available. If the buffer length is greater than
574: 0, then use that value as the length of the buffer. Getpacket also
575: tells you what computer the message was received from -
576: (otherconnectindex).
577:
578: ���������������������������������������������������������������������������Ŀ
579: � DIGITIZED SOUND FUNCTIONS: �
580: �����������������������������������������������������������������������������
581: Note: If you want to write your own digitized sound driver, simply delete
582: these functions from GAME.C.
583:
584: initsb();
585: Initializes the digitized sound routines. You need to call this
586: only once at the beginning of the program. Currently, the
587: sample rate is 11,025 Hz.
588:
589: wsay(char *filename, long freq, char volume);
590: Play the sound file at the given frequency and volume. If you
591: set freq = 4096, the sound will play at normal frequency (given
592: the sound was also recorded at 11025 Hz) To play the sound an
593: octave higher, for example, set freq = 8192. Volume ranges from
594: 0 (silent) to 255 (full volume). Ex: wsay("blowup.wav",4096L,255);
595:
596: uninitsb();
597: Turns the speaker off, so sounds don't continue playing while
598: your back in DOS.
599:
600: ���������������������������������������������������������������������������Ŀ
601: � MUSIC FUNCTIONS: �
602: �����������������������������������������������������������������������������
603: Note: If you want to write your own music driver, simply delete these
604: functions from GAME.C. The BUILD engine uses interrupt vector 0x8 (IRQ0)
605: and that may complicate things. If you like my music, perhaps I can send
606: you my MIDI sequencer program (It requires MPU-401, and TSENG-ET4000 SVGA,
607: but could be standardized if there's enough demand).
608:
609: loadmusic(char *filename);
610: Loads the given song into memory. Be sure INSTS.DAT is in the
611: current directory. If no extension is given, then .KSM will be
612: appended to the filename. You should use this function only when
613: the music is off.
614: musicon();
615: Enable the playing of music. Use this only after loadmusic has
616: been called.
617: musicoff();
618: Disable the playing of music. Be sure to call this before quitting
619: to DOS.
620:
621: ���������������������������������������������������������������������������ͻ
622: ���������������������������������������������������������������������������
623: ���������������������������������������������������������������������������
624: ���������������������������������������������������������������������������
625: ���������������������������������������������������������������������������
626: ���������������������������������������������������������������������������
627: ���������������������������������������������������������������������������
628: ���������������������������������������������������������������������������
629: ���������������������������������������������������������������������������
630: ���������������������������������������������������������������������������ͼ
631:
632: ���������������������������������������������������������������������������Ŀ
633: � BUILD Revision History: �
634: �����������������������������������������������������������������������������
635: 2/6/94 - Added this revision thing.
636: - Setup program.
637: - A faster new mode for standard VGAs called chain mode.
638: ������������������������������������������������������������������������������
639: 2/8/94 - Fixed chain mode with groudraws.
640: - Added sector joining in 2D EDIT MODE - press J on first sector.
641: Then press J again on sector to join with. Attributes will be
642: taken from first sector. Possible bugs.
643: - Improved controls for slower computers.
644: - Made timer interrupt rate 120/second instead of 240/second.
645: ������������������������������������������������������������������������������
646: 2/9/94 - Started to work on status bar in 2D EDIT MODE.
647: - Added special optimization for the Western Digitial (Paradise)
648: chipset just like with TSENG ET4000.
649: ������������������������������������������������������������������������������
650: 2/10/94 - Added a door attribute to sectors. To make a sector a door,
651: press "D" on the ceiling of the sector in 3D EDIT MODE. For
652: the door to work, the ceiling of the door sector must be a
653: tiny bit lower than lowest neighboring ceiling. To open/close
654: the door, you may press the space bar. Note: Space Bar is also
655: used for copy and paste in 3D EDIT MODE. You may have to go
656: into game mode to test out the doors for now.
657: - Added a wall orientation attribute to walls. This attribute is
658: used especially in conjunction with doors. So far, you have
659: been working with walls that are start from the top. For
660: example, if you hold down 2/8 on the keypad in 3D EDIT MODE,
661: the wall always starts from the top. But for doors, you
662: sometimes need walls to start from the bottom. To do this,
663: press "O" (for orientation) on the wall, and it will now
664: start from the bottom.
665: ������������������������������������������������������������������������������
666: 2/12/94 - Fixed some bugs for sprites. Sprites don't disappear anymore.
667: Now you will pick up all sprites when running over them.
668: Monsters will not stop shooting anymore.
669: - Made the sound blaster sounds have a 1-sound cache. That is, if
670: the same sound is to be played several times in a row, it will
671: only be loaded once.
672: - Added *.GIF format support to EDITART for 320*200 size images.
673: - Changed the PASTE key in 3D EDIT MODE from Space bar to Left
674: Enter because the Space bar conflicted with opening doors.
675: - Added music as an option in the setup program. To run the music,
676: you need INSTS.DAT and a song file with a .KSM extension.
677: - Split the editor from the game.
678: BUILD is now the map editor - you don't need BUILD.C anymore.
679: GAME is now the actual game that you will be programming.
680: I am giving you GAME.C to work with. Its code is simpler
681: than before because there are no more editing function
682: calls in it.
683: - Sprites move in a straight line now until they hit walls. When
684: they hit walls, they pick a new angle to travel in.
685: - Remember that tiny little guy with the "Al" on his shirt?
686: Next time you're in DOOM1.DAT, try shooting him. Then look
687: at the code in GAME.C.
688: - In EDITART, when you press, "u", you now select filenames with
689: the arrow keys and enter rather than having to type in
690: the exact filename.
691: - Board maps now have extension .MAP and artwork files now have
692: extension .ART to help distinguish between the different types
693: of files.
694: ������������������������������������������������������������������������������
695: 2/22/94 - Fixed small bug with EDITART not loading right when names.h
696: existed with no names defined.
697: - You can now edit new boards by typing:
698: BUILD <file that doesn't exist> like "BUILD NEWBOARD"
699: - Added ALT-S in 2D EDIT Mode to change a whole white loop inside a
700: sector to a red loop.
701: - When viewing the tiles (pressing "v") you can now use PGUP/PGDN.
702: - Added a message bar in 2D EDIT Mode.
703: - Added TAB and L.ALT-TAB keys to view all the attributes of a
704: sector, wall, or sprite (see above documentation).
705: - Debugged and bullet-proofed ALT-S.
706: - Fixed a bug that doesn't allow you to drag points with number
707: greater than 1023. (There can actually be 4096 walls and 1024
708: sectors, and 4096 sprites currently, an easy thing to increase)
709: - Changed overwritesprite function paramaters. If you are using it
710: in your c file, you must change it! Now it looks like this:
711:
712: overwritesprite (long x, long y, short tilenum, char shade,
713: char orientation);
714:
715: If orientation = 0: x and y are the top left corner.
716: If orientation = 1: x and y are the middle (like before).
717: - Added permanentwritesprite function for status bars or other
718: sections of the screen that will not be overwritten by the
719: engine. When using this function, you may want to modify the
720: STARTUMOST / STARTDMOST arrays. The format of this function is
721: like overwritesprite except that the x and y are always top
722: left corner, no orientation variable, and no translucence.
723:
724: permanentwritesprite (long x, long y, short tilenum, char shade);
725:
726: - Added an attribute to the printext and printnum functions. Please
727: change these function if you use them in your program. The
728: current formats are:
729:
730: printext(long x, long y, char buffer[42], short tilenum,
731: char invisiblecol)
732: printnum(long x, long y, long num, short tilenum,
733: char invisiblecol);
734:
735: Invisiblecol tells printext what color to draw the transparent
736: pixels. If invisiblecol is 255 then the transpararent pixels are
737: still transparent.
738: ������������������������������������������������������������������������������
739: 2/26/94 - Completely reprogrammed EDITART.
740: IMPORTANT: PLEASE RUN CONVART.EXE ON ALL ARTWORK FILES! (If you have not
741: already). It will convert PICS.ART in the old format to
742: TILES.ART in the new format, so you may have to do some
743: renaming when converting artwork and also rename the loadpics
744: line in your C file. BUILD WILL NOT RUN UNLESS YOU DO THIS!
745: With the new artwork file, the tiles can now be any size from
746: 1*1 to 1024*240 and they no longer have to be powers of 2.
747: This feature allows parallaxing skies that are 1024 pixels wide
748: to cover all 360�, or 320 pixel wide status bars. It can also
749: be used to display 320*200 title screens.
750: - When pressing 'U' in EDITART, you can now change directories
751: and the current loading directory will be remembered.
752: - When pressing 'U' in EDITART, you can press the mouse button to
753: readjust the size of the tile.
754: - When pressing 'U' in EDITART, press ENTER for an automatic
755: palette conversion or press SPACE BAR for no conversion.
756: - Walls that are Blocked ('B') in BUILD are now shown in pink.
757: If the wall does not show pink in your board, just press
758: 'B' twice to permanently fix it.
759: - Made smooshiness values easier to work with. Hold down 5 on the
760: keypad with 2/4/6/8 to align the walls to multiples of the
761: tile that is used. Also, when you do Tab and L.Enter for
762: Copy&Paste, the y-repeat values stay the same, and the
763: x-repeat values are adjusted so the pixels of the bitmaps
764: have a square-aspect ratio.
765: - Added masked walls. But since they don't quite work perfectly
766: yet, and they are extremely hard to edit now, so for now, just
767: enjoy the technologiy in DOOM1.MAP. Don't worry - you'll get
768: your hands on this soon!
769: - Fixed the "earthquake" effect on really high walls. The walls
770: will not move up and down, but the pixel fuzzyness bug is
771: still in there.
772: - Put door variables and tile information into BUILD.H for you to
773: play around with.
774: - Made walls, ceilings, and floors also work with the animation
775: attribute in EDITART.
776: ������������������������������������������������������������������������������
777: 3/2/94 - Made power of 2 size tiles work with ceilings & floors.
778: - When using different size ceilings & floors, made an option in
779: 3D EDIT MODE. If you want a tile to be smooshed into the normal
780: 64*64 area, press 'E' to unExpand the tile.
781: - Groudraws now look more cubical than before. (But be careful of
782: crashing with them for now)
783: - IMPORTANT: Changed the Board format. If you tried running BUILD
784: before reading this, and it didn't work, shame on you! You
785: should always look at the history section of BUILD.TXT first!
786: Since from now on, I am writing Board/Art converters, I am
787: giving you CONVMAP.EXE to convert maps. You can type either:
788: C:\BUILD>convmap house.map
789: to convert an individual map or:
790: C:\BUILD>for %i in (*.map) do convmap %i
791: to convert all the maps in a directory.
792:
793: - IMPORTANT: Sprites are now on 2 different sets of doubly-linked
794: lists. The big advantage of this method is that when sprites
795: are deleted, there can be holes in the sprite list with
796: no slow down. Before I used to have linked lists for each
797: sector pointing to all the sprites in it. Well, I have updated
798: that and added more linked lists that tell whether sprites
799: are active or inactive (not a fun thing to progam) But not
800: to worry, you don't have to deal with changing the linked
801: lists, thanks to my very easy function calls. YOU WILL
802: HAVE TO CHANGE YOUR CODE TO SUPPORT THE NEW LINKED LISTS.
803: You should know how to search through each list. See BUILD.H
804: for a detailed description of how the linked lists work, and
805: see the top of this file for description of the new sprite
806: function calls.
807:
808: insertsprite(short sectnum, short statnum);
809: deletesprite(short spritenum);
810: changespritesect(short spritenum, short newsectnum);
811: changespritestat(short spritenum, short newstatnum);
812:
813: In your code, you will have to change the following:
814: firstsprite[spritenum] --> headspritesect[spritenum]
815: sprite[spritenum].point2 --> nextspritesect[spritenum]
816:
817: Also, you should change the part of your main loop that scans
818: through all the active sprites to look more like this:
819:
820:
821: i = headspritestat[1]; //head of active sprite list
822: while (i != -1)
823: {
824: nexti = nextspritestat[i]; //back up next sprite in case current
825: //one is deleted.
826:
827: //your code goes here (use i as the sprite number)
828:
829: spriteisdeletedskip:
830: i = nexti; //go to next sprite
831: }
832:
833:
834:
835: - Added tagging (naming) to any sector, sprite, or wall. That means
836: you can change a tag in the BUILD editor by pressing T with the
837: mouse cursor on the highlighted sector. And in GAME.C, you
838: can access the tag this way:
839: sector[sectnum].tag;
840: sprite[spritenum].tag;
841: wall[wallnum].tag;
842: Note: All 3 types of tags are long integers, but in BUILD.C
843: you can only make them short integers. I am planning to
844: let you use the upper 16 bits of the tag byte as use for
845: you only. (like permanently unreserved bits)
846: - Added serial link. But it doesn't work very well yet. You
847: may have to try going into GAME several times before it works.
848: ������������������������������������������������������������������������������
849: 3/15/94 - Fixed maskable walls - now sort out with sprite better. Easier
850: to edit. Simply press 'M' at a place where a maskable wall
851: should be (like where you normally press 'B' for blocking)
852: - Can flip walls, masked walls, and sprites x-wise by pressing
853: 'F' in 3D EDIT MODE. Also, it is possible to save space in
854: sprite rotations, by flipping it x-wise by programming one of
855: the bits in sprite[].cstat.
856: - A few other minor things, but I forgot what they were.
857: ������������������������������������������������������������������������������
858: 3/19/94 - Fixed one of the many crashing bugs.
859: For Duke Nukem III team:
860: CITY.MAP will not crash anymore with new version. The
861: reason it crashed was because in your TILES.ART, you had
862: either ANMFD:0, ANMBK:0, or OSCI:0. That caused a MOD 0
863: in my animation routine. I bullet-proofed that. How about
864: fixing tiles #34, #112, or #114 in your TILES.ART.
865: - Wrote divide by zero handler. Now if there is a divide by zero,
866: BUILD goes back into text mode and fills the screen with
867: /0/0/0/0/..., then gives a DOS prompt. (In other words, you
868: don't have to type "MODE CO80" anymore for /0 crashes)
869: - Optimized routines in assembly for 486's using my great new
870: Intel 32-bit optimizing techniques book that dad got for me.
871: - Fixed ALT-S in BUILD so ANY white loop can be converted into a
872: red loop except for the 1 and only 1 outermost white loop.
873: - FINALLY! Splitsector bug is fixed! You can now split a very
874: complicated sector with tons of sectors inside it or with
875: plenty of sprites. Also sprites will not get deleted
876: spontaneously with split sector any more.
877: - Ctrl-Enter in 3D EDIT MODE is like the normal Enter paste key,
878: but Ctrl-Enter pastes the attributes to an entire loop of
879: walls (if a wall is highlighted).
880: ������������������������������������������������������������������������������
881: 3/22/94 - Added doors that open left and right. See sector[].tag #9 in the top
882: of this file for details - also look at my board, NUKELAND.MAP,
883: in BUILD to see how to make this type of door.
884: - Increased the number of status lists. You may recall my active /
885: inactive sprite lists called headspritestat, prevspritestat,
886: and nextspritestat. Don't worry - you will NOT have to
887: change any of your code. The only thing I changed is now
888: you can have 1024 different lists of sprites rather than just
889: 2 lists if you want to use them. For example, you might want
890: to run through all the brown monsters on the board. Instead
891: of putting all different types of monsters on the active
892: list, it is faster to have a separate list just for brown
893: monsters. Use your imagination!
894: ������������������������������������������������������������������������������
895: 3/31/94 - Fixed some palette problems with EDITART. Now when you press 'P'
896: in 'U' mode, the palette of all the existing tiles are
897: converted to the new palette. Also the text colors should
898: be similar colors on different palettes now.
899: - Changed bit 0 of sprite[].cstat to the hitscan checking / ignoring
900: bit. You should set this bit to 1 for monsters, 0 for
901: bullets, 0 for pick-upable objects like coins, and 1 for
902: objects like columns. Right now, (Since it's not in the
903: BUILD editor), you must set these bits in your code right
904: after you load the board.
905: - I did not document the neartagsector, neartagwall, and
906: neartagsprite very well, so if you don't know how to use
907: them alreay, please read on. These 3 variables are modified
908: by the engine every time you call draw3dscreen(). These
909: variables are usually -1. These variables will be >= 0 if
910: all of these cases are true:
911: 1. You are looking at a wall, sprite, or sector.
912: 2. You are close enough to the wall, sprite, or sector
913: to be able to use the action key with it.
914: 3. The tag of the wall, sprite, or sector is greater or
915: equal to 1.
916: As you can see, neartagsector makes a perfect variable for
917: detecting whether or not you are opening a door. You can
918: also use neartagwall for switches on walls. Also, you can
919: use neartagsprite for sprites that are switches.
920: - PROGRAMMERS: PLEASE MAKE THESE EASY CODE MODIFICATIONS:
921: I reversed the way variables are stored in BUILD.H.
922: Now the variables will be local to the ENGINE and externed
923: to GAME. Before they were local to GAME and externed to the
924: engine. All you have to do is this:
925: 1. You can remove the #define MAIN if you want to.
926: 2. Delete the externs declarations that I used to have
927: in the beginning of GAME.C, because I put them in
928: BUILD.H. I will try not to put externs in the GAME
929: in the future to save you the time of copying and
930: pasting code. Here is a list of externs I moved:
931:
932: EXTERN short neartagsector, neartagwall, neartagsprite;
933: EXTERN long *animateptr[MAXANIMATES], animategoal[MAXANIMATES];
934: EXTERN long animatevel[MAXANIMATES], animatecnt;
935: EXTERN short tilesizx[MAXTILES], tilesizy[MAXTILES];
936: EXTERN long numtiles, picanm[MAXTILES], waloff[MAXTILES];
937: - Added a global parallaxing sky type variable. Now I have 3
938: different types of parallaxing skies. Here they are:
939:
940: 0 - Totally flat parallaxing sky.
941: 1 - X-only stretching parallaxing sky (This is what DOOM uses).
942: 2 - X- and Y- stretching parallaxing sky. (This is what BUILD
943: uses by default)
944: A good place to set the parallaxing sky is right after you
945: call initengine().
946: - Added local tile selection to the BUILD editor. This means
947: that when you press V on a sprite, you will see only the
948: sprites that are on the level so far. If you want to use
949: a sprite that is not already used on the current board, press
950: V again and you will be able to select from the huge list
951: that you are used to from before. The local tile list will
952: be sorted according to how much each tile is used on the
953: current board. Note that the local tile list will be
954: different depending where the mouse cursor was left when you
955: pressed V (or H).
956: ������������������������������������������������������������������������������
957: 4/4/94 - Changed the way ART files work. YOU MUST READ THIS:
958: There are some two easy things that you must do 2 things before
959: you can use the new engine:
960:
961: 1. Type CONVART1.EXE to convert your ARTWORK to the new
962: format. (If I forgot to send this file to you, please call
963: and torture me.) Now, instead of everything being stored
964: in one huge file, TILES.ART, I am splitting the artwork into
965: several files each holding 256 tiles in it. This will allow
966: you to make infinitely large artwork files in EDITART.
967:
968: 2. In GAME.C, you must change the line,
969: loadpics("tiles.art");
970: to:
971: loadpics("tiles000.art");
972: All you have to give loadpics is the first filename of your
973: artwork, and the engine will automatically know how to
974: modify the 3 digits at the end and load all the artwork
975: files properly.
976: ������������������������������������������������������������������������������
977: 4/5/94 - Fixed the "fuzzy" pixels on high walls. Now you make walls as
978: high as skyscrapers, and when you look at it up close, the
979: pixels will still look like perfect rectangles. Note: This
980: fix may require you to press 'O' in 3D EDIT MODE to put
981: your boards back to normal.
982: - When you pressed ENTER on weird-sized tiles, sometimes in the old
983: version the pixels would not be square aspect ratio. Now
984: when you press ENTER, they will be.
985: - You can now set the starting position in 2D EDIT MODE with the
986: Scroll Lock key. The starting position will look like a
987: brown arrow, and your current position will look like a
988: white arrow. Now you don't have to keep returning to start
989: when you save your board.
990: - Added some new things to the structures - guess what this means?
991: CONVMAP3! THE NEW OBJ'S and BUILD will NOT work until you
992: run CONVMAP3. (Please call if I forgot to give
993: you this file)
994: Notice that I added these things to the structures:
995:
996: sectortype:
997: bit 2 of ceilingstat&floorstat:
998: 1 = North/South panning, 0 = East/West panning
999: char ceilingpanning, floorpanning;
1000: walltype:
1001: bit 6 of cstat
1002: 1 = Vertical panning, 0 = Horizontal panning
1003: char panning;
1004: short overpicnum;
1005: spritetype:
1006: char *extra;
1007:
1008: Now an explanation of each:
1009: To the sector structure, I added the capability to pan
1010: the floors and ceilings. Usually ceilingpanning and
1011: floorpanning are set to 0. For example, a good way to make
1012: an earthquake would be to randomly increment or decrement
1013: to panning values. To allow you to pan the ceilings or
1014: floors at any of the standard 90 degree angles, I made
1015: bit 2 of sectortype's ceilingstat/floorstat byte choose
1016: whether the ceilingpanning/floorpanning byte should move
1017: the ceiling/floor North/South or East/West.
1018: To the wall structure, I added panning also. Bit 6
1019: of cstat and the panning values work in the same as the
1020: ceilings and floors.
1021: To the sprite structure, I added only 1 variable.
1022: The "extra" pointer is intended for your use only, so you
1023: can have the sprite's structure extended if you so desire.
1024: ������������������������������������������������������������������������������
1025: 4/6/94 - In 2D EDIT MODE, you can now press ESC to get a message in the
1026: message bar that says this:
1027:
1028: (N)ew, (L)oad, (S)ave, (Q)uit
1029:
1030: And it all works too. (Press ESC to cancel)
1031: Loading lets you select the file just like 'U' in EDITART.
1032: - The old version of BUILD had the coordinate system all screwed
1033: up in 2D EDIT MODE. I fixed this. Included with
1034: CONVMAP3.EXE is a conversion utility that will make your
1035: boards have the same orientation as in the older BUILD
1036: editors. If you don't care if the whole map gets rotated
1037: in the 2D editor, then press N.
1038: ������������������������������������������������������������������������������
1039: 4/7/94 - Changed the way Orientation works ('O' in 3D EDIT MODE)
1040:
1041: Now, when you draw a normal door in BUILD, you do NOT have to
1042: press 'O' everywhere to make the walls of the door move right.
1043: Now, the default is that everything moves right. Here's a
1044: detailed description of how the new orientation works:
1045:
1046: For white lines (no neighboring sector):
1047:
1048: orientation = 0 (default) means picture is aligned with
1049: sector[].ceilingz.
1050: orientation = 1 means picture aligned with sector[].floorz.
1051:
1052: For red lines (has a neighboring sector):
1053:
1054: orientation = 0 (default) means picture is aligned with
1055: either the ceilingz or floorz of the next sector.
1056: orientation = 1 means picture aligned with
1057: sector[].ceilingz.
1058:
1059: Don't worry if you don't understand the detailed description.
1060: Just know that it's better this way. I have included the
1061: proper conversions in CONVMAP3.EXE.
1062: - Added wall&ceiling x-panning keys to the 3D EDIT MODE. Press
1063: the , or . keys to pan a wall or ceiling left or right. You
1064: can hold down the 5 key on the keypad to align at every eighth
1065: panning value. (Just like with 2,4,6,8).
1066: - Made TAB&ENTER in 3D EDIT MODE also copy the CSTAT byte of
1067: the wall's attributes. This means that attributes such as
1068: the block attribute, 1-way wall attribute, orientation,
1069: and x-flipping attribute are also copied & pasted.
1070: - Added a new function, cansee.
1071:
1072: cansee(long x1, long y1, long z1, short sectnum1,
1073: long x2, long y2, long z2, short sectnum2)
1074:
1075: All you do is pass it the coordinates of a 3D line
1076: and the respective sectors of each point of the line.
1077: The function will return a 1 if the points can see each
1078: other or a 0 if there is something blocking the two points
1079: from seeing each other. This is how I determine whether
1080: a monster can see you or not. Try playing DOOM1.DAT with
1081: digitized sound enabled to fully enjoy this great new
1082: function!
1083: ������������������������������������������������������������������������������
1084: 4/12/94 - Fixed HITSCAN function. Since it works a little differently
1085: and the parameters are different, let me describe how the
1086: new hitscan works:
1087:
1088: hitscan(long xstart, long ystart, long zstart, short startsectnum,
1089: long vectorx, long vectory, long vectorz,
1090: short *hitsect, short *hitwall, short *hitsprite,
1091: long *hitx, long *hity, long *hitz);
1092:
1093: Pass the starting 3D position:
1094: (xstart, ystart, zstart, startsectnum)
1095: Then pass the 3D angle to shoot (defined as a 3D vector):
1096: (vectorx, vectory, vectorz)
1097: Then set up the return values for the object hit:
1098: (hitsect, hitwall, hitsprite)
1099: and the exact 3D point where the ray hits:
1100: (hitx, hity, hitz)
1101:
1102: How to determine what was hit:
1103: * Hitsect is always equal to the sector that was hit
1104: (always >= 0).
1105:
1106: * If the ray hits a sprite then:
1107: hitsect = thesectornumber
1108: hitsprite = thespritenumber
1109: hitwall = -1
1110:
1111: * If the ray hits a wall then:
1112: hitsect = thesectornumber
1113: hitsprite = -1
1114: hitwall = thewallnumber
1115:
1116: * If the ray hits the ceiling of a sector then:
1117: hitsect = thesectornumber
1118: hitsprite = -1
1119: hitwall = -1
1120: vectorz < 0
1121: (If vectorz < 0 then you're shooting upward which means
1122: that you couldn't have hit a floor)
1123:
1124: * If the ray hits the floor of a sector then:
1125: hitsect = thesectornumber
1126: hitsprite = -1
1127: hitwall = -1
1128: vectorz > 0
1129: (If vectorz > 0 then you're shooting downard which means
1130: that you couldn't have hit a ceiling)
1131:
1132: - Added a position window to the bottom of the menu in 2D EDIT
1133: MODE. It shows the posx, posy, and ang variables.
1134: ������������������������������������������������������������������������������
1135: 4/14/94 - Overwritesprite now clips to the startumost / startdmost arrays.
1136: Now the only way to write to the status bar is with
1137: the permanentwritesprite function.
1138:
1139: - ATTENTION PROGRAMMERS! I Split draw3dscreen() into 2 separate
1140: function calls.
1141:
1142: old: draw3dscreen(); //Draws walls, ceilings, floors, p-skies
1143: // groudraws, sprites, and masked walls.
1144:
1145: new: drawrooms(); //Draws walls, ceilings, floors, p-skies
1146: // and groudraws.
1147: drawmasks(); //Draws sprites and masked walls.
1148:
1149: The reason I split draw3dscreen was so you could manipulate only
1150: the sprites that the engine is going to draw to the screen
1151: before the sprites are actually drawn.
1152:
1153: - I think I may have fixed that darn sector line bug! Before, the
1154: bug usually appeared when you were on a (red) sector line where
1155: the ceiling and floor of the sector were very far from each
1156: other. This overflowed some really high positive values into
1157: the negative range and vice versa.
1158: ������������������������������������������������������������������������������
1159: 4/18/94 - Wall clipping now works much better! (You can still VERY RARELY
1160: sneak through walls, however)
1161: ATTENTION PROGRAMMERS:
1162: MOVESPRITE and CLIPMOVE have been changed. They now look
1163: like this:
1164:
1165: clipmove (long *x, long *y, long *z, short *sectnum,
1166: long xvect, long yvect, long walldist,
1167: char cliptype);
1168:
1169: movesprite(short spritenum,
1170: long xchange, long ychange, long zchange,
1171: long walldist, char cliptype);
1172:
1173: To use the new clipmove:
1174: Pass the pointers of the starting position (x, y, z). Then
1175: pass the starting position's sector number as a pointer also.
1176: Also these values will be modified accordingly. Pass the
1177: direction and velocity by using a vector (xvect, yvect).
1178: If you don't fully understand these equations, please call me.
1179: xvect = velocity * cos(angle)
1180: yvect = velocity * sin(angle)
1181: Walldist tells how close the object can get to a wall. I use
1182: 128L as my default. If you increase walldist all of a sudden
1183: for a certain object, the object might leak through a wall, so
1184: don't do that!
1185:
1186: To use the new movesprite:
1187: Works like before, but you also pass walldist (How close the
1188: sprite can get to a wall)
1189:
1190: - New function for sprites:
1191: setsprite(short spritenum, long newx, long newy, long newz);
1192:
1193: This function simply sets the sprite's position to a specified
1194: coordinate (newx, newy, newz) without any checking to see
1195: whether the position is valid or not. You could directly
1196: modify the sprite[].x, sprite[].y, and sprite[].z values, but
1197: if you use my function, the sprite is guaranteed to be in the
1198: right sector.
1199:
1200: - You can now change the angle in 2D EDIT MODE with the
1201: < and > keys. Move the mouse cursor to a sprite first.
1202: Hold down shift with the < and > to get more precise angles.
1203: - You can now press 'B' on sprites in 3D EDIT MODE. This in effect
1204: is xoring bit 0 of sprite[].cstat, which will not only be
1205: sensitive to hitscan, but will also block you from walking
1206: through the sprite. Sprites with the 'B' attribute will
1207: appear pink in 2D EDIT MODE.
1208: - You can now edit the Hi 16 bits of the tag in 2D EDIT MODE.
1209: Just like T and ALT-T, you press H and ALT-H to edit the high
1210: 16-bits. When a structure's attributes are displayed, the tag
1211: will be displayed as 2 unsigned shorts. The first number
1212: represents the hi 16 bits and the second number represents the
1213: lo 16 bits.
1214: ������������������������������������������������������������������������������
1215: 4/23/94 - Added 'G' in Editart to GOTO a tile by typing in the tile number.
1216: - Changed the way masking walls work a little bit. Now the
1217: masking walls use the picture wall[].overpicnum rather than
1218: wall[].picnum.
1219: - Made hitscan hit maskable walls.
1220: ������������������������������������������������������������������������������
1221: 4/24/94 - Made palette.dat support any number of shades up to 64. There
1222: is no change to the palette.dat format. The palette.dat
1223: format is:
1224:
1225: First the palette (768 bytes) Values range from 0-63
1226: Then the lookup shades (256 * number_of_shades) The
1227: shades are stored in groups of 256 bytes.
1228:
1229: - If you use Mark Dochtermann's palette program, then you can
1230: convert his data files (such as palette.pal and colormap.lmp)
1231: to my palette format, palette.dat, with my great Qbasic
1232: program, PALMP.BAS. To run it, first copy the basic program
1233: into the same directory as the 2 source palette files are in.
1234: Then type: "QBASIC PALMP" and then press SHIFT+F5 (to run it).
1235:
1236: - Added a global variable, HORIZ. Horiz usually equals 100.
1237: Modifying horiz will move the whole screen up / down. I
1238: added 2 keys, +/- in my own game.c to demonstrate this. You
1239: can use this variable for looking up and down if you want.
1240: (Even though this is not "truly" looking up and down, if
1241: you're lucky, you might be able to fake out some people!)
1242:
1243: - New Key in 3D EDIT MODE, the forward slash. Use / with the
1244: tile panning keys (, and .) to flip the horizontal / vertical
1245: orientation bits for walls, ceilings or floors.
1246: ������������������������������������������������������������������������������
1247: 4/28/94 - NEW BOARD VERSION! You must run CONVMAP4.EXE on all your boards.
1248: Here's what I changed in the structures:
1249:
1250: Sectors:
1251: I got rid of:
1252: char sector[].ceilingpanning, sector[].floorpanning;
1253: sector[].ceilingstat/floorstat bit 2 zeroed out
1254: and added:
1255: char sector[].ceilingxpanning, sector[].ceilingypanning;
1256: char sector[].floorgxpanning, sector[].floorypanning;
1257:
1258: Walls:
1259:
1260: I got rid of:
1261: char wall[].panning;
1262: wall[].cstat bit 6 zeroed out
1263: and added:
1264: char wall[].xpanning;
1265: char wall[].ypanning;
1266:
1267: Sprites:
1268:
1269: I got rid of:
1270: short sprite[].vel;
1271: and added:
1272: short sprite[].xvel;
1273: short sprite[].yvel;
1274: The reason I did this was so sprites could be moved in
1275: different directions than sprite[].ang. Please make
1276: use of both xvel and yvel. Here's the equation I would
1277: use to convert from the old to new. For example:
1278:
1279: old:
1280: sprite[i].vel = 256;
1281: new:
1282: sprite[i].xvel = (sintable[(sprite[i].ang+512)&2047]>>6);
1283: sprite[i].yvel = (sintable[sprite[i].ang&2047]>>6);
1284:
1285: The reason I am shifting the sines right by 6 is becuase
1286: my sintable ranges from -16384 to 16384. Dividing by
1287: 64 gives a maximum range of -256 to 256.
1288:
1289: CONVMAP4.EXE also attempts to convert the masked walls so
1290: overpicnum is the masked wall's picnum.
1291:
1292: - Changed 3D EDIT MODE panning keys:
1293: Since panning is now all 4 directions, I got rid of the
1294: , and . keys and put the keys on the keypad using 2,4,6,8.
1295: Usually 2,4,6,8 are for x- and y-repeats, but if you hold
1296: down either shift key, then they act as x- and y- panning
1297: values.
1298: The / key now resets the panning values to 0.
1299:
1300: - Please read the updated descriptions of how to make masking walls
1301: in the 3D EDIT MODE KEYS in the top of build.txt. See
1302: the 'M' and 'Shift + M' keys.
1303:
1304: - Also look at the top of this file for a description of dragpoint(), a
1305: great new function that makes it easy to morph sectors.
1306: ������������������������������������������������������������������������������
1307: 4/29/94 - Added some minor keys to 3D EDIT MODE. Alt. +/- change the
1308: visibility variable. It ranges from 5 (darkest) to 17
1309: (lightest) and it starts at 13.
1310:
1311: - Made 1-way walls have more options. Now, for example, you can
1312: make rectangular switches on walls. Please look at my
1313: nukeland.map for an example of how to do switches. (The
1314: switches are close to start - just go through the door and
1315: bear left.)
1316:
1317: - For those who asked, here's how some sample bobbing code:
1318: First, calculate the distance actually moved - because if you
1319: are not moving then you shouldn't bob:
1320:
1321: CODE:
1322: oposx = posx; oposy = posy;
1323: clipmove(&posx,&posy,&posz,&cursectnum,xvect,yvect,128L);
1324: dist = ksqrt((posx-oposx)*(posx-oposx)+(posy-oposy)*(posy-oposy));
1325:
1326: Then modify the horizon value by multiplying the distance
1327: actually moved by a sine wave. (default is horiz = 100).
1328:
1329: CODE:
1330: horiz = 100 + ((dist*sintable[(totalclock<<5)&2047])>>19);
1331:
1332: - Remember that moving block in the slime in NUKELAND.MAP? It
1333: works a lot better now. I am now modifying the floor panning
1334: values to make the floor match up correctly with the block.
1335:
1336: - Fixed the screen capturing (F12) to save captures as PCX files.
1337: This is for BUILD, GAME, and EDITART.
1338:
1339: - Fixed bug in EDITART when you press 'U' on a blank tile. It
1340: should not crash any more.
1341:
1342: - Made Tab & Enter a little smarter in copying the right attributes
1343: to different types of objects.
1344:
1345: - Added ceiling / floor 90� rotation attributes. All 8
1346: rotations are possible. 3 bits have been added to both
1347: the sector[].ceilingstat and sector[].floorstat flags.
1348: If you look in BUILD.H, you will see the new flags
1349: descriptions. You can use the 'F' key in 3D EDIT MODE on
1350: a ceiling or floor to change the rotation.
1351:
1352: ������������������������������������������������������������������������������
1353: 4/30/94 - ATTENTION PROGRAMMERS:
1354: I removed the function, getsector, and added a more expandable
1355: function, updatesector. Also, updatesector is smart enough
1356: to check to see if you are in the same sector OR neighboring
1357: sectors first before going through every single sector.
1358: Getsector used to go though all the sectors every time you
1359: crossed a sector line.
1360:
1361: getsector(); (no arguments, returns nothing - REMOVED)
1362: * used to make sure that CURSECTNUM matched up with
1363: the right sector according to the POSX and POSY values.
1364: updatesector(posx,posy,&cursectnum);
1365: * the new way of writing getsector. You can do a
1366: search&replace on your code. Be careful when you use this
1367: function with sprites because remember that the sprite's
1368: sector number should not be modified directly. For example,
1369: you might want to code it this way:
1370:
1371: tempsectnum = sprite[i].sectnum;
1372: updatesector(sprite[i].x,sprite[i].y,&tempsectnum);
1373: if (tempsectnum != sprite[i].sectnum)
1374: changespritesect(i,tempsectnum);
1375:
1376: Actually, I think the setsprite function is better for
1377: updating a sprite's sector number.
1378:
1379: - Added swinging doors! Look at NUKELAND.MAP in my GAME.EXE for
1380: an example. For swinging doors, I used a new math-helper
1381: function, rotatepoint.
1382:
1383: rotatepoint(long xpivot, long ypivot,
1384: long x, long y,
1385: short deltaang,
1386: long *x2, long *y2);
1387:
1388: Rotatepoint will rotate point(x,y) around point(xpivot,ypivot)
1389: by the deltang value. The resultant point will be s
1390:
1391: - Fixed crashing bug in BUILD when a wall's tile doesn't exist.
1392: ������������������������������������������������������������������������������
1393: 5/02/94 - I improved the pre-level check on the swinging doors, so now
1394: you can have multiple doors in a sector that open any way.
1395: This is how I do my double swinging doors (demonstrated in
1396: NUKELAND.MAP)
1397:
1398: - I added a revolving door! See NUKELAND.MAP for an example. (The
1399: revolving door is beyond the bouncing platforms in the slime
1400: pit)
1401:
1402: - Fixed bug with joining sectors in 2D EDIT MODE. The sprites
1403: don't get deleted any more.
1404: ������������������������������������������������������������������������������
1405: 5/04/94 - Optimized the masked walls.
1406:
1407: - Cleaned up the sprite drawing code (and many bugs that that came
1408: along with it.)
1409: ������������������������������������������������������������������������������
1410: 5/05/94 - Made cylindrical walls with any number of points VERY easy to
1411: make in BUILD. Here's how you do it: Highlight a wall and
1412: press 'C' on it. Then move the mouse to the proper position
1413: to make a nice circle. You can press '+' or '-' to change
1414: the number of points on the circle. Press 'C' again to cancel
1415: or press space bar to actually change the map.
1416: ������������������������������������������������������������������������������
1417: 5/07/94 - Made a fully-operational subway! Look at subway.map.
1418:
1419: - Made a new type of door - a sliding door where the door doesn't
1420: get "x-smooshed" when it is opened. (See description of
1421: sector tag 16 & wall tag 6)
1422:
1423: - Also note that I my first subroutine in game.c! It is:
1424: operatesector(short dasector)
1425: All the door code is now in this function (with a few
1426: exceptions, such as parts of the swinging doors and revolving
1427: door)
1428: ������������������������������������������������������������������������������
1429: 5/08/94 - Made EDITART and BUILD support different tile sizes in 'V' mode.
1430: Here are the three possible sizes:
1431: 0. 64*64 - 5*3 grid - views 15 tiles (old default)
1432: 1. 32*32 - 10*6 grid - views 60 tiles (new default)
1433: 2. 16*16 - 20*12 grid - views 240 tiles
1434: Press the '*' and '/' keys in 'V' mode if you want to change
1435: the grid resolution.
1436:
1437: - Added/fixed up a new key in 3D EDIT MODE, the dot key (. or >)
1438: This key attempts to match up all the tiles along a wall. It
1439: scans along the walls towards the right as long as the picture
1440: number of the next wall is the same as the original picture
1441: number. Note that some walls may not work right, especially
1442: floor / ceiling steps.
1443:
1444: - Made 2D EDIT MODE default to this when inserting sprites:
1445: 1. Sprite clipping = on for sprites taller than 32 pixels
1446: 2. Sprite clipping = off for sprites shorter than 32 pixels.
1447:
1448: - Fixed sprite clipping with Z-coordinates
1449: ������������������������������������������������������������������������������
1450: 5/10/94 - Fixed some sprite dragging bugs
1451:
1452: - Made neartag? maximum sensing distance a global variable called
1453: neartagdist. See build.h.
1454: ������������������������������������������������������������������������������
1455: 5/11/94 - Added sector / groups of sectors selection. When selecting
1456: sectors, hold down the right ALT key. It works just like
1457: right shift. You must completely surround any sector you
1458: wish to select. Once selected, you can drag the mess of
1459: sectors with the mouse. This is great for separating sectors
1460: from each other.
1461:
1462: - Added sector duplication. First select a bunch of sectors. Then
1463: press the insert key. (with the select sectors flashing) Then
1464: This duplication is like stamping. So, you must drag
1465: the sector bunch somewhere else after stamping to see your
1466: great accomplishments.
1467: ������������������������������������������������������������������������������
1468: 5/12/94 - Added group-sector PGUP / PGDN. Here's a neat trick that will
1469: let you move a whole section of a board up / down quickly.
1470: First you select a bunch of sectors with the right ALT key in
1471: 2D mode. Then flip to 3D mode and if you press PGUP / PGDN
1472: on any of the highlighted sectors, the rest of the highlighted
1473: sectors will move also.
1474:
1475: - Added group-sector rotation. Once you do a sector select (right
1476: ALT), you can press the , or . keys to rotate the selected
1477: sectors. Hold down the shift key with the keys to get fine
1478: angle rotation (WARNING: You will get distortion with fine
1479: angle rotation in this version)
1480:
1481: - Added sector count and wall count information at the bottom of
1482: the 2D edit mode status bar.
1483:
1484: - Fixed some stupid bug that you probably wouldn't have found if
1485: you made boards with BUILD for the rest of your life.
1486:
1487: - You can now press 'B' to block / unblock a wall or sprite in
1488: 2D edit mode.
1489:
1490: - Made Ctrl-Shift Enter auto-shade a sector. First make any
1491: wall of the loop as light as the lightest shade you want.
1492: Then make any other wall of the loop as dark as the darkest
1493: shade you want. Finally press Ctrl-Shift Enter on the wall
1494: that should be lightest. Now the loop should be smoothly
1495: shaded. If it is not smoothly shaded, you may need to insert
1496: more points on the walls.
1497:
1498: - Fixed my .PCX format bug. My screen captures now load properly
1499: in Deluxe programs.
1500: ������������������������������������������������������������������������������
1501: 5/13/94 - Made my serial code in Game.c work better. I fixed the bullet
1502: shooting and made all types of doors work. Unfortunately, you
1503: still may have to run at slower COM speeds.
1504: ������������������������������������������������������������������������������
1505: 5/14/94 - Fixed deadly bug with sector copy & sprites.
1506:
1507: - Added hitscan sensitivity bit. It is bit 6 (64) of wall[].cstat.
1508: In 3D edit mode, you can press 'H' to toggle the bit. (H used
1509: to be like 'V' for choosing height tile numbers for groudraws -
1510: I change the 'H' key to Alt-V since I don't think anybody was
1511: using it anyway) By default, hitscan CAN go through maskable
1512: walls. If a hitscan is set to not go through a maskable wall,
1513: The wall will appear BRIGHT pink in 2D edit mode.
1514: ������������������������������������������������������������������������������
1515: 5/15/94 - Made more subroutines in game.c and moved documentation from the
1516: end of game.c into this text file. Added some more comments
1517: also. Game.c is so much easier to read now! The main loop is
1518: less than 50 lines long!
1519:
1520: - Made some optimizations to my serial code now that everything
1521: is in functions.
1522:
1523: - ATTENTION PROGRAMMERS:
1524: I added one new paramater (cliptype) to both the movesprite
1525: and clipmove functions. If the new parameter is a 0, then
1526: the clipping is normal (Use 0 to clip you and monsters).
1527: If the new parameter is a 1, then the object is clipped to
1528: the same things that hitscan is clipped to (use 1 for all
1529: bullets).
1530: See the above documentation for a detailed description of the
1531: parameters. (Remember that I moved the documentation from
1532: GAME.C into the middle BUILD.TXT)
1533: Finally, you can have sprites and bullets going where you
1534: want them to go!
1535: ������������������������������������������������������������������������������
1536: 5/18/94 - Added support for the Spaceplayer (6-degree of freedom Space ball)
1537: Try out the SETUP program now.
1538:
1539: - Fixed some bugs with the 'E' key in 3D EDIT MODE. As long as both
1540: dimensions of the tile are powers of 2, then the picture should
1541: be visible. It should not be a solid color with a few weird
1542: lines any more.
1543:
1544: - Fixed some bugs with the Z control in 3D EDIT MODE. In normal
1545: operation, BUILD attempts to keep your Z constant even if
1546: you cross sector lines. Then I added a special new mode that
1547: locks your heightofffloor to a certain value. You Z will
1548: change instantly if you cross sector lines. To use this mode,
1549: press the Caps Lock key. Press Caps Lock key again for normal
1550: operation.
1551:
1552: - ATTENTION PROGRAMMERS! I put all of engineinput into GAME.C
1553: This means you have absolutely total control of the Z's. (The
1554: only thing left is some key code I still have in my timer
1555: handler)
1556:
1557: OK, now read carefully! Here's how to convert to the new OBJ's:
1558:
1559: 1. First of all, the Spaceball code is now also in game.c.
1560: A. You will need to put this line in game.c:
1561: include "spw_int.h"
1562: B. And make sure to add spwint.obj your makefile.
1563: 2. Heightoffceiling, heightofffloor, and gravity have been
1564: removed from BUILD.H. If you still want to use them
1565: then you should defined them as globals in your own code.
1566: 3. You should go through every single key of my gameinput()
1567: function in game.c and copy any code you want.
1568: ������������������������������������������������������������������������������
1569: 5/23/94 - GREAT NEW STUFF!
1570:
1571: Be sure to check out GAME.EXE and try out these new keys!
1572:
1573: Rt. Enter = Switch between 3D / 2D modes
1574: Lt. +/- = Zoom in 2D mode
1575:
1576: Added 2D map display with auto-mapping! The 2D maps use a
1577: higher resolution 16-color mode. You have a choice of either
1578: using a 640*350*16 screen or a 640*480*16 screen with a 144-high
1579: status bar (remember that 640*480*16 cannot fit in 256K with 2
1580: screen pages so I have to cheat with a status bar).
1581:
1582: NEW FUNCTIONS:
1583:
1584: draw2dscreen(long posxe, long posye, short ange, long zoome,
1585: short gride)
1586: Draws the 2d screen - this function is a direct replacement
1587: for the drawrooms() and drawmasks() functions. Be sure
1588: to call either qsetmode640350() or qsetmode640480()
1589: first. When switching back to 3d mode, be sure to call
1590: qsetmode320200().
1591:
1592: IMPORTANT NOTES:
1593: 1. The overwritesprite function should only be called in
1594: 3D mode. If you do this in 2D mode, junk will be
1595: written to the 2D screen and a crash is possible.
1596: 2. When you switch back to 3D mode, you should call the
1597: permanentwritesprite functions to draw the status bar,
1598: or whatever else you have to draw.
1599: 3. You must call the nextpage() function in both 2D and
1600: 3D modes.
1601:
1602: qsetmode320200();
1603: Set to the game mode and load palette (320*200*256)
1604: qsetmode640350();
1605: Set to the 2D map mode #1 (640*350*16)
1606: qsetmode640480();
1607: Set to the 2D map mode #2 (640*480*16)
1608:
1609: NEW VARIABLES (see description in build.h):
1610:
1611: EXTERN char show2dwall[MAXWALLS>>3];
1612: EXTERN char show2dsprite[MAXSPRITES>>3];
1613: EXTERN char automapping;
1614:
1615: - Added parallaxing floors! Works like the parallaxing skies, but
1616: the other side. In 3D EDIT MODE, press P on ceiling for
1617: parallaxing sky, or press P on floor for parallaxing floor.
1618:
1619: ������������������������������������������������������������������������������
1620: 5/24/94 - There is a new function that I forgot to document in the last
1621: version. Oops!
1622:
1623: doanimations() is this function.
1624: It's not really new, but I split it off of the
1625: drawrooms/drawmasks functions. This function animates anything
1626: that you use setanimation with. Please stick it in your code
1627: somewhere after you draw the screen.
1628: ������������������������������������������������������������������������������
1629: 5/26/94 - You can now do TRANSLUSCENT sprites! I am using bit 1 of
1630: sprite[].cstat to detemine whether or not the sprite is
1631: transluscent or not. In 3D EDIT MODE, you can press 'T' to
1632: toggle the transluscence bit.
1633: IMPORTANT: Transluscence WILL NOT WORK until you run my
1634: TRANSPAL.EXE program. On the command line, simply type:
1635: C:\BUILD>transpal [filename]
1636: If you do not specify a filename, the default will be
1637: palette.dat. If your palette.dat file is now around 40K long,
1638: then you are ready for transluscence!
1639:
1640: - Added TRANSLUSCENCE to masked walls. See bit 7 of wall[].cstat.
1641: Press 'T' on wall to toggle the transluscence bit.
1642:
1643: - In this BUILD update, I have collected many different palettes
1644: for comparison purposes. Try running TRANSPAL.EXE on each of
1645: them and see for yourself which palettes work the best with
1646: transluscence!
1647:
1648: ������������������������������������������������������������������������������
1649: 5/29/94 - ATTENTION PROGRAMMERS: I completely rewrote the neartag code.
1650: Here's what you have to do to convert your game.c files:
1651:
1652: 1. You should move the neartag variables that I used to
1653: have in BUILD.H into your C code.
1654: 2. You must call the neartag function yourself if you want
1655: to see if you're near a tagged object. Neartag is NOT
1656: automatically updated by the engine any more.
1657: 3. I highly recommend that you put your neartag function
1658: call at the first line in your space bar code. This way,
1659: you can optimize the neartag calculations by only doing
1660: them when you press the space bar. (Exception: For
1661: ladders, I think you'll have to call neartag every single
1662: frame)
1663:
1664: Here's a description of the new neartag function:
1665: Neartag works sort of like hitscan, but is optimized to
1666: scan only close objects and scan only objects with
1667: tags != 0.
1668:
1669: neartag(long x, long y, long z, short sectnum, short ang, //Starting position & angle
1670: short *neartagsector, //Returns near sector if sector[].tag != 0
1671: short *neartagwall, //Returns near wall if wall[].tag != 0
1672: short *neartagsprite, //Returns near sprite if sprite[].tag != 0
1673: long *neartaghitdist, //Returns actual distance to object (scale: 1024=largest grid size)
1674: long neartagrange) //Choose maximum distance to scan (scale: 1024=largest grid size)
1675:
1676: ������������������������������������������������������������������������������
1677: 5/31/94 - Added a function to get a sprite's screen coordinates. I put
1678: some sample code in my GAME in the analyzesprites function.
1679: Simply hold down the CAPS LOCK key in my GAME.EXE, and the
1680: screen will be centered around the sprite closest to the
1681: center of the screen.
1682:
1683: Here's a new function in the engine I used to do this:
1684:
1685: getspritescreencoord(short spritesortnum, long *scrx, long *scry)
1686:
1687: Note that spritesortnum is the index into the spritesortcnt
1688: arrays, NOT the normal sprite arrays. Scrx and scry are actual
1689: screen coordinates ranging from 0-319 and 0-199 respectively.
1690: ������������������������������������������������������������������������������
1691: 6/6/94 - Made EDITART support sprite centering and animation speed.
1692:
1693: Now when you press 'A' in EDITART, the animation speed is
1694: actually saved to disk and runs the same speed in BUILD
1695: and your GAME. Press + and - to change the animation speed.
1696: There are 16 different animation speeds.
1697: (Speed is proportional to (totalclock>>animspeed))
1698:
1699: To center a sprite, press the weird ~` key (located just above
1700: the TAB key). You will see some cross hairs. Simply use
1701: the arrow keys to the desired position.
1702:
1703: For both the 'A' and ~` keys, you can press Enter to accept
1704: the new values or ESC to cancel.
1705:
1706: - Added a variable to BUILD.H, lockclock. Lockclock is to
1707: totalclock as lockspeed is to clockspeed.
1708: ������������������������������������������������������������������������������
1709: 6/7/94 - Made 3 different Z coordinate modes in BUILD.
1710:
1711: Mode 0: Game mode (default)
1712: Mode 1: Height lock mode
1713: Mode 2: Float mode
1714:
1715: Press Caps Lock to switch between the 3 modes.
1716: A and Z move up and down for all 3 modes.
1717: ������������������������������������������������������������������������������
1718: 6/10/94 - Added a new function that should solve all your sound problems.
1719:
1720: kenchaintimer(void (__interrupt __far *datimerchainaddress)(),
1721: short dachainpersecond)
1722:
1723: Please look at the IMPORTANT ENGINE FUNCTIONS section above for
1724: a full description.
1725: ������������������������������������������������������������������������������
1726: 6/20/94 - Got rid of the comsend / comgetchar functions. Replaced them
1727: with sendpacket and getpacket.
1728:
1729: - Added network support.
1730:
1731: - Got rid of qsetmode320200(). Just replace it with setgamemode().
1732: The 2 are exactly the same.
1733:
1734: - Got rid of clockspeed variables. Just replace it with lockspeed.
1735:
1736: - Adjusted my z directions of shooting depending on the horizon.
1737: You may want to readjust your code for this.
1738:
1739: - You now pass the number of tics as a long to doanimations.
1740: doanimations(long numtics);
1741:
1742: - FIXED DEADLY BUG! This may have been causing bigtime crash-city
1743: bugs! The problem was with show2dsprite and show2dwall. In
1744: my engine.c I forgot that they were BIT arrays, not BYTE arrays.
1745: When I initialized the arrays to 0, I initialized 8 times the
1746: length, possibly overwriting your precious data! I initialize
1747: these arrays in the initengine and loadboard functions.
1748:
1749: - ATTENTION PROGRAMMERS: In order to get rid of the posx, posy,
1750: posz, ang, posz, and horiz variables from BUILD.H, I added some
1751: parameters to a few functions. YOU MUST REWRITE YOUR CODE
1752: TO SUPPORT THESE:
1753: loadboard(char *filename, long *posx, long *posy, long *posz,
1754: short *ang, short *cursectnum)
1755: saveboard(char *filename, long *posx, long *posy, long *posz,
1756: short *ang, short *cursectnum)
1757: drawrooms(long posx, long posy, long posz,
1758: short ang, long horiz, short *cursectnum)
1759:
1760: THESE VARIABLES SHOULD BE MOVED INTO GAME.C:
1761: long posx, posy, posz, horiz;
1762: short ang, cursectnum;
1763: long hvel;
1764: ������������������������������������������������������������������������������
1765: 6/22/94 - ATTENTION PROGRAMMERS: Added 1 parameter to movesprite, the
1766: number of tics (such as lockspeed).
1767:
1768: movesprite(short spritenum, long xchange, long ychange,
1769: long zchange, long walldist,
1770: char cliptype, long numtics)
1771:
1772: - ATTENTION PROGRAMMERS: At one time, I used to have 4 timing
1773: variable in the engine. (totalclock, clockspeed,
1774: lockclock, lockspeed). I got rid of all of them except
1775: totalclock. If you want to use the other 3 variables, you
1776: must simulate them yourself. Here's how you do it:
1777:
1778: Step 1. Define clockspeed, lockclock, and lockspeed as global
1779: longs in your code.
1780:
1781: Step 2. Be sure to zero out all 3 variables just before
1782: starting to play each level. (You could zero out
1783: totalclock also.)
1784:
1785: Step 3. Right after every time you call the nextpage()
1786: function, insert this code line for line:
1787:
1788: lockspeed = totalclock-lockclock;
1789: lockclock += lockspeed;
1790: clockspeed = lockspeed;
1791:
1792: You really don't need clockspeed if you have lockspeed.
1793: You should replace all clockspeed's with lockspeed's.
1794: Before, I had both because both totalclock and clockspeed used
1795: to be incremented in the timer handler and could be changed
1796: at any time.
1797:
1798: - I added my own optional random function, krand() which returns
1799: a pseudo-random number as a long from 0 to 65535. Notice that
1800: I put a randomseed variable in BUILD.H called randomseed.
1801:
1802: ������������������������������������������������������������������������������
1803: 6/24/94 - I just want to try to explain how all of my multiplayer code
1804: works. Theory: Think of the whole program as 2 functions:
1805:
1806: Function 1. Draw the screen (could be 2D / 3D)
1807: Function 2. Move things. (sprites, walls, sectors, and you!)
1808:
1809: My communications in GAME.C work on a MASTER/SLAVE
1810: system where it would be nice if the faster computer was the
1811: MASTER. (Right now, the first computer in is the MASTER).
1812: The big trick to keeping everything in sync (and I do mean
1813: everything- even moving platforms, revolving doors, & subways)
1814: is to call function #2 with the exact same parameters as input
1815: on all computers the same number of times and in the same
1816: order. Now this might seem like a lot of information but it
1817: really isn't! Let me explain the role of the MASTER and SLAVE:
1818:
1819: The MASTER's job:
1820: 1. Read in own input changes
1821: 2. Read in any slave player input changes
1822: (getpackets function - reads in foreign vel, svel,
1823: angvel, & the bits)
1824:
1825: 3. Just before calling the movethings function, send the
1826: input to the movethings function:
1827: A. Master's tic cnt (synctics)
1828: B. Every player's velocities (syncvel, svel, angvel)
1829: C. Every player's status bits (Space, Ctrl, Shift, etc.)
1830: 4. Call the movethings function
1831: 5. Draw screen
1832:
1833: The SLAVE's job:
1834: 1. Read in own input changes
1835: 2. Send own input changes to master.
1836: 3. Read in all master movethings input parameters and
1837: call movethings function for each packet. This may
1838: mean calling the movethings function more than once
1839: between calling the drawscreen functions. This is
1840: waste, but it's the price you have to pay to keep
1841: things in sync.
1842: 4. Draw screen
1843:
1844:
1845: You may ask how do monsters stay in sync even if you are
1846: not sending any monster information over the line. The
1847: answer to this is simple.
1848: 1. You make sure that a random seed starts the same on
1849: both computers.
1850: 2. Only call the rand() or krand() function in the
1851: movethings function.
1852:
1853: Before you try my demo, I wanted to say that, I have
1854: ABSOLUTELY NO ERROR CORRECTION in my code at this point. It
1855: is most certainly my next project. For serial link, I would
1856: recommend a rate of about 14400 baud. In the future, I think
1857: I can optimize the code enough to work at rates as low at 2400
1858: baud! Let me explain how well certain setups should work
1859: without error correction:
1860: Ken's guesses on how badly it will crash WITH NO ERROR
1861: CORRECTION (Build the way it is now):
1862:
1863: 1. Serial link using 8250 chips - out of sync after 15
1864: seconds because a few bytes were missed.
1865: 2. Serial link using 16550 chips - out of sync after 10
1866: minutes because 16550 chips have a 16 byte FIFO and
1867: therefore don't lose bytes as often as the 8250.
1868: 3. Modem - out of sync after less than 5 seconds.
1869: 4. Network - out of sync after 1 minute. Networks love to
1870: lose full packets here and there.
1871:
1872: I will be working on error correction for all of the above
1873: situations. Any error correction techniques I use will be
1874: internal to the engine and completely transparent to you (so
1875: you can start coding now!) If the demo actually works multi-
1876: player, then you may want to look at my GAME keys at the top
1877: of this file again. There are some significant changes.
1878:
1879: * I replaced the old COM functions section at the top of
1880: BUILD.TXT with a COMMUNICATIONS FUNCTIONS section. Please
1881: look through it for descriptions of at least these 2
1882: functions:
1883:
1884: sendpacket(short otherconnectnum, char *bufptr, short bufleng)
1885: getpacket(short *otherconnectnum, char *bufptr)
1886:
1887: * Another rule to keep in mind while testing: (as if there
1888: aren't enough already) Always make sure you have the
1889: same EXE's and MAP'S or else the games will get out of sync.
1890:
1891: * Connection numbers and Index numbers:
1892: For networks, each computer has a given connection number.
1893: Connection numbers range from 1 to 100. Player number 1
1894: might have connection number 5 and player number 2 might have
1895: connection number 17. Since a player's connection number
1896: can be anything between 1 and 100, I don't want you to
1897: allocate 100 of every variable such as posx[100]. My
1898: solution was to make index numbers. So in this case:
1899:
1900: connectnum[0] = 5; connectindex[5] = 0;
1901: connectnum[1] = 17; connectindex[17] = 1;
1902:
1903: * Now I'll will describe some new variables at the top of GAME.C
1904:
1905: myconnectnum - connection number of your computer
1906: myconnectindex - index number of your computer
1907: masterconnectnum - connection number of the MASTER computer
1908: screenpeek - index number of which player's eyes you are
1909: looking through.
1910: numplayers - if numplayers >= 2 then multiplayer mode is
1911: enabled, else single player game.
1912:
1913: connecthead, connectpoint2[MAXPLAYERS] - These 2 variables
1914: form a linked list of all the index numbers.
1915: Here's some example code that traverses the list of
1916: players:
1917:
1918: p = connecthead;
1919: while (p != -1)
1920: {
1921: printf("Player index %d has connection number %d\n",p,connectnum[p]);
1922: p = connectpoint2[p];
1923: }
1924:
1925: * These variables are used to record / playback a demo. (This
1926: is like POSCAPT.DAT, but with everything in sync!) In my
1927: GAME, i single player mode, I have it so if you press the
1928: Left ENTER, then it will playback everything. These are
1929: the only variables necessary to store a demo run:
1930:
1931: static long reccnt; //Number of frames
1932: static short recsyncvel[16384]; //Vel for each frame
1933: static short recsyncsvel[16384]; //Svel for each frame
1934: static short recsyncangvel[16384]; //Angvel for each frame
1935: static short recsyncbits[16384]; //Bits for each frame
1936: static short recsynctics[16384]; //Tics for each frame
1937:
1938: * These variables are used for communications syncing:
1939:
1940: static short syncvel[MAXPLAYERS+1]; //Vel of each player
1941: static short syncsvel[MAXPLAYERS+1]; //Svel of each player
1942: static short syncangvel[MAXPLAYERS+1]; //Angvel of each player
1943: static short syncbits[MAXPLAYERS+1]; //Bits for each player
1944: static short synctics; //Number of tics of MASTER ONLY
1945:
1946: * Unless I suddenly make BUILD a 6-degree of freedom engine
1947: tomorrow, this should be the most difficult update in a long
1948: time! Good Luck in programming! I'm sure I left a lot of
1949: things out, so I'll be expecting plenty of phone calls!
1950: ������������������������������������������������������������������������������
1951: 6/27/94 - I scaled the vel, svel and angvel variabile down 1 bit so they
1952: fit into a signed char. (Before they ranged from -256 to 256)
1953: Now they range from (-128 to 127).
1954: ������������������������������������������������������������������������������
1955: 6/28/94 - Optimized the size of my COM(modem)/network packets in game.c.
1956: I made the tics into a char. I also use some new buffers called
1957: osyncvel, osyncsvel, osyncangvel, and osyncbits. Now I send
1958: extra byte with bit fields that tell whether I need to update
1959: the syncvel, syncsvel, syncangvel, or syncbits variables. If
1960: the bit field of the extra byte is off then I don't send the
1961: byte(s) it represents. You can now play my GAME at 4800 baud.
1962:
1963: static signed char syncvel[MAXPLAYERS+1], osyncvel[MAXPLAYERS+1];
1964: static signed char syncsvel[MAXPLAYERS+1], osyncsvel[MAXPLAYERS+1];
1965: static signed char syncangvel[MAXPLAYERS+1], osyncangvel[MAXPLAYERS+1];
1966: static short syncbits[MAXPLAYERS+1], osyncbits[MAXPLAYERS+1];
1967: static unsigned char synctics;
1968:
1969: - There was an crashing error with transluscence palette on low
1970: memory configurations. When you exit the BUILD editor,
1971: you normally get some numbers like this.
1972: Memory status: 788979(788979) bytes
1973: If the first number (art memory cache size) was less than the
1974: second number (art file size), then the whole art file did
1975: not fit in memory. The reason for the crashing was because
1976: loadpics() sucks all memory up to the size of the art file.
1977: The 64K transluscent palette is malloc'd when you call the
1978: setgamemode() function for the first time. The was no memory
1979: left to allocate the palette. I fixed this by making the
1980: transluscent palette take 64K of the art memory cache if
1981: it could not malloc the 64K.
1982:
1983: - I programmed some error correction for the COM(modem). Here is
1984: my new of Ken's guesses on how badly it will crash (assuming
1985: that it will always crash eventually.) You will be seeing new
1986: and better correction methods in the future.
1987:
1988: ERROR CORRECTION METHOD #1:
1989: 1. Serial link using 8250 chips - out of sync after 5 minutes.
1990: 2. Serial link using 16550 chips - out of sync after 10 minutes.
1991: 3. Modem - out of sync after 3 minutes - try it!
1992: 4. Network - out of sync after 1 minute. Networks love to
1993: lose full packets here and there. (not changed)
1994: ������������������������������������������������������������������������������
1995: 6/29/94 - Added some code to my GAME.C that will let you type in messages
1996: and send them to all remote players. Press Tab (or T for
1997: those people who play that other, very bad, game too much)
1998: to start typing in a message. Press either Enter key to send
1999: the message to the other player.
2000: ������������������������������������������������������������������������������
2001: 6/30/94 - ATTENTION PROGRAMMERS: I changed the values that clipmove and
2002: movesprite return! Here's how they work now:
2003: If you did not hit anything, then they return 0.
2004: Movesprite only: If the object hits a ceiling / floor
2005: then movesprite returns 16384+(sectornum hit).
2006: If the first object you hit before sliding was a wall,
2007: then they return the 32768+(wallnum hit).
2008: If the first object you hit before sliding was a sprite,
2009: then they return the 49152+(spritenum hit).
2010:
2011: Be careful when adding these changes to your code since the
2012: return value are sort of reversed:
2013:
2014: return values: � Hit nothing: � Hit something:
2015: ���������������������������������������������������������
2016: Old functions: � 1 � 0
2017: ��������������������������������������������������������-
2018: � � 16384+sectnum (Movesprite only)
2019: New functions: � 0 � or 32768+wallnum
2020: � � or 49152+spritenum
2021:
2022: ������������������������������������������������������������������������������
2023: 7/1/94 - Made getangle always return an angle from 0 to 2047. Before I
2024: forgot to and it 2047 and sometimes the angle was negative.
2025:
2026: - Made overwritesprite when using the centering option be sensitive
2027: to the Editart centering tool. (The ~` key.)
2028:
2029: - Made Ctrl+Rt.Shift highlight points on a loop rather than points
2030: inside a rectangle.
2031: ������������������������������������������������������������������������������
2032: 7/2/94 - Added some neat features to my GAME.C to make multi-player mode
2033: even more fun. I added a portable bowling ball/bomb-thrower.
2034: kills instantly! (similar to rocket launcher) I also added
2035: water fountains. If you hold the space bar down on them,
2036: you slowly get more life.
2037:
2038: - O.K. I think I actually got the syncronization working perfectly
2039: for COM(modem) play. I haven't had all day to test it out yet!
2040: (Still no error correction with networks)
2041:
2042: Here are some steps in playing over the modem:
2043: 1. Be sure that both people have the exact same version of
2044: the EXEs, ART, and MAPs.
2045: 2. Then go into SETUP and set the COM port to the com port
2046: of your modem. Even though 9600 baud should work, I
2047: would recommend going at 4800 baud because:
2048: A. It works fine at 4800 baud so there is really
2049: no need to go any faster.
2050: B. Fewer errors over the modem so less time
2051: spent re-sending packets.
2052: 3. Then type: MODEM [mapname] (must be same mapname!)
2053: This will bring you into my terminal program. You can
2054: set the modem initialization string in MODEM.BAT by
2055: changing the first command line option of the TERM
2056: line. Please disable modem compression and
2057: correction for least jerky play. Then connect with
2058: the other modem using various methods, such as one
2059: person typing ATA and the other typing ATD or one
2060: person typing ATS0=1 and the other typing
2061: ATDT(phone #).
2062: 4. Wait through the beeps and buzzes until it says CONNECT
2063: on the bottom window.
2064: 5. If you can now chat with each other then things are
2065: going well. When the first person presses ESC, both
2066: computers will automatically quit to DOS and go right
2067: into the GAME.
2068: 6. Play!
2069: ������������������������������������������������������������������������������
2070: 7/5/94 - Serial moder over COM(modem) should work perfectly now.
2071:
2072: - Added scaredfallz to BUILD.H. It is a global variable that
2073: tells monsters what height is too high to fall through. You
2074: can set cliptype parameter to 2 for movesprite and clipmove.
2075: ������������������������������������������������������������������������������
2076: 7/6/94 - Fixed clipping bug that used to let you go through certain concave
2077: corners.
2078:
2079: - Added new function which works well with clipmove. Ever notice
2080: was when you're at the edge of a cliff and you go just a tiny
2081: bit over, you fall, but shouldn't yet? Unlike what you have
2082: been doing, this new function finds the highest and lowest z
2083: coordinates that your clipping BOX can get to. It must search
2084: for all sectors (and sprites) that go into your clipping box.
2085: Currently, you were searching the z's at the center point only
2086: by simply using the sector[].ceilingz and sector[].floorz
2087: variables.
2088:
2089: getzrange(long x, long y, long z, short sectnum,
2090: long *ceilz, long *florz,
2091: long walldist, char cliptype)
2092:
2093: Pass x, y, z, sector normally. Walldist can be 128. Cliptype
2094: can be 0, 1, or 2. (just like movesprite and clipmove)
2095: This function returnes the 2 z maxes in ceilz and florz.
2096: See GAME.C for an example.
2097:
2098: - Fixed bug with weird vertical lines in transluscent masked walls
2099: in chain mode.
2100: ������������������������������������������������������������������������������
2101: 7/10/94 - Made screen capture (F12) work in 2D modes also. It always
2102: saves to a 256 color PCX file.
2103:
2104: - Made screen re-sizeable. Use this easy new function to re-size
2105: the screen:
2106:
2107: setview(long scrx1, long scry1, long scrx2, long scry2);
2108:
2109: It is TOO easy to use. You simply pass is the Upper-left hand
2110: corner and the bottom-right corner in screen coordinates of the
2111: rectangular region you want the engine to draw to. The engine
2112: automatically centers the horizon at the middle of the window and
2113: scales everything properly.
2114:
2115: Notes:
2116: - Since the engine does extra scaling calculations for
2117: window sizes that are not 320 pixels wide, I do not
2118: recommend making the default mode with a window size
2119: just under 320 pixels wide since the engine can
2120: actually run a little slower. (such as 312-319
2121: pixels wide) Keep them 320 wide.
2122: - Feel free to modify the startumost / startdmost arrays
2123: AFTER a setview call if you want weird window shapes.
2124: Keep in mind that startumost[0] and startdmost[0] are
2125: always refer to the left edge of the viewing window.
2126: (NOT left edge of screen.)
2127: ������������������������������������������������������������������������������
2128: 7/19/94 - Finally got around to writing the number-of-tiles-per-file
2129: resizer. Simply type rsizeart. All instructions will be
2130: displayed when running the program before the actual
2131: conversion.
2132:
2133: - Fixed a few bugs in Editart. I hope I fixed those evil bugs that
2134: rarely come by. I'm pretty sure I fixed the bug that made the
2135: screen go blank in 'V' mode, and the bug where a few pixels
2136: in the top left corners of tiles sometimes get overwritten.
2137:
2138: - Added a key in Build 2D edit mode. Press 'E' on a sprite to
2139: change its status list number.
2140:
2141: - Fixed those lousy Editart subdirectory colors in 'U' for those
2142: teams with great color palettes, but don't have my ugly shade
2143: of pink.
2144:
2145: - Fixed bug with non-200 high P-skies. The p-skies are now (by
2146: default) centered on the horizon no matter what the height is.
2147:
2148: - Added multiple size PCX and GIF support in Editart. You can now
2149: load pictures up to 1024*256. (That's all that can fit in VGA
2150: video memory) If you need to load a bigger picture than that,
2151: it will be chopped off at the bottom, but will still load the
2152: top piece.
2153:
2154: - I know that I have introduced some wonderful new bugs with the
2155: sprite drawing. I know why they're happening, but I am
2156: looking for a good solution so as to not make you change
2157: any code. I will put another upload with these bugs fixed
2158: soon.
2159: ������������������������������������������������������������������������������
2160: 7/20/94 - Added TRUE ornamented walls. Right now the actual ornamentation
2161: must be programmed by you with 2 simple functions:
2162:
2163: copytilepiece(long tilenume1, long sourcex1, long sourcey1,
2164: long xsiz, long ysiz,
2165: long tilenume2, long destx1, long desty1)
2166:
2167: * This function simply copies any section of a source tile
2168: to any part of a destination tile. It will automatically
2169: skip transparent pixels. It will wrap-around in the
2170: source but not the destination. If for some reason
2171: the destination tile gets removed from the cache, the
2172: destination tile will be reset to original form. This
2173: is why I had to add this second function:
2174:
2175: allocatepermanenttile(short tilenume, long xsiz, long ysiz)
2176:
2177: * This function allocates a place on the cache as permanent.
2178: Right now, I reset the cache every time you call this
2179: function so I would recommend calling this function
2180: right after loadpics.
2181:
2182: I have an example of both of these functions in GAME.C. Try
2183: playing GAME DOOM1.MAP and go into the secret room with
2184: the pictures of Ken. Shoot some walls there. The pictures
2185: with Ken and the Explosion over it were done with
2186: copytilepiece and allocated permanently at tile 4095. A
2187: good idea for allocating permanent tiles would be to start
2188: at 4095 and decrement. You can also allocate a permanent
2189: tile over the original tile itself.
2190:
2191: - Tile panning matching keys work a lot better. They now work
2192: well with bottom steps. Also, it works well with matching
2193: up windows.
2194: ������������������������������������������������������������������������������
2195: 7/25/94 - A week ago, I uploaded a version of BUILD which unfortunately
2196: had more bugs than the previous version. This upload should
2197: have those bugs fixed - especially the sprite bugs. (I hope)
2198:
2199: - I think I may actually have the sprite feet behind stairs bug
2200: working perfectly.
2201:
2202: - The engine should now be even faster the before last week. (A
2203: week ago, I temporarily changed the parallaxing sky algorithm,
2204: making the engine slower in those areas)
2205:
2206: - Added a variable, parallaxyoffs in BUILD.H. It defaults to 0.
2207: If you set it to 100, then all parallaxing skies will be
2208: properly moved 100 pixels higher.
2209:
2210: - Fixed some weird drawing bug related to parallaxing skies and
2211: sprites.
2212: ������������������������������������������������������������������������������
2213: 7/26/94 - Made sprite's sectors dependent on the z coordinates in the BUILD
2214: editor. (Helpful if you use overlapping in your maps)
2215: ������������������������������������������������������������������������������
2216: 7/29/94 - Made precache function. Simply call:
2217: precache() (no parameters)
2218: right after you call loadboard(?,?,...) and it will load
2219: all tiles in the current board into the cache. Note that
2220: animations of sprites after the first one will not be
2221: precached. I have included my precacheing code at the
2222: end of game.c for those interested in making the precaching
2223: fancy.
2224:
2225: - Fixed bug in editart which made it sometimes save the art files
2226: and names.h in the wrong directory (the last directory you
2227: were in when you were in 'U' mode). You may want to search
2228: your artwork directories to see if you were a victim of this
2229: bug.
2230: ������������������������������������������������������������������������������
2231: 7/30/94 - Made Ctrl-Enter paste parallaxing sky tiles to all neighboring
2232: parallaxing sky areas also.
2233: ������������������������������������������������������������������������������
2234: 7/31/94 - Fixed (most) crashing bugs - Doesn't even crash on the highest
2235: skyscrapers now! Since I can never be SURE that the crashing
2236: is gone, I need you to test it for me - compare the number
2237: of times it crashes per second since the last version. It
2238: should be much better.
2239:
2240: - Fixed sector line bug! Get close to a step, hold down Shift+Z
2241: and the edges of the step will NOT jitter like before AND you
2242: will not get random walls going through the screen.
2243: ������������������������������������������������������������������������������
2244: 8/1/94 - Got rid of the OLD transluscent stuff from overwritesprite and
2245: permanentwritesprite. (Before it used the 8K shading table
2246: which didn't work very well)
2247:
2248: - Added new true 50/50 transluscence option to overwritesprite.
2249: See bit 2 in the next comment.
2250:
2251: - Fixed overwritesprite so it works with different screen sizes.
2252: You don't need to do any scaling calculations! Should be
2253: compatible with old function. Added new bit 1 to orientation
2254: parameter to determine whether or not the sprite should be
2255: scaled and clipped to the viewing window.
2256:
2257: overwritesprite (long thex, long they, short tilenum,
2258: signed char shade, char orientation)
2259:
2260: If Bit 0 of orientation = 0: (thex, they) is top-left corner
2261: If Bit 0 of orientation = 1: (thex, they) is middle
2262: If Bit 1 of orientation = 0: no relation to viewing window
2263: If Bit 1 of orientation = 1: scale and clip to viewing window
2264: If Bit 2 of orientation = 0: normal
2265: If Bit 2 of orientation = 1: 50/50 transluscent!
2266:
2267: * If it works at full screen, simply set bit 1 of orientation
2268: to 1, and it should automatically scale properly!
2269:
2270: - Made it so 2/4/6/8 keys in 3D EDIT MODE now only move the objects
2271: 1 step rather than continuously, giving more control over the
2272: repeat/panning values of things.
2273:
2274: - Made the / key not only reset the repeats of walls, but also for
2275: sprites. It will set both repeats of the sprite to the default
2276: size of 64. If you hold down shift with / on a sprite, it
2277: will give the sprite a square aspect ratio by setting the
2278: xrepeat to equal the yrepeat value.
2279: ������������������������������������������������������������������������������
2280: 8/2/94 - Doubled the board size from: (0 to 65536, 0 to 65536) to
2281: (-65536 to 65536, -65536 to 65536) Notice that the grid in
2282: 2D EDIT MODE is much bigger than before. Since it is very easy
2283: to double the maximum board size, just tell me if you need
2284: a larger board. The only bad thing about allowing larger
2285: boards is that the map designer is more likely to make some
2286: sectors too large and cause overflow bugs. 32 bits can only
2287: go so far you know!
2288:
2289: - I think I MAY have fixed a bug in BUILD that used to make it crash
2290: when quitting. It had something to do with the vertical grid
2291: lines in 2D EDIT MODE when zoomed way in around the upper left
2292: corner of the map (I think).
2293: ������������������������������������������������������������������������������
2294: 8/3/94 - Optimized Editart loading and saving.
2295:
2296: - Made 'V' screen in Editart 320*400 instead of 320*200.
2297:
2298: - Before I said I fixed the bug in EDITART where a few pixels in the
2299: top left corners of tiles sometimes got overwritten. Well I
2300: lied. This time I really fixed it. (I hope)
2301: ������������������������������������������������������������������������������
2302: 8/7/94 - Made x&y repeats, x&y pannings easier to adjust. It now works
2303: like the default keyboard handler. It moves once when you
2304: first press the key. A little later, it starts to move fast.
2305: ������������������������������������������������������������������������������
2306: 8/11/94 - Added great new sprite rotation function which works like
2307: overwritesprite (like 2DRAW sprites)
2308:
2309: rotatesprite(long sx, long sy, long z, short a, short picnum)
2310:
2311: (sx, sy) is the center of the sprite to draw defined as
2312: screen coordinates shifted up by 16.
2313: (z) is the zoom. Normal size is 65536.
2314: Ex: 131072 is zoomed in 2X and 32768 is zoomed out 2X.
2315: (a) is the angle (0 is straight up)
2316: (picnum) is the tile number
2317:
2318: Ex: rotatesprite(160L<<16,100L<<16,65536,lockclock<<4,DEMOSIGN);
2319: This example will draw the DEMOSIGN tile in the center of the
2320: screen and rotate about once per second.
2321:
2322: Rotatesprite clips to the same area as overwritesprite but does
2323: not scale or do transluscence yet.
2324:
2325: - Please look at the new permanentwritesprite documentation at the
2326: top of this file!
2327:
2328: - Network should now work again - It now works great on my network
2329: with 3 players! It may possibly also work with 4 or 5 players
2330: too, but I didn't feel like running between 2 rooms to test it!
2331: I never thought the day would come when I would get NET, COM,
2332: and MODEM all working respectably!
2333:
2334: - Changed setup program so you can select 2, 3, 4, or 5 players in
2335: a network game. (The 5 is just to annoy people who like that
2336: other lousy game)
2337:
2338: - ATTENTION BUILDERS! Added TILE MOVING to EDITART! For now, it
2339: will only work WITHIN THE SAME ART FILE. Do the tile moving
2340: all in 'V' mode. Here are the new keys in 'V' mode:
2341:
2342: To swap 2 tiles:
2343: Simply press space bar on the first tile, then space
2344: bar on the second.
2345: To swap a group of tiles:
2346: Press 1 on the first tile, press 2 to remember the region
2347: between where you pressed 1 and 2. Press 3 at the
2348: place to where you want to swap all the tiles.
2349:
2350: Don't forget that this is all SWAPPING, tiles will (should)
2351: NOT be overwritten using these keys.
2352:
2353: - ATTENTION PROGRAMMERS! Added ceildist and flordist parameters to
2354: both clipmove and movesprite. I always had them all set to
2355: (4<<8) by default.
2356:
2357: clipmove(long *x, long *y, long *z, short *sectnum,
2358: long xvect, long yvect,
2359: long walldist, long ceildist, long flordist,
2360: char cliptype)
2361:
2362: movesprite(short spritenum, long xchange, long ychange, long zchange,
2363: long walldist, long ceildist, long flordist,
2364: char cliptype, long numtics)
2365:
2366: - Moved some com/network code from the getpackets function in game
2367: into the engine.
2368: ������������������������������������������������������������������������������
2369: 8/15/94 - Fixed some network initialization code and it now works with 4
2370: players. (I tested it.)
2371: ������������������������������������������������������������������������������
2372: 8/16/94 - Added different shirt color support. Here's how you do it:
2373:
2374: allocatespritepalookup(long palnum, char *remapbuf)
2375:
2376: See more documentation of allocatespritepalookup at the top of
2377: this file.
2378: ������������������������������������������������������������������������������
2379: 8/18/94 - I made it so you can redefine the keys in the setup program under
2380: the input devices menu.
2381:
2382: - ATTENTION EVERYONE - for this new version, you MUST go into my
2383: new SETUP program, and SAVE CHANGES AND QUIT once. The arrow
2384: key code will not work if you don't do this! If you are
2385: one of those people who actually read BUILD.TXT, give yourself
2386: 1 point. I wonder who will get "caught" for not reading this!
2387: ������������������������������������������������������������������������������
2388: 8/22/94 - Added pixel height and wall length information to 2D EDIT MODE
2389: when you press Tab or Alt-Tab on a sector or wall.
2390:
2391: - Now show the actual number of sprites in 2D EDIT MODE.
2392:
2393: - Improved digitized sound routines. Just thought I'd mention it.
2394:
2395: - Added a "save As" feature to 2D EDIT MODE.
2396:
2397: - Now show all lo and hi tags in 2D EDIT MODE on the map itself!
2398: Note that position of the sector tag's text is put at the
2399: average point of all the points of the sector, so if you have
2400: a weird shape tagged sector, the text might show up at an
2401: inconvenient place.
2402:
2403: - You can turn the tag boxes on or off by pressing CTRL-T or by
2404: zooming out.
2405:
2406: - ATTENTION EVERYONE - for the new BUILD.EXE and OBJ's, you will
2407: need to copy my new TABLES.DAT over your old one. Also, you
2408: must go into SETUP and SAVE&QUIT. I have split the TABLES.DAT
2409: file into 2 separate files. They are:
2410:
2411: TABLES.DAT - 10880 bytes - sin tables, fonts, etc.
2412: SETUP.DAT - 23 bytes - (6 options) + (17 custom keys)
2413:
2414: The SETUP.DAT file is the only file SETUP.EXE accesses now.
2415: This means that from now on, if I want to add something to
2416: TABLES.DAT, you won't have to go into the setup program and reset
2417: the options again.
2418: ������������������������������������������������������������������������������
2419: 8/24/94 - Relative alignment now fully works with ROTATION! Relative
2420: alignment will allow ceilings and floors to align with the
2421: first 2 points of a sector. This will relieve you of
2422: programming special ceiling and floor panning code for moving
2423: sectors.
2424: In 3D EDIT MODE, simply press 'R' on a ceiling / floor to switch
2425: between relative alignment mode and normal mode. Notice that
2426: bit 6 of both sector[].ceilingstat and sector[].floorstat are
2427: relative alignment bits.
2428: I have an example of relative alignment in nukeland.map in the
2429: high blue room off the main octagonal room. Also note that my
2430: subways and dragsectors now use relative alignment for panning.
2431: ������������������������������������������������������������������������������
2432: 8/25/94 - I added a new parameter to printext256 and printext16. I need
2433: to document this stuff!
2434: ������������������������������������������������������������������������������
2435: 8/27/94 - Made it so you can't shrink sprites so much you can't grab them
2436: any more in 3D EDIT MODE.
2437:
2438: - Added (G)oto feature into Build 'V' mode. Simply press G, type
2439: the tile number and it will go there.
2440: ������������������������������������������������������������������������������
2441: 9/7/94 - Fixed relative alignment bugs I noticed. My subway.map won't
2442: crash anymore and the relatively aligned ceilings and floors
2443: should not pan crazily anymore when looking from a far
2444: distance.
2445: ������������������������������������������������������������������������������
2446: 9/9/94 - ATTENTION PROGRAMMERS: I added a new parameter to
2447: overwritesprite. Dapalnum can be from 0-15 depending on
2448: what palette lookup table is being used. Dapalnum is normally
2449: 0. Overwritesprite now looks like this:
2450:
2451: overwritesprite (long thex, long they, short tilenum,
2452: signed char shade, char orientation, char dapalnum)
2453: ������������������������������������������������������������������������������
2454: 9/13/94 - ATTENTION PROGRAMMERS: I changed the last parameter of drawrooms
2455: (sector number) to be passed as a value, NOT a pointer anymore.
2456:
2457: drawrooms(long daposx, long daposy, long daposz,
2458: short daang, long dahoriz, short dacursectnum)
2459: ������������������������������������������������������������������������������
2460: 9/15/94 - ATTENTION PROGRAMMERS: I took out the COM(modem)/network code
2461: from my engine.obj and put it into a separate .obj called
2462: multi.obj. (I also removed the sound from my engine and stuck
2463: it in kdmeng.obj) Please include it in your makefile. Here is
2464: a list of ALL of the variables and functions you will need to
2465: know to program for multiple players:
2466:
2467: VARIABLES: (You should extern these in your game.c)
2468: extern short numplayers, myconnectindex;
2469: extern short connecthead, connectpoint2[MAXPLAYERS];
2470: extern long *lastpacket2clock;
2471:
2472: FUNCTIONS:
2473: initmultiplayers(option[4],option[5]);
2474: uninitmultiplayers();
2475:
2476: sendlogon();
2477: sendlogoff();
2478:
2479: sendpacket(connecthead,tempbuf,j);
2480: sendpacket(-1,tempbuf,j);
2481: leng = getpacket(&otherconnectindex,tempbuf);
2482:
2483: Please see detailed descriptions of these functions at the top
2484: of this file.
2485:
2486: - Multiplayer code is now MUCH cleaner!
2487:
2488: - Please try my game on your networks again! My game now works
2489: perfectly with 3 players on a network that used to crash at
2490: the DOS4GW prompt just a week ago! My game needs only IPX,
2491: no server to run.
2492: ������������������������������������������������������������������������������
2493: 9/16/94 - ATTENTION PROGRAMMERS: CONVMAP5!!! YOU MUST RUN CONVMAP5 ON
2494: ALL OF YOUR MAPS IF YOU WANT THEM TO WORK WITH THE NEW
2495: BUILD.EXE OR OBJ'S! Following are the exact changes I made
2496: to the new map format:
2497:
2498: * Added numextras
2499: * Added sector[].ceilingpal
2500: * Added sector[].floorpal
2501: * Added sector[].visibility
2502: * Split sector[].tag to sector[].lotag and sector[].hitag
2503: * Added sector[].extra
2504: * Expanded wall[].cstat to a short
2505: * Split wall[].tag to wall[].lotag and wall[].hitag
2506: * Added wall[].extra
2507: * Split sprite[].tag to sprite[].lotag and sprite[].hitag
2508: * Got rid of sprite[].extra (the void * mess)
2509: * Added sprite[].extra
2510:
2511: The only thing programmers have to worry about when converting
2512: are the tags. I split them into lo and hi tags.
2513: (See BUILD.H for new structure formats)
2514:
2515: I got rid of the (void *)extra thing from the sprite
2516: structure. I know I may have made some promises it
2517: wouldn't change and it was for your use only, but what
2518: can I say - it's not needed anymore (in other words,
2519: if you're already using it, TOUGH LUCK). I have my
2520: own, new, method for extending sector, wall, or
2521: sprite structures. You will be able to extend any
2522: structure as much as you want AND be able to edit it
2523: all in the BUILD editor to be saved in the permanent
2524: map format. Notice I added a (short)extra to all 3
2525: main structures. They default to -1. But if they
2526: are >= 0 then they form a linked list out of the
2527: extra structure. NOTE: THIS EXTRA STUFF IS NOT
2528: PROGRAMMED YET! I'm just mentioning it becuase the
2529: new map format has this extendability. I'll try to
2530: get it done soon though. (9/21/94) - Actually just
2531: ignore the fact that this paragraph ever existed.
2532: I'm just keeping it here for history purposes.
2533:
2534: - Renamed my allocatespritepalookup function to makepalookup since
2535: it now also applies to walls, ceilings, floors, p-skies and
2536: masked walls.
2537: ������������������������������������������������������������������������������
2538: 9/20/94 - Added rotated sprites. These new rotated sprites rotate in the
2539: same way as masked walls. Sounds like a waste since the
2540: engine already has masked walls? NOT AT ALL! With rotated
2541: sprites, you can EASILY do TRUE ornamented walls FULLY inside
2542: the BUILD editor with even MORE versatility than that other
2543: game out there. For example, you can place the ornamentation
2544: anywhere on the wall, with sizing control using 2,4,6,8 on the
2545: keypad, and even ornament with transluscence! In 3D EDIT
2546: MODE, simply press 'R' on a sprite to make it a rotated
2547: sprite (Programmers see bit 4 of sprite[].cstat)
2548:
2549: - Fixed crashing bug with sector (Rt. ALT) copy/paste in 2D EDIT
2550: MODE.
2551:
2552: - You can now copy groups of sectors from 1 map to another! Here's
2553: how you do it:
2554:
2555: Step 1: Capture a bunch of sectors with the Rt. ALT selection
2556: tool.
2557: Step 2: With the sectors still highlighted, you can now load
2558: another map and the highlighted sectors will
2559: automatically be inserted into the new map. (They
2560: will still be highlighted)
2561: ������������������������������������������������������������������������������
2562: 9/21/94 - Fixed bug with cursectnum not always being right after loading
2563: the board. I now check it and make sure it's right when
2564: saving in BUILD now.
2565:
2566: - Added 'O' key in 2D/3D EDIT MODES. It will push a rotated sprite
2567: backwards (using hitscan) into the first wall and
2568: automatically adjust the angle to make the sprite appear
2569: as if it was part of the wall.
2570:
2571: - You can now press 'S' to insert a sprite in 3D EDIT MODE. Press
2572: 'S' on a ceiling or floor.
2573:
2574: - You can now press delete to delete a sprite in 3D EDIT MODE.
2575: ������������������������������������������������������������������������������
2576: 9/22/94 - Programmed Nick & Peter's BUILD stub to their EXACT
2577: specifications. See WSTUB.C for code & documentation.
2578: ������������������������������������������������������������������������������
2579: 9/27/94 - Fixed Rt. Alt block copying nextsector1 pointer bug.
2580: ������������������������������������������������������������������������������
2581: 9/29/94 - Added special bitmapped effect which I either call lava or
2582: boiling slime. See my initlava and movelava functions
2583: inside GAME.C.
2584:
2585: - I added a bit array call gotpic. The engine will set the
2586: respective gotpic bit for each picnum drawn to the screen,
2587: including ceilings, floors, walls, sprites, masked walls -
2588: even overwritesprites, etc. This array is mainly for
2589: making the game only calculate special bitmapped effects
2590: when that certain picnum is on the screen.
2591:
2592: Note 1: The engine does NOT automatically clear the gotpic
2593: bits for you. If you want to test gotpic for a certain
2594: picnum, you should clear it if you want to test it again.
2595:
2596: Note 2: It is not necessary to use permanentwritesprite
2597: for bitmapped special effects - after all, if you see it,
2598: it MUST be in the cache.
2599:
2600: Added to BUILD.H:
2601: EXTERN char gotpic[MAXTILES>>3];
2602:
2603: Example code in GAME.C:
2604: if ((gotpic[SLIME>>3]&(1<<(SLIME&7))) > 0) //test bit
2605: {
2606: gotpic[SLIME>>3] &= ~(1<<(SLIME&7)); //clear bit
2607:
2608: if (waloff[SLIME] != -1) //if in cache
2609: movelava((char *)waloff[SLIME]); //calculate!
2610: }
2611:
2612: - Added what some people call gamma correction. I think
2613: brightness is a better description though.
2614:
2615: setbrightness(char brightness);
2616:
2617: Simply call this function where brightness ranges from
2618: 0 to 4. Brightness defaults to 0. Levels 1-4 are all brighter
2619: than 0. If you switch between 2D & 3D modes, the engine will
2620: remember the current brightness level.
2621: ������������������������������������������������������������������������������
2622: 9/30/94 - Added a few keys to fake a multiplayer game all on 1 computer.
2623: In my game, press Insert to add a new player at the starting
2624: position, and Delete to delete the last player. Press
2625: scroll lock to get control of the other players. In the same
2626: way Lt. Enter lets you view other players, Scroll lock will
2627: let you control other players (single player game only)
2628: ������������������������������������������������������������������������������
2629: 10/2/94 - Moved all doanimations code from engine into game.c. If you
2630: are using the doanimations code, here's exactly what you
2631: need to do to make it work with your code again:
2632:
2633: Step 1: Copy these 3 functions which you should find at
2634: the end of my Game.c:
2635:
2636: doanimations(long numtics)
2637: getanimationgoal(long animptr)
2638: setanimation(long *animptr, long thegoal, long thevel)
2639:
2640: Step 2: Move these variables out of BUILD.H and into your
2641: game.c:
2642:
2643: #define MAXANIMATES 512
2644: static long *animateptr[MAXANIMATES], animategoal[MAXANIMATES];
2645: static long animatevel[MAXANIMATES], animatecnt = 0;
2646:
2647: * If you copied my door code, you will probably have to convert
2648: some parameters to longs. (oops!)
2649:
2650: - Got rid of printnum from the engine. It is an outdated function.
2651: Use either printext256 or printext16 instead.
2652:
2653: - Added y-flipping for both normal and rotated sprites. (see bit
2654: 3 of sprite[].cstat in BUILD.H.
2655:
2656: - Added y-flipping for walls. (see bit 8 of wall[].cstat in
2657: BUILD.H.
2658:
2659: - Fixed bug with initialization of Master and Slave for
2660: COM(Modem) only. If both computers went in at the same
2661: time, it used to sometimes think both were Masters.
2662: ������������������������������������������������������������������������������
2663: 10/4/94 - Alt-C in 3D EDIT MODE changes all picnums on the whole map
2664: from the picnum in tab to the picnum under the mouse cursor.
2665: ������������������������������������������������������������������������������
2666: 10/6/94 - Fixed y-flipping bug on walls and masked walls.
2667: ������������������������������������������������������������������������������
2668: 10/16/94 - Fixed bug in editart that didn't convert the maps right after
2669: swapping tiles.
2670:
2671: - Added excellent function to my multi.obj.
2672:
2673: long getoutputcirclesize();
2674: This function returns the number of bytes that have not
2675: yet been copied. If there are still more than say, 16 bytes,
2676: then you may be sending too many bytes per second. This can
2677: happen if the frame rate of a computer is faster than the
2678: speed of the serial mode (Ex: Try 2400 baud with a Pentium 90!)
2679: this function will tell you how many bytes are left to copy
2680: In other words, if getoutputcirclesize() < 16 then it is safe
2681: to send a packet. If you already have serial mode working
2682: all you have to do to update your code is to copy the lines
2683: in my sync() function the deal with the getoutputcirclesize
2684: function. Everything else in sync() and getpackets() is
2685: pretty much the same.
2686:
2687: - Programmed some example code in my game that will allow players
2688: to change masters and slaves during the game without losing
2689: sync. Simply press 'M' in my multiplayer game, and that
2690: computer will become the master! It is interesting how
2691: the frame rate and controllability changes.
2692: ������������������������������������������������������������������������������
2693: 10/31/94 - Added basic scripting to EDITART. Don't expect it to be
2694: everything you ever dreamed of (yet).
2695:
2696: Scripts are saved in a file called CAPFIL.TXT. You can edit the
2697: text file, but be careful not to screw it up too badly (such
2698: as extra commas, spaces in weird places, etc.) since I am
2699: parsing it in EDITART.
2700:
2701: Whenever you select a box in 'U' mode, a line will be appended to
2702: the CAPFIL.TXT file.
2703:
2704: WRITING THE CAPFIL.TXT FILE:
2705: In 'U' mode, you can press 'O' instead of ENTER to select a tile.
2706: What 'O' does that is different from ENTER is that it takes
2707: the center point of the highlighted rectangle, and searches
2708: outward until a total rectangle of transparent pixels (255)
2709: is reached. This is useful for grabbing sprites - not only
2710: will you not have fine adjust to the exact borders of a
2711: sprite now, but when you re-grab from the pcx's you can
2712: change the size of the sprite freely.
2713:
2714: READING THE CAPFIL.TXT FILE:
2715: There are 2 ways to re-grab from the CAPFIL.TXT file. If you
2716: press ALT-U in the main screen, everything will be re-grabbed.
2717: If you press ALT-U in 'V' mode, then you should first select
2718: the range by pressing '1' and '2' on the range boundaries.
2719:
2720: Format of CAPFIL.TXT lines:
2721: Tile #, Full path/file name, x1, y1, xsize, ysize
2722:
2723: Note: If xsize and ysize are 0, then that means you did
2724: an 'O' grab and EDITART will search from point (x1, y1)
2725: when you do a re-grab.
2726:
2727: Example CAPFIL.TXT file:
2728: 31,D:\CAPTUR00.PCX,220,98,64,64
2729: 110,D:\CAPTUR00.PCX,49,72,0,0
2730:
2731: The first line says that tile #31 is a 64*64 tile and the
2732: second line says that tile #110 is unknown size tile (grabbed
2733: with the 'O' key)
2734:
2735: Note: You can only do 1 grab per tile with my scripting system.
2736: You may have done your parallaxing skies with several grabs.
2737: If so then try to make the tile into 1 large PCX and do 1
2738: grab. (The largest grabbing size right now is 1024*256)
2739:
2740: -------------------------------------------------------------------
2741:
2742: - Made Editart's screen capture (F12) save to PCX's the exact size
2743: of the tile and not include the status bar at the bottom. It
2744: will also save large tiles to large PCX's - Now it's easy and
2745: lossless to extract a tile from Editart!
2746:
2747: - ATTENTION PROGRAMMES! Added 2 new parameters to getzrange for
2748: returning the objects hit on top and bottom.
2749: (sectors / sprites) See my updated documentation at the top
2750: of this file.
2751:
2752: - Fixed clipping bugs with sprites near sector lines. (I hope)
2753:
2754: - Got 3D Red-Blue glasses mode working for all VGA cards. First
2755: set the graphics mode to red-blue mode in the setup program.
2756: The left eye is red and the right eye is blue. There are
2757: 4 keys that let you adjust the 3D view:
2758: [,] = Adjust width between eyes (3D width)
2759: Shift [,] = Adjust width of parallax (2D width)
2760: ������������������������������������������������������������������������������
2761: 11/1/94 - Guess what? I turned 19 today. Doesn't that just suck. Now,
2762: if you play my build game on my birthday, all the extemely
2763: evil and scary brown monsters will be replaced with super
2764: happy fun dogs that throw smiley red jelly coconuts at you.
2765: Also, my incredibly evil and scary music will be replaced
2766: with super happy music. Actually this whole paragraph is
2767: a joke (except for the birthday part).
2768:
2769: - Made centering work with rotated sprites.
2770:
2771: - Fix centering with x and y flipped sprites.
2772:
2773: - Rotated sprites now get chopped off by the ceiling or floor in
2774: the same way normal sprites get chopped. Sprites do not get
2775: chopped if there is a parallaxing sky / floor.
2776:
2777: - Made Shift + F12 is BUILD 2D mode inverse black and white.
2778:
2779: - If SETUP.DAT is not found then default options are loaded
2780: instead of quitting to DOS.
2781:
2782: - ATTENTION PROGRAMMERS! Added 3 parameters to makepalookup that
2783: allow you to do FOG effects. The first 2 parameters are the
2784: same as before. The last 3 are the color that the palette
2785: fades to as you get further away. Before, this color was
2786: always black (0,0,0). White would be (63,63,63).
2787:
2788: makepalookup(long palnum, char *remapbuf,
2789: char redvalue, char greenvalue, char bluevalue)
2790:
2791: - ATTENTION PROGRAMMERS! Moved 2 things into BUILD.H. Please
2792: make sure to update it:
2793:
2794: #define MAXPALOOKUPS 256
2795: and
2796: EXTERN char *palookup[MAXPALOOKUPS];
2797:
2798: The palookup array is an array of pointers that point to the
2799: first byte of each 8K palette lookup table. All 256 pointers
2800: are initialized to NULL by initengine() except for palookup[0]
2801: which is the default 8K palette. This will allow you to modify
2802: the palette lookup table directly for non-snowy fading effects,
2803: etc. Each palette lookup table has 32 shades. Each shade has
2804: 256 bytes. Shade 0 is closest (actual palette brightness) and
2805: shade 31 is farthest (dark usually). (256*32 = 8192 or 8K)
2806: ������������������������������������������������������������������������������
2807: 11/3/94 - Now show white lines in 'V' mode of EDITART at ART file tile
2808: boundaries.
2809:
2810: - Added Insert and Delete commands to EDITART! These Insert and
2811: Delete keys WILL shift all tiles after the one being inserted
2812: or deleted just like a regular text editor. To insert or
2813: delete tiles, simply go the 'V' screen in EDITART and bang
2814: away! Don't worry these keys are fully multi-tile file
2815: compatible (unlike swapping right now).
2816: You will notice that the white line boundaries that
2817: I just added will actually move if you press Insert or Delete.
2818: This changes the number of tiles per art file. But that's
2819: ok. If the art files ever get too unbalanced, you can run
2820: the RSIZEART.EXE utility to fix it.
2821: Ken's lesson of the day: For the final release of your
2822: games, you only need 1 art file. The reason I spent my time
2823: programming multiple art files was because of EDITART.
2824: Since EDITART need to READ & WRITE to the art files, it must
2825: hold a whole art file in memory at a time. Since Build and
2826: Game only READ the art files, a caching system can be made
2827: and only 1 art file is necessary even for lo-memory systems.
2828: ������������������������������������������������������������������������������
2829: 11/4/94 - ATTENTION MAP DESIGNERS! Added a long-awaited feature to BUILD
2830: which I call "loop joining". Have you ever gotten this
2831: frustrating message in 2D EDIT MODE before?
2832:
2833: "You can't split sector by connecting different loops."
2834:
2835: Well, you're not going to see it any more because I fixed
2836: it! Yup. You can now split a sector along a line connecting
2837: different loops of the sector.
2838:
2839: Try this - Convert the sector on the left to the sector
2840: on the right:
2841:
2842: Split #1 Split #2
2843: �������Ŀ �������Ŀ �������Ŀ
2844: � ���Ŀ � � ���Ŀ � � ���Ŀ �
2845: � � � � � � � � � � � �
2846: � ����� � � ����� � � ����� �
2847: ��������� ��������� ���������
2848: (Given) (Half done) (Result)
2849: (1 sector) (Still 1 sector) (2 sectors)
2850:
2851: Before the only was to do this was to delete all the
2852: sectors and then redraw them again.
2853:
2854: I'm sure loop joining has its share of tricks, as most
2855: BUILD functions do, so you may want to spend some time just
2856: playing around with this new function.
2857:
2858: - Removed my own profiler stuff - Hline calculations, etc. code.
2859: Watcom's sampler and profiler is much better anyway.
2860:
2861: - Fixed neartag divide by zero bug with walls (I hope).
2862: Anyone calling neartag for every player per movethings?
2863: I would try not to - How much is that unnoticable extra 0.02
2864: frames per second worth to you anyway?
2865: ������������������������������������������������������������������������������
2866: 11/9/94 - Added new array to BUILD.H called gotsector. It works a lot
2867: like the gotpic array, but this array determines which sectors
2868: were considered during the drawrooms function. Note that
2869: gotsector, unlike gotpic IS cleared to 0 during every call
2870: to drawrooms.
2871:
2872: - Fixed Editart 'U' mode mouse control bug. I typed too fast this
2873: time.
2874:
2875: - Fixed Build split sector bug of accidently deleting sprites. It
2876: should not delete any sprites when splitting sectors now.
2877: ������������������������������������������������������������������������������
2878: 11/15/94 - ATTENTION PROGRAMMERS!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2879: I moved ALL my timer code and arrow key code into GAME.C.
2880: Here are the exact instructions that you need to follow to
2881: upgrade your code to the new obj's:
2882:
2883: 1. From the end of my GAME.C, take the code from these 4
2884: functions:
2885:
2886: ---> inittimer();
2887: ---> uninittimer();
2888: ---> void __interrupt __far timerhandler();
2889: ---> keytimerstuff();
2890:
2891: 2. After each initengine, call inittimer right AFTER:
2892:
2893: initengine();
2894: ---> inittimer();
2895:
2896: After each uninitengine, call uninittimer right BEFORE:
2897:
2898: ---> uninittimer();
2899: uninitengine();
2900:
2901: 3. You may need to include this (if not already included):
2902:
2903: ---> #include <dos.h>
2904:
2905: 4. Add these 2 lines to declare the timerhandler:
2906:
2907: ---> void (__interrupt __far *oldtimerhandler)();
2908: ---> void __interrupt __far timerhandler(void);
2909:
2910: 5. Since BUILD.H NO LONGER has vel, svel, and angvel, you
2911: must add the following line to your game:
2912: (These variables are modified inside keytimerstuff())
2913:
2914: ---> static long vel, svel, angvel;
2915:
2916: 6. Let me list some variables that I recently removed from my
2917: GAME. This may or may not affect you:
2918:
2919: oposx[], oposy[], oang[], etc.. - GONE!
2920: lastpacket2clock - GONE!
2921: lastsynctics - GONE!
2922: drawscreen's smoothratio parameter & related code - GONE!
2923: kenchaintimer - GONE! (Don't think anybody was using it
2924: because it didn't solve sound compatibility problems)
2925: ������������������������������������������������������������������������������
2926: 11/16/94 - Made swinging door clipping work MUCH better! It is much more
2927: difficult to "sneak" through the door now. With the swinging
2928: door clipping working much better, I made it possible to open
2929: doors even if you are in the same sector as the door itself.
2930: Now you won't have to stand back a certain distance to open
2931: the doors. (It is much less annoying this way) Since neartag
2932: does not normally scan cursectnum's sector tags, you will
2933: need to check cursectnum's tags yourself (if you so desire)
2934:
2935: Example: (extracted from my GAME.C)
2936:
2937: neartag(posx[snum],posy[snum],posz[snum],cursectnum[snum],
2938: ang[snum],&neartagsector,&neartagwall,&neartagsprite,
2939: &neartaghitdist,1024L);
2940: if (neartagsector == -1) //If no neartagsector found...
2941: {
2942: i = cursectnum[snum]; //Test current sector for tagging
2943: if ((sector[i].lotag|sector[i].hitag) != 0)
2944: neartagsector = i; //Cursectnum is the neartagsector!
2945: }
2946:
2947: - Improved my gamma correction algorithm. Since it now uses a new
2948: 1K at the end of my TABLES.DAT, be sure to update all your
2949: TABLES.DAT files! My new gamma correction supports 16 levels
2950: of brightness (0-15). You need not change any code in your
2951: game if you already have gamma correction programmed.
2952: ������������������������������������������������������������������������������
2953: 11/17/94 - Made swinging door clipping code work even better. The bug was:
2954: it only tested the clipping if you were in the same sector as
2955: the door. So I put this handy little function in GAME.C which
2956: simply tests if 2 sectors are neighbors or not:
2957: testneighborsectors(short sect1, short sect2)
2958: Check it out!
2959:
2960: - Rewrote my clipinsidebox function. You probably don't use this
2961: function, but if you copied my swinging door code, then you
2962: will need to update this. Clipinsidebox is used for clipping
2963: to determine whether a player or sprite is too close to a
2964: wall.
2965:
2966: clipinsidebox(long x, long y, short wallnum, long walldist)
2967: X and y are the position of the sprite or player. Wallnum
2968: is the wall to test, and walldist is the fatness of the sprite
2969: or player (same as clipmove). It returns a 1 if the sprite or
2970: player's clipping square intersects the wall or 0 if not.
2971:
2972: Example - You can test all 4 walls of a swinging door and make
2973: sure the door doesn't run you over:
2974:
2975: short swingwall[4]; //4 wall indeces of a swinging door
2976: for (i=0;i<4;i++)
2977: if (clipinsidebox(posx,posy,swingwall[i],128L) == 1)
2978: {
2979: //Swinging door swung into player, so move door back to
2980: //its old position / inverse swinging direction.
2981:
2982: break;
2983: }
2984: ������������������������������������������������������������������������������
2985: 11/22/94 - Made build posx, posy, posz, ang, cursectnum, and horiz variables
2986: nonstatic.
2987:
2988: - Made hi-res screen capture work.
2989:
2990: - Fixed some of those evil view-clipping bugs with rotated sprites
2991: on red sector lines. I think it should work with rotated
2992: sprites on horizontal or vertical red lines. I'm not sure
2993: about weird angled lines.
2994: ������������������������������������������������������������������������������
2995: 11/23/94 - ATTENTION PROGRAMMERS: Made parallaxing skies tileable in any
2996: equal size chunk where the chunk x size is a power of 2
2997: from 16-1024. You can now make a 2048 wide parallaxing sky
2998: with 2 chunks of 1024 (gobble gobble).
2999:
3000: These lines were added to BUILD.H:
3001:
3002: #define MAXPSKYTILES 256
3003: EXTERN short pskyoff[MAXPSKYTILES], pskybits;
3004:
3005: pskyoff[MAXPSKYTILES] is an array of OFFSETS of each tile
3006: from the picnum of the parallaxing sky.
3007:
3008: pskybits is NOT the actual number of tiles, but the
3009: log (base 2) of the number of tiles. Look at this table:
3010:
3011: For 1 tile, pskybits = 0
3012: For 2 tiles, pskybits = 1
3013: For 4 tiles, pskybits = 2
3014: For 8 tiles, pskybits = 3
3015: For 16 tiles, pskybits = 4
3016: etc.
3017:
3018:
3019: I know that most teams have a 1024 wide parallaxing sky that
3020: wraps all the way around. Don't worry - this is the
3021: default now. When initengine is called, the variables
3022: default to this:
3023:
3024: pskyoff[0] = 0;
3025: pskybits = 0;
3026:
3027: You may have used a 512 wide parallaxing sky (like in my game)
3028: that repeated every 180 degrees. To make this work with
3029: the new version, set these variables like this right after
3030: initengine is called:
3031:
3032: pskyoff[0] = 0;
3033: pskyoff[1] = 0;
3034: pskybits = 1;
3035:
3036: Note that both pskyoff variables are 0 here. This will
3037: make the parallaxing sky repeat.
3038:
3039: With the new tiling, you can save memory by making small
3040: chuck sizes, such as 64 or 128, and repeating certain
3041: sections.
3042: ������������������������������������������������������������������������������
3043: 11/25/94 - Fixed some really stupid keyboard problem in Build.
3044: ������������������������������������������������������������������������������
3045: 11/29/94 - Added FLOOR SPRITES!!! Here are some things that floor sprites
3046: can do for you:
3047:
3048: * Make bridges and balconies
3049: * Use them for ceiling and floor ornamentation
3050: * Use them in place of a rotating sector - modifying 1 angle
3051: is much faster than rotating tons of points.
3052: * Weapon such as a spinning saw blade or, of course, a smiley
3053: red jelly coconut. (?)
3054: * How about a "walking" hole like in Ken's Labyrinth
3055: * You could throw a footstep on the floor every time you make a
3056: step. The steps would go away after awhile. Maybe if you
3057: step in mud, the next 16 or so footsteps will be plotted.
3058: * You could even fake radial shading with a transluscent floor
3059: sprite. (Transluscent floor sprites not yet programmed)
3060:
3061: Just imagine all the great stuff you can do with floor
3062: sprites combined with wall sprites! I can't wait to see what
3063: you all come up with!
3064:
3065: ��� To clear some confusion, and to shorten conversations, let
3066: � me give official names to my 3 kinds of sprites:
3067: �
3068: � Normal stupid sprites - "FACE SPRITES"
3069: � Rotated / masked wall sprites - "WALL SPRITES"
3070: � New ceiling & floor sprites - "FLOOR SPRITES"
3071: �
3072: � Also let me clear up the 2 kinds of clipping:
3073: �
3074: � Clipping when moving something - "MOVEMENT CLIPPING"
3075: ��� Clipping when drawing something - "VIEW CLIPPING"
3076:
3077: To make a floor sprite in BUILD, simply press 'R' on any
3078: sprite until it becomes a floor sprite. The xrepeat and
3079: yrepeat values should work perfectly with floor sprites.
3080: Floor sprites can be rotated at any of 2048 degrees, using
3081: the sprite[].ang. Press < / > for course angle adjustment
3082: or < / > with shift for fine angle adjustment. Also, you
3083: can press 'F' on a floor sprite to flip it over like a
3084: mirror. I am using another bit in sprite[].cstat to determine
3085: the type of sprite. See the documentation in BUILD.H.
3086:
3087: Now for the bad news:
3088:
3089: * Floor sprite textures have similar restrictions as normal
3090: ceilings and floors - both dimensions must be a power of 2.
3091: This will most likely not change.
3092:
3093: And some known problems which I will have to fix:
3094: * Transluscence doesn't work yet
3095: * Sorting with other sprites
3096: * View clipping with walls
3097: * Doesn't work too well in hi-res mode
3098:
3099: See NUKELAND.MAP for some examples of floor sprites. I have both
3100: a bridge and a balcony on the level. Please find them!
3101: Remember that floor sprites don't work in mode x or hi-res
3102: mode YET!
3103: ������������������������������������������������������������������������������
3104: 11/30/94 - Made WALL SPRITE and FLOOR SPRITE correctly do movement clipping.
3105: ������������������������������������������������������������������������������
3106: 12/1/94 - Made new map called BRIDGES.MAP. It is excellent! It has 3
3107: bridges all crossing each other. Enjoy!
3108:
3109: - For Editart, I added re-centering after delete and / to reset
3110: centering while in centering mode.
3111:
3112: - Debugged more of the floor sprite stuff.
3113: ������������������������������������������������������������������������������
3114: 12/2/94 - Made transluscence with floor sprites work. Check out my fake
3115: radial shading under the lights of SUBWAY.MAP.
3116:
3117: - Optimized floor sprites in assembler. Transluscent floor sprites
3118: are a bit slower than normal floor sprites.
3119: ������������������������������������������������������������������������������
3120: 12/6/94 - Made a special 1-way mode for WALL and FLOOR sprites
3121: (not FACE sprites). In BUILD 3D mode, you can press '1' on
3122: a wall or floor sprite to make it only draw if you are on
3123: 1 side of it. This method of back-face culling will not only
3124: make non-masking objects with thickness draw twice as fast,
3125: but will also make fewer drawing bugs due to sprite drawing
3126: order. Try out my BRIDGES.MAP. There's a new section at the
3127: top and it's not another "ugly Ken's face n' slime" room.
3128: ������������������������������������������������������������������������������
3129: 12/8/94 - Editart and Build now capture with capt#### rather than captur##
3130: allowing 10000 captured pictures.
3131: ������������������������������������������������������������������������������
3132: 12/23/94 - Increased Maximum number of walls to 8192.
3133: ������������������������������������������������������������������������������
3134: 12/28/94 - Made BUILD stub keys F5-F8 work in 3D mode also. See top
3135: of BSTUB.C for full documentation of some new useful
3136: variables that can be used inside the stub:
3137:
3138: extern long qsetmode;
3139: extern short searchsector, searchwall, searchstat;
3140:
3141: In 3D mode, F5 and F6 do the exact same thing and F7 and F8
3142: do the exact same thing (you don't need the extra key to
3143: distinguish between sectors, walls and sprites, since the
3144: mouse cursor can only be on 1 of the 3 objects in 3D mode.
3145:
3146: Note: Since F5-F8 are called in 3D mode, you must be sure
3147: NOT to use any 2D routines during those calls! This means
3148: you will have to put the 3D/2D case check in all six
3149: subroutines:
3150: ExtShowSectorData, ExtShowWallData, ExtShowSpriteData,
3151: ExtEditSectorData, ExtEditWallData, ExtEditSpriteData
3152:
3153: - KEN'S PROPOSAL (NOT YET DONE) I am thinking of making a new
3154: (and maybe final) map format. But before I do it, I am going
3155: to ask all of you for any suggestions on new fields to add to
3156: my 3 big structures (sector, wall, sprite):
3157:
3158: Here are a few things already on my list to add:
3159:
3160: * char sprite[].clipdist - THIS IS FOR SURE
3161: This will be a sprite's clipping distance. My default
3162: walldist is 128. With this field, you will finally be
3163: able to make a unique fatness for each sprite with no
3164: clipping bugs. I will probably shift this field up 2-4
3165: bits to give it a range of more than just 0-255.
3166:
3167: * char wall[].pal, sprite[].pal - PRETTY SURE
3168: It should have been this way the whole time. Currently
3169: the wall's palookup number is sector[].floorpal. While
3170: it may save some memory, It has too many limitations.
3171: I can make my map converter automatically convert all
3172: walls of a sector to equal the sector[].floorpal so
3173: don't worry about that type of conversion. If I do
3174: this, I can get rid of the spritepal[] hack.
3175:
3176: * I have decided that the sector[].extra, wall[].extra, and
3177: sprite[].extra will remain in the structures as little
3178: gifts for your use only. That's right! ALL YOURS!
3179: ENJOY!!!
3180:
3181: * char sprite[].xoffset, sprite[].yoffset - NOT SURE YET
3182: Some have asked for monster animations using the same
3183: frame at 2 different times of an animation sequence having
3184: different centers.
3185: These will be signed chars. I'm not sure whether to
3186: make these offsets as offsets to the centering information
3187: from Editart or just make them the absolute offsets where
3188: Editart's data is the default offset. I wonder if there's
3189: a better way to do this without having to waste 8K.
3190:
3191: * Do I have your permission to remove nextsector2 and
3192: nextwall2? Anybody using them? If so, can you use the
3193: extra variable instead? This will save 16K since both
3194: are shorts. (MAXWALLS*short + MAXWALLS*short = 16384)
3195: They were originally intended for 2 stories
3196: but it would be totally ridiculous for me even to think
3197: about programming that now. Besides, you can use wall
3198: and floor sprites to fake 2 story areas. KEN PROMISE:
3199: I will fix those darn view-clipping bugs eventually!
3200:
3201:
3202: Please send any comments/suggestions to my internet address
3203: ([email protected]) I will consider each suggestion
3204: carefully, because everything you suggest now won't have
3205: to be an ugly hack like spritepal[] later.
3206: ������������������������������������������������������������������������������
3207: 1/1/95 - ����� ������ ��� �� �� �� �� �� ������ ������ ������ ��
3208: �� �� �� ���� �� �� �� �������� �� �� �� �� �� ��
3209: �� �� �� ������� ��� ��� �������� ������ ������ ������ ��
3210: �� �� �� �� ���� ����� �� �� �� �� �� �� ��
3211: ����� ������ �� ��� ��� �� �� �� �� �� ������ ��
3212:
3213: CONVMAP6! Here is what I changed in the structures:
3214:
3215: * Added wall[].pal, sprite[].pal
3216: * Added sprite[].clipdist
3217: * Expanded sprite[].cstat to a short
3218: * Added sprite[].xoffset, sprite[].yoffset
3219: * Removed wall[].nextsector2, wall[].nextwall2
3220: * Renamed wall[].nextsector1 to just wall[].nextsector
3221: * Renamed wall[].nextwall1 to just wall[].nextwall
3222: * Scrapped numextras and extratype structure - Don't confuse
3223: this with sector[].extra, wall[].extra, sprite[].extra
3224: which ARE in map version 6.
3225:
3226: Probably the only change above that will affect programmers is
3227: getting rid of the '1' in wall[].nextsector1&wall[].nextwall1.
3228: All the following changes were possible because of the new
3229: map format.
3230:
3231: - Got rid of the spritepal array in BUILD.H. With my grea
3232: new map version 6, you can simply modify sprite[].pal!
3233:
3234: - Made all .pal fields editable in 3D EDIT MODE. Press ALT-P
3235: and simply edit the number as you would in 2D mode.
3236:
3237: - Made sprite[].xoffset and sprite[].yoffset work as
3238: offsets to the offsets that are already in EDITART.
3239: Simple addition. They should work for all 3 types
3240: of sprites.
3241:
3242: - Made BUILD Tab&Enter also copy tags&extra if copying similar
3243: structures. Also fixed some other attributes when
3244: copying between structure types.
3245:
3246: - Made sprites highlighted with Rt. Shift duplicate and stamp
3247: when the insert key is pressed in 2D EDIT MODE.
3248:
3249: - Made sprite[].clipdist work as the FACE SPRITE'S clipping
3250: fatness. NOTE: Sprite[].clipdist is shifted up 2 to
3251: allow a range from 0-1020, so if the sprite[].clipdist
3252: is set to 32, then the clipping radius is actually 128.
3253:
3254: - Removed the walldist parameter from movesprite. Movesprite
3255: now just uses the sprite[spritenum].clipdist field of
3256: whatever sprite is passed (shifted up 2).
3257:
3258: movesprite(short spritenum, long xchange, long ychange,
3259: long zchange, long ceildist, long flordist,
3260: char cliptype, long numtics)
3261:
3262: If you use clipmove or getzrange, you should check that you
3263: are passing the correct walldist parameters. I'm saying
3264: you may want to change some of the 128s to
3265: (sprite[spritenum].clipdist<<2).
3266: ������������������������������������������������������������������������������
3267: 1/3/95 - Made startumost[], startdmost[] into shorts.
3268:
3269: - Optimized and fixed gamma correction in Stereo Red-Blue mode.
3270:
3271: - Made weapons or anything using overwritesprite in Stereo Red-Blue
3272: mode be at screen depth.
3273: ������������������������������������������������������������������������������
3274: 1/4/95 - Not that anybody would care (except for some crazed mega-hackers)
3275: but I am just mentioning the fact that I did this:
3276:
3277: animateoffs(short tilenum, short fakevar);
3278: where fakevar is sectnum+0
3279: or wallnum+16384
3280: or spritenum+32768
3281: or 49152 (just ignore-it's for rotatesprite)
3282:
3283: Also: I changed one: "mov al, 0" instruction into an
3284: "xor al, al", a net savings of
3285: ONE LOUSY BYTE! Let's not get TOO
3286: excited! (By the way, just kidding)
3287: ������������������������������������������������������������������������������
3288: 1/5/95 - Fixed the sprite centering with x-flipped FACE SPRITES.
3289:
3290: - Found a bug with my swinging door clipping code. There are 2
3291: types of swinging doors, forwards (opens CCW) and
3292: backwards (opens CW). The bug was that you could sneak
3293: through a backwards door from the back side. Well, I fixed
3294: it, so now I challenge you to sneak through my swinging doors
3295: now! If you are using my swinging door code, please make
3296: these changes which you should find in my new GAME.C:
3297:
3298: 1. Changed declaration at beginning of GAME.C:
3299: static short swingwall[32][5];
3300:
3301: 2. Added new line in prepareboard:
3302: swingwall[swingcnt][4] = lastwall(swingwall[swingcnt][3]);
3303:
3304: 3. Modified some stuff in tagcode:
3305: //swingangopendir is -1 if forwards, 1 is backwards
3306: l = (swingangopendir[i] > 0);
3307: for(k=l+3;k>=l;k--)
3308: if...
3309:
3310: - Here are some more functions that have been in the engine for
3311: a while, but I forgot to document...
3312: precache, loadtile, lastwall, rotatepoint
3313: They are now documented at the top of this file.
3314: ������������������������������������������������������������������������������
3315: 1/6/95 - Optimized loading/saving of maps by using fewer read/write calls.
3316: ������������������������������������������������������������������������������
3317: 1/14/95 - Fixed evil crashing bug that I accidently introduced in the
3318: 1/3/95 version of Build. This crashing bug happened mostly
3319: in tall rooms with lots of FACE SPRITES. It used to crash
3320: very infrequently when you were standing almost exactly, but
3321: NOT on the same x & y coordinates of a FACE SPRITE where the
3322: z-distance was high.
3323: ������������������������������������������������������������������������������
3324: 1/15/95 - Fixed up network code so now you can miss 4 packets in row safely
3325: over the network rather than just 2.
3326: ������������������������������������������������������������������������������
3327: 1/16/95 - Added strafe left / strafe right keys to my SETUP.DAT file and
3328: char keys[19] array. If you actually use my keys array for
3329: custom keys, here's what to do: I inserted the new strafing
3330: keys at keys[12] & keys[13], so just add 2 to any keys with
3331: an index >= 12.
3332:
3333: - Made the sprites in 2D EDIT MODE of Build highlight properly
3334: again.
3335:
3336: - Added another parameter to permanentwritesprite, palookup number:
3337:
3338: permanentwritesprite(long thex, long they, short tilenum,
3339: signed char shade, long cx1, long cy1,
3340: long cx2, long cy2, char dapalnum);
3341: ������������������������������������������������������������������������������
3342: 1/17/95 - You can now select a bunch of sprites in 2D EDIT MODE with
3343: Rt. shift, then go to 3D mode and change the z's of all the
3344: highlighted sprites.
3345: ������������������������������������������������������������������������������
3346: 1/20/95 - Made Tab&Enter in 3D EDIT MODE copy .pal also whenever .shade is
3347: normally copied. Shift+Enter will now copy just
3348: .pal and .shade.
3349: ������������������������������������������������������������������������������
3350: 1/21/95 - Made Splitsector work with overlapping better.
3351:
3352: - In Editart 'U' mode, it now goes automatically to the PCX and
3353: coordinates of a tile if it is already in capfil.txt.
3354:
3355: - In Editart, made capt????.PCX not get overwritten if they already
3356: exist.
3357:
3358: - Fixed Build tab on masked walls.
3359:
3360: - Made zmode and kensplayerheight variables public in BUILD/BSTUB
3361: so you can now compile BUILD to start out with your own
3362: preferred settings. Kensplayerheight defaults to 32 and
3363: zmode defaults to 0. You can over-ride these settings in
3364: the new ExtInit function.
3365:
3366: - Made Editart tiles much easier to center by showing all tiles
3367: in the center of the screen instead of at the top-left corner.
3368: (Editart will not allow you to center tiles larger than
3369: 320*200 right now)
3370:
3371: - Made 'O' (optimize) key in Editart automatically preserve
3372: the centering information.
3373:
3374: - ATTENTION BSTUB PROGRAMMERS! Added ExtInit, ExtUnInit, and
3375: ExtCheckKeys to BSTUB.C. Please just copy mine into your
3376: current BSTUB. ExtInit and ExtUnInit are called only once.
3377: ExtInit is called before loadpics() and after initengine().
3378: ExtCheckKeys() is called just before nextpage in both 2D
3379: and 3D modes. In 3D mode, you must call editinput inside
3380: ExtCheckKeys just like my example in BSTUB.
3381: ������������������������������������������������������������������������������
3382: 1/24/95 - Fixed vertical line chained mode bug with permanentwritesprites.
3383: ������������������������������������������������������������������������������
3384: 1/31/95 - Fixed parallaxing sky tiling bug.
3385: ������������������������������������������������������������������������������
3386: 2/1/95 - Fixed network crashing bug when call interrupt 0x1c. You call
3387: this interrupt when you chain to the old timer handler. Now
3388:
3389: - Rewrote multiplayer code in game.c a bit. Moved both sync()
3390: and getpackets() into the main program. The master code and
3391: single player game code are now the same. Slaves need to
3392: drawscreen and send packets only when a packet is received
3393: from the master. Got rid of fake sync[MAXPLAYERS] slot by
3394: using a local sync buffers. Rewrote checkmasterslaveswitch().
3395: If you don't get what I did, it doesn't matter because you
3396: already have working network code!
3397:
3398: - Added new key in EDITART 'V' mode. Press ALT-R to generate
3399: a tile frequency report. It will scan all MAP files in the
3400: same directory as the ART files. The frequency count will
3401: show up as text in the top-left corner of the boxes in
3402: 'V' mode. Press ALT-R again to turn off text.
3403:
3404: - Perfected NCOPY! Copies about 150K / second which is 10 times
3405: faster than a 115200bps serial cable. Since NCOPY already
3406: links with multi.obj, it should not be too difficult to make
3407: joining work in the middle of a network game. Please wait
3408: until I make some sample code for you!
3409: Receiver types: NCOPY (Ex: "NCOPY")
3410: Sender types: NCOPY [filespec] (Ex: "NCOPY *.ART")
3411:
3412: Ken's formula:
3413: NCOPY + Loading&Saving GAMES = joining in middle
3414: of network game!
3415:
3416: - Made a DOOM to BUILD converter. Right now it only converts
3417: ceilings, floors, and walls now, and some of the wall
3418: textures are screwed up. Just because I converted some
3419: lousy stinkin' maps DOES NOT MEAN I AM GOING TO PROGRAM DOOM!
3420: Unfortunately, the converter is programmed in QuickBasic right
3421: now, it won't compile, and I didn't feel like putting up the
3422: 7 MEG converted ART file up. When I convert it to C, I'll
3423: upload it for all!
3424: ������������������������������������������������������������������������������
3425: 2/7/95 - Fixed overwritesprite bugs with translucence in chained mode
3426: and above top of screen.
3427:
3428: - Made bit 3 of overwritesprite x-flip the picture if set.
3429:
3430: - Optimized various parts of engine.
3431: ������������������������������������������������������������������������������
3432: 2/8/95 - Fixed shading of all sprite types so they match perfectly with
3433: their surroundings. Floor sprites now shade in the exact same
3434: way as ceilings and floors. (Before, the whole floor sprite
3435: had the same shade throughout)
3436: ������������������������������������������������������������������������������
3437: 2/9/95 - Started on loading and saving game code so I could give some
3438: sample code for joining network games, but none of it works
3439: yet, so just ignore it for now!
3440:
3441: - Added frame rate in BSTUB.C. It averages the last 16 frames.
3442: ������������������������������������������������������������������������������
3443: 2/16/95 - Added another bit to sprite[].cstat for y-centering control. If
3444: bit 7 is set then the sprite's center will be the actual
3445: center rather then at the default position which is at the
3446: bottom of the sprite. If you use this centering bit,
3447: you finally get "WYSIWYG" centering contol in EDITART.
3448: ������������������������������������������������������������������������������
3449: 2/24/95 - Made floor sprites now support any x size by a power of 2 y size.
3450: (That's better than before!) These are the same restrictions
3451: on walls.
3452: ������������������������������������������������������������������������������
3453: 2/25/95 - Got loading / saving code to work with my game. Press Ctrl-L to
3454: load game and Ctrl-S to save game. Saved games are called
3455: SAVE0000.GAME and are about 300K. Don't worry about the large
3456: sizes of the saved game files since they can be easily
3457: compressed to less than 50K.
3458: ������������������������������������������������������������������������������
3459: 2/26/95 - I Finally made my multiplayer code run with fast frame rates AND
3460: pefect controls on ALL computers of a multiplayer game. I am
3461: now sending keystrokes of all computers at a constant rate of
3462: 40 times per second. All computers interpolate between frames
3463: to get screen frame rates of higher or lower than 40 fps
3464: (even in single player mode).
3465:
3466: Here are the exact steps you will need to follow if you want to
3467: update your code:
3468:
3469: 1. WHAT'S THE FAKETIMERHANDLER()?
3470:
3471: To send packets exactly 40 times a second, it would
3472: sure be nice to send them right from the timer interrupt
3473: handler. Too bad network packets just won't get sent
3474: from the interrupt handler. (It may work from the
3475: interrupt handler in Serial/Modem mode) So the solution
3476: is to make a "fake" timer handler that must be called
3477: at least 40 times a second even on the slowest computer.
3478: Throughout my engine, I call faketimerhandler(). If you
3479: have any slow parts in your game code, you may want to
3480: called faketimerhandler() also.
3481: Besides the very first few lines, the rest of the code
3482: was taken directly from my old sync and getpackets
3483: functions.
3484:
3485: 2. BYE BYE SYNCTICS!
3486:
3487: Now that all computers are calling movethings a
3488: constant number of times a second, you don't need any
3489: synctics variables anymore. You can convert all the
3490: synctics variables to a define such as:
3491: "#define TICSPERFRAME 3"
3492: Doing this will guarantee that a game runs the same on
3493: all speed computers.
3494:
3495: 3. FRAME INTERPOLATION (optional):
3496:
3497: static long ototalclock = 0, gotlastpacketclock = 0;
3498: static long oposx[MAXPLAYERS], cposx[MAXPLAYERS];
3499: static long oposy[MAXPLAYERS], cposy[MAXPLAYERS];
3500: static long oposz[MAXPLAYERS], cposz[MAXPLAYERS];
3501: static long ohoriz[MAXPLAYERS], choriz[MAXPLAYERS];
3502: static long ozoom[MAXPLAYERS], czoom[MAXPLAYERS];
3503: static short oang[MAXPLAYERS], cang[MAXPLAYERS];
3504:
3505: Add to prepareboard:
3506: for(i=connecthead;i>=0;i=connectpoint2[i])
3507: {
3508: oposx[i] = posx[i];
3509: oposy[i] = (etc.)
3510: }
3511: ototalclock = 0;
3512: gotlastpacketclock = 0;
3513:
3514: Even though you may be getting more than 40fps, you will
3515: only be seeing 40fps unless you interpolate between frames.
3516: The oposx[], etc. variables back up the last posx[], etc.
3517: variables so you can interpolate your actually drawing
3518: position as some fraction between the two. This fraction
3519: is smoothratio.
3520: See beginning of drawscreen code. Here's where I actually
3521: calculate the interpolated position to draw the screen.
3522:
3523: for(i=connecthead;i>=0;i=connectpoint2[i])
3524: {
3525: cposx[i] = oposx[i]+mulscale(posx[i]-oposx[i],smoothratio,16);
3526: cposy[i] = oposy[i]+mulscale(posy[i]-oposy[i],smoothratio,16);
3527: cposz[i] = oposz[i]+mulscale(posz[i]-oposz[i],smoothratio,16);
3528: choriz[i] = ohoriz[i]+mulscale(horiz[i]-ohoriz[i],smoothratio,16);
3529: czoom[i] = ozoom[i]+mulscale(zoom[i]-ozoom[i],smoothratio,16);
3530: cang[i] = oang[i]+mulscale(((ang[i]+1024-oang[i])&2047)-1024,smoothratio,16);
3531: }
3532:
3533: Draw the screen using cposx[], etc. instead of posx[], etc.
3534:
3535: #pragma aux mulscale =\
3536: "imul ebx",\
3537: "shrd eax, edx, cl",\
3538: parm [eax][ebx][ecx]\
3539: modify [edx]\
3540:
3541: It reads: eax = (eax*ebx)>>cl. Unlike C, this will
3542: not overflow even if eax*ebx > 2^31, making full use of
3543: the 64-bit result of the imul instruction.
3544:
3545: 4. MOVETHINGS FIFO:
3546:
3547: static long movefifoplc, movefifoend;
3548: static signed char baksyncvel[64][MAXPLAYERS];
3549: static signed char baksyncsvel[64][MAXPLAYERS];
3550: static signed char baksyncangvel[64][MAXPLAYERS];
3551: static short baksyncbits[64][MAXPLAYERS];
3552:
3553: Add to prepareboard: movefifoplc = 0; movefifoend = 0;
3554:
3555: It is bad to call movethings inside faketimerhandler
3556: because you don't want things to move while you're drawing
3557: the screen. To solve this, I made movethings just save
3558: away the parameters it was called with using a circular
3559: buffer, and when I'm actually ready to DO the movement code,
3560: I call domovethings.
3561: Rename movethings to domovethings and see my new
3562: movethings. This code is all for the fifo.
3563:
3564: Put this line in movethings:
3565: gotlastpacketclock = totalclock;
3566:
3567: At the top of domovethings, copy my code for loading off
3568: of the fifo. Also set oposx[] = posx[], etc. here.
3569:
3570: 5. You may want to add a global variable that controls whether
3571: you are in continuous packet sending mode or not. Only
3572: in the main loop should ready2send be != 0.
3573: static long ready2send = 0;
3574:
3575: 6. The new main loop can be as short as this, with no case
3576: checking for masters and slaves.
3577:
3578: ready2send = 1;
3579: while (keystatus[1] == 0) //Main loop starts here
3580: {
3581: //Actaully move everything here.
3582: while (movefifoplc != movefifoend) domovethings();
3583:
3584: //Second parameter is for frame interpolation,
3585: //A fraction that ranges from 0-65536.
3586: drawscreen(screenpeek,(totalclock-gotlastpacketclock)*(65536/TICSPERFRAME));
3587: }
3588: ready2send = 0;
3589: ������������������������������������������������������������������������������
3590: 3/6/95 - New key in BUILD. Now when you use relative alignment mode on
3591: ceiling and floor textures, you can press Alt-F on the ceiling
3592: or floor to choose a new wall to align to. It actually
3593: rotates the walls of a sector by 1.
3594:
3595: - Fixed screen capture PCX saving bug in both EDITART and BUILD.
3596:
3597: - Added a parameter to screencapture, a filename.
3598: screencapture(char *filename)
3599: Ex: screencapture("captxxxx.pcx");
3600: Please specify the full filename. Screencapture will modify
3601: the 4 x's of the string to be a number starting at 0000.
3602: ������������������������������������������������������������������������������
3603: 3/8/95 - Made my rotatesprite function use Editart centering information.
3604: The center is the pivot point of rotation.
3605:
3606: - Added y-flipping to overwritesprite. See above documentation.
3607:
3608: - Added 2 new parameters to rotatesprite, shade and pal
3609:
3610: rotatesprite (long sx, long sy, long z, short a,
3611: short picnum, signed char shade, char pal);
3612:
3613: ������������������������������������������������������������������������������
3614: 3/10/95 - Fixed sprite showing through closed sectors bug.
3615:
3616: - Made it possible to draw the overhead map in 3D mode by adding
3617: a line drawing function in 3D mode called drawline256. It
3618: draws a line clipped to the viewing rectangle last set in
3619: setview(). Here are the parameters:
3620:
3621: drawline256(long x1, long y1, long x2, long y2, char col);
3622:
3623: Note: The coordinates are all shifted up 12.
3624: Example: drawline256(0L,0L,319L<<12,199L<<12,31);
3625: ������������������������������������������������������������������������������
3626: 3/11/95 - Made drawline256 draw in a cleaner way, making use of the full
3627: 12 bits of precision.
3628: ������������������������������������������������������������������������������
3629: 3/14/95 - Optimized / cleaned up parts of hitscan, neartag, cansee.
3630: Gee, I hope they all still work!
3631: ������������������������������������������������������������������������������
3632: 3/18/95 - I'm back in RI!
3633:
3634: - Fixed recently added movesprite z parameter bug that may have
3635: done strange things with monsters, such as stuck in sectors
3636: I thought the following expression: !(cstat&128)
3637: would be true if bit 7 was a 0, but I WAS WRONG!
3638: Get this straight:
3639: ! - logical NOT, returns 0 if != 0 else 1 (!2457=0, !0=1)
3640: ~ - bitwise NOT, xor's it with 0xffffffff (~0x5f=0xa0)
3641: ������������������������������������������������������������������������������
3642: 3/21/95 - Gave access to some more variables in BSTUB.
3643:
3644: - Made clipmove return a valid sector even if you're not between
3645: its ceiling and floor. If you use overlapping sectors,
3646: clipmove will find the sector closest to your z.
3647: ������������������������������������������������������������������������������
3648: 3/28/95 - Optimized transluscence for masked walls and wall sprites.
3649:
3650: - Today is the day I declare my serial/modem error correction code
3651: perfect! Sure, I may have bragged over and over again about
3652: how perfect my correction method is each time, but this time
3653: I mean it. This is ship-it quality error correction. The old
3654: method had a few dark, evil, and ugly bugs that sometimes
3655: totally screwed up bigtime.
3656: ������������������������������������������������������������������������������
3657: 4/5/95 - Got Master/Slave switching to stay in sync again with new
3658: multiplayer code. Right after the master sends a packet
3659: where a switch is made, I disable the master from sending
3660: any more packets by setting ready2send to 0. Ready2send
3661: will be set back to 1 only after the actual switch in
3662: checkmasterslaveswitch. Here's what I added to movethings:
3663:
3664: //Do this for Master/Slave switching
3665: for(i=connectpoint2[connecthead];i>=0;i=connectpoint2[i])
3666: if (syncbits[i]&512) ready2send = 0;
3667: ������������������������������������������������������������������������������
3668: 4/10/95 - Optimized continuous setview calls between 2 different window
3669: sizes.
3670:
3671: - ATTENTION PROGRAMMERS: Moved movesprite code into game.c. It
3672: no longer exists in the engine. It is a "cover-up" function
3673: and it should be yours.
3674:
3675: - Added a circular keyboard buffer to my keyboard handler. It is
3676: fully compatible with the keystatus arrays. Use this buffer
3677: for typing in messages or cheat codes. If you do not use this
3678: buffer (or you wrote your own interrupt handler), you will miss
3679: keys and it is very annoying.
3680:
3681: I added these variables to build.h:
3682:
3683: #define KEYFIFOSIZ 64
3684: EXTERN volatile char keyfifo[KEYFIFOSIZ],
3685: keyfifoplc, keyfifoend;
3686:
3687: Every time a key is pressed and released, I add 2 bytes to the
3688: circular buffer. The first byte is the scan code. The second
3689: byte is a 1 for key pressed or 0 for key released. You can
3690: ignore the key releases if you wish. You must read 2 bytes at
3691: a time from this buffer.
3692: (scancode,keystat),(scancode,keystat),...
3693:
3694: Here's how you read the keyboard fifo:
3695: while (keyfifoplc != keyfifoend) //More characters to read
3696: {
3697: ch = keyfifo[keyfifoplc];
3698: keystate = keyfifo[(keyfifoplc+1)&(KEYFIFOSIZ-1)];
3699: //Increment buffer pointer
3700: keyfifoplc = ((keyfifoplc+2)&(KEYFIFOSIZ-1));
3701:
3702: printf("Scancode: %d, status: %d\n",ch,keystate);
3703: }
3704:
3705: The interrupt handler does the same as above but writes and
3706: increments using keyfifoend as the index.
3707: You can easily clear the buffer this way:
3708: keyfifoplc = keyfifoend
3709:
3710: - Made clipmove/getzrange not clip on the back side of a 1-sided
3711: wall/floor sprite. It makes the clipping a little faster
3712: and seems to fix a few minor clipping bugs. Don't get too
3713: excited.
3714:
3715: - Fixed getzrange's ceilz/florz mismatch with floor sprites against
3716: normal ceilings and floors.
3717:
3718: - Made Build default to y-centered centering mode when sprites
3719: are inserted (bit 7 of sprite[].cstat)
3720:
3721: - Fixed clipmove bugs with y-centered centering mode.
3722:
3723: - Made it so you don't get stuck sliding along multiple properly
3724: aligned wall/floor sprites.
3725:
3726: - Please update to my new tables.dat.
3727: ������������������������������������������������������������������������������
3728: 4/11/95 - Optimized parts of clipmove / getzrange. Is it faster? Did I
3729: make more bugs?
3730:
3731: - Made the movesprite code in GAME.C now use getzrange. This
3732: allows sprites to walk on floor sprites and bombs roll across
3733: bridges. I will include the original movesprite code that
3734: came from the engine in case you want to start with things
3735: the way they used to be.
3736:
3737: - Made ornamentation in BUILD 3D mode much easier. Now you can
3738: press 'S' to insert a sprite on walls (not just ceilings
3739: and floors). When you insert a sprite on a wall, it will
3740: automatically be set to a wall sprite at the wall's angle.
3741: Also it will be 1-sided with blocking off (The optimal
3742: options for a decorative sprite on a wall).
3743:
3744: - Added ALT-D to BUILD 3D mode. It lets you type in clipdist
3745: for sprites. It works in the same way as ALT-P for palookup
3746: changing.
3747:
3748: ������������������������������������������������������������������������������
3749: 4/15/95 - Fixed return value bug in setanimation and cleaned up these 3
3750: functions: doanimations, getanimationgoal, setanimation.
3751: Since they are now in game.c, you will need to copy them to
3752: update.
3753: ������������������������������������������������������������������������������
3754: 4/16/95 - Fixed hitscan not passing through loops bug.
3755:
3756: - Fixed hitscan so it hits wall and floor sprites in the right
3757: places.
3758:
3759: - ATTENTION PROGRAMMERS!!! Made bit 8 of sprite[].cstat the
3760: hitscan clipping bit. It works like the hitscan bit for walls.
3761: Note that both the wall and sprite cstat variables now have
3762: 2 separate bits for clipping, where:
3763: 1 is for use with the clipmove/getzrange function and
3764: 1 is for use with the hitscan function only.
3765: Before, hitscan used to use 1 bit for all sprite clipping.
3766: In your maps, the sprite hitscan bits are all zeros. That's bad!
3767: To make things work like they used to, the sprite hitscan bit
3768: must be set equal to the old sprite blocking bit. So I was nice
3769: enough to make a program, FIXSPRBT.EXE, which will do just that.
3770:
3771: PLEASE RUN FIXSPRBT.EXE ON ALL YOUR MAPS. You don't HAVE to
3772: run it on all your maps since the map format hasn't changed, but
3773: it will save you annoying attribute setting time if you do.
3774:
3775: - Did a few things to make these blocking bits easier to edit:
3776: Since H and ALT-H were already used, I made CTRL-H toggle the
3777: hitscan bit for both walls and sprites in 2D mode. B toggles
3778: the blocking bit. B also now sets the hitscan bit to its
3779: default value when you press it. For sprites, the hitscan bit
3780: default is equal to the clipmove bit. For walls, the hitscan
3781: bit default is always 0.
3782:
3783: - Added new map mode! Check it out in my game. I now have 3 map
3784: modes. Not that this really matters to you game programmers, but
3785: this is how my game works:
3786: dimensionmode[snum] == 1 3D MODE + junky line map
3787: dimensionmode[snum] == 2 SUPER MAP!
3788: dimensionmode[snum] == 3 3D MODE
3789:
3790: I added show2dsector to BUILD.H which controls which works
3791: like the other show2d... bit arrays. It tells which sectors
3792: to show.
3793: EXTERN char show2dsector[MAXSECTORS>>3];
3794:
3795: I rewrote parts of drawoverheadmap to accommodate this new
3796: mode - so it would be nice if you updated to my new code.
3797:
3798: Added a new function that clears full screen to a specified
3799: color:
3800: clearview(0L);
3801:
3802: Oh and did I forget to mention the big function! Parameters
3803: are the exact same my drawoverheadmap function:
3804: drawmapview(cposx,cposy,czoom,cang);
3805:
3806: Note: The new map mode right now is slowed down bigtime by
3807: the face sprites using the rotatesprite function. The
3808: rotatesprite right now is using a worse than awful
3809: algorithm. When I optimize rotatesprite, the frame rate
3810: of the new map mode will fly!
3811: ������������������������������������������������������������������������������
3812: 4/18/95 - Added default sprite cstat variable when you insert new sprites.
3813: Set it to 0 if you hate the new centering mode in ExtInit
3814: or 128 if you like the new centering mode.
3815: Add this line to your Bstub if you wish:
3816: extern short defaultspritecstat;
3817:
3818: - If a wall & sprite are same distance away using hitscan, hitscan
3819: now chooses the sprite.
3820:
3821: - Optimized rotatesprite.
3822:
3823: - ATTENTION PROGRAMMERS: Added new paramater at end of
3824: rotatesprite: A char where the first bit tells it to use
3825: transluscence mode or not.
3826:
3827: rotatesprite(long sx, long sy, long z, short a, short picnum,
3828: signed char dashade, char dapalnum, char dastat)
3829:
3830: if ((dastat&1) == 0) - no transluscence
3831: if ((dastat&1) != 0) - transluscence
3832:
3833: - Cleaned up drawmapview further by making ALL floor sprite draw
3834: with the texture in the right place and made the polygon
3835: filling algorithm use higher screen coordinate precision.
3836: ������������������������������������������������������������������������������
3837: 4/19/95 - Added parameter to makepalookup:
3838:
3839: makepalookup(long palnum, char *remapbuf,
3840: signed char r, signed char g, signed char b,
3841: char dastat)
3842:
3843: if ((dastat&1) == 0) then makepalookup will allocate & deallocate
3844: the memory block for use but will not waste the time creating
3845: a palookup table (assuming you will create one yourself)
3846: if ((dastat&1) != 0) then makepalookup will allocate & deallocate
3847: the memory block AND create a palookup table using the rgb
3848: values you pass.
3849:
3850: - Made my ceiling&floor update the self-modified palookup pointers
3851: when palookup[sector[].?pal] changes, not just when
3852: sector[].?pal] changes. Watching for changing pointers rather
3853: than changing indeces should solve the problem with screwy
3854: palookup selection for ceilings&floors. Ignore what I said
3855: before. You should now be able to change palookup pointers
3856: freely.
3857:
3858: - Optimized relative alignment. It should be the same speed as
3859: all other ceilings & floors now.
3860:
3861: - Warning: Since I added the new bit in sprite[].cstat, there are
3862: now 9 bits in use. Make sure to treat it as a short. In my
3863: code, I had some bugs where I did this:
3864: sprite[].cstat &= (255-4); BAD! Cstat's a short! Please
3865: check your code and make sure you clear the bits this way:
3866: sprite[].cstat &= ~4;
3867: ������������������������������������������������������������������������������
3868: 4/21/95 - Fixed bug with flipping textures on ceilings & floors. In
3869: BUIL0419.ZIP I had a bug whenever a ceiling or floor texture
3870: had bit 4 set. It drew the texture backwards. Well, I
3871: fixed it. Hope you didn't "Build" on this bug!
3872: ������������������������������������������������������������������������������
3873: 4/22/95 - Fixed really really stupid hitscan returning sector < 0 bug. If
3874: you were calling hitscan from the top-left triangular region
3875: of the board it stupidly returned a -1 for the sector. Well,
3876: I fixed it.
3877:
3878: - ATTENTION EVERYBODY!!! Moved setup.dat loading from the engine
3879: into GAME.C and BSTUB.C. If you copy this code from game.c
3880: into your game / bstub, they will work like it used to:
3881:
3882: ----- NEW GLOBAL VARIABLES: -----
3883:
3884: #define NUMOPTIONS 8
3885: #define NUMKEYS 19
3886: static long chainxres[4] = {256,320,360,400};
3887: static long chainyres[11] = {200,240,256,270,300,350,
3888: 360,400,480,512,540};
3889: static long vesares[7][2] = {320,200,640,400,640,480,
3890: 800,600,1024,768,
3891: 1280,1024,1600,1200};
3892: static char option[NUMOPTIONS] = {0,0,0,0,0,0,1,0};
3893: static char keys[NUMKEYS] =
3894: {
3895: 0xc8,0xd0,0xcb,0xcd,0x2a,0x9d,0x1d,0x39,
3896: 0x1e,0x2c,0xd1,0xc9,0x47,0x49,
3897: 0x9c,0x1c,0xd,0xc,0xf,
3898: };
3899:
3900: ----- Put this where you call initengine -----
3901:
3902: long fil;
3903:
3904: if ((fil = open("setup.dat",O_BINARY|O_RDWR,S_IREAD)) != -1)
3905: {
3906: read(fil,&option[0],NUMOPTIONS);
3907: read(fil,&keys[0],NUMKEYS);
3908: close(fil);
3909: }
3910: if (option[3] != 0) moustat = initmouse();
3911:
3912: switch(option[0])
3913: {
3914: case 0: initengine(0,chainxres[option[6]&15],chainyres[option[6]>>4]); break;
3915: case 1: initengine(1,vesares[option[6]&15][0],vesares[option[6]&15][1]); break;
3916: case 2: initengine(2,320L,200L); break;
3917: case 3: initengine(3,320L,200L); break;
3918: case 4: initengine(4,320L,200L); break;
3919: case 5: initengine(5,320L,200L); break;
3920: case 6: initengine(6,320L,200L); break;
3921: }
3922:
3923: ----- That's it! -----
3924:
3925: Initengine now has 3 parameters:
3926: initengine(char davidoption, long daxdim, long daydim)
3927: See revised initengine description at the top of this file.
3928:
3929: Now that engine.c doesn't use setup.dat, you can use your
3930: own setup program.
3931:
3932: Don't forget to update BSTUB!
3933:
3934: NOTE!!! While MY setup program allows you select many different
3935: video modes, no new modes are supported yet in BUILD!
3936: (It's on my list.)
3937:
3938:
3939: - Fixed keyboard repeating.
3940: ������������������������������������������������������������������������������
3941: 4/26/95 - Hi-res now works in all modes! The code I gave in the 4/22/95
3942: description is still perfectly valid, so please copy it if
3943: you haven't already looked at it. Here are some important
3944: new variables I put in BUILD.H:
3945:
3946: EXTERN char vidoption;
3947: EXTERN long xdim, ydim, ylookup[MAXYDIM+1];
3948:
3949: Vidoption is simply the first parameter you pass to
3950: initengine. Xdim and Ydim are the screen sizes you pass to
3951: initengine, such as 320*200 or 640*480.
3952: Ylookup is a lookup table that works like this:
3953: If (vidoption == 0) ylookup[i] = ((i*xdim)>>2);
3954: if (vidoption != 0) ylookup[i] = i*xdim;
3955: There is 1 exception: If you are using a chained mode which
3956: can only fit only 1 viewing page, then the engine actually
3957: does a screen-buffer mode and blits to the chained screen
3958: so for this case, ylookup[i] = i*xdim.
3959:
3960: - Added bit to the dastat parameter of rotatesprite.
3961: if ((dastat&2) != 0) - align to screen size so the gun or
3962: whatever is always over the same relative spot of the screen.
3963: Works like bit 2 of the flags parameter in overwritesprite.
3964:
3965: - Added pixel writing and reading that will work in all BUILD
3966: graphics modes. They work just like you think they should.
3967:
3968: plotpixel(long x, long y, char col);
3969: char getpixel(long x, long y);
3970:
3971: Please do not overuse these functions! They are NOT intended
3972: for fast drawing!
3973:
3974: - Changed tables.dat so parallaxing skies at high resolutions
3975: work accurately.
3976:
3977: - I made bit 15 of sprite[].cstat the invisible bit. If it is
3978: set, then the sprite won't even be considered for sorting and
3979: there is absolutely no speed loss due to its existence. It is
3980: faster to use this bit then manually set thesprite[] to -1.
3981:
3982: Since drawrooms collects the list of sprites drawmasks is about
3983: to sort, make sure the bit is set before drawrooms. If you use
3984: frame interpolation, you usually want to tell drawmasks somehow
3985: to not draw yourself. Before you used to use the
3986: thesprite[] = -1 trick. Now you do it like this:
3987:
3988: sprite[i].cstat |= 0x8000; //Set invisible bit
3989: drawrooms(posx,posy,etc.);
3990: sprite[i].cstat &= ~0x8000; //Restore invisible bit
3991:
3992: - Fixed distance overflow bug (the one that showed garbage
3993: textures if a wall was really far away).
3994: ������������������������������������������������������������������������������
3995: 4/27/95 - Made an example board, MONWALK.MAP, where monsters walk along
3996: a bridge with no railing, onto a sector, and even up and down
3997: a stairway without falling off it. If you shoot a brown so
3998: it's almost dead, it will turn transluscent. If it's
3999: transluscent, it won't shoot bullets. It is much easier to
4000: test the monsters' walking when they don't shoot!
4001:
4002: - Try my new and improved fake network player mode! Each fake
4003: network player now gets their own window. Use insert and
4004: delete to add or remove players. Use Scroll lock to switch
4005: which window you control. If you have a Pentium, I would
4006: recommend trying this out in 640*480 mode.
4007:
4008: - Noticed a bug with my movesprite code:
4009: For clipmove, I was getting the z-coordinate right, but for
4010: getzrange I forgot to subtract half the sprite's height if
4011: the sprite was using the real centered centering mode.
4012:
4013: These lines set daz to the actual center of sprite i no matter
4014: what centering mode is used:
4015:
4016: daz = sprite[i].z;
4017: if ((sprite[i].cstat&128) == 0)
4018: daz -= ((tilesizy[sprite[i].picnum]*sprite[i].yrepeat)<<1);
4019: ������������������������������������������������������������������������������
4020: 4/28/95 - ATTENTION PROGRAMMERS! When a tile is not in the cache:
4021: Before it used to be this:
4022:
4023: if (waloff[tilenum] == -1) loadtile(tilenum);
4024: or
4025: if (waloff[tilenum] < 0) loadtile(tilenum);
4026:
4027: Now it's this:
4028:
4029: if (waloff[tilenum] == 0) loadtile(tilenum);
4030:
4031: PLEASE MODIFY YOUR CODE IF YOU USE WALOFF!
4032:
4033: Windows can allocate memory with addresses so high, they
4034: are negative. That makes the (waloff[tilenum] < 0)
4035: method totally stupid and attempt to reload from disk
4036: the tile constantly! I can think of 3 reasons why I
4037: originally designed my system in this fashion:
4038: mestupid, mestinx, and merottts.
4039:
4040: - Fixed visibility for different screen sizes.
4041:
4042: - ATTENTION PROGRAMMERS! Now multiply by visibility rather than
4043: shift right by visiblity so you get a broader range of
4044: visibility. If you want the visiblity to work like before,
4045: use this conversion table:
4046:
4047: Old visibility New visibility
4048: 8 -> 16384
4049: 9 -> 8192
4050: 10 -> 4096
4051: 11 -> 2048
4052: 12 -> 1024
4053: 13 -> 512
4054: 14 -> 256
4055: 15 -> 128
4056:
4057: - Made Alt-F make the selected wall the first wall of a sector.
4058: This is useful for quick relative alignment adjustments.
4059: Alt-F for 2D and 3D modes may not work for sectors with loops
4060: inside of them.
4061: ������������������������������������������������������������������������������
4062: 5/1/95 - Optimized horizontal line setup code from 9 multiplies to
4063: 7 multiplies.
4064:
4065: - Fixed dark vertical lines in parallaxing skies bug I recently
4066: introduced.
4067:
4068: - Optimized horizontal line assembly code so it doesn't use the
4069: awful SHLD instruction any more. This is a good speed
4070: improvement for Pentiums only.
4071: ������������������������������������������������������������������������������
4072: 5/2/95 - Added some code to my GAME.C which detects when a computer gets
4073: out of sync in a multiplayer game. It's not as easy as you
4074: may think with all the faketimerhandler and fifo crap. If
4075: you want to put this code in your game, search all areas in
4076: my code with the keyword "syncval".
4077:
4078: - Fixed palookup crashing bug.
4079: ������������������������������������������������������������������������������
4080: 5/6/95 - Moved windowx1, windowy1, windowx2, windowy2 variables into
4081: BUILD.H. They are the exact parameters you passed to the
4082: last setview call. Please DO NOT modify them directly.
4083: Use setview to modify them.
4084: ������������������������������������������������������������������������������
4085: 5/10/95 - Fixed makepalookup bug when shading to non 0.
4086:
4087: - Fixed palookup pointer setting bug.
4088:
4089: - ATTENTION PROGRAMMERS! I made a new cacheing system which allows
4090: any type of object to be allocated in my cache, such as
4091: artwork tiles and sounds or whatever else you may want to
4092: put on the cache. This may or may not affect you. If you
4093: haven't been hacking into my code, then you shouldn't have to
4094: change your code. The cacheing routines have been moved into
4095: a separate module, cache1d.obj. If you link engine.obj, then
4096: you must also link cache1d.obj. Please update your makefiles.
4097:
4098: For anybody who may want to re-write my cacheing system, here's
4099: how it now works: (I have only 3 functions in cache1d.obj
4100: right now, initcache, uninitcache, and allocache)
4101:
4102: Allocate a nice BIG buffer, like from 1MB-4MB and
4103: call initcache(long cachestart, long cachesize) where
4104:
4105: cachestart = (long)(pointer to start of BIG buffer)
4106: cachesize = length of BIG buffer
4107:
4108: Ex: initcache(FP_OFF(pic),cachesize);
4109:
4110: Loadpics calls this function for you so you don't normally
4111: need to call it.
4112:
4113: call allocache(long ptr, long siz) whenever you need to
4114: allocate a temporary buffer, where
4115:
4116: ptr = (long)(pointer to (4-byte pointer to thing))\
4117: siz = number of bytes
4118:
4119: Ex: if (waloff[tilenume] == 0)
4120: allocache((long)&waloff[tilenume],walsiz[tilenume]);
4121:
4122: Allocache is totally tile independent. To allocate a sound
4123: on the cache, you can call allocache.
4124:
4125: There are 3 functions in the engine which help manage the
4126: cache for you: loadpics - calls initcache
4127: loadtile - calls allocache
4128: allocatepermanenttile - special function
4129: that allocates permanent memory
4130: from the cache.
4131:
4132: - Fixed clipmove crashing bug when passing a sectnum < 0. Whenever
4133: you moved in BUILD and you weren't in a valid sector, memory
4134: was getting trashed.
4135: ������������������������������������������������������������������������������
4136: 5/12/95 - Added ExtPreCheckKeys(void) to BSTUB.C. It is called before
4137: drawrooms / drawmasks in 3D mode, whereas ExtCheckKeys(void)
4138: is called after drawrooms / drawmasks (and before nextpage).
4139:
4140: - Added bit to flags of rotatesprite to allow x-flipping. See
4141: updated documentation.
4142: ������������������������������������������������������������������������������
4143: 5/17/95 - Added aspect ratio for those weird modes like 320*400, etc.
4144: You could call setaspect to properly adjust a mode that is
4145: not exactly correct, or for special effect that stretch
4146: the screen.
4147:
4148: In ENGINE.OBJ, I added a function, setaspect(long daaspect),
4149: where you pass the Y/X aspect ratio scaled up 16 bits, so
4150: 65536 would be normal. You don't need to call this if you
4151: don't want to. By default, in setview, I call setaspect
4152: with these parameters:
4153:
4154: setaspect(divscale16(ydim*320,xdim*200));
4155: (also written as:)
4156: setaspect(((ydim*320)<<16)/(xdim*200));
4157:
4158: Note that in 320*200 mode the value passed would be 65536
4159: which is a 1:1 aspect ratio.
4160:
4161: In BUILD.H, I added yxaspect and xyaspect.
4162:
4163: When you call setaspect(daaspect),
4164:
4165: yxaspect = daaspect;
4166: xyaspect = (1<<32) / yxaspect; //reciprocal
4167: and other internal variables, so DON'T MODIFY YXASPECT
4168: AND XYASPECT DIRECTLY!
4169:
4170: Since drawmapview is also affect by the aspect ratio, you
4171: will need to make sure drawoverheadmap is affected so
4172: the map modes match up. Please look at and copy my updated
4173: drawoverheadmap function into your GAME.C if you use it.
4174: ������������������������������������������������������������������������������
4175: 5/18/95 - Revised caching system so it supports locking.
4176: Here are the new parameters to allocache:
4177:
4178: allocache(long *bufptr, long bufsiz, char *lockptr)
4179: *bufptr = pointer to 4-byte pointer to buffer
4180: bufsiz = number of bytes to allocate
4181: *lockptr = pointer to 1-byte locking char. 1=locked, 0=not
4182:
4183: And uninitcache works a little differently too:
4184: Call uninitcache(0) to remove all UNLOCKED items or
4185: Call uninitcache(1) to remove ALL items.
4186: After calling uninitcache, you do not need to call
4187: initcache to use the cache again.
4188: ������������������������������������������������������������������������������
4189: 5/21/95 - Made changespritesect and changespritestat return 0 instead of -1
4190: when changing to same value.
4191: ������������������������������������������������������������������������������
4192: 5/25/95 - Added relative visibility for sectors. In 3D EDIT MODE, use
4193: ALT+(keyp.)+/- to change an individual sector's visibility.
4194: Press Shift in addition for fine visibility changine. By
4195: default you change it by 16. Press CTRL+ALT+(keyp.)+/- to
4196: change the global visibility. The global visibility is not
4197: saved in the map.
4198:
4199: - Can now delete many sectors at a time. Select sectors with the
4200: rt. Alt. Then press Ctrl-delete on any highlighted sector to
4201: delete all the highlighted sectors.
4202:
4203: - Fixed build sometimes not saving when quitting from 2D mode bug.
4204: ������������������������������������������������������������������������������
4205: 5/27/95 - Fixed bugs in network work that should make it miss packets
4206: much less often than before.
4207:
4208: - Fixed bug in ncopy so it shouldn't halt or crash anymore.
4209:
4210: - Added spritecstat[] the thesprite arrays. Please use my
4211: thesprite arrays rather than modifying the sprite directly
4212: since hitscan and clipmove use bits 4 and 8 of sprite[].cstat.
4213:
4214: - ATTENTION PROGRAMMERS: Added 1 parameter to neartag that will
4215: allow you to search only lotags or only hitags. See updated
4216: documentation above.
4217:
4218: neartag (long xs, long ys, long zs, short sectnum, short ange,
4219: short *neartagsector, short *neartagwall, short *neartagsprite,
4220: long *neartaghitdist, long neartagrange, char tagsearch)
4221:
4222: If tagsearch = 1, neartag searches lotag only
4223: If tagsearch = 2, neartag searches hitag only
4224: If tagsearch = 3, neartag searches lotag&hitag
4225:
4226: Neartag used to always search both lotag&hitag.
4227: ������������������������������������������������������������������������������
4228: 5/30/95 - Added ExtAnalyzeSprites(void) to BSTUB and a spriteshade array
4229: to BUILD.H.
4230:
4231: - Made circle drawing in 2D EDIT MODE work better at large sizes.
4232: ������������������������������������������������������������������������������
4233: 6/5/95 - Added shareware / registered artwork version control to EDITART.
4234: In 'V' mode, when you press ALT-R to get a report of tile
4235: frequencies of tiles on all the maps in the current directory,
4236: you can toggle the shareware/registered bit with the space bar.
4237: This bit is saved in the top bit of the picanm bits so it is
4238: stored permanently in the art file. Press ALT-D in this mode
4239: to automatically delete all registered tiles. Please before
4240: you do the deleting phase, copy all artwork to a temporary
4241: directory!!! It is safe, however, the toggle the new bit in
4242: the full version.
4243: ������������������������������������������������������������������������������
4244: 6/7/95 - Made 3 main structures defined with typedef so struct prefix
4245: is no longer needed with sectortype, walltype, and spritetype.
4246:
4247: - Added new function to engine:
4248:
4249: short sectorofwall(short dawall);
4250:
4251: It returns the sector of a given wall. It is well optimized
4252: including sector[sector[].nextwall].nextsector if a red wall
4253: and a binary search on the sector[].wallptr's if it is a
4254: white wall. On average, sectorofwall should have to scan
4255: through only 10 different sector indeces to find the right
4256: sector (not 1024!).
4257:
4258: - ATTENTION PROGRAMMERS! Made all the separate thesprite arrays
4259: into a single array of sprite structures call tsprite. See
4260: BUILD.H!!! This means:
4261:
4262: spritepicnum[i] is now tsprite[i].picnum
4263: spritex[i] is now tsprite[i].x
4264: spritey[i] is now tsprite[i].y
4265: spritez[i] is now tsprite[i].z
4266: spriteshade[i] is now tsprite[i].shade
4267: spritecstat[i] is now tsprite[i].cstat
4268: spritepal[i] is now tsprite[i].pal
4269: thesprite[i] is now tsprite[i].owner <<<============
4270:
4271: Everything above is straight forward, except for thesprite,
4272: which has been renamed to owner.
4273:
4274: All other tsprite parameters, such as .xrepeat, .yoffset,
4275: etc. can also be modified without changing the real
4276: sprite structure so the game won't out of sync.
4277:
4278: - Made tsprite[].statnum be a priority variable for sorting sprites
4279: that are the exact same distance from you. I think higher
4280: means more in front.
4281:
4282: - Made clipmove allow you to cross any red sector line when the z's
4283: of the next sector are farther apart. This may solve clipping
4284: bugs such as when you're in water. You may be able to remove
4285: some work-arounds you may have programmed previously.
4286:
4287: - NEW FILE GROUPING SYSTEM!!!
4288: My system will first search for the stand-alone file in the
4289: directory. If it doesn't find it, then it will search for it
4290: in the group file. If it still doesn't find it then -1 city.
4291: Use KGROUP.EXE to create a grouped file from a lot of other
4292: files. Type KGROUP [grouped filename][filespec][filespec][...]
4293: For example this line will create the new grouped file,
4294: stuff.dat, including all the following files specified:
4295: kgroup stuff.dat *.art *.map tables.dat palette.dat
4296: Feel free to make your own batch files. If there is demand,
4297: I can make kgroup support appending, replacing, and extraction.
4298:
4299: Here is the file format of a grouped file:
4300: �����������������������������������������������������������������Ŀ
4301: � 12 bytes - File grouping ID �
4302: � 4 bytes - Number of files �
4303: �����������������������������������������������������������������Ĵ
4304: �For each file: (16 bytes per file) �
4305: � 12 bytes - Filename with extension (13th byte would be a 0) �
4306: � 4 bytes - Length of file �
4307: �����������������������������������������������������������������Ĵ
4308: � Pure, raw file data, ordered just like you think it would be �
4309: �������������������������������������������������������������������
4310: There just couldn't be a simpler format. This format is so
4311: hacker happy that when you view it in a hex editor, all the
4312: filenames line up perfectly since they're multiples of 16.
4313: Anybody who can't figure this out, of course, not only rots,
4314: but is probably one of those really stupid people who would
4315: actually "pay" to get the full version of a game.
4316:
4317: The engine currently supports grouping for:
4318: *.ART, *.MAP, TABLES.DAT and PALETTE.DAT. If you want
4319: to group your own files, you will have to use my loading
4320: routines rather than the standard ones for those files. My
4321: file routines are basically an extra layer around the standard
4322: lo-level functions. Look at these 5 routines I currently
4323: support:
4324:
4325: Welcome to the K-routines!
4326: open -> kopen4load(char *filename)
4327: read -> kread(long handle, void *buffer, long leng)
4328: lseek -> klseek(long handle, long offset, long whence)
4329: filelength -> kfilelength(long handle)
4330: close -> kclose(long handle)
4331:
4332: Note that you only pass the filename to my kopen4load function.
4333:
4334: Here are 2 other routines that you MUST use, whether you like
4335: my file grouping system or not:
4336:
4337: initgroupfile(char *groupfilename)
4338: Call this with the name of your grouped file before
4339: any possible file loading will the k-routines. Note that
4340: tables.dat uses the k-routines and it is in initengine().
4341: Please don't give your grouped filename an extension that
4342: starts with W, ends with D, and has a vowel in between.
4343: And don't even bother to write your own file grouping
4344: system because even if you do, people still have to write
4345: their own new utilities to read the ART and MAP files.
4346:
4347: uninitgroupfile()
4348: Call before quitting to DOS.
4349: ------------------------------------------------------
4350: - ATTENTION PROGRAMMERS! Changed kopen4load from:
4351:
4352: kopen4load(char *filename)
4353: to:
4354: kopen4load(char *filename, char searchfirst)
4355:
4356: where:
4357: if searchfirst = 0 then search stand alone first then group file
4358: if searchfirst = 1 then search group file only
4359: ������������������������������������������������������������������������������
4360: 6/12/95 - Tracked down an OUT OF SYNC bug with my multiplayer code!
4361: In my GAME.C, the way I had my sync arrays organized were
4362: wrong. The problem was that if faketimerhandler was
4363: called during domovethings, the sync arrays may have been
4364: changed, getting the game out of sync. The solution is
4365: to keep the sync arrays in domovethings totally separate
4366: from the sync arrays in faketimerhandler. I split my sync
4367: arrays into 2 separate arrays, sync and fsync, where fsync
4368: and osync are for use BEFORE the FIFO only (such as
4369: faketimerhandler and getpackets), and sync is used AFTER
4370: the FIFO only (such as domovethings). PLEASE SPLIT YOUR
4371: SYNC ARRAYS AS I DESCRIBED!
4372:
4373: - The OUT OF SYNC message doesn't flicker any more. See the
4374: section of code in GAME.C where I set syncstat.
4375:
4376: - Fixed up a waitforeverybody function for network games which
4377: waits for everybody to be at a certain part of the game.
4378: Waitforeverybody also uses getpackets message number 5.
4379:
4380: - Added new clipping function that will push players away from
4381: walls that are too close. It solves A LOT of movement
4382: clipping problems. It can be pretty darn slow if it detects
4383: that you're too close to a wall, so I'd recommend using it
4384: only for players.
4385:
4386: pushmove (long *x, long *y, long *z, short *sectnum,
4387: long walldist, long ceildist, long flordist, char cliptype)
4388:
4389: The parameters are exactly the same as clipmove but with no
4390: xvect or yvect. Pushmove returns either a 0 or -1. If
4391: it returns a -1, then that means that it could not push
4392: the player away from the offending wall after 256 tries.
4393: When this happens, then you should kill the player
4394: instantly, because this only happens when the player is
4395: getting smooshed.
4396: ������������������������������������������������������������������������������
4397: 6/13/95 - Made clipinsidebox and clipinsideboxline return 0 if line doesn't
4398: intersect box, 1 if line intersects box and center of box
4399: is in front of line, or 2 if line intersects box and center
4400: of box is behind line.
4401:
4402: - Cansee should now work properly with overlapping.
4403: ������������������������������������������������������������������������������
4404: 6/19/95 - ATTENTION! Remove work-arounds!!! Found nasty getzrange bug.
4405: Getzrange used to let you fall through red sector line cracks
4406: when you were near more multiple red sector line sharing the
4407: same 2 sectors. Sound familiar anybody?
4408:
4409: - Made pushmove return the sector of whatever x and y end up in.
4410: ������������������������������������������������������������������������������
4411: 6/22/95 - I included cache1d.c renamed to cache1d.txt in this upload.
4412: ������������������������������������������������������������������������������
4413: 6/26/95 - Made face and wall sprites of clipmove, getzrange, hitscan, and
4414: neartag sensitive to the y-offset that you set in Editart.
4415:
4416: - Made one sprite sorting case work perfectly: where multiple
4417: sprites have the same x and y location (and priority). The
4418: sorting still doesn't work perfectly, but this one case can
4419: solve many of the current sprite sorting bugs, such as
4420: inserting a floor sprite of blood below a dead body.
4421:
4422: - Fixed some sprite drawing clipping bugs for wall and floor
4423: sprites. Now, wall sprites and floor sprites should not
4424: show through walls, ceilings, or floors when they're not
4425: supposed to. Also, I fixed a case where wall sprites
4426: disappeared when they happened to be between 2 white walls
4427: that clipped it.
4428: ������������������������������������������������������������������������������
4429: 6/27/95 - Fixed even more sprite drawing clipping bugs for wall sprites.
4430:
4431: - BONUS!!! Wall sprites now clip to white walls! (not red walls)
4432: If you ornament a wall, make sure that neither endpoint of the
4433: wall sprite is behind the wall or else it will get clipped.
4434: Please run lookatme.map from my game.exe which demonstrates
4435: some of the things you can do in build now without bugs.
4436: ������������������������������������������������������������������������������
4437: 6/30/95 - Made drawline256 clip with startumost/startdmost.
4438:
4439: - Moved keyboard handler into GAME.C. Here's what you need to do
4440: to use my keyboard handler (see my GAME.C):
4441:
4442: 1. Some global variables:
4443:
4444: #define KEYFIFOSIZ 64
4445: void (__interrupt __far *oldkeyhandler)();
4446: void __interrupt __far keyhandler(void);
4447: volatile char keystatus[256], keyfifo[KEYFIFOSIZ];
4448: volatile char keyfifoplc, keyfifoend;
4449: volatile char readch, oldreadch, extended, keytemp;
4450:
4451: 2. initkeys()
4452:
4453: 3. uninitkeys()
4454:
4455: 4. keyhandler()
4456:
4457: 5. Make sure to call initkeys and uninitkeys. A good place
4458: would be next to where you call inittimer / uninittimer.
4459:
4460: I didn't put my keyboard handler into BSTUB since I am using
4461: keystatus throughout build.obj. Besides I didn't want to anybody
4462: too bad of a headache for one upload.
4463:
4464: - Did you know that screencapture inverses black and white if you
4465: hold either shift key down? This option is useful for
4466: printing out board maps. Since I don't own the keyboard
4467: any more, I had to make screencapture take inverseit as the
4468: second parameter.
4469:
4470: screencapture(char *filename, char inverseit);
4471:
4472: Ex: screencapture("captxxxx.pcx",keystatus[0x2a]|keystatus[0x36]);
4473:
4474: If (inverseit == 0) then nuttin' special
4475: If (inverseit == 1) then super-reverso blacko-whiteo mode!
4476:
4477: I also had to move the stereo adjustment keys into game.c
4478: Just search for the "stereo" keyword in GAME.C. It'll take
4479: through all the necessary places.
4480: ������������������������������������������������������������������������������
4481: 7/5/95 - Moved my keytimerstuff from my timerhandler into getinput.
4482: (which is where it should be)
4483: ������������������������������������������������������������������������������
4484: 7/10/95 - Added a loadtilelockmode variable to BUILD.H. It's a global
4485: variable that makes future loadtile calls allocate their
4486: buffers on the cache as unlocked (0-default) or locked (1).
4487: I decided to make this a global variable rather than a
4488: parameter to save some people from rewriting code.
4489:
4490: EXTERN char loadtilelockmode;
4491:
4492: - Made my 2D EDIT MODE space bar code clear out new sectors and
4493: wall structures to 0. (except for the extras which are -1)
4494: ������������������������������������������������������������������������������
4495: 7/20/95 - I forgot to documenent rotatesprite bit 3, which controls
4496: whether or not the sprite will be clipped to the startumost
4497: /startdmost arrays. If the bit is a 1, then the sprite will
4498: not be clipped. This mode is useful for doing status bars
4499: at variable resolutions. What you do is instead of calling
4500: permanentwritesprite, you call rotatesprite with the scaling
4501: bit and startumost/startdmost clipping bit off. For non
4502: screen-buffer modes, be sure to call rotatesprite for each
4503: page of the mode. Use the numpages variable in BUILD.H to
4504: get the number of video pages used.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.