zdoom/raze
0
0
Fork 0
mirror of https://github.com/ZDoom/Raze.git synced 2025-01-27 10:40:52 +00:00
Code Issues Projects Releases Packages Wiki Activity
raze/source/games/exhumed/src/sequence.cpp

610 lines
17 KiB
C++
Raw Blame 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 "gamehud.h"
#include "sequence.h"
#include "engine.h"
#include "exhumed.h"
#include "sound.h"
#include "player.h"
#include "aistuff.h"
#include "view.h"
#include <string.h>
#include <stdio.h>
BEGIN_PS_NS
int16_t nPilotLightFrame;
int16_t nPilotLightCount;
static FTextureID nShadowPic;
static int16_t nShadowWidth = 1;
int16_t nFlameHeight = 1;
static constexpr const char *SeqNames[] =
{
"rothands",
"sword",
"pistol",
"m_60",
"flamer", // 4
"grenade",
"cobra",
"bonesaw",
"scramble",
"glove",
"mummy", // 10
"skull",
"poof",
"kapow",
"fireball",
"bubble",
"spider", // 16
"anubis",
"anuball",
"fish",
"snakehed", // 20?
"snakbody",
"wasp",
"cobrapow",
"scorp",
"joe", // 25
"status",
"dead",
"deadex",
"anupoof",
"skulpoof", // 30
"bullet",
"shadow",
"grenroll",
"grenboom",
"splash",
"grenpow",
"skulstrt",
"firepoof",
"bloodhit",
"lion", // 40
"items",
"lavag", // 42
"lsplash",
"lavashot",
"smokebal",
"firepot",
"rex",
"set", // 48
"queen",
"roach", // 50
"hawk",
"setghost",
"setgblow",
"bizztail",
"bizzpoof",
"queenegg",
"roacshot",
"backgrnd",
"screens", // 59
"arrow",
"fonts",
"drips",
"firetrap",
"magic2",
"creepy",
"slider", // 66
"ravolt",
"eyehit",
"font2", // 69
"seebubbl",
"blood",
"drum",
"poof2",
"deadbrn",
"grenbubb",
"rochfire",
"rat"
};
static TMap<FName, TArray<Seq>> FileSeqMap;
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
const TArray<Seq>* const getFileSeqs(const FName nSeqFile)
{
return FileSeqMap.CheckKey(nSeqFile);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
static void fixSeqs()
{
// Seq file "skulstrt" has one sprite face with 20 frames instead of 24.
if (const auto skulstrt = FileSeqMap.CheckKey("skulstrt"))
{
// Get 5th sequence with missing frames.
if (const auto seq = skulstrt->Data(4))
{
// Store last frame.
const auto lastframe = seq->frames.Last();
// Repeat last frame another four times.
for (unsigned i = 20; i < 24; i++)
{
seq->frames.Push(lastframe);
}
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
static int addSeq(const char *seqName)
{
const FStringf seqfilename("%s.seq", seqName);
const auto hFile = fileSystem.ReopenFileReader(fileSystem.FindFile(seqfilename), true);
if (!hFile.isOpen())
{
Printf("Unable to open '%s'!\n", seqfilename.GetChars());
return 0;
}
constexpr auto id1 = MAKE_ID('I', 'H', 0, 0);
constexpr auto id2 = MAKE_ID('D', 'S', 0, 0);
uint16_t tag;
hFile.Read(&tag, sizeof(tag));
if (tag < id1 || (tag > id1 && tag != id2))
{
Printf("Unsupported sequence version!\n");
return 0;
}
int16_t CenterX, CenterY, nSeqs;
hFile.Read(&CenterX, sizeof(CenterX));
hFile.Read(&CenterY, sizeof(CenterY));
hFile.Read(&nSeqs, sizeof(nSeqs));
if (nSeqs <= 0)
{
Printf("Invalid sequence count!\n");
return 0;
}
TArray<int16_t> nSeqFrames(nSeqs, true);
TArray<int16_t> nSeqFrameCount(nSeqs, true);
TArray<int16_t> nSeqFlags(nSeqs, true);
hFile.Read(nSeqFrames.Data(), nSeqs * sizeof(int16_t));
hFile.Read(nSeqFrameCount.Data(), nSeqs * sizeof(int16_t));
hFile.Read(nSeqFlags.Data(), nSeqs * sizeof(int16_t));
int16_t nFrames;
hFile.Read(&nFrames, sizeof(nFrames));
if (nFrames <= 0)
{
Printf("Invalid frame count!\n");
return 0;
}
TArray<int16_t> nFrameChunks(nFrames, true);
TArray<int16_t> nFrameChunkCount(nFrames, true);
TArray<int16_t> nFrameFlags(nFrames, true);
TArray<int16_t> nFrameSounds(nFrames, true);
hFile.Read(nFrameChunks.Data(), nFrames * sizeof(int16_t));
hFile.Read(nFrameChunkCount.Data(), nFrames * sizeof(int16_t));
hFile.Read(nFrameFlags.Data(), nFrames * sizeof(int16_t));
memset(nFrameSounds.Data(), -1, nFrames * sizeof(int16_t));
int16_t nChunks;
hFile.Read(&nChunks, sizeof(nChunks));
if (nChunks <= 0)
{
Printf("Invalid chunk count!\n");
return 0;
}
TArray<int16_t> nChunkPosX(nChunks, true);
TArray<int16_t> nChunkPosY(nChunks, true);
TArray<int16_t> nChunkPicnum(nChunks, true);
TArray<int16_t> nChunkFlags(nChunks, true);
hFile.Read(nChunkPosX.Data(), nChunks * sizeof(int16_t));
hFile.Read(nChunkPosY.Data(), nChunks * sizeof(int16_t));
hFile.Read(nChunkPicnum.Data(), nChunks * sizeof(int16_t));
hFile.Read(nChunkFlags.Data(), nChunks * sizeof(int16_t));
if (tag == id2)
{
int16_t nSounds;
hFile.Read(&nSounds, sizeof(nSounds));
TArray<char> buffer(nSounds * 10, true);
memset(buffer.Data(), 0, nSounds * 10);
for (int i = 0; i < nSounds; i++)
{
hFile.Read(&buffer[i * 10], 8);
}
int16_t nSounds2;
hFile.Read(&nSounds2, sizeof(nSounds2));
for (int i = 0; i < nSounds2; i++)
{
int16_t nSeqFrame, nSoundVal;
hFile.Read(&nSeqFrame, sizeof(nSeqFrame));
hFile.Read(&nSoundVal, sizeof(nSoundVal));
const int nSndIndex = nSoundVal & 0x1FF;
const int nSndFlags = nSoundVal & 0xFE00;
if (nSndIndex < nSounds)
{
nFrameSounds[nSeqFrame] = LoadSound(&buffer[nSndIndex * 10]) | nSndFlags;
}
else
{
Printf("Invalid sound index %d in %s, maximum is %d\n", nSndIndex, seqfilename.GetChars(), nSounds);
}
}
}
// Add hastable entry for the amount of sequences this file contains.
auto& gSequences = FileSeqMap.Insert(FName(seqName), TArray<Seq>(nSeqs, true));
// Read all this data into something sane.
for (int nSeq = 0; nSeq < nSeqs; nSeq++)
{
// Store unused sequence flags, they may be used with future expansion.
auto& gSeq = gSequences[nSeq];
gSeq.flags = nSeqFlags[nSeq];
// Determine where we are in our frame array.
const int firstFrame = nSeqFrames[nSeq];
const int lastFrame = nSeqFrameCount[nSeq] + firstFrame;
// Get sequence's frame array and resize.
auto& gSeqFrames = gSeq.frames;
gSeqFrames.Resize(lastFrame - firstFrame);
// Build out frame array.
for (int nFrame = firstFrame; nFrame < lastFrame; nFrame++)
{
// Store reference to this frame and start filling.
auto& gSeqFrame = gSeqFrames[nFrame - firstFrame];
gSeqFrame.sound = nFrameSounds[nFrame];
gSeqFrame.flags = nFrameFlags[nFrame];
// Determine where we are in our chunk array.
const int firstChunk = nFrameChunks[nFrame];
const int lastChunk = nFrameChunkCount[nFrame] + firstChunk;
// Build out chunk array.
for (int nChunk = firstChunk; nChunk < lastChunk; nChunk++)
{
gSeqFrame.chunks.Push({
(int16_t)(nChunkPosX[nChunk] - CenterX),
(int16_t)(nChunkPosY[nChunk] - CenterY),
tileGetTextureID(nChunkPicnum[nChunk]),
nChunkFlags[nChunk],
});
}
}
}
return nSeqs;
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void seq_LoadSequences()
{
for (const auto& seq : SeqNames)
{
if (addSeq(seq) == 0)
{
Printf("Error loading '%s'\n", seq);
}
}
// Perform sequence post-processing for where original assets are malformed.
fixSeqs();
nShadowPic = getSequence("shadow")->getFirstFrameTexture();
nShadowWidth = (int16_t)TexMan.GetGameTexture(nShadowPic)->GetDisplayWidth();
nFlameHeight = (int16_t)TexMan.GetGameTexture(getSequence("firepoof")->getFirstFrameTexture())->GetDisplayHeight();
nPilotLightCount = getSequence("flamer", 3)->frames.Size();
nPilotLightFrame = 0;
const auto fontSeq = getSequence("font2");
const auto nFontFirstChar = fontSeq->getFirstFrameTexture();
for (unsigned i = 0; i < fontSeq->frames.Size(); i++)
{
auto tex = TexMan.GetGameTexture(nFontFirstChar + i);
tex->SetOffsets(0, 0);
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void seq_DrawPilotLightSeq(double xPos, double yPos, double nAngle)
{
const auto& seqFrameChunks = getSequence("flamer", 3)->frames[0].chunks;
for (unsigned i = 0; i < seqFrameChunks.Size(); i++)
{
const auto& frameChunk = seqFrameChunks[i];
const double x = xPos + frameChunk.xpos;
const double y = yPos + frameChunk.ypos;
hud_drawsprite(x, y, 1, nAngle, frameChunk.tex, 0, 0, 1);
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void seq_DrawGunSequence(const SeqFrame& seqFrame, double xPos, double yPos, int nShade, int nPal, DAngle nAngle, double nAlpha, int nStat)
{
if (seqFrame.flags & 4)
nShade = -100;
for (unsigned i = 0; i < seqFrame.chunks.Size(); i++)
{
const auto& frameChunk = seqFrame.chunks[i];
const double x = xPos + frameChunk.xpos;
const double y = yPos + frameChunk.ypos;
const int frameStat = nStat | (RS_XFLIPHUD * !!(frameChunk.flags & 1)) | (RS_YFLIPHUD * !!(frameChunk.flags & 2));
hud_drawsprite(x, y, 1, nAngle.Degrees(), frameChunk.tex, nShade, nPal, frameStat, nAlpha);
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void seq_PlotArrowSequence(const int nSprite, const FName seqFile, const int16_t seqIndex, const int frameIndex)
{
tspritetype* pTSprite = mytspriteArray->get(nSprite);
const DAngle nAngle = (nCamerapos.XY() - pTSprite->pos.XY()).Angle();
const int seqOffset = (((pTSprite->Angles.Yaw + DAngle90 + DAngle22_5 - nAngle).Buildang()) & kAngleMask) >> 8;
const auto& seqFrame = getSequence(seqFile, seqIndex + seqOffset)->frames[frameIndex];
const auto& frameChunk = seqFrame.chunks[0];
if (seqFrame.flags & 4)
pTSprite->shade -= 100;
pTSprite->statnum = seqFrame.chunks.Size();
pTSprite->cstat |= CSTAT_SPRITE_YCENTER;
if (seqOffset & 3)
{
pTSprite->cstat |= CSTAT_SPRITE_ALIGNMENT_WALL | CSTAT_SPRITE_YFLIP;
}
else
{
pTSprite->cstat &= ~(CSTAT_SPRITE_ALIGNMENT_WALL | CSTAT_SPRITE_YFLIP);
}
if (frameChunk.flags & 1)
{
pTSprite->xoffset = (int8_t)frameChunk.xpos;
pTSprite->cstat |= CSTAT_SPRITE_XFLIP;
}
else
{
pTSprite->xoffset = (int8_t)-frameChunk.xpos;
}
pTSprite->yoffset = -frameChunk.ypos;
pTSprite->setspritetexture(frameChunk.tex);
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void seq_PlotSequence(const int nSprite, const FName seqFile, const int16_t seqIndex, const int16_t frameIndex, const int16_t nFlags)
{
tspritetype* pTSprite = mytspriteArray->get(nSprite);
int seqOffset = 0;
if (!(nFlags & 1))
{
const DAngle nAngle = (nCamerapos.XY() - pTSprite->pos.XY()).Angle();
seqOffset = (((pTSprite->Angles.Yaw + DAngle22_5 - nAngle).Buildang()) & kAngleMask) >> 8;
}
const auto fileSeqs = getFileSeqs(seqFile);
const auto& seqFrame = fileSeqs->Data(seqIndex + seqOffset)->frames[frameIndex];
const auto chunkCount = seqFrame.chunks.Size();
const auto nShade = pTSprite->shade - (100 * !!(fileSeqs->Data(seqIndex)->frames[frameIndex].flags & 4));
const auto nStatnum = (nFlags & 0x100) ? -3 : 100;
for (unsigned i = 0; i < chunkCount; i++)
{
const auto& frameChunk = seqFrame.chunks[i];
tspritetype* tsp = mytspriteArray->newTSprite();
tsp->pos = pTSprite->pos;
tsp->shade = nShade;
tsp->pal = pTSprite->pal;
tsp->scale = pTSprite->scale;
tsp->Angles.Yaw = pTSprite->Angles.Yaw;
tsp->ownerActor = pTSprite->ownerActor;
tsp->sectp = pTSprite->sectp;
tsp->cstat = pTSprite->cstat |= CSTAT_SPRITE_YCENTER;
tsp->clipdist = pTSprite->clipdist;
tsp->statnum = chunkCount - i + nStatnum + 1;
if (frameChunk.flags & 1)
{
tsp->xoffset = (int8_t)frameChunk.xpos;
tsp->cstat |= CSTAT_SPRITE_XFLIP; // x-flipped
}
else
{
tsp->xoffset = -frameChunk.xpos;
}
tsp->yoffset = -frameChunk.ypos;
tsp->setspritetexture(frameChunk.tex);
}
if (!(pTSprite->cstat & CSTAT_SPRITE_BLOCK_ALL) || (pTSprite->ownerActor->spr.statnum == 100 && nNetPlayerCount))
{
pTSprite->ownerActor = nullptr;
}
else
{
const auto pSector = pTSprite->sectp;
const double nFloorZ = pSector->floorz;
if (nFloorZ <= getPlayer(nLocalPlayer)->GetActor()->viewzoffset + getPlayer(nLocalPlayer)->GetActor()->spr.pos.Z)
{
pTSprite->ownerActor = nullptr;
}
else
{
const auto nTexWidth = (int)TexMan.GetGameTexture(seqFrame.getFirstChunkTexture())->GetDisplayWidth();
const auto nScale = max(((nTexWidth << 5) / nShadowWidth) - int16_t((nFloorZ - pTSprite->pos.Z) * 2.), 1) * REPEAT_SCALE;
pTSprite->setspritetexture(nShadowPic);
pTSprite->cstat = CSTAT_SPRITE_ALIGNMENT_FLOOR | CSTAT_SPRITE_TRANSLUCENT;
pTSprite->pos.Z = pSector->floorz;
pTSprite->scale = DVector2(nScale, nScale);
pTSprite->statnum = -3;
pTSprite->pal = 0;
}
}
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
DEFINE_FIELD_X(SeqFrameChunk, SeqFrameChunk, xpos);
DEFINE_FIELD_X(SeqFrameChunk, SeqFrameChunk, ypos);
DEFINE_FIELD_X(SeqFrameChunk, SeqFrameChunk, tex);
DEFINE_FIELD_X(SeqFrameChunk, SeqFrameChunk, flags);
DEFINE_FIELD_X(SeqFrame, SeqFrame, sound);
DEFINE_FIELD_X(SeqFrame, SeqFrame, flags);
DEFINE_FIELD_X(Seq, Seq, flags);
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
DEFINE_ACTION_FUNCTION(_SeqFrame, playSound)
{
PARAM_SELF_STRUCT_PROLOGUE(SeqFrame);
self->playSound(getPlayer(nLocalPlayer)->GetActor());
return 0;
}
DEFINE_ACTION_FUNCTION(_SeqFrame, Size)
{
PARAM_SELF_STRUCT_PROLOGUE(SeqFrame);
ACTION_RETURN_INT(self->chunks.Size());
}
DEFINE_ACTION_FUNCTION(_SeqFrame, getChunk)
{
PARAM_SELF_STRUCT_PROLOGUE(SeqFrame);
PARAM_INT(chunkId);
ACTION_RETURN_POINTER(self->chunks.Data(chunkId));
}
DEFINE_ACTION_FUNCTION(_Seq, Size)
{
PARAM_SELF_STRUCT_PROLOGUE(Seq);
ACTION_RETURN_INT(self->frames.Size());
}
DEFINE_ACTION_FUNCTION(_Seq, getFrame)
{
PARAM_SELF_STRUCT_PROLOGUE(Seq);
PARAM_INT(frameId);
ACTION_RETURN_POINTER(self->frames.Data(frameId));
}
DEFINE_ACTION_FUNCTION(_Exhumed, GetStatusSequence)
{
PARAM_PROLOGUE;
PARAM_INT(seqId);
ACTION_RETURN_CONST_POINTER(getSequence("status", seqId));
}
//---------------------------------------------------------------------------
//
//
//
//---------------------------------------------------------------------------
void SerializeSequence(FSerializer& arc)
{
if (arc.BeginObject("sequence"))
{
arc("pilotlightframe", nPilotLightFrame)
("pilotlightcount", nPilotLightCount)
("shadowwidth", nShadowWidth)
("flameheight", nFlameHeight)
.EndObject();
}
}
END_PS_NS
Reference in a new issue View git blame Copy permalink