zdoom/raze-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/raze-gles.git synced 2024-11-13 07:58:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

Clean up bullet code a bit

Browse source
This commit is contained in:
nukeykt 2019-09-26 06:16:12 +09:00 committed by Christoph Oelckers
parent a1ce0830db
commit 83a4485140
3 changed files with 702 additions and 790 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

566
source/exhumed/src/bullet.cpp
View file

@ -138,66 +138,6 @@ void BulletHitsSprite(Bullet *pBullet, short nBulletSprite, short nHitSprite, in
switch (pBullet->nType)
{
case 0:
case 4:
case 5:
case 6:
case 7:
case 10:
case 11:
{
break;
}
case 14:
{
if (nStat > 107 || nStat == 98) {
return;
}
// else - fall through to below cases
}
case 1:
case 2:
case 8:
case 9:
case 12:
case 13:
case 15:
case 16:
{
// loc_29E59
if (!nStat || nStat > 98) {
break;
}
short nSprite = pBullet->nSprite;
if (nStat == 98)
{
short nAngle = sprite[nSprite].ang + 256;
int nRand = RandomSize(9);
sprite[nHitSprite].xvel = Sin((nAngle - nRand) + 512) * 2;
sprite[nHitSprite].yvel = Sin((nAngle - nRand)) * 2;
sprite[nHitSprite].zvel = (-(RandomSize(3) + 1)) << 8;
}
else
{
int xVel = sprite[nHitSprite].xvel;
int yVel = sprite[nHitSprite].yvel;
sprite[nHitSprite].xvel = Sin(sprite[nSprite].ang + 512) >> 2;
sprite[nHitSprite].yvel = Sin(sprite[nSprite].ang) >> 2;
MoveCreature(nHitSprite);
sprite[nHitSprite].xvel = xVel;
sprite[nHitSprite].yvel = yVel;
}
break;
}
case 3:
{
if (nStat > 107 || nStat == 98) {
@ -216,6 +156,56 @@ void BulletHitsSprite(Bullet *pBullet, short nBulletSprite, short nHitSprite, in
return;
}
case 14:
{
if (nStat > 107 || nStat == 98) {
return;
}
// else - fall through to below cases
fallthrough__;
}
case 1:
case 2:
case 8:
case 9:
case 12:
case 13:
case 15:
case 16:
{
// loc_29E59
if (!nStat || nStat > 98) {
break;
}
short nSprite = pBullet->nSprite;
spritetype *pSprite = &sprite[nSprite];
spritetype *pHitSprite = &sprite[nHitSprite];
if (nStat != 98)
{
int xVel = pHitSprite->xvel;
int yVel = pHitSprite->yvel;
pHitSprite->xvel = Cos(pSprite->ang) >> 2;
pHitSprite->yvel = Sin(pSprite->ang) >> 2;
MoveCreature(nHitSprite);
pHitSprite->xvel = xVel;
pHitSprite->yvel = yVel;
}
else
{
short nAngle = pSprite->ang - (RandomSize(9) - 256);
pHitSprite->xvel = Cos(nAngle) << 1;
pHitSprite->yvel = Sin(nAngle) << 1;
pHitSprite->zvel = (-(RandomSize(3) + 1)) << 8;
}
break;
}
default:
break;
@ -236,52 +226,31 @@ void BulletHitsSprite(Bullet *pBullet, short nBulletSprite, short nHitSprite, in
return;
}
if (nStat < 98)
{
if (nStat <= 0)
switch (nStat)
{
case 97:
break;
case 0:
case 98:
case 102:
case 141:
case 152:
BuildAnim(-1, 12, 0, x, y, z, nSector, 40, 0);
}
else if (nStat == 97)
{
return;
}
else
{
// BHS_B
break;
default:
BuildAnim(-1, 39, 0, x, y, z, nSector, 40, 0);
if (pBullet->nType > 2)
{
BuildAnim(-1, pBulletInfo->field_C, 0, x, y, z, nSector, 40, pBulletInfo->nFlags);
}
}
return;
}
else
{
if (nStat == 98 || nStat == 141 || nStat == 152 || nStat == 102)
{
BuildAnim(-1, 12, 0, x, y, z, nSector, 40, 0);
}
else
{
// BHS_B
BuildAnim(-1, 39, 0, x, y, z, nSector, 40, 0);
if (pBullet->nType > 2)
{
BuildAnim(-1, pBulletInfo->field_C, 0, x, y, z, nSector, 40, pBulletInfo->nFlags);
}
}
return;
break;
}
}
void BackUpBullet(int *x, int *y, short nAngle)
{
*x -= Sin(nAngle + 512) >> 11;
*x -= Cos(nAngle) >> 11;
*y -= Sin(nAngle) >> 11;
}
@ -291,129 +260,114 @@ int MoveBullet(short nBullet)
short hitwall = -1;
short hitsprite = -1;
short nType = BulletList[nBullet].nType;
short nSprite = BulletList[nBullet].nSprite;
Bullet *pBullet = &BulletList[nBullet];
short nType = pBullet->nType;
bulletInfo *pBulletInfo = &BulletInfo[nType];
int x = sprite[nSprite].x;
int y = sprite[nSprite].y;
int z = sprite[nSprite].z; // ebx
short nSectFlag = SectFlag[sprite[nSprite].sectnum];
short nSprite = BulletList[nBullet].nSprite;
spritetype *pSprite = &sprite[nSprite];
int x = pSprite->x;
int y = pSprite->y;
int z = pSprite->z; // ebx
short nSectFlag = SectFlag[pSprite->sectnum];
int x2, y2, z2;
short var_3C = BulletList[nBullet].field_10;
short var_3C = pBullet->field_10;
int nVal;
if (var_3C < 30000)
{
short nEnemySprite = nBulletEnemy[nBullet];
if (nBulletEnemy[nBullet] <= -1) {
goto MoveBullet_goto_A; // FIXME
}
if (!(sprite[nEnemySprite].cstat & 0x101))
if (nEnemySprite > -1)
{
if (!(sprite[nEnemySprite].cstat & 0x101))
nBulletEnemy[nBullet] = -1;
MoveBullet_goto_A:
else
{
nVal = AngleChase(nSprite, nEnemySprite, var_3C, 0, 16);
goto MOVEEND;
}
}
if (nType == 3)
{
if (BulletList[nBullet].field_E >= 8)
if (pBullet->field_E < 8)
{
sprite[nSprite].xrepeat += 4;
sprite[nSprite].yrepeat += 4;
pSprite->xrepeat -= 1;
pSprite->yrepeat += 8;
pBullet->z -= 200;
if (pSprite->shade < 90) {
pSprite->shade += 35;
}
if (pBullet->field_E == 3)
{
pBullet->nSeq = 45;
pBullet->field_2 = 0;
pSprite->xrepeat = 40;
pSprite->yrepeat = 40;
pSprite->shade = 0;
pSprite->z += 512;
}
}
else
{
sprite[nSprite].xrepeat -= 1;
sprite[nSprite].yrepeat += 8;
BulletList[nBullet].z -= 200;
if (sprite[nSprite].shade < 90) {
sprite[nSprite].shade += 35;
}
if (BulletList[nBullet].field_E == 3)
{
BulletList[nBullet].nSeq = 45;
BulletList[nBullet].field_2 = 0;
sprite[nSprite].xrepeat = 40;
sprite[nSprite].yrepeat = 40;
sprite[nSprite].shade = 0;
sprite[nSprite].z += 512;
}
pSprite->xrepeat += 4;
pSprite->yrepeat += 4;
}
}
// loc_2A1DD
nVal = movesprite(nSprite, BulletList[nBullet].x, BulletList[nBullet].y, BulletList[nBullet].z, sprite[nSprite].clipdist >> 1, sprite[nSprite].clipdist >> 1, CLIPMASK1);
}
else
{
nVal = AngleChase(nSprite, nEnemySprite, var_3C, 0, 16);
}
nVal = movesprite(nSprite, pBullet->x, pBullet->y, pBullet->z, pSprite->clipdist >> 1, pSprite->clipdist >> 1, CLIPMASK1);
MOVEEND:
if (nVal)
{
x2 = sprite[nSprite].x;
y2 = sprite[nSprite].y;
z2 = sprite[nSprite].z;
hitsect = sprite[nSprite].sectnum;
x2 = pSprite->x;
y2 = pSprite->y;
z2 = pSprite->z;
hitsect = pSprite->sectnum;
if (nVal & 0x30000)
{
hitwall = nVal & 0x3FFF;
goto loc_2A48A;
goto HITWALL;
}
else
{
if ((nVal & 0xC000) == 0x8000)
switch (nVal & 0xc000)
{
case 0x8000:
hitwall = nVal & 0x3FFF;
goto loc_2A48A;
}
else if ((nVal & 0xC000) == 0xC000)
{
goto HITWALL;
case 0xc000:
hitsprite = nVal & 0x3FFF;
goto loc_2A405;
}
else {
goto loc_2A25F;
goto HITSPRITE;
}
}
}
else
{
loc_2A25F:
// sprite[nSprite].sectnum may have changed since we set nSectFlag ?
short nFlagVal = nSectFlag ^ SectFlag[sprite[nSprite].sectnum];
short nFlagVal = nSectFlag ^ SectFlag[pSprite->sectnum];
if (nFlagVal & kSectUnderwater)
{
DestroyBullet(nBullet);
nVal = 1;
}
if (nVal) {
return nVal;
}
if (nType == 15)
if (nVal == 0 && nType != 15 && nType != 3)
{
return nVal;
}
if (nType != 3)
{
AddFlash(sprite[nSprite].sectnum, sprite[nSprite].x, sprite[nSprite].y, sprite[nSprite].z, nVal);
AddFlash(sprite[nSprite].sectnum, sprite[nSprite].x, sprite[nSprite].y, sprite[nSprite].z, 0);
if (sprite[nSprite].pal != 5) {
sprite[nSprite].pal = 1;
}
}
}
}
else
{
nVal = 1;
@ -430,7 +384,7 @@ loc_2A25F:
{
vec3_t startPos = { x, y, z };
hitdata_t hitData;
hitscan(&startPos, sprite[nSprite].sectnum, Sin(sprite[nSprite].ang + 512), Sin(sprite[nSprite].ang), (-Sin(BulletList[nBullet].field_C)) << 3, &hitData, CLIPMASK1);
hitscan(&startPos, pSprite->sectnum, Cos(pSprite->ang), Sin(pSprite->ang), (-Sin(pBullet->field_C)) << 3, &hitData, CLIPMASK1);
x2 = hitData.pos.x;
y2 = hitData.pos.y;
z2 = hitData.pos.z;
@ -446,16 +400,10 @@ loc_2A25F:
lasthitwall = hitwall;
lasthitsprite = hitsprite;
if (lasthitsprite > -1)
if (hitsprite > -1)
{
loc_2A405:
if (sprite[nSprite].pal != 5 || sprite[hitsprite].statnum != 100)
{
// assert(hitsect <= kMaxSectors);
BulletHitsSprite(&BulletList[nBullet], sprite[nSprite].owner, hitsprite, x2, y2, z2, hitsect);
}
else
HITSPRITE:
if (pSprite->pal == 5 && sprite[hitsprite].statnum != 100)
{
short nPlayer = GetPlayerFromSprite(hitsprite);
if (!PlayerList[nPlayer].bIsMummified)
@ -464,21 +412,27 @@ loc_2A405:
SetNewWeapon(nPlayer, kWeaponMummified);
}
}
else
{
// assert(hitsect <= kMaxSectors);
BulletHitsSprite(pBullet, pSprite->owner, hitsprite, x2, y2, z2, hitsect);
}
}
else if (hitwall > -1)
{
loc_2A48A:
HITWALL:
if (wall[hitwall].picnum == kEnergy1)
{
short nSector = wall[hitwall].nextsector;
if (nSector > -1)
{
short nDamage = BulletInfo[BulletList[nBullet].nType].nDamage;
if (BulletList[nBullet].field_13 > 1) {
short nDamage = BulletInfo[pBullet->nType].nDamage;
if (pBullet->field_13 > 1) {
nDamage *= 2;
}
short nNormal = GetWallNormal(hitwall) & 0x7FF;
short nNormal = GetWallNormal(hitwall) & kAngleMask;
runlist_DamageEnemy(sector[nSector].extra, nNormal, nDamage);
}
@ -490,33 +444,21 @@ loc_2A48A:
{
if ((SectBelow[hitsect] >= 0 && (SectFlag[SectBelow[hitsect]] & kSectUnderwater)) || SectDepth[hitsect])
{
sprite[nSprite].x = x2;
sprite[nSprite].y = y2;
sprite[nSprite].z = z2;
pSprite->x = x2;
pSprite->y = y2;
pSprite->z = z2;
BuildSplash(nSprite, hitsect);
}
else
{
BuildAnim(-1, BulletInfo[nType].field_C, 0, x2, y2, z2, hitsect, 40, BulletInfo[nType].nFlags);
BuildAnim(-1, pBulletInfo->field_C, 0, x2, y2, z2, hitsect, 40, pBulletInfo->nFlags);
}
}
else
else if (hitwall >= 0)
{
// short nType = BulletList[nBullet].nType;
BackUpBullet(&x2, &y2, pSprite->ang);
if (hitwall < 0)
{
sprite[nSprite].x = x2;
sprite[nSprite].y = y2;
sprite[nSprite].z = z2;
mychangespritesect(nSprite, hitsect);
}
else
{
BackUpBullet(&x2, &y2, sprite[nSprite].ang);
if (nType != 3 || !RandomSize(2))
if (nType != 3 || RandomSize(2) == 0)
{
int zOffset = RandomSize(8) << 3;
@ -525,21 +467,28 @@ loc_2A48A:
}
// draws bullet puff on walls when they're shot
BuildAnim(-1, BulletInfo[nType].field_C, 0, x2, y2, z2 + zOffset, hitsect, 40, BulletInfo[nType].nFlags);
BuildAnim(-1, pBulletInfo->field_C, 0, x2, y2, z2 + zOffset, hitsect, 40, pBulletInfo->nFlags);
}
}
else
{
pSprite->x = x2;
pSprite->y = y2;
pSprite->z = z2;
mychangespritesect(nSprite, hitsect);
}
// loc_2A639:
if (BulletInfo[nType].field_10)
{
nRadialBullet = nType;
runlist_RadialDamageEnemy(nSprite, BulletInfo[nType].nDamage, BulletInfo[nType].field_10);
runlist_RadialDamageEnemy(nSprite, pBulletInfo->nDamage, pBulletInfo->field_10);
nRadialBullet = -1;
AddFlash(sprite[nSprite].sectnum, sprite[nSprite].x, sprite[nSprite].y, sprite[nSprite].z, 128);
}
AddFlash(pSprite->sectnum, pSprite->x, pSprite->y, pSprite->z, 128);
}
DestroyBullet(nBullet);
@ -558,18 +507,20 @@ void SetBulletEnemy(short nBullet, short nEnemy)
int BuildBullet(short nSprite, int nType, int ebx, int ecx, int val1, int nAngle, int val2, int val3)
{
Bullet sBullet;
bulletInfo *pBulletInfo = &BulletInfo[nType];
if (BulletInfo[nType].field_4 > 30000)
if (pBulletInfo->field_4 > 30000)
{
if (val2 >= 10000)
{
val2 -= 10000;
short nTargetSprite = val2;
spritetype *pTargetSprite = &sprite[nTargetSprite];
// assert(sprite[nTargetSprite].sectnum <= kMaxSectors);
if (sprite[nTargetSprite].cstat & 0x101)
if (pTargetSprite->cstat & 0x101)
{
sBullet.nType = nType;
sBullet.field_13 = val3;
@ -581,7 +532,7 @@ int BuildBullet(short nSprite, int nType, int ebx, int ecx, int val1, int nAngle
assert(sprite[nTargetSprite].sectnum >= 0 && sprite[nTargetSprite].sectnum < kMaxSectors);
BulletHitsSprite(&sBullet, nSprite, nTargetSprite, sprite[nTargetSprite].x, sprite[nTargetSprite].y, sprite[nTargetSprite].z - (nHeight >> 1), sprite[nTargetSprite].sectnum);
BulletHitsSprite(&sBullet, nSprite, nTargetSprite, pTargetSprite->x, pTargetSprite->y, pTargetSprite->z - (nHeight >> 1), pTargetSprite->sectnum);
mydeletesprite(sBullet.nSprite);
return -1;
}
@ -598,16 +549,16 @@ int BuildBullet(short nSprite, int nType, int ebx, int ecx, int val1, int nAngle
short nSector;
if (sprite[nSprite].statnum != 100)
{
nSector = sprite[nSprite].sectnum;
}
else
if (sprite[nSprite].statnum == 100)
{
nSector = nPlayerViewSect[GetPlayerFromSprite(nSprite)];
}
else
{
nSector = sprite[nSprite].sectnum;
}
int nBulletSprite = insertsprite(nSector, 200);
short nBulletSprite = insertsprite(nSector, 200);
int nHeight = GetSpriteHeight(nSprite);
nHeight = nHeight - (nHeight >> 2);
@ -623,13 +574,14 @@ int BuildBullet(short nSprite, int nType, int ebx, int ecx, int val1, int nAngle
assert(nBulletSprite >= 0 && nBulletSprite < kMaxSprites);
short nBullet = GrabBullet();
Bullet *pBullet = &BulletList[nBullet];
nBulletEnemy[nBullet] = -1;
sprite[nBulletSprite].cstat = 0;
sprite[nBulletSprite].shade = -64;
if (BulletInfo[nType].nFlags & 4) {
if (pBulletInfo->nFlags & 4) {
sprite[nBulletSprite].pal = 4;
}
else {
@ -638,7 +590,7 @@ int BuildBullet(short nSprite, int nType, int ebx, int ecx, int val1, int nAngle
sprite[nBulletSprite].clipdist = 25;
short nRepeat = BulletInfo[nType].xyRepeat;
short nRepeat = pBulletInfo->xyRepeat;
if (nRepeat < 0) {
nRepeat = 30;
}
@ -658,24 +610,24 @@ int BuildBullet(short nSprite, int nType, int ebx, int ecx, int val1, int nAngle
// GrabTimeSlot(3);
BulletList[nBullet].field_10 = 0;
BulletList[nBullet].field_E = BulletInfo[nType].field_2;
BulletList[nBullet].field_2 = 0;
pBullet->field_10 = 0;
pBullet->field_E = pBulletInfo->field_2;
pBullet->field_2 = 0;
short nSeq;
if (BulletInfo[nType].field_8 == -1)
if (pBulletInfo->field_8 != -1)
{
BulletList[nBullet].field_12 = 1;
nSeq = BulletInfo[nType].nSeq;
pBullet->field_12 = 0;
nSeq = pBulletInfo->field_8;
}
else
{
BulletList[nBullet].field_12 = 0;
nSeq = BulletInfo[nType].field_8;
pBullet->field_12 = 1;
nSeq = pBulletInfo->nSeq;
}
BulletList[nBullet].nSeq = nSeq;
pBullet->nSeq = nSeq;
sprite[nBulletSprite].picnum = seq_GetSeqPicnum(nSeq, 0, 0);
@ -683,24 +635,20 @@ int BuildBullet(short nSprite, int nType, int ebx, int ecx, int val1, int nAngle
sprite[nBulletSprite].cstat |= 0x8000;
}
BulletList[nBullet].field_C = val2 & 0x7FF; // TODO - anglemask?
BulletList[nBullet].nType = nType;
BulletList[nBullet].nSprite = nBulletSprite;
BulletList[nBullet].field_6 = runlist_AddRunRec(sprite[nBulletSprite].lotag - 1, nBullet | 0xB0000);
BulletList[nBullet].field_8 = runlist_AddRunRec(NewRun, nBullet | 0xB0000);
BulletList[nBullet].field_13 = val3;
pBullet->field_C = val2 & 0x7FF; // TODO - anglemask?
pBullet->nType = nType;
pBullet->nSprite = nBulletSprite;
pBullet->field_6 = runlist_AddRunRec(sprite[nBulletSprite].lotag - 1, nBullet | 0xB0000);
pBullet->field_8 = runlist_AddRunRec(NewRun, nBullet | 0xB0000);
pBullet->field_13 = val3;
sprite[nBulletSprite].z += val1;
int var_18;
nSector = sprite[nBulletSprite].sectnum;
while (1)
while (sprite[nBulletSprite].z < sector[nSector].ceilingz)
{
if (sprite[nBulletSprite].z >= sector[nSector].ceilingz) {
break;
}
if (SectAbove[nSector] == -1)
{
sprite[nBulletSprite].z = sector[nSector].ceilingz;
@ -713,7 +661,7 @@ int BuildBullet(short nSprite, int nType, int ebx, int ecx, int val1, int nAngle
if (val2 < 10000)
{
var_18 = ((-Sin(val2)) * BulletInfo[nType].field_4) >> 11;
var_18 = ((-Sin(val2)) * pBulletInfo->field_4) >> 11;
}
else
{
@ -721,81 +669,75 @@ int BuildBullet(short nSprite, int nType, int ebx, int ecx, int val1, int nAngle
short nTargetSprite = val2;
if (BulletInfo[nType].field_4 > 30000)
if ((unsigned int)pBulletInfo->field_4 > 30000)
{
nBulletEnemy[nBullet] = nTargetSprite;
}
else
{
nHeight = GetSpriteHeight(nTargetSprite);
int nHeightAdjust;
if (sprite[nTargetSprite].statnum == 100)
{
nHeightAdjust = nHeight >> 2;
nHeight -= nHeight >> 2;
}
else
{
nHeightAdjust = nHeight >> 1;
nHeight -= nHeight >> 1;
}
nHeight -= nHeightAdjust;
int var_20 = sprite[nTargetSprite].z - nHeight;
int x, y;
if (nSprite == -1 || sprite[nSprite].statnum == 100)
if (nSprite != -1 && sprite[nSprite].statnum != 100)
{
x = sprite[nTargetSprite].x;
y = sprite[nTargetSprite].y;
if (sprite[nTargetSprite].statnum != 100)
{
x += (sprite[nTargetSprite].xvel * 20) >> 6;
y += (sprite[nTargetSprite].yvel * 20) >> 6;
}
else
{
int nPlayer = GetPlayerFromSprite(nTargetSprite);
if (nPlayer > -1)
{
x += nPlayerDX[nPlayer] * 15;
y += nPlayerDY[nPlayer] * 15;
}
}
x -= sprite[nBulletSprite].x;
y -= sprite[nBulletSprite].y;
nAngle = GetMyAngle(x, y);
sprite[nSprite].ang = nAngle;
}
else
{
// loc_2ABA3:
x = sprite[nTargetSprite].x - sprite[nBulletSprite].x;
y = sprite[nTargetSprite].y - sprite[nBulletSprite].y;
}
else
{
x = sprite[nTargetSprite].x;
y = sprite[nTargetSprite].y;
if (sprite[nTargetSprite].statnum == 100)
{
int nPlayer = GetPlayerFromSprite(nTargetSprite);
if (nPlayer > -1)
{
x += ((nPlayerDX[nPlayer] << 4) - nPlayerDX[nPlayer]);
y += ((nPlayerDY[nPlayer] << 4) - nPlayerDY[nPlayer]);
}
}
else
{
short nXVel = sprite[nTargetSprite].xvel;
short nYVel = sprite[nTargetSprite].yvel;
x += (((nXVel << 2) + nXVel) << 2) >> 6;
y += (((nYVel << 2) + nYVel) << 2) >> 6;
}
y -= sprite[nBulletSprite].y;
x -= sprite[nBulletSprite].x;
nAngle = GetMyAngle(x, y);
sprite[nSprite].ang = nAngle;
}
int nSqrt = lsqrt(y*y + x*x);
if (nSqrt <= 0)
if ((unsigned int)nSqrt > 0)
{
var_18 = ((var_20 - sprite[nBulletSprite].z) * pBulletInfo->field_4) / nSqrt;
}
else
{
var_18 = 0;
}
else
{
var_18 = ((var_20 - sprite[nBulletSprite].z) * BulletInfo[nType].field_4) / nSqrt;
}
}
}
BulletList[nBullet].z = 0;
BulletList[nBullet].x = (sprite[nSprite].clipdist << 2) * Sin(nAngle + 512);
BulletList[nBullet].y = (sprite[nSprite].clipdist << 2) * Sin(nAngle);
pBullet->z = 0;
pBullet->x = (sprite[nSprite].clipdist << 2) * Cos(nAngle);
pBullet->y = (sprite[nSprite].clipdist << 2) * Sin(nAngle);
nBulletEnemy[nBullet] = -1;
if (MoveBullet(nBullet))
@ -804,13 +746,13 @@ int BuildBullet(short nSprite, int nType, int ebx, int ecx, int val1, int nAngle
}
else
{
BulletList[nBullet].field_10 = BulletInfo[nType].field_4;
BulletList[nBullet].x = (Sin(nAngle + 512) >> 3) * BulletInfo[nType].field_4;
BulletList[nBullet].y = (Sin(nAngle) >> 3) * BulletInfo[nType].field_4;
BulletList[nBullet].z = var_18 >> 3;
pBullet->field_10 = pBulletInfo->field_4;
pBullet->x = (Cos(nAngle) >> 3) * pBulletInfo->field_4;
pBullet->y = (Sin(nAngle) >> 3) * pBulletInfo->field_4;
pBullet->z = var_18 >> 3;
}
return (nBulletSprite & 0xFFFF) | (nBullet << 16);
return nBulletSprite | (nBullet << 16);
}
void FuncBullet(int a, int b, int nRun)
@ -825,32 +767,6 @@ void FuncBullet(int a, int b, int nRun)
switch (nMessage)
{
default:
{
DebugOut("unknown msg %x for bullet\n", a & 0x7F0000);
return;
}
case 0xA0000:
return;
case 0x90000:
{
short nSprite2 = a & 0xFFFF;
tsprite[nSprite2].statnum = 1000;
if (BulletList[nBullet].nType == 15)
{
seq_PlotArrowSequence(nSprite2, nSeq, BulletList[nBullet].field_2);
}
else
{
seq_PlotSequence(nSprite2, nSeq, BulletList[nBullet].field_2, 0);
tsprite[nSprite2].owner = -1;
}
return;
}
case 0x20000:
{
short nFlag = FrameFlag[SeqBase[nSeq] + BulletList[nBullet].field_2];
@ -874,20 +790,40 @@ void FuncBullet(int a, int b, int nRun)
BulletList[nBullet].field_2 = 0;
}
if (BulletList[nBullet].field_E == -1)
if (BulletList[nBullet].field_E != -1 && --BulletList[nBullet].field_E == 0)
{
MoveBullet(nBullet);
DestroyBullet(nBullet);
}
else
{
BulletList[nBullet].field_E--;
if (!BulletList[nBullet].field_E) {
DestroyBullet(nBullet);
}
else {
MoveBullet(nBullet);
}
break;
}
case 0x90000:
{
short nSprite2 = a & 0xFFFF;
tsprite[nSprite2].statnum = 1000;
if (BulletList[nBullet].nType == 15)
{
seq_PlotArrowSequence(nSprite2, nSeq, BulletList[nBullet].field_2);
}
else
{
seq_PlotSequence(nSprite2, nSeq, BulletList[nBullet].field_2, 0);
tsprite[nSprite2].owner = -1;
}
break;
}
case 0xA0000:
break;
default:
{
DebugOut("unknown msg %x for bullet\n", a & 0x7F0000);
return;
}
}

8
source/exhumed/src/engine.h
View file

@ -6,6 +6,7 @@
#include "build.h"
#include "pragmas.h"
#include "typedefs.h"
#include "trigdat.h"
#define kMaxTiles 6144
#define kMaxSprites 4096
@ -27,7 +28,12 @@ enum
inline int Sin(int angle)
{
return sintable[angle & 0x7FF];
return sintable[angle & kAngleMask];
}
inline int Cos(int angle)
{
return sintable[(angle + 512) & kAngleMask];
}
int movesprite(short spritenum, int dx, int dy, int dz, int ceildist, int flordist, unsigned int clipmask);

202
source/exhumed/src/move.cpp
View file

@ -296,59 +296,47 @@ int BelowNear(short nSprite)
int movespritez(short nSprite, int z, int height, int flordist, int clipdist)
{
short nSector = sprite[nSprite].sectnum;
spritetype* pSprite = &sprite[nSprite];
short nSector = pSprite->sectnum;
assert(nSector >= 0 && nSector < kMaxSectors);
overridesect = nSector;
int edi = nSector;
short edi = nSector;
// backup cstat
uint16_t cstat = sprite[nSprite].cstat;
uint16_t cstat = pSprite->cstat;
sprite[nSprite].cstat &= 0xFFFE;
pSprite->cstat &= ~CSTAT_SPRITE_BLOCK;
int nRet = 0;
if (SectFlag[nSector] & kSectUnderwater) {
short nSectFlags = SectFlag[nSector];
if (nSectFlags & kSectUnderwater) {
z >>= 1;
}
int spriteZ = sprite[nSprite].z;
int spriteZ = pSprite->z;
int floorZ = sector[nSector].floorz;
int ebp = spriteZ + z;
int eax = sector[nSector].ceilingz + (height >> 1);
if ((SectFlag[nSector] & kSectUnderwater) && ebp < eax) {
if ((nSectFlags & kSectUnderwater) && ebp < eax) {
ebp = eax;
}
// loc_151E7:
while (1)
while (ebp > sector[pSprite->sectnum].floorz && SectBelow[pSprite->sectnum] >= 0)
{
if (ebp <= sector[sprite[nSprite].sectnum].floorz || SectBelow[sprite[nSprite].sectnum] < 0)
break;
edi = SectBelow[sprite[nSprite].sectnum];
edi = SectBelow[pSprite->sectnum];
mychangespritesect(nSprite, edi);
}
if (edi == nSector)
if (edi != nSector)
{
while (1)
{
if ((ebp >= sector[sprite[nSprite].sectnum].ceilingz) || (SectAbove[sprite[nSprite].sectnum] < 0))
break;
edi = SectAbove[sprite[nSprite].sectnum];
mychangespritesect(nSprite, edi);
}
}
else
{
sprite[nSprite].z = ebp;
pSprite->z = ebp;
if (SectFlag[edi] & kSectUnderwater)
{
@ -356,21 +344,30 @@ int movespritez(short nSprite, int z, int height, int flordist, int clipdist)
D3PlayFX(StaticSound[kSound2], nSprite);
}
if (sprite[nSprite].statnum <= 107) {
sprite[nSprite].hitag = 0;
if (pSprite->statnum <= 107) {
pSprite->hitag = 0;
}
}
}
else
{
while ((ebp < sector[pSprite->sectnum].ceilingz) && (SectAbove[pSprite->sectnum] >= 0))
{
edi = SectAbove[pSprite->sectnum];
mychangespritesect(nSprite, edi);
}
}
// This function will keep the player from falling off cliffs when you're too close to the edge.
// This function finds the highest and lowest z coordinates that your clipping BOX can get to.
getzrange_old(sprite[nSprite].x, sprite[nSprite].y, sprite[nSprite].z - 256, sprite[nSprite].sectnum,
(int32_t*)&sprceiling, (int32_t*)&hihit, (int32_t*)&sprfloor, (int32_t*)&lohit, 128, CLIPMASK0);
getzrange_old(pSprite->x, pSprite->y, pSprite->z - 256, pSprite->sectnum,
&sprceiling, &hihit, &sprfloor, &lohit, 128, CLIPMASK0);
int mySprfloor = sprfloor;
if ((lohit & 0xC000) != 0xC000) {
mySprfloor += SectDepth[sprite[nSprite].sectnum];
mySprfloor += SectDepth[pSprite->sectnum];
}
if (ebp > mySprfloor)
@ -379,64 +376,24 @@ int movespritez(short nSprite, int z, int height, int flordist, int clipdist)
{
bTouchFloor = kTrue;
if ((lohit & 0xC000) != 0xC000)
{
// Path B
if (SectBelow[sprite[nSprite].sectnum] == -1)
{
nRet |= 0x20000;
short nSectDamage = SectDamage[sprite[nSprite].sectnum];
if (nSectDamage != 0)
{
if (sprite[nSprite].hitag < 15)
{
IgniteSprite(nSprite);
sprite[nSprite].hitag = 20;
}
#if 0
short dx = nSectDamage;
dx >>= 2;
int eax = dx;
int edx = eax;
edx >>= 2;
eax -= edx;
int outval;
__asm
{
mov dx, nSectDamage
sar dx, 2
movsx eax, dx
mov edx, eax
sar edx, 2; // >> 4
sub eax, edx
//mov edx, eax
movsx edx, ax
mov outval, edx
}
#endif
nSectDamage >>= 2;
nSectDamage = nSectDamage - (nSectDamage>>2);
if (nSectDamage) {
runlist_DamageEnemy(nSprite, -1, nSectDamage);
}
}
sprite[nSprite].zvel = 0;
}
}
else
if ((lohit & 0xC000) == 0xC000)
{
// Path A
short nFloorSprite = lohit & 0x3FFF;
if (sprite[nSprite].statnum != 100 || !sprite[nFloorSprite].statnum || sprite[nFloorSprite].statnum >= 100)
if (pSprite->statnum == 100 && sprite[nFloorSprite].statnum != 0 || sprite[nFloorSprite].statnum < 100)
{
short nStat = sprite[nFloorSprite].statnum;
if (!nStat || nStat > 199)
short nDamage = (z >> 9);
if (nDamage)
{
runlist_DamageEnemy(nFloorSprite, nSprite, nDamage << 1);
}
pSprite->zvel = -z;
}
else
{
if (sprite[nFloorSprite].statnum == 0 || sprite[nFloorSprite].statnum > 199)
{
nRet |= 0x20000;
}
@ -445,27 +402,44 @@ int movespritez(short nSprite, int z, int height, int flordist, int clipdist)
nRet |= lohit;
}
sprite[nSprite].zvel = 0;
pSprite->zvel = 0;
}
}
else
{
if (z >> 9)
// Path B
if (SectBelow[pSprite->sectnum] == -1)
{
runlist_DamageEnemy((lohit & 0x3FFF), nSprite, (z >> 9) * 2);
nRet |= 0x20000;
short nSectDamage = SectDamage[pSprite->sectnum];
if (nSectDamage != 0)
{
if (pSprite->hitag < 15)
{
IgniteSprite(nSprite);
pSprite->hitag = 20;
}
nSectDamage >>= 2;
nSectDamage = nSectDamage - (nSectDamage>>2);
if (nSectDamage) {
runlist_DamageEnemy(nSprite, -1, nSectDamage);
}
}
sprite[nSprite].zvel = -z;
pSprite->zvel = 0;
}
}
}
// loc_1543B:
ebp = mySprfloor;
sprite[nSprite].z = mySprfloor;
pSprite->z = mySprfloor;
}
else
{
if ((ebp - height) < sprceiling && ((hihit & 0xC000) == 0xC000 || SectAbove[sprite[nSprite].sectnum] == -1))
if ((ebp - height) < sprceiling && ((hihit & 0xC000) == 0xC000 || SectAbove[pSprite->sectnum] == -1))
{
ebp = sprceiling + height;
nRet |= 0x10000;
@ -481,12 +455,12 @@ int movespritez(short nSprite, int z, int height, int flordist, int clipdist)
}
}
sprite[nSprite].cstat = cstat; // restore cstat
sprite[nSprite].z = ebp;
pSprite->cstat = cstat; // restore cstat
pSprite->z = ebp;
if (sprite[nSprite].statnum == 100)
if (pSprite->statnum == 100)
{
BuildNear(sprite[nSprite].x, sprite[nSprite].y, clipdist + (clipdist / 2), sprite[nSprite].sectnum);
BuildNear(pSprite->x, pSprite->y, clipdist + (clipdist / 2), pSprite->sectnum);
nRet |= BelowNear(nSprite);
}
@ -501,17 +475,18 @@ int GetSpriteHeight(int nSprite)
// TODO - where is ceildist used?
int movesprite(short nSprite, int dx, int dy, int dz, int ceildist, int flordist, unsigned int clipmask)
{
spritetype *pSprite = &sprite[nSprite];
bTouchFloor = kFalse;
int x = sprite[nSprite].x;
int y = sprite[nSprite].y;
int z = sprite[nSprite].z;
int x = pSprite->x;
int y = pSprite->y;
int z = pSprite->z;
int nSpriteHeight = GetSpriteHeight(nSprite);
int nClipDist = sprite[nSprite].clipdist << 2;
int nClipDist = (int8_t)pSprite->clipdist << 2;
short nSector = sprite[nSprite].sectnum;
short nSector = pSprite->sectnum;
assert(nSector >= 0 && nSector < kMaxSectors);
int floorZ = sector[nSector].floorz;
@ -524,20 +499,18 @@ int movesprite(short nSprite, int dx, int dy, int dz, int ceildist, int flordist
dy >>= 1;
}
short nSprite2 = nSprite;
nRet |= movespritez(nSprite, dz, nSpriteHeight, flordist, nClipDist);
nSector = sprite[nSprite].sectnum; // modified in movespritez so re-grab this variable
nSector = pSprite->sectnum; // modified in movespritez so re-grab this variable
if (sprite[nSprite].statnum == 100)
if (pSprite->statnum == 100)
{
short nPlayer = GetPlayerFromSprite(nSprite2);
short nPlayer = GetPlayerFromSprite(nSprite);
int varA = 0;
int varB = 0;
CheckSectorFloor(overridesect, sprite[nSprite].z, &varB, &varA);
CheckSectorFloor(overridesect, pSprite->z, &varB, &varA);
if (varB || varA)
{
@ -550,15 +523,12 @@ int movesprite(short nSprite, int dx, int dy, int dz, int ceildist, int flordist
}
else
{
CheckSectorFloor(overridesect, sprite[nSprite].z, &dx, &dy);
CheckSectorFloor(overridesect, pSprite->z, &dx, &dy);
}
/*
The game masks off the top 16 bits of the return value.
*/
nRet |= clipmove_old(&sprite[nSprite].x, &sprite[nSprite].y, &sprite[nSprite].z, &nSector, dx, dy, nClipDist, nSpriteHeight, flordist, clipmask) & 0xFFFF;
nRet |= (uint16_t)clipmove_old(&pSprite->x, &pSprite->y, &pSprite->z, &nSector, dx, dy, nClipDist, nSpriteHeight, flordist, clipmask);
if ((nSector != sprite[nSprite].sectnum) && nSector >= 0)
if ((nSector != pSprite->sectnum) && nSector >= 0)
{
if (nRet & 0x20000) {
dz = 0;
@ -566,16 +536,16 @@ int movesprite(short nSprite, int dx, int dy, int dz, int ceildist, int flordist
if ((sector[nSector].floorz - z) < (dz + flordist))
{
sprite[nSprite].x = x;
sprite[nSprite].y = y;
pSprite->x = x;
pSprite->y = y;
}
else
{
mychangespritesect(nSprite, nSector);
if (sprite[nSprite].pal < 5 && !sprite[nSprite].hitag)
if (pSprite->pal < 5 && !pSprite->hitag)
{
sprite[nSprite].pal = sector[sprite[nSprite].sectnum].ceilingpal;
pSprite->pal = sector[pSprite->sectnum].ceilingpal;
}
}
}
@ -1237,7 +1207,7 @@ int AngleChase(int nSprite, int nSprite2, int ebx, int ecx, int push1)
int GetWallNormal(short nWall)
{
nWall &= 0x1FFF;
nWall &= kMaxWalls-1;
int nWall2 = wall[nWall].point2;