zdoom/raze
0
0
Fork 0
mirror of https://github.com/ZDoom/Raze.git synced 2025-02-03 05:31:05 +00:00
Code Issues Projects Releases Packages Wiki Activity
raze/source/games/duke/src/spawn_d.cpp

834 lines
18 KiB
C++
Raw Normal View History

- spawn function transitioned.
2020-05-15 20:59:13 +00:00
//-------------------------------------------------------------------------
/*
Copyright (C) 1996, 2003 - 3D Realms Entertainment
Copyright (C) 2000, 2003 - Matt Saettler (EDuke Enhancements)
Copyright (C) 2020 - Christoph Oelckers
This file is part of Enhanced 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
EDuke enhancements integrated: 04/13/2003 - Matt Saettler
Note: EDuke source was in transition. Changes are in-progress in the
source as it is released.
*/
//-------------------------------------------------------------------------
#include <utility>
#include "ns.h"
#include "global.h"
- renamed a few headers.
2020-06-24 19:21:02 +00:00
#include "sounds.h"
- got rid of the dynamic tilemap. Most tile access is in game specific code, the remaining code only accesses 51 tiles
2020-07-03 21:56:14 +00:00
#include "names_d.h"
- clearcamera and ssp.
2020-10-21 17:38:53 +00:00
#include "dukeactor.h"
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
BEGIN_DUKE_NS
- Duke: replaced DukeLinearSpriteIterator and explicit loops over the sprite[] array.
2021-12-04 12:02:38 +00:00
DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>* actors)
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
{
- DukeActor scriptification framework.
2022-01-16 23:51:40 +00:00
if (act->GetClass() != RUNTIME_CLASS(DDukeActor))
{
CallInitialize(act);
return act;
}
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
auto sectp = act->sector();
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
if (isWorldTour())
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
{
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
switch (act->spr.picnum)
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
{
case BOSS2STAYPUT:
case BOSS3STAYPUT:
case BOSS5STAYPUT:
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
act->actorstayput = act->sector();
- Duke: added [[fallthrough]] annotations wherever needed.
2021-11-14 11:25:25 +00:00
[[fallthrough]];
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
case FIREFLY:
case BOSS5:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.picnum != FIREFLY)
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
{
- scriptified the respawn controller. This also handles one special RRRA controller which was just easier to scriptify right away than temporarily work around it.
2022-11-20 10:58:19 +00:00
if (actj && isrespawncontroller(actj))
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.pal = actj->spr.pal;
if (act->spr.pal != 0)
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
{
- first batch of set_const_clipdist replacements
2022-10-04 17:08:29 +00:00
act->clipdist = 20;
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.625, 0.625);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
else
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(1.25, 1.25);
- manual set_const_clipdist replacements
2022-10-04 17:13:26 +00:00
act->clipdist = 41;
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
}
}
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
else
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.625, 0.625);
- first batch of set_const_clipdist replacements
2022-10-04 17:08:29 +00:00
act->clipdist = 20;
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
}
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj)
act->spr.lotag = 0;
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if ((act->spr.lotag > ud.player_skill) || ud.monsters_off)
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0, 0);
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
break;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
else
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
{
- removed inline wrappers that are not needed anymore. # Conflicts: # source/games/duke/src/spawn_r.cpp
2020-11-02 22:06:20 +00:00
makeitfall(act);
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat |= CSTAT_SPRITE_BLOCK_ALL;
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
ps[connecthead].max_actors_killed++;
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj) {
- hittype in spawn code.
2020-11-02 19:54:27 +00:00
act->timetosleep = 0;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
check_fta_sounds_d(act);
- use symbolic STAT_ constants in spawninit where available.
2022-10-16 15:19:55 +00:00
ChangeActorStat(act, STAT_ACTOR);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
else
- use symbolic STAT_ constants in spawninit where available.
2022-10-16 15:19:55 +00:00
ChangeActorStat(act, STAT_ZOMBIEACTOR);
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
}
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
return act;
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
case FIREFLYFLYINGEFFECT:
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
act->SetOwner(actj);
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.25, 0.25);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
return act;
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
case LAVAPOOLBUBBLE:
- started removing wrappers. ScaleX() and ScaleY() done. No manual changes in here.
2022-10-07 21:33:37 +00:00
if (actj->spr.scale.X < 0.46875)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
return act;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
act->SetOwner(actj);
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- floatified all remaining add_int_pos calls.
2022-09-15 15:48:51 +00:00
act->spr.pos.X += krandf(32) - 16;
act->spr.pos.Y += krandf(32) - 16;
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.25, 0.25);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
return act;
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
case WHISPYSMOKE:
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- floatified all remaining add_int_pos calls.
2022-09-15 15:48:51 +00:00
act->spr.pos.X += krandf(16) - 8;
act->spr.pos.Y += krandf(16) - 8;
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.3125, 0.3125);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
return act;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
case SERIOUSSAM:
- use symbolic STAT_ constants in spawninit where available.
2022-10-16 15:19:55 +00:00
ChangeActorStat(act, STAT_ZOMBIEACTOR);
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat = CSTAT_SPRITE_BLOCK_ALL;
act->spr.extra = 150;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
return act;
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
}
}
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
switch (act->spr.picnum)
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
{
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
default:
spawninitdefault(actj, act);
break;
case FOF:
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0, 0);
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case WATERSPLASH2:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- GetActor pos replacement
2022-08-22 16:34:01 +00:00
SetActor(act, actj->spr.pos);
- manual repeats in Duke.
2022-10-05 22:08:51 +00:00
double s = 0.125 + (krand() & 7) * REPEAT_SCALE;
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(s, s);
- manual repeats in Duke.
2022-10-05 22:08:51 +00:00
}
else
{
double s = 0.25 + (krand() & 15) * REPEAT_SCALE;
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(s, s);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.shade = -16;
act->spr.cstat |= CSTAT_SPRITE_YCENTER;
if (actj)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
if (actj->sector()->lotag == 2)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- renamed slope functions so that the int versions get a special name.
2022-09-27 11:59:57 +00:00
act->spr.pos.Z = getceilzofslopeptr(act->sector(), act->spr.pos) + 16;
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat |= CSTAT_SPRITE_YFLIP;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
else if (actj->sector()->lotag == 1)
- renamed slope functions so that the int versions get a special name.
2022-09-27 11:59:57 +00:00
act->spr.pos.Z = getflorzofslopeptr(act->sector(), act->spr.pos);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
if (sectp->floorpicnum == FLOORSLIME ||
sectp->ceilingpicnum == FLOORSLIME)
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.pal = 7;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
[[fallthrough]];
case NEON1:
case NEON2:
case NEON3:
case NEON4:
case NEON5:
case NEON6:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.picnum != WATERSPLASH2)
act->spr.cstat |= CSTAT_SPRITE_BLOCK_ALL;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
[[fallthrough]];
case NUKEBUTTON:
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case NATURALLIGHTNING:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
act->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case TRANSPORTERSTAR:
case TRANSPORTERBEAM:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
spawntransporter(actj, act, act->spr.picnum == TRANSPORTERBEAM);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case FRAMEEFFECT1:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- removed Scale(), CopyScale() and MultScale wrappers.
2022-10-07 21:41:15 +00:00
act->spr.scale = actj->spr.scale;
- t[] replacement in spawn code.
2021-12-23 15:24:11 +00:00
act->temp_data[1] = actj->spr.picnum;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
else act->spr.scale = DVector2(0, 0);
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
case BLOOD:
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.25, 0.25);
- replaced all add_int_z calls with constants.
2022-08-20 15:59:15 +00:00
act->spr.pos.Z -= 26;
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj && actj->spr.pal == 6)
act->spr.pal = 6;
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case LAVAPOOL:
if (!isWorldTour()) // Twentieth Anniversary World Tour
return act;
[[fallthrough]];
case BLOODPOOL:
case PUKE:
if (spawnbloodpoolpart1(act)) break;
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj && act->spr.picnum != PUKE)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj->spr.pal == 1)
act->spr.pal = 1;
- flammable actors scriptified.
2022-11-14 15:31:45 +00:00
else if (actj->spr.pal != 6 && actj->spr.picnum != NUKEBARREL)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj->spr.picnum == FECES)
act->spr.pal = 7; // Brown
else act->spr.pal = 2; // Red
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
else act->spr.pal = 0; // green
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat |= CSTAT_SPRITE_ALIGNMENT_FLOOR;
if (act->spr.picnum == LAVAPOOL) // Twentieth Anniversary World Tour
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- renamed slope functions so that the int versions get a special name.
2022-09-27 11:59:57 +00:00
act->spr.pos.Z = getflorzofslopeptr(act->sector(), act->spr.pos) - 0.78125;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
[[fallthrough]];
case FECES:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj)
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(REPEAT_SCALE, REPEAT_SCALE);
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case SPACEMARINE:
- scriptified the trip bombs.
2022-11-17 17:38:25 +00:00
act->spr.extra = 20;
act->spr.cstat |= CSTAT_SPRITE_BLOCK_ALL;
- use symbolic STAT_ constants in spawninit where available.
2022-10-16 15:19:55 +00:00
ChangeActorStat(act, STAT_ZOMBIEACTOR);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case HYDRENT:
case SATELITE:
case FUELPOD:
case SOLARPANNEL:
case ANTENNA:
case MONK:
case INDY:
case LUKE:
case JURYGUY:
case FANSPRITE:
case FETUS:
case FETUSBROKE:
case PIPE1:
case PIPE2:
case PIPE3:
case PIPE4:
case PIPE5:
case PIPE6:
- first batch of set_const_clipdist replacements
2022-10-04 17:08:29 +00:00
act->clipdist = 8;
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat |= CSTAT_SPRITE_BLOCK_ALL;
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, 0);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case FEMMAG1:
case FEMMAG2:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, 0);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case DUKETAG:
case SIGN1:
case SIGN2:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (ud.multimode < 2 && act->spr.pal)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0, 0);
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
else act->spr.pal = 0;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case MASKWALL1:
case MASKWALL2:
case MASKWALL3:
case MASKWALL4:
case MASKWALL5:
case MASKWALL6:
case MASKWALL7:
case MASKWALL8:
case MASKWALL9:
case MASKWALL10:
case MASKWALL11:
case MASKWALL12:
case MASKWALL13:
case MASKWALL14:
case MASKWALL15:
{
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
auto j = act->spr.cstat & (CSTAT_SPRITE_ALIGNMENT_MASK | CSTAT_SPRITE_XFLIP | CSTAT_SPRITE_YFLIP);
act->spr.cstat = j | CSTAT_SPRITE_BLOCK;
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, 0);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
}
case FOOTPRINTS:
case FOOTPRINTS2:
case FOOTPRINTS3:
case FOOTPRINTS4:
initfootprint(actj, act);
break;
case FEM1:
case FEM2:
case FEM3:
case FEM4:
case FEM5:
case FEM6:
case FEM7:
case FEM8:
case FEM9:
case FEM10:
case PODFEM1:
case NAKED1:
case STATUE:
case TOUGHGAL:
- renamed yvel to yint in Duke. It's never used as velocity, but as an auxiliary parameter so name it appropriately.
2022-09-01 16:15:52 +00:00
act->spr.yint = act->spr.hitag;
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.hitag = -1;
if (act->spr.picnum == PODFEM1) act->spr.extra <<= 1;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
[[fallthrough]];
case BLOODYPOLE:
- scriptified the pool balls.
2022-11-27 22:36:39 +00:00
act->spr.cstat |= CSTAT_SPRITE_BLOCK_ALL;
act->clipdist = 8;
- use symbolic STAT_ constants in spawninit where available.
2022-10-16 15:19:55 +00:00
ChangeActorStat(act, STAT_ZOMBIEACTOR);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
case DUKELYINGDEAD:
- use isPlayer function where possible.
2022-11-26 13:48:51 +00:00
if (actj && actj->isPlayer())
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- removed Scale(), CopyScale() and MultScale wrappers.
2022-10-07 21:41:15 +00:00
act->spr.scale = actj->spr.scale;
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.shade = actj->spr.shade;
- use PlayerIndex where appropriate.
2022-09-01 14:42:23 +00:00
act->spr.pal = ps[actj->PlayerIndex()].palookup;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
[[fallthrough]];
case DUKECAR:
case HELECOPT:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat = 0;
act->spr.extra = 1;
- int_vel stuff with constants.
2022-09-11 17:28:45 +00:00
act->vel.X = 292 / 16.;
act->vel.Z = 360 / 256.;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
[[fallthrough]];
case BLIMP:
- scriptified the respawn marker.
2022-11-27 17:06:32 +00:00
act->spr.cstat |= CSTAT_SPRITE_BLOCK_ALL;
act->clipdist = 32;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
[[fallthrough]];
case MIKE:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.picnum == MIKE)
- renamed yvel to yint in Duke. It's never used as velocity, but as an auxiliary parameter so name it appropriately.
2022-09-01 16:15:52 +00:00
act->spr.yint = act->spr.hitag;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
[[fallthrough]];
case WEATHERWARN:
- use symbolic STAT_ constants in spawninit where available.
2022-10-16 15:19:55 +00:00
ChangeActorStat(act, STAT_ACTOR);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case SPOTLITE:
break;
case BULLETHOLE:
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.046875, 0.046875);
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat = CSTAT_SPRITE_ALIGNMENT_WALL | randomFlip();
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
insertspriteq(act);
[[fallthrough]];
case MONEY:
case MAIL:
case PAPER:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.picnum == MONEY || act->spr.picnum == MAIL || act->spr.picnum == PAPER)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
act->temp_data[0] = krand() & 2047;
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat = randomFlip();
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.125, 0.125);
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
act->spr.Angles.Yaw = randomAngle();
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case SHELL: //From the player
case SHOTGUNSHELL:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
initshell(actj, act, act->spr.picnum == SHELL);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case ONFIRE:
// Twentieth Anniversary World Tour
if (!isWorldTour())
break;
[[fallthrough]];
case EXPLOSION2:
case EXPLOSION2BOT:
case BURNING:
case BURNING2:
case SMALLSMOKE:
case SHRINKEREXPLOSION:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
act->spr.Angles.Yaw = actj->spr.Angles.Yaw;
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.shade = -64;
act->spr.cstat = CSTAT_SPRITE_YCENTER | randomXFlip();
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.picnum == EXPLOSION2 || act->spr.picnum == EXPLOSION2BOT)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.75, 0.75);
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.shade = -127;
act->spr.cstat |= CSTAT_SPRITE_YCENTER;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
else if (act->spr.picnum == SHRINKEREXPLOSION)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.5, 0.5);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
else if (act->spr.picnum == SMALLSMOKE || act->spr.picnum == ONFIRE)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
// 64 "money"
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.375, 0.375);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
else if (act->spr.picnum == BURNING || act->spr.picnum == BURNING2)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.0625, 0.0625);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- renamed slope functions so that the int versions get a special name.
2022-09-27 11:59:57 +00:00
double x = getflorzofslopeptr(act->sector(), act->spr.pos);
- eliminated all set_int_z calls in Duke.
2022-09-13 20:49:32 +00:00
if (act->spr.pos.Z > x - 12)
act->spr.pos.Z = x - 12;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.picnum == ONFIRE)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- floatified all remaining add_int_pos calls.
2022-09-15 15:48:51 +00:00
act->spr.pos.X += krandf(32) - 16;
act->spr.pos.Y += krandf(32) - 16;
act->spr.pos.Z -= krandf(40);
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat |= CSTAT_SPRITE_YCENTER;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
case PLAYERONWATER:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- removed Scale(), CopyScale() and MultScale wrappers.
2022-10-07 21:41:15 +00:00
act->spr.scale = actj->spr.scale;
- removed the mul vel wrappers
2022-09-03 08:04:16 +00:00
act->vel.Z = 0.5;
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
if (act->sector()->lotag != 2)
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_DUMMYPLAYER);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
case APLAYER:
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0, 0);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
int j = ud.coop;
if (j == 2) j = 0;
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (ud.multimode < 2 || (ud.multimode > 1 && j != act->spr.lotag))
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
else
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_PLAYER);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
}
case WATERBUBBLE:
- use isPlayer function where possible.
2022-11-26 13:48:51 +00:00
if (actj && actj->isPlayer())
- some simple replacements.
2022-02-07 07:47:18 +00:00
act->spr.pos.Z -= 16;
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.picnum == WATERBUBBLE)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj)
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
act->spr.Angles.Yaw = actj->spr.Angles.Yaw;
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.0625, 0.0625);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
else act->spr.scale = DVector2(0.5, 0.5);
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
case WATERDRIPSPLASH:
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.375, 0.375);
- more repeats replaced by SetScale.
2022-10-05 22:01:01 +00:00
ChangeActorStat(act, STAT_STANDABLE);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
case PLUG:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.lotag = 9999;
- more repeats replaced by SetScale.
2022-10-05 22:01:01 +00:00
ChangeActorStat(act, STAT_STANDABLE);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case WATERBUBBLEMAKER:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.hitag && act->spr.picnum == WATERBUBBLEMAKER)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{ // JBF 20030913: Pisses off move(), eg. in bobsp2
- floatified movetouchplate
2022-09-11 21:16:06 +00:00
Printf(TEXTCOLOR_YELLOW "WARNING: WATERBUBBLEMAKER %d @ %d,%d with hitag!=0. Applying fixup.\n", act->GetIndex(), int(act->spr.pos.X), int(act->spr.pos.Y));
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.hitag = 0;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
- floatified movetouchplate
2022-09-11 21:16:06 +00:00
ChangeActorStat(act, STAT_STANDABLE);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case TARGET:
case DUCK:
case LETTER:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.extra = 1;
act->spr.cstat |= CSTAT_SPRITE_BLOCK_ALL;
- handle the bolts These used temp_data which was remapped to temp_pos for being floats.
2022-10-07 16:43:24 +00:00
ChangeActorStat(act, STAT_ACTOR);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case OCTABRAINSTAYPUT:
case LIZTROOPSTAYPUT:
case PIGCOPSTAYPUT:
case LIZMANSTAYPUT:
case BOSS1STAYPUT:
case PIGCOPDIVE:
case COMMANDERSTAYPUT:
case BOSS4STAYPUT:
- use DCoreActor::sector() wherever possible.
2021-12-30 15:51:56 +00:00
act->actorstayput = act->sector();
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
[[fallthrough]];
case BOSS1:
case BOSS2:
case BOSS3:
case BOSS4:
case ROTATEGUN:
case GREENSLIME:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.picnum == GREENSLIME)
act->spr.extra = 1;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
[[fallthrough]];
case DRONE:
case LIZTROOPONTOILET:
case LIZTROOPJUSTSIT:
case LIZTROOPSHOOT:
case LIZTROOPJETPACK:
case LIZTROOPDUCKING:
case LIZTROOPRUNNING:
case LIZTROOP:
case OCTABRAIN:
case COMMANDER:
case PIGCOP:
case LIZMAN:
case LIZMANSPITTING:
case LIZMANFEEDING:
case LIZMANJUMP:
case ORGANTIC:
case SHARK:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.pal == 0)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
switch (act->spr.picnum)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
case LIZTROOPONTOILET:
case LIZTROOPSHOOT:
case LIZTROOPJETPACK:
case LIZTROOPDUCKING:
case LIZTROOPRUNNING:
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
case LIZTROOPSTAYPUT:
case LIZTROOPJUSTSIT:
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
case LIZTROOP:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.pal = 22;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
break;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
}
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (bossguy(act))
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- scriptified the respawn controller. This also handles one special RRRA controller which was just easier to scriptify right away than temporarily work around it.
2022-11-20 10:58:19 +00:00
if (actj && isrespawncontroller(actj))
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.pal = actj->spr.pal;
if (act->spr.pal && (!isWorldTour() || !(currentLevel->flags & LEVEL_WT_BOSSSPAWN) || act->spr.pal != 22))
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- first batch of set_const_clipdist replacements
2022-10-04 17:08:29 +00:00
act->clipdist = 20;
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.625, 0.625);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
else
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(1.25, 1.25);
- manual set_const_clipdist replacements
2022-10-04 17:13:26 +00:00
act->clipdist = 41;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
}
else
{
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.picnum != SHARK)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.625, 0.625);
- first batch of set_const_clipdist replacements
2022-10-04 17:08:29 +00:00
act->clipdist = 20;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
else
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.9375, 0.9375);
- first batch of set_const_clipdist replacements
2022-10-04 17:08:29 +00:00
act->clipdist = 10;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
}
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj) act->spr.lotag = 0;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if ((act->spr.lotag > ud.player_skill) || ud.monsters_off == 1)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0, 0);
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
}
else
{
makeitfall(act);
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- scriptified the rat.
2022-11-27 19:25:41 +00:00
act->spr.cstat |= CSTAT_SPRITE_BLOCK_ALL;
if (act->spr.picnum != SHARK)
ps[myconnectindex].max_actors_killed++;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.picnum == ORGANTIC) act->spr.cstat |= CSTAT_SPRITE_YCENTER;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
act->timetosleep = 0;
check_fta_sounds_d(act);
- use symbolic STAT_ constants in spawninit where available.
2022-10-16 15:19:55 +00:00
ChangeActorStat(act, STAT_ACTOR);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- use symbolic STAT_ constants in spawninit where available.
2022-10-16 15:19:55 +00:00
else ChangeActorStat(act, STAT_ZOMBIEACTOR);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.picnum == ROTATEGUN)
- remove vel clear wrappers
2022-09-03 08:02:25 +00:00
act->vel.Z = 0;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
case HEAVYHBOMB:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj) act->SetOwner(actj);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
else act->SetOwner(act);
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.140625, 0.140625);
- renamed yvel to yint in Duke. It's never used as velocity, but as an auxiliary parameter so name it appropriately.
2022-09-01 16:15:52 +00:00
act->spr.yint = 4;
- scriptified the Recon.
2022-11-28 17:57:50 +00:00
if (initreactor(actj, act, false)) return act;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case FLAMETHROWERSPRITE:
case FLAMETHROWERAMMO: // Twentieth Anniversary World Tour
if (!isWorldTour())
break;
[[fallthrough]];
case ATOMICHEALTH:
case STEROIDS:
case HEATSENSOR:
case SHIELD:
case AIRTANK:
case TRIPBOMBSPRITE:
case JETPACK:
case HOLODUKE:
case FIRSTGUNSPRITE:
case CHAINGUNSPRITE:
case SHOTGUNSPRITE:
case RPGSPRITE:
case SHRINKERSPRITE:
case FREEZESPRITE:
case DEVISTATORSPRITE:
case SHOTGUNAMMO:
case FREEZEAMMO:
case HBOMBAMMO:
case CRYSTALAMMO:
case GROWAMMO:
case BATTERYAMMO:
case DEVISTATORAMMO:
case RPGAMMO:
case BOOTS:
case AMMO:
case AMMOLOTS:
case COLA:
case FIRSTAID:
case SIXPAK:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.lotag = 0;
- replaced all add_int_z calls with constants.
2022-08-20 15:59:15 +00:00
act->spr.pos.Z -= 32;
- int_vel stuff with constants.
2022-09-11 17:28:45 +00:00
act->vel.Z = -4;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
ssp(act, CLIPMASK0);
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (krand() & 4) act->spr.cstat |= CSTAT_SPRITE_XFLIP;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
else
{
act->SetOwner(act);
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat = 0;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if ((ud.multimode < 2 && act->spr.pal != 0) || (act->spr.lotag > ud.player_skill))
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0, 0);
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
}
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.pal = 0;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
[[fallthrough]];
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
case ACCESSCARD:
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.picnum == ATOMICHEALTH)
act->spr.cstat |= CSTAT_SPRITE_YCENTER;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (ud.multimode > 1 && ud.coop != 1 && act->spr.picnum == ACCESSCARD)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0, 0);
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
}
else
{
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.picnum == AMMO)
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.25, 0.25);
else act->spr.scale = DVector2(0.5, 0.5);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.shade = -17;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj) ChangeActorStat(act, STAT_ACTOR);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
else
{
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_ZOMBIEACTOR);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
makeitfall(act);
}
break;
case FLOORFLAME:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.shade = -127;
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_STANDABLE);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case BOUNCEMINE:
act->SetOwner(act);
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat |= CSTAT_SPRITE_BLOCK_ALL; //Make it hitable
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.375, 0.375);
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.shade = -127;
act->spr.extra = gs.impact_damage << 2;
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_ZOMBIEACTOR);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case CAMERAPOLE:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.extra = 1;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (gs.camerashitable) act->spr.cstat = CSTAT_SPRITE_BLOCK_ALL;
else act->spr.cstat = 0;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
[[fallthrough]];
case GENERICPOLE:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (ud.multimode < 2 && act->spr.pal != 0)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0, 0);
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
}
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
else act->spr.pal = 0;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case STEAM:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- Change `spritetypebase::angle` to a DRotator named `Angles`. * Major pre-requisite for the next steps I'm undertaking, let's get it into the branch now.
2022-11-25 12:13:50 +00:00
act->spr.Angles.Yaw = actj->spr.Angles.Yaw;
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat = CSTAT_SPRITE_ALIGNMENT_WALL | CSTAT_SPRITE_YCENTER | CSTAT_SPRITE_TRANSLUCENT;
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(REPEAT_SCALE, REPEAT_SCALE);
- simple replacements in sector and spawn code
2022-09-13 17:56:37 +00:00
act->vel.X = -0.5;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
ssp(act, CLIPMASK0);
}
[[fallthrough]];
case CEILINGSTEAM:
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_STANDABLE);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
case SECTOREFFECTOR:
- Duke: replaced DukeLinearSpriteIterator and explicit loops over the sprite[] array.
2021-12-04 12:02:38 +00:00
spawneffector(act, actors);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
case TOILET:
case STALL:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.lotag = 1;
act->spr.cstat |= CSTAT_SPRITE_BLOCK_ALL;
- first batch of set_const_clipdist replacements
2022-10-04 17:08:29 +00:00
act->clipdist = 2;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
act->SetOwner(act);
break;
case RUBBERCAN:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.extra = 0;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
[[fallthrough]];
case EXPLODINGBARREL:
case HORSEONSIDE:
case FIREBARREL:
case NUKEBARREL:
case FIREVASE:
case NUKEBARRELDENTED:
case NUKEBARRELLEAKED:
case WOODENHORSE:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj)
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0.5, 0.5);
- first batch of set_const_clipdist replacements
2022-10-04 17:08:29 +00:00
act->clipdist = 18;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
makeitfall(act);
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (actj) act->SetOwner(actj);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
else act->SetOwner(act);
[[fallthrough]];
case EGG:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (ud.monsters_off == 1 && act->spr.picnum == EGG)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- unwrapped SetScale as well. Again no edits here - it's one big replace action.
2022-10-07 21:52:29 +00:00
act->spr.scale = DVector2(0, 0);
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_MISC);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
else
{
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
if (act->spr.picnum == EGG)
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
{
- manual set_const_clipdist replacements
2022-10-04 17:13:26 +00:00
act->clipdist = 6;
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
ps[connecthead].max_actors_killed++;
}
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.cstat = CSTAT_SPRITE_BLOCK_ALL | randomXFlip();
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_ZOMBIEACTOR);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
}
break;
case TOILETWATER:
- spawn_d.cpp
2021-12-21 20:57:32 +00:00
act->spr.shade = -16;
- moved some common utilities into the backend.
2021-11-26 20:52:01 +00:00
ChangeActorStat(act, STAT_STANDABLE);
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
break;
- tabified two files in Duke that were missed somehow, plus some comment cleanup elsewhere.
2021-11-09 23:05:42 +00:00
}
- cleaned up Duke's spawn code. The paths for initializing a map placed sprite and spawning a new actor at run time are now fully separate aside from the actual initialization of the actor.
2021-11-19 09:41:50 +00:00
return act;
- spawn function transitioned.
2020-05-15 20:59:13 +00:00
}
END_DUKE_NS
Reference in a new issue Copy permalink