zdoom/raze
0
0
Fork 0
mirror of https://github.com/ZDoom/Raze.git synced 2024-11-16 01:11:44 +00:00
Code Issues Projects Releases Packages Wiki Activity

- use EventObject in SEQINST

Browse source
This commit is contained in:
Christoph Oelckers 2021-11-23 20:38:41 +01:00
parent 2721a59dc4
commit 45a8654fc2
5 changed files with 133 additions and 131 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
source/games/blood/src/_polymost.cpp
View file

@ -195,7 +195,7 @@ void setPortalFlags(int mode)
}
}
// Note: wall range checks on wall[] need to be disabled because this writes beyond the regular part.
// Note: debug range checks on wall [] need to be disabled because this deliberately writes beyond the regular part.
void DrawMirrors(int x, int y, int z, fixed_t a, fixed_t horiz, int smooth, int viewPlayer)
{

46
source/games/blood/src/nnexts.cpp
View file

@ -3515,49 +3515,51 @@ void useSeqSpawnerGen(DBloodActor* sourceactor, int objType, int index, DBloodAc
switch (objType)
{
case OBJ_SECTOR:
{
auto pSector = &sector[index];
if (pXSource->data2 <= 0)
{
if (pXSource->data3 == 3 || pXSource->data3 == 1)
seqKill(2, index);
seqKill(SS_FLOOR, pSector);
if (pXSource->data3 == 3 || pXSource->data3 == 2)
seqKill(1, index);
seqKill(SS_CEILING, pSector);
}
else
{
if (pXSource->data3 == 3 || pXSource->data3 == 1)
seqSpawn(pXSource->data2, SS_FLOOR, index, -1);
seqSpawn(pXSource->data2, SS_FLOOR, pSector, -1);
if (pXSource->data3 == 3 || pXSource->data3 == 2)
seqSpawn(pXSource->data2, SS_CEILING, index, -1);
seqSpawn(pXSource->data2, SS_CEILING, pSector, -1);
}
return;
}
case OBJ_WALL:
{
auto pWall = &wall[index];
if (pXSource->data2 <= 0)
{
if (pXSource->data3 == 3 || pXSource->data3 == 1)
seqKill(0, index);
seqKill(SS_WALL, pWall);
if ((pXSource->data3 == 3 || pXSource->data3 == 2) && (pWall->cstat & CSTAT_WALL_MASKED))
seqKill(4, index);
seqKill(SS_MASKED, pWall);
}
else
{
if (pXSource->data3 == 3 || pXSource->data3 == 1)
seqSpawn(pXSource->data2, SS_WALL, index, -1);
seqSpawn(pXSource->data2, SS_WALL, pWall, -1);
if (pXSource->data3 == 3 || pXSource->data3 == 2) {
if (pWall->nextwall < 0) {
if (pXSource->data3 == 3)
seqSpawn(pXSource->data2, SS_WALL, index, -1);
seqSpawn(pXSource->data2, SS_WALL, pWall, -1);
}
else {
if (!(pWall->cstat & CSTAT_WALL_MASKED))
pWall->cstat |= CSTAT_WALL_MASKED;
seqSpawn(pXSource->data2, SS_MASKED, index, -1);
seqSpawn(pXSource->data2, SS_MASKED, pWall, -1);
}
}
@ -3904,17 +3906,17 @@ bool condCheckMixed(DBloodActor* aCond, const EVENT& event, int cmpOp, bool PUSH
case 70:
switch (arg3)
{
default: return (condCmp(seqGetID(0, wallnum(pObj)), arg1, arg2, cmpOp) || condCmp(seqGetID(4, wallnum(pObj)), arg1, arg2, cmpOp));
case 1: return condCmp(seqGetID(0, wallnum(pObj)), arg1, arg2, cmpOp);
case 2: return condCmp(seqGetID(4, wallnum(pObj)), arg1, arg2, cmpOp);
default: return (condCmp(seqGetID(SS_WALL, pObj), arg1, arg2, cmpOp) || condCmp(seqGetID(SS_MASKED, pObj), arg1, arg2, cmpOp));
case 1: return condCmp(seqGetID(SS_WALL, pObj), arg1, arg2, cmpOp);
case 2: return condCmp(seqGetID(SS_MASKED, pObj), arg1, arg2, cmpOp);
}
break;
case 71:
switch (arg3)
{
default: return (condCmp(seqGetStatus(0, wallnum(pObj)), arg1, arg2, cmpOp) || condCmp(seqGetStatus(4, wallnum(pObj)), arg1, arg2, cmpOp));
case 1: return condCmp(seqGetStatus(0, wallnum(pObj)), arg1, arg2, cmpOp);
case 2: return condCmp(seqGetStatus(4, wallnum(pObj)), arg1, arg2, cmpOp);
default: return (condCmp(seqGetStatus(SS_WALL, pObj), arg1, arg2, cmpOp) || condCmp(seqGetStatus(SS_MASKED, pObj), arg1, arg2, cmpOp));
case 1: return condCmp(seqGetStatus(SS_WALL, pObj), arg1, arg2, cmpOp);
case 2: return condCmp(seqGetStatus(SS_MASKED, pObj), arg1, arg2, cmpOp);
}
break;
}
@ -3969,17 +3971,17 @@ bool condCheckMixed(DBloodActor* aCond, const EVENT& event, int cmpOp, bool PUSH
// wall???
switch (arg3)
{
default: return (condCmp(seqGetID(1, sectnum(pObj)), arg1, arg2, cmpOp) || condCmp(seqGetID(2, sectnum(pObj)), arg1, arg2, cmpOp));
case 1: return condCmp(seqGetID(1, sectnum(pObj)), arg1, arg2, cmpOp);
case 2: return condCmp(seqGetID(2, sectnum(pObj)), arg1, arg2, cmpOp);
default: return (condCmp(seqGetID(SS_CEILING, pObj), arg1, arg2, cmpOp) || condCmp(seqGetID(SS_FLOOR, pObj), arg1, arg2, cmpOp));
case 1: return condCmp(seqGetID(SS_CEILING, pObj), arg1, arg2, cmpOp);
case 2: return condCmp(seqGetID(SS_FLOOR, pObj), arg1, arg2, cmpOp);
}
break;
case 71:
switch (arg3)
{
default: return (condCmp(seqGetStatus(1, sectnum(pObj)), arg1, arg2, cmpOp) || condCmp(seqGetStatus(2, sectnum(pObj)), arg1, arg2, cmpOp));
case 1: return condCmp(seqGetStatus(1, sectnum(pObj)), arg1, arg2, cmpOp);
case 2: return condCmp(seqGetStatus(2, sectnum(pObj)), arg1, arg2, cmpOp);
default: return (condCmp(seqGetStatus(SS_CEILING, pObj), arg1, arg2, cmpOp) || condCmp(seqGetStatus(SS_FLOOR, pObj), arg1, arg2, cmpOp));
case 1: return condCmp(seqGetStatus(SS_CEILING, pObj), arg1, arg2, cmpOp);
case 2: return condCmp(seqGetStatus(SS_FLOOR, pObj), arg1, arg2, cmpOp);
}
break;
}

194
source/games/blood/src/seq.cpp
View file

@ -126,10 +126,8 @@ void seqPrecacheId(int id, int palette)
//
//---------------------------------------------------------------------------
void UpdateCeiling(int nSector, SEQFRAME* pFrame)
void UpdateCeiling(sectortype* pSector, SEQFRAME* pFrame)
{
assert(validSectorIndex(nSector));
sectortype* pSector = &sector[nSector];
pSector->ceilingpicnum = seqGetTile(pFrame);
pSector->ceilingshade = pFrame->shade;
if (pFrame->palette)
@ -142,10 +140,8 @@ void UpdateCeiling(int nSector, SEQFRAME* pFrame)
//
//---------------------------------------------------------------------------
void UpdateFloor(int nSector, SEQFRAME* pFrame)
void UpdateFloor(sectortype* pSector, SEQFRAME* pFrame)
{
assert(validSectorIndex(nSector));
sectortype* pSector = &sector[nSector];
pSector->floorpicnum = seqGetTile(pFrame);
pSector->floorshade = pFrame->shade;
if (pFrame->palette)
@ -158,10 +154,8 @@ void UpdateFloor(int nSector, SEQFRAME* pFrame)
//
//---------------------------------------------------------------------------
void UpdateWall(int nWall, SEQFRAME* pFrame)
void UpdateWall(walltype* pWall, SEQFRAME* pFrame)
{
assert(validWallIndex(nWall));
walltype* pWall = &wall[nWall];
assert(pWall->hasX());
pWall->picnum = seqGetTile(pFrame);
if (pFrame->palette)
@ -190,10 +184,8 @@ void UpdateWall(int nWall, SEQFRAME* pFrame)
//
//---------------------------------------------------------------------------
void UpdateMasked(int nWall, SEQFRAME* pFrame)
void UpdateMasked(walltype* pWall, SEQFRAME* pFrame)
{
assert(validWallIndex(nWall));
walltype* pWall = &wall[nWall];
assert(pWall->hasX());
walltype* pWallNext = pWall->nextWall();
pWall->overpicnum = pWallNext->overpicnum = seqGetTile(pFrame);
@ -326,17 +318,22 @@ void SEQINST::Update()
assert(frameIndex < pSequence->nFrames);
switch (type)
{
case 0:
UpdateWall(seqindex, &pSequence->frames[frameIndex]);
case SS_WALL:
assert(target.isWall());
UpdateWall(target.wall(), &pSequence->frames[frameIndex]);
break;
case 1:
UpdateCeiling(seqindex, &pSequence->frames[frameIndex]);
case SS_CEILING:
assert(target.isSector());
UpdateCeiling(target.sector(), &pSequence->frames[frameIndex]);
break;
case 2:
UpdateFloor(seqindex, &pSequence->frames[frameIndex]);
case SS_FLOOR:
assert(target.isSector());
UpdateFloor(target.sector(), &pSequence->frames[frameIndex]);
break;
case 3:
case SS_SPRITE:
{
assert(target.isActor());
auto actor = target.actor();
if (!actor) break;
UpdateSprite(actor, &pSequence->frames[frameIndex]);
if (pSequence->frames[frameIndex].playsound) {
@ -388,16 +385,17 @@ void SEQINST::Update()
}
break;
}
case 4:
UpdateMasked(seqindex, &pSequence->frames[frameIndex]);
case SS_MASKED:
assert(target.isWall());
UpdateMasked(target.wall(), &pSequence->frames[frameIndex]);
break;
}
// all seq callbacks are for sprites, but there's no sanity checks here that what gets passed is meant to be for a sprite...
if (pSequence->frames[frameIndex].trigger && callback != -1)
{
assert(type == 3);
if (type == 3) seqClientCallback[callback](type, actor);
assert(type == SS_SPRITE);
if (target.isActor()) seqClientCallback[callback](type, target.actor());
}
}
@ -415,8 +413,8 @@ struct ActiveList
void clear() { list.Clear(); }
int getSize() { return list.Size(); }
SEQINST* getInst(int num) { return &list[num]; }
int getIndex(int num) { return list[num].seqindex; }
DBloodActor* getActor(int num) { return list[num].actor; }
EventObject getElement(int num) { return list[num].target; }
//DBloodActor* getActor(int num) { return list[num].actor; }
int getType(int num) { return list[num].type; }
void remove(int num)
@ -431,30 +429,26 @@ struct ActiveList
return &list.Last();
}
SEQINST* get(int type, int index)
SEQINST* get(int type, const EventObject& eob)
{
for (auto& n : list)
{
if (n.type == type && n.seqindex == index) return &n;
if (n.type == type && n.target == eob) return &n;
}
return nullptr;
}
SEQINST* get(DBloodActor* actor)
{
for (auto& n : list)
{
if (n.type == 3 && n.actor == actor) return &n;
}
return nullptr;
return get(SS_SPRITE, EventObject(actor));
}
void remove(int type, int index)
void remove(int type, const EventObject& eob)
{
for (unsigned i = 0; i < list.Size(); i++)
{
auto& n = list[i];
if (n.type == type && n.seqindex == index)
if (n.type == type && n.target == eob)
{
remove(i);
return;
@ -464,15 +458,7 @@ struct ActiveList
void remove(DBloodActor* actor)
{
for (unsigned i = 0; i < list.Size(); i++)
{
auto& n = list[i];
if (n.type == 3 && n.actor == actor)
{
remove(i);
return;
}
}
remove(SS_SPRITE, EventObject(actor));
}
};
@ -485,9 +471,9 @@ static ActiveList activeList;
//
//---------------------------------------------------------------------------
SEQINST* GetInstance(int type, int nIndex)
SEQINST* GetInstance(int type, const EventObject& eob)
{
return activeList.get(type, nIndex);
return activeList.get(type, eob);
}
SEQINST* GetInstance(DBloodActor* actor)
@ -495,23 +481,8 @@ SEQINST* GetInstance(DBloodActor* actor)
return activeList.get(actor);
}
int seqGetStatus(DBloodActor* actor)
void seqKill(int type, const EventObject& nIndex)
{
SEQINST* pInst = activeList.get(actor);
if (pInst) return pInst->frameIndex;
return -1;
}
int seqGetID(DBloodActor* actor)
{
SEQINST* pInst = activeList.get(actor);
if (pInst) return pInst->nSeqID;
return -1;
}
void seqKill(int type, int nIndex)
{
assert(type != SS_SPRITE);
activeList.remove(type, nIndex);
}
@ -520,6 +491,16 @@ void seqKillAll()
activeList.clear();
}
void seqKill(int type, sectortype* actor)
{
activeList.remove(type, EventObject(actor));
}
void seqKill(int type, walltype* actor)
{
activeList.remove(type, EventObject(actor));
}
void seqKill(DBloodActor* actor)
{
activeList.remove(actor);
@ -595,14 +576,13 @@ Seq* getSequence(int res_id)
//
//---------------------------------------------------------------------------
void seqSpawn(int nSeqID, int type, int nIndex, int callback)
void seqSpawn_(int nSeqID, int type, const EventObject& eob, int callback)
{
assert(type != SS_SPRITE);
Seq* pSequence = getSequence(nSeqID);
if (pSequence == nullptr) return;
SEQINST* pInst = activeList.get(type, nIndex);
SEQINST* pInst = activeList.get(type, eob);
if (!pInst)
{
pInst = activeList.getNew();
@ -620,38 +600,25 @@ void seqSpawn(int nSeqID, int type, int nIndex, int callback)
pInst->timeCounter = (short)pSequence->ticksPerFrame;
pInst->frameIndex = 0;
pInst->type = type;
pInst->seqindex = nIndex;
pInst->actor = nullptr;
pInst->target = eob;
pInst->Update();
}
void seqSpawn(int nSeqID, DBloodActor* actor, int callback)
{
Seq* pSequence = getSequence(nSeqID);
if (pSequence == nullptr) return;
SEQINST* pInst = activeList.get(actor);
if (!pInst)
{
pInst = activeList.getNew();
}
else
{
// already playing this sequence?
if (pInst->nSeqID == nSeqID)
return;
seqSpawn_(nSeqID, SS_SPRITE, EventObject(actor), callback);
}
pInst->pSequence = pSequence;
pInst->nSeqID = nSeqID;
pInst->callback = callback;
pInst->timeCounter = (short)pSequence->ticksPerFrame;
pInst->frameIndex = 0;
pInst->type = SS_SPRITE;
pInst->seqindex = 0;
pInst->actor = actor;
pInst->Update();
void seqSpawn(int nSeqID, int type, sectortype* sect, int callback)
{
assert(type == SS_FLOOR || type == SS_CEILING);
seqSpawn_(nSeqID, type, EventObject(sect), callback);
}
void seqSpawn(int nSeqID, int type, walltype* wal, int callback)
{
assert(type == SS_WALL || type == SS_MASKED);
seqSpawn_(nSeqID, type, EventObject(wal), callback);
}
//---------------------------------------------------------------------------
@ -660,20 +627,49 @@ void seqSpawn(int nSeqID, DBloodActor* actor, int callback)
//
//---------------------------------------------------------------------------
int seqGetStatus(int type, int nIndex)
int seqGetStatus(int type, sectortype* nIndex)
{
SEQINST* pInst = activeList.get(type, nIndex);
SEQINST* pInst = activeList.get(type, EventObject(nIndex));
if (pInst) return pInst->frameIndex;
return -1;
}
int seqGetID(int type, int nIndex)
int seqGetID(int type, sectortype* nIndex)
{
SEQINST* pInst = activeList.get(type, nIndex);
SEQINST* pInst = activeList.get(type, EventObject(nIndex));
if (pInst) return pInst->nSeqID;
return -1;
}
int seqGetStatus(int type, walltype* nIndex)
{
SEQINST* pInst = activeList.get(type, EventObject(nIndex));
if (pInst) return pInst->frameIndex;
return -1;
}
int seqGetID(int type, walltype* nIndex)
{
SEQINST* pInst = activeList.get(type, EventObject(nIndex));
if (pInst) return pInst->nSeqID;
return -1;
}
int seqGetStatus(DBloodActor* actor)
{
SEQINST* pInst = activeList.get(actor);
if (pInst) return pInst->frameIndex;
return -1;
}
int seqGetID(DBloodActor* actor)
{
SEQINST* pInst = activeList.get(actor);
if (pInst) return pInst->nSeqID;
return -1;
}
//---------------------------------------------------------------------------
//
//
@ -686,8 +682,7 @@ void seqProcess(int nTicks)
{
SEQINST* pInst = activeList.getInst(i);
Seq* pSeq = pInst->pSequence;
int index = pInst->seqindex;
auto actor = pInst->actor;
auto target = pInst->target;
assert(pInst->frameIndex < pSeq->nFrames);
@ -705,6 +700,8 @@ void seqProcess(int nTicks)
{
if (pInst->type == SS_SPRITE)
{
assert(target.isActor());
auto actor = target.actor();
if (actor)
{
evKillActor(actor);
@ -716,8 +713,8 @@ void seqProcess(int nTicks)
else if (pInst->type == SS_MASKED)
{
assert(validWallIndex(index));
auto pWall = &wall[index];
assert(target.isWall());
auto pWall = target.wall();
pWall->cstat &= ~(8 + 16 + 32);
if (pWall->twoSided())
pWall->nextWall()->cstat &= ~(8 + 16 + 32);
@ -751,8 +748,7 @@ FSerializer& Serialize(FSerializer& arc, const char* keyname, SEQINST& w, SEQINS
("seqid", w.nSeqID)
("timecounter", w.timeCounter)
("frameindex", w.frameIndex)
("index", w.seqindex)
("actor", w.actor);
("target", w.target);
arc.EndObject();
}

18
source/games/blood/src/seq.h
View file

@ -76,8 +76,8 @@ class DBloodActor;
struct SEQINST
{
Seq* pSequence;
DBloodActor* actor;
int seqindex, type;
EventObject target;
int type;
int nSeqID;
int callback;
@ -93,18 +93,22 @@ inline int seqGetTile(SEQFRAME* pFrame)
int seqRegisterClient(void(*pClient)(int, int));
void seqPrecacheId(int id, int palette);
SEQINST* GetInstance(int a1, int a2);
SEQINST* GetInstance(int a1, EventObject& a2);
SEQINST* GetInstance(DBloodActor* actor);
void UnlockInstance(SEQINST* pInst);
void seqSpawn(int a1, int a2, int a3, int a4 = -1);
void seqSpawn(int a1, int ty, walltype* a2, int a4 = -1);
void seqSpawn(int a1, int ty, sectortype* a2, int a4 = -1);
void seqSpawn(int a1, DBloodActor* actor, int a4 = -1);
void seqKill(int a1, int a2);
void seqKill(int a1, walltype* a2);
void seqKill(int a1, sectortype* a2);
void seqKill(DBloodActor* actor);
void seqKillAll(void);
int seqGetStatus(int a1, int a2);
int seqGetStatus(int a1, walltype* a2);
int seqGetStatus(int a1, sectortype* a2);
int seqGetStatus(DBloodActor*);
int seqGetID(int a1, int a2);
int seqGetID(int a1, walltype* a2);
int seqGetID(int a1, sectortype* a2);
int seqGetID(DBloodActor*);
void seqProcess(int a1);

2
source/games/blood/src/triggers.cpp
View file

@ -1834,7 +1834,7 @@ void trMessageSprite(DBloodActor* actor, EVENT event)
break;
#ifdef NOONE_EXTENSIONS
case kCmdModernUse:
modernTypeTrigger(SS_SPRITE, 0, actor, event);
modernTypeTrigger(OBJ_SPRITE, 0, actor, event);
break;
#endif
default: