mirror of
https://github.com/jmarshall23/Hellfire.git
synced 2026-08-11 23:40:51 +02:00
Justin Marshall
5866 lines
165 KiB
C++
5866 lines
165 KiB
C++
/*-----------------------------------------------------------------------**
|
|
** Diablo
|
|
**
|
|
** Objects file
|
|
**
|
|
** (C)1995 Condor, Inc. All rights reserved.
|
|
**
|
|
**-----------------------------------------------------------------------**
|
|
** $Header: /Diablo/OBJECTS.CPP 5 2/12/97 10:51a Dbrevik2 $
|
|
**-----------------------------------------------------------------------**
|
|
**
|
|
** File Routines
|
|
**-----------------------------------------------------------------------*/
|
|
#include <time.h>
|
|
|
|
#include "diablo.h"
|
|
#pragma hdrstop
|
|
#include "sound.h"
|
|
#include "objects.h"
|
|
#include "objdat.h"
|
|
#include "engine.h"
|
|
#include "gendung.h"
|
|
#include "lighting.h"
|
|
#include "items.h"
|
|
#include "player.h"
|
|
#include "monster.h"
|
|
#include "monstint.h"
|
|
#include "control.h"
|
|
#include "cursor.h"
|
|
#include "spells.h"
|
|
#include "minitext.h"
|
|
#include "textdat.h"
|
|
#include "quests.h"
|
|
#include "drlg_l1.h"
|
|
#include "missiles.h"
|
|
#include "misdat.h"
|
|
#include "effects.h"
|
|
#include "themes.h"
|
|
#include "itemdat.h"
|
|
#include "stores.h"
|
|
#include "monstdat.h"
|
|
#include "error.h"
|
|
#include "msg.h"
|
|
#include "multi.h"
|
|
#include "automap.h"
|
|
#include "drlg_l4.h"
|
|
#include "towners.h"
|
|
#include "inv.h"
|
|
#include "setmaps.h"
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
** Externs
|
|
**-----------------------------------------------------------------------*/
|
|
int ObjIndex(int x, int y);
|
|
static bool OperateFountains(int, int);
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
** Local Defines
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
//#define NO_L5_DOORS // JKE just until I get doors.
|
|
|
|
#define DOOR_CLOSED 0
|
|
#define DOOR_OPEN 1
|
|
#define DOOR_BLOCKED 2
|
|
|
|
#define TRAP_NODIR 0
|
|
#define TRAP_HORIZ 1
|
|
#define TRAP_VERT 2
|
|
|
|
#define TOTAL_FOUNTAINS 4
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
** Global Variables
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
ObjectStruct object[MAXOBJECTS];
|
|
long numobjects;
|
|
|
|
static char ObjFileList[MAXLVLOBJS];
|
|
static int numobjfiles = 0;
|
|
static BYTE *pObjCels[MAXLVLOBJS];
|
|
|
|
int objectactive[MAXOBJECTS];
|
|
int objectavail[MAXOBJECTS];
|
|
|
|
static int trapid;
|
|
static int trapdir;
|
|
|
|
static int leverid;
|
|
|
|
BOOL InitObjFlag; //True while initing, false otherwise
|
|
|
|
static int const bxadd[] = { -1, 0, 1, -1, 1, -1, 0, 1 };
|
|
static int const byadd[] = { -1, -1, -1, 0, 0, 1, 1, 1 };
|
|
|
|
int SpellProgress;
|
|
|
|
#if CHEATS
|
|
extern BOOL itemcheat;
|
|
extern BOOL uniqcheat;
|
|
#endif
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
** Function Prototypes
|
|
**-----------------------------------------------------------------------*/
|
|
void AddMushPatch();
|
|
void AddSlainHero();
|
|
void AddSkulkenObject(int, int, int, int);
|
|
static void AddNa_Krul_Stuff();
|
|
void OpenNaKrul();
|
|
static void AddNaKrulLeverObj();
|
|
static bool HCheckSpell(int);
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
// Shrine Data
|
|
|
|
|
|
// Shrine names
|
|
static char const * const shrinestrs[] = {
|
|
"Mysterious", // 0
|
|
"Hidden", // 1
|
|
"Gloomy", // 2
|
|
"Weird", // 3
|
|
"Magical", // 4
|
|
"Stone", // 5
|
|
"Religious", // 6
|
|
"Enchanted", // 7
|
|
"Thaumaturgic", // 8
|
|
"Fascinating", // 9
|
|
"Cryptic", // 10
|
|
"Magical", // 11
|
|
"Eldritch", // 12
|
|
"Eerie", // 13
|
|
"Divine", // 14
|
|
"Holy", // 15
|
|
"Sacred", // 16
|
|
"Spiritual", // 17
|
|
"Spooky", // 18
|
|
"Abandoned", // 19
|
|
"Creepy", // 20
|
|
"Quiet", // 21
|
|
"Secluded", // 22
|
|
"Ornate", // 23
|
|
"Glimmering", // 24
|
|
"Tainted", // 25
|
|
"Oily", // 26
|
|
"Glowing", // 27
|
|
"Mendicant's", // 28
|
|
"Sparkling", // 29
|
|
"Town", // 30
|
|
"Shimmering", // 31
|
|
"Solar", // 33
|
|
"Murphy's", // 34
|
|
};
|
|
#define NUMSHRINETYPES (sizeof(shrinestrs)/sizeof(char *))
|
|
|
|
// Shrine min level it can appear
|
|
static char const shrineminlvl[NUMSHRINETYPES] = {
|
|
1, // 0 Mysterious
|
|
1, // 1 Hidden
|
|
1, // 2 Gloomy
|
|
1, // 3 Weird
|
|
1, // 4 Magical
|
|
1, // 5 Stone
|
|
1, // 6 Religious
|
|
1, // 7 Enchanted
|
|
1, // 8 Thaumaturgic
|
|
1, // 9 Fascinating
|
|
1, // 10 Cryptic
|
|
1, // 11 Supernatural
|
|
1, // 12 Eldritch
|
|
1, // 13 Eerie
|
|
1, // 14 Divine
|
|
1, // 15 Holy
|
|
1, // 16 Sacred
|
|
1, // 17 Spiritual
|
|
1, // 18 Spooky
|
|
1, // 19 Abandoned
|
|
1, // 20 Creepy
|
|
1, // 21 Quiet
|
|
1, // 22 Secluded
|
|
1, // 23 Ornate
|
|
1, // 24 Glimmering
|
|
1, // 25 Tainted
|
|
1, // 26 Oily
|
|
1, // 27 Glowing
|
|
1, // 28 Mendicants
|
|
1, // 29 Edisons
|
|
1, // 30 Town
|
|
1, // 31 Energy
|
|
1, // 32 Solar
|
|
1, // 33 Murphy's
|
|
};
|
|
|
|
// Shrine max level it can appear
|
|
static char const shrinemaxlvl[NUMSHRINETYPES] = {
|
|
MAX_LEVELS, // 0 Mysterious
|
|
MAX_LEVELS, // 1 Hidden
|
|
MAX_LEVELS, // 2 Gloomy
|
|
MAX_LEVELS, // 3 Weird
|
|
MAX_LEVELS, // 4 Magical
|
|
MAX_LEVELS, // 5 Stone
|
|
MAX_LEVELS, // 6 Religious
|
|
8, // 7 Enchanted
|
|
MAX_LEVELS, // 8 Thaumaturgic
|
|
MAX_LEVELS, // 9 Fascinating
|
|
MAX_LEVELS, // 10 Cryptic
|
|
MAX_LEVELS, // 11 Supernatural
|
|
MAX_LEVELS, // 12 Eldritch
|
|
MAX_LEVELS, // 13 Eerie
|
|
MAX_LEVELS, // 14 Divine
|
|
MAX_LEVELS, // 15 Holy
|
|
MAX_LEVELS, // 16 Sacred
|
|
MAX_LEVELS, // 17 Spiritual
|
|
MAX_LEVELS, // 18 Spooky
|
|
MAX_LEVELS, // 19 Abandoned
|
|
MAX_LEVELS, // 20 Creepy
|
|
MAX_LEVELS, // 21 Quiet
|
|
MAX_LEVELS, // 22 Secluded
|
|
MAX_LEVELS, // 23 Ornate
|
|
MAX_LEVELS, // 24 Glimmering
|
|
MAX_LEVELS, // 25 Tainted
|
|
MAX_LEVELS, // 26 Oily
|
|
MAX_LEVELS, // 27 Glowing
|
|
MAX_LEVELS, // 28 Mendicants
|
|
MAX_LEVELS, // 29 Edisons
|
|
MAX_LEVELS, // 30 Town
|
|
MAX_LEVELS, // 31 Energy
|
|
MAX_LEVELS, // 32 Solar
|
|
MAX_LEVELS, // 33 Murphy's
|
|
};
|
|
|
|
#define SHRINE_ALL 0
|
|
#define SHRINE_SINGLE 1
|
|
#define SHRINE_MULTI 2
|
|
|
|
// Shrine available for either, single, or multiplayer?
|
|
static char const shrineavail[NUMSHRINETYPES] = {
|
|
SHRINE_ALL, // 0 Mysterious
|
|
SHRINE_ALL, // 1 Hidden
|
|
SHRINE_SINGLE, // 2 Gloomy
|
|
SHRINE_SINGLE, // 3 Weird
|
|
SHRINE_ALL, // 4 Magical
|
|
SHRINE_ALL, // 5 Stone
|
|
SHRINE_ALL, // 6 Religious
|
|
SHRINE_ALL, // 7 Enchanted
|
|
SHRINE_SINGLE, // 8 Thaumaturgic
|
|
SHRINE_ALL, // 9 Fascinating
|
|
SHRINE_ALL, // 10 Cryptic
|
|
SHRINE_ALL, // 11 Supernatural
|
|
SHRINE_ALL, // 12 Eldritch
|
|
SHRINE_ALL, // 13 Eerie
|
|
SHRINE_ALL, // 14 Divine
|
|
SHRINE_ALL, // 15 Holy
|
|
SHRINE_ALL, // 16 Sacred
|
|
SHRINE_ALL, // 17 Spiritual
|
|
SHRINE_MULTI, // 18 Spooky
|
|
SHRINE_ALL, // 19 Abandoned
|
|
SHRINE_ALL, // 20 Creepy
|
|
SHRINE_ALL, // 21 Quiet
|
|
SHRINE_ALL, // 22 Secluded
|
|
SHRINE_ALL, // 23 Ornate
|
|
SHRINE_ALL, // 24 Glimmering
|
|
SHRINE_MULTI, // 25 Tainted
|
|
SHRINE_ALL, // 26 Oily
|
|
SHRINE_ALL, // 27 Glowing
|
|
SHRINE_ALL, // 28 Mendicants
|
|
SHRINE_ALL, // 29 Edisons
|
|
SHRINE_ALL, // 30 Town
|
|
SHRINE_ALL, // 31 Energy
|
|
SHRINE_SINGLE, // 32 Solar
|
|
SHRINE_ALL, // 33 Murphy's
|
|
};
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static char const * const StoryBookName[] = {
|
|
// The Librium of the Horadrim (White Books)
|
|
|
|
"The Great Conflict",
|
|
"The Wages of Sin are War",
|
|
"The Tale of the Horadrim",
|
|
|
|
// Grimoire of the Burning Hells (Red Books)
|
|
|
|
"The Dark Exile",
|
|
"The Sin War",
|
|
"The Binding of the Three",
|
|
|
|
// The Journals of Lazarus the Betrayer (Normal Book Color)
|
|
|
|
"The Realms Beyond",
|
|
"Tale of the Three",
|
|
"The Black King",
|
|
|
|
// The Journals of Skulken the Necromancer JKE
|
|
|
|
"Journal: The Ensorcellment",
|
|
"Journal: The Meeting",
|
|
"Journal: The Tirade",
|
|
"Journal: His Power Grows",
|
|
"Journal: NA-KRUL",
|
|
"Journal: The End",
|
|
|
|
"A Spellbook"
|
|
};
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
void InitObjectGFX() {
|
|
BYTE fileload[MAXOBJFILES];
|
|
int i,j,t;
|
|
int templevel; //JKE
|
|
|
|
ZeroMemory(fileload,sizeof(fileload));
|
|
|
|
// temp hack to get object art to appear. JKE
|
|
templevel = currlevel;
|
|
if ((currlevel >= CRYPTSTART) && (currlevel <= CRYPTEND))
|
|
templevel = templevel - CRYPTSTART + 1; // replace templevel with currlevel when done.
|
|
else if ((currlevel >= HIVESTART) && (currlevel <= HIVEEND))
|
|
templevel = templevel - HIVESTART + 9;
|
|
|
|
for (i = 0; AllObjects[i].oload != -1; ++i) {
|
|
if ((AllObjects[i].oload == OBJMUST)
|
|
&& (templevel >= AllObjects[i].ominlvl)
|
|
&& (templevel <= AllObjects[i].omaxlvl))
|
|
fileload[AllObjects[i].ofindex] = TRUE;
|
|
|
|
if (AllObjects[i].otheme != -1) {
|
|
for (t = 0; t < numthemes; ++t) {
|
|
if (theme[t].ttype == AllObjects[i].otheme)
|
|
fileload[AllObjects[i].ofindex] = TRUE;
|
|
}
|
|
}
|
|
|
|
if (AllObjects[i].oquest != -1) {
|
|
j = AllObjects[i].oquest;
|
|
if (QuestStatus(j))
|
|
fileload[AllObjects[i].ofindex] = TRUE;
|
|
}
|
|
}
|
|
|
|
app_assert(numobjfiles == 0);
|
|
for (i = 0; i < MAXOBJFILES; ++i) {
|
|
if (fileload[i]) {
|
|
char filestr[32];
|
|
ObjFileList[numobjfiles] = i;
|
|
sprintf(filestr, "Objects\\%s.CEL", ObjMasterFList[i]);
|
|
if ((currlevel >= HIVESTART) && (currlevel < CRYPTSTART)) //JKE OBJECTS
|
|
sprintf(filestr, "Objects\\%s.CEL", HObjMasterFList[i]);
|
|
else if (currlevel >= CRYPTSTART)
|
|
sprintf(filestr, "Objects\\%s.CEL", CObjMasterFList[i]);
|
|
|
|
app_assert(! pObjCels[numobjfiles]);
|
|
pObjCels[numobjfiles] = LoadFileInMemSig(filestr,NULL,'OGFX');
|
|
++numobjfiles;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
void FreeObjectGFX() {
|
|
for (int i = 0; i < numobjfiles; ++i) {
|
|
DiabloFreePtr(pObjCels[i]);
|
|
}
|
|
numobjfiles = 0;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
static bool RndLocOk(int xp, int yp) {
|
|
if (dMonster[xp][yp] != 0) return FALSE;
|
|
if (dPlayer[xp][yp] != 0) return FALSE;
|
|
if (dObject[xp][yp] != 0) return FALSE;
|
|
if (dFlags[xp][yp] & BFLAG_SETPC) return FALSE;
|
|
if (nSolidTable[dPiece[xp][yp]]) return FALSE;
|
|
if (leveltype == 1) {
|
|
if ((dPiece[xp][yp] > 126) && (dPiece[xp][yp] < 144))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
static bool TrapLocOk(int xp, int yp) {
|
|
if (dFlags[xp][yp] & BFLAG_SETPC) return false;
|
|
if (nSolidTable[dPiece[xp][yp]]) return false;
|
|
return true;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
static bool RoomLocOk(int xp, int yp) {
|
|
if (dPlayer[xp][yp] != 0) return false;
|
|
if (dObject[xp][yp] != 0) return false;
|
|
if (dFlags[xp][yp] & BFLAG_SETPC) return false;
|
|
if (nSolidTable[dPiece[xp][yp]]) return false;
|
|
return true;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
void InitRndLocObj(int min, int max, int objtype) {
|
|
int xp, yp;
|
|
|
|
int numobjs = random(139,max - min) + min;
|
|
for (int i = 0; i < numobjs; ++i) {
|
|
while (1) {
|
|
xp = random(139,DMAXX - DIRTEDGE) + (DIRTEDGED2);
|
|
yp = random(139,DMAXY - DIRTEDGE) + (DIRTEDGED2);
|
|
if (! RndLocOk(xp-1, yp-1)) continue;
|
|
if (! RndLocOk(xp+0, yp-1)) continue;
|
|
if (! RndLocOk(xp+1, yp-1)) continue;
|
|
if (! RndLocOk(xp-1, yp+0)) continue;
|
|
if (! RndLocOk(xp+0, yp+0)) continue;
|
|
if (! RndLocOk(xp+1, yp+0)) continue;
|
|
if (! RndLocOk(xp-1, yp+1)) continue;
|
|
if (! RndLocOk(xp+0, yp+1)) continue;
|
|
if (! RndLocOk(xp+1, yp+1)) continue;
|
|
break;
|
|
}
|
|
AddObject(objtype, xp, yp);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void InitRndLocBigObj(int min, int max, int objtype) {
|
|
int xp, yp;
|
|
int numobjs = random(140,max - min) + min;
|
|
for (int i = 0; i < numobjs; ++i) {
|
|
while (1) {
|
|
xp = random(140,DMAXX - DIRTEDGE) + (DIRTEDGED2);
|
|
yp = random(140,DMAXY - DIRTEDGE) + (DIRTEDGED2);
|
|
if (! RndLocOk(xp-1, yp-2)) continue;
|
|
if (! RndLocOk(xp+0, yp-2)) continue;
|
|
if (! RndLocOk(xp+1, yp-2)) continue;
|
|
if (! RndLocOk(xp-1, yp-1)) continue;
|
|
if (! RndLocOk(xp+0, yp-1)) continue;
|
|
if (! RndLocOk(xp+1, yp-1)) continue;
|
|
if (! RndLocOk(xp-1, yp+0)) continue;
|
|
if (! RndLocOk(xp+0, yp+0)) continue;
|
|
if (! RndLocOk(xp+1, yp+0)) continue;
|
|
if (! RndLocOk(xp-1, yp+1)) continue;
|
|
if (! RndLocOk(xp+0, yp+1)) continue;
|
|
if (! RndLocOk(xp+1, yp+1)) continue;
|
|
break;
|
|
}
|
|
|
|
AddObject(objtype, xp, yp);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
static void InitRndLocObj5x5(int min, int max, int objtype) {
|
|
int xp, yp, xx, yy, cnt;
|
|
bool done;
|
|
|
|
int numobjs = random(139,max - min) + min;
|
|
for (int i = 0; i < numobjs; ++i) {
|
|
cnt = 0;
|
|
done = false;
|
|
while (! done) {
|
|
done = true;
|
|
xp = random(139,DMAXX - DIRTEDGE) + (DIRTEDGED2);
|
|
yp = random(139,DMAXY - DIRTEDGE) + (DIRTEDGED2);
|
|
for (yy = -2; yy <= 2; ++yy) {
|
|
for (xx = -2; xx <= 2; ++xx) if (! RndLocOk(xp+xx,yp+yy)) done = FALSE;
|
|
}
|
|
if (!done) {
|
|
++cnt;
|
|
if (cnt > 20000) return;
|
|
}
|
|
}
|
|
AddObject(objtype, xp, yp);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void ClrAllObjects ()
|
|
{
|
|
int i;
|
|
|
|
#if 0
|
|
for (i = 0; i < MAXOBJECTS; ++i) {
|
|
object[i]._ox = 0;
|
|
object[i]._oy = 0;
|
|
object[i]._oAnimData = NULL;
|
|
object[i]._oAnimDelay = 0;
|
|
object[i]._oAnimCnt = 0;
|
|
object[i]._oAnimLen = 0;
|
|
object[i]._oAnimFrame = 0;
|
|
object[i]._oDelFlag = FALSE;
|
|
object[i]._oVar1 = 0;
|
|
object[i]._oVar2 = 0;
|
|
object[i]._oVar3 = 0;
|
|
object[i]._oVar4 = 0;
|
|
}
|
|
#else
|
|
memset(object, 0, sizeof(object));
|
|
#endif
|
|
|
|
numobjects = 0;
|
|
|
|
for (i = 0; i < MAXOBJECTS; ++i) {
|
|
objectavail[i] = i;
|
|
//objectactive[i] = 0;
|
|
}
|
|
memset(objectactive, 0, sizeof(objectactive));
|
|
trapid = 1;
|
|
trapdir = TRAP_NODIR;
|
|
leverid = 1;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddTortures()
|
|
{
|
|
int yp, xp;
|
|
|
|
for (yp = 0; yp < DMAXY; ++yp) {
|
|
for (xp = 0; xp < DMAXX; ++xp) {
|
|
if (dPiece[xp][yp] == 367) {
|
|
AddObject(OBJ_TORTURE1, xp, yp+1);
|
|
AddObject(OBJ_TORTURE3, xp+2, yp-1);
|
|
AddObject(OBJ_TORTURE2, xp, yp+3);
|
|
AddObject(OBJ_TORTURE4, xp+4, yp-1);
|
|
AddObject(OBJ_TORTURE5, xp, yp+5);
|
|
AddObject(OBJ_TNUDEM1, xp+1, yp+3);
|
|
AddObject(OBJ_TNUDEM2, xp+4, yp+5);
|
|
AddObject(OBJ_TNUDEM3, xp+2, yp);
|
|
AddObject(OBJ_TNUDEM4, xp+3, yp+2);
|
|
AddObject(OBJ_TNUDEW1, xp+2, yp+4);
|
|
AddObject(OBJ_TNUDEW2, xp+2, yp+1);
|
|
AddObject(OBJ_TNUDEW3, xp+4, yp+2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddCandles()
|
|
{
|
|
int const xp = quests[Q_PWATER]._qtx;
|
|
int const yp = quests[Q_PWATER]._qty;
|
|
|
|
AddObject(OBJ_STORYCANDLE, xp-2, yp+1);
|
|
AddObject(OBJ_STORYCANDLE, xp+3, yp+1);
|
|
AddObject(OBJ_STORYCANDLE, xp-1, yp+2);
|
|
AddObject(OBJ_STORYCANDLE, xp+2, yp+2);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddTrapLine(int min, int max, int tobjtype, int lobjtype)
|
|
{
|
|
int i, j, xp, yp, numobjs;
|
|
int sx, sy, xa, ya, t;
|
|
int lx1, ly1, lx2, ly2;
|
|
bool found;
|
|
|
|
numobjs = random(0,max - min) + min;
|
|
for (i = 0; i < numobjs; ++i) {
|
|
found = false;
|
|
while (!found) {
|
|
found = true;
|
|
xp = random(0,DMAXX - DIRTEDGE) + (DIRTEDGED2);
|
|
yp = random(0,DMAXY - DIRTEDGE) + (DIRTEDGED2);
|
|
if (random(0,2)) {
|
|
while (TrapLocOk(xp, yp-1)) --yp; // Go to bottom
|
|
sx = xp;
|
|
sy = yp;
|
|
xa = 0;
|
|
ya = 1;
|
|
t = 0;
|
|
while (TrapLocOk(xp, yp+1) && found) {
|
|
found = found && RndLocOk(xp-3, yp);
|
|
found = found && RndLocOk(xp-2, yp);
|
|
found = found && RndLocOk(xp-1, yp);
|
|
found = found && RndLocOk(xp, yp);
|
|
found = found && RndLocOk(xp+1, yp);
|
|
found = found && RndLocOk(xp+2, yp);
|
|
found = found && RndLocOk(xp+3, yp);
|
|
++yp;
|
|
++t;
|
|
}
|
|
lx1 = xp-2;
|
|
ly1 = random(0,t-1) + sy + 1;
|
|
lx2 = xp+2;
|
|
ly2 = random(0,t-1) + sy + 1;
|
|
trapdir = TRAP_VERT;
|
|
} else {
|
|
while (TrapLocOk(xp-1, yp)) --xp; // Go to left
|
|
sx = xp;
|
|
sy = yp;
|
|
xa = 1;
|
|
ya = 0;
|
|
t = 0;
|
|
while (TrapLocOk(xp+1, yp) && found) {
|
|
found = found && RndLocOk(xp, yp-3);
|
|
found = found && RndLocOk(xp, yp-2);
|
|
found = found && RndLocOk(xp, yp-1);
|
|
found = found && RndLocOk(xp, yp);
|
|
found = found && RndLocOk(xp, yp+1);
|
|
found = found && RndLocOk(xp, yp+2);
|
|
found = found && RndLocOk(xp, yp+3);
|
|
++xp;
|
|
++t;
|
|
}
|
|
lx1 = random(0,t-1) + sx + 1;
|
|
ly1 = yp-2;
|
|
lx2 = random(0,t-1) + sx + 1;
|
|
ly2 = yp+2;
|
|
trapdir = TRAP_HORIZ;
|
|
}
|
|
if ((t < 5) || (t > 12)) found = FALSE;
|
|
}
|
|
|
|
// Place trap
|
|
xp = sx;
|
|
yp = sy;
|
|
for (j = 0; j <= t; ++j) {
|
|
AddObject(tobjtype, xp, yp);
|
|
xp += xa;
|
|
yp += ya;
|
|
}
|
|
|
|
// Place levers
|
|
AddObject(lobjtype, lx1, ly1);
|
|
AddObject(lobjtype, lx2, ly2);
|
|
|
|
++trapid; // Next trap
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddLeverObj(int lx1, int ly1, int lx2, int ly2, int x1, int y1, int x2, int y2)
|
|
{
|
|
int xp, yp;
|
|
while (1) {
|
|
xp = random(141,lx2 - lx1 + 1) + lx1;
|
|
yp = random(141,ly2 - ly1 + 1) + ly1;
|
|
if (! RndLocOk(xp-1, yp-1)) continue;
|
|
if (! RndLocOk(xp+0, yp-1)) continue;
|
|
if (! RndLocOk(xp+1, yp-1)) continue;
|
|
if (! RndLocOk(xp-1, yp+0)) continue;
|
|
if (! RndLocOk(xp+0, yp+0)) continue;
|
|
if (! RndLocOk(xp+1, yp+0)) continue;
|
|
if (! RndLocOk(xp-1, yp+1)) continue;
|
|
if (! RndLocOk(xp+0, yp+1)) continue;
|
|
if (! RndLocOk(xp+1, yp+1)) continue;
|
|
break;
|
|
}
|
|
|
|
AddObject(OBJ_LEVER, xp, yp);
|
|
int i = dObject[xp][yp] - 1;
|
|
SetObjMapRange(i, x1, y1, x2, y2, leverid);
|
|
++leverid;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddBookLever(int lx1, int ly1, int lx2, int ly2, int x1, int y1, int x2, int y2, int msg)
|
|
{
|
|
/* int xp, yp;
|
|
while (1) {
|
|
xp = random(142,lx2 - lx1 + 1) + lx1;
|
|
yp = random(142,ly2 - ly1 + 1) + ly1;
|
|
if (! RndLocOk(xp-1, yp-1)) continue;
|
|
if (! RndLocOk(xp+0, yp-1)) continue;
|
|
if (! RndLocOk(xp+1, yp-1)) continue;
|
|
if (! RndLocOk(xp-1, yp+0)) continue;
|
|
if (! RndLocOk(xp+0, yp+0)) continue;
|
|
if (! RndLocOk(xp+1, yp+0)) continue;
|
|
if (! RndLocOk(xp-1, yp+1)) continue;
|
|
if (! RndLocOk(xp+0, yp+1)) continue;
|
|
if (! RndLocOk(xp+1, yp+1)) continue;
|
|
break;
|
|
}
|
|
*/
|
|
int xp, yp, xx, yy, cnt;
|
|
bool done;
|
|
|
|
cnt = 0;
|
|
done = false;
|
|
while (! done) {
|
|
done = true;
|
|
xp = random(139,DMAXX - DIRTEDGE) + (DIRTEDGED2);
|
|
yp = random(139,DMAXY - DIRTEDGE) + (DIRTEDGED2);
|
|
for (yy = -2; yy <= 2; ++yy) {
|
|
for (xx = -2; xx <= 2; ++xx) if (! RndLocOk(xp+xx,yp+yy)) done = FALSE;
|
|
}
|
|
if (!done) {
|
|
++cnt;
|
|
if (cnt > 20000) return;
|
|
}
|
|
}
|
|
if (QuestStatus(Q_BLIND)) AddObject(OBJ_BLINDBOOK, xp, yp);
|
|
if (QuestStatus(Q_WARLORD)) AddObject(OBJ_STEELTOME, xp, yp);
|
|
if (QuestStatus(Q_BLOOD)) {
|
|
xp = (setpc_x << 1) + DIRTEDGED2 + 9;
|
|
yp = (setpc_y << 1) + DIRTEDGED2 + 24;
|
|
AddObject(OBJ_BLOODBOOK, xp, yp);
|
|
}
|
|
app_assert((DWORD)xp < MAXDUNX);
|
|
app_assert((DWORD)yp < MAXDUNY);
|
|
int i = dObject[xp][yp] - 1;
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
SetObjMapRange(i, x1, y1, x2, y2, leverid);
|
|
SetBookMsg(i, msg);
|
|
++leverid;
|
|
object[i]._oVar6 = object[i]._oAnimFrame + 1;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
static void InitRndBarrels()
|
|
{
|
|
int xp, yp, o, rv, c, t;
|
|
|
|
int numobjs = random(143,5) + 3;
|
|
for (int i = 0; i < numobjs; ++i) {
|
|
while (1) {
|
|
xp = random(143,DMAXX - DIRTEDGE) + (DIRTEDGED2);
|
|
yp = random(143,DMAXY - DIRTEDGE) + (DIRTEDGED2);
|
|
if (! RndLocOk(xp, yp)) continue;
|
|
break;
|
|
}
|
|
|
|
// Add normal or exploding barrel
|
|
if (random(143,4)) o = OBJ_BARREL;
|
|
else o = OBJ_BARRELEX;
|
|
AddObject(o, xp, yp);
|
|
c = 1;
|
|
|
|
bool found = true;
|
|
while ((random(143,c >> 1) == 0) && (found)) {
|
|
t = 0;
|
|
found = false;
|
|
while ((!found) && (t < 3)) {
|
|
rv = random(143,8);
|
|
xp += bxadd[rv];
|
|
yp += byadd[rv];
|
|
found = RndLocOk(xp, yp);
|
|
++t;
|
|
}
|
|
if (found) {
|
|
if (random(143,5)) o = OBJ_BARREL;
|
|
else o = OBJ_BARRELEX;
|
|
AddObject(o, xp, yp);
|
|
++c;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void AddL1Objs(int x1, int y1, int x2, int y2)
|
|
{
|
|
int i,j,pn;
|
|
|
|
for (j = y1; j < y2; ++j) {
|
|
for (i = x1; i < x2; ++i) {
|
|
// Add Light
|
|
pn = dPiece[i][j];
|
|
if (pn == 270) AddObject(OBJ_L1LIGHT, i, j);
|
|
if ((pn == 44) || (pn == 51) || (pn == 214))
|
|
AddObject(OBJ_L1DOORL, i, j);
|
|
if ((pn == 46) || (pn == 56)) AddObject(OBJ_L1DOORR, i, j);
|
|
}
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void AddL5Objs(int x1, int y1, int x2, int y2)
|
|
{
|
|
int i,j,pn;
|
|
|
|
for (j = y1; j < y2; ++j) {
|
|
for (i = x1; i < x2; ++i) {
|
|
// Add Light
|
|
pn = dPiece[i][j];
|
|
// if (pn == 270) AddObject(OBJ_L1LIGHT, i, j);
|
|
if (pn == 77)
|
|
AddObject(OBJ_L1DOORL, i, j);
|
|
if (pn == 80)
|
|
AddObject(OBJ_L1DOORR, i, j);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void AddL2Objs(int x1, int y1, int x2, int y2)
|
|
{
|
|
int i,j,pn;
|
|
|
|
for (j = y1; j < y2; ++j) {
|
|
for (i = x1; i < x2; ++i) {
|
|
// Add Doors
|
|
pn = dPiece[i][j];
|
|
if (pn == 13 || pn == 541) AddObject(OBJ_L2DOORL, i, j);
|
|
if (pn == 17 || pn == 542) AddObject(OBJ_L2DOORR, i, j);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddL3Objs(int x1, int y1, int x2, int y2)
|
|
{
|
|
int i,j,pn;
|
|
|
|
for (j = y1; j < y2; ++j) {
|
|
for (i = x1; i < x2; ++i) {
|
|
// Add Doors
|
|
pn = dPiece[i][j];
|
|
if (pn == 531) AddObject(OBJ_L3DOORL, i, j);
|
|
if (pn == 534) AddObject(OBJ_L3DOORR, i, j);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static bool TorchLocOK(int xp, int yp)
|
|
{
|
|
if (dFlags[xp][yp] & BFLAG_SETPC) return false;
|
|
return true;
|
|
}
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddL2Torches()
|
|
{
|
|
int i,j,pn;
|
|
|
|
for (j = 0; j < DMAXY; ++j) {
|
|
for (i = 0; i < DMAXX; ++i) {
|
|
// Add Torches
|
|
if(TorchLocOK(i,j)) {
|
|
pn = dPiece[i][j];
|
|
if ((pn == 1) && (random(145,3) == 0)) AddObject(OBJ_TORCHL2, i, j);
|
|
if ((pn == 5) && (random(145,3) == 0)) AddObject(OBJ_TORCHR2, i, j);
|
|
if ((pn == 37) && (random(145,10) == 0) && (dObject[i-1][j] == 0)) AddObject(OBJ_TORCHL, i-1, j);
|
|
if ((pn == 41) && (random(145,10) == 0) && (dObject[i][j-1] == 0)) AddObject(OBJ_TORCHR, i, j-1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
static bool WallTrapLocOk(int xp, int yp)
|
|
{
|
|
if (dFlags[xp][yp] & BFLAG_SETPC) return false;
|
|
if (!nTrapTable[dPiece[xp][yp]]) return false;
|
|
return true;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddObjTraps()
|
|
{
|
|
int i,j;
|
|
int x,y;
|
|
int rndv;
|
|
char oi, oi2;
|
|
|
|
if (currlevel == 1) rndv = 10;
|
|
if (currlevel >= 2) rndv = 15;
|
|
if (currlevel >= 5) rndv = 20;
|
|
if (currlevel >= 7) rndv = 25;
|
|
for (j = 0; j < DMAXY; ++j) {
|
|
for (i = 0; i < DMAXX; ++i) {
|
|
if ((dObject[i][j] > 0) && (random(144,100) < rndv)) {
|
|
oi = dObject[i][j] - 1;
|
|
if (AllObjects[object[oi]._otype].oTrapFlag) {
|
|
x = i;
|
|
y = j;
|
|
if (random(144,2) == 0) {
|
|
--x;
|
|
while (!nSolidTable[dPiece[x][y]]) --x;
|
|
if (WallTrapLocOk(x, y) && ((i - x) > 1)) {
|
|
AddObject(OBJ_TRAPL, x, y);
|
|
oi2 = dObject[x][y] - 1;
|
|
object[oi2]._oVar1 = i;
|
|
object[oi2]._oVar2 = j;
|
|
object[oi]._oTrapFlag = TRUE;
|
|
}
|
|
} else {
|
|
--y;
|
|
while (!nSolidTable[dPiece[x][y]]) --y;
|
|
if (WallTrapLocOk(x, y) && ((j - y) > 1)) {
|
|
AddObject(OBJ_TRAPR, x, y);
|
|
oi2 = dObject[x][y] - 1;
|
|
object[oi2]._oVar1 = i;
|
|
object[oi2]._oVar2 = j;
|
|
object[oi]._oTrapFlag = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddChestTraps()
|
|
{
|
|
int i,j;
|
|
char oi;
|
|
|
|
for (j = 0; j < DMAXY; ++j) {
|
|
for (i = 0; i < DMAXX; ++i) {
|
|
if (dObject[i][j] > 0) {
|
|
oi = dObject[i][j] - 1;
|
|
if ((object[oi]._otype >= OBJ_CHEST1) &&
|
|
(object[oi]._otype <= OBJ_CHEST3) &&
|
|
(!object[oi]._oTrapFlag) &&
|
|
(random(0, 100) < 10)) {
|
|
object[oi]._otype = (object[oi]._otype - OBJ_CHEST1) + OBJ_TCHEST1;
|
|
object[oi]._oTrapFlag = TRUE;
|
|
if (leveltype == 2) object[oi]._oVar4 = random(0, 2); // Type of trap
|
|
#if defined(HELLFIRE2)
|
|
else object[oi]._oVar4 = random(0, 7);
|
|
#else
|
|
else object[oi]._oVar4 = random(0, 6);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
** Used by diablo level only!!!!!
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void LoadMapObjects(BYTE *pMap, int startx, int starty, int x1, int y1, int w, int h, int leveridx)
|
|
{
|
|
int i,j,rw,rh;
|
|
int ox,oy;
|
|
BYTE *lm;
|
|
long mapoff;
|
|
int ot, oi;
|
|
|
|
InitObjFlag = TRUE;
|
|
|
|
lm = pMap;
|
|
rw = *lm;
|
|
lm += 2;
|
|
rh = *lm;
|
|
// Skip map + height word
|
|
mapoff = ((rw * rh) << 1) + 2;
|
|
// Convert to index mini tile level instead of mega
|
|
rw = rw << 1;
|
|
rh = rh << 1;
|
|
// Skip treasure and monster map
|
|
mapoff += ((rw * rh) << 2);
|
|
lm += mapoff;
|
|
|
|
for (j = 0; j < rh; ++j) {
|
|
for (i = 0; i < rw; ++i) {
|
|
if (*lm != 0) {
|
|
ot = *lm;
|
|
ox = i + DIRTEDGED2 + startx;
|
|
oy = j + DIRTEDGED2 + starty;
|
|
AddObject(ObjTypeConv[ot], ox, oy);
|
|
oi = ObjIndex(ox, oy);
|
|
SetObjMapRange(oi, x1, y1, x1+w, y1+h, leveridx);
|
|
}
|
|
lm+=2;
|
|
}
|
|
}
|
|
|
|
InitObjFlag = FALSE;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void LoadMapObjs(BYTE *pMap, int startx, int starty)
|
|
{
|
|
int i,j,rw,rh;
|
|
int ox,oy;
|
|
BYTE *lm;
|
|
long mapoff;
|
|
int ot;
|
|
|
|
InitObjFlag = TRUE;
|
|
|
|
lm = pMap;
|
|
rw = *lm;
|
|
lm += 2;
|
|
rh = *lm;
|
|
// Skip map + height word
|
|
mapoff = ((rw * rh) << 1) + 2;
|
|
// Convert to index mini tile level instead of mega
|
|
rw = rw << 1;
|
|
rh = rh << 1;
|
|
// Skip treasure and monster map
|
|
mapoff += ((rw * rh) << 2);
|
|
lm += mapoff;
|
|
|
|
for (j = 0; j < rh; ++j) {
|
|
for (i = 0; i < rw; ++i) {
|
|
if (*lm != 0) {
|
|
ot = *lm;
|
|
ox = i + DIRTEDGED2 + startx;
|
|
oy = j + DIRTEDGED2 + starty;
|
|
AddObject(ObjTypeConv[ot], ox, oy);
|
|
}
|
|
lm+=2;
|
|
}
|
|
}
|
|
|
|
InitObjFlag = FALSE;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
** Levers for diablo level
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddDiabObjs()
|
|
{
|
|
BYTE *pSetPiece;
|
|
int xx, yy;
|
|
|
|
pSetPiece = LoadFileInMemSig("Levels\\L4Data\\diab1.DUN",NULL,'STPC');
|
|
xx = (diabquad1x << 1);
|
|
yy = (diabquad1y << 1);
|
|
LoadMapObjects(pSetPiece, xx, yy, diabquad2x, diabquad2y, 11, 12, 1);
|
|
DiabloFreePtr(pSetPiece);
|
|
|
|
pSetPiece = LoadFileInMemSig("Levels\\L4Data\\diab2a.DUN",NULL,'STPC');
|
|
xx = (diabquad2x << 1);
|
|
yy = (diabquad2y << 1);
|
|
LoadMapObjects(pSetPiece, xx, yy, diabquad3x, diabquad3y, 11, 11, 2);
|
|
DiabloFreePtr(pSetPiece);
|
|
|
|
pSetPiece = LoadFileInMemSig("Levels\\L4Data\\diab3a.DUN",NULL,'STPC');
|
|
xx = (diabquad3x << 1);
|
|
yy = (diabquad3y << 1);
|
|
LoadMapObjects(pSetPiece, xx, yy, diabquad4x, diabquad4y, 9, 9, 3);
|
|
DiabloFreePtr(pSetPiece);
|
|
}
|
|
|
|
static void AddSkulkenBooks(int number) // Journal entry books JKE
|
|
{
|
|
int xp,yp,xx,yy,cnt;
|
|
bool done;
|
|
|
|
cnt = 0;
|
|
done = false;
|
|
while (! done) {
|
|
done = true;
|
|
xp = random(139,DMAXX - DIRTEDGE) + (DIRTEDGED2);
|
|
yp = random(139,DMAXY - DIRTEDGE) + (DIRTEDGED2);
|
|
for (yy = -2; yy <= 2; ++yy) {
|
|
for (xx = -3; xx <= 3; ++xx) if (! RndLocOk(xp+xx,yp+yy)) done = FALSE;
|
|
}
|
|
if (!done) {
|
|
++cnt;
|
|
if (cnt > 20000) return;
|
|
}
|
|
}
|
|
AddSkulkenObject(OBJ_STORYBOOK, number, xp, yp);
|
|
|
|
// AddObject(OBJ_STORYBOOK, xp, yp);
|
|
|
|
AddObject(OBJ_STORYCANDLE, xp-2, yp+1);
|
|
AddObject(OBJ_STORYCANDLE, xp-2, yp);
|
|
AddObject(OBJ_STORYCANDLE, xp-1, yp-1);
|
|
AddObject(OBJ_STORYCANDLE, xp+1, yp-1);
|
|
AddObject(OBJ_STORYCANDLE, xp+2, yp);
|
|
AddObject(OBJ_STORYCANDLE, xp+2, yp+1);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddStoryBooks()
|
|
{
|
|
int xp,yp,xx,yy,cnt;
|
|
bool done;
|
|
|
|
cnt = 0;
|
|
done = false;
|
|
while (! done) {
|
|
done = true;
|
|
xp = random(139,DMAXX - DIRTEDGE) + (DIRTEDGED2);
|
|
yp = random(139,DMAXY - DIRTEDGE) + (DIRTEDGED2);
|
|
for (yy = -2; yy <= 2; ++yy) {
|
|
for (xx = -3; xx <= 3; ++xx) if (! RndLocOk(xp+xx,yp+yy)) done = FALSE;
|
|
}
|
|
if (!done) {
|
|
++cnt;
|
|
if (cnt > 20000) return;
|
|
}
|
|
}
|
|
AddObject(OBJ_STORYBOOK, xp, yp);
|
|
AddObject(OBJ_STORYCANDLE, xp-2, yp+1);
|
|
AddObject(OBJ_STORYCANDLE, xp-2, yp);
|
|
AddObject(OBJ_STORYCANDLE, xp-1, yp-1);
|
|
AddObject(OBJ_STORYCANDLE, xp+1, yp-1);
|
|
AddObject(OBJ_STORYCANDLE, xp+2, yp);
|
|
AddObject(OBJ_STORYCANDLE, xp+2, yp+1);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddHookedBodies(int freq)
|
|
{
|
|
int i, j, ii, jj;
|
|
|
|
//Add tortured bodies on hooks
|
|
for (j = 0; j < MDMAXY; ++j) {
|
|
for (i = 0; i < MDMAXX; ++i) {
|
|
if ((dungeon[i][j] == 1 || dungeon[i][j] == 2) &&
|
|
((!random(0, freq)) && (SkipThemeRoom(i, j)))) {
|
|
ii = (i << 1) + DIRTEDGED2;
|
|
jj = (j << 1) + DIRTEDGED2;
|
|
if ((dungeon[i][j] == 1) && (dungeon[i+1][j] == 6)) {
|
|
switch(random(0, 3)) {
|
|
case 0:
|
|
AddObject(OBJ_TORTURE1, ii+1, jj);
|
|
break;
|
|
case 1:
|
|
AddObject(OBJ_TORTURE2, ii+1, jj);
|
|
break;
|
|
case 2:
|
|
AddObject(OBJ_TORTURE5, ii+1, jj);
|
|
break;
|
|
}
|
|
} else if ((dungeon[i][j] == 2) && (dungeon[i][j+1] == 6)) {
|
|
switch(random(0, 2)) {
|
|
case 0:
|
|
AddObject(OBJ_TORTURE3, ii, jj);
|
|
break;
|
|
case 1:
|
|
AddObject(OBJ_TORTURE4, ii, jj);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
static void AddL4Goodies()
|
|
{
|
|
AddHookedBodies(6);
|
|
InitRndLocObj(2, 6, OBJ_TNUDEM1);
|
|
InitRndLocObj(2, 6, OBJ_TNUDEM2);
|
|
InitRndLocObj(2, 6, OBJ_TNUDEM3);
|
|
InitRndLocObj(2, 6, OBJ_TNUDEM4);
|
|
InitRndLocObj(2, 6, OBJ_TNUDEW1);
|
|
InitRndLocObj(2, 6, OBJ_TNUDEW2);
|
|
InitRndLocObj(2, 6, OBJ_TNUDEW3);
|
|
InitRndLocObj(2, 6, OBJ_DECAP);
|
|
InitRndLocObj(1, 3, OBJ_CAULDRON);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
static void AddLazStand()
|
|
{
|
|
int xp,yp,xx,yy,cnt;
|
|
bool done = false;
|
|
|
|
cnt = 0;
|
|
while (! done) {
|
|
done = true;
|
|
xp = random(139,DMAXX - DIRTEDGE) + (DIRTEDGED2);
|
|
yp = random(139,DMAXY - DIRTEDGE) + (DIRTEDGED2);
|
|
for (yy = -3; yy <= 3; ++yy) {
|
|
for (xx = -2; xx <= 3; ++xx) if (! RndLocOk(xp+xx,yp+yy)) done = FALSE;
|
|
}
|
|
if (!done) {
|
|
++cnt;
|
|
if (cnt > 10000) {
|
|
// If can't find big area put it anywhere
|
|
InitRndLocObj(1, 1, OBJ_LAZSTAND);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
AddObject(OBJ_LAZSTAND, xp, yp);
|
|
AddObject(OBJ_TNUDEM2, xp+0, yp+2);
|
|
AddObject(OBJ_STORYCANDLE, xp+1, yp+2);
|
|
AddObject(OBJ_TNUDEM3, xp+2, yp+2);
|
|
AddObject(OBJ_TNUDEW1, xp+0, yp-2);
|
|
AddObject(OBJ_STORYCANDLE, xp+1, yp-2);
|
|
AddObject(OBJ_TNUDEW2, xp+2, yp-2);
|
|
AddObject(OBJ_STORYCANDLE, xp-1, yp-1);
|
|
AddObject(OBJ_TNUDEW3, xp-1, yp+0);
|
|
AddObject(OBJ_STORYCANDLE, xp-1, yp+1);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
** Does not get called for setlevels so no worries
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void InitObjects ()
|
|
{
|
|
int textdef;
|
|
byte *setp;
|
|
|
|
ClrAllObjects();
|
|
SpellProgress = 0;
|
|
|
|
// No objects on DIABLO_LEVEL. Inited seperatly
|
|
if (currlevel == DIABLO_LEVEL) {
|
|
AddDiabObjs();
|
|
return;
|
|
}
|
|
|
|
InitObjFlag = TRUE;
|
|
|
|
int rs = GetRndSeed();
|
|
|
|
if (currlevel == SLAIN_HERO_LEVEL && gbMaxPlayers == 1) {
|
|
AddSlainHero();
|
|
}
|
|
|
|
if (currlevel == quests[Q_BKMUSHRM]._qlevel
|
|
&& quests[Q_BKMUSHRM]._qactive == QUEST_NOTACTIVE) {
|
|
AddMushPatch();
|
|
}
|
|
|
|
if (currlevel == STORY_BOOK1_LEVEL) AddStoryBooks();
|
|
else if (currlevel == STORY_BOOK2_LEVEL) AddStoryBooks();
|
|
else if (currlevel == STORY_BOOK3_LEVEL) AddStoryBooks();
|
|
|
|
if (currlevel == SKULKEN_BOOK1_LEVEL)
|
|
{
|
|
// AddSkulkenBooks(0);
|
|
AddSkulkenBooks(1);
|
|
|
|
// AddStoryBooks();
|
|
// AddStoryBooks();
|
|
}
|
|
else if (currlevel == SKULKEN_BOOK2_LEVEL)
|
|
{
|
|
AddSkulkenBooks(2);
|
|
AddSkulkenBooks(3);
|
|
}
|
|
else if (currlevel == SKULKEN_BOOK3_LEVEL)
|
|
{
|
|
AddSkulkenBooks(4);
|
|
AddSkulkenBooks(5);
|
|
}
|
|
|
|
if (currlevel == NA_KRUL_LEVEL)
|
|
{
|
|
AddNa_Krul_Stuff();
|
|
|
|
}
|
|
|
|
if (leveltype == 1) {
|
|
if (QuestStatus(Q_BUTCHER)) AddTortures();
|
|
if (QuestStatus(Q_PWATER)) AddCandles();
|
|
if (QuestStatus(Q_LTBANNER)) AddObject(OBJ_SIGNCHEST,(setpc_x << 1) + DIRTEDGED2 + 10, (setpc_y << 1) + DIRTEDGED2 + 3);
|
|
|
|
InitRndLocBigObj(10, 15, OBJ_SARC);
|
|
if (currlevel < CRYPTSTART)
|
|
AddL1Objs(0, 0, DMAXX, DMAXY);
|
|
else
|
|
AddL5Objs(0,0,DMAXX,DMAXY);
|
|
InitRndBarrels();
|
|
}
|
|
if (leveltype == 2) {
|
|
if (QuestStatus(Q_ROCK))
|
|
InitRndLocObj5x5(1, 1, OBJ_STAND); // Rock stand
|
|
if (QuestStatus(Q_SCHAMB))
|
|
InitRndLocObj5x5(1, 1, OBJ_BOOK2R); // SCamb book
|
|
|
|
AddL2Objs(0, 0, DMAXX, DMAXY);
|
|
AddL2Torches();
|
|
if (QuestStatus(Q_BLIND)) {
|
|
if (plr[myplr]._pClass == CLASS_WARRIOR) textdef = TXT_WARBLIND;
|
|
else if (plr[myplr]._pClass == CLASS_ROGUE) textdef = TXT_ROGBLIND;
|
|
else if (plr[myplr]._pClass == CLASS_SORCEROR) textdef = TXT_SORBLIND;
|
|
else if (plr[myplr]._pClass == CLASS_MONK) textdef = TXT_MNKBLIND;
|
|
else if (plr[myplr]._pClass == CLASS_BARD) textdef = TXT_BRDBLIND;
|
|
else if (plr[myplr]._pClass == CLASS_BARBARIAN) textdef = TXT_BARBLIND;
|
|
quests[Q_BLIND]._qmsg = textdef;
|
|
AddBookLever(0, 0, DMAXX, DMAXY, setpc_x, setpc_y, setpc_x+setpc_w+1, setpc_y+setpc_h+1, textdef);
|
|
setp = LoadFileInMemSig("Levels\\L2Data\\Blind2.DUN",NULL,'STPC');
|
|
LoadMapObjs(setp, (setpc_x << 1), (setpc_y << 1));
|
|
DiabloFreePtr(setp);
|
|
}
|
|
if (QuestStatus(Q_BLOOD)) {
|
|
if (plr[myplr]._pClass == CLASS_WARRIOR) textdef = TXT_WARBLOOD;
|
|
else if (plr[myplr]._pClass == CLASS_ROGUE) textdef = TXT_ROGBLOOD;
|
|
else if (plr[myplr]._pClass == CLASS_SORCEROR) textdef = TXT_SORBLOOD;
|
|
else if (plr[myplr]._pClass == CLASS_MONK) textdef = TXT_MNKBLOOD;
|
|
else if (plr[myplr]._pClass == CLASS_BARD) textdef = TXT_BRDBLOOD;
|
|
else if (plr[myplr]._pClass == CLASS_BARBARIAN) textdef = TXT_BARBLOOD;
|
|
quests[Q_BLOOD]._qmsg = textdef;
|
|
AddBookLever(0, 0, DMAXX, DMAXY, setpc_x, setpc_y + 3, setpc_x + 2, setpc_y + 7, textdef);
|
|
AddObject(OBJ_PEDISTAL, (setpc_x << 1) + DIRTEDGED2 + 9, (setpc_y << 1) +DIRTEDGED2 + 16);
|
|
}
|
|
InitRndBarrels();
|
|
}
|
|
|
|
if (leveltype == 3) {
|
|
AddL3Objs(0, 0, DMAXX, DMAXY);
|
|
InitRndBarrels();
|
|
}
|
|
|
|
if (leveltype == 4) {
|
|
if (QuestStatus(Q_WARLORD)) {
|
|
if (plr[myplr]._pClass == CLASS_WARRIOR) textdef = TXT_WARLORD;
|
|
else if (plr[myplr]._pClass == CLASS_ROGUE) textdef = TXT_ROGLORD;
|
|
else if (plr[myplr]._pClass == CLASS_SORCEROR) textdef = TXT_SORLORD;
|
|
else if (plr[myplr]._pClass == CLASS_MONK) textdef = TXT_MNKLORD;
|
|
else if (plr[myplr]._pClass == CLASS_BARD) textdef = TXT_BRDLORD;
|
|
else if (plr[myplr]._pClass == CLASS_BARBARIAN) textdef = TXT_BARLORD;
|
|
quests[Q_WARLORD]._qmsg = textdef;
|
|
AddBookLever(0, 0, DMAXX, DMAXY, setpc_x, setpc_y, setpc_x+setpc_w, setpc_y+setpc_h, textdef);
|
|
setp = LoadFileInMemSig("Levels\\L4Data\\Warlord.DUN",NULL,'STPC');
|
|
LoadMapObjs(setp, (setpc_x << 1), (setpc_y << 1));
|
|
DiabloFreePtr(setp);
|
|
}
|
|
if (QuestStatus(Q_BETRAYER) && (gbMaxPlayers == 1)) {
|
|
AddLazStand();
|
|
}
|
|
InitRndBarrels();
|
|
AddL4Goodies();
|
|
}
|
|
|
|
InitRndLocObj(5, 10, OBJ_CHEST1);
|
|
InitRndLocObj(3, 6, OBJ_CHEST2);
|
|
InitRndLocObj(1, 5, OBJ_CHEST3);
|
|
if (leveltype != 4) AddObjTraps();
|
|
if (leveltype > 1) AddChestTraps();
|
|
|
|
InitObjFlag = FALSE;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void SetMapObjects(BYTE *pMap, int startx, int starty)
|
|
{
|
|
int i,j,rw,rh;
|
|
int ox,oy;
|
|
BYTE *lm, *h;
|
|
long mapoff;
|
|
int ot;
|
|
bool fileload[MAXOBJFILES];
|
|
char filestr[32];
|
|
|
|
ClrAllObjects();
|
|
InitObjFlag = TRUE;
|
|
|
|
for (i = 0; i < MAXOBJFILES; ++i) fileload[i] = FALSE;
|
|
|
|
// Load all must obj gfx for leveltype
|
|
for (i = 0; AllObjects[i].oload != -1; ++i) {
|
|
if ((AllObjects[i].oload == OBJMUST) && (leveltype == AllObjects[i].olvltype))
|
|
fileload[AllObjects[i].ofindex] = true;
|
|
}
|
|
|
|
lm = pMap;
|
|
rw = *lm;
|
|
lm += 2;
|
|
rh = *lm;
|
|
// Skip map + height word
|
|
mapoff = ((rw * rh) << 1) + 2;
|
|
// Convert to index mini tile level instead of mega
|
|
rw = rw << 1;
|
|
rh = rh << 1;
|
|
// Skip treasure and monster map
|
|
mapoff += ((rw * rh) << 2);
|
|
lm += mapoff;
|
|
|
|
h = lm;
|
|
for (j = 0; j < rh; ++j) {
|
|
for (i = 0; i < rw; ++i) {
|
|
if (*lm != 0) {
|
|
ot = *lm;
|
|
ot = ObjTypeConv[ot];
|
|
fileload[AllObjects[ot].ofindex] = TRUE;
|
|
}
|
|
lm+=2;
|
|
}
|
|
}
|
|
|
|
app_assert(numobjfiles == 0);
|
|
for (i = 0; i < MAXOBJFILES; ++i) {
|
|
if (fileload[i]) {
|
|
ObjFileList[numobjfiles] = i;
|
|
sprintf(filestr, "Objects\\%s.CEL", ObjMasterFList[i]);
|
|
app_assert(! pObjCels[numobjfiles]);
|
|
pObjCels[numobjfiles] = LoadFileInMemSig(filestr,NULL,'OGFX');
|
|
++numobjfiles;
|
|
}
|
|
}
|
|
|
|
lm = h;
|
|
for (j = 0; j < rh; ++j) {
|
|
for (i = 0; i < rw; ++i) {
|
|
if (*lm != 0) {
|
|
ot = *lm;
|
|
ox = i + DIRTEDGED2 + startx;
|
|
oy = j + DIRTEDGED2 + starty;
|
|
AddObject(ObjTypeConv[ot], ox, oy);
|
|
}
|
|
lm+=2;
|
|
}
|
|
}
|
|
|
|
InitObjFlag = FALSE;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void DeleteObject(int oi, int i)
|
|
{
|
|
int ox,oy;
|
|
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
ox = object[oi]._ox;
|
|
oy = object[oi]._oy;
|
|
dObject[ox][oy] = 0;
|
|
|
|
objectavail[MAXOBJECTS - numobjects] = oi;
|
|
--numobjects;
|
|
if ((numobjects > 0) && (i != numobjects)) {
|
|
objectactive[i] = objectactive[numobjects];
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void SetupObject(int i, int x, int y, int ot)
|
|
{
|
|
int ai, j;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._otype = ot;
|
|
object[i]._ox = x;
|
|
object[i]._oy = y;
|
|
|
|
ai = AllObjects[ot].ofindex;
|
|
for (j = 0; ObjFileList[j] != ai; ++j);
|
|
object[i]._oAnimData = pObjCels[j];
|
|
|
|
object[i]._oAnimFlag = AllObjects[ot].oAnimFlag;
|
|
if (object[i]._oAnimFlag) {
|
|
object[i]._oAnimDelay = AllObjects[ot].oAnimDelay;
|
|
object[i]._oAnimCnt = random(146,AllObjects[ot].oAnimDelay);
|
|
object[i]._oAnimLen = AllObjects[ot].oAnimLen;
|
|
object[i]._oAnimFrame = random(146,AllObjects[ot].oAnimLen-1) + 1;
|
|
} else {
|
|
object[i]._oAnimDelay = 1000;
|
|
object[i]._oAnimCnt = 0;
|
|
object[i]._oAnimLen = AllObjects[ot].oAnimLen;
|
|
object[i]._oAnimFrame = AllObjects[ot].oAnimDelay;
|
|
}
|
|
|
|
object[i]._oAnimWidth = AllObjects[ot].oAnimWidth;
|
|
object[i]._oSolidFlag = AllObjects[ot].oSolidFlag;
|
|
object[i]._oMissFlag = AllObjects[ot].oMissFlag;
|
|
object[i]._oLight = AllObjects[ot].oLightFlag;
|
|
object[i]._oDelFlag = FALSE;
|
|
object[i]._oBreak = AllObjects[ot].oBreak;
|
|
object[i]._oSelFlag = AllObjects[ot].oSelFlag;
|
|
object[i]._oPreFlag = FALSE;
|
|
object[i]._oTrapFlag = FALSE;
|
|
object[i]._oDoorFlag = FALSE;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void SetObjMapRange(int i, int x1, int y1, int x2, int y2, int v)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oVar1 = x1;
|
|
object[i]._oVar2 = y1;
|
|
object[i]._oVar3 = x2;
|
|
object[i]._oVar4 = y2;
|
|
object[i]._oVar8 = v;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void SetBookMsg(int i, int msg)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oVar7 = msg;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddL1Door(int i, int x, int y, int ot)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oDoorFlag = TRUE;
|
|
if (ot == OBJ_L1DOORL) {
|
|
object[i]._oVar1 = dPiece[x][y];
|
|
object[i]._oVar2 = dPiece[x][y-1];
|
|
} else {
|
|
object[i]._oVar1 = dPiece[x][y];
|
|
object[i]._oVar2 = dPiece[x-1][y];
|
|
}
|
|
object[i]._oVar4 = DOOR_CLOSED;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddSCambBook(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
// if (quests[Q_SCHAMB]._qactive != QUEST_NOTACTIVE) {
|
|
// object[i]._oSelFlag = OSEL_NONE;
|
|
// object[i]._oAnimFrame = 6;
|
|
// }
|
|
object[i]._oVar1 = setpc_x;
|
|
object[i]._oVar2 = setpc_y;
|
|
object[i]._oVar3 = setpc_x+setpc_w+1;
|
|
object[i]._oVar4 = setpc_y+setpc_h+1;
|
|
object[i]._oVar6 = object[i]._oAnimFrame + 1;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddChest(int i, int t)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (random(147,2) == 0) object[i]._oAnimFrame += 3; // Left or right
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
// Set # chest items. If a setlevel then so to max items.
|
|
switch(t) {
|
|
case OBJ_CHEST1:
|
|
case OBJ_TCHEST1:
|
|
if (setlevel) object[i]._oVar1 = 1;
|
|
else object[i]._oVar1 = random(147,2);
|
|
break;
|
|
case OBJ_CHEST2:
|
|
case OBJ_TCHEST2:
|
|
if (setlevel) object[i]._oVar1 = 2;
|
|
else object[i]._oVar1 = random(147,3);
|
|
break;
|
|
case OBJ_CHEST3:
|
|
case OBJ_TCHEST3:
|
|
if (setlevel) object[i]._oVar1 = 3;
|
|
else object[i]._oVar1 = random(147,4);
|
|
break;
|
|
}
|
|
object[i]._oVar2 = random(147,8);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddL2Door(int i, int x, int y, int ot)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oDoorFlag = TRUE;
|
|
if (ot == OBJ_L2DOORL) ObjSetMicro(x, y, 538);
|
|
else ObjSetMicro(x, y, 540);
|
|
object[i]._oVar4 = DOOR_CLOSED;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddL3Door(int i, int x, int y, int ot)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oDoorFlag = TRUE;
|
|
if (ot == OBJ_L3DOORL) ObjSetMicro(x, y, 531);
|
|
else ObjSetMicro(x, y, 534);
|
|
object[i]._oVar4 = DOOR_CLOSED;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddSarc(int i)
|
|
{
|
|
int x,y;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
x = object[i]._ox;
|
|
y = object[i]._oy - 1;
|
|
dObject[x][y] = -1 - (char)i;
|
|
object[i]._oVar1 = random(153,10);
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
if (object[i]._oVar1 >= 8) object[i]._oVar2 = PreSpawnSkeleton();
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddFlameTrap(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oVar1 = trapid; // Set trap id
|
|
object[i]._oVar2 = 0; // Trap active
|
|
object[i]._oVar3 = trapdir; // Horizontal, Vertical, or none
|
|
object[i]._oVar4 = 0; // Init to off
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddFlameLvr(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oVar1 = trapid; // Set trap id
|
|
object[i]._oVar2 = OBJ_FLAMEHOLE; // Trap active
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddTrap(int i, int ot)
|
|
{
|
|
int mt, tdiff;
|
|
|
|
// Difficulty
|
|
tdiff = (currlevel / 3) + 1;
|
|
// Temp hack trap JKE 7/30
|
|
if (currlevel > 16) tdiff = ((currlevel-4)/3) + 1;
|
|
if (currlevel > 20) tdiff = ((currlevel-8)/3) + 1;
|
|
|
|
// Missile type
|
|
mt = random(148,tdiff);
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (mt == 0) object[i]._oVar3 = MIT_ARROW;
|
|
if (mt == 1) object[i]._oVar3 = MIT_FIREBOLT;
|
|
if (mt == 2) object[i]._oVar3 = MIT_LIGHTCTRL;
|
|
object[i]._oVar4 = 0; // Trap active
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddObjLight(int i, int r)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (InitObjFlag) {
|
|
DoLighting(object[i]._ox, object[i]._oy, r, -1);
|
|
object[i]._oVar1 = -1;
|
|
} else object[i]._oVar1 = 0;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddBarrel(int i, int ot)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
//object[i]._oVar1 = random(149,5) + 5; // Barrel hit points
|
|
object[i]._oVar1 = 0;
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
object[i]._oVar2 = random(149,10); // What is inside
|
|
object[i]._oVar3 = random(149,3); // if item, useful or not
|
|
if (object[i]._oVar2 >= 8)
|
|
object[i]._oVar4 = PreSpawnSkeleton(); // Get monster index if one will pop out
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddShrine(int i)
|
|
{
|
|
int st, j;
|
|
bool slist[NUMSHRINETYPES];
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oPreFlag = TRUE;
|
|
for (j = 0; j < NUMSHRINETYPES; ++j) {
|
|
if ((currlevel >= shrineminlvl[j]) && (currlevel <= shrinemaxlvl[j]))
|
|
slist[j] = true;
|
|
else
|
|
slist[j] = false;
|
|
if ((gbMaxPlayers != 1) && (shrineavail[j] == SHRINE_SINGLE)) slist[j] = false;
|
|
if ((gbMaxPlayers == 1) && (shrineavail[j] == SHRINE_MULTI)) slist[j] = false;
|
|
}
|
|
|
|
// Choose shrine type
|
|
do {
|
|
st = random(150,NUMSHRINETYPES);
|
|
} while (!slist[st]);
|
|
|
|
object[i]._oVar1 = st;
|
|
|
|
if (random(150,2)) {
|
|
object[i]._oAnimFrame = 12;
|
|
object[i]._oAnimLen = 22;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddBookcase(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
object[i]._oPreFlag = TRUE;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddBookstand(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddBloodFtn(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddPurifyingFountain(int i)
|
|
{
|
|
int x, y;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
x = object[i]._ox;
|
|
y = object[i]._oy;
|
|
dObject[x][y-1] = -1 - (char)i;
|
|
dObject[x-1][y] = -1 - (char)i;
|
|
dObject[x-1][y-1] = -1 - (char)i;
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddArmorStand(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (!armorFlag) {
|
|
//A functional armor stand has already been placed
|
|
//Only place non-functional empty stands
|
|
object[i]._oAnimFlag = 2;
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
}
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddGoatShrine(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddCauldron(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddMurkyFountain(int i)
|
|
{
|
|
int x, y;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
x = object[i]._ox;
|
|
y = object[i]._oy;
|
|
dObject[x][y-1] = -1 - (char)i;
|
|
dObject[x-1][y] = -1 - (char)i;
|
|
dObject[x-1][y-1] = -1 - (char)i;
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddTearFountain(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddDecap(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
object[i]._oAnimFrame = random(151,8) + 1;
|
|
object[i]._oPreFlag = TRUE;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
const void AddVilebook(int i)
|
|
{
|
|
if ((setlevel) && (setlvlnum == SL_VILEBETRAYER)) {
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oAnimFrame = 4;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
const void AddMagicCircle(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
object[i]._oPreFlag = TRUE;
|
|
object[i]._oVar6 = OBJNOWARP;
|
|
object[i]._oVar5 = OBJWARP1;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
const void AddBrnCross(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
const void AddPedistal(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oVar1 = setpc_x;
|
|
object[i]._oVar2 = setpc_y;
|
|
object[i]._oVar3 = setpc_x + setpc_w;
|
|
object[i]._oVar4 = setpc_y + setpc_h;
|
|
}
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
int const StoryText[3][3] = {
|
|
{ TXT_BOOK11, TXT_BOOK12, TXT_BOOK13 },
|
|
{ TXT_BOOK21, TXT_BOOK22, TXT_BOOK23 },
|
|
{ TXT_BOOK31, TXT_BOOK32, TXT_BOOK33 } };
|
|
|
|
static void AddStoryBook(int i)
|
|
{
|
|
// Use the last level seed to determine book types (which of 3)
|
|
SetRndSeed(glSeedTbl[16]);
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oVar1 = random(0, 3);
|
|
if (currlevel == STORY_BOOK1_LEVEL) object[i]._oVar2 = StoryText[object[i]._oVar1][0];
|
|
else if (currlevel == STORY_BOOK2_LEVEL) object[i]._oVar2 = StoryText[object[i]._oVar1][1];
|
|
else if (currlevel == STORY_BOOK3_LEVEL) object[i]._oVar2 = StoryText[object[i]._oVar1][2];
|
|
object[i]._oVar3 = (object[i]._oVar1 * 3) + (currlevel >> 2) - 1;
|
|
|
|
object[i]._oAnimFrame = 5 - (object[i]._oVar1 << 1);
|
|
object[i]._oVar4 = object[i]._oAnimFrame + 1;
|
|
}
|
|
|
|
static void addskulkenbook (int i, int number) // number is the text to associate JKE
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (number > 5)
|
|
{
|
|
object[i]._oVar8 = number;
|
|
switch (object[i]._oVar8)
|
|
{
|
|
case 6:
|
|
// object[i]._oVar2 = TXT_SPELL1;
|
|
|
|
if (plr[myplr]._pClass == CLASS_WARRIOR) object[i]._oVar2 = TXT_SPELL1;
|
|
else if (plr[myplr]._pClass == CLASS_ROGUE) object[i]._oVar2 = TXT_R_SPELL1;
|
|
else if (plr[myplr]._pClass == CLASS_SORCEROR) object[i]._oVar2 = TXT_S_SPELL1;
|
|
else if (plr[myplr]._pClass == CLASS_MONK) object[i]._oVar2 = TXT_M_SPELL1;
|
|
else if (plr[myplr]._pClass == CLASS_BARD) object[i]._oVar2 = TXT_B_SPELL1;
|
|
else if (plr[myplr]._pClass == CLASS_BARBARIAN) object[i]._oVar2 = TXT_C_SPELL1;
|
|
break;
|
|
|
|
case 7:
|
|
// object[i]._oVar2 = TXT_SPELL2;
|
|
|
|
if (plr[myplr]._pClass == CLASS_WARRIOR) object[i]._oVar2 = TXT_SPELL2;
|
|
else if (plr[myplr]._pClass == CLASS_ROGUE) object[i]._oVar2 = TXT_R_SPELL2;
|
|
else if (plr[myplr]._pClass == CLASS_SORCEROR) object[i]._oVar2 = TXT_S_SPELL2;
|
|
else if (plr[myplr]._pClass == CLASS_MONK) object[i]._oVar2 = TXT_M_SPELL2;
|
|
else if (plr[myplr]._pClass == CLASS_BARD) object[i]._oVar2 = TXT_B_SPELL2;
|
|
else if (plr[myplr]._pClass == CLASS_BARBARIAN) object[i]._oVar2 = TXT_C_SPELL2;
|
|
break;
|
|
|
|
case 8:
|
|
// object[i]._oVar2 = TXT_SPELL3;
|
|
|
|
if (plr[myplr]._pClass == CLASS_WARRIOR) object[i]._oVar2 = TXT_SPELL3;
|
|
else if (plr[myplr]._pClass == CLASS_ROGUE) object[i]._oVar2 = TXT_R_SPELL3;
|
|
else if (plr[myplr]._pClass == CLASS_SORCEROR) object[i]._oVar2 = TXT_S_SPELL3;
|
|
else if (plr[myplr]._pClass == CLASS_MONK) object[i]._oVar2 = TXT_M_SPELL3;
|
|
else if (plr[myplr]._pClass == CLASS_BARD) object[i]._oVar2 = TXT_B_SPELL3;
|
|
else if (plr[myplr]._pClass == CLASS_BARBARIAN) object[i]._oVar2 = TXT_C_SPELL3;
|
|
break;
|
|
}
|
|
|
|
object[i]._oVar1 = 1;
|
|
object[i]._oVar3 = 15;
|
|
|
|
object[i]._oAnimFrame = 5 - ((object[i]._oVar1) << 1);
|
|
object[i]._oVar4 = object[i]._oAnimFrame + 1;
|
|
}
|
|
else
|
|
{
|
|
object[i]._oVar1 = 1;
|
|
object[i]._oVar2 = TXT_SKULLJRNL1 + number;
|
|
|
|
object[i]._oVar3 = 9 + number;
|
|
|
|
object[i]._oAnimFrame = 5 - (object[i]._oVar1 << 1);
|
|
object[i]._oVar4 = object[i]._oAnimFrame + 1;
|
|
object[i]._oVar8 = 0;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddWeaponRack(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (!weaponFlag) {
|
|
//A functional weapon rack has already been placed
|
|
//Only place non-functional empty racks
|
|
object[i]._oAnimFlag = 2;
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
}
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddTorturedBody(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oRndSeed = GetRndSeed();
|
|
object[i]._oAnimFrame = random(0, 4) + 1;
|
|
object[i]._oPreFlag = TRUE;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
* GetRndObjLoc
|
|
*
|
|
* Gets a x by y empty location for object placement
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void GetRndObjLoc(int randarea, int &xx, int &yy)
|
|
{
|
|
int i,j;
|
|
bool failed;
|
|
|
|
if (randarea) {
|
|
int tries = 0;
|
|
do {
|
|
if (++tries > 1000 && randarea > 1)
|
|
--randarea;
|
|
xx = random(0, DMAXX);
|
|
yy = random(0, DMAXY);
|
|
failed = false;
|
|
for (i = 0; i < randarea && !failed; ++i)
|
|
for (j = 0; j < randarea && !failed; ++j)
|
|
failed = !RndLocOk(xx + i, yy + j);
|
|
} while (failed);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddMushPatch()
|
|
{
|
|
int x,y;
|
|
if (numobjects < MAXOBJECTS) {
|
|
int i = objectavail[0];
|
|
|
|
GetRndObjLoc(5, x, y);
|
|
dObject[x+1][y+1] = -1 - (char)i;
|
|
dObject[x+2][y+1] = -1 - (char)i;
|
|
dObject[x+1][y+2] = -1 - (char)i;
|
|
AddObject(OBJ_MUSHPATCH, x+2, y+2);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void AddSlainHero()
|
|
{
|
|
int x, y;
|
|
|
|
GetRndObjLoc(5, x, y);
|
|
AddObject(OBJ_SLAINHERO, x+2, y+2);
|
|
}
|
|
|
|
|
|
void AddSkulkenObject(int ot, int number, int ox, int oy)
|
|
{
|
|
int oi; // Standard setup JKE
|
|
|
|
if (numobjects < MAXOBJECTS) {
|
|
oi = objectavail[0];
|
|
objectavail[0] = objectavail[MAXOBJECTS - numobjects - 1];
|
|
objectactive[numobjects] = oi;
|
|
dObject[ox][oy] = (char)oi + 1;
|
|
// Standard init
|
|
SetupObject(oi, ox, oy, ot);
|
|
|
|
addskulkenbook(oi, number);
|
|
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
object[oi]._oAnimWidth2 = (object[oi]._oAnimWidth - 64) >> 1;
|
|
++numobjects;
|
|
}
|
|
}
|
|
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void AddObject(int ot, int ox, int oy)
|
|
{
|
|
int oi;
|
|
|
|
if (numobjects < MAXOBJECTS) {
|
|
oi = objectavail[0];
|
|
objectavail[0] = objectavail[MAXOBJECTS - numobjects - 1];
|
|
objectactive[numobjects] = oi;
|
|
dObject[ox][oy] = (char)oi + 1;
|
|
// Standard init
|
|
SetupObject(oi, ox, oy, ot);
|
|
// Bonus inits
|
|
switch (ot) {
|
|
case OBJ_L1LIGHT :
|
|
//AddObjLight(oi, 10);
|
|
AddObjLight(oi, 5);
|
|
break;
|
|
case OBJ_CANDLE1 :
|
|
case OBJ_CANDLE2 :
|
|
case OBJ_SKFIRE :
|
|
case OBJ_BOOKCANDLE:
|
|
AddObjLight(oi, 5);
|
|
break;
|
|
case OBJ_STORYCANDLE:
|
|
AddObjLight(oi, 3);
|
|
break;
|
|
case OBJ_TORCHL:
|
|
case OBJ_TORCHR:
|
|
case OBJ_TORCHL2:
|
|
case OBJ_TORCHR2:
|
|
AddObjLight(oi, 8);
|
|
break;
|
|
case OBJ_L1DOORL :
|
|
case OBJ_L1DOORR :
|
|
AddL1Door(oi, ox, oy, ot);
|
|
break;
|
|
case OBJ_L2DOORL :
|
|
case OBJ_L2DOORR :
|
|
AddL2Door(oi, ox, oy, ot);
|
|
break;
|
|
case OBJ_L3DOORL :
|
|
case OBJ_L3DOORR :
|
|
AddL3Door(oi, ox, oy, ot);
|
|
break;
|
|
case OBJ_BOOK2R:
|
|
AddSCambBook(oi);
|
|
break;
|
|
case OBJ_CHEST1:
|
|
case OBJ_CHEST2:
|
|
case OBJ_CHEST3:
|
|
case OBJ_TCHEST1:
|
|
case OBJ_TCHEST2:
|
|
case OBJ_TCHEST3:
|
|
AddChest(oi, ot);
|
|
break;
|
|
case OBJ_SARC:
|
|
AddSarc(oi);
|
|
break;
|
|
case OBJ_FLAMEHOLE:
|
|
AddFlameTrap(oi);
|
|
break;
|
|
case OBJ_FLAMELVR:
|
|
AddFlameLvr(oi);
|
|
break;
|
|
case OBJ_WATER:
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
object[oi]._oAnimFrame = 1;
|
|
break;
|
|
case OBJ_TRAPL:
|
|
case OBJ_TRAPR:
|
|
AddTrap(oi, ot);
|
|
break;
|
|
case OBJ_BARREL:
|
|
case OBJ_BARRELEX:
|
|
AddBarrel(oi, ot);
|
|
break;
|
|
case OBJ_SHRINEL:
|
|
case OBJ_SHRINER:
|
|
AddShrine(oi);
|
|
break;
|
|
case OBJ_BOOKCASEL:
|
|
case OBJ_BOOKCASER:
|
|
AddBookcase(oi);
|
|
break;
|
|
case OBJ_SKELBOOK:
|
|
case OBJ_BOOKSTAND:
|
|
AddBookstand(oi);
|
|
break;
|
|
case OBJ_BLOODFTN:
|
|
AddBloodFtn(oi);
|
|
break;
|
|
case OBJ_DECAP:
|
|
AddDecap(oi);
|
|
break;
|
|
case OBJ_PURIFYINGFTN:
|
|
AddPurifyingFountain(oi);
|
|
break;
|
|
case OBJ_ARMORSTAND:
|
|
case OBJ_WARARMOR:
|
|
AddArmorStand(oi);
|
|
break;
|
|
case OBJ_GOATSHRINE:
|
|
AddGoatShrine(oi);
|
|
break;
|
|
case OBJ_CAULDRON:
|
|
AddCauldron(oi);
|
|
break;
|
|
case OBJ_MURKYFTN:
|
|
AddMurkyFountain(oi);
|
|
break;
|
|
case OBJ_TEARFTN:
|
|
AddTearFountain(oi);
|
|
break;
|
|
case OBJ_BOOK2L:
|
|
AddVilebook(oi);
|
|
break;
|
|
case OBJ_MCIRCLE1:
|
|
case OBJ_MCIRCLE2:
|
|
AddMagicCircle(oi);
|
|
break;
|
|
case OBJ_STORYBOOK:
|
|
AddStoryBook(oi);
|
|
break;
|
|
case OBJ_TBCROSS:
|
|
case OBJ_BCROSS:
|
|
AddBrnCross(oi);
|
|
AddObjLight(oi, 5);
|
|
break;
|
|
case OBJ_PEDISTAL:
|
|
AddPedistal(oi);
|
|
break;
|
|
case OBJ_WARWEAP:
|
|
case OBJ_WEAPONRACK:
|
|
AddWeaponRack(oi);
|
|
break;
|
|
case OBJ_TNUDEM2:
|
|
AddTorturedBody(oi);
|
|
break;
|
|
}
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
object[oi]._oAnimWidth2 = (object[oi]._oAnimWidth - 64) >> 1;
|
|
++numobjects;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void Obj_Light(int i, int lr)
|
|
{
|
|
int ox, oy;
|
|
int dx, dy, p, tr;
|
|
bool turnon = false;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oVar1 == -1) return;
|
|
|
|
ox = object[i]._ox;
|
|
oy = object[i]._oy;
|
|
tr = lr + PLRLRAD;
|
|
if (lightflag == 0) {
|
|
for (p = 0; (p < MAX_PLRS) && (!turnon); ++p) {
|
|
if (!plr[p].plractive) continue;
|
|
if (currlevel != plr[p].plrlevel) continue;
|
|
dx = abs(plr[p]._px - ox);
|
|
dy = abs(plr[p]._py - oy);
|
|
if ((dx < tr) && (dy < tr)) turnon = true;
|
|
}
|
|
}
|
|
if (turnon) {
|
|
if (object[i]._oVar1 == 0) object[i]._olid = AddLight (ox, oy, lr);
|
|
object[i]._oVar1 = 1;
|
|
} else {
|
|
if (object[i]._oVar1 == 1) AddUnLight(object[i]._olid);
|
|
object[i]._oVar1 = 0;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void Obj_Circle(int i)
|
|
{
|
|
int px, py, ox, oy;
|
|
int v1, v2, v3;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
ox = object[i]._ox;
|
|
oy = object[i]._oy;
|
|
px = plr[myplr]._px;
|
|
py = plr[myplr]._py;
|
|
if ((px == ox) && (py == oy)) {
|
|
if (object[i]._otype == OBJ_MCIRCLE1) object[i]._oAnimFrame = 2;
|
|
if (object[i]._otype == OBJ_MCIRCLE2) object[i]._oAnimFrame = 4;
|
|
if ((ox == 45) && (oy == 47)) object[i]._oVar6 = OBJWARP2;
|
|
else if ((ox == 26) && (oy == 46)) object[i]._oVar6 = OBJWARP1;
|
|
else object[i]._oVar6 = OBJNOWARP;
|
|
if ((ox == 35) && (oy == 36) && object[i]._oVar5 == OBJWARP3) {
|
|
object[i]._oVar6 = OBJDONEWARP;
|
|
v1 = 35;
|
|
v2 = 46;
|
|
ObjChangeMapResync(object[i]._oVar1, object[i]._oVar2, object[i]._oVar3, object[i]._oVar4);
|
|
if (quests[Q_BETRAYER]._qactive == QUEST_NOTDONE)
|
|
quests[Q_BETRAYER]._qvar1 = 4;
|
|
v3 = dPiece[v1][v2];
|
|
//Cast phase
|
|
AddMissile(plr[myplr]._px, plr[myplr]._py, v1, v2, plr[myplr]._pdir, MIT_PHASE, MI_ENEMYMONST, myplr, 0, 0);
|
|
void TrackInit(BOOL bMouseDown);
|
|
TrackInit(FALSE);
|
|
// drb.patch1.start.1/24/97
|
|
// static BYTE sgbMouseDown;
|
|
extern BYTE sgbMouseDown;
|
|
// drb.patch1.end.1/24/97
|
|
sgbMouseDown = FALSE;
|
|
ReleaseCapture();
|
|
ClrPlrPath(myplr);
|
|
void StartStand(int, int);
|
|
StartStand(myplr, 0);
|
|
}
|
|
}
|
|
else {
|
|
if (object[i]._otype == OBJ_MCIRCLE1) object[i]._oAnimFrame = 1;
|
|
if (object[i]._otype == OBJ_MCIRCLE2) object[i]._oAnimFrame = 3;
|
|
object[i]._oVar6 = OBJNOWARP;
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void Obj_StopAnim(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oAnimFrame == object[i]._oAnimLen) {
|
|
object[i]._oAnimCnt = 0;
|
|
object[i]._oAnimDelay = 1000;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void Obj_Door(int i)
|
|
{
|
|
int dx, dy;
|
|
bool dok;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oVar4 == DOOR_CLOSED) {
|
|
object[i]._oSelFlag = OSEL_ALL;
|
|
object[i]._oMissFlag = FALSE;
|
|
} else {
|
|
dx = object[i]._ox;
|
|
dy = object[i]._oy;
|
|
dok = (dMonster[dx][dy] == 0);
|
|
dok = dok && (dItem[dx][dy] == 0);
|
|
dok = dok && (dDead[dx][dy] == 0);
|
|
dok = dok && (dPlayer[dx][dy] == 0);
|
|
object[i]._oSelFlag = OSEL_TOP;
|
|
if (dok) object[i]._oVar4 = DOOR_OPEN;
|
|
else object[i]._oVar4 = DOOR_BLOCKED;
|
|
object[i]._oMissFlag = TRUE;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void Obj_Sarc(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oAnimFrame == object[i]._oAnimLen) object[i]._oAnimFlag = FALSE;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void ActivateTrapLine(int ttype, int tid)
|
|
{
|
|
int i, oi;
|
|
|
|
for (i = 0; i < numobjects; ++i) {
|
|
oi = objectactive[i];
|
|
if ((object[oi]._otype == ttype) && (object[oi]._oVar1 == tid)) {
|
|
object[oi]._oVar4 = 1;
|
|
object[oi]._oAnimFlag = TRUE;
|
|
object[oi]._oAnimDelay = 1;
|
|
object[oi]._olid = AddLight (object[oi]._ox, object[oi]._oy, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void Obj_FlameTrap(int i)
|
|
{
|
|
int xp,yp;
|
|
int j;
|
|
|
|
// Is trap active?
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oVar2 != 0) {
|
|
// Not active, try dying down
|
|
if (object[i]._oVar4 != 0) {
|
|
--object[i]._oAnimFrame;
|
|
if (object[i]._oAnimFrame == 1) {
|
|
object[i]._oVar4 = 0;
|
|
AddUnLight(object[i]._olid);
|
|
} else {
|
|
if (object[i]._oAnimFrame <= 4) ChangeLightRadius(object[i]._olid, object[i]._oAnimFrame);
|
|
}
|
|
}
|
|
} else {
|
|
// Active so continue
|
|
// Not on?
|
|
if (object[i]._oVar4 == 0) {
|
|
if (object[i]._oVar3 == TRAP_VERT) {
|
|
xp = object[i]._ox-2;
|
|
yp = object[i]._oy;
|
|
for (j = 0; j < 5; ++j) {
|
|
if ((dPlayer[xp][yp] != 0) || (dMonster[xp][yp] != 0))
|
|
object[i]._oVar4 = 1;
|
|
++xp;
|
|
}
|
|
} else {
|
|
xp = object[i]._ox;
|
|
yp = object[i]._oy-2;
|
|
for (j = 0; j < 5; ++j) {
|
|
if ((dPlayer[xp][yp] != 0) || (dMonster[xp][yp] != 0))
|
|
object[i]._oVar4 = 1;
|
|
++yp;
|
|
}
|
|
}
|
|
if (object[i]._oVar4 != 0) ActivateTrapLine(object[i]._otype, object[i]._oVar1);
|
|
} else {
|
|
if (object[i]._oAnimFrame == object[i]._oAnimLen) object[i]._oAnimFrame = 11;
|
|
if (object[i]._oAnimFrame <= 5) ChangeLightRadius(object[i]._olid, object[i]._oAnimFrame);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void Obj_Trap(int i)
|
|
{
|
|
int oti;
|
|
bool otrig = false;
|
|
int sx, sy, dx, dy;
|
|
int x, y;
|
|
int ax, ay;
|
|
int mdir;
|
|
|
|
// Triggered?
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oVar4 == 0) {
|
|
oti = dObject[object[i]._oVar1][object[i]._oVar2] - 1;
|
|
switch (object[oti]._otype) {
|
|
case OBJ_CHEST1:
|
|
case OBJ_CHEST2:
|
|
case OBJ_CHEST3:
|
|
case OBJ_SWITCHSKL:
|
|
case OBJ_LEVER :
|
|
case OBJ_SARC:
|
|
if (object[oti]._oSelFlag == OSEL_NONE) otrig = true;
|
|
break;
|
|
case OBJ_L1DOORL :
|
|
case OBJ_L1DOORR :
|
|
case OBJ_L2DOORL :
|
|
case OBJ_L2DOORR :
|
|
case OBJ_L3DOORL :
|
|
case OBJ_L3DOORR :
|
|
if (object[oti]._oVar4 != DOOR_CLOSED) otrig = true;
|
|
break;
|
|
}
|
|
if (otrig) {
|
|
object[i]._oVar4 = 1;
|
|
sx = object[i]._ox;
|
|
sy = object[i]._oy;
|
|
dx = object[oti]._ox;
|
|
dy = object[oti]._oy;
|
|
ax = dx;
|
|
ay = dy;
|
|
for (y = ay-1; y <= ay+1; ++y) {
|
|
for (x = ax-1; x <= ax+1; ++x) {
|
|
if (dPlayer[x][y] != 0) {
|
|
dx = x;
|
|
dy = y;
|
|
}
|
|
}
|
|
}
|
|
if (!deltaload) {
|
|
mdir = GetDirection(sx, sy, dx, dy);
|
|
AddMissile(sx, sy, dx, dy, mdir, object[i]._oVar3, MI_ENEMYPLR, -1, 0, 0);
|
|
PlaySfxLoc(IS_TRAP, object[oti]._ox, object[oti]._oy);
|
|
}
|
|
object[oti]._oTrapFlag = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void Obj_BCrossDamage(int i)
|
|
{
|
|
int resist;
|
|
int damage[4] = { 6, 8, 10, 12 };
|
|
|
|
if (plr[myplr]._pmode != PM_DEATH) {
|
|
//Check for fire resistance. If resistance, adjust damage accordingly.
|
|
resist = plr[myplr]._pFireResist;
|
|
if (resist > 0) damage[leveltype-1] -= (damage[leveltype-1] * resist) / 100;
|
|
//Is the player in the fire?
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if ((plr[myplr]._px == object[i]._ox) && (plr[myplr]._py == object[i]._oy-1)) {
|
|
//Subtract damage
|
|
plr[myplr]._pHitPoints -= damage[leveltype-1];
|
|
plr[myplr]._pHPBase -= damage[leveltype-1];
|
|
//Check if player is dead
|
|
if ((plr[myplr]._pHitPoints >> HP_SHIFT) <= 0) {
|
|
// rjs - manashld fix? - SetPlayerHitPoints(myplr, 0);
|
|
StartPlrKill(myplr, FALSE);
|
|
} else {
|
|
//Play pain sfx
|
|
if (plr[myplr]._pClass == CLASS_WARRIOR) PlaySfxLoc(PS_WARR68, plr[myplr]._px, plr[myplr]._py);
|
|
#if !IS_VERSION(SHAREWARE)
|
|
else if (plr[myplr]._pClass == CLASS_ROGUE) PlaySfxLoc(PS_ROGUE68, plr[myplr]._px, plr[myplr]._py);
|
|
else if (plr[myplr]._pClass == CLASS_SORCEROR) PlaySfxLoc(PS_MAGE68, plr[myplr]._px, plr[myplr]._py);
|
|
else if (plr[myplr]._pClass == CLASS_MONK) PlaySfxLoc(PS_MONK68, plr[myplr]._px, plr[myplr]._py);
|
|
else if (plr[myplr]._pClass == CLASS_BARD) PlaySfxLoc(PS_BARD68, plr[myplr]._px, plr[myplr]._py);
|
|
else if (plr[myplr]._pClass == CLASS_BARBARIAN) PlaySfxLoc(PS_BARBARIAN68, plr[myplr]._px, plr[myplr]._py);
|
|
#endif
|
|
}
|
|
drawhpflag = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void ProcessObjects ()
|
|
{
|
|
int i, oi;
|
|
|
|
for (i = 0; i < numobjects; ++i) {
|
|
oi = objectactive[i];
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
switch (object[oi]._otype) {
|
|
case OBJ_L1LIGHT :
|
|
Obj_Light(oi, 10);
|
|
break;
|
|
case OBJ_CANDLE2 :
|
|
case OBJ_SKFIRE :
|
|
case OBJ_BOOKCANDLE:
|
|
Obj_Light(oi, 5);
|
|
break;
|
|
case OBJ_STORYCANDLE:
|
|
Obj_Light(oi, 3);
|
|
break;
|
|
case OBJ_CRUX1 :
|
|
case OBJ_CRUX2 :
|
|
case OBJ_CRUX3 :
|
|
case OBJ_BARREL:
|
|
case OBJ_BARRELEX:
|
|
case OBJ_SHRINEL:
|
|
case OBJ_SHRINER:
|
|
Obj_StopAnim(oi);
|
|
break;
|
|
case OBJ_L1DOORL :
|
|
case OBJ_L1DOORR :
|
|
case OBJ_L2DOORL :
|
|
case OBJ_L2DOORR :
|
|
case OBJ_L3DOORL :
|
|
case OBJ_L3DOORR :
|
|
Obj_Door(oi);
|
|
break;
|
|
case OBJ_TORCHL:
|
|
case OBJ_TORCHR:
|
|
case OBJ_TORCHL2:
|
|
case OBJ_TORCHR2:
|
|
Obj_Light(oi, 8);
|
|
break;
|
|
case OBJ_SARC:
|
|
Obj_Sarc(oi);
|
|
break;
|
|
case OBJ_FLAMEHOLE:
|
|
Obj_FlameTrap(oi);
|
|
break;
|
|
case OBJ_TRAPL:
|
|
case OBJ_TRAPR:
|
|
Obj_Trap(oi);
|
|
break;
|
|
case OBJ_MCIRCLE1:
|
|
case OBJ_MCIRCLE2:
|
|
Obj_Circle(oi);
|
|
break;
|
|
case OBJ_TBCROSS:
|
|
case OBJ_BCROSS:
|
|
Obj_Light(oi, 10);
|
|
Obj_BCrossDamage(oi);
|
|
break;
|
|
}
|
|
|
|
// Animate Objects
|
|
if (object[oi]._oAnimFlag) {
|
|
++object[oi]._oAnimCnt;
|
|
if (object[oi]._oAnimCnt >= object[oi]._oAnimDelay) {
|
|
object[oi]._oAnimCnt = 0;
|
|
++object[oi]._oAnimFrame;
|
|
if (object[oi]._oAnimFrame > object[oi]._oAnimLen) object[oi]._oAnimFrame = 1;
|
|
}
|
|
}
|
|
}
|
|
i = 0;
|
|
while (i < numobjects) {
|
|
oi = objectactive[i];
|
|
if (object[oi]._oDelFlag) {
|
|
DeleteObject(oi, i);
|
|
i = 0;
|
|
} else ++i;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void ObjSetMicro(int dx, int dy, int pn)
|
|
{
|
|
WORD *mtsource;
|
|
int t;
|
|
WORD *mt;
|
|
|
|
dPiece[dx][dy] = pn;
|
|
--pn;
|
|
mt = &(dMT2[CalcRot(dx,dy)].mt[0]);
|
|
if (leveltype != 4) {
|
|
mtsource = (WORD *)(pMiniTiles + 20*pn);
|
|
for(t = 0; t < 10; ++t)
|
|
// MiniTiles array uses opposite y direction
|
|
// hence wierd index on next line
|
|
mt[t] = mtsource[8-(t&0xe)+(t&1)];
|
|
} else {
|
|
mtsource = (WORD *)(pMiniTiles + 32*pn);
|
|
for(t = 0; t < 16; ++t)
|
|
// MiniTiles array uses opposite y direction
|
|
// hence wierd index on next line
|
|
mt[t] = mtsource[14-(t&0xe)+(t&1)];
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void ObjSetMicro12(int dx, int dy)
|
|
{
|
|
long mt1,mt2;
|
|
int pn;
|
|
|
|
pn = dPiece[dx][dy] - 1;
|
|
__asm {
|
|
mov esi,dword ptr [pMiniTiles]
|
|
xor eax,eax
|
|
mov ax,word ptr [pn]
|
|
mov ebx,20
|
|
mul ebx
|
|
add esi,eax
|
|
add esi,16
|
|
xor eax,eax
|
|
lodsw
|
|
mov word ptr [mt1],ax
|
|
lodsw
|
|
mov word ptr [mt2],ax
|
|
}
|
|
dMT2[CalcRot(dx,dy)].mt[0] = mt1 & 0xffff;
|
|
dMT2[CalcRot(dx,dy)].mt[1] = mt2 & 0xffff;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void ObjSetMini(int x, int y, int v)
|
|
{
|
|
long v1,v2,v3,v4;
|
|
int xx, yy;
|
|
|
|
__asm {
|
|
mov esi,dword ptr [pMegaTiles]
|
|
xor eax,eax
|
|
mov ax,word ptr [v];
|
|
dec eax
|
|
shl eax,3
|
|
add esi,eax
|
|
xor eax,eax
|
|
lodsw
|
|
inc eax
|
|
mov dword ptr [v1],eax
|
|
lodsw
|
|
inc eax
|
|
mov dword ptr [v2],eax
|
|
lodsw
|
|
inc eax
|
|
mov dword ptr [v3],eax
|
|
lodsw
|
|
inc eax
|
|
mov dword ptr [v4],eax
|
|
}
|
|
xx = (x << 1) + DIRTEDGED2;
|
|
yy = (y << 1) + DIRTEDGED2;
|
|
ObjSetMicro(xx, yy, v1);
|
|
ObjSetMicro(xx+1, yy, v2);
|
|
ObjSetMicro(xx, yy+1, v3);
|
|
ObjSetMicro(xx+1, yy+1, v4);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void ObjL1Special(int x1, int y1, int x2, int y2)
|
|
{
|
|
int i,j;
|
|
|
|
for (j = y1; j <= y2; ++j) {
|
|
for (i = x1; i <= x2; ++i) {
|
|
dSpecial[i][j] = 0;
|
|
// Place tops of arches
|
|
if (dPiece[i][j] == 12) dSpecial[i][j] = 1;
|
|
if (dPiece[i][j] == 11) dSpecial[i][j] = 2;
|
|
if (dPiece[i][j] == 71) dSpecial[i][j] = 1;
|
|
if (dPiece[i][j] == 259) dSpecial[i][j] = 5;
|
|
if (dPiece[i][j] == 249) dSpecial[i][j] = 2;
|
|
if (dPiece[i][j] == 325) dSpecial[i][j] = 2;
|
|
if (dPiece[i][j] == 321) dSpecial[i][j] = 1;
|
|
if (dPiece[i][j] == 255) dSpecial[i][j] = 4;
|
|
if (dPiece[i][j] == 211) dSpecial[i][j] = 1;
|
|
if (dPiece[i][j] == 344) dSpecial[i][j] = 2;
|
|
if (dPiece[i][j] == 341) dSpecial[i][j] = 1;
|
|
if (dPiece[i][j] == 331) dSpecial[i][j] = 2;
|
|
if (dPiece[i][j] == 418) dSpecial[i][j] = 1;
|
|
if (dPiece[i][j] == 421) dSpecial[i][j] = 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void ObjL2Special(int x1, int y1, int x2, int y2)
|
|
{
|
|
int i,j;
|
|
|
|
for (j = y1; j <= y2; ++j) {
|
|
for (i = x1; i <= x2; ++i) {
|
|
dSpecial[i][j] = 0;
|
|
if (dPiece[i][j] == 541) dSpecial[i][j] = 5;
|
|
if (dPiece[i][j] == 178) dSpecial[i][j] = 5;
|
|
if (dPiece[i][j] == 551) dSpecial[i][j] = 5;
|
|
if (dPiece[i][j] == 542) dSpecial[i][j] = 6;
|
|
if (dPiece[i][j] == 553) dSpecial[i][j] = 6;
|
|
if (dPiece[i][j] == 13) dSpecial[i][j] = 5;
|
|
if (dPiece[i][j] == 17) dSpecial[i][j] = 6;
|
|
}
|
|
}
|
|
|
|
for (j = y1; j <= y2; ++j) {
|
|
for (i = x1; i <= x2; ++i) {
|
|
if (dPiece[i][j] == 132) {
|
|
dSpecial[i][j+1] = 2;
|
|
dSpecial[i][j+2] = 1;
|
|
}
|
|
if ((dPiece[i][j] == 135) || (dPiece[i][j] == 139)) {
|
|
dSpecial[i+1][j] = 3;
|
|
dSpecial[i+2][j] = 4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void DoorSet(int oi, int dx, int dy)
|
|
{
|
|
int pn;
|
|
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
pn = dPiece[dx][dy];
|
|
if (currlevel < HIVESTART)
|
|
{
|
|
if (pn == 43) ObjSetMicro(dx,dy,392);
|
|
if (pn == 45) ObjSetMicro(dx,dy,394);
|
|
if ((pn == 50) && (object[oi]._otype == OBJ_L1DOORL)) ObjSetMicro(dx,dy,411);
|
|
if ((pn == 50) && (object[oi]._otype == OBJ_L1DOORR)) ObjSetMicro(dx,dy,412);
|
|
if (pn == 54) ObjSetMicro(dx,dy,397);
|
|
if (pn == 55) ObjSetMicro(dx,dy,398);
|
|
if (pn == 61) ObjSetMicro(dx,dy,399);
|
|
if (pn == 67) ObjSetMicro(dx,dy,400);
|
|
if (pn == 68) ObjSetMicro(dx,dy,401);
|
|
if (pn == 69) ObjSetMicro(dx,dy,403);
|
|
if (pn == 70) ObjSetMicro(dx,dy,404);
|
|
if (pn == 72) ObjSetMicro(dx,dy,406);
|
|
if (pn == 212) ObjSetMicro(dx,dy,407); // Blood
|
|
if (pn == 354) ObjSetMicro(dx,dy,409); // Plain L
|
|
if (pn == 355) ObjSetMicro(dx,dy,410); // Plain R
|
|
if (pn == 411) ObjSetMicro(dx,dy,396); // Double open
|
|
if (pn == 412) ObjSetMicro(dx,dy,396); // Double open
|
|
}
|
|
else
|
|
{
|
|
|
|
if (pn == 75) ObjSetMicro(dx,dy,204);
|
|
if (pn == 79) ObjSetMicro(dx,dy,208);
|
|
if ((pn == 86) && (object[oi]._otype == OBJ_L1DOORL)) ObjSetMicro(dx,dy,232);
|
|
if ((pn == 86) && (object[oi]._otype == OBJ_L1DOORR)) ObjSetMicro(dx,dy,234);
|
|
if (pn == 91) ObjSetMicro(dx,dy,215);
|
|
if (pn == 93) ObjSetMicro(dx,dy,218);
|
|
if (pn == 99) ObjSetMicro(dx,dy,220);
|
|
if (pn == 111) ObjSetMicro(dx,dy,222);
|
|
if (pn == 113) ObjSetMicro(dx,dy,224);
|
|
if (pn == 115) ObjSetMicro(dx,dy,226);
|
|
if (pn == 117) ObjSetMicro(dx,dy,228);
|
|
if (pn == 119) ObjSetMicro(dx,dy,230);
|
|
if (pn == 232) ObjSetMicro(dx,dy,212); // Double open
|
|
if (pn == 234) ObjSetMicro(dx,dy,212); // Double open
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void RedoPlayerVision()
|
|
{
|
|
int p;
|
|
|
|
for (p = 0; p < MAX_PLRS; ++p) {
|
|
if (! plr[p].plractive) continue;
|
|
if (currlevel != plr[p].plrlevel) continue;
|
|
ChangeVisionXY(plr[p]._pvid, plr[p]._px, plr[p]._py);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateL1RDoor(int pnum, int oi, bool sendflag)
|
|
{
|
|
int dx, dy;
|
|
bool dok;
|
|
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
if (object[oi]._oVar4 == DOOR_BLOCKED) {
|
|
if (!deltaload) PlaySfxLoc(IS_DOORCLOS, object[oi]._ox, object[oi]._oy);
|
|
return;
|
|
}
|
|
dx = object[oi]._ox;
|
|
dy = object[oi]._oy;
|
|
if (object[oi]._oVar4 == DOOR_CLOSED) {
|
|
if ((pnum == myplr) && sendflag) NetSendCmdParam1(TRUE,CMD_OPENDOOR,oi);
|
|
if (currlevel < CRYPTSTART)
|
|
{
|
|
if (!deltaload) PlaySfxLoc(IS_DOOROPEN, object[oi]._ox, object[oi]._oy);
|
|
}
|
|
else
|
|
{
|
|
if (!deltaload) PlaySfxLoc(CR_DOOROPEN, object[oi]._ox, object[oi]._oy);
|
|
}
|
|
if (currlevel < CRYPTSTART)
|
|
ObjSetMicro(dx,dy,395);
|
|
else
|
|
ObjSetMicro(dx,dy,209);
|
|
if (currlevel < HIVESTART)
|
|
dSpecial[dx][dy] = 8;
|
|
else
|
|
dSpecial[dx][dy] = 2;
|
|
ObjSetMicro12(dx,dy-1);
|
|
--dx;
|
|
object[oi]._oAnimFrame += 2;
|
|
#ifdef NO_L5_DOORS
|
|
if (currlevel > HIVESTART)
|
|
object[oi]._oAnimFrame = -1;
|
|
#endif
|
|
|
|
object[oi]._oPreFlag = TRUE;
|
|
DoorSet(oi, dx, dy);
|
|
object[oi]._oVar4 = DOOR_OPEN;
|
|
object[oi]._oSelFlag = OSEL_TOP;
|
|
RedoPlayerVision();
|
|
} else {
|
|
if (currlevel < CRYPTSTART)
|
|
{
|
|
if (!deltaload) PlaySfxLoc(IS_DOORCLOS, object[oi]._ox, object[oi]._oy);
|
|
}
|
|
else
|
|
{
|
|
if (!deltaload) PlaySfxLoc(CR_DOORCLOS, object[oi]._ox, object[oi]._oy);
|
|
}
|
|
dok = (dMonster[dx][dy] == 0);
|
|
dok = dok && (dItem[dx][dy] == 0);
|
|
dok = dok && (dDead[dx][dy] == 0);
|
|
if (dok) {
|
|
if ((pnum == myplr) && sendflag) NetSendCmdParam1(TRUE,CMD_CLOSEDOOR,oi);
|
|
object[oi]._oVar4 = DOOR_CLOSED;
|
|
object[oi]._oSelFlag = OSEL_ALL;
|
|
ObjSetMicro(dx,dy,object[oi]._oVar1);
|
|
if (currlevel < HIVESTART)
|
|
{
|
|
if (object[oi]._oVar2 != 50) ObjSetMicro(dx-1,dy,object[oi]._oVar2);
|
|
else {
|
|
// Double door
|
|
if (dPiece[dx-1][dy] == 396) ObjSetMicro(dx-1,dy,411);
|
|
else ObjSetMicro(dx-1,dy,object[oi]._oVar2);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (object[oi]._oVar2 != 86) ObjSetMicro(dx-1,dy,object[oi]._oVar2);
|
|
else {
|
|
// Double door
|
|
if (dPiece[dx-1][dy] == 210) ObjSetMicro(dx-1,dy,232);
|
|
else ObjSetMicro(dx-1,dy,object[oi]._oVar2);
|
|
}
|
|
}
|
|
object[oi]._oAnimFrame -= 2;
|
|
object[oi]._oPreFlag = FALSE;
|
|
RedoPlayerVision();
|
|
} else object[oi]._oVar4 = DOOR_BLOCKED;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateL1LDoor(int pnum, int oi, bool sendflag)
|
|
{
|
|
int dx, dy;
|
|
bool dok;
|
|
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
if (object[oi]._oVar4 == DOOR_BLOCKED) {
|
|
if (!deltaload) PlaySfxLoc(IS_DOORCLOS, object[oi]._ox, object[oi]._oy);
|
|
return;
|
|
}
|
|
dx = object[oi]._ox;
|
|
dy = object[oi]._oy;
|
|
if (object[oi]._oVar4 == DOOR_CLOSED) {
|
|
if ((pnum == myplr) && sendflag) NetSendCmdParam1(TRUE,CMD_OPENDOOR,oi);
|
|
if (currlevel < CRYPTSTART)
|
|
{
|
|
if (!deltaload) PlaySfxLoc(IS_DOOROPEN, object[oi]._ox, object[oi]._oy);
|
|
}
|
|
else
|
|
{
|
|
if (!deltaload) PlaySfxLoc(CR_DOOROPEN, object[oi]._ox, object[oi]._oy);
|
|
}
|
|
if (currlevel < CRYPTSTART)
|
|
{
|
|
if (object[oi]._oVar1 == 214)
|
|
ObjSetMicro(dx,dy,408); //Blood
|
|
else
|
|
ObjSetMicro(dx,dy,393);
|
|
}
|
|
else
|
|
ObjSetMicro(dx,dy,206);
|
|
if (currlevel < HIVESTART)
|
|
dSpecial[dx][dy] = 7;
|
|
else
|
|
dSpecial[dx][dy] = 1;
|
|
ObjSetMicro12(dx-1,dy);
|
|
--dy;
|
|
object[oi]._oAnimFrame += 2;
|
|
#ifdef NO_L5_DOORS
|
|
if (currlevel > HIVESTART)
|
|
object[oi]._oAnimFrame = -1;
|
|
#endif
|
|
object[oi]._oPreFlag = TRUE;
|
|
DoorSet(oi, dx, dy);
|
|
object[oi]._oVar4 = DOOR_OPEN;
|
|
object[oi]._oSelFlag = OSEL_TOP;
|
|
RedoPlayerVision();
|
|
} else {
|
|
if (currlevel < CRYPTSTART)
|
|
{
|
|
if (!deltaload) PlaySfxLoc(IS_DOORCLOS, object[oi]._ox, object[oi]._oy);
|
|
}
|
|
else
|
|
{
|
|
if (!deltaload) PlaySfxLoc(CR_DOORCLOS, object[oi]._ox, object[oi]._oy);
|
|
}
|
|
dok = (dMonster[dx][dy] == 0);
|
|
dok = dok && (dItem[dx][dy] == 0);
|
|
dok = dok && (dDead[dx][dy] == 0);
|
|
if (dok) {
|
|
if ((pnum == myplr) && sendflag) NetSendCmdParam1(TRUE,CMD_CLOSEDOOR,oi);
|
|
object[oi]._oVar4 = DOOR_CLOSED;
|
|
object[oi]._oSelFlag = OSEL_ALL;
|
|
ObjSetMicro(dx,dy,object[oi]._oVar1);
|
|
if (currlevel < HIVESTART)
|
|
{
|
|
if (object[oi]._oVar2 != 50) ObjSetMicro(dx,dy-1,object[oi]._oVar2);
|
|
else {
|
|
// Double door
|
|
if (dPiece[dx][dy-1] == 396) ObjSetMicro(dx,dy-1,412);
|
|
else ObjSetMicro(dx,dy-1,object[oi]._oVar2);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (object[oi]._oVar2 != 86) ObjSetMicro(dx,dy-1,object[oi]._oVar2);
|
|
else {
|
|
// Double door
|
|
if (dPiece[dx][dy-1] == 210) ObjSetMicro(dx,dy-1,234);
|
|
else ObjSetMicro(dx,dy-1,object[oi]._oVar2);
|
|
}
|
|
}
|
|
|
|
object[oi]._oAnimFrame -= 2;
|
|
object[oi]._oPreFlag = FALSE;
|
|
RedoPlayerVision();
|
|
} else object[oi]._oVar4 = DOOR_BLOCKED;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
// this is the stupidest fix I've ever seen an' I did it! JKE
|
|
/*-----------------------------------------------------------------------*/
|
|
void OpenCloseAllDoors()
|
|
{
|
|
int i;
|
|
BOOL odeltaload = deltaload;
|
|
|
|
deltaload = TRUE;
|
|
for (i = 0; i < MAXOBJECTS; ++i)
|
|
{
|
|
if (object[i]._otype == OBJ_L1DOORL)
|
|
{
|
|
OperateL1LDoor(myplr, i, FALSE);
|
|
OperateL1LDoor(myplr, i, FALSE);
|
|
}
|
|
else
|
|
if (object[i]._otype == OBJ_L1DOORR)
|
|
{
|
|
OperateL1RDoor(myplr, i, FALSE);
|
|
OperateL1RDoor(myplr, i, FALSE);
|
|
}
|
|
}
|
|
deltaload = odeltaload;
|
|
}
|
|
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateL2RDoor(int pnum, int oi, bool sendflag)
|
|
{
|
|
int dx, dy;
|
|
bool dok;
|
|
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
if (object[oi]._oVar4 == DOOR_BLOCKED) {
|
|
if (!deltaload) PlaySfxLoc(IS_DOORCLOS, object[oi]._ox, object[oi]._oy);
|
|
return;
|
|
}
|
|
dx = object[oi]._ox;
|
|
dy = object[oi]._oy;
|
|
if (object[oi]._oVar4 == DOOR_CLOSED) {
|
|
if ((pnum == myplr) && sendflag) NetSendCmdParam1(TRUE,CMD_OPENDOOR,oi);
|
|
if (!deltaload) PlaySfxLoc(IS_DOOROPEN, object[oi]._ox, object[oi]._oy);
|
|
ObjSetMicro(dx,dy,17);
|
|
object[oi]._oAnimFrame += 2;
|
|
object[oi]._oPreFlag = TRUE;
|
|
object[oi]._oVar4 = DOOR_OPEN;
|
|
object[oi]._oSelFlag = OSEL_TOP;
|
|
RedoPlayerVision();
|
|
} else {
|
|
if (!deltaload) PlaySfxLoc(IS_DOORCLOS, object[oi]._ox, object[oi]._oy);
|
|
dok = (dMonster[dx][dy] == 0);
|
|
dok = dok && (dItem[dx][dy] == 0);
|
|
dok = dok && (dDead[dx][dy] == 0);
|
|
if (dok) {
|
|
if ((pnum == myplr) && sendflag) NetSendCmdParam1(TRUE,CMD_CLOSEDOOR,oi);
|
|
object[oi]._oVar4 = DOOR_CLOSED;
|
|
object[oi]._oSelFlag = OSEL_ALL;
|
|
ObjSetMicro(dx,dy,540);
|
|
object[oi]._oAnimFrame -= 2;
|
|
object[oi]._oPreFlag = FALSE;
|
|
RedoPlayerVision();
|
|
} else object[oi]._oVar4 = DOOR_BLOCKED;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
const void OperateL2LDoor(int pnum, int oi, BOOL sendflag)
|
|
{
|
|
int dx, dy;
|
|
bool dok;
|
|
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
if (object[oi]._oVar4 == DOOR_BLOCKED) {
|
|
if (!deltaload) PlaySfxLoc(IS_DOORCLOS, object[oi]._ox, object[oi]._oy);
|
|
return;
|
|
}
|
|
dx = object[oi]._ox;
|
|
dy = object[oi]._oy;
|
|
if (object[oi]._oVar4 == DOOR_CLOSED) {
|
|
if ((pnum == myplr) && sendflag) NetSendCmdParam1(TRUE,CMD_OPENDOOR,oi);
|
|
if (!deltaload) PlaySfxLoc(IS_DOOROPEN, object[oi]._ox, object[oi]._oy);
|
|
ObjSetMicro(dx,dy,13);
|
|
object[oi]._oAnimFrame += 2;
|
|
object[oi]._oPreFlag = TRUE;
|
|
object[oi]._oVar4 = DOOR_OPEN;
|
|
object[oi]._oSelFlag = OSEL_TOP;
|
|
RedoPlayerVision();
|
|
} else {
|
|
if (!deltaload) PlaySfxLoc(IS_DOORCLOS, object[oi]._ox, object[oi]._oy);
|
|
dok = (dMonster[dx][dy] == 0);
|
|
dok = dok && (dItem[dx][dy] == 0);
|
|
dok = dok && (dDead[dx][dy] == 0);
|
|
if (dok) {
|
|
if ((pnum == myplr) && sendflag) NetSendCmdParam1(TRUE,CMD_CLOSEDOOR,oi);
|
|
object[oi]._oVar4 = DOOR_CLOSED;
|
|
object[oi]._oSelFlag = OSEL_ALL;
|
|
ObjSetMicro(dx,dy,538);
|
|
object[oi]._oAnimFrame -= 2;
|
|
object[oi]._oPreFlag = FALSE;
|
|
RedoPlayerVision();
|
|
} else object[oi]._oVar4 = DOOR_BLOCKED;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateL3RDoor(int pnum, int oi, bool sendflag)
|
|
{
|
|
int dx, dy;
|
|
bool dok;
|
|
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
if (object[oi]._oVar4 == DOOR_BLOCKED) {
|
|
if (!deltaload) PlaySfxLoc(IS_DOORCLOS, object[oi]._ox, object[oi]._oy);
|
|
return;
|
|
}
|
|
dx = object[oi]._ox;
|
|
dy = object[oi]._oy;
|
|
if (object[oi]._oVar4 == DOOR_CLOSED) {
|
|
if ((pnum == myplr) && sendflag) NetSendCmdParam1(TRUE,CMD_OPENDOOR,oi);
|
|
if (!deltaload) PlaySfxLoc(IS_DOOROPEN, object[oi]._ox, object[oi]._oy);
|
|
ObjSetMicro(dx,dy,541);
|
|
object[oi]._oAnimFrame += 2;
|
|
object[oi]._oPreFlag = TRUE;
|
|
object[oi]._oVar4 = DOOR_OPEN;
|
|
object[oi]._oSelFlag = OSEL_TOP;
|
|
RedoPlayerVision();
|
|
} else {
|
|
if (!deltaload) PlaySfxLoc(IS_DOORCLOS, object[oi]._ox, object[oi]._oy);
|
|
dok = (dMonster[dx][dy] == 0);
|
|
dok = dok && (dItem[dx][dy] == 0);
|
|
dok = dok && (dDead[dx][dy] == 0);
|
|
if (dok) {
|
|
if ((pnum == myplr) && sendflag) NetSendCmdParam1(TRUE,CMD_CLOSEDOOR,oi);
|
|
object[oi]._oVar4 = DOOR_CLOSED;
|
|
object[oi]._oSelFlag = OSEL_ALL;
|
|
ObjSetMicro(dx,dy,534);
|
|
object[oi]._oAnimFrame -= 2;
|
|
object[oi]._oPreFlag = FALSE;
|
|
RedoPlayerVision();
|
|
} else object[oi]._oVar4 = DOOR_BLOCKED;
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
static void OperateL3LDoor(int pnum, int oi, bool sendflag)
|
|
{
|
|
int dx, dy;
|
|
bool dok;
|
|
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
if (object[oi]._oVar4 == DOOR_BLOCKED) {
|
|
if (!deltaload) PlaySfxLoc(IS_DOORCLOS, object[oi]._ox, object[oi]._oy);
|
|
return;
|
|
}
|
|
dx = object[oi]._ox;
|
|
dy = object[oi]._oy;
|
|
if (object[oi]._oVar4 == DOOR_CLOSED) {
|
|
if ((pnum == myplr) && sendflag) NetSendCmdParam1(TRUE,CMD_OPENDOOR,oi);
|
|
if (!deltaload) PlaySfxLoc(IS_DOOROPEN, object[oi]._ox, object[oi]._oy);
|
|
ObjSetMicro(dx,dy,538);
|
|
object[oi]._oAnimFrame += 2;
|
|
object[oi]._oPreFlag = TRUE;
|
|
object[oi]._oVar4 = DOOR_OPEN;
|
|
object[oi]._oSelFlag = OSEL_TOP;
|
|
RedoPlayerVision();
|
|
} else {
|
|
if (!deltaload) PlaySfxLoc(IS_DOORCLOS, object[oi]._ox, object[oi]._oy);
|
|
dok = (dMonster[dx][dy] == 0);
|
|
dok = dok && (dItem[dx][dy] == 0);
|
|
dok = dok && (dDead[dx][dy] == 0);
|
|
if (dok) {
|
|
if ((pnum == myplr) && sendflag) NetSendCmdParam1(TRUE,CMD_CLOSEDOOR,oi);
|
|
object[oi]._oVar4 = DOOR_CLOSED;
|
|
object[oi]._oSelFlag = OSEL_ALL;
|
|
ObjSetMicro(dx,dy,531);
|
|
object[oi]._oAnimFrame -= 2;
|
|
object[oi]._oPreFlag = FALSE;
|
|
RedoPlayerVision();
|
|
} else object[oi]._oVar4 = DOOR_BLOCKED;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void MonstCheckDoors(int m)
|
|
{
|
|
int i, oi, dpx, dpy;
|
|
int mx, my;
|
|
|
|
mx = monster[m]._mx;
|
|
my = monster[m]._my;
|
|
if (!(dObject[mx-1][my-1]
|
|
|| dObject[mx][my-1]
|
|
|| dObject[mx+1][my-1]
|
|
|| dObject[mx-1][my]
|
|
|| dObject[mx+1][my]
|
|
|| dObject[mx-1][my+1]
|
|
|| dObject[mx][my+1]
|
|
|| dObject[mx+1][my+1]))
|
|
return;
|
|
for (i = 0; i < numobjects; ++i) {
|
|
oi = objectactive[i];
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
if ((object[oi]._otype == OBJ_L1DOORL) || (object[oi]._otype == OBJ_L1DOORR)) {
|
|
if (object[oi]._oVar4 == DOOR_CLOSED) {
|
|
dpx = abs(object[oi]._ox - mx);
|
|
dpy = abs(object[oi]._oy - my);
|
|
if ((dpx == 1) && (dpy <= 1) && (object[oi]._otype == OBJ_L1DOORL)) OperateL1LDoor(myplr, oi, true);
|
|
if ((dpx <= 1) && (dpy == 1) && (object[oi]._otype == OBJ_L1DOORR)) OperateL1RDoor(myplr, oi, true);
|
|
}
|
|
}
|
|
if ((object[oi]._otype == OBJ_L2DOORL) || (object[oi]._otype == OBJ_L2DOORR)) {
|
|
if (object[oi]._oVar4 == DOOR_CLOSED) {
|
|
dpx = abs(object[oi]._ox - mx);
|
|
dpy = abs(object[oi]._oy - my);
|
|
if ((dpx == 1) && (dpy <= 1) && (object[oi]._otype == OBJ_L2DOORL)) OperateL2LDoor(myplr, oi, true);
|
|
if ((dpx <= 1) && (dpy == 1) && (object[oi]._otype == OBJ_L2DOORR)) OperateL2RDoor(myplr, oi, true);
|
|
}
|
|
}
|
|
if ((object[oi]._otype == OBJ_L3DOORL) || (object[oi]._otype == OBJ_L3DOORR)) {
|
|
if (object[oi]._oVar4 == DOOR_CLOSED) {
|
|
dpx = abs(object[oi]._ox - mx);
|
|
dpy = abs(object[oi]._oy - my);
|
|
|
|
if ((dpx == 1) && (dpy <= 1) && (object[oi]._otype == OBJ_L3DOORR)) OperateL3RDoor(myplr, oi, true);
|
|
if ((dpx <= 1) && (dpy == 1) && (object[oi]._otype == OBJ_L3DOORL)) OperateL3LDoor(myplr, oi, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void ObjChangeMap(int x1, int y1, int x2, int y2)
|
|
{
|
|
int i,j;
|
|
|
|
for (j = y1; j <= y2; ++j) {
|
|
for (i = x1; i <= x2; ++i) {
|
|
ObjSetMini(i, j, pdungeon[i][j]);
|
|
dungeon[i][j] = pdungeon[i][j]; // For automap
|
|
}
|
|
}
|
|
if ((leveltype == 1)&&(currlevel < HIVESTART)) { // JKE
|
|
ObjL1Special((x1 << 1) + DIRTEDGED2, (y1 << 1) + DIRTEDGED2, (x2 << 1) + DIRTEDGED2 + 1, (y2 << 1) + DIRTEDGED2 + 1);
|
|
AddL1Objs((x1 << 1) + DIRTEDGED2, (y1 << 1) + DIRTEDGED2, (x2 << 1) + DIRTEDGED2 + 1, (y2 << 1) + DIRTEDGED2 + 1);
|
|
}
|
|
if (leveltype == 2) {
|
|
ObjL2Special((x1 << 1) + DIRTEDGED2, (y1 << 1) + DIRTEDGED2, (x2 << 1) + DIRTEDGED2 + 1, (y2 << 1) + DIRTEDGED2 + 1);
|
|
AddL2Objs((x1 << 1) + DIRTEDGED2, (y1 << 1) + DIRTEDGED2, (x2 << 1) + DIRTEDGED2 + 1, (y2 << 1) + DIRTEDGED2 + 1);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void ObjChangeMapResync(int x1, int y1, int x2, int y2)
|
|
{
|
|
int i,j;
|
|
|
|
for (j = y1; j <= y2; ++j) {
|
|
for (i = x1; i <= x2; ++i) {
|
|
ObjSetMini(i, j, pdungeon[i][j]);
|
|
dungeon[i][j] = pdungeon[i][j]; // For automap
|
|
}
|
|
}
|
|
|
|
if ((leveltype == 1)&&(currlevel < HIVESTART))
|
|
ObjL1Special((x1 << 1) + DIRTEDGED2, (y1 << 1) + DIRTEDGED2, (x2 << 1) + DIRTEDGED2 + 1, (y2 << 1) + DIRTEDGED2 + 1);
|
|
|
|
if (leveltype == 2)
|
|
ObjL2Special((x1 << 1) + DIRTEDGED2, (y1 << 1) + DIRTEDGED2, (x2 << 1) + DIRTEDGED2 + 1, (y2 << 1) + DIRTEDGED2 + 1);
|
|
|
|
}
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateL1Door(int pnum, int i, bool sendflag)
|
|
{
|
|
int dpx, dpy;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
dpx = abs(object[i]._ox - plr[pnum]._px);
|
|
dpy = abs(object[i]._oy - plr[pnum]._py);
|
|
if ((dpx == 1) && (dpy <= 1) && (object[i]._otype == OBJ_L1DOORL)) OperateL1LDoor(pnum, i, sendflag);
|
|
if ((dpx <= 1) && (dpy == 1) && (object[i]._otype == OBJ_L1DOORR)) OperateL1RDoor(pnum, i, sendflag);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateLever(int pnum, int i)
|
|
{
|
|
bool mapflag;
|
|
int j, oi, ot;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return;
|
|
if (!deltaload) PlaySfxLoc(IS_LEVER, object[i]._ox, object[i]._oy);
|
|
|
|
// Toggle to on
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
++object[i]._oAnimFrame;
|
|
|
|
mapflag = true;
|
|
if (currlevel == DIABLO_LEVEL) {
|
|
for (j = 0; j < numobjects; ++j) {
|
|
oi = objectactive[j];
|
|
ot = object[oi]._otype;
|
|
if (ot == OBJ_SWITCHSKL) {
|
|
if ((object[i]._oVar8 == object[oi]._oVar8) && (object[oi]._oSelFlag != OSEL_NONE))
|
|
mapflag = FALSE;
|
|
}
|
|
}
|
|
}
|
|
if (currlevel == NA_KRUL_LEVEL)
|
|
{
|
|
// dPiece[Na_Krul.LeverX][Na_Krul.LeverY] = 316;
|
|
OpenNaKrul();
|
|
Na_Krul.Lever_Thrown = TRUE;
|
|
mapflag = FALSE;
|
|
quests[Q_NA_KRUL]._qactive = QUEST_DONE;
|
|
}
|
|
if (mapflag) ObjChangeMap(object[i]._oVar1, object[i]._oVar2, object[i]._oVar3, object[i]._oVar4);
|
|
if (pnum == myplr) NetSendCmdParam1(FALSE,CMD_OPERATEOBJ,i);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateBook(int pnum, int i)
|
|
{
|
|
int v1, v2, v3;
|
|
int j, oi, ot, itm;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return;
|
|
if ((setlevel) && (setlvlnum == SL_VILEBETRAYER)) {
|
|
bool found = false;
|
|
bool dowarp = false;
|
|
for (j = 0; j < numobjects; ++j) {
|
|
oi = objectactive[j];
|
|
ot = object[oi]._otype;
|
|
if ((ot == OBJ_MCIRCLE2) && (object[oi]._oVar6 == OBJWARP1)) {
|
|
v1 = 27;
|
|
v2 = 29;
|
|
// rmw.patch1.start.1/23/97
|
|
// object[oi]._oVar6 == OBJDONEWARP;
|
|
object[oi]._oVar6 = OBJDONEWARP;
|
|
// rmw.patch1.end.1/23/97
|
|
dowarp = TRUE;
|
|
}
|
|
if ((ot == OBJ_MCIRCLE2) && (object[oi]._oVar6 == OBJWARP2)) {
|
|
v1 = 43;
|
|
v2 = 29;
|
|
// rmw.patch1.start.1/23/97
|
|
// object[oi]._oVar6 == OBJDONEWARP;
|
|
object[oi]._oVar6 = OBJDONEWARP;
|
|
// rmw.patch1.end.1/23/97
|
|
dowarp = TRUE;
|
|
}
|
|
if (dowarp) {
|
|
v3 = dPiece[v1][v2];
|
|
++object[dObject[35][36]-1]._oVar5;
|
|
AddMissile(plr[pnum]._px, plr[pnum]._py, v1, v2, plr[pnum]._pdir, MIT_PHASE, MI_ENEMYMONST, pnum, 0, 0);
|
|
found = TRUE;
|
|
dowarp = FALSE;
|
|
}
|
|
}
|
|
if (!found) return;
|
|
}
|
|
// Toggle open
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
++object[i]._oAnimFrame;
|
|
if ((setlevel) && (setlvlnum == SL_BONECHAMB)) {
|
|
__int64 t = 1;
|
|
plr[myplr]._pMemSpells |= t << (SPL_GUARDIAN-1);
|
|
if (plr[pnum]._pSplLvl[SPL_GUARDIAN] < SPELLCAP) {
|
|
++plr[myplr]._pSplLvl[SPL_GUARDIAN];
|
|
}
|
|
quests[Q_SCHAMB]._qactive = QUEST_DONE;
|
|
if (!deltaload) PlaySfxLoc(IS_QUESTDN, object[i]._ox, object[i]._oy);
|
|
InitDiabloMsg(MSG_INBONE);
|
|
AddMissile(plr[myplr]._px, plr[myplr]._py, object[i]._ox - 2, object[i]._oy - 4, plr[myplr]._pdir, MIT_GUARDIAN, MI_ENEMYMONST, myplr, 0, 0);
|
|
}
|
|
if ((setlevel) && (setlvlnum == SL_VILEBETRAYER)) {
|
|
ObjChangeMapResync(object[i]._oVar1, object[i]._oVar2, object[i]._oVar3, object[i]._oVar4);
|
|
for (itm = 0; itm < numobjects; ++itm) SyncObjectAnim(objectactive[itm]);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateBookLever(int pnum, int i)
|
|
{
|
|
int x,y, tren;
|
|
|
|
app_assert(gbMaxPlayers == 1);
|
|
x = (setpc_x << 1) + DIRTEDGED2;
|
|
y = (setpc_y << 1) + DIRTEDGED2;
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return;
|
|
if (qtextflag) return;
|
|
// Check quests
|
|
if ((object[i]._otype == OBJ_BLINDBOOK) && (quests[Q_BLIND]._qvar1 == 0)) {
|
|
quests[Q_BLIND]._qactive = QUEST_NOTDONE;
|
|
quests[Q_BLIND]._qlog = TRUE;
|
|
quests[Q_BLIND]._qvar1 = 1;
|
|
}
|
|
if ((object[i]._otype == OBJ_BLOODBOOK) && (quests[Q_BLOOD]._qvar1 == 0)) {
|
|
quests[Q_BLOOD]._qactive = QUEST_NOTDONE;
|
|
quests[Q_BLOOD]._qlog = TRUE;
|
|
quests[Q_BLOOD]._qvar1 = 1;
|
|
SpawnQuestItem(IDI_BLDSTONE, (setpc_x << 1) + 3 + DIRTEDGED2, (setpc_y << 1) + 10 + DIRTEDGED2, FALSE, ISEL_FLR);
|
|
SpawnQuestItem(IDI_BLDSTONE, (setpc_x << 1) + 15 + DIRTEDGED2, (setpc_y << 1) + 10 + DIRTEDGED2, FALSE, ISEL_FLR);
|
|
SpawnQuestItem(IDI_BLDSTONE, (setpc_x << 1) + 9 + DIRTEDGED2, (setpc_y << 1) + 17 + DIRTEDGED2, FALSE, ISEL_FLR);
|
|
}
|
|
if ((object[i]._otype == OBJ_STEELTOME) && (quests[Q_WARLORD]._qvar1 == 0)) {
|
|
quests[Q_WARLORD]._qactive = QUEST_NOTDONE;
|
|
quests[Q_WARLORD]._qlog = TRUE;
|
|
quests[Q_WARLORD]._qvar1 = 1;
|
|
}
|
|
// Change map
|
|
if (object[i]._oAnimFrame != object[i]._oVar6) {
|
|
if (object[i]._otype != OBJ_BLOODBOOK) ObjChangeMap(object[i]._oVar1, object[i]._oVar2, object[i]._oVar3, object[i]._oVar4);
|
|
if (object[i]._otype == OBJ_BLINDBOOK) {
|
|
CreateItem(UID_OPTAMULET, x+5, y+5);
|
|
tren = TransVal;
|
|
TransVal = 9;
|
|
DRLG_MRectTrans(object[i]._oVar1, object[i]._oVar2, object[i]._oVar3, object[i]._oVar4);
|
|
TransVal = tren;
|
|
}
|
|
}
|
|
// Toggle open
|
|
// object[i]._oSelFlag = OSEL_NONE;
|
|
object[i]._oAnimFrame = object[i]._oVar6;
|
|
// Display msg
|
|
InitQTextMsg(object[i]._oVar7);
|
|
if (pnum == myplr) NetSendCmdParam1(FALSE,CMD_OPERATEOBJ,i);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateSChambBk(int pnum, int i)
|
|
{
|
|
int textdef,j;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return;
|
|
if (qtextflag) return;
|
|
// object[i]._oSelFlag = OSEL_NONE;
|
|
// Change map
|
|
if (object[i]._oAnimFrame != object[i]._oVar6) {
|
|
ObjChangeMapResync(object[i]._oVar1, object[i]._oVar2, object[i]._oVar3, object[i]._oVar4);
|
|
for (j = 0; j < numobjects; ++j) SyncObjectAnim(objectactive[j]);
|
|
}
|
|
// Toggle open
|
|
object[i]._oAnimFrame = object[i]._oVar6;
|
|
if (quests[Q_SCHAMB]._qactive == QUEST_NOTACTIVE) {
|
|
quests[Q_SCHAMB]._qactive = QUEST_NOTDONE;
|
|
quests[Q_SCHAMB]._qlog = TRUE;
|
|
}
|
|
|
|
if (plr[myplr]._pClass == CLASS_WARRIOR) textdef = TXT_WARBONE;
|
|
else if (plr[myplr]._pClass == CLASS_ROGUE) textdef = TXT_ROGBONE;
|
|
else if (plr[myplr]._pClass == CLASS_SORCEROR) textdef = TXT_SORBONE;
|
|
else if (plr[myplr]._pClass == CLASS_MONK) textdef = TXT_MNKBONE;
|
|
else if (plr[myplr]._pClass == CLASS_BARD) textdef = TXT_BRDBONE;
|
|
else if (plr[myplr]._pClass == CLASS_BARBARIAN) textdef = TXT_BARBONE;
|
|
quests[Q_SCHAMB]._qmsg = textdef;
|
|
InitQTextMsg(textdef);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateChest(int pnum, int i, bool sendmsg)
|
|
{
|
|
int j, mdir, mtype = MIT_ARROW;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return;
|
|
if (!deltaload) PlaySfxLoc(IS_CHEST, object[i]._ox, object[i]._oy);
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
object[i]._oAnimFrame += 2;
|
|
if (deltaload) return;
|
|
SetRndSeed(object[i]._oRndSeed);
|
|
|
|
if (setlevel) { //Create only good items for set levels
|
|
for (j = 0; j < object[i]._oVar1; ++j) {
|
|
CreateRndItem(object[i]._ox, object[i]._oy, TRUE, sendmsg, FALSE);
|
|
}
|
|
} else {
|
|
for (j = 0; j < object[i]._oVar1; ++j) {
|
|
if (object[i]._oVar2) CreateRndItem(object[i]._ox, object[i]._oy, FALSE, sendmsg, FALSE);
|
|
else CreateRndUseful(pnum, object[i]._ox, object[i]._oy, sendmsg);
|
|
}
|
|
}
|
|
|
|
if ((object[i]._oTrapFlag) &&
|
|
(object[i]._otype >= OBJ_TCHEST1) &&
|
|
(object[i]._otype <= OBJ_TCHEST3)) {
|
|
mdir = GetDirection(object[i]._ox, object[i]._oy, plr[pnum]._px, plr[pnum]._py);
|
|
switch(object[i]._oVar4) {
|
|
case 0:
|
|
mtype = MIT_ARROW;
|
|
break;
|
|
case 1:
|
|
mtype = MIT_FARROW;
|
|
break;
|
|
case 2:
|
|
mtype = MIT_NOVA;
|
|
break;
|
|
case 3:
|
|
mtype = MIT_FLAMEBOX;
|
|
// SpawnSkeleton(object[i]._oVar2, object[i]._ox, object[i]._oy);
|
|
break;
|
|
case 4:
|
|
mtype = MIT_DISENCHANT;
|
|
break;
|
|
case 5:
|
|
mtype = MIT_MANAREMOVE;
|
|
break;
|
|
#if defined(HELLFIRE2)
|
|
// GWP Another good trap might be acid splatted all around.
|
|
case 6:
|
|
mtype = MIT_LIGHTBOX;
|
|
// SpawnSkeleton(object[i]._oVar2, object[i]._ox, object[i]._oy);
|
|
break;
|
|
#endif
|
|
default:
|
|
mtype = MIT_ARROW;
|
|
break;
|
|
}
|
|
AddMissile(object[i]._ox, object[i]._oy, plr[pnum]._px, plr[pnum]._py, mdir, mtype, MI_ENEMYPLR, -1, 0, 0);
|
|
object[i]._oTrapFlag = FALSE;
|
|
}
|
|
if (pnum == myplr) NetSendCmdParam2(FALSE,CMD_PLROPOBJ,pnum,i);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateMushPatch(int pnum, int i)
|
|
{
|
|
int x, y;
|
|
|
|
if (!(quests[Q_BKMUSHRM]._qactive == QUEST_NOTDONE
|
|
&& (quests[Q_BKMUSHRM]._qvar1 >= QS_TOMEGIVEN))) // FUNGALTM was given to Witch
|
|
{
|
|
if (!deltaload && pnum == myplr) {
|
|
if (plr[myplr]._pClass == CLASS_WARRIOR) PlaySFX(PS_WARR13);
|
|
#if !IS_VERSION(SHAREWARE)
|
|
else if (plr[myplr]._pClass == CLASS_ROGUE) PlaySFX(PS_ROGUE13);
|
|
else if (plr[myplr]._pClass == CLASS_SORCEROR) PlaySFX(PS_MAGE13);
|
|
else if (plr[myplr]._pClass == CLASS_MONK) PlaySFX(PS_MONK13);
|
|
else if (plr[myplr]._pClass == CLASS_BARD) PlaySFX(PS_BARD13);
|
|
else if (plr[myplr]._pClass == CLASS_BARBARIAN) PlaySFX(PS_BARBARIAN13);
|
|
#endif
|
|
}
|
|
return;
|
|
}
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE)
|
|
return;
|
|
if (!deltaload) PlaySfxLoc(IS_CHEST, object[i]._ox, object[i]._oy);
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
object[i]._oAnimFrame += 1;
|
|
if (deltaload) return;
|
|
GetSuperItemLoc(object[i]._ox, object[i]._oy, x, y);
|
|
SpawnQuestItem(IDI_MUSHROOM, x,y,0, ISEL_NONE);
|
|
quests[Q_BKMUSHRM]._qvar1 = QS_MUSHSPAWNED;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateInnSignChest(int pnum, int i)
|
|
{
|
|
int x, y;
|
|
|
|
if (!(quests[Q_LTBANNER]._qvar1 == 2))
|
|
{
|
|
if (!deltaload && pnum == myplr) {
|
|
if (plr[myplr]._pClass == CLASS_WARRIOR) PlaySFX(PS_WARR24);
|
|
#if !IS_VERSION(SHAREWARE)
|
|
else if (plr[myplr]._pClass == CLASS_ROGUE) PlaySFX(PS_ROGUE24);
|
|
else if (plr[myplr]._pClass == CLASS_SORCEROR) PlaySFX(PS_MAGE24);
|
|
else if (plr[myplr]._pClass == CLASS_MONK) PlaySFX(PS_MONK24);
|
|
else if (plr[myplr]._pClass == CLASS_BARD) PlaySFX(PS_BARD24);
|
|
else if (plr[myplr]._pClass == CLASS_BARBARIAN) PlaySFX(PS_BARBARIAN24);
|
|
#endif
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (object[i]._oSelFlag == OSEL_NONE)
|
|
return;
|
|
if (!deltaload) PlaySfxLoc(IS_CHEST, object[i]._ox, object[i]._oy);
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
object[i]._oAnimFrame += 2;
|
|
if (deltaload) return;
|
|
GetSuperItemLoc(object[i]._ox, object[i]._oy, x, y);
|
|
SpawnQuestItem(IDI_BANNER, x,y,0, ISEL_NONE);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateSlainHero(int pnum, int i, bool sendmsg)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return;
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
if (deltaload) return;
|
|
|
|
if (plr[pnum]._pClass == CLASS_WARRIOR) {
|
|
//Create magic breast plate
|
|
CreateMagicArmor(object[i]._ox, object[i]._oy, IT_HARMOR, ITEM_BPLATE, FALSE, TRUE);
|
|
#if !IS_VERSION(SHAREWARE)
|
|
PlaySfxLoc(PS_WARR9, plr[myplr]._px, plr[myplr]._py);
|
|
#endif
|
|
} else if (plr[pnum]._pClass == CLASS_ROGUE) {
|
|
//Create magic long battle bow
|
|
CreateMagicWeapon(object[i]._ox, object[i]._oy, IT_BOW, ITEM_STLLONGBOW, FALSE, TRUE);
|
|
#if !IS_VERSION(SHAREWARE)
|
|
PlaySfxLoc(PS_ROGUE9, plr[myplr]._px, plr[myplr]._py);
|
|
#endif
|
|
} else if (plr[pnum]._pClass == CLASS_SORCEROR) {
|
|
//Create book of lightning
|
|
CreateSpellBook(object[i]._ox, object[i]._oy, SPL_LIGHTNING, FALSE, TRUE);
|
|
#if !IS_VERSION(SHAREWARE)
|
|
PlaySfxLoc(PS_MAGE9, plr[myplr]._px, plr[myplr]._py);
|
|
#endif
|
|
} else if (plr[pnum]._pClass == CLASS_MONK) {
|
|
//Create magic staff
|
|
CreateMagicWeapon(object[i]._ox, object[i]._oy, IT_STAFF, ITEM_STLSTAFF, FALSE, TRUE);
|
|
#if !IS_VERSION(SHAREWARE)
|
|
PlaySfxLoc(PS_MONK9, plr[myplr]._px, plr[myplr]._py);
|
|
#endif
|
|
} else if (plr[pnum]._pClass == CLASS_BARD) {
|
|
//Create special sword.
|
|
CreateMagicWeapon(object[i]._ox, object[i]._oy, IT_SWORD, ITEM_BASTSRD, FALSE, TRUE);
|
|
#if !IS_VERSION(SHAREWARE)
|
|
PlaySfxLoc(PS_BARD9, plr[myplr]._px, plr[myplr]._py);
|
|
#endif
|
|
} else if (plr[pnum]._pClass == CLASS_BARBARIAN) {
|
|
//Create special sword.
|
|
CreateMagicWeapon(object[i]._ox, object[i]._oy, IT_AXE, ITEM_BTLAXE, FALSE, TRUE);
|
|
#if !IS_VERSION(SHAREWARE)
|
|
PlaySfxLoc(PS_BARBARIAN9, plr[myplr]._px, plr[myplr]._py);
|
|
#endif
|
|
}
|
|
if (pnum == myplr) NetSendCmdParam1(FALSE,CMD_OPERATEOBJ,i);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateTrapLvr(int i)
|
|
{
|
|
int j, oi;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oAnimFrame == 1) {
|
|
// Toggle to on
|
|
++object[i]._oAnimFrame;
|
|
for (j = 0; j < numobjects; ++j) {
|
|
oi = objectactive[j];
|
|
if ((object[oi]._otype == object[i]._oVar2) && (object[oi]._oVar1 == object[i]._oVar1)) {
|
|
object[oi]._oVar2 = 1;
|
|
object[oi]._oAnimFlag = FALSE;
|
|
}
|
|
}
|
|
} else {
|
|
// Toggle to off
|
|
--object[i]._oAnimFrame;
|
|
for (j = 0; j < numobjects; ++j) {
|
|
oi = objectactive[j];
|
|
if ((object[oi]._otype == object[i]._oVar2) && (object[oi]._oVar1 == object[i]._oVar1)) {
|
|
object[oi]._oVar2 = 0;
|
|
if (object[oi]._oVar4 != 0) object[oi]._oAnimFlag = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateSarc(int pnum, int i, bool sendmsg)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return;
|
|
if (!deltaload) PlaySfxLoc(IS_SARC, object[i]._ox, object[i]._oy);
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
if (deltaload) {
|
|
object[i]._oAnimFrame = object[i]._oAnimLen;
|
|
return;
|
|
} else {
|
|
object[i]._oAnimFlag = TRUE;
|
|
object[i]._oAnimDelay = 3;
|
|
}
|
|
SetRndSeed(object[i]._oRndSeed);
|
|
if (object[i]._oVar1 <= 2) CreateRndItem(object[i]._ox, object[i]._oy, FALSE, sendmsg, FALSE);
|
|
if (object[i]._oVar1 >= 8) SpawnSkeleton(object[i]._oVar2, object[i]._ox, object[i]._oy);
|
|
|
|
#if CHEATS
|
|
if (itemcheat)
|
|
CreateMagicWeapon(object[i]._ox, object[i]._oy, IT_STAFF, ITEM_SHRTSTAFF, FALSE, TRUE);
|
|
#endif
|
|
|
|
if (pnum == myplr) NetSendCmdParam1(FALSE,CMD_OPERATEOBJ,i);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateL2Door(int pnum, int i, bool sendflag)
|
|
{
|
|
int dpx, dpy;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
dpx = abs(object[i]._ox - plr[pnum]._px);
|
|
dpy = abs(object[i]._oy - plr[pnum]._py);
|
|
if ((dpx == 1) && (dpy <= 1) && (object[i]._otype == OBJ_L2DOORL)) OperateL2LDoor(pnum, i, sendflag);
|
|
if ((dpx <= 1) && (dpy == 1) && (object[i]._otype == OBJ_L2DOORR)) OperateL2RDoor(pnum, i, sendflag);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateL3Door(int pnum, int i, bool sendflag)
|
|
{
|
|
int dpx, dpy;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
dpx = abs(object[i]._ox - plr[pnum]._px);
|
|
dpy = abs(object[i]._oy - plr[pnum]._py);
|
|
if ((dpx == 1) && (dpy <= 1) && (object[i]._otype == OBJ_L3DOORR)) OperateL3RDoor(pnum, i, sendflag);
|
|
if ((dpx <= 1) && (dpy == 1) && (object[i]._otype == OBJ_L3DOORL)) OperateL3LDoor(pnum, i, sendflag);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperatePedistal(int pnum, int i)
|
|
{
|
|
int jstn;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oVar6 != 3) {
|
|
if (PlrHasItem(pnum, IDI_BLDSTONE, jstn)) {
|
|
RemoveInvItem(pnum, jstn);
|
|
++object[i]._oAnimFrame;
|
|
++object[i]._oVar6;
|
|
}
|
|
if (object[i]._oVar6 == 1) {
|
|
if (!deltaload) PlaySfxLoc(LS_PUDDLE, object[i]._ox, object[i]._oy);
|
|
ObjChangeMap(setpc_x, setpc_y + 3, setpc_x + 2, setpc_y + 7);
|
|
}
|
|
if (object[i]._oVar6 == 2) {
|
|
if (!deltaload) PlaySfxLoc(LS_PUDDLE, object[i]._ox, object[i]._oy);
|
|
ObjChangeMap(setpc_x + 6, setpc_y + 3, setpc_x + setpc_w, setpc_y + 7);
|
|
}
|
|
if (object[i]._oVar6 == 3) {
|
|
if (!deltaload) PlaySfxLoc(LS_BLODSTAR, object[i]._ox, object[i]._oy);
|
|
ObjChangeMap(object[i]._oVar1, object[i]._oVar2, object[i]._oVar3, object[i]._oVar4);
|
|
byte *setp;
|
|
setp = LoadFileInMemSig("Levels\\L2Data\\Blood2.DUN", NULL, 'STPC');
|
|
LoadMapObjs(setp, (setpc_x << 1), (setpc_y << 1));
|
|
DiabloFreePtr(setp);
|
|
CreateItem(UID_ARMOFVAL, (setpc_x << 1) + 9 + DIRTEDGED2, (setpc_y << 1) + 3 + DIRTEDGED2);
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void TryDisarm(int pnum, int i)
|
|
{
|
|
int j, oi, oti;
|
|
int trapdisper;
|
|
bool checkflag;
|
|
|
|
if (pnum == myplr) NewCursor(GLOVE_CURS);
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (!object[i]._oTrapFlag) return;
|
|
|
|
trapdisper = (plr[pnum]._pDexterity << 1) - (currlevel * 5);
|
|
if (random(154,100) > trapdisper) return;
|
|
|
|
for (j = 0; j < numobjects; ++j) {
|
|
oi = objectactive[j];
|
|
checkflag = false;
|
|
if (object[oi]._otype == OBJ_TRAPL) checkflag = true;
|
|
if (object[oi]._otype == OBJ_TRAPR) checkflag = true;
|
|
if (checkflag) {
|
|
oti = dObject[object[oi]._oVar1][object[oi]._oVar2] - 1;
|
|
if (oti == i) {
|
|
object[oi]._oVar4 = 1;
|
|
object[i]._oTrapFlag = FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
int ItemMiscIdIdx(int imiscid)
|
|
{
|
|
int i = 0;
|
|
while ((AllItemsList[i].iRnd == IRND_NO) || (AllItemsList[i].iMiscId != imiscid)) ++i;
|
|
return(i);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateShrine(int pnum, int i, int sType)
|
|
{
|
|
int r, xx, yy, idata, sc;
|
|
int v1, v2, v3, v4;
|
|
__int64 lv, t;
|
|
bool done;
|
|
|
|
//Fixes any gold cheats
|
|
if (dropGoldFlag) {
|
|
dropGoldFlag = FALSE;
|
|
dropGoldValue = 0;
|
|
}
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return;
|
|
SetRndSeed(object[i]._oRndSeed);
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
if (! deltaload) {
|
|
PlaySfxLoc(sType, object[i]._ox, object[i]._oy);
|
|
object[i]._oAnimFlag = TRUE;
|
|
object[i]._oAnimDelay = 1;
|
|
} else {
|
|
object[i]._oAnimFrame = object[i]._oAnimLen;
|
|
object[i]._oAnimFlag = FALSE;
|
|
}
|
|
switch (object[i]._oVar1) {
|
|
case 0 : // Mysterious
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
//Subtract 1 from all attributes
|
|
ModifyPlrStr(pnum, -1);
|
|
ModifyPlrMag(pnum, -1);
|
|
ModifyPlrDex(pnum, -1);
|
|
ModifyPlrVit(pnum, -1);
|
|
//Add 6 to random attribute. We are actually adding 5 since we
|
|
//subtracted 1 above.
|
|
switch(random(0, 4)) {
|
|
case 0:
|
|
ModifyPlrStr(pnum, 6);
|
|
break;
|
|
case 1:
|
|
ModifyPlrMag(pnum, 6);
|
|
break;
|
|
case 2:
|
|
ModifyPlrDex(pnum, 6);
|
|
break;
|
|
case 3:
|
|
ModifyPlrVit(pnum, 6);
|
|
break;
|
|
}
|
|
CheckStats(pnum);
|
|
InitDiabloMsg(SHRINE_1);
|
|
break;
|
|
case 1 : // Hidden
|
|
v1 = 0;
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
//Find out if player has any items equipped
|
|
for (r = 0; r < NUM_INVLOC; ++r) {
|
|
if (plr[pnum].InvBody[r]._itype != -1) ++v1;
|
|
}
|
|
//Add 10 to max and current durability of all equipped items.
|
|
if (v1 > 0) {
|
|
for (r = 0; r < NUM_INVLOC; ++r) {
|
|
if (plr[pnum].InvBody[r]._itype != -1) {
|
|
//Ignore any items which are indestructible.
|
|
if ((plr[pnum].InvBody[r]._iMaxDur != INFINITE_DUR) &&
|
|
(plr[pnum].InvBody[r]._iMaxDur != 0)) {
|
|
plr[pnum].InvBody[r]._iDurability += 10;
|
|
plr[pnum].InvBody[r]._iMaxDur += 10;
|
|
if (plr[pnum].InvBody[r]._iDurability > plr[pnum].InvBody[r]._iMaxDur)
|
|
plr[pnum].InvBody[r]._iDurability = plr[pnum].InvBody[r]._iMaxDur;
|
|
}
|
|
}
|
|
}
|
|
done = false;
|
|
while (!done) {
|
|
|
|
// JMM.PATCH3
|
|
int numitems = 0;
|
|
for( r = 0; r < NUM_INVLOC; ++r ) {
|
|
if ( plr[pnum].InvBody[r]._itype != -1 )
|
|
++numitems;
|
|
}
|
|
if( !numitems ) {
|
|
done = true;
|
|
break;
|
|
}
|
|
// JMM.ENDPATCH3
|
|
|
|
r = random(0, NUM_INVLOC);
|
|
if (plr[pnum].InvBody[r]._itype != -1) {
|
|
//Ignore any items which are indestructible.
|
|
if ((plr[pnum].InvBody[r]._iMaxDur != INFINITE_DUR) &&
|
|
(plr[pnum].InvBody[r]._iMaxDur != 0)) {
|
|
//Subtract 20 from random equipped item. We are actually
|
|
//subtracting 10 since we added 10 above.
|
|
plr[pnum].InvBody[r]._iDurability -= 20;
|
|
plr[pnum].InvBody[r]._iMaxDur -= 20;
|
|
if (plr[pnum].InvBody[r]._iDurability <= 0) plr[pnum].InvBody[r]._iDurability = 1;
|
|
if (plr[pnum].InvBody[r]._iMaxDur <= 0) plr[pnum].InvBody[r]._iMaxDur = 1;
|
|
done = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
InitDiabloMsg(SHRINE_2);
|
|
break;
|
|
case 2: // Gloomy (Single Player Only)
|
|
if (deltaload) return;
|
|
if (pnum == myplr) {
|
|
if (plr[pnum].HeadItem._itype != -1) plr[pnum].HeadItem._iAC += 2;
|
|
if (plr[pnum].BodyItem._itype != -1) plr[pnum].BodyItem._iAC += 2;
|
|
if (plr[pnum].Hand1Item._itype != -1) {
|
|
if (plr[pnum].Hand1Item._itype == IT_SHIELD)
|
|
plr[pnum].Hand1Item._iAC += 2;
|
|
else {
|
|
--plr[pnum].Hand1Item._iMaxDam;
|
|
if (plr[pnum].Hand1Item._iMaxDam < plr[pnum].Hand1Item._iMinDam)
|
|
plr[pnum].Hand1Item._iMaxDam = plr[pnum].Hand1Item._iMinDam;
|
|
}
|
|
}
|
|
if (plr[pnum].Hand2Item._itype != -1) {
|
|
if (plr[pnum].Hand2Item._itype == IT_SHIELD)
|
|
plr[pnum].Hand2Item._iAC += 2;
|
|
else {
|
|
--plr[pnum].Hand2Item._iMaxDam;
|
|
if (plr[pnum].Hand2Item._iMaxDam < plr[pnum].Hand2Item._iMinDam)
|
|
plr[pnum].Hand2Item._iMaxDam = plr[pnum].Hand2Item._iMinDam;
|
|
}
|
|
}
|
|
for (r = 0; r < plr[pnum]._pNumInv; ++r) {
|
|
switch(plr[pnum].InvList[r]._itype) {
|
|
case IT_SHIELD:
|
|
case IT_ARMOR:
|
|
case IT_MARMOR:
|
|
case IT_HARMOR:
|
|
case IT_HELM:
|
|
plr[pnum].InvList[r]._iAC += 2;
|
|
break;
|
|
case IT_SWORD:
|
|
case IT_AXE:
|
|
case IT_BOW:
|
|
case IT_MACE:
|
|
case IT_STAFF:
|
|
--plr[pnum].InvList[r]._iMaxDam;
|
|
if (plr[pnum].InvList[r]._iMaxDam < plr[pnum].InvList[r]._iMinDam)
|
|
plr[pnum].InvList[r]._iMaxDam = plr[pnum].InvList[r]._iMinDam;
|
|
break;
|
|
}
|
|
}
|
|
InitDiabloMsg(SHRINE_3);
|
|
}
|
|
break;
|
|
case 3: // Weird (Single Player Only)
|
|
if (deltaload) return;
|
|
if (pnum == myplr) {
|
|
if ((plr[pnum].Hand1Item._itype != -1) && (plr[pnum].Hand1Item._itype != IT_SHIELD))
|
|
++plr[pnum].Hand1Item._iMaxDam;
|
|
if ((plr[pnum].Hand2Item._itype != -1) && (plr[pnum].Hand2Item._itype != IT_SHIELD))
|
|
++plr[pnum].Hand2Item._iMaxDam;
|
|
for (r = 0; r < plr[pnum]._pNumInv; ++r) {
|
|
switch(plr[pnum].InvList[r]._itype) {
|
|
case IT_SWORD:
|
|
case IT_AXE:
|
|
case IT_BOW:
|
|
case IT_MACE:
|
|
case IT_STAFF:
|
|
++plr[pnum].InvList[r]._iMaxDam;
|
|
break;
|
|
}
|
|
}
|
|
InitDiabloMsg(SHRINE_4);
|
|
}
|
|
break;
|
|
case 4: // Magical
|
|
case 11: // Supernatural
|
|
if (deltaload) return;
|
|
//Cast mana shield
|
|
AddMissile(plr[pnum]._px, plr[pnum]._py, plr[pnum]._px, plr[pnum]._py,
|
|
plr[pnum]._pdir, MIT_MANASHIELD, -1, pnum, 0,
|
|
(leveltype << 1));
|
|
if (pnum != myplr) return;
|
|
InitDiabloMsg(SHRINE_5);
|
|
break;
|
|
case 5: // Stone
|
|
if (deltaload) return;
|
|
if (pnum == myplr) {
|
|
for (r = 0; r < NUM_INVLOC; ++r) {
|
|
if (plr[pnum].InvBody[r]._itype == IT_STAFF)
|
|
plr[pnum].InvBody[r]._iCharges = plr[pnum].InvBody[r]._iMaxCharges;
|
|
}
|
|
for (r = 0; r < plr[pnum]._pNumInv; ++r) {
|
|
if (plr[pnum].InvList[r]._itype == IT_STAFF)
|
|
plr[pnum].InvList[r]._iCharges = plr[pnum].InvList[r]._iMaxCharges;
|
|
}
|
|
for (r = 0; r < MAXSPD; ++r) {
|
|
if (plr[pnum].SpdList[r]._itype == IT_STAFF)
|
|
plr[pnum].SpdList[r]._iCharges = plr[pnum].SpdList[r]._iMaxCharges;
|
|
}
|
|
InitDiabloMsg(SHRINE_6);
|
|
}
|
|
break;
|
|
case 6: // Religious
|
|
if (deltaload) return;
|
|
if (pnum == myplr) {
|
|
for (r = 0; r < NUM_INVLOC; ++r) {
|
|
plr[pnum].InvBody[r]._iDurability = plr[pnum].InvBody[r]._iMaxDur;
|
|
}
|
|
for (r = 0; r < plr[pnum]._pNumInv; ++r) {
|
|
plr[pnum].InvList[r]._iDurability = plr[pnum].InvList[r]._iMaxDur;
|
|
}
|
|
for (r = 0; r < MAXSPD; ++r) {
|
|
plr[pnum].SpdList[r]._iDurability = plr[pnum].SpdList[r]._iMaxDur;
|
|
}
|
|
InitDiabloMsg(SHRINE_7);
|
|
}
|
|
break;
|
|
case 7: // Enchanted (Levels 1-8 Only)
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
//Get memorized spell count
|
|
sc = 0;
|
|
lv = 1;
|
|
for (r = 1; r <= MAXSPELLS; ++r) {
|
|
if (plr[pnum]._pMemSpells & lv) ++sc;
|
|
lv = lv << 1;
|
|
}
|
|
//Only add and subtract if player has more than 1 spell memorized
|
|
if (sc > 1) {
|
|
//Add one to all memorized spell levels
|
|
lv = 1;
|
|
for (r = 1; r <= MAXSPELLS; ++r) {
|
|
if (plr[pnum]._pMemSpells & lv) {
|
|
if (plr[pnum]._pSplLvl[r] < SPELLCAP) {
|
|
++plr[pnum]._pSplLvl[r];
|
|
v1 = r;
|
|
}
|
|
}
|
|
lv = lv << 1;
|
|
}
|
|
//Subtract 2 from random memorized spell. We are actually subtracting
|
|
//1 since we added 1 above.
|
|
done = false;
|
|
while (!done) {
|
|
lv = 1;
|
|
r = random(0, MAXSPELLS);
|
|
lv = lv << r;
|
|
if (plr[pnum]._pMemSpells & lv) {
|
|
if (plr[pnum]._pSplLvl[r+1] >= 2) plr[pnum]._pSplLvl[r+1] -= 2;
|
|
else plr[pnum]._pSplLvl[r+1] = 0;
|
|
done = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
InitDiabloMsg(SHRINE_8);
|
|
break;
|
|
case 8: // Thaumaturgic (Single Player Only)
|
|
//All chests regenerate
|
|
for (r = 0; r < numobjects; ++r) {
|
|
v1 = objectactive[r];
|
|
app_assert((DWORD)v1 < MAXOBJECTS);
|
|
if (((object[v1]._otype == OBJ_CHEST1) ||
|
|
(object[v1]._otype == OBJ_CHEST2) ||
|
|
(object[v1]._otype == OBJ_CHEST3)) &&
|
|
(object[v1]._oSelFlag == OSEL_NONE)) {
|
|
object[v1]._oRndSeed = GetRndSeed();
|
|
object[v1]._oSelFlag = OSEL_FLR;
|
|
object[v1]._oAnimFrame -= 2;
|
|
}
|
|
}
|
|
if (deltaload) return;
|
|
if (pnum == myplr) InitDiabloMsg(SHRINE_9);
|
|
break;
|
|
case 9: // Fascinating
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
//Give player fire bolt level +2
|
|
t = 1;
|
|
plr[pnum]._pMemSpells |= t << (SPL_FIREBOLT-1);
|
|
if (plr[pnum]._pSplLvl[SPL_FIREBOLT] < SPELLCAP) ++plr[pnum]._pSplLvl[SPL_FIREBOLT] ;
|
|
if (plr[pnum]._pSplLvl[SPL_FIREBOLT] < SPELLCAP) ++plr[pnum]._pSplLvl[SPL_FIREBOLT] ;
|
|
//Subtract 1/10 of mana
|
|
v1 = plr[pnum]._pMaxManaBase / 10;
|
|
v2 = plr[pnum]._pMana - plr[pnum]._pManaBase;
|
|
v3 = plr[pnum]._pMaxMana - plr[pnum]._pMaxManaBase;
|
|
plr[pnum]._pManaBase -= v1;
|
|
plr[pnum]._pMana -= v1;
|
|
plr[pnum]._pMaxMana -= v1;
|
|
plr[pnum]._pMaxManaBase -= v1;
|
|
if ((plr[pnum]._pMana >> MANA_SHIFT) <= 0) {
|
|
plr[pnum]._pMana = v2;
|
|
plr[pnum]._pManaBase = 0;
|
|
}
|
|
if ((plr[pnum]._pMaxMana >> MANA_SHIFT) <= 0) {
|
|
plr[pnum]._pMaxMana = v3;
|
|
plr[pnum]._pMaxManaBase = 0;
|
|
}
|
|
InitDiabloMsg(SHRINE_10);
|
|
break;
|
|
case 10: // Cryptic
|
|
if (deltaload) return;
|
|
//Cast nova
|
|
AddMissile(plr[pnum]._px, plr[pnum]._py, plr[pnum]._px, plr[pnum]._py,
|
|
plr[pnum]._pdir, MIT_NOVA, -1, pnum, 0, (leveltype << 1));
|
|
if (pnum != myplr) return;
|
|
//Give full mana
|
|
plr[pnum]._pMana = plr[pnum]._pMaxMana;
|
|
plr[pnum]._pManaBase = plr[pnum]._pMaxManaBase;
|
|
InitDiabloMsg(SHRINE_11);
|
|
break;
|
|
case 12: // Eldritch
|
|
if (deltaload) return;
|
|
if (pnum == myplr) {
|
|
//All health and mana potions become full rejuv.
|
|
for (r = 0; r < plr[pnum]._pNumInv; ++r) {
|
|
if (plr[pnum].InvList[r]._itype == IT_MISC) {
|
|
if ((plr[pnum].InvList[r]._iMiscId == IMID_PLHEAL) ||
|
|
(plr[pnum].InvList[r]._iMiscId == IMID_PMANA)) {
|
|
idata = ItemMiscIdIdx(IMID_REJUV);
|
|
SetPlrHandItem(&plr[pnum].HoldItem, idata);
|
|
GetPlrHandSeed(&plr[pnum].HoldItem);
|
|
plr[pnum].HoldItem._iStatFlag = TRUE;
|
|
plr[pnum].InvList[r] = plr[pnum].HoldItem;
|
|
}
|
|
if ((plr[pnum].InvList[r]._iMiscId == IMID_PHEAL) ||
|
|
(plr[pnum].InvList[r]._iMiscId == IMID_PFMANA)) {
|
|
idata = ItemMiscIdIdx(IMID_FREJUV);
|
|
SetPlrHandItem(&plr[pnum].HoldItem, idata);
|
|
GetPlrHandSeed(&plr[pnum].HoldItem);
|
|
plr[pnum].HoldItem._iStatFlag = TRUE;
|
|
plr[pnum].InvList[r] = plr[pnum].HoldItem;
|
|
}
|
|
}
|
|
}
|
|
for (r = 0; r < MAXSPD; ++r) {
|
|
if (plr[pnum].SpdList[r]._itype == IT_MISC) {
|
|
if ((plr[pnum].SpdList[r]._iMiscId == IMID_PLHEAL) ||
|
|
(plr[pnum].SpdList[r]._iMiscId == IMID_PMANA)) {
|
|
idata = ItemMiscIdIdx(IMID_REJUV);
|
|
SetPlrHandItem(&plr[pnum].HoldItem, idata);
|
|
GetPlrHandSeed(&plr[pnum].HoldItem);
|
|
plr[pnum].HoldItem._iStatFlag = TRUE;
|
|
plr[pnum].SpdList[r] = plr[pnum].HoldItem;
|
|
}
|
|
if ((plr[pnum].SpdList[r]._iMiscId == IMID_PHEAL) ||
|
|
(plr[pnum].SpdList[r]._iMiscId == IMID_PFMANA)) {
|
|
idata = ItemMiscIdIdx(IMID_FREJUV);
|
|
SetPlrHandItem(&plr[pnum].HoldItem, idata);
|
|
GetPlrHandSeed(&plr[pnum].HoldItem);
|
|
plr[pnum].HoldItem._iStatFlag = TRUE;
|
|
plr[pnum].SpdList[r] = plr[pnum].HoldItem;
|
|
}
|
|
}
|
|
}
|
|
InitDiabloMsg(SHRINE_13);
|
|
}
|
|
break;
|
|
case 13: // Eerie
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
//Add 2 to magic
|
|
ModifyPlrMag(pnum, 2);
|
|
CheckStats(pnum);
|
|
InitDiabloMsg(SHRINE_14);
|
|
break;
|
|
case 14: // Divine
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
//Put this in because full rejuvs are only available from level 7 on.
|
|
if ((currlevel << 1) < 7) {
|
|
//Create 1 full heal and 1 full mana
|
|
CreateTypeItem(object[i]._ox, object[i]._oy, FALSE, IT_MISC, IMID_PFMANA, FALSE, TRUE);
|
|
CreateTypeItem(object[i]._ox, object[i]._oy, FALSE, IT_MISC, IMID_PHEAL, FALSE, TRUE);
|
|
} else {
|
|
//Create 2 full rejuv
|
|
CreateTypeItem(object[i]._ox, object[i]._oy, FALSE, IT_MISC, IMID_FREJUV, FALSE, TRUE);
|
|
CreateTypeItem(object[i]._ox, object[i]._oy, FALSE, IT_MISC, IMID_FREJUV, FALSE, TRUE);
|
|
}
|
|
//Give full mana and life
|
|
plr[pnum]._pMana = plr[pnum]._pMaxMana;
|
|
plr[pnum]._pManaBase = plr[pnum]._pMaxManaBase;
|
|
plr[pnum]._pHitPoints = plr[pnum]._pMaxHP;
|
|
plr[pnum]._pHPBase = plr[pnum]._pMaxHPBase;
|
|
InitDiabloMsg(SHRINE_15);
|
|
break;
|
|
case 15: // Holy
|
|
if (deltaload) return;
|
|
v4 = 0;
|
|
do {
|
|
v1 = random(159,DMAXX);
|
|
v2 = random(159,DMAXY);
|
|
v3 = dPiece[v1][v2];
|
|
++v4;
|
|
if (v4 > (DMAXX*DMAXY)) break;
|
|
} while (nSolidTable[v3] != 0 || dObject[v1][v2] != 0 || dMonster[v1][v2] != 0);
|
|
//Cast phase
|
|
AddMissile(plr[pnum]._px, plr[pnum]._py, v1, v2, plr[pnum]._pdir,
|
|
MIT_PHASE, -1, pnum, 0, (leveltype << 1));
|
|
if (pnum != myplr) return;
|
|
InitDiabloMsg(SHRINE_16);
|
|
break;
|
|
case 16: // Sacred
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
//Give player charged bolt level +2
|
|
t = 1;
|
|
plr[pnum]._pMemSpells |= t << (SPL_CBOLT-1);
|
|
if (plr[pnum]._pSplLvl[SPL_CBOLT] < SPELLCAP) ++plr[pnum]._pSplLvl[SPL_CBOLT] ;
|
|
if (plr[pnum]._pSplLvl[SPL_CBOLT] < SPELLCAP) ++plr[pnum]._pSplLvl[SPL_CBOLT] ;
|
|
//Subtract 1/10 of mana
|
|
v1 = plr[pnum]._pMaxManaBase / 10;
|
|
v2 = plr[pnum]._pMana - plr[pnum]._pManaBase;
|
|
v3 = plr[pnum]._pMaxMana - plr[pnum]._pMaxManaBase;
|
|
plr[pnum]._pManaBase -= v1;
|
|
plr[pnum]._pMana -= v1;
|
|
plr[pnum]._pMaxMana -= v1;
|
|
plr[pnum]._pMaxManaBase -= v1;
|
|
if ((plr[pnum]._pMana >> MANA_SHIFT) <= 0) {
|
|
plr[pnum]._pMana = v2;
|
|
plr[pnum]._pManaBase = 0;
|
|
}
|
|
if ((plr[pnum]._pMaxMana >> MANA_SHIFT) <= 0) {
|
|
plr[pnum]._pMaxMana = v3;
|
|
plr[pnum]._pMaxManaBase = 0;
|
|
}
|
|
InitDiabloMsg(SHRINE_17);
|
|
break;
|
|
case 17: // Spiritual
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
//Fill inventory with gold
|
|
for (r = 0; r < MAXINV; ++r) {
|
|
if (plr[pnum].InvGrid[r] == 0) {
|
|
v2 = (leveltype * 5) + random(160,leveltype * 10);
|
|
v1 = plr[pnum]._pNumInv;
|
|
plr[pnum].InvList[v1] = golditem;
|
|
plr[pnum].InvList[v1]._iSeed = GetRndSeed();
|
|
++plr[pnum]._pNumInv;
|
|
plr[pnum].InvGrid[r] = plr[pnum]._pNumInv;
|
|
plr[pnum].InvList[v1]._ivalue = v2;
|
|
plr[pnum]._pGold += v2;
|
|
SetGoldCurs(pnum, v1);
|
|
}
|
|
}
|
|
InitDiabloMsg(SHRINE_18);
|
|
break;
|
|
case 18: // Spooky (Multi Player Only)
|
|
if (deltaload) return;
|
|
if (pnum == myplr) InitDiabloMsg(SHRINE_19);
|
|
else {
|
|
//Full rejuv for other players
|
|
InitDiabloMsg(SHRINE_19B);
|
|
plr[myplr]._pHitPoints = plr[myplr]._pMaxHP;
|
|
plr[myplr]._pHPBase = plr[myplr]._pMaxHPBase;
|
|
plr[myplr]._pMana = plr[myplr]._pMaxMana;
|
|
plr[myplr]._pManaBase = plr[myplr]._pMaxManaBase;
|
|
}
|
|
break;
|
|
case 19: // Abandoned
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
//Add 2 to dexterity
|
|
ModifyPlrDex(pnum, 2);
|
|
CheckStats(pnum);
|
|
if (pnum == myplr) InitDiabloMsg(SHRINE_20);
|
|
break;
|
|
case 20: // Creepy
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
//Add 2 to strength
|
|
ModifyPlrStr(pnum, 2);
|
|
CheckStats(pnum);
|
|
if (pnum == myplr) InitDiabloMsg(SHRINE_21);
|
|
break;
|
|
case 21: // Quiet
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
//Add 2 to vitality
|
|
ModifyPlrVit(pnum, 2);
|
|
CheckStats(pnum);
|
|
if (pnum == myplr) InitDiabloMsg(SHRINE_22);
|
|
break;
|
|
case 22: // Secluded
|
|
if (deltaload) return;
|
|
if (pnum == myplr) {
|
|
//Complete automap for current level
|
|
for (yy = 0; yy < AUTOMAPY; ++yy) {
|
|
for (xx = 0; xx < AUTOMAPX; ++xx) automapview[xx][yy] = TRUE;
|
|
}
|
|
InitDiabloMsg(SHRINE_23);
|
|
}
|
|
break;
|
|
case 23: // Ornate
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
//Give player holy bolt level +2
|
|
t = 1;
|
|
plr[pnum]._pMemSpells |= t << (SPL_HBOLT-1);
|
|
if (plr[pnum]._pSplLvl[SPL_HBOLT] < SPELLCAP) ++plr[pnum]._pSplLvl[SPL_HBOLT] ;
|
|
if (plr[pnum]._pSplLvl[SPL_HBOLT] < SPELLCAP) ++plr[pnum]._pSplLvl[SPL_HBOLT] ;
|
|
//Subtract 1/10 of mana
|
|
v1 = plr[pnum]._pMaxManaBase / 10;
|
|
v2 = plr[pnum]._pMana - plr[pnum]._pManaBase;
|
|
v3 = plr[pnum]._pMaxMana - plr[pnum]._pMaxManaBase;
|
|
plr[pnum]._pManaBase -= v1;
|
|
plr[pnum]._pMana -= v1;
|
|
plr[pnum]._pMaxMana -= v1;
|
|
plr[pnum]._pMaxManaBase -= v1;
|
|
if ((plr[pnum]._pMana >> MANA_SHIFT) <= 0) {
|
|
plr[pnum]._pMana = v2;
|
|
plr[pnum]._pManaBase = 0;
|
|
}
|
|
if ((plr[pnum]._pMaxMana >> MANA_SHIFT) <= 0) {
|
|
plr[pnum]._pMaxMana = v3;
|
|
plr[pnum]._pMaxManaBase = 0;
|
|
}
|
|
InitDiabloMsg(SHRINE_24);
|
|
break;
|
|
case 24: // Glimmering
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
//All items are identified
|
|
for (r = 0; r < NUM_INVLOC; ++r) {
|
|
if ((plr[pnum].InvBody[r]._iMagical != IMAGIC_NONE) && !plr[pnum].InvBody[r]._iIdentified)
|
|
plr[pnum].InvBody[r]._iIdentified = TRUE;
|
|
}
|
|
for (r = 0; r < plr[pnum]._pNumInv; ++r) {
|
|
if ((plr[pnum].InvList[r]._iMagical != IMAGIC_NONE) && !plr[pnum].InvList[r]._iIdentified)
|
|
plr[pnum].InvList[r]._iIdentified = TRUE;
|
|
}
|
|
for (r = 0; r < MAXSPD; ++r) {
|
|
if ((plr[pnum].SpdList[r]._iMagical != IMAGIC_NONE) && !plr[pnum].SpdList[r]._iIdentified)
|
|
plr[pnum].SpdList[r]._iIdentified = TRUE;
|
|
}
|
|
InitDiabloMsg(SHRINE_25);
|
|
break;
|
|
case 25: // Tainted (Multi Player Only)
|
|
if (deltaload) return;
|
|
if (pnum == myplr) InitDiabloMsg(SHRINE_26);
|
|
else {
|
|
//All other players get +1 to 3 random stats and -1 to other
|
|
InitDiabloMsg(SHRINE_26B);
|
|
r = random(155,4);
|
|
if (r == 0) v1 = 1;
|
|
else v1 = -1;
|
|
if (r == 1) v2 = 1;
|
|
else v2 = -1;
|
|
if (r == 2) v3 = 1;
|
|
else v3 = -1;
|
|
if (r == 3) v4 = 1;
|
|
else v4 = -1;
|
|
ModifyPlrStr(myplr, v1);
|
|
ModifyPlrMag(myplr, v2);
|
|
ModifyPlrDex(myplr, v3);
|
|
ModifyPlrVit(myplr, v4);
|
|
CheckStats(myplr);
|
|
}
|
|
break;
|
|
case 26: // Oily
|
|
// Increase good stats by 1.
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
InitDiabloMsg(SHRINE_27);
|
|
switch(plr[myplr]._pClass)
|
|
{
|
|
case CLASS_SORCEROR:
|
|
ModifyPlrMag(myplr,2);
|
|
break;
|
|
case CLASS_ROGUE:
|
|
ModifyPlrDex(myplr,2);
|
|
break;
|
|
case CLASS_WARRIOR:
|
|
ModifyPlrStr(myplr,2);
|
|
break;
|
|
case CLASS_BARBARIAN:
|
|
ModifyPlrVit(myplr,2);
|
|
break;
|
|
case CLASS_MONK:
|
|
ModifyPlrStr(myplr,1);
|
|
ModifyPlrDex(myplr,1);
|
|
break;
|
|
case CLASS_BARD:
|
|
ModifyPlrDex(myplr,1);
|
|
ModifyPlrMag(myplr,1);
|
|
break;
|
|
}
|
|
CheckStats(pnum);
|
|
AddMissile(object[i]._ox, object[i]._oy, plr[myplr]._px, plr[myplr]._py, plr[myplr]._pdir, MIT_FIREWALL, MI_ENEMYPLR, 0, 2 + (2 * currlevel), 0);
|
|
break;
|
|
case 27: // Glowing
|
|
{
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
InitDiabloMsg(SHRINE_28);
|
|
long CurrentExp = plr[myplr]._pExperience;
|
|
long ModMagic;
|
|
|
|
if (CurrentExp > 5000)
|
|
{
|
|
ModMagic = 5;
|
|
CurrentExp = (long)(CurrentExp * 0.95);
|
|
}
|
|
else
|
|
{
|
|
ModMagic = CurrentExp/1000;
|
|
CurrentExp = 0;
|
|
|
|
}
|
|
|
|
ModifyPlrMag(myplr, ModMagic);
|
|
plr[myplr]._pExperience = CurrentExp;
|
|
CheckStats(pnum);
|
|
|
|
}
|
|
break;
|
|
case 28: // Mendicant's
|
|
{
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
InitDiabloMsg(SHRINE_29);
|
|
long const HalfCurrentGold = plr[myplr]._pGold / 2;
|
|
|
|
AddPlrExperience(myplr, plr[myplr]._pLevel, HalfCurrentGold);
|
|
TakePlrsMoney(HalfCurrentGold); // uses global var myplr.
|
|
CheckStats(pnum);
|
|
}
|
|
break;
|
|
case 29: // Sparkling
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
InitDiabloMsg(SHRINE_30);
|
|
AddPlrExperience(myplr, plr[myplr]._pLevel, 1000 * currlevel);
|
|
AddMissile(object[i]._ox, object[i]._oy, plr[myplr]._px, plr[myplr]._py, plr[myplr]._pdir, MIT_FLASH, MI_ENEMYPLR, 0, 2 + (3 * currlevel), 0);
|
|
CheckStats(pnum);
|
|
break;
|
|
case 30: // Town
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
InitDiabloMsg(SHRINE_31);
|
|
AddMissile(object[i]._ox, object[i]._oy, plr[myplr]._px, plr[myplr]._py, plr[myplr]._pdir, MIT_TOWN, MI_ENEMYPLR, 0, 0, 0);
|
|
break;
|
|
case 31: // Shimmering
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
InitDiabloMsg(SHRINE_32);
|
|
plr[pnum]._pMana = plr[pnum]._pMaxMana; // restore to full mana.
|
|
plr[pnum]._pManaBase = plr[pnum]._pMaxManaBase;
|
|
break;
|
|
case 32: // Solar
|
|
{
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
time_t time_of_day = time(0);
|
|
struct tm * const tmbuf = localtime(&time_of_day);
|
|
|
|
if (tmbuf->tm_hour > 20 || tmbuf->tm_hour < 4)
|
|
{
|
|
InitDiabloMsg(SHRINE_33D);
|
|
ModifyPlrVit(myplr, 2);
|
|
}
|
|
else if (tmbuf->tm_hour > 18)
|
|
{
|
|
InitDiabloMsg(SHRINE_33C);
|
|
ModifyPlrMag(myplr, 2);
|
|
}
|
|
else if (tmbuf->tm_hour > 12)
|
|
{
|
|
InitDiabloMsg(SHRINE_33B);
|
|
ModifyPlrStr(myplr, 2);
|
|
}
|
|
else if (tmbuf->tm_hour > 4)
|
|
{
|
|
InitDiabloMsg(SHRINE_33A);
|
|
ModifyPlrDex(myplr, 2);
|
|
}
|
|
|
|
CheckStats(pnum);
|
|
}
|
|
break;
|
|
case 33: // Murphy's
|
|
{
|
|
if (deltaload) return;
|
|
if (pnum != myplr) return;
|
|
InitDiabloMsg(SHRINE_34);
|
|
long i;
|
|
long broken = 0;
|
|
|
|
for (i = 0; i < 7; ++i)
|
|
{
|
|
ItemStruct * const itm = &plr[myplr].InvBody[i];
|
|
|
|
if (itm->_itype == -1) continue;
|
|
|
|
if (random(0,3) == 0
|
|
&& itm->_iDurability != INFINITE_DUR
|
|
&& itm->_iDurability != 0) // There are two values for infinite durablity !!!
|
|
{
|
|
// Randomly break something.
|
|
itm->_iDurability /= 2;
|
|
broken = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!broken)
|
|
{
|
|
long const ThirdCurrentGold = plr[myplr]._pGold / 3;
|
|
TakePlrsMoney(ThirdCurrentGold); // uses global var myplr.
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
CalcPlrInv(pnum, TRUE);
|
|
force_redraw = FULLDRAW;
|
|
if (pnum == myplr) NetSendCmdParam2(FALSE,CMD_PLROPOBJ,pnum,i);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateSkelBook(int pnum, int i, bool sendmsg)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return;
|
|
if (!deltaload) PlaySfxLoc(IS_ISCROL, object[i]._ox, object[i]._oy);
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
object[i]._oAnimFrame += 2;
|
|
if (deltaload) return;
|
|
SetRndSeed(object[i]._oRndSeed);
|
|
if (random(161,5)) CreateTypeItem(object[i]._ox, object[i]._oy, FALSE, IT_MISC, IMID_SCROLL, sendmsg, FALSE);
|
|
else CreateTypeItem(object[i]._ox, object[i]._oy, FALSE, IT_MISC, IMID_BOOK, sendmsg, FALSE);
|
|
if (pnum == myplr) NetSendCmdParam1(FALSE,CMD_OPERATEOBJ,i);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateBookCase(int pnum, int i, bool sendmsg)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return;
|
|
if (!deltaload) PlaySfxLoc(IS_ISCROL, object[i]._ox, object[i]._oy);
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
object[i]._oAnimFrame -= 2;
|
|
if (deltaload) return;
|
|
SetRndSeed(object[i]._oRndSeed);
|
|
CreateTypeItem(object[i]._ox, object[i]._oy, FALSE, IT_MISC, IMID_BOOK, sendmsg, FALSE);
|
|
if (QuestStatus(Q_ZHAR)) {
|
|
if (monster[4].mName == UniqMonst[MU_ZHAR].mName) {
|
|
if ((monster[4]._msquelch == 255) && (monster[4]._mhitpoints != 0)) {
|
|
monster[4].mtalkmsg = TXT_ZHAR2;
|
|
M_StartStand(0, monster[4]._mdir);
|
|
monster[4]._mgoal = MG_ATTACK2;
|
|
monster[4]._mmode = MM_TALK;
|
|
}
|
|
}
|
|
}
|
|
if (pnum == myplr) NetSendCmdParam1(FALSE,CMD_OPERATEOBJ,i);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateDecap(int pnum, int i, bool sendmsg)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return;
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
if (deltaload) return;
|
|
SetRndSeed(object[i]._oRndSeed);
|
|
CreateRndItem(object[i]._ox, object[i]._oy, FALSE, sendmsg, FALSE);
|
|
if (pnum == myplr) NetSendCmdParam1(FALSE,CMD_OPERATEOBJ,i);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateArmorStand(int pnum, int i, bool sendmsg)
|
|
{
|
|
int uniqueRnd;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return;
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
++object[i]._oAnimFrame;
|
|
if (deltaload) return;
|
|
SetRndSeed(object[i]._oRndSeed);
|
|
|
|
//Randomize uniqueness
|
|
uniqueRnd = random(0, 2);
|
|
//Create an appropriate armor for the current level
|
|
if (currlevel <= 5) {
|
|
//Create unique only IT_ARMOR
|
|
CreateTypeItem(object[i]._ox, object[i]._oy, TRUE, IT_ARMOR, IMID_NONE, sendmsg, FALSE);
|
|
} else if (currlevel >= 6 && currlevel <= 9) {
|
|
//Create random unique IT_MARMOR
|
|
CreateTypeItem(object[i]._ox, object[i]._oy, uniqueRnd, IT_MARMOR, IMID_NONE, sendmsg, FALSE);
|
|
} else if (currlevel >= 10 && currlevel <= 12) {
|
|
//Create non-unique IT_HARMOR
|
|
CreateTypeItem(object[i]._ox, object[i]._oy, FALSE, IT_HARMOR, IMID_NONE, sendmsg, FALSE);
|
|
} else if (currlevel >= 13 && currlevel <= 16) {
|
|
//Create unique IT_HARMOR
|
|
CreateTypeItem(object[i]._ox, object[i]._oy, TRUE, IT_HARMOR, IMID_NONE, sendmsg, FALSE);
|
|
} else if (currlevel >= 17) {
|
|
//Use the uniques for now, but we will add our own specifics JKE 7/30
|
|
CreateTypeItem(object[i]._ox, object[i]._oy, TRUE, IT_HARMOR, IMID_NONE, sendmsg, FALSE);
|
|
}
|
|
|
|
if (pnum == myplr) NetSendCmdParam1(FALSE,CMD_OPERATEOBJ,i);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static int FindValidShrine(int i)
|
|
/*-----------------------------------------------------------------------*
|
|
** Description: Used by OperateGoatShrine and OperateCauldron to find a
|
|
** usable shrine function.
|
|
** Input: i = Object index
|
|
** Return: Shrine function index.
|
|
**-----------------------------------------------------------------------*/
|
|
{
|
|
int rv;
|
|
bool done = false;
|
|
|
|
//Search until we find a valid shrine type. Ignore Thaumaturgic shrine
|
|
//because it could possibly screw up the animation.
|
|
do {
|
|
rv = random(0, NUMSHRINETYPES);
|
|
if ((currlevel >= shrineminlvl[rv]) &&
|
|
(currlevel <= shrinemaxlvl[rv]) &&
|
|
(rv != 8)) {
|
|
done = true;
|
|
}
|
|
if (done) {
|
|
if ((gbMaxPlayers != 1) && (shrineavail[rv] == SHRINE_SINGLE)) {
|
|
done = FALSE;
|
|
} else if ((gbMaxPlayers == 1) && (shrineavail[rv] == SHRINE_MULTI)) {
|
|
done = FALSE;
|
|
} else done = TRUE; //We found a shrine type we can use.
|
|
}
|
|
} while (!done);
|
|
|
|
return rv;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateGoatShrine(int pnum, int i, int sType)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
SetRndSeed(object[i]._oRndSeed);
|
|
object[i]._oVar1 = FindValidShrine(i);
|
|
OperateShrine(pnum, i, sType);
|
|
object[i]._oAnimDelay = 2;
|
|
force_redraw = FULLDRAW;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateCauldron(int pnum, int i, int sType)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
SetRndSeed(object[i]._oRndSeed);
|
|
object[i]._oVar1 = FindValidShrine(i);
|
|
OperateShrine(pnum, i, sType);
|
|
object[i]._oAnimFrame = 3;
|
|
object[i]._oAnimFlag = FALSE;
|
|
force_redraw = FULLDRAW;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static bool OperateFountains(int pnum, int i)
|
|
{
|
|
int ii;
|
|
bool rv = false;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
SetRndSeed(object[i]._oRndSeed);
|
|
|
|
switch(object[i]._otype) {
|
|
case OBJ_PURIFYINGFTN:
|
|
if (deltaload) return rv;
|
|
if (pnum != myplr) return rv;
|
|
if (plr[pnum]._pMana < plr[pnum]._pMaxMana) {
|
|
PlaySfxLoc(LS_FOUNTAIN, object[i]._ox, object[i]._oy);
|
|
//Add 1 Mana point
|
|
plr[pnum]._pMana += (1 << MANA_SHIFT);
|
|
plr[pnum]._pManaBase += (1 << MANA_SHIFT);
|
|
if (plr[pnum]._pMana > plr[pnum]._pMaxMana) {
|
|
plr[pnum]._pMana = plr[pnum]._pMaxMana;
|
|
plr[pnum]._pManaBase = plr[pnum]._pMaxManaBase;
|
|
}
|
|
rv = true;
|
|
} else if (!deltaload) PlaySfxLoc(LS_FOUNTAIN, object[i]._ox, object[i]._oy);
|
|
break;
|
|
case OBJ_BLOODFTN:
|
|
if (deltaload) return rv;
|
|
if (pnum != myplr) return rv;
|
|
if (plr[pnum]._pHitPoints < plr[pnum]._pMaxHP) {
|
|
PlaySfxLoc(LS_FOUNTAIN, object[i]._ox, object[i]._oy);
|
|
//Add 1 HP point
|
|
plr[pnum]._pHitPoints += (1 << HP_SHIFT);
|
|
plr[pnum]._pHPBase += (1 << HP_SHIFT);
|
|
if (plr[pnum]._pHitPoints > plr[pnum]._pMaxHP) {
|
|
plr[pnum]._pHitPoints = plr[pnum]._pMaxHP;
|
|
plr[pnum]._pHPBase = plr[pnum]._pMaxHPBase;
|
|
}
|
|
rv = true;
|
|
} else if (!deltaload) PlaySfxLoc(LS_FOUNTAIN, object[i]._ox, object[i]._oy);
|
|
break;
|
|
case OBJ_MURKYFTN:
|
|
if (object[i]._oSelFlag != OSEL_NONE) {
|
|
if (!deltaload) PlaySfxLoc(LS_FOUNTAIN, object[i]._ox, object[i]._oy);
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
if (deltaload) return rv;
|
|
//Casts infravision
|
|
AddMissile(plr[pnum]._px, plr[pnum]._py, plr[pnum]._px, plr[pnum]._py,
|
|
plr[pnum]._pdir, MIT_INFRA, -1, pnum, 0,
|
|
(leveltype << 1));
|
|
rv = true;
|
|
if (pnum == myplr) NetSendCmdParam1(FALSE,CMD_OPERATEOBJ,i);
|
|
}
|
|
break;
|
|
case OBJ_TEARFTN:
|
|
if (object[i]._oSelFlag != OSEL_NONE) {
|
|
int rndVal;
|
|
int statVal = -1;
|
|
int saveRnd = -1;
|
|
int status = FALSE;
|
|
ii = 0;
|
|
if (!deltaload) PlaySfxLoc(LS_FOUNTAIN, object[i]._ox, object[i]._oy);
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
if (deltaload) return rv;
|
|
if (pnum != myplr) return rv;
|
|
//-1 to random stat, +1 to another
|
|
do {
|
|
if ((rndVal = random(0, 4)) != saveRnd) {
|
|
switch(rndVal) {
|
|
case 0:
|
|
ModifyPlrStr(pnum, statVal);
|
|
break;
|
|
case 1:
|
|
ModifyPlrMag(pnum, statVal);
|
|
break;
|
|
case 2:
|
|
ModifyPlrDex(pnum, statVal);
|
|
break;
|
|
case 3:
|
|
ModifyPlrVit(pnum, statVal);
|
|
break;
|
|
}
|
|
saveRnd = rndVal;
|
|
statVal = 1;
|
|
++ii;
|
|
}
|
|
if (ii > 1) status = TRUE;
|
|
} while(!status);
|
|
CheckStats(pnum);
|
|
rv = true;
|
|
if (pnum == myplr) NetSendCmdParam1(FALSE,CMD_OPERATEOBJ,i);
|
|
}
|
|
break;
|
|
}
|
|
force_redraw = FULLDRAW;
|
|
return rv;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateWeaponRack(int pnum, int i, bool sendmsg)
|
|
{
|
|
int weaponType, sfxType;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return;
|
|
SetRndSeed(object[i]._oRndSeed);
|
|
|
|
//Choose random weapon/sfx type
|
|
switch((random(0, 4)+1)) {
|
|
case 1:
|
|
weaponType = IT_SWORD;
|
|
sfxType = IS_FSWOR;
|
|
break;
|
|
case 2:
|
|
weaponType = IT_AXE;
|
|
sfxType = IS_FAXE;
|
|
break;
|
|
case 3:
|
|
weaponType = IT_BOW;
|
|
sfxType = IS_FBOW;
|
|
break;
|
|
case 4:
|
|
weaponType = IT_MACE;
|
|
sfxType = IS_FAXE;
|
|
break;
|
|
}
|
|
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
++object[i]._oAnimFrame;
|
|
if (deltaload) return;
|
|
|
|
//Create a random weapon. Create unique weapons from level 4 down.
|
|
if (leveltype > 1) CreateTypeItem(object[i]._ox, object[i]._oy, TRUE, weaponType, IMID_NONE, sendmsg, FALSE);
|
|
else CreateTypeItem(object[i]._ox, object[i]._oy, FALSE, weaponType, IMID_NONE, sendmsg, FALSE);
|
|
|
|
if (pnum == myplr) NetSendCmdParam1(FALSE,CMD_OPERATEOBJ,i);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateStoryBook(int pnum, int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return;
|
|
if (deltaload) return;
|
|
if (qtextflag) return;
|
|
if (pnum != myplr) return;
|
|
object[i]._oAnimFrame = object[i]._oVar4;
|
|
PlaySfxLoc(IS_ISCROL, object[i]._ox, object[i]._oy);
|
|
|
|
if ((object[i]._oVar8 != 0) && (currlevel == NA_KRUL_LEVEL))
|
|
{
|
|
if ((Na_Krul.Lever_Thrown != TRUE) && (quests[Q_NA_KRUL]._qactive != QUEST_DONE))
|
|
if(HCheckSpell(object[i]._oVar8))
|
|
{
|
|
NetSendCmd(FALSE,CMD_OPEN_NAKRUL);
|
|
return;
|
|
}
|
|
}
|
|
else if (currlevel >= CRYPTSTART)
|
|
{
|
|
quests[Q_NA_KRUL]._qactive = QUEST_NOTDONE;
|
|
quests[Q_NA_KRUL]._qlog = TRUE;
|
|
quests[Q_NA_KRUL]._qmsg = object[i]._oVar2;
|
|
}
|
|
|
|
InitQTextMsg(object[i]._oVar2);
|
|
NetSendCmdParam1(FALSE,CMD_OPERATEOBJ,i);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void OperateLazStand(int pnum, int i)
|
|
{
|
|
int x, y;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return;
|
|
if (deltaload) return;
|
|
if (qtextflag) return;
|
|
if (pnum != myplr) return;
|
|
++object[i]._oAnimFrame;
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
GetSuperItemLoc(object[i]._ox, object[i]._oy, x, y);
|
|
SpawnQuestItem(IDI_LAZSTAFF, x, y, 0, ISEL_NONE);
|
|
//quests[Q_BKMUSHRM]._qvar1 = QS_MUSHSPAWNED;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void OperateObject(int pnum, int i, BOOL TeleFlag)
|
|
{
|
|
bool senditemmsg;
|
|
|
|
if (pnum == myplr) senditemmsg = true;
|
|
else senditemmsg = false;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
switch (object[i]._otype) {
|
|
case OBJ_L1DOORL :
|
|
case OBJ_L1DOORR :
|
|
if (TeleFlag) {
|
|
if (object[i]._otype == OBJ_L1DOORL) OperateL1LDoor(pnum, i, true);
|
|
if (object[i]._otype == OBJ_L1DOORR) OperateL1RDoor(pnum, i, true);
|
|
} else {
|
|
if (pnum == myplr) OperateL1Door(pnum, i, TRUE);
|
|
}
|
|
break;
|
|
case OBJ_L2DOORL :
|
|
case OBJ_L2DOORR :
|
|
if (TeleFlag) {
|
|
if (object[i]._otype == OBJ_L2DOORL) OperateL2LDoor(pnum, i, true);
|
|
if (object[i]._otype == OBJ_L2DOORR) OperateL2RDoor(pnum, i, true);
|
|
} else {
|
|
if (pnum == myplr) OperateL2Door(pnum, i, TRUE);
|
|
}
|
|
break;
|
|
case OBJ_L3DOORL :
|
|
case OBJ_L3DOORR :
|
|
if (TeleFlag) {
|
|
if (object[i]._otype == OBJ_L3DOORL) OperateL3LDoor(pnum, i, true);
|
|
if (object[i]._otype == OBJ_L3DOORR) OperateL3RDoor(pnum, i, true);
|
|
} else {
|
|
if (pnum == myplr) OperateL3Door(pnum, i, TRUE);
|
|
}
|
|
break;
|
|
case OBJ_SWITCHSKL:
|
|
case OBJ_LEVER :
|
|
OperateLever(pnum, i);
|
|
break;
|
|
case OBJ_BOOK2L:
|
|
OperateBook(pnum, i);
|
|
break;
|
|
case OBJ_BOOK2R:
|
|
OperateSChambBk(pnum, i);
|
|
break;
|
|
case OBJ_CHEST1:
|
|
case OBJ_CHEST2:
|
|
case OBJ_CHEST3:
|
|
case OBJ_TCHEST1:
|
|
case OBJ_TCHEST2:
|
|
case OBJ_TCHEST3:
|
|
OperateChest(pnum, i, senditemmsg);
|
|
break;
|
|
case OBJ_SARC:
|
|
OperateSarc(pnum, i, senditemmsg);
|
|
break;
|
|
case OBJ_FLAMELVR:
|
|
OperateTrapLvr(i);
|
|
break;
|
|
// case OBJ_BOOKLVR:
|
|
case OBJ_BLINDBOOK:
|
|
case OBJ_BLOODBOOK:
|
|
case OBJ_STEELTOME:
|
|
OperateBookLever(pnum, i);
|
|
break;
|
|
case OBJ_SHRINEL:
|
|
case OBJ_SHRINER:
|
|
OperateShrine(pnum, i, IS_MAGIC);
|
|
break;
|
|
case OBJ_SKELBOOK:
|
|
case OBJ_BOOKSTAND:
|
|
OperateSkelBook(pnum, i, senditemmsg);
|
|
break;
|
|
case OBJ_BOOKCASEL:
|
|
case OBJ_BOOKCASER:
|
|
OperateBookCase(pnum, i, senditemmsg);
|
|
break;
|
|
case OBJ_DECAP:
|
|
OperateDecap(pnum, i, senditemmsg);
|
|
break;
|
|
case OBJ_ARMORSTAND:
|
|
case OBJ_WARARMOR:
|
|
OperateArmorStand(pnum, i, senditemmsg);
|
|
break;
|
|
case OBJ_GOATSHRINE:
|
|
OperateGoatShrine(pnum, i, LS_GSHRINE);
|
|
break;
|
|
case OBJ_CAULDRON:
|
|
OperateCauldron(pnum, i, LS_CALDRON);
|
|
break;
|
|
case OBJ_MURKYFTN:
|
|
case OBJ_TEARFTN:
|
|
case OBJ_BLOODFTN:
|
|
case OBJ_PURIFYINGFTN:
|
|
OperateFountains(pnum, i);
|
|
break;
|
|
case OBJ_STORYBOOK:
|
|
OperateStoryBook(pnum, i);
|
|
break;
|
|
case OBJ_PEDISTAL:
|
|
OperatePedistal(pnum, i);
|
|
break;
|
|
case OBJ_WARWEAP:
|
|
case OBJ_WEAPONRACK:
|
|
OperateWeaponRack(pnum, i, senditemmsg);
|
|
break;
|
|
case OBJ_MUSHPATCH:
|
|
OperateMushPatch(pnum, i);
|
|
break;
|
|
case OBJ_LAZSTAND:
|
|
OperateLazStand(pnum, i);
|
|
break;
|
|
case OBJ_SLAINHERO:
|
|
OperateSlainHero(pnum, i, senditemmsg);
|
|
break;
|
|
case OBJ_SIGNCHEST:
|
|
OperateInnSignChest(pnum, i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void SyncOpL1Door(int pnum, int cmd, int i)
|
|
{
|
|
if (pnum == myplr) return;
|
|
bool opok = false;
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if ((cmd == CMD_OPENDOOR) && (object[i]._oVar4 == DOOR_CLOSED)) opok = TRUE;
|
|
if ((cmd == CMD_CLOSEDOOR) && (object[i]._oVar4 == DOOR_OPEN)) opok = TRUE;
|
|
if (opok) {
|
|
if (object[i]._otype == OBJ_L1DOORL) OperateL1LDoor(-1, i, false);
|
|
if (object[i]._otype == OBJ_L1DOORR) OperateL1RDoor(-1, i, false);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void SyncOpL2Door(int pnum, int cmd, int i)
|
|
{
|
|
if (pnum == myplr) return;
|
|
bool opok = false;
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if ((cmd == CMD_OPENDOOR) && (object[i]._oVar4 == DOOR_CLOSED)) opok = true;
|
|
if ((cmd == CMD_CLOSEDOOR) && (object[i]._oVar4 == DOOR_OPEN)) opok = true;
|
|
if (opok) {
|
|
if (object[i]._otype == OBJ_L2DOORL) OperateL2LDoor(-1, i, false);
|
|
if (object[i]._otype == OBJ_L2DOORR) OperateL2RDoor(-1, i, false);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void SyncOpL3Door(int pnum, int cmd, int i)
|
|
{
|
|
if (pnum == myplr) return;
|
|
bool opok = false;
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if ((cmd == CMD_OPENDOOR) && (object[i]._oVar4 == DOOR_CLOSED)) opok = true;
|
|
if ((cmd == CMD_CLOSEDOOR) && (object[i]._oVar4 == DOOR_OPEN)) opok = true;
|
|
if (opok) {
|
|
if (object[i]._otype == OBJ_L3DOORL) OperateL3LDoor(-1, i, false);
|
|
if (object[i]._otype == OBJ_L3DOORR) OperateL3RDoor(-1, i, false);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void SyncOpObject(int pnum, int cmd, int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
switch (object[i]._otype) {
|
|
case OBJ_L1DOORL :
|
|
case OBJ_L1DOORR :
|
|
SyncOpL1Door(pnum, cmd, i);
|
|
break;
|
|
case OBJ_L2DOORL :
|
|
case OBJ_L2DOORR :
|
|
SyncOpL2Door(pnum, cmd, i);
|
|
break;
|
|
case OBJ_L3DOORL :
|
|
case OBJ_L3DOORR :
|
|
SyncOpL3Door(pnum, cmd, i);
|
|
break;
|
|
case OBJ_SWITCHSKL:
|
|
case OBJ_LEVER :
|
|
OperateLever(pnum, i);
|
|
break;
|
|
case OBJ_CHEST1:
|
|
case OBJ_CHEST2:
|
|
case OBJ_CHEST3:
|
|
case OBJ_TCHEST1:
|
|
case OBJ_TCHEST2:
|
|
case OBJ_TCHEST3:
|
|
OperateChest(pnum, i, FALSE);
|
|
break;
|
|
case OBJ_SARC:
|
|
OperateSarc(pnum, i, FALSE);
|
|
break;
|
|
// case OBJ_BOOKLVR:
|
|
case OBJ_BLINDBOOK:
|
|
case OBJ_BLOODBOOK:
|
|
case OBJ_STEELTOME:
|
|
OperateBookLever(pnum, i);
|
|
break;
|
|
case OBJ_SHRINEL:
|
|
case OBJ_SHRINER:
|
|
OperateShrine(pnum, i, IS_MAGIC);
|
|
break;
|
|
case OBJ_SKELBOOK:
|
|
case OBJ_BOOKSTAND:
|
|
OperateSkelBook(pnum, i, FALSE);
|
|
break;
|
|
case OBJ_BOOKCASEL:
|
|
case OBJ_BOOKCASER:
|
|
OperateBookCase(pnum, i, FALSE);
|
|
break;
|
|
case OBJ_DECAP:
|
|
OperateDecap(pnum, i, FALSE);
|
|
break;
|
|
case OBJ_ARMORSTAND:
|
|
case OBJ_WARARMOR:
|
|
OperateArmorStand(pnum, i, FALSE);
|
|
break;
|
|
case OBJ_GOATSHRINE:
|
|
OperateGoatShrine(pnum, i, LS_GSHRINE);
|
|
break;
|
|
case OBJ_CAULDRON:
|
|
OperateCauldron(pnum, i, LS_CALDRON);
|
|
break;
|
|
case OBJ_MURKYFTN:
|
|
case OBJ_TEARFTN:
|
|
OperateFountains(pnum, i);
|
|
break;
|
|
case OBJ_STORYBOOK:
|
|
OperateStoryBook(pnum, i);
|
|
break;
|
|
case OBJ_PEDISTAL:
|
|
OperatePedistal(pnum, i);
|
|
break;
|
|
case OBJ_WARWEAP:
|
|
case OBJ_WEAPONRACK:
|
|
OperateWeaponRack(pnum, i, FALSE);
|
|
break;
|
|
case OBJ_MUSHPATCH:
|
|
OperateMushPatch(pnum, i);
|
|
break;
|
|
case OBJ_SLAINHERO:
|
|
OperateSlainHero(pnum, i, FALSE);
|
|
break;
|
|
case OBJ_SIGNCHEST:
|
|
OperateInnSignChest(pnum, i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void BreakCrux(int i)
|
|
{
|
|
int j, ot, oi;
|
|
bool mapflag;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oAnimFlag = TRUE;
|
|
object[i]._oAnimFrame = 1;
|
|
object[i]._oAnimDelay = 1;
|
|
object[i]._oSolidFlag = TRUE;
|
|
object[i]._oMissFlag = TRUE;
|
|
object[i]._oBreak = OBJ_BROKEN;
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
|
|
mapflag = true;
|
|
for (j = 0; j < numobjects; ++j) {
|
|
oi = objectactive[j];
|
|
ot = object[oi]._otype;
|
|
if ((ot == OBJ_CRUX1) || (ot == OBJ_CRUX2) || (ot == OBJ_CRUX3)) {
|
|
if (object[i]._oVar8 == object[oi]._oVar8) {
|
|
if (object[oi]._oBreak != OBJ_BROKEN) mapflag = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mapflag) {
|
|
if (!deltaload) PlaySfxLoc(IS_LEVER, object[i]._ox, object[i]._oy);
|
|
ObjChangeMap(object[i]._oVar1, object[i]._oVar2, object[i]._oVar3, object[i]._oVar4);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
// DKT971012: Gary has items.cpp checked out; this should go there
|
|
|
|
void RndUnique(int x, int y, int level)
|
|
{
|
|
int uil[MAXUITEMS];
|
|
int i, numui = 0;
|
|
|
|
for (i=UID_LGTFORGE+1; i < MAXUITEMS && UniqueItemList[i].UIItemId != -1; ++i)
|
|
{
|
|
if (level*2 >= UniqueItemList[i].UIMinLvl)
|
|
uil[numui++] = i;
|
|
}
|
|
|
|
if (numui > 0)
|
|
{
|
|
int uitem = uil[random(0, numui)];
|
|
SpawnUnique(uitem, x, y);
|
|
}
|
|
}
|
|
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void BreakBarrel(int pnum, int i, int dam, BOOL forcebreak, BOOL sendmsg)
|
|
{
|
|
int x, y, oi;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) return; // already broken?
|
|
if (forcebreak) {
|
|
object[i]._oVar1 = 0; // force it to bust open
|
|
} else {
|
|
object[i]._oVar1 -= dam; // normal damage
|
|
// if someone else is breaking the object, and it wasn't a force break
|
|
// message, then it hasn't broken yet.
|
|
if ((pnum != myplr) && (object[i]._oVar1 <= 0)) object[i]._oVar1 = 1;
|
|
}
|
|
if (object[i]._oVar1 > 0) {
|
|
if (!deltaload) PlaySfxLoc(IS_IBOW, object[i]._ox, object[i]._oy);
|
|
return;
|
|
}
|
|
|
|
object[i]._oVar1 = 0; // broken
|
|
object[i]._oAnimFlag = TRUE;
|
|
object[i]._oAnimFrame = 1;
|
|
object[i]._oAnimDelay = 1;
|
|
object[i]._oSolidFlag = FALSE;
|
|
object[i]._oMissFlag = TRUE;
|
|
object[i]._oBreak = OBJ_BROKEN;
|
|
object[i]._oSelFlag = OSEL_NONE;
|
|
object[i]._oPreFlag = TRUE;
|
|
if (deltaload) {
|
|
object[i]._oAnimFrame = object[i]._oAnimLen;
|
|
object[i]._oAnimCnt = 0;
|
|
object[i]._oAnimDelay = 1000;
|
|
return;
|
|
}
|
|
if (object[i]._otype == OBJ_BARRELEX) {
|
|
bool foo;
|
|
|
|
if (currlevel >= CRYPTSTART && currlevel <= CRYPTEND)
|
|
PlaySfxLoc(IS_URNFIRE, object[i]._ox, object[i]._oy);
|
|
else if (currlevel >= HIVESTART && currlevel <= HIVEEND)
|
|
PlaySfxLoc(IS_PODFIRE, object[i]._ox, object[i]._oy);
|
|
else
|
|
PlaySfxLoc(IS_BARLFIRE, object[i]._ox, object[i]._oy);
|
|
for (y = object[i]._oy-1; y <= object[i]._oy+1; ++y) {
|
|
for (x = object[i]._ox-1; x <= object[i]._ox+1; ++x) {
|
|
if (dMonster[x][y] > 0) MonsterTrapHit(dMonster[x][y]-1, 1, 4, 0, MIMT_FIRE, 0);
|
|
if (dPlayer[x][y] > 0) PlayerMHit(dPlayer[x][y]-1, -1, 0, 8, 16, MIMT_FIRE, 0, FALSE, &foo);
|
|
if (dObject[x][y] > 0) {
|
|
oi = dObject[x][y] - 1;
|
|
if ((object[oi]._otype == OBJ_BARRELEX) && (object[oi]._oBreak != OBJ_BROKEN))
|
|
BreakBarrel(pnum, oi, dam, TRUE, sendmsg);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (currlevel >= CRYPTSTART && currlevel <= CRYPTEND)
|
|
PlaySfxLoc(IS_URN, object[i]._ox, object[i]._oy);
|
|
else if (currlevel >= HIVESTART && currlevel <= HIVEEND)
|
|
PlaySfxLoc(IS_POD, object[i]._ox, object[i]._oy);
|
|
else
|
|
PlaySfxLoc(IS_BARREL, object[i]._ox, object[i]._oy);
|
|
SetRndSeed(object[i]._oRndSeed);
|
|
#if CHEATS
|
|
if (uniqcheat)
|
|
RndUnique(object[i]._ox, object[i]._oy, currlevel);
|
|
else
|
|
#endif
|
|
if (object[i]._oVar2 <= 1) {
|
|
if (!object[i]._oVar3) CreateRndUseful(pnum, object[i]._ox, object[i]._oy, sendmsg);
|
|
else CreateRndItem(object[i]._ox, object[i]._oy, FALSE, sendmsg, FALSE);
|
|
}
|
|
if (object[i]._oVar2 >= 8) SpawnSkeleton(object[i]._oVar4, object[i]._ox, object[i]._oy);
|
|
}
|
|
|
|
|
|
if (pnum == myplr) NetSendCmdParam2(FALSE,CMD_BREAKOBJ,pnum,i);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void BreakObject(int pnum, int oi)
|
|
{
|
|
int objdam, mind, maxd;
|
|
|
|
if (pnum != -1) {
|
|
mind = plr[pnum]._pIMinDam;
|
|
maxd = plr[pnum]._pIMaxDam;
|
|
objdam = random(163,maxd - mind + 1) + mind;
|
|
objdam += (objdam * plr[pnum]._pIBonusDam) / 100;
|
|
objdam += plr[pnum]._pIBonusDamMod + plr[pnum]._pDamageMod;
|
|
} else objdam = 10;
|
|
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
switch (object[oi]._otype) {
|
|
case OBJ_CRUX1 :
|
|
case OBJ_CRUX2 :
|
|
case OBJ_CRUX3 :
|
|
BreakCrux(oi);
|
|
break;
|
|
case OBJ_BARREL:
|
|
case OBJ_BARRELEX:
|
|
BreakBarrel(pnum, oi, objdam, FALSE, TRUE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void SyncBreakObj(int pnum, int oi)
|
|
{
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
switch (object[oi]._otype) {
|
|
case OBJ_BARREL:
|
|
case OBJ_BARRELEX:
|
|
BreakBarrel(pnum, oi, 0, TRUE, FALSE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void SyncL1Doors(int i)
|
|
{
|
|
int dx, dy;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oVar4 == DOOR_CLOSED) {
|
|
object[i]._oMissFlag = FALSE;
|
|
return;
|
|
} else object[i]._oMissFlag = TRUE;
|
|
dx = object[i]._ox;
|
|
dy = object[i]._oy;
|
|
object[i]._oSelFlag = OSEL_TOP;
|
|
if (currlevel < HIVESTART)
|
|
{
|
|
if (object[i]._otype == OBJ_L1DOORL) {
|
|
if (object[i]._oVar1 == 214) ObjSetMicro(dx,dy,408); //Blood
|
|
else ObjSetMicro(dx,dy,393);
|
|
dSpecial[dx][dy] = 7;
|
|
ObjSetMicro12(dx-1,dy);
|
|
--dy;
|
|
} else {
|
|
ObjSetMicro(dx,dy,395);
|
|
if (currlevel < HIVESTART)
|
|
dSpecial[dx][dy] = 8;
|
|
ObjSetMicro12(dx,dy-1);
|
|
--dx;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (object[i]._otype == OBJ_L1DOORL) {
|
|
ObjSetMicro(dx,dy,206);
|
|
dSpecial[dx][dy] = 1;
|
|
ObjSetMicro12(dx-1,dy);
|
|
--dy;
|
|
} else {
|
|
ObjSetMicro(dx,dy,209);
|
|
dSpecial[dx][dy] = 2;
|
|
ObjSetMicro12(dx,dy-1);
|
|
--dx;
|
|
}
|
|
}
|
|
|
|
DoorSet(i, dx, dy);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void SyncCrux(int i)
|
|
{
|
|
int j, ot, oi;
|
|
bool mapflag;
|
|
|
|
mapflag = TRUE;
|
|
for (j = 0; j < numobjects; ++j) {
|
|
oi = objectactive[j];
|
|
app_assert((DWORD)oi < MAXOBJECTS);
|
|
ot = object[oi]._otype;
|
|
if ((ot == OBJ_CRUX1) || (ot == OBJ_CRUX2) || (ot == OBJ_CRUX3)) {
|
|
if (object[i]._oVar8 == object[oi]._oVar8) {
|
|
if (object[oi]._oBreak != OBJ_BROKEN) mapflag = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mapflag) ObjChangeMap(object[i]._oVar1, object[i]._oVar2, object[i]._oVar3, object[i]._oVar4);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void SyncLever(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oSelFlag == OSEL_NONE) {
|
|
ObjChangeMap(object[i]._oVar1, object[i]._oVar2, object[i]._oVar3, object[i]._oVar4);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void SyncQSTLever(int i)
|
|
{
|
|
int tren;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oAnimFrame == object[i]._oVar6) {
|
|
ObjChangeMapResync(object[i]._oVar1, object[i]._oVar2, object[i]._oVar3, object[i]._oVar4);
|
|
if (object[i]._otype == OBJ_BLINDBOOK) {
|
|
tren = TransVal;
|
|
TransVal = 9;
|
|
DRLG_MRectTrans(object[i]._oVar1, object[i]._oVar2, object[i]._oVar3, object[i]._oVar4);
|
|
TransVal = tren;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void SyncPedistal(int i)
|
|
{
|
|
byte *setp;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oVar6 == 1) {
|
|
ObjChangeMapResync(setpc_x, setpc_y + 3, setpc_x + 2, setpc_y + 7);
|
|
}
|
|
if (object[i]._oVar6 == 2) {
|
|
ObjChangeMapResync(setpc_x, setpc_y + 3, setpc_x + 2, setpc_y + 7);
|
|
ObjChangeMapResync(setpc_x + 6, setpc_y + 3, setpc_x + setpc_w, setpc_y + 7);
|
|
}
|
|
if (object[i]._oVar6 == 3) {
|
|
ObjChangeMapResync(object[i]._oVar1, object[i]._oVar2, object[i]._oVar3, object[i]._oVar4);
|
|
setp = LoadFileInMemSig("Levels\\L2Data\\Blood2.DUN", NULL, 'STPC');
|
|
LoadMapObjs(setp, (setpc_x << 1), (setpc_y << 1));
|
|
DiabloFreePtr(setp);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void SyncL2Doors(int i)
|
|
{
|
|
int dx, dy;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
if (object[i]._oVar4 == DOOR_CLOSED) object[i]._oMissFlag = FALSE;
|
|
else object[i]._oMissFlag = TRUE;
|
|
dx = object[i]._ox;
|
|
dy = object[i]._oy;
|
|
object[i]._oSelFlag = OSEL_TOP;
|
|
|
|
//Fix doors upon returning to level or loading level
|
|
if ((object[i]._otype == OBJ_L2DOORL) &&
|
|
(object[i]._oVar4 == DOOR_CLOSED)) {
|
|
ObjSetMicro(dx,dy,538);
|
|
} else if ((object[i]._otype == OBJ_L2DOORL) &&
|
|
((object[i]._oVar4 == DOOR_OPEN) ||
|
|
(object[i]._oVar4 == DOOR_BLOCKED))) {
|
|
ObjSetMicro(dx,dy,13);
|
|
} else if ((object[i]._otype == OBJ_L2DOORR) &&
|
|
(object[i]._oVar4 == DOOR_CLOSED)) {
|
|
ObjSetMicro(dx,dy,540);
|
|
} else if ((object[i]._otype == OBJ_L2DOORR) &&
|
|
((object[i]._oVar4 == DOOR_OPEN) ||
|
|
(object[i]._oVar4 == DOOR_BLOCKED))) {
|
|
ObjSetMicro(dx,dy,17);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
static void SyncL3Doors(int i)
|
|
{
|
|
int dx, dy;
|
|
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
object[i]._oMissFlag = TRUE;
|
|
dx = object[i]._ox;
|
|
dy = object[i]._oy;
|
|
object[i]._oSelFlag = OSEL_TOP;
|
|
|
|
//Fix doors upon returning to level or loading level
|
|
if ((object[i]._otype == OBJ_L3DOORL) &&
|
|
(object[i]._oVar4 == DOOR_CLOSED)) {
|
|
ObjSetMicro(dx,dy,531);
|
|
} else if ((object[i]._otype == OBJ_L3DOORL) &&
|
|
((object[i]._oVar4 == DOOR_OPEN) ||
|
|
(object[i]._oVar4 == DOOR_BLOCKED))) {
|
|
ObjSetMicro(dx,dy,538);
|
|
} else if ((object[i]._otype == OBJ_L3DOORR) &&
|
|
(object[i]._oVar4 == DOOR_CLOSED)) {
|
|
ObjSetMicro(dx,dy,534);
|
|
} else if ((object[i]._otype == OBJ_L3DOORR) &&
|
|
((object[i]._oVar4 == DOOR_OPEN) ||
|
|
(object[i]._oVar4 == DOOR_BLOCKED))) {
|
|
ObjSetMicro(dx,dy,541);
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void SyncObjectAnim(int o)
|
|
{
|
|
int ai, ot, j;
|
|
|
|
app_assert((DWORD)o < MAXOBJECTS);
|
|
ot = object[o]._otype;
|
|
ai = AllObjects[ot].ofindex;
|
|
for (j = 0; ObjFileList[j] != ai; ++j);
|
|
object[o]._oAnimData = pObjCels[j];
|
|
|
|
switch (object[o]._otype) {
|
|
case OBJ_L1DOORL :
|
|
case OBJ_L1DOORR :
|
|
SyncL1Doors(o);
|
|
break;
|
|
case OBJ_L2DOORL :
|
|
case OBJ_L2DOORR :
|
|
SyncL2Doors(o);
|
|
break;
|
|
case OBJ_L3DOORL :
|
|
case OBJ_L3DOORR :
|
|
SyncL3Doors(o);
|
|
break;
|
|
case OBJ_CRUX1 :
|
|
case OBJ_CRUX2 :
|
|
case OBJ_CRUX3 :
|
|
SyncCrux(o);
|
|
break;
|
|
case OBJ_SWITCHSKL:
|
|
case OBJ_LEVER :
|
|
case OBJ_BOOK2L:
|
|
SyncLever(o);
|
|
break;
|
|
case OBJ_BLINDBOOK:
|
|
case OBJ_STEELTOME:
|
|
case OBJ_BOOK2R:
|
|
SyncQSTLever(o);
|
|
break;
|
|
case OBJ_PEDISTAL:
|
|
SyncPedistal(o);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*
|
|
**-----------------------------------------------------------------------*/
|
|
|
|
void GetObjectStr(int i)
|
|
{
|
|
app_assert((DWORD)i < MAXOBJECTS);
|
|
switch (object[i]._otype) {
|
|
case OBJ_CRUX1 :
|
|
case OBJ_CRUX2 :
|
|
case OBJ_CRUX3 :
|
|
strcpy(infostr, "Crucified Skeleton");
|
|
break;
|
|
case OBJ_LEVER :
|
|
case OBJ_FLAMELVR:
|
|
strcpy(infostr, "Lever");
|
|
break;
|
|
case OBJ_L1DOORL :
|
|
case OBJ_L1DOORR :
|
|
case OBJ_L2DOORL :
|
|
case OBJ_L2DOORR :
|
|
case OBJ_L3DOORL :
|
|
case OBJ_L3DOORR :
|
|
if (object[i]._oVar4 == DOOR_OPEN) strcpy(infostr, "Open Door");
|
|
if (object[i]._oVar4 == DOOR_CLOSED) strcpy(infostr, "Closed Door");
|
|
if (object[i]._oVar4 == DOOR_BLOCKED) strcpy(infostr, "Blocked Door");
|
|
break;
|
|
case OBJ_BOOK2L:
|
|
if (setlevel) {
|
|
if (setlvlnum == SL_BONECHAMB)
|
|
strcpy(infostr, "Ancient Tome");
|
|
else if (setlvlnum == SL_VILEBETRAYER)
|
|
strcpy(infostr, "Book of Vileness");
|
|
}
|
|
break;
|
|
case OBJ_SWITCHSKL:
|
|
strcpy(infostr, "Skull Lever");
|
|
break;
|
|
// case OBJ_BOOKLVR:
|
|
// strcpy(infostr, "Tome");
|
|
// break;
|
|
case OBJ_BOOK2R:
|
|
strcpy(infostr, "Mythical Book");
|
|
break;
|
|
case OBJ_CHEST1:
|
|
case OBJ_TCHEST1:
|
|
strcpy(infostr, "Small Chest");
|
|
break;
|
|
case OBJ_CHEST2:
|
|
case OBJ_TCHEST2:
|
|
strcpy(infostr, "Chest");
|
|
break;
|
|
case OBJ_CHEST3:
|
|
case OBJ_TCHEST3:
|
|
case OBJ_SIGNCHEST:
|
|
strcpy(infostr, "Large Chest");
|
|
break;
|
|
case OBJ_SARC:
|
|
strcpy(infostr, "Sarcophagus");
|
|
break;
|
|
case OBJ_BOOKSHELF:
|
|
strcpy(infostr, "Bookshelf");
|
|
break;
|
|
case OBJ_BOOKCASEL:
|
|
case OBJ_BOOKCASER:
|
|
strcpy(infostr, "Bookcase");
|
|
break;
|
|
case OBJ_BARREL:
|
|
case OBJ_BARRELEX:
|
|
if (currlevel >= HIVESTART && currlevel <= HIVEEND)
|
|
strcpy(infostr, "Pod");
|
|
else if (currlevel >= CRYPTSTART && currlevel <= CRYPTEND)
|
|
strcpy(infostr, "Urn");
|
|
else
|
|
strcpy(infostr, "Barrel");
|
|
break;
|
|
case OBJ_SHRINEL:
|
|
case OBJ_SHRINER:
|
|
sprintf(tempstr, "%s Shrine", shrinestrs[object[i]._oVar1]);
|
|
strcpy(infostr, tempstr);
|
|
break;
|
|
case OBJ_SKELBOOK:
|
|
strcpy(infostr, "Skeleton Tome");
|
|
break;
|
|
case OBJ_BOOKSTAND:
|
|
strcpy(infostr, "Library Book");
|
|
break;
|
|
case OBJ_BLOODFTN:
|
|
strcpy(infostr, "Blood Fountain");
|
|
break;
|
|
case OBJ_DECAP:
|
|
strcpy(infostr, "Decapitated Body");
|
|
break;
|
|
case OBJ_BLINDBOOK:
|
|
strcpy(infostr, "Book of the Blind");
|
|
break;
|
|
case OBJ_STEELTOME:
|
|
strcpy(infostr, "Steel Tome");
|
|
break;
|
|
case OBJ_BLOODBOOK:
|
|
strcpy(infostr, "Book of Blood");
|
|
break;
|
|
case OBJ_PURIFYINGFTN:
|
|
strcpy(infostr, "Purifying Spring");
|
|
break;
|
|
case OBJ_ARMORSTAND:
|
|
case OBJ_WARARMOR:
|
|
strcpy(infostr, "Armor");
|
|
break;
|
|
case OBJ_WARWEAP:
|
|
strcpy(infostr, "Weapon Rack");
|
|
break;
|
|
case OBJ_GOATSHRINE:
|
|
strcpy(infostr, "Goat Shrine");
|
|
break;
|
|
case OBJ_CAULDRON:
|
|
strcpy(infostr, "Cauldron");
|
|
break;
|
|
case OBJ_MURKYFTN:
|
|
strcpy(infostr, "Murky Pool");
|
|
break;
|
|
case OBJ_TEARFTN:
|
|
strcpy(infostr, "Fountain of Tears");
|
|
break;
|
|
case OBJ_PEDISTAL:
|
|
strcpy(infostr, "Pedestal of Blood");
|
|
break;
|
|
case OBJ_STORYBOOK:
|
|
strcpy(infostr, StoryBookName[object[i]._oVar3]);
|
|
break;
|
|
case OBJ_WEAPONRACK:
|
|
strcpy(infostr, "Weapon Rack");
|
|
break;
|
|
case OBJ_MUSHPATCH:
|
|
strcpy(infostr, "Mushroom Patch");
|
|
break;
|
|
case OBJ_LAZSTAND:
|
|
strcpy(infostr, "Vile Stand");
|
|
break;
|
|
case OBJ_SLAINHERO:
|
|
strcpy(infostr, "Slain Hero");
|
|
break;
|
|
}
|
|
if ((plr[myplr]._pClass == CLASS_ROGUE) && (object[i]._oTrapFlag)) {
|
|
sprintf(tempstr, "Trapped %s", infostr);
|
|
strcpy(infostr, tempstr);
|
|
infoclr = ICOLOR_RED;
|
|
}
|
|
}
|
|
|
|
static void SpellBook (int number, int locx, int locy)
|
|
{
|
|
AddSkulkenObject(OBJ_STORYBOOK, number, locx, locy);
|
|
|
|
|
|
}
|
|
|
|
static void AddNa_Krul_Stuff()
|
|
{
|
|
int spell;
|
|
|
|
AddNaKrulLeverObj();
|
|
|
|
spell = random(0, 6);
|
|
switch (spell)
|
|
{
|
|
case 0:
|
|
SpellBook(6, Na_Krul.x + 3, Na_Krul.y);
|
|
SpellBook(7, Na_Krul.x + 2, Na_Krul.y - 3);
|
|
SpellBook(8, Na_Krul.x + 2, Na_Krul.y + 2);
|
|
break;
|
|
case 1:
|
|
SpellBook(6, Na_Krul.x + 3, Na_Krul.y);
|
|
SpellBook(8, Na_Krul.x + 2, Na_Krul.y - 3);
|
|
SpellBook(7, Na_Krul.x + 2, Na_Krul.y + 2);
|
|
break;
|
|
case 2:
|
|
SpellBook(7, Na_Krul.x + 3, Na_Krul.y);
|
|
SpellBook(6, Na_Krul.x + 2, Na_Krul.y - 3);
|
|
SpellBook(8, Na_Krul.x + 2, Na_Krul.y + 2);
|
|
break;
|
|
case 3:
|
|
SpellBook(7, Na_Krul.x + 3, Na_Krul.y);
|
|
SpellBook(8, Na_Krul.x + 2, Na_Krul.y - 3);
|
|
SpellBook(6, Na_Krul.x + 2, Na_Krul.y + 2);
|
|
break;
|
|
case 4:
|
|
SpellBook(8, Na_Krul.x + 3, Na_Krul.y);
|
|
SpellBook(7, Na_Krul.x + 2, Na_Krul.y - 3);
|
|
SpellBook(6, Na_Krul.x + 2, Na_Krul.y + 2);
|
|
break;
|
|
case 5:
|
|
SpellBook(8, Na_Krul.x + 3, Na_Krul.y);
|
|
SpellBook(6, Na_Krul.x + 2, Na_Krul.y - 3);
|
|
SpellBook(7, Na_Krul.x + 2, Na_Krul.y + 2);
|
|
break;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
static bool HCheckSpell(int number)
|
|
{
|
|
|
|
switch (number)
|
|
{
|
|
case 6:
|
|
SpellProgress = 1;
|
|
break;
|
|
case 7:
|
|
if (SpellProgress == 1)
|
|
SpellProgress = 2;
|
|
else
|
|
SpellProgress = 0;
|
|
break;
|
|
case 8:
|
|
if (SpellProgress == 2)
|
|
{
|
|
// qtextflag = FALSE;
|
|
// stream_stop();
|
|
return true;
|
|
}
|
|
else
|
|
SpellProgress = 0;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
void OpenNaKrul()
|
|
{
|
|
if (currlevel == NA_KRUL_LEVEL)
|
|
{
|
|
PlaySfxLoc(CR_DOOROPEN, Na_Krul.x, Na_Krul.y);
|
|
dPiece[Na_Krul.x][Na_Krul.y] = 298;
|
|
dPiece[Na_Krul.x][Na_Krul.y - 1] = 301;
|
|
dPiece[Na_Krul.x][Na_Krul.y - 2] = 300;
|
|
dPiece[Na_Krul.x][Na_Krul.y + 1] = 299;
|
|
|
|
SetDungeonMicros();
|
|
}
|
|
}
|
|
|
|
void OpenNaKrul2()
|
|
{
|
|
dPiece[Na_Krul.x][Na_Krul.y] = 298;
|
|
dPiece[Na_Krul.x][Na_Krul.y - 1] = 301;
|
|
dPiece[Na_Krul.x][Na_Krul.y - 2] = 300;
|
|
dPiece[Na_Krul.x][Na_Krul.y + 1] = 299;
|
|
|
|
SetDungeonMicros();
|
|
}
|
|
|
|
static void AddNaKrulLeverObj()
|
|
{
|
|
int xp, yp;
|
|
while (1) {
|
|
xp = random(141,80) + DIRTEDGED2;
|
|
yp = random(141,80) + DIRTEDGED2;
|
|
if (! RndLocOk(xp-1, yp-1)) continue;
|
|
if (! RndLocOk(xp+0, yp-1)) continue;
|
|
if (! RndLocOk(xp+1, yp-1)) continue;
|
|
if (! RndLocOk(xp-1, yp+0)) continue;
|
|
if (! RndLocOk(xp+0, yp+0)) continue;
|
|
if (! RndLocOk(xp+1, yp+0)) continue;
|
|
if (! RndLocOk(xp-1, yp+1)) continue;
|
|
if (! RndLocOk(xp+0, yp+1)) continue;
|
|
if (! RndLocOk(xp+1, yp+1)) continue;
|
|
break;
|
|
}
|
|
|
|
// temp test
|
|
xp = Na_Krul.x + 3;
|
|
yp = Na_Krul.y - 1;
|
|
|
|
Na_Krul.LeverX = xp;
|
|
Na_Krul.LeverY = yp;
|
|
AddObject(OBJ_LEVER, xp, yp);
|
|
}
|
|
|