mirror
/
devilutionX
mirror of https://github.com/diasurgical/devilutionX.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Get rid of SCREEN_X / SCREEN_Y 

GlobalOutputBuffer() now returns a clipped subregion
pull/1205/head
Gleb Mazovetskiy 5 years ago committed by Anders Jenbo
parent
0c2284a091
commit
70d1d633bd
19 changed files with 194 additions and 193 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 16
      Source/automap.cpp
  2. 5
      Source/capture.cpp
  3. 68
      Source/control.cpp
  4. 4
      Source/engine.h
  5. 10
      Source/gmenu.cpp
  6. 2
      Source/help.cpp
  7. 4
      Source/interfac.cpp
  8. 98
      Source/inv.cpp
  9. 12
      Source/items.cpp
  10. 12
      Source/minitext.cpp
  11. 4
      Source/palette.cpp
  12. 4
      Source/plrmsg.cpp
  13. 10
      Source/quests.cpp
  14. 22
      Source/render.cpp
  15. 57
      Source/scrollrt.cpp
  16. 24
      Source/stores.cpp
  17. 9
      SourceX/dx.cpp
  18. 4
      SourceX/qol.cpp
  19. 22
      defs.h

16
Source/automap.cpp
Unescape View File

@ -277,8 +277,8 @@ void SearchAutomapItem(CelOutputBuffer out)
Sint32 px = i - 2 * AutoMapXOfs - ViewX;
Sint32 py = j - 2 * AutoMapYOfs - ViewY;
x = (ScrollInfo._sxoff * AutoMapScale / 100 >> 1) + (px - py) * AmLine16 + gnScreenWidth / 2 + SCREEN_X;
y = (ScrollInfo._syoff * AutoMapScale / 100 >> 1) + (px + py) * AmLine8 + (gnScreenHeight - PANEL_HEIGHT) / 2 + SCREEN_Y;
x = (ScrollInfo._sxoff * AutoMapScale / 100 >> 1) + (px - py) * AmLine16 + gnScreenWidth / 2;
y = (ScrollInfo._syoff * AutoMapScale / 100 >> 1) + (px + py) * AmLine8 + (gnScreenHeight - PANEL_HEIGHT) / 2;
if (PANELS_COVER) {
if (invflag || sbookflag)
@ -318,8 +318,8 @@ void DrawAutomapPlr(CelOutputBuffer out, int pnum)
px = x - 2 * AutoMapXOfs - ViewX;
py = y - 2 * AutoMapYOfs - ViewY;
x = (plr[pnum]._pxoff * AutoMapScale / 100 >> 1) + (ScrollInfo._sxoff * AutoMapScale / 100 >> 1) + (px - py) * AmLine16 + gnScreenWidth / 2 + SCREEN_X;
y = (plr[pnum]._pyoff * AutoMapScale / 100 >> 1) + (ScrollInfo._syoff * AutoMapScale / 100 >> 1) + (px + py) * AmLine8 + (gnScreenHeight - PANEL_HEIGHT) / 2 + SCREEN_Y;
x = (plr[pnum]._pxoff * AutoMapScale / 100 >> 1) + (ScrollInfo._sxoff * AutoMapScale / 100 >> 1) + (px - py) * AmLine16 + gnScreenWidth / 2;
y = (plr[pnum]._pyoff * AutoMapScale / 100 >> 1) + (ScrollInfo._syoff * AutoMapScale / 100 >> 1) + (px + py) * AmLine8 + (gnScreenHeight - PANEL_HEIGHT) / 2;
if (PANELS_COVER) {
if (invflag || sbookflag)
@ -621,11 +621,11 @@ void DrawAutomap(CelOutputBuffer out)
mapy = AutoMapY - 1;
if (cells & 1) {
sx = gnScreenWidth / 2 + SCREEN_X - AmLine64 * ((cells - 1) >> 1);
sy = (gnScreenHeight - PANEL_HEIGHT) / 2 + SCREEN_Y - AmLine32 * ((cells + 1) >> 1);
sx = gnScreenWidth / 2 - AmLine64 * ((cells - 1) >> 1);
sy = (gnScreenHeight - PANEL_HEIGHT) / 2 - AmLine32 * ((cells + 1) >> 1);
} else {
sx = gnScreenWidth / 2 + SCREEN_X - AmLine64 * (cells >> 1) + AmLine32;
sy = (gnScreenHeight - PANEL_HEIGHT) / 2 + SCREEN_Y - AmLine32 * (cells >> 1) - AmLine16;
sx = gnScreenWidth / 2 - AmLine64 * (cells >> 1) + AmLine32;
sy = (gnScreenHeight - PANEL_HEIGHT) / 2 - AmLine32 * (cells >> 1) - AmLine16;
}
if (ViewX & 1) {
sx -= AmLine16;

5
Source/capture.cpp
Unescape View File

@ -152,8 +152,8 @@ static void RedPalette()
}
palette_update();
SDL_Rect SrcRect = {
SCREEN_X,
SCREEN_Y,
BUFFER_BORDER_LEFT,
BUFFER_BORDER_TOP,
gnScreenWidth,
gnScreenHeight,
};
@ -180,7 +180,6 @@ void CaptureScreen()
lock_buf(2);
CelOutputBuffer buf = GlobalBackBuffer();
buf = buf.subregion(SCREEN_X, SCREEN_Y, gnScreenWidth, gnScreenHeight);
success = CaptureHdr(buf.w(), buf.h(), out_stream);
if (success) {
success = CapturePix(buf, out_stream);

68
Source/control.cpp
Unescape View File

@ -385,8 +385,8 @@ void DrawSpellList(CelOutputBuffer out)
if (currlevel == 0 && !spelldata[j].sTownSpell)
SetSpellTrans(RSPLTYPE_INVALID);
DrawSpellCel(out, x, y, pSpellCels, SpellITbl[j], SPLICONLENGTH);
lx = x - BORDER_LEFT;
ly = y - BORDER_TOP - SPLICONLENGTH;
lx = x;
ly = y - SPLICONLENGTH;
if (MouseX >= lx && MouseX < lx + SPLICONLENGTH && MouseY >= ly && MouseY < ly + SPLICONLENGTH) {
pSpell = (spell_id)j;
pSplType = (spell_type)i;
@ -656,9 +656,9 @@ void DrawLifeFlask(CelOutputBuffer out)
filled = 11;
filled += 2;
DrawFlask(out, pLifeBuff, 13, 3, SCREEN_X + PANEL_LEFT + 109, SCREEN_Y + PANEL_TOP - 13, filled);
DrawFlask(out, pLifeBuff, 13, 3, PANEL_LEFT + 109, PANEL_TOP - 13, filled);
if (filled != 13)
DrawFlask(out, pBtmBuff, 109, filled + 3, SCREEN_X + PANEL_LEFT + 109, SCREEN_Y + PANEL_TOP - 13 + filled, 13 - filled);
DrawFlask(out, pBtmBuff, 109, filled + 3, PANEL_LEFT + 109, PANEL_TOP - 13 + filled, 13 - filled);
}
void UpdateLifeFlask(CelOutputBuffer out)
@ -693,9 +693,9 @@ void DrawManaFlask(CelOutputBuffer out)
filled = 11;
filled += 2;
DrawFlask(out, pManaBuff, 13, 3, SCREEN_X + PANEL_LEFT + 475, SCREEN_Y + PANEL_TOP - 13, filled);
DrawFlask(out, pManaBuff, 13, 3, PANEL_LEFT + 475, PANEL_TOP - 13, filled);
if (filled != 13)
DrawFlask(out, pBtmBuff, 475, filled + 3, SCREEN_X + PANEL_LEFT + 475, SCREEN_Y + PANEL_TOP - 13 + filled, 13 - filled);
DrawFlask(out, pBtmBuff, 475, filled + 3, PANEL_LEFT + 475, PANEL_TOP - 13 + filled, 13 - filled);
}
void control_update_life_mana()
@ -861,8 +861,8 @@ void DoSpeedBook()
spselflag = TRUE;
xo = PANEL_X + 12 + SPLICONLENGTH * 10;
yo = PANEL_Y - 17;
X = xo - (BORDER_LEFT - SPLICONLENGTH / 2);
Y = yo - (BORDER_TOP + SPLICONLENGTH / 2);
X = xo + SPLICONLENGTH / 2;
Y = yo - SPLICONLENGTH / 2;
if (plr[myplr]._pRSpell != SPL_INVALID) {
for (i = 0; i < 4; i++) {
@ -884,8 +884,8 @@ void DoSpeedBook()
for (j = 1; j < MAX_SPELLS; j++) {
if (spell & spells) {
if (j == plr[myplr]._pRSpell && i == plr[myplr]._pRSplType) {
X = xo - (BORDER_LEFT - SPLICONLENGTH / 2);
Y = yo - (BORDER_TOP + SPLICONLENGTH / 2);
X = xo + SPLICONLENGTH / 2;
Y = yo - SPLICONLENGTH / 2;
}
xo -= SPLICONLENGTH;
if (xo == PANEL_X + 12 - SPLICONLENGTH) {
@ -1311,16 +1311,12 @@ void DrawInfoBox(CelOutputBuffer out)
void PrintGameStr(CelOutputBuffer out, int x, int y, const char *str, int color)
{
BYTE c;
int sx, sy;
sx = x + SCREEN_X;
sy = y + SCREEN_Y;
while (*str) {
c = gbFontTransTbl[(BYTE)*str++];
BYTE c = gbFontTransTbl[(BYTE)*str++];
c = fontframe[c];
if (c)
PrintChar(out, sx, sy, c, color);
sx += fontkern[c] + 1;
PrintChar(out, x, y, c, color);
x += fontkern[c] + 1;
}
}
@ -1338,10 +1334,8 @@ static void MY_PlrStringXY(CelOutputBuffer out, int x, int y, int endX, const ch
{
BYTE c;
const char *tmp;
int sx, sy, screen_x, line, widthOffset;
int screen_x, line, widthOffset;
sx = x + SCREEN_X;
sy = y + SCREEN_Y;
widthOffset = endX - x + 1;
line = 0;
screen_x = 0;
@ -1352,16 +1346,16 @@ static void MY_PlrStringXY(CelOutputBuffer out, int x, int y, int endX, const ch
}
if (screen_x < widthOffset)
line = (widthOffset - screen_x) >> 1;
sx += line;
x += line;
while (*pszStr) {
c = gbFontTransTbl[(BYTE)*pszStr++];
c = fontframe[c];
line += fontkern[c] + base;
if (c) {
if (line < widthOffset)
PrintChar(out, sx, sy, c, col);
PrintChar(out, x, y, c, col);
}
sx += fontkern[c] + base;
x += fontkern[c] + base;
}
}
@ -1371,7 +1365,7 @@ void DrawChr(CelOutputBuffer out)
char chrstr[64];
int mindam, maxdam;
CelDrawTo(out, SCREEN_X, 351 + SCREEN_Y, pChrPanel, 1, SPANEL_WIDTH);
CelDrawTo(out, 0, 351, pChrPanel, 1, SPANEL_WIDTH);
ADD_PlrStringXY(out, 20, 32, 151, plr[myplr]._pName, COL_WHITE);
ADD_PlrStringXY(out, 168, 32, 299, ClassStrTblOld[plr[myplr]._pClass], COL_WHITE);
@ -1545,13 +1539,13 @@ void DrawChr(CelOutputBuffer out)
ADD_PlrStringXY(out, 95, 266, 126, chrstr, COL_RED);
plr_class pc = plr[myplr]._pClass;
if (plr[myplr]._pBaseStr < MaxStats[pc][ATTRIB_STR])
CelDrawTo(out, 137 + SCREEN_X, 159 + SCREEN_Y, pChrButtons, chrbtn[ATTRIB_STR] + 2, 41);
CelDrawTo(out, 137, 159, pChrButtons, chrbtn[ATTRIB_STR] + 2, 41);
if (plr[myplr]._pBaseMag < MaxStats[pc][ATTRIB_MAG])
CelDrawTo(out, 137 + SCREEN_X, 187 + SCREEN_Y, pChrButtons, chrbtn[ATTRIB_MAG] + 4, 41);
CelDrawTo(out, 137, 187, pChrButtons, chrbtn[ATTRIB_MAG] + 4, 41);
if (plr[myplr]._pBaseDex < MaxStats[pc][ATTRIB_DEX])
CelDrawTo(out, 137 + SCREEN_X, 216 + SCREEN_Y, pChrButtons, chrbtn[ATTRIB_DEX] + 6, 41);
CelDrawTo(out, 137, 216, pChrButtons, chrbtn[ATTRIB_DEX] + 6, 41);
if (plr[myplr]._pBaseVit < MaxStats[pc][ATTRIB_VIT])
CelDrawTo(out, 137 + SCREEN_X, 244 + SCREEN_Y, pChrButtons, chrbtn[ATTRIB_VIT] + 8, 41);
CelDrawTo(out, 137, 244, pChrButtons, chrbtn[ATTRIB_VIT] + 8, 41);
}
if (plr[myplr]._pMaxHP > plr[myplr]._pMaxHPBase)
@ -1747,7 +1741,7 @@ void RedBack(CelOutputBuffer out)
BYTE *dst, *tbl;
if (leveltype != DTYPE_HELL) {
dst = out.at(SCREEN_X, SCREEN_Y);
dst = out.begin();
tbl = &pLightTbl[idx];
for (h = gnViewportHeight; h; h--, dst += out.pitch() - gnScreenWidth) {
for (w = gnScreenWidth; w; w--) {
@ -1756,7 +1750,7 @@ void RedBack(CelOutputBuffer out)
}
}
} else {
dst = out.at(SCREEN_X, SCREEN_Y);
dst = out.begin();
tbl = &pLightTbl[idx];
for (h = gnViewportHeight; h; h--, dst += out.pitch() - gnScreenWidth) {
for (w = gnScreenWidth; w; w--) {
@ -1833,20 +1827,20 @@ void DrawSpellBook(CelOutputBuffer out)
char st;
unsigned __int64 spl;
CelDrawTo(out, RIGHT_PANEL_X, 351 + SCREEN_Y, pSpellBkCel, 1, SPANEL_WIDTH);
CelDrawTo(out, RIGHT_PANEL_X, 351, pSpellBkCel, 1, SPANEL_WIDTH);
if (gbIsHellfire && sbooktab < 5) {
CelDrawTo(out, RIGHT_PANEL_X + 61 * sbooktab + 7, 348 + SCREEN_Y, pSBkBtnCel, sbooktab + 1, 61);
CelDrawTo(out, RIGHT_PANEL_X + 61 * sbooktab + 7, 348, pSBkBtnCel, sbooktab + 1, 61);
} else {
// BUGFIX: rendering of page 3 and page 4 buttons are both off-by-one pixel (fixed).
int sx = RIGHT_PANEL_X + 76 * sbooktab + 7;
if (sbooktab == 2 || sbooktab == 3) {
sx++;
}
CelDrawTo(out, sx, 348 + SCREEN_Y, pSBkBtnCel, sbooktab + 1, 76);
CelDrawTo(out, sx, 348, pSBkBtnCel, sbooktab + 1, 76);
}
spl = plr[myplr]._pMemSpells | plr[myplr]._pISpells | plr[myplr]._pAblSpells;
yp = 55 + SCREEN_Y;
yp = 55;
for (i = 1; i < 8; i++) {
sn = SpellPages[sbooktab][i - 1];
if (sn != -1 && spl & SPELLBIT(sn)) {
@ -1932,7 +1926,7 @@ void DrawGoldSplit(CelOutputBuffer out, int amount)
int screen_x, i;
screen_x = 0;
CelDrawTo(out, 351 + SCREEN_X, 178 + SCREEN_Y, pGBoxBuff, 1, 261);
CelDrawTo(out, 351, 178, pGBoxBuff, 1, 261);
sprintf(tempstr, "You have %u gold", initialDropGoldValue);
ADD_PlrStringXY(out, 366, 87, 600, tempstr, COL_GOLD);
sprintf(tempstr, "%s. How many do", get_pieces_str(initialDropGoldValue));
@ -1951,7 +1945,7 @@ void DrawGoldSplit(CelOutputBuffer out, int amount)
} else {
screen_x = 450;
}
CelDrawTo(out, screen_x, 140 + SCREEN_Y, pSPentSpn2Cels, PentSpn2Spin(), 12);
CelDrawTo(out, screen_x, 140, pSPentSpn2Cels, PentSpn2Spin(), 12);
}
void control_drop_gold(char vkey)
@ -2029,7 +2023,7 @@ static char *control_print_talk_msg(CelOutputBuffer out, char *msg, int *x, int
BYTE c;
int width;
*x += 200 + SCREEN_X;
*x += 200;
y += 22 + PANEL_Y;
width = *x;
while (*msg) {

4
Source/engine.h
Unescape View File

@ -137,7 +137,7 @@ struct CelOutputBuffer {
*/
CelOutputBuffer subregion(Sint16 x, Sint16 y, Uint16 w, Uint16 h) const
{
return CelOutputBuffer(surface, SDL_Rect { x, y, w, h });
return CelOutputBuffer(surface, SDL_Rect { region.x + x, region.y + y, w, h });
}
/**
@ -146,7 +146,7 @@ struct CelOutputBuffer {
CelOutputBuffer subregionY(Sint16 y, Sint16 h) const
{
SDL_Rect subregion = region;
subregion.y = y;
subregion.y += y;
subregion.h = h;
return CelOutputBuffer(surface, subregion);
}

10
Source/gmenu.cpp
Unescape View File

@ -187,7 +187,7 @@ static void gmenu_draw_menu_item(CelOutputBuffer out, TMenuItem *pItem, int y)
DWORD w, x, nSteps, step, pos;
w = gmenu_get_lfont(pItem);
if (pItem->dwFlags & GMENU_SLIDER) {
x = 16 + w / 2 + SCREEN_X;
x = 16 + w / 2;
CelDrawTo(out, x + PANEL_LEFT, y - 10, optbar_cel, 1, 287);
step = pItem->dwFlags & 0xFFF;
nSteps = (pItem->dwFlags & 0xFFF000) >> 12;
@ -197,7 +197,7 @@ static void gmenu_draw_menu_item(CelOutputBuffer out, TMenuItem *pItem, int y)
gmenu_clear_buffer(out, x + 2 + PANEL_LEFT, y - 12, pos + 13, 28);
CelDrawTo(out, x + 2 + pos + PANEL_LEFT, y - 12, option_cel, 1, 27);
}
x = gnScreenWidth / 2 - w / 2 + SCREEN_X;
x = gnScreenWidth / 2 - w / 2;
light_table_index = (pItem->dwFlags & GMENU_ENABLED) ? 0 : 15;
gmenu_print_text(out, x, y, pItem->pszStr);
if (pItem == sgpCurrItem) {
@ -223,11 +223,11 @@ void gmenu_draw(CelOutputBuffer out)
LogoAnim_frame = 1;
LogoAnim_tick = ticks;
}
CelDrawTo(out, (gnScreenWidth - 430) / 2 + SCREEN_X, 102 + SCREEN_Y + UI_OFFSET_Y, sgpLogo, LogoAnim_frame, 430);
CelDrawTo(out, (gnScreenWidth - 430) / 2, 102 + UI_OFFSET_Y, sgpLogo, LogoAnim_frame, 430);
} else {
CelDrawTo(out, (gnScreenWidth - 296) / 2 + SCREEN_X, 102 + SCREEN_Y + UI_OFFSET_Y, sgpLogo, 1, 296);
CelDrawTo(out, (gnScreenWidth - 296) / 2, 102 + UI_OFFSET_Y, sgpLogo, 1, 296);
}
y = 160 + SCREEN_Y + UI_OFFSET_Y;
y = 160 + UI_OFFSET_Y;
i = sgpCurrentMenu;
if (sgpCurrentMenu->fnMenu) {
while (i->fnMenu) {

2
Source/help.cpp
Unescape View File

@ -460,7 +460,7 @@ static void DrawHelpLine(CelOutputBuffer out, int x, int y, char *text, char col
width = 0;
sx = x + 32 + PANEL_X;
sy = y * 12 + 44 + SCREEN_Y + UI_OFFSET_Y;
sy = y * 12 + 44 + UI_OFFSET_Y;
while (*text) {
c = gbFontTransTbl[(BYTE)*text];
text++;

4
Source/interfac.cpp
Unescape View File

@ -244,13 +244,13 @@ static void DrawCutscene()
lock_buf(1);
CelOutputBuffer out = GlobalBackBuffer();
CelDrawTo(out, PANEL_X, 480 + SCREEN_Y - 1 + UI_OFFSET_Y, sgpBackCel, 1, 640);
CelDrawTo(out, PANEL_X, 480 - 1 + UI_OFFSET_Y, sgpBackCel, 1, 640);
for (i = 0; i < sgdwProgress; i++) {
DrawProgress(
out,
BarPos[progress_id][0] + i + PANEL_X,
BarPos[progress_id][1] + SCREEN_Y + UI_OFFSET_Y,
BarPos[progress_id][1] + UI_OFFSET_Y,
progress_id);
}

98
Source/inv.cpp
Unescape View File

@ -167,10 +167,10 @@ void DrawInv(CelOutputBuffer out)
BOOL invtest[NUM_INV_GRID_ELEM];
int frame, frame_width, color, screen_x, screen_y, i, j, ii;
CelDrawTo(out, RIGHT_PANEL_X, 351 + SCREEN_Y, pInvCels, 1, SPANEL_WIDTH);
CelDrawTo(out, RIGHT_PANEL_X, 351, pInvCels, 1, SPANEL_WIDTH);
if (!plr[myplr].InvBody[INVLOC_HEAD].isEmpty()) {
InvDrawSlotBack(out, RIGHT_PANEL_X + 133, 59 + SCREEN_Y, 2 * INV_SLOT_SIZE_PX, 2 * INV_SLOT_SIZE_PX);
InvDrawSlotBack(out, RIGHT_PANEL_X + 133, 59, 2 * INV_SLOT_SIZE_PX, 2 * INV_SLOT_SIZE_PX);
frame = plr[myplr].InvBody[INVLOC_HEAD]._iCurs + CURSOR_FIRSTITEM;
frame_width = InvItemWidth[frame];
@ -184,29 +184,29 @@ void DrawInv(CelOutputBuffer out)
color = ICOL_RED;
}
if (frame <= 179) {
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 133, 59 + SCREEN_Y, pCursCels, frame, frame_width);
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 133, 59, pCursCels, frame, frame_width);
} else {
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 133, 59 + SCREEN_Y, pCursCels2, frame - 179, frame_width);
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 133, 59, pCursCels2, frame - 179, frame_width);
}
}
if (plr[myplr].InvBody[INVLOC_HEAD]._iStatFlag) {
if (frame <= 179) {
CelClippedDrawTo(out, RIGHT_PANEL_X + 133, 59 + SCREEN_Y, pCursCels, frame, frame_width);
CelClippedDrawTo(out, RIGHT_PANEL_X + 133, 59, pCursCels, frame, frame_width);
} else {
CelClippedDrawTo(out, RIGHT_PANEL_X + 133, 59 + SCREEN_Y, pCursCels2, frame - 179, frame_width);
CelClippedDrawTo(out, RIGHT_PANEL_X + 133, 59, pCursCels2, frame - 179, frame_width);
}
} else {
if (frame <= 179) {
CelDrawLightRedTo(out, RIGHT_PANEL_X + 133, 59 + SCREEN_Y, pCursCels, frame, frame_width, 1);
CelDrawLightRedTo(out, RIGHT_PANEL_X + 133, 59, pCursCels, frame, frame_width, 1);
} else {
CelDrawLightRedTo(out, RIGHT_PANEL_X + 133, 59 + SCREEN_Y, pCursCels2, frame - 179, frame_width, 1);
CelDrawLightRedTo(out, RIGHT_PANEL_X + 133, 59, pCursCels2, frame - 179, frame_width, 1);
}
}
}
if (!plr[myplr].InvBody[INVLOC_RING_LEFT].isEmpty()) {
InvDrawSlotBack(out, RIGHT_PANEL_X + 48, 205 + SCREEN_Y, INV_SLOT_SIZE_PX, INV_SLOT_SIZE_PX);
InvDrawSlotBack(out, RIGHT_PANEL_X + 48, 205, INV_SLOT_SIZE_PX, INV_SLOT_SIZE_PX);
frame = plr[myplr].InvBody[INVLOC_RING_LEFT]._iCurs + CURSOR_FIRSTITEM;
frame_width = InvItemWidth[frame];
@ -220,29 +220,29 @@ void DrawInv(CelOutputBuffer out)
color = ICOL_RED;
}
if (frame <= 179) {
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 48, 205 + SCREEN_Y, pCursCels, frame, frame_width);
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 48, 205, pCursCels, frame, frame_width);
} else {
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 48, 205 + SCREEN_Y, pCursCels2, frame - 179, frame_width);
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 48, 205, pCursCels2, frame - 179, frame_width);
}
}
if (plr[myplr].InvBody[INVLOC_RING_LEFT]._iStatFlag) {
if (frame <= 179) {
CelClippedDrawTo(out, RIGHT_PANEL_X + 48, 205 + SCREEN_Y, pCursCels, frame, frame_width);
CelClippedDrawTo(out, RIGHT_PANEL_X + 48, 205, pCursCels, frame, frame_width);
} else {
CelClippedDrawTo(out, RIGHT_PANEL_X + 48, 205 + SCREEN_Y, pCursCels2, frame - 179, frame_width);
CelClippedDrawTo(out, RIGHT_PANEL_X + 48, 205, pCursCels2, frame - 179, frame_width);
}
} else {
if (frame <= 179) {
CelDrawLightRedTo(out, RIGHT_PANEL_X + 48, 205 + SCREEN_Y, pCursCels, frame, frame_width, 1);
CelDrawLightRedTo(out, RIGHT_PANEL_X + 48, 205, pCursCels, frame, frame_width, 1);
} else {
CelDrawLightRedTo(out, RIGHT_PANEL_X + 48, 205 + SCREEN_Y, pCursCels2, frame - 179, frame_width, 1);
CelDrawLightRedTo(out, RIGHT_PANEL_X + 48, 205, pCursCels2, frame - 179, frame_width, 1);
}
}
}
if (!plr[myplr].InvBody[INVLOC_RING_RIGHT].isEmpty()) {
InvDrawSlotBack(out, RIGHT_PANEL_X + 249, 205 + SCREEN_Y, INV_SLOT_SIZE_PX, INV_SLOT_SIZE_PX);
InvDrawSlotBack(out, RIGHT_PANEL_X + 249, 205, INV_SLOT_SIZE_PX, INV_SLOT_SIZE_PX);
frame = plr[myplr].InvBody[INVLOC_RING_RIGHT]._iCurs + CURSOR_FIRSTITEM;
frame_width = InvItemWidth[frame];
@ -256,29 +256,29 @@ void DrawInv(CelOutputBuffer out)
color = ICOL_RED;
}
if (frame <= 179) {
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 249, 205 + SCREEN_Y, pCursCels, frame, frame_width);
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 249, 205, pCursCels, frame, frame_width);
} else {
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 249, 205 + SCREEN_Y, pCursCels2, frame - 179, frame_width);
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 249, 205, pCursCels2, frame - 179, frame_width);
}
}
if (plr[myplr].InvBody[INVLOC_RING_RIGHT]._iStatFlag) {
if (frame <= 179) {
CelClippedDrawTo(out, RIGHT_PANEL_X + 249, 205 + SCREEN_Y, pCursCels, frame, frame_width);
CelClippedDrawTo(out, RIGHT_PANEL_X + 249, 205, pCursCels, frame, frame_width);
} else {
CelClippedDrawTo(out, RIGHT_PANEL_X + 249, 205 + SCREEN_Y, pCursCels2, frame - 179, frame_width);
CelClippedDrawTo(out, RIGHT_PANEL_X + 249, 205, pCursCels2, frame - 179, frame_width);
}
} else {
if (frame <= 179) {
CelDrawLightRedTo(out, RIGHT_PANEL_X + 249, 205 + SCREEN_Y, pCursCels, frame, frame_width, 1);
CelDrawLightRedTo(out, RIGHT_PANEL_X + 249, 205, pCursCels, frame, frame_width, 1);
} else {
CelDrawLightRedTo(out, RIGHT_PANEL_X + 249, 205 + SCREEN_Y, pCursCels2, frame - 179, frame_width, 1);
CelDrawLightRedTo(out, RIGHT_PANEL_X + 249, 205, pCursCels2, frame - 179, frame_width, 1);
}
}
}
if (!plr[myplr].InvBody[INVLOC_AMULET].isEmpty()) {
InvDrawSlotBack(out, RIGHT_PANEL_X + 205, 60 + SCREEN_Y, INV_SLOT_SIZE_PX, INV_SLOT_SIZE_PX);
InvDrawSlotBack(out, RIGHT_PANEL_X + 205, 60, INV_SLOT_SIZE_PX, INV_SLOT_SIZE_PX);
frame = plr[myplr].InvBody[INVLOC_AMULET]._iCurs + CURSOR_FIRSTITEM;
frame_width = InvItemWidth[frame];
@ -292,35 +292,35 @@ void DrawInv(CelOutputBuffer out)
color = ICOL_RED;
}
if (frame <= 179) {
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 205, 60 + SCREEN_Y, pCursCels, frame, frame_width);
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 205, 60, pCursCels, frame, frame_width);
} else {
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 205, 60 + SCREEN_Y, pCursCels2, frame - 179, frame_width);
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 205, 60, pCursCels2, frame - 179, frame_width);
}
}
if (plr[myplr].InvBody[INVLOC_AMULET]._iStatFlag) {
if (frame <= 179) {
CelClippedDrawTo(out, RIGHT_PANEL_X + 205, 60 + SCREEN_Y, pCursCels, frame, frame_width);
CelClippedDrawTo(out, RIGHT_PANEL_X + 205, 60, pCursCels, frame, frame_width);
} else {
CelClippedDrawTo(out, RIGHT_PANEL_X + 205, 60 + SCREEN_Y, pCursCels2, frame - 179, frame_width);
CelClippedDrawTo(out, RIGHT_PANEL_X + 205, 60, pCursCels2, frame - 179, frame_width);
}
} else {
if (frame <= 179) {
CelDrawLightRedTo(out, RIGHT_PANEL_X + 205, 60 + SCREEN_Y, pCursCels, frame, frame_width, 1);
CelDrawLightRedTo(out, RIGHT_PANEL_X + 205, 60, pCursCels, frame, frame_width, 1);
} else {
CelDrawLightRedTo(out, RIGHT_PANEL_X + 205, 60 + SCREEN_Y, pCursCels2, frame - 179, frame_width, 1);
CelDrawLightRedTo(out, RIGHT_PANEL_X + 205, 60, pCursCels2, frame - 179, frame_width, 1);
}
}
}
if (!plr[myplr].InvBody[INVLOC_HAND_LEFT].isEmpty()) {
InvDrawSlotBack(out, RIGHT_PANEL_X + 17, 160 + SCREEN_Y, 2 * INV_SLOT_SIZE_PX, 3 * INV_SLOT_SIZE_PX);
InvDrawSlotBack(out, RIGHT_PANEL_X + 17, 160, 2 * INV_SLOT_SIZE_PX, 3 * INV_SLOT_SIZE_PX);
frame = plr[myplr].InvBody[INVLOC_HAND_LEFT]._iCurs + CURSOR_FIRSTITEM;
frame_width = InvItemWidth[frame];
// calc item offsets for weapons smaller than 2x3 slots
screen_x = frame_width == INV_SLOT_SIZE_PX ? (RIGHT_PANEL_X + 31) : (RIGHT_PANEL_X + 17);
screen_y = InvItemHeight[frame] == (3 * INV_SLOT_SIZE_PX) ? (160 + SCREEN_Y) : (146 + SCREEN_Y);
screen_y = InvItemHeight[frame] == (3 * INV_SLOT_SIZE_PX) ? (160) : (146);
if (pcursinvitem == INVITEM_HAND_LEFT) {
color = ICOL_WHITE;
@ -355,12 +355,12 @@ void DrawInv(CelOutputBuffer out)
if (plr[myplr]._pClass != PC_BARBARIAN
|| plr[myplr].InvBody[INVLOC_HAND_LEFT]._itype != ITYPE_SWORD
&& plr[myplr].InvBody[INVLOC_HAND_LEFT]._itype != ITYPE_MACE) {
InvDrawSlotBack(out, RIGHT_PANEL_X + 248, 160 + SCREEN_Y, 2 * INV_SLOT_SIZE_PX, 3 * INV_SLOT_SIZE_PX);
InvDrawSlotBack(out, RIGHT_PANEL_X + 248, 160, 2 * INV_SLOT_SIZE_PX, 3 * INV_SLOT_SIZE_PX);
light_table_index = 0;
cel_transparency_active = TRUE;
const int dst_x = RIGHT_PANEL_X + (frame_width == INV_SLOT_SIZE_PX ? 261 : 247);
const int dst_y = SCREEN_Y + 160;
const int dst_y = 160;
if (frame <= 179) {
CelClippedBlitLightTransTo(out, dst_x, dst_y, pCursCels, frame, frame_width);
} else {
@ -372,13 +372,13 @@ void DrawInv(CelOutputBuffer out)
}
}
if (!plr[myplr].InvBody[INVLOC_HAND_RIGHT].isEmpty()) {
InvDrawSlotBack(out, RIGHT_PANEL_X + 248, 160 + SCREEN_Y, 2 * INV_SLOT_SIZE_PX, 3 * INV_SLOT_SIZE_PX);
InvDrawSlotBack(out, RIGHT_PANEL_X + 248, 160, 2 * INV_SLOT_SIZE_PX, 3 * INV_SLOT_SIZE_PX);
frame = plr[myplr].InvBody[INVLOC_HAND_RIGHT]._iCurs + CURSOR_FIRSTITEM;
frame_width = InvItemWidth[frame];
// calc item offsets for weapons smaller than 2x3 slots
screen_x = frame_width == INV_SLOT_SIZE_PX ? (RIGHT_PANEL_X + 261) : (RIGHT_PANEL_X + 249);
screen_y = InvItemHeight[frame] == 3 * INV_SLOT_SIZE_PX ? (160 + SCREEN_Y) : (146 + SCREEN_Y);
screen_y = InvItemHeight[frame] == 3 * INV_SLOT_SIZE_PX ? (160) : (146);
if (pcursinvitem == INVITEM_HAND_RIGHT) {
color = ICOL_WHITE;
@ -411,7 +411,7 @@ void DrawInv(CelOutputBuffer out)
}
if (!plr[myplr].InvBody[INVLOC_CHEST].isEmpty()) {
InvDrawSlotBack(out, RIGHT_PANEL_X + 133, 160 + SCREEN_Y, 2 * INV_SLOT_SIZE_PX, 3 * INV_SLOT_SIZE_PX);
InvDrawSlotBack(out, RIGHT_PANEL_X + 133, 160, 2 * INV_SLOT_SIZE_PX, 3 * INV_SLOT_SIZE_PX);
frame = plr[myplr].InvBody[INVLOC_CHEST]._iCurs + CURSOR_FIRSTITEM;
frame_width = InvItemWidth[frame];
@ -425,23 +425,23 @@ void DrawInv(CelOutputBuffer out)
color = ICOL_RED;
}
if (frame <= 179) {
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 133, 160 + SCREEN_Y, pCursCels, frame, frame_width);
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 133, 160, pCursCels, frame, frame_width);
} else {
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 133, 160 + SCREEN_Y, pCursCels2, frame - 179, frame_width);
CelBlitOutlineTo(out, color, RIGHT_PANEL_X + 133, 160, pCursCels2, frame - 179, frame_width);
}
}
if (plr[myplr].InvBody[INVLOC_CHEST]._iStatFlag) {
if (frame <= 179) {
CelClippedDrawTo(out, RIGHT_PANEL_X + 133, 160 + SCREEN_Y, pCursCels, frame, frame_width);
CelClippedDrawTo(out, RIGHT_PANEL_X + 133, 160, pCursCels, frame, frame_width);
} else {
CelClippedDrawTo(out, RIGHT_PANEL_X + 133, 160 + SCREEN_Y, pCursCels2, frame - 179, frame_width);
CelClippedDrawTo(out, RIGHT_PANEL_X + 133, 160, pCursCels2, frame - 179, frame_width);
}
} else {
if (frame <= 179) {
CelDrawLightRedTo(out, RIGHT_PANEL_X + 133, 160 + SCREEN_Y, pCursCels, frame, frame_width, 1);
CelDrawLightRedTo(out, RIGHT_PANEL_X + 133, 160, pCursCels, frame, frame_width, 1);
} else {
CelDrawLightRedTo(out, RIGHT_PANEL_X + 133, 160 + SCREEN_Y, pCursCels2, frame - 179, frame_width, 1);
CelDrawLightRedTo(out, RIGHT_PANEL_X + 133, 160, pCursCels2, frame - 179, frame_width, 1);
}
}
}
@ -452,7 +452,7 @@ void DrawInv(CelOutputBuffer out)
InvDrawSlotBack(
out,
InvRect[i + SLOTXY_INV_FIRST].X + RIGHT_PANEL_X,
InvRect[i + SLOTXY_INV_FIRST].Y + SCREEN_Y - 1,
InvRect[i + SLOTXY_INV_FIRST].Y - 1,
INV_SLOT_SIZE_PX,
INV_SLOT_SIZE_PX);
}
@ -480,14 +480,14 @@ void DrawInv(CelOutputBuffer out)
out,
color,
InvRect[j + SLOTXY_INV_FIRST].X + RIGHT_PANEL_X,
InvRect[j + SLOTXY_INV_FIRST].Y + SCREEN_Y - 1,
InvRect[j + SLOTXY_INV_FIRST].Y - 1,
pCursCels, frame, frame_width);
} else {
CelBlitOutlineTo(
out,
color,
InvRect[j + SLOTXY_INV_FIRST].X + RIGHT_PANEL_X,
InvRect[j + SLOTXY_INV_FIRST].Y + SCREEN_Y - 1,
InvRect[j + SLOTXY_INV_FIRST].Y - 1,
pCursCels2, frame - 179, frame_width);
}
}
@ -497,13 +497,13 @@ void DrawInv(CelOutputBuffer out)
CelClippedDrawTo(
out,
InvRect[j + SLOTXY_INV_FIRST].X + RIGHT_PANEL_X,
InvRect[j + SLOTXY_INV_FIRST].Y + SCREEN_Y - 1,
InvRect[j + SLOTXY_INV_FIRST].Y - 1,
pCursCels, frame, frame_width);
} else {
CelClippedDrawTo(
out,
InvRect[j + SLOTXY_INV_FIRST].X + RIGHT_PANEL_X,
InvRect[j + SLOTXY_INV_FIRST].Y + SCREEN_Y - 1,
InvRect[j + SLOTXY_INV_FIRST].Y - 1,
pCursCels2, frame - 179, frame_width);
}
} else {
@ -511,13 +511,13 @@ void DrawInv(CelOutputBuffer out)
CelDrawLightRedTo(
out,
InvRect[j + SLOTXY_INV_FIRST].X + RIGHT_PANEL_X,
InvRect[j + SLOTXY_INV_FIRST].Y + SCREEN_Y - 1,
InvRect[j + SLOTXY_INV_FIRST].Y - 1,
pCursCels, frame, frame_width, 1);
} else {
CelDrawLightRedTo(
out,
InvRect[j + SLOTXY_INV_FIRST].X + RIGHT_PANEL_X,
InvRect[j + SLOTXY_INV_FIRST].Y + SCREEN_Y - 1,
InvRect[j + SLOTXY_INV_FIRST].Y - 1,
pCursCels2, frame - 179, frame_width, 1);
}
}

12
Source/items.cpp
Unescape View File

@ -3962,8 +3962,8 @@ void PrintItemPower(char plidx, ItemStruct *x)
static void DrawUTextBack(CelOutputBuffer out)
{
CelDrawTo(out, RIGHT_PANEL_X - SPANEL_WIDTH + 24, SCREEN_Y + 327, pSTextBoxCels, 1, 271);
DrawHalfTransparentRectTo(out, RIGHT_PANEL_X - SPANEL_WIDTH + 27, SCREEN_Y + 28, 265, 297);
CelDrawTo(out, RIGHT_PANEL_X - SPANEL_WIDTH + 24, 327, pSTextBoxCels, 1, 271);
DrawHalfTransparentRectTo(out, RIGHT_PANEL_X - SPANEL_WIDTH + 27, 28, 265, 297);
}
void PrintUString(CelOutputBuffer out, int x, int y, BOOL cjustflag, const char *str, int col)
@ -3971,8 +3971,8 @@ void PrintUString(CelOutputBuffer out, int x, int y, BOOL cjustflag, const char
int len, width, sx, sy, i, k;
BYTE c;
sx = x + 32 + SCREEN_X;
sy = y * 12 + 44 + SCREEN_Y;
sx = x + 32;
sy = y * 12 + 44;
len = strlen(str);
k = 0;
if (cjustflag) {
@ -3996,8 +3996,8 @@ void PrintUString(CelOutputBuffer out, int x, int y, BOOL cjustflag, const char
static void DrawULine(CelOutputBuffer out, int y)
{
BYTE *src = out.at(SCREEN_X + 26 + RIGHT_PANEL - SPANEL_WIDTH, SCREEN_Y + 25);
BYTE *dst = out.at(26 + RIGHT_PANEL_X - SPANEL_WIDTH, SCREEN_Y + y * 12 + 38);
BYTE *src = out.at(26 + RIGHT_PANEL - SPANEL_WIDTH, 25);
BYTE *dst = out.at(26 + RIGHT_PANEL_X - SPANEL_WIDTH, y * 12 + 38);
for (int i = 0; i < 3; i++, src += out.pitch(), dst += out.pitch())
memcpy(dst, src, 267); // BUGFIX: should be 267 (fixed)

12
Source/minitext.cpp
Unescape View File

@ -145,7 +145,7 @@ int CalcTextSpeed(int nSFX)
void PrintQTextChr(int sx, int sy, Uint8 *pCelBuff, int nCel)
{
CelOutputBuffer buf = GlobalBackBuffer();
const int start_y = 49 + SCREEN_Y + UI_OFFSET_Y;
const int start_y = 49 + UI_OFFSET_Y;
buf = buf.subregionY(start_y, 260);
CelDrawTo(buf, sx, sy - start_y, pCelBuff, nCel, 22);
}
@ -158,7 +158,7 @@ void ScrollQTextContent(const char *pnl)
{
for (Uint32 currTime = SDL_GetTicks(); sgLastScroll + qtextSpd < currTime; sgLastScroll += qtextSpd) {
qtexty--;
if (qtexty <= 49 + SCREEN_Y + UI_OFFSET_Y) {
if (qtexty <= 49 + UI_OFFSET_Y) {
qtexty += 38;
qtextptr = pnl;
if (*pnl == '|') {
@ -202,7 +202,7 @@ static void DrawQTextContent(CelOutputBuffer out)
}
tx = 48 + PANEL_X;
ty += lineHeight;
if (ty > 341 + SCREEN_Y + UI_OFFSET_Y) {
if (ty > 341 + UI_OFFSET_Y) {
doneflag = true;
}
}
@ -241,7 +241,7 @@ void InitQTextMsg(int m)
questlog = false;
qtextptr = alltext[m].txtstr;
qtextflag = true;
qtexty = 340 + SCREEN_Y + UI_OFFSET_Y;
qtexty = 340 + UI_OFFSET_Y;
qtextSpd = CalcTextSpeed(alltext[m].sfxnr);
sgLastScroll = SDL_GetTicks();
}
@ -250,8 +250,8 @@ void InitQTextMsg(int m)
void DrawQTextBack(CelOutputBuffer out)
{
CelDrawTo(out, PANEL_X + 24, SCREEN_Y + 327 + UI_OFFSET_Y, pTextBoxCels, 1, 591);
DrawHalfTransparentRectTo(out, PANEL_X + 27, SCREEN_Y + UI_OFFSET_Y + 28, 585, 297);
CelDrawTo(out, PANEL_X + 24, 327 + UI_OFFSET_Y, pTextBoxCels, 1, 591);
DrawHalfTransparentRectTo(out, PANEL_X + 27, UI_OFFSET_Y + 28, 585, 297);
}
void DrawQText(CelOutputBuffer out)

4
Source/palette.cpp
Unescape View File

@ -230,7 +230,7 @@ void PaletteFadeIn(int fr)
DWORD tc = SDL_GetTicks();
for (i = 0; i < 256; i = (SDL_GetTicks() - tc) / 2.083) { // 32 frames @ 60hz
SetFadeLevel(i);
SDL_Rect SrcRect = { SCREEN_X, SCREEN_Y, gnScreenWidth, gnScreenHeight };
SDL_Rect SrcRect = { BUFFER_BORDER_LEFT, BUFFER_BORDER_TOP, gnScreenWidth, gnScreenHeight };
BltFast(&SrcRect, NULL);
RenderPresent();
}
@ -247,7 +247,7 @@ void PaletteFadeOut(int fr)
DWORD tc = SDL_GetTicks();
for (i = 256; i > 0; i = 256 - (SDL_GetTicks() - tc) / 2.083) { // 32 frames @ 60hz
SetFadeLevel(i);
SDL_Rect SrcRect = { SCREEN_X, SCREEN_Y, gnScreenWidth, gnScreenHeight };
SDL_Rect SrcRect = { BUFFER_BORDER_LEFT, BUFFER_BORDER_TOP, gnScreenWidth, gnScreenHeight };
BltFast(&SrcRect, NULL);
RenderPresent();
}

4
Source/plrmsg.cpp
Unescape View File

@ -87,8 +87,8 @@ void InitPlrMsg()
void DrawPlrMsg(CelOutputBuffer out)
{
int i;
DWORD x = 10 + SCREEN_X;
DWORD y = 70 + SCREEN_Y;
DWORD x = 10;
DWORD y = 70;
DWORD width = gnScreenWidth - 20;
_plrmsg *pMsg;

10
Source/quests.cpp
Unescape View File

@ -810,8 +810,8 @@ static void PrintQLString(CelOutputBuffer out, int x, int y, BOOL cjustflag, con
int len, width, i, k, sx, sy;
BYTE c;
sx = x + 32 + SCREEN_X;
sy = y * 12 + 44 + SCREEN_Y;
sx = x + 32;
sy = y * 12 + 44;
len = strlen(str);
k = 0;
if (cjustflag) {
@ -823,7 +823,7 @@ static void PrintQLString(CelOutputBuffer out, int x, int y, BOOL cjustflag, con
sx += k;
}
if (qline == y) {
CelDrawTo(out, cjustflag ? x + k + 12 + SCREEN_X : x + 12 + SCREEN_X, sy + 1, pSPentSpn2Cels, PentSpn2Spin(), 12);
CelDrawTo(out, cjustflag ? x + k + 12 : x + 12, sy + 1, pSPentSpn2Cels, PentSpn2Spin(), 12);
}
for (i = 0; i < len; i++) {
c = fontframe[gbFontTransTbl[(BYTE)str[i]]];
@ -834,7 +834,7 @@ static void PrintQLString(CelOutputBuffer out, int x, int y, BOOL cjustflag, con
sx += fontkern[c] + 1;
}
if (qline == y) {
CelDrawTo(out, cjustflag ? x + k + 36 + SCREEN_X : 276 + SCREEN_X - x, sy + 1, pSPentSpn2Cels, PentSpn2Spin(), 12);
CelDrawTo(out, cjustflag ? x + k + 36 : 276 - x, sy + 1, pSPentSpn2Cels, PentSpn2Spin(), 12);
}
}
@ -843,7 +843,7 @@ void DrawQuestLog(CelOutputBuffer out)
int y, i;
PrintQLString(out, 0, 2, TRUE, "Quest Log", 3);
CelDrawTo(out, SCREEN_X, SCREEN_Y + 351, pQLogCel, 1, SPANEL_WIDTH);
CelDrawTo(out, 0, 351, pQLogCel, 1, SPANEL_WIDTH);
y = qtopline;
for (i = 0; i < numqlines; i++) {
PrintQLString(out, 0, y, TRUE, questlist[qlist[i]]._qlstr, 0);

22
Source/render.cpp
Unescape View File

@ -453,6 +453,14 @@ void RenderTile(CelOutputBuffer out, int x, int y)
DWORD m, *pFrameTable;
const DWORD *mask;
// TODO: Get rid of overdraw by rendering edge tiles separately.
out.region.x -= BUFFER_BORDER_LEFT;
out.region.y -= BUFFER_BORDER_TOP;
out.region.w += BUFFER_BORDER_LEFT;
out.region.h += BUFFER_BORDER_TOP;
x += BUFFER_BORDER_LEFT;
y += BUFFER_BORDER_TOP;
pFrameTable = (DWORD *)pDungeonCels;
src = &pDungeonCels[SDL_SwapLE32(pFrameTable[level_cel_block & 0xFFF])];
@ -505,7 +513,7 @@ void RenderTile(CelOutputBuffer out, int x, int y)
}
#endif
BYTE *dst_begin = out.at(0, SCREEN_Y);
BYTE *dst_begin = out.at(0, BUFFER_BORDER_TOP);
BYTE *dst_end = out.end();
BYTE *dst = out.at(x, y);
const int dst_pitch = out.pitch();
@ -580,12 +588,20 @@ void world_draw_black_tile(CelOutputBuffer out, int sx, int sy)
{
int i, j;
if (sx >= SCREEN_X + gnScreenWidth || sy >= SCREEN_Y + gnViewportHeight + TILE_WIDTH / 2)
if (sx >= gnScreenWidth || sy >= gnViewportHeight + TILE_WIDTH / 2)
return;
if (sx < SCREEN_X - (TILE_WIDTH - 4) || sy < SCREEN_Y)
if (sx < -(TILE_WIDTH - 4) || sy < 0)
return;
// TODO: Get rid of overdraw by rendering edge tiles separately.
out.region.x -= BUFFER_BORDER_LEFT;
out.region.y -= BUFFER_BORDER_TOP;
out.region.w += BUFFER_BORDER_LEFT;
out.region.h += BUFFER_BORDER_TOP;
sx += BUFFER_BORDER_LEFT;
sy += BUFFER_BORDER_TOP;
BYTE *dst = out.at(sx + TILE_WIDTH / 2 - 2, sy);
for (i = TILE_HEIGHT - 2, j = 1; i >= 0; i -= 2, j++, dst -= out.pitch() + 2) {
if (dst < out.end())

57
Source/scrollrt.cpp
Unescape View File

@ -122,9 +122,7 @@ static void scrollrt_draw_cursor_back_buffer(CelOutputBuffer out)
return;
}
BlitCursor(
out.at(SCREEN_X + sgdwCursX, SCREEN_Y + sgdwCursY), out.pitch(),
sgSaveBack, sgdwCursWdt);
BlitCursor(out.at(sgdwCursX, sgdwCursY), out.pitch(), sgSaveBack, sgdwCursWdt);
sgdwCursXOld = sgdwCursX;
sgdwCursYOld = sgdwCursY;
@ -182,14 +180,12 @@ static void scrollrt_draw_cursor_item(CelOutputBuffer out)
sgdwCursHgt -= sgdwCursY;
sgdwCursHgt++;
BlitCursor(
sgSaveBack, sgdwCursWdt,
out.at(SCREEN_X + sgdwCursX, SCREEN_Y + sgdwCursY), out.pitch());
BlitCursor(sgSaveBack, sgdwCursWdt, out.at(sgdwCursX, sgdwCursY), out.pitch());
mx++;
my++;
out = out.subregion(0, 0, out.w() - 2, SCREEN_Y + gnScreenHeight);
out = out.subregion(0, 0, out.w() - 2, out.h());
if (pcurs >= CURSOR_FIRSTITEM) {
col = PAL16_YELLOW + 5;
if (plr[myplr].HoldItem._iMagical != 0) {
@ -199,22 +195,22 @@ static void scrollrt_draw_cursor_item(CelOutputBuffer out)
col = PAL16_RED + 5;
}
if (pcurs <= 179) {
CelBlitOutlineTo(out, col, mx + SCREEN_X, my + cursH + SCREEN_Y - 1, pCursCels, pcurs, cursW);
CelBlitOutlineTo(out, col, mx, my + cursH - 1, pCursCels, pcurs, cursW);
if (col != PAL16_RED + 5) {
CelClippedDrawSafeTo(out, mx + SCREEN_X, my + cursH + SCREEN_Y - 1, pCursCels, pcurs, cursW);
CelClippedDrawSafeTo(out, mx, my + cursH - 1, pCursCels, pcurs, cursW);
} else {
CelDrawLightRedSafeTo(out, mx + SCREEN_X, my + cursH + SCREEN_Y - 1, pCursCels, pcurs, cursW, 1);
CelDrawLightRedSafeTo(out, mx, my + cursH - 1, pCursCels, pcurs, cursW, 1);
}
} else {
CelBlitOutlineTo(out, col, mx + SCREEN_X, my + cursH + SCREEN_Y - 1, pCursCels2, pcurs - 179, cursW);
CelBlitOutlineTo(out, col, mx, my + cursH - 1, pCursCels2, pcurs - 179, cursW);
if (col != PAL16_RED + 5) {
CelClippedDrawSafeTo(out, mx + SCREEN_X, my + cursH + SCREEN_Y - 1, pCursCels2, pcurs - 179, cursW);
CelClippedDrawSafeTo(out, mx, my + cursH - 1, pCursCels2, pcurs - 179, cursW);
} else {
CelDrawLightRedSafeTo(out, mx + SCREEN_X, my + cursH + SCREEN_Y - 1, pCursCels2, pcurs - 179, cursW, 0);
CelDrawLightRedSafeTo(out, mx, my + cursH - 1, pCursCels2, pcurs - 179, cursW, 0);
}
}
} else {
CelClippedDrawSafeTo(out, mx + SCREEN_X, my + cursH + SCREEN_Y - 1, pCursCels, pcurs, cursW);
CelClippedDrawSafeTo(out, mx, my + cursH - 1, pCursCels, pcurs, cursW);
}
}
@ -799,7 +795,7 @@ static void scrollrt_draw_dungeon(CelOutputBuffer out, int sx, int sy, int dx, i
// Tree leaves should always cover player when entering or leaving the tile,
// So delay the rendering until after the next row is being drawn.
// This could probably have been better solved by sprites in screen space.
if (sx > 0 && sy > 0 && dy > TILE_HEIGHT + SCREEN_Y) {
if (sx > 0 && sy > 0 && dy > TILE_HEIGHT) {
char bArch = dSpecial[sx - 1][sy - 1];
if (bArch != 0) {
CelDrawTo(out, dx, dy - TILE_HEIGHT, pSpecialCels, bArch, 64);
@ -876,7 +872,7 @@ static void scrollrt_draw(CelOutputBuffer out, int x, int y, int sx, int sy, int
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
if (x >= 0 && x < MAXDUNX && y >= 0 && y < MAXDUNY) {
if (x + 1 < MAXDUNX && y - 1 >= 0 && sx + TILE_WIDTH <= SCREEN_X + gnScreenWidth) {
if (x + 1 < MAXDUNX && y - 1 >= 0 && sx + TILE_WIDTH <= gnScreenWidth) {
// Render objects behind walls first to prevent sprites, that are moving
// between tiles, from poking through the walls as they exceed the tile bounds.
// A proper fix for this would probably be to layout the sceen and render by
@ -919,8 +915,8 @@ static void Zoom(CelOutputBuffer out)
{
int wdt = gnScreenWidth / 2;
int src_x = SCREEN_X + gnScreenWidth / 2 - 1;
int dst_x = SCREEN_X + gnScreenWidth - 1;
int src_x = gnScreenWidth / 2 - 1;
int dst_x = gnScreenWidth - 1;
if (PANELS_COVER) {
if (chrflag || questlog) {
@ -933,8 +929,8 @@ static void Zoom(CelOutputBuffer out)
}
}
BYTE *src = out.at(src_x, SCREEN_Y + gnViewportHeight / 2 - 1);
BYTE *dst = out.at(dst_x, SCREEN_Y + gnViewportHeight - 1);
BYTE *src = out.at(src_x, gnViewportHeight / 2 - 1);
BYTE *dst = out.at(dst_x, gnViewportHeight - 1);
for (int hgt = 0; hgt < gnViewportHeight / 2; hgt++) {
for (int i = 0; i < wdt; i++) {
@ -1098,12 +1094,12 @@ static void DrawGame(CelOutputBuffer full_out, int x, int y)
// Limit rendering to the view area
CelOutputBuffer out = zoomflag
? full_out.subregionY(0, SCREEN_Y + gnViewportHeight)
: full_out.subregionY(0, SCREEN_Y + gnViewportHeight / 2);
? full_out.subregionY(0, gnViewportHeight)
: full_out.subregionY(0, gnViewportHeight / 2);
// Adjust by player offset and tile grid alignment
sx = ScrollInfo._sxoff + tileOffsetX + SCREEN_X;
sy = ScrollInfo._syoff + tileOffsetY + SCREEN_Y;
sx = ScrollInfo._sxoff + tileOffsetX;
sy = ScrollInfo._syoff + tileOffsetY;
columns = tileColums;
rows = tileRows;
@ -1185,7 +1181,7 @@ static void DrawGame(CelOutputBuffer full_out, int x, int y)
scrollrt_draw(out, x, y, sx, sy, rows, columns);
if (!zoomflag) {
Zoom(full_out.subregionY(0, SCREEN_Y + gnScreenHeight));
Zoom(full_out.subregionY(0, gnScreenHeight));
}
}
@ -1196,7 +1192,7 @@ void DrawView(CelOutputBuffer out, int StartX, int StartY)
{
DrawGame(out, StartX, StartY);
if (automapflag) {
DrawAutomap(out.subregionY(0, SCREEN_Y + gnViewportHeight));
DrawAutomap(out.subregionY(0, gnViewportHeight));
}
DrawMonsterHealthBar(out);
@ -1264,8 +1260,8 @@ void ClearScreenBuffer()
assert(pal_surface != NULL);
SDL_Rect SrcRect = {
SCREEN_X,
SCREEN_Y,
BUFFER_BORDER_LEFT,
BUFFER_BORDER_TOP,
gnScreenWidth,
gnScreenHeight,
};
@ -1397,10 +1393,7 @@ static void DrawFPS(CelOutputBuffer out)
*/
static void DoBlitScreen(Sint16 dwX, Sint16 dwY, Uint16 dwWdt, Uint16 dwHgt)
{
SDL_Rect SrcRect = { dwX, dwY, dwWdt, dwHgt };
SrcRect.x += SCREEN_X;
SrcRect.y += SCREEN_Y;
SDL_Rect SrcRect = { BUFFER_BORDER_LEFT + dwX, BUFFER_BORDER_TOP + dwY, dwWdt, dwHgt };
SDL_Rect DstRect = { dwX, dwY, dwWdt, dwHgt };
BltFast(&SrcRect, &DstRect);

24
Source/stores.cpp
Unescape View File

@ -63,16 +63,16 @@ const char *const talkname[] = {
void DrawSTextBack(CelOutputBuffer out)
{
CelDrawTo(out, PANEL_X + 344, 327 + SCREEN_Y + UI_OFFSET_Y, pSTextBoxCels, 1, 271);
DrawHalfTransparentRectTo(out, PANEL_X + 347, SCREEN_Y + UI_OFFSET_Y + 28, 265, 297);
CelDrawTo(out, PANEL_X + 344, 327 + UI_OFFSET_Y, pSTextBoxCels, 1, 271);
DrawHalfTransparentRectTo(out, PANEL_X + 347, UI_OFFSET_Y + 28, 265, 297);
}
void DrawSSlider(CelOutputBuffer out, int y1, int y2)
{
int yd1, yd2, yd3;
yd1 = y1 * 12 + 44 + SCREEN_Y + UI_OFFSET_Y;
yd2 = y2 * 12 + 44 + SCREEN_Y + UI_OFFSET_Y;
yd1 = y1 * 12 + 44 + UI_OFFSET_Y;
yd2 = y2 * 12 + 44 + UI_OFFSET_Y;
if (stextscrlubtn != -1)
CelDrawTo(out, PANEL_X + 601, yd1, pSTextSlidCels, 12, 12);
else
@ -93,7 +93,7 @@ void DrawSSlider(CelOutputBuffer out, int y1, int y2)
yd3 = 1000 * (stextsval + ((yd3 - stextup) >> 2)) / (storenumh - 1) * (y2 * 12 - y1 * 12 - 24) / 1000;
else
yd3 = 0;
CelDrawTo(out, PANEL_X + 601, (y1 + 1) * 12 + 44 + SCREEN_Y + UI_OFFSET_Y + yd3, pSTextSlidCels, 13, 12);
CelDrawTo(out, PANEL_X + 601, (y1 + 1) * 12 + 44 + UI_OFFSET_Y + yd3, pSTextSlidCels, 13, 12);
}
void AddSLine(int y)
@ -2289,7 +2289,7 @@ void PrintSString(CelOutputBuffer out, int x, int y, bool cjustflag, const char
else
xx = PANEL_X + 352;
sx = xx + x;
sy = s + 44 + SCREEN_Y + UI_OFFSET_Y;
sy = s + 44 + UI_OFFSET_Y;
len = strlen(str);
if (stextsize)
yy = 577;
@ -2305,7 +2305,7 @@ void PrintSString(CelOutputBuffer out, int x, int y, bool cjustflag, const char
sx += k;
}
if (stextsel == y) {
CelDrawTo(out, cjustflag ? xx + x + k - 20 : xx + x - 20, s + 45 + SCREEN_Y + UI_OFFSET_Y, pSPentSpn2Cels, PentSpn2Spin(), 12);
CelDrawTo(out, cjustflag ? xx + x + k - 20 : xx + x - 20, s + 45 + UI_OFFSET_Y, pSPentSpn2Cels, PentSpn2Spin(), 12);
}
for (i = 0; i < len; i++) {
c = fontframe[gbFontTransTbl[(BYTE)str[i]]];
@ -2328,7 +2328,7 @@ void PrintSString(CelOutputBuffer out, int x, int y, bool cjustflag, const char
}
}
if (stextsel == y) {
CelDrawTo(out, cjustflag ? (xx + x + k + 4) : (PANEL_X + 596 - x), s + 45 + SCREEN_Y + UI_OFFSET_Y, pSPentSpn2Cels, PentSpn2Spin(), 12);
CelDrawTo(out, cjustflag ? (xx + x + k + 4) : (PANEL_X + 596 - x), s + 45 + UI_OFFSET_Y, pSPentSpn2Cels, PentSpn2Spin(), 12);
}
}
@ -2338,12 +2338,12 @@ void DrawSLine(CelOutputBuffer out, int y)
BYTE *src, *dst;
int width;
if (stextsize) {
src = out.at(SCREEN_X + PANEL_LEFT + 26, SCREEN_Y + 25 + UI_OFFSET_Y);
dst = out.at(26 + PANEL_X, SCREEN_Y + sy + 38 + UI_OFFSET_Y);
src = out.at(PANEL_LEFT + 26, 25 + UI_OFFSET_Y);
dst = out.at(26 + PANEL_X, sy + 38 + UI_OFFSET_Y);
width = 587; // BUGFIX: should be 587, not 586 (fixed)
} else {
src = out.at(SCREEN_X + PANEL_LEFT + 346, SCREEN_Y + 25 + UI_OFFSET_Y);
dst = out.at(346 + PANEL_X, SCREEN_Y + sy + 38 + UI_OFFSET_Y);
src = out.at(PANEL_LEFT + 346, 25 + UI_OFFSET_Y);
dst = out.at(346 + PANEL_X, sy + 38 + UI_OFFSET_Y);
width = 267; // BUGFIX: should be 267, not 266 (fixed)
}

9
SourceX/dx.cpp
Unescape View File

@ -36,7 +36,12 @@ SDL_Surface *pal_surface;
static void dx_create_back_buffer()
{
pal_surface = SDL_CreateRGBSurfaceWithFormat(0, BUFFER_WIDTH, BUFFER_HEIGHT, 8, SDL_PIXELFORMAT_INDEX8);
pal_surface = SDL_CreateRGBSurfaceWithFormat(
/*flags=*/0,
/*width=*/BUFFER_BORDER_LEFT + gnScreenWidth + BUFFER_BORDER_RIGHT,
/*height=*/BUFFER_BORDER_TOP + gnScreenHeight + BUFFER_BORDER_BOTTOM,
/*depth=*/8,
SDL_PIXELFORMAT_INDEX8);
if (pal_surface == NULL) {
ErrSdl();
}
@ -125,7 +130,7 @@ CelOutputBuffer GlobalBackBuffer()
return CelOutputBuffer();
}
return CelOutputBuffer(pal_surface);
return CelOutputBuffer(pal_surface, SDL_Rect{BUFFER_BORDER_LEFT, BUFFER_BORDER_TOP, gnScreenWidth, gnScreenHeight});
}
void dx_cleanup()

4
SourceX/qol.cpp
Unescape View File

@ -20,12 +20,12 @@ int GetTextWidth(const char *s)
void FastDrawHorizLine(CelOutputBuffer out, int x, int y, int width, BYTE col)
{
memset(out.at(SCREEN_X + x, SCREEN_Y + y), col, width);
memset(out.at(x, y), col, width);
}
void FastDrawVertLine(CelOutputBuffer out, int x, int y, int height, BYTE col)
{
BYTE *p = out.at(SCREEN_X + x, SCREEN_Y + y);
BYTE *p = out.at(x, y);
for (int j = 0; j < height; j++) {
*p = col;
p += out.pitch();

22
defs.h
Unescape View File

@ -123,16 +123,10 @@
#define SCREEN_BPP 32
#endif
#define BORDER_LEFT 64
#define BORDER_TOP 160
#define BORDER_RIGHT dvl::borderRight
#define BORDER_BOTTOM 16
#define SCREEN_X BORDER_LEFT
#define SCREEN_Y BORDER_TOP
#define BUFFER_WIDTH (BORDER_LEFT + gnScreenWidth + BORDER_RIGHT)
#define BUFFER_HEIGHT (BORDER_TOP + gnScreenHeight + BORDER_BOTTOM)
#define BUFFER_BORDER_LEFT 64
#define BUFFER_BORDER_TOP 160
#define BUFFER_BORDER_RIGHT dvl::borderRight
#define BUFFER_BORDER_BOTTOM 16
#define UI_OFFSET_Y ((Sint16)((gnScreenHeight - 480) / 2))
@ -143,18 +137,18 @@
#define PANEL_HEIGHT 128
#define PANEL_TOP (gnScreenHeight - PANEL_HEIGHT)
#define PANEL_LEFT (gnScreenWidth - PANEL_WIDTH) / 2
#define PANEL_X (SCREEN_X + PANEL_LEFT)
#define PANEL_Y (SCREEN_Y + PANEL_TOP)
#define PANEL_X PANEL_LEFT
#define PANEL_Y PANEL_TOP
#define SPANEL_WIDTH 320
#define SPANEL_HEIGHT 352
#define PANELS_COVER (gnScreenWidth <= PANEL_WIDTH && gnScreenHeight <= SPANEL_HEIGHT + PANEL_HEIGHT)
#define RIGHT_PANEL (gnScreenWidth - SPANEL_WIDTH)
#define RIGHT_PANEL_X (SCREEN_X + RIGHT_PANEL)
#define RIGHT_PANEL_X RIGHT_PANEL
#define DIALOG_TOP ((gnScreenHeight - PANEL_HEIGHT) / 2 - 18)
#define DIALOG_Y (SCREEN_Y + DIALOG_TOP)
#define DIALOG_Y DIALOG_TOP
#define NIGHTMARE_TO_HIT_BONUS 85
#define HELL_TO_HIT_BONUS 120

Write Preview
Loading…
Cancel
Save