hans/Hellfire
1
0
Fork 0
mirror of https://github.com/jmarshall23/Hellfire.git synced 2026-08-11 23:40:51 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
ea74cd99214c85ad8181c68770a7f532be7c3e6e
Hellfire/TOWN.CPP
T
Justin Marshall ea74cd9921 Lots of feature upgrades.
2026-05-30 02:50:21 -07:00

2028 lines
49 KiB
C++
Raw Blame History

/*-----------------------------------------------------------------------**
** Diablo
**
** Town file
**
** (C)1995 Condor, Inc. All rights reserved.
**
**-----------------------------------------------------------------------**
** $Header: /Diablo/TOWN.CPP 2 1/23/97 12:21p Jmorin $
**-----------------------------------------------------------------------**
**
** File Routines
**-----------------------------------------------------------------------*/
#include "diablo.h"
#pragma hdrstop
#include "sound.h"
#include "engine.h"
#include "scrollrt.h"
#include "scrlasm.h"
#include "gendung.h"
#include "items.h"
#include "cursor.h"
#include "trigs.h"
#include "control.h"
#include "gamemenu.h"
#include "player.h"
#include "monster.h"
#include "town.h"
#include "towners.h"
#include "inv.h"
#include "quests.h"
#include "minitext.h"
#include "stores.h"
#include "effects.h"
#include "automap.h"
#include "help.h"
#include "error.h"
#include "doom.h"
#include "multi.h"
#define T_POUTC 165
#define TOWN_PLAYER_LIGHT 1
// #define TESTINGCRYPT // JKE set this to keep the crypt open
#if RLE_DRAW
void DrawUnit (long xp,long yp,BYTE *pCelBuff,long nCel,long nCelW,long ostart,long oend);
void DrawLitUnit (long xp,long yp,BYTE *pCelBuff,long nCel,long nCelW,long ostart,long oend);
void DrawLitUnitLerpOverlay(long xp, long yp, BYTE *pCelBuff, long nCel, long nCelW, long ostart, long oend, int density);
void DrawUnitClipped (long xp,long yp,BYTE *pCelBuff,long nCel,long nCelW,long ostart,long oend);
void DrawLitUnitClipped (long xp,long yp,BYTE *pCelBuff,long nCel,long nCelW,long ostart,long oend);
void DrawLitUnitLerpOverlayClipped(long xp, long yp, BYTE *pCelBuff, long nCel, long nCelW, long ostart, long oend, int density);
void DrawUnitOutline(byte ocolor, long xp, long yp, BYTE *pCelBuff, long nCel, long nCelW, long ostart, long oend);
void DrawUnitOutlineClipped(byte ocolor, long xp, long yp, BYTE *pCelBuff, long nCel, long nCelW, long ostart, long oend);
#endif
extern "C" {
extern int gnTownTileX;
extern int gnTownTileY;
extern int gnTownFlickerFrame;
}
extern int gnRenderFrameInterp;
extern int PlrWalkLenTbl[NUM_CLASSES];
static void T_DrawHTLXsub (BYTE *pTo, int sx, int sy, int xp, int yp, BOOL chflag);
static void T_DrawHTLXsub2 (BYTE *pTo, int sx, int sy, int sv, int sv2, int xp, int yp, BOOL chflag);
static void T_DrawHTLXsub3 (BYTE *pTo, int sx, int sy, int ev, int ev2, int xp, int yp, BOOL chflag);
static void T_DrawPlayerTownUnit(PlayerStruct *pPlayer, int xp, int yp, BYTE *pCelBuff, long nCel, long nCelW, long ostart, long oend, BOOL clipped);
void ApplyWorldGoldShimmer(ItemStruct *pItem, int itemIndex, int x, int y, int ostart, int oend);
void plrmsg_draw();
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
static void T_SetTownTile(int sx, int sy)
{
gnTownTileX = sx;
gnTownTileY = sy;
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
static int T_VisualHalfStep(long velocity)
{
int interp;
__int64 step;
interp = gnRenderFrameInterp;
if (interp <= 0 || velocity == 0)
return 0;
if (interp > 256)
interp = 256;
step = velocity;
if (step < 0)
return -(int)(((-step) * interp) >> 16);
return (int)((step * interp) >> 16);
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
static BOOL T_PlayerUsesVisualLerp(PlayerStruct *pPlayer)
{
return pPlayer->_pmode == PM_WALK
|| pPlayer->_pmode == PM_WALK2
|| pPlayer->_pmode == PM_WALK3;
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
static BOOL T_PlayerHasVisualStep(PlayerStruct *pPlayer)
{
int walkLen;
walkLen = 8;
if (currlevel != 0)
walkLen = PlrWalkLenTbl[pPlayer->_pClass];
return pPlayer->_pVar8 < walkLen;
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
static int T_GetPlayerDrawX(PlayerStruct *pPlayer, int xp)
{
xp += pPlayer->_pxoff;
if (T_PlayerUsesVisualLerp(pPlayer) && T_PlayerHasVisualStep(pPlayer))
xp += T_VisualHalfStep(pPlayer->_pxvel);
return xp;
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
static int T_GetPlayerDrawY(PlayerStruct *pPlayer, int yp)
{
yp += pPlayer->_pyoff;
if (T_PlayerUsesVisualLerp(pPlayer) && T_PlayerHasVisualStep(pPlayer))
yp += T_VisualHalfStep(pPlayer->_pyvel);
return yp;
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
static int T_GetScrollDrawX()
{
int sxoff;
PlayerStruct *pPlayer;
sxoff = ScrollInfo._sxoff;
if (ScrollInfo._sdir == SCRL_NONE)
return sxoff;
pPlayer = &plr[myplr];
if (T_PlayerUsesVisualLerp(pPlayer) && T_PlayerHasVisualStep(pPlayer))
sxoff -= T_VisualHalfStep(pPlayer->_pxvel);
return sxoff;
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
static int T_GetScrollDrawY()
{
int syoff;
PlayerStruct *pPlayer;
syoff = ScrollInfo._syoff;
if (ScrollInfo._sdir == SCRL_NONE)
return syoff;
pPlayer = &plr[myplr];
if (T_PlayerUsesVisualLerp(pPlayer) && T_PlayerHasVisualStep(pPlayer))
syoff -= T_VisualHalfStep(pPlayer->_pyvel);
return syoff;
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
static int T_GetVisualLerpDensity(int animCnt, int animDelay)
{
int interp;
int progress;
int density;
if (animDelay <= 1)
return 0;
interp = gnRenderFrameInterp;
if (interp < 0)
interp = 0;
if (interp > 256)
interp = 256;
progress = animCnt * 256 + interp;
density = (progress * 4) / (animDelay * 256);
if (density < 1)
return 0;
if (density > 3)
density = 3;
return density;
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
static int T_GetPlayerLerpFrame(PlayerStruct *pPlayer, int *density)
{
int frame;
*density = T_GetVisualLerpDensity(pPlayer->_pAnimCnt, pPlayer->_pAnimDelay);
if (*density == 0)
return 0;
frame = pPlayer->_pAnimFrame + 1;
if (frame > pPlayer->_pAnimLen)
return 0;
return frame;
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
static void T_DrawPlayerTownUnit(PlayerStruct *pPlayer, int xp, int yp, BYTE *pCelBuff, long nCel, long nCelW, long ostart, long oend, BOOL clipped)
{
long oldnLVal;
int density, nextFrame;
oldnLVal = nLVal;
nLVal = TOWN_PLAYER_LIGHT;
#if RLE_DRAW
if (clipped)
DrawLitUnitClipped(xp, yp, pCelBuff, nCel, nCelW, ostart, oend);
else
DrawLitUnit(xp, yp, pCelBuff, nCel, nCelW, ostart, oend);
nextFrame = T_GetPlayerLerpFrame(pPlayer, &density);
if (nextFrame) {
if (clipped)
DrawLitUnitLerpOverlayClipped(xp, yp, pCelBuff, nextFrame, nCelW, ostart, oend, density);
else
DrawLitUnitLerpOverlay(xp, yp, pCelBuff, nextFrame, nCelW, ostart, oend, density);
}
#else
if (clipped)
CDrawSlabCelL(xp, yp, pCelBuff, nCel, nCelW, ostart, oend);
else
DrawSlabCelL(xp, yp, pCelBuff, nCel, nCelW, ostart, oend);
#endif
nLVal = oldnLVal;
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void TDrawBlankMini(BYTE *pDecodeTo)
{
app_assert(gpBuffer);
__asm {
mov edi,dword ptr [pDecodeTo] // Dest
mov edx,30
mov ebx,1
xor eax,eax
//mov eax,0d3d3d3d3h
_BLp1: cmp edi,dword ptr [glClipY]
jb _Done
add edi,edx
mov ecx,ebx
rep stosd
add edi,edx
sub edi,NBUFFW64
or edx,edx
jz _Bb
sub edx,2
inc ebx
jmp _BLp1
_Bb: mov edx,2
mov ebx,15
_BLp2: cmp edi,dword ptr [glClipY]
jb _Done
add edi,edx
mov ecx,ebx
rep stosd
add edi,edx
sub edi,NBUFFW64
dec ebx
add edx,2
cmp edx,32
jnz _BLp2
_Done: nop
}
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void TCDrawBlankMini(BYTE *pDecodeTo)
{
app_assert(gpBuffer);
__asm {
mov edi,dword ptr [pDecodeTo] // Dest
mov edx,30
mov ebx,1
xor eax,eax
//mov eax,0d3d3d3d3h
_BLp1: cmp edi,dword ptr [glClipY]
jb _C1
add edi,64
jmp _C2
_C1: add edi,edx
mov ecx,ebx
rep stosd
add edi,edx
_C2: sub edi,NBUFFW64
or edx,edx
jz _Bb
sub edx,2
inc ebx
jmp _BLp1
_Bb: mov edx,2
mov ebx,15
_BLp2: cmp edi,dword ptr [glClipY]
jb _C3
add edi,64
jmp _C4
_C3: add edi,edx
mov ecx,ebx
rep stosd
add edi,edx
_C4: sub edi,NBUFFW64
dec ebx
add edx,2
cmp edx,32
jnz _BLp2
}
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void T_CDrawSpecial(BYTE *pTo, long nCel)
{
/*
long RLELen;
long nBufferW;
app_assert(gpBuffer);
__asm {
mov ebx,dword ptr [pSpecialCels]
mov eax,dword ptr [nCel]
shl eax,2
add ebx,eax
mov eax,dword ptr [ebx+4]
sub eax,dword ptr [ebx]
mov dword ptr [RLELen],eax
mov esi,dword ptr [pSpecialCels]
add esi,dword ptr [ebx]
mov edi,dword ptr [pTo] // Dest
mov eax,832 // Increase width
mov dword ptr [nBufferW],eax
mov ebx,dword ptr [RLELen]
add ebx,esi
_T1Lp1: mov edx,64
_T1Lp2: xor eax,eax // Load control byte
lodsb
or al,al
js _T1J
sub edx,eax
cmp edi,dword ptr [glClipY]
jb _T1C1
add esi,eax
add edi,eax
jmp _T1x
_T1C1: mov ecx,eax
shr ecx,1
jnc _T1w
movsb
jecxz _T1x
_T1w: shr ecx,1
jnc _T1Lp3
movsw
jecxz _T1x
_T1Lp3: rep movsd
_T1x: or edx,edx
jz _T1Nxt
jmp _T1Lp2
_T1J: neg al // Do jump
add edi,eax
sub edx,eax
jnz _T1Lp2
_T1Nxt: sub edi,dword ptr [nBufferW]
cmp ebx,esi
jnz _T1Lp1
}
*/
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void T_DrawSpecial(BYTE *pTo, int nCel)
{
/*
long RLELen;
long nBufferW;
app_assert(gpBuffer);
__asm {
mov ebx,dword ptr [pSpecialCels]
mov eax,dword ptr [nCel]
shl eax,2
add ebx,eax
mov eax,dword ptr [ebx+4]
sub eax,dword ptr [ebx]
mov dword ptr [RLELen],eax
mov esi,dword ptr [pSpecialCels]
add esi,dword ptr [ebx]
mov edi,dword ptr [pTo] // Dest
mov eax,832 // Increase width
mov dword ptr [nBufferW],eax
mov ebx,dword ptr [RLELen]
add ebx,esi
_T1Lp1: mov edx,64
_T1Lp2: xor eax,eax // Load control byte
lodsb
or al,al
js _T1J
sub edx,eax
cmp edi,dword ptr [glClipY]
jb _Done
mov ecx,eax
shr ecx,1
jnc _T1w
movsb
jecxz _T1x
_T1w: shr ecx,1
jnc _T1Lp3
movsw
jecxz _T1x
_T1Lp3: rep movsd
_T1x: or edx,edx
jz _T1Nxt
jmp _T1Lp2
_T1J: neg al // Do jump
add edi,eax
sub edx,eax
jnz _T1Lp2
_T1Nxt: sub edi,dword ptr [nBufferW]
cmp ebx,esi
jnz _T1Lp1
_Done: nop
}
*/
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void T_DrawEFlag1(BYTE *pTo2, int sx, int sy, int xp, int yp)
{
BYTE *pTo;
int t;
WORD *mt;
pTo = pTo2;
mt = &dMT2[CalcRot(sx,sy)].mt[0];
T_SetTownTile(sx, sy);
for(t = 0; t < 12; t += 2)
{
if (gdwPNum = mt[t]) DrawMTileClipBottom (pTo);
if (gdwPNum = mt[t+1]) DrawMTileClipBottom (pTo+32);
pTo -= NBUFFWSL5;
}
T_DrawHTLXsub (pTo2, sx, sy, xp, yp, FALSE);
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
static void T_DrawHTLXsub (BYTE *pTo, int sx, int sy, int xp, int yp, BOOL chflag)
{
int pxp,pyp;
char bv;
int mi;
app_assert(gpBuffer);
pTo = gpBuffer + nBuffWTbl[yp] + xp;
if (dItem[sx][sy] != 0) {
bv = dItem[sx][sy] - 1;
pxp = xp - item[bv]._iAnimWidth2;
if (bv == cursitem) COutlineSlabCel(181, pxp, yp, item[bv]._iAnimData, item[bv]._iAnimFrame, item[bv]._iAnimWidth, 0, 8);
CDrawSlabCel(pxp, yp, item[bv]._iAnimData, item[bv]._iAnimFrame, item[bv]._iAnimWidth, 0, 8);
ApplyWorldGoldShimmer(&item[bv], bv, pxp, yp, 0, 8);
}
if ((dFlags[sx][sy] & BFLAG_MONSTLR) != 0) {
mi = -(dMonster[sx][sy-1] + 1);
pxp = xp - towner[mi]._tAnimWidth2;
pyp = yp;
if (mi == cursmonst) COutlineSlabCel(166, pxp, pyp, towner[mi]._tAnimData, towner[mi]._tAnimFrame, towner[mi]._tAnimWidth, 0, 8);
CDrawSlabCel(pxp, pyp, towner[mi]._tAnimData, towner[mi]._tAnimFrame, towner[mi]._tAnimWidth, 0, 8);
}
if (dMonster[sx][sy] > 0) {
mi = dMonster[sx][sy] - 1;
pxp = xp - towner[mi]._tAnimWidth2;
pyp = yp;
if (mi == cursmonst) COutlineSlabCel(166, pxp, pyp, towner[mi]._tAnimData, towner[mi]._tAnimFrame, towner[mi]._tAnimWidth, 0, 8);
CDrawSlabCel(pxp, pyp, towner[mi]._tAnimData, towner[mi]._tAnimFrame, towner[mi]._tAnimWidth, 0, 8);
}
if ((dFlags[sx][sy] & BFLAG_PLRLR) != 0) {
bv = -(dPlayer[sx][sy-1] + 1);
pxp = T_GetPlayerDrawX(&plr[bv], xp) - plr[bv]._pAnimWidth2;
pyp = T_GetPlayerDrawY(&plr[bv], yp);
#if RLE_DRAW
if (bv == cursplr) DrawUnitOutlineClipped(T_POUTC, pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, 0, 8);
#else
if (bv == cursplr) COutlineSlabCel(T_POUTC, pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, 0, 8);
#endif
T_DrawPlayerTownUnit(&plr[bv], pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, 0, 8, TRUE);
if (chflag)
{
// if (plr[bv]._peflag == 2) T_DrawEFlag1(pTo-NBUFFWSL4+96, sx-2, sy+1, xp-96, yp-16);
if (plr[bv]._peflag != 0) T_DrawEFlag1(pTo-64, sx-1, sy+1, xp-64, yp);
}
}
if (dFlags[sx][sy] & BFLAG_DEADPLR)
DrawDeadPlr(sx, sy, xp, yp, 0, 8, TRUE);
if (dPlayer[sx][sy] > 0) {
bv = dPlayer[sx][sy] - 1;
pxp = T_GetPlayerDrawX(&plr[bv], xp) - plr[bv]._pAnimWidth2;
pyp = T_GetPlayerDrawY(&plr[bv], yp);
#if RLE_DRAW
if (bv == cursplr) DrawUnitOutlineClipped(T_POUTC, pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, 0, 8);
#else
if (bv == cursplr) COutlineSlabCel(T_POUTC, pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, 0, 8);
#endif
T_DrawPlayerTownUnit(&plr[bv], pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, 0, 8, TRUE);
if (chflag)
{
// if (plr[bv]._peflag == 2) T_DrawEFlag1(pTo-NBUFFWSL4+96, sx-2, sy+1, xp-96, yp-16);
if (plr[bv]._peflag != 0) T_DrawEFlag1(pTo-64, sx-1, sy+1, xp-64, yp);
}
}
if ((dFlags[sx][sy] & BFLAG_MISSILE) != 0) CDrawMissile(sx, sy, xp, yp, 0, 8, FALSE);
if (dSpecial[sx][sy]) T_CDrawSpecial(pTo, dSpecial[sx][sy]);
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void T_DrawHTileLineX (int sx, int sy, int xp, int yp, int nd, int halfflag)
{
int i;
BYTE *pTo;
int t;
WORD *mt;
app_assert(gpBuffer);
if (halfflag != 0) {
if ((sy >= 0) && (sy < DMAXY) && (sx >= 0) && (sx < DMAXX)) {
if (gdwPNum = dPiece[sx][sy]) {
pTo = gpBuffer + nBuffWTbl[yp] + xp + 32;
mt = &dMT2[CalcRot(sx,sy)].mt[0];
T_SetTownTile(sx, sy);
for(t = 1; t < 17; t += 2)
{
if (gdwPNum = mt[t]) DrawMTileClipBottom (pTo);
pTo -= NBUFFWSL5;
}
pTo = gpBuffer + nBuffWTbl[yp] + xp;
T_DrawHTLXsub (pTo, sx, sy, xp, yp, FALSE);
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TCDrawBlankMini(pTo);
}
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TCDrawBlankMini(pTo);
}
sx++;
sy--;
xp += 64;
}
nd -= halfflag;
for (i = 0; i < nd; i++) {
if ((sy >= 0) && (sy < DMAXY) && (sx >= 0) && (sx < DMAXX)) {
gdwPNum = dPiece[sx][sy];
if (gdwPNum != 0) {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
mt = &dMT2[CalcRot(sx,sy)].mt[0];
T_SetTownTile(sx, sy);
for(t = 0; t < 16; t+= 2)
{
if (gdwPNum = mt[t]) DrawMTileClipBottom (pTo);
if (gdwPNum = mt[t+1]) DrawMTileClipBottom (pTo+32);
pTo -= NBUFFWSL5;
}
pTo = gpBuffer + nBuffWTbl[yp] + xp;
T_DrawHTLXsub (pTo, sx, sy, xp, yp, TRUE);
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TCDrawBlankMini(pTo);
}
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TCDrawBlankMini(pTo);
}
sx++;
sy--;
xp += 64;
}
if (halfflag != 0) {
if ((sy >= 0) && (sy < DMAXY) && (sx >= 0) && (sx < DMAXX)) {
gdwPNum = dPiece[sx][sy];
if (gdwPNum != 0) {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
mt = &dMT2[CalcRot(sx,sy)].mt[0];
T_SetTownTile(sx, sy);
for(t = 0; t < 16; t+= 2)
{
if (gdwPNum = mt[t]) DrawMTileClipBottom (pTo);
pTo -= NBUFFWSL5;
}
pTo = gpBuffer + nBuffWTbl[yp] + xp;
T_DrawHTLXsub (pTo, sx, sy, xp, yp, FALSE);
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TCDrawBlankMini(pTo);
}
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TCDrawBlankMini(pTo);
}
}
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void T_DrawEFlag2(BYTE *pTo2, int sx, int sy, int sv, int sv2, int xp, int yp)
{
BYTE *pTo;
int t;
WORD *mt;
if (sv == 0) pTo = pTo2;
else
pTo = pTo2 + (NBUFFWSL5 * sv);
mt = &dMT2[CalcRot(sx,sy)].mt[0];
T_SetTownTile(sx, sy);
for(t = 0; t < 6; t++)
{
if (sv <= t) {
if (gdwPNum = mt[2*t+2]) DrawMTileClipBottom (pTo);
if (gdwPNum = mt[2*t+3]) DrawMTileClipBottom (pTo+32);
}
pTo -= NBUFFWSL5;
}
if (sv2 < 8) {
T_DrawHTLXsub2 (pTo2, sx, sy, sv, sv2, xp, yp, FALSE);
}
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
static void T_DrawHTLXsub2 (BYTE *pTo, int sx, int sy, int sv, int sv2, int xp, int yp, BOOL chflag)
{
int pxp,pyp;
char bv;
int mi;
if (dItem[sx][sy] != 0) {
bv = dItem[sx][sy] - 1;
pxp = xp - item[bv]._iAnimWidth2;
if (bv == cursitem) COutlineSlabCel(181, pxp, yp, item[bv]._iAnimData, item[bv]._iAnimFrame, item[bv]._iAnimWidth, sv2, 8);
CDrawSlabCel(pxp, yp, item[bv]._iAnimData, item[bv]._iAnimFrame, item[bv]._iAnimWidth, sv2, 8);
ApplyWorldGoldShimmer(&item[bv], bv, pxp, yp, sv2, 8);
}
if ((dFlags[sx][sy] & BFLAG_MONSTLR) != 0) {
mi = -(dMonster[sx][sy-1] + 1);
pxp = xp - towner[mi]._tAnimWidth2;
pyp = yp;
if (mi == cursmonst) COutlineSlabCel(166, pxp, pyp, towner[mi]._tAnimData, towner[mi]._tAnimFrame, towner[mi]._tAnimWidth, sv2, 8);
CDrawSlabCel(pxp, pyp, towner[mi]._tAnimData, towner[mi]._tAnimFrame, towner[mi]._tAnimWidth, sv2, 8);
}
if (dMonster[sx][sy] > 0) {
mi = dMonster[sx][sy] - 1;
pxp = xp - towner[mi]._tAnimWidth2;
pyp = yp;
if (mi == cursmonst) COutlineSlabCel(166, pxp, pyp, towner[mi]._tAnimData, towner[mi]._tAnimFrame, towner[mi]._tAnimWidth, sv2, 8);
CDrawSlabCel(pxp, pyp, towner[mi]._tAnimData, towner[mi]._tAnimFrame, towner[mi]._tAnimWidth, sv2, 8);
}
if ((dFlags[sx][sy] & BFLAG_PLRLR) != 0) {
bv = -(dPlayer[sx][sy-1] + 1);
pxp = T_GetPlayerDrawX(&plr[bv], xp) - plr[bv]._pAnimWidth2;
pyp = T_GetPlayerDrawY(&plr[bv], yp);
#if RLE_DRAW
if (bv == cursplr) DrawUnitOutlineClipped(T_POUTC, pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, sv2, 8);
#else
if (bv == cursplr) COutlineSlabCel(T_POUTC, pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, sv2, 8);
#endif
T_DrawPlayerTownUnit(&plr[bv], pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, sv2, 8, TRUE);
if (chflag)
{
// if (plr[bv]._peflag == 2) T_DrawEFlag2(pTo-NBUFFWSL4+96, sx-2, sy+1, sv, sv2, xp-96, yp-16);
if (plr[bv]._peflag != 0) T_DrawEFlag2(pTo-64, sx-1, sy+1, sv, sv2, xp-64, yp);
}
}
if (dFlags[sx][sy] & BFLAG_DEADPLR)
DrawDeadPlr(sx, sy, xp, yp, sv2, 8, TRUE);
if (dPlayer[sx][sy] > 0) {
bv = dPlayer[sx][sy] - 1;
pxp = T_GetPlayerDrawX(&plr[bv], xp) - plr[bv]._pAnimWidth2;
pyp = T_GetPlayerDrawY(&plr[bv], yp);
#if RLE_DRAW
if (bv == cursplr) DrawUnitOutlineClipped(T_POUTC, pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, sv2, 8);
#else
if (bv == cursplr) COutlineSlabCel(T_POUTC, pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, sv2, 8);
#endif
T_DrawPlayerTownUnit(&plr[bv], pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, sv2, 8, TRUE);
if (chflag)
{
// if (plr[bv]._peflag == 2) T_DrawEFlag2(pTo-NBUFFWSL4+96, sx-2, sy+1, sv, sv2, xp-96, yp-16);
if (plr[bv]._peflag != 0) T_DrawEFlag2(pTo-64, sx-1, sy+1, sv, sv2, xp-64, yp);
}
}
if ((dFlags[sx][sy] & BFLAG_MISSILE) != 0) CDrawMissile(sx, sy, xp, yp, sv2, 8, FALSE);
if (dSpecial[sx][sy]) T_CDrawSpecial(pTo+nBuffWTbl[sv2<<4], dSpecial[sx][sy]);
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void T_DrawHTLX2 (int sx, int sy, int xp, int yp, int nd, int sv, int halfflag)
{
int i;
BYTE *pTo;
int sv2;
int t;
WORD *mt;
app_assert(gpBuffer);
sv2 = (sv + 1) << 1;
if (halfflag != 0) {
if ((sy >= 0) && (sy < DMAXY) && (sx >= 0) && (sx < DMAXX)) {
if (gdwPNum = dPiece[sx][sy]) {
pTo = gpBuffer + nBuffWTbl[yp] + xp - NBUFFWSL5 + 32;
mt = &dMT2[CalcRot(sx,sy)].mt[0];
T_SetTownTile(sx, sy);
for(t = 0; t < 7; t++)
{
if ((sv <= t) && (gdwPNum = mt[2*t+3])) DrawMTileClipBottom (pTo);
pTo -= NBUFFWSL5;
}
if (sv2 < 8) {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
T_DrawHTLXsub2 (pTo, sx, sy, sv, sv2, xp, yp, FALSE);
}
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TCDrawBlankMini(pTo);
}
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TCDrawBlankMini(pTo);
}
sx++;
sy--;
xp += 64;
}
nd -= halfflag;
for (i = 0; i < nd; i++) {
if ((sy >= 0) && (sy < DMAXY) && (sx >= 0) && (sx < DMAXX)) {
gdwPNum = dPiece[sx][sy];
if (gdwPNum != 0) {
pTo = gpBuffer + nBuffWTbl[yp] + xp - NBUFFWSL5;
mt = &dMT2[CalcRot(sx,sy)].mt[0];
T_SetTownTile(sx, sy);
for(t = 0; t < 7; t++)
{
if (sv <= t) {
if (gdwPNum = mt[2*t+2]) DrawMTileClipBottom (pTo);
if (gdwPNum = mt[2*t+3]) DrawMTileClipBottom (pTo+32);
}
pTo -= NBUFFWSL5;
}
if (sv2 < 8) {
pTo = gpBuffer + nBuffWTbl[yp] + xp - (sv2 * NBUFFWSL4);
T_DrawHTLXsub2 (pTo, sx, sy, sv, sv2, xp, yp, TRUE);
}
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TCDrawBlankMini(pTo);
}
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TCDrawBlankMini(pTo);
}
sx++;
sy--;
xp += 64;
}
if (halfflag != 0) {
if ((sy >= 0) && (sy < DMAXY) && (sx >= 0) && (sx < DMAXX)) {
gdwPNum = dPiece[sx][sy];
if (gdwPNum != 0) {
pTo = gpBuffer + nBuffWTbl[yp] + xp - NBUFFWSL5;
mt = &dMT2[CalcRot(sx,sy)].mt[0];
T_SetTownTile(sx, sy);
for(t = 0; t < 7; t++)
{
if ((sv <= t) && (gdwPNum = mt[2*t+2])) DrawMTileClipBottom (pTo);
pTo -= NBUFFWSL5;
}
if (sv2 < 8) {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
T_DrawHTLXsub2 (pTo, sx, sy, sv, sv2, xp, yp, FALSE);
}
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TCDrawBlankMini(pTo);
}
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TCDrawBlankMini(pTo);
}
}
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void T_DrawEFlag3(BYTE *pTo2, int sx, int sy, int ev, int ev2, int xp, int yp)
{
BYTE *pTo;
int t;
WORD *mt;
pTo = pTo2;
mt = &dMT2[CalcRot(sx,sy)].mt[0];
T_SetTownTile(sx, sy);
for(t = 0; t < 7; t++)
{
if (ev >= t) {
if (gdwPNum = mt[2*t]) DrawMTileClipTop (pTo);
if (gdwPNum = mt[2*t+1]) DrawMTileClipTop (pTo+32);
}
pTo -= NBUFFWSL5;
}
T_DrawHTLXsub3 (pTo2, sx, sy, ev, ev2, xp, yp, FALSE);
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
static void T_DrawHTLXsub3 (BYTE *pTo, int sx, int sy, int ev, int ev2, int xp, int yp, BOOL chflag)
{
int pxp,pyp;
char bv;
int mi;
if (dItem[sx][sy] != 0) {
bv = dItem[sx][sy] - 1;
pxp = xp - item[bv]._iAnimWidth2;
if (bv == cursitem) OutlineSlabCel(181, pxp, yp, item[bv]._iAnimData, item[bv]._iAnimFrame, item[bv]._iAnimWidth, 0, ev2);
app_assert(item[bv]._iAnimData);
DrawSlabCel(pxp, yp, item[bv]._iAnimData, item[bv]._iAnimFrame, item[bv]._iAnimWidth, 0, ev2);
ApplyWorldGoldShimmer(&item[bv], bv, pxp, yp, 0, ev2);
}
if ((dFlags[sx][sy] & BFLAG_MONSTLR) != 0) {
mi = -(dMonster[sx][sy-1] + 1);
pxp = xp - towner[mi]._tAnimWidth2;
pyp = yp;
if (mi == cursmonst) OutlineSlabCel(166, pxp, pyp, towner[mi]._tAnimData, towner[mi]._tAnimFrame, towner[mi]._tAnimWidth, 0, ev2);
app_assert(towner[mi]._tAnimData);
DrawSlabCel(pxp, pyp, towner[mi]._tAnimData, towner[mi]._tAnimFrame, towner[mi]._tAnimWidth, 0, ev2);
}
if (dMonster[sx][sy] > 0) {
mi = dMonster[sx][sy] - 1;
pxp = xp - towner[mi]._tAnimWidth2;
pyp = yp;
if (mi == cursmonst) OutlineSlabCel(166, pxp, pyp, towner[mi]._tAnimData, towner[mi]._tAnimFrame, towner[mi]._tAnimWidth, 0, ev2);
app_assert(towner[mi]._tAnimData);
DrawSlabCel(pxp, pyp, towner[mi]._tAnimData, towner[mi]._tAnimFrame, towner[mi]._tAnimWidth, 0, ev2);
}
if ((dFlags[sx][sy] & BFLAG_PLRLR) != 0) {
bv = -(dPlayer[sx][sy-1] + 1);
pxp = T_GetPlayerDrawX(&plr[bv], xp) - plr[bv]._pAnimWidth2;
pyp = T_GetPlayerDrawY(&plr[bv], yp);
#if RLE_DRAW
if (bv == cursplr) DrawUnitOutline(T_POUTC, pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, 0, ev2);
app_assert(plr[bv]._pAnimData);
#else
if (bv == cursplr) OutlineSlabCel(T_POUTC, pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, 0, ev2);
app_assert(plr[bv]._pAnimData);
#endif
T_DrawPlayerTownUnit(&plr[bv], pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, 0, ev2, FALSE);
if (chflag)
{
// if (plr[bv]._peflag == 2) T_DrawEFlag3(pTo-NBUFFWSL4-96, sx-2, sy+1, ev, ev2, xp-96, yp-16);
if (plr[bv]._peflag != 0) T_DrawEFlag3(pTo-64, sx-1, sy+1, ev, ev2, xp-64, yp);
}
}
if (dFlags[sx][sy] & BFLAG_DEADPLR)
DrawDeadPlr(sx, sy, xp, yp, 0, ev2, FALSE);
if (dPlayer[sx][sy] > 0) {
bv = dPlayer[sx][sy] - 1;
pxp = T_GetPlayerDrawX(&plr[bv], xp) - plr[bv]._pAnimWidth2;
pyp = T_GetPlayerDrawY(&plr[bv], yp);
#if RLE_DRAW
if (bv == cursplr) DrawUnitOutline(T_POUTC, pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, 0, ev2);
app_assert(plr[bv]._pAnimData);
#else
if (bv == cursplr) OutlineSlabCel(T_POUTC, pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, 0, ev2);
app_assert(plr[bv]._pAnimData);
#endif
T_DrawPlayerTownUnit(&plr[bv], pxp, pyp, plr[bv]._pAnimData, plr[bv]._pAnimFrame, plr[bv]._pAnimWidth, 0, ev2, FALSE);
if (chflag)
{
// if (plr[bv]._peflag == 2) T_DrawEFlag3(pTo-NBUFFWSL4-96, sx-2, sy+1, ev, ev2, xp-96, yp-16);
if (plr[bv]._peflag != 0) T_DrawEFlag3(pTo-64, sx-1, sy+1, ev, ev2, xp-64, yp);
}
}
if ((dFlags[sx][sy] & BFLAG_MISSILE) != 0) DrawMissile(sx, sy, xp, yp, 0, ev2, FALSE);
if (dSpecial[sx][sy]) T_DrawSpecial(pTo, dSpecial[sx][sy]);
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void T_DrawHTLX3 (int sx, int sy, int xp, int yp, int nd, int ev, int halfflag)
{
int i;
BYTE *pTo;
int ev2;
int t;
WORD *mt;
app_assert(gpBuffer);
ev2 = (ev + 1) << 1;
if (ev2 > 8) ev2 = 8;
if (halfflag != 0) {
if ((sy >= 0) && (sy < DMAXY) && (sx >= 0) && (sx < DMAXX)) {
if (gdwPNum = dPiece[sx][sy]) {
pTo = gpBuffer + nBuffWTbl[yp] + xp + 32;
mt = &dMT2[CalcRot(sx,sy)].mt[0];
T_SetTownTile(sx, sy);
for(t = 0; t < 7; t++)
{
if ((ev >= t) && (gdwPNum = mt[2*t+1])) DrawMTileClipTop (pTo);
pTo -= NBUFFWSL5;
}
pTo = gpBuffer + nBuffWTbl[yp] + xp;
T_DrawHTLXsub3 (pTo, sx, sy, ev, ev2, xp, yp, FALSE);
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TDrawBlankMini(pTo);
}
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TDrawBlankMini(pTo);
}
sx++;
sy--;
xp += 64;
}
nd -= halfflag;
for (i = 0; i < nd; i++) {
if ((sy >= 0) && (sy < DMAXY) && (sx >= 0) && (sx < DMAXX)) {
gdwPNum = dPiece[sx][sy];
if (gdwPNum != 0) {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
mt = &dMT2[CalcRot(sx,sy)].mt[0];
T_SetTownTile(sx, sy);
for(t = 0; t < 7; t++)
{
if (ev >= t) {
if (gdwPNum = mt[2*t]) DrawMTileClipTop (pTo);
if (gdwPNum = mt[2*t+1]) DrawMTileClipTop (pTo+32);
}
pTo -= NBUFFWSL5;
}
pTo = gpBuffer + nBuffWTbl[yp] + xp;
T_DrawHTLXsub3 (pTo, sx, sy, ev, ev2, xp, yp, TRUE);
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TDrawBlankMini(pTo);
}
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TDrawBlankMini(pTo);
}
sx++;
sy--;
xp += 64;
}
if (halfflag != 0) {
if ((sy >= 0) && (sy < DMAXY) && (sx >= 0) && (sx < DMAXX)) {
gdwPNum = dPiece[sx][sy];
if (gdwPNum != 0) {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
mt = &dMT2[CalcRot(sx,sy)].mt[0];
T_SetTownTile(sx, sy);
for(t = 0; t < 7; t++)
{
if ((ev >= t) && (gdwPNum = mt[2*t])) DrawMTileClipTop (pTo);
pTo -= NBUFFWSL5;
}
pTo = gpBuffer + nBuffWTbl[yp] + xp;
T_DrawHTLXsub3 (pTo, sx, sy, ev, ev2, xp, yp, FALSE);
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TDrawBlankMini(pTo);
}
} else {
pTo = gpBuffer + nBuffWTbl[yp] + xp;
TDrawBlankMini(pTo);
}
}
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void T_SVGADrawView (int StartX, int StartY)
{
int xpos, ypos;
int i;
int width,height;
ViewDX = 640;
ViewDY = 352;
ViewBX = 10;
ViewBY = 11;
xpos = 64 + T_GetScrollDrawX();
ypos = 175 + T_GetScrollDrawY();
StartX -= 10;
StartY -= 1;
width = 10;
height = 5;
if (chrflag || questlog) {
StartX += 2;
StartY -= 2;
xpos += 288;
width = 6;
}
if (invflag || sbookflag) {
StartX += 2;
StartY -= 2;
xpos -= 32;
width = 6;
}
switch (ScrollInfo._sdir) {
case SCRL_NONE :
break;
case SCRL_U :
ypos -= 32;
StartX--;
StartY--;
height++;
break;
case SCRL_UR :
ypos -= 32;
StartX--;
StartY--;
width++;
height++;
break;
case SCRL_R :
width++;
break;
case SCRL_DR :
width++;
height++;
break;
case SCRL_D :
height++;
break;
case SCRL_DL :
xpos -= 64;
StartX--;
StartY++;
width++;
height++;
break;
case SCRL_L :
xpos -= 64;
StartX--;
StartY++;
width++;
break;
case SCRL_UL :
xpos -= 64;
ypos -= 32;
StartX -= 2;
width++;
height++;
break;
}
app_assert(gpBuffer);
glClipY = (long)gpBuffer + nBuffWTbl[160];
for (i = 0; i < 7; i++) {
T_DrawHTLX3(StartX, StartY, xpos, ypos, width, i, 0);
StartY++;
xpos -= 32;
ypos += 16;
T_DrawHTLX3(StartX, StartY, xpos, ypos, width, i, 1);
StartX++;
xpos += 32;
ypos += 16;
}
app_assert(gpBuffer);
glClipY = (long)gpBuffer + nBuffWTbl[512];
for (i = 0; i < height; i++) {
T_DrawHTileLineX(StartX, StartY, xpos, ypos, width, 0);
StartY++;
xpos -= 32;
ypos += 16;
T_DrawHTileLineX(StartX, StartY, xpos, ypos, width, 1);
StartX++;
xpos += 32;
ypos += 16;
}
for (i = 0; i < 7; i++) {
T_DrawHTLX2(StartX, StartY, xpos, ypos, width, i, 0);
StartY++;
xpos -= 32;
ypos += 16;
T_DrawHTLX2(StartX, StartY, xpos, ypos, width, i, 1);
StartX++;
xpos += 32;
ypos += 16;
}
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void T_VGADrawView (int StartX, int StartY)
{
int xpos, ypos;
int i;
int width,height;
long csrc, cdest, cw;
ViewDX = 384;
ViewDY = 192;
ViewBX = 6;
ViewBY = 6;
xpos = 64 + T_GetScrollDrawX();
ypos = 143 + T_GetScrollDrawY();
StartX -= 6;
StartY -= 1;
width = 6;
height = 0;
switch (ScrollInfo._sdir) {
case SCRL_NONE :
break;
case SCRL_U :
ypos -= 32;
StartX--;
StartY--;
height++;
break;
case SCRL_UR :
ypos -= 32;
StartX--;
StartY--;
width++;
height++;
break;
case SCRL_R :
width++;
break;
case SCRL_DR :
width++;
height++;
break;
case SCRL_D :
height++;
break;
case SCRL_DL :
xpos -= 64;
StartX--;
StartY++;
width++;
height++;
break;
case SCRL_L :
xpos -= 64;
StartX--;
StartY++;
width++;
break;
case SCRL_UL :
xpos -= 64;
ypos -= 32;
StartX -= 2;
width++;
height++;
break;
}
app_assert(gpBuffer);
glClipY = (long)gpBuffer + nBuffWTbl[143];
for (i = 0; i < 7; i++) {
T_DrawHTLX3(StartX, StartY, xpos, ypos, width, i, 0);
StartY++;
xpos -= 32;
ypos += 16;
T_DrawHTLX3(StartX, StartY, xpos, ypos, width, i, 1);
StartX++;
xpos += 32;
ypos += 16;
}
app_assert(gpBuffer);
glClipY = (long)gpBuffer + nBuffWTbl[320];
for (i = 0; i < height; i++) {
T_DrawHTileLineX(StartX, StartY, xpos, ypos, width, 0);
StartY++;
xpos -= 32;
ypos += 16;
T_DrawHTileLineX(StartX, StartY, xpos, ypos, width, 1);
StartX++;
xpos += 32;
ypos += 16;
}
for (i = 0; i < 7; i++) {
T_DrawHTLX2(StartX, StartY, xpos, ypos, width, i, 0);
StartY++;
xpos -= 32;
ypos += 16;
T_DrawHTLX2(StartX, StartY, xpos, ypos, width, i, 1);
StartX++;
xpos += 32;
ypos += 16;
}
if (chrflag || questlog) {
csrc = 245168;
cdest = 392064;
cw = 160;
} else {
if (invflag || sbookflag) {
csrc = 245168;
cdest = 391744;
cw = 160;
} else {
csrc = 245088;
cdest = 391744;
cw = 320;
}
}
// Double res copy
app_assert(gpBuffer);
__asm {
mov esi,[gpBuffer]
mov edx,[cdest]
mov edi,esi
mov ecx,[csrc]
add edi,edx
add esi,ecx
mov ebx,edi
add ebx,768
mov edx,176
_YLp:
mov ecx,[cw]
_XLp:
mov al,[esi]
inc esi
mov ah,al
mov [edi],ax
mov [ebx],ax
add edi,2
add ebx,2
dec ecx
jnz _XLp
mov eax,768
add eax,[cw]
sub esi,eax
add eax,eax
sub ebx,eax
sub edi,eax
dec edx
jnz _YLp
}
/* // Double res copy (Old)
app_assert(gpBuffer);
__asm {
mov esi,dword ptr [gpBuffer]
mov edi,esi
add esi,dword ptr [csrc]
add edi,dword ptr [cdest]
mov ebx,edi
add ebx,768
mov edx,176
_YLp: mov ecx,dword ptr [cw]
_XLp: lodsb
mov ah,al
stosw
mov word ptr [ebx],ax
add ebx,2
loop _XLp
mov eax,768
add eax,dword ptr [cw]
sub esi,eax
add eax,eax
sub ebx,eax
sub edi,eax
dec edx
jnz _YLp
}*/
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void T_DrawView (int StartX, int StartY)
{
/* __asm {
mov edi,dword ptr [gpBuffer]
add edi,122944
mov edx,352
mov eax,092929292h // yellow
//xor eax,eax // black
_YLp: mov ecx,160
rep stosd
add edi,128
dec edx
jnz _YLp
}*/
// Non-town draw routines use nLVal and nTrans as global params,
// but in town all tiles are fully lit, and there are no transparent
// walls, so we set them here once for the whole screen
nLVal = 0;
nTrans = 0;
gnTownFlickerFrame = GetTickCount() / 120;
if (svgamode) T_SVGADrawView (StartX, StartY);
else T_VGADrawView (StartX, StartY);
if (automapflag) DrawAutomap();
if ((stextflag) && (!qtextflag)) DrawSText();
if (invflag) DrawInv();
else if (sbookflag) DrawSpellBook();
DrawDurIcon();
if (chrflag) DrawChr();
else if (questlog) DrawQuestLog();
else if ((plr[myplr]._pStatPts != 0) && (!spselflag)) DrawLevelUpIcon();
if (uitemflag) DrawUniqueInfo();
if (qtextflag) DrawQText();
if (spselflag) DrawSpellList();
if (dropGoldFlag) DrawGoldBox(dropGoldValue);
if (helpflag) DrawHelp();
if (msgflag) DrawDiabloMsg();
if (PauseMode && !deathflag) DrawPause();
plrmsg_draw();
gmenu_draw();
DrawMapOfDoom();
DrawInfoBox();
DrawHealthTop();
DrawManaTop();
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void T_SetDungeonMicros()
{
int wv;
int i,j;
int t;
WORD *mtsource;
WORD *mt;
// Init the light values for each piece
for (j = 0; j < DMAXY; j++) {
for (i = 0; i < DMAXX; i++) {
wv = dPiece[i][j];
mt = &dMT2[CalcRot(i,j)].mt[0];
if (wv != 0) {
wv--;
mtsource = (WORD *)(pMiniTiles + 32*wv);
for(t = 0; t < 16; t++)
// MiniTiles array uses opposite y direction
// hence wierd index on next line
mt[t] = mtsource[14-(t&0xe)+(t&1)];
} else {
for(t = 0; t < 16; t++)
mt[t] = 0;
}
}
}
#if 0
int xmp,ymp,nPNum;
int s;
WORD tempmt[16];
// Zero micro tile values for each piece
for (j = 0; j < DMAXY; j++) {
for (i = 0; i < DMAXX; i++) {
mt = &dMT2[CalcRot(i,j)].mt[0];
for(t = 0; t < 16; t++)
tempmt[t] = 0;
nPNum = mt[0];
if (((nPNum & 0x7000) == 0x4000) && (nPNum)) tempmt[0] = 1;
nPNum = mt[1];
if (((nPNum & 0x7000) == 0x5000) && (nPNum != 0)) tempmt[1] = 1;
for(t = 2; t < 16; t++)
{
nPNum = mt[t];
if (((nPNum & 0x7000) == 0) && nPNum)
{
tempmt[t] = 1;
xmp = i;
ymp = j;
for(s = t-2; s >= 0 && xmp > 0 && ymp > 0; s -= 2)
{
xmp--;
ymp--;
dMT2[CalcRot(xmp,ymp)].mt[s] = 0;
}
}
}
for(t = 0; t < 13; t += 2)
{
if(tempmt[t] && tempmt[t+2])
{
xmp = i-1;
ymp = j;
for(s = t+1; s >= 0 && xmp >= 0 && ymp >= 0; s -= 2)
{
dMT2[CalcRot(xmp,ymp)].mt[s] = 0;
xmp--;
ymp--;
}
}
}
for(t = 1; t < 14; t += 2)
{
if(tempmt[t] && tempmt[t+2])
{
xmp = i;
ymp = j-1;
for(s = t+1; s >= 0 && xmp >= 0 && ymp >= 0; s -= 2)
{
dMT2[CalcRot(xmp,ymp)].mt[s] = 0;
xmp--;
ymp--;
}
}
}
}
}
#endif
if (svgamode) {
ViewDX = 640;
ViewDY = 352;
ViewBX = 10;
ViewBY = 11;
} else {
ViewDX = 384;
ViewDY = 224;
ViewBX = 6;
ViewBY = 7;
}
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void T_FillSector (BYTE *P3Tiles, BYTE *pSector, int xi, int yi, int w, int h)
{
int i,j,xx,yy;
long v1,v2,v3,v4,ii;
// Convert dungeon mega tiles to mini tiles
ii = 4;
yy = yi;
for (j = 0; j < h; j++) {
xx = xi;
for (i = 0; i < w; i++) {
__asm {
mov esi,dword ptr [pSector]
mov eax,dword ptr [ii]
add esi,eax
xor eax,eax
lodsw
or eax,eax
jz _Zero
dec eax
mov esi,dword ptr [P3Tiles]
shl eax,3
add esi,eax
xor eax,eax
lodsw
inc eax
mov dword ptr [v1],eax
lodsw
inc eax
mov dword ptr [v2],eax
lodsw
inc eax
mov dword ptr [v3],eax
lodsw
inc eax
mov dword ptr [v4],eax
jmp _Done
_Zero: mov dword ptr [v1],eax
mov dword ptr [v2],eax
mov dword ptr [v3],eax
mov dword ptr [v4],eax
_Done: nop
}
dPiece[xx][yy] = (int) v1;
dPiece[xx+1][yy] = (int) v2;
dPiece[xx][yy+1] = (int) v3;
dPiece[xx+1][yy+1] = (int) v4;
xx += 2;
ii += 2;
}
yy += 2;
}
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void T_FillTile(BYTE *P3Tiles, int xx, int yy, int t)
{
long v1,v2,v3,v4;
// Convert dungeon mega tiles to mini tiles
__asm {
mov eax,dword ptr [t]
dec eax
mov esi,dword ptr [P3Tiles]
shl eax,3
add esi,eax
xor eax,eax
lodsw
inc eax
mov dword ptr [v1],eax
lodsw
inc eax
mov dword ptr [v2],eax
lodsw
inc eax
mov dword ptr [v3],eax
lodsw
inc eax
mov dword ptr [v4],eax
jmp _Done
mov dword ptr [v1],eax
mov dword ptr [v2],eax
mov dword ptr [v3],eax
mov dword ptr [v4],eax
_Done: nop
}
dPiece[xx][yy] = (int) v1;
dPiece[xx+1][yy] = (int) v2;
dPiece[xx][yy+1] = (int) v3;
dPiece[xx+1][yy+1] = (int) v4;
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
void OpenNest()
{
dPiece[78][60] = 1162; // shadow at fork
dPiece[79][60] = 1163;
dPiece[78][61] = 1164;
dPiece[79][61] = 1294;
dPiece[78][62] = 1262; // bridge
dPiece[78][63] = 1264;
dPiece[79][62] = 1296;
dPiece[79][63] = 1297;
dPiece[79][64] = 1298; // second shadow
dPiece[78][64] = 282;
dPiece[78][65] = 284;
dPiece[79][65] = 285;
dPiece[80][60] = 1299; // start tile of thing
dPiece[80][61] = 1301;
dPiece[81][61] = 1302;
dPiece[82][60] = 1303; // second tile of thing
dPiece[83][60] = 1304;
dPiece[82][61] = 1305;
dPiece[83][61] = 1306;
dPiece[80][62] = 1307; // third tile of thing
dPiece[81][62] = 1308;
dPiece[80][63] = 1309;
dPiece[81][63] = 1310;
dPiece[80][64] = 1311; // forth tile of thing
dPiece[81][64] = 1312;
dPiece[80][65] = 1313;
dPiece[81][65] = 1314;
dPiece[82][64] = 1319; // fifth tile of thing
dPiece[83][64] = 1320;
dPiece[82][65] = 1321;
dPiece[83][65] = 1322;
dPiece[82][62] = 1315; // sixth tile of thing
dPiece[83][62] = 1316;
dPiece[82][63] = 1317;
dPiece[83][63] = 1318;
dPiece[84][61] = 280; // remove tree
dPiece[84][62] = 280;
dPiece[84][63] = 280;
// dPiece[85][59] = 11;
dPiece[85][60] = 280;
dPiece[85][61] = 280;
dPiece[85][62] = 8;
dPiece[85][63] = 8;
dPiece[85][64] = 8;
dPiece[86][60] = 217;
dPiece[86][61] = 24;
dPiece[85][62] = 19;
// dPiece[86][62] = 11;
// dPiece[86][63] = 11;
// dPiece[86][64] = 11;
dPiece[84][64] = 280;
// dPiece[86][65] = 11;
T_SetDungeonMicros();
}
void CloseNest()
{
dPiece[78][60] = 1162; // shadow at fork
dPiece[79][60] = 1259;
dPiece[78][61] = 1260;
dPiece[79][61] = 1261;
dPiece[78][62] = 1262; // bridge
dPiece[79][62] = 1263;
dPiece[78][63] = 1264;
dPiece[79][63] = 1265;
dPiece[78][64] = 1266; // second shadow
dPiece[79][64] = 1267;
dPiece[78][65] = 1268;
dPiece[80][60] = 1269; // start tile of thing
dPiece[81][60] = 1270;
dPiece[80][61] = 1271;
dPiece[81][61] = 1272;
dPiece[82][60] = 1273; // second tile of thing
dPiece[83][60] = 1274;
dPiece[82][61] = 1275;
dPiece[83][61] = 1276;
dPiece[80][62] = 1277; // third tile of thing
dPiece[81][62] = 1278;
dPiece[80][63] = 1279;
dPiece[81][63] = 1280;
dPiece[80][64] = 1281; // forth tile of thing
dPiece[81][64] = 1282;
dPiece[80][65] = 1283;
dPiece[81][65] = 1284;
dPiece[82][64] = 1289; // fifth tile of thing
dPiece[83][64] = 1290;
dPiece[82][65] = 1291;
dPiece[83][65] = 1292;
dPiece[82][62] = 1285; // sixth tile of thing
dPiece[83][62] = 1286;
dPiece[82][63] = 1287;
dPiece[83][63] = 1288;
dPiece[84][61] = 280; // remove tree
dPiece[84][62] = 280;
dPiece[84][63] = 280;
// dPiece[85][59] = 11;
dPiece[85][60] = 280;
dPiece[85][61] = 280;
dPiece[85][62] = 8;
dPiece[85][63] = 8;
dPiece[85][64] = 8;
dPiece[86][60] = 217;
dPiece[86][61] = 24;
dPiece[85][62] = 19;
// dPiece[86][62] = 11;
// dPiece[86][63] = 11;
// dPiece[86][64] = 11;
dPiece[84][64] = 280;
// dPiece[86][65] = 11;
T_SetDungeonMicros();
}
void CloseCrypt()
{
dPiece[36][21] = 1323;
dPiece[37][21] = 1324;
dPiece[36][22] = 1325;
dPiece[37][22] = 1326;
dPiece[36][23] = 1327;
dPiece[37][23] = 1328;
dPiece[36][24] = 1329;
dPiece[37][24] = 1330;
dPiece[35][21] = 1339;
dPiece[34][21] = 1340;
// dPiece[34][22] = 1341;
// dPiece[35][22] = 1342;
T_SetDungeonMicros();
}
void OpenCrypt()
{
dPiece[36][21] = 1331;
dPiece[37][21] = 1332;
dPiece[36][22] = 1333;
dPiece[37][22] = 1334;
dPiece[36][23] = 1335;
dPiece[37][23] = 1336;
dPiece[36][24] = 1337;
dPiece[37][24] = 1338;
dPiece[35][21] = 1339;
dPiece[34][21] = 1340;
// dPiece[34][22] = 1341;
// dPiece[35][22] = 1342;
T_SetDungeonMicros();
}
void T_Pass3()
{
BYTE *P3Tiles;
BYTE *pSector;
int xx,yy;
// Init Dungeon to blank
for (yy = 0; yy < DMAXY; yy+=2) {
for (xx = 0; xx < DMAXX; xx+=2) {
dPiece[xx][yy] = 0;
dPiece[xx+1][yy] = 0;
dPiece[xx][yy+1] = 0;
dPiece[xx+1][yy+1] = 0;
}
}
// Load convertion tiles
P3Tiles = LoadFileInMemSig("Levels\\TownData\\Town.TIL",NULL,'TOWN');
// Load map sector
pSector = LoadFileInMemSig("Levels\\TownData\\Sector1s.DUN",NULL,'TOWN');
T_FillSector(P3Tiles, pSector, 46, 46, 25, 25);
DiabloFreePtr(pSector);
pSector = LoadFileInMemSig("Levels\\TownData\\Sector2s.DUN",NULL,'TOWN');
T_FillSector(P3Tiles, pSector, 46, 0, 25, 23);
DiabloFreePtr(pSector);
pSector = LoadFileInMemSig("Levels\\TownData\\Sector3s.DUN",NULL,'TOWN');
T_FillSector(P3Tiles, pSector, 0, 46, 23, 25);
DiabloFreePtr(pSector);
pSector = LoadFileInMemSig("Levels\\TownData\\Sector4s.DUN",NULL,'TOWN');
T_FillSector(P3Tiles, pSector, 0, 0, 23, 23);
DiabloFreePtr(pSector);
#ifdef TESTINGCRYPT
quests[Q_CRYPTMAP]._qactive = QUEST_DONE;
#endif
#if IS_VERSION(SHAREWARE)
// Close Maus shortcut
T_FillTile(P3Tiles, 48, 20, 320);
// Close cave shortcut
T_FillTile(P3Tiles, 16, 68, 332);
T_FillTile(P3Tiles, 16, 70, 331);
// Close crev shortcut
for (xx = 36; xx < 46; xx++) T_FillTile(P3Tiles, xx, 78, random(0,4)+1);
#else
if (gbMaxPlayers == 1) {
if ((quests[Q_FARMER]._qactive == QUEST_DONE) || (quests[Q_FARMER]._qactive == QUEST_REALLYDONE)
|| (quests[Q_COWSUIT]._qactive == QUEST_DONE) || (quests[Q_COWSUIT]._qactive == QUEST_REALLYDONE))
{
OpenNest();
}
else
{
CloseNest();
}
if ((quests[Q_CRYPTMAP]._qactive != QUEST_DONE) && (!plr[myplr]._pLvlVisited[CRYPTSTART]))
CloseCrypt();
else
OpenCrypt();
// Close Maus shortcut
if (!((plr[myplr].pTownWarps & 0x01) || plr[myplr]._pLevel >= 10))
T_FillTile(P3Tiles, 48, 20, 320);
// Close cave shortcut
if (!((plr[myplr].pTownWarps & 0x02) || plr[myplr]._pLevel >= 15))
{
T_FillTile(P3Tiles, 16, 68, 332);
T_FillTile(P3Tiles, 16, 70, 331);
}
// Close crev shortcut or open or close or whatever is asked today
if (!((plr[myplr].pTownWarps & 0x04) || plr[myplr]._pLevel >= 20))
// if (!(plr[myplr].pTownWarps & 0x04))
{
for (xx = 36; xx < 46; xx++)
T_FillTile(P3Tiles, xx, 78, random(0,4)+1);
}
}
else
{
if ((quests[Q_FARMER]._qactive == QUEST_DONE) || (quests[Q_FARMER]._qactive == QUEST_REALLYDONE)
|| (quests[Q_COWSUIT]._qactive == QUEST_DONE) || (quests[Q_COWSUIT]._qactive == QUEST_REALLYDONE))
{
OpenNest();
}
else
{
CloseNest();
}
if ((quests[Q_CRYPTMAP]._qactive != QUEST_DONE) && (!plr[myplr]._pLvlVisited[CRYPTSTART]))
CloseCrypt();
else
OpenCrypt();
}
#endif
if ((quests[Q_PWATER]._qactive == QUEST_DONE) || (quests[Q_PWATER]._qactive == QUEST_NOTAVAIL))
T_FillTile(P3Tiles, 60, 70, 71);
else
T_FillTile(P3Tiles, 60, 70, 342);
DiabloFreePtr(P3Tiles);
}
/*-----------------------------------------------------------------------**
**-----------------------------------------------------------------------*/
extern int TWarpFrom;
void CreateTown(int entry)
{
int i,j;
dminx = 10;
dminy = 10;
dmaxx = 84;
dmaxy = 84;
if (entry == LVL_DOWN) {
ViewX = 75; // Your house
ViewY = 68;
} else {
if (entry == LVL_UP) {
ViewX = 25; // Near church
ViewY = 31;
} else {
if (entry == LVL_TWARPUP) {
if (TWarpFrom == 5) {
ViewX = 49; // Maus warp
ViewY = 22;
}
if (TWarpFrom == 9) {
ViewX = 18; // Cave warp
ViewY = 69;
}
if (TWarpFrom == 13) {
ViewX = 41; // Hell warp
ViewY = 81;
}// JKE add level up here.
if (TWarpFrom == CRYPTSTART) {
ViewX = 36;
ViewY = 25;
}
if (TWarpFrom == HIVESTART) {
ViewX = 79;
ViewY = 62;
}
}
}
}
T_Pass3();
// Init the light values for each piece
ZeroMemory(dLight,sizeof(dLight));
ZeroMemory(dFlags,sizeof(dFlags));
ZeroMemory(dPlayer,sizeof(dPlayer));
ZeroMemory(dMonster,sizeof(dMonster));
ZeroMemory(dObject,sizeof(dObject));
ZeroMemory(dItem,sizeof(dItem));
ZeroMemory(dSpecial,sizeof(dSpecial));
for (j = 0; j < DMAXY; j++) {
for (i = 0; i < DMAXX; i++) {
int nPiece = dPiece[i][j];
if (nPiece == 360) dSpecial[i][j] = 1;
else if (nPiece == 358) dSpecial[i][j] = 2;
else if (nPiece == 129) dSpecial[i][j] = 6;
else if (nPiece == 130) dSpecial[i][j] = 7;
else if (nPiece == 128) dSpecial[i][j] = 8;
else if (nPiece == 117) dSpecial[i][j] = 9;
else if (nPiece == 157) dSpecial[i][j] = 10;
else if (nPiece == 158) dSpecial[i][j] = 11;
else if (nPiece == 156) dSpecial[i][j] = 12;
else if (nPiece == 162) dSpecial[i][j] = 13;
else if (nPiece == 160) dSpecial[i][j] = 14;
else if (nPiece == 214) dSpecial[i][j] = 15;
else if (nPiece == 212) dSpecial[i][j] = 16;
else if (nPiece == 217) dSpecial[i][j] = 17;
else if (nPiece == 216) dSpecial[i][j] = 18;
}
}
T_SetDungeonMicros();
}
Reference in New Issue View Git Blame Copy Permalink