zdoom/raze
0
0
Fork 0
mirror of https://github.com/ZDoom/Raze.git synced 2024-12-03 09:32:45 +00:00
Code Issues Projects Releases Packages Wiki Activity
raze/source/games/sw/src/sprite.cpp

6904 lines
197 KiB
C++
Raw Blame History

//-------------------------------------------------------------------------
/*
Copyright (C) 1997, 2005 - 3D Realms Entertainment
This file is part of Shadow Warrior version 1.2
Shadow Warrior 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
Original Source: 1997 - Frank Maddin and Jim Norwood
Prepared for public release: 03/28/2005 - Charlie Wiederhold, 3D Realms
*/
//-------------------------------------------------------------------------
#include "ns.h"
#include "build.h"
#include "names2.h"
#include "panel.h"
#include "misc.h"
#include "tags.h"
#include "ai.h"
#include "light.h"
#include "break.h"
#include "network.h"
#include "pal.h"
#include "sounds.h"
#include "interpolate.h"
#include "interpso.h"
#include "sprite.h"
#include "weapon.h"
#include "jsector.h"
#include "misc.h"
#include "player.h"
#include "quotemgr.h"
#include "v_text.h"
#include "gamecontrol.h"
#include "gamefuncs.h"
BEGIN_SW_NS
// ugly hack stuff.
int parallaxyscale_override, pskybits_override;
int SetupCoolie(DSWActor*);
int SetupNinja(DSWActor*);
int SetupGoro(DSWActor*);
int SetupCoolg(DSWActor*);
int SetupEel(DSWActor*);
int SetupSumo(DSWActor*);
int SetupZilla(DSWActor*);
int SetupToiletGirl(DSWActor*);
int SetupWashGirl(DSWActor*);
int SetupCarGirl(DSWActor*);
int SetupMechanicGirl(DSWActor*);
int SetupSailorGirl(DSWActor*);
int SetupPruneGirl(DSWActor*);
int SetupTrashCan(DSWActor*);
int SetupBunny(DSWActor*);
int SetupRipper(DSWActor*);
int SetupRipper2(DSWActor*);
int SetupSerp(DSWActor*);
int SetupLava(DSWActor* actor);
int SetupSkel(DSWActor*);
int SetupHornet(DSWActor*);
int SetupSkull(DSWActor*);
int SetupBetty(DSWActor*);
int SetupPachinkoLight(DSWActor*);
int SetupPachinko1(DSWActor*);
int SetupPachinko2(DSWActor*);
int SetupPachinko3(DSWActor*);
int SetupPachinko4(DSWActor*);
int SetupGirlNinja(DSWActor*);
ANIMATOR DoVator, DoVatorAuto;
ANIMATOR DoRotator;
ANIMATOR DoSlidor;
ANIMATOR DoSpike, DoSpikeAuto;
ANIMATOR DoLavaErupt;
int DoSlidorInstantClose(DSWActor*);
void InitWeaponRocket(PLAYER*);
void InitWeaponUzi(PLAYER*);
int MoveSkip4, MoveSkip2, MoveSkip8;
int MinEnemySkill;
extern STATE s_CarryFlag[];
extern STATE s_CarryFlagNoDet[];
// beware of mess... :(
static double globhiz, globloz;
static Collision globhihit, globlohit;
short wait_active_check_offset;
double PlaxCeilGlobZadjust, PlaxFloorGlobZadjust;
void SetSectorWallBits(sectortype* sect, int bit_mask, bool set_sectwall, bool set_nextwall);
int DoActorDebris(DSWActor* actor);
void ActorWarpUpdatePos(DSWActor*,sectortype* sect);
void ActorWarpType(DSWActor* sp, DSWActor* act_warp);
int MissileZrange(DSWActor*);
#define ACTIVE_CHECK_TIME (3*120)
TRACK Track[MAX_TRACKS];
SECTOR_OBJECT SectorObject[MAX_SECTOR_OBJECTS];
int DirArr[] = {NORTH, NE, EAST, SE, SOUTH, SW, WEST, NW, NORTH, NE, EAST, SE, SOUTH, SW, WEST, NW};
#define SCROLL_RATE 20
#define SCROLL_FIRE_RATE 20
STATE s_DebrisNinja[] =
{
{NINJA_DIE + 3, 100, DoActorDebris, &s_DebrisNinja[0]},
};
STATE s_DebrisRat[] =
{
{750, 100, DoActorDebris, &s_DebrisRat[0]},
};
STATE s_DebrisCrab[] =
{
{423, 100, DoActorDebris, &s_DebrisCrab[0]},
};
STATE s_DebrisStarFish[] =
{
{426, 100, DoActorDebris, &s_DebrisStarFish[0]},
};
ANIMATOR DoGet, DoKey, DoSpriteFade;
// temporary
#define ICON_REPAIR_KIT 1813
#define REPAIR_KIT_RATE 1100
STATE s_RepairKit[] =
{
{ICON_REPAIR_KIT + 0, REPAIR_KIT_RATE, DoGet, &s_RepairKit[0]}
};
STATE s_GoldSkelKey[] =
{
{GOLD_SKELKEY, 100, DoGet, &s_GoldSkelKey[0]}
};
STATE s_BlueKey[] =
{
{BLUE_KEY, 100, DoGet, &s_BlueKey[0]}
};
STATE s_BlueCard[] =
{
{BLUE_CARD, 100, DoGet, &s_BlueCard[0]}
};
STATE s_SilverSkelKey[] =
{
{SILVER_SKELKEY, 100, DoGet, &s_SilverSkelKey[0]}
};
STATE s_RedKey[] =
{
{RED_KEY, 100, DoGet, &s_RedKey[0]}
};
STATE s_RedCard[] =
{
{RED_CARD, 100, DoGet, &s_RedCard[0]}
};
STATE s_BronzeSkelKey[] =
{
{BRONZE_SKELKEY, 100, DoGet, &s_BronzeSkelKey[0]}
};
STATE s_GreenKey[] =
{
{GREEN_KEY, 100, DoGet, &s_GreenKey[0]}
};
STATE s_GreenCard[] =
{
{GREEN_CARD, 100, DoGet, &s_GreenCard[0]}
};
STATE s_RedSkelKey[] =
{
{RED_SKELKEY, 100, DoGet, &s_RedSkelKey[0]}
};
STATE s_YellowKey[] =
{
{YELLOW_KEY, 100, DoGet, &s_YellowKey[0]}
};
STATE s_YellowCard[] =
{
{YELLOW_CARD, 100, DoGet, &s_YellowCard[0]}
};
STATE* s_Key[] =
{
s_RedKey,
s_BlueKey,
s_GreenKey,
s_YellowKey,
s_RedCard,
s_BlueCard,
s_GreenCard,
s_YellowCard,
s_GoldSkelKey,
s_SilverSkelKey,
s_BronzeSkelKey,
s_RedSkelKey
};
#define KEY_RATE 25
#if 0
STATE s_BlueKey[] =
{
{BLUE_KEY + 0, KEY_RATE, DoKey, &s_BlueKey[0]}
};
STATE s_RedKey[] =
{
{RED_KEY + 0, KEY_RATE, DoKey, &s_RedKey[0]}
};
STATE s_GreenKey[] =
{
{GREEN_KEY + 0, KEY_RATE, DoKey, &s_GreenKey[0]}
};
STATE s_YellowKey[] =
{
{YELLOW_KEY + 0, KEY_RATE, DoKey, &s_YellowKey[0]}
};
STATE* s_Key[] =
{
s_RedKey,
s_BlueKey,
s_GreenKey,
s_YellowKey,
s_RedCard,
s_BlueCard,
s_GreenCard,
s_YellowCard,
s_GoldSkelKey,
s_SilverSkelKey,
s_BronzeSkelKey,
s_RedSkelKey
};
#endif
#if 0
STATE s_BlueKeyStatue[] =
{
{BLUE_KEY_STATUE + 0, KEY_RATE, DoSpriteFade, &s_BlueKeyStatue[0]}
};
STATE s_RedKeyStatue[] =
{
{RED_KEY_STATUE + 0, KEY_RATE, DoSpriteFade, &s_RedKeyStatue[0]}
};
STATE s_GreenKeyStatue[] =
{
{GREEN_KEY_STATUE + 0, KEY_RATE, DoSpriteFade, &s_GreenKeyStatue[0]}
};
STATE s_YellowKeyStatue[] =
{
{YELLOW_KEY_STATUE + 0, KEY_RATE, DoSpriteFade, &s_YellowKeyStatue[0]}
};
STATE* s_KeyStatue[] =
{
s_RedKeyStatue,
s_BlueKeyStatue,
s_GreenKeyStatue,
s_YellowKeyStatue,
};
#endif
#define Red_COIN 2440
#define Yellow_COIN 2450
#define Green_COIN 2460
#define RED_COIN_RATE 10
#define YELLOW_COIN_RATE 8
#define GREEN_COIN_RATE 6
ANIMATOR DoCoin;
STATE s_RedCoin[] =
{
{Red_COIN + 0, RED_COIN_RATE, DoCoin, &s_RedCoin[1]},
{Red_COIN + 1, RED_COIN_RATE, DoCoin, &s_RedCoin[2]},
{Red_COIN + 2, RED_COIN_RATE, DoCoin, &s_RedCoin[3]},
{Red_COIN + 3, RED_COIN_RATE, DoCoin, &s_RedCoin[4]},
{Red_COIN + 4, RED_COIN_RATE, DoCoin, &s_RedCoin[5]},
{Red_COIN + 5, RED_COIN_RATE, DoCoin, &s_RedCoin[6]},
{Red_COIN + 6, RED_COIN_RATE, DoCoin, &s_RedCoin[7]},
{Red_COIN + 7, RED_COIN_RATE, DoCoin, &s_RedCoin[0]},
};
// !JIM! Frank, I made coins go progressively faster
STATE s_YellowCoin[] =
{
{Yellow_COIN + 0, YELLOW_COIN_RATE, DoCoin, &s_YellowCoin[1]},
{Yellow_COIN + 1, YELLOW_COIN_RATE, DoCoin, &s_YellowCoin[2]},
{Yellow_COIN + 2, YELLOW_COIN_RATE, DoCoin, &s_YellowCoin[3]},
{Yellow_COIN + 3, YELLOW_COIN_RATE, DoCoin, &s_YellowCoin[4]},
{Yellow_COIN + 4, YELLOW_COIN_RATE, DoCoin, &s_YellowCoin[5]},
{Yellow_COIN + 5, YELLOW_COIN_RATE, DoCoin, &s_YellowCoin[6]},
{Yellow_COIN + 6, YELLOW_COIN_RATE, DoCoin, &s_YellowCoin[7]},
{Yellow_COIN + 7, YELLOW_COIN_RATE, DoCoin, &s_YellowCoin[0]},
};
STATE s_GreenCoin[] =
{
{Green_COIN + 0, GREEN_COIN_RATE, DoCoin, &s_GreenCoin[1]},
{Green_COIN + 1, GREEN_COIN_RATE, DoCoin, &s_GreenCoin[2]},
{Green_COIN + 2, GREEN_COIN_RATE, DoCoin, &s_GreenCoin[3]},
{Green_COIN + 3, GREEN_COIN_RATE, DoCoin, &s_GreenCoin[4]},
{Green_COIN + 4, GREEN_COIN_RATE, DoCoin, &s_GreenCoin[5]},
{Green_COIN + 5, GREEN_COIN_RATE, DoCoin, &s_GreenCoin[6]},
{Green_COIN + 6, GREEN_COIN_RATE, DoCoin, &s_GreenCoin[7]},
{Green_COIN + 7, GREEN_COIN_RATE, DoCoin, &s_GreenCoin[0]},
};
ANIMATOR DoFireFly;
#if 0
STATE s_FireFly[] =
{
{FIRE_FLY0, 120 * 3, DoFireFly, &s_FireFly[1]},
{FIRE_FLY1, 20, DoFireFly, &s_FireFly[2]},
{FIRE_FLY2, 20, DoFireFly, &s_FireFly[3]},
{FIRE_FLY3, 20, DoFireFly, &s_FireFly[4]},
{FIRE_FLY4, 60, DoFireFly, &s_FireFly[0]},
};
#else
STATE s_FireFly[] =
{
{FIRE_FLY0, FIRE_FLY_RATE * 4, DoFireFly, &s_FireFly[0]}
};
#endif
STATE s_IconStar[] =
{
{ICON_STAR, 100, DoGet, &s_IconStar[0]}
};
STATE s_IconUzi[] =
{
{ICON_UZI, 100, DoGet, &s_IconUzi[0]}
};
STATE s_IconLgUziAmmo[] =
{
{ICON_LG_UZI_AMMO, 100, DoGet, &s_IconLgUziAmmo[0]}
};
STATE s_IconUziFloor[] =
{
{ICON_UZIFLOOR, 100, DoGet, &s_IconUziFloor[0]}
};
STATE s_IconRocket[] =
{
{ICON_ROCKET, 100, DoGet, &s_IconRocket[0]}
};
STATE s_IconLgRocket[] =
{
{ICON_LG_ROCKET, 100, DoGet, &s_IconLgRocket[0]}
};
STATE s_IconShotgun[] =
{
{ICON_SHOTGUN, 100, DoGet, &s_IconShotgun[0]}
};
STATE s_IconLgShotshell[] =
{
{ICON_LG_SHOTSHELL, 100, DoGet, &s_IconLgShotshell[0]}
};
STATE s_IconAutoRiot[] =
{
{ICON_AUTORIOT, 100, DoGet, &s_IconAutoRiot[0]}
};
STATE s_IconGrenadeLauncher[] =
{
{ICON_GRENADE_LAUNCHER, 100, DoGet, &s_IconGrenadeLauncher[0]}
};
STATE s_IconLgGrenade[] =
{
{ICON_LG_GRENADE, 100, DoGet, &s_IconLgGrenade[0]}
};
STATE s_IconLgMine[] =
{
{ICON_LG_MINE, 100, DoGet, &s_IconLgMine[0]}
};
STATE s_IconGuardHead[] =
{
{ICON_GUARD_HEAD + 0, 15, DoGet, &s_IconGuardHead[0]},
// {ICON_GUARD_HEAD + 1, 15, DoGet, &s_IconGuardHead[2]},
// {ICON_GUARD_HEAD + 2, 15, DoGet, &s_IconGuardHead[0]}
};
#define FIREBALL_LG_AMMO_RATE 12
STATE s_IconFireballLgAmmo[] =
{
{ICON_FIREBALL_LG_AMMO + 0, FIREBALL_LG_AMMO_RATE, DoGet, &s_IconFireballLgAmmo[1]},
{ICON_FIREBALL_LG_AMMO + 1, FIREBALL_LG_AMMO_RATE, DoGet, &s_IconFireballLgAmmo[2]},
{ICON_FIREBALL_LG_AMMO + 2, FIREBALL_LG_AMMO_RATE, DoGet, &s_IconFireballLgAmmo[0]},
};
STATE s_IconHeart[] =
{
{ICON_HEART + 0, 25, DoGet, &s_IconHeart[1]},
{ICON_HEART + 1, 25, DoGet, &s_IconHeart[0]},
};
#define HEART_LG_AMMO_RATE 12
STATE s_IconHeartLgAmmo[] =
{
{ICON_HEART_LG_AMMO + 0, HEART_LG_AMMO_RATE, DoGet, &s_IconHeartLgAmmo[1]},
{ICON_HEART_LG_AMMO + 1, HEART_LG_AMMO_RATE, DoGet, &s_IconHeartLgAmmo[0]},
};
STATE s_IconMicroGun[] =
{
{ICON_MICRO_GUN, 100, DoGet, &s_IconMicroGun[0]}
};
STATE s_IconMicroBattery[] =
{
{ICON_MICRO_BATTERY, 100, DoGet, &s_IconMicroBattery[0]}
};
// !JIM! Added rail crap
STATE s_IconRailGun[] =
{
{ICON_RAIL_GUN, 100, DoGet, &s_IconRailGun[0]}
};
STATE s_IconRailAmmo[] =
{
{ICON_RAIL_AMMO, 100, DoGet, &s_IconRailAmmo[0]}
};
STATE s_IconElectro[] =
{
{ICON_ELECTRO + 0, 25, DoGet, &s_IconElectro[1]},
{ICON_ELECTRO + 1, 25, DoGet, &s_IconElectro[0]},
};
#define ICON_SPELL_RATE 8
STATE s_IconSpell[] =
{
{ICON_SPELL + 0, ICON_SPELL_RATE, DoGet, &s_IconSpell[1]},
{ICON_SPELL + 1, ICON_SPELL_RATE, DoGet, &s_IconSpell[2]},
{ICON_SPELL + 2, ICON_SPELL_RATE, DoGet, &s_IconSpell[3]},
{ICON_SPELL + 3, ICON_SPELL_RATE, DoGet, &s_IconSpell[4]},
{ICON_SPELL + 4, ICON_SPELL_RATE, DoGet, &s_IconSpell[5]},
{ICON_SPELL + 5, ICON_SPELL_RATE, DoGet, &s_IconSpell[6]},
{ICON_SPELL + 6, ICON_SPELL_RATE, DoGet, &s_IconSpell[7]},
{ICON_SPELL + 7, ICON_SPELL_RATE, DoGet, &s_IconSpell[8]},
{ICON_SPELL + 8, ICON_SPELL_RATE, DoGet, &s_IconSpell[9]},
{ICON_SPELL + 9, ICON_SPELL_RATE, DoGet, &s_IconSpell[10]},
{ICON_SPELL + 10, ICON_SPELL_RATE, DoGet, &s_IconSpell[11]},
{ICON_SPELL + 11, ICON_SPELL_RATE, DoGet, &s_IconSpell[12]},
{ICON_SPELL + 12, ICON_SPELL_RATE, DoGet, &s_IconSpell[13]},
{ICON_SPELL + 13, ICON_SPELL_RATE, DoGet, &s_IconSpell[14]},
{ICON_SPELL + 14, ICON_SPELL_RATE, DoGet, &s_IconSpell[15]},
{ICON_SPELL + 15, ICON_SPELL_RATE, DoGet, &s_IconSpell[0]},
};
STATE s_IconArmor[] =
{
{ICON_ARMOR + 0, 15, DoGet, &s_IconArmor[0]},
};
STATE s_IconMedkit[] =
{
{ICON_MEDKIT + 0, 15, DoGet, &s_IconMedkit[0]},
};
STATE s_IconChemBomb[] =
{
{ICON_CHEMBOMB, 15, DoGet, &s_IconChemBomb[0]},
};
STATE s_IconFlashBomb[] =
{
{ICON_FLASHBOMB, 15, DoGet, &s_IconFlashBomb[0]},
};
STATE s_IconNuke[] =
{
{ICON_NUKE, 15, DoGet, &s_IconNuke[0]},
};
STATE s_IconCaltrops[] =
{
{ICON_CALTROPS, 15, DoGet, &s_IconCaltrops[0]},
};
#define ICON_SM_MEDKIT 1802
STATE s_IconSmMedkit[] =
{
{ICON_SM_MEDKIT + 0, 15, DoGet, &s_IconSmMedkit[0]},
};
#define ICON_BOOSTER 1810
STATE s_IconBooster[] =
{
{ICON_BOOSTER + 0, 15, DoGet, &s_IconBooster[0]},
};
#define ICON_HEAT_CARD 1819
STATE s_IconHeatCard[] =
{
{ICON_HEAT_CARD + 0, 15, DoGet, &s_IconHeatCard[0]},
};
#if 0
STATE s_IconEnvironSuit[] =
{
{ICON_ENVIRON_SUIT + 0, 20, DoGet, &s_IconEnvironSuit[0]},
};
#endif
STATE s_IconCloak[] =
{
// {ICON_CLOAK + 0, 20, DoGet, &s_IconCloak[1]},
// {ICON_CLOAK + 1, 20, DoGet, &s_IconCloak[2]},
{ICON_CLOAK + 0, 20, DoGet, &s_IconCloak[0]},
};
STATE s_IconFly[] =
{
{ICON_FLY + 0, 20, DoGet, &s_IconFly[1]},
{ICON_FLY + 1, 20, DoGet, &s_IconFly[2]},
{ICON_FLY + 2, 20, DoGet, &s_IconFly[3]},
{ICON_FLY + 3, 20, DoGet, &s_IconFly[4]},
{ICON_FLY + 4, 20, DoGet, &s_IconFly[5]},
{ICON_FLY + 5, 20, DoGet, &s_IconFly[6]},
{ICON_FLY + 6, 20, DoGet, &s_IconFly[7]},
{ICON_FLY + 7, 20, DoGet, &s_IconFly[0]}
};
STATE s_IconNightVision[] =
{
{ICON_NIGHT_VISION + 0, 20, DoGet, &s_IconNightVision[0]},
};
STATE s_IconFlag[] =
{
{ICON_FLAG + 0, 32, DoGet, &s_IconFlag[1]},
{ICON_FLAG + 1, 32, DoGet, &s_IconFlag[2]},
{ICON_FLAG + 2, 32, DoGet, &s_IconFlag[0]}
};
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void SetOwner(DSWActor* ownr, DSWActor* child, bool flag)
{
if (flag && ownr != nullptr && ownr->hasU())
{
ownr->user.Flags2 |= (SPR2_CHILDREN);
}
child->ownerActor = ownr;
}
DSWActor* GetOwner(DSWActor* child)
{
return child ? child->ownerActor.Get() : nullptr;
}
void ClearOwner(DSWActor* child)
{
if (child) child->ownerActor = nullptr;
}
void SetAttach(DSWActor* ownr, DSWActor* child)
{
if (child && child->hasU() && ownr->hasU())
{
ownr->user.Flags2 |= (SPR2_CHILDREN);
child->user.attachActor = ownr;
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void KillActor(DSWActor* actor)
{
int i;
unsigned stat;
//extern short Zombies;
ASSERT(!Prediction);
ASSERT(actor->spr.statnum < MAXSTATUS);
//////////////////////////////////////////////
// Check sounds list to kill attached sounds
DeleteNoSoundOwner(actor);
DeleteNoFollowSoundOwner(actor);
//////////////////////////////////////////////
if (actor->hasU())
{
PLAYER* pp;
int pnum;
// doing a MissileSetPos - don't allow killing
if (actor->user.Flags & (SPR_SET_POS_DONT_KILL))
return;
// for attached sprites that are getable make sure they don't have
// any Anims attached
AnimDelete(ANIM_Userz, 0, actor);
AnimDelete(ANIM_Spritez, 0, actor);
StopInterpolation(actor, Interp_Sprite_Z);
// adjust sprites attached to sector objects
if (actor->user.Flags & (SPR_SO_ATTACHED))
{
SECTOR_OBJECT* sop;
int sn, FoundSpriteNdx = -1;
for (sop = SectorObject; sop < &SectorObject[MAX_SECTOR_OBJECTS]; sop++)
{
for (sn = 0; sop->so_actors[sn] != nullptr; sn++)
{
if (sop->so_actors[sn] == actor)
{
FoundSpriteNdx = sn;
}
}
if (FoundSpriteNdx >= 0)
{
// back up sn so it points to the last valid sprite num
sn--;
ASSERT(sop->so_actors[sn] != nullptr);
so_stopspriteinterpolation(sop, actor);
// replace the one to be deleted with the last ndx
sop->so_actors[FoundSpriteNdx] = sop->so_actors[sn];
// the last ndx is not -1
sop->so_actors[sn] = nullptr;
break;
}
}
}
// if a player is dead and watching this sprite
// reset it.
TRAVERSE_CONNECT(pnum)
{
pp = Player + pnum;
if (pp->KillerActor != nullptr)
{
if (pp->KillerActor == actor)
{
pp->KillerActor = nullptr;;
}
}
}
// if on a track and died reset the track to non-occupied
if (actor->spr.statnum == STAT_ENEMY)
{
if (actor->user.track != -1)
{
if (Track[actor->user.track].flags)
Track[actor->user.track].flags &= ~(TF_TRACK_OCCUPIED);
}
}
// if missile is heading for the sprite, the missile need to know
// that it is already dead
if ((actor->spr.extra & SPRX_PLAYER_OR_ENEMY))
{
static int8_t MissileStats[] = {STAT_MISSILE, STAT_MISSILE_SKIP4};
for (stat = 0; stat < SIZ(MissileStats); stat++)
{
SWStatIterator it(MissileStats[stat]);
while (auto itActor = it.Next())
{
if (!itActor->hasU()) continue;
if (itActor->user.WpnGoalActor == itActor)
{
itActor->user.WpnGoalActor = nullptr;
}
}
}
}
// much faster
if (actor->user.Flags2 & (SPR2_CHILDREN))
{
// check for children and alert them that the Owner is dead
// don't bother th check if you've never had children
for (stat = 0; stat < STAT_DONT_DRAW; stat++)
{
SWStatIterator it(stat);
while (auto itActor = it.Next())
{
if (GetOwner(itActor) == actor)
{
ClearOwner(itActor);
}
if (itActor->hasU() && itActor->user.attachActor == actor)
{
itActor->user.attachActor = nullptr;
}
}
}
}
if (actor->spr.statnum == STAT_ENEMY)
{
SWStatIterator it(STAT_ENEMY);
while (auto itActor = it.Next())
{
if (itActor->hasU() && itActor->user.targetActor == actor)
{
DoActorPickClosePlayer(itActor);
}
}
}
if (actor->user.flameActor != nullptr)
{
SetSuicide(actor->user.flameActor);
}
}
actor->Destroy();
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void ChangeState(DSWActor* actor, STATE* statep)
{
if (!actor->hasU())
return;
actor->user.Tics = 0;
actor->user.State = actor->user.StateStart = statep;
// Just in case
PicAnimOff(actor->user.State->Pic);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void change_actor_stat(DSWActor* actor, int stat, bool quick)
{
ChangeActorStat(actor, stat);
if (actor->hasU() && !quick)
{
actor->user.Flags &= ~(SPR_SKIP2|SPR_SKIP4);
if (stat >= STAT_SKIP4_START && stat <= STAT_SKIP4_END)
actor->user.Flags |= (SPR_SKIP4);
if (stat >= STAT_SKIP2_START && stat <= STAT_SKIP2_END)
actor->user.Flags |= (SPR_SKIP2);
switch (stat)
{
//case STAT_DEAD_ACTOR:
//case STAT_ITEM:
//case STAT_SKIP4:
#if 0
case STAT_PLAYER0:
case STAT_PLAYER1:
case STAT_PLAYER2:
case STAT_PLAYER3:
case STAT_PLAYER4:
case STAT_PLAYER5:
case STAT_PLAYER6:
case STAT_PLAYER7:
#endif
case STAT_ENEMY_SKIP4:
case STAT_ENEMY:
// for enemys - create offsets so all enemys don't call FAFcansee at once
wait_active_check_offset += ACTORMOVETICS*3;
if (wait_active_check_offset > ACTIVE_CHECK_TIME)
wait_active_check_offset = 0;
actor->user.wait_active_check = wait_active_check_offset;
// don't do a break here
actor->user.Flags |= (SPR_SHADOW);
break;
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void SpawnUser(DSWActor* actor, short id, STATE* state)
{
ASSERT(!Prediction);
actor->clearUser(); // make sure to delete old, stale content first!
actor->allocUser();
PRODUCTION_ASSERT(actor->hasU());
// be careful State can be nullptr
actor->user.State = actor->user.StateStart = state;
change_actor_stat(actor, actor->spr.statnum);
actor->user.ID = id;
actor->user.Health = 100;
actor->user.WpnGoalActor = nullptr;
actor->user.attachActor = nullptr;
actor->user.track = -1;
actor->user.targetActor = Player[0].actor;
actor->user.Radius = 220;
actor->user.Sibling = -1;
actor->user.WaitTics = 0;
actor->user.OverlapZ = 4;
actor->user.bounce = 0;
actor->user.motion_blur_num = 0;
actor->user.motion_blur_dist = 16;
actor->backuppos();
actor->user.oz = actor->opos.Z;
actor->user.active_range = MIN_ACTIVE_RANGE;
// default
// based on clipmove z of 48 pixels off the floor
actor->user.floor_dist = 48 - 28;
actor->user.ceiling_dist = 8;
// Problem with sprites spawned really close to white sector walls
// cant do a getzrange there
// Just put in some valid starting values
actor->user.loz = actor->sector()->floorz;
actor->user.hiz = actor->sector()->ceilingz;
actor->user.lowActor = nullptr;
actor->user.highActor = nullptr;
actor->user.lo_sectp = actor->sector();
actor->user.hi_sectp = actor->sector();
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
DSWActor* SpawnActor(int stat, int id, STATE* state, sectortype* sect, const DVector3& pos, DAngle init_ang, double vel)
{
if (sect == nullptr)
return nullptr;
ASSERT(!Prediction);
auto spawnedActor = insertActor(sect, stat);
spawnedActor->spr.pos = pos;
SpawnUser(spawnedActor, id, state);
// be careful State can be nullptr
if (spawnedActor->user.State)
{
spawnedActor->spr.picnum = spawnedActor->user.State->Pic;
PicAnimOff(spawnedActor->spr.picnum);
}
spawnedActor->spr.scale = DVector2(1, 1);
spawnedActor->spr.Angles.Yaw = init_ang;
spawnedActor->vel.X = vel;
return spawnedActor;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void PicAnimOff(short picnum)
{
short anim_type = (picanm[picnum].sf & PICANM_ANIMTYPE_MASK) >> PICANM_ANIMTYPE_SHIFT;
ASSERT(picnum >= 0 && picnum < MAXTILES);
if (!anim_type)
return;
picanm[picnum].sf &= ~(PICANM_ANIMTYPE_MASK);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
bool IconSpawn(DSWActor* actor)
{
// if multi item and not a modem game
if ((actor->spr.extra & SPRX_MULTI_ITEM))
{
if (numplayers <= 1 || gNet.MultiGameType == MULTI_GAME_COOPERATIVE)
return false;
}
actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK | CSTAT_SPRITE_BLOCK_HITSCAN | CSTAT_SPRITE_ONE_SIDE | CSTAT_SPRITE_ALIGNMENT_FLOOR);
return true;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
bool ActorTestSpawn(DSWActor* actor)
{
if (actor->spr.statnum == STAT_DEFAULT && actor->spr.lotag == TAG_SPAWN_ACTOR)
{
auto actorNew = insertActor(actor->sector(), STAT_DEFAULT);
actorNew->spr = actor->spr;
actorNew->clipdist = actor->clipdist;
change_actor_stat(actorNew, STAT_SPAWN_TRIGGER);
actorNew->spr.cstat &= ~(CSTAT_SPRITE_BLOCK|CSTAT_SPRITE_BLOCK_HITSCAN);
return false;
}
// Countermeasure for mods that leave the lower skills unpopulated.
int spawnskill = (actor->spr.extra & SPRX_SKILL);
if (MinEnemySkill > 0 && spawnskill == MinEnemySkill) spawnskill = 0;
// Skill ranges from -1 (No Monsters) to 3.
if (spawnskill > Skill)
{
// JBF: hack to fix Wanton Destruction's missing Sumos, Serpents, and Zilla on Skill < 2
if (((actor->spr.picnum == SERP_RUN_R0 || actor->spr.picnum == SUMO_RUN_R0) && actor->spr.lotag > 0 &&
actor->spr.lotag != TAG_SPAWN_ACTOR && actor->spr.extra > 0) || actor->spr.picnum == ZILLA_RUN_R0)
{
const char *c;
// NOTE: Wanton's $boat.map has two sumos, neither of which actually activate
// anything but are spawned in, and one of them has a skill level 2 mask. This
// hack however forces both sumos to appear on the easy levels. Bummer.
switch (actor->spr.picnum)
{
case SERP_RUN_R0: c = "serpent"; break;
case SUMO_RUN_R0: c = "sumo"; break;
case ZILLA_RUN_R0: c = "zilla"; break;
default: c = "?"; break;
}
Printf("WARNING: skill-masked %s at %d,%d,%d not being killed because it "
"activates something\n", c, int(actor->spr.pos.X), int(actor->spr.pos.Y), int(actor->spr.pos.Z));
return true;
}
//always spawn girls in addons
if ((actor->spr.picnum == TOILETGIRL_R0 ||
actor->spr.picnum == WASHGIRL_R0 ||
actor->spr.picnum == MECHANICGIRL_R0 ||
actor->spr.picnum == CARGIRL_R0 ||
actor->spr.picnum == PRUNEGIRL_R0 ||
actor->spr.picnum == SAILORGIRL_R0) && (g_gameType & GAMEFLAG_ADDON)) return true;
// spawn Bouncing Betty (mine) in TD map 09 Warehouse
if (actor->spr.picnum == 817 && (currentLevel->gameflags & LEVEL_SW_SPAWNMINES))
return true;
return false;
}
return true;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
int EnemyCheckSkill()
{
SWStatIterator it(STAT_DEFAULT);
int maxskill = INT_MAX;
while (auto actor = it.Next())
{
switch (actor->spr.picnum)
{
case COOLIE_RUN_R0:
case NINJA_RUN_R0:
case NINJA_CRAWL_R0:
case GORO_RUN_R0:
case 1441:
case COOLG_RUN_R0:
case EEL_RUN_R0:
case SUMO_RUN_R0:
case ZILLA_RUN_R0:
case RIPPER_RUN_R0:
case RIPPER2_RUN_R0:
case SERP_RUN_R0:
case LAVA_RUN_R0:
case SKEL_RUN_R0:
case HORNET_RUN_R0:
case SKULL_R0:
case BETTY_R0:
case GIRLNINJA_RUN_R0:
{
int myskill = actor->spr.extra & SPRX_SKILL;
if (myskill < maxskill) maxskill = myskill;
}
}
}
if (maxskill < 0 || maxskill == INT_MAX) maxskill = 0;
return maxskill;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
bool ActorSpawn(DSWActor* actor)
{
bool ret = true;
int picnum = actor->spr.picnum;
switch (picnum)
{
case COOLIE_RUN_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupCoolie(actor);
break;
}
case NINJA_RUN_R0:
case NINJA_CRAWL_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupNinja(actor);
break;
}
case GORO_RUN_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupGoro(actor);
break;
}
case 1441:
case COOLG_RUN_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupCoolg(actor);
break;
}
case EEL_RUN_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupEel(actor);
break;
}
case SUMO_RUN_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupSumo(actor);
break;
}
case ZILLA_RUN_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupZilla(actor);
break;
}
case TOILETGIRL_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupToiletGirl(actor);
break;
}
case WASHGIRL_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupWashGirl(actor);
break;
}
case CARGIRL_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupCarGirl(actor);
break;
}
case MECHANICGIRL_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupMechanicGirl(actor);
break;
}
case SAILORGIRL_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupSailorGirl(actor);
break;
}
case PRUNEGIRL_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupPruneGirl(actor);
break;
}
case TRASHCAN:
{
PicAnimOff(picnum);
SetupTrashCan(actor);
break;
}
case BUNNY_RUN_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupBunny(actor);
break;
}
case RIPPER_RUN_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupRipper(actor);
break;
}
case RIPPER2_RUN_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupRipper2(actor);
break;
}
case SERP_RUN_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupSerp(actor);
break;
}
case LAVA_RUN_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupLava(actor);
break;
}
case SKEL_RUN_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupSkel(actor);
break;
}
case HORNET_RUN_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupHornet(actor);
break;
}
case SKULL_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupSkull(actor);
break;
}
case BETTY_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupBetty(actor);
break;
}
case 623: // Pachinko win light
{
PicAnimOff(picnum);
SetupPachinkoLight(actor);
break;
}
case PACHINKO1:
{
PicAnimOff(picnum);
SetupPachinko1(actor);
break;
}
case PACHINKO2:
{
PicAnimOff(picnum);
SetupPachinko2(actor);
break;
}
case PACHINKO3:
{
PicAnimOff(picnum);
SetupPachinko3(actor);
break;
}
case PACHINKO4:
{
PicAnimOff(picnum);
SetupPachinko4(actor);
break;
}
case GIRLNINJA_RUN_R0:
{
if (!ActorTestSpawn(actor))
{
KillActor(actor);
return false;
}
PicAnimOff(picnum);
SetupGirlNinja(actor);
break;
}
default:
ret = false;
break;
}
return ret;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void IconDefault(DSWActor* actor)
{
change_actor_stat(actor, STAT_ITEM);
actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK | CSTAT_SPRITE_BLOCK_HITSCAN);
actor->user.Radius = 650;
DoActorZrange(actor);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void PreMapCombineFloors(void)
{
const int MAX_FLOORS = 32;
int i, j, k;
int base_offset;
short pnum;
struct BOUND_LIST
{
DSWActor* offset;
};
BOUND_LIST BoundList[MAX_FLOORS];
memset(BoundList, 0, MAX_FLOORS * sizeof(BOUND_LIST));
SWStatIterator it(0);
while (auto actor = it.Next())
{
if (actor->spr.picnum != ST1)
continue;
if (actor->spr.hitag == BOUND_FLOOR_OFFSET || actor->spr.hitag == BOUND_FLOOR_BASE_OFFSET)
{
ASSERT(actor->spr.lotag < MAX_FLOORS);
BoundList[actor->spr.lotag].offset = actor;
change_actor_stat(actor, STAT_FAF);
}
}
for (i = base_offset = 0; i < MAX_FLOORS; i++)
{
// blank so continue
if (!BoundList[i].offset)
continue;
if (BoundList[i].offset->spr.hitag == BOUND_FLOOR_BASE_OFFSET)
{
base_offset = i;
continue;
}
DVector2 dv = BoundList[base_offset].offset->spr.pos.XY() - BoundList[i].offset->spr.pos.XY();
BFSSectorSearch search(BoundList[i].offset->sector());
while (auto dasect = search.GetNext())
{
SWSectIterator it2(dasect);
while (auto jActor = it2.Next())
{
jActor->spr.pos += dv;
}
for (auto& wal : dasect->walls)
{
wal.move(wal.pos + dv);
if (wal.twoSided())
search.Add(wal.nextSector());
}
}
TRAVERSE_CONNECT(pnum)
{
PLAYER* pp = &Player[pnum];
auto dasect = pp->cursector;
search.Rewind();
while (auto itsect = search.GetNext())
{
if (itsect == dasect)
{
pp->actor->spr.pos.XY() += dv;
pp->actor->backupvec2();
break;
}
}
}
}
// get rid of the sprites used
it.Reset(STAT_FAF);
while (auto actor = it.Next())
{
KillActor(actor);
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void SpriteSetupPost(void)
{
double cz,fz;
// Post processing of some sprites after gone through the main SpriteSetup()
// routine
SWStatIterator it(STAT_FLOOR_PAN);
while (auto iActor = it.Next())
{
SWSectIterator it2(iActor->sector());
while (auto jActor = it2.Next())
{
if (jActor->spr.picnum == ST1)
continue;
if ((jActor->spr.cstat & (CSTAT_SPRITE_ALIGNMENT_WALL|CSTAT_SPRITE_ALIGNMENT_FLOOR)))
continue;
if (jActor->hasU())
continue;
calcSlope(jActor->sector(), jActor->spr.pos, &cz, &fz);
if (abs(jActor->spr.pos.Z - fz) > 4)
continue;
SpawnUser(jActor, 0, nullptr);
change_actor_stat(jActor, STAT_NO_STATE);
jActor->user.ceiling_dist = 4;
jActor->user.floor_dist = -2;
jActor->user.ActorActionFunc = DoActorDebris;
jActor->spr.cstat |= CSTAT_SPRITE_BREAKABLE;
jActor->spr.extra |= SPRX_BREAKABLE;
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void SpriteSetup(void)
{
short num;
double cz,fz;
MinEnemySkill = EnemyCheckSkill();
// special case for player
PicAnimOff(PLAYER_NINJA_RUN_R0);
// Clear Sprite Extension structure
// Clear all extra bits - they are set by sprites
for(auto& sect: sector)
{
sect.extra = 0;
}
// Clear PARALLAX_LEVEL overrides
parallaxyscale_override = 0;
pskybits_override = -1;
// Call my little sprite setup routine first
JS_SpriteSetup();
int minEnemySkill = EnemyCheckSkill();
SWStatIterator it(STAT_DEFAULT);
while (auto actor = it.Next())
{
// not used yetv
calcSlope(actor->sector(), actor->spr.pos, &cz, &fz);
if (actor->spr.pos.Z > ((cz + fz) * 0.5))
{
// closer to a floor
actor->spr.cstat |= (CSTAT_SPRITE_CLOSE_FLOOR);
}
// CSTAT_SPIN is insupported - get rid of it
if ((actor->spr.cstat & (CSTAT_SPRITE_ALIGNMENT_MASK)) == CSTAT_SPRITE_ALIGNMENT_SLAB)
actor->spr.cstat &= ~(CSTAT_SPRITE_ALIGNMENT_SLAB);
// if BLOCK is set set BLOCK_HITSCAN
// Hope this doesn't screw up anything
if (actor->spr.cstat & (CSTAT_SPRITE_BLOCK))
actor->spr.cstat |= (CSTAT_SPRITE_BLOCK_HITSCAN);
////////////////////////////////////////////
//
// BREAKABLE CHECK
//
////////////////////////////////////////////
// USER SETUP - TAGGED BY USER
// Non ST1 sprites that are tagged like them
if (TEST_BOOL1(actor) && actor->spr.picnum != ST1)
{
actor->spr.extra &= ~(
SPRX_BOOL4|
SPRX_BOOL5|
SPRX_BOOL6|
SPRX_BOOL7|
SPRX_BOOL8|
SPRX_BOOL9|
SPRX_BOOL10);
switch (actor->spr.hitag)
{
case BREAKABLE:
// need something that tells missiles to hit them
// but allows actors to move through them
SetActorSizeX(actor);
actor->spr.extra |= (SPRX_BREAKABLE);
actor->spr.cstat |= (CSTAT_SPRITE_BREAKABLE);
break;
}
}
else
{
// BREAK SETUP TABLE AUTOMATED
SetupSpriteForBreak(actor);
}
if (actor->spr.lotag == TAG_SPRITE_HIT_MATCH)
{
// if multi item and not a modem game
if ((actor->spr.extra & SPRX_MULTI_ITEM))
{
if (numplayers <= 1 || gNet.MultiGameType == MULTI_GAME_COOPERATIVE)
{
KillActor(actor);
continue;
}
}
// crack sprite
if (actor->spr.picnum == 80)
{
actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK);
actor->spr.cstat |= (CSTAT_SPRITE_BLOCK_HITSCAN|CSTAT_SPRITE_BLOCK_MISSILE);;
}
else
{
actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK);
actor->spr.cstat |= (CSTAT_SPRITE_BLOCK_HITSCAN|CSTAT_SPRITE_BLOCK_MISSILE);;
actor->spr.cstat |= (CSTAT_SPRITE_INVISIBLE);;
}
if (SP_TAG8(actor) & BIT(0))
actor->spr.cstat |= (CSTAT_SPRITE_INVISIBLE);
if (SP_TAG8(actor) & BIT(1))
actor->spr.cstat &= ~(CSTAT_SPRITE_INVISIBLE);
change_actor_stat(actor, STAT_SPRITE_HIT_MATCH);
continue;
}
if (actor->spr.picnum >= TRACK_SPRITE &&
actor->spr.picnum <= TRACK_SPRITE + MAX_TRACKS)
{
short track_num;
// skip this sprite, just for numbering walls/sectors
if (actor->spr.cstat & (CSTAT_SPRITE_ALIGNMENT_WALL))
continue;
track_num = actor->spr.picnum - TRACK_SPRITE + 0;
change_actor_stat(actor, STAT_TRACK + track_num);
continue;
}
if (ActorSpawn(actor))
continue;
switch (actor->spr.picnum)
{
case ST_QUICK_JUMP:
change_actor_stat(actor, STAT_QUICK_JUMP);
break;
case ST_QUICK_JUMP_DOWN:
change_actor_stat(actor, STAT_QUICK_JUMP_DOWN);
break;
case ST_QUICK_SUPER_JUMP:
change_actor_stat(actor, STAT_QUICK_SUPER_JUMP);
break;
case ST_QUICK_SCAN:
change_actor_stat(actor, STAT_QUICK_SCAN);
break;
case ST_QUICK_EXIT:
change_actor_stat(actor, STAT_QUICK_EXIT);
break;
case ST_QUICK_OPERATE:
change_actor_stat(actor, STAT_QUICK_OPERATE);
break;
case ST_QUICK_DUCK:
change_actor_stat(actor, STAT_QUICK_DUCK);
break;
case ST_QUICK_DEFEND:
change_actor_stat(actor, STAT_QUICK_DEFEND);
break;
case ST1:
{
sectortype* sectp = actor->sector();
short tag;
short bit;
// get rid of defaults
if (SP_TAG3(actor) == 32)
SP_TAG3(actor) = 0;
tag = actor->spr.hitag;
actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK|CSTAT_SPRITE_BLOCK_HITSCAN);
actor->spr.cstat |= (CSTAT_SPRITE_INVISIBLE);
// for bounding sector objects
if ((tag >= 500 && tag < 600) || tag == SECT_SO_CENTER)
{
// NOTE: These will get deleted by the sector object
// setup code
change_actor_stat(actor, STAT_ST1);
break;
}
if (tag < 16)
{
bit = 1 << (tag);
actor->sector()->extra |= (bit);
if (bit & (SECTFX_SINK))
{
sectp->u_defined = true;
sectp->depth_fixed = IntToFixed(actor->spr.lotag);
KillActor(actor);
}
else if (bit & (SECTFX_OPERATIONAL))
{
KillActor(actor);
}
else if (bit & (SECTFX_CURRENT))
{
sectp->u_defined = true;
sectp->speed = actor->spr.lotag;
sectp->angle = actor->spr.Angles.Yaw;
KillActor(actor);
}
else if (bit & (SECTFX_NO_RIDE))
{
change_actor_stat(actor, STAT_NO_RIDE);
}
else if (bit & (SECTFX_DIVE_AREA))
{
sectp->u_defined = true;
sectp->number = actor->spr.lotag;
change_actor_stat(actor, STAT_DIVE_AREA);
}
else if (bit & (SECTFX_UNDERWATER))
{
sectp->u_defined = true;
sectp->number = actor->spr.lotag;
change_actor_stat(actor, STAT_UNDERWATER);
}
else if (bit & (SECTFX_UNDERWATER2))
{
sectp->u_defined = true;
sectp->number = actor->spr.lotag;
if (actor->spr.clipdist == 1) // notreallyclipdist
sectp->flags |= (SECTFU_CANT_SURFACE);
change_actor_stat(actor, STAT_UNDERWATER2);
}
}
else
{
switch (tag)
{
#if 0
case MULTI_PLAYER_START:
change_actor_stat(actor, STAT_MULTI_START + actor->spr.lotag);
break;
case MULTI_COOPERATIVE_START:
change_actor_stat(actor, STAT_CO_OP_START + actor->spr.lotag);
break;
#endif
case SECT_MATCH:
sectp->u_defined = true;
sectp->number = actor->spr.lotag;
KillActor(actor);
break;
case SLIDE_SECTOR:
sectp->u_defined = true;
sectp->flags |= (SECTFU_SLIDE_SECTOR);
sectp->speed = SP_TAG2(actor);
KillActor(actor);
break;
case SECT_DAMAGE:
{
sectp->u_defined = true;
if (TEST_BOOL1(actor))
sectp->flags |= (SECTFU_DAMAGE_ABOVE_SECTOR);
sectp->damage = actor->spr.lotag;
KillActor(actor);
break;
}
case PARALLAX_LEVEL:
{
parallaxyscale_override = 8192;
pskybits_override = actor->spr.lotag;
if (SP_TAG4(actor) > 2048)
parallaxyscale_override = SP_TAG4(actor);
defineSky(DEFAULTPSKY, pskybits_override, nullptr, 0, parallaxyscale_override / 8192.f);
KillActor(actor);
break;
}
case BREAKABLE:
// used for wall info
change_actor_stat(actor, STAT_BREAKABLE);
break;
case SECT_DONT_COPY_PALETTE:
{
sectp->u_defined = true;
sectp->flags |= (SECTFU_DONT_COPY_PALETTE);
KillActor(actor);
break;
}
case SECT_FLOOR_PAN:
{
// if moves with SO
if (TEST_BOOL1(actor))
actor->vel.X = 0;
else
actor->vel.X = actor->spr.lotag * maptoworld;
StartInterpolation(actor->sector(), Interp_Sect_FloorPanX);
StartInterpolation(actor->sector(), Interp_Sect_FloorPanY);
change_actor_stat(actor, STAT_FLOOR_PAN);
break;
}
case SECT_CEILING_PAN:
{
// if moves with SO
if (TEST_BOOL1(actor))
actor->vel.X = 0;
else
actor->vel.X = actor->spr.lotag * maptoworld;
StartInterpolation(actor->sector(), Interp_Sect_CeilingPanX);
StartInterpolation(actor->sector(), Interp_Sect_CeilingPanY);
change_actor_stat(actor, STAT_CEILING_PAN);
break;
}
case SECT_WALL_PAN_SPEED:
{
HitInfo hit{};
hitscan(actor->spr.pos.plusZ(-8), actor->sector(), DVector3(actor->spr.Angles.Yaw.ToVector() * 1024, 0), hit, CLIPMASK_MISSILE);
if (hit.hitWall == nullptr)
{
KillActor(actor);
break;
}
actor->tempwall = hit.hitWall;
// if moves with SO
if (TEST_BOOL1(actor))
actor->vel.X = 0;
else
actor->vel.X = actor->spr.lotag * maptoworld;
actor->spr.Angles.Yaw = mapangle(SP_TAG6(actor));
// attach to the sector that contains the wall
ChangeActorSect(actor, hit.hitSector);
StartInterpolation(hit.hitWall, Interp_Wall_PanX);
StartInterpolation(hit.hitWall, Interp_Wall_PanY);
change_actor_stat(actor, STAT_WALL_PAN);
break;
}
case WALL_DONT_STICK:
{
HitInfo hit{};
hitscan(actor->spr.pos.plusZ(-8), actor->sector(), DVector3(actor->spr.Angles.Yaw.ToVector() * 1024, 0), hit, CLIPMASK_MISSILE);
if (hit.hitWall == nullptr)
{
KillActor(actor);
break;
}
hit.hitWall->extra |= WALLFX_DONT_STICK;
KillActor(actor);
break;
}
case TRIGGER_SECTOR:
{
actor->sector()->extra |= (SECTFX_TRIGGER);
change_actor_stat(actor, STAT_TRIGGER);
break;
}
case DELETE_SPRITE:
{
change_actor_stat(actor, STAT_DELETE_SPRITE);
break;
}
case SPAWN_ITEMS:
{
if ((actor->spr.extra & SPRX_MULTI_ITEM))
{
if (numplayers <= 1 || gNet.MultiGameType == MULTI_GAME_COOPERATIVE)
{
KillActor(actor);
break;
}
}
change_actor_stat(actor, STAT_SPAWN_ITEMS);
break;
}
case CEILING_FLOOR_PIC_OVERRIDE:
{
// block hitscans depending on translucency
if (SP_TAG7(actor) == 0 || SP_TAG7(actor) == 1)
{
if (SP_TAG3(actor) == 0)
actor->sector()->ceilingstat |= (CSTAT_SECTOR_FAF_BLOCK_HITSCAN);
else
actor->sector()->floorstat |= (CSTAT_SECTOR_FAF_BLOCK_HITSCAN);
}
else if (TEST_BOOL1(actor))
{
if (SP_TAG3(actor) == 0)
actor->sector()->ceilingstat |= (CSTAT_SECTOR_FAF_BLOCK_HITSCAN);
else
actor->sector()->floorstat |= (CSTAT_SECTOR_FAF_BLOCK_HITSCAN);
}
// copy tag 7 to tag 6 and pre-shift it
SP_TAG6(actor) = SP_TAG7(actor);
SP_TAG6(actor) <<= 7;
change_actor_stat(actor, STAT_CEILING_FLOOR_PIC_OVERRIDE);
break;
}
case QUAKE_SPOT:
{
change_actor_stat(actor, STAT_QUAKE_SPOT);
SET_SP_TAG13(actor, ((SP_TAG6(actor)*10) * 120));
break;
}
case SECT_CHANGOR:
{
change_actor_stat(actor, STAT_CHANGOR);
break;
}
#if 0
case SECT_DEBRIS_SEWER:
{
ANIMATOR DoGenerateSewerDebris;
SpawnUser(actor, 0, nullptr);
ASSERT(actor->hasU());
actor->user.RotNum = 0;
actor->user.WaitTics = actor->spr.lotag * 120;
actor->user.ActorActionFunc = DoGenerateSewerDebris;
change_actor_stat(actor, STAT_NO_STATE);
break;
}
#endif
case SECT_VATOR:
{
short speed,vel,time,type,start_on,floor_vator;
SpawnUser(actor, 0, nullptr);
// vator already set - ceiling AND floor vator
if ((sectp->extra & SECTFX_VATOR))
{
sectp->u_defined = true;
sectp->flags |= (SECTFU_VATOR_BOTH);
}
sectp->extra |= (SECTFX_VATOR);
SetSectorWallBits(actor->sector(), WALLFX_DONT_STICK, true, true);
actor->sector()->extra |= (SECTFX_DYNAMIC_AREA);
// don't step on toes of other sector settings
if (sectp->lotag == 0 && sectp->hitag == 0)
sectp->lotag = TAG_VATOR;
type = SP_TAG3(actor);
speed = SP_TAG4(actor);
vel = SP_TAG5(actor);
time = SP_TAG9(actor);
start_on = !!TEST_BOOL1(actor);
floor_vator = true;
if (actor->spr.cstat & (CSTAT_SPRITE_YFLIP))
floor_vator = false;
actor->user.jump_speed = actor->user.vel_tgt = speed;
actor->user.vel_rate = vel;
actor->user.WaitTics = time*15; // 1/8 of a sec
actor->user.Tics = 0;
actor->user.Flags |= (SPR_ACTIVE);
switch (type)
{
case 0:
actor->user.Flags &= ~(SPR_ACTIVE);
actor->user.ActorActionFunc = DoVator;
break;
case 1:
actor->user.Flags &= ~(SPR_ACTIVE);
actor->user.ActorActionFunc = DoVator;
break;
case 2:
actor->user.ActorActionFunc = DoVatorAuto;
break;
case 3:
actor->user.Flags &= ~(SPR_ACTIVE);
actor->user.ActorActionFunc = DoVatorAuto;
break;
}
if (floor_vator)
{
// start off
actor->user.pos.Z = sectp->floorz;
actor->user.z_tgt = actor->spr.pos.Z;
if (start_on)
{
double amt = actor->spr.pos.Z - sectp->floorz;
// start in the on position
sectp->setfloorz(actor->spr.pos.Z);
actor->user.z_tgt = actor->user.pos.Z;
MoveSpritesWithSector(actor->sector(), amt, false); // floor
}
// set orig z
actor->opos.Z = sectp->floorz;
actor->user.oz = actor->opos.Z;
}
else
{
// start off
actor->user.pos.Z = sectp->ceilingz;
actor->user.z_tgt = actor->spr.pos.Z;
if (start_on)
{
double amt = actor->spr.pos.Z - sectp->ceilingz;
// starting in the on position
sectp->setceilingz(actor->spr.pos.Z);
actor->user.z_tgt = actor->user.pos.Z;
MoveSpritesWithSector(actor->sector(), amt, true); // ceiling
}
// set orig z
actor->opos.Z = sectp->ceilingz;
actor->user.oz = actor->opos.Z;
}
change_actor_stat(actor, STAT_VATOR);
break;
}
case SECT_ROTATOR_PIVOT:
{
change_actor_stat(actor, STAT_ROTATOR_PIVOT);
break;
}
case SECT_ROTATOR:
{
short time,type;
short wallcount,startwall,endwall,w;
SpawnUser(actor, 0, nullptr);
SetSectorWallBits(actor->sector(), WALLFX_DONT_STICK, true, true);
// need something for this
sectp->lotag = TAG_ROTATOR;
sectp->hitag = actor->spr.lotag;
type = SP_TAG3(actor);
time = SP_TAG9(actor);
actor->user.WaitTics = time*15; // 1/8 of a sec
actor->user.Tics = 0;
actor->user.rotator.Alloc();
actor->user.rotator->open_dest = SP_TAG5(actor);
actor->user.rotator->speed = SP_TAG7(actor);
actor->user.rotator->vel = SP_TAG8(actor);
actor->user.rotator->pos = 0; // closed
actor->user.rotator->tgt = actor->user.rotator->open_dest; // closed
actor->user.rotator->SetNumWalls(actor->sector()->walls.Size());
actor->user.rotator->orig_speed = actor->user.rotator->speed;
wallcount = 0;
for(auto& wal : actor->sector()->walls)
{
actor->user.rotator->orig[wallcount] = wal.pos;
wallcount++;
}
actor->user.Flags |= (SPR_ACTIVE);
switch (type)
{
case 0:
actor->user.Flags &= ~(SPR_ACTIVE);
actor->user.ActorActionFunc = DoRotator;
break;
case 1:
actor->user.Flags &= ~(SPR_ACTIVE);
actor->user.ActorActionFunc = DoRotator;
break;
}
change_actor_stat(actor, STAT_ROTATOR);
break;
}
case SECT_SLIDOR:
{
short time,type;
SpawnUser(actor, 0, nullptr);
SetSectorWallBits(actor->sector(), WALLFX_DONT_STICK, true, true);
// need something for this
sectp->lotag = TAG_SLIDOR;
sectp->hitag = actor->spr.lotag;
type = SP_TAG3(actor);
time = SP_TAG9(actor);
actor->user.WaitTics = time*15; // 1/8 of a sec
actor->user.Tics = 0;
actor->user.rotator.Alloc();
actor->user.rotator->open_dest = SP_TAG5(actor);
actor->user.rotator->speed = SP_TAG7(actor);
actor->user.rotator->vel = SP_TAG8(actor);
actor->user.rotator->pos = 0; // closed
actor->user.rotator->tgt = actor->user.rotator->open_dest; // closed
actor->user.rotator->ClearWalls();
actor->user.rotator->orig_speed = actor->user.rotator->speed;
actor->user.Flags |= (SPR_ACTIVE);
switch (type)
{
case 0:
actor->user.Flags &= ~(SPR_ACTIVE);
actor->user.ActorActionFunc = DoSlidor;
break;
case 1:
actor->user.Flags &= ~(SPR_ACTIVE);
actor->user.ActorActionFunc = DoSlidor;
break;
}
if (TEST_BOOL5(actor))
{
DoSlidorInstantClose(actor);
}
change_actor_stat(actor, STAT_SLIDOR);
break;
}
case SECT_SPIKE:
{
short speed,vel,time,type,start_on,floor_vator;
double florz,ceilz;
Collision trash;
SpawnUser(actor, 0, nullptr);
SetSectorWallBits(actor->sector(), WALLFX_DONT_STICK, false, true);
actor->sector()->extra |= (SECTFX_DYNAMIC_AREA);
type = SP_TAG3(actor);
speed = SP_TAG4(actor);
vel = SP_TAG5(actor);
time = SP_TAG9(actor);
start_on = !!TEST_BOOL1(actor);
floor_vator = true;
if (actor->spr.cstat & (CSTAT_SPRITE_YFLIP))
floor_vator = false;
actor->user.jump_speed = actor->user.vel_tgt = speed;
actor->user.vel_rate = vel;
actor->user.WaitTics = time*15; // 1/8 of a sec
actor->user.Tics = 0;
actor->user.Flags |= (SPR_ACTIVE);
switch (type)
{
case 0:
actor->user.Flags &= ~(SPR_ACTIVE);
actor->user.ActorActionFunc = DoSpike;
break;
case 1:
actor->user.Flags &= ~(SPR_ACTIVE);
actor->user.ActorActionFunc = DoSpike;
break;
case 2:
actor->user.ActorActionFunc = DoSpikeAuto;
break;
case 3:
actor->user.Flags &= ~(SPR_ACTIVE);
actor->user.ActorActionFunc = DoSpikeAuto;
break;
}
getzrangepoint(actor->spr.pos, actor->sector(), &ceilz, &trash, &florz, &trash);
if (floor_vator)
{
actor->user.zclip = florz;
// start off
actor->user.pos.Z = actor->user.zclip;
actor->user.z_tgt = actor->spr.pos.Z;
if (start_on)
{
// start in the on position
actor->user.zclip = actor->spr.pos.Z;
actor->user.z_tgt = actor->user.pos.Z;
SpikeAlign(actor);
}
// set orig z
actor->user.oz = actor->user.zclip;
actor->opos.Z = actor->user.oz;
}
else
{
actor->user.zclip = ceilz;
// start off
actor->user.pos.Z = actor->user.zclip;
actor->user.z_tgt = actor->spr.pos.Z;
if (start_on)
{
// starting in the on position
actor->user.zclip = actor->spr.pos.Z;
actor->user.z_tgt = actor->user.pos.Z;
SpikeAlign(actor);
}
// set orig z
actor->user.oz = actor->user.zclip;
actor->opos.Z = actor->user.oz;
}
change_actor_stat(actor, STAT_SPIKE);
break;
}
case LIGHTING:
{
int wallcount = 0;
int8_t* wall_shade;
LIGHT_Tics(actor) = 0;
if (LIGHT_ShadeInc(actor) == 0)
LIGHT_ShadeInc(actor) = 1;
// save off original floor and ceil shades
LIGHT_FloorShade(actor) = actor->sector()->floorshade;
LIGHT_CeilingShade(actor) = actor->sector()->ceilingshade;
// count walls of sector
for(auto& wal : actor->sector()->walls)
{
wallcount++;
if (TEST_BOOL5(actor))
{
if (wal.twoSided())
wallcount++;
}
}
SpawnUser(actor, 0, nullptr);
actor->user.WallShade.Resize(wallcount);
wallcount = 0;
wall_shade = actor->user.WallShade.Data();
// save off original wall shades
for(auto& wal : actor->sector()->walls)
{
wall_shade[wallcount] = wal.shade;
wallcount++;
if (TEST_BOOL5(actor))
{
if (wal.twoSided())
{
wall_shade[wallcount] = wal.nextWall()->shade;
wallcount++;
}
}
}
actor->user.spal = actor->spr.pal;
// DON'T USE COVER function
change_actor_stat(actor, STAT_LIGHTING, true);
break;
}
case LIGHTING_DIFFUSE:
{
int wallcount = 0;
int8_t* wall_shade;
LIGHT_Tics(actor) = 0;
// save off original floor and ceil shades
LIGHT_FloorShade(actor) = actor->sector()->floorshade;
LIGHT_CeilingShade(actor) = actor->sector()->ceilingshade;
// count walls of sector
for (auto& wal : actor->sector()->walls)
{
wallcount++;
if (TEST_BOOL5(actor))
{
if (wal.twoSided())
wallcount++;
}
}
// !LIGHT
// make an wall_shade array and put it in User
SpawnUser(actor, 0, nullptr);
actor->user.WallShade.Resize(wallcount);
wallcount = 0;
wall_shade = actor->user.WallShade.Data();
// save off original wall shades
for (auto& wal : actor->sector()->walls)
{
wall_shade[wallcount] = wal.shade;
wallcount++;
if (TEST_BOOL5(actor))
{
if (wal.twoSided())
{
wall_shade[wallcount] = wal.nextWall()->shade;
wallcount++;
}
}
}
// DON'T USE COVER function
change_actor_stat(actor, STAT_LIGHTING_DIFFUSE, true);
break;
}
case SECT_VATOR_DEST:
change_actor_stat(actor, STAT_VATOR);
break;
case SO_WALL_DONT_MOVE_UPPER:
change_actor_stat(actor, STAT_WALL_DONT_MOVE_UPPER);
break;
case SO_WALL_DONT_MOVE_LOWER:
change_actor_stat(actor, STAT_WALL_DONT_MOVE_LOWER);
break;
case FLOOR_SLOPE_DONT_DRAW:
change_actor_stat(actor, STAT_FLOOR_SLOPE_DONT_DRAW);
break;
case DEMO_CAMERA:
actor->vel.Z = 100 / 256.; //attempt horiz control
change_actor_stat(actor, STAT_DEMO_CAMERA);
break;
case LAVA_ERUPT:
{
SpawnUser(actor, ST1, nullptr);
change_actor_stat(actor, STAT_NO_STATE);
actor->user.ActorActionFunc = DoLavaErupt;
// interval between erupts
if (SP_TAG10(actor) == 0)
SP_TAG10(actor) = 20;
// interval in seconds
actor->user.WaitTics = RandomRange(SP_TAG10(actor)) * 120;
// time to erupt
if (SP_TAG9(actor) == 0)
SP_TAG9(actor) = 10;
actor->spr.pos.Z += 30;
break;
}
case SECT_EXPLODING_CEIL_FLOOR:
{
SetSectorWallBits(actor->sector(), WALLFX_DONT_STICK, false, true);
if ((sectp->floorstat & CSTAT_SECTOR_SLOPE))
{
SP_TAG5(actor) = sectp->floorheinum;
sectp->setfloorslope(0);
}
if ((sectp->ceilingstat & CSTAT_SECTOR_SLOPE))
{
SP_TAG6(actor) = sectp->ceilingheinum;
sectp->setceilingslope(0);
}
SP_TAG4(actor) = int(fabs(sectp->ceilingz - sectp->floorz));
sectp->setceilingz(sectp->floorz);
change_actor_stat(actor, STAT_EXPLODING_CEIL_FLOOR);
break;
}
case SECT_COPY_SOURCE:
change_actor_stat(actor, STAT_COPY_SOURCE);
break;
case SECT_COPY_DEST:
{
SetSectorWallBits(actor->sector(), WALLFX_DONT_STICK, false, true);
change_actor_stat(actor, STAT_COPY_DEST);
break;
}
case SECT_WALL_MOVE:
change_actor_stat(actor, STAT_WALL_MOVE);
break;
case SECT_WALL_MOVE_CANSEE:
change_actor_stat(actor, STAT_WALL_MOVE_CANSEE);
break;
case SPRI_CLIMB_MARKER:
{
// setup climb marker
change_actor_stat(actor, STAT_CLIMB_MARKER);
// make a QUICK_LADDER sprite automatically
auto actorNew = insertActor(actor->sector(), STAT_QUICK_LADDER);
actorNew->spr.cstat = 0;
actorNew->spr.extra = 0;
actorNew->spr.pos = actor->spr.pos;
actorNew->spr.Angles.Yaw += DAngle180;
actorNew->spr.picnum = actor->spr.picnum;
actorNew->spr.pos += actor->spr.Angles.Yaw.ToVector() * 24;
break;
}
case SO_AUTO_TURRET:
#if 0
switch (gNet.MultiGameType)
{
case MULTI_GAME_NONE:
change_actor_stat(actor, STAT_ST1);
break;
case MULTI_GAME_COMMBAT:
KillActor(actor);
break;
case MULTI_GAME_COOPERATIVE:
change_actor_stat(actor, STAT_ST1);
break;
}
#else
change_actor_stat(actor, STAT_ST1);
#endif
break;
case SO_DRIVABLE_ATTRIB:
case SO_SCALE_XY_MULT:
case SO_SCALE_INFO:
case SO_SCALE_POINT_INFO:
case SO_TORNADO:
case SO_FLOOR_MORPH:
case SO_AMOEBA:
case SO_SET_SPEED:
case SO_ANGLE:
case SO_SPIN:
case SO_SPIN_REVERSE:
case SO_BOB_START:
case SO_BOB_SPEED:
case SO_TURN_SPEED:
case SO_SYNC1:
case SO_SYNC2:
case SO_LIMIT_TURN:
case SO_MATCH_EVENT:
case SO_MAX_DAMAGE:
case SO_RAM_DAMAGE:
case SO_SLIDE:
case SO_KILLABLE:
case SECT_SO_SPRITE_OBJ:
case SECT_SO_DONT_ROTATE:
case SECT_SO_CLIP_DIST:
{
// NOTE: These will get deleted by the sector
// object
// setup code
change_actor_stat(actor, STAT_ST1);
break;
}
case SOUND_SPOT:
SET_SP_TAG13(actor, SP_TAG4(actor));
change_actor_stat(actor, STAT_SOUND_SPOT);
break;
case STOP_SOUND_SPOT:
change_actor_stat(actor, STAT_STOP_SOUND_SPOT);
break;
case SPAWN_SPOT:
if (!actor->hasU())
SpawnUser(actor, ST1, nullptr);
if (actor->spr.scale.X == 1 && actor->spr.scale.Y == 1) // clear default scale.
actor->spr.scale = DVector2(0, 0);
change_actor_stat(actor, STAT_SPAWN_SPOT);
break;
case VIEW_THRU_CEILING:
case VIEW_THRU_FLOOR:
{
// make sure there is only one set per level of these
SWStatIterator it2(STAT_FAF);
while (auto itActor = it2.Next())
{
if (itActor->spr.hitag == actor->spr.hitag && itActor->spr.lotag == actor->spr.lotag)
{
I_Error("Two VIEW_THRU_ tags with same match found on level\n1: x %d, y %d \n2: x %d, y %d", int(actor->spr.pos.X), int(actor->spr.pos.Y), int(itActor->spr.pos.X), int(itActor->spr.pos.Y));
}
}
change_actor_stat(actor, STAT_FAF);
break;
}
case VIEW_LEVEL1:
case VIEW_LEVEL2:
case VIEW_LEVEL3:
case VIEW_LEVEL4:
case VIEW_LEVEL5:
case VIEW_LEVEL6:
{
change_actor_stat(actor, STAT_FAF);
break;
}
case PLAX_GLOB_Z_ADJUST:
{
actor->sector()->extra |= (SECTFX_Z_ADJUST);
PlaxCeilGlobZadjust = SP_TAG2(actor) * zmaptoworld;
PlaxFloorGlobZadjust = SP_TAG3(actor) * zmaptoworld;
KillActor(actor);
break;
}
case CEILING_Z_ADJUST:
{
actor->sector()->extra |= (SECTFX_Z_ADJUST);
change_actor_stat(actor, STAT_ST1);
break;
}
case FLOOR_Z_ADJUST:
{
actor->sector()->extra |= (SECTFX_Z_ADJUST);
change_actor_stat(actor, STAT_ST1);
break;
}
case WARP_TELEPORTER:
{
actor->spr.cstat |= (CSTAT_SPRITE_INVISIBLE);
actor->sector()->extra |= (SECTFX_WARP_SECTOR);
change_actor_stat(actor, STAT_WARP);
// if just a destination teleporter
// don't set up flags
if (SP_TAG10(actor) == 1)
break;
// move the the next wall
auto start_wall = actor->sector()->walls.Data();
auto wall_num = start_wall;
// Travel all the way around loop setting wall bits
do
{
// DO NOT TAG WHITE WALLS!
if (wall_num->twoSided())
{
wall_num->cstat |= (CSTAT_WALL_WARP_HITSCAN);
}
wall_num = wall_num->point2Wall();
}
while (wall_num != start_wall);
break;
}
case WARP_CEILING_PLANE:
case WARP_FLOOR_PLANE:
{
actor->spr.cstat |= (CSTAT_SPRITE_INVISIBLE);
actor->sector()->extra |= (SECTFX_WARP_SECTOR);
change_actor_stat(actor, STAT_WARP);
break;
}
case WARP_COPY_SPRITE1:
actor->spr.cstat |= (CSTAT_SPRITE_INVISIBLE);
actor->sector()->extra |= (SECTFX_WARP_SECTOR);
change_actor_stat(actor, STAT_WARP_COPY_SPRITE1);
break;
case WARP_COPY_SPRITE2:
actor->spr.cstat |= (CSTAT_SPRITE_INVISIBLE);
actor->sector()->extra |= (SECTFX_WARP_SECTOR);
change_actor_stat(actor, STAT_WARP_COPY_SPRITE2);
break;
case FIREBALL_TRAP:
case BOLT_TRAP:
case SPEAR_TRAP:
{
SpawnUser(actor, 0, nullptr);
ClearOwner(actor);
change_actor_stat(actor, STAT_TRAP);
break;
}
case SECT_SO_DONT_BOB:
{
sectp->u_defined = true;
sectp->flags |= (SECTFU_SO_DONT_BOB);
KillActor(actor);
break;
}
case SECT_LOCK_DOOR:
{
sectp->u_defined = true;
sectp->number = actor->spr.lotag;
sectp->stag = SECT_LOCK_DOOR;
KillActor(actor);
break;
}
case SECT_SO_SINK_DEST:
{
sectp->u_defined = true;
sectp->flags |= (SECTFU_SO_SINK_DEST);
sectp->number = actor->spr.lotag; // acually the offset Z
// value
KillActor(actor);
break;
}
case SECT_SO_DONT_SINK:
{
sectp->u_defined = true;
sectp->flags |= (SECTFU_SO_DONT_SINK);
KillActor(actor);
break;
}
case SO_SLOPE_FLOOR_TO_POINT:
{
sectp->u_defined = true;
sectp->flags |= (SECTFU_SO_SLOPE_FLOOR_TO_POINT);
sectp->extra |= (SECTFX_DYNAMIC_AREA);
KillActor(actor);
break;
}
case SO_SLOPE_CEILING_TO_POINT:
{
sectp->u_defined = true;
sectp->flags |= (SECTFU_SO_SLOPE_CEILING_TO_POINT);
sectp->extra |= (SECTFX_DYNAMIC_AREA);
KillActor(actor);
break;
}
case SECT_SO_FORM_WHIRLPOOL:
{
sectp->u_defined = true;
sectp->stag = SECT_SO_FORM_WHIRLPOOL;
sectp->height = actor->spr.lotag;
KillActor(actor);
break;
}
case SECT_ACTOR_BLOCK:
{
// move the the next wall
auto start_wall = actor->sector()->walls.Data();
auto wall_num = start_wall;
// Travel all the way around loop setting wall bits
do
{
wall_num->cstat |= (CSTAT_WALL_BLOCK_ACTOR);
if (wall_num->twoSided())
wall_num->nextWall()->cstat |= CSTAT_WALL_BLOCK_ACTOR;
wall_num = wall_num->point2Wall();
}
while (wall_num != start_wall);
KillActor(actor);
break;
}
}
}
}
break;
case RED_CARD:
num = 4;
goto KeyMain;
case RED_KEY:
num = 0;
goto KeyMain;
case BLUE_CARD:
num = 5;
goto KeyMain;
case BLUE_KEY:
num = 1;
goto KeyMain;
case GREEN_CARD:
num = 6;
goto KeyMain;
case GREEN_KEY:
num = 2;
goto KeyMain;
case YELLOW_CARD:
num = 7;
goto KeyMain;
case YELLOW_KEY:
num = 3;
goto KeyMain;
case GOLD_SKELKEY:
num = 8;
goto KeyMain;
case SILVER_SKELKEY:
num = 9;
goto KeyMain;
case BRONZE_SKELKEY:
num = 10;
goto KeyMain;
case RED_SKELKEY:
num = 11;
KeyMain:
{
if (gNet.MultiGameType == MULTI_GAME_COMMBAT || gNet.MultiGameType == MULTI_GAME_AI_BOTS)
{
KillActor(actor);
break;
}
SpawnUser(actor, 0, nullptr);
actor->spr.picnum = actor->user.ID = actor->spr.picnum;
actor->user.spal = actor->spr.pal; // Set the palette from build
//actor->spr.cstat |= (CSTAT_SPRITE_ALIGNMENT_WALL);
ChangeState(actor, s_Key[num]);
picanm[actor->spr.picnum].sf &= ~(PICANM_ANIMTYPE_MASK);
picanm[actor->spr.picnum + 1].sf &= ~(PICANM_ANIMTYPE_MASK);
change_actor_stat(actor, STAT_ITEM);
actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK | CSTAT_SPRITE_BLOCK_HITSCAN | CSTAT_SPRITE_ONE_SIDE);
actor->user.Radius = 500;
actor->spr.hitag = LUMINOUS; //Set so keys over ride colored lighting
DoActorZrange(actor);
}
break;
// Used for multiplayer locks
case 1846:
case 1850:
case 1852:
case 2470:
if ((actor->spr.extra & SPRX_MULTI_ITEM))
if (numplayers <= 1 || gNet.MultiGameType == MULTI_GAME_COOPERATIVE)
{
KillActor(actor);
}
break;
case FIRE_FLY0:
break;
case ICON_REPAIR_KIT:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_REPAIR_KIT, s_RepairKit);
IconDefault(actor);
break;
case ICON_STAR:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_STAR, s_IconStar);
IconDefault(actor);
break;
case ICON_LG_MINE:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_LG_MINE, s_IconLgMine);
IconDefault(actor);
break;
case ICON_MICRO_GUN:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_MICRO_GUN, s_IconMicroGun);
IconDefault(actor);
break;
case ICON_MICRO_BATTERY:
NUKE_REPLACEMENT:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_MICRO_BATTERY, s_IconMicroBattery);
IconDefault(actor);
break;
case ICON_UZI:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_UZI, s_IconUzi);
IconDefault(actor);
break;
case ICON_UZIFLOOR:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_UZIFLOOR, s_IconUziFloor);
IconDefault(actor);
break;
case ICON_LG_UZI_AMMO:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_LG_UZI_AMMO, s_IconLgUziAmmo);
IconDefault(actor);
break;
case ICON_GRENADE_LAUNCHER:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_GRENADE_LAUNCHER, s_IconGrenadeLauncher);
IconDefault(actor);
break;
case ICON_LG_GRENADE:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_LG_GRENADE, s_IconLgGrenade);
IconDefault(actor);
break;
case ICON_RAIL_GUN:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_RAIL_GUN, s_IconRailGun);
IconDefault(actor);
break;
case ICON_RAIL_AMMO:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_RAIL_AMMO, s_IconRailAmmo);
IconDefault(actor);
break;
case ICON_ROCKET:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_ROCKET, s_IconRocket);
IconDefault(actor);
break;
case ICON_LG_ROCKET:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_LG_ROCKET, s_IconLgRocket);
IconDefault(actor);
break;
case ICON_SHOTGUN:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_SHOTGUN, s_IconShotgun);
actor->user.Radius = 350; // Shotgun is hard to pick up for some reason.
IconDefault(actor);
break;
case ICON_LG_SHOTSHELL:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_LG_SHOTSHELL, s_IconLgShotshell);
IconDefault(actor);
break;
case ICON_AUTORIOT:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_AUTORIOT, s_IconAutoRiot);
IconDefault(actor);
break;
case ICON_GUARD_HEAD:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_GUARD_HEAD, s_IconGuardHead);
IconDefault(actor);
break;
case ICON_FIREBALL_LG_AMMO:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_FIREBALL_LG_AMMO, s_IconFireballLgAmmo);
IconDefault(actor);
break;
case ICON_HEART:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_HEART, s_IconHeart);
IconDefault(actor);
break;
case ICON_HEART_LG_AMMO:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_HEART_LG_AMMO, s_IconHeartLgAmmo);
IconDefault(actor);
break;
#if 0
case ICON_ELECTRO:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_ELECTRO, s_IconElectro);
IconDefault(actor);
break;
#endif
case ICON_SPELL:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_SPELL, s_IconSpell);
IconDefault(actor);
PicAnimOff(actor->spr.picnum);
break;
case ICON_ARMOR:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_ARMOR, s_IconArmor);
if (actor->spr.pal != PALETTE_PLAYER3)
actor->spr.pal = actor->user.spal = PALETTE_PLAYER1;
else
actor->spr.pal = actor->user.spal = PALETTE_PLAYER3;
IconDefault(actor);
break;
case ICON_MEDKIT:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_MEDKIT, s_IconMedkit);
IconDefault(actor);
break;
case ICON_SM_MEDKIT:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_SM_MEDKIT, s_IconSmMedkit);
IconDefault(actor);
break;
case ICON_CHEMBOMB:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_CHEMBOMB, s_IconChemBomb);
IconDefault(actor);
break;
case ICON_FLASHBOMB:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_FLASHBOMB, s_IconFlashBomb);
IconDefault(actor);
break;
case ICON_NUKE:
if (gNet.MultiGameType)
{
if (!gNet.Nuke)
{
goto NUKE_REPLACEMENT;
break;
}
}
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_NUKE, s_IconNuke);
IconDefault(actor);
break;
case ICON_CALTROPS:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_CALTROPS, s_IconCaltrops);
IconDefault(actor);
break;
case ICON_BOOSTER:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_BOOSTER, s_IconBooster);
IconDefault(actor);
break;
case ICON_HEAT_CARD:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_HEAT_CARD, s_IconHeatCard);
IconDefault(actor);
break;
#if 0
case ICON_ENVIRON_SUIT:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_ENVIRON_SUIT, s_IconEnvironSuit);
IconDefault(actor);
PicAnimOff(actor->spr.picnum);
break;
#endif
case ICON_CLOAK:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_CLOAK, s_IconCloak);
IconDefault(actor);
PicAnimOff(actor->spr.picnum);
break;
case ICON_FLY:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_FLY, s_IconFly);
IconDefault(actor);
PicAnimOff(actor->spr.picnum);
break;
case ICON_NIGHT_VISION:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_NIGHT_VISION, s_IconNightVision);
IconDefault(actor);
PicAnimOff(actor->spr.picnum);
break;
case ICON_FLAG:
if (!IconSpawn(actor))
{
KillActor(actor);
break;
}
SpawnUser(actor, ICON_FLAG, s_IconFlag);
actor->user.spal = actor->spr.pal;
actor->sector()->hitag = 9000; // Put flag's color in sect containing it
actor->sector()->lotag = actor->user.spal;
IconDefault(actor);
PicAnimOff(actor->spr.picnum);
break;
#if 0
case 380:
case 396:
case 430:
case 512:
case 521:
case 541:
case 2720:
#endif
case 3143:
case 3157:
{
SpawnUser(actor, actor->spr.picnum, nullptr);
change_actor_stat(actor, STAT_STATIC_FIRE);
actor->user.ID = FIREBALL_FLAMES;
actor->user.Radius = 200;
actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK);
actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK_HITSCAN);
actor->spr.hitag = LUMINOUS; //Always full brightness
actor->spr.shade = -40;
break;
}
// blades
case BLADE1:
case BLADE2:
case BLADE3:
case 5011:
{
SpawnUser(actor, actor->spr.picnum, nullptr);
change_actor_stat(actor, STAT_DEFAULT);
actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK);
actor->spr.cstat |= (CSTAT_SPRITE_BLOCK_HITSCAN);
actor->spr.extra |= (SPRX_BLADE);
break;
}
case BREAK_LIGHT:
case BREAK_BARREL:
case BREAK_PEDISTAL:
case BREAK_BOTTLE1:
case BREAK_BOTTLE2:
case BREAK_MUSHROOM:
//if ((actor->spr.extra & SPRX_BREAKABLE))
// break;
SpawnUser(actor, actor->spr.picnum, nullptr);
SetActorSizeX(actor);
actor->spr.cstat |= (CSTAT_SPRITE_BREAKABLE);
actor->spr.extra |= (SPRX_BREAKABLE);
break;
// switches
case 581:
case 582:
case 558:
case 559:
case 560:
case 561:
case 562:
case 563:
case 564:
case 565:
case 566:
case 567:
case 568:
case 569:
case 570:
case 571:
case 572:
case 573:
case 574:
case 551:
case 552:
case 575:
case 576:
case 577:
case 578:
case 579:
case 589:
case 583:
case 584:
case 553:
case 554:
{
if ((actor->spr.extra & SPRX_MULTI_ITEM))
{
if (numplayers <= 1 || gNet.MultiGameType == MULTI_GAME_COOPERATIVE)
{
KillActor(actor);
break;
}
}
actor->spr.cstat |= (CSTAT_SPRITE_BLOCK | CSTAT_SPRITE_BLOCK_HITSCAN);
break;
}
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
bool ItemSpotClear(DSWActor* actor, short statnum, short id)
{
bool found = false;
int i;
if (TEST_BOOL2(actor))
{
SWSectIterator it(actor->sector());
while (auto itActor = it.Next())
{
if (itActor->spr.statnum == statnum && itActor->user.ID == id)
{
found = true;
break;
}
}
}
return !found;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void SetupItemForJump(DSWActor* spawner, DSWActor* actor)
{
// setup item for jumping
if (SP_TAG7(spawner))
{
change_actor_stat(actor, STAT_SKIP4);
actor->user.ceiling_dist = (6);
actor->user.floor_dist = (0);
actor->user.Counter = 0;
actor->vel.X = SP_TAG7(spawner) * 0.25;
actor->vel.Z = SP_TAG8(spawner) * -0.125;
UpdateChange(actor);
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
int ActorCoughItem(DSWActor* actor)
{
short choose;
DSWActor* actorNew = nullptr;
switch (actor->user.ID)
{
case SAILORGIRL_R0:
ASSERT(actor->insector());
actorNew = insertActor(actor->sector(), STAT_SPAWN_ITEMS);
actorNew->spr.cstat = 0;
actorNew->spr.extra = 0;
actorNew->spr.pos = ActorVectOfMiddle(actor);
actorNew->spr.Angles.Yaw = nullAngle;
actorNew->spr.extra = 0;
// vel
SP_TAG7(actorNew) = 1;
// zvel
SP_TAG8(actorNew) = 40;
choose = RANDOM_P2(1024);
if (choose > 854)
SP_TAG3(actorNew) = 91; // Match number
else if (choose > 684)
SP_TAG3(actorNew) = 48; // Match number
else if (choose > 514)
SP_TAG3(actorNew) = 58; // Match number
else if (choose > 344)
SP_TAG3(actorNew) = 60; // Match number
else if (choose > 174)
SP_TAG3(actorNew) = 62; // Match number
else
SP_TAG3(actorNew) = 68; // Match number
// match
SP_TAG2(actorNew) = -1;
// kill
RESET_BOOL1(actorNew);
SpawnItemsMatch(-1);
break;
case GORO_RUN_R0:
if (RANDOM_P2(1024) < 700)
return 0;
ASSERT(actor->insector());
actorNew = insertActor(actor->sector(), STAT_SPAWN_ITEMS);
actorNew->spr.cstat = 0;
actorNew->spr.extra = 0;
actorNew->spr.pos = ActorVectOfMiddle(actor);
actorNew->spr.Angles.Yaw = nullAngle;
actorNew->spr.extra = 0;
// vel
SP_TAG7(actorNew) = 1;
// zvel
SP_TAG8(actorNew) = 40;
SP_TAG3(actorNew) = 69; // Match number
// match
SP_TAG2(actorNew) = -1;
// kill
RESET_BOOL1(actorNew);
SpawnItemsMatch(-1);
break;
case RIPPER2_RUN_R0:
if (RANDOM_P2(1024) < 700)
return 0;
ASSERT(actor->insector());
actorNew = insertActor(actor->sector(), STAT_SPAWN_ITEMS);
actorNew->spr.cstat = 0;
actorNew->spr.extra = 0;
actorNew->spr.pos = ActorVectOfMiddle(actor);
actorNew->spr.Angles.Yaw = nullAngle;
actorNew->spr.extra = 0;
// vel
SP_TAG7(actorNew) = 1;
// zvel
SP_TAG8(actorNew) = 40;
SP_TAG3(actorNew) = 70; // Match number
// match
SP_TAG2(actorNew) = -1;
// kill
RESET_BOOL1(actorNew);
SpawnItemsMatch(-1);
break;
case NINJA_RUN_R0:
if (actor->user.PlayerP)
{
if (RANDOM_P2(1024) > 200)
return 0;
ASSERT(actor->insector());
actorNew = insertActor(actor->sector(), STAT_SPAWN_ITEMS);
actorNew->spr.cstat = 0;
actorNew->spr.extra = 0;
actorNew->spr.pos = ActorVectOfMiddle(actor);
actorNew->spr.Angles.Yaw = nullAngle;
actorNew->spr.extra = 0;
// vel
SP_TAG7(actorNew) = 1;
// zvel
SP_TAG8(actorNew) = 40;
switch (actor->user.WeaponNum)
{
case WPN_UZI:
SP_TAG3(actorNew) = 0;
break;
case WPN_SHOTGUN:
SP_TAG3(actorNew) = 51;
break;
case WPN_STAR:
if (actor->user.PlayerP->WpnAmmo[WPN_STAR] < 9)
break;
SP_TAG3(actorNew) = 41;
break;
case WPN_MINE:
if (actor->user.PlayerP->WpnAmmo[WPN_MINE] < 5)
break;
SP_TAG3(actorNew) = 42;
break;
case WPN_MICRO:
case WPN_ROCKET:
SP_TAG3(actorNew) = 43;
break;
case WPN_GRENADE:
SP_TAG3(actorNew) = 45;
break;
case WPN_RAIL:
SP_TAG3(actorNew) = 47;
break;
case WPN_HEART:
SP_TAG3(actorNew) = 55;
break;
case WPN_HOTHEAD:
SP_TAG3(actorNew) = 53;
break;
}
// match
SP_TAG2(actorNew) = -1;
// kill
RESET_BOOL1(actorNew);
SpawnItemsMatch(-1);
break;
}
if (RANDOM_P2(1024) < 512)
return 0;
ASSERT(actor->insector());
actorNew = insertActor(actor->sector(), STAT_SPAWN_ITEMS);
actorNew->spr.cstat = 0;
actorNew->spr.extra = 0;
actorNew->spr.pos = ActorVectOfMiddle(actor);
actorNew->spr.Angles.Yaw = nullAngle;
actorNew->spr.extra = 0;
// vel
SP_TAG7(actorNew) = 1;
// zvel
SP_TAG8(actorNew) = 40;
if (actor->user.spal == PAL_XLAT_LT_TAN)
{
SP_TAG3(actorNew) = 44;
}
else if (actor->user.spal == PAL_XLAT_LT_GREY)
{
SP_TAG3(actorNew) = 46;
}
else if (actor->user.spal == PALETTE_PLAYER5) // Green Ninja
{
if (RANDOM_P2(1024) < 700)
SP_TAG3(actorNew) = 61;
else
SP_TAG3(actorNew) = 60;
}
else if (actor->user.spal == PALETTE_PLAYER3) // Red Ninja
{
// type
if (RANDOM_P2(1024) < 800)
SP_TAG3(actorNew) = 68;
else
SP_TAG3(actorNew) = 44;
}
else
{
if (RANDOM_P2(1024) < 512)
SP_TAG3(actorNew) = 41;
else
SP_TAG3(actorNew) = 68;
}
// match
SP_TAG2(actorNew) = -1;
// kill
RESET_BOOL1(actorNew);
SpawnItemsMatch(-1);
break;
case PACHINKO1:
case PACHINKO2:
case PACHINKO3:
case PACHINKO4:
ASSERT(actor->insector());
actorNew = insertActor(actor->sector(), STAT_SPAWN_ITEMS);
actorNew->spr.cstat = 0;
actorNew->spr.extra = 0;
actorNew->spr.pos.XY() = actor->spr.pos.XY();
actorNew->spr.pos.Z = ActorLowerZ(actor) + 10;
actorNew->spr.Angles.Yaw = actor->spr.Angles.Yaw;
// vel
SP_TAG7(actorNew) = 10;
// zvel
SP_TAG8(actorNew) = 10;
if (actor->user.ID == PACHINKO1)
{
if (RANDOM_P2(1024) < 600)
SP_TAG3(actorNew) = 64; // Small MedKit
else
SP_TAG3(actorNew) = 59; // Fortune Cookie
}
else if (actor->user.ID == PACHINKO2)
{
if (RANDOM_P2(1024) < 600)
SP_TAG3(actorNew) = 52; // Lg Shot Shell
else
SP_TAG3(actorNew) = 68; // Uzi clip
}
else if (actor->user.ID == PACHINKO3)
{
if (RANDOM_P2(1024) < 600)
SP_TAG3(actorNew) = 57;
else
SP_TAG3(actorNew) = 63;
}
else if (actor->user.ID == PACHINKO4)
{
if (RANDOM_P2(1024) < 600)
SP_TAG3(actorNew) = 60;
else
SP_TAG3(actorNew) = 61;
}
// match
SP_TAG2(actorNew) = -1;
// kill
RESET_BOOL1(actorNew);
SpawnItemsMatch(-1);
break;
}
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
int SpawnItemsMatch(short match)
{
DSWActor* spawnedActor = nullptr;
SWStatIterator it(STAT_SPAWN_ITEMS);
while (auto itActor = it.Next())
{
if (SP_TAG2(itActor) != match)
continue;
switch (SP_TAG3(itActor))
{
case 90:
spawnedActor = BunnyHatch2(itActor);
spawnedActor->user.spal = spawnedActor->spr.pal = PALETTE_PLAYER8; // Boy
spawnedActor->spr.Angles.Yaw = itActor->spr.Angles.Yaw;
break;
case 91:
spawnedActor = BunnyHatch2(itActor);
spawnedActor->user.spal = spawnedActor->spr.pal = PALETTE_PLAYER0; // Girl
spawnedActor->spr.Angles.Yaw = itActor->spr.Angles.Yaw;
break;
case 92:
spawnedActor = BunnyHatch2(itActor);
spawnedActor->spr.Angles.Yaw = itActor->spr.Angles.Yaw;
break;
case 40:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_REPAIR_KIT))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_REPAIR_KIT, s_RepairKit, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 41:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_STAR))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_STAR, s_IconStar, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 42:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_LG_MINE))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_LG_MINE, s_IconLgMine, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 43:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_MICRO_GUN))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_MICRO_GUN, s_IconMicroGun, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 44:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_MICRO_BATTERY))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_MICRO_BATTERY, s_IconMicroBattery, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 45:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_GRENADE_LAUNCHER))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_GRENADE_LAUNCHER, s_IconGrenadeLauncher, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 46:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_LG_GRENADE))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_LG_GRENADE, s_IconLgGrenade, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 47:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_RAIL_GUN))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_RAIL_GUN, s_IconRailGun, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 48:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_RAIL_AMMO))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_RAIL_AMMO, s_IconRailAmmo, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 49:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_ROCKET))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_ROCKET, s_IconRocket, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 51:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_SHOTGUN))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_SHOTGUN, s_IconShotgun, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 52:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_LG_SHOTSHELL))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_LG_SHOTSHELL, s_IconLgShotshell, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 53:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_GUARD_HEAD))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_GUARD_HEAD, s_IconGuardHead, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 54:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_FIREBALL_LG_AMMO))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_FIREBALL_LG_AMMO, s_IconFireballLgAmmo, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 55:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_HEART))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_HEART, s_IconHeart, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 56:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_HEART_LG_AMMO))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_HEART_LG_AMMO, s_IconHeartLgAmmo, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 57:
{
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_ARMOR))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_ARMOR, s_IconArmor, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
if (spawnedActor->spr.pal != PALETTE_PLAYER3)
spawnedActor->spr.pal = spawnedActor->user.spal = PALETTE_PLAYER1;
else
spawnedActor->spr.pal = spawnedActor->user.spal = PALETTE_PLAYER3;
break;
}
case 58:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_MEDKIT))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_MEDKIT, s_IconMedkit, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 59:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_SM_MEDKIT))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_SM_MEDKIT, s_IconSmMedkit, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 60:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_CHEMBOMB))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_CHEMBOMB, s_IconChemBomb, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 61:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_FLASHBOMB))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_FLASHBOMB, s_IconFlashBomb, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 62:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_NUKE))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_NUKE, s_IconNuke, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 63:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_CALTROPS))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_CALTROPS, s_IconCaltrops, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 64:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_BOOSTER))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_BOOSTER, s_IconBooster, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 65:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_HEAT_CARD))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_HEAT_CARD, s_IconHeatCard, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 66:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_CLOAK))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_CLOAK, s_IconCloak, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 67:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_NIGHT_VISION))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_NIGHT_VISION, s_IconNightVision, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 68:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_LG_UZI_AMMO))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_LG_UZI_AMMO, s_IconLgUziAmmo, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 69:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_GUARD_HEAD))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_GUARD_HEAD, s_IconGuardHead, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 70:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_HEART))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_HEART, s_IconHeart, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 20:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_UZIFLOOR))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_UZIFLOOR, s_IconUziFloor, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 32:
case 0:
if (!ItemSpotClear(itActor, STAT_ITEM, ICON_UZI))
break;
spawnedActor = SpawnActor(STAT_ITEM, ICON_UZI, s_IconUzi, itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->user.Flags2 |= SPR2_NEVER_RESPAWN;
IconDefault(spawnedActor);
SetupItemForJump(itActor, spawnedActor);
break;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
case 12:
{
short num;
static const uint8_t KeyPal[] =
{
PALETTE_PLAYER9,
PALETTE_PLAYER7,
PALETTE_PLAYER6,
PALETTE_PLAYER4,
PALETTE_PLAYER9,
PALETTE_PLAYER7,
PALETTE_PLAYER6,
PALETTE_PLAYER4,
PALETTE_PLAYER4,
PALETTE_PLAYER1,
PALETTE_PLAYER8,
PALETTE_PLAYER9
};
if (gNet.MultiGameType == MULTI_GAME_COMMBAT || gNet.MultiGameType == MULTI_GAME_AI_BOTS)
break;
num = SP_TAG3(itActor) - 1;
if (!ItemSpotClear(itActor, STAT_ITEM, s_Key[num]->Pic))
break;
spawnedActor = SpawnActor(STAT_ITEM, s_Key[num]->Pic, s_Key[num], itActor->sector(), itActor->spr.pos, itActor->spr.Angles.Yaw);
spawnedActor->spr.picnum = spawnedActor->user.ID = s_Key[num]->Pic;
// need to set the palette here - suggest table lookup
spawnedActor->user.spal = spawnedActor->spr.pal = KeyPal[num];
ChangeState(spawnedActor, s_Key[num]);
picanm[spawnedActor->spr.picnum].sf &= ~(PICANM_ANIMTYPE_MASK);
picanm[spawnedActor->spr.picnum + 1].sf &= ~(PICANM_ANIMTYPE_MASK);
SetupItemForJump(itActor, spawnedActor);
break;
}
}
if (!TEST_BOOL1(itActor))
KillActor(itActor);
}
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
int NewStateGroup(DSWActor* actor, STATE* StateGroup[])
{
if (!StateGroup)
return 0;
ASSERT(actor->hasU());
// Kind of a goofy check, but it should catch alot of invalid states!
// BTW, 6144 is the max tile number allowed in editart.
if (actor->user.State && (actor->user.State->Pic < 0 || actor->user.State->Pic > MAXTILES)) // JBF: verify this!
return 0;
actor->user.Rot = StateGroup;
actor->user.State = actor->user.StateStart = StateGroup[0];
actor->user.Tics = 0;
// turn anims off because people keep setting them in the
// art file
picanm[actor->spr.picnum].sf &= ~(PICANM_ANIMTYPE_MASK);
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
bool SpriteOverlap(DSWActor* actor_a, DSWActor* actor_b)
{
if (!actor_a->hasU() || !actor_b->hasU()) return false;
double dist = (actor_a->spr.pos.XY() - actor_b->spr.pos.XY()).Length();
if (dist > (actor_a->user.fRadius() + actor_b->user.fRadius()))
{
return false;
}
double spa_tos = ActorZOfTop(actor_a);
double spa_bos = ActorZOfBottom(actor_a);
double spb_tos = ActorZOfTop(actor_b);
double spb_bos = ActorZOfBottom(actor_b);
double overlap_z = actor_a->user.OverlapZ + actor_b->user.OverlapZ;
// if the top of sprite a is below the bottom of b
if (spa_tos - overlap_z > spb_bos)
{
return false;
}
// if the top of sprite b is is below the bottom of a
if (spb_tos - overlap_z > spa_bos)
{
return false;
}
return true;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
bool SpriteOverlapZ(DSWActor* actor_a, DSWActor* actor_b, double z_overlap)
{
double spa_tos = ActorZOfTop(actor_a);
double spa_bos = ActorZOfBottom(actor_a);
double spb_tos = ActorZOfTop(actor_b);
double spb_bos = ActorZOfBottom(actor_b);
// if the top of sprite a is below the bottom of b
if (spa_tos + z_overlap > spb_bos)
{
return false;
}
// if the top of sprite b is is below the bottom of a
if (spb_tos + z_overlap > spa_bos)
{
return false;
}
return true;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void getzrangepoint(const DVector3& pos, sectortype* sect,
double* ceil_z, Collision* ceilhit, double* flor_z, Collision* florhit)
{
short cstat;
if (sect == nullptr)
{
*ceil_z = 0x800000;
*flor_z = 0x7fffff;
florhit->invalidate();
return;
}
// Initialize z's and hits to the current sector's top&bottom
calcSlope(sect, pos, ceil_z, flor_z);
ceilhit->setSector(sect);
florhit->setSector(sect);
// Go through sprites of only the current sector
SWSectIterator it(sect);
while (auto itActor = it.Next())
{
cstat = itActor->spr.cstat;
if ((cstat & (CSTAT_SPRITE_ALIGNMENT_MASK | CSTAT_SPRITE_BLOCK)) != (CSTAT_SPRITE_ALIGNMENT_FLOOR|CSTAT_SPRITE_BLOCK))
continue; // Only check blocking floor sprites
double fdaz = spriteGetZOfSlopef(&itActor->spr, pos.XY(), spriteGetSlope(itActor));
// Only check if sprite's 2-sided or your on the 1-sided side
if (((cstat & CSTAT_SPRITE_ONE_SIDE) != 0) && ((pos.Z > fdaz) == ((cstat & CSTAT_SPRITE_YFLIP) == 0)))
continue;
DVector2 out[4];
GetFlatSpritePosition(itActor, itActor->spr.pos.XY(), out);
if (!insidePoly(pos.X, pos.Y, out, 4)) continue;
// Clipping time!
if (pos.Z > fdaz)
{
if (fdaz > *ceil_z)
{
*ceil_z = fdaz;
ceilhit->setSprite(itActor);
}
}
else
{
if (fdaz < *flor_z)
{
*flor_z = fdaz;
florhit->setSprite(itActor);
}
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void DoActorZrange(DSWActor* actor)
{
Collision ceilhit, florhit;
auto save_cstat = actor->spr.cstat & CSTAT_SPRITE_BLOCK;
actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK);
DVector3 pos = actor->spr.pos.plusZ(-ActorSizeZ(actor) * 0.5);
FAFgetzrange(pos, actor->sector(), &actor->user.hiz, &ceilhit, &actor->user.loz, &florhit, actor->clipdist - GETZRANGE_CLIP_ADJ, CLIPMASK_ACTOR);
actor->spr.cstat |= save_cstat;
actor->user.lo_sectp = actor->user.hi_sectp = nullptr;
actor->user.highActor = nullptr;
actor->user.lowActor = nullptr;
switch (ceilhit.type)
{
case kHitSprite:
actor->user.highActor = ceilhit.actor();
break;
case kHitSector:
actor->user.hi_sectp = ceilhit.hitSector;
break;
default:
ASSERT(true==false);
break;
}
switch (florhit.type)
{
case kHitSprite:
actor->user.lowActor = florhit.actor();
break;
case kHitSector:
actor->user.lo_sectp = florhit.hitSector;
break;
default:
ASSERT(true==false);
break;
}
}
//---------------------------------------------------------------------------
//
// !AIC - puts getzrange results into USER varaible actor->user.loz. actor->user.hiz, actor->user.lo_sectp, actor->user.hi_sectp, etc.
// The loz and hiz are used a lot.
//
//---------------------------------------------------------------------------
int DoActorGlobZ(DSWActor* actor)
{
actor->user.loz = globloz;
actor->user.hiz = globhiz;
actor->user.lo_sectp = actor->user.hi_sectp = nullptr;
actor->user.highActor = nullptr;
actor->user.lowActor = nullptr;
switch (globhihit.type)
{
case kHitSprite:
actor->user.highActor = globhihit.actor();
break;
default:
actor->user.hi_sectp = globhihit.hitSector;
break;
}
switch (globlohit.type)
{
case kHitSprite:
actor->user.lowActor = globlohit.actor();
break;
default:
actor->user.lo_sectp = globlohit.hitSector;
break;
}
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
bool ActorDrop(DSWActor* actor, const DVector3& pos, sectortype* new_sector, double min_height)
{
double hiz, loz;
Collision ceilhit, florhit;
// look only at the center point for a floor sprite
auto save_cstat = (actor->spr.cstat & CSTAT_SPRITE_BLOCK);
actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK);
FAFgetzrangepoint(pos.plusZ(-ActorSizeZ(actor) * 0.5), new_sector, &hiz, &ceilhit, &loz, &florhit);
actor->spr.cstat |= (save_cstat);
if (florhit.type < 0 || ceilhit.type < 0)
{
return true;
}
switch (florhit.type)
{
case kHitSprite:
{
auto hsp = florhit.actor();
// if its a floor sprite and not too far down
if ((hsp->spr.cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR) &&
(abs(loz - pos.Z) <= min_height))
{
return false;
}
break;
}
case kHitSector:
{
if (abs(loz - pos.Z) <= min_height)
{
return false;
}
break;
}
default:
ASSERT(true == false);
break;
}
return true;
}
//---------------------------------------------------------------------------
//
// Primarily used in ai.c for now - need to get rid of
//
//---------------------------------------------------------------------------
bool DropAhead(DSWActor* actor, double min_height)
{
auto vect = actor->spr.pos + actor->spr.Angles.Yaw.ToVector() * 16;
auto newsector = actor->sector();
updatesector(vect, &newsector);
// look straight down for a drop
if (ActorDrop(actor, vect, newsector, min_height))
return true;
return false;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
/*
!AIC KEY - Called by ai.c routines. Calls move_sprite which calls clipmove.
This incapulates move_sprite and makes sure that actors don't walk off of
ledges. If it finds itself in mid air then it restores the last good
position. This is a hack because Ken had no good way of doing this from his
code. ActorDrop() is called from here.
*/
int move_actor(DSWActor* actor, const DVector3& change)
{
DSWActor* highActor;
DSWActor* lowActor;
sectortype* lo_sectp,* hi_sectp;
int cliptype = CLIPMASK_ACTOR;
if (actor->user.Flags & (SPR_NO_SCAREDZ))
{
// For COOLG & HORNETS
// set to actual z before you move
actor->spr.pos.Z = actor->user.pos.Z;
}
// save off x,y values
auto apos = actor->spr.pos;
auto loz = actor->user.loz;
auto hiz = actor->user.hiz;
lowActor = actor->user.lowActor;
highActor = actor->user.highActor;
lo_sectp = actor->user.lo_sectp;
hi_sectp = actor->user.hi_sectp;
auto sect = actor->sector();
actor->user.coll = move_sprite(actor, change, actor->user.ceiling_dist, actor->user.floor_dist, cliptype, ACTORMOVETICS);
ASSERT(actor->insector());
// try and determine whether you moved > lo_step in the z direction
if (!(actor->user.Flags & (SPR_NO_SCAREDZ | SPR_JUMPING | SPR_CLIMBING | SPR_FALLING | SPR_DEAD | SPR_SWIMMING)))
{
if (abs(actor->spr.pos.Z - globloz) > actor->user.lo_step)
{
// cancel move
actor->spr.pos = apos;
//actor->spr.pos.Z = actor->user.loz; // place on ground in case you are in the air
actor->user.loz = loz;
actor->user.hiz = hiz;
actor->user.lowActor = lowActor;
actor->user.highActor = highActor;
actor->user.lo_sectp = lo_sectp;
actor->user.hi_sectp = hi_sectp;
actor->user.coll.invalidate();
ChangeActorSect(actor, sect);
return false;
}
if (ActorDrop(actor, actor->spr.pos, actor->sector(), actor->user.lo_step))
{
// cancel move
actor->spr.pos = apos;
//actor->spr.pos.Z = actor->user.loz; // place on ground in case you are in the air
actor->user.loz = loz;
actor->user.hiz = hiz;
actor->user.lowActor = lowActor;
actor->user.highActor = highActor;
actor->user.lo_sectp = lo_sectp;
actor->user.hi_sectp = hi_sectp;
actor->user.coll.invalidate();
ChangeActorSect(actor, sect);
return false;
}
}
actor->user.Flags |= (SPR_MOVED);
if (actor->user.coll.type == kHitNone)
{
// Keep track of how far sprite has moved
double dist = (apos.XY() - actor->spr.pos.XY()).Length();
actor->user.TargetDist -= dist;
actor->user.Dist += dist;
actor->user.DistCheck += dist;
return true;
}
else
{
return false;
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
int DoStayOnFloor(DSWActor* actor)
{
actor->spr.pos.Z = actor->sector()->floorz;
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
int DoGrating(DSWActor* actor)
{
int dir;
const int GRATE_FACTORI = 3;
const double GRATE_FACTOR = GRATE_FACTORI * maptoworld;
// reduce to 0 to 3 value
dir = int(actor->spr.Angles.Yaw.Normalized360().Degrees()) / 90;
DVector2 v(0, 0);
if ((dir & 1) == 0)
{
if (dir == 0)
v.X = 2 * GRATE_FACTOR;
else
v.X = -2 * GRATE_FACTOR;
}
else
{
if (dir == 1)
v.Y= 2 * GRATE_FACTOR;
else
v.Y= -2 * GRATE_FACTOR;
}
actor->spr.pos += v;
actor->spr.hitag -= GRATE_FACTORI;
if (actor->spr.hitag <= 0)
{
change_actor_stat(actor, STAT_DEFAULT);
actor->clearUser();
}
SetActorZ(actor, actor->spr.pos);
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
int DoKey(DSWActor* actor)
{
actor->spr.Angles.Yaw += mapangle(14 * ACTORMOVETICS);
DoGet(actor);
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
int DoCoin(DSWActor* actor)
{
int offset;
actor->user.WaitTics -= ACTORMOVETICS * 2;
if (actor->user.WaitTics <= 0)
{
KillActor(actor);
return 0;
}
if (actor->user.WaitTics < 10*120)
{
if (actor->user.StateStart != s_GreenCoin)
{
offset = int(actor->user.State - actor->user.StateStart);
ChangeState(actor, s_GreenCoin);
actor->user.State = actor->user.StateStart + offset;
}
}
else if (actor->user.WaitTics < 20*120)
{
if (actor->user.StateStart != s_YellowCoin)
{
offset = int(actor->user.State - actor->user.StateStart);
ChangeState(actor, s_YellowCoin);
actor->user.State = actor->user.StateStart + offset;
}
}
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
int KillGet(DSWActor* actor)
{
switch (gNet.MultiGameType)
{
case MULTI_GAME_NONE:
case MULTI_GAME_COOPERATIVE:
KillActor(actor);
break;
case MULTI_GAME_COMMBAT:
case MULTI_GAME_AI_BOTS:
if (actor->user.Flags2 & (SPR2_NEVER_RESPAWN))
{
KillActor(actor);
break;
}
actor->user.WaitTics = 30*120;
actor->spr.cstat |= (CSTAT_SPRITE_INVISIBLE);
// respawn markers
if (!gNet.SpawnMarkers || actor->spr.hitag == TAG_NORESPAWN_FLAG) // No coin if it's a special flag
break;
auto actorNew = SpawnActor(STAT_ITEM, Red_COIN, s_RedCoin, actor->sector(), actor->spr.pos, nullAngle);
actorNew->spr.shade = -20;
actorNew->user.WaitTics = actor->user.WaitTics - 12;
break;
}
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
int KillGetAmmo(DSWActor* actor)
{
switch (gNet.MultiGameType)
{
case MULTI_GAME_NONE:
case MULTI_GAME_COOPERATIVE:
KillActor(actor);
break;
case MULTI_GAME_COMMBAT:
case MULTI_GAME_AI_BOTS:
if (actor->user.Flags2 & (SPR2_NEVER_RESPAWN))
{
KillActor(actor);
break;
}
// No Respawn mode - all ammo goes away
if (gNet.NoRespawn)
{
KillActor(actor);
break;
}
actor->user.WaitTics = 30*120;
actor->spr.cstat |= (CSTAT_SPRITE_INVISIBLE);
// respawn markers
if (!gNet.SpawnMarkers)
break;
auto actorNew = SpawnActor(STAT_ITEM, Red_COIN, s_RedCoin, actor->sector(), actor->spr.pos, nullAngle);
actorNew->spr.shade = -20;
actorNew->user.WaitTics = actor->user.WaitTics - 12;
break;
}
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
int KillGetWeapon(DSWActor* actor)
{
switch (gNet.MultiGameType)
{
case MULTI_GAME_NONE:
KillActor(actor);
break;
case MULTI_GAME_COOPERATIVE:
// don't kill weapons in coop
// unless told too :)
if (actor->user.Flags2 & (SPR2_NEVER_RESPAWN))
{
KillActor(actor);
break;
}
break;
case MULTI_GAME_COMMBAT:
case MULTI_GAME_AI_BOTS:
if (actor->user.Flags2 & (SPR2_NEVER_RESPAWN))
{
KillActor(actor);
break;
}
// No Respawn mode - all weapons stay
// but can only get once
if (gNet.NoRespawn)
break;
actor->user.WaitTics = 30*120;
actor->spr.cstat |= (CSTAT_SPRITE_INVISIBLE);
// respawn markers
if (!gNet.SpawnMarkers)
break;
auto actorNew = SpawnActor(STAT_ITEM, Red_COIN, s_RedCoin, actor->sector(), actor->spr.pos, nullAngle);
actorNew->spr.shade = -20;
actorNew->user.WaitTics = actor->user.WaitTics - 12;
break;
}
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
int DoSpawnItemTeleporterEffect(DSWActor* actor)
{
extern STATE s_TeleportEffect[];
auto effect = SpawnActor(STAT_MISSILE, 0, s_TeleportEffect, actor->sector(), actor->spr.pos.plusZ(-12), actor->spr.Angles.Yaw);
effect->spr.shade = -40;
effect->spr.scale = DVector2(0.5625, 0.5625);
effect->spr.cstat |= CSTAT_SPRITE_YCENTER;
effect->spr.cstat &= ~(CSTAT_SPRITE_BLOCK|CSTAT_SPRITE_BLOCK_HITSCAN);
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void ChoosePlayerGetSound(PLAYER* pp)
{
int choose_snd=0;
if (pp != Player+myconnectindex) return;
choose_snd = StdRandomRange((MAX_GETSOUNDS-1)<<8)>>8;
PlayerSound(PlayerGetItemVocs[choose_snd], v3df_follow|v3df_dontpan,pp);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
bool CanGetWeapon(PLAYER* pp, DSWActor* actor, int WPN)
{
switch (gNet.MultiGameType)
{
case MULTI_GAME_NONE:
return true;
case MULTI_GAME_COOPERATIVE:
if (actor->user.Flags2 & (SPR2_NEVER_RESPAWN))
return true;
if (pp->WpnGotOnceFlags & BIT(WPN))
return false;
return true;
case MULTI_GAME_COMMBAT:
case MULTI_GAME_AI_BOTS:
if (actor->user.Flags2 & (SPR2_NEVER_RESPAWN))
return true;
// No Respawn - can't get a weapon again if you already got it
if (gNet.NoRespawn && (pp->WpnGotOnceFlags & BIT(WPN)))
return false;
return true;
}
return true;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
struct InventoryDecl_t InventoryDecls[InvDecl_TOTAL] =
{
{50 },
{100 },
{20 },
{50 },
{100 },
{1 },
{2 },
{3 },
{100 },
{100 },
{100 },
};
enum
{
ITEMFLASHAMT = -8,
ITEMFLASHCLR = 144
};
int DoGet(DSWActor* actor)
{
PLAYER* pp;
short pnum, key_num;
bool can_see;
// For flag stuff
// Invisiblility is only used for DeathMatch type games
// Sprites stays invisible for a period of time and is un-gettable
// then "Re-Spawns" by becomming visible. Its never actually killed.
if (actor->spr.cstat & (CSTAT_SPRITE_INVISIBLE))
{
actor->user.WaitTics -= ACTORMOVETICS * 2;
if (actor->user.WaitTics <= 0)
{
PlaySound(DIGI_ITEM_SPAWN, actor, v3df_none);
DoSpawnItemTeleporterEffect(actor);
actor->spr.cstat &= ~(CSTAT_SPRITE_INVISIBLE);
}
return 0;
}
if(actor->vel.X != 0)
{
if (!DoItemFly(actor))
{
actor->vel.X = 0;
change_actor_stat(actor, STAT_ITEM);
}
}
TRAVERSE_CONNECT(pnum)
{
pp = &Player[pnum];
DSWActor* plActor = pp->actor;
int weaponswitch = WeaponSwitch(pnum);
if (pp->Flags & (PF_DEAD))
continue;
double dist = (pp->actor->spr.pos.XY() - actor->spr.pos).Length();
if ((unsigned)dist > (plActor->user.fRadius() + actor->user.fRadius()))
{
continue;
}
if (!SpriteOverlap(actor, pp->actor))
{
continue;
}
auto cstat_bak = actor->spr.cstat;
actor->spr.cstat |= (CSTAT_SPRITE_BLOCK|CSTAT_SPRITE_BLOCK_HITSCAN);
can_see = FAFcansee(actor->spr.pos, actor->sector(), pp->actor->getPosWithOffsetZ(), pp->cursector);
actor->spr.cstat = cstat_bak;
if (!can_see)
{
continue;
}
switch (actor->user.ID)
{
//
// Keys
//
case RED_CARD:
case RED_KEY:
key_num = 0;
goto KeyMain;
case BLUE_CARD:
case BLUE_KEY:
key_num = 1;
goto KeyMain;
case GREEN_CARD:
case GREEN_KEY:
key_num = 2;
goto KeyMain;
case YELLOW_CARD:
case YELLOW_KEY:
key_num = 3;
goto KeyMain;
case GOLD_SKELKEY:
key_num = 4;
goto KeyMain;
case SILVER_SKELKEY:
key_num = 5;
goto KeyMain;
case BRONZE_SKELKEY:
key_num = 6;
goto KeyMain;
case RED_SKELKEY:
key_num = 7;
KeyMain:
if (pp->HasKey[key_num])
break;
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_KEYMSG + key_num));
pp->HasKey[key_num] = true;
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_KEY, actor, v3df_dontpan);
// don't kill keys in coop
if (gNet.MultiGameType == MULTI_GAME_COOPERATIVE)
break;
KillActor(actor);
break;
case ICON_ARMOR:
if (pp->Armor < InventoryDecls[InvDecl_Kevlar].amount)
{
if (actor->user.spal == PALETTE_PLAYER3)
{
PlayerUpdateArmor(pp, 1000+InventoryDecls[InvDecl_Kevlar].amount);
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_INVENTORY + InvDecl_Kevlar));
}
else
{
if (pp->Armor < InventoryDecls[InvDecl_Armor].amount)
{
PlayerUpdateArmor(pp, 1000+InventoryDecls[InvDecl_Armor].amount);
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_INVENTORY + InvDecl_Armor));
}
else
break;
}
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_BIGITEM, actor, v3df_dontpan);
// override for respawn mode
if (gNet.MultiGameType == MULTI_GAME_COMMBAT && gNet.NoRespawn)
{
KillActor(actor);
break;
}
KillGet(actor);
}
break;
//
// Health - Instant Use
//
case ICON_SM_MEDKIT:
if (plActor->user.Health < 100)
{
bool putbackmax=false;
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_INVENTORY + InvDecl_SmMedkit));
if (pp->MaxHealth == 200)
{
pp->MaxHealth = 100;
putbackmax = true;
}
PlayerUpdateHealth(pp, InventoryDecls[InvDecl_SmMedkit].amount);
if (putbackmax) pp->MaxHealth = 200;
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
// override for respawn mode
if (gNet.MultiGameType == MULTI_GAME_COMMBAT && gNet.NoRespawn)
{
KillActor(actor);
break;
}
KillGet(actor);
}
break;
case ICON_BOOSTER: // Fortune cookie
pp->MaxHealth = 200;
if (plActor->user.Health < 200)
{
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_INVENTORY + InvDecl_Booster));
PlayerUpdateHealth(pp, InventoryDecls[InvDecl_Booster].amount); // This is for health
// over 100%
// Say something witty
if (pp == Player+myconnectindex)
{
int cookie = StdRandomRange(MAX_FORTUNES);
// print to the console, and the user quote display.
FStringf msg("%s %s", GStrings("TXTS_FORTUNE"), quoteMgr.GetQuote(QUOTE_COOKIE + cookie));
Printf(PRINT_NONOTIFY, TEXTCOLOR_SAPPHIRE "%s\n", msg.GetChars());
if (hud_messages)
{
strncpy(pp->cookieQuote, msg, 255);
pp->cookieQuote[255] = 0;
pp->cookieTime = 540;
}
}
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_BIGITEM, actor, v3df_dontpan);
// override for respawn mode
if (gNet.MultiGameType == MULTI_GAME_COMMBAT && gNet.NoRespawn)
{
KillActor(actor);
break;
}
KillGet(actor);
}
break;
//
// Inventory
//
case ICON_MEDKIT:
if (!pp->InventoryAmount[INVENTORY_MEDKIT] || pp->InventoryPercent[INVENTORY_MEDKIT] < InventoryDecls[InvDecl_Medkit].amount)
{
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_INVENTORY + InvDecl_Medkit));
pp->InventoryPercent[INVENTORY_MEDKIT] = InventoryDecls[InvDecl_Medkit].amount;
pp->InventoryAmount[INVENTORY_MEDKIT] = 1;
PlayerUpdateInventory(pp, INVENTORY_MEDKIT);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
// override for respawn mode
if (gNet.MultiGameType == MULTI_GAME_COMMBAT && gNet.NoRespawn)
{
KillActor(actor);
break;
}
KillGet(actor);
}
break;
case ICON_CHEMBOMB:
if (pp->InventoryAmount[INVENTORY_CHEMBOMB] < InventoryDecls[InvDecl_ChemBomb].amount)
{
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_INVENTORY + InvDecl_ChemBomb));
pp->InventoryPercent[INVENTORY_CHEMBOMB] = 0;
pp->InventoryAmount[INVENTORY_CHEMBOMB]++;
PlayerUpdateInventory(pp, INVENTORY_CHEMBOMB);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGet(actor);
}
break;
case ICON_FLASHBOMB:
if (pp->InventoryAmount[INVENTORY_FLASHBOMB] < InventoryDecls[InvDecl_FlashBomb].amount)
{
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_INVENTORY + InvDecl_FlashBomb));
pp->InventoryPercent[INVENTORY_FLASHBOMB] = 0;
pp->InventoryAmount[INVENTORY_FLASHBOMB]++;
PlayerUpdateInventory(pp, INVENTORY_FLASHBOMB);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGet(actor);
}
break;
case ICON_CALTROPS:
if (pp->InventoryAmount[INVENTORY_CALTROPS] < InventoryDecls[InvDecl_Caltrops].amount)
{
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_INVENTORY + InvDecl_Caltrops));
pp->InventoryPercent[INVENTORY_CALTROPS] = 0;
pp->InventoryAmount[INVENTORY_CALTROPS]+=3;
if (pp->InventoryAmount[INVENTORY_CALTROPS] > InventoryDecls[InvDecl_Caltrops].amount)
pp->InventoryAmount[INVENTORY_CALTROPS] = InventoryDecls[InvDecl_Caltrops].amount;
PlayerUpdateInventory(pp, INVENTORY_CALTROPS);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGet(actor);
}
break;
case ICON_NIGHT_VISION:
if (!pp->InventoryAmount[INVENTORY_NIGHT_VISION] || pp->InventoryPercent[INVENTORY_NIGHT_VISION] < InventoryDecls[InvDecl_NightVision].amount)
{
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_INVENTORY + InvDecl_NightVision));
pp->InventoryPercent[INVENTORY_NIGHT_VISION] = InventoryDecls[InvDecl_NightVision].amount;
pp->InventoryAmount[INVENTORY_NIGHT_VISION] = 1;
PlayerUpdateInventory(pp, INVENTORY_NIGHT_VISION);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGet(actor);
}
break;
case ICON_REPAIR_KIT:
if (!pp->InventoryAmount[INVENTORY_REPAIR_KIT] || pp->InventoryPercent[INVENTORY_REPAIR_KIT] < InventoryDecls[InvDecl_RepairKit].amount)
{
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_INVENTORY + InvDecl_RepairKit));
pp->InventoryPercent[INVENTORY_REPAIR_KIT] = InventoryDecls[InvDecl_RepairKit].amount;
pp->InventoryAmount[INVENTORY_REPAIR_KIT] = 1;
PlayerUpdateInventory(pp, INVENTORY_REPAIR_KIT);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
// don't kill repair kit in coop
if (gNet.MultiGameType == MULTI_GAME_COOPERATIVE)
break;
KillGet(actor);
}
break;
#if 0
case ICON_ENVIRON_SUIT:
if (!pp->InventoryAmount[INVENTORY_ENVIRON_SUIT] || pp->InventoryPercent[INVENTORY_ENVIRON_SUIT] < 100)
{
pp->InventoryPercent[INVENTORY_ENVIRON_SUIT] = 100;
pp->InventoryAmount[INVENTORY_ENVIRON_SUIT] = 1;
PlayerUpdateInventory(pp, INVENTORY_ENVIRON_SUIT);
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGet(actor);
}
break;
#endif
case ICON_CLOAK:
if (!pp->InventoryAmount[INVENTORY_CLOAK] || pp->InventoryPercent[INVENTORY_CLOAK] < InventoryDecls[InvDecl_Cloak].amount)
{
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_INVENTORY + InvDecl_Cloak));
pp->InventoryPercent[INVENTORY_CLOAK] = InventoryDecls[InvDecl_Cloak].amount;
pp->InventoryAmount[INVENTORY_CLOAK] = 1;
PlayerUpdateInventory(pp, INVENTORY_CLOAK);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGet(actor);
}
break;
//
// Weapon
//
case ICON_STAR:
if (!CanGetWeapon(pp, actor, WPN_STAR))
break;
pp->WpnGotOnceFlags |= (BIT(WPN_STAR));
if (pp->WpnAmmo[WPN_STAR] >= DamageData[WPN_STAR].max_ammo)
break;
PutStringInfo(Player+pnum, sw_darts? GStrings("TXTS_DARTS") : quoteMgr.GetQuote(QUOTE_WPNSHURIKEN));
PlayerUpdateAmmo(pp, WPN_STAR, DamageData[WPN_STAR].weapon_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGetWeapon(actor);
if (pp->WpnFlags & (BIT(WPN_STAR)))
break;
pp->WpnFlags |= (BIT(WPN_STAR));
if (!weaponswitch)
break;
if (plActor->user.WeaponNum <= WPN_STAR && plActor->user.WeaponNum != WPN_SWORD)
break;
InitWeaponStar(pp);
break;
case ICON_LG_MINE:
if (!CanGetWeapon(pp, actor, WPN_MINE))
break;
pp->WpnGotOnceFlags |= (BIT(WPN_MINE));
if (pp->WpnAmmo[WPN_MINE] >= DamageData[WPN_MINE].max_ammo)
break;
//sprintf(ds,"Sticky Bombs");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_WPNSTICKY));
PlayerUpdateAmmo(pp, WPN_MINE, DamageData[WPN_MINE].weapon_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
ChoosePlayerGetSound(pp);
KillGetWeapon(actor);
if (pp->WpnFlags & (BIT(WPN_MINE)))
break;
pp->WpnFlags |= (BIT(WPN_MINE));
if (!weaponswitch)
break;
if (plActor->user.WeaponNum > WPN_MINE && plActor->user.WeaponNum != WPN_SWORD)
break;
InitWeaponMine(pp);
break;
case ICON_UZI:
case ICON_UZIFLOOR:
if (!CanGetWeapon(pp, actor, WPN_UZI))
break;
pp->WpnGotOnceFlags |= (BIT(WPN_UZI));
if (pp->Flags & (PF_TWO_UZI) && pp->WpnAmmo[WPN_UZI] >= DamageData[WPN_UZI].max_ammo)
break;
//sprintf(ds,"UZI Submachine Gun");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_WPNUZI));
// pp->WpnAmmo[WPN_UZI] += 50;
PlayerUpdateAmmo(pp, WPN_UZI, DamageData[WPN_UZI].weapon_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGetWeapon(actor);
if (pp->WpnFlags & (BIT(WPN_UZI)) && (pp->Flags & PF_TWO_UZI))
break;
// flag to help with double uzi powerup - simpler but kludgy
pp->Flags |= (PF_PICKED_UP_AN_UZI);
if (pp->WpnFlags & (BIT(WPN_UZI)))
{
pp->Flags |= (PF_TWO_UZI);
pp->WpnUziType = 0; // Let it come up
if (pp == Player+myconnectindex)
PlayerSound(DIGI_DOUBLEUZI, v3df_dontpan|v3df_follow, pp);
}
else
{
pp->WpnFlags |= (BIT(WPN_UZI));
ChoosePlayerGetSound(pp);
}
if (!weaponswitch)
break;
if (plActor->user.WeaponNum > WPN_UZI && plActor->user.WeaponNum != WPN_SWORD)
break;
InitWeaponUzi(pp);
break;
case ICON_LG_UZI_AMMO:
if (pp->WpnAmmo[WPN_UZI] >= DamageData[WPN_UZI].max_ammo)
break;
//sprintf(ds,"UZI Clip");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_AMMOUZI));
PlayerUpdateAmmo(pp, WPN_UZI, DamageData[WPN_UZI].ammo_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGetAmmo(actor);
break;
case ICON_MICRO_GUN:
if (!CanGetWeapon(pp, actor, WPN_MICRO))
break;
pp->WpnGotOnceFlags |= (BIT(WPN_MICRO));
if (pp->WpnFlags & (BIT(WPN_MICRO)) && pp->WpnAmmo[WPN_MICRO] >= DamageData[WPN_MICRO].max_ammo)
break;
//sprintf(ds,"Missile Launcher");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_WPNLAUNCH));
// pp->WpnAmmo[WPN_MICRO] += 5;
PlayerUpdateAmmo(pp, WPN_MICRO, DamageData[WPN_MICRO].weapon_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
ChoosePlayerGetSound(pp);
KillGetWeapon(actor);
if (pp->WpnFlags & (BIT(WPN_MICRO)))
break;
pp->WpnFlags |= (BIT(WPN_MICRO));
if (!weaponswitch)
break;
if (plActor->user.WeaponNum > WPN_MICRO && plActor->user.WeaponNum != WPN_SWORD)
break;
InitWeaponMicro(pp);
break;
case ICON_MICRO_BATTERY:
if (pp->WpnAmmo[WPN_MICRO] >= DamageData[WPN_MICRO].max_ammo)
break;
//sprintf(ds,"Missiles");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_AMMOLAUNCH));
PlayerUpdateAmmo(pp, WPN_MICRO, DamageData[WPN_MICRO].ammo_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGetAmmo(actor);
break;
case ICON_NUKE:
if (pp->WpnRocketNuke != 1)
{
//sprintf(ds,"Nuclear Warhead");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_WPNNUKE));
pp->WpnRocketNuke =uint8_t(DamageData[DMG_NUCLEAR_EXP].weapon_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
if (StdRandomRange(1000) > 800 && pp == Player+myconnectindex)
PlayerSound(DIGI_ILIKENUKES, v3df_dontpan|v3df_doppler|v3df_follow,pp);
if (pp->CurWpn == pp->Wpn[WPN_MICRO])
{
if (pp->WpnRocketType != 2)
{
extern PANEL_STATE ps_MicroNukeFlash[];
pp->CurWpn->over[MICRO_SHOT_NUM].tics = 0;
pp->CurWpn->over[MICRO_SHOT_NUM].State = ps_MicroNukeFlash;
// Play Nuke available sound here!
}
}
KillGetAmmo(actor);
}
break;
case ICON_GRENADE_LAUNCHER:
if (!CanGetWeapon(pp, actor, WPN_GRENADE))
break;
pp->WpnGotOnceFlags |= (BIT(WPN_GRENADE));
if (pp->WpnFlags & (BIT(WPN_GRENADE)) && pp->WpnAmmo[WPN_GRENADE] >= DamageData[WPN_GRENADE].max_ammo)
break;
//sprintf(ds,"Grenade Launcher");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_WPNGRENADE));
// pp->WpnAmmo[WPN_GRENADE] += 6;
PlayerUpdateAmmo(pp, WPN_GRENADE, DamageData[WPN_GRENADE].weapon_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
//ChoosePlayerGetSound(pp);
if (StdRandomRange(1000) > 800 && pp == Player+myconnectindex)
PlayerSound(DIGI_LIKEBIGWEAPONS, v3df_dontpan|v3df_doppler|v3df_follow,pp);
KillGetWeapon(actor);
if (pp->WpnFlags & (BIT(WPN_GRENADE)))
break;
pp->WpnFlags |= (BIT(WPN_GRENADE));
if (!weaponswitch)
break;
if (plActor->user.WeaponNum > WPN_GRENADE && plActor->user.WeaponNum != WPN_SWORD)
break;
InitWeaponGrenade(pp);
break;
case ICON_LG_GRENADE:
if (pp->WpnAmmo[WPN_GRENADE] >= DamageData[WPN_GRENADE].max_ammo)
break;
//sprintf(ds,"Grenade Shells");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_AMMOGRENADE));
PlayerUpdateAmmo(pp, WPN_GRENADE, DamageData[WPN_GRENADE].ammo_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGetAmmo(actor);
break;
#if 0
case ICON_ROCKET:
pp->WpnAmmo[WPN_ROCKET] += 15;
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGet(actor);
if (pp->WpnFlags & (BIT(WPN_ROCKET)))
break;
pp->WpnFlags |= (BIT(WPN_ROCKET));
if (!weaponswitch)
break;
InitWeaponRocket(pp);
break;
case ICON_LG_ROCKET:
sprintf(ds,"20 Missiles");
PutStringInfo(Player+pnum, ds);
PlayerUpdateAmmo(pp, WPN_ROCKET, 20);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGet(actor);
break;
#endif
case ICON_RAIL_GUN:
if (SW_SHAREWARE) { KillActor(actor); break; }
if (!CanGetWeapon(pp, actor, WPN_RAIL))
break;
pp->WpnGotOnceFlags |= (BIT(WPN_RAIL));
if (pp->WpnFlags & (BIT(WPN_RAIL)) && pp->WpnAmmo[WPN_RAIL] >= DamageData[WPN_RAIL].max_ammo)
break;
//sprintf(ds,"Rail Gun");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_WPNRAILGUN));
PlayerUpdateAmmo(pp, WPN_RAIL, DamageData[WPN_RAIL].weapon_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
if (pp == Player+myconnectindex)
{
if (StdRandomRange(1000) > 700)
PlayerSound(DIGI_LIKEBIGWEAPONS, v3df_dontpan|v3df_doppler|v3df_follow,pp);
else
PlayerSound(DIGI_GOTRAILGUN, v3df_dontpan|v3df_doppler|v3df_follow,pp);
}
//ChoosePlayerGetSound(pp);
KillGetWeapon(actor);
if (pp->WpnFlags & (BIT(WPN_RAIL)))
break;
pp->WpnFlags |= (BIT(WPN_RAIL));
if (!weaponswitch)
break;
if (plActor->user.WeaponNum > WPN_RAIL && plActor->user.WeaponNum != WPN_SWORD)
break;
InitWeaponRail(pp);
break;
case ICON_RAIL_AMMO:
if (SW_SHAREWARE) { KillActor(actor); break; }
if (pp->WpnAmmo[WPN_RAIL] >= DamageData[WPN_RAIL].max_ammo)
break;
//sprintf(ds,"Rail Gun Rods");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_AMMORAILGUN));
PlayerUpdateAmmo(pp, WPN_RAIL, DamageData[WPN_RAIL].ammo_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGetAmmo(actor);
break;
case ICON_SHOTGUN:
if (!CanGetWeapon(pp, actor, WPN_SHOTGUN))
break;
pp->WpnGotOnceFlags |= (BIT(WPN_SHOTGUN));
if (pp->WpnFlags & (BIT(WPN_SHOTGUN)) && pp->WpnAmmo[WPN_SHOTGUN] >= DamageData[WPN_SHOTGUN].max_ammo)
break;
//sprintf(ds,"Riot Gun");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_WPNRIOT));
// pp->WpnAmmo[WPN_SHOTGUN] += 10;
PlayerUpdateAmmo(pp, WPN_SHOTGUN, DamageData[WPN_SHOTGUN].weapon_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
ChoosePlayerGetSound(pp);
KillGetWeapon(actor);
if (pp->WpnFlags & (BIT(WPN_SHOTGUN)))
break;
pp->WpnFlags |= (BIT(WPN_SHOTGUN));
if (!weaponswitch)
break;
if (plActor->user.WeaponNum > WPN_SHOTGUN && plActor->user.WeaponNum != WPN_SWORD)
break;
InitWeaponShotgun(pp);
break;
case ICON_LG_SHOTSHELL:
if (pp->WpnAmmo[WPN_SHOTGUN] >= DamageData[WPN_SHOTGUN].max_ammo)
break;
//sprintf(ds,"Shotshells");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_AMMORIOT));
PlayerUpdateAmmo(pp, WPN_SHOTGUN, DamageData[WPN_SHOTGUN].ammo_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGetAmmo(actor);
break;
#if 0
case ICON_AUTORIOT:
if (pp->WpnShotgunAuto != 50)
{
sprintf(ds,"Riot Gun TurboDrive, +50 12-Gauge Slugs");
PutStringInfo(Player+pnum, ds);
pp->WpnShotgunAuto = 50;
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGet(actor);
if (pp->CurWpn == pp->Wpn[WPN_SHOTGUN])
{
if (pp->WpnShotgunType != 1)
{
extern PANEL_STATE ps_ShotgunFlash[];
pp->CurWpn->over[SHOTGUN_AUTO_NUM].tics = 0;
pp->CurWpn->over[SHOTGUN_AUTO_NUM].State = ps_ShotgunFlash;
}
}
}
break;
#endif
case ICON_GUARD_HEAD:
if (SW_SHAREWARE) { KillActor(actor); break; }
if (!CanGetWeapon(pp, actor, WPN_HOTHEAD))
break;
pp->WpnGotOnceFlags |= (BIT(WPN_HOTHEAD));
if (pp->WpnFlags & (BIT(WPN_HOTHEAD)) && pp->WpnAmmo[WPN_HOTHEAD] >= DamageData[WPN_HOTHEAD].max_ammo)
break;
//sprintf(ds,"Guardian Head");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_WPNHEAD));
PlayerUpdateAmmo(pp, WPN_HOTHEAD, DamageData[WPN_HOTHEAD].weapon_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
//ChoosePlayerGetSound(pp);
if (StdRandomRange(1000) > 800 && pp == Player+myconnectindex)
PlayerSound(DIGI_LIKEBIGWEAPONS, v3df_dontpan|v3df_doppler|v3df_follow,pp);
KillGetWeapon(actor);
if (pp->WpnFlags & (BIT(WPN_HOTHEAD)))
break;
pp->WpnFlags |= (BIT(WPN_NAPALM) | BIT(WPN_RING) | BIT(WPN_HOTHEAD));
if (!weaponswitch)
break;
if (plActor->user.WeaponNum > WPN_HOTHEAD && plActor->user.WeaponNum != WPN_SWORD)
break;
InitWeaponHothead(pp);
break;
case ICON_FIREBALL_LG_AMMO:
if (SW_SHAREWARE) { KillActor(actor); break; }
if (pp->WpnAmmo[WPN_HOTHEAD] >= DamageData[WPN_HOTHEAD].max_ammo)
break;
//sprintf(ds,"Firebursts");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_AMMOHEAD));
PlayerUpdateAmmo(pp, WPN_HOTHEAD, DamageData[WPN_HOTHEAD].ammo_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGetAmmo(actor);
break;
case ICON_HEART:
if (SW_SHAREWARE) { KillActor(actor); break; }
if (!CanGetWeapon(pp, actor, WPN_HEART))
break;
pp->WpnGotOnceFlags |= (BIT(WPN_HEART));
if (pp->WpnFlags & (BIT(WPN_HEART)) && pp->WpnAmmo[WPN_HEART] >= DamageData[WPN_HEART].max_ammo)
break;
//sprintf(ds,"Ripper Heart");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_WPNRIPPER));
PlayerUpdateAmmo(pp, WPN_HEART, DamageData[WPN_HEART].weapon_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
//ChoosePlayerGetSound(pp);
if (StdRandomRange(1000) > 800 && pp == Player+myconnectindex)
PlayerSound(DIGI_LIKEBIGWEAPONS, v3df_dontpan|v3df_doppler|v3df_follow,pp);
KillGetWeapon(actor);
if (pp->WpnFlags & (BIT(WPN_HEART)))
break;
pp->WpnFlags |= (BIT(WPN_HEART));
if (!weaponswitch)
break;
if (plActor->user.WeaponNum > WPN_HEART && plActor->user.WeaponNum != WPN_SWORD)
break;
InitWeaponHeart(pp);
break;
case ICON_HEART_LG_AMMO:
if (SW_SHAREWARE) { KillActor(actor); break; }
if (pp->WpnAmmo[WPN_HEART] >= DamageData[WPN_HEART].max_ammo)
break;
//sprintf(ds,"Deathcoils");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_AMMORIPPER));
PlayerUpdateAmmo(pp, WPN_HEART, DamageData[WPN_HEART].ammo_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGetAmmo(actor);
break;
case ICON_HEAT_CARD:
if (pp->WpnRocketHeat != 5)
{
//sprintf(ds,"Heat Seeker Card");
PutStringInfo(Player+pnum, quoteMgr.GetQuote(QUOTE_AMMONUKE));
pp->WpnRocketHeat = uint8_t(DamageData[DMG_NUCLEAR_EXP].ammo_pickup);
SetFadeAmt(pp,ITEMFLASHAMT,ITEMFLASHCLR); // Flash blue on item pickup
if (pp == Player+myconnectindex)
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
KillGet(actor);
if (pp->CurWpn == pp->Wpn[WPN_MICRO])
{
if (pp->WpnRocketType == 0)
{
pp->WpnRocketType = 1;
}
else if (pp->WpnRocketType == 2)
{
extern PANEL_STATE ps_MicroHeatFlash[];
pp->CurWpn->over[MICRO_HEAT_NUM].tics = 0;
pp->CurWpn->over[MICRO_HEAT_NUM].State = ps_MicroHeatFlash;
}
}
}
break;
case ICON_FLAG:
{
if (actor->spr.pal == pp->actor->spr.pal) break; // Can't pick up your own flag!
PlaySound(DIGI_ITEM, actor, v3df_dontpan);
DSWActor* actorNew;
if (actor->spr.hitag == TAG_NORESPAWN_FLAG)
actorNew = SpawnActor(STAT_ITEM, ICON_FLAG, s_CarryFlagNoDet, actor->sector(), actor->spr.pos, nullAngle);
else
actorNew = SpawnActor(STAT_ITEM, ICON_FLAG, s_CarryFlag, actor->sector(), actor->spr.pos, nullAngle);
actorNew->spr.shade = -20;
// Attach flag to player
actorNew->user.Counter = 0;
actorNew->spr.cstat &= ~(CSTAT_SPRITE_BLOCK|CSTAT_SPRITE_BLOCK_HITSCAN);
actorNew->spr.cstat |= (CSTAT_SPRITE_ALIGNMENT_WALL);
SetAttach(pp->actor, actorNew);
actorNew->user.pos.Z = ActorZOfMiddle(pp->actor); // Set mid way up who it hit
actorNew->user.spal = actorNew->spr.pal = actor->spr.pal; // Set the palette of the flag
SetOwner(pp->actor, actorNew); // Player now owns the flag
actorNew->user.flagOwnerActor = actor; // Tell carried flag who owns it
KillGet(actor); // Set up for flag respawning
break;
}
default:
KillActor(actor);
}
}
return 0;
}
//---------------------------------------------------------------------------
//
// This function mostly only adjust the active_range field
//
//---------------------------------------------------------------------------
void ProcessActiveVars(DSWActor* actor)
{
const int TIME_TILL_INACTIVE = (4 * 120);
if (!(actor->user.Flags & SPR_ACTIVE))
{
// if actor has been unaware for more than a few seconds
actor->user.inactive_time += ACTORMOVETICS;
if (actor->user.inactive_time > TIME_TILL_INACTIVE)
{
// reset to min update range
actor->user.active_range = MIN_ACTIVE_RANGE;
// keep time low so it doesn't roll over
actor->user.inactive_time = TIME_TILL_INACTIVE;
}
}
actor->user.wait_active_check += ACTORMOVETICS;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void AdjustActiveRange(PLAYER* pp, DSWActor* actor, double dist)
{
DSWActor* plActor = pp->actor;
// do no FAFcansee before it is time
if (actor->user.wait_active_check < ACTIVE_CHECK_TIME)
return;
actor->user.wait_active_check = 0;
// check aboslute max
if (dist > MAX_ACTIVE_RANGE)
return;
// do not do a FAFcansee if your already active
// Actor only becomes INACTIVE in DoActorDecision
if (actor->user.Flags & (SPR_ACTIVE))
return;
//
// From this point on Actor is INACTIVE
//
// if actor can still see the player
if (FAFcansee(ActorVectOfTop(actor), actor->sector(), ActorUpperVect(plActor), plActor->sector()))
{
// Player is visible
// adjust update range of this sprite
// some huge distance
actor->user.active_range = 75000;
// sprite is AWARE
actor->user.Flags |= (SPR_ACTIVE);
actor->user.inactive_time = 0;
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
/*
!AIC KEY - Reads state tables for animation frame transitions and handles
calling animators, QUICK_CALLS, etc. This is handled for many types of
sprites not just actors.
*/
int StateControl(DSWActor* actor)
{
short StateTics;
if (!actor->user.State)
{
ASSERT(actor->user.ActorActionFunc);
(actor->user.ActorActionFunc)(actor);
return 0;
}
if (actor->spr.statnum >= STAT_SKIP4_START && actor->spr.statnum <= STAT_SKIP4_END)
actor->user.Tics += ACTORMOVETICS * 2;
else
actor->user.Tics += ACTORMOVETICS;
// Skip states if too much time has passed
while (actor->user.Tics >= (actor->user.State->Tics & SF_TICS_MASK))
{
StateTics = (actor->user.State->Tics & SF_TICS_MASK);
if ((actor->user.State->Tics & SF_TIC_ADJUST))
{
ASSERT(actor->user.Attrib);
ASSERT(actor->user.speed < MAX_SPEED);
ASSERT(StateTics > -actor->user.Attrib->TicAdjust[actor->user.speed]);
StateTics += actor->user.Attrib->TicAdjust[actor->user.speed];
}
// Set Tics
actor->user.Tics -= StateTics;
// Transition to the next state
actor->user.State = actor->user.State->NextState;
// Look for flags embedded into the Tics variable
while ((actor->user.State->Tics & SF_QUICK_CALL))
{
// Call it once and go to the next state
(*actor->user.State->Animator)(actor);
ASSERT(actor->hasU()); //put this in to see if actor was getting killed with in his QUICK_CALL state
if (!actor->hasU())
break;
// if still on the same QUICK_CALL should you
// go to the next state.
if ((actor->user.State->Tics & SF_QUICK_CALL))
actor->user.State = actor->user.State->NextState;
}
if (!actor->hasU())
break;
if (!actor->user.State->Pic)
{
NewStateGroup(actor, (STATE* *) actor->user.State->NextState);
}
}
if (actor->hasU())
{
ASSERT(actor->user.State);
// Set picnum to the correct pic
if ((actor->user.State->Tics & SF_WALL_STATE))
{
ASSERT(actor->user.WallP);
actor->user.WallP->wallpicnum = actor->user.State->Pic;
}
else
{
if (actor->user.RotNum > 1)
actor->spr.picnum = actor->user.Rot[0]->Pic;
else
actor->spr.picnum = actor->user.State->Pic;
}
// Call the correct animator
if (actor->user.State->Animator && actor->user.State->Animator != NullAnimator)
(*actor->user.State->Animator)(actor);
}
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void SpriteControl(void)
{
int32_t stat;
short pnum, CloseToPlayer;
PLAYER* pp;
short StateTics;
SWStatIterator it(STAT_MISC);
while (auto actor = it.Next())
{
StateControl(actor);
}
// Items and skip2 things
if (MoveSkip2 == 0)
{
for (stat = STAT_SKIP2_START + 1; stat <= STAT_SKIP2_END; stat++)
{
it.Reset(stat);
while (auto actor = it.Next())
{
StateControl(actor);
}
}
}
if (MoveSkip2 == 0) // limit to 20 times a second
{
// move bad guys around
it.Reset(STAT_ENEMY);
while (auto actor = it.Next())
{
if (!actor->hasU()) continue;
CloseToPlayer = false;
ProcessActiveVars(actor);
TRAVERSE_CONNECT(pnum)
{
pp = &Player[pnum];
// Only update the ones closest
double dist = (pp->actor->spr.pos.XY() - actor->spr.pos.XY()).Length();
AdjustActiveRange(pp, actor, dist);
if (dist < actor->user.active_range)
{
CloseToPlayer = true;
}
}
actor->user.Flags &= ~(SPR_MOVED);
// Only update the ones close to ANY player
if (CloseToPlayer)
{
StateControl(actor);
}
else
{
// to far away to be attacked
actor->user.Flags &= ~(SPR_ATTACKED);
}
}
}
// Skip4 things
if (MoveSkip4 == 0) // limit to 10 times a second
{
for (stat = STAT_SKIP4_START; stat <= STAT_SKIP4_END; stat++)
{
it.Reset(stat);
while (auto actor = it.Next())
{
StateControl(actor);
}
}
}
it.Reset(STAT_NO_STATE);
while (auto actor = it.Next())
{
if (actor->hasU() && actor->user.ActorActionFunc)
actor->user.ActorActionFunc(actor);
}
if (MoveSkip8 == 0)
{
it.Reset(STAT_STATIC_FIRE);
while (auto itActor = it.Next())
{
DoStaticFlamesDamage(itActor);
}
}
if (MoveSkip4 == 0) // limit to 10 times a second
{
it.Reset(STAT_WALLBLOOD_QUEUE);
while (auto actor = it.Next())
{
StateControl(actor);
}
}
// vator/rotator/spike/slidor all have some code to
// prevent calling of the action func()
it.Reset(STAT_VATOR);
while (auto actor = it.Next())
{
if (!actor->hasU())
continue;
if (actor->user.Tics)
{
if ((actor->user.Tics -= synctics) <= 0)
SetVatorActive(actor);
else
continue;
}
if (!(actor->user.Flags & SPR_ACTIVE))
continue;
actor->user.ActorActionFunc(actor);
}
it.Reset(STAT_SPIKE);
while (auto actor = it.Next())
{
if (actor->user.Tics)
{
if ((actor->user.Tics -= synctics) <= 0)
SetSpikeActive(actor);
else
continue;
}
if (!(actor->user.Flags & SPR_ACTIVE))
continue;
actor->user.ActorActionFunc(actor);
}
it.Reset(STAT_ROTATOR);
while (auto actor = it.Next())
{
if (actor->user.Tics)
{
if ((actor->user.Tics -= synctics) <= 0)
SetRotatorActive(actor);
else
continue;
}
if (!(actor->user.Flags & SPR_ACTIVE))
continue;
actor->user.ActorActionFunc(actor);
}
it.Reset(STAT_SLIDOR);
while (auto actor = it.Next())
{
if (actor->user.Tics)
{
if ((actor->user.Tics -= synctics) <= 0)
SetSlidorActive(actor);
else
continue;
}
if (!(actor->user.Flags & SPR_ACTIVE))
continue;
actor->user.ActorActionFunc(actor);
}
it.Reset(STAT_SUICIDE);
while (auto actor = it.Next())
{
KillActor(actor);
}
}
//---------------------------------------------------------------------------
//
// This moves an actor about with FAFgetzrange clip adjustment
//
//---------------------------------------------------------------------------
/*
!AIC KEY - calls clipmove - Look through and try to understatnd Should
hopefully never have to change this. Its very delicate.
*/
Collision move_sprite(DSWActor* actor, const DVector3& change, double ceildist, double flordist, uint32_t cliptype, int numtics)
{
Collision retval{};
double zH;
short tempshort;
ASSERT(actor->hasU());
auto clip_pos = actor->spr.pos;
// Can't modify sprite sectors
// directly becuase of linked lists
auto dasect = actor->sector();
auto lastsect = dasect;
if (actor->spr.cstat & (CSTAT_SPRITE_YCENTER))
{
zH = 0;
}
else
{
// move the center point up for moving
zH = actor->user.zclip;
clip_pos.Z -= zH;
}
clipmove(clip_pos, &dasect, change * numtics * 0.125, actor->clipdist, ceildist, flordist, cliptype, retval, 1);
actor->spr.pos.XY() = clip_pos.XY();
if (dasect == nullptr)
{
retval.setWall(0); // this is wrong but what the original code did.
return retval;
}
if ((dasect != actor->sector()) && (dasect != nullptr))
ChangeActorSect(actor, dasect);
// Set the blocking bit to 0 temporarly so FAFgetzrange doesn't pick
// up its own sprite
auto tempstat = actor->spr.cstat;
actor->spr.cstat = 0;
// I subtracted 8 from the clipdist because actors kept going up on
// ledges they were not supposed to go up on. Did the same for the
// player. Seems to work ok!
auto pos = actor->spr.pos.plusZ(-zH - zmaptoworld);
FAFgetzrange(pos, actor->sector(),
&globhiz, &globhihit, &globloz, &globlohit,
actor->clipdist - GETZRANGE_CLIP_ADJ, cliptype);
actor->spr.cstat = tempstat;
// !AIC - puts getzrange results into USER varaible actor->user.loz. actor->user.hiz, actor->user.lo_sectp, actor->user.hi_sectp, etc.
// Takes info from global variables
DoActorGlobZ(actor);
clip_pos.Z = actor->spr.pos.Z + ((change.Z * numtics) * 0.125);
// test for hitting ceiling or floor
if ((clip_pos.Z - zH <= globhiz) || (clip_pos.Z - zH > globloz))
{
if (retval.type == kHitNone)
{
if (actor->user.Flags & (SPR_CLIMBING))
{
actor->spr.pos.Z = clip_pos.Z;
return retval;
}
retval.setSector(dasect);
}
}
else
{
actor->spr.pos.Z = clip_pos.Z;
}
// extra processing for Stacks and warping
if (FAF_ConnectArea(actor->sector()))
SetActorZ(actor, actor->spr.pos);
if ((actor->sector()->extra & SECTFX_WARP_SECTOR))
{
DSWActor* sp_warp;
auto posv = actor->spr.pos;
if ((sp_warp = WarpPlane(posv, &dasect)))
{
actor->spr.pos = posv;
ActorWarpUpdatePos(actor, dasect);
ActorWarpType(actor, sp_warp);
}
if (actor->sector() != lastsect)
{
if ((sp_warp = Warp(posv, &dasect)))
{
actor->spr.pos = posv;
ActorWarpUpdatePos(actor, dasect);
ActorWarpType(actor, sp_warp);
}
}
}
return retval;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void MissileWarpUpdatePos(DSWActor* actor, sectortype* sect)
{
actor->backuppos();
actor->user.oz = actor->opos.Z;
ChangeActorSect(actor, sect);
MissileZrange(actor);
}
void ActorWarpUpdatePos(DSWActor* actor, sectortype* sect)
{
actor->backuppos();
actor->user.oz = actor->opos.Z;
ChangeActorSect(actor, sect);
DoActorZrange(actor);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void MissileWarpType(DSWActor* actor, DSWActor* act_warp)
{
switch (SP_TAG1(act_warp))
{
case WARP_CEILING_PLANE:
case WARP_FLOOR_PLANE:
return;
}
switch (SP_TAG3(act_warp))
{
case 1:
break;
default:
PlaySound(DIGI_ITEM_SPAWN, actor, v3df_none);
DoSpawnItemTeleporterEffect(actor);
break;
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void ActorWarpType(DSWActor* actor, DSWActor* act_warp)
{
switch (SP_TAG3(act_warp))
{
case 1:
break;
default:
PlaySound(DIGI_ITEM_SPAWN, actor, v3df_none);
DoSpawnTeleporterEffectPlace(actor);
break;
}
}
//---------------------------------------------------------------------------
//
// This moves a small projectile with FAFgetzrangepoint
//
//---------------------------------------------------------------------------
int MissileWaterAdjust(DSWActor* actor)
{
auto sectp = actor->user.lo_sectp;
if (sectp && sectp->hasU())
{
if (FixedToInt(sectp->depth_fixed))
actor->user.loz -= FixedToInt(sectp->depth_fixed);
}
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
int MissileZrange(DSWActor* actor)
{
// Set the blocking bit to 0 temporarly so FAFgetzrange doesn't pick
// up its own sprite
auto tempshort = actor->spr.cstat;
actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK);
FAFgetzrangepoint(actor->spr.pos.plusZ(-zmaptoworld), actor->sector(), &globhiz, &globhihit, &globloz, &globlohit);
actor->spr.cstat = tempshort;
DoActorGlobZ(actor);
return 0;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
Collision move_missile(DSWActor* actor, const DVector3& change, double ceil_dist, double flor_dist, uint32_t cliptype, int numtics)
{
Collision retval{};
double zH;
ASSERT(actor->hasU());
auto clip_pos = actor->spr.pos;
// Can't modify sprite sectors
// directly becuase of linked lists
auto dasect = actor->sector();
auto lastsect = dasect;
if (actor->spr.cstat & (CSTAT_SPRITE_YCENTER))
{
zH = 0;
}
else
{
zH = actor->user.zclip;
clip_pos.Z -= zH;
}
clipmove(clip_pos, &dasect, change * numtics * 0.125, actor->clipdist, ceil_dist, flor_dist, cliptype, retval, 1);
actor->spr.pos.XY() = clip_pos.XY();
if (dasect == nullptr)
{
// we've gone beyond a white wall - kill it
retval.setVoid();
return retval;
}
if ((dasect != actor->sector()) && (dasect != nullptr))
ChangeActorSect(actor, dasect);
// Set the blocking bit to 0 temporarly so FAFgetzrange doesn't pick
// up its own sprite
auto tempshort = actor->spr.cstat;
actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK);
FAFgetzrangepoint(actor->spr.pos.plusZ(-zmaptoworld), actor->sector(), &globhiz, &globhihit, &globloz, &globlohit);
actor->spr.cstat = tempshort;
DoActorGlobZ(actor);
// getzrangepoint moves water down
// missiles don't need the water to be down
MissileWaterAdjust(actor);
clip_pos.Z = actor->spr.pos.Z + ((change.Z * numtics) * 0.125);
// NOTE: this does not tell you when you hit a floor sprite
// this case is currently treated like it hit a sector
// test for hitting ceiling or floor
if (clip_pos.Z - zH <= actor->user.hiz + ceil_dist)
{
// normal code
actor->spr.pos.Z = actor->user.hiz + zH + ceil_dist;
if (retval.type == kHitNone)
retval.setSector(dasect);
}
else if (clip_pos.Z - zH > actor->user.loz - flor_dist)
{
actor->spr.pos.Z = actor->user.loz + zH - flor_dist;
if (retval.type == kHitNone)
retval.setSector(dasect);
}
else
{
actor->spr.pos.Z = clip_pos.Z;
}
if (FAF_ConnectArea(actor->sector()))
SetActorZ(actor, actor->spr.pos);
if ((actor->sector()->extra & SECTFX_WARP_SECTOR))
{
DSWActor* sp_warp;
auto pos = actor->spr.pos;
if ((sp_warp = WarpPlane(pos, &dasect)))
{
actor->spr.pos = pos;
MissileWarpUpdatePos(actor, dasect);
MissileWarpType(actor, sp_warp);
}
if (actor->sector() != lastsect)
{
if ((sp_warp = Warp(pos, &dasect)))
{
actor->spr.pos = pos;
MissileWarpUpdatePos(actor, dasect);
MissileWarpType(actor, sp_warp);
}
}
}
if (retval.type != kHitNone && (actor->sector()->ceilingstat & CSTAT_SECTOR_SKY))
{
if (actor->spr.pos.Z < actor->sector()->ceilingz)
{
retval.setVoid();
}
}
if (retval.type != kHitNone && (actor->sector()->floorstat & CSTAT_SECTOR_SKY))
{
if (actor->spr.pos.Z > actor->sector()->floorz)
{
retval.setVoid();
}
}
return retval;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
Collision move_ground_missile(DSWActor* actor, const DVector2& change, double ceildist, double flordist, uint32_t cliptype, int numtics)
{
Collision retval{};
int ox,oy;
ASSERT(actor->hasU());
// Can't modify sprite sectors
// directly becuase of linked lists
auto dasect = actor->sector();
auto lastsect = dasect;
auto opos = actor->spr.pos;
double daz = actor->spr.pos.Z;
// climbing a wall
if (actor->user.z_tgt)
{
if (abs(actor->user.z_tgt - actor->spr.pos.Z) > 40)
{
if (actor->user.z_tgt > actor->spr.pos.Z)
{
actor->spr.pos.Z += 30;
return retval;
}
else
{
actor->spr.pos.Z -= 30;
return retval;
}
}
else
actor->user.z_tgt = 0;
}
actor->spr.pos += change * 0.5;
updatesector(actor->spr.pos, &dasect);
if (dasect == nullptr)
{
// back up and try again
dasect = actor->sector();
lastsect = dasect;
opos = actor->spr.pos;
opos.Z = daz;
clipmove(opos, &dasect, change * numtics * 0.125, actor->clipdist, ceildist, flordist, cliptype, retval, 1);
actor->spr.pos.XY() = opos.XY();
}
if (dasect == nullptr)
{
// we've gone beyond a white wall - kill it
retval.setVoid();
return retval;
}
if (retval.type != kHitNone) // ran into a white wall
{
return retval;
}
actor->user.z_tgt = 0;
if ((dasect != actor->sector()) && (dasect != nullptr))
{
actor->spr.pos.Z = getflorzofslopeptr(dasect, actor->spr.pos.X, actor->spr.pos.Y);
ChangeActorSect(actor, dasect);
}
calcSlope(actor->sector(), actor->spr.pos, &actor->user.hiz, &actor->user.loz);
actor->user.hi_sectp = actor->user.lo_sectp = actor->sector();
actor->user.highActor = nullptr; actor->user.lowActor = nullptr;
actor->spr.pos.Z = actor->user.loz - 8;
if (abs(actor->user.hiz - actor->user.loz) < 12)
{
// we've gone into a very small place - kill it
retval.setVoid();
return retval;
}
if ((actor->sector()->extra & SECTFX_WARP_SECTOR))
{
DSWActor* sp_warp;
auto pos = actor->spr.pos;
if ((sp_warp = WarpPlane(pos, &dasect)))
{
actor->spr.pos = pos;
MissileWarpUpdatePos(actor, dasect);
MissileWarpType(actor, sp_warp);
}
if (actor->sector() != lastsect)
{
if ((sp_warp = Warp(pos, &dasect)))
{
actor->spr.pos = pos;
MissileWarpUpdatePos(actor, dasect);
MissileWarpType(actor, sp_warp);
}
}
}
return retval;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
#include "saveable.h"
static saveable_code saveable_sprite_code[] =
{
SAVE_CODE(DoGrating),
SAVE_CODE(DoKey),
SAVE_CODE(DoCoin),
SAVE_CODE(DoGet),
};
static saveable_data saveable_sprite_data[] =
{
SAVE_DATA(Track),
SAVE_DATA(SectorObject),
SAVE_DATA(s_DebrisNinja),
SAVE_DATA(s_DebrisRat),
SAVE_DATA(s_DebrisCrab),
SAVE_DATA(s_DebrisStarFish),
SAVE_DATA(s_RepairKit),
SAVE_DATA(s_GoldSkelKey),
SAVE_DATA(s_BlueKey),
SAVE_DATA(s_BlueCard),
SAVE_DATA(s_SilverSkelKey),
SAVE_DATA(s_RedKey),
SAVE_DATA(s_RedCard),
SAVE_DATA(s_BronzeSkelKey),
SAVE_DATA(s_GreenKey),
SAVE_DATA(s_GreenCard),
SAVE_DATA(s_RedSkelKey),
SAVE_DATA(s_YellowKey),
SAVE_DATA(s_YellowCard),
SAVE_DATA(s_Key),
SAVE_DATA(s_BlueKey),
SAVE_DATA(s_RedKey),
SAVE_DATA(s_GreenKey),
SAVE_DATA(s_YellowKey),
SAVE_DATA(s_Key),
/*
SAVE_DATA(s_BlueKeyStatue),
SAVE_DATA(s_RedKeyStatue),
SAVE_DATA(s_GreenKeyStatue),
SAVE_DATA(s_YellowKeyStatue),
SAVE_DATA(s_KeyStatue),
*/
SAVE_DATA(s_RedCoin),
SAVE_DATA(s_YellowCoin),
SAVE_DATA(s_GreenCoin),
SAVE_DATA(s_FireFly),
SAVE_DATA(s_IconStar),
SAVE_DATA(s_IconUzi),
SAVE_DATA(s_IconLgUziAmmo),
SAVE_DATA(s_IconUziFloor),
SAVE_DATA(s_IconRocket),
SAVE_DATA(s_IconLgRocket),
SAVE_DATA(s_IconShotgun),
SAVE_DATA(s_IconLgShotshell),
SAVE_DATA(s_IconAutoRiot),
SAVE_DATA(s_IconGrenadeLauncher),
SAVE_DATA(s_IconLgGrenade),
SAVE_DATA(s_IconLgMine),
SAVE_DATA(s_IconGuardHead),
SAVE_DATA(s_IconFireballLgAmmo),
SAVE_DATA(s_IconHeart),
SAVE_DATA(s_IconHeartLgAmmo),
SAVE_DATA(s_IconMicroGun),
SAVE_DATA(s_IconMicroBattery),
SAVE_DATA(s_IconRailGun),
SAVE_DATA(s_IconRailAmmo),
SAVE_DATA(s_IconElectro),
SAVE_DATA(s_IconSpell),
SAVE_DATA(s_IconArmor),
SAVE_DATA(s_IconMedkit),
SAVE_DATA(s_IconChemBomb),
SAVE_DATA(s_IconFlashBomb),
SAVE_DATA(s_IconNuke),
SAVE_DATA(s_IconCaltrops),
SAVE_DATA(s_IconSmMedkit),
SAVE_DATA(s_IconBooster),
SAVE_DATA(s_IconHeatCard),
//SAVE_DATA(s_IconEnvironSuit),
SAVE_DATA(s_IconCloak),
SAVE_DATA(s_IconFly),
SAVE_DATA(s_IconNightVision),
SAVE_DATA(s_IconFlag),
};
saveable_module saveable_sprite =
{
// code
saveable_sprite_code,
SIZ(saveable_sprite_code),
// data
saveable_sprite_data,
SIZ(saveable_sprite_data)
};
END_SW_NS
Reference in a new issue View git blame Copy permalink