2020-05-20 20:18:03 +00:00
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
/*
|
|
|
|
Copyright (C) 1996, 2003 - 3D Realms Entertainment
|
|
|
|
Copyright (C) 2017-2019 Nuke.YKT
|
2020-06-28 07:03:31 +00:00
|
|
|
Copyright (C) 2020 - Christoph Oelckers
|
2020-05-20 20:18:03 +00:00
|
|
|
|
|
|
|
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"
|
2020-07-03 21:56:14 +00:00
|
|
|
#include "names_r.h"
|
2020-07-07 15:56:20 +00:00
|
|
|
#include "mapinfo.h"
|
2020-10-21 17:14:41 +00:00
|
|
|
#include "dukeactor.h"
|
2021-04-11 07:59:55 +00:00
|
|
|
#include "precache.h"
|
2020-05-20 20:18:03 +00:00
|
|
|
|
|
|
|
BEGIN_DUKE_NS
|
|
|
|
|
2020-05-21 09:41:48 +00:00
|
|
|
void addjaildoor(int p1, int p2, int iht, int jlt, int p3, int h);
|
|
|
|
void addminecart(int p1, int p2, int i, int iht, int p3, int childsectnum);
|
|
|
|
void addtorch(int i);
|
|
|
|
void addlightning(int i);
|
|
|
|
|
|
|
|
|
2020-05-20 20:18:03 +00:00
|
|
|
static inline void tloadtile(int tilenum, int palnum = 0)
|
|
|
|
{
|
|
|
|
markTileForPrecache(tilenum, palnum);
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-10-28 05:30:41 +00:00
|
|
|
static void cachespritenum(spritetype *spr)
|
2020-05-20 20:18:03 +00:00
|
|
|
{
|
2020-07-20 21:21:27 +00:00
|
|
|
char maxc;
|
|
|
|
short j;
|
2020-10-28 05:30:41 +00:00
|
|
|
int pal = spr->pal;
|
2020-07-20 21:21:27 +00:00
|
|
|
|
2020-10-28 05:30:41 +00:00
|
|
|
if (ud.monsters_off && badguy(spr)) return;
|
2020-07-20 21:21:27 +00:00
|
|
|
|
|
|
|
maxc = 1;
|
|
|
|
|
2020-10-28 05:30:41 +00:00
|
|
|
switch (spr->picnum)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
|
|
|
case HYDRENT:
|
|
|
|
tloadtile(BROKEFIREHYDRENT);
|
|
|
|
for (j = TOILETWATER; j < (TOILETWATER + 4); j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
break;
|
|
|
|
case RRTILE2121:
|
|
|
|
case RRTILE2122:
|
2020-10-28 05:30:41 +00:00
|
|
|
tloadtile(spr->picnum, pal);
|
2020-07-20 21:21:27 +00:00
|
|
|
break;
|
|
|
|
case TOILET:
|
|
|
|
tloadtile(TOILETBROKE);
|
|
|
|
for (j = TOILETWATER; j < (TOILETWATER + 4); j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
break;
|
|
|
|
case STALL:
|
|
|
|
tloadtile(STALLBROKE);
|
|
|
|
for (j = TOILETWATER; j < (TOILETWATER + 4); j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
break;
|
|
|
|
case FORCERIPPLE:
|
|
|
|
maxc = 9;
|
|
|
|
break;
|
|
|
|
case RUBBERCAN:
|
|
|
|
maxc = 2;
|
|
|
|
break;
|
|
|
|
case TOILETWATER:
|
|
|
|
maxc = 4;
|
|
|
|
break;
|
|
|
|
case BUBBASTAND:
|
|
|
|
for (j = BUBBASCRATCH; j <= (BUBBASCRATCH + 47); j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
break;
|
|
|
|
case SBSWIPE:
|
|
|
|
if (isRRRA())
|
|
|
|
for (j = SBSWIPE; j <= (SBSWIPE + 29); j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case COOT:
|
|
|
|
for (j = COOT; j <= (COOT + 217); j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
for (j = COOTJIBA; j < COOTJIBC + 4; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
break;
|
|
|
|
case LTH:
|
|
|
|
maxc = 105;
|
|
|
|
for (j = LTH; j < (LTH + maxc); j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
break;
|
|
|
|
case BILLYRAY:
|
|
|
|
maxc = 144;
|
|
|
|
for (j = BILLYWALK; j < (BILLYWALK + maxc); j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
for (j = BILLYJIBA; j <= BILLYJIBB + 4; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
break;
|
|
|
|
case COW:
|
|
|
|
maxc = 56;
|
2020-10-28 05:30:41 +00:00
|
|
|
for (j = spr->picnum; j < (spr->picnum + maxc); j++)
|
2020-07-20 21:21:27 +00:00
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
break;
|
|
|
|
case DOGRUN:
|
|
|
|
for (j = DOGATTACK; j <= DOGATTACK + 35; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
for (j = DOGRUN; j <= DOGRUN + 80; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
break;
|
|
|
|
case RABBIT:
|
|
|
|
if (isRRRA())
|
|
|
|
{
|
|
|
|
for (j = RABBIT; j <= RABBIT + 54; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
for (j = RABBIT + 56; j <= RABBIT + 56 + 49; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
for (j = RABBIT + 56; j <= RABBIT + 56 + 49; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case BIKERB:
|
|
|
|
case BIKERBV2:
|
|
|
|
if (isRRRA())
|
|
|
|
{
|
|
|
|
for (j = BIKERB; j <= BIKERB + 104; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case BIKER:
|
|
|
|
if (isRRRA())
|
|
|
|
{
|
|
|
|
for (j = BIKER; j <= BIKER + 116; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
for (j = BIKER + 150; j <= BIKER + 150 + 104; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CHEER:
|
|
|
|
if (isRRRA())
|
|
|
|
{
|
|
|
|
for (j = CHEER; j <= CHEER + 44; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
for (j = CHEER + 47; j <= CHEER + 47 + 211; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
for (j = CHEER + 262; j <= CHEER + 262 + 72; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CHEERB:
|
|
|
|
if (isRRRA())
|
|
|
|
{
|
|
|
|
for (j = CHEERB; j <= CHEERB + 83; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
for (j = CHEERB + 157; j <= CHEERB + 157 + 83; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case MAMA:
|
|
|
|
if (isRRRA())
|
|
|
|
{
|
|
|
|
for (j = MAMA; j <= MAMA + 78; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
for (j = MAMA + 80; j <= MAMA + 80 + 7; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
for (j = MAMA + 90; j <= MAMA + 90 + 94; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CHEERBOAT:
|
|
|
|
if (isRRRA())
|
|
|
|
{
|
|
|
|
tloadtile(CHEERBOAT);
|
|
|
|
maxc = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case HULKBOAT:
|
|
|
|
if (isRRRA())
|
|
|
|
{
|
|
|
|
tloadtile(HULKBOAT);
|
|
|
|
maxc = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case MINIONBOAT:
|
|
|
|
if (isRRRA())
|
|
|
|
{
|
|
|
|
tloadtile(MINIONBOAT);
|
|
|
|
maxc = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case BILLYPLAY:
|
|
|
|
if (isRRRA())
|
|
|
|
{
|
|
|
|
for (j = BILLYPLAY; j <= BILLYPLAY + 2; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case COOTPLAY:
|
|
|
|
if (isRRRA())
|
|
|
|
{
|
|
|
|
for (j = COOTPLAY; j <= COOTPLAY + 4; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PIG:
|
|
|
|
case PIGSTAYPUT:
|
|
|
|
maxc = 68;
|
|
|
|
break;
|
|
|
|
case TORNADO:
|
|
|
|
maxc = 7;
|
|
|
|
break;
|
|
|
|
case HEN:
|
|
|
|
case HENSTAND:
|
|
|
|
maxc = 34;
|
|
|
|
break;
|
|
|
|
case APLAYER:
|
|
|
|
maxc = 0;
|
|
|
|
if (ud.multimode > 1)
|
|
|
|
{
|
|
|
|
maxc = 5;
|
|
|
|
for (j = APLAYER; j < APLAYER + 220; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
for (j = DUKEGUN; j < DUKELEG + 4; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ATOMICHEALTH:
|
|
|
|
maxc = 14;
|
|
|
|
break;
|
|
|
|
case DRONE:
|
|
|
|
maxc = 6;
|
|
|
|
break;
|
|
|
|
case EXPLODINGBARREL:
|
|
|
|
case SEENINE:
|
|
|
|
case OOZFILTER:
|
|
|
|
maxc = 3;
|
|
|
|
break;
|
|
|
|
case NUKEBARREL:
|
|
|
|
case CAMERA1:
|
|
|
|
maxc = 5;
|
|
|
|
break;
|
|
|
|
case VIXEN:
|
|
|
|
maxc = 214;
|
2020-10-28 05:30:41 +00:00
|
|
|
for (j = spr->picnum; j < spr->picnum + maxc; j++)
|
2020-07-20 21:21:27 +00:00
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
break;
|
|
|
|
case SBMOVE:
|
|
|
|
if (!isRRRA())
|
|
|
|
{
|
|
|
|
|
|
|
|
maxc = 54;
|
2020-10-28 05:30:41 +00:00
|
|
|
for (j = spr->picnum; j < spr->picnum + maxc; j++)
|
2020-07-20 21:21:27 +00:00
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 100;
|
|
|
|
for (j = SBMOVE; j < SBMOVE + maxc; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case HULK:
|
|
|
|
maxc = 40;
|
2020-10-28 05:30:41 +00:00
|
|
|
for (j = spr->picnum - 41; j < spr->picnum + maxc - 41; j++)
|
2020-07-20 21:21:27 +00:00
|
|
|
tloadtile(j, pal);
|
|
|
|
for (j = HULKJIBA; j <= HULKJIBC + 4; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
break;
|
|
|
|
case MINION:
|
|
|
|
maxc = 141;
|
2020-10-28 05:30:41 +00:00
|
|
|
for (j = spr->picnum; j < spr->picnum + maxc; j++)
|
2020-07-20 21:21:27 +00:00
|
|
|
tloadtile(j, pal);
|
|
|
|
for (j = MINJIBA; j <= MINJIBC + 4; j++)
|
|
|
|
tloadtile(j, pal);
|
|
|
|
maxc = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2020-10-28 05:30:41 +00:00
|
|
|
for (j = spr->picnum; j < (spr->picnum + maxc); j++)
|
2020-07-20 21:21:27 +00:00
|
|
|
tloadtile(j, pal);
|
2020-05-20 20:18:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
static void cachegoodsprites(void)
|
|
|
|
{
|
2020-07-20 21:21:27 +00:00
|
|
|
short i;
|
|
|
|
|
|
|
|
tloadtile(BOTTOMSTATUSBAR);
|
|
|
|
if (ud.multimode > 1)
|
|
|
|
{
|
|
|
|
tloadtile(FRAGBAR);
|
|
|
|
}
|
|
|
|
|
|
|
|
//tloadtile(VIEWSCREEN);
|
|
|
|
|
|
|
|
for (i = FOOTPRINTS; i < FOOTPRINTS + 3; i++)
|
|
|
|
tloadtile(i);
|
|
|
|
|
|
|
|
for (i = BURNING; i < BURNING + 14; i++)
|
|
|
|
tloadtile(i);
|
|
|
|
|
|
|
|
for (i = FIRSTGUN; i < FIRSTGUN + 10; i++)
|
|
|
|
tloadtile(i);
|
|
|
|
|
|
|
|
for (i = EXPLOSION2; i < EXPLOSION2 + 21; i++)
|
|
|
|
tloadtile(i);
|
|
|
|
|
|
|
|
tloadtile(BULLETHOLE);
|
|
|
|
|
|
|
|
for (i = SHOTGUN; i < SHOTGUN + 8; i++)
|
|
|
|
tloadtile(i);
|
|
|
|
|
|
|
|
tloadtile(FOOTPRINTS);
|
|
|
|
|
|
|
|
for (i = JIBS1; i < (JIBS5 + 5); i++)
|
|
|
|
tloadtile(i);
|
|
|
|
|
|
|
|
for (i = SCRAP1; i < (SCRAP1 + 19); i++)
|
|
|
|
tloadtile(i);
|
|
|
|
|
|
|
|
for (i = SMALLSMOKE; i < (SMALLSMOKE + 4); i++)
|
|
|
|
tloadtile(i);
|
|
|
|
|
2020-05-20 20:18:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-20 20:48:54 +00:00
|
|
|
void cacheit_r(void)
|
2020-05-20 20:18:03 +00:00
|
|
|
{
|
2021-04-28 20:23:48 +00:00
|
|
|
if (!r_precache) return;
|
2020-10-28 05:30:41 +00:00
|
|
|
int i;
|
2020-07-20 21:21:27 +00:00
|
|
|
|
|
|
|
cachegoodsprites();
|
|
|
|
|
|
|
|
for(i=0;i<numwalls;i++)
|
|
|
|
{
|
|
|
|
tloadtile(wall[i].picnum, wall[i].pal);
|
|
|
|
if(wall[i].overpicnum >= 0)
|
|
|
|
tloadtile(wall[i].overpicnum, wall[i].pal);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < numsectors; i++)
|
|
|
|
{
|
|
|
|
tloadtile(sector[i].floorpicnum, sector[i].floorpal);
|
|
|
|
tloadtile(sector[i].ceilingpicnum, sector[i].ceilingpal);
|
|
|
|
if (sector[i].ceilingpicnum == LA)
|
|
|
|
{
|
|
|
|
tloadtile(LA + 1);
|
|
|
|
tloadtile(LA + 2);
|
|
|
|
}
|
|
|
|
|
2020-10-28 05:30:41 +00:00
|
|
|
DukeSectIterator it(i);
|
|
|
|
while (auto j = it.Next())
|
|
|
|
{
|
2021-04-15 17:21:43 +00:00
|
|
|
if(j->s->xrepeat != 0 && j->s->yrepeat != 0 && (j->s->cstat&32768) == 0)
|
|
|
|
cachespritenum(j->s);
|
2020-10-28 05:30:41 +00:00
|
|
|
}
|
2020-07-20 21:21:27 +00:00
|
|
|
}
|
|
|
|
precacheMarkedTiles();
|
2020-05-20 20:18:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
|
2020-05-21 09:41:48 +00:00
|
|
|
void prelevel_r(int g)
|
2020-05-20 20:18:03 +00:00
|
|
|
{
|
2020-07-20 21:21:27 +00:00
|
|
|
struct player_struct* p;
|
|
|
|
short i;
|
|
|
|
short j;
|
|
|
|
short startwall;
|
|
|
|
short endwall;
|
|
|
|
short lotaglist;
|
|
|
|
short lotags[65];
|
|
|
|
int speed;
|
|
|
|
int dist;
|
|
|
|
short sound;
|
|
|
|
sound = 0;
|
|
|
|
|
|
|
|
prelevel_common(g);
|
|
|
|
p = &ps[screenpeek];
|
|
|
|
|
2021-05-02 12:01:10 +00:00
|
|
|
if (currentLevel->gameflags & LEVEL_RR_CLEARMOONSHINE)
|
|
|
|
ps[myconnectindex].steroids_amount = 0;
|
2020-07-20 21:21:27 +00:00
|
|
|
|
|
|
|
if (isRRRA())
|
|
|
|
{
|
|
|
|
|
|
|
|
for (j = 0; j < MAXSPRITES; j++)
|
|
|
|
{
|
2020-10-28 05:37:17 +00:00
|
|
|
auto spr = &sprite[j];
|
|
|
|
if (spr->pal == 100)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
|
|
|
if (numplayers > 1)
|
|
|
|
deletesprite(j);
|
|
|
|
else
|
2020-10-28 05:37:17 +00:00
|
|
|
spr->pal = 0;
|
2020-07-20 21:21:27 +00:00
|
|
|
}
|
2020-10-28 05:37:17 +00:00
|
|
|
else if (spr->pal == 101)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2020-10-28 05:37:17 +00:00
|
|
|
spr->extra = 0;
|
|
|
|
spr->hitag = 1;
|
|
|
|
spr->pal = 0;
|
2020-07-20 21:21:27 +00:00
|
|
|
changespritestat(j, 118);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < numsectors; i++)
|
|
|
|
{
|
|
|
|
if (sector[i].ceilingpicnum == RRTILE2577)
|
|
|
|
thunderon = 1;
|
|
|
|
|
|
|
|
switch (sector[i].lotag)
|
|
|
|
{
|
|
|
|
case 41:
|
2020-10-14 19:16:54 +00:00
|
|
|
{
|
2020-10-28 05:37:17 +00:00
|
|
|
DukeSectIterator it(i);
|
|
|
|
while (auto act = it.Next())
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2021-04-15 17:21:43 +00:00
|
|
|
auto spr = act->s;
|
2020-10-28 05:37:17 +00:00
|
|
|
if (spr->picnum == RRTILE11)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2020-10-28 05:37:17 +00:00
|
|
|
dist = spr->lotag << 4;
|
|
|
|
speed = spr->hitag;
|
|
|
|
deletesprite(act);
|
2020-07-20 21:21:27 +00:00
|
|
|
}
|
2020-10-28 05:37:17 +00:00
|
|
|
if (spr->picnum == RRTILE38)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2020-10-28 05:37:17 +00:00
|
|
|
sound = spr->lotag;
|
|
|
|
deletesprite(act);
|
2020-07-20 21:21:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
for (j = 0; j < numsectors; j++)
|
|
|
|
{
|
|
|
|
if (sector[i].hitag == sector[j].hitag && j != i)
|
|
|
|
{
|
2020-10-18 10:10:46 +00:00
|
|
|
// & 32767 to avoid some ordering issues here.
|
|
|
|
// Other code assumes that the lotag is always a sector effector type and can mask the high bit in.
|
|
|
|
addjaildoor(dist, speed, sector[i].hitag, sector[j].lotag & 32767, sound, j);
|
2020-07-20 21:21:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2020-10-14 19:16:54 +00:00
|
|
|
}
|
2020-07-20 21:21:27 +00:00
|
|
|
case 42:
|
|
|
|
{
|
|
|
|
short ii;
|
|
|
|
int childsectnum = -1;
|
2020-10-28 05:37:17 +00:00
|
|
|
DukeSectIterator it(i);
|
|
|
|
while (auto act = it.Next())
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2021-04-15 17:21:43 +00:00
|
|
|
auto sj = act->s;
|
2020-10-14 19:16:54 +00:00
|
|
|
if (sj->picnum == RRTILE64)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2020-10-14 19:16:54 +00:00
|
|
|
dist = sj->lotag << 4;
|
|
|
|
speed = sj->hitag;
|
2020-07-20 21:21:27 +00:00
|
|
|
for (ii = 0; ii < MAXSPRITES; ii++)
|
|
|
|
{
|
2020-11-02 22:53:55 +00:00
|
|
|
auto spr = &sprite[ii];
|
|
|
|
if (spr->picnum == RRTILE66)
|
|
|
|
if (spr->lotag == sj->sectnum)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2020-11-02 22:53:55 +00:00
|
|
|
childsectnum = spr->sectnum;
|
2020-07-20 21:21:27 +00:00
|
|
|
deletesprite(ii);
|
|
|
|
}
|
|
|
|
}
|
2020-10-28 05:37:17 +00:00
|
|
|
deletesprite(act);
|
2020-07-20 21:21:27 +00:00
|
|
|
}
|
2020-10-14 19:16:54 +00:00
|
|
|
if (sj->picnum == RRTILE65)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2020-10-14 19:16:54 +00:00
|
|
|
sound = sj->lotag;
|
2020-10-28 05:37:17 +00:00
|
|
|
deletesprite(act);
|
2020-07-20 21:21:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
addminecart(dist, speed, i, sector[i].hitag, sound, childsectnum);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-02 18:13:58 +00:00
|
|
|
DukeStatIterator it(STAT_DEFAULT);
|
|
|
|
while (auto ac = it.Next())
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2021-04-15 17:21:43 +00:00
|
|
|
auto si = ac->s;
|
2020-10-23 18:27:05 +00:00
|
|
|
LoadActor(ac, -1, -1);
|
2020-07-20 21:21:27 +00:00
|
|
|
|
2020-10-14 20:18:10 +00:00
|
|
|
if (si->lotag == -1 && (si->cstat & 16))
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2020-10-14 20:18:10 +00:00
|
|
|
ps[0].exitx = si->x;
|
|
|
|
ps[0].exity = si->y;
|
2020-07-20 21:21:27 +00:00
|
|
|
}
|
2020-10-14 20:18:10 +00:00
|
|
|
else switch (si->picnum)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
|
|
|
case NUKEBUTTON:
|
|
|
|
chickenplant = 1;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case GPSPEED:
|
2021-11-06 12:47:06 +00:00
|
|
|
si->sector()->extra = si->lotag;
|
2020-11-02 18:13:58 +00:00
|
|
|
deletesprite(ac);
|
2020-07-20 21:21:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case CYCLER:
|
|
|
|
if (numcyclers >= MAXCYCLERS)
|
|
|
|
I_Error("Too many cycling sectors.");
|
2020-10-14 20:18:10 +00:00
|
|
|
cyclers[numcyclers][0] = si->sectnum;
|
|
|
|
cyclers[numcyclers][1] = si->lotag;
|
|
|
|
cyclers[numcyclers][2] = si->shade;
|
2021-11-06 12:47:06 +00:00
|
|
|
cyclers[numcyclers][3] = si->sector()->floorshade;
|
2020-10-14 20:18:10 +00:00
|
|
|
cyclers[numcyclers][4] = si->hitag;
|
|
|
|
cyclers[numcyclers][5] = (si->ang == 1536);
|
2020-07-20 21:21:27 +00:00
|
|
|
numcyclers++;
|
2020-11-02 18:13:58 +00:00
|
|
|
deletesprite(ac);
|
2020-07-20 21:21:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case RRTILE18:
|
2020-10-28 05:37:17 +00:00
|
|
|
addtorch(si);
|
2020-11-02 18:13:58 +00:00
|
|
|
deletesprite(ac);
|
2020-07-20 21:21:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case RRTILE35:
|
2020-10-28 05:37:17 +00:00
|
|
|
addlightning(si);
|
2020-11-02 18:13:58 +00:00
|
|
|
deletesprite(ac);
|
2020-07-20 21:21:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case RRTILE68:
|
2020-10-14 20:18:10 +00:00
|
|
|
shadedsector[si->sectnum] = 1;
|
2020-11-02 18:13:58 +00:00
|
|
|
deletesprite(ac);
|
2020-07-20 21:21:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case RRTILE67:
|
2020-10-14 20:18:10 +00:00
|
|
|
si->cstat |= 32768;
|
2020-07-20 21:21:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SOUNDFX:
|
|
|
|
if (ambientfx >= 64)
|
|
|
|
I_Error("Too many ambient effects");
|
|
|
|
else
|
|
|
|
{
|
2020-10-14 20:18:10 +00:00
|
|
|
ambienthitag[ambientfx] = si->hitag;
|
|
|
|
ambientlotag[ambientfx] = si->lotag;
|
|
|
|
si->ang = ambientfx;
|
2020-07-20 21:21:27 +00:00
|
|
|
ambientfx++;
|
2020-10-14 20:18:10 +00:00
|
|
|
si->lotag = 0;
|
|
|
|
si->hitag = 0;
|
2020-07-20 21:21:27 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < MAXSPRITES; i++)
|
|
|
|
{
|
2020-10-28 05:41:39 +00:00
|
|
|
auto spr = &sprite[i];
|
|
|
|
if (spr->picnum == RRTILE19)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
|
|
|
if (geocnt > 64)
|
|
|
|
I_Error("Too many geometry effects");
|
2020-10-28 05:41:39 +00:00
|
|
|
if (spr->hitag == 0)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2020-10-28 05:41:39 +00:00
|
|
|
geosector[geocnt] = spr->sectnum;
|
2020-07-20 21:21:27 +00:00
|
|
|
for (j = 0; j < MAXSPRITES; j++)
|
|
|
|
{
|
2020-10-28 05:41:39 +00:00
|
|
|
auto spj = &sprite[j];
|
|
|
|
if (spr->lotag == spj->lotag && j != i && spj->picnum == RRTILE19)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2020-10-28 05:41:39 +00:00
|
|
|
if (spj->hitag == 1)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2020-10-28 05:41:39 +00:00
|
|
|
geosectorwarp[geocnt] = spj->sectnum;
|
|
|
|
geox[geocnt] = spr->x - spj->x;
|
|
|
|
geoy[geocnt] = spr->y - spj->y;
|
|
|
|
//geoz[geocnt] = spr->z - spj->z;
|
2020-07-20 21:21:27 +00:00
|
|
|
}
|
2020-10-28 05:41:39 +00:00
|
|
|
if (spj->hitag == 2)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2020-10-28 05:41:39 +00:00
|
|
|
geosectorwarp2[geocnt] = spj->sectnum;
|
|
|
|
geox2[geocnt] = spr->x - spj->x;
|
|
|
|
geoy2[geocnt] = spr->y - spj->y;
|
|
|
|
//geoz2[geocnt] = spr->z - spj->z;
|
2020-07-20 21:21:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
geocnt++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < MAXSPRITES; i++)
|
|
|
|
{
|
2020-10-28 05:46:40 +00:00
|
|
|
auto spr = &sprite[i];
|
|
|
|
if (spr->statnum < MAXSTATUS)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2020-10-28 05:46:40 +00:00
|
|
|
if (spr->picnum == SECTOREFFECTOR && spr->lotag == 14)
|
2020-07-20 21:21:27 +00:00
|
|
|
continue;
|
2020-11-02 20:00:53 +00:00
|
|
|
spawn(nullptr, i);
|
2020-07-20 21:21:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < MAXSPRITES; i++)
|
|
|
|
{
|
2020-10-28 05:46:40 +00:00
|
|
|
auto spr = &sprite[i];
|
|
|
|
if (spr->statnum < MAXSTATUS)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2020-10-28 05:46:40 +00:00
|
|
|
if (spr->picnum == SECTOREFFECTOR && spr->lotag == 14)
|
2020-11-02 20:00:53 +00:00
|
|
|
spawn(nullptr, i);
|
2020-07-20 21:21:27 +00:00
|
|
|
}
|
2020-10-28 05:46:40 +00:00
|
|
|
if (spr->picnum == RRTILE19)
|
2020-07-20 21:21:27 +00:00
|
|
|
deletesprite(i);
|
2020-10-28 05:46:40 +00:00
|
|
|
if (spr->picnum == RRTILE34)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2021-05-12 15:33:33 +00:00
|
|
|
sectorextra[spr->sectnum] = uint8_t(spr->lotag);
|
2020-07-20 21:21:27 +00:00
|
|
|
deletesprite(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
lotaglist = 0;
|
|
|
|
|
2020-10-14 20:18:10 +00:00
|
|
|
it.Reset(STAT_DEFAULT);
|
2020-11-02 18:13:58 +00:00
|
|
|
while (auto ac = it.Next())
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2021-04-15 17:21:43 +00:00
|
|
|
auto spr = ac->s;
|
2020-10-28 05:46:40 +00:00
|
|
|
switch (spr->picnum)
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
|
|
|
case RRTILE8464 + 1:
|
|
|
|
if (!isRRRA()) break;
|
|
|
|
case DIPSWITCH + 1:
|
|
|
|
case DIPSWITCH2 + 1:
|
|
|
|
case PULLSWITCH + 1:
|
|
|
|
case HANDSWITCH + 1:
|
|
|
|
case SLOTDOOR + 1:
|
|
|
|
case LIGHTSWITCH + 1:
|
|
|
|
case SPACELIGHTSWITCH + 1:
|
|
|
|
case SPACEDOORSWITCH + 1:
|
|
|
|
case FRANKENSTINESWITCH + 1:
|
|
|
|
case LIGHTSWITCH2 + 1:
|
|
|
|
case POWERSWITCH1 + 1:
|
|
|
|
case LOCKSWITCH1 + 1:
|
|
|
|
case POWERSWITCH2 + 1:
|
|
|
|
case NUKEBUTTON:
|
|
|
|
case NUKEBUTTON + 1:
|
|
|
|
|
|
|
|
for (j = 0; j < lotaglist; j++)
|
2020-10-28 05:46:40 +00:00
|
|
|
if (spr->lotag == lotags[j])
|
2020-07-20 21:21:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
if (j == lotaglist)
|
|
|
|
{
|
2020-10-28 05:46:40 +00:00
|
|
|
lotags[lotaglist] = spr->lotag;
|
2020-07-20 21:21:27 +00:00
|
|
|
lotaglist++;
|
|
|
|
if (lotaglist > 64)
|
|
|
|
I_Error("Too many switches (64 max).");
|
|
|
|
|
2020-11-02 22:53:55 +00:00
|
|
|
DukeStatIterator it1(STAT_EFFECTOR);
|
|
|
|
while (auto j = it1.Next())
|
2020-07-20 21:21:27 +00:00
|
|
|
{
|
2021-04-15 17:21:43 +00:00
|
|
|
if (j->s->lotag == 12 && j->s->hitag == spr->lotag)
|
2020-11-02 22:53:55 +00:00
|
|
|
j->temp_data[0] = 1;
|
2020-07-20 21:21:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mirrorcnt = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < numwalls; i++)
|
|
|
|
{
|
|
|
|
walltype* wal;
|
|
|
|
wal = &wall[i];
|
|
|
|
|
|
|
|
if (wal->overpicnum == MIRROR && (wal->cstat & 32) != 0)
|
|
|
|
{
|
|
|
|
j = wal->nextsector;
|
|
|
|
|
|
|
|
if (mirrorcnt > 63)
|
|
|
|
I_Error("Too many mirrors (64 max.)");
|
|
|
|
if ((j >= 0) && sector[j].ceilingpicnum != MIRROR)
|
|
|
|
{
|
|
|
|
sector[j].ceilingpicnum = MIRROR;
|
|
|
|
sector[j].floorpicnum = MIRROR;
|
|
|
|
mirrorwall[mirrorcnt] = i;
|
|
|
|
mirrorsector[mirrorcnt] = j;
|
|
|
|
mirrorcnt++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (numanimwalls >= MAXANIMWALLS)
|
|
|
|
I_Error("Too many 'anim' walls (max 512.)");
|
|
|
|
|
|
|
|
animwall[numanimwalls].tag = 0;
|
|
|
|
animwall[numanimwalls].wallnum = 0;
|
|
|
|
|
|
|
|
switch (wal->overpicnum)
|
|
|
|
{
|
|
|
|
case FANSPRITE:
|
|
|
|
wall->cstat |= 65;
|
|
|
|
animwall[numanimwalls].wallnum = i;
|
|
|
|
numanimwalls++;
|
|
|
|
break;
|
|
|
|
case BIGFORCE:
|
|
|
|
animwall[numanimwalls].wallnum = i;
|
|
|
|
numanimwalls++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
wal->extra = -1;
|
|
|
|
|
|
|
|
switch (wal->picnum)
|
|
|
|
{
|
|
|
|
case SCREENBREAK6:
|
|
|
|
case SCREENBREAK7:
|
|
|
|
case SCREENBREAK8:
|
|
|
|
for (j = SCREENBREAK6; j <= SCREENBREAK8; j++)
|
|
|
|
tloadtile(j);
|
|
|
|
animwall[numanimwalls].wallnum = i;
|
|
|
|
animwall[numanimwalls].tag = -1;
|
|
|
|
numanimwalls++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Invalidate textures in sector behind mirror
|
|
|
|
for (i = 0; i < mirrorcnt; i++)
|
|
|
|
{
|
|
|
|
startwall = sector[mirrorsector[i]].wallptr;
|
|
|
|
endwall = startwall + sector[mirrorsector[i]].wallnum;
|
|
|
|
for (j = startwall; j < endwall; j++)
|
|
|
|
{
|
|
|
|
wall[j].picnum = MIRROR;
|
|
|
|
wall[j].overpicnum = MIRROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
thunder_brightness = 0;
|
|
|
|
if (!thunderon)
|
|
|
|
{
|
|
|
|
g_visibility = p->visibility;
|
|
|
|
}
|
2020-05-21 09:41:48 +00:00
|
|
|
}
|
|
|
|
|
2020-05-20 20:18:03 +00:00
|
|
|
|
2020-05-21 09:41:48 +00:00
|
|
|
END_DUKE_NS
|