mirror of
https://github.com/jmarshall23/Hellfire.git
synced 2026-08-12 07:50:53 +02:00
Justin Marshall
3036 lines
80 KiB
C++
3036 lines
80 KiB
C++
/*-----------------------------------------------------------------------**
|
|
** Diablo
|
|
**
|
|
** Control panel file
|
|
**
|
|
** (C)1995 Condor, Inc. All rights reserved.
|
|
**
|
|
**-----------------------------------------------------------------------**
|
|
** $Header: /Diablo/STORES.CPP 6 3/19/97 11:19a Jmcreynolds $
|
|
**-----------------------------------------------------------------------**
|
|
**
|
|
** File Routines
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
#include "diablo.h"
|
|
#pragma hdrstop
|
|
#include "engine.h"
|
|
#include "control.h"
|
|
#include "scrollrt.h"
|
|
#include "gendung.h"
|
|
#include "items.h"
|
|
#include "itemdat.h"
|
|
#include "player.h"
|
|
#include "stores.h"
|
|
#include "minitext.h"
|
|
#include "cursor.h"
|
|
#include "inv.h"
|
|
#include "quests.h"
|
|
#include "effects.h"
|
|
#include "multi.h"
|
|
#include "towners.h"
|
|
#include "spelldat.h"
|
|
#include "textdat.h"
|
|
#include "spells.h"
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
** Local defines
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
#define STEXT_SMALL 0
|
|
#define STEXT_LARGE 1
|
|
|
|
#define MAXHOLDITEMS 48
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
** Global variables
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
BYTE *pSTextBoxCels;
|
|
BYTE *pSTextSpinCels;
|
|
BYTE *pSTextSlidCels;
|
|
|
|
char stextflag, stextsize;
|
|
int stextspin, stextsel;
|
|
int stextlhold, stextshold, stextvhold;
|
|
|
|
BOOL stextscrl;
|
|
int stextsval, stextsmax;
|
|
int stextup, stextdown;
|
|
|
|
char stextscrlubtn, stextscrldbtn;
|
|
|
|
int SStringY[24] = {
|
|
0, 12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144,
|
|
156, 168, 180, 192, 204, 216, 228, 240, 252, 264, 276 };
|
|
|
|
STextStruct stext[NUMSTLINES];
|
|
|
|
ItemStruct smithitem[MAXSMITHITEMS];
|
|
|
|
ItemStruct premiumitem[MAXPREMIUM];
|
|
int numpremium, premiumlevel;
|
|
|
|
ItemStruct witchitem[MAXWITCHITEMS];
|
|
|
|
ItemStruct boyitem;
|
|
int boylevel;
|
|
|
|
ItemStruct healitem[MAXHEALITEMS];
|
|
|
|
ItemStruct storehold[MAXHOLDITEMS];
|
|
char storehidx[MAXHOLDITEMS];
|
|
|
|
ItemStruct golditem;
|
|
|
|
int storenumh;
|
|
|
|
int gossipstart, gossipend;
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
char *talkname[] = {
|
|
"Griswold",
|
|
"Pepin",
|
|
"",
|
|
"Ogden",
|
|
"Cain",
|
|
"Farnham",
|
|
"Adria",
|
|
"Gillian",
|
|
"Wirt"
|
|
};
|
|
|
|
int talker;
|
|
extern QuestData questlist[];
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
void ClearSText(int, int);
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void InitStores()
|
|
{
|
|
app_assert(! pSTextBoxCels);
|
|
pSTextBoxCels = LoadFileInMemSig("Data\\TextBox2.CEL",NULL,'STOR');
|
|
pSTextSpinCels = LoadFileInMemSig("Data\\PentSpn2.CEL",NULL,'STOR');
|
|
pSTextSlidCels = LoadFileInMemSig("Data\\TextSlid.CEL",NULL,'STOR');
|
|
ClearSText(0, NUMSTLINES);
|
|
stextflag = STORE_NONE;
|
|
stextspin = 1;
|
|
stextsize = STEXT_SMALL;
|
|
stextscrl = FALSE;
|
|
numpremium = 0;
|
|
premiumlevel = 1;
|
|
for (int i = 0; i < MAXPREMIUM; i++) premiumitem[i]._itype = -1;
|
|
boyitem._itype = -1;
|
|
boylevel = 0;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void SetupTownStores()
|
|
{
|
|
int i, l;
|
|
|
|
// PATCH2.JMM.3/10/97
|
|
SetRndSeed( glSeedTbl[currlevel] * GetTickCount( ) );
|
|
// ENDPATCh2.JMM.3/10/97
|
|
|
|
|
|
// How deep have I gone?
|
|
if (gbMaxPlayers == 1) {
|
|
l = 0;
|
|
for (i = 0; i < NUMLEVELS; i++)
|
|
if (plr[myplr]._pLvlVisited[i]) l = i;
|
|
} else {
|
|
l = plr[myplr]._pLevel >> 1;
|
|
}
|
|
|
|
// Make sure they carry relevant items all the time
|
|
l += 2;
|
|
if (l < 6) l = 6;
|
|
if (l > 16) l = 16;
|
|
|
|
// Setup a gold item for transactions
|
|
SpawnStoreGold();
|
|
// Setup blacksmith items
|
|
SpawnSmith(l);
|
|
// Setup witch items
|
|
SpawnWitch(l);
|
|
// Setup healer items
|
|
SpawnHealer(l);
|
|
|
|
// Setup boy items can alter the random seed
|
|
SpawnBoy(plr[myplr]._pLevel);
|
|
// SpawnPremium can alter the random seed
|
|
SpawnPremium(myplr);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
void FreeStoreMem()
|
|
{
|
|
DiabloFreePtr(pSTextBoxCels);
|
|
DiabloFreePtr(pSTextSpinCels);
|
|
DiabloFreePtr(pSTextSlidCels);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*
|
|
|
|
BOOL StoreQuestTalk(int t)
|
|
{
|
|
int i;
|
|
for (i = 0; i < MAXQUESTS; i++) {
|
|
if ((quests[i]._qactive == QUEST_NOTDONE) && (Qtalklist[t][i] != -1)) return(TRUE);
|
|
}
|
|
return(FALSE);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void DrawSTextBack()
|
|
{
|
|
DrawCel(408, 487, pSTextBoxCels, 1, 271);
|
|
|
|
app_assert(gpBuffer);
|
|
__asm {
|
|
mov edi,dword ptr [gpBuffer]
|
|
add edi,372123
|
|
|
|
xor eax,eax
|
|
mov edx,148
|
|
_YLp: mov ecx,132
|
|
_XLp1: stosb
|
|
inc edi
|
|
loop _XLp1
|
|
stosb
|
|
sub edi,1033
|
|
mov ecx,132
|
|
_XLp2: inc edi
|
|
stosb
|
|
loop _XLp2
|
|
sub edi,1032
|
|
dec edx
|
|
jnz _YLp
|
|
mov ecx,132
|
|
_XLp3: stosb
|
|
inc edi
|
|
loop _XLp3
|
|
stosb
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void PrintSString(int x, int y, BOOL cjustflag, char str[], char col, int val)
|
|
{
|
|
long boffset;
|
|
int sl,i,w,tw,aw,xx,yy,xa;
|
|
char valstr[32];
|
|
|
|
yy = SStringY[y] + stext[y]._syoff;
|
|
if (stextsize == STEXT_SMALL) xa = 416;
|
|
else xa = 96;
|
|
boffset = nBuffWTbl[yy + 204] + x + xa;
|
|
sl = strlen(str);
|
|
if (stextsize == STEXT_SMALL) aw = 257;
|
|
else aw = 577;
|
|
w = 0;
|
|
if (cjustflag) {
|
|
tw = 0;
|
|
for (i = 0; i < sl; i++) {
|
|
BYTE c = char2print(str[i]);
|
|
c = fonttrans[c];
|
|
tw += fontkern[c]+1;
|
|
}
|
|
if (tw < aw) w = (aw - tw) >> 1;
|
|
boffset += w;
|
|
}
|
|
if (stextsel == y) {
|
|
if (cjustflag) xx = x + w + xa - 20;
|
|
else xx = x + xa - 20;
|
|
DrawCel(xx, yy + 205, pSTextSpinCels, stextspin, 12);
|
|
}
|
|
for (i = 0; i < sl; i++) {
|
|
BYTE c = char2print(str[i]);
|
|
c = fonttrans[c];
|
|
w += fontkern[c]+1;
|
|
if ((c != 0) && (w <= aw)) DrawPanelFont(boffset, c, col);
|
|
boffset += fontkern[c]+1;
|
|
}
|
|
if ((!cjustflag) && (val >= 0)) {
|
|
sprintf(valstr, "%i", val);
|
|
boffset = nBuffWTbl[yy + 204] + 656 - x;
|
|
sl = strlen(valstr);
|
|
for (i = sl-1; i >= 0; i--) {
|
|
BYTE c = char2print(valstr[i]);
|
|
c = fonttrans[c];
|
|
boffset -= fontkern[c]+1;
|
|
if (c != 0) DrawPanelFont(boffset, c, col);
|
|
}
|
|
}
|
|
if (stextsel == y) {
|
|
if (cjustflag) xx = x + w + xa + 4;
|
|
else xx = 660 - x;
|
|
DrawCel(xx, yy + 205, pSTextSpinCels, stextspin, 12);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void DrawSLine(int y)
|
|
{
|
|
long soffset, doffset;
|
|
long width, wadd;
|
|
int yy;
|
|
|
|
yy = SStringY[y];
|
|
if (stextsize == STEXT_LARGE) {
|
|
soffset = 142170;
|
|
doffset = nBuffWTbl[yy + 198] + 90;
|
|
width = 146;
|
|
wadd = 182;
|
|
} else {
|
|
soffset = 142490;
|
|
doffset = nBuffWTbl[yy + 198] + 410;
|
|
width = 66;
|
|
wadd = 502;
|
|
}
|
|
|
|
app_assert(gpBuffer);
|
|
__asm {
|
|
mov esi,dword ptr [gpBuffer]
|
|
mov edi,esi
|
|
add esi,dword ptr [soffset]
|
|
add edi,dword ptr [doffset]
|
|
|
|
mov ebx,dword ptr [wadd]
|
|
|
|
mov edx,3
|
|
_YLp: mov ecx,dword ptr [width]
|
|
rep movsd
|
|
movsw
|
|
add esi,ebx
|
|
add edi,ebx
|
|
dec edx
|
|
jnz _YLp
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void DrawScrlBar(int y1, int y2)
|
|
{
|
|
int i, yy1, yy2, v, s;
|
|
|
|
yy1 = SStringY[y1] + 204;
|
|
yy2 = SStringY[y2] + 204;
|
|
if (stextscrlubtn != -1) DrawCel(665, yy1, pSTextSlidCels, 12, 12);
|
|
else DrawCel(665, yy1, pSTextSlidCels, 10, 12);
|
|
if (stextscrldbtn != -1) DrawCel(665, yy2, pSTextSlidCels, 11, 12);
|
|
else DrawCel(665, yy2, pSTextSlidCels, 9, 12);
|
|
for (i = (yy1+12); i < yy2; i+=12) DrawCel(665, i, pSTextSlidCels, 14, 12);
|
|
|
|
if (stextsel != 22) s = stextsel;
|
|
else s = stextlhold;
|
|
if (storenumh > 1) {
|
|
v = ((s - stextup) >> 2) + stextsval;
|
|
v = v * 1000;
|
|
v = v / (storenumh-1);
|
|
v = v * (SStringY[y2]-SStringY[y1]-24);
|
|
v = v / 1000;
|
|
} else v = 0;
|
|
v += SStringY[y1+1] + 204;
|
|
DrawCel(665, v, pSTextSlidCels, 13, 12);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void SetupSTextWin()
|
|
{
|
|
stextsize = STEXT_SMALL;
|
|
stextsel = -1;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void SetupSTextLWin()
|
|
{
|
|
stextsize = STEXT_LARGE;
|
|
stextsel = -1;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void ClearSText(int s, int e)
|
|
{
|
|
int i;
|
|
|
|
for (i = s; i < e; i++) {
|
|
stext[i]._sx = 0;
|
|
stext[i]._syoff = 0;
|
|
stext[i]._sstr[0] = 0;
|
|
stext[i]._sjust = FALSE;
|
|
stext[i]._sclr = ICOLOR_WHITE;
|
|
stext[i]._sline = FALSE;
|
|
stext[i]._ssel = FALSE;
|
|
stext[i]._sval = -1;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void AddSLine(int y)
|
|
{
|
|
stext[y]._sx = 0;
|
|
stext[y]._syoff = 0;
|
|
stext[y]._sstr[0] = 0;
|
|
stext[y]._sline = TRUE;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void AddSTextVal(int y, int val)
|
|
{
|
|
stext[y]._sval = val;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void OffsetSTextY(int y, int yo)
|
|
{
|
|
stext[y]._syoff = yo;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void AddSText(int x, int y, BOOL j, char str[], char clr, BOOL sel)
|
|
{
|
|
stext[y]._sx = x;
|
|
stext[y]._syoff = 0;
|
|
strcpy(stext[y]._sstr,str);
|
|
stext[y]._sjust = j;
|
|
stext[y]._sclr = clr;
|
|
stext[y]._sline = FALSE;
|
|
stext[y]._ssel = sel;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
static void PrintStoreItem(const ItemStruct * x, int l, char iclr)
|
|
{
|
|
char sstr[128];
|
|
|
|
sstr[0] = 0;
|
|
if (x->_iIdentified) {
|
|
if ((x->_iMagical != IMAGIC_UNIQUE) && (x->_iPrePower != -1)) {
|
|
PrintItemPower(x->_iPrePower, x);
|
|
strcat(sstr, tempstr);
|
|
}
|
|
if (x->_iSufPower != -1) {
|
|
PrintItemPower(x->_iSufPower, x);
|
|
if (sstr[0] != 0) strcat(sstr, ", ");
|
|
strcat(sstr, tempstr);
|
|
}
|
|
}
|
|
if ((x->_iMiscId == IMID_STAFF) && (x->_iMaxCharges != 0)) {
|
|
sprintf(tempstr, "Charges: %i/%i", x->_iCharges, x->_iMaxCharges);
|
|
if (sstr[0] != 0) strcat(sstr, ", ");
|
|
strcat(sstr, tempstr);
|
|
}
|
|
|
|
if (sstr[0] != 0) {
|
|
AddSText(40, l, FALSE, sstr, iclr, FALSE);
|
|
l++;
|
|
}
|
|
|
|
sstr[0] = 0;
|
|
if (x->_iClass == IC_WEAP) sprintf(sstr, "Damage: %i-%i ", x->_iMinDam, x->_iMaxDam);
|
|
if (x->_iClass == IC_ARMOR) sprintf(sstr, "Armor: %i ", x->_iAC);
|
|
|
|
if ((x->_iMaxDur == INFINITE_DUR) || (x->_iMaxDur == 0)) strcat(sstr, "Indestructible, ");
|
|
else {
|
|
sprintf(tempstr, "Dur: %i/%i, ", x->_iDurability, x->_iMaxDur);
|
|
strcat(sstr, tempstr);
|
|
}
|
|
if (x->_itype == IT_MISC) sstr[0] = 0;
|
|
if ((x->_iMinStr + x->_iMinMag + x->_iMinDex) == 0) {
|
|
strcat(sstr, "No required attributes");
|
|
} else {
|
|
strcpy(tempstr, "Required:");
|
|
if (x->_iMinStr != 0) sprintf(tempstr, "%s %i Str", tempstr, x->_iMinStr);
|
|
if (x->_iMinMag != 0) sprintf(tempstr, "%s %i Mag", tempstr, (byte) x->_iMinMag);
|
|
if (x->_iMinDex != 0) sprintf(tempstr, "%s %i Dex", tempstr, x->_iMinDex);
|
|
strcat(sstr, tempstr);
|
|
}
|
|
AddSText(40, l++, FALSE, sstr, iclr, FALSE);
|
|
|
|
if ((x->_iMagical == IMAGIC_UNIQUE) && (x->_iIdentified))
|
|
AddSText(40, l++, FALSE, "Unique Item", iclr, FALSE);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
extern int AP2x2Tbl[10];
|
|
|
|
void StoreAutoPlace()
|
|
{
|
|
int i, w, h, idx;
|
|
BOOL done;
|
|
|
|
SetICursor(plr[myplr].HoldItem._iCurs + ICSTART);
|
|
// all items are either 1x1, 1x2, 1x3, 2x2, or 2x3
|
|
// the inv is 10x4
|
|
w = icursW28;
|
|
h = icursH28;
|
|
done = FALSE;
|
|
if ((w == 1) && (h == 1)) {
|
|
// Check to see if speed bar available first
|
|
idx = plr[myplr].HoldItem.IDidx;
|
|
if ((plr[myplr].HoldItem._iStatFlag) && (AllItemsList[idx].iUsable)) {
|
|
for (i = 0; (i < MAXSPD) && (!done); i++) {
|
|
if (plr[myplr].SpdList[i]._itype == -1) {
|
|
plr[myplr].SpdList[i] = plr[myplr].HoldItem;
|
|
done = TRUE;
|
|
}
|
|
}
|
|
}
|
|
// Start in lower left and continue trying right then up a line
|
|
for (i = 30; (i <= 39) && (!done); i++) done = AutoPlace(myplr, i, w, h, TRUE);
|
|
for (i = 20; (i <= 29) && (!done); i++) done = AutoPlace(myplr, i, w, h, TRUE);
|
|
for (i = 10; (i <= 19) && (!done); i++) done = AutoPlace(myplr, i, w, h, TRUE);
|
|
for (i = 0; (i <= 9) && (!done); i++) done = AutoPlace(myplr, i, w, h, TRUE);
|
|
}
|
|
if ((w == 1) && (h == 2)) {
|
|
// Try 3rd row, 1st row, and then 2nd row
|
|
for (i = 29; (i >= 20) && (!done); i--) done = AutoPlace(myplr, i, w, h, TRUE);
|
|
for (i = 9; (i >= 0) && (!done); i--) done = AutoPlace(myplr, i, w, h, TRUE);
|
|
for (i = 19; (i >= 10) && (!done); i--) done = AutoPlace(myplr, i, w, h, TRUE);
|
|
}
|
|
if ((w == 1) && (h == 3)) {
|
|
// Try 1st row then 2nd row
|
|
for (i = 0; (i < 20) && (!done); i++) done = AutoPlace(myplr, i, w, h, TRUE);
|
|
}
|
|
if ((w == 2) && (h == 2)) {
|
|
// Try 1st and 3rd row starting right and moving left
|
|
for (i = 0; (i < 10) && (!done); i++) done = AutoPlace(myplr, AP2x2Tbl[i], w, h, TRUE);
|
|
// Try 3rd row, 1st row, and then 2nd row
|
|
for (i = 21; (i < 29) && (!done); i+=2) done = AutoPlace(myplr, i, w, h, TRUE);
|
|
for (i = 1; (i < 9) && (!done); i+=2) done = AutoPlace(myplr, i, w, h, TRUE);
|
|
for (i = 10; (i < 19) && (!done); i++) done = AutoPlace(myplr, i, w, h, TRUE);
|
|
}
|
|
if ((w == 2) && (h == 3)) {
|
|
// Try 1st row then 2nd row
|
|
for (i = 0; (i < 9) && (!done); i++) done = AutoPlace(myplr, i, w, h, TRUE);
|
|
for (i = 10; (i < 19) && (!done); i++) done = AutoPlace(myplr, i, w, h, TRUE);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartSmith()
|
|
{
|
|
stextsize = STEXT_SMALL;
|
|
stextscrl = FALSE;
|
|
AddSText(0, 1, TRUE, "Welcome to the", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 3, TRUE, "Blacksmith's shop", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 7, TRUE, "Would you like to:", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 10, TRUE, "Talk to Griswold", ICOLOR_BLUE, TRUE);
|
|
AddSText(0, 12, TRUE, "Buy basic items", ICOLOR_WHITE, TRUE);
|
|
AddSText(0, 14, TRUE, "Buy premium items", ICOLOR_WHITE, TRUE);
|
|
AddSText(0, 16, TRUE, "Sell items", ICOLOR_WHITE, TRUE);
|
|
AddSText(0, 18, TRUE, "Repair items", ICOLOR_WHITE, TRUE);
|
|
AddSText(0, 20, TRUE, "Leave the shop", ICOLOR_WHITE, TRUE);
|
|
AddSLine(5);
|
|
storenumh = 20;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_ScrollSBuy(int idx)
|
|
{
|
|
int l, ls;
|
|
char iclr;
|
|
|
|
ClearSText(5, 21);
|
|
stextup = 5;
|
|
for (l = 5; l < 20; l+=4) {
|
|
if (smithitem[idx]._itype != -1) {
|
|
ls = l;
|
|
iclr = ICOLOR_WHITE;
|
|
if (smithitem[idx]._iMagical) iclr = ICOLOR_BLUE;
|
|
if (!smithitem[idx]._iStatFlag) iclr = ICOLOR_RED;
|
|
if (smithitem[idx]._iMagical) AddSText(20, l, FALSE, smithitem[idx]._iIName, iclr, TRUE);
|
|
else AddSText(20, l, FALSE, smithitem[idx]._iName, iclr, TRUE);
|
|
AddSTextVal(l, smithitem[idx]._iIvalue);
|
|
PrintStoreItem(&smithitem[idx], l+1, iclr);
|
|
stextdown = ls;
|
|
idx++;
|
|
}
|
|
}
|
|
if ((!stext[stextsel]._ssel) && (stextsel != 22)) stextsel = stextdown;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartSBuy()
|
|
{
|
|
int i;
|
|
|
|
stextsize = STEXT_LARGE;
|
|
stextscrl = TRUE;
|
|
stextsval = 0;
|
|
sprintf(tempstr, "I have these items for sale : Your gold : %i", plr[myplr]._pGold);
|
|
AddSText(0, 1, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(3);
|
|
AddSLine(21);
|
|
S_ScrollSBuy(stextsval);
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, FALSE);
|
|
OffsetSTextY(22, 6);
|
|
|
|
storenumh = 0;
|
|
for (i = 0; smithitem[i]._itype != -1; i++) storenumh++;
|
|
stextsmax = storenumh - 4;
|
|
if (stextsmax < 0) stextsmax = 0;
|
|
//if (storenumh == 0) StartStore(STORE_SMITH);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_ScrollSPBuy(int idx)
|
|
{
|
|
int l, ls;
|
|
char iclr;
|
|
int boughtitems;
|
|
|
|
ClearSText(5, 21);
|
|
stextup = 5;
|
|
// Premium items don't get deleted from the list, so idx is not an index
|
|
// into premium array, but rather to the nth available item.
|
|
boughtitems = idx;
|
|
idx = 0;
|
|
while (boughtitems) {
|
|
if (premiumitem[idx]._itype != -1)
|
|
boughtitems--;
|
|
idx++;
|
|
}
|
|
for (l = 5; ((l < 20) && (idx < MAXPREMIUM)); l+=4) {
|
|
if (premiumitem[idx]._itype != -1) {
|
|
ls = l;
|
|
iclr = ICOLOR_WHITE;
|
|
if (premiumitem[idx]._iMagical) iclr = ICOLOR_BLUE;
|
|
if (!premiumitem[idx]._iStatFlag) iclr = ICOLOR_RED;
|
|
AddSText(20, l, FALSE, premiumitem[idx]._iIName, iclr, TRUE);
|
|
AddSTextVal(l, premiumitem[idx]._iIvalue);
|
|
PrintStoreItem(&premiumitem[idx], l+1, iclr);
|
|
stextdown = ls;
|
|
} else if (idx < MAXPREMIUM) l-=4;
|
|
idx++;
|
|
}
|
|
if ((!stext[stextsel]._ssel) && (stextsel != 22)) stextsel = stextdown;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
BOOL S_StartSPBuy()
|
|
{
|
|
int i;
|
|
|
|
storenumh = 0;
|
|
for (i = 0; i < MAXPREMIUM; i++) if (premiumitem[i]._itype != -1) storenumh++;
|
|
if (storenumh == 0) {
|
|
StartStore(STORE_SMITH);
|
|
stextsel = 14;
|
|
return(FALSE);
|
|
} else {
|
|
stextsize = STEXT_LARGE;
|
|
stextscrl = TRUE;
|
|
stextsval = 0;
|
|
sprintf(tempstr, "I have these premium items for sale : Your gold : %i", plr[myplr]._pGold);
|
|
AddSText(0, 1, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(3);
|
|
AddSLine(21);
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, FALSE);
|
|
OffsetSTextY(22, 6);
|
|
|
|
stextsmax = storenumh - 4;
|
|
if (stextsmax < 0) stextsmax = 0;
|
|
|
|
S_ScrollSPBuy(stextsval);
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
BOOL SmithSellOk(int i)
|
|
{
|
|
ItemStruct *pI;
|
|
|
|
if (i >= 0)
|
|
pI = &plr[myplr].InvList[i];
|
|
else
|
|
pI = &plr[myplr].SpdList[-(i+1)];
|
|
|
|
if (pI->_itype == -1) return FALSE;
|
|
|
|
if (pI->_iMiscId > IMID_FIRSTOIL &&
|
|
pI->_iMiscId < IMID_LASTOIL)
|
|
return TRUE;
|
|
|
|
if (pI->_itype == IT_MISC) return FALSE;
|
|
if (pI->_itype == IT_GOLD) return FALSE;
|
|
if (pI->_itype == IT_FOOD) return FALSE;
|
|
if (pI->_itype == IT_STAFF && pI->_iSpell != SPL_NONE) return FALSE;
|
|
if (pI->_iClass == IC_SPECIAL) return FALSE;
|
|
if (pI->IDidx == IDI_LAZSTAFF) return FALSE;
|
|
|
|
// if (plr[myplr].InvList[i]._iMagical && plr[myplr].InvList[i]._iIdentified) {
|
|
// if (plr[myplr].InvList[i]._iIvalue == 0) return FALSE;
|
|
// }
|
|
return TRUE;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_ScrollSSell(int idx)
|
|
{
|
|
int l, ls, sidx, v;
|
|
char iclr;
|
|
|
|
ClearSText(5, 21);
|
|
stextup = 5;
|
|
sidx = idx;
|
|
for (l = 5; l < 20 && idx < storenumh; l+=4) {
|
|
if (storehold[idx]._itype != -1) {
|
|
ls = l;
|
|
iclr = ICOLOR_WHITE;
|
|
if (storehold[idx]._iMagical) iclr = ICOLOR_BLUE;
|
|
if (!storehold[idx]._iStatFlag) iclr = ICOLOR_RED;
|
|
if (storehold[idx]._iMagical && storehold[idx]._iIdentified) {
|
|
AddSText(20, l, FALSE, storehold[idx]._iIName, iclr, TRUE);
|
|
v = storehold[idx]._iIvalue;
|
|
} else {
|
|
AddSText(20, l, FALSE, storehold[idx]._iName, iclr, TRUE);
|
|
v = storehold[idx]._ivalue;
|
|
}
|
|
AddSTextVal(l, v);
|
|
PrintStoreItem(&storehold[idx], l+1, iclr);
|
|
stextdown = ls;
|
|
}
|
|
idx++;
|
|
}
|
|
stextsmax = storenumh - 4;
|
|
if (stextsmax < 0) stextsmax = 0;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartSSell()
|
|
{
|
|
int i;
|
|
BOOL sellok;
|
|
|
|
stextsize = STEXT_LARGE;
|
|
sellok = FALSE;
|
|
storenumh = 0;
|
|
for (i = 0; i < MAXHOLDITEMS; i++) storehold[i]._itype = -1;
|
|
for (i = 0; i < plr[myplr]._pNumInv && storenumh < MAXHOLDITEMS; i++) {
|
|
if (SmithSellOk(i)) {
|
|
sellok = TRUE;
|
|
storehold[storenumh] = plr[myplr].InvList[i];
|
|
if (storehold[storenumh]._iMagical && storehold[storenumh]._iIdentified)
|
|
storehold[storenumh]._ivalue = storehold[storenumh]._iIvalue;
|
|
storehold[storenumh]._ivalue = storehold[storenumh]._ivalue >> 2;
|
|
if (!storehold[storenumh]._ivalue)
|
|
storehold[storenumh]._ivalue = 1;
|
|
storehold[storenumh]._iIvalue = storehold[storenumh]._ivalue;
|
|
storehidx[storenumh] = i;
|
|
storenumh++;
|
|
}
|
|
}
|
|
for (i = 0; i < MAXSPD && storenumh < MAXHOLDITEMS; i++) {
|
|
if (SmithSellOk(-(i+1))) {
|
|
sellok = TRUE;
|
|
storehold[storenumh] = plr[myplr].SpdList[i];
|
|
if (storehold[storenumh]._iMagical && storehold[storenumh]._iIdentified)
|
|
storehold[storenumh]._ivalue = storehold[storenumh]._iIvalue;
|
|
storehold[storenumh]._ivalue = storehold[storenumh]._ivalue >> 2;
|
|
if (!storehold[storenumh]._ivalue)
|
|
storehold[storenumh]._ivalue = 1;
|
|
storehold[storenumh]._iIvalue = storehold[storenumh]._ivalue;
|
|
storehidx[storenumh] = -(i+1);
|
|
storenumh++;
|
|
}
|
|
}
|
|
|
|
if (!sellok) {
|
|
stextscrl = FALSE;
|
|
sprintf(tempstr, "You have nothing I want. Your gold : %i", plr[myplr]._pGold);
|
|
AddSText(0, 1, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(3);
|
|
AddSLine(21);
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, TRUE);
|
|
OffsetSTextY(22, 6);
|
|
} else {
|
|
stextscrl = TRUE;
|
|
stextsval = 0;
|
|
stextsmax = plr[myplr]._pNumInv;
|
|
sprintf(tempstr, "Which item is for sale? Your gold : %i", plr[myplr]._pGold);
|
|
AddSText(0, 1, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(3);
|
|
AddSLine(21);
|
|
S_ScrollSSell(stextsval);
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, TRUE);
|
|
OffsetSTextY(22, 6);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
BOOL SmithRepairOk(int i)
|
|
{
|
|
if (plr[myplr].InvList[i]._itype == -1) return FALSE;
|
|
if (plr[myplr].InvList[i]._itype == IT_MISC) return FALSE;
|
|
if (plr[myplr].InvList[i]._itype == IT_GOLD) return FALSE;
|
|
if (plr[myplr].InvList[i]._itype == IT_FOOD) return FALSE;
|
|
if (plr[myplr].InvList[i]._iDurability == plr[myplr].InvList[i]._iMaxDur) return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
static void AddStoreHoldRepair(ItemStruct * itm,int i)
|
|
{
|
|
int v;
|
|
|
|
app_assert(itm->_iMaxDur > 0);
|
|
|
|
storehold[storenumh] = *itm;
|
|
itm = &storehold[storenumh];
|
|
if (itm->_iMagical && itm->_iIdentified)
|
|
itm->_ivalue = (itm->_iIvalue * 30) / 100;
|
|
v = ((itm->_iMaxDur - itm->_iDurability) * 100) / itm->_iMaxDur;
|
|
v = (v * itm->_ivalue) / 100;
|
|
if (v == 0) {
|
|
if (itm->_iMagical && itm->_iIdentified) return;
|
|
else v = 1;
|
|
}
|
|
if (v > 1) v >>= 1;
|
|
itm->_ivalue = itm->_iIvalue = v;
|
|
storehidx[storenumh++] = i;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartSRepair()
|
|
{
|
|
int i;
|
|
BOOL repairok;
|
|
|
|
stextsize = STEXT_LARGE;
|
|
repairok = FALSE;
|
|
storenumh = 0;
|
|
for (i = 0; i < MAXHOLDITEMS; i++) storehold[i]._itype = -1;
|
|
if ((plr[myplr].HeadItem._itype != -1) && (plr[myplr].HeadItem._iDurability != plr[myplr].HeadItem._iMaxDur)) {
|
|
repairok = TRUE;
|
|
AddStoreHoldRepair(&plr[myplr].HeadItem, -1);
|
|
}
|
|
if ((plr[myplr].BodyItem._itype != -1) && (plr[myplr].BodyItem._iDurability != plr[myplr].BodyItem._iMaxDur)) {
|
|
repairok = TRUE;
|
|
AddStoreHoldRepair(&plr[myplr].BodyItem, -2);
|
|
}
|
|
if ((plr[myplr].Hand1Item._itype != -1) && (plr[myplr].Hand1Item._iDurability != plr[myplr].Hand1Item._iMaxDur)) {
|
|
repairok = TRUE;
|
|
AddStoreHoldRepair(&plr[myplr].Hand1Item, -3);
|
|
}
|
|
if ((plr[myplr].Hand2Item._itype != -1) && (plr[myplr].Hand2Item._iDurability != plr[myplr].Hand2Item._iMaxDur)) {
|
|
repairok = TRUE;
|
|
AddStoreHoldRepair(&plr[myplr].Hand2Item, -4);
|
|
}
|
|
for (i = 0; i < plr[myplr]._pNumInv && storenumh < MAXHOLDITEMS; i++) {
|
|
if (SmithRepairOk(i)) {
|
|
repairok = TRUE;
|
|
AddStoreHoldRepair(&plr[myplr].InvList[i], i);
|
|
}
|
|
}
|
|
if (!repairok) {
|
|
stextscrl = FALSE;
|
|
sprintf(tempstr, "You have nothing to repair. Your gold : %i", plr[myplr]._pGold);
|
|
AddSText(0, 1, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(3);
|
|
AddSLine(21);
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, TRUE);
|
|
OffsetSTextY(22, 6);
|
|
} else {
|
|
stextscrl = TRUE;
|
|
stextsval = 0;
|
|
stextsmax = plr[myplr]._pNumInv;
|
|
sprintf(tempstr, "Repair which item? Your gold : %i", plr[myplr]._pGold);
|
|
AddSText(0, 1, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(3);
|
|
AddSLine(21);
|
|
S_ScrollSSell(stextsval);
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, TRUE);
|
|
OffsetSTextY(22, 6);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartWitch()
|
|
{
|
|
stextsize = STEXT_SMALL;
|
|
stextscrl = FALSE;
|
|
AddSText(0, 2, TRUE, "Witch's shack", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 9, TRUE, "Would you like to:", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 12, TRUE, "Talk to Adria", ICOLOR_BLUE, TRUE);
|
|
AddSText(0, 14, TRUE, "Buy items", ICOLOR_WHITE, TRUE);
|
|
AddSText(0, 16, TRUE, "Sell items", ICOLOR_WHITE, TRUE);
|
|
AddSText(0, 18, TRUE, "Recharge staves", ICOLOR_WHITE, TRUE);
|
|
AddSText(0, 20, TRUE, "Leave the shack", ICOLOR_WHITE, TRUE);
|
|
AddSLine(5);
|
|
storenumh = 20;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_ScrollWBuy(int idx)
|
|
{
|
|
int l, ls, sidx;
|
|
char iclr;
|
|
|
|
ClearSText(5, 21);
|
|
stextup = 5;
|
|
sidx = idx;
|
|
for (l = 5; l < 20; l+=4) {
|
|
if (witchitem[idx]._itype != -1) {
|
|
ls = l;
|
|
iclr = ICOLOR_WHITE;
|
|
if (witchitem[idx]._iMagical) iclr = ICOLOR_BLUE;
|
|
if (!witchitem[idx]._iStatFlag) iclr = ICOLOR_RED;
|
|
if (witchitem[idx]._iMagical) AddSText(20, l, FALSE, witchitem[idx]._iIName, iclr, TRUE);
|
|
else AddSText(20, l, FALSE, witchitem[idx]._iName, iclr, TRUE);
|
|
AddSTextVal(l, witchitem[idx]._iIvalue);
|
|
PrintStoreItem(&witchitem[idx], l+1, iclr);
|
|
stextdown = ls;
|
|
idx++;
|
|
}
|
|
}
|
|
if ((!stext[stextsel]._ssel) && (stextsel != 22)) stextsel = stextdown;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartWBuy()
|
|
{
|
|
int i;
|
|
|
|
stextsize = STEXT_LARGE;
|
|
stextscrl = TRUE;
|
|
stextsval = 0;
|
|
stextsmax = 20;
|
|
sprintf(tempstr, "I have these items for sale : Your gold : %i", plr[myplr]._pGold);
|
|
AddSText(0, 1, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(3);
|
|
AddSLine(21);
|
|
S_ScrollWBuy(stextsval);
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, FALSE);
|
|
OffsetSTextY(22, 6);
|
|
|
|
storenumh = 0;
|
|
for (i = 0; witchitem[i]._itype != -1; i++) storenumh++;
|
|
stextsmax = storenumh - 4;
|
|
if (stextsmax < 0) stextsmax = 0;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
BOOL WitchSellOk(int i)
|
|
{
|
|
BOOL rv;
|
|
ItemStruct *pI;
|
|
|
|
rv = FALSE;
|
|
if (i >= 0)
|
|
pI = &plr[myplr].InvList[i];
|
|
else
|
|
pI = &plr[myplr].SpdList[-(i+1)];
|
|
|
|
if (pI->_itype == IT_MISC) rv = TRUE;
|
|
if ((pI->_iMiscId > IMID_FIRSTOIL) && (pI->_iMiscId < IMID_LASTOIL))
|
|
rv = FALSE;
|
|
if (pI->_iClass == IC_SPECIAL)
|
|
rv = FALSE;
|
|
|
|
if (pI->_itype == IT_STAFF && pI->_iSpell != SPL_NONE) rv = TRUE;
|
|
// if (pI->_iMagical && pI->_iIdentified) {
|
|
// if (pI->_iIvalue == 0) rv = FALSE;
|
|
// }
|
|
if (pI->IDidx >= IDI_FIRSTQUEST
|
|
&& pI->IDidx <= IDI_LASTQUEST)
|
|
rv = FALSE;
|
|
if (pI->IDidx == IDI_LAZSTAFF) rv = FALSE;
|
|
return(rv);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartWSell()
|
|
{
|
|
int i;
|
|
BOOL sellok;
|
|
|
|
stextsize = STEXT_LARGE;
|
|
sellok = FALSE;
|
|
storenumh = 0;
|
|
for (i = 0; i < MAXHOLDITEMS; i++) storehold[i]._itype = -1;
|
|
for (i = 0; i < plr[myplr]._pNumInv && storenumh < MAXHOLDITEMS; i++) {
|
|
if (WitchSellOk(i)) {
|
|
sellok = TRUE;
|
|
storehold[storenumh] = plr[myplr].InvList[i];
|
|
if (storehold[storenumh]._iMagical && storehold[storenumh]._iIdentified)
|
|
storehold[storenumh]._ivalue = storehold[storenumh]._iIvalue;
|
|
storehold[storenumh]._ivalue = storehold[storenumh]._ivalue >> 2;
|
|
if (!storehold[storenumh]._ivalue)
|
|
storehold[storenumh]._ivalue = 1;
|
|
storehold[storenumh]._iIvalue = storehold[storenumh]._ivalue;
|
|
storehidx[storenumh] = i;
|
|
storenumh++;
|
|
}
|
|
}
|
|
for (i = 0; i < MAXSPD && storenumh < MAXHOLDITEMS; i++) {
|
|
if ((plr[myplr].SpdList[i]._itype != -1) && (WitchSellOk(-(i+1)))) {
|
|
sellok = TRUE;
|
|
storehold[storenumh] = plr[myplr].SpdList[i];
|
|
if (storehold[storenumh]._iMagical && storehold[storenumh]._iIdentified)
|
|
storehold[storenumh]._ivalue = storehold[storenumh]._iIvalue;
|
|
storehold[storenumh]._ivalue = storehold[storenumh]._ivalue >> 2;
|
|
if (!storehold[storenumh]._ivalue)
|
|
storehold[storenumh]._ivalue = 1;
|
|
storehold[storenumh]._iIvalue = storehold[storenumh]._ivalue;
|
|
storehidx[storenumh] = -(i+1);
|
|
storenumh++;
|
|
}
|
|
}
|
|
if (!sellok) {
|
|
stextscrl = FALSE;
|
|
sprintf(tempstr, "You have nothing I want. Your gold : %i", plr[myplr]._pGold);
|
|
AddSText(0, 1, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(3);
|
|
AddSLine(21);
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, TRUE);
|
|
OffsetSTextY(22, 6);
|
|
} else {
|
|
stextscrl = TRUE;
|
|
stextsval = 0;
|
|
stextsmax = plr[myplr]._pNumInv;
|
|
sprintf(tempstr, "Which item is for sale? Your gold : %i", plr[myplr]._pGold);
|
|
AddSText(0, 1, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(3);
|
|
AddSLine(21);
|
|
S_ScrollSSell(stextsval);
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, TRUE);
|
|
OffsetSTextY(22, 6);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
BOOL WitchRechargeOk(int i)
|
|
{
|
|
BOOL rv;
|
|
|
|
rv = FALSE;
|
|
if ((plr[myplr].InvList[i]._itype == IT_STAFF) &&
|
|
(plr[myplr].InvList[i]._iCharges != plr[myplr].InvList[i]._iMaxCharges))
|
|
{
|
|
rv = TRUE;
|
|
}
|
|
|
|
// new: you can recharge unique items too.
|
|
if ((plr[myplr].InvList[i]._iMiscId == IMID_UNIQUE ||
|
|
(plr[myplr].InvList[i]._iMiscId == IMID_STAFF)) &&
|
|
(plr[myplr].InvList[i]._iCharges < plr[myplr].InvList[i]._iMaxCharges))
|
|
{
|
|
rv = TRUE;
|
|
}
|
|
//*****
|
|
return(rv);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void AddStoreHoldRecharge(ItemStruct itm, int i)
|
|
{
|
|
int v;
|
|
|
|
storehold[storenumh] = itm;
|
|
storehold[storenumh]._ivalue += spelldata[itm._iSpell].sStaffCost;
|
|
v = ((storehold[storenumh]._iMaxCharges - storehold[storenumh]._iCharges) * 100) / storehold[storenumh]._iMaxCharges;
|
|
storehold[storenumh]._ivalue = ((v * storehold[storenumh]._ivalue) / 100) >> 1;
|
|
storehold[storenumh]._iIvalue = storehold[storenumh]._ivalue;
|
|
storehidx[storenumh] = i;
|
|
storenumh++;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartWRecharge()
|
|
{
|
|
int i;
|
|
BOOL rechargeok;
|
|
|
|
stextsize = STEXT_LARGE;
|
|
rechargeok = FALSE;
|
|
storenumh = 0;
|
|
for (i = 0; i < MAXHOLDITEMS; i++) storehold[i]._itype = -1;
|
|
if (( (plr[myplr].Hand1Item._itype == IT_STAFF)
|
|
|| (plr[myplr].Hand1Item._iMiscId == IMID_UNIQUE))
|
|
&& (plr[myplr].Hand1Item._iCharges != plr[myplr].Hand1Item._iMaxCharges))
|
|
{
|
|
rechargeok = TRUE;
|
|
AddStoreHoldRecharge(plr[myplr].Hand1Item, -1);
|
|
}
|
|
for (i = 0; i < plr[myplr]._pNumInv && storenumh < MAXHOLDITEMS; i++) {
|
|
if (WitchRechargeOk(i)) {
|
|
rechargeok = TRUE;
|
|
AddStoreHoldRecharge(plr[myplr].InvList[i], i);
|
|
}
|
|
}
|
|
if (!rechargeok) {
|
|
stextscrl = FALSE;
|
|
sprintf(tempstr, "You have nothing to recharge. Your gold : %i", plr[myplr]._pGold);
|
|
AddSText(0, 1, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(3);
|
|
AddSLine(21);
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, TRUE);
|
|
OffsetSTextY(22, 6);
|
|
} else {
|
|
stextscrl = TRUE;
|
|
stextsval = 0;
|
|
stextsmax = plr[myplr]._pNumInv;
|
|
sprintf(tempstr, "Recharge which item? Your gold : %i", plr[myplr]._pGold);
|
|
AddSText(0, 1, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(3);
|
|
AddSLine(21);
|
|
S_ScrollSSell(stextsval);
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, TRUE);
|
|
OffsetSTextY(22, 6);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartNoMoney()
|
|
{
|
|
StartStore(stextshold);
|
|
stextsize = STEXT_LARGE;
|
|
stextscrl = FALSE;
|
|
ClearSText(5, 23);
|
|
AddSText(0, 14, TRUE, "You do not have enough gold", ICOLOR_WHITE, TRUE);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartNoRoom()
|
|
{
|
|
StartStore(stextshold);
|
|
stextscrl = FALSE;
|
|
ClearSText(5, 23);
|
|
AddSText(0, 14, TRUE, "You do not have enough room in inventory", ICOLOR_WHITE, TRUE);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartConfirm()
|
|
{
|
|
char iclr;
|
|
BOOL idprint;
|
|
|
|
StartStore(stextshold);
|
|
stextscrl = FALSE;
|
|
ClearSText(5, 23);
|
|
iclr = ICOLOR_WHITE;
|
|
if (plr[myplr].HoldItem._iMagical) iclr = ICOLOR_BLUE;
|
|
if (!plr[myplr].HoldItem._iStatFlag) iclr = ICOLOR_RED;
|
|
|
|
if (plr[myplr].HoldItem._iMagical) idprint = TRUE;
|
|
else idprint = FALSE;
|
|
|
|
if (stextshold == STORE_STORYID) idprint = FALSE;
|
|
|
|
if ((plr[myplr].HoldItem._iMagical) && (!plr[myplr].HoldItem._iIdentified)) {
|
|
if (stextshold == STORE_SSELL) idprint = FALSE;
|
|
if (stextshold == STORE_WSELL) idprint = FALSE;
|
|
if (stextshold == STORE_SREPAIR) idprint = FALSE;
|
|
if (stextshold == STORE_WRECHARGE) idprint = FALSE;
|
|
}
|
|
|
|
if (idprint)
|
|
AddSText(20, 8, FALSE, plr[myplr].HoldItem._iIName, iclr, FALSE);
|
|
else
|
|
AddSText(20, 8, FALSE, plr[myplr].HoldItem._iName, iclr, FALSE);
|
|
|
|
AddSTextVal(8, plr[myplr].HoldItem._iIvalue);
|
|
PrintStoreItem(&plr[myplr].HoldItem, 9, iclr);
|
|
switch(stextshold) {
|
|
case STORE_SBUY:
|
|
case STORE_WBUY:
|
|
case STORE_HBUY:
|
|
case STORE_SPBUY:
|
|
strcpy(tempstr, "Are you sure you want to buy this item?");
|
|
break;
|
|
case STORE_SSELL:
|
|
case STORE_WSELL:
|
|
strcpy(tempstr, "Are you sure you want to sell this item?");
|
|
break;
|
|
case STORE_SREPAIR:
|
|
strcpy(tempstr, "Are you sure you want to repair this item?");
|
|
break;
|
|
case STORE_WRECHARGE:
|
|
strcpy(tempstr, "Are you sure you want to recharge this item?");
|
|
break;
|
|
case STORE_BBUY:
|
|
strcpy(tempstr, "Do we have a deal?");
|
|
break;
|
|
case STORE_STORYID:
|
|
strcpy(tempstr, "Are you sure you want to identify this item?");
|
|
break;
|
|
}
|
|
AddSText(0, 15, TRUE, tempstr, ICOLOR_WHITE, FALSE);
|
|
AddSText(0, 18, TRUE, "Yes", ICOLOR_WHITE, TRUE);
|
|
AddSText(0, 20, TRUE, "No", ICOLOR_WHITE, TRUE);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartBoy()
|
|
{
|
|
stextsize = STEXT_SMALL;
|
|
stextscrl = FALSE;
|
|
AddSText(0, 2, TRUE, "Wirt the Peg-legged boy", ICOLOR_GOLD, FALSE);
|
|
AddSLine(5);
|
|
if (boyitem._itype != -1) {
|
|
AddSText(0, 8, TRUE, "Talk to Wirt", ICOLOR_BLUE, TRUE);
|
|
AddSText(0, 12, TRUE, "I have something for sale,", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 14, TRUE, "but it will cost 50 gold", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 16, TRUE, "just to take a look. ", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 18, TRUE, "What have you got?", ICOLOR_WHITE, TRUE);
|
|
AddSText(0, 20, TRUE, "Say goodbye", ICOLOR_WHITE, TRUE);
|
|
}
|
|
else {
|
|
AddSText(0, 12, TRUE, "Talk to Wirt", ICOLOR_BLUE, TRUE);
|
|
AddSText(0, 18, TRUE, "Say goodbye", ICOLOR_WHITE, TRUE);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartBBoy()
|
|
{
|
|
int iclr;
|
|
|
|
stextsize = STEXT_LARGE;
|
|
stextscrl = FALSE;
|
|
sprintf(tempstr, "I have this item for sale : Your gold : %i", plr[myplr]._pGold);
|
|
AddSText(0, 1, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(3);
|
|
AddSLine(21);
|
|
iclr = ICOLOR_WHITE;
|
|
if (boyitem._iMagical) iclr = ICOLOR_BLUE;
|
|
if (!boyitem._iStatFlag) iclr = ICOLOR_RED;
|
|
if (boyitem._iMagical) AddSText(20, 10, FALSE, boyitem._iIName, iclr, TRUE);
|
|
else AddSText(20, 10, FALSE, boyitem._iName, iclr, TRUE);
|
|
// PATCH2.JMM
|
|
// No actual change--just note that the value of the item = 75% value
|
|
AddSTextVal(10, boyitem._iIvalue - (boyitem._iIvalue >> 2));
|
|
// ENDPATCH2.JMM
|
|
PrintStoreItem(&boyitem, 11, iclr);
|
|
AddSText(0, 22, TRUE, "Leave", ICOLOR_WHITE, TRUE);
|
|
OffsetSTextY(22, 6);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartHealer()
|
|
{
|
|
// heal automatically
|
|
if (plr[myplr]._pHitPoints != plr[myplr]._pMaxHP) PlaySFX(IS_CAST8);
|
|
plr[myplr]._pHitPoints = plr[myplr]._pMaxHP;
|
|
plr[myplr]._pHPBase = plr[myplr]._pMaxHPBase;
|
|
drawhpflag = TRUE;
|
|
|
|
stextsize = STEXT_SMALL;
|
|
stextscrl = FALSE;
|
|
AddSText(0, 1, TRUE, "Welcome to the", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 3, TRUE, "Healer's home", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 9, TRUE, "Would you like to:", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 12, TRUE, "Talk to Pepin", ICOLOR_BLUE, TRUE);
|
|
// AddSText(0, 14, TRUE, "Receive healing", ICOLOR_WHITE, TRUE);
|
|
AddSText(0, 14, TRUE, "Buy items", ICOLOR_WHITE, TRUE);
|
|
AddSText(0, 16, TRUE, "Leave Healer's home", ICOLOR_WHITE, TRUE);
|
|
AddSLine(5);
|
|
storenumh = 20;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_ScrollHBuy(int idx)
|
|
{
|
|
int l, ls;
|
|
char iclr;
|
|
|
|
ClearSText(5, 21);
|
|
stextup = 5;
|
|
for (l = 5; l < 20; l+=4) {
|
|
if (healitem[idx]._itype != -1) {
|
|
ls = l;
|
|
iclr = ICOLOR_WHITE;
|
|
if (!healitem[idx]._iStatFlag) iclr = ICOLOR_RED;
|
|
AddSText(20, l, FALSE, healitem[idx]._iName, iclr, TRUE);
|
|
AddSTextVal(l, healitem[idx]._iIvalue);
|
|
PrintStoreItem(&healitem[idx], l+1, iclr);
|
|
stextdown = ls;
|
|
idx++;
|
|
}
|
|
}
|
|
if ((!stext[stextsel]._ssel) && (stextsel != 22)) stextsel = stextdown;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartHBuy()
|
|
{
|
|
int i;
|
|
|
|
stextsize = STEXT_LARGE;
|
|
stextscrl = TRUE;
|
|
stextsval = 0;
|
|
sprintf(tempstr, "I have these items for sale : Your gold : %i", plr[myplr]._pGold);
|
|
AddSText(0, 1, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(3);
|
|
AddSLine(21);
|
|
S_ScrollHBuy(stextsval);
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, FALSE);
|
|
OffsetSTextY(22, 6);
|
|
|
|
storenumh = 0;
|
|
for (i = 0; healitem[i]._itype != -1; i++) storenumh++;
|
|
stextsmax = storenumh - 4;
|
|
if (stextsmax < 0) stextsmax = 0;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartStory()
|
|
{
|
|
stextsize = STEXT_SMALL;
|
|
stextscrl = FALSE;
|
|
AddSText(0, 2, TRUE, "The Town Elder", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 9, TRUE, "Would you like to:", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 12, TRUE, "Talk to Cain", ICOLOR_BLUE, TRUE);
|
|
AddSText(0, 14, TRUE, "Identify an item", ICOLOR_WHITE, TRUE);
|
|
AddSText(0, 18, TRUE, "Say goodbye", ICOLOR_WHITE, TRUE);
|
|
AddSLine(5);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
BOOL IdItemOk(ItemStruct *i)
|
|
{
|
|
if (i->_itype == -1) return(FALSE);
|
|
if (i->_iMagical == IMAGIC_NONE) return(FALSE);
|
|
if (i->_iIdentified) return(FALSE);
|
|
return(TRUE);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
#define STOREIDCOST 100
|
|
|
|
void AddStoreHoldId(ItemStruct itm, int i)
|
|
{
|
|
storehold[storenumh] = itm;
|
|
storehold[storenumh]._ivalue = STOREIDCOST;
|
|
storehold[storenumh]._iIvalue = STOREIDCOST;
|
|
storehidx[storenumh] = i;
|
|
storenumh++;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartSIdentify()
|
|
{
|
|
int i;
|
|
BOOL idok;
|
|
|
|
stextsize = STEXT_LARGE;
|
|
idok = FALSE;
|
|
storenumh = 0;
|
|
for (i = 0; i < MAXHOLDITEMS; i++) storehold[i]._itype = -1;
|
|
if (IdItemOk(&plr[myplr].HeadItem)) {
|
|
idok = TRUE;
|
|
AddStoreHoldId(plr[myplr].HeadItem, -1);
|
|
}
|
|
if (IdItemOk(&plr[myplr].BodyItem)) {
|
|
idok = TRUE;
|
|
AddStoreHoldId(plr[myplr].BodyItem, -2);
|
|
}
|
|
if (IdItemOk(&plr[myplr].Hand1Item)) {
|
|
idok = TRUE;
|
|
AddStoreHoldId(plr[myplr].Hand1Item, -3);
|
|
}
|
|
if (IdItemOk(&plr[myplr].Hand2Item)) {
|
|
idok = TRUE;
|
|
AddStoreHoldId(plr[myplr].Hand2Item, -4);
|
|
}
|
|
if (IdItemOk(&plr[myplr].Ring1Item)) {
|
|
idok = TRUE;
|
|
AddStoreHoldId(plr[myplr].Ring1Item, -5);
|
|
}
|
|
if (IdItemOk(&plr[myplr].Ring2Item)) {
|
|
idok = TRUE;
|
|
AddStoreHoldId(plr[myplr].Ring2Item, -6);
|
|
}
|
|
if (IdItemOk(&plr[myplr].NeckItem)) {
|
|
idok = TRUE;
|
|
AddStoreHoldId(plr[myplr].NeckItem, -7);
|
|
}
|
|
for (i = 0; i < plr[myplr]._pNumInv && storenumh < MAXHOLDITEMS; i++) {
|
|
if (IdItemOk(&plr[myplr].InvList[i])) {
|
|
idok = TRUE;
|
|
AddStoreHoldId(plr[myplr].InvList[i], i);
|
|
}
|
|
}
|
|
if (!idok) {
|
|
stextscrl = FALSE;
|
|
sprintf(tempstr, "You have nothing to identify. Your gold : %i", plr[myplr]._pGold);
|
|
AddSText(0, 1, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(3);
|
|
AddSLine(21);
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, TRUE);
|
|
OffsetSTextY(22, 6);
|
|
} else {
|
|
stextscrl = TRUE;
|
|
stextsval = 0;
|
|
stextsmax = plr[myplr]._pNumInv;
|
|
sprintf(tempstr, "Identify which item? Your gold : %i", plr[myplr]._pGold);
|
|
AddSText(0, 1, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(3);
|
|
AddSLine(21);
|
|
S_ScrollSSell(stextsval);
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, TRUE);
|
|
OffsetSTextY(22, 6);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartIdShow()
|
|
{
|
|
char iclr;
|
|
|
|
StartStore(stextshold);
|
|
stextscrl = FALSE;
|
|
ClearSText(5, 23);
|
|
iclr = ICOLOR_WHITE;
|
|
if (plr[myplr].HoldItem._iMagical) iclr = ICOLOR_BLUE;
|
|
if (!plr[myplr].HoldItem._iStatFlag) iclr = ICOLOR_RED;
|
|
|
|
AddSText(0, 7, TRUE, "This item is:", ICOLOR_WHITE, FALSE);
|
|
|
|
AddSText(20, 11, FALSE, plr[myplr].HoldItem._iIName, iclr, FALSE);
|
|
PrintStoreItem(&plr[myplr].HoldItem, 12, iclr);
|
|
|
|
AddSText(0, 18, TRUE, "Done", ICOLOR_WHITE, TRUE);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
#if !IS_VERSION(SHAREWARE)
|
|
void S_StartTalk()
|
|
{
|
|
int i, tq, sn, la, gl;
|
|
|
|
stextsize = STEXT_SMALL;
|
|
stextscrl = FALSE;
|
|
sprintf(tempstr, "Talk to %s", talkname[talker]);
|
|
AddSText(0, 2, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(5);
|
|
|
|
tq = 0;
|
|
for (i = 0; i < MAXQUESTS; i++) {
|
|
if ((quests[i]._qactive == QUEST_NOTDONE) && (Qtalklist[talker][i] != -1) && quests[i]._qlog) tq++;
|
|
}
|
|
if (tq > 6) {
|
|
sn = 14 - (tq >> 1);
|
|
la = 1;
|
|
} else {
|
|
sn = 15 - tq;
|
|
la = 2;
|
|
}
|
|
gl = sn - 2;
|
|
for (i = 0; i < MAXQUESTS; i++) {
|
|
if ((quests[i]._qactive == QUEST_NOTDONE) && (Qtalklist[talker][i] != -1) && quests[i]._qlog) {
|
|
AddSText(0, sn, TRUE, questlist[i]._qlstr, ICOLOR_WHITE, TRUE);
|
|
sn += la;
|
|
}
|
|
}
|
|
|
|
AddSText(0, gl, TRUE, "Gossip", ICOLOR_BLUE, TRUE);
|
|
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, TRUE);
|
|
}
|
|
|
|
#else
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartShareTalk()
|
|
{
|
|
stextsize = STEXT_SMALL;
|
|
stextscrl = FALSE;
|
|
sprintf(tempstr, "Talk to %s", talkname[talker]);
|
|
AddSText(0, 2, TRUE, tempstr, ICOLOR_GOLD, FALSE);
|
|
AddSLine(5);
|
|
|
|
sprintf(tempstr, "Talking to %s", talkname[talker]);
|
|
AddSText(0, 10, TRUE, tempstr, ICOLOR_WHITE, FALSE);
|
|
AddSText(0, 12, TRUE, "is not available", ICOLOR_WHITE, FALSE);
|
|
AddSText(0, 14, TRUE, "in the shareware", ICOLOR_WHITE, FALSE);
|
|
AddSText(0, 16, TRUE, "version.", ICOLOR_WHITE, FALSE);
|
|
AddSText(0, 22, TRUE, "Back", ICOLOR_WHITE, TRUE);
|
|
}
|
|
#endif
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartTavern()
|
|
{
|
|
stextsize = STEXT_SMALL;
|
|
stextscrl = FALSE;
|
|
AddSText(0, 1, TRUE, "Welcome to the", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 3, TRUE, "Rising Sun", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 9, TRUE, "Would you like to:", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 12, TRUE, "Talk to Ogden", ICOLOR_BLUE, TRUE);
|
|
AddSText(0, 18, TRUE, "Leave the tavern", ICOLOR_WHITE, TRUE);
|
|
AddSLine(5);
|
|
storenumh = 20;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartBarMaid()
|
|
{
|
|
stextsize = STEXT_SMALL;
|
|
stextscrl = FALSE;
|
|
AddSText(0, 2, TRUE, "Gillian", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 9, TRUE, "Would you like to:", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 12, TRUE, "Talk to Gillian", ICOLOR_BLUE, TRUE);
|
|
AddSText(0, 18, TRUE, "Say goodbye", ICOLOR_WHITE, TRUE);
|
|
AddSLine(5);
|
|
storenumh = 20;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StartDrunk()
|
|
{
|
|
stextsize = STEXT_SMALL;
|
|
stextscrl = FALSE;
|
|
AddSText(0, 2, TRUE, "Farnham the Drunk", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 9, TRUE, "Would you like to:", ICOLOR_GOLD, FALSE);
|
|
AddSText(0, 12, TRUE, "Talk to Farnham", ICOLOR_BLUE, TRUE);
|
|
AddSText(0, 18, TRUE, "Say Goodbye", ICOLOR_WHITE, TRUE);
|
|
AddSLine(5);
|
|
storenumh = 20;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void StartStore(char s)
|
|
{
|
|
int i;
|
|
|
|
sbookflag = FALSE;
|
|
invflag = FALSE;
|
|
chrflag = FALSE;
|
|
questlog = FALSE;
|
|
dropGoldFlag = FALSE;
|
|
ClearSText(0, NUMSTLINES);
|
|
ReleaseStoreBtn();
|
|
switch(s) {
|
|
case STORE_SMITH:
|
|
S_StartSmith();
|
|
break;
|
|
case STORE_SBUY:
|
|
if (storenumh > 0) S_StartSBuy();
|
|
break;
|
|
case STORE_SSELL:
|
|
S_StartSSell();
|
|
break;
|
|
case STORE_SREPAIR:
|
|
S_StartSRepair();
|
|
break;
|
|
case STORE_WITCH:
|
|
S_StartWitch();
|
|
break;
|
|
case STORE_WBUY:
|
|
if (storenumh > 0) S_StartWBuy();
|
|
break;
|
|
case STORE_WSELL:
|
|
S_StartWSell();
|
|
break;
|
|
case STORE_WRECHARGE:
|
|
S_StartWRecharge();
|
|
break;
|
|
case STORE_NOMONEY:
|
|
S_StartNoMoney();
|
|
break;
|
|
case STORE_NOROOM:
|
|
S_StartNoRoom();
|
|
break;
|
|
case STORE_CONFIRM:
|
|
S_StartConfirm();
|
|
break;
|
|
case STORE_BOY:
|
|
S_StartBoy();
|
|
break;
|
|
case STORE_BBUY:
|
|
S_StartBBoy();
|
|
break;
|
|
case STORE_HEALER:
|
|
S_StartHealer();
|
|
break;
|
|
case STORE_STORYTLR:
|
|
S_StartStory();
|
|
break;
|
|
case STORE_HBUY:
|
|
if (storenumh > 0) S_StartHBuy();
|
|
break;
|
|
case STORE_STORYID:
|
|
S_StartSIdentify();
|
|
break;
|
|
case STORE_SPBUY:
|
|
if (! S_StartSPBuy()) return;
|
|
break;
|
|
case STORE_TALK:
|
|
#if IS_VERSION(SHAREWARE)
|
|
S_StartShareTalk();
|
|
#else
|
|
S_StartTalk();
|
|
#endif
|
|
break;
|
|
case STORE_IDSHOW:
|
|
S_StartIdShow();
|
|
break;
|
|
case STORE_TAVERN:
|
|
S_StartTavern();
|
|
break;
|
|
case STORE_DRUNK:
|
|
S_StartDrunk();
|
|
break;
|
|
case STORE_BARMAID:
|
|
S_StartBarMaid();
|
|
break;
|
|
}
|
|
|
|
for (i = 0; (i < NUMSTLINES) && (!stext[i]._ssel); i++)
|
|
NULL;
|
|
if (i == NUMSTLINES) stextsel = -1;
|
|
else stextsel = i;
|
|
stextflag = s;
|
|
if (s == STORE_SBUY && storenumh == 0) {
|
|
StartStore(STORE_SMITH);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void DrawSText()
|
|
{
|
|
int i;
|
|
|
|
// Draw background
|
|
if (stextsize == STEXT_SMALL) DrawSTextBack();
|
|
else DrawQTextBack();
|
|
|
|
if (stextscrl) {
|
|
switch(stextflag) {
|
|
case STORE_SBUY:
|
|
S_ScrollSBuy(stextsval);
|
|
break;
|
|
case STORE_SPBUY:
|
|
S_ScrollSPBuy(stextsval);
|
|
break;
|
|
case STORE_SSELL:
|
|
case STORE_SREPAIR:
|
|
case STORE_WSELL:
|
|
case STORE_WRECHARGE:
|
|
case STORE_STORYID:
|
|
S_ScrollSSell(stextsval);
|
|
break;
|
|
case STORE_WBUY:
|
|
S_ScrollWBuy(stextsval);
|
|
break;
|
|
case STORE_HBUY:
|
|
S_ScrollHBuy(stextsval);
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < NUMSTLINES; i++) {
|
|
if (stext[i]._sline) DrawSLine(i);
|
|
if (stext[i]._sstr[0] != 0) PrintSString(stext[i]._sx, i, stext[i]._sjust, stext[i]._sstr, stext[i]._sclr, stext[i]._sval);
|
|
}
|
|
|
|
if (stextscrl) DrawScrlBar(4, 20);
|
|
|
|
stextspin = (stextspin & 0x7) + 1;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void STextESC()
|
|
{
|
|
if (qtextflag) {
|
|
qtextflag = FALSE;
|
|
if (leveltype == 0) stream_stop();
|
|
return;
|
|
}
|
|
switch(stextflag) {
|
|
case STORE_SMITH:
|
|
case STORE_WITCH:
|
|
case STORE_BOY:
|
|
case STORE_BBUY:
|
|
case STORE_HEALER:
|
|
case STORE_STORYTLR:
|
|
case STORE_TAVERN:
|
|
case STORE_BARMAID:
|
|
case STORE_DRUNK:
|
|
stextflag = STORE_NONE;
|
|
break;
|
|
case STORE_TALK:
|
|
StartStore(stextshold);
|
|
stextsel = stextlhold;
|
|
break;
|
|
case STORE_SBUY:
|
|
StartStore(STORE_SMITH);
|
|
stextsel = 12;
|
|
break;
|
|
case STORE_SPBUY:
|
|
StartStore(STORE_SMITH);
|
|
stextsel = 14;
|
|
break;
|
|
case STORE_SSELL:
|
|
StartStore(STORE_SMITH);
|
|
stextsel = 16;
|
|
break;
|
|
case STORE_SREPAIR:
|
|
StartStore(STORE_SMITH);
|
|
stextsel = 18;
|
|
break;
|
|
case STORE_WBUY:
|
|
StartStore(STORE_WITCH);
|
|
stextsel = 14;
|
|
break;
|
|
case STORE_WSELL:
|
|
StartStore(STORE_WITCH);
|
|
stextsel = 16;
|
|
break;
|
|
case STORE_WRECHARGE:
|
|
StartStore(STORE_WITCH);
|
|
stextsel = 18;
|
|
break;
|
|
case STORE_HBUY:
|
|
StartStore(STORE_HEALER);
|
|
stextsel = 16;
|
|
break;
|
|
case STORE_STORYID:
|
|
StartStore(STORE_STORYTLR);
|
|
stextsel = 14;
|
|
break;
|
|
case STORE_IDSHOW:
|
|
StartStore(STORE_STORYID);
|
|
break;
|
|
case STORE_NOMONEY:
|
|
case STORE_NOROOM:
|
|
case STORE_CONFIRM:
|
|
StartStore(stextshold);
|
|
stextsel = stextlhold;
|
|
stextsval = stextvhold;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void STextUp()
|
|
{
|
|
PlaySFX(IS_TITLEMOV);
|
|
if (stextsel != -1) {
|
|
if (stextscrl) {
|
|
if (stextsel == stextup) {
|
|
if (stextsval != 0) stextsval--;
|
|
} else {
|
|
stextsel--;
|
|
while (!stext[stextsel]._ssel) {
|
|
if (stextsel == 0) stextsel = NUMSTLINES-1;
|
|
else stextsel--;
|
|
}
|
|
}
|
|
} else {
|
|
if (stextsel == 0) stextsel = NUMSTLINES-1;
|
|
else stextsel--;
|
|
while (!stext[stextsel]._ssel) {
|
|
if (stextsel == 0) stextsel = NUMSTLINES-1;
|
|
else stextsel--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void STextDown()
|
|
{
|
|
PlaySFX(IS_TITLEMOV);
|
|
if (stextsel != -1) {
|
|
if (stextscrl) {
|
|
if (stextsel == stextdown) {
|
|
if (stextsval < stextsmax) stextsval++;
|
|
} else {
|
|
stextsel++;
|
|
while (!stext[stextsel]._ssel) {
|
|
if (stextsel == NUMSTLINES-1) stextsel = 0;
|
|
else stextsel++;
|
|
}
|
|
}
|
|
} else {
|
|
if (stextsel == NUMSTLINES-1) stextsel = 0;
|
|
else stextsel++;
|
|
while (!stext[stextsel]._ssel) {
|
|
if (stextsel == NUMSTLINES-1) stextsel = 0;
|
|
else stextsel++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void STextPgUp()
|
|
{
|
|
PlaySFX(IS_TITLEMOV);
|
|
if ((stextsel != -1) && (stextscrl)) {
|
|
if (stextsel == stextup) {
|
|
if (stextsval != 0) stextsval-=4;
|
|
if (stextsval < 0) stextsval = 0;
|
|
} else {
|
|
stextsel = stextup;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void STextPgDown()
|
|
{
|
|
PlaySFX(IS_TITLEMOV);
|
|
if ((stextsel != -1) && (stextscrl)) {
|
|
if (stextsel == stextdown) {
|
|
if (stextsval < stextsmax) stextsval+=4;
|
|
if (stextsval > stextsmax) stextsval = stextsmax;
|
|
} else {
|
|
stextsel = stextdown;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_SmithEnter()
|
|
{
|
|
switch(stextsel) {
|
|
case 10:
|
|
talker = TWN_BLKSMITH;
|
|
stextshold = STORE_SMITH;
|
|
stextlhold = 10;
|
|
gossipstart = TXT_GRIS2;
|
|
gossipend = TXT_GRIS13;
|
|
StartStore(STORE_TALK);
|
|
break;
|
|
case 12:
|
|
StartStore(STORE_SBUY);
|
|
break;
|
|
case 14:
|
|
StartStore(STORE_SPBUY);
|
|
break;
|
|
case 16:
|
|
StartStore(STORE_SSELL);
|
|
break;
|
|
case 18:
|
|
StartStore(STORE_SREPAIR);
|
|
break;
|
|
case 20:
|
|
stextflag = STORE_NONE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void SetGoldCurs(int pnum, int i)
|
|
{
|
|
if (plr[pnum].InvList[i]._ivalue >= GOLD_VT2) {
|
|
plr[pnum].InvList[i]._iCurs = ITEM_5GOLD;
|
|
} else {
|
|
if (plr[pnum].InvList[i]._ivalue <= GOLD_VT1) plr[pnum].InvList[i]._iCurs = ITEM_1GOLD;
|
|
else plr[pnum].InvList[i]._iCurs = ITEM_3GOLD;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void SetSpdbarGoldCurs(int pnum, int i)
|
|
{
|
|
if (plr[pnum].SpdList[i]._ivalue >= GOLD_VT2) {
|
|
plr[pnum].SpdList[i]._iCurs = ITEM_5GOLD;
|
|
} else {
|
|
if (plr[pnum].SpdList[i]._ivalue <= GOLD_VT1) plr[pnum].SpdList[i]._iCurs = ITEM_1GOLD;
|
|
else plr[pnum].SpdList[i]._iCurs = ITEM_3GOLD;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void TakePlrsMoney(long cost)
|
|
{
|
|
int i;
|
|
|
|
// Take players money
|
|
plr[myplr]._pGold = CalculateGold(myplr) - cost;
|
|
|
|
// Remove gold from speed list first; if there is any
|
|
// Try non GOLD_VMAX first, then break into the GOLD_VMAX piles
|
|
for (i = 0; ((i < MAXSPD) && (cost > 0)); i++) {
|
|
if ((plr[myplr].SpdList[i]._itype == IT_GOLD) &&
|
|
(plr[myplr].SpdList[i]._ivalue != GOLD_VMAX)) {
|
|
if (cost < plr[myplr].SpdList[i]._ivalue) {
|
|
plr[myplr].SpdList[i]._ivalue -= cost;
|
|
SetSpdbarGoldCurs(myplr, i);
|
|
cost = 0;
|
|
} else {
|
|
cost -= plr[myplr].SpdList[i]._ivalue;
|
|
RemoveSpdBarItem(myplr, i);
|
|
i = -1; // restart looping
|
|
}
|
|
}
|
|
}
|
|
if (cost > 0) {
|
|
// GOLD_VMAX piles
|
|
for (i = 0; ((i < MAXSPD) && (cost > 0)); i++) {
|
|
if (plr[myplr].SpdList[i]._itype == IT_GOLD) {
|
|
if (cost < plr[myplr].SpdList[i]._ivalue) {
|
|
plr[myplr].SpdList[i]._ivalue -= cost;
|
|
SetSpdbarGoldCurs(myplr, i);
|
|
cost = 0;
|
|
} else {
|
|
cost -= plr[myplr].SpdList[i]._ivalue;
|
|
RemoveSpdBarItem(myplr, i);
|
|
i = -1; // restart looping
|
|
}
|
|
}
|
|
}
|
|
}
|
|
force_redraw = FULLDRAW;
|
|
|
|
// Remove gold from inventory list if there was no gold in the speed list
|
|
// or all gold from the speed list was deplenished.
|
|
// Try non GOLD_VMAX first, then break into the GOLD_VMAX piles
|
|
if (cost > 0) {
|
|
for (i = 0; ((i < plr[myplr]._pNumInv) && (cost > 0)); i++) {
|
|
if ((plr[myplr].InvList[i]._itype == IT_GOLD) &&
|
|
(plr[myplr].InvList[i]._ivalue != GOLD_VMAX)) {
|
|
if (cost < plr[myplr].InvList[i]._ivalue) {
|
|
plr[myplr].InvList[i]._ivalue -= cost;
|
|
SetGoldCurs(myplr, i);
|
|
cost = 0;
|
|
} else {
|
|
cost -= plr[myplr].InvList[i]._ivalue;
|
|
RemoveInvItem(myplr, i);
|
|
i = -1; // restart looping
|
|
}
|
|
}
|
|
}
|
|
if (cost > 0) {
|
|
// GOLD_VMAX piles
|
|
for (i = 0; ((i < plr[myplr]._pNumInv) && (cost > 0)); i++) {
|
|
if (plr[myplr].InvList[i]._itype == IT_GOLD) {
|
|
if (cost < plr[myplr].InvList[i]._ivalue) {
|
|
plr[myplr].InvList[i]._ivalue -= cost;
|
|
SetGoldCurs(myplr, i);
|
|
cost = 0;
|
|
} else {
|
|
cost -= plr[myplr].InvList[i]._ivalue;
|
|
RemoveInvItem(myplr, i);
|
|
i = -1; // restart looping
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void SmithBuyItem()
|
|
{
|
|
int idx;
|
|
|
|
// Take players money
|
|
TakePlrsMoney(plr[myplr].HoldItem._iIvalue);
|
|
|
|
// Put in players inv
|
|
if (!plr[myplr].HoldItem._iMagical) plr[myplr].HoldItem._iIdentified = FALSE;
|
|
StoreAutoPlace();
|
|
|
|
// Remove from smithitems
|
|
idx = ((stextlhold - stextup) >> 2) + stextvhold;
|
|
if (idx == MAXSMITHITEMS-1) smithitem[idx]._itype = -1;
|
|
else {
|
|
while (smithitem[idx+1]._itype != -1) {
|
|
smithitem[idx] = smithitem[idx+1];
|
|
idx++;
|
|
}
|
|
smithitem[idx]._itype = -1;
|
|
}
|
|
|
|
CalcPlrInv(myplr, TRUE);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_SBuyEnter()
|
|
{
|
|
int idx, i;
|
|
BOOL done;
|
|
|
|
if (stextsel == 22) {
|
|
StartStore(STORE_SMITH);
|
|
stextsel = 12;
|
|
} else {
|
|
stextshold = STORE_SBUY;
|
|
stextlhold = stextsel;
|
|
stextvhold = stextsval;
|
|
idx = ((stextsel - stextup) >> 2) + stextsval;
|
|
if (plr[myplr]._pGold < smithitem[idx]._iIvalue) {
|
|
StartStore(STORE_NOMONEY);
|
|
} else {
|
|
plr[myplr].HoldItem = smithitem[idx];
|
|
SetCursor(plr[myplr].HoldItem._iCurs + ICSTART);
|
|
done = FALSE;
|
|
for (i = 0; (i < MAXINV) && (!done); i++) done = AutoPlace(myplr, i, cursW/28, cursH/28, FALSE);
|
|
if (done) StartStore(STORE_CONFIRM);
|
|
else StartStore(STORE_NOROOM);
|
|
SetCursor(GLOVE_CURS);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void SmithBuyPItem()
|
|
{
|
|
int idx, i;
|
|
|
|
// Take players money
|
|
TakePlrsMoney(plr[myplr].HoldItem._iIvalue);
|
|
|
|
// Put in players inv
|
|
if (!plr[myplr].HoldItem._iMagical) plr[myplr].HoldItem._iIdentified = FALSE;
|
|
StoreAutoPlace();
|
|
|
|
// Remove from premiumitems
|
|
int xx = ((stextlhold - stextup) >> 2) + stextvhold;
|
|
idx = 0;
|
|
for (i = 0; xx >= 0; i++) {
|
|
if (premiumitem[i]._itype != -1) {
|
|
xx--;
|
|
idx = i;
|
|
}
|
|
}
|
|
premiumitem[idx]._itype = -1;
|
|
numpremium--;
|
|
|
|
// replenish premium list
|
|
SpawnPremium(myplr);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_SPBuyEnter()
|
|
{
|
|
int idx, i;
|
|
BOOL done;
|
|
|
|
if (stextsel == 22) {
|
|
StartStore(STORE_SMITH);
|
|
stextsel = 14;
|
|
} else {
|
|
stextshold = STORE_SPBUY;
|
|
stextlhold = stextsel;
|
|
stextvhold = stextsval;
|
|
int xx = ((stextsel - stextup) >> 2) + stextsval;
|
|
idx = 0;
|
|
for (i = 0; xx >= 0; i++) {
|
|
if (premiumitem[i]._itype != -1) {
|
|
xx--;
|
|
idx = i;
|
|
}
|
|
}
|
|
if (plr[myplr]._pGold < premiumitem[idx]._iIvalue) {
|
|
StartStore(STORE_NOMONEY);
|
|
} else {
|
|
plr[myplr].HoldItem = premiumitem[idx];
|
|
SetCursor(plr[myplr].HoldItem._iCurs + ICSTART);
|
|
done = FALSE;
|
|
for (i = 0; (i < MAXINV) && (!done); i++) done = AutoPlace(myplr, i, cursW/28, cursH/28, FALSE);
|
|
if (done) StartStore(STORE_CONFIRM);
|
|
else StartStore(STORE_NOROOM);
|
|
SetCursor(GLOVE_CURS);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
BOOL StoreGoldFit(int idx)
|
|
{
|
|
int sz, numsqrs, i;
|
|
long cost;
|
|
|
|
// How many squares am I going to need?
|
|
cost = storehold[idx]._iIvalue;
|
|
numsqrs = cost / GOLD_VMAX;
|
|
if ((cost % GOLD_VMAX) != 0) numsqrs++;
|
|
SetCursor(storehold[idx]._iCurs + ICSTART);
|
|
sz = (cursW/28) * (cursH/28);
|
|
SetCursor(GLOVE_CURS);
|
|
if (sz >= numsqrs) return(TRUE);
|
|
for (i = 0; i < MAXINV; i++) {
|
|
if (plr[myplr].InvGrid[i] == 0) sz++;
|
|
}
|
|
for (i = 0; i < plr[myplr]._pNumInv; i++) {
|
|
if ((plr[myplr].InvList[i]._itype == IT_GOLD) &&
|
|
(plr[myplr].InvList[i]._ivalue != GOLD_VMAX)) {
|
|
if ((cost + plr[myplr].InvList[i]._ivalue) <= GOLD_VMAX) cost = 0;
|
|
else cost -= (GOLD_VMAX - plr[myplr].InvList[i]._ivalue);
|
|
}
|
|
}
|
|
numsqrs = cost / GOLD_VMAX;
|
|
if ((cost % GOLD_VMAX) != 0) numsqrs++;
|
|
if (sz >= numsqrs) return(TRUE);
|
|
else return(FALSE);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void PlaceStoreGold(long v)
|
|
{
|
|
int i, ii, xx, yy;
|
|
BOOL done;
|
|
|
|
done = FALSE;
|
|
for (ii = 0; (ii < MAXINV) && (!done); ii++) {
|
|
yy = (ii / 10) * 10;
|
|
xx = ii % 10;
|
|
if (plr[myplr].InvGrid[xx+yy] == 0) {
|
|
i = plr[myplr]._pNumInv;
|
|
// drb.patch1.start.02/13/97
|
|
void GetGoldSeed(int pnum, ItemStruct *h);
|
|
GetGoldSeed(myplr, &golditem);
|
|
// drb.patch1.end.02/13/97
|
|
plr[myplr].InvList[i] = golditem;
|
|
plr[myplr]._pNumInv++;
|
|
plr[myplr].InvGrid[xx+yy] = plr[myplr]._pNumInv;
|
|
plr[myplr].InvList[i]._ivalue = v;
|
|
SetGoldCurs(myplr, i);
|
|
done = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void StoreSellItem()
|
|
{
|
|
int idx, i;
|
|
long cost;
|
|
|
|
// Remove item from inv
|
|
idx = ((stextlhold - stextup) >> 2) + stextvhold;
|
|
if (storehidx[idx] >= 0) RemoveInvItem(myplr, storehidx[idx]);
|
|
else RemoveSpdBarItem(myplr, -(storehidx[idx]+1));
|
|
|
|
// Get value
|
|
cost = storehold[idx]._iIvalue;
|
|
|
|
// Remove from hold list
|
|
storenumh--;
|
|
if (idx != storenumh) {
|
|
while (idx < storenumh) {
|
|
storehold[idx] = storehold[idx+1];
|
|
storehidx[idx] = storehidx[idx+1];
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
// Add value to player
|
|
plr[myplr]._pGold += cost;
|
|
// Try placing with other gold first
|
|
for (i = 0; ((i < plr[myplr]._pNumInv) && (cost > 0)); i++) {
|
|
if ((plr[myplr].InvList[i]._itype == IT_GOLD) &&
|
|
(plr[myplr].InvList[i]._ivalue != GOLD_VMAX)) {
|
|
if ((cost + plr[myplr].InvList[i]._ivalue) <= GOLD_VMAX) {
|
|
plr[myplr].InvList[i]._ivalue += cost;
|
|
SetGoldCurs(myplr, i);
|
|
cost = 0;
|
|
} else {
|
|
cost -= (GOLD_VMAX - plr[myplr].InvList[i]._ivalue);
|
|
plr[myplr].InvList[i]._ivalue = GOLD_VMAX;
|
|
SetGoldCurs(myplr, i);
|
|
}
|
|
}
|
|
}
|
|
// Place new gold slots
|
|
if (cost > 0) {
|
|
while (cost > GOLD_VMAX) {
|
|
PlaceStoreGold(GOLD_VMAX);
|
|
cost -= GOLD_VMAX;
|
|
}
|
|
PlaceStoreGold(cost);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_SSellEnter()
|
|
{
|
|
int idx;
|
|
|
|
if (stextsel == 22) {
|
|
StartStore(STORE_SMITH);
|
|
stextsel = 16;
|
|
} else {
|
|
stextshold = STORE_SSELL;
|
|
stextlhold = stextsel;
|
|
stextvhold = stextsval;
|
|
idx = ((stextsel - stextup) >> 2) + stextsval;
|
|
plr[myplr].HoldItem = storehold[idx];
|
|
if (StoreGoldFit(idx)) StartStore(STORE_CONFIRM);
|
|
else StartStore(STORE_NOROOM);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void SmithRepairItem()
|
|
{
|
|
int i, idx;
|
|
|
|
// Take players money
|
|
TakePlrsMoney(plr[myplr].HoldItem._iIvalue);
|
|
|
|
idx = ((stextlhold - stextup) >> 2) + stextvhold;
|
|
storehold[idx]._iDurability = storehold[idx]._iMaxDur;
|
|
i = storehidx[idx];
|
|
if (i < 0) {
|
|
if (i == -1) plr[myplr].HeadItem._iDurability = plr[myplr].HeadItem._iMaxDur;
|
|
if (i == -2) plr[myplr].BodyItem._iDurability = plr[myplr].BodyItem._iMaxDur;
|
|
if (i == -3) plr[myplr].Hand1Item._iDurability = plr[myplr].Hand1Item._iMaxDur;
|
|
if (i == -4) plr[myplr].Hand2Item._iDurability = plr[myplr].Hand2Item._iMaxDur;
|
|
} else plr[myplr].InvList[i]._iDurability = plr[myplr].InvList[i]._iMaxDur;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_SRepairEnter()
|
|
{
|
|
int idx;
|
|
|
|
if (stextsel == 22) {
|
|
StartStore(STORE_SMITH);
|
|
stextsel = 18;
|
|
} else {
|
|
stextshold = STORE_SREPAIR;
|
|
stextlhold = stextsel;
|
|
stextvhold = stextsval;
|
|
idx = ((stextsel - stextup) >> 2) + stextsval;
|
|
plr[myplr].HoldItem = storehold[idx];
|
|
if (plr[myplr]._pGold < storehold[idx]._iIvalue) StartStore(STORE_NOMONEY);
|
|
else StartStore(STORE_CONFIRM);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_WitchEnter()
|
|
{
|
|
switch(stextsel) {
|
|
case 12:
|
|
talker = TWN_WITCH;
|
|
stextshold = STORE_WITCH;
|
|
stextlhold = 12;
|
|
gossipstart = TXT_ADRIA2;
|
|
gossipend = TXT_ADRIA13;
|
|
StartStore(STORE_TALK);
|
|
break;
|
|
case 14:
|
|
StartStore(STORE_WBUY);
|
|
break;
|
|
case 16:
|
|
StartStore(STORE_WSELL);
|
|
break;
|
|
case 18:
|
|
StartStore(STORE_WRECHARGE);
|
|
break;
|
|
case 20:
|
|
stextflag = STORE_NONE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void WitchBuyItem()
|
|
{
|
|
int idx;
|
|
|
|
// Check if mana, full mana, portal, at top of list. These need new seeds
|
|
idx = ((stextlhold - stextup) >> 2) + stextvhold;
|
|
if (idx < 3) plr[myplr].HoldItem._iSeed = GetRndSeed();
|
|
|
|
// Take players money
|
|
TakePlrsMoney(plr[myplr].HoldItem._iIvalue);
|
|
|
|
// Put in players inv
|
|
StoreAutoPlace();
|
|
|
|
// Remove from witchitems
|
|
// If item index is mana, don't remove from her items list
|
|
if (idx < 3) {
|
|
CalcPlrInv(myplr, TRUE);
|
|
return;
|
|
}
|
|
if (idx == MAXWITCHITEMS-1) witchitem[idx]._itype = -1;
|
|
else {
|
|
while (witchitem[idx+1]._itype != -1) {
|
|
witchitem[idx] = witchitem[idx+1];
|
|
idx++;
|
|
}
|
|
witchitem[idx]._itype = -1;
|
|
}
|
|
|
|
CalcPlrInv(myplr, TRUE);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_WBuyEnter()
|
|
{
|
|
int idx, i;
|
|
BOOL done;
|
|
|
|
if (stextsel == 22) {
|
|
StartStore(STORE_WITCH);
|
|
stextsel = 14;
|
|
} else {
|
|
stextshold = STORE_WBUY;
|
|
stextlhold = stextsel;
|
|
stextvhold = stextsval;
|
|
idx = ((stextsel - stextup) >> 2) + stextsval;
|
|
if (plr[myplr]._pGold < witchitem[idx]._iIvalue) {
|
|
StartStore(STORE_NOMONEY);
|
|
} else {
|
|
plr[myplr].HoldItem = witchitem[idx];
|
|
SetCursor(plr[myplr].HoldItem._iCurs + ICSTART);
|
|
done = FALSE;
|
|
for (i = 0; (i < MAXINV) && (!done); i++) done = SpecialAutoPlace(myplr, i, cursW/28, cursH/28, FALSE);
|
|
if (done) StartStore(STORE_CONFIRM);
|
|
else StartStore(STORE_NOROOM);
|
|
SetCursor(GLOVE_CURS);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_WSellEnter()
|
|
{
|
|
int idx;
|
|
|
|
if (stextsel == 22) {
|
|
StartStore(STORE_WITCH);
|
|
stextsel = 16;
|
|
} else {
|
|
stextshold = STORE_WSELL;
|
|
stextlhold = stextsel;
|
|
stextvhold = stextsval;
|
|
idx = ((stextsel - stextup) >> 2) + stextsval;
|
|
plr[myplr].HoldItem = storehold[idx];
|
|
if (StoreGoldFit(idx)) StartStore(STORE_CONFIRM);
|
|
else StartStore(STORE_NOROOM);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void WitchRechargeItem()
|
|
{
|
|
int i, idx;
|
|
|
|
// Take players money
|
|
TakePlrsMoney(plr[myplr].HoldItem._iIvalue);
|
|
|
|
// Recharge staff
|
|
idx = ((stextlhold - stextup) >> 2) + stextvhold;
|
|
storehold[idx]._iCharges = storehold[idx]._iMaxCharges;
|
|
i = storehidx[idx];
|
|
if (i < 0) plr[myplr].Hand1Item._iCharges = plr[myplr].Hand1Item._iMaxCharges;
|
|
else plr[myplr].InvList[i]._iCharges = plr[myplr].InvList[i]._iMaxCharges;
|
|
CalcPlrInv(myplr, TRUE);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_WRechargeEnter()
|
|
{
|
|
int idx;
|
|
|
|
if (stextsel == 22) {
|
|
StartStore(STORE_WITCH);
|
|
stextsel = 18;
|
|
} else {
|
|
stextshold = STORE_WRECHARGE;
|
|
stextlhold = stextsel;
|
|
stextvhold = stextsval;
|
|
idx = ((stextsel - stextup) >> 2) + stextsval;
|
|
plr[myplr].HoldItem = storehold[idx];
|
|
if (plr[myplr]._pGold < storehold[idx]._iIvalue) StartStore(STORE_NOMONEY);
|
|
else StartStore(STORE_CONFIRM);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_BoyEnter()
|
|
{
|
|
if ((boyitem._itype != -1) && (stextsel == 18)) {
|
|
if (plr[myplr]._pGold < 50) {
|
|
stextshold = STORE_BOY;
|
|
stextlhold = stextsel;
|
|
stextvhold = stextsval;
|
|
StartStore(STORE_NOMONEY);
|
|
} else {
|
|
TakePlrsMoney(50);
|
|
StartStore(STORE_BBUY);
|
|
}
|
|
} else {
|
|
if ( ((stextsel == 8) && (boyitem._itype != -1)) || ((stextsel == 12) && (boyitem._itype == -1)) ) {
|
|
talker = TWN_BOY;
|
|
stextshold = STORE_BOY;
|
|
stextlhold = stextsel;
|
|
gossipstart = TXT_WIRT2;
|
|
gossipend = TXT_WIRT12;
|
|
StartStore(STORE_TALK);
|
|
} else stextflag = STORE_NONE;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void BoyBuyItem()
|
|
{
|
|
// Take players money
|
|
TakePlrsMoney(plr[myplr].HoldItem._iIvalue);
|
|
|
|
// Put in players inv
|
|
StoreAutoPlace();
|
|
|
|
// Remove from boyitem
|
|
boyitem._itype = -1;
|
|
stextshold = STORE_BOY;
|
|
|
|
CalcPlrInv(myplr, TRUE);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void HealerBuyItem()
|
|
{
|
|
int idx;
|
|
|
|
// Check if healing, full healing at top of list. These need new seeds
|
|
idx = ((stextlhold - stextup) >> 2) + stextvhold;
|
|
if (gbMaxPlayers == 1) {
|
|
if (idx < 2) plr[myplr].HoldItem._iSeed = GetRndSeed();
|
|
} else {
|
|
if (idx < 3) plr[myplr].HoldItem._iSeed = GetRndSeed();
|
|
}
|
|
|
|
// Take players money
|
|
TakePlrsMoney(plr[myplr].HoldItem._iIvalue);
|
|
|
|
// Put in players inv
|
|
if (!plr[myplr].HoldItem._iMagical) plr[myplr].HoldItem._iIdentified = FALSE;
|
|
StoreAutoPlace();
|
|
|
|
// Remove from healitems
|
|
// If item index is mana, don't remove from his items list
|
|
if (gbMaxPlayers == 1) {
|
|
if (idx < 2) return;
|
|
} else {
|
|
if (idx < 3) return;
|
|
}
|
|
idx = ((stextlhold - stextup) >> 2) + stextvhold;
|
|
if (idx == MAXHEALITEMS-1) healitem[idx]._itype = -1;
|
|
else {
|
|
while (healitem[idx+1]._itype != -1) {
|
|
healitem[idx] = healitem[idx+1];
|
|
idx++;
|
|
}
|
|
healitem[idx]._itype = -1;
|
|
}
|
|
|
|
CalcPlrInv(myplr, TRUE);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_BBuyEnter()
|
|
{
|
|
int i;
|
|
BOOL done;
|
|
|
|
if (stextsel == 10) {
|
|
stextshold = STORE_BBUY;
|
|
stextlhold = stextsel;
|
|
stextvhold = stextsval;
|
|
// PATCH2.JMM
|
|
//if (plr[myplr]._pGold < ( boyitem._iIvalue + ) StartStore(STORE_NOMONEY);
|
|
if (plr[myplr]._pGold < ( boyitem._iIvalue - (boyitem._iIvalue >> 2) ) ) StartStore(STORE_NOMONEY);
|
|
// ENDPATCH2.JMM
|
|
else {
|
|
plr[myplr].HoldItem = boyitem;
|
|
plr[myplr].HoldItem._iIvalue -= (plr[myplr].HoldItem._iIvalue >> 2);
|
|
SetCursor(plr[myplr].HoldItem._iCurs + ICSTART);
|
|
done = FALSE;
|
|
for (i = 0; (i < MAXINV) && (!done); i++) done = AutoPlace(myplr, i, cursW/28, cursH/28, FALSE);
|
|
if (done) StartStore(STORE_CONFIRM);
|
|
else StartStore(STORE_NOROOM);
|
|
SetCursor(GLOVE_CURS);
|
|
}
|
|
} else stextflag = STORE_NONE;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void StoryIdItem()
|
|
{
|
|
int i, idx;
|
|
|
|
idx = ((stextlhold - stextup) >> 2) + stextvhold;
|
|
i = storehidx[idx];
|
|
if (i < 0) {
|
|
if (i == -1) plr[myplr].HeadItem._iIdentified = TRUE;
|
|
if (i == -2) plr[myplr].BodyItem._iIdentified = TRUE;
|
|
if (i == -3) plr[myplr].Hand1Item._iIdentified = TRUE;
|
|
if (i == -4) plr[myplr].Hand2Item._iIdentified = TRUE;
|
|
if (i == -5) plr[myplr].Ring1Item._iIdentified = TRUE;
|
|
if (i == -6) plr[myplr].Ring2Item._iIdentified = TRUE;
|
|
if (i == -7) plr[myplr].NeckItem._iIdentified = TRUE;
|
|
}
|
|
else
|
|
plr[myplr].InvList[i]._iIdentified = TRUE;
|
|
|
|
plr[myplr].HoldItem._iIdentified = TRUE;
|
|
|
|
// Take players money
|
|
TakePlrsMoney(plr[myplr].HoldItem._iIvalue);
|
|
CalcPlrInv(myplr,TRUE);
|
|
}
|
|
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_ConfirmEnter()
|
|
{
|
|
if (stextsel == 18) {
|
|
switch(stextshold) {
|
|
case STORE_SBUY:
|
|
SmithBuyItem();
|
|
break;
|
|
case STORE_SPBUY:
|
|
SmithBuyPItem();
|
|
break;
|
|
case STORE_SSELL:
|
|
case STORE_WSELL:
|
|
StoreSellItem();
|
|
break;
|
|
case STORE_SREPAIR:
|
|
SmithRepairItem();
|
|
break;
|
|
case STORE_WBUY:
|
|
WitchBuyItem();
|
|
break;
|
|
case STORE_WRECHARGE:
|
|
WitchRechargeItem();
|
|
break;
|
|
case STORE_BBUY:
|
|
BoyBuyItem();
|
|
break;
|
|
case STORE_HBUY:
|
|
HealerBuyItem();
|
|
break;
|
|
case STORE_STORYID:
|
|
StoryIdItem();
|
|
StartStore(STORE_IDSHOW);
|
|
return;
|
|
}
|
|
StartStore(stextshold);
|
|
} else {
|
|
StartStore(stextshold);
|
|
stextsel = stextlhold;
|
|
stextsval = stextvhold;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_HealerEnter()
|
|
{
|
|
switch(stextsel) {
|
|
case 12:
|
|
talker = TWN_HEALER;
|
|
stextshold = STORE_HEALER;
|
|
stextlhold = 12;
|
|
gossipstart = TXT_PEPIN2;
|
|
gossipend = TXT_PEPIN11;
|
|
StartStore(STORE_TALK);
|
|
break;
|
|
// case 14:
|
|
// if (plr[myplr]._pHitPoints != plr[myplr]._pMaxHP) PlaySFX(IS_CAST8);
|
|
// plr[myplr]._pHitPoints = plr[myplr]._pMaxHP;
|
|
// plr[myplr]._pHPBase = plr[myplr]._pMaxHPBase;
|
|
// drawhpflag = TRUE;
|
|
// break;
|
|
case 14:
|
|
StartStore(STORE_HBUY);
|
|
break;
|
|
case 16:
|
|
stextflag = STORE_NONE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_HBuyEnter()
|
|
{
|
|
int idx, i;
|
|
BOOL done;
|
|
|
|
if (stextsel == 22) {
|
|
StartStore(STORE_HEALER);
|
|
stextsel = 16;
|
|
} else {
|
|
stextshold = STORE_HBUY;
|
|
stextlhold = stextsel;
|
|
stextvhold = stextsval;
|
|
idx = ((stextsel - stextup) >> 2) + stextsval;
|
|
if (plr[myplr]._pGold < healitem[idx]._iIvalue) {
|
|
StartStore(STORE_NOMONEY);
|
|
} else {
|
|
plr[myplr].HoldItem = healitem[idx];
|
|
SetCursor(plr[myplr].HoldItem._iCurs + ICSTART);
|
|
done = FALSE;
|
|
for (i = 0; (i < MAXINV) && (!done); i++) done = SpecialAutoPlace(myplr, i, cursW/28, cursH/28, FALSE);
|
|
if (done) StartStore(STORE_CONFIRM);
|
|
else StartStore(STORE_NOROOM);
|
|
SetCursor(GLOVE_CURS);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_StoryEnter()
|
|
{
|
|
switch(stextsel) {
|
|
case 12:
|
|
talker = TWN_TELLER;
|
|
stextshold = STORE_STORYTLR;
|
|
stextlhold = 12;
|
|
gossipstart = TXT_STORY2;
|
|
gossipend = TXT_STORY11;
|
|
StartStore(STORE_TALK);
|
|
break;
|
|
case 14:
|
|
StartStore(STORE_STORYID);
|
|
break;
|
|
case 18:
|
|
stextflag = STORE_NONE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_SIDEnter()
|
|
{
|
|
int idx;
|
|
|
|
if (stextsel == 22) {
|
|
StartStore(STORE_STORYTLR);
|
|
stextsel = 14;
|
|
} else {
|
|
stextshold = STORE_STORYID;
|
|
stextlhold = stextsel;
|
|
stextvhold = stextsval;
|
|
idx = ((stextsel - stextup) >> 2) + stextsval;
|
|
plr[myplr].HoldItem = storehold[idx];
|
|
if (plr[myplr]._pGold < storehold[idx]._iIvalue) StartStore(STORE_NOMONEY);
|
|
else StartStore(STORE_CONFIRM);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_TalkEnter()
|
|
{
|
|
int i, tq, sn, la;
|
|
|
|
if (stextsel == 22) {
|
|
StartStore(stextshold);
|
|
stextsel = stextlhold;
|
|
} else {
|
|
tq = 0;
|
|
for (i = 0; i < MAXQUESTS; i++) {
|
|
if ((quests[i]._qactive == QUEST_NOTDONE) && (Qtalklist[talker][i] != -1) && quests[i]._qlog) tq++;
|
|
}
|
|
if (tq > 6) {
|
|
sn = 14 - (tq >> 1);
|
|
la = 1;
|
|
} else {
|
|
sn = 15 - tq;
|
|
la = 2;
|
|
}
|
|
if (stextsel == (sn - 2)) {
|
|
// Gossip
|
|
SetRndSeed(towner[talker]._tSeed);
|
|
int m = random(0, gossipend - gossipstart + 1) + gossipstart;
|
|
InitQTextMsg(m);
|
|
} else {
|
|
// Quest info
|
|
for (i = 0; i < MAXQUESTS; i++) {
|
|
if ((quests[i]._qactive == QUEST_NOTDONE) && (Qtalklist[talker][i] != -1) && quests[i]._qlog) {
|
|
if (sn == stextsel) InitQTextMsg(Qtalklist[talker][i]);
|
|
sn += la;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_TavernEnter()
|
|
{
|
|
switch(stextsel) {
|
|
case 12:
|
|
talker = TWN_BAROWNER;
|
|
stextshold = STORE_TAVERN;
|
|
stextlhold = 12;
|
|
gossipstart = TXT_OGDEN2;
|
|
gossipend = TXT_OGDEN10;
|
|
StartStore(STORE_TALK);
|
|
break;
|
|
case 18:
|
|
stextflag = STORE_NONE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_BarmaidEnter()
|
|
{
|
|
switch(stextsel) {
|
|
case 12:
|
|
talker = TWN_BARMAID;
|
|
stextshold = STORE_BARMAID;
|
|
stextlhold = 12;
|
|
gossipstart = TXT_GILIAN2;
|
|
gossipend = TXT_GILIAN10;
|
|
StartStore(STORE_TALK);
|
|
break;
|
|
case 18:
|
|
stextflag = STORE_NONE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void S_DrunkEnter()
|
|
{
|
|
switch(stextsel) {
|
|
case 12:
|
|
talker = TWN_DRUNK;
|
|
stextshold = STORE_DRUNK;
|
|
stextlhold = 12;
|
|
gossipstart = TXT_FARN2;
|
|
gossipend = TXT_FARN13;
|
|
StartStore(STORE_TALK);
|
|
break;
|
|
case 18:
|
|
stextflag = STORE_NONE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void STextEnter()
|
|
{
|
|
if (qtextflag) {
|
|
qtextflag = FALSE;
|
|
if (leveltype == 0) stream_stop();
|
|
return;
|
|
}
|
|
PlaySFX(IS_TITLSLCT);
|
|
switch(stextflag) {
|
|
case STORE_SMITH:
|
|
S_SmithEnter();
|
|
break;
|
|
case STORE_SBUY:
|
|
S_SBuyEnter();
|
|
break;
|
|
case STORE_SPBUY:
|
|
S_SPBuyEnter();
|
|
break;
|
|
case STORE_SSELL:
|
|
S_SSellEnter();
|
|
break;
|
|
case STORE_SREPAIR:
|
|
S_SRepairEnter();
|
|
break;
|
|
case STORE_WITCH:
|
|
S_WitchEnter();
|
|
break;
|
|
case STORE_WBUY:
|
|
S_WBuyEnter();
|
|
break;
|
|
case STORE_WSELL:
|
|
S_WSellEnter();
|
|
break;
|
|
case STORE_WRECHARGE:
|
|
S_WRechargeEnter();
|
|
break;
|
|
case STORE_NOMONEY:
|
|
case STORE_NOROOM:
|
|
StartStore(stextshold);
|
|
stextsel = stextlhold;
|
|
stextsval = stextvhold;
|
|
break;
|
|
case STORE_CONFIRM:
|
|
S_ConfirmEnter();
|
|
break;
|
|
case STORE_BOY:
|
|
S_BoyEnter();
|
|
break;
|
|
case STORE_BBUY:
|
|
S_BBuyEnter();
|
|
break;
|
|
case STORE_HEALER:
|
|
S_HealerEnter();
|
|
break;
|
|
case STORE_STORYTLR:
|
|
S_StoryEnter();
|
|
break;
|
|
case STORE_HBUY:
|
|
S_HBuyEnter();
|
|
break;
|
|
case STORE_STORYID:
|
|
S_SIDEnter();
|
|
break;
|
|
case STORE_TALK:
|
|
S_TalkEnter();
|
|
break;
|
|
case STORE_IDSHOW:
|
|
StartStore(STORE_STORYID);
|
|
break;
|
|
case STORE_TAVERN:
|
|
S_TavernEnter();
|
|
break;
|
|
case STORE_BARMAID:
|
|
S_BarmaidEnter();
|
|
break;
|
|
case STORE_DRUNK:
|
|
S_DrunkEnter();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void CheckStoreBtn()
|
|
{
|
|
int y;
|
|
|
|
if (qtextflag) {
|
|
qtextflag = FALSE;
|
|
if (leveltype == 0) stream_stop();
|
|
return;
|
|
}
|
|
if (stextsel == -1) return;
|
|
if ((MouseY < 32) || (MouseY > 320)) return;
|
|
if (stextsize == STEXT_SMALL) {
|
|
if ((MouseX < 344) || (MouseX > 616)) return;
|
|
} else {
|
|
if ((MouseX < 24) || (MouseX > 616)) return;
|
|
}
|
|
y = (MouseY - 32) / 12;
|
|
if ((stextscrl) && (MouseX > 600)) {
|
|
if (y == 4) {
|
|
if (stextscrlubtn <= 0) {
|
|
STextUp();
|
|
stextscrlubtn = 10;
|
|
} else stextscrlubtn--;
|
|
}
|
|
if (y == 20) {
|
|
if (stextscrldbtn <= 0) {
|
|
STextDown();
|
|
stextscrldbtn = 10;
|
|
} else stextscrldbtn--;
|
|
}
|
|
} else {
|
|
if (y < 5) return;
|
|
if (y >= 23) y = 22;
|
|
if ((stextscrl) && (y < 21) && (!stext[y]._ssel)) {
|
|
if (stext[y-2]._ssel) y -= 2;
|
|
else if (stext[y-1]._ssel) y--;
|
|
}
|
|
if ((stext[y]._ssel) || (stextscrl && (y == 22))) {
|
|
stextsel = y;
|
|
STextEnter();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------**
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void ReleaseStoreBtn()
|
|
{
|
|
stextscrlubtn = -1;
|
|
stextscrldbtn = -1;
|
|
}
|
|
|