hans/Hellfire
1
0
Fork 0
mirror of https://github.com/jmarshall23/Hellfire.git synced 2026-08-11 23:40:51 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
main
Hellfire/MISSILES.SAV
T
Justin Marshall 101266ab72 Initial commit.
2026-04-27 10:35:40 -07:00

6890 lines
202 KiB
Plaintext
Raw Permalink Blame History

/*-----------------------------------------------------------------------**
** Diablo
**
** Missiles file
**
** (C)1995 Condor, Inc. All rights reserved.
**
**-----------------------------------------------------------------------**
** $Header: /Diablo/MISSILES.CPP 3 2/25/97 2:27p Jmcreynolds $
**-----------------------------------------------------------------------**
**
** File Routines
**-----------------------------------------------------------------------*/
#include "diablo.h"
#pragma hdrstop
#include <math.h>
#include <limits>
#include "sound.h"
#include "missiles.h"
#include "misdat.h"
#include "engine.h"
#include "gendung.h"
#include "lighting.h"
#include "items.h"
#include "player.h"
#include "monster.h"
#include "monstdat.h"
#include "monstint.h"
#include "control.h"
#include "objects.h"
#include "objdat.h"
#include "spells.h"
#include "cursor.h"
#include "dead.h"
#include "effects.h"
#include "palette.h"
#include "inv.h"
#include "msg.h"
#include "quests.h"
#include "itemdat.h"
#include "multi.h"
#include "trigs.h"
#include "scrollrt.h"
/*-----------------------------------------------------------------------*
** Constants
**-----------------------------------------------------------------------*/
#if RLE_DRAW
#define CEL_EXT ".CL2"
#else
#define CEL_EXT ".CEL"
#endif
/*-----------------------------------------------------------------------*
** Global Variables
**-----------------------------------------------------------------------*/
MissileStruct missile[MAXMISSILES];
int nummissiles;
static int missilevars[MAXMISSILES][3]; //0 missile num; 1 var1; 2 var2
static int nummissilevars;
int missileactive[MAXMISSILES];
int missileavail[MAXMISSILES];
int XDirAdd[8] = { 1, 0, -1, -1, -1, 0, 1, 1 };
int YDirAdd[8] = { 1, 1, 1, 0, -1, -1, -1, 0 };
// Indexes into the CrawlTable.
static int const CrawlNum[19] = { 0, 3, 12, 45, 94, 159, 240, 337, 450, 579, 724,
885, 1062, 1255, 1464, 1689, 1930, 2187, 2460 };
BOOL ManashieldFlag;
BOOL MissilePreFlag;
typedef BOOL (*CHECKFUNC)(int x, int y);
static void GetMissilePos(int i);
/*-----------------------------------------------------------------------**
**----------------------- General use routines --------------------------**
**-----------------------------------------------------------------------*/
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void GetDamageAmt(int i, int * mind, int * maxd)
{
int k, sl;
app_assert(myplr < MAX_PLRS);
app_assert(i < 64);
sl = plr[myplr]._pSplLvl[i] + plr[myplr]._pISplLvlAdd;
switch (i) {
case SPL_FIREBOLT:
*mind = 1 + (plr[myplr]._pMagic >> 3) + sl;
*maxd = 10 + (plr[myplr]._pMagic >> 3) + sl;
break;
case SPL_HEAL:
*mind = 1 + plr[myplr]._pLevel + sl;
if (plr[myplr]._pClass == CLASS_WARRIOR) *mind = *mind << 1;
else if (plr[myplr]._pClass == CLASS_ROGUE ||
plr[myplr]._pClass == CLASS_BARD) *mind += (*mind >> 1);
*maxd = 10;
for (k = 0; k < plr[myplr]._pLevel; ++k) *maxd += 4;
for (k = 0; k < sl; ++k) *maxd += 6;
if (plr[myplr]._pClass == CLASS_WARRIOR) *maxd = *maxd << 1;
else if (plr[myplr]._pClass == CLASS_ROGUE ||
plr[myplr]._pClass == CLASS_BARD) *maxd += (*maxd >> 1);
*mind = -1;
*maxd = -1;
break;
case SPL_LIGHTNING:
*mind = 2;
*maxd = plr[myplr]._pLevel + 2;
break;
case SPL_FLASH:
*mind = plr[myplr]._pLevel;
for (k = sl; k > 0; --k) *mind += (*mind >> 3);
*mind += *mind >> 1;
*maxd = *mind << 1; // this is not actual(below is) - its a kludge to make it seem acurate text wise
/**maxd = 0;
for (k = 0; k <= plr[myplr]._pLevel; ++k) *maxd += 20;
for (k = sl; k > 0; --k) *maxd += (*maxd >> 3);
*maxd += *maxd >> 1;*/
break;
case SPL_IDENTIFY:
case SPL_TOWN:
case SPL_STONE:
case SPL_INFRA:
case SPL_PHASE:
case SPL_MANASHLD:
case SPL_DOOM:
case SPL_BLOODR:
case SPL_INVIS:
case SPL_BLOODB:
case SPL_TELE:
case SPL_ETHER:
case SPL_REPAIR:
case SPL_RECHARGE:
case SPL_DISARM:
case SPL_RESURRECT:
case SPL_TELEKINESIS:
case SPL_BONESPIRIT:
*mind = -1;
*maxd = -1;
break;
case SPL_WALL:
*mind = ((2 + plr[myplr]._pLevel) << 2) >> 1;
*maxd = ((20 + plr[myplr]._pLevel) << 2) >> 1;
break;
case SPL_FIREBALL:
*mind = (2 + plr[myplr]._pLevel) << 1;
for (k = sl; k > 0; --k) *mind += (*mind >> 3);
*maxd = (20 + plr[myplr]._pLevel) << 1;
for (k = sl; k > 0; --k) *maxd += (*maxd >> 3);
break;
case SPL_GUARDIAN:
*mind = 1 + (plr[myplr]._pLevel >> 1);
for (k = sl; k > 0; --k) *mind += (*mind >> 3);
*maxd = 10 + (plr[myplr]._pLevel >> 1);
for (k = sl; k > 0; --k) *maxd += (*maxd >> 3);
break;
case SPL_CHAIN:
// this is not actual - its a kludge to make it seem acurate text wise
*mind = 2 << 1;
*maxd = (plr[myplr]._pLevel + 2) << 1;
break;
case SPL_WAVE:
// this is not actual - its a kludge to make it seem acurate text wise
*mind = ((1 + plr[myplr]._pLevel) << 2) + ((1 + plr[myplr]._pLevel) << 1);
*maxd = ((10 + plr[myplr]._pLevel) << 2) + ((10 + plr[myplr]._pLevel) << 1);
break;
case SPL_NOVA:
// this is not actual - its a kludge to make it seem acurate text wise
*mind = (5 + plr[myplr]._pLevel) >> 1;
for (k = sl; k > 0; --k) *mind += (*mind >> 3);
*mind = (*mind << 2) + *mind;
*maxd = (30 + plr[myplr]._pLevel) >> 1;
for (k = sl; k > 0; --k) *maxd += (*maxd >> 3);
*maxd = (*maxd << 2) + *maxd;
break;
case SPL_FLAME:
*mind = 2;
*mind += *mind >> 1;
*maxd = (plr[myplr]._pLevel + 4);
*maxd += *maxd >> 1;
break;
case SPL_GOLEM:
*mind = 11;
*maxd = 17;
break;
case SPL_APOCA:
*mind = 0;
for (k = 0; k < plr[myplr]._pLevel; ++k) *mind += 1;
*maxd = 0;
for (k = 0; k < plr[myplr]._pLevel; ++k) *maxd += 6;
break;
case SPL_ELEMENT:
*mind = (2 + plr[myplr]._pLevel) << 1;
for (k = sl; k > 0; --k) *mind += (*mind >> 3);
*maxd = (20 + plr[myplr]._pLevel) << 1;
for (k = sl; k > 0; --k) *maxd += (*maxd >> 3);
break;
case SPL_CBOLT:
*mind = 1;
*maxd = 1 + (plr[myplr]._pMagic >> 2);
break;
case SPL_HBOLT:
*mind = 9 + plr[myplr]._pLevel;
*maxd = 18 + plr[myplr]._pLevel;
break;
case SPL_HEALOTHER:
*mind = 1 + plr[myplr]._pLevel + sl;
if (plr[myplr]._pClass == CLASS_WARRIOR) *mind = *mind << 1;
if (plr[myplr]._pClass == CLASS_ROGUE ||
plr[myplr]._pClass == CLASS_BARD ) *mind += (*mind >> 1);
*maxd = 10;
for (k = 0; k < plr[myplr]._pLevel; ++k) *maxd += 4;
for (k = 0; k < sl; ++k) *maxd += 6;
if (plr[myplr]._pClass == CLASS_WARRIOR) *maxd = *maxd << 1;
if (plr[myplr]._pClass == CLASS_ROGUE ||
plr[myplr]._pClass == CLASS_BARD ) *maxd += (*maxd >> 1);
*mind = -1;
*maxd = -1;
break;
case SPL_BSTAR:
*mind = ((plr[myplr]._pMagic>>1)-(plr[myplr]._pMagic>>3)) + (sl << 1) + sl;
*maxd = *mind;
break;
}
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
int CheckBlock(int fx, int fy, int tx, int ty)
{
int pn, dir, coll;
coll = 0;
while ((fx != tx) || (fy != ty)) {
dir = GetDirection(fx, fy, tx, ty);
fx += XDirAdd[dir];
fy += YDirAdd[dir];
app_assert(fx < MAXDUNX);
app_assert(fy < MAXDUNY);
pn = dPiece[fx][fy];
app_assert(pn <= MAXTILES);
if (nSolidTable[pn]) coll = 1;
}
return coll;
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
int FindClosest(int sx, int sy, int rad)
{
int cr, cidx, cent, cne, mid, tx, ty;
if (rad > 19) rad = 19;
for (cr = 1; cr < rad; ++cr) {
cidx = CrawlNum[cr];
cent = cidx + 1;
for (cne = CrawlTable[cidx]; cne > 0; --cne) {
tx = sx + CrawlTable[cent];
ty = sy + CrawlTable[(cent + 1)];
if (tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
mid = dMonster[tx][ty];
if ((mid > 0) && (CheckBlock(sx, sy, tx, ty) == 0))
return (mid - 1);
}
cent += 2;
}
}
return (-1);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
static bool SetMissileLocation(int i, int *sx, int *sy, int rad)
{
bool success = false;
if (rad > 19) rad = 19;
for (int cr = 1; cr < rad && !success; ++cr) {
int const cidx = CrawlNum[cr];
int cent = cidx + 1;
for (int cne = CrawlTable[cidx]; cne > 0; --cne, cent += 2) {
int const tx = *sx + CrawlTable[cent];
int const ty = *sy + CrawlTable[(cent + 1)];
if (tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
int const pn = dPiece[tx][ty];
if (!nSolidTable[pn] && dObject[tx][ty] == 0) {
missile[i]._mix = tx;
missile[i]._miy = ty;
*sx = tx;
*sy = ty;
success = true;
break;
}
}
}
}
return (success);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
int GetSpellLevel(int id, int sn)
{
int rv;
app_assert(id < MAX_PLRS);
app_assert(sn < 64);
if (id == myplr)
rv = plr[id]._pSplLvl[sn] + plr[id]._pISplLvlAdd;
else
rv = 1;
if (rv < 0 ) rv = 0;
return (rv);
}
#if 0 // UNUSED
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void RndBlood(int x, int y, int type, int dam, int hp)
{
int pct, str;
app_assert(hp != 0);
str = 0;
pct = (dam * 100) / hp;
if (pct > 65) str = 1;
if (pct > 80) str = 2;
if (pct > 90) str = 3;
str = 1;
//AddMissile(x, y, str, 0, 0, type, 0, myplr, 0);
}
#endif
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
static int GetDirection8(int x1, int y1, int x2, int y2)
{
BYTE const Dirs[16][16] = {
{ 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 0
{ 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 1
{ 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 2
{ 2, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 }, // 3
{ 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 }, // 4
{ 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0 }, // 5
{ 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // 6
{ 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // 7
{ 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // 8
{ 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // 9
{ 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // 10
{ 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // 11
{ 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // 12
{ 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // 13
{ 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // 14
{ 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }};// 15
BYTE const lrtoul[3] = { 3, 4, 5 };
BYTE const urtoll[3] = { 3, 2, 1 };
BYTE const lltour[3] = { 7, 6, 5 };
BYTE const ultolr[3] = { 7, 0, 1 };
int mx, my, md;
mx = abs(x2 - x1);
if (mx > 15) mx = 15;
my = abs(y2 - y1);
if (my > 15) my = 15;
md = Dirs[my][mx];
if (x1 > x2) {
if (y1 > y2) md = lrtoul[md];
else md = urtoll[md];
} else {
if (y1 > y2) md = lltour[md];
else md = ultolr[md];
}
return (md);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
static int GetDirection16(int x1, int y1, int x2, int y2)
{
const BYTE Dirs[16][16] = {
{ 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 0
{ 4, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, // 1
{ 4, 3, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 }, // 2
{ 4, 3, 3, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 }, // 3
{ 4, 4, 3, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // 4
{ 4, 4, 3, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, // 5
{ 4, 4, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1 }, // 6
{ 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1 }, // 7
{ 4, 4, 4, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1 }, // 8
{ 4, 4, 4, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, 1 }, // 9
{ 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1 }, // 10
{ 4, 4, 4, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1 }, // 11
{ 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2 }, // 12
{ 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2 }, // 13
{ 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2 }, // 14
{ 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2 }};// 15
const BYTE lrtoul[5] = { 6, 7, 8, 9, 10 };
const BYTE urtoll[5] = { 6, 5, 4, 3, 2 };
const BYTE lltour[5] = { 14, 13, 12, 11, 10 };
const BYTE ultolr[5] = { 14, 15, 0, 1, 2 };
int mx, my, md;
mx = abs(x2 - x1);
if (mx > 15) mx = 15;
my = abs(y2 - y1);
if (my > 15) my = 15;
md = Dirs[my][mx];
if (x1 > x2) {
if (y1 > y2) md = lrtoul[md];
else md = urtoll[md];
} else {
if (y1 > y2) md = lltour[md];
else md = ultolr[md];
}
return (md);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void DeleteMissile(int mi, int i)
{
app_assert(nummissiles <= MAXMISSILES);
missileavail[MAXMISSILES - nummissiles] = mi;
--nummissiles;
if ((nummissiles > 0) && (i != nummissiles)) {
app_assert(i < MAXMISSILES);
missileactive[i] = missileactive[nummissiles];
}
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
static void GetMissileVel(int i, int sx, int sy, int dx, int dy, int v)
{
double dxp, dyp, dr;
dxp = (((dx - sx) << 5) - ((dy - sy) << 5)) << 16;
dyp = (((dx - sx) << 5) + ((dy - sy) << 5)) << 16;
dr = sqrt((dxp * dxp) + (dyp * dyp));
app_assert(i < MAXMISSILES);
missile[i]._mixvel = static_cast<long>(((v << 16) * dxp) / dr);
missile[i]._miyvel = static_cast<long>(((v << 15) * dyp) / dr);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
static void PutMissile(int i)
{
int mx, my;
app_assert(i < MAXMISSILES);
mx = missile[i]._mix;
my = missile[i]._miy;
if (mx <= 0 || my <= 0 || mx >= DMAXX || my >= DMAXY)
missile[i]._miDelFlag = TRUE;
if (!missile[i]._miDelFlag) {
dFlags[mx][my] |= BFLAG_MISSILE;
if (dMissile[mx][my] == 0) dMissile[mx][my] = (char)i + 1;
else dMissile[mx][my] = -1;
if (missile[i]._miPreFlag) MissilePreFlag = TRUE;
}
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
static BYTE GetDirNum(int mi)
{
app_assert(mi < MAXMISSILES);
return (misfiledata[(missile[mi]._miAnimType)].mAnimFAmt >= 8) ? missile[mi]._mimfnum : 0;
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
static void GetMissilePos(int i)
{
long mx, my;
long dx, dy;
long lx, ly; // lighting offsets
app_assert(i < MAXMISSILES);
mx = missile[i]._mitxoff >> 16;
my = missile[i]._mityoff >> 16;
dx = (mx + (my << 1));
dy = ((my << 1) - mx);
if (dx < 0) {
lx = -((-dx) >> 3);
dx = -((-dx) >> 6);
} else {
lx = dx >> 3;
dx = dx >> 6;
}
if (dy < 0) {
ly = -((-dy) >> 3);
dy = -((-dy) >> 6);
} else {
ly = dy >> 3;
dy = dy >> 6;
}
missile[i]._mix = dx + missile[i]._misx;
missile[i]._miy = dy + missile[i]._misy;
missile[i]._mixoff = mx - ((dx - dy) << 5);
missile[i]._miyoff = my - ((dx + dy) << 4);
ChangeLightOff(missile[i]._mlid, lx - (dx << 3), ly - (dy << 3));
}
/*-----------------------------------------------------------------------*
* MoveMissilePos
*
* Adjusts missile's drawing location to prevent overlapping tiles
* Written specifically for monster missiles (e.g., Rhino), which are large.
**-----------------------------------------------------------------------*/
static void MoveMissilePos(int i)
{
int dx,dy;
int mx,my;
app_assert(i < MAXMISSILES);
switch (missile[i]._mimfnum) {
case 0 : // Down
dx = 1;
dy = 1;
break;
case 1 : // Down Left
dx = 1;
dy = 1;
break;
case 2 : // Left
dx = 0;
dy = 1;
break;
case 3 : // Up Left
dx = 0;
dy = 0;
break;
case 4 : // Up
dx = 0;
dy = 0;
break;
case 5 : // Up Right
dx = 0;
dy = 0;
break;
case 6 : // Right
dx = 1;
dy = 0;
break;
case 7 : // Down Right
dx = 1;
dy = 1;
break;
}
mx = missile[i]._mix + dx;
my = missile[i]._miy + dy;
// note -- _misource is the monster which became this missile
if (PosOkMonst(missile[i]._misource,mx,my)) {
missile[i]._mix += dx;
missile[i]._miy += dy;
missile[i]._mixoff -= ((dx - dy) << 5);
missile[i]._miyoff -= ((dx + dy) << 4);
}
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
BOOL MonsterTrapHit(int m, int mindam, int maxdam, int dist, int t, byte shift)
{
int hit, hper;
long dam;
int mor; // monster's resist type
int mir;
BOOL resist = FALSE;
BOOL ret;
app_assert(m < MAXMONSTERS);
if (monster[m].mtalkmsg != 0) return FALSE;
if ((monster[m]._mhitpoints >> HP_SHIFT) <= 0) return FALSE;
app_assert(monster[m].MType != NULL);
if(monster[m].MType->mtype == MT_ILLWEAV && monster[m]._mgoal == MG_RUN_AWAY)
return FALSE;
if (monster[m]._mmode == MM_MISSILE) return(FALSE);
mir = missiledata[t].mResist;
mor = monster[m].mMagicRes;
if( (mor & M_IM && mir == MIMT_MISC)
|| (mor & M_IF && mir == MIMT_FIRE)
|| (mor & M_IL && mir == MIMT_LGHT))
return FALSE;
if( (mor & M_RM && mir == MIMT_MISC)
|| (mor & M_RF && mir == MIMT_FIRE)
|| (mor & M_RL && mir == MIMT_LGHT))
resist = TRUE;
hit = random(68, 100);
hper = 90 - monster[m].mArmorClass - dist;
if (hper < 5) hper = 5;
if (hper > 95) hper = 95;
if (CheckMonsterHit(m, ret))
return(ret);
#if CHEATS
else if((hit < hper) || simplecheat || cheatflag || (monster[m]._mmode == MM_STONE)) {
#else
else if((hit < hper) || (monster[m]._mmode == MM_STONE)) {
#endif
dam = random(68, maxdam - mindam + 1) + mindam;
if (shift == 0) dam = dam << HP_SHIFT;
if (resist)
monster[m]._mhitpoints -= dam >> 2;
else
monster[m]._mhitpoints -= dam;
#if CHEATS
if (simplecheat || cheatflag) monster[m]._mhitpoints = 0;
#endif
// rjs - x2 dam if stone - if (monster[m]._mmode == MM_STONE) monster[m]._mhitpoints -= dam;
if ((monster[m]._mhitpoints >> HP_SHIFT) <= 0) {
if (monster[m]._mmode == MM_STONE) {
M_StartKill(m, -1);
monster[m]._mmode = MM_STONE;
} else M_StartKill(m, -1);
}
else if(resist)
{
PlayEffect(m, MS_GOTHIT);
}
else
{
if (monster[m]._mmode == MM_STONE) {
if (m > 3) M_StartHit(m, -1, dam); // dont let golems get hit
monster[m]._mmode = MM_STONE;
} else {
if (m > 3) M_StartHit(m, -1, dam); // dont let golems get hit
}
}
return(TRUE);
} else return(FALSE);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
BOOL MonsterMHit(int pnum, int m, int mindam, int maxdam, int dist, int t, byte shift)
{
int hit, hper;
long dam;
int mor; // monster's resist type
int mir; // missile resistance category
BOOL resist = FALSE;
BOOL ret;
app_assert(m < MAXMONSTERS);
if (monster[m].mtalkmsg != 0) return(FALSE);
if ((monster[m]._mhitpoints >> HP_SHIFT) <= 0) return(FALSE);
app_assert(monster[m].MData != NULL);
if ((t == MIT_HBOLT) &&
(monster[m].MType->mtype != MT_DIABLO) &&
(monster[m].MData->mMonstClass != MC_UNDEAD)) return(FALSE);
app_assert(monster[m].MType != NULL);
if(monster[m].MType->mtype == MT_ILLWEAV && monster[m]._mgoal == MG_RUN_AWAY)
return FALSE;
if (monster[m]._mmode == MM_MISSILE) return(FALSE);
mir = missiledata[t].mResist;
mor = monster[m].mMagicRes;
if( (mor & M_IM && mir == MIMT_MISC)
|| (mor & M_IF && mir == MIMT_FIRE)
|| (mor & M_IL && mir == MIMT_LGHT)
|| (mor & M_IA && mir == MIMT_ACID))
return FALSE;
if( (mor & M_RM && mir == MIMT_MISC)
|| (mor & M_RF && mir == MIMT_FIRE)
|| (mor & M_RL && mir == MIMT_LGHT))
resist = TRUE;
hit = random(69, 100);
if (missiledata[t].mType == MIS_WEAP) {
hper = BASE_TO_HIT + plr[pnum]._pLevel - monster[m].mArmorClass - plr[pnum]._pIEnAc;
hper += plr[pnum]._pDexterity + plr[pnum]._pIBonusToHit;
hper -= (dist * dist) >> 1;
if (plr[pnum]._pClass == CLASS_ROGUE) hper += 20;
if (plr[pnum]._pClass == CLASS_WARRIOR ||
plr[pnum]._pClass == CLASS_BARD) hper += 10;
} else {
hper = BASE_TO_HIT + plr[pnum]._pMagic - (monster[m].mLevel << 1) - dist;
if (plr[pnum]._pClass == CLASS_SORCEROR) hper += 20;
else if (plr[pnum]._pClass == CLASS_BARD) hper += 10;
}
if (hper < 5) hper = 5;
if (hper > 95) hper = 95;
if (monster[m]._mmode == MM_STONE) hit = 0;
if (CheckMonsterHit(m, ret))
return(ret);
#if CHEATS
else if((hit < hper) || cheatflag || simplecheat) {
#else
else if (hit < hper) {
#endif
if (t == MIT_BONESPIRIT)
dam = (monster[m]._mhitpoints / 3) >> HP_SHIFT;
else
dam = random(70, maxdam - mindam + 1) + mindam;
if (missiledata[t].mType == MIS_WEAP) {
dam += (dam * plr[pnum]._pIBonusDam) / 100;
dam += plr[pnum]._pIBonusDamMod;
if (plr[pnum]._pClass == CLASS_ROGUE) dam += plr[pnum]._pDamageMod;
else dam += (plr[pnum]._pDamageMod >> 1);
}
if (shift == 0) dam = dam << HP_SHIFT;
if (resist) dam = dam >> 2;
if (pnum == myplr) monster[m]._mhitpoints -= dam;
if (plr[pnum]._pIFlags & IAF_MNOHEAL) monster[m]._mFlags |= MFLAG_NOHEAL;
#if CHEATS
//if (pnum == myplr && cheatflag) monster[m]._mhitpoints = 0;
#endif
//rjs - x2 stone dam - if (pnum == myplr && monster[m]._mmode == MM_STONE) monster[m]._mhitpoints -= dam;
if ((monster[m]._mhitpoints >> HP_SHIFT) <= 0) {
if (monster[m]._mmode == MM_STONE) {
M_StartKill(m, pnum);
monster[m]._mmode = MM_STONE;
} else M_StartKill(m, pnum);
//(old) AddPlrExperience(pnum, monster[m].mLevel, monster[m].mExp);
//(new, but moved) AddPlrMonstExper(monster[m].mLevel, monster[m].mExp, monster[m].mWhoHit);
}
else if(resist)
{
PlayEffect(m, MS_GOTHIT);
}
else
{
if (monster[m]._mmode == MM_STONE) {
if (m > 3) M_StartHit(m, pnum, dam);
monster[m]._mmode = MM_STONE;
} else {
if ((missiledata[t].mType == MIS_WEAP) && (plr[pnum]._pIFlags & IAF_KNOCKBACK)) M_GetKnockback(m);
if (m > 3) M_StartHit(m, pnum, dam);
}
}
// wake up monster if it's inactive
if(!monster[m]._msquelch)
{
monster[m]._msquelch = 255;
monster[m]._lastx = plr[pnum]._px;
monster[m]._lasty = plr[pnum]._py;
}
return(TRUE);
} else return(FALSE);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
BOOL PlayerMHit(int pnum, int m, int dist, int mind, int maxd, int mtype, byte shift, BOOL earflag)
{
int hit, hper, tac;
long dam;
int blk, blkper, blkdir;
int resper = 0;
app_assert(pnum < MAX_PLRS);
if ((plr[pnum]._pHitPoints >> HP_SHIFT) <= 0) return(FALSE);
if (plr[pnum]._pInvincible) return(FALSE);
if (((plr[pnum]._pSpellFlags & SF_ETHER) != 0) && (missiledata[mtype].mType == MIS_WEAP)) return(FALSE);
hit = random(72, 100);
#if CHEATS
if (simplecheat || cheatflag) hit = 1000;
#endif
if (missiledata[mtype].mType == MIS_WEAP) {
// rjs tac = (byte)plr[pnum]._pArmorClass + plr[pnum]._pIAC + plr[pnum]._pIBonusAC;
tac = plr[pnum]._pIAC + plr[pnum]._pIBonusAC;
tac += (plr[pnum]._pDexterity / 5);
if (m != -1) hper = 30 + monster[m].mHit - tac + ((monster[m].mLevel - plr[pnum]._pLevel) << 1) - (dist << 1);
else hper = 100 - (tac >> 1) - (dist << 1);
} else {
if (m != -1) hper = 40 + (monster[m].mLevel << 1) - (plr[pnum]._pLevel << 1) - (dist << 1);
else hper = 40;
}
if (hper < 10) hper = 10;
if ((currlevel == 14) && (hper < 20)) hper = 20;
if ((currlevel == 15) && (hper < 25)) hper = 25;
if ((currlevel == 16) && (hper < 30)) hper = 30;
if (((plr[pnum]._pmode == PM_STAND) || (plr[pnum]._pmode == PM_ATTACK)) && (plr[pnum]._pBlockFlag)) blk = random(73, 100);
else blk = 100;
if (shift == 1) blk = 100; // can't block continous damage spells
if (mtype == MIT_ACIDPUD) blk = 100; // can't block acid puddles (drb)
if (m != -1) blkper = plr[pnum]._pBaseToBlk + plr[pnum]._pDexterity - ((monster[m].mLevel - plr[pnum]._pLevel) << 1);
else blkper = plr[pnum]._pBaseToBlk + plr[pnum]._pDexterity;
if (blkper < 0) blkper = 0;
if (blkper > 100) blkper = 100;
switch(missiledata[mtype].mResist) {
case MIMT_FIRE:
resper = plr[pnum]._pFireResist;
break;
case MIMT_LGHT:
resper = plr[pnum]._pLghtResist;
break;
case MIMT_MISC:
case MIMT_ACID:
resper = plr[pnum]._pMagResist;
break;
default:
resper = 0;
break;
}
if (hit < hper) {
// Hit, so calc damage
if (mtype == MIT_BONESPIRIT) {
dam = plr[pnum]._pHitPoints / 3;
} else {
if (shift == 0) {
dam = (maxd - mind + 1) << HP_SHIFT;
dam = random(75, dam) + (mind << HP_SHIFT);
if (plr[pnum]._pIFlags & IAF_TRAPDAM) dam = dam >> 1;
dam += (plr[pnum]._pIGetHit << HP_SHIFT);
if (dam < (1 << HP_SHIFT)) dam = (1 << HP_SHIFT);
} else {
dam = maxd - mind + 1;
dam = random(75, dam) + mind;
if (plr[pnum]._pIFlags & IAF_TRAPDAM) dam = dam >> 1;
dam += plr[pnum]._pIGetHit;
if (dam < (1 << HP_SHIFT)) dam = (1 << HP_SHIFT);
}
}
// Did I resist?
if (resper > 0) {
dam -= (dam * resper) / 100;
if (pnum == myplr) {
plr[pnum]._pHitPoints -= dam;
plr[pnum]._pHPBase -= dam;
}
if (plr[pnum]._pHitPoints > plr[pnum]._pMaxHP) {
plr[pnum]._pHitPoints = plr[pnum]._pMaxHP;
plr[pnum]._pHPBase = plr[pnum]._pMaxHPBase;
}
if ((plr[pnum]._pHitPoints >> HP_SHIFT) <= 0) {
// rjs - manashld fix? - plr[pnum]._pHitPoints = 0;
StartPlrKill(pnum, earflag);
}
else {
// No get hit
if (plr[pnum]._pClass == CLASS_WARRIOR) PlaySfxLoc(PS_WARR69, plr[pnum]._px, plr[pnum]._py);
#if !IS_VERSION(SHAREWARE)
else if (plr[pnum]._pClass == CLASS_ROGUE) PlaySfxLoc(PS_ROGUE69, plr[pnum]._px, plr[pnum]._py);
else if (plr[pnum]._pClass == CLASS_SORCEROR) PlaySfxLoc(PS_MAGE69, plr[pnum]._px, plr[pnum]._py);
else if (plr[pnum]._pClass == CLASS_MONK) PlaySfxLoc(PS_MONK69, plr[pnum]._px, plr[pnum]._py);
else if (plr[pnum]._pClass == CLASS_BARD) PlaySfxLoc(PS_BARD69, plr[pnum]._px, plr[pnum]._py);
#endif
//PlaySfxLoc(PS_LGHIT, plr[pnum]._px, plr[pnum]._py);
drawhpflag = TRUE;
}
return(TRUE);
} else {
// Did I block?
if (blk < blkper) {
if (m != -1) blkdir = GetDirection(plr[pnum]._px, plr[pnum]._py, monster[m]._mx, monster[m]._my);
else blkdir = plr[pnum]._pdir;
StartPlrBlock(pnum, blkdir);
return(TRUE);
} else {
if (pnum == myplr) {
plr[pnum]._pHitPoints -= dam;
plr[pnum]._pHPBase -= dam;
}
if (plr[pnum]._pHitPoints > plr[pnum]._pMaxHP) {
plr[pnum]._pHitPoints = plr[pnum]._pMaxHP;
plr[pnum]._pHPBase = plr[pnum]._pMaxHPBase;
}
if ((plr[pnum]._pHitPoints >> HP_SHIFT) <= 0) {
// rjs - manashld fix? - plr[pnum]._pHitPoints = 0;
StartPlrKill(pnum, earflag);
} else StartPlrHit(pnum, dam, FALSE);
return(TRUE);
}
}
}
return(FALSE);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
BOOL Plr2PlrMHit(int pnum, int p, int mindam, int maxdam, int dist, int mtype, byte shift)
{
int hit, hper, tac;
long dam;
int blk, blkper, blkdir;
int resper;
// pnum is missiles source
// p is missiles dest
app_assert(p < MAX_PLRS);
if (plr[p]._pInvincible) return(FALSE);
if (mtype == MIT_HBOLT) return(FALSE);
if (((plr[p]._pSpellFlags & SF_ETHER) != 0) && (missiledata[mtype].mType == MIS_WEAP)) return(FALSE);
switch(missiledata[mtype].mResist) {
case MIMT_FIRE:
resper = plr[p]._pFireResist;
break;
case MIMT_LGHT:
resper = plr[p]._pLghtResist;
break;
case MIMT_MISC:
case MIMT_ACID:
resper = plr[p]._pMagResist;
break;
default:
resper = 0;
break;
}
hit = random(69, 100);
if (missiledata[mtype].mType == MIS_WEAP) {
//rjs tac = (byte)plr[p]._pArmorClass + plr[p]._pIAC + plr[p]._pIBonusAC;
tac = plr[p]._pIAC + plr[p]._pIBonusAC;
tac += (plr[p]._pDexterity / 5);
hper = BASE_TO_HIT + plr[pnum]._pLevel - tac;
hper += plr[pnum]._pDexterity + plr[pnum]._pIBonusToHit;
hper -= (dist * dist) >> 1;
if (plr[pnum]._pClass == CLASS_ROGUE) hper += 20;
if (plr[pnum]._pClass == CLASS_WARRIOR) hper += 10;
} else {
hper = BASE_TO_HIT + plr[pnum]._pMagic - (plr[p]._pLevel << 1) - dist;
if (plr[pnum]._pClass == CLASS_SORCEROR) hper += 20;
}
if (hper < 5) hper = 5;
if (hper > 95) hper = 95;
if (hit < hper) {
// Hit, calc blk %
if (((plr[p]._pmode == PM_STAND) || (plr[p]._pmode == PM_ATTACK)) && (plr[p]._pBlockFlag)) blk = random(73, 100);
else blk = 100;
if (shift == 1) blk = 100; // can't block continous damage spells
blkper = plr[p]._pBaseToBlk + plr[p]._pDexterity - ((plr[pnum]._pLevel - plr[p]._pLevel) << 1);
if (blkper < 0) blkper = 0;
if (blkper > 100) blkper = 100;
// Hit, so calc damage
if (mtype == MIT_BONESPIRIT) {
dam = plr[p]._pHitPoints / 3;
} else {
dam = random(70, maxdam - mindam + 1) + mindam;
if (missiledata[mtype].mType == MIS_WEAP) {
dam += (dam * plr[pnum]._pIBonusDam) / 100;
dam += plr[pnum]._pIBonusDamMod + plr[pnum]._pDamageMod;
}
if (shift == 0) dam = dam << HP_SHIFT;
}
// NEW! Take 1/2 damage from plr spells (drb 11/23)
if (missiledata[mtype].mType != MIS_WEAP) dam = dam >> 1;
// Did I resist?
if (resper > 0) {
dam -= (dam * resper) / 100;
// No get hit
if (pnum == myplr) NetSendCmdDamage(TRUE, p, dam);
if (plr[pnum]._pClass == CLASS_WARRIOR) PlaySfxLoc(PS_WARR69, plr[pnum]._px, plr[pnum]._py);
#if !IS_VERSION(SHAREWARE)
else if (plr[pnum]._pClass == CLASS_ROGUE) PlaySfxLoc(PS_ROGUE69, plr[pnum]._px, plr[pnum]._py);
else if (plr[pnum]._pClass == CLASS_SORCEROR) PlaySfxLoc(PS_MAGE69, plr[pnum]._px, plr[pnum]._py);
else if (plr[pnum]._pClass == CLASS_MONK) PlaySfxLoc(PS_MONK69, plr[pnum]._px, plr[pnum]._py);
else if (plr[pnum]._pClass == CLASS_BARD) PlaySfxLoc(PS_BARD69, plr[pnum]._px, plr[pnum]._py);
#endif
//PlaySfxLoc(PS_LGHIT, plr[p]._px, plr[p]._py);
return(TRUE);
} else {
// Did I block?
if (blk < blkper) {
blkdir = GetDirection(plr[p]._px, plr[p]._py, plr[pnum]._px, plr[pnum]._py);
StartPlrBlock(p, blkdir);
return(TRUE);
} else {
if (pnum == myplr) NetSendCmdDamage(TRUE, p, dam);
StartPlrHit(p, dam, FALSE);
return(TRUE);
}
}
}
return(FALSE);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
static void CheckMissileCol(int i, int mindam, int maxdam, byte shift, int mx, int my, byte nodel)
{
int pn,oi;
BOOL earflag;
app_assert(i < MAXMISSILES);
app_assert(mx < MAXDUNX);
app_assert(my < MAXDUNY);
if ((missile[i]._miAnimType == MF_FIRE)
|| (missile[i]._miAnimType == MF_LIGHTNING && missile[i]._mixvel == 0 && missile[i]._miyvel == 0)
|| (missile[i]._misource == -1)) {
if (dMonster[mx][my] > 0) {
if (missile[i]._miAnimType == MF_FIRE
|| missile[i]._miAnimType == MF_LIGHTNING) {
if (MonsterMHit(missile[i]._misource, dMonster[mx][my] - 1, mindam, maxdam, missile[i]._midist, missile[i]._mitype, shift)) {
if (nodel == 0) missile[i]._mirange = 0;
missile[i]._miHitFlag = TRUE;
}
} else {
if (MonsterTrapHit(dMonster[mx][my] - 1, mindam, maxdam, missile[i]._midist, missile[i]._mitype, shift)) {
if (nodel == 0) missile[i]._mirange = 0;
missile[i]._miHitFlag = TRUE;
}
}
}
if (dPlayer[mx][my] > 0) {
if (missile[i]._miAnimType == MF_FIRE
|| missile[i]._miAnimType == MF_LIGHTNING) earflag = TRUE;
else earflag = FALSE;
if (PlayerMHit(dPlayer[mx][my] - 1, -1, missile[i]._midist, mindam, maxdam, missile[i]._mitype, shift, earflag)) {
if (nodel == 0) missile[i]._mirange = 0;
missile[i]._miHitFlag = TRUE;
}
}
} else {
if (missile[i]._micaster == MI_ENEMYMONST) {
if (dMonster[mx][my] > 0) {
if (MonsterMHit(missile[i]._misource, dMonster[mx][my] - 1, mindam, maxdam, missile[i]._midist, missile[i]._mitype, shift)) {
if (nodel == 0) missile[i]._mirange = 0;
missile[i]._miHitFlag = TRUE;
}
} else {
if ((dMonster[mx][my] < 0) && (monster[-(dMonster[mx][my] + 1)]._mmode == MM_STONE)) {
if (MonsterMHit(missile[i]._misource, -(dMonster[mx][my] + 1), mindam, maxdam, missile[i]._midist, missile[i]._mitype, shift)) {
if (nodel == 0) missile[i]._mirange = 0;
missile[i]._miHitFlag = TRUE;
}
}
}
if ((dPlayer[mx][my] > 0) && ((dPlayer[mx][my]-1) != missile[i]._misource)) {
if (Plr2PlrMHit(missile[i]._misource, dPlayer[mx][my]-1, mindam, maxdam, missile[i]._midist, missile[i]._mitype, shift)) {
if (nodel == 0) missile[i]._mirange = 0;
missile[i]._miHitFlag = TRUE;
}
}
} else {
if (((monster[missile[i]._misource]._mFlags & MFLAG_MID) != 0) && ((dMonster[mx][my] > 0) && (monster[(dMonster[mx][my] - 1)]._mFlags & MFLAG_MKILLER) != 0)) {
if (MonsterTrapHit(dMonster[mx][my] - 1, mindam, maxdam, missile[i]._midist, missile[i]._mitype, shift)) {
if (nodel == 0) missile[i]._mirange = 0;
missile[i]._miHitFlag = TRUE;
}
}
if (dPlayer[mx][my] > 0) {
if (PlayerMHit(dPlayer[mx][my] - 1, missile[i]._misource, missile[i]._midist, mindam, maxdam, missile[i]._mitype, shift, FALSE)) {
if (nodel == 0) missile[i]._mirange = 0;
missile[i]._miHitFlag = TRUE;
}
}
}
}
if (dObject[mx][my] != 0) {
if (dObject[mx][my] > 0) oi = dObject[mx][my] - 1;
else oi = -(dObject[mx][my] + 1);
if (!object[oi]._oMissFlag) {
if (object[oi]._oBreak == OBJ_BREAKABLE) BreakObject(-1, oi);
if (nodel == 0) missile[i]._mirange = 0;
missile[i]._miHitFlag = FALSE;
}
}
pn = dPiece[mx][my];
app_assert(pn <= MAXTILES);
if (nMissileTable[pn]) {
if (nodel == 0) missile[i]._mirange = 0;
missile[i]._miHitFlag = FALSE;
}
if ((missile[i]._mirange == 0) && (missiledata[missile[i]._mitype].miSFX != -1)) {
PlaySfxLoc(missiledata[missile[i]._mitype].miSFX, missile[i]._mix, missile[i]._miy);
}
}
static void SetMissAnim(int mi, int animtype)
{
int dir;
app_assert(mi < MAXMISSILES);
dir = missile[mi]._mimfnum;
missile[mi]._miAnimType = animtype;
missile[mi]._miAnimFlags = misfiledata[animtype].mFlags;
missile[mi]._miAnimData = misfiledata[animtype].mAnimData[dir];
missile[mi]._miAnimDelay = misfiledata[animtype].mAnimDelay[dir];
missile[mi]._miAnimLen = misfiledata[animtype].mAnimLen[dir];
missile[mi]._miAnimWidth = misfiledata[animtype].mAnimWidth[dir];
missile[mi]._miAnimWidth2 = misfiledata[animtype].mAnimWidth2[dir];
missile[mi]._miAnimCnt = 0;
missile[mi]._miAnimFrame = 1;
}
void SetMissDir(int mi, int dir)
{
app_assert(mi < MAXMISSILES);
missile[mi]._mimfnum = dir;
SetMissAnim(mi, missile[mi]._miAnimType);
}
/*-----------------------------------------------------------------------**
**---------------------- Initialization Routines ------------------------**
**-----------------------------------------------------------------------*/
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
#if RLE_DRAW
void ILoadMissileGFX(BYTE mf) {
int i;
char strbuff[256];
BYTE *p;
MisFileData * pMisDat;
pMisDat = &misfiledata[mf];
if (pMisDat->mFlags & MFF_MULTI) {
// All directions are packed into one file
sprintf(strbuff,"Missiles\\%s" CEL_EXT, pMisDat->mAnimPath);
p = LoadFileInMemSig(strbuff,NULL,'MISS');
for (i = 0; i < pMisDat->mAnimFAmt; ++i)
pMisDat->mAnimData[i] = p + (reinterpret_cast<DWORD *>(p))[i];
}
else if (pMisDat->mAnimFAmt == 1) {
sprintf(strbuff,"Missiles\\%s" CEL_EXT, pMisDat->mAnimPath);
if(! pMisDat->mAnimData[0])
pMisDat->mAnimData[0] = LoadFileInMemSig(strbuff,NULL,'MISS');
}
else {
for (i = 0; i < pMisDat->mAnimFAmt; ++i) {
sprintf(strbuff, "Missiles\\%s%i" CEL_EXT, pMisDat->mAnimPath, i + 1);
if(! pMisDat->mAnimData[i])
pMisDat->mAnimData[i] = LoadFileInMemSig(strbuff,NULL,'MISS');
}
}
}
#endif
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
#if !RLE_DRAW
void ILoadMissileGFX(BYTE mf) {
int i;
char strbuff[256];
BYTE *p;
if (misfiledata[mf].mFlags & MFF_MULTI) {
// All directions are packed into one file
sprintf(strbuff,"Missiles\\%s.CEL", misfiledata[mf].mAnimPath);
p = LoadFileInMemSig(strbuff,NULL,'MISS');
for (i = 0; i < misfiledata[mf].mAnimFAmt; ++i) {
misfiledata[mf].mAnimData[i] = p + *static_cast<DWORD *>(p + (i<<2));
}
}
else if (misfiledata[mf].mAnimFAmt == 1) {
sprintf(strbuff,"Missiles\\%s.CEL", misfiledata[mf].mAnimPath);
if(! misfiledata[mf].mAnimData[0])
misfiledata[mf].mAnimData[0] = LoadFileInMemSig(strbuff,NULL,'MISS');
} else {
for (i = 0; i < misfiledata[mf].mAnimFAmt; ++i) {
sprintf(strbuff, "Missiles\\%s%i.CEL", misfiledata[mf].mAnimPath, i + 1);
if(! misfiledata[mf].mAnimData[i])
misfiledata[mf].mAnimData[i] = LoadFileInMemSig(strbuff,NULL,'MISS');
}
}
}
#endif
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void InitMissileGFX()
{
int i;
for (i = 0; misfiledata[i].mAnimFAmt; ++i) {
if (!(misfiledata[i].mFlags & MFF_MONSTONLY)) {
ILoadMissileGFX(i);
}
}
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
static void FreeMissileFile(int i)
{
int j;
void * y;
if (misfiledata[i].mFlags & MFF_MULTI)
{
if(misfiledata[i].mAnimData[0])
{
y = static_cast<void *> (misfiledata[i].mAnimData[0] - (misfiledata[i].mAnimFAmt << 2));
DiabloFreePtr(y);
misfiledata[i].mAnimData[0] = NULL;
}
}
else
{
for (j = 0; j < misfiledata[i].mAnimFAmt; ++j)
if(misfiledata[i].mAnimData[j])
{
DiabloFreePtr(misfiledata[i].mAnimData[j]);
}
}
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void FreeMissileGFX()
{
int i;
for (i = 0; misfiledata[i].mAnimFAmt; ++i) {
if (!(misfiledata[i].mFlags & MFF_MONSTONLY)) {
FreeMissileFile(i);
}
}
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void IFreeMissileGFX()
{
int i;
for (i = 0; misfiledata[i].mAnimFAmt; ++i)
if(misfiledata[i].mFlags & MFF_MONSTONLY)
FreeMissileFile(i);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void InitMissiles()
{
int i, j, mx;
// Delete any active infravision/ etheralize
plr[myplr]._pSpellFlags &= ~SF_ETHER;
if (plr[myplr]._pInfraFlag == TRUE) {
app_assert(nummissiles <= MAXMISSILES);
for (i = 0; i < nummissiles; ++i) {
mx = missileactive[i];
app_assert(mx < MAXMISSILES);
if ((missile[mx]._mitype == MIT_INFRA) && (missile[mx]._misource == myplr))
CalcPlrItemVals(missile[mx]._misource,TRUE);
}
}
nummissiles = 0;
for (i = 0; i < MAXMISSILES; ++i) {
missileavail[i] = i;
missileactive[i] = 0;
}
nummissilevars = 0;
for (i = 0; i < MAXMISSILES; ++i) {
missilevars[i][0] = -1;
missilevars[i][1] = 0;
missilevars[i][2] = 0;
}
for (j = 0; j < DMAXY; ++j) {
for (i = 0; i < DMAXX; ++i) {
dFlags[i][j] = dFlags[i][j] & ~BFLAG_MISSILE;
}
}
}
/*-----------------------------------------------------------------------**
**------------------ Missile Initialization Routines --------------------**
**-----------------------------------------------------------------------*/
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddRuneOfFire(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
if (id >= 0) {
UseMana(id, SPL_RUNEOFFIRE);
}
if (SetMissileLocation(mi, &dx, &dy, 10)) {
missile[mi]._miVar1 = MIT_MISEXP;
missile[mi]._miDelFlag = FALSE;
missile[mi]._mlid = AddLight(dx, dy, 8);
}
else missile[mi]._miDelFlag = TRUE;
app_assert(mi < MAXMISSILES);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddRuneOfLight(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
if (id >= 0) {
UseMana(id, SPL_RUNEOFLIGHT);
}
if (SetMissileLocation(mi, &dx, &dy, 10)) {
missile[mi]._miVar1 = MIT_LIGHTBALL;
missile[mi]._miDelFlag = FALSE;
missile[mi]._mlid = AddLight(dx, dy, 8);
}
else missile[mi]._miDelFlag = TRUE;
app_assert(mi < MAXMISSILES);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddRuneOfNova(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
if (id >= 0) {
UseMana(id, SPL_RUNEOFNOVA);
}
if (SetMissileLocation(mi, &sx, &sy, 10)) {
missile[mi]._miVar1 = MIT_NOVA;
missile[mi]._miDelFlag = FALSE;
missile[mi]._mlid = AddLight(sx, sy, 8);
}
else missile[mi]._miDelFlag = TRUE;
app_assert(mi < MAXMISSILES);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddRuneOfImmolation(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
if (id >= 0) {
UseMana(id, SPL_RUNEOFIMMOLATION);
}
if (SetMissileLocation(mi, &dx, &dy, 10)) {
missile[mi]._miVar1 = MIT_IMMOLATION;
missile[mi]._miDelFlag = FALSE;
missile[mi]._mlid = AddLight(dx, dy, 8);
}
else missile[mi]._miDelFlag = TRUE;
app_assert(mi < MAXMISSILES);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddRuneOfStone(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
if (id >= 0) {
UseMana(id, SPL_RUNEOFSTONE);
}
if (SetMissileLocation(mi, &dx, &dy, 10)) {
missile[mi]._miVar1 = MIT_STONE;
missile[mi]._miDelFlag = FALSE;
missile[mi]._mlid = AddLight(dx, dy, 8);
}
else missile[mi]._miDelFlag = TRUE;
app_assert(mi < MAXMISSILES);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddReflect(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
if (id >= 0) {
if (plr[id]._pReflectCount < 0)
plr[id]._pReflectCount = 0;
plr[id]._pReflectCount += GetSpellLevel(id, SPL_REFLECT) * plr[id]._pLevel;
UseMana(id, SPL_REFLECT);
}
missile[mi]._mirange = 0;
missile[mi]._miDelFlag = TRUE;
app_assert(mi < MAXMISSILES);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddBerserk(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
if (id >= 0) {
app_assert(mi < MAXMISSILES);
missile[mi]._misource = id;
// search in a 5 radius around tile clicked for monster
for (int k = 0; k < 6; ++k) {
int const l = CrawlNum[k];
int j = l + 1;
for (int i = CrawlTable[l]; i > 0; --i, j += 2) {
int const tx = dx + CrawlTable[j];
int const ty = dy + CrawlTable[(j + 1)];
if (tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
int mid = dMonster[tx][ty];
if (mid > 0) --mid;
else mid = -(mid + 1);
if ((mid > 3)
&& (monster[mid]._uniqtype == 0)
&& (monster[mid]._mAi != AI_DIABLO)
&& (monster[mid]._mmode != MM_FADEIN)
&& (monster[mid]._mmode != MM_FADEOUT)
//&& (monster[mid]._mmode != MM_DEATH)
&& (monster[mid]._mmode != MM_MISSILE)) {
i = -99;
k = 6;
int const SpellLevel = GetSpellLevel(id, SPL_BERSERK);
monster[mid]._mFlags |= MFLAG_BERSERK | MFLAG_MKILLER;
monster[mid].mMinDamage = static_cast<BYTE>(SpellLevel + monster[mid].mMinDamage * (1.0 + (0.01 * (random(145,10) + 20))));
monster[mid].mMaxDamage = static_cast<BYTE>(SpellLevel + monster[mid].mMaxDamage * (1.0 + (0.01 * (random(145,10) + 20))));
monster[mid].mMinDamage2 = static_cast<BYTE>(SpellLevel + monster[mid].mMinDamage2 * (1.0 + (0.01 * (random(145,10) + 20))));
monster[mid].mMaxDamage2 = static_cast<BYTE>(SpellLevel + monster[mid].mMaxDamage2 * (1.0 + (0.01 * (random(145,10) + 20))));
UseMana(id, SPL_BERSERK);
break;
}
}
}
}
}
missile[mi]._mirange = 0;
missile[mi]._miDelFlag = TRUE;
app_assert(mi < MAXMISSILES);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddDisEnchant(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
app_assert(mi < MAXMISSILES);
missile[mi]._misource = id;
// search in a 3 radius around chest trap for players.
for (int k = 0; k < 3; ++k) {
int const l = CrawlNum[k];
int j = l + 1;
for (int i = CrawlTable[l]; i > 0; --i, j += 2) {
int const tx = sx + CrawlTable[j];
int const ty = sy + CrawlTable[(j + 1)];
if (tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
int pid = dPlayer[tx][ty];
if (pid == 0)
continue;
if (pid > 0) --pid;
else pid = -(pid + 1);
// Belt items only.
if (random(205, 2)) {
// distroy healing and mana potions && 1/2 rejuvination.
for (int splIndex = 0; splIndex < MAXSPD; ++splIndex) {
if (plr[pid].SpdList[splIndex]._itype == IT_MISC
&& (plr[pid].SpdList[splIndex]._iMiscId == IMID_PLHEAL
|| plr[pid].SpdList[splIndex]._iMiscId == IMID_PHEAL
|| plr[pid].SpdList[splIndex]._iMiscId == IMID_PMANA
|| plr[pid].SpdList[splIndex]._iMiscId == IMID_PFMANA
|| plr[pid].SpdList[splIndex]._iMiscId == IMID_REJUV)
) {
RemoveSpdBarItem(pid, splIndex);
}
else if (plr[pid].SpdList[splIndex]._iMiscId == IMID_FREJUV){
int const idata = ItemMiscIdIdx(IMID_REJUV);
SetPlrHandItem(&plr[pid].HoldItem, idata);
GetPlrHandSeed(&plr[pid].HoldItem);
plr[pid].HoldItem._iStatFlag = TRUE;
plr[pid].SpdList[splIndex] = plr[pid].HoldItem;
}
}
}
else if (random(206, 2)) {
// downgrade full potions to partial
// Partical go away.
for (int splIndex = 0; splIndex < MAXSPD; ++splIndex) {
if (plr[pid].SpdList[splIndex]._itype == IT_MISC ) {
switch (plr[pid].SpdList[splIndex]._iMiscId)
{
case IMID_PHEAL:
{
int const idata = ItemMiscIdIdx(IMID_PLHEAL);
SetPlrHandItem(&plr[pid].HoldItem, idata);
GetPlrHandSeed(&plr[pid].HoldItem);
plr[pid].HoldItem._iStatFlag = TRUE;
plr[pid].SpdList[splIndex] = plr[pid].HoldItem;
}
break;
case IMID_PFMANA:
{
int const idata = ItemMiscIdIdx(IMID_PMANA);
SetPlrHandItem(&plr[pid].HoldItem, idata);
GetPlrHandSeed(&plr[pid].HoldItem);
plr[pid].HoldItem._iStatFlag = TRUE;
plr[pid].SpdList[splIndex] = plr[pid].HoldItem;
}
break;
case IMID_FREJUV:
{
int const idata = ItemMiscIdIdx(IMID_REJUV);
SetPlrHandItem(&plr[pid].HoldItem, idata);
GetPlrHandSeed(&plr[pid].HoldItem);
plr[pid].HoldItem._iStatFlag = TRUE;
plr[pid].SpdList[splIndex] = plr[pid].HoldItem;
}
break;
case IMID_PMANA:
case IMID_PLHEAL:
case IMID_REJUV:
RemoveSpdBarItem(pid, splIndex);
break;
}
force_redraw = FULLDRAW;
}
}
}
else if (random(207, 2)) {
// convert rejuventation to healing or mana.
for (int splIndex = 0; splIndex < MAXSPD; ++splIndex) {
if (plr[pid].SpdList[splIndex]._itype == IT_MISC ) {
if(plr[pid].SpdList[splIndex]._iMiscId == IMID_REJUV) {
int const idata = ItemMiscIdIdx(random(210,2) ? IMID_PLHEAL : IMID_PMANA);
SetPlrHandItem(&plr[pid].HoldItem, idata);
GetPlrHandSeed(&plr[pid].HoldItem);
plr[pid].HoldItem._iStatFlag = TRUE;
plr[pid].SpdList[splIndex] = plr[pid].HoldItem;
}
else if(plr[pid].SpdList[splIndex]._iMiscId == IMID_FREJUV) {
int const idata = ItemMiscIdIdx(random(211,2) ? IMID_PHEAL : IMID_PFMANA);
SetPlrHandItem(&plr[pid].HoldItem, idata);
GetPlrHandSeed(&plr[pid].HoldItem);
plr[pid].HoldItem._iStatFlag = TRUE;
plr[pid].SpdList[splIndex] = plr[pid].HoldItem;
}
force_redraw = FULLDRAW;
}
}
}
else if (random(208, 5)) {
// distroy scrolls and oils.
for (int splIndex = 0; splIndex < MAXSPD; ++splIndex) {
if ( (plr[pid].SpdList[splIndex]._iMiscId > IMID_FIRSTOIL
&& plr[pid].SpdList[splIndex]._iMiscId < IMID_LASTOIL)
|| plr[pid].SpdList[splIndex]._iMiscId == IMID_SCROLL
|| plr[pid].SpdList[splIndex]._iMiscId == IMID_TSCROLL
) {
RemoveSpdBarItem(pid, splIndex);
}
}
}
}
}
}
missile[mi]._mirange = 0;
missile[mi]._miDelFlag = TRUE;
app_assert(mi < MAXMISSILES);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddManaRemove(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
app_assert(mi < MAXMISSILES);
missile[mi]._misource = id;
// search in a 3 radius around chest trap for players.
for (int k = 0; k < 3; ++k) {
int const l = CrawlNum[k];
int j = l + 1;
for (int i = CrawlTable[l]; i > 0; --i, j += 2) {
int const tx = sx + CrawlTable[j];
int const ty = sy + CrawlTable[(j + 1)];
if (tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
int pid = dPlayer[tx][ty];
if (pid == 0)
continue;
if (pid > 0) --pid;
else pid = -(pid + 1);
plr[pid]._pMana = 0;
plr[pid]._pManaBase = plr[pid]._pMana - (plr[pid]._pMaxMana - plr[pid]._pMaxManaBase);
CalcPlrInv(pid, FALSE);
drawmanaflag = TRUE;
}
}
}
missile[mi]._mirange = 0;
missile[mi]._miDelFlag = TRUE;
app_assert(mi < MAXMISSILES);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddLArrow(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
if (mienemy == MI_ENEMYMONST) {
if (plr[id]._pClass == CLASS_ROGUE) GetMissileVel(mi,sx,sy,dx,dy,31+(plr[id]._pLevel>>2));
else if (plr[id]._pClass == CLASS_WARRIOR) GetMissileVel(mi,sx,sy,dx,dy,31+(plr[id]._pLevel>>3));
else GetMissileVel(mi,sx,sy,dx,dy,32);
} else GetMissileVel(mi,sx,sy,dx,dy,32);
SetMissDir(mi, GetDirection16(sx,sy,dx,dy));
app_assert(mi < MAXMISSILES);
missile[mi]._mirange = 256;
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
missile[mi]._mlid = AddLight(sx, sy, 5);
//PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddArrow(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
int av;
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
if (mienemy == MI_ENEMYMONST) {
av = 32;
if (plr[id]._pIFlags & IAF_RNDARROW) av = random(64, 32) + 16; // rnd arrow speed
if (plr[id]._pClass == CLASS_ROGUE) av += (plr[id]._pLevel-1) >> 2; // rouge level speed increase
if (plr[id]._pClass == CLASS_WARRIOR) av += (plr[id]._pLevel-1) >> 3; // warrior level speed increase
GetMissileVel(mi,sx,sy,dx,dy,av);
} else GetMissileVel(mi,sx,sy,dx,dy,32);
app_assert(mi < MAXMISSILES);
missile[mi]._miAnimFrame = GetDirection16(sx,sy,dx,dy) + 1;
missile[mi]._mirange = 256;
//PutMissile(mi);
}
void AddSpecialArrow(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_FIREBALL) || !PRE_BETA
int extraspeed = 0;
// if ((sx == dx) && (sy == dy)) {
// dx += XDirAdd[midir];
// dy += YDirAdd[midir];
// }
app_assert(mi < MAXMISSILES);
if (mienemy == MI_ENEMYMONST)
{
if (plr[id]._pClass == CLASS_ROGUE)
extraspeed = (plr[id]._pLevel-1) >> 2; // rogue level speed increase
else if (plr[id]._pClass == CLASS_WARRIOR)
extraspeed = (plr[id]._pLevel-1) >> 3; // warrior level speed increase
}
missile[mi]._mirange = 1;
missile[mi]._miVar1 = dx;
missile[mi]._miVar2 = dy;
missile[mi]._miVar3 = extraspeed;
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void GetVileMissPos(int mi, int dx, int dy)
{
int xx, yy;
app_assert(mi < MAXMISSILES);
for (int l = 1; l < 50; ++l) {
for (int j = -l; j <= l; ++j) {
yy = dy + j;
for (int i = -l; i <= l; ++i) {
xx = dx + i;
if (PosOkPlayer(myplr,xx,yy)) {
missile[mi]._mix = xx;
missile[mi]._miy = yy;
return;
}
}
}
}
// There is just no way it will ever reach here
missile[mi]._mix = dx;
missile[mi]._miy = dy;
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
#define DIST(x,y,d) (abs(x) < d && abs(y) < d)
// Flag for fireman missile
#define MIF_DIDHIT 1
#define MINAWAY 3
#define MAXAWAY 6
void AddRndTeleport(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_PHASE) || !PRE_BETA
int pn, r1, r2;
int nTries = 0;
do {
// don't get stuck in an infinite loop...
if (++nTries > 500) {
r1 = 0;
r2 = 0;
break;
}
r1 = random(58, MAXAWAY - MINAWAY) + MINAWAY + 1;
r2 = random(58, MAXAWAY - MINAWAY) + MINAWAY + 1;
if (random(58, 2) == 1) r1 = -r1;
if (random(58, 2) == 1) r2 = -r2;
pn = dPiece[sx + r1][sy + r2];
} while (nSolidTable[pn] != 0 || dObject[sx + r1][sy + r2] != 0 || dMonster[sx + r1][sy + r2] != 0);
app_assert(mi < MAXMISSILES);
missile[mi]._mirange = 2;
missile[mi]._miVar1 = 0;
// special code for Vile Betrayer quest
if ((setlevel) && (setlvlnum == 5)) {
int oi = dObject[dx][dy]-1;
if ((object[oi]._otype == OBJ_MCIRCLE1) || (object[oi]._otype == OBJ_MCIRCLE2)) {
missile[mi]._mix = dx;
missile[mi]._miy = dy;
if (!PosOkPlayer(myplr, dx, dy)) GetVileMissPos(mi, dx, dy);
}
}
else {
missile[mi]._mix = sx + r1;
missile[mi]._miy = sy + r2;
if (mienemy == MI_ENEMYMONST) UseMana(id, SPL_PHASE);
}
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
#undef max
void AddTeleStairs(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
int minDist = std::numeric_limits<int>::is_specialized && std::numeric_limits<int>::is_bounded
? std::numeric_limits<int>::max() : 99999;
if (id >= 0) {
sx = plr[id]._px;
sy = plr[id]._py;
}
int rx = sx;
int ry = sy;
for (int i = 0;i < numtrigs && i < MAXTRIGGERS; ++i) {
if (trigs[i]._tmsg == WM_DIABTWARPUP
|| trigs[i]._tmsg == WM_DIABPREVLVL
|| trigs[i]._tmsg == WM_DIABNEXTLVL
|| trigs[i]._tmsg == WM_DIABRTNLVL) {
int triggerx;
int triggery;
if ((leveltype == 1 || leveltype == 2)
&& (trigs[i]._tmsg == WM_DIABNEXTLVL
|| trigs[i]._tmsg == WM_DIABPREVLVL
|| trigs[i]._tmsg == WM_DIABRTNLVL) ){
triggerx = trigs[i]._tx;
triggery = trigs[i]._ty + 1;
}
else {
triggerx = trigs[i]._tx + 1;
triggery = trigs[i]._ty;
}
int xdiff = sx - triggerx;
xdiff *= xdiff;
int ydiff = sy - triggery;
ydiff *= ydiff;
int const NewDist = xdiff + ydiff;
if (NewDist < minDist)
{
minDist = NewDist;
rx = triggerx;
ry = triggery;
}
}
}
app_assert(mi < MAXMISSILES);
missile[mi]._mirange = 2;
missile[mi]._miVar1 = 0;
missile[mi]._mix = rx;
missile[mi]._miy = ry;
if (mienemy == MI_ENEMYMONST) UseMana(id, SPL_TELESTAIRS);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddFirebolt(int mi, int sx, int sy, int dx, int dy, int midir, char micaster, int id, int dam)
{
#if (PRE_BETA && PRE_FIREBOLT) || !PRE_BETA
int sp, i, mx;
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
app_assert(mi < MAXMISSILES);
if (micaster == MI_ENEMYMONST)
{
app_assert(nummissiles <= MAXMISSILES);
for (i = 0; i < nummissiles; ++i) {
mx = missileactive[i];
app_assert(mx < MAXMISSILES);
if ((missile[mx]._mitype == MIT_GUARDIAN) &&
(missile[mx]._misource == id) && (missile[mx]._miVar3 == mi)) {
break;
}
}
if (i == nummissiles) UseMana(id, SPL_FIREBOLT);
if (id != -1) {
sp = 16 + (missile[mi]._mispllvl << 1);
if (sp >= 63) sp = 63;
} else sp = 16;
}
else
sp = 26;
GetMissileVel(mi,sx,sy,dx,dy,sp);
SetMissDir(mi, GetDirection16(sx,sy,dx,dy));
missile[mi]._mirange = 256;
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
missile[mi]._mlid = AddLight(sx, sy, 8);
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddMagmaball(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
GetMissileVel(mi,sx,sy,dx,dy,16);
app_assert(mi < MAXMISSILES);
// Graphics don't line up, so we have to move them...
missile[mi]._mitxoff += 3*missile[mi]._mixvel;
missile[mi]._mityoff += 3*missile[mi]._miyvel;
GetMissilePos(mi);
missile[mi]._mirange = 256;
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
missile[mi]._mlid = AddLight(sx, sy, 8);
//PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddKrull(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
GetMissileVel(mi,sx,sy,dx,dy,16);
app_assert(mi < MAXMISSILES);
missile[mi]._mirange = 256;
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
// missile[mi]._mlid = AddLight(sx, sy, 8);
PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddTeleport(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_TELE) || !PRE_BETA
int i, pn;
int k, l, j;
int tx, ty;
app_assert(dx < MAXDUNX);
app_assert(dy < MAXDUNY);
app_assert(mi < MAXMISSILES);
missile[mi]._miDelFlag = TRUE;
for (k = 0; k < 6; ++k) {
l = CrawlNum[k];
j = l + 1;
for (i = CrawlTable[l]; i > 0; --i) {
tx = dx + CrawlTable[j];
ty = dy + CrawlTable[(j + 1)];
if (tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
pn = dPiece[tx][ty];
if ((nSolidTable[pn] | dMonster[tx][ty] | dObject[tx][ty] | dPlayer[tx][ty]) == 0) {
missile[mi]._mix = tx;
missile[mi]._miy = ty;
missile[mi]._misx = tx;
missile[mi]._misy = ty;
missile[mi]._miDelFlag = FALSE;
k = 6;
break;
}
}
j += 2;
}
}
if (missile[mi]._miDelFlag == FALSE) {
UseMana(id, SPL_TELE);
missile[mi]._mirange = 2;
}
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddLightball(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
GetMissileVel(mi,sx,sy,dx,dy,16);
app_assert(mi < MAXMISSILES);
missile[mi]._midam = dam;
missile[mi]._miAnimFrame = random(63, 8) + 1;
missile[mi]._mirange = 255;
if (id < 0) {
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
} else {
missile[mi]._miVar1 = plr[id]._px;
missile[mi]._miVar2 = plr[id]._py;
}
//PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddFirewall(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_WALL) || !PRE_BETA
int i;
app_assert(mi < MAXMISSILES);
missile[mi]._midam = (random(53, 10) + random(53, 10) + 2 + (id > 0) ? plr[id]._pLevel : currlevel) << 4;
missile[mi]._midam = missile[mi]._midam >> 1;
GetMissileVel(mi,sx,sy,dx,dy,16);
missile[mi]._mirange = 10;
for (i = missile[mi]._mispllvl; i > 0; --i) missile[mi]._mirange += 10;
if (mienemy != MI_ENEMYMONST || id < 0) // trap or somesuch
{
missile[mi]._mirange = missile[mi]._mirange + currlevel;
}
else
{
missile[mi]._mirange = missile[mi]._mirange + ((plr[id]._pISplDur * missile[mi]._mirange) >> 7);
}
missile[mi]._mirange = missile[mi]._mirange << 4;
missile[mi]._miVar1 = missile[mi]._mirange - missile[mi]._miAnimLen;
missile[mi]._miVar2 = 0;
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddFireball(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_FIREBALL) || !PRE_BETA
int i;
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
app_assert(mi < MAXMISSILES);
if (mienemy == MI_ENEMYMONST)
{
missile[mi]._midam = (random(60, 10) + random(60, 10) + 2 + plr[id]._pLevel) << 1;
for (i = missile[mi]._mispllvl; i > 0; --i) missile[mi]._midam += (missile[mi]._midam >> 3);
i = 16 + (missile[mi]._mispllvl << 1);
if (i > 50) i = 50;
UseMana(id, SPL_FIREBALL);
}
else
{
i = 16;
}
GetMissileVel(mi,sx,sy,dx,dy,i);
SetMissDir(mi, GetDirection16(sx,sy,dx,dy));
missile[mi]._mirange = 256;
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
missile[mi]._miVar3 = 0;
missile[mi]._miVar4 = sx;
missile[mi]._miVar5 = sy;
missile[mi]._mlid = AddLight(sx, sy, 8);
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddSpiralFireBall(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_FIREBALL) || !PRE_BETA
int i;
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
app_assert(mi < MAXMISSILES);
if (mienemy == MI_ENEMYMONST)
{
missile[mi]._midam = (random(60, 10) + random(60, 10) + 2 + plr[id]._pLevel) << 1;
for (i = missile[mi]._mispllvl; i > 0; --i) missile[mi]._midam += (missile[mi]._midam >> 3);
i = 16 + (missile[mi]._mispllvl << 1);
if (i > 50) i = 50;
UseMana(id, SPL_FIREBALL);
}
else
{
i = 16;
}
GetMissileVel(mi,sx,sy,dx,dy,i);
SetMissDir(mi, GetDirection16(sx,sy,dx,dy));
missile[mi]._mirange = 256;
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
missile[mi]._miVar3 = 0;
missile[mi]._miVar4 = sx;
missile[mi]._miVar5 = sy;
missile[mi]._miVar6 = 2;
missile[mi]._miVar7 = 2;
missile[mi]._mlid = AddLight(sx, sy, 8);
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
void AddFBArrow(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_FIREBALL) || !PRE_BETA
int i;
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
app_assert(mi < MAXMISSILES);
if (mienemy == MI_ENEMYMONST)
{
i = 16 + missile[mi]._mispllvl;
if (i > 50) i = 50;
// UseMana(id, SPL_FIREBALL);
}
else
{
i = 16;
}
GetMissileVel(mi,sx,sy,dx,dy,i);
SetMissDir(mi, GetDirection16(sx,sy,dx,dy));
missile[mi]._mirange = 256;
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
missile[mi]._miVar3 = 0;
missile[mi]._miVar4 = sx;
missile[mi]._miVar5 = sy;
missile[mi]._mlid = AddLight(sx, sy, 8);
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddLightctrl(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
if (dam == 0 && mienemy == MI_ENEMYMONST) UseMana(id, SPL_LIGHTNING); // if not 0 - probably is chain lightning
app_assert(mi < MAXMISSILES);
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
GetMissileVel(mi,sx,sy,dx,dy,32);
missile[mi]._miAnimFrame = random(52, 8) + 1;
missile[mi]._mirange = 256;
}
void AddLTArrow(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
app_assert(mi < MAXMISSILES);
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
GetMissileVel(mi,sx,sy,dx,dy,32);
missile[mi]._miAnimFrame = random(52, 8) + 1;
missile[mi]._mirange = 255;
if (id < 0) {
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
} else {
missile[mi]._miVar1 = plr[id]._px;
missile[mi]._miVar2 = plr[id]._py;
}
//PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddLightning(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_LIGHTNING) || !PRE_BETA
// Note: midir is used to pass in the missile # of the root of the lightning chain.
// A negative midir means that this is not part of a chain.
app_assert(mi < MAXMISSILES);
missile[mi]._misx = dx;
missile[mi]._misy = dy;
if(midir >= 0)
{
missile[mi]._mixoff = missile[midir]._mixoff;
missile[mi]._miyoff = missile[midir]._miyoff;
missile[mi]._mitxoff = missile[midir]._mitxoff;
missile[mi]._mityoff = missile[midir]._mityoff;
}
missile[mi]._miAnimFrame = random(52, 8) + 1;
if (midir >= 0 && mienemy != MI_ENEMYPLR && id != -1) {
missile[mi]._mirange = 6 + (missile[mi]._mispllvl >> 1);
} else {
if (midir >= 0 && id != -1) {
missile[mi]._mirange = 10;
} else missile[mi]._mirange = 8;
}
missile[mi]._mlid = AddLight(missile[mi]._mix, missile[mi]._miy, 4);
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddMisexp(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
if (mienemy != MI_ENEMYMONST && id > 0) {
app_assert(id < MAXMONSTERS);
app_assert(monster[id].MType != NULL);
switch (monster[id].MType->mtype)
{
case MT_SUCCUBUS:
SetMissAnim(mi,MF_FLAREXP);
break;
case MT_SNOWWICH:
SetMissAnim(mi,MF_BFLAREXP);
break;
case MT_HLSPWN:
SetMissAnim(mi,MF_DFLAREXP);
break;
case MT_SOLBRNR:
SetMissAnim(mi,MF_CFLAREXP);
break;
}
}
app_assert(mi < MAXMISSILES);
missile[mi]._mix = missile[dx]._mix;
missile[mi]._miy = missile[dx]._miy;
missile[mi]._misx = missile[dx]._misx;
missile[mi]._misy = missile[dx]._misy;
missile[mi]._mixoff = missile[dx]._mixoff;
missile[mi]._miyoff = missile[dx]._miyoff;
missile[mi]._mitxoff = missile[dx]._mitxoff;
missile[mi]._mityoff = missile[dx]._mityoff;
missile[mi]._mixvel = 0;
missile[mi]._miyvel = 0;
missile[mi]._mirange = missile[mi]._miAnimLen;
missile[mi]._miVar1 = 0;
//PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddWeapexp(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
app_assert(mi < MAXMISSILES);
missile[mi]._mix = sx;
missile[mi]._miy = sy;
missile[mi]._misx = sx;
missile[mi]._misy = sy;
missile[mi]._mixvel = 0;
missile[mi]._miyvel = 0;
missile[mi]._miVar1 = 0;
missile[mi]._miVar2 = dx;
missile[mi]._mimfnum = 0;
if (dx == 1) SetMissAnim(mi, MF_EXP1);
else SetMissAnim(mi, MF_CBOLT);
missile[mi]._mirange = missile[mi]._miAnimLen - 1;
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
BOOL CheckIfTrig(int x, int y)
{
int i;
app_assert(numtrigs <= MAXTRIGGERS);
for (i = 0; i < numtrigs; ++i)
if (((x == trigs[i]._tx) && (y == trigs[i]._ty)) ||
((abs(trigs[i]._tx-x) < 2) && (abs(trigs[i]._ty-y) < 2))) return(TRUE);
return(FALSE);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddTown(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_TOWN) || !PRE_BETA
int i, pn;
int k, l, j;
int tx, ty, mx;
app_assert(mi < MAXMISSILES);
if (currlevel != 0) {
missile[mi]._miDelFlag = TRUE;
for (k = 0; k < 6; ++k) {
l = CrawlNum[k];
j = l + 1;
for (i = CrawlTable[l]; i > 0; --i) {
tx = dx + CrawlTable[j];
ty = dy + CrawlTable[(j + 1)];
if (tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
pn = dPiece[tx][ty];
app_assert(pn <= MAXTILES);
if (((nSolidTable[pn] | dObject[tx][ty] | nMissileTable[pn] |
dPlayer[tx][ty] | dMissile[tx][ty]) == 0) &&
(!CheckIfTrig(tx, ty))) {
missile[mi]._mix = tx;
missile[mi]._miy = ty;
missile[mi]._misx = tx;
missile[mi]._misy = ty;
missile[mi]._miDelFlag = FALSE;
k = 6;
break;
}
}
j += 2;
}
}
} else {
tx = dx;
ty = dy;
missile[mi]._mix = tx;
missile[mi]._miy = ty;
missile[mi]._misx = tx;
missile[mi]._misy = ty;
missile[mi]._miDelFlag = FALSE;
}
missile[mi]._mirange = 100;
missile[mi]._miVar1 = missile[mi]._mirange - (missile[mi]._miAnimLen);
missile[mi]._miVar2 = 0;
// Move current portal?
for (i = 0; i < nummissiles; ++i) {
mx = missileactive[i];
if ((missile[mx]._mitype == MIT_TOWN) &&
(mx != mi) &&
(missile[mx]._misource == id)) {
missile[mx]._mirange = 0;
}
}
PutMissile(mi);
if (id == myplr && missile[mi]._miDelFlag == FALSE && currlevel != 0) {
if (!setlevel) NetSendCmdLocParam3(TRUE, CMD_ACTIVATEPORTAL, tx, ty, currlevel, leveltype, FALSE);
else NetSendCmdLocParam3(TRUE, CMD_ACTIVATEPORTAL, tx, ty, setlvlnum, leveltype, TRUE);
}
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddFlash(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_FLASH) || !PRE_BETA
int i;
app_assert(mi < MAXMISSILES);
if (mienemy == MI_ENEMYMONST) {
if (id != -1) {
missile[mi]._midam = 0;
for (i = 0; i <= plr[id]._pLevel; ++i) missile[mi]._midam += random(55, 20) + 1;
for (i = missile[mi]._mispllvl; i > 0; --i) missile[mi]._midam += (missile[mi]._midam >> 3);
missile[mi]._midam += missile[mi]._midam >> 1;
UseMana(id, SPL_FLASH);
} else {
missile[mi]._midam = (currlevel >> 1);
}
}
else
missile[mi]._midam = monster[id].mLevel << 1;
missile[mi]._mirange = 19;
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddAura(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_FLASH) || !PRE_BETA
#if defined(HELLFIRE2)
app_assert(mi < MAXMISSILES);
if (mienemy == MI_ENEMYMONST) {
if (id != -1) {
missile[mi]._midam = 0;
missile[mi]._mirange = 245 + (10 * missile[mi]._mispllvl) + (2 * (id > 0) ? plr[id].plrlevel : 1);
plr[id]._pBaseToBlk += 50;
UseMana(id, SPL_AURA);
}
}
#endif
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddAura2(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_FLASH) || !PRE_BETA
app_assert(mi < MAXMISSILES);
if (mienemy == MI_ENEMYMONST) {
if (id != -1) {
missile[mi]._midam = 0;
missile[mi]._mirange = 245 + (10 * missile[mi]._mispllvl) + (2 * (id > 0) ? plr[id].plrlevel : 1);
}
}
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddFlash2(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_FLASH) || !PRE_BETA
int i;
app_assert(mi < MAXMISSILES);
if (mienemy == MI_ENEMYMONST)
{
if (id != -1) {
missile[mi]._midam = 0;
for (i = 0; i <= plr[id]._pLevel; ++i) missile[mi]._midam += random(56, 2) + 1;
for (i = missile[mi]._mispllvl; i > 0; --i) missile[mi]._midam += (missile[mi]._midam >> 3);
missile[mi]._midam += missile[mi]._midam >> 1;
} else {
missile[mi]._midam = (currlevel >> 1);
}
}
missile[mi]._miPreFlag = TRUE;
missile[mi]._mirange = 19;
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddManashield(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_MANASHLD) || !PRE_BETA
app_assert(mi < MAXMISSILES);
missile[mi]._mirange = ((plr[id]._pLevel << 4) << 1) + (plr[id]._pLevel << 4);
missile[mi]._miVar1 = plr[id]._pHitPoints;
missile[mi]._miVar2 = plr[id]._pHPBase;
missile[mi]._miVar8 = KILL_UNKNOWN; // killed by unknown source (inited)
if (mienemy == MI_ENEMYMONST) UseMana(id, SPL_MANASHLD);
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddFiremove(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
app_assert(mi < MAXMISSILES);
missile[mi]._midam = random(59, 10) + 1 + plr[id]._pLevel;
GetMissileVel(mi,sx,sy,dx,dy,16);
missile[mi]._mirange = 255;
missile[mi]._miVar1 = 0;
missile[mi]._miVar2 = 0;
++missile[mi]._mix;
++missile[mi]._miy;
missile[mi]._miyoff-=32;
//PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddGuardian(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_GUARDIAN) || !PRE_BETA
int i, pn;
int k, l, j;
int tx, ty;
app_assert(mi < MAXMISSILES);
missile[mi]._midam = random(62, 10) + 1 + (plr[id]._pLevel >> 1);
for (i = missile[mi]._mispllvl; i > 0; --i) missile[mi]._midam += (missile[mi]._midam >> 3);
missile[mi]._miDelFlag = TRUE;
for (k = 0; k < 6; ++k) {
l = CrawlNum[k];
j = l + 1;
for (i = CrawlTable[l]; i > 0; --i) {
tx = dx + CrawlTable[j];
ty = dy + CrawlTable[(j + 1)];
app_assert(tx < MAXDUNX);
app_assert(ty < MAXDUNY);
pn = dPiece[tx][ty];
app_assert(pn <= MAXTILES);
if (tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
//if ((dFlags[tx][ty] & BFLAG_VISIBLE) &&
if ((LineClear(sx, sy, tx, ty)) &&
((nSolidTable[pn] | dMonster[tx][ty] | dObject[tx][ty] | nMissileTable[pn] | dMissile[tx][ty]) == 0)) {
missile[mi]._mix = tx;
missile[mi]._miy = ty;
missile[mi]._misx = tx;
missile[mi]._misy = ty;
missile[mi]._miDelFlag = FALSE;
UseMana(id, SPL_GUARDIAN);
k = 6;
break;
}
}
j += 2;
}
}
if (missile[mi]._miDelFlag == TRUE) return;
missile[mi]._misource = id;
missile[mi]._mlid = AddLight(missile[mi]._mix, missile[mi]._miy, 1);
missile[mi]._mirange = (plr[id]._pLevel >> 1) + missile[mi]._mispllvl;
missile[mi]._mirange = missile[mi]._mirange + ((plr[id]._pISplDur * missile[mi]._mirange) >> 7);
if (missile[mi]._mirange > 30) missile[mi]._mirange = 30;
missile[mi]._mirange = missile[mi]._mirange << 4;
if (missile[mi]._mirange < 30) missile[mi]._mirange = 30;
missile[mi]._miVar1 = missile[mi]._mirange - (missile[mi]._miAnimLen);
missile[mi]._miVar2 = 0;
missile[mi]._miVar3 = 1;
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddChain(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_CHAIN) || !PRE_BETA
app_assert(mi < MAXMISSILES);
missile[mi]._miVar1 = dx;
missile[mi]._miVar2 = dy;
missile[mi]._mirange = 1;
UseMana(id, SPL_CHAIN);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
/*void AddChainOLD(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
int i, k, j, mx;
if (dam == 0) {
k = 0;
j = -1;
for (i = 0; i < nummissilevars; ++i) {
mx = missilevars[i][0];
if (mx >= 0 && missile[mx]._mitype == MIT_CHAIN && missile[mx]._miVar8 > k) k = missile[mx]._miVar8;
if (mx < 0) j = i;
}
++k;
missile[mi]._miVar8 = k;
if (j == -1) {
++nummissilevars;
j = nummissilevars;
}
missilevars[j][0] = mi;
missilevars[j][1] = MIT_CHAIN;
missilevars[j][2] = 0;
} else {
for (i = 0; i < nummissilevars; ++i) {
mx = missilevars[i][0];
if (mx >= 0 && missile[mx]._mitype == MIT_CHAIN && missile[mx]._miVar8 == dam) missilevars[i][2]++;
}
}
k = 0;
missile[mi]._midam = 0;
for (i = 0; i < nummissiles; ++i) {
mx = missileactive[i];
if (missile[mx]._mitype == MIT_CHAIN && missile[mx]._midam > k) k = missile[mx]._midam;
if (missile[mx]._mitype == MIT_CHAINBALL && missile[mx]._miVar1 > k) k = missile[mx]._miVar1;
}
++k;
missile[mi]._midam = k;
missile[mi]._mirange = 12 + GetSpellLevel(id, SPL_LIGHTNING);
missile[mi]._mirange = missile[mi]._mirange + ((plr[id]._pISplDur * missile[mi]._mirange) >> 7);
missile[mi]._miVar1 = 0;
missile[mi]._miVar2 = 0;
missile[mi]._miVar3 = 0;
missile[mi]._miVar4 = 0;
missile[mi]._miVar5 = dx;
missile[mi]._miVar6 = dy;
missile[mi]._miVar7 = 0;
UseMana(id, SPL_CHAIN);
}*/
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
/*void AddChainballOLD(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
int i, mx;
missile[mi]._miVar1 = dam;
missile[mi]._miVar2 = 0;
missile[mi]._miVar3 = 0;
missile[mi]._miVar4 = 0;
for (i = 0; i < nummissiles; ++i) {
mx = missileactive[i];
if ((missile[mx]._mitype == MIT_CHAIN) && (missile[mx]._miVar2 == 1) && (missile[mx]._midam == dam)) {
missile[mi]._miVar2 = missile[mx]._miVar2;
missile[mi]._miVar3 = missile[mx]._miVar3;
missile[mi]._miVar4 = missile[mx]._miVar4;
}
if ((missile[mx]._mitype == MIT_CHAIN) && (missile[mx]._midam == dam))
missile[mi]._miVar8 = missile[mx]._miVar8;
}
if (dMonster[sx][sy] != 0) {
missile[mi]._miVar5 = sx;
missile[mi]._miVar6 = sy;
} else {
missile[mi]._miVar5 = 0;
missile[mi]._miVar6 = 0;
}
missile[mi]._midam = (random(61, plr[id]._pLevel) + random(61, 6) + 4) << HP_SHIFT;
GetMissileVel(mi, sx, sy, dx, dy, 16);
missile[mi]._mirange = ((plr[id]._pLevel << 4) << 1) + (GetSpellLevel(id, SPL_CHAIN) << 4);
PutMissile(mi);
}*/
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddBlood(int mi, int sx, int sy, int str, int dy, int midir, char mienemy, int id, int dam)
{
SetMissDir(mi, str);
app_assert(mi < MAXMISSILES);
missile[mi]._midam = 0;
missile[mi]._miLightFlag = TRUE;
missile[mi]._mirange = 250;
//PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddBone(int mi, int sx, int sy, int str, int dy, int midir, char mienemy, int id, int dam)
{
if (str > 3) str = 2;
SetMissDir(mi, str);
app_assert(mi < MAXMISSILES);
missile[mi]._midam = 0;
missile[mi]._miLightFlag = TRUE;
missile[mi]._mirange = 250;
//PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddMetal(int mi, int sx, int sy, int str, int dy, int midir, char mienemy, int id, int dam)
{
if (str > 3) str = 2;
SetMissDir(mi, str);
app_assert(mi < MAXMISSILES);
missile[mi]._midam = 0;
missile[mi]._miLightFlag = TRUE;
missile[mi]._mirange = (missile[mi]._miAnimLen);
//PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddRhino(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
AnimStruct *anim;
app_assert(id < MAXMONSTERS);
app_assert(monster[id].MType != NULL);
if (EquivMonst(monster[id].MType->mtype, MT_HORNED))
anim = &monster[id].MType->Anims[MA_SPECIAL];
else if (EquivMonst(monster[id].MType->mtype, MT_NSNAKE))
anim = &monster[id].MType->Anims[MA_ATTACK];
else
anim = &monster[id].MType->Anims[MA_WALK];
GetMissileVel(mi,sx,sy,dx,dy,18);
app_assert(mi < MAXMISSILES);
missile[mi]._mimfnum = midir;
missile[mi]._miAnimFlags = NULL;
missile[mi]._miAnimData = anim->Cels[midir];
missile[mi]._miAnimDelay = anim->Rate;
missile[mi]._miAnimLen = anim->Frames;
missile[mi]._miAnimWidth = monster[id].MType->mAnimWidth;
missile[mi]._miAnimWidth2 = monster[id].MType->mAnimWidth2;
missile[mi]._miAnimAdd = 1;
if (EquivMonst(monster[id].MType->mtype, MT_NSNAKE))
missile[mi]._miAnimFrame = 7;
missile[mi]._miVar1 = 0;
missile[mi]._miVar2 = 0;
missile[mi]._miLightFlag = TRUE;
if(monster[id]._uniqtype) {
missile[mi]._miUniqTrans = monster[id]._uniqtrans+1;
missile[mi]._mlid = monster[id].mlid;
}
missile[mi]._mirange = 256;
PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddFireman(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
AnimStruct *anim;
app_assert(id < MAXMONSTERS);
app_assert(monster[id].MType != NULL);
anim = &monster[id].MType->Anims[MA_WALK];
GetMissileVel(mi,sx,sy,dx,dy,16);
app_assert(mi < MAXMISSILES);
missile[mi]._mimfnum = midir;
missile[mi]._miAnimFlags = NULL;
missile[mi]._miAnimData = anim->Cels[midir];
missile[mi]._miAnimDelay = anim->Rate;
missile[mi]._miAnimLen = anim->Frames;
missile[mi]._miAnimWidth = monster[id].MType->mAnimWidth;
missile[mi]._miAnimWidth2 = monster[id].MType->mAnimWidth2;
missile[mi]._miAnimAdd = 1;
missile[mi]._miVar1 = 0;
missile[mi]._miVar2 = 0;
missile[mi]._miLightFlag = TRUE;
if(monster[id]._uniqtype)
missile[mi]._miUniqTrans = monster[id]._uniqtrans+1;
dMonster[monster[id]._mx][monster[id]._my] = 0;
missile[mi]._mirange = 256;
PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddFlare(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
int d;
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
GetMissileVel(mi,sx,sy,dx,dy,16);
app_assert(mi < MAXMISSILES);
missile[mi]._mirange = 256;
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
missile[mi]._mlid = AddLight(sx, sy, 8);
if (mienemy == MI_ENEMYMONST) {
UseMana(id, SPL_BSTAR);
d = 5;
//for (k = missile[mi]._mispllvl; k > 0; --k) d -= 1;
//if (d <= 0) d = 1;
#if CHEATS
if (simplecheat || cheatflag) d = 0;
#endif
plr[id]._pHitPoints -= (d << HP_SHIFT);
plr[id]._pHPBase -= (d << HP_SHIFT);
drawhpflag = TRUE;
if (plr[id]._pHitPoints <= 0) {
// rjs - manashld fix? - plr[id]._pHitPoints = 0;
StartPlrKill(id, FALSE);
}
} else {
if (id > 0) {
if (monster[id].MType->mtype == MT_SUCCUBUS) SetMissAnim(mi,MF_FLARE);
if (monster[id].MType->mtype == MT_SNOWWICH) SetMissAnim(mi,MF_BFLARE);
if (monster[id].MType->mtype == MT_HLSPWN) SetMissAnim(mi,MF_DFLARE);
if (monster[id].MType->mtype == MT_SOLBRNR) SetMissAnim(mi,MF_CFLARE);
}
}
//PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddAcid(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
GetMissileVel(mi,sx,sy,dx,dy,16);
SetMissDir(mi, GetDirection16(sx,sy,dx,dy));
app_assert(mi < MAXMISSILES);
missile[mi]._mirange = 15 + 5*(monster[id]._mint+1);
missile[mi]._mlid = -1;
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
/*void AddDoom(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
int i, j, k, l;
int mid;
// search in a 5 radius around tile clicked for monster
for (k = 0; k < 6; ++k) {
l = CrawlNum[k];
j = l + 1;
for (i = CrawlTable[l]; i > 0; --i) {
mid = dMonster[(dx + CrawlTable[j])][(dy + CrawlTable[(j + 1)])];
if (mid != 0) {
if (mid > 0) --mid;
else mid = -(mid + 1);
if ((monster[mid]._mhitpoints >> HP_SHIFT) > 0) {
missile[mi]._miVar1 = dx + CrawlTable[j];
missile[mi]._miVar2 = dy + CrawlTable[j + 1];
missile[mi]._miVar3 = mid;
i = -99;
k = 6;
break;
}
}
j += 2;
}
}
// if no monsters found in search
if (i != -99) {
missile[mi]._miDelFlag = TRUE;
return;
}
GetMissileVel(mi, sx, sy, missile[mi]._miVar1, missile[mi]._miVar2, 16);
SetMissDir(mi, GetDirection(sx, sy, missile[mi]._miVar1, missile[mi]._miVar2));
missile[mi]._mix = sx;
missile[mi]._miy = sy;
missile[mi]._misx = sx;
missile[mi]._misy = sy;
missile[mi]._misource = id;
missile[mi]._midam = 26;
missile[mi]._mirange = ((plr[id]._pLevel << 4) >> 2) + (plr[id]._pLevel << 4) ;
for (i = GetSpellLevel(id, SPL_DOOM); i > 0; --i) missile[mi]._mirange += ((missile[mi]._mirange << 4) >> 3);
missile[mi]._mirange = missile[mi]._mirange + ((plr[id]._pISplDur * missile[mi]._mirange) >> 7);
UseMana(id, SPL_DOOM);
PutMissile(mi);
}*/
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddFireonly(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
app_assert(mi < MAXMISSILES);
missile[mi]._midam = dam;
missile[mi]._mixvel = 0;
missile[mi]._miyvel = 0;
missile[mi]._mirange = 50;
missile[mi]._miVar1 = missile[mi]._mirange - missile[mi]._miAnimLen;
missile[mi]._miVar2 = 0;
//PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddAcidpud(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
int monst;
app_assert(mi < MAXMISSILES);
missile[mi]._mixvel = 0;
missile[mi]._miyvel = 0;
missile[mi]._mixoff = 0;
missile[mi]._miyoff = 0;
/*
missile[mi]._misx = missile[dx]._misx;
missile[mi]._misy = missile[dx]._misy;
missile[mi]._mixoff = missile[dx]._mixoff;
missile[mi]._miyoff = missile[dx]._miyoff;
missile[mi]._mitxoff = missile[dx]._mitxoff;
missile[mi]._mityoff = missile[dx]._mityoff;
*/
missile[mi]._miLightFlag = TRUE;
// MoveMissilePos(mi);
monst = missile[mi]._misource;
missile[mi]._mirange = random(50,15) + 40*(monster[monst]._mint + 1);
missile[mi]._miPreFlag = TRUE;
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddStone(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_STONE) || !PRE_BETA
int i, j, k, l, tx, ty;
int mid;
app_assert(mi < MAXMISSILES);
missile[mi]._misource = id;
// search in a 5 radius around tile clicked for monster
for (k = 0; k < 6; ++k) {
l = CrawlNum[k];
j = l + 1;
for (i = CrawlTable[l]; i > 0; --i) {
tx = dx + CrawlTable[j];
ty = dy + CrawlTable[(j + 1)];
if (tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
mid = dMonster[tx][ty];
if (mid > 0) --mid;
else mid = -(mid + 1);
if ((mid > 3)
&& (monster[mid]._mAi != AI_DIABLO)
&& (monster[mid]._mmode != MM_FADEIN)
&& (monster[mid]._mmode != MM_FADEOUT)
//&& (monster[mid]._mmode != MM_DEATH)
&& (monster[mid]._mmode != MM_MISSILE)) {
i = -99;
k = 6;
missile[mi]._miVar1 = monster[mid]._mmode;
missile[mi]._miVar2 = mid;
monster[mid]._mmode = MM_STONE;
break;
}
}
j += 2;
}
}
// if no monsters found in search
if (i != -99) {
missile[mi]._miDelFlag = TRUE;
return;
}
missile[mi]._mix = tx;
missile[mi]._miy = ty;
missile[mi]._misx = missile[mi]._mix;
missile[mi]._misy = missile[mi]._miy;
missile[mi]._mirange = 6 + missile[mi]._mispllvl;
//if (missile[mi]._mirange == 0) missile[mi]._mirange = 1;
//for (i = missile[mi]._mispllvl; i > 0; --i) missile[mi]._mirange += (missile[mi]._mirange >> 3);
missile[mi]._mirange = missile[mi]._mirange + ((plr[id]._pISplDur * missile[mi]._mirange) >> 7);
if (missile[mi]._mirange > 15) missile[mi]._mirange = 15;
missile[mi]._mirange = missile[mi]._mirange << 4;
UseMana(id, SPL_STONE);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
/*void AddInvis(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
int i;
missile[mi]._mirange = plr[id]._pLevel << 4;
for (i = GetSpellLevel(id, SPL_INVIS); i > 0; --i) missile[mi]._mirange += ((missile[mi]._mirange << 4) >> 3);
missile[mi]._mirange = missile[mi]._mirange + ((plr[id]._pISplDur * missile[mi]._mirange) >> 7);
UseMana(id, SPL_INVIS);
missile[mi]._miDelFlag = TRUE;
}*/
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddGolem(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_GOLEM) || !PRE_BETA
int i, mx;
//int tx, ty, k, j, l;
app_assert(mi < MAXMISSILES);
missile[mi]._miDelFlag = FALSE;
for (i = 0; i < nummissiles; ++i) {
mx = missileactive[i];
if ((missile[mx]._mitype == MIT_GOLEM) && (mx != mi) &&
(missile[mx]._misource == id)) {
missile[mi]._miDelFlag = TRUE;
return;
}
}
/*for (k = 0; k < 6; ++k) {
l = CrawlNum[k];
j = l + 1;
for (i = CrawlTable[l]; i > 0; --i) {
tx = dx + CrawlTable[j];
ty = dy + CrawlTable[(j + 1)];
if (tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
pn = dPiece[tx][ty];
if ((LineClear(sx, sy, tx, ty)) &&
((nSolidTable[pn] | dMonster[tx][ty] | dObject[tx][ty]) == 0)) {*/
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
missile[mi]._miVar4 = dx;
missile[mi]._miVar5 = dy;
if ((monster[id]._mx != 1 || monster[id]._my != 0) && (id == myplr)) M_StartKill(id, id);
//missile[mi]._miDelFlag = FALSE;
UseMana(id, SPL_GOLEM);
/*k = 6;
break;
}
}
j += 2;
}
}*/
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddEther(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_ETHER) || !PRE_BETA
int i;
app_assert(mi < MAXMISSILES);
missile[mi]._mirange = (plr[id]._pLevel << 4) >> 1;
for (i = missile[mi]._mispllvl; i > 0; --i) missile[mi]._mirange += (missile[mi]._mirange >> 3);
missile[mi]._mirange = missile[mi]._mirange + ((plr[id]._pISplDur * missile[mi]._mirange) >> 7);
missile[mi]._miVar1 = plr[id]._pHitPoints;
missile[mi]._miVar2 = plr[id]._pHPBase;
if (mienemy == MI_ENEMYMONST) UseMana(id, SPL_ETHER);
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddBloodR(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_BLOODR) || !PRE_BETA
int manaval;
app_assert(mi < MAXMISSILES);
missile[mi]._miDelFlag = TRUE;
return; // spell deleted - left code here just in case
if (!(plr[id]._pIFlags & IAF_LMANA)) {
plr[id]._pHitPoints -= (10 << HP_SHIFT);
plr[id]._pHPBase -= (10 << HP_SHIFT);
manaval = ((missile[mi]._mispllvl + 8) << MANA_SHIFT);
plr[id]._pMana += manaval;
plr[id]._pManaBase += manaval;
if (plr[id]._pMana > plr[id]._pMaxMana) plr[id]._pMana = plr[id]._pMaxMana;
if (plr[id]._pManaBase > plr[id]._pMaxManaBase) plr[id]._pManaBase = plr[id]._pMaxManaBase;
if (plr[id]._pHitPoints <= 0) {
// rjs - manashld fix? - plr[id]._pHitPoints = 0;
StartPlrKill(id, FALSE);
}
}
UseMana(id, SPL_BLOODR);
drawhpflag = TRUE;
missile[mi]._miDelFlag = TRUE;
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddSpurt(int mi, int sx, int sy, int str, int dy, int midir, char mienemy, int id, int dam)
{
app_assert(mi < MAXMISSILES);
missile[mi]._midam = dam;
missile[mi]._mix = sx;
missile[mi]._miy = sy;
missile[mi]._misx = sx;
missile[mi]._misy = sy;
missile[mi]._misource = id;
if (dam == 1)
SetMissDir(mi, 0);
else
SetMissDir(mi, 1);
missile[mi]._miLightFlag = TRUE;
missile[mi]._mirange = missile[mi]._miAnimLen;
//PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddBoom(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
app_assert(mi < MAXMISSILES);
missile[mi]._mix = dx;
missile[mi]._miy = dy;
missile[mi]._misx = dx;
missile[mi]._misy = dy;
missile[mi]._mixvel = 0;
missile[mi]._miyvel = 0;
missile[mi]._midam = dam;
missile[mi]._mirange = missile[mi]._miAnimLen;
missile[mi]._miVar1 = 0;
//PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddHeal(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_HEAL) || !PRE_BETA
int i;
long l;
l = (random(57, 10) + 1) << HP_SHIFT;
for (i = 0; i < plr[id]._pLevel; ++i) l += ((random(57, 4) + 1) << HP_SHIFT);
app_assert(mi < MAXMISSILES);
for (i = 0; i < missile[mi]._mispllvl; ++i) l += ((random(57, 6) + 1) << HP_SHIFT);
if (plr[id]._pClass == CLASS_WARRIOR) l = l << 1;
if (plr[id]._pClass == CLASS_ROGUE) l += (l >> 1);
plr[id]._pHitPoints += l;
if (plr[id]._pHitPoints > plr[id]._pMaxHP) plr[id]._pHitPoints = plr[id]._pMaxHP;
plr[id]._pHPBase += l;
if (plr[id]._pHPBase > plr[id]._pMaxHPBase) plr[id]._pHPBase = plr[id]._pMaxHPBase;
UseMana(id, SPL_HEAL);
drawhpflag = TRUE;
missile[mi]._miDelFlag = TRUE;
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddMana(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_HEAL) || !PRE_BETA
int i;
long l;
l = (random(57, 10) + 1) << MANA_SHIFT;
for (i = 0; i < plr[id]._pLevel; ++i) l += ((random(57, 4) + 1) << MANA_SHIFT);
app_assert(mi < MAXMISSILES);
for (i = 0; i < missile[mi]._mispllvl; ++i) l += ((random(57, 6) + 1) << MANA_SHIFT);
if (plr[id]._pClass == CLASS_SORCEROR) l = l << 1;
if (plr[id]._pClass == CLASS_ROGUE) l += (l >> 1);
plr[id]._pMana += l;
if (plr[id]._pMana > plr[id]._pMaxMana) plr[id]._pMana = plr[id]._pMaxMana;
plr[id]._pManaBase += l;
if (plr[id]._pManaBase > plr[id]._pMaxManaBase) plr[id]._pManaBase = plr[id]._pMaxManaBase;
UseMana(id, SPL_MANA);
drawmanaflag = TRUE;
missile[mi]._miDelFlag = TRUE;
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
void AddFMana(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_HEAL) || !PRE_BETA
app_assert(mi < MAXMISSILES);
plr[id]._pMana = plr[id]._pMaxMana;
plr[id]._pManaBase = plr[id]._pMaxManaBase;
UseMana(id, SPL_FMANA);
drawmanaflag = TRUE;
#endif
missile[mi]._miDelFlag = TRUE;
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddHealOther(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_HEALOTHER) || !PRE_BETA
app_assert(mi < MAXMISSILES);
missile[mi]._miDelFlag = TRUE;
UseMana(id, SPL_HEALOTHER);
if (id == myplr) {
NewCursor(HEALOTHER_CURS);
}
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddElement(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_ELEMENT) || !PRE_BETA
int i;
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
//missile[mi]._midam = 0;
//for (i = 0; i < plr[id]._pLevel; ++i) missile[mi]._midam += random(67, 6) + 1;
//for (i = missile[mi]._mispllvl; i > 0; --i) missile[mi]._midam += (missile[mi]._midam >> 3);
app_assert(mi < MAXMISSILES);
missile[mi]._midam = (random(60, 10) + random(60, 10) + 2 + plr[id]._pLevel) << 1;
for (i = missile[mi]._mispllvl; i > 0; --i) missile[mi]._midam += (missile[mi]._midam >> 3);
missile[mi]._midam = missile[mi]._midam >> 1;
GetMissileVel(mi, sx, sy, dx, dy, 16);
SetMissDir(mi, GetDirection8(sx, sy, dx, dy));
missile[mi]._mirange = 256;
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
missile[mi]._miVar3 = 0;
missile[mi]._miVar4 = dx;
missile[mi]._miVar5 = dy;
missile[mi]._mlid = AddLight(sx, sy, 8);
UseMana(id, SPL_ELEMENT);
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddIdentify(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_IDENTIFY) || !PRE_BETA
app_assert(mi < MAXMISSILES);
missile[mi]._miDelFlag = TRUE;
UseMana(id, SPL_IDENTIFY);
if (id == myplr) {
if (sbookflag) sbookflag = FALSE;
if (!invflag) invflag = TRUE;
NewCursor(IDENTIFY_CURS);
}
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddFirewallC(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_WALL) || !PRE_BETA
int i, pn;
int k, l, j;
int tx, ty;
app_assert(mi < MAXMISSILES);
missile[mi]._miDelFlag = TRUE;
for (k = 0; k < 6; ++k) {
l = CrawlNum[k];
j = l + 1;
for (i = CrawlTable[l]; i > 0; --i) {
tx = dx + CrawlTable[j];
ty = dy + CrawlTable[(j + 1)];
if (tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
pn = dPiece[tx][ty];
//if ((dFlags[tx][ty] & BFLAG_VISIBLE) && ((sx != tx) || (sy != ty)) &&
if ((LineClear(sx, sy, tx, ty)) && ((sx != tx) || (sy != ty)) &&
((nSolidTable[pn] | dObject[tx][ty]) == 0)) {
missile[mi]._miVar1 = tx;
missile[mi]._miVar2 = ty;
missile[mi]._miVar5 = tx;
missile[mi]._miVar6 = ty;
missile[mi]._miDelFlag = FALSE;
k = 6;
break;
}
}
j += 2;
}
}
if (missile[mi]._miDelFlag == TRUE) return;
missile[mi]._miVar7 = 0;
missile[mi]._miVar8 = 0;
//midir = GetDirection(sx, sy, tx, ty);
missile[mi]._miVar3 = (midir - 2) & 0x0007;
missile[mi]._miVar4 = (midir + 2) & 0x0007;
missile[mi]._mirange = 7;
UseMana(id, SPL_WALL);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddFlameBox(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_WALL) || !PRE_BETA
app_assert(mi < MAXMISSILES);
missile[mi]._miDelFlag = TRUE;
if (mienemy == MI_ENEMYMONST){
UseMana(id, SPL_RINGOFFIRE);
}
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
missile[mi]._miDelFlag = FALSE;
missile[mi]._miVar3 = 0;
missile[mi]._miVar4 = 0;
missile[mi]._miVar5 = 0;
missile[mi]._miVar6 = 0;
missile[mi]._miVar7 = 0;
missile[mi]._miVar8 = 0;
missile[mi]._mirange = 7;
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddShowMagicItems(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_WALL) || !PRE_BETA
app_assert(mi < MAXMISSILES);
missile[mi]._miDelFlag = FALSE;
missile[mi]._miVar1 = 0;
missile[mi]._miVar2 = 0;
missile[mi]._miVar3 = 0;
missile[mi]._miVar4 = 0;
missile[mi]._miVar5 = 0;
missile[mi]._miVar6 = 0;
missile[mi]._miVar7 = 0;
missile[mi]._miVar8 = 0;
HighLightAllItems = true;
missile[mi]._mirange = 245 + (10 * missile[mi]._mispllvl) + (2 * (id > 0) ? plr[id].plrlevel : 1);
if (mienemy == MI_ENEMYMONST){
UseMana(id, SPL_SHOWMAGITEMS);
}
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddInfra(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_INFRA) || !PRE_BETA
int i;
app_assert(mi < MAXMISSILES);
missile[mi]._mirange = 99 << 4;
for (i = missile[mi]._mispllvl; i > 0; --i) missile[mi]._mirange += (missile[mi]._mirange >> 3);
missile[mi]._mirange = missile[mi]._mirange + ((plr[id]._pISplDur * missile[mi]._mirange) >> 7);
if (mienemy == MI_ENEMYMONST) UseMana(id, SPL_INFRA);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddWave(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_WAVE) || !PRE_BETA
missile[mi]._miVar1 = dx;
missile[mi]._miVar2 = dy;
missile[mi]._miVar3 = 0;
missile[mi]._miVar4 = 0;
missile[mi]._mirange = 1;
missile[mi]._miAnimFrame = 4;
UseMana(id, SPL_WAVE);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddNova(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_NOVA) || !PRE_BETA
int k;
app_assert(mi < MAXMISSILES);
missile[mi]._miVar1 = dx;
missile[mi]._miVar2 = dy;
if (id != -1) {
missile[mi]._midam = random(66, 6) + random(66, 6) + random(66, 6) + random(66, 6) + random(66, 6);
missile[mi]._midam += 5 + plr[id]._pLevel;
missile[mi]._midam = missile[mi]._midam >> 1;
for (k = missile[mi]._mispllvl; k > 0; --k) missile[mi]._midam += (missile[mi]._midam >> 3);
if (mienemy == MI_ENEMYMONST) UseMana(id, SPL_NOVA);
} else {
missile[mi]._midam = random(66, 3) + random(66, 3) + random(66, 3);
missile[mi]._midam += (currlevel >> 1);
}
missile[mi]._mirange = 1;
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddBoil(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
// not in game
missile[mi]._miDelFlag = TRUE;
return;
/*
#if (PRE_BETA && PRE_BLOODB) || !PRE_BETA
missile[mi]._miVar1 = dx;
missile[mi]._miVar2 = dy;
missile[mi]._mirange = 1;
#else
missile[mi]._miDelFlag = TRUE;
#endif*/
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddRepair(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_REPAIR) || !PRE_BETA
app_assert(mi < MAXMISSILES);
missile[mi]._miDelFlag = TRUE;
UseMana(id, SPL_REPAIR);
if (id == myplr) {
if (sbookflag) sbookflag = FALSE;
if (!invflag) invflag = TRUE;
NewCursor(REPAIR_CURS);
}
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddRecharge(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_RECHARGE) || !PRE_BETA
app_assert(mi < MAXMISSILES);
missile[mi]._miDelFlag = TRUE;
UseMana(id, SPL_RECHARGE);
if (id == myplr) {
if (sbookflag) sbookflag = FALSE;
if (!invflag) invflag = TRUE;
NewCursor(RECHARGE_CURS);
}
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddDisarm(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_DISARM) || !PRE_BETA
app_assert(mi < MAXMISSILES);
missile[mi]._miDelFlag = TRUE;
UseMana(id, SPL_DISARM);
if (id == myplr) {
NewCursor(DISARM_CURS);
}
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddApoca(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_APOCA) || !PRE_BETA
int i;
app_assert(mi < MAXMISSILES);
missile[mi]._miVar1 = 8;
missile[mi]._miVar2 = sy - missile[mi]._miVar1;
missile[mi]._miVar3 = sy + missile[mi]._miVar1;
missile[mi]._miVar4 = sx - missile[mi]._miVar1;
missile[mi]._miVar5 = sx + missile[mi]._miVar1;
missile[mi]._miVar6 = missile[mi]._miVar4;
if (missile[mi]._miVar2 <= 0) missile[mi]._miVar2 = 1;
if (missile[mi]._miVar3 >= MAXDUNY) missile[mi]._miVar3 = MAXDUNY - 1;
if (missile[mi]._miVar4 <= 0) missile[mi]._miVar4 = 1;
if (missile[mi]._miVar5 >= MAXDUNX) missile[mi]._miVar5 = MAXDUNX - 1;
for (i = 0; i < plr[id]._pLevel; ++i) missile[mi]._midam += random(67, 6) + 1;
missile[mi]._mirange = 255;
missile[mi]._miDelFlag = FALSE;
UseMana(id, SPL_APOCA);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddFlame(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int seqno)
{
#if (PRE_BETA && PRE_FLAME) || !PRE_BETA
// seqno: the number of flame chunk for this spell instance
int i;
app_assert(mi < MAXMISSILES);
missile[mi]._miVar2 = 0;
//for (i = 0; i < 2 - seqno; ++i) {
for (i = seqno; i > 0; --i) {
missile[mi]._miVar2 += 5;
}
missile[mi]._misx = dx;
missile[mi]._misy = dy;
missile[mi]._mixoff = missile[midir]._mixoff;
missile[mi]._miyoff = missile[midir]._miyoff;
missile[mi]._mitxoff = missile[midir]._mitxoff;
missile[mi]._mityoff = missile[midir]._mityoff;
missile[mi]._mirange = 20 + missile[mi]._miVar2;
missile[mi]._mlid = AddLight(sx, sy, 1);
if (mienemy == MI_ENEMYMONST) {
missile[mi]._midam = (random(79, plr[id]._pLevel) + random(79, 2) + 2) << 3;
missile[mi]._midam += missile[mi]._midam >> 1;
//missile[mi]._midam = plr[id]._pLevel << 2;
//for (i = missile[mi]._mispllvl; i > 0; --i) missile[mi]._midam += (missile[mi]._midam >> 3);
//missile[mi]._midam = missile[mi]._midam << 1 + missile[mi]._midam;
} else {
missile[mi]._midam = random(77, monster[id].mMaxDamage - monster[id].mMinDamage + 1) + monster[id].mMinDamage;
}
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddFlamec(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_FLAME) || !PRE_BETA
//int k;
//int tsx, tsy;
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
GetMissileVel(mi, sx, sy, dx, dy, 32);
if (mienemy == MI_ENEMYMONST) UseMana(id, SPL_FLAME);
app_assert(mi < MAXMISSILES);
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
missile[mi]._miVar3 = 0;
missile[mi]._mirange = 256;
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddCbolt(int mi, int sx, int sy, int dx, int dy, int midir, char micaster, int id, int dam)
{
#if (PRE_BETA && PRE_CBOLT) || !PRE_BETA
app_assert(mi < MAXMISSILES);
if (micaster == MI_ENEMYMONST)
{
if (id == myplr) {
missile[mi]._mirnd = random(63, 15) + 1;
// INSERT send seed code
} else {
// INSERT get seed from network message for syncing
// used as a number idx not a seed so no SetRndSeed necessary
missile[mi]._mirnd = random(63, 15) + 1;
}
missile[mi]._midam = random(68, plr[id]._pMagic >> 2) + 1;
//for (i = missile[mi]._mispllvl; i > 0; --i) ++missile[mi]._midam;
}
else
{
missile[mi]._mirnd = random(63, 15) + 1;
missile[mi]._midam = 15;
}
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
missile[mi]._miAnimFrame = random(63, 8) + 1;
missile[mi]._mlid = AddLight(sx, sy, 5);
GetMissileVel(mi, sx, sy, dx, dy, 8);
missile[mi]._miVar1 = 5;
missile[mi]._miVar2 = midir;
missile[mi]._miVar3 = 0;
missile[mi]._mirange = 256;
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
void AddCBArrow(int mi, int sx, int sy, int dx, int dy, int midir, char micaster, int id, int dam)
{
#if (PRE_BETA && PRE_CBOLT) || !PRE_BETA
app_assert(mi < MAXMISSILES);
if (micaster == MI_ENEMYMONST)
{
if (id == myplr) {
missile[mi]._mirnd = random(63, 15) + 1;
// INSERT send seed code
} else {
// INSERT get seed from network message for syncing
// used as a number idx not a seed so no SetRndSeed necessary
missile[mi]._mirnd = random(63, 15) + 1;
}
}
else
{
missile[mi]._mirnd = random(63, 15) + 1;
missile[mi]._midam = 15;
}
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
missile[mi]._miAnimFrame = random(63, 8) + 1;
missile[mi]._mlid = AddLight(sx, sy, 5);
GetMissileVel(mi, sx, sy, dx, dy, 8);
missile[mi]._miVar1 = 5;
missile[mi]._miVar2 = midir;
missile[mi]._miVar3 = 0;
missile[mi]._mirange = 256;
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddHbolt(int mi, int sx, int sy, int dx, int dy, int midir, char micaster, int id, int dam)
{
#if (PRE_BETA && PRE_HBOLT) || !PRE_BETA
int sp;
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
app_assert(mi < MAXMISSILES);
if (id != -1) {
sp = 16 + (missile[mi]._mispllvl << 1);
if (sp >= 63) sp = 63;
} else sp = 16;
GetMissileVel(mi, sx, sy, dx, dy, sp);
SetMissDir(mi, GetDirection16(sx, sy, dx, dy));
missile[mi]._mirange = 256;
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
missile[mi]._mlid = AddLight(sx, sy, 8);
missile[mi]._midam = random(69, 10) + 9 + plr[id]._pLevel;
UseMana(id, SPL_HBOLT);
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
void AddHBArrow(int mi, int sx, int sy, int dx, int dy, int midir, char micaster, int id, int dam)
{
#if (PRE_BETA && PRE_HBOLT) || !PRE_BETA
int sp;
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
app_assert(mi < MAXMISSILES);
if (id != -1) {
sp = 16 + (missile[mi]._mispllvl << 1);
if (sp >= 63) sp = 63;
} else sp = 16;
GetMissileVel(mi, sx, sy, dx, dy, sp);
SetMissDir(mi, GetDirection16(sx, sy, dx, dy));
missile[mi]._mirange = 256;
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
missile[mi]._mlid = AddLight(sx, sy, 8);
//PutMissile(mi);
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddResurrect(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_RESURRECT) || !PRE_BETA
UseMana(id, SPL_RESURRECT);
if (id == myplr) {
NewCursor(RESURRECT_CURS);
}
#endif
app_assert(mi < MAXMISSILES);
missile[mi]._miDelFlag = TRUE;
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddResurrectBeam(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_RESURRECT) || !PRE_BETA
app_assert(mi < MAXMISSILES);
missile[mi]._mix = dx;
missile[mi]._miy = dy;
missile[mi]._misx = missile[mi]._mix;
missile[mi]._misy = missile[mi]._miy;
missile[mi]._mixvel = 0;
missile[mi]._miyvel = 0;
missile[mi]._mirange = misfiledata[MF_RESURRECT].mAnimLen[0];
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddTelekinesis(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_TELEKINESIS) || !PRE_BETA
app_assert(mi < MAXMISSILES);
missile[mi]._miDelFlag = TRUE;
UseMana(id, SPL_TELEKINESIS);
if (id == myplr) {
NewCursor(TELE_CURS);
}
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
/*void AddBoneSpirit(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
int d, mid, mx, my;
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
GetMissileVel(mi, sx, sy, dx, dy, 16);
missile[mi]._mirange = 256;
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
missile[mi]._mlid = AddLight(sx, sy, 8);
if (mienemy == MI_ENEMYMONST) {
UseMana(id, SPL_BONESPIRIT);
d = 6;
#if CHEATS
if (simplecheat || cheatflag) d = 0;
#endif
plr[id]._pHitPoints -= (d << HP_SHIFT);
plr[id]._pHPBase -= (d << HP_SHIFT);
drawhpflag = TRUE;
if (plr[id]._pHitPoints <= 0) {
// rjs - manashld fix? - plr[id]._pHitPoints = 0;
StartPlrKill(id, FALSE);
}
if (dPlayer[dx][dy] != 0) {
missile[mi]._miVar6 = 1;
if (dPlayer[dx][dy] > 0) mid = dPlayer[dx][dy] - 1;
else mid = -(dPlayer[dx][dy] + 1);
mx = plr[mid]._px;
my = plr[mid]._py;
} else {
missile[mi]._miVar6 = 0;
if (dMonster[dx][dy] <= 0) mid = FindClosest(sx, sy, 19);
else mid = dMonster[dx][dy] - 1;
mx = monster[mid]._mx;
my = monster[mid]._my;
}
if (mid > 0) {
missile[mi]._miVar3 = mid;
GetMissileVel(mi, sx, sy, mx, my, 16);
SetMissDir(mi, GetDirection8(sx, sy, mx, my));
}
}
PutMissile(mi);
}
*/
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddBoneSpirit(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
#if (PRE_BETA && PRE_BONESPIRIT) || !PRE_BETA
int d;
if ((sx == dx) && (sy == dy)) {
dx += XDirAdd[midir];
dy += YDirAdd[midir];
}
app_assert(mi < MAXMISSILES);
missile[mi]._midam = 0;
GetMissileVel(mi, sx, sy, dx, dy, 16);
SetMissDir(mi, GetDirection8(sx, sy, dx, dy));
missile[mi]._mirange = 256;
missile[mi]._miVar1 = sx;
missile[mi]._miVar2 = sy;
missile[mi]._miVar3 = 0;
missile[mi]._miVar4 = dx;
missile[mi]._miVar5 = dy;
missile[mi]._mlid = AddLight(sx, sy, 8);
if (mienemy == MI_ENEMYMONST) {
UseMana(id, SPL_BONESPIRIT);
d = 6;
#if CHEATS
if (simplecheat || cheatflag) d = 0;
#endif
plr[id]._pHitPoints -= (d << HP_SHIFT);
plr[id]._pHPBase -= (d << HP_SHIFT);
drawhpflag = TRUE;
if (plr[id]._pHitPoints <= 0) {
// rjs - manashld fix? - plr[id]._pHitPoints = 0;
StartPlrKill(id, FALSE);
}
}
#else
missile[mi]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddRportal(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
app_assert(mi < MAXMISSILES);
missile[mi]._mix = sx;
missile[mi]._miy = sy;
missile[mi]._misx = sx;
missile[mi]._misy = sy;
missile[mi]._mirange = 100;
missile[mi]._miVar1 = missile[mi]._mirange - (missile[mi]._miAnimLen);
missile[mi]._miVar2 = 0;
PutMissile(mi);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void AddDiabApoca(int mi, int sx, int sy, int dx, int dy, int midir, char mienemy, int id, int dam)
{
BOOL LineClear(int x1, int y1, int x2, int y2);
int pnum;
for (pnum = 0; pnum < gbMaxPlayers; ++pnum)
{
if (plr[pnum].plractive
&& LineClear(sx,sy,plr[pnum]._pfutx, plr[pnum]._pfuty))
AddMissile(0, 0, plr[pnum]._pfutx, plr[pnum]._pfuty, 0, MIT_FIREPLAR, mienemy, id, dam, 0);
}
app_assert(mi < MAXMISSILES);
missile[mi]._miDelFlag = TRUE;
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
int AddMissile(int sx, int sy, int v1, int v2, int midir, int mitype, char micaster, int id, int v3, int spllvl)
{
// v1 and v2 are usually dx and dy (this can be different per missile)
// v3 is usually damage amount
int mi;
// check if exceeded number of missiles
if (nummissiles >= MAXMISSILES)
return -1;
// get next missile id that is available
mi = missileavail[0];
missileavail[0] = missileavail[MAXMISSILES - nummissiles - 1];
missileactive[nummissiles] = mi;
++nummissiles;
// Zero out the data first.
memset(&missile[mi], 0, sizeof(MissileStruct));
// do some standard missile setups
missile[mi]._mitype = mitype;
missile[mi]._micaster = micaster;
missile[mi]._misource = id;
missile[mi]._miAnimType = missiledata[mitype].mFileNum;
missile[mi]._miDrawFlag = missiledata[mitype].mDraw;
missile[mi]._mispllvl = spllvl;
missile[mi]._mimfnum = midir;
if (missile[mi]._miAnimType != MF_NONE
&& misfiledata[(missile[mi]._miAnimType)].mAnimFAmt >= 8)
SetMissDir(mi, midir);
else
SetMissDir(mi, 0);
missile[mi]._mix = sx;
missile[mi]._miy = sy;
missile[mi]._mixoff = 0;
missile[mi]._miyoff = 0;
missile[mi]._misx = sx;
missile[mi]._misy = sy;
missile[mi]._mitxoff = 0;
missile[mi]._mityoff = 0;
missile[mi]._miDelFlag = FALSE;
missile[mi]._miAnimAdd = 1;
missile[mi]._miLightFlag = FALSE;
missile[mi]._miPreFlag = FALSE;
missile[mi]._miUniqTrans = FALSE;
missile[mi]._midam = v3;
missile[mi]._miHitFlag = FALSE;
missile[mi]._midist = 0;
missile[mi]._mlid = -1;
missile[mi]._mirnd = 0;
if (missiledata[mitype].mlSFX != -1)
PlaySfxLoc(missiledata[mitype].mlSFX, missile[mi]._mix, missile[mi]._miy);
missiledata[mitype].mAddProc(mi, sx, sy, v1, v2, midir, micaster, id, v3);
return mi;
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
/*int ChainBounceOLD (int i, int sx, int sy)
{
int j, mi, mx, dir;
if (dMonster[sx][sy] != 0) {
if (dMonster[sx][sy] > 0) mi = dMonster[sx][sy] - 1;
else mi = -(dMonster[sx][sy] + 1);
if ((monster[mi]._mhitpoints >> HP_SHIFT) > 0) {
for (j = 0; j < nummissilevars; ++j) {
mx = missilevars[j][0];
if ((mx >= 0) && (missile[mx]._mitype == MIT_CHAIN) && (missile[mx]._miVar8 == missile[i]._miVar8) &&
(missilevars[j][2] >= (plr[(missile[i]._misource)]._pLevel >> 1))) {
missilevars[j][0] = -1;
return 3;
}
}
dir = GetDirection(missile[i]._mix, missile[i]._miy, sx, sy);
AddMissile(missile[i]._mix, missile[i]._miy, sx, sy, dir, MIT_CHAIN, MI_ENEMYMONST, missile[i]._misource, missile[i]._miVar8);
return 1;
}
}
return 0;
}*/
extern BOOL LineClear(int x1, int y1, int x2, int y2);
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
int Sentfire(int i, int sx, int sy)
{
int ex, dir;
ex = 0;
app_assert(i < MAXMISSILES);
if (LineClear(missile[i]._mix, missile[i]._miy, sx, sy)
&& (dMonster[sx][sy] > 0)
&& ((monster[(dMonster[sx][sy] - 1)]._mhitpoints >> HP_SHIFT) > 0)
&& ((dMonster[sx][sy]-1) > 3)) {
dir = GetDirection(missile[i]._mix, missile[i]._miy, sx, sy);
missile[i]._miVar3 = missileavail[0]; // get next mid
AddMissile(missile[i]._mix, missile[i]._miy, sx, sy, dir, MIT_FIREBOLT, MI_ENEMYMONST, missile[i]._misource, missile[i]._midam, GetSpellLevel(missile[i]._misource, SPL_FIREBOLT));
ex = -1;
}
if (ex == -1) {
SetMissDir(i, 2);
missile[i]._miVar2 = 3;
}
return (ex);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Dummy(int i)
{}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Rune(int i)
{
int const tx = missile[i]._mix;
int const ty = missile[i]._miy;
int mid = dMonster[tx][ty];
int pid = dPlayer[tx][ty];
if (mid != 0
|| pid != 0) {
int dir;
if (mid != 0) {
if (mid > 0) --mid;
else mid = -(mid + 1);
dir = GetDirection(missile[i]._mixoff, missile[i]._miyoff,
monster[mid]._mxoff, monster[mid]._myoff);
}
else {
if (pid > 0) --pid;
else pid = -(pid + 1);
dir = GetDirection(missile[i]._mixoff, missile[i]._miyoff,
plr[pid]._pxoff, plr[pid]._pyoff);
}
if (missile[i]._miVar1 == MIT_MISEXP){
AddMissile(tx, ty, i, 0, dir, missile[i]._miVar1, MI_ENEMYMONST, missile[i]._misource, missile[i]._midam, missile[i]._mispllvl);
}
else {
AddMissile(tx, ty, tx, ty, dir, missile[i]._miVar1, MI_ENEMYMONST, missile[i]._misource, missile[i]._midam, missile[i]._mispllvl);
}
missile[i]._miDelFlag = TRUE;
}
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Golem(int i)
{
#if (PRE_BETA && PRE_GOLEM) || !PRE_BETA
int id, pn;
int j, k, l, m;
int tx, ty;
app_assert(i < MAXMISSILES);
id = missile[i]._misource;
if (monster[id]._mx == 1 && monster[id]._my == 0) {
for (k = 0; k < 6; ++k) {
l = CrawlNum[k];
j = l + 1;
for (m = CrawlTable[l]; m > 0; --m) {
tx = missile[i]._miVar4 + CrawlTable[j];
ty = missile[i]._miVar5 + CrawlTable[(j + 1)];
if (tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
pn = dPiece[tx][ty];
if ((LineClear(missile[i]._miVar1, missile[i]._miVar2, tx, ty)) &&
((nSolidTable[pn] | dMonster[tx][ty] | dObject[tx][ty]) == 0)) {
k = 6;
SpawnGolum(id, tx, ty, i);
break;
}
}
j += 2;
}
}
}
missile[i]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_SetManashield(int i)
{
#if (PRE_BETA && PRE_MANASHLD) || !PRE_BETA
ManashieldFlag = 1;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_LArrow(int i)
{
int p, mind, maxd, rst;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
p = missile[i]._misource;
if (missile[i]._miAnimType != MF_CBOLT && missile[i]._miAnimType != MF_EXP1) {
++missile[i]._midist;
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
if (p != -1) {
if (missile[i]._micaster == MI_ENEMYMONST) {
mind = plr[p]._pIMinDam;
maxd = plr[p]._pIMaxDam;
} else {
mind = monster[p].mMinDamage;
maxd = monster[p].mMaxDamage;
}
} else {
mind = currlevel + random(68, 10) + 1;
maxd = (currlevel * 2) + random(68, 10) + 1;
}
if ((missile[i]._mix != missile[i]._misx) || (missile[i]._miy != missile[i]._misy)) {
rst = missiledata[(missile[i]._mitype)].mResist;
missiledata[(missile[i]._mitype)].mResist = MIMT_NONE;
CheckMissileCol(i, mind, maxd, 0, missile[i]._mix, missile[i]._miy, 0);
missiledata[(missile[i]._mitype)].mResist = rst;
}
if (missile[i]._mirange == 0) {
missile[i]._mimfnum = 0;
missile[i]._mitxoff -= missile[i]._mixvel;
missile[i]._mityoff -= missile[i]._miyvel;
GetMissilePos(i);
if (missile[i]._mitype == MIT_LARROW) {
SetMissAnim(i, MF_CBOLT);
missile[i]._mirange = missile[i]._miAnimLen - 1;
} else {
SetMissAnim(i, MF_EXP1);
missile[i]._mirange = missile[i]._miAnimLen - 1;
}
} else {
if ((missile[i]._mix != missile[i]._miVar1) || (missile[i]._miy != missile[i]._miVar2)) {
missile[i]._miVar1 = missile[i]._mix;
missile[i]._miVar2 = missile[i]._miy;
ChangeLight(missile[i]._mlid, missile[i]._miVar1, missile[i]._miVar2, 5);
}
}
} else {
ChangeLight(missile[i]._mlid, missile[i]._mix, missile[i]._miy, 5 + missile[i]._miAnimFrame);
rst = missiledata[(missile[i]._mitype)].mResist;
// drb.patch1.start.02/25/97
if (missile[i]._mitype == MIT_LARROW) {
if (p != -1) {
mind = plr[p]._pILMinDam;
maxd = plr[p]._pILMaxDam;
} else {
mind = currlevel + random(68, 10) + 1;
maxd = (currlevel * 2) + random(68, 10) + 1;
}
missiledata[MIT_LARROW].mResist = MIMT_LGHT;
CheckMissileCol(i, mind, maxd, 0, missile[i]._mix, missile[i]._miy, 1);
}
if (missile[i]._mitype == MIT_FARROW) {
if (p != -1) {
mind = plr[p]._pIFMinDam;
maxd = plr[p]._pIFMaxDam;
} else {
mind = currlevel + random(68, 10) + 1;
maxd = (currlevel * 2) + random(68, 10) + 1;
}
missiledata[MIT_FARROW].mResist = MIMT_FIRE;
CheckMissileCol(i, mind, maxd, 0, missile[i]._mix, missile[i]._miy, 1);
}
// endpatch1.2/25/97
missiledata[(missile[i]._mitype)].mResist = rst;
}
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
}
PutMissile(i);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Arrow(int i)
{
int p, mind, maxd;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
++missile[i]._midist;
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
p = missile[i]._misource;
if (p != -1) {
if (missile[i]._micaster == MI_ENEMYMONST) {
mind = plr[p]._pIMinDam;
maxd = plr[p]._pIMaxDam;
} else {
mind = monster[p].mMinDamage;
maxd = monster[p].mMaxDamage;
}
} else {
mind = currlevel;
maxd = currlevel * 2;
}
if ((missile[i]._mix != missile[i]._misx) || (missile[i]._miy != missile[i]._misy))
CheckMissileCol(i, mind, maxd, 0, missile[i]._mix, missile[i]._miy, 0);
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
PutMissile(i);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Firebolt(int i)
{
#if (PRE_BETA && PRE_FIREBOLT) || !PRE_BETA
int omx, omy, d, p;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
if (missile[i]._mitype == MIT_BONESPIRIT && missile[i]._mimfnum == 8) {
if (missile[i]._mirange == 0) {
if(missile[i]._mlid >= 0) AddUnLight(missile[i]._mlid);
missile[i]._miDelFlag = TRUE;
PlaySfxLoc(LS_BSIMPCT, missile[i]._mix, missile[i]._miy);
}
PutMissile(i);
return;
}
omx = missile[i]._mitxoff;
omy = missile[i]._mityoff;
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
p = missile[i]._misource;
if (p != -1) {
if (missile[i]._micaster == MI_ENEMYMONST) {
switch(missile[i]._mitype) {
case MIT_FLARE:
d = ((plr[p]._pMagic>>1)-(plr[p]._pMagic>>3)) + (missile[i]._mispllvl << 1) + missile[i]._mispllvl;
break;
case MIT_FIREBOLT:
d = random(75, 10) + 1 + (plr[p]._pMagic >> 3) + missile[i]._mispllvl;
break;
case MIT_BONESPIRIT:
//d = (monster[missile[i]._miVar3]._mhitpoints >> HP_SHIFT) >> 1;
d = 0;
break;
}
} else d = (random(77, monster[p].mMaxDamage - monster[p].mMinDamage + 1) + monster[p].mMinDamage);
} else d = random(78, currlevel << 1) + currlevel;
if ((missile[i]._mix != missile[i]._misx) || (missile[i]._miy != missile[i]._misy))
CheckMissileCol(i, d, d, 0, missile[i]._mix, missile[i]._miy, 0);
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
missile[i]._mitxoff = omx;
missile[i]._mityoff = omy;
GetMissilePos(i);
switch(missile[i]._mitype) {
case MIT_FLARE:
AddMissile(missile[i]._mix, missile[i]._miy, i, 0, missile[i]._mimfnum, MIT_FLAREXP, missile[i]._micaster, missile[i]._misource, 0, 0);
break;
case MIT_FIREBOLT:
case MIT_MAGMABALL:
AddMissile(missile[i]._mix, missile[i]._miy, i, 0, missile[i]._mimfnum, MIT_MISEXP, missile[i]._micaster, missile[i]._misource, 0, 0);
break;
case MIT_ACID:
AddMissile(missile[i]._mix, missile[i]._miy, i, 0, missile[i]._mimfnum, MIT_ACIDSPLAT, missile[i]._micaster, missile[i]._misource, 0, 0);
break;
case MIT_BONESPIRIT:
SetMissDir(i, 8);
missile[i]._mirange = 7;
missile[i]._miDelFlag = FALSE;
PutMissile(i);
return;
}
if(missile[i]._mlid >= 0) AddUnLight(missile[i]._mlid);
} else {
if ((missile[i]._mix != missile[i]._miVar1) || (missile[i]._miy != missile[i]._miVar2)) {
missile[i]._miVar1 = missile[i]._mix;
missile[i]._miVar2 = missile[i]._miy;
if(missile[i]._mlid >= 0) ChangeLight(missile[i]._mlid, missile[i]._miVar1, missile[i]._miVar2, 8);
}
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Lightball(int i)
{
int j, tx, ty, oi;
app_assert(i < MAXMISSILES);
tx = missile[i]._miVar1;
ty = missile[i]._miVar2;
--missile[i]._mirange;
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
j = missile[i]._mirange;
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 0, missile[i]._mix, missile[i]._miy, 0);
if (missile[i]._miHitFlag == TRUE) missile[i]._mirange = j;
// fix for shires and fireing nova - rjs
if (dObject[tx][ty] != 0 && tx == missile[i]._mix && ty == missile[i]._miy) {
if (dObject[tx][ty] > 0) oi = dObject[tx][ty] - 1;
else oi = -(dObject[tx][ty] + 1);
if (object[oi]._otype == OBJ_SHRINEL || object[oi]._otype == OBJ_SHRINER) missile[i]._mirange = j;
}
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
PutMissile(i);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Krull(int i)
{
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 0, missile[i]._mix, missile[i]._miy, 0);
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
PutMissile(i);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Acidpud(int i)
{
int range;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
// GetMissilePos(i);
range = missile[i]._mirange;
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 1, missile[i]._mix, missile[i]._miy, 0);
missile[i]._mirange = range; // CheckMissileCol clears range if there's a collision,
// but this missile sticks around even after a collision
// MoveMissilePos(i);
if (missile[i]._mirange == 0)
{
if(missile[i]._mimfnum)
missile[i]._miDelFlag = TRUE;
else
{
SetMissDir(i, 1);
missile[i]._mirange = missile[i]._miAnimLen;
}
}
PutMissile(i);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Firewall(int i)
{
#if (PRE_BETA && PRE_WALL) || !PRE_BETA
int ExpLight[14] = {2,3,4,5,5,6,7,8,9,10,11,12,12};
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
if (missile[i]._mirange == missile[i]._miVar1) {
SetMissDir(i, 1);
missile[i]._miAnimFrame = random(83, 11) + 1;
}
if (missile[i]._mirange == missile[i]._miAnimLen - 1) {
SetMissDir(i, 0);
missile[i]._miAnimFrame = 13;
missile[i]._miAnimAdd = -1;
}
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 1, missile[i]._mix, missile[i]._miy, 1);
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
}
if ((missile[i]._mimfnum != 0) && (missile[i]._mirange != 0) &&
(missile[i]._miAnimAdd != -1) && (missile[i]._miVar2 < 12)) {
if (missile[i]._miVar2 == 0)
missile[i]._mlid = AddLight(missile[i]._mix, missile[i]._miy, ExpLight[(missile[i]._miVar2)]);
ChangeLight(missile[i]._mlid, missile[i]._mix, missile[i]._miy, ExpLight[(missile[i]._miVar2)]);
++missile[i]._miVar2;
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Fireball(int i)
{
#if (PRE_BETA && PRE_FIREBALL) || !PRE_BETA
int dam, px, py, id, mx, my;
app_assert(i < MAXMISSILES);
id = missile[i]._misource;
dam = missile[i]._midam;
//dam = missile[i]._mispllvl; // rjs test
//missiledata[(missile[i]._mitype)].mResist = MIMT_NONE;
--missile[i]._mirange;
if (missile[i]._micaster == MI_ENEMYMONST) {
px = plr[id]._px;
py = plr[id]._py;
} else {
px = monster[id]._mx;
py = monster[id]._my;
}
if (missile[i]._miAnimType == MF_BIGEXP) {
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
}
PutMissile(i);
return;
}
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
if ((missile[i]._mix != missile[i]._misx) || (missile[i]._miy != missile[i]._misy))
CheckMissileCol(i, dam, dam, 0, missile[i]._mix, missile[i]._miy, 0);
if (missile[i]._mirange == 0) {
mx = missile[i]._mix;
my = missile[i]._miy;
ChangeLight(missile[i]._mlid, mx, my, missile[i]._miAnimFrame);
if (CheckBlock(px, py, mx , my ) == 0) CheckMissileCol(i, dam, dam, 0, mx, my, 1);
if (CheckBlock(px, py, mx , my + 1) == 0) CheckMissileCol(i, dam, dam, 0, mx, my + 1, 1);
if (CheckBlock(px, py, mx , my - 1) == 0) CheckMissileCol(i, dam, dam, 0, mx, my - 1, 1);
if (CheckBlock(px, py, mx + 1, my ) == 0) CheckMissileCol(i, dam, dam, 0, mx + 1, my, 1);
if (CheckBlock(px, py, mx + 1, my - 1) == 0) CheckMissileCol(i, dam, dam, 0, mx + 1, my - 1, 1);
if (CheckBlock(px, py, mx + 1, my + 1) == 0) CheckMissileCol(i, dam, dam, 0, mx + 1, my + 1, 1);
if (CheckBlock(px, py, mx - 1, my ) == 0) CheckMissileCol(i, dam, dam, 0, mx - 1, my, 1);
if (CheckBlock(px, py, mx - 1, my + 1) == 0) CheckMissileCol(i, dam, dam, 0, mx - 1, my + 1, 1);
if (CheckBlock(px, py, mx - 1, my - 1) == 0) CheckMissileCol(i, dam, dam, 0, mx - 1, my - 1, 1);
//++missile[i]._mix;
//++missile[i]._miy;
//missile[i]._miyoff -= 32;
if ((!TransList[dTransVal[mx][my]]) ||
((missile[i]._mixvel < 0) &&
((TransList[dTransVal[mx][my+1]] && nSolidTable[dPiece[mx][my+1]]) ||
(TransList[dTransVal[mx][my-1]] && nSolidTable[dPiece[mx][my-1]])))) {
++missile[i]._mix;
++missile[i]._miy;
missile[i]._miyoff -= 32;
}
if (((missile[i]._miyvel > 0) &&
((TransList[dTransVal[mx+1][my]] && nSolidTable[dPiece[mx+1][my]]) ||
(TransList[dTransVal[mx-1][my]] && nSolidTable[dPiece[mx-1][my]])))) {
missile[i]._miyoff -= 32;
}
if (((missile[i]._mixvel > 0) &&
((TransList[dTransVal[mx][my+1]] && nSolidTable[dPiece[mx][my+1]]) ||
(TransList[dTransVal[mx][my-1]] && nSolidTable[dPiece[mx][my-1]])))) {
missile[i]._mixoff -= 32;
}
missile[i]._mimfnum = 0;
SetMissAnim(i, MF_BIGEXP);
missile[i]._mirange = missile[i]._miAnimLen - 1;
} else {
if ((missile[i]._mix != missile[i]._miVar1) || (missile[i]._miy != missile[i]._miVar2)) {
missile[i]._miVar1 = missile[i]._mix;
missile[i]._miVar2 = missile[i]._miy;
ChangeLight(missile[i]._mlid, missile[i]._miVar1, missile[i]._miVar2, 8);
}
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
// Doesn't work yet. GWP
**-----------------------------------------------------------------------*/
void MI_SpiralFireBall(int i)
{
#if (PRE_BETA && PRE_FIREBALL) || !PRE_BETA
int px, py, mx, my;
app_assert(i < MAXMISSILES);
int const id = missile[i]._misource;
int const dam = missile[i]._midam;
int xcurve;
int ycurve;
// Set the direction into a spiral.
if (missile[i]._miVar7 < 0) {
missile[i]._miVar6 *= 2;
missile[i]._miVar7 = missile[i]._miVar6;
--missile[i]._mimfnum;
if (missile[i]._mimfnum < 0)
missile[i]._mimfnum = 7;
}
else --missile[i]._miVar7;
switch (missile[i]._mimfnum) {
case 0: // Down
xcurve = missile[i]._mixvel;
ycurve = 0;
break;
case 1: // Down left
xcurve = missile[i]._mixvel;
ycurve = missile[i]._miyvel;
break;
case 2: // Left
xcurve = 0;
ycurve = missile[i]._miyvel;
break;
case 3: // Up Left
xcurve = missile[i]._mixvel;
ycurve = missile[i]._miyvel;
break;
case 4: // Up
xcurve = missile[i]._mixvel;
ycurve = 0;
break;
case 5: // Up right
xcurve = missile[i]._mixvel;
ycurve = missile[i]._miyvel;
break;
case 6: // Right
xcurve = 0;
ycurve = missile[i]._miyvel;
break;
case 7: // Down Right
xcurve = missile[i]._mixvel;
ycurve = missile[i]._miyvel;
break;
}
--missile[i]._mirange;
if (missile[i]._micaster == MI_ENEMYMONST) {
px = plr[id]._px;
py = plr[id]._py;
} else {
px = monster[id]._mx;
py = monster[id]._my;
}
if (missile[i]._miAnimType == MF_BIGEXP) {
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
}
PutMissile(i);
return;
}
missile[i]._mitxoff += xcurve;
missile[i]._mityoff += ycurve;
GetMissilePos(i);
if ((missile[i]._mix != missile[i]._misx) || (missile[i]._miy != missile[i]._misy))
CheckMissileCol(i, dam, dam, 0, missile[i]._mix, missile[i]._miy, 0);
if (missile[i]._mirange == 0) {
mx = missile[i]._mix;
my = missile[i]._miy;
ChangeLight(missile[i]._mlid, mx, my, missile[i]._miAnimFrame);
if (CheckBlock(px, py, mx , my ) == 0) CheckMissileCol(i, dam, dam, 0, mx, my, 1);
if (CheckBlock(px, py, mx , my + 1) == 0) CheckMissileCol(i, dam, dam, 0, mx, my + 1, 1);
if (CheckBlock(px, py, mx , my - 1) == 0) CheckMissileCol(i, dam, dam, 0, mx, my - 1, 1);
if (CheckBlock(px, py, mx + 1, my ) == 0) CheckMissileCol(i, dam, dam, 0, mx + 1, my, 1);
if (CheckBlock(px, py, mx + 1, my - 1) == 0) CheckMissileCol(i, dam, dam, 0, mx + 1, my - 1, 1);
if (CheckBlock(px, py, mx + 1, my + 1) == 0) CheckMissileCol(i, dam, dam, 0, mx + 1, my + 1, 1);
if (CheckBlock(px, py, mx - 1, my ) == 0) CheckMissileCol(i, dam, dam, 0, mx - 1, my, 1);
if (CheckBlock(px, py, mx - 1, my + 1) == 0) CheckMissileCol(i, dam, dam, 0, mx - 1, my + 1, 1);
if (CheckBlock(px, py, mx - 1, my - 1) == 0) CheckMissileCol(i, dam, dam, 0, mx - 1, my - 1, 1);
//++missile[i]._mix;
//++missile[i]._miy;
//missile[i]._miyoff -= 32;
if ((!TransList[dTransVal[mx][my]]) ||
((missile[i]._mixvel < 0) &&
((TransList[dTransVal[mx][my+1]] && nSolidTable[dPiece[mx][my+1]]) ||
(TransList[dTransVal[mx][my-1]] && nSolidTable[dPiece[mx][my-1]])))) {
++missile[i]._mix;
++missile[i]._miy;
missile[i]._miyoff -= 32;
}
if (((missile[i]._miyvel > 0) &&
((TransList[dTransVal[mx+1][my]] && nSolidTable[dPiece[mx+1][my]]) ||
(TransList[dTransVal[mx-1][my]] && nSolidTable[dPiece[mx-1][my]])))) {
missile[i]._miyoff -= 32;
}
if (((missile[i]._mixvel > 0) &&
((TransList[dTransVal[mx][my+1]] && nSolidTable[dPiece[mx][my+1]]) ||
(TransList[dTransVal[mx][my-1]] && nSolidTable[dPiece[mx][my-1]])))) {
missile[i]._mixoff -= 32;
}
missile[i]._mimfnum = 0;
SetMissAnim(i, MF_BIGEXP);
missile[i]._mirange = missile[i]._miAnimLen - 1;
} else {
if ((missile[i]._mix != missile[i]._miVar1) || (missile[i]._miy != missile[i]._miVar2)) {
missile[i]._miVar1 = missile[i]._mix;
missile[i]._miVar2 = missile[i]._miy;
ChangeLight(missile[i]._mlid, missile[i]._miVar1, missile[i]._miVar2, 8);
}
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Lightctrl(int i)
{
#if (PRE_BETA && PRE_LIGHTNING) || !PRE_BETA
int pn, dam, p, mx, my;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
dam = 0;
p = missile[i]._misource;
if (p != -1) {
if (missile[i]._micaster == MI_ENEMYMONST) {
dam = random(79, plr[p]._pLevel) + random(79, 2) + 2;
dam = dam << HP_SHIFT;
} else {
dam = (random(80, monster[p].mMaxDamage - monster[p].mMinDamage + 1) + monster[p].mMinDamage) << 1;
}
} else {
dam = random(81, currlevel) + (currlevel << 1);
}
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
mx = missile[i]._mix;
my = missile[i]._miy;
app_assert(mx < MAXDUNX);
app_assert(my < MAXDUNY);
pn = dPiece[mx][my];
app_assert(pn <= MAXTILES);
if (missile[i]._misource == -1) {
if ((mx != missile[i]._misx) || (my != missile[i]._misy))
if (nMissileTable[pn]) missile[i]._mirange = 0;
} else {
if (nMissileTable[pn]) missile[i]._mirange = 0;
}
if ((!nMissileTable[pn]) && ((mx != missile[i]._miVar1) || (my != missile[i]._miVar2)) &&
(mx > 0) && (my > 0) && (mx < DMAXX) && (my < DMAXY)) {
// Add LIGHTNING if the player or trap threw this, otherwise add THINLIGHT for thin demon
if (missile[i]._misource != -1) {
if (missile[i]._micaster == MI_ENEMYPLR && EquivMonst(monster[missile[i]._misource].MType->mtype, MT_STORM))
AddMissile(missile[i]._mix, missile[i]._miy, missile[i]._misx, missile[i]._misy, i, MIT_THINLIGHT, missile[i]._micaster, missile[i]._misource, dam, missile[i]._mispllvl);
else
AddMissile(missile[i]._mix, missile[i]._miy, missile[i]._misx, missile[i]._misy, i, MIT_LIGHTNING, missile[i]._micaster, missile[i]._misource, dam, missile[i]._mispllvl);
} else {
AddMissile(missile[i]._mix, missile[i]._miy, missile[i]._misx, missile[i]._misy, i, MIT_LIGHTNING, missile[i]._micaster, missile[i]._misource, dam, missile[i]._mispllvl);
}
missile[i]._miVar1 = missile[i]._mix;
missile[i]._miVar2 = missile[i]._miy;
}
if ((missile[i]._mirange == 0) || (mx <= 0) || (my <= 0) || (mx >= DMAXX) || (my > DMAXY))
missile[i]._miDelFlag = TRUE;
#endif
}
void MI_LTArrow(int i)
{
#if (PRE_BETA && PRE_LIGHTNING) || !PRE_BETA
int pn, mx, my;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
mx = missile[i]._mix;
my = missile[i]._miy;
app_assert(mx < MAXDUNX);
app_assert(my < MAXDUNY);
pn = dPiece[mx][my];
app_assert(pn <= MAXTILES);
if (missile[i]._misource == -1) {
if ((mx != missile[i]._misx) || (my != missile[i]._misy))
if (nMissileTable[pn]) missile[i]._mirange = 0;
} else {
if (nMissileTable[pn]) missile[i]._mirange = 0;
}
if ((!nMissileTable[pn]) && ((mx != missile[i]._miVar1) || (my != missile[i]._miVar2)) &&
(mx > 0) && (my > 0) && (mx < DMAXX) && (my < DMAXY)) {
// Add LIGHTNING if the player or trap threw this, otherwise add THINLIGHT for thin demon
if (missile[i]._misource != -1) {
if (missile[i]._micaster == MI_ENEMYPLR && EquivMonst(monster[missile[i]._misource].MType->mtype, MT_STORM))
AddMissile(missile[i]._mix, missile[i]._miy, missile[i]._misx, missile[i]._misy, i, MIT_THINLIGHT, missile[i]._micaster, missile[i]._misource, missile[i]._midam, missile[i]._mispllvl);
else
AddMissile(missile[i]._mix, missile[i]._miy, missile[i]._misx, missile[i]._misy, i, MIT_LIGHTNING, missile[i]._micaster, missile[i]._misource, missile[i]._midam, missile[i]._mispllvl);
} else {
AddMissile(missile[i]._mix, missile[i]._miy, missile[i]._misx, missile[i]._misy, i, MIT_LIGHTNING, missile[i]._micaster, missile[i]._misource, missile[i]._midam, missile[i]._mispllvl);
}
missile[i]._miVar1 = missile[i]._mix;
missile[i]._miVar2 = missile[i]._miy;
}
if ((missile[i]._mirange == 0) || (mx <= 0) || (my <= 0) || (mx >= DMAXX) || (my > DMAXY))
missile[i]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Lightning(int i)
{
#if (PRE_BETA && PRE_LIGHTNING) || !PRE_BETA
int j;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
j = missile[i]._mirange;
if ((missile[i]._mix != missile[i]._misx) || (missile[i]._miy != missile[i]._misy))
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 1, missile[i]._mix, missile[i]._miy, 0);
if (missile[i]._miHitFlag == TRUE) missile[i]._mirange = j;
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Town(int i)
{
#if (PRE_BETA && PRE_TOWN) || !PRE_BETA
int p;
int ExpLight[17] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,15,15};
app_assert(i < MAXMISSILES);
if (missile[i]._mirange > 1) --missile[i]._mirange;
if (missile[i]._mirange == missile[i]._miVar1) {
SetMissDir(i, 1);
}
if ((currlevel != 0) && (missile[i]._mimfnum != 1) && (missile[i]._mirange != 0)) {
if (missile[i]._miVar2 == 0)
missile[i]._mlid = AddLight(missile[i]._mix, missile[i]._miy, ExpLight[(missile[i]._miVar2)]);
ChangeLight(missile[i]._mlid, missile[i]._mix, missile[i]._miy, ExpLight[(missile[i]._miVar2)]);
++missile[i]._miVar2;
}
for (p = 0; p < MAX_PLRS; ++p) {
if (! plr[p].plractive) continue;
if (currlevel != plr[p].plrlevel) continue;
if (plr[p]._pLvlChanging) continue;
if (plr[p]._pmode != PM_STAND) continue;
if (plr[p]._px != missile[i]._mix) continue;
if (plr[p]._py != missile[i]._miy) continue;
ClrPlrPath(p);
if (p == myplr) {
NetSendCmdParam1(TRUE,CMD_WARP,missile[i]._misource);
plr[p]._pmode = PM_NEWLVL;
}
}
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Flash(int i)
{
#if (PRE_BETA && PRE_FLASH) || !PRE_BETA
app_assert(i < MAXMISSILES);
if ((missile[i]._micaster == MI_ENEMYMONST) && (missile[i]._misource != -1))
plr[missile[i]._misource]._pInvincible = TRUE;
--missile[i]._mirange;
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 1, missile[i]._mix-1, missile[i]._miy, 1);
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 1, missile[i]._mix, missile[i]._miy, 1);
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 1, missile[i]._mix+1, missile[i]._miy, 1);
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 1, missile[i]._mix-1, missile[i]._miy+1, 1);
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 1, missile[i]._mix, missile[i]._miy+1, 1);
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 1, missile[i]._mix+1, missile[i]._miy+1, 1);
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
if ((missile[i]._micaster == MI_ENEMYMONST) && (missile[i]._misource != -1))
plr[(missile[i]._misource)]._pInvincible = FALSE;
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Aura(int i)
{
#if (PRE_BETA && PRE_FLASH) || !PRE_BETA
app_assert(i < MAXMISSILES);
if ((missile[i]._micaster == MI_ENEMYMONST) && (missile[i]._misource != -1)) {
missile[i]._mix = plr[missile[i]._misource]._pfutx;
missile[i]._miy = plr[missile[i]._misource]._pfuty;
}
--missile[i]._mirange;
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
if ((missile[i]._micaster == MI_ENEMYMONST) && (missile[i]._misource != -1))
plr[(missile[i]._misource)]._pBaseToBlk -= 50;
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Aura2(int i)
{
#if (PRE_BETA && PRE_FLASH) || !PRE_BETA
app_assert(i < MAXMISSILES);
if ((missile[i]._micaster == MI_ENEMYMONST) && (missile[i]._misource != -1)) {
missile[i]._mix = plr[missile[i]._misource]._pfutx;
missile[i]._miy = plr[missile[i]._misource]._pfuty;
}
--missile[i]._mirange;
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Flash2(int i)
{
#if (PRE_BETA && PRE_FLASH) || !PRE_BETA
app_assert(i < MAXMISSILES);
if ((missile[i]._micaster == MI_ENEMYMONST) && (missile[i]._misource != -1))
plr[(missile[i]._misource)]._pInvincible = TRUE;
--missile[i]._mirange;
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 1, missile[i]._mix-1, missile[i]._miy-1, 1);
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 1, missile[i]._mix, missile[i]._miy-1, 1);
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 1, missile[i]._mix+1, missile[i]._miy-1, 1);
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
if ((missile[i]._micaster == MI_ENEMYMONST) && (missile[i]._misource != -1))
plr[(missile[i]._misource)]._pInvincible = FALSE;
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Manashield(int i)
{
#if (PRE_BETA && PRE_MANASHLD) || !PRE_BETA
int j, id;
long diff, pct;
//--missile[i]._mirange;
app_assert(i < MAXMISSILES);
id = missile[i]._misource;
missile[i]._mix = plr[id]._px;
missile[i]._miy = plr[id]._py;
missile[i]._mitxoff = plr[id]._pxoff << 16;
missile[i]._mityoff = plr[id]._pyoff << 16;
if (plr[id]._pmode == PM_WALK3) {
missile[i]._misx = plr[id]._pfutx;
missile[i]._misy = plr[id]._pfuty;
} else {
missile[i]._misx = plr[id]._px;
missile[i]._misy = plr[id]._py;
}
GetMissilePos(i);
if (plr[id]._pmode == PM_WALK3) {
if (plr[id]._pdir == DIR_L) ++missile[i]._mix;
else ++missile[i]._miy;
}
if (id != myplr) {
if (currlevel != plr[id].plrlevel) missile[i]._miDelFlag = TRUE;
PutMissile(i);
return;
}
if (plr[id]._pMana <= 0 || (!plr[id].plractive)) missile[i]._mirange = 0;
if (plr[id]._pHitPoints < missile[i]._miVar1) {
diff = missile[i]._miVar1 - plr[id]._pHitPoints;
pct = 0;
for (j = 0; j < missile[i]._mispllvl && j < 7; ++j) pct += 3;
if (pct > 0) diff = diff - (diff / pct);
if (diff < 0) diff = 0;
drawmanaflag = TRUE;
drawhpflag = TRUE;
if (plr[id]._pMana >= diff) {
plr[id]._pHitPoints = missile[i]._miVar1;
plr[id]._pHPBase = missile[i]._miVar2;
plr[id]._pMana -= diff;
plr[id]._pManaBase -= diff;
} else {
plr[id]._pHitPoints -= (diff - plr[id]._pMana);
plr[id]._pHPBase -= (diff - plr[id]._pMana);
plr[id]._pMana = 0;
plr[id]._pManaBase = -(plr[id]._pMaxMana - plr[id]._pMaxManaBase);
missile[i]._mirange = 0;
missile[i]._miDelFlag = TRUE;
if (plr[id]._pHitPoints < 0) SetPlayerHitPoints(id, 0);
if (((plr[id]._pHitPoints >> HP_SHIFT) == 0) && (id == myplr))
StartPlrKill(id, missile[i]._miVar8);
}
}
missile[i]._miVar1 = plr[id]._pHitPoints;
missile[i]._miVar2 = plr[id]._pHPBase;
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
NetSendCmd(TRUE, CMD_ENDSHIELD);
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Ether(int i)
{
#if (PRE_BETA && PRE_ETHER) || !PRE_BETA
int id;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
id = missile[i]._misource;
missile[i]._mix = plr[id]._px;
missile[i]._miy = plr[id]._py;
missile[i]._mitxoff = plr[id]._pxoff << 16;
missile[i]._mityoff = plr[id]._pyoff << 16;
if (plr[id]._pmode == PM_WALK3) {
missile[i]._misx = plr[id]._pfutx;
missile[i]._misy = plr[id]._pfuty;
} else {
missile[i]._misx = plr[id]._px;
missile[i]._misy = plr[id]._py;
}
GetMissilePos(i);
if (plr[id]._pmode == PM_WALK3) {
if (plr[id]._pdir == DIR_L) ++missile[i]._mix;
else ++missile[i]._miy;
}
plr[id]._pSpellFlags |= SF_ETHER;
if (missile[i]._mirange == 0 || plr[id]._pHitPoints <= 0) {
missile[i]._miDelFlag = TRUE;
plr[id]._pSpellFlags &= ~SF_ETHER;
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Firemove(int i)
{
int j;
int ExpLight[14] = {2,3,4,5,5,6,7,8,9,10,11,12,12};
app_assert(i < MAXMISSILES);
--missile[i]._mix;
--missile[i]._miy;
missile[i]._miyoff+=32;
++missile[i]._miVar1;
if (missile[i]._miVar1 == missile[i]._miAnimLen) {
SetMissDir(i, 1);
missile[i]._miAnimFrame = random(82, 11) + 1;
}
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
j = missile[i]._mirange;
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 0, missile[i]._mix, missile[i]._miy, 0);
if (missile[i]._miHitFlag == TRUE) missile[i]._mirange = j;
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
}
if ((missile[i]._mimfnum == 0) && (missile[i]._mirange != 0)) {
if (missile[i]._miVar2 == 0)
missile[i]._mlid = AddLight(missile[i]._mix, missile[i]._miy, ExpLight[(missile[i]._miVar2)]);
ChangeLight(missile[i]._mlid, missile[i]._mix, missile[i]._miy, ExpLight[(missile[i]._miVar2)]);
++missile[i]._miVar2;
}
else if ((missile[i]._mix != missile[i]._miVar3) || (missile[i]._miy != missile[i]._miVar4)) {
missile[i]._miVar3 = missile[i]._mix;
missile[i]._miVar4 = missile[i]._miy;
ChangeLight(missile[i]._mlid, missile[i]._miVar3, missile[i]._miVar4, 8);
}
++missile[i]._mix;
++missile[i]._miy;
missile[i]._miyoff-=32;
PutMissile(i);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Guardian(int i)
{
#if (PRE_BETA && PRE_GUARDIAN) || !PRE_BETA
int j, k, sx, sy, sx1, sy1, ex;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
if (missile[i]._miVar2 > 0) --missile[i]._miVar2;
if ((missile[i]._mirange == missile[i]._miVar1) || ((missile[i]._mimfnum == 2) &&
(missile[i]._miVar2 == 0))) {
SetMissDir(i, 1);
}
if ((missile[i]._mirange % 16) == 0) {
ex = 0;
for (k = 0; (k < 23) && (ex != -1); ++k) {
for (j = 10; (j >= 0) && (ex != -1); j-=2) {
if (vCrawlTable[k][j] == 0 && vCrawlTable[k][j + 1] == 0) break;
if ((sx1 != vCrawlTable[k][j]) || (sy1 != vCrawlTable[k][j + 1])) {
sx = missile[i]._mix + vCrawlTable[k][j];
sy = missile[i]._miy + vCrawlTable[k][j+1];
ex = Sentfire(i, sx, sy);
if (ex == -1) break;
sx = missile[i]._mix - vCrawlTable[k][j];
sy = missile[i]._miy - vCrawlTable[k][j+1];
ex = Sentfire(i, sx, sy);
if (ex == -1) break;
sx = missile[i]._mix + vCrawlTable[k][j];
sy = missile[i]._miy - vCrawlTable[k][j+1];
ex = Sentfire(i, sx, sy);
if (ex == -1) break;
sx = missile[i]._mix - vCrawlTable[k][j];
sy = missile[i]._miy + vCrawlTable[k][j+1];
ex = Sentfire(i, sx, sy);
if (ex == -1) break;
sx1 = vCrawlTable[k][j];
sy1 = vCrawlTable[k][j + 1];
}
}
}
}
if (missile[i]._mirange == 14) {
SetMissDir(i, 0);
missile[i]._miAnimFrame = 15;
missile[i]._miAnimAdd = -1;
}
missile[i]._miVar3 += missile[i]._miAnimAdd;
if (missile[i]._miVar3 > 15) {
missile[i]._miVar3 = 15;
} else {
if (missile[i]._miVar3 > 0)
ChangeLight(missile[i]._mlid, missile[i]._mix, missile[i]._miy, missile[i]._miVar3);
}
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Chain(int i)
{
#if (PRE_BETA && PRE_CHAIN) || !PRE_BETA
int sx, sy, id, dir;
int l, n, m, k, rad;
int tx, ty;
app_assert(i < MAXMISSILES);
id = missile[i]._misource;
sx = missile[i]._mix;
sy = missile[i]._miy;
dir = GetDirection(sx, sy, missile[i]._miVar1, missile[i]._miVar2);
AddMissile(sx, sy, missile[i]._miVar1, missile[i]._miVar2, dir, MIT_LIGHTCTRL, MI_ENEMYMONST, id, 1, missile[i]._mispllvl);
rad = 3 + missile[i]._mispllvl;
if (rad > 19) rad = 19;
for (m = 1; m < rad; ++m) {
n = CrawlNum[m];
l = n + 1;
for (k = CrawlTable[n]; k > 0; --k) {
tx = sx + CrawlTable[l];
ty = sy + CrawlTable[(l + 1)];
if (tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
if ((dMonster[tx][ty]) > 0) {
dir = GetDirection(sx, sy, tx, ty);
AddMissile(sx, sy, tx, ty, dir, MIT_LIGHTCTRL, MI_ENEMYMONST, id, 1, missile[i]._mispllvl);
}
}
l += 2;
}
}
--missile[i]._mirange;
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
/*void MI_ChainOLD(int i)
{
int dir;
if ((missile[i]._mirange % 3) == 0) {
dir = GetDirection(missile[i]._mix, missile[i]._miy, missile[i]._miVar5, missile[i]._miVar6);
AddMissile(missile[i]._mix, missile[i]._miy, missile[i]._miVar5, missile[i]._miVar6, dir, MIT_CHAINBALL, MI_ENEMYMONST, missile[i]._misource, missile[i]._midam);
++missile[i]._miVar7;
}
--missile[i]._mirange;
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
}*/
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
/*void MI_ChainballOLD(int i)
{
int mx, id;
int k, l, m, n, rad;
--missile[i]._mirange;
id = missile[i]._misource;
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
if ((missile[i]._miVar2 == 1) && (missile[i]._mix == missile[i]._miVar3) && (missile[i]._miy == missile[i]._miVar4)) {
missile[i]._miVar2 = 0;
missile[i]._mirange = 0;
k = 0;
for (l = 0; l < nummissiles; ++l) {
mx = missileactive[l];
if (missile[mx]._mitype == MIT_CHAINBALL && missile[i]._miVar1 == missile[mx]._miVar1) ++k;
if ((missile[mx]._mitype == MIT_CHAIN) && (missile[i]._miVar1 == missile[mx]._midam))
k+=((4 + (GetSpellLevel(id, SPL_LIGHTNING) / 3)) - missile[mx]._miVar7);
}
if (k == 1) {
rad = 6 + GetSpellLevel(id, SPL_CHAIN);
if (rad > 19) rad = 19;
for (m = 1; m < rad; ++m) {
n = CrawlNum[m];
l = n + 1;
for (k = CrawlTable[n]; k > 0; --k) {
if (ChainBounce (i, missile[i]._mix + CrawlTable[l], missile[i]._miy + CrawlTable[(l + 1)]) > 0) {
m = rad;
break;
}
l += 2;
}
}
}
} else {
if ((missile[i]._mix != missile[i]._miVar5) || (missile[i]._miy != missile[i]._miVar6))
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 1, missile[i]._mix, missile[i]._miy, 0);
if (missile[i]._miHitFlag == TRUE && missile[i]._mirange == 0 && missile[i]._miVar2 == 0) {
for (l = 0; l < nummissiles; ++l) {
mx = missileactive[l];
if ((missile[mx]._mitype == MIT_CHAIN && missile[i]._miVar1 == missile[mx]._midam) ||
(missile[mx]._mitype == MIT_CHAINBALL && missile[i]._miVar1 == missile[mx]._miVar1)) {
missile[mx]._miVar2 = 1; // flag hit and cont until v3, v4
missile[mx]._miVar3 = missile[i]._mix; // x of hit
missile[mx]._miVar4 = missile[i]._miy; // y of hit
}
}
}
}
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
PutMissile(i);
}*/
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Blood(int i)
{
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
if (missile[i]._miAnimFrame == missile[i]._miAnimLen) {
// missile[i]._miAnimFrame = missile[i]._miAnimLen;
missile[i]._miPreFlag = TRUE;
}
PutMissile(i);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Weapexp(int i)
{
int id, mind, maxd;
int ExpLight[10] = {9,10,11,12,11,10,8,6,4,2};
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
id = missile[i]._misource;
if (missile[i]._miVar2 == 1) {
mind = plr[id]._pIFMinDam;
maxd = plr[id]._pIFMaxDam;
missiledata[missile[i]._mitype].mResist = MIMT_FIRE;
} else {
mind = plr[id]._pILMinDam;
maxd = plr[id]._pILMaxDam;
missiledata[missile[i]._mitype].mResist = MIMT_LGHT;
}
CheckMissileCol(i, mind, maxd, 0, missile[i]._mix, missile[i]._miy, 0);
if (missile[i]._miVar1 == 0) {
missile[i]._mlid = AddLight(missile[i]._mix, missile[i]._miy, ExpLight[(missile[i]._miVar1)]);
} else {
if (missile[i]._mirange != 0)
ChangeLight(missile[i]._mlid, missile[i]._mix, missile[i]._miy, ExpLight[(missile[i]._miVar1)]);
}
++missile[i]._miVar1;
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
return;
}
PutMissile(i);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Misexp(int i)
{
int ExpLight[10] = {9,10,11,12,11,10,8,6,4,2};
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
return;
}
if (missile[i]._miVar1 == 0) {
missile[i]._mlid = AddLight(missile[i]._mix, missile[i]._miy, ExpLight[(missile[i]._miVar1)]);
} else {
if (missile[i]._mirange != 0)
ChangeLight(missile[i]._mlid, missile[i]._mix, missile[i]._miy, ExpLight[(missile[i]._miVar1)]);
}
++missile[i]._miVar1;
PutMissile(i);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Acidsplat(int i)
{
int monst;
int dam;
app_assert(i < MAXMISSILES);
if (missile[i]._mirange == missile[i]._miAnimLen) {
++missile[i]._mix;
++missile[i]._miy;
missile[i]._miyoff-=32;
}
--missile[i]._mirange;
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
monst = missile[i]._misource;
dam = (monster[monst].MData->mLevel < 2) ? 1:2;
AddMissile(missile[i]._mix, missile[i]._miy, i, 0, missile[i]._mimfnum, MIT_ACIDPUD, MI_ENEMYPLR, missile[i]._misource, dam, missile[i]._mispllvl);
return;
}
PutMissile(i);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Teleport(int i)
{
#if (PRE_BETA && PRE_TELE) || !PRE_BETA
int id;
app_assert(i < MAXMISSILES);
id = missile[i]._misource;
//sprintf(tempstr, "X: %i Y: %i FX: %i FY: %i", plr[myplr]._px, plr[myplr]._py, plr[myplr]._pfutx, plr[myplr]._pfuty);
//AddPanelString(tempstr, TEXT_LEFT);
--missile[i]._mirange;
if (missile[i]._mirange <= 0) {
missile[i]._miDelFlag = TRUE;
return;
}
dPlayer[(plr[id]._px)][(plr[id]._py)] = 0;
PlrClrTrans(plr[id]._px, plr[id]._py);
plr[id]._px = missile[i]._mix;
plr[id]._py = missile[i]._miy;
plr[id]._pfutx = plr[id]._px;
plr[id]._pfuty = plr[id]._py;
plr[id]._poldx = plr[id]._px;
plr[id]._poldy = plr[id]._py;
PlrDoTrans(plr[id]._px, plr[id]._py);
missile[i]._miVar1 = 1;
dPlayer[(plr[id]._px)][(plr[id]._py)] = 1 + (char)id;
if (leveltype != 0) {
ChangeLightXY(plr[id]._plid, plr[id]._px, plr[id]._py);
ChangeVisionXY(plr[id]._pvid, plr[id]._px, plr[id]._py);
}
if (id == myplr) {
ViewX = plr[id]._px - ScrollInfo._sdx;
ViewY = plr[id]._py - ScrollInfo._sdy;
}
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
/*void MI_Doom(int i)
{
int k, l, m, n;
int mid;
--missile[i]._mirange;
// check if monster moved
mid = dMonster[(missile[i]._miVar1)][(missile[i]._miVar2)];
if (mid != 0) {
if (mid > 0) --mid;
else mid = -(mid + 1);
}
// if he did search again
if (mid != missile[i]._miVar3) {
for (m = 0; m < 6; ++m) {
n = CrawlNum[m];
l = n + 1;
for (k = CrawlTable[n]; k > 0; --k) {
mid = dMonster[((missile[i]._miVar1) + CrawlTable[l])][((missile[i]._miVar2) + CrawlTable[(l + 1)])];
if (mid != 0) {
if (mid > 0) --mid;
else mid = -(mid + 1);
if (mid == missile[i]._miVar3) {
missile[i]._miVar1 += CrawlTable[l];
missile[i]._miVar2 += CrawlTable[l + 1];
k = -99;
m = 6;
break;
}
}
l += 2;
}
}
// if monster killed before doom kills it
if (k != -99) {
missile[i]._miDelFlag = TRUE;
PutMissile(i);
return;
}
// get new velocity and directions
GetMissileVel(i, missile[i]._mix, missile[i]._miy, missile[i]._miVar1, missile[i]._miVar2, 16);
SetMissDir(i, GetDirection(missile[i]._mix, missile[i]._miy, missile[i]._miVar1, missile[i]._miVar2));
}
// move missile
if (missile[i]._mimfnum != 9) {
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
}
// get mid for current missile pos - for checking if target monster killed
mid = dMonster[(missile[i]._mix)][(missile[i]._miy)];
if (mid != 0) {
if (mid > 0) --mid;
else mid = -(mid + 1);
}
// check for collision if not followed monster dont end missile
k = missile[i]._mirange;
if ((missile[i]._mix != plr[myplr]._px) || (missile[i]._miy != plr[myplr]._py)) CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 1, missile[i]._mix, missile[i]._miy, 0);
if ((missile[i]._mirange == 0) && (mid != missile[i]._miVar3) && (missile[i]._miHitFlag == TRUE)) missile[i]._mirange = k;
// if target monster not dead halt missile in place
if ((missile[i]._mirange == 0) && (mid == missile[i]._miVar3)) {
missile[i]._mirange = k;
if ((monster[mid]._mhitpoints >> HP_SHIFT) > 0) {
if (missile[i]._mimfnum != 9) {
SetMissDir(i, 9);
}
} else {
// target is killed so re-search
for (m = 1; m < 6; ++m) {
n = CrawlNum[m];
l = n + 1;
for (k = CrawlTable[n]; k > 0; --k) {
mid = dMonster[((missile[i]._miVar1) + CrawlTable[l])][((missile[i]._miVar2) + CrawlTable[(l + 1)])];
if (mid != 0) {
if (mid > 0) --mid;
else mid = -(mid + 1);
if ((monster[mid]._mhitpoints >> HP_SHIFT) > 0) {
missile[i]._miVar1 += CrawlTable[l];
missile[i]._miVar2 += CrawlTable[l + 1];
missile[i]._miVar3 = mid;
k = -99;
m = 6;
break;
}
}
l += 2;
}
}
// get new velocity and directions
if (k == 0) missile[i]._mirange = 0;
else {
GetMissileVel(i, missile[i]._mix, missile[i]._miy, missile[i]._miVar1, missile[i]._miVar2, 16);
SetMissDir(i, GetDirection(missile[i]._mix, missile[i]._miy, missile[i]._miVar1, missile[i]._miVar2));
}
}
}
// delete or place missile
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
PutMissile(i);
}*/
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Stone (int i)
{
#if (PRE_BETA && PRE_STONE) || !PRE_BETA
int m;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
m = missile[i]._miVar2;
if (monster[m]._mhitpoints == 0 && missile[i]._miAnimType != MF_STONE) {
SetMissAnim(i, MF_STONE);
missile[i]._mirange = 11;
}
if (monster[m]._mmode != MM_STONE) missile[i]._miDelFlag = TRUE;
else {
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
if (monster[m]._mhitpoints > 0) {
// app_assert(dMonster[monster[m]._mx][monster[m]._my] == m+1
// || dMonster[monster[m]._mx][monster[m]._my] == -(m+1));
monster[m]._mmode = missile[i]._miVar1;
}
else AddDead(monster[m]._mx, monster[m]._my, stonendx, monster[m]._mdir);
}
if (missile[i]._miAnimType == MF_STONE) PutMissile(i);
}
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Boom(int i)
{
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
if (missile[i]._miVar1 == 0) CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 0, missile[i]._mix, missile[i]._miy, 1);
if (missile[i]._miHitFlag == TRUE) missile[i]._miVar1 = 1;
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
PutMissile(i);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Rhino(int i)
{
int mix,miy;
int mix2, miy2;
int omx, omy;
int monst;
BOOL placemiss = FALSE;
app_assert(i < MAXMISSILES);
monst = missile[i]._misource;
app_assert(monst < MAXMONSTERS);
if (monster[monst]._mmode != MM_MISSILE) { // monster got blood-boiled or something
missile[i]._miDelFlag = TRUE;
return;
}
GetMissilePos(i);
omx = missile[i]._mix;
omy = missile[i]._miy;
dMonster[omx][omy] = NULL;
if (monster[monst]._mAi == AI_SNAKE)
{
// Snake should stop a few frames before it enters player's square
// So we run its animation a few frames ahead here and test below
// to see if the square is available
missile[i]._mitxoff += 2*missile[i]._mixvel;
missile[i]._mityoff += 2*missile[i]._miyvel;
GetMissilePos(i);
mix2 = missile[i]._mix;
miy2 = missile[i]._miy;
missile[i]._mitxoff -= 1*missile[i]._mixvel;
missile[i]._mityoff -= 1*missile[i]._miyvel;
}
else
{
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
}
GetMissilePos(i);
mix = missile[i]._mix;
miy = missile[i]._miy;
if (PosOkMonst(monst, mix, miy)
&& (monster[monst]._mAi != AI_SNAKE || PosOkMonst(monst, mix2, miy2)))
{
dMonster[mix][miy] = -(monst + 1);
monster[monst]._mx = monster[monst]._moldx = monster[monst]._mfutx = mix;
monster[monst]._my = monster[monst]._moldy = monster[monst]._mfuty = miy;
if(monster[monst]._uniqtype)
ChangeLightXY(missile[i]._mlid, mix, miy);
MoveMissilePos(i);
PutMissile(i);
}
else
{
MissToMonst(i,omx,omy);
missile[i]._miDelFlag = TRUE;
}
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Fireman(int i)
{
int mix,miy;
int omx, omy;
int id, m;
BOOL placemiss = FALSE;
int px,py, p;
GetMissilePos(i);
app_assert(i < MAXMISSILES);
omx = missile[i]._mix;
omy = missile[i]._miy;
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
m = missile[i]._misource;
mix = missile[i]._mix;
miy = missile[i]._miy;
p = monster[m]._menemy;
if ((monster[m]._mFlags & MFLAG_MID) == 0) {
px = plr[p]._px;
py = plr[p]._py;
} else {
px = monster[p]._mx;
py = monster[p]._my;
}
if((mix != omx || miy != omy)
&&
((missile[i]._miVar1 & MIF_DIDHIT
&& !DIST(omx-px, omy-py, 4))
|| missile[i]._miVar2 > 1)
&& PosOkMonst(missile[i]._misource, omx, omy)
)
{
// return to monster domain
MissToMonst(i,omx, omy);
missile[i]._miDelFlag = TRUE;
}
else
if ((monster[m]._mFlags & MFLAG_MID) == 0) id = dPlayer[mix][miy];
else id = dMonster[mix][miy];
if(!PosOkMissile(mix, miy)
|| (id > 0 && !(missile[i]._miVar1 & MIF_DIDHIT)))
{
// bounce away
missile[i]._mixvel = -missile[i]._mixvel;
missile[i]._miyvel = -missile[i]._miyvel;
missile[i]._mimfnum = opposite[missile[i]._mimfnum];
missile[i]._miAnimData = monster[m].MType->Anims[MA_WALK].Cels[missile[i]._mimfnum];
++missile[i]._miVar2;
if(id > 0)
{
missile[i]._miVar1 |= MIF_DIDHIT;
}
placemiss = TRUE;
}
else
placemiss = TRUE;
if(placemiss)
{
// ChangeLightXY(monster[m].mlid, monster[m]._mx, monster[m]._my);
MoveMissilePos(i);
PutMissile(i);
}
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_FirewallC(int i)
{
#if (PRE_BETA && PRE_WALL) || !PRE_BETA
int tx, ty, pn, id;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
id = missile[i]._misource;
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
else {
// if you take this out of here the wall will go though everything (hence using the nsolidtable)
//if (missile[i]._miVar1 >= MAXDUNX || missile[i]._miVar2 >= MAXDUNY)
// app_fatal("Tried placing firewall piece off edge of map at (%d,%d)",missile[i]._miVar1,missile[i]._miVar2);
pn = dPiece[missile[i]._miVar1][missile[i]._miVar2];
app_assert(pn <= MAXTILES);
tx = missile[i]._miVar1 + XDirAdd[missile[i]._miVar3];
ty = missile[i]._miVar2 + YDirAdd[missile[i]._miVar3];
if (nMissileTable[pn] == 0 && missile[i]._miVar8 == 0 && tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
AddMissile(missile[i]._miVar1, missile[i]._miVar2, missile[i]._miVar1, missile[i]._miVar2, plr[id]._pdir, MIT_FIREWALL, MI_ENEMYMONST, id, 0, missile[i]._mispllvl);
missile[i]._miVar1 = tx;
missile[i]._miVar2 = ty;
} else missile[i]._miVar8 = 1;
// if you take this out of here the wall will go though everything (hence using the nsolidtable)
//if (missile[i]._miVar5 >= MAXDUNX || missile[i]._miVar6 >= MAXDUNY)
// app_fatal("Tried placing firewall piece off edge of map at (%d,%d)",missile[i]._miVar5,missile[i]._miVar6);
pn = dPiece[missile[i]._miVar5][missile[i]._miVar6];
app_assert(pn <= MAXTILES);
tx = missile[i]._miVar5 + XDirAdd[missile[i]._miVar4];
ty = missile[i]._miVar6 + YDirAdd[missile[i]._miVar4];
if (nMissileTable[pn] == 0 && missile[i]._miVar7 == 0 && tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
AddMissile(missile[i]._miVar5, missile[i]._miVar6, missile[i]._miVar5, missile[i]._miVar6, plr[id]._pdir, MIT_FIREWALL, MI_ENEMYMONST, id, 0, missile[i]._mispllvl);
missile[i]._miVar5 = tx;
missile[i]._miVar6 = ty;
} else missile[i]._miVar7 = 1;
}
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_FlameBox(int i)
{
#if (PRE_BETA && PRE_WALL) || !PRE_BETA
app_assert(i < MAXMISSILES);
missile[i]._miDelFlag = TRUE;
int const id = missile[i]._micaster;
int const l = CrawlNum[3];
int j = l + 1;
int const dam = ((random(53, 10) + random(53, 10) + 2 + ((id > 0) ? plr[id]._pLevel : currlevel)) << 4) >> 1;
for (int m = CrawlTable[l]; m > 0; --m, j+=2) {
int const tx = missile[i]._miVar1 + CrawlTable[j];
int const ty = missile[i]._miVar2 + CrawlTable[j + 1];
if (tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
int const pn = dPiece[tx][ty];
if (!nSolidTable[pn] && dObject[tx][ty] == 0)
{
if (nMissileTable[pn] == 0 && missile[i]._miVar8 == 0 && tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
AddMissile(tx, ty, tx, ty, 0, MIT_FIREWALL, MI_ENEMYMONST, id, dam, missile[i]._mispllvl);
} else missile[i]._miVar8 = 1;
}
}
}
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_LightBox(int i)
{
#if (PRE_BETA && PRE_WALL) || !PRE_BETA
app_assert(i < MAXMISSILES);
missile[i]._miDelFlag = TRUE;
int const id = missile[i]._micaster;
int const l = CrawlNum[3];
int j = l + 1;
int const dam = ((random(53, 10) + random(53, 10) + 2 + ((id > 0) ? plr[id]._pLevel : currlevel)) << 4) >> 1;
for (int m = CrawlTable[l]; m > 0; --m, j+=2) {
int const tx = missile[i]._miVar1 + CrawlTable[j];
int const ty = missile[i]._miVar2 + CrawlTable[j + 1];
if (tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
int const pn = dPiece[tx][ty];
if (!nSolidTable[pn] && dObject[tx][ty] == 0)
{
if (nMissileTable[pn] == 0 && missile[i]._miVar8 == 0 && tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
AddMissile(tx, ty, tx, ty, 0, MIT_LIGHTWALL, MI_ENEMYMONST, id, dam, missile[i]._mispllvl);
} else missile[i]._miVar8 = 1;
}
}
}
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_ShowMagicItems(int i)
{
#if (PRE_BETA && PRE_WALL) || !PRE_BETA
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
HighLightAllItems = false;
}
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_LightwallC(int i)
{
// GWP 9/4/97
// Copy of MI_FirewallC with switched to call the MIT_LIGHTWALL instead of MIT_FIREWALL
#if (PRE_BETA && PRE_WALL) || !PRE_BETA
int tx, ty, pn;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
int const id = missile[i]._misource;
int const dam = ((random(53, 10) + random(53, 10) + 2 + ((id > 0) ? plr[id]._pLevel : 0)) << 4) >> 1;
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
else {
// if you take this out of here the wall will go though everything (hence using the nsolidtable)
//if (missile[i]._miVar1 >= MAXDUNX || missile[i]._miVar2 >= MAXDUNY)
// app_fatal("Tried placing firewall piece off edge of map at (%d,%d)",missile[i]._miVar1,missile[i]._miVar2);
pn = dPiece[missile[i]._miVar1][missile[i]._miVar2];
app_assert(pn <= MAXTILES);
tx = missile[i]._miVar1 + XDirAdd[missile[i]._miVar3];
ty = missile[i]._miVar2 + YDirAdd[missile[i]._miVar3];
if (nMissileTable[pn] == 0 && missile[i]._miVar8 == 0 && tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
AddMissile(missile[i]._miVar1, missile[i]._miVar2, missile[i]._miVar1, missile[i]._miVar2, plr[id]._pdir, MIT_LIGHTWALL, MI_ENEMYMONST, id, dam, missile[i]._mispllvl);
missile[i]._miVar1 = tx;
missile[i]._miVar2 = ty;
} else missile[i]._miVar8 = 1;
// if you take this out of here the wall will go though everything (hence using the nsolidtable)
//if (missile[i]._miVar5 >= MAXDUNX || missile[i]._miVar6 >= MAXDUNY)
// app_fatal("Tried placing firewall piece off edge of map at (%d,%d)",missile[i]._miVar5,missile[i]._miVar6);
pn = dPiece[missile[i]._miVar5][missile[i]._miVar6];
app_assert(pn <= MAXTILES);
tx = missile[i]._miVar5 + XDirAdd[missile[i]._miVar4];
ty = missile[i]._miVar6 + YDirAdd[missile[i]._miVar4];
if (nMissileTable[pn] == 0 && missile[i]._miVar7 == 0 && tx > 0 && tx < MAXDUNX && ty > 0 && ty < MAXDUNY) {
AddMissile(missile[i]._miVar5, missile[i]._miVar6, missile[i]._miVar5, missile[i]._miVar6, plr[id]._pdir, MIT_LIGHTWALL, MI_ENEMYMONST, id, dam, missile[i]._mispllvl);
missile[i]._miVar5 = tx;
missile[i]._miVar6 = ty;
} else missile[i]._miVar7 = 1;
}
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Infra(int i)
{
#if (PRE_BETA && PRE_INFRA) || !PRE_BETA
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
plr[(missile[i]._misource)]._pInfraFlag = TRUE;
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
CalcPlrItemVals(missile[i]._misource,TRUE);
}
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Apoca(int i)
{
#if (PRE_BETA && PRE_APOCA) || !PRE_BETA
int j, k, id;
BOOL exit;
app_assert(i < MAXMISSILES);
id = missile[i]._misource;
exit = FALSE;
for (j = missile[i]._miVar2; (j < missile[i]._miVar3) && (exit == FALSE); ++j) {
for (k = missile[i]._miVar4; (k < missile[i]._miVar5) && (exit == FALSE); ++k) {
if (dMonster[k][j] > 3 && nSolidTable[(dPiece[k][j])] == 0) {
AddMissile(k, j, k, j, plr[id]._pdir, MIT_BOOM, MI_ENEMYMONST, id, missile[i]._midam, 0);
exit = TRUE;
}
}
if (exit == FALSE) missile[i]._miVar4 = missile[i]._miVar6;
}
if (exit == TRUE) {
missile[i]._miVar2 = j - 1;
missile[i]._miVar4 = k;
} else missile[i]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Wave(int i)
{
#if (PRE_BETA && PRE_WAVE) || !PRE_BETA
int dira, dirb, nxa, nya, nxb, nyb;
int pn, sd, j, f1, f2, id, sx, sy, dx, dy;
f1 = 0;
f2 = 0;
app_assert(i < MAXMISSILES);
id = missile[i]._misource;
sx = missile[i]._mix;
sy = missile[i]._miy;
dx = missile[i]._miVar1;
dy = missile[i]._miVar2;
sd = GetDirection(sx, sy, dx, dy);
dira = (sd - 2) & 0x0007;
dirb = (sd + 2) & 0x0007;
nxa = sx + XDirAdd[sd];
nya = sy + YDirAdd[sd];
//if (nxa >= MAXDUNX || nya >= MAXDUNY)
// app_fatal("Tried placing flamewave piece off edge of map at (%d,%d)",nxa,nya);
pn = dPiece[nxa][nya];
app_assert(pn <= MAXTILES);
if (nMissileTable[pn] == 0) {
AddMissile(nxa, nya, nxa + XDirAdd[sd], nya + YDirAdd[sd], plr[id]._pdir, MIT_FIREMOVE, MI_ENEMYMONST, id, 0, missile[i]._mispllvl);
nxa += XDirAdd[dira];
nya += YDirAdd[dira];
nxb = sx + XDirAdd[sd] + XDirAdd[dirb];
nyb = sy + YDirAdd[sd] + YDirAdd[dirb];
for (j = 0; j < (2 + (missile[i]._mispllvl>>1)); ++j) {
//if (nxa >= MAXDUNX || nya >= MAXDUNY)
// app_fatal("Tried placing flamewave piece off edge of map at (%d,%d)",nxa,nya);
pn = dPiece[nxa][nya];
app_assert(pn <= MAXTILES);
if (nMissileTable[pn] == 0 && f1 == 0 && nxa > 0 && nxa < MAXDUNX && nya > 0 && nya < MAXDUNY) {
AddMissile(nxa, nya, nxa + XDirAdd[sd], nya + YDirAdd[sd], plr[id]._pdir, MIT_FIREMOVE, MI_ENEMYMONST, id, 0, missile[i]._mispllvl);
nxa += XDirAdd[dira];
nya += YDirAdd[dira];
} else f1 = 1;
//if (nxb >= MAXDUNX || nyb >= MAXDUNY)
// app_fatal("Tried placing flamewave piece off edge of map at (%d,%d)",nxb,nyb);
pn = dPiece[nxb][nyb];
app_assert(pn <= MAXTILES);
if (nMissileTable[pn] == 0 && f2 == 0 && nxb > 0 && nxb < MAXDUNX && nyb > 0 && nyb < MAXDUNY) {
AddMissile(nxb, nyb, nxb + XDirAdd[sd], nyb + YDirAdd[sd], plr[id]._pdir, MIT_FIREMOVE, MI_ENEMYMONST, id, 0, missile[i]._mispllvl);
nxb += XDirAdd[dirb];
nyb += YDirAdd[dirb];
} else f2 = 1;
}
}
--missile[i]._mirange;
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
#define RAD 6
void MI_Nova(int i)
{
#if (PRE_BETA && PRE_NOVA) || !PRE_BETA
int k, id, sx, sy, dir, en;
int sx1, sy1, dam, dx, dy;
sx1 = sy1 = 0;
app_assert(i < MAXMISSILES);
id = missile[i]._misource;
dam = missile[i]._midam;
sx = missile[i]._mix;
sy = missile[i]._miy;
dx = missile[i]._miVar1;
dy = missile[i]._miVar2;
if (id != -1) {
dir = plr[id]._pdir;
en = MI_ENEMYMONST;
} else {
dir = 0;
en = MI_ENEMYPLR;
}
for (k = 0; k < 23; ++k) {
if ((sx1 != vCrawlTable[k][RAD]) || (sy1 != vCrawlTable[k][RAD + 1])) {
dx = sx + vCrawlTable[k][RAD];
dy = sy + vCrawlTable[k][RAD + 1];
AddMissile(sx, sy, dx, dy, dir, MIT_LIGHTBALL, en, id, dam, missile[i]._mispllvl);
dx = sx - vCrawlTable[k][RAD];
dy = sy - vCrawlTable[k][RAD + 1];
AddMissile(sx, sy, dx, dy, dir, MIT_LIGHTBALL, en, id, dam, missile[i]._mispllvl);
dx = sx - vCrawlTable[k][RAD];
dy = sy + vCrawlTable[k][RAD + 1];
AddMissile(sx, sy, dx, dy, dir, MIT_LIGHTBALL, en, id, dam, missile[i]._mispllvl);
dx = sx + vCrawlTable[k][RAD];
dy = sy - vCrawlTable[k][RAD + 1];
AddMissile(sx, sy, dx, dy, dir, MIT_LIGHTBALL, en, id, dam, missile[i]._mispllvl);
sx1 = vCrawlTable[k][RAD];
sy1 = vCrawlTable[k][RAD + 1];
}
}
--missile[i]._mirange;
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_FireNova(int i)
{
#if (PRE_BETA && PRE_NOVA) || !PRE_BETA
int k, id, sx, sy, dir, en;
int sx1, sy1, dam, dx, dy;
sx1 = sy1 = 0;
app_assert(i < MAXMISSILES);
id = missile[i]._misource;
dam = missile[i]._midam;
sx = missile[i]._mix;
sy = missile[i]._miy;
dx = missile[i]._miVar1;
dy = missile[i]._miVar2;
if (id != -1) {
dir = plr[id]._pdir;
en = MI_ENEMYMONST;
} else {
dir = 0;
en = MI_ENEMYPLR;
}
for (k = 0; k < 23; ++k) {
if ((sx1 != vCrawlTable[k][RAD]) || (sy1 != vCrawlTable[k][RAD + 1])) {
dx = sx + vCrawlTable[k][RAD];
dy = sy + vCrawlTable[k][RAD + 1];
AddMissile(sx, sy, dx, dy, dir, MIT_FBARROW, en, id, dam, missile[i]._mispllvl);
dx = sx - vCrawlTable[k][RAD];
dy = sy - vCrawlTable[k][RAD + 1];
AddMissile(sx, sy, dx, dy, dir, MIT_FBARROW, en, id, dam, missile[i]._mispllvl);
dx = sx - vCrawlTable[k][RAD];
dy = sy + vCrawlTable[k][RAD + 1];
AddMissile(sx, sy, dx, dy, dir, MIT_FBARROW, en, id, dam, missile[i]._mispllvl);
dx = sx + vCrawlTable[k][RAD];
dy = sy - vCrawlTable[k][RAD + 1];
AddMissile(sx, sy, dx, dy, dir, MIT_FBARROW, en, id, dam, missile[i]._mispllvl);
sx1 = vCrawlTable[k][RAD];
sy1 = vCrawlTable[k][RAD + 1];
}
}
--missile[i]._mirange;
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
#endif
}
void MI_SpecialArrow(int i)
{
#if (PRE_BETA && PRE_FIREBALL) || !PRE_BETA
int id, sx, sy, dir, en;
int sx1, sy1, dam, dx, dy;
sx1 = sy1 = 0;
app_assert(i < MAXMISSILES);
id = missile[i]._misource;
dam = missile[i]._midam;
sx = missile[i]._mix;
sy = missile[i]._miy;
dx = missile[i]._miVar1;
dy = missile[i]._miVar2;
int extraspeed = missile[i]._miVar3;
int mitype = MIT_ARROW;
if (id != -1) {
dir = plr[id]._pdir;
en = MI_ENEMYMONST;
switch(plr[id]._pILMinDam)
{
case 0: mitype = MIT_FBARROW; break;
case 1: mitype = MIT_LTARROW; break;
case 2: mitype = MIT_CBARROW; break;
case 3: mitype = MIT_HBARROW; break;
default: break;
}
} else {
dir = 0;
en = MI_ENEMYPLR;
}
AddMissile(sx, sy, dx, dy, dir, mitype, en, id, dam, extraspeed);
if (mitype == MIT_CBARROW)
{
AddMissile(sx, sy, dx, dy, dir, mitype, en, id, dam, extraspeed);
AddMissile(sx, sy, dx, dy, dir, mitype, en, id, dam, extraspeed);
}
--missile[i]._mirange;
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Boil(int i)
{
app_assert(i < MAXMISSILES);
missile[i]._miDelFlag = TRUE;
return;
/*#if (PRE_BETA && PRE_BLOODB) || !PRE_BETA
int j, mid, id, dx, dy, pct;
long dm;
BOOL M_Talker (int);
id = missile[i]._misource;
dx = missile[i]._miVar1;
dy = missile[i]._miVar2;
mid = dMonster[dx][dy];
if (mid > 0) --mid;
else mid = -(mid + 1);
if (mid > 0) {
if ((M_Talker(mid) && monster[mid].mtalkmsg != 0) || ((plr[id]._pLevel - 6 + missile[i]._mispllvl) <= monster[mid].mLevel)) {
missile[i]._miDelFlag = TRUE;
return;
}
if (monster[mid].mMagicRes & M_IM) return;
dm = monster[mid]._mhitpoints;
monster[mid]._mhitpoints = 0;
M_StartKill(mid, id);
AddPlrExperience(id, monster[mid].mLevel, monster[mid].mExp);
dMonster[monster[mid]._mx][monster[mid]._my] = 0;
monster[mid]._mDelFlag = TRUE;
AddMissile(monster[mid]._mx, monster[mid]._my, monster[mid]._mx, monster[mid]._my, plr[id]._pdir, MIT_SPURT, MI_ENEMYMONST, id, (random(87, 2) + 1), 0);
AddDead(monster[mid]._mx, monster[mid]._my, spurtndx, monster[mid]._mdir);
pct = 0;
for (j = 0; j < missile[i]._mispllvl && j < 5; ++j) pct += 10;
//dm = (monster[mid]._mmaxhp >> 1);
if (pct > 0) dm -= (dm / pct);
plr[id]._pHitPoints -= dm;
plr[id]._pHPBase -= dm;
if (plr[id]._pHitPoints > plr[id]._pMaxHP) {
plr[id]._pHitPoints = plr[id]._pMaxHP;
plr[id]._pHPBase = plr[id]._pMaxHPBase;
}
if (plr[id]._pHitPoints <= 0) {
// rjs - manashld fix? - plr[id]._pHitPoints = 0;
StartPlrKill(id, FALSE);
} else StartPlrHit(id, dm);
PlaySfxLoc(LS_BLODBOIL, monster[mid]._mx, monster[mid]._my);
UseMana(id, SPL_BLOODB);
}
--missile[i]._mirange;
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
#endif*/
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Flame(int i)
{
#if (PRE_BETA && PRE_FLAME) || !PRE_BETA
int k, id;
app_assert(i < MAXMISSILES);
id = missile[i]._misource;
--missile[i]._mirange;
--missile[i]._miVar2;
k = missile[i]._mirange;
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 1, missile[i]._mix, missile[i]._miy, 0);
if ((missile[i]._mirange == 0) && (missile[i]._miHitFlag == TRUE)) missile[i]._mirange = k;
if (missile[i]._miVar2 == 0) missile[i]._miAnimFrame = 20;
if (missile[i]._miVar2 <= 0) {
k = missile[i]._miAnimFrame;
if (k > 11) k = 24 - k;
ChangeLight(missile[i]._mlid, missile[i]._mix, missile[i]._miy, k);
}
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
}
if (missile[i]._miVar2 <= 0) PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Flamec(int i)
{
#if (PRE_BETA && PRE_FLAME) || !PRE_BETA
int id, pn;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
id = missile[i]._misource;
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
if ((missile[i]._mix != missile[i]._miVar1) || (missile[i]._miy != missile[i]._miVar2)) {
app_assert(missile[i]._mix < MAXDUNX);
app_assert(missile[i]._miy < MAXDUNY);
pn = dPiece[missile[i]._mix][missile[i]._miy];
app_assert(pn <= MAXTILES);
if (nMissileTable[pn] == 0)
AddMissile(missile[i]._mix, missile[i]._miy, missile[i]._misx, missile[i]._misy, i, MIT_FLAME, missile[i]._micaster, id, missile[i]._miVar3, missile[i]._mispllvl);
else
missile[i]._mirange = 0;
missile[i]._miVar1 = missile[i]._mix;
missile[i]._miVar2 = missile[i]._miy;
++missile[i]._miVar3;
}
if (missile[i]._mirange == 0 || missile[i]._miVar3 == 3) missile[i]._miDelFlag = TRUE;
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Cbolt(int i)
{
#if (PRE_BETA && PRE_CBOLT) || !PRE_BETA
int bpath[16] = { -1, 0, 1, -1, 0, 1, -1, -1, 0, 0, 1, 1, 0, 1, -1, 0 };
int sx, sy, dx, dy, md;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
if (missile[i]._miAnimType != MF_LIGHTNING) {
if (missile[i]._miVar3 == 0) {
md = (missile[i]._miVar2 + bpath[missile[i]._mirnd]) & 0x07;
missile[i]._mirnd = (missile[i]._mirnd + 1) & 0x0f;
sx = missile[i]._mix;
sy = missile[i]._miy;
dx = sx + XDirAdd[md];
dy = sy + YDirAdd[md];
GetMissileVel(i, sx, sy, dx, dy, 8);
missile[i]._miVar3 = 16;
} else --missile[i]._miVar3;
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
CheckMissileCol(i, missile[i]._midam, missile[i]._midam, 0, missile[i]._mix, missile[i]._miy, 0);
if (missile[i]._miHitFlag == TRUE) {
missile[i]._miVar1 = 8;
missile[i]._mimfnum = 0;
missile[i]._mixoff = 0;
missile[i]._miyoff = 0;
SetMissAnim(i, MF_LIGHTNING);
missile[i]._mirange = missile[i]._miAnimLen;
GetMissilePos(i);
}
ChangeLight(missile[i]._mlid, missile[i]._mix, missile[i]._miy, missile[i]._miVar1);
}
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Hbolt(int i)
{
#if (PRE_BETA && PRE_HBOLT) || !PRE_BETA
int dam;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
if (missile[i]._miAnimType != MF_HEXPL) {
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
dam = missile[i]._midam;
if ((missile[i]._mix != missile[i]._misx) || (missile[i]._miy != missile[i]._misy))
CheckMissileCol(i, dam, dam, 0, missile[i]._mix, missile[i]._miy, 0);
if (missile[i]._mirange == 0) {
missile[i]._mitxoff -= missile[i]._mixvel;
missile[i]._mityoff -= missile[i]._miyvel;
GetMissilePos(i);
missile[i]._mimfnum = 0;
SetMissAnim(i, MF_HEXPL);
missile[i]._mirange = missile[i]._miAnimLen - 1;
} else {
if ((missile[i]._mix != missile[i]._miVar1) || (missile[i]._miy != missile[i]._miVar2)) {
missile[i]._miVar1 = missile[i]._mix;
missile[i]._miVar2 = missile[i]._miy;
ChangeLight(missile[i]._mlid, missile[i]._miVar1, missile[i]._miVar2, 8);
}
}
} else {
ChangeLight(missile[i]._mlid, missile[i]._mix, missile[i]._miy, 7 + missile[i]._miAnimFrame);
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
}
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Element(int i)
{
#if (PRE_BETA && PRE_ELEMENT) || !PRE_BETA
int j, mid, sd, dam;
int cx, cy, px, py, id;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
dam = missile[i]._midam;
id = missile[i]._misource;
if (missile[i]._miAnimType == MF_BIGEXP) {
cx = missile[i]._mix;
cy = missile[i]._miy;
px = plr[id]._px;
py = plr[id]._py;
ChangeLight(missile[i]._mlid, cx, cy, missile[i]._miAnimFrame);
if (CheckBlock(px, py, cx , cy ) == 0) CheckMissileCol(i, dam, dam, 1, cx, cy, 1);
if (CheckBlock(px, py, cx , cy + 1) == 0) CheckMissileCol(i, dam, dam, 1, cx, cy + 1, 1);
if (CheckBlock(px, py, cx , cy - 1) == 0) CheckMissileCol(i, dam, dam, 1, cx, cy - 1, 1);
if (CheckBlock(px, py, cx + 1, cy ) == 0) CheckMissileCol(i, dam, dam, 1, cx + 1, cy, 1);
if (CheckBlock(px, py, cx + 1, cy - 1) == 0) CheckMissileCol(i, dam, dam, 1, cx + 1, cy - 1, 1);
if (CheckBlock(px, py, cx + 1, cy + 1) == 0) CheckMissileCol(i, dam, dam, 1, cx + 1, cy + 1, 1);
if (CheckBlock(px, py, cx - 1, cy ) == 0) CheckMissileCol(i, dam, dam, 1, cx - 1, cy, 1);
if (CheckBlock(px, py, cx - 1, cy + 1) == 0) CheckMissileCol(i, dam, dam, 1, cx - 1, cy + 1, 1);
if (CheckBlock(px, py, cx - 1, cy - 1) == 0) CheckMissileCol(i, dam, dam, 1, cx - 1, cy - 1, 1);
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
}
PutMissile(i);
return;
}
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
cx = missile[i]._mix;
cy = missile[i]._miy;
j = missile[i]._mirange;
CheckMissileCol(i, dam, dam, 0, cx, cy, 0);
if (missile[i]._miVar3 == 0) {
//if (missile[i]._mirange == 0 && missile[i]._miHitFlag == TRUE) missile[i]._mirange = j;
//if ((missile[i]._mirange == 0) && (missile[i]._miHitFlag != TRUE)) missile[i]._miVar3 = 1;
if ((cx == missile[i]._miVar4) && (cy == missile[i]._miVar5)) missile[i]._miVar3 = 1;
}
if (missile[i]._miVar3 == 1) {
missile[i]._miVar3 = 2;
missile[i]._mirange = 255;
mid = FindClosest(cx, cy, 19);
if (mid > 0) {
sd = GetDirection8(cx, cy, monster[mid]._mx, monster[mid]._my);
SetMissDir(i, sd);
GetMissileVel(i, cx, cy, monster[mid]._mx, monster[mid]._my, 16);
} else {
sd = plr[id]._pdir;
SetMissDir(i, sd);
GetMissileVel(i, cx, cy, cx + XDirAdd[sd], cy + YDirAdd[sd], 16);
}
}
if ((cx != missile[i]._miVar1) || (cy != missile[i]._miVar2)) {
missile[i]._miVar1 = cx;
missile[i]._miVar2 = cy;
ChangeLight(missile[i]._mlid, cx, cy, 8);
}
if (missile[i]._mirange == 0) {
missile[i]._mimfnum = 0;
SetMissAnim(i, MF_BIGEXP);
missile[i]._mirange = missile[i]._miAnimLen - 1;
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Bonespirit(int i)
{
#if (PRE_BETA && PRE_BONESPIRIT) || !PRE_BETA
int j, mid, sd, dam;
int cx, cy, id;
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
dam = missile[i]._midam;
id = missile[i]._misource;
if (missile[i]._mimfnum == 8) {
cx = missile[i]._mix;
cy = missile[i]._miy;
//px = plr[id]._px;
//py = plr[id]._py;
ChangeLight(missile[i]._mlid, cx, cy, missile[i]._miAnimFrame);
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
}
PutMissile(i);
return;
}
missile[i]._mitxoff += missile[i]._mixvel;
missile[i]._mityoff += missile[i]._miyvel;
GetMissilePos(i);
cx = missile[i]._mix;
cy = missile[i]._miy;
j = missile[i]._mirange;
CheckMissileCol(i, dam, dam, 0, cx, cy, 0);
if (missile[i]._miVar3 == 0) {
//if (missile[i]._mirange == 0 && missile[i]._miHitFlag == TRUE) missile[i]._mirange = j;
//if ((missile[i]._mirange == 0) && (missile[i]._miHitFlag != TRUE)) missile[i]._miVar3 = 1;
if ((cx == missile[i]._miVar4) && (cy == missile[i]._miVar5)) missile[i]._miVar3 = 1;
}
if (missile[i]._miVar3 == 1) {
missile[i]._miVar3 = 2;
missile[i]._mirange = 255;
mid = FindClosest(cx, cy, 19);
if (mid > 0) {
missile[i]._midam = (monster[mid]._mhitpoints >> HP_SHIFT) >> 1;
sd = GetDirection8(cx, cy, monster[mid]._mx, monster[mid]._my);
SetMissDir(i, sd);
GetMissileVel(i, cx, cy, monster[mid]._mx, monster[mid]._my, 16);
} else {
sd = plr[id]._pdir;
SetMissDir(i, sd);
GetMissileVel(i, cx, cy, cx + XDirAdd[sd], cy + YDirAdd[sd], 16);
}
}
if ((cx != missile[i]._miVar1) || (cy != missile[i]._miVar2)) {
missile[i]._miVar1 = cx;
missile[i]._miVar2 = cy;
ChangeLight(missile[i]._mlid, cx, cy, 8);
}
if (missile[i]._mirange == 0) {
SetMissDir(i, 8);
missile[i]._mirange = 7;
}
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_ResurrectBeam(int i)
{
#if (PRE_BETA && PRE_RESURRECT) || !PRE_BETA
app_assert(i < MAXMISSILES);
--missile[i]._mirange;
if (missile[i]._mirange == 0) missile[i]._miDelFlag = TRUE;
PutMissile(i);
#endif
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void MI_Rportal(int i)
{
int ExpLight[17] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,15,15};
app_assert(i < MAXMISSILES);
if (missile[i]._mirange > 1) --missile[i]._mirange;
if (missile[i]._mirange == missile[i]._miVar1) {
SetMissDir(i, 1);
}
if ((currlevel != 0) && (missile[i]._mimfnum != 1) && (missile[i]._mirange != 0)) {
if (missile[i]._miVar2 == 0)
missile[i]._mlid = AddLight(missile[i]._mix, missile[i]._miy, ExpLight[(missile[i]._miVar2)]);
ChangeLight(missile[i]._mlid, missile[i]._mix, missile[i]._miy, ExpLight[(missile[i]._miVar2)]);
++missile[i]._miVar2;
}
if (missile[i]._mirange == 0) {
missile[i]._miDelFlag = TRUE;
AddUnLight(missile[i]._mlid);
}
PutMissile(i);
}
/*-----------------------------------------------------------------------*
**-----------------------------------------------------------------------*/
void ProcessMissiles ()
{
int i, mi;
for (i = 0; i < nummissiles; ++i) {
mi = missileactive[i];
dFlags[missile[mi]._mix][missile[mi]._miy] &= BFMASK_MISSILE;
dMissile[missile[mi]._mix][missile[mi]._miy] = 0;
}
i = 0;
while (i < nummissiles) {
mi = missileactive[i];
if (missile[mi]._miDelFlag) {
DeleteMissile(mi, i);
i = 0;
} else ++i;
}
MissilePreFlag = FALSE;
ManashieldFlag = 0;
for (i = 0; i < nummissiles; ++i) {
mi = missileactive[i];
missiledata[missile[mi]._mitype].mProc(mi);
if(!(missile[mi]._miAnimFlags & MFF_STATIC))
{
++missile[mi]._miAnimCnt;
if (missile[mi]._miAnimCnt >= missile[mi]._miAnimDelay) {
missile[mi]._miAnimCnt = 0;
missile[mi]._miAnimFrame += missile[mi]._miAnimAdd;
if (missile[mi]._miAnimFrame > missile[mi]._miAnimLen) missile[mi]._miAnimFrame = 1;
if (missile[mi]._miAnimFrame < 1) missile[mi]._miAnimFrame = missile[mi]._miAnimLen;
}
}
}
if (ManashieldFlag) {
for (i = 0; i < nummissiles; ++i) {
mi = missileactive[i];
if (missile[mi]._mitype == MIT_MANASHIELD) MI_Manashield(mi);
}
}
i = 0;
while (i < nummissiles) {
mi = missileactive[i];
if (missile[mi]._miDelFlag) {
DeleteMissile(mi, i);
i = 0;
} else ++i;
}
}
void SyncMissAnim()
{
int i,mi;
for (i = 0; i < nummissiles; ++i)
{
app_assert(i < MAXMISSILES);
mi = missileactive[i];
app_assert(mi < MAXMISSILES);
MissileStruct *Miss = &missile[mi];
Miss->_miAnimData = misfiledata[Miss->_miAnimType].mAnimData[Miss->_mimfnum];
if (Miss->_mitype == MIT_RHINO)
{
AnimStruct *anim;
if (EquivMonst(monster[Miss->_misource].MType->mtype, MT_HORNED))
anim = &monster[Miss->_misource].MType->Anims[MA_SPECIAL];
else if (EquivMonst(monster[Miss->_misource].MType->mtype, MT_NSNAKE))
anim = &monster[Miss->_misource].MType->Anims[MA_ATTACK];
else
anim = &monster[Miss->_misource].MType->Anims[MA_WALK];
missile[mi]._miAnimData = anim->Cels[Miss->_mimfnum];
}
// need similar section for Fireman
}
}
/*-----------------------------------------------------------------------*
** Used when we need to "emergency" delete missiles
**-----------------------------------------------------------------------*/
void ClearMissileSpot(int mi)
{
app_assert(mi < MAXMISSILES);
dFlags[missile[mi]._mix][missile[mi]._miy] &= BFMASK_MISSILE;
dMissile[missile[mi]._mix][missile[mi]._miy] = 0;
}
Reference in New Issue View Git Blame Copy Permalink