raze/source/games/exhumed/src/anims.cpp

345 lines
8.4 KiB
C++
Raw Normal View History

//-------------------------------------------------------------------------
/*
Copyright (C) 2010-2019 EDuke32 developers and contributors
Copyright (C) 2019 sirlemonhead, Nuke.YKT
This file is part of PCExhumed.
PCExhumed is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License version 2
as published by the Free Software Foundation.
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.
*/
//-------------------------------------------------------------------------
#include "ns.h"
#include "engine.h"
#include "aistuff.h"
#include "sequence.h"
#include "exhumed.h"
#include "sound.h"
#include <assert.h>
BEGIN_PS_NS
short nMagicSeq = -1;
short nPreMagicSeq = -1;
short nSavePointSeq = -1;
2020-11-29 23:47:53 +00:00
FreeListArray<Anim, kMaxAnims> AnimList;
2020-11-29 23:47:53 +00:00
FSerializer& Serialize(FSerializer& arc, const char* keyname, Anim& w, Anim* def)
{
2020-11-29 23:47:53 +00:00
if (arc.BeginObject(keyname))
{
arc("seq", w.nIndex2)
("val1", w.nIndex)
2020-11-29 23:47:53 +00:00
("val2", w.field_4)
("sprite", w.nSprite)
("runrec", w.nRun)
("flags", w.nAction)
2020-11-29 23:47:53 +00:00
.EndObject();
}
2020-11-29 23:47:53 +00:00
return arc;
}
2020-11-29 23:47:53 +00:00
void SerializeAnim(FSerializer& arc)
{
if (arc.BeginObject("anims"))
{
arc("magic", nMagicSeq)
("premagic", nPreMagicSeq)
("savepoint", nSavePointSeq)
("list", AnimList)
.EndObject();
}
}
2020-11-29 23:47:53 +00:00
void InitAnims()
{
AnimList.Clear();
nMagicSeq = SeqOffsets[kSeqItems] + 21;
nPreMagicSeq = SeqOffsets[kSeqMagic2];
nSavePointSeq = SeqOffsets[kSeqItems] + 12;
}
void DestroyAnim(int nAnim)
{
2021-10-24 18:06:46 +00:00
auto pActor = &AnimList[nAnim];
short nSprite = pActor->nSprite;
if (nSprite >= 0)
{
auto pSprite = &sprite[nSprite];
StopSpriteSound(nSprite);
runlist_SubRunRec(pActor->nRun);
runlist_DoSubRunRec(pSprite->extra);
runlist_FreeRun(pSprite->lotag - 1);
}
2020-11-29 23:47:53 +00:00
AnimList.Release(nAnim);
}
int BuildAnim(int nSprite, int val, int val2, int x, int y, int z, int nSector, int nRepeat, int nFlag)
{
2020-11-29 23:47:53 +00:00
int nAnim = AnimList.Get();
if (nAnim < 0) {
return -1;
}
2021-10-24 18:06:46 +00:00
auto pActor = &AnimList[nAnim];
if (nSprite == -1) {
nSprite = insertsprite(nSector, 500);
}
auto pSprite = &sprite[nSprite];
pSprite->x = x;
pSprite->y = y;
pSprite->z = z;
pSprite->cstat = 0;
if (nFlag & 4)
{
pSprite->pal = 4;
pSprite->shade = -64;
}
else
{
pSprite->pal = 0;
pSprite->shade = -12;
}
pSprite->clipdist = 10;
pSprite->xrepeat = nRepeat;
pSprite->yrepeat = nRepeat;
pSprite->picnum = 1;
pSprite->ang = 0;
pSprite->xoffset = 0;
pSprite->yoffset = 0;
pSprite->xvel = 0;
pSprite->yvel = 0;
pSprite->zvel = 0;
pSprite->backuppos();
// CHECKME - where is hitag set otherwise?
if (pSprite->statnum < 900) {
pSprite->hitag = -1;
}
pSprite->lotag = runlist_HeadRun() + 1;
pSprite->owner = -1;
pSprite->extra = runlist_AddRunRec(pSprite->lotag - 1, nAnim, 0x100000);
pActor->nRun = runlist_AddRunRec(NewRun, nAnim, 0x100000);
2021-10-24 18:06:46 +00:00
pActor->nSprite = nSprite;
pActor->nAction = nFlag;
pActor->nIndex = 0;
pActor->nIndex2 = SeqOffsets[val] + val2;
2021-10-24 18:06:46 +00:00
pActor->field_4 = 256;
if (nFlag & 0x80) {
pSprite->cstat |= 0x2; // set transluscence
}
return nAnim;
}
short GetAnimSprite(short nAnim)
{
2021-10-24 18:06:46 +00:00
auto pActor = &AnimList[nAnim];
return pActor->nSprite;
}
2021-10-15 19:06:53 +00:00
void AIAnim::Tick(RunListEvent* ev)
{
short nAnim = RunData[ev->nRun].nObjIndex;
assert(nAnim >= 0 && nAnim < kMaxAnims);
2021-10-24 18:06:46 +00:00
auto pActor = &AnimList[nAnim];
2021-10-24 18:06:46 +00:00
short nSprite = pActor->nSprite;
short nSeq = pActor->nIndex2;
2021-10-15 19:06:53 +00:00
auto pSprite = &sprite[nSprite];
assert(nSprite != -1);
short var_1C = pActor->nIndex;
2021-10-15 19:06:53 +00:00
if (!(pSprite->cstat & 0x8000))
{
2021-10-15 19:06:53 +00:00
seq_MoveSequence(nSprite, nSeq, var_1C);
}
if (pSprite->statnum == kStatIgnited)
{
short nSpriteB = pSprite->hitag;
if (nSpriteB > -1)
{
2021-10-15 19:06:53 +00:00
auto pSpriteB = &sprite[nSpriteB];
pSprite->x = pSpriteB->x;
pSprite->y = pSpriteB->y;
pSprite->z = pSpriteB->z;
2021-10-15 19:06:53 +00:00
if (pSpriteB->sectnum != pSprite->sectnum)
{
2021-10-15 19:06:53 +00:00
if (pSpriteB->sectnum < 0 || pSpriteB->sectnum >= kMaxSectors)
{
DestroyAnim(nAnim);
mydeletesprite(nSprite);
return;
}
else
{
mychangespritesect(nSprite, pSpriteB->sectnum);
}
}
2021-10-15 19:06:53 +00:00
if (!var_1C)
{
2021-10-15 19:06:53 +00:00
if (pSpriteB->cstat != 0x8000)
{
2021-10-15 19:06:53 +00:00
short hitag2 = pSpriteB->hitag;
pSpriteB->hitag--;
2021-10-15 19:06:53 +00:00
if (hitag2 >= 15)
{
2021-10-15 19:06:53 +00:00
runlist_DamageEnemy(nSpriteB, -1, (pSpriteB->hitag - 14) * 2);
2021-10-15 19:06:53 +00:00
if (pSpriteB->shade < 100)
{
2021-10-15 19:06:53 +00:00
pSpriteB->pal = 0;
pSpriteB->shade++;
}
2021-10-15 19:06:53 +00:00
if (!(pSpriteB->cstat & 101))
2019-11-30 16:04:59 +00:00
{
DestroyAnim(nAnim);
mydeletesprite(nSprite);
2021-10-15 19:06:53 +00:00
return;
2019-11-30 16:04:59 +00:00
}
}
2021-10-15 19:06:53 +00:00
else
{
pSpriteB->hitag = 1;
DestroyAnim(nAnim);
mydeletesprite(nSprite);
}
}
else
{
2021-10-15 19:06:53 +00:00
pSpriteB->hitag = 1;
DestroyAnim(nAnim);
mydeletesprite(nSprite);
}
}
}
2021-10-15 19:06:53 +00:00
}
pActor->nIndex++;
if (pActor->nIndex >= SeqSize[nSeq])
2021-10-15 19:06:53 +00:00
{
if (pActor->nAction & 0x10)
{
pActor->nIndex = 0;
}
2021-10-15 19:06:53 +00:00
else if (nSeq == nPreMagicSeq)
{
pActor->nIndex = 0;
pActor->nIndex2 = nMagicSeq;
2021-10-24 18:06:46 +00:00
short nAnimSprite = pActor->nSprite;
pActor->nAction |= 0x10;
2021-10-15 19:06:53 +00:00
sprite[nAnimSprite].cstat |= 2;
}
2021-10-15 19:06:53 +00:00
else if (nSeq == nSavePointSeq)
{
pActor->nIndex = 0;
pActor->nIndex2++;
pActor->nAction |= 0x10;
2021-10-15 19:06:53 +00:00
}
else
{
2021-10-15 19:06:53 +00:00
DestroyAnim(nAnim);
mydeletesprite(nSprite);
}
}
}
2021-10-15 19:06:53 +00:00
void AIAnim::Draw(RunListEvent* ev)
{
short nAnim = RunData[ev->nRun].nObjIndex;
2021-10-15 19:06:53 +00:00
assert(nAnim >= 0 && nAnim < kMaxAnims);
2021-10-24 18:06:46 +00:00
auto pActor = &AnimList[nAnim];
short nSeq = pActor->nIndex2;
2021-10-15 19:06:53 +00:00
seq_PlotSequence(ev->nParam, nSeq, pActor->nIndex, 0x101);
2021-10-15 19:06:53 +00:00
ev->pTSprite->owner = -1;
}
void FuncAnim(int nObject, int nMessage, int nDamage, int nRun)
{
AIAnim ai;
runlist_DispatchEvent(&ai, nObject, nMessage, nDamage, nRun);
}
2021-10-24 17:18:11 +00:00
void BuildExplosion(DExhumedActor* pActor)
{
2021-10-24 17:18:11 +00:00
auto pSprite = &pActor->s();
short nSector = pSprite->sectnum;
int edx = 36;
if (SectFlag[nSector] & kSectUnderwater)
{
edx = 75;
}
else if (pSprite->z == sector[nSector].floorz)
{
edx = 34;
}
BuildAnim(nullptr, edx, 0, pSprite->x, pSprite->y, pSprite->z, pSprite->sectnum, pSprite->xrepeat, 4);
}
2021-10-24 17:18:11 +00:00
void BuildSplash(DExhumedActor* actor, int nSector)
{
2021-10-24 17:18:11 +00:00
auto pSprite = &actor->s();
int nRepeat, nSound;
if (pSprite->statnum != 200)
{
nRepeat = pSprite->xrepeat + (RandomWord() % pSprite->xrepeat);
nSound = kSound0;
}
else
{
nRepeat = 20;
nSound = kSound1;
}
int bIsLava = SectFlag[nSector] & kSectLava;
int edx, nFlag;
if (bIsLava)
{
edx = 43;
nFlag = 4;
}
else
{
edx = 35;
nFlag = 0;
}
auto pActor = BuildAnim(nullptr, edx, 0, pSprite->x, pSprite->y, sector[nSector].floorz, nSector, nRepeat, nFlag);
if (!bIsLava)
{
D3PlayFX(StaticSound[nSound] | 0xa00, pActor);
}
}
END_PS_NS