teambeef/raze
0
0
Fork 0
mirror of https://github.com/DrBeef/Raze.git synced 2024-12-15 07:01:21 +00:00
Code Issues Projects Releases Packages Wiki Activity
raze/source/games/duke/src/sectors_r.cpp

2389 lines
68 KiB
C++
Raw Normal View History

- the beginning of sector.cpp The math backend functions have been moved out of Build because they originally have a good license. # Conflicts: # source/build/src/mdsprite.cpp # source/build/src/polymost.cpp
2020-05-10 10:42:47 +00:00
//-------------------------------------------------------------------------
/*
Copyright (C) 1996, 2003 - 3D Realms Entertainment
Copyright (C) 2017-2019 Nuke.YKT
This file is part of Duke Nukem 3D version 1.5 - Atomic Edition
Duke Nukem 3D is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Original Source: 1996 - Todd Replogle
Prepared for public release: 03/21/2003 - Charlie Wiederhold, 3D Realms
*/
//-------------------------------------------------------------------------
#include "ns.h"
#include "global.h"
#include "sounds_common.h"
#include "names_rr.h"
// PRIMITIVE
BEGIN_DUKE_NS
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
bool isadoorwall_r(int dapic)
{
switch(dapic)
{
case DOORTILE1:
case DOORTILE2:
case DOORTILE3:
case DOORTILE4:
case DOORTILE5:
case DOORTILE6:
case DOORTILE7:
case DOORTILE8:
case DOORTILE9:
case DOORTILE10:
case DOORTILE11:
case DOORTILE12:
case DOORTILE14:
case DOORTILE15:
case DOORTILE16:
case DOORTILE17:
case DOORTILE18:
case DOORTILE19:
case DOORTILE20:
case DOORTILE21:
case DOORTILE22:
case RRTILE1856:
case RRTILE1877:
return 1;
}
return 0;
}
bool isablockdoor(int dapic)
{
switch (dapic)
{
case RRTILE1792:
case RRTILE1801:
case RRTILE1805:
case RRTILE1807:
case RRTILE1808:
case RRTILE1812:
case RRTILE1821:
case RRTILE1826:
case RRTILE1850:
case RRTILE1851:
case RRTILE1856:
case RRTILE1877:
case RRTILE1938:
case RRTILE1942:
case RRTILE1944:
case RRTILE1945:
case RRTILE1951:
case RRTILE1961:
case RRTILE1964:
case RRTILE1985:
case RRTILE1995:
case RRTILE2022:
case RRTILE2052:
case RRTILE2053:
case RRTILE2060:
case RRTILE2074:
case RRTILE2132:
case RRTILE2136:
case RRTILE2139:
case RRTILE2150:
case RRTILE2178:
case RRTILE2186:
case RRTILE2319:
case RRTILE2321:
case RRTILE2326:
case RRTILE2329:
case RRTILE2578:
case RRTILE2581:
case RRTILE2610:
case RRTILE2613:
case RRTILE2621:
case RRTILE2622:
case RRTILE2676:
case RRTILE2732:
case RRTILE2831:
case RRTILE2832:
case RRTILE2842:
case RRTILE2940:
case RRTILE2970:
case RRTILE3083:
case RRTILE3100:
case RRTILE3155:
case RRTILE3195:
case RRTILE3232:
case RRTILE3600:
case RRTILE3631:
case RRTILE3635:
case RRTILE3637:
case RRTILE3643+2:
case RRTILE3643+3:
case RRTILE3647:
case RRTILE3652:
case RRTILE3653:
case RRTILE3671:
case RRTILE3673:
case RRTILE3684:
case RRTILE3708:
case RRTILE3714:
case RRTILE3716:
case RRTILE3723:
case RRTILE3725:
case RRTILE3737:
case RRTILE3754:
case RRTILE3762:
case RRTILE3763:
case RRTILE3764:
case RRTILE3765:
case RRTILE3767:
case RRTILE3793:
case RRTILE3814:
case RRTILE3815:
case RRTILE3819:
case RRTILE3827:
case RRTILE3837:
return true;
case RRTILE1996:
case RRTILE2382:
case RRTILE2961:
case RRTILE3804:
case RRTILE7430:
case RRTILE7467:
case RRTILE7469:
case RRTILE7470:
case RRTILE7475:
case RRTILE7566:
case RRTILE7576:
case RRTILE7716:
case RRTILE8063:
case RRTILE8067:
case RRTILE8076:
case RRTILE8106:
case RRTILE8379:
case RRTILE8380:
case RRTILE8565:
case RRTILE8605:
return isRRRA();
}
return false;
}
20% of sector.cpp # Conflicts: # source/games/duke/src/zz_sector.cpp
2020-05-10 14:53:09 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void animatewalls_r(void)
{
int i, j, p, t;
if (isRRRA() &&ps[screenpeek].sea_sick_stat == 1)
{
for (i = 0; i < MAXWALLS; i++)
{
if (wall[i].picnum == RRTILE7873)
wall[i].xpanning += 6;
else if (wall[i].picnum == RRTILE7870)
wall[i].xpanning += 6;
}
}
for (p = 0; p < numanimwalls; p++)
{
i = animwall[p].wallnum;
j = wall[i].picnum;
switch (j)
{
case SCREENBREAK1:
case SCREENBREAK2:
case SCREENBREAK3:
case SCREENBREAK4:
case SCREENBREAK5:
case SCREENBREAK9:
case SCREENBREAK10:
case SCREENBREAK11:
case SCREENBREAK12:
case SCREENBREAK13:
if ((krand() & 255) < 16)
{
animwall[p].tag = wall[i].picnum;
wall[i].picnum = SCREENBREAK6;
}
continue;
case SCREENBREAK6:
case SCREENBREAK7:
case SCREENBREAK8:
if (animwall[p].tag >= 0)
wall[i].picnum = animwall[p].tag;
else
{
wall[i].picnum++;
if (wall[i].picnum == (SCREENBREAK6 + 3))
wall[i].picnum = SCREENBREAK6;
}
continue;
}
if (wall[i].cstat & 16)
switch (wall[i].overpicnum)
{
case W_FORCEFIELD:
case W_FORCEFIELD + 1:
case W_FORCEFIELD + 2:
t = animwall[p].tag;
- the beginning of sector.cpp The math backend functions have been moved out of Build because they originally have a good license. # Conflicts: # source/build/src/mdsprite.cpp # source/build/src/polymost.cpp
2020-05-10 10:42:47 +00:00
20% of sector.cpp # Conflicts: # source/games/duke/src/zz_sector.cpp
2020-05-10 14:53:09 +00:00
if (wall[i].cstat & 254)
{
wall[i].xpanning -= t >> 10; // sintable[(t+512)&2047]>>12;
wall[i].ypanning -= t >> 10; // sintable[t&2047]>>12;
if (wall[i].extra == 1)
{
wall[i].extra = 0;
animwall[p].tag = 0;
}
else
animwall[p].tag += 128;
if (animwall[p].tag < (128 << 4))
{
if (animwall[p].tag & 128)
wall[i].overpicnum = W_FORCEFIELD;
else wall[i].overpicnum = W_FORCEFIELD + 1;
}
else
{
if ((krand() & 255) < 32)
animwall[p].tag = 128 << (krand() & 3);
else wall[i].overpicnum = W_FORCEFIELD + 1;
}
}
break;
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void operaterespawns_r(int low)
{
short i, j, nexti;
i = headspritestat[11];
while (i >= 0)
{
nexti = nextspritestat[i];
if (sprite[i].lotag == low) switch (sprite[i].picnum)
{
case RESPAWN:
if (badguypic(sprite[i].hitag) && ud.monsters_off) break;
j = spawn(i, TRANSPORTERSTAR);
sprite[j].z -= (32 << 8);
sprite[i].extra = 66 - 12; // Just a way to killit
break;
case RRTILE7424:
if (isRRRA() && !ud.monsters_off)
changespritestat(i, 119);
break;
}
i = nexti;
}
}
- the beginning of sector.cpp The math backend functions have been moved out of Build because they originally have a good license. # Conflicts: # source/build/src/mdsprite.cpp # source/build/src/polymost.cpp
2020-05-10 10:42:47 +00:00
checkhitswitch intentionally not merged because this is too messy.
2020-05-10 16:05:36 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void operateforcefields_r(int s, int low)
{
operateforcefields_common(s, low, { BIGFORCE });
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
bool checkhitswitch_r(int snum, int w, int switchtype)
{
char switchpal;
short i, x, lotag, hitag, picnum, correctdips, numdips;
int sx, sy;
if (w < 0) return 0;
correctdips = 1;
numdips = 0;
if (switchtype == 1) // A wall sprite
{
lotag = sprite[w].lotag; if (lotag == 0) return 0;
hitag = sprite[w].hitag;
sx = sprite[w].x;
sy = sprite[w].y;
picnum = sprite[w].picnum;
switchpal = sprite[w].pal;
}
else
{
lotag = wall[w].lotag; if (lotag == 0) return 0;
hitag = wall[w].hitag;
sx = wall[w].x;
sy = wall[w].y;
picnum = wall[w].picnum;
switchpal = wall[w].pal;
}
switch (picnum)
{
case DIPSWITCH:
case DIPSWITCH + 1:
case TECHSWITCH:
case TECHSWITCH + 1:
case ALIENSWITCH:
case ALIENSWITCH + 1:
break;
case ACCESSSWITCH:
case ACCESSSWITCH2:
if (ps[snum].access_incs == 0)
{
if (switchpal == 0)
{
if (ps[snum].keys[1])
ps[snum].access_incs = 1;
else
{
FTA(70, &ps[snum]);
if (isRRRA()) spritesound(99, w);
}
}
else if (switchpal == 21)
{
if (ps[snum].keys[2])
ps[snum].access_incs = 1;
else
{
FTA(71, &ps[snum]);
if (isRRRA()) spritesound(99, w);
}
}
else if (switchpal == 23)
{
if (ps[snum].keys[3])
ps[snum].access_incs = 1;
else
{
FTA(72, &ps[snum]);
if (isRRRA()) spritesound(99, w);
}
}
if (ps[snum].access_incs == 1)
{
if (switchtype == 0)
ps[snum].access_wallnum = w;
else
ps[snum].access_spritenum = w;
}
return 0;
}
case MULTISWITCH2:
case MULTISWITCH2 + 1:
case MULTISWITCH2 + 2:
case MULTISWITCH2 + 3:
case RRTILE8464:
case RRTILE8660:
if (isRRRA()) break;
case DIPSWITCH2:
case DIPSWITCH2 + 1:
case DIPSWITCH3:
case DIPSWITCH3 + 1:
case MULTISWITCH:
case MULTISWITCH + 1:
case MULTISWITCH + 2:
case MULTISWITCH + 3:
case PULLSWITCH:
case PULLSWITCH + 1:
case HANDSWITCH:
case HANDSWITCH + 1:
case SLOTDOOR:
case SLOTDOOR + 1:
case LIGHTSWITCH:
case LIGHTSWITCH + 1:
case SPACELIGHTSWITCH:
case SPACELIGHTSWITCH + 1:
case SPACEDOORSWITCH:
case SPACEDOORSWITCH + 1:
case FRANKENSTINESWITCH:
case FRANKENSTINESWITCH + 1:
case LIGHTSWITCH2:
case LIGHTSWITCH2 + 1:
case POWERSWITCH1:
case POWERSWITCH1 + 1:
case LOCKSWITCH1:
case LOCKSWITCH1 + 1:
case POWERSWITCH2:
case POWERSWITCH2 + 1:
case NUKEBUTTON:
case NUKEBUTTON + 1:
case RRTILE2214:
case RRTILE2697:
case RRTILE2697 + 1:
case RRTILE2707:
case RRTILE2707 + 1:
if (check_activator_motion(lotag)) return 0;
break;
default:
if (isadoorwall(picnum) == 0) return 0;
break;
}
i = headspritestat[0];
while (i >= 0)
{
if (lotag == sprite[i].lotag) switch (sprite[i].picnum)
{
case DIPSWITCH:
case TECHSWITCH:
case ALIENSWITCH:
if (switchtype == 1 && w == i) sprite[i].picnum++;
else if (sprite[i].hitag == 0) correctdips++;
numdips++;
break;
case TECHSWITCH + 1:
case DIPSWITCH + 1:
case ALIENSWITCH + 1:
if (switchtype == 1 && w == i) sprite[i].picnum--;
else if (sprite[i].hitag == 1) correctdips++;
numdips++;
break;
case MULTISWITCH:
case MULTISWITCH + 1:
case MULTISWITCH + 2:
case MULTISWITCH + 3:
sprite[i].picnum++;
if (sprite[i].picnum > (MULTISWITCH + 3))
sprite[i].picnum = MULTISWITCH;
break;
case MULTISWITCH2:
case MULTISWITCH2 + 1:
case MULTISWITCH2 + 2:
case MULTISWITCH2 + 3:
if (!isRRRA()) break;
sprite[i].picnum++;
if (sprite[i].picnum > (MULTISWITCH2 + 3))
sprite[i].picnum = MULTISWITCH2;
break;
case RRTILE2214:
if (ud.level_number > 6)
ud.level_number = 0;
sprite[i].picnum++;
break;
case RRTILE8660:
if (!isRRRA()) break;
case ACCESSSWITCH:
case ACCESSSWITCH2:
case SLOTDOOR:
case LIGHTSWITCH:
case SPACELIGHTSWITCH:
case SPACEDOORSWITCH:
case FRANKENSTINESWITCH:
case LIGHTSWITCH2:
case POWERSWITCH1:
case LOCKSWITCH1:
case POWERSWITCH2:
case HANDSWITCH:
case PULLSWITCH:
case DIPSWITCH2:
case DIPSWITCH3:
case NUKEBUTTON:
case RRTILE2697:
case RRTILE2707:
if (sprite[i].picnum == DIPSWITCH3)
if (sprite[i].hitag == 999)
{
short j, nextj;
j = headspritestat[107];
while (j >= 0)
{
nextj = nextspritestat[j];
if (sprite[j].picnum == RRTILE3410)
{
sprite[j].picnum++;
sprite[j].hitag = 100;
sprite[j].extra = 0;
spritesound(474, j);
}
else if (sprite[j].picnum == RRTILE295)
deletesprite(j);
j = nextj;
}
sprite[i].picnum++;
break;
}
if (sprite[i].picnum == NUKEBUTTON)
chickenplant = 0;
if (sprite[i].picnum == RRTILE8660)
{
BellTime = 132;
word_119BE0 = i;
}
sprite[i].picnum++;
break;
case PULLSWITCH + 1:
case HANDSWITCH + 1:
case LIGHTSWITCH2 + 1:
case POWERSWITCH1 + 1:
case LOCKSWITCH1 + 1:
case POWERSWITCH2 + 1:
case SLOTDOOR + 1:
case LIGHTSWITCH + 1:
case SPACELIGHTSWITCH + 1:
case SPACEDOORSWITCH + 1:
case FRANKENSTINESWITCH + 1:
case DIPSWITCH2 + 1:
case DIPSWITCH3 + 1:
case NUKEBUTTON + 1:
case RRTILE2697 + 1:
case RRTILE2707 + 1:
if (sprite[i].picnum == NUKEBUTTON + 1)
chickenplant = 1;
if (sprite[i].hitag != 999)
sprite[i].picnum--;
break;
}
i = nextspritestat[i];
}
for (i = 0; i < numwalls; i++)
{
x = i;
if (lotag == wall[x].lotag)
switch (wall[x].picnum)
{
case DIPSWITCH:
case TECHSWITCH:
case ALIENSWITCH:
if (switchtype == 0 && i == w) wall[x].picnum++;
else if (wall[x].hitag == 0) correctdips++;
numdips++;
break;
case DIPSWITCH + 1:
case TECHSWITCH + 1:
case ALIENSWITCH + 1:
if (switchtype == 0 && i == w) wall[x].picnum--;
else if (wall[x].hitag == 1) correctdips++;
numdips++;
break;
case MULTISWITCH:
case MULTISWITCH + 1:
case MULTISWITCH + 2:
case MULTISWITCH + 3:
wall[x].picnum++;
if (wall[x].picnum > (MULTISWITCH + 3))
wall[x].picnum = MULTISWITCH;
break;
case MULTISWITCH2:
case MULTISWITCH2 + 1:
case MULTISWITCH2 + 2:
case MULTISWITCH2 + 3:
if (!isRRRA()) break;
wall[x].picnum++;
if (wall[x].picnum > (MULTISWITCH2 + 3))
wall[x].picnum = MULTISWITCH2;
break;
case RRTILE8660:
if (!isRRRA()) break;
case ACCESSSWITCH:
case ACCESSSWITCH2:
case SLOTDOOR:
case LIGHTSWITCH:
case SPACELIGHTSWITCH:
case SPACEDOORSWITCH:
case LIGHTSWITCH2:
case POWERSWITCH1:
case LOCKSWITCH1:
case POWERSWITCH2:
case PULLSWITCH:
case HANDSWITCH:
case DIPSWITCH2:
case DIPSWITCH3:
case RRTILE2697:
case RRTILE2707:
wall[x].picnum++;
break;
case HANDSWITCH + 1:
case PULLSWITCH + 1:
case LIGHTSWITCH2 + 1:
case POWERSWITCH1 + 1:
case LOCKSWITCH1 + 1:
case POWERSWITCH2 + 1:
case SLOTDOOR + 1:
case LIGHTSWITCH + 1:
case SPACELIGHTSWITCH + 1:
case SPACEDOORSWITCH + 1:
case DIPSWITCH2 + 1:
case DIPSWITCH3 + 1:
case RRTILE2697 + 1:
case RRTILE2707 + 1:
wall[x].picnum--;
break;
}
}
if (lotag == (short)65535)
{
ps[myconnectindex].gm = MODE_EOL;
if (ud.from_bonus)
{
ud.level_number = ud.from_bonus;
ud.m_level_number = ud.level_number;
ud.from_bonus = 0;
}
else
{
// fixme: This needs to be taken from the level definitions.
if (isRRRA() && ud.level_number == 6 && ud.volume_number == 0)
g_RAendEpisode = 1; // hack to force advancing to episode 2.
ud.level_number = (++ud.level_number < MAXLEVELS) ? ud.level_number : 0;
ud.m_level_number = ud.level_number;
}
}
vec3_t v = { sx, sy, ps[snum].posz };
switch (picnum)
{
default:
if (isadoorwall(picnum) == 0) break;
case DIPSWITCH:
case DIPSWITCH + 1:
case TECHSWITCH:
case TECHSWITCH + 1:
case ALIENSWITCH:
case ALIENSWITCH + 1:
if (picnum == DIPSWITCH || picnum == DIPSWITCH + 1 ||
picnum == ALIENSWITCH || picnum == ALIENSWITCH + 1 ||
picnum == TECHSWITCH || picnum == TECHSWITCH + 1)
{
if (picnum == ALIENSWITCH || picnum == ALIENSWITCH + 1)
{
if (switchtype == SWITCH_SPRITE)
S_PlaySound3D(ALIEN_SWITCH1, w, &v);
else S_PlaySound3D(ALIEN_SWITCH1, ps[snum].i, &v);
}
else
{
if (switchtype == SWITCH_SPRITE)
S_PlaySound3D(SWITCH_ON, w, &v);
else S_PlaySound3D(SWITCH_ON, ps[snum].i, &v);
}
if (numdips != correctdips) break;
S_PlaySound3D(END_OF_LEVEL_WARN, ps[snum].i, &v);
}
case MULTISWITCH2:
case MULTISWITCH2 + 1:
case MULTISWITCH2 + 2:
case MULTISWITCH2 + 3:
case RRTILE8464:
case RRTILE8660:
if (!isRRRA()) break;
case DIPSWITCH2:
case DIPSWITCH2 + 1:
case DIPSWITCH3:
case DIPSWITCH3 + 1:
case MULTISWITCH:
case MULTISWITCH + 1:
case MULTISWITCH + 2:
case MULTISWITCH + 3:
case ACCESSSWITCH:
case ACCESSSWITCH2:
case SLOTDOOR:
case SLOTDOOR + 1:
case LIGHTSWITCH:
case LIGHTSWITCH + 1:
case SPACELIGHTSWITCH:
case SPACELIGHTSWITCH + 1:
case SPACEDOORSWITCH:
case SPACEDOORSWITCH + 1:
case FRANKENSTINESWITCH:
case FRANKENSTINESWITCH + 1:
case LIGHTSWITCH2:
case LIGHTSWITCH2 + 1:
case POWERSWITCH1:
case POWERSWITCH1 + 1:
case LOCKSWITCH1:
case LOCKSWITCH1 + 1:
case POWERSWITCH2:
case POWERSWITCH2 + 1:
case HANDSWITCH:
case HANDSWITCH + 1:
case PULLSWITCH:
case PULLSWITCH + 1:
case RRTILE2697:
case RRTILE2697 + 1:
case RRTILE2707:
case RRTILE2707 + 1:
if (isRRRA())
{
if (picnum == RRTILE8660)
{
BellTime = 132;
word_119BE0 = w;
sprite[w].picnum++;
}
else if (picnum == RRTILE8464)
{
sprite[w].picnum = sprite[w].picnum + 1;
if (hitag == 10001)
{
if (ps[snum].SeaSick == 0)
ps[snum].SeaSick = 350;
operateactivators(668, ps[snum].i);
operatemasterswitches(668);
spritesound(328, ps[snum].i);
return 1;
}
}
else if (hitag == 10000)
{
if (picnum == MULTISWITCH || picnum == (MULTISWITCH + 1) ||
picnum == (MULTISWITCH + 2) || picnum == (MULTISWITCH + 3) ||
picnum == MULTISWITCH2 || picnum == (MULTISWITCH2 + 1) ||
picnum == (MULTISWITCH2 + 2) || picnum == (MULTISWITCH2 + 3))
{
int var6c[3], var54, j;
short jpn, jht;
var54 = 0;
S_PlaySound3D(SWITCH_ON, w, &v);
for (j = 0; j < MAXSPRITES; j++)
{
jpn = sprite[j].picnum;
jht = sprite[j].hitag;
if ((jpn == MULTISWITCH || jpn == MULTISWITCH2) && jht == 10000)
{
if (var54 < 3)
{
var6c[var54] = j;
var54++;
}
}
}
if (var54 == 3)
{
S_PlaySound3D(78, w, &v);
for (j = 0; j < var54; j++)
{
sprite[var6c[j]].hitag = 0;
if (picnum >= MULTISWITCH2)
sprite[var6c[j]].picnum = MULTISWITCH2 + 3;
else
sprite[var6c[j]].picnum = MULTISWITCH + 3;
checkhitswitch_r(snum, var6c[j], 1);
}
}
return 1;
}
}
}
if (picnum == MULTISWITCH || picnum == (MULTISWITCH + 1) ||
picnum == (MULTISWITCH + 2) || picnum == (MULTISWITCH + 3))
lotag += picnum - MULTISWITCH;
if (isRRRA())
{
if (picnum == MULTISWITCH2 || picnum == (MULTISWITCH2 + 1) ||
picnum == (MULTISWITCH2 + 2) || picnum == (MULTISWITCH2 + 3))
lotag += picnum - MULTISWITCH2;
}
x = headspritestat[3];
while (x >= 0)
{
if (((sprite[x].hitag) == lotag))
{
switch (sprite[x].lotag)
{
case 46:
case 47:
case 48:
if (!isRRRA()) break;
case 12:
sector[sprite[x].sectnum].floorpal = 0;
hittype[x].temp_data[0]++;
if (hittype[x].temp_data[0] == 2)
hittype[x].temp_data[0]++;
break;
case 24:
case 34:
case 25:
hittype[x].temp_data[4] = !hittype[x].temp_data[4];
if (hittype[x].temp_data[4])
FTA(15, &ps[snum]);
else FTA(2, &ps[snum]);
break;
case 21:
FTA(2, &ps[screenpeek]);
break;
}
}
x = nextspritestat[x];
}
operateactivators(lotag, snum);
operateforcefields(ps[snum].i, lotag);
operatemasterswitches(lotag);
if (picnum == DIPSWITCH || picnum == DIPSWITCH + 1 ||
picnum == ALIENSWITCH || picnum == ALIENSWITCH + 1 ||
picnum == TECHSWITCH || picnum == TECHSWITCH + 1) return 1;
if (hitag == 0 && isadoorwall(picnum) == 0)
{
if (switchtype == SWITCH_SPRITE)
S_PlaySound3D(SWITCH_ON, w, &v);
else S_PlaySound3D(SWITCH_ON, ps[snum].i, &v);
}
else if (hitag != 0)
{
auto flags = S_GetUserFlags(hitag);
if (switchtype == SWITCH_SPRITE && (flags & SF_TALK) == 0)
S_PlaySound3D(hitag, w, &v);
else
A_PlaySound(hitag, ps[snum].i);
}
return 1;
}
return 0;
}
- the beginning of sector.cpp The math backend functions have been moved out of Build because they originally have a good license. # Conflicts: # source/build/src/mdsprite.cpp # source/build/src/polymost.cpp
2020-05-10 10:42:47 +00:00
- more sector stuff.
2020-05-10 18:59:38 +00:00
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void activatebysector_r(int sect, int j)
{
short i;
i = headspritesect[sect];
while (i >= 0)
{
if (sprite[i].picnum == ACTIVATOR)
{
operateactivators(sprite[i].lotag, -1);
// return;
}
i = nextspritesect[i];
}
if (sector[sect].lotag != 22)
operatesectors(sect, j);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void checkhitwall_r(int spr, int dawallnum, int x, int y, int z, int atwith)
{
short j, i, sn = -1, darkestwall;
walltype* wal;
spritetype* s;
wal = &wall[dawallnum];
if (wal->overpicnum == MIRROR)
{
switch (atwith)
{
case RPG2:
if (!isRRRA()) break;
case HEAVYHBOMB:
case RADIUSEXPLOSION:
case RPG:
case HYDRENT:
case SEENINE:
case OOZFILTER:
case EXPLODINGBARREL:
lotsofglass(spr, dawallnum, 70);
wal->cstat &= ~16;
wal->overpicnum = MIRRORBROKE;
spritesound(GLASS_HEAVYBREAK, spr);
return;
}
}
if (((wal->cstat & 16) || wal->overpicnum == BIGFORCE) && wal->nextsector >= 0)
if (sector[wal->nextsector].floorz > z)
if (sector[wal->nextsector].floorz - sector[wal->nextsector].ceilingz)
switch (wal->overpicnum)
{
case FANSPRITE:
wal->overpicnum = FANSPRITEBROKE;
wal->cstat &= 65535 - 65;
if (wal->nextwall >= 0)
{
wall[wal->nextwall].overpicnum = FANSPRITEBROKE;
wall[wal->nextwall].cstat &= 65535 - 65;
}
spritesound(VENT_BUST, spr);
spritesound(GLASS_BREAKING, spr);
return;
case RRTILE1973:
updatesector(x, y, &sn); if (sn < 0) return;
wal->overpicnum = GLASS2;
lotsofpopcorn(spr, dawallnum, 64);
wal->cstat = 0;
if (wal->nextwall >= 0)
wall[wal->nextwall].cstat = 0;
i = EGS(sn, x, y, z, SECTOREFFECTOR, 0, 0, 0, ps[0].getang(), 0, 0, spr, 3);
sprite[i].lotag = 128; hittype[i].temp_data[1] = 2; hittype[i].temp_data[2] = dawallnum;
spritesound(GLASS_BREAKING, i);
return;
case GLASS:
updatesector(x, y, &sn); if (sn < 0) return;
wal->overpicnum = GLASS2;
lotsofglass(spr, dawallnum, 10);
wal->cstat = 0;
if (wal->nextwall >= 0)
wall[wal->nextwall].cstat = 0;
i = EGS(sn, x, y, z, SECTOREFFECTOR, 0, 0, 0, ps[0].getang(), 0, 0, spr, 3);
sprite[i].lotag = 128; hittype[i].temp_data[1] = 2; hittype[i].temp_data[2] = dawallnum;
spritesound(GLASS_BREAKING, i);
return;
case STAINGLASS1:
updatesector(x, y, &sn); if (sn < 0) return;
lotsofcolourglass(spr, dawallnum, 80);
wal->cstat = 0;
if (wal->nextwall >= 0)
wall[wal->nextwall].cstat = 0;
spritesound(VENT_BUST, spr);
spritesound(GLASS_BREAKING, spr);
return;
}
switch (wal->picnum)
{
case RRTILE8464:
if (isRRRA()) break;
break;
case RRTILE3643:
case RRTILE3643 + 1:
case RRTILE3643 + 2:
case RRTILE3643 + 3:
{
short sect;
short unk = 0;
short jj;
short nextjj;
short startwall, endwall;
sect = wall[wal->nextwall].nextsector;
jj = headspritesect[sect];
while (jj != -1)
{
nextjj = nextspritesect[jj];
s = &sprite[jj];
if (s->lotag == 6)
{
for (j = 0; j < 16; j++) RANDOMSCRAP(s, i);
g_spriteExtra[jj]++;
if (g_spriteExtra[jj] == 25)
{
startwall = sector[s->sectnum].wallptr;
endwall = startwall + sector[s->sectnum].wallnum;
for (i = startwall; i < endwall; i++)
sector[wall[i].nextsector].lotag = 0;
sector[s->sectnum].lotag = 0;
stopsound(sprite[jj].lotag);
spritesound(400, jj);
deletesprite(jj);
}
}
jj = nextjj;
}
return;
}
case RRTILE7555:
if (!isRRRA()) break;
wal->picnum = SBMOVE;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE7441:
if (!isRRRA()) break;
wal->picnum = RRTILE5016;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE7559:
if (!isRRRA()) break;
wal->picnum = RRTILE5017;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE7433:
if (!isRRRA()) break;
wal->picnum = RRTILE5018;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE7557:
if (!isRRRA()) break;
wal->picnum = RRTILE5019;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE7553:
if (!isRRRA()) break;
wal->picnum = RRTILE5020;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE7552:
if (!isRRRA()) break;
wal->picnum = RRTILE5021;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE7568:
if (!isRRRA()) break;
wal->picnum = RRTILE5022;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE7540:
if (!isRRRA()) break;
wal->picnum = RRTILE5023;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE7558:
if (!isRRRA()) break;
wal->picnum = RRTILE5024;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE7554:
if (!isRRRA()) break;
wal->picnum = RRTILE5025;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE7579:
if (!isRRRA()) break;
wal->picnum = RRTILE5026;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE7561:
if (!isRRRA()) break;
wal->picnum = RRTILE5027;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE7580:
if (!isRRRA()) break;
wal->picnum = RRTILE5037;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE8227:
if (!isRRRA()) break;
wal->picnum = RRTILE5070;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE8503:
if (!isRRRA()) break;
wal->picnum = RRTILE5079;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE8567:
case RRTILE8568:
case RRTILE8569:
case RRTILE8570:
case RRTILE8571:
if (!isRRRA()) break;
wal->picnum = RRTILE5082;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE7859:
if (!isRRRA()) break;
wal->picnum = RRTILE5081;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE8496:
if (!isRRRA()) break;
wal->picnum = RRTILE5061;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE8617:
if (!isRRRA()) break;
if (numplayers < 2)
{
wal->picnum = RRTILE8618;
spritesound(47, spr);
}
return;
case RRTILE8620:
if (!isRRRA()) break;
wal->picnum = RRTILE8621;
spritesound(47, spr);
return;
case RRTILE8622:
if (!isRRRA()) break;
wal->picnum = RRTILE8623;
spritesound(495, spr);
return;
case RRTILE7657:
if (!isRRRA()) break;
wal->picnum = RRTILE7659;
spritesound(GLASS_HEAVYBREAK, spr);
return;
case RRTILE8497:
if (!isRRRA()) break;
wal->picnum = RRTILE5076;
spritesound(495, spr);
return;
case RRTILE7533:
if (!isRRRA()) break;
wal->picnum = RRTILE5035;
spritesound(495, spr);
return;
case COLAMACHINE:
case VENDMACHINE:
breakwall(wal->picnum + 2, spr, dawallnum);
spritesound(GLASS_BREAKING, spr);
return;
case OJ:
case SCREENBREAK6:
case SCREENBREAK7:
case SCREENBREAK8:
lotsofglass(spr, dawallnum, 30);
wal->picnum = W_SCREENBREAK + (krand() % (isRRRA() ? 2 : 3));
spritesound(GLASS_HEAVYBREAK, spr);
return;
case ATM:
wal->picnum = ATMBROKE;
lotsofmoney(&sprite[spr], 1 + (krand() & 7));
spritesound(GLASS_HEAVYBREAK, spr);
break;
case WALLLIGHT1:
case WALLLIGHT3:
case WALLLIGHT4:
case TECHLIGHT2:
case TECHLIGHT4:
case RRTILE1814:
case RRTILE1939:
case RRTILE1986:
case RRTILE1988:
case RRTILE2123:
case RRTILE2125:
case RRTILE2636:
case RRTILE2878:
case RRTILE2898:
case RRTILE3200:
case RRTILE3202:
case RRTILE3204:
case RRTILE3206:
case RRTILE3208:
if (rnd(128))
spritesound(GLASS_HEAVYBREAK, spr);
else spritesound(GLASS_BREAKING, spr);
lotsofglass(spr, dawallnum, 30);
if (wal->picnum == RRTILE1814)
wal->picnum = RRTILE1817;
if (wal->picnum == RRTILE1986)
wal->picnum = RRTILE1987;
if (wal->picnum == RRTILE1939)
wal->picnum = RRTILE2004;
if (wal->picnum == RRTILE1988)
wal->picnum = RRTILE2005;
if (wal->picnum == RRTILE2898)
wal->picnum = RRTILE2899;
if (wal->picnum == RRTILE2878)
wal->picnum = RRTILE2879;
if (wal->picnum == RRTILE2123)
wal->picnum = RRTILE2124;
if (wal->picnum == RRTILE2125)
wal->picnum = RRTILE2126;
if (wal->picnum == RRTILE3200)
wal->picnum = RRTILE3201;
if (wal->picnum == RRTILE3202)
wal->picnum = RRTILE3203;
if (wal->picnum == RRTILE3204)
wal->picnum = RRTILE3205;
if (wal->picnum == RRTILE3206)
wal->picnum = RRTILE3207;
if (wal->picnum == RRTILE3208)
wal->picnum = RRTILE3209;
if (wal->picnum == RRTILE2636)
wal->picnum = RRTILE2637;
if (wal->picnum == WALLLIGHT1)
wal->picnum = WALLLIGHTBUST1;
if (wal->picnum == WALLLIGHT3)
wal->picnum = WALLLIGHTBUST3;
if (wal->picnum == WALLLIGHT4)
wal->picnum = WALLLIGHTBUST4;
if (wal->picnum == TECHLIGHT2)
wal->picnum = TECHLIGHTBUST2;
if (wal->picnum == TECHLIGHT4)
wal->picnum = TECHLIGHTBUST4;
if (!wal->lotag) return;
sn = wal->nextsector;
if (sn < 0) return;
darkestwall = 0;
wal = &wall[sector[sn].wallptr];
for (i = sector[sn].wallnum; i > 0; i--, wal++)
if (wal->shade > darkestwall)
darkestwall = wal->shade;
j = krand() & 1;
i = headspritestat[3];
while (i >= 0)
{
if (sprite[i].hitag == wall[dawallnum].lotag && sprite[i].lotag == 3)
{
hittype[i].temp_data[2] = j;
hittype[i].temp_data[3] = darkestwall;
hittype[i].temp_data[4] = 1;
}
i = nextspritestat[i];
}
break;
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void checkplayerhurt_r(struct player_struct* p, int j)
{
if ((j & 49152) == 49152)
{
j &= (MAXSPRITES - 1);
switch (sprite[j].picnum)
{
case RRTILE2430:
case RRTILE2431:
case RRTILE2432:
case RRTILE2443:
case RRTILE2446:
case RRTILE2451:
case RRTILE2455:
if (isRRRA() && p->hurt_delay2 < 8)
{
sprite[p->i].extra -= 2;
p->hurt_delay2 = 16;
SetPlayerPal(p, PalEntry(32, 32, 0, 0));
spritesound(DUKE_LONGTERM_PAIN, p->i);
}
break;
case CACTUS:
if (!isRRRA() && p->hurt_delay < 8)
{
sprite[p->i].extra -= 5;
p->hurt_delay = 16;
SetPlayerPal(p, PalEntry(32, 32, 0, 0));
spritesound(DUKE_LONGTERM_PAIN, p->i);
}
break;
}
return;
}
if ((j & 49152) != 32768) return;
j &= (MAXWALLS - 1);
if (p->hurt_delay > 0) p->hurt_delay--;
else if (wall[j].cstat & 85) switch (wall[j].overpicnum)
{
case BIGFORCE:
p->hurt_delay = 26;
checkhitwall(p->i, j,
p->posx + (sintable[(p->getang() + 512) & 2047] >> 9),
p->posy + (sintable[p->getang() & 2047] >> 9),
p->posz, -1);
break;
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
bool checkhitceiling_r(int sn)
{
short i, j;
switch (sector[sn].ceilingpicnum)
{
case WALLLIGHT1:
case WALLLIGHT3:
case WALLLIGHT4:
case TECHLIGHT2:
case TECHLIGHT4:
case RRTILE1939:
case RRTILE1986:
case RRTILE1988:
case RRTILE2123:
case RRTILE2125:
case RRTILE2878:
case RRTILE2898:
ceilingglass(ps[myconnectindex].i, sn, 10);
spritesound(GLASS_BREAKING, ps[screenpeek].i);
if (sector[sn].ceilingpicnum == WALLLIGHT1)
sector[sn].ceilingpicnum = WALLLIGHTBUST1;
if (sector[sn].ceilingpicnum == WALLLIGHT3)
sector[sn].ceilingpicnum = WALLLIGHTBUST3;
if (sector[sn].ceilingpicnum == WALLLIGHT4)
sector[sn].ceilingpicnum = WALLLIGHTBUST4;
if (sector[sn].ceilingpicnum == TECHLIGHT2)
sector[sn].ceilingpicnum = TECHLIGHTBUST2;
if (sector[sn].ceilingpicnum == TECHLIGHT4)
sector[sn].ceilingpicnum = TECHLIGHTBUST4;
if (sector[sn].ceilingpicnum == RRTILE1986)
sector[sn].ceilingpicnum = RRTILE1987;
if (sector[sn].ceilingpicnum == RRTILE1939)
sector[sn].ceilingpicnum = RRTILE2004;
if (sector[sn].ceilingpicnum == RRTILE1988)
sector[sn].ceilingpicnum = RRTILE2005;
if (sector[sn].ceilingpicnum == RRTILE2898)
sector[sn].ceilingpicnum = RRTILE2899;
if (sector[sn].ceilingpicnum == RRTILE2878)
sector[sn].ceilingpicnum = RRTILE2879;
if (sector[sn].ceilingpicnum == RRTILE2123)
sector[sn].ceilingpicnum = RRTILE2124;
if (sector[sn].ceilingpicnum == RRTILE2125)
sector[sn].ceilingpicnum = RRTILE2126;
if (!sector[sn].hitag)
{
i = headspritesect[sn];
while (i >= 0)
{
if (sprite[i].picnum == SECTOREFFECTOR && (sprite[i].lotag == 12 || (isRRRA() && (sprite[i].lotag == 47 || sprite[i].lotag == 48))))
{
j = headspritestat[3];
while (j >= 0)
{
if (sprite[j].hitag == sprite[i].hitag)
hittype[j].temp_data[3] = 1;
j = nextspritestat[j];
}
break;
}
i = nextspritesect[i];
}
}
i = headspritestat[3];
j = krand() & 1;
while (i >= 0)
{
if (sprite[i].hitag == (sector[sn].hitag) && sprite[i].lotag == 3)
{
hittype[i].temp_data[2] = j;
hittype[i].temp_data[4] = 1;
}
i = nextspritestat[i];
}
return 1;
}
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void checkhitsprite_r(int i, int sn)
{
int j, k, p;
spritetype* s;
i &= (MAXSPRITES - 1);
if (isRRRA()) switch (sprite[i].picnum)
{
case RRTILE8464:
break;
case RRTILE8487:
case RRTILE8489:
spritesound(471, i);
sprite[i].picnum++;
break;
case RRTILE7638:
case RRTILE7644:
case RRTILE7646:
case RRTILE7650:
case RRTILE7653:
case RRTILE7655:
case RRTILE7691:
case RRTILE7876:
case RRTILE7881:
case RRTILE7883:
sprite[i].picnum++;
spritesound(VENT_BUST, i);
break;
case RRTILE7879:
sprite[i].picnum++;
spritesound(495, i);
hitradius(i, 10, 0, 0, 1, 1);
break;
case RRTILE7648:
case RRTILE7694:
case RRTILE7700:
case RRTILE7702:
case RRTILE7711:
sprite[i].picnum++;
spritesound(47, i);
break;
case RRTILE7636:
sprite[i].picnum += 3;
spritesound(VENT_BUST, i);
break;
case RRTILE7875:
sprite[i].picnum += 3;
spritesound(VENT_BUST, i);
break;
case RRTILE7640:
sprite[i].picnum += 2;
spritesound(VENT_BUST, i);
break;
case RRTILE7595:
case RRTILE7704:
sprite[i].picnum = RRTILE7705;
spritesound(495, i);
break;
case RRTILE8579:
sprite[i].picnum = RRTILE5014;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE7441:
sprite[i].picnum = RRTILE5016;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE7534:
sprite[i].picnum = RRTILE5029;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE7545:
sprite[i].picnum = RRTILE5030;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE7547:
sprite[i].picnum = RRTILE5031;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE7574:
sprite[i].picnum = RRTILE5032;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE7575:
sprite[i].picnum = RRTILE5033;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE7578:
sprite[i].picnum = RRTILE5034;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE7478:
sprite[i].picnum = RRTILE5035;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8525:
sprite[i].picnum = RRTILE5036;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8537:
sprite[i].picnum = RRTILE5062;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8215:
sprite[i].picnum = RRTILE5064;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8216:
sprite[i].picnum = RRTILE5065;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8217:
sprite[i].picnum = RRTILE5066;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8218:
sprite[i].picnum = RRTILE5067;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8220:
sprite[i].picnum = RRTILE5068;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8221:
sprite[i].picnum = RRTILE5069;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8312:
sprite[i].picnum = RRTILE5071;
spritesound(472, i);
break;
case RRTILE8395:
sprite[i].picnum = RRTILE5072;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8423:
sprite[i].picnum = RRTILE5073;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE3462:
sprite[i].picnum = RRTILE5074;
spritesound(GLASS_HEAVYBREAK, i);
break;
case UWHIP:
sprite[i].picnum = RRTILE5075;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8608:
sprite[i].picnum = RRTILE5083;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8609:
sprite[i].picnum = RRTILE5084;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8567:
case RRTILE8568:
case RRTILE8569:
case RRTILE8570:
case RRTILE8571:
sprite[i].picnum = RRTILE5082;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8640:
sprite[i].picnum = RRTILE5085;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8611:
sprite[i].picnum = RRTILE5086;
spritesound(GLASS_HEAVYBREAK, i);
break;
case TECHLIGHTBUST2:
sprite[i].picnum = TECHLIGHTBUST4;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8497:
sprite[i].picnum = RRTILE5076;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8162:
case RRTILE8163:
case RRTILE8164:
case RRTILE8165:
case RRTILE8166:
case RRTILE8167:
case RRTILE8168:
changespritestat(i, 5);
sprite[i].picnum = RRTILE5063;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8589:
case RRTILE8590:
case RRTILE8591:
case RRTILE8592:
case RRTILE8593:
case RRTILE8594:
case RRTILE8595:
changespritestat(i, 5);
sprite[i].picnum = RRTILE8588;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE3497:
sprite[i].picnum = RRTILE5076;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE3498:
sprite[i].picnum = RRTILE5077;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE3499:
sprite[i].picnum = RRTILE5078;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8503:
sprite[i].picnum = RRTILE5079;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE7901:
sprite[i].picnum = RRTILE5080;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE7696:
sprite[i].picnum = RRTILE7697;
spritesound(DUKE_SHUCKS, i);
break;
case RRTILE7806:
sprite[i].picnum = RRTILE5043;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE7885:
case RRTILE7890:
sprite[i].picnum = RRTILE5045;
spritesound(495, i);
hitradius(i, 10, 0, 0, 1, 1);
break;
case RRTILE7886:
sprite[i].picnum = RRTILE5046;
spritesound(495, i);
hitradius(i, 10, 0, 0, 1, 1);
break;
case RRTILE7887:
sprite[i].picnum = RRTILE5044;
spritesound(GLASS_HEAVYBREAK, i);
hitradius(i, 10, 0, 0, 1, 1);
break;
case RRTILE7900:
sprite[i].picnum = RRTILE5047;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE7906:
sprite[i].picnum = RRTILE5048;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE7912:
case RRTILE7913:
sprite[i].picnum = RRTILE5049;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8047:
sprite[i].picnum = RRTILE5050;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8596:
sprite[i].picnum = RRTILE8598;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8059:
sprite[i].picnum = RRTILE5051;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8060:
sprite[i].picnum = RRTILE5052;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8222:
sprite[i].picnum = RRTILE5053;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8223:
sprite[i].picnum = RRTILE5054;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8224:
sprite[i].picnum = RRTILE5055;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8370:
sprite[i].picnum = RRTILE5056;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8371:
sprite[i].picnum = RRTILE5057;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8372:
sprite[i].picnum = RRTILE5058;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8373:
sprite[i].picnum = RRTILE5059;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8396:
sprite[i].picnum = RRTILE5038;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8397:
sprite[i].picnum = RRTILE5039;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8398:
sprite[i].picnum = RRTILE5040;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8399:
sprite[i].picnum = RRTILE5041;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8385:
sprite[i].picnum = RRTILE8386;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8387:
sprite[i].picnum = RRTILE8388;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8389:
sprite[i].picnum = RRTILE8390;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8391:
sprite[i].picnum = RRTILE8392;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE7553:
sprite[i].picnum = RRTILE5035;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8475:
sprite[i].picnum = RRTILE5075;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8498:
sprite[i].picnum = RRTILE5077;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8499:
sprite[i].picnum = RRTILE5078;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE2445:
sprite[i].picnum = RRTILE2450;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE2123:
sprite[i].picnum = RRTILE2124;
spritesound(GLASS_BREAKING, i);
lotsofglass(i, -1, 10);
break;
case RRTILE3773:
sprite[i].picnum = RRTILE8651;
spritesound(GLASS_BREAKING, i);
lotsofglass(i, -1, 10);
break;
case RRTILE7533:
sprite[i].picnum = RRTILE5035;
spritesound(495, i);
hitradius(i, 10, 0, 0, 1, 1);
break;
case RRTILE8394:
sprite[i].picnum = RRTILE5072;
spritesound(495, i);
break;
case RRTILE8461:
case RRTILE8462:
sprite[i].picnum = RRTILE5074;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8679:
sprite[i].picnum = RRTILE8680;
spritesound(DUKE_SHUCKS, i);
hitradius(i, 10, 0, 0, 1, 1);
if (sprite[i].lotag != 0)
{
short j;
for (j = 0; j < MAXSPRITES; j++)
{
if (sprite[j].picnum == RRTILE8679 && sprite[j].pal == 4)
{
if (sprite[j].lotag == sprite[i].lotag)
sprite[j].picnum = RRTILE8680;
}
}
}
break;
case RRTILE3584:
sprite[i].picnum = RRTILE8681;
spritesound(495, i);
hitradius(i, 250, 0, 0, 1, 1);
break;
case RRTILE8682:
sprite[i].picnum = RRTILE8683;
spritesound(GLASS_HEAVYBREAK, i);
break;
case RRTILE8099:
if (sprite[i].lotag == 5)
{
short j;
sprite[i].lotag = 0;
sprite[i].picnum = RRTILE5087;
spritesound(340, i);
for (j = 0; j < MAXSPRITES; j++)
{
if (sprite[j].picnum == RRTILE8094)
sprite[j].picnum = RRTILE5088;
}
}
break;
case RRTILE2431:
if (sprite[i].pal != 4)
{
sprite[i].picnum = RRTILE2451;
if (sprite[i].lotag != 0)
{
short j;
for (j = 0; j < MAXSPRITES; j++)
{
if (sprite[j].picnum == RRTILE2431 && sprite[j].pal == 4)
{
if (sprite[i].lotag == sprite[j].lotag)
sprite[j].picnum = RRTILE2451;
}
}
}
}
break;
case RRTILE2443:
if (sprite[i].pal != 19)
sprite[i].picnum = RRTILE2455;
break;
case RRTILE2455:
spritesound(SQUISHED, i);
guts(&sprite[i], RRTILE2465, 3, myconnectindex);
deletesprite(i);
break;
case RRTILE2451:
if (sprite[i].pal != 4)
{
spritesound(SQUISHED, i);
if (sprite[i].lotag != 0)
{
short j;
for (j = 0; j < MAXSPRITES; j++)
{
if (sprite[j].picnum == RRTILE2451 && sprite[j].pal == 4)
{
if (sprite[i].lotag == sprite[j].lotag)
{
guts(&sprite[i], RRTILE2460, 12, myconnectindex);
guts(&sprite[i], RRTILE2465, 3, myconnectindex);
sprite[j].xrepeat = 0;
sprite[j].yrepeat = 0;
sprite[i].xrepeat = 0;
sprite[i].yrepeat = 0;
}
}
}
}
else
{
guts(&sprite[i], RRTILE2460, 12, myconnectindex);
guts(&sprite[i], RRTILE2465, 3, myconnectindex);
sprite[i].xrepeat = 0;
sprite[i].yrepeat = 0;
}
}
break;
case RRTILE2437:
spritesound(439, i);
break;
}
switch (sprite[i].picnum)
{
case RRTILE3114:
sprite[i].picnum = RRTILE3117;
break;
case RRTILE2876:
sprite[i].picnum = RRTILE2990;
break;
case RRTILE3152:
sprite[i].picnum = RRTILE3218;
break;
case RRTILE3153:
sprite[i].picnum = RRTILE3219;
break;
case RRTILE2030:
sprite[i].picnum = RRTILE2034;
spritesound(GLASS_BREAKING, i);
lotsofglass(i, -1, 10);
break;
case RRTILE2893:
case RRTILE2915:
case RRTILE3115:
case RRTILE3171:
switch (sprite[i].picnum)
{
case RRTILE2915:
sprite[i].picnum = RRTILE2977;
break;
case RRTILE2893:
sprite[i].picnum = RRTILE2978;
break;
case RRTILE3115:
sprite[i].picnum = RRTILE3116;
break;
case RRTILE3171:
sprite[i].picnum = RRTILE3216;
break;
}
spritesound(GLASS_BREAKING, i);
lotsofglass(i, -1, 10);
break;
case RRTILE2156:
case RRTILE2158:
case RRTILE2160:
case RRTILE2175:
sprite[i].picnum++;
spritesound(GLASS_BREAKING, i);
lotsofglass(i, -1, 10);
break;
case RRTILE2137:
case RRTILE2151:
case RRTILE2152:
spritesound(GLASS_BREAKING, i);
lotsofglass(i, -1, 10);
sprite[i].picnum++;
for (k = 0; k < 6; k++)
EGS(sprite[i].sectnum, sprite[i].x, sprite[i].y, sprite[i].z - (8 << 8), SCRAP6 + (krand() & 15), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (sprite[i].zvel >> 2), i, 5);
break;
case BOWLINGBALL:
sprite[sn].xvel = (sprite[i].xvel >> 1) + (sprite[i].xvel >> 2);
sprite[sn].ang -= (krand() & 16);
spritesound(355, i);
break;
case STRIPEBALL:
case QUEBALL:
case RRTILE3440:
case RRTILE3440 + 1:
case HENSTAND:
case HENSTAND + 1:
if (sprite[sn].picnum == QUEBALL || sprite[sn].picnum == STRIPEBALL)
{
sprite[sn].xvel = (sprite[i].xvel >> 1) + (sprite[i].xvel >> 2);
sprite[sn].ang -= (sprite[i].ang << 1) + 1024;
sprite[i].ang = getangle(sprite[i].x - sprite[sn].x, sprite[i].y - sprite[sn].y) - 512;
if (S_CheckSoundPlaying(POOLBALLHIT) < 2)
spritesound(POOLBALLHIT, i);
}
else if (sprite[sn].picnum == RRTILE3440 || sprite[sn].picnum == RRTILE3440 + 1)
{
sprite[sn].xvel = (sprite[i].xvel >> 1) + (sprite[i].xvel >> 2);
sprite[sn].ang -= ((sprite[i].ang << 1) + krand()) & 64;
sprite[i].ang = (sprite[i].ang + krand()) & 16;
spritesound(355, i);
}
else if (sprite[sn].picnum == HENSTAND || sprite[sn].picnum == HENSTAND + 1)
{
sprite[sn].xvel = (sprite[i].xvel >> 1) + (sprite[i].xvel >> 2);
sprite[sn].ang -= ((sprite[i].ang << 1) + krand()) & 16;
sprite[i].ang = (sprite[i].ang + krand()) & 16;
spritesound(355, i);
}
else
{
if (krand() & 3)
{
sprite[i].xvel = 164;
sprite[i].ang = sprite[sn].ang;
}
}
break;
case TREE1:
case TREE2:
case TIRE:
case BOX:
switch (sprite[sn].picnum)
{
case RPG2:
if (!isRRRA()) break;
case RADIUSEXPLOSION:
case RPG:
case FIRELASER:
case HYDRENT:
case HEAVYHBOMB:
case TRIPBOMBSPRITE:
case COOLEXPLOSION1:
case OWHIP:
case UWHIP:
if (hittype[i].temp_data[0] == 0)
{
sprite[i].cstat &= ~257;
hittype[i].temp_data[0] = 1;
spawn(i, BURNING);
}
break;
}
break;
case CACTUS:
// case CACTUSBROKE:
switch (sprite[sn].picnum)
{
case RPG2:
if (!isRRRA()) break;
case RADIUSEXPLOSION:
case RPG:
case FIRELASER:
case HYDRENT:
case HEAVYHBOMB:
case TRIPBOMBSPRITE:
case COOLEXPLOSION1:
case OWHIP:
case UWHIP:
for (k = 0; k < 64; k++)
{
j = EGS(sprite[i].sectnum, sprite[i].x, sprite[i].y, sprite[i].z - (krand() % (48 << 8)), SCRAP6 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (sprite[i].zvel >> 2), i, 5);
sprite[j].pal = 8;
}
if (sprite[i].picnum == CACTUS)
sprite[i].picnum = CACTUSBROKE;
sprite[i].cstat &= ~257;
// else deletesprite(i);
break;
}
break;
case FANSPRITE:
sprite[i].picnum = FANSPRITEBROKE;
sprite[i].cstat &= (65535 - 257);
spritesound(GLASS_HEAVYBREAK, i);
s = &sprite[i];
for (j = 0; j < 16; j++) RANDOMSCRAP(s, i);
break;
case WATERFOUNTAIN:
case WATERFOUNTAIN + 1:
case WATERFOUNTAIN + 2:
case WATERFOUNTAIN + 3:
spawn(i, TOILETWATER);
break;
case SATELITE:
case FUELPOD:
case SOLARPANNEL:
case ANTENNA:
if (sprite[sn].extra != G_DefaultActorHealth(SHOTSPARK1)) // TRANSITIONAL - fix after getting rid of EDUKE cruft
{
for (j = 0; j < 15; j++)
EGS(sprite[i].sectnum, sprite[i].x, sprite[i].y, sector[sprite[i].sectnum].floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
krand() & 2047, (krand() & 127) + 64, -(krand() & 511) - 256, i, 5);
spawn(i, EXPLOSION2);
deletesprite(i);
}
break;
case RRTILE1824:
if (!isRRRA()) break;
case BOTTLE1:
case BOTTLE2:
case BOTTLE3:
case BOTTLE4:
case BOTTLE5:
case BOTTLE6:
case BOTTLE8:
case BOTTLE10:
case BOTTLE11:
case BOTTLE12:
case BOTTLE13:
case BOTTLE14:
case BOTTLE15:
case BOTTLE16:
case BOTTLE17:
case BOTTLE18:
case BOTTLE19:
case DOMELITE:
case SUSHIPLATE1:
case SUSHIPLATE2:
case SUSHIPLATE3:
case SUSHIPLATE4:
case SUSHIPLATE5:
case WAITTOBESEATED:
case VASE:
case STATUEFLASH:
case STATUE:
if (sprite[i].picnum == BOTTLE10)
lotsofmoney(&sprite[i], 4 + (krand() & 3));
else if (sprite[i].picnum == STATUE || sprite[i].picnum == STATUEFLASH)
{
lotsofcolourglass(i, -1, 40);
spritesound(GLASS_HEAVYBREAK, i);
}
else if (sprite[i].picnum == VASE)
lotsofglass(i, -1, 40);
spritesound(GLASS_BREAKING, i);
sprite[i].ang = krand() & 2047;
lotsofglass(i, -1, 8);
deletesprite(i);
break;
case RRTILE2654:
case RRTILE2656:
case RRTILE3172:
if (!isRRRA()) break;
case BOTTLE7:
spritesound(GLASS_BREAKING, i);
lotsofglass(i, -1, 10);
deletesprite(i);
break;
case FORCESPHERE:
sprite[i].xrepeat = 0;
hittype[sprite[i].owner].temp_data[0] = 32;
hittype[sprite[i].owner].temp_data[1] = !hittype[sprite[i].owner].temp_data[1];
hittype[sprite[i].owner].temp_data[2] ++;
spawn(i, EXPLOSION2);
break;
case TOILET:
sprite[i].picnum = TOILETBROKE;
sprite[i].cstat |= (krand() & 1) << 2;
sprite[i].cstat &= ~257;
spawn(i, TOILETWATER);
spritesound(GLASS_BREAKING, i);
break;
case STALL:
sprite[i].picnum = STALLBROKE;
sprite[i].cstat |= (krand() & 1) << 2;
sprite[i].cstat &= ~257;
spawn(i, TOILETWATER);
spritesound(GLASS_HEAVYBREAK, i);
break;
case HYDRENT:
sprite[i].picnum = BROKEFIREHYDRENT;
spawn(i, TOILETWATER);
// for(k=0;k<5;k++)
// {
// j = EGS(sprite[i].sectnum,sprite[i].x,sprite[i].y,sprite[i].z-(krand()%(48<<8)),SCRAP3+(krand()&3),-8,48,48,krand()&2047,(krand()&63)+64,-(krand()&4095)-(sprite[i].zvel>>2),i,5);
// sprite[j].pal = 2;
// }
spritesound(GLASS_HEAVYBREAK, i);
break;
case GRATE1:
sprite[i].picnum = BGRATE1;
sprite[i].cstat &= (65535 - 256 - 1);
spritesound(VENT_BUST, i);
break;
case CIRCLEPANNEL:
sprite[i].picnum = CIRCLEPANNELBROKE;
sprite[i].cstat &= (65535 - 256 - 1);
spritesound(VENT_BUST, i);
break;
case PIPE1:
case PIPE2:
case PIPE3:
case PIPE4:
case PIPE5:
case PIPE6:
switch (sprite[i].picnum)
{
case PIPE1:sprite[i].picnum = PIPE1B; break;
case PIPE2:sprite[i].picnum = PIPE2B; break;
case PIPE3:sprite[i].picnum = PIPE3B; break;
case PIPE4:sprite[i].picnum = PIPE4B; break;
case PIPE5:sprite[i].picnum = PIPE5B; break;
case PIPE6:sprite[i].picnum = PIPE6B; break;
}
j = spawn(i, STEAM);
sprite[j].z = sector[sprite[i].sectnum].floorz - (32 << 8);
break;
case CHAIR1:
case CHAIR2:
sprite[i].picnum = BROKENCHAIR;
sprite[i].cstat = 0;
break;
case CHAIR3:
case MOVIECAMERA:
case SCALE:
case VACUUM:
case CAMERALIGHT:
case IVUNIT:
case POT1:
case POT2:
case POT3:
spritesound(GLASS_HEAVYBREAK, i);
s = &sprite[i];
for (j = 0; j < 16; j++) RANDOMSCRAP(s, i);
deletesprite(i);
break;
case PLAYERONWATER:
i = sprite[i].owner;
default:
if ((sprite[i].cstat & 16) && sprite[i].hitag == 0 && sprite[i].lotag == 0 && sprite[i].statnum == 0)
break;
if ((sprite[sn].picnum == SHRINKSPARK || sprite[sn].picnum == FREEZEBLAST || sprite[sn].owner != i) && sprite[i].statnum != 4)
{
if (badguy(&sprite[i]) == 1)
{
if (sprite[sn].picnum == RPG) sprite[sn].extra <<= 1;
else if (isRRRA() && sprite[sn].picnum == RPG2) sprite[sn].extra <<= 1;
if ((sprite[i].picnum != DRONE))
if (sprite[sn].picnum != FREEZEBLAST)
//if (actortype[sprite[i].picnum] == 0) //TRANSITIONAL. Cannot be done right with EDuke mess backing the engine.
{
j = spawn(sn, JIBS6);
if (sprite[sn].pal == 6)
sprite[j].pal = 6;
sprite[j].z += (4 << 8);
sprite[j].xvel = 16;
sprite[j].xrepeat = sprite[j].yrepeat = 24;
sprite[j].ang += 32 - (krand() & 63);
}
j = sprite[sn].owner;
if (j >= 0 && sprite[j].picnum == APLAYER && sprite[i].picnum != DRONE)
if (ps[sprite[j].yvel].curr_weapon == SHOTGUN_WEAPON)
{
shoot(i, BLOODSPLAT3);
shoot(i, BLOODSPLAT1);
shoot(i, BLOODSPLAT2);
shoot(i, BLOODSPLAT4);
}
if (sprite[i].statnum == 2)
{
changespritestat(i, 1);
hittype[i].timetosleep = SLEEPTIME;
}
}
if (sprite[i].statnum != 2)
{
if (sprite[sn].picnum == FREEZEBLAST && ((sprite[i].picnum == APLAYER && sprite[i].pal == 1) || (freezerhurtowner == 0 && sprite[sn].owner == i)))
return;
hittype[i].picnum = sprite[sn].picnum;
hittype[i].extra += sprite[sn].extra;
if (sprite[i].picnum != COW)
hittype[i].ang = sprite[sn].ang;
hittype[i].owner = sprite[sn].owner;
}
if (sprite[i].statnum == 10)
{
p = sprite[i].yvel;
if (ps[p].newowner >= 0)
{
ps[p].newowner = -1;
ps[p].posx = ps[p].oposx;
ps[p].posy = ps[p].oposy;
ps[p].posz = ps[p].oposz;
ps[p].q16ang = ps[p].oq16ang;
updatesector(ps[p].posx, ps[p].posy, &ps[p].cursectnum);
setpal(&ps[p]);
j = headspritestat[1];
while (j >= 0)
{
if (sprite[j].picnum == CAMERA1) sprite[j].yvel = 0;
j = nextspritestat[j];
}
}
if (sprite[hittype[i].owner].picnum != APLAYER)
if (ud.player_skill >= 3)
sprite[sn].extra += (sprite[sn].extra >> 1);
}
}
break;
}
}
- the beginning of sector.cpp The math backend functions have been moved out of Build because they originally have a good license. # Conflicts: # source/build/src/mdsprite.cpp # source/build/src/polymost.cpp
2020-05-10 10:42:47 +00:00
END_DUKE_NS
Reference in a new issue Copy permalink