summaryrefslogtreecommitdiff
path: root/SRC/REPLACE.CPP
diff options
context:
space:
mode:
Diffstat (limited to 'SRC/REPLACE.CPP')
-rw-r--r--SRC/REPLACE.CPP258
1 files changed, 258 insertions, 0 deletions
diff --git a/SRC/REPLACE.CPP b/SRC/REPLACE.CPP
new file mode 100644
index 0000000..afb26c0
--- /dev/null
+++ b/SRC/REPLACE.CPP
@@ -0,0 +1,258 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <dos.h>
+#include <conio.h>
+
+#include "debug4g.h"
+#include "engine.h"
+#include "globals.h"
+#include "resource.h"
+#include "misc.h"
+#include "gameutil.h"
+#include "screen.h"
+#include "tile.h"
+
+#include <memcheck.h>
+
+
+// empty function stubs
+void allocache(long *, long, char *) {}
+void initcache(long, long) {}
+
+
+void * kmalloc( size_t size )
+{
+ void *ptr = Resource::Alloc( (long)size );
+ dprintf( "kmalloc(%i) = %P\n", size, ptr );
+ return ptr;
+}
+
+
+void kfree( void * ptr )
+{
+ dprintf( "kfree(%p)\n", ptr );
+ Resource::Free( ptr );
+}
+
+
+int loadpics( char * )
+{
+ if (tileInit() == 0)
+ return -1;
+ return 0;
+}
+
+
+void loadtile( short nTile )
+{
+ tileLoadTile(nTile);
+}
+
+
+ulong allocatepermanenttile( short nTile, long nSizeX, long nSizeY )
+{
+ return (ulong)tileAllocTile(nTile, nSizeX, nSizeY);
+}
+
+void overwritesprite( long thex, long they, short tilenum, schar shade, char flags, char dapalnum )
+{
+ rotatesprite(thex << 16, they << 16, 0x10000, (short)((flags & 8) << 7), tilenum, shade, dapalnum,
+ (char)(((flags & 1 ^ 1) << 4) + (flags & 2) + ((flags & 4) >> 2) + ((flags & 16) >> 2) ^ ((flags & 8) >> 1)),
+ windowx1, windowy1, windowx2, windowy2);
+}
+
+short animateoffs( short nTile, ushort nInfo )
+{
+ int index = 0, frames, clock;
+
+ dassert(nTile >= 0 && nTile < kMaxTiles);
+
+ if ( (nInfo & 0xC000) == 0x8000) // sprite
+ {
+ // hash sprite frame by info variable
+ clock = (gFrameClock + CRC32(&nInfo, 2)) >> picanm[nTile].speed;
+ }
+ else
+ clock = gFrameClock >> picanm[nTile].speed;
+
+ frames = picanm[nTile].frames;
+
+ if (frames > 0)
+ {
+ switch(picanm[nTile].type)
+ {
+ case 1: // Oscil
+ index = clock % (frames * 2);
+ if (index >= frames)
+ index = frames * 2 - index;
+ break;
+
+ case 2: // Forward
+ index = clock % (frames + 1);
+ break;
+
+ case 3: // Backward
+ index = -(clock % (frames + 1));
+ break;
+ }
+ }
+ return (short)index;
+}
+
+
+/*
+inline BOOL flintersect(long x1, long y1, long z1, long x2, long y2, long z2, long x3,
+ long y3, long x4, long y4, long *intx, long *inty, long *intz)
+{
+ long x21 = x2 - x1;
+ long x34 = x3 - x4;
+ long y21 = y2 - y1;
+ long y34 = y3 - y4;
+ long bot = x21 * y34 - y21 * x34;
+
+ if ( bot >= 0 )
+ return FALSE;
+
+ long x31 = x3 - x1;
+ long y31 = y3 - y1;
+ long topt = x31 * y34 - y31 * x34;
+ if ( topt > 0 || topt <= bot)
+ return FALSE;
+ long topu = x21 * y31 - y21 * x31;
+ if ( topu > 0 || topu <= bot)
+ return FALSE;
+
+ long t = divscale24(topt, bot);
+ *intx = x1 + mulscale24(x21, t);
+ *inty = y1 + mulscale24(y21, t);
+ *intz = z1 + mulscale24(z2 - z1, t);
+ return TRUE;
+}
+
+
+
+BOOL cansee(long x0, long y0, long z0, short sect0, long x1, long y1, long z1, short sect1)
+{
+ SECTOR *pSector;
+ WALL *pWall, *pWall2;
+ int i, nSector, nCount, nWalls;
+ long nNextSector, x, y, z, daz, daz2;
+ short clipsectorlist[512];
+
+ int qx = x1 - x0;
+ int qy = y1 - y0;
+
+ if ( x0 == x1 && y0 == y1 )
+ return (sect0 == sect1);
+
+ clipsectorlist[0] = sect0;
+ nCount = 1;
+
+ for( i = 0; i < nCount; i++ )
+ {
+ nSector = clipsectorlist[i];
+ pSector = &sector[nSector];
+
+ for( nWalls = pSector->wallnum, pWall = &wall[pSector->wallptr]; nWalls > 0; nWalls--, pWall++)
+ {
+ pWall2 = &wall[pWall->point2];
+
+ if ( flintersect(x0, y0, z0, x1, y1, z1,
+ pWall->x, pWall->y, pWall2->x, pWall2->y, &x, &y, &z) != 0)
+ {
+ nNextSector = pWall->nextsector;
+ if (nNextSector < 0)
+ return FALSE;
+
+ getzsofslope((short)nSector, x, y, &daz, &daz2);
+ if ( z <= daz || z >= daz2 )
+ return FALSE;
+
+ getzsofslope((short)nNextSector, x, y, &daz, &daz2);
+ if ( z <= daz || z >= daz2 )
+ return FALSE;
+
+ for (int j = nCount - 1; j >= 0; j--)
+ {
+ if (clipsectorlist[j] == nNextSector)
+ break;
+ }
+
+ if ( j < 0 )
+ clipsectorlist[nCount++] = (short)nNextSector;
+ dassert(nCount < 512);
+ }
+ }
+
+ if ( clipsectorlist[i] == sect1 )
+ return TRUE;
+ }
+ return FALSE;
+}
+*/
+
+
+unsigned movesprite(short nSprite, long dx, long dy, long dz, long ceildist, long flordist, char cliptype, long nTicks)
+{
+ int retval;
+ short nSector;
+ int zTop, zBot;
+ long zCeil, zFloor;
+
+ dassert(nSprite >= 0 && nSprite < kMaxSprites);
+ SPRITE *pSprite = &sprite[nSprite];
+
+ nSector = pSprite->sectnum;
+ dassert(nSector>= 0 && nSector < kMaxSectors);
+
+ retval = ClipMove(&pSprite->x, &pSprite->y, &pSprite->z, &nSector,
+ dx * nTicks >> 4, dy * nTicks >> 4, pSprite->clipdist << 2,
+ ceildist, flordist, cliptype);
+
+ if ((nSector != pSprite->sectnum) && (nSector >= 0))
+ changespritesect(nSprite, nSector);
+
+ int z = pSprite->z + dz * nTicks;
+ GetSpriteExtents(pSprite, &zTop, &zBot);
+ pSprite->z = z;
+
+ getzsofslope(nSector, pSprite->x, pSprite->y, &zCeil, &zFloor);
+
+ if ( !(sector[nSector].floorstat & kSectorParallax) )
+ pSprite->z += ClipHigh(zFloor - zBot, 0);
+ if ( !(sector[nSector].ceilingstat & kSectorParallax) )
+ pSprite->z += ClipLow(zCeil - zTop, 0);
+
+ if (retval != 0)
+ return retval;
+
+ if ( pSprite->z < z )
+ return kHitFloor | nSector;
+
+ if ( pSprite->z > z )
+ return kHitCeiling | nSector;
+
+ return 0;
+}
+
+
+void uninitengine()
+{
+ tileTerm();
+}
+
+
+void loadpalette()
+{
+ scrLoadPalette();
+}
+
+
+int getpalookup(long nVis, long nShade)
+{
+ if ( gFogMode )
+ return ClipHigh(nVis >> 8, 15) * 16 + ClipRange(nShade >> 2, 0, 15);
+ else
+ return ClipRange(nShade + (nVis >> 8), 0, kPalLookups - 1);
+}