mirror of
https://github.com/ZDoom/Raze.git
synced 2024-12-14 22:51:11 +00:00
368 lines
13 KiB
C++
368 lines
13 KiB
C++
//-------------------------------------------------------------------------
|
|
/*
|
|
Copyright (C) 2010-2019 EDuke32 developers and contributors
|
|
Copyright (C) 2019 Nuke.YKT
|
|
|
|
This file is part of NBlood.
|
|
|
|
NBlood 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.
|
|
*/
|
|
//-------------------------------------------------------------------------
|
|
#pragma once
|
|
|
|
BEGIN_BLD_NS
|
|
|
|
|
|
enum
|
|
{
|
|
kMaxXSprites = 16384,
|
|
kMaxXWalls = 512,
|
|
kMaxXSectors = 512
|
|
};
|
|
|
|
enum
|
|
{
|
|
kAttrMove = 0x0001, // is affected by movement physics
|
|
kAttrGravity = 0x0002, // is affected by gravity
|
|
kAttrFalling = 0x0004, // in z motion
|
|
kAttrAiming = 0x0008,
|
|
kAttrRespawn = 0x0010,
|
|
kAttrFree = 0x0020,
|
|
kAttrSmoke = 0x0100, // receives tsprite smoke/steam
|
|
};
|
|
|
|
|
|
// by NoOne: functions to quckly check range of specifical arrays
|
|
inline bool xsectRangeIsFine(int nXindex) {
|
|
return (nXindex >= 0 && nXindex < kMaxXSectors);
|
|
}
|
|
|
|
inline bool xwallRangeIsFine(int nXindex) {
|
|
return (nXindex >= 0 && nXindex < kMaxXWalls);
|
|
}
|
|
#pragma pack(push, 1)
|
|
|
|
struct AISTATE;
|
|
|
|
struct XSPRITE {
|
|
|
|
AISTATE* aiState; // ai
|
|
union
|
|
{
|
|
uint32_t flags;
|
|
struct {
|
|
unsigned int state : 1; // State 0
|
|
unsigned int triggerOn : 1; // going ON
|
|
unsigned int triggerOff : 1; // going OFF
|
|
unsigned int restState : 1; // restState
|
|
unsigned int Interrutable : 1; // Interruptable
|
|
unsigned int Decoupled : 1; // Decoupled
|
|
unsigned int triggerOnce : 1; // 1-shot
|
|
unsigned int isTriggered : 1; // works in case if triggerOnce selected
|
|
unsigned int Push : 1; // Push
|
|
unsigned int Vector : 1; // Vector
|
|
unsigned int Impact : 1; // Impact
|
|
unsigned int Pickup : 1; // Pickup
|
|
unsigned int Touch : 1; // Touch
|
|
unsigned int Sight : 1; // Sight
|
|
unsigned int Proximity : 1; // Proximity
|
|
unsigned int lS : 1; // Single
|
|
unsigned int lB : 1; // Bloodbath
|
|
unsigned int lT : 1; // Launch Team
|
|
unsigned int lC : 1; // Coop
|
|
unsigned int DudeLockout : 1; // DudeLockout
|
|
unsigned int locked : 1; // Locked
|
|
unsigned int dudeDeaf : 1; // dudeDeaf
|
|
unsigned int dudeAmbush : 1; // dudeAmbush
|
|
unsigned int dudeGuard : 1; // dudeGuard
|
|
unsigned int dudeFlag4 : 1; // unused
|
|
unsigned int wave : 2; // Wave
|
|
unsigned int medium : 2; // medium
|
|
unsigned int respawn : 2; // Respawn option
|
|
unsigned int unused2 : 1; // (new) patrol state
|
|
};
|
|
};
|
|
|
|
DBloodActor* target; // target sprite
|
|
|
|
int32_t targetX; // target x
|
|
int32_t targetY; // target y
|
|
int32_t targetZ; // target z
|
|
int32_t sysData1; // used to keep here various system data, so user can't change it in map editor
|
|
int32_t sysData2; //
|
|
int32_t scale; // used for scaling SEQ size on sprites
|
|
uint32_t physAttr; // currently used by additional physics sprites to keep it's attributes.
|
|
uint32_t health;
|
|
uint32_t busy;
|
|
|
|
int16_t data1; // Data 1
|
|
int16_t data2; // Data 2
|
|
int16_t data3; // Data 3
|
|
int16_t burnSource;
|
|
uint16_t txID; // TX ID
|
|
uint16_t rxID; // RX ID
|
|
uint16_t command; // Cmd
|
|
uint16_t busyTime; // busyTime
|
|
uint16_t waitTime; // waitTime
|
|
uint16_t data4; // Data 4
|
|
uint16_t goalAng; // Dude goal ang
|
|
uint16_t burnTime;
|
|
uint16_t height;
|
|
uint16_t stateTimer; // ai timer
|
|
|
|
uint8_t respawnPending; // respawnPending
|
|
uint8_t dropMsg; // Drop Item
|
|
uint8_t key; // Key
|
|
uint8_t lSkill; // Launch 12345
|
|
uint8_t lockMsg; // Lock msg
|
|
int8_t dodgeDir; // Dude dodge direction
|
|
uint8_t unused1; // modern flags
|
|
uint8_t unused3; // something about sight checks
|
|
uint8_t unused4; // patrol turn delay
|
|
|
|
};
|
|
|
|
struct XSECTOR {
|
|
|
|
union
|
|
{
|
|
uint64_t flags;
|
|
struct {
|
|
unsigned int state : 1; // State
|
|
unsigned int triggerOn : 1; // Send at ON
|
|
unsigned int triggerOff : 1; // Send at OFF
|
|
unsigned int restState : 1;
|
|
unsigned int interruptable : 1; // Interruptable
|
|
unsigned int reTriggerA : 1; // OFF->ON wait
|
|
unsigned int reTriggerB : 1; // ON->OFF wait
|
|
unsigned int shadeAlways : 1; // Lighting shadeAlways
|
|
unsigned int shadeFloor : 1; // Lighting floor
|
|
unsigned int shadeCeiling : 1; // Lighting ceiling
|
|
unsigned int shadeWalls : 1; // Lighting walls
|
|
unsigned int panAlways : 1; // Pan always
|
|
unsigned int panFloor : 1; // Pan floor
|
|
unsigned int panCeiling : 1; // Pan ceiling
|
|
unsigned int Drag : 1; // Pan drag
|
|
unsigned int Underwater : 1; // Underwater
|
|
unsigned int decoupled : 1; // Decoupled
|
|
unsigned int triggerOnce : 1; // 1-shot
|
|
unsigned int isTriggered : 1;
|
|
unsigned int Push : 1; // Push
|
|
unsigned int Vector : 1; // Vector
|
|
unsigned int Reserved : 1; // Reserved
|
|
unsigned int Enter : 1; // Enter
|
|
unsigned int Exit : 1; // Exit
|
|
unsigned int Wallpush : 1; // WallPush
|
|
unsigned int color : 1; // Color Lights
|
|
unsigned int stopOn : 1;
|
|
unsigned int stopOff : 1;
|
|
unsigned int Crush : 1; // Crush
|
|
unsigned int locked : 1; // Locked
|
|
unsigned int windAlways : 1; // Wind always
|
|
unsigned int dudeLockout : 1;
|
|
unsigned int bobAlways : 1; // Motion always
|
|
unsigned int bobFloor : 1; // Motion bob floor
|
|
unsigned int bobCeiling : 1; // Motion bob ceiling
|
|
unsigned int bobRotate : 1; // Motion rotate
|
|
unsigned int unused1 : 1; // (new) pause motion
|
|
|
|
};
|
|
};
|
|
|
|
uint32_t busy;
|
|
int32_t offCeilZ;
|
|
int32_t onCeilZ;
|
|
int32_t offFloorZ;
|
|
int32_t onFloorZ;
|
|
uint32_t windVel; // Wind vel (changed from 10 bit to use higher velocity values)
|
|
|
|
uint16_t data; // Data
|
|
uint16_t txID; // TX ID
|
|
uint16_t rxID; // RX ID
|
|
uint16_t busyTimeA; // OFF->ON busyTime
|
|
uint16_t waitTimeA; // OFF->ON waitTime
|
|
uint16_t panAngle; // Motion angle
|
|
uint16_t busyTimeB; // ON->OFF busyTime
|
|
uint16_t waitTimeB; // ON->OFF waitTime
|
|
DBloodActor* marker0;
|
|
DBloodActor* marker1;
|
|
DBloodActor* basePath;
|
|
DBloodActor* actordata;
|
|
uint16_t windAng; // Wind ang
|
|
uint16_t bobTheta; // Motion Theta
|
|
int16_t bobSpeed; // Motion speed
|
|
|
|
uint8_t busyWaveA; // OFF->ON wave
|
|
uint8_t busyWaveB; // ON->OFF wave
|
|
uint8_t command; // Cmd
|
|
int8_t amplitude; // Lighting amplitude
|
|
uint8_t freq; // Lighting freq
|
|
uint8_t phase; // Lighting phase
|
|
uint8_t wave; // Lighting wave
|
|
int8_t shade; // Lighting value
|
|
uint8_t panVel; // Motion speed
|
|
uint8_t Depth; // Depth
|
|
uint8_t Key; // Key
|
|
uint8_t ceilpal; // Ceil pal2
|
|
uint8_t damageType; // DamageType
|
|
uint8_t floorpal; // Floor pal2
|
|
uint8_t bobZRange; // Motion Z range
|
|
};
|
|
|
|
struct XWALL {
|
|
|
|
union
|
|
{
|
|
uint32_t flags;
|
|
struct {
|
|
unsigned int state : 1; // State
|
|
unsigned int triggerOn : 1; // going ON
|
|
unsigned int triggerOff : 1; // going OFF
|
|
unsigned int restState : 1; // restState
|
|
unsigned int interruptable : 1; // Interruptable
|
|
unsigned int panAlways : 1; // panAlways
|
|
unsigned int decoupled : 1; // Decoupled
|
|
unsigned int triggerOnce : 1; // 1-shot
|
|
unsigned int isTriggered : 1;
|
|
unsigned int triggerPush : 1; // Push
|
|
unsigned int triggerVector : 1; // Vector
|
|
unsigned int triggerTouch : 1; // by NoOne: renamed from Reserved to Touch as it works with Touch now.
|
|
unsigned int locked : 1; // Locked
|
|
unsigned int dudeLockout : 1; // DudeLockout
|
|
};
|
|
};
|
|
uint32_t busy;
|
|
|
|
int16_t data; // Data
|
|
uint16_t txID; // TX ID
|
|
uint16_t rxID; // RX ID
|
|
uint16_t busyTime; // busyTime
|
|
uint16_t waitTime; // waitTime
|
|
|
|
uint8_t command; // Cmd
|
|
int8_t panXVel; // panX
|
|
int8_t panYVel; // panY
|
|
uint8_t key; // Key
|
|
};
|
|
|
|
struct MAPSIGNATURE {
|
|
char signature[4];
|
|
int16_t version;
|
|
};
|
|
|
|
struct MAPHEADER {
|
|
int32_t x; // x
|
|
int32_t y; // y
|
|
int32_t z; // z
|
|
int16_t ang; // ang
|
|
int16_t sect; // sect
|
|
int16_t pskybits; // pskybits
|
|
int32_t visibility; // visibility
|
|
int32_t mattid; // song id, Matt
|
|
uint8_t parallax; // parallaxtype
|
|
int32_t revision; // map revision
|
|
int16_t numsectors; // numsectors
|
|
int16_t numwalls; // numwalls
|
|
int16_t numsprites; // numsprites
|
|
};
|
|
|
|
struct MAPHEADER2 {
|
|
char name[64];
|
|
int numxsprites; // xsprite size
|
|
int numxwalls; // xwall size
|
|
int numxsectors; // xsector size
|
|
uint8_t pad[52];
|
|
};
|
|
|
|
#pragma pack(pop)
|
|
|
|
extern unsigned int gStatCount[kMaxStatus + 1];;
|
|
|
|
extern bool drawtile2048, encrypted;
|
|
extern MAPHEADER2 byte_19AE44;
|
|
|
|
extern XSECTOR xsector[kMaxXSectors];
|
|
extern XWALL xwall[kMaxXWalls];
|
|
|
|
extern uint8_t qsector_filler[kMaxSectors];
|
|
|
|
extern int gVisibility;
|
|
extern int gMapRev, gMattId, gSkyCount;
|
|
extern const char *gItemText[];
|
|
extern const char *gAmmoText[];
|
|
extern const char *gWeaponText[];
|
|
|
|
extern int XWallsUsed, XSectorsUsed;
|
|
|
|
static inline int GetWallType(int nWall)
|
|
{
|
|
return wall[nWall].type;
|
|
}
|
|
|
|
template<typename T> void GetSpriteExtents(T const * const pSprite, int *top, int *bottom)
|
|
{
|
|
*top = *bottom = pSprite->z;
|
|
if ((pSprite->cstat & 0x30) != 0x20)
|
|
{
|
|
int height = tileHeight(pSprite->picnum);
|
|
int center = height / 2 + tileTopOffset(pSprite->picnum);
|
|
*top -= (pSprite->yrepeat << 2)*center;
|
|
*bottom += (pSprite->yrepeat << 2)*(height - center);
|
|
}
|
|
}
|
|
|
|
#ifdef POLYMER
|
|
#pragma pack(push, 1)
|
|
struct PolymerLight_t {
|
|
int16_t lightId, lightmaxrange;
|
|
_prlight* lightptr;
|
|
uint8_t lightcount;
|
|
};
|
|
#pragma pack(pop)
|
|
|
|
extern PolymerLight_t gPolymerLight[kMaxSprites];
|
|
|
|
void DeleteLight(int32_t s);
|
|
|
|
#endif
|
|
|
|
void InsertSpriteSect(int nSprite, int nSector);
|
|
void RemoveSpriteSect(int nSprite);
|
|
void InsertSpriteStat(int nSprite, int nStat);
|
|
void RemoveSpriteStat(int nSprite);
|
|
void qinitspritelists(void);
|
|
DBloodActor* InsertSprite(int nSector, int nStat);
|
|
int DeleteSprite(int nSprite);
|
|
int ChangeSpriteSect(int nSprite, int nSector);
|
|
int qchangespritesect(short nSprite, short nSector);
|
|
int ChangeSpriteStat(int nSprite, int nStatus);
|
|
void InitFreeList(unsigned short *pList, int nCount);
|
|
void dbInit(void);
|
|
void PropagateMarkerReferences(void);
|
|
unsigned int dbReadMapCRC(const char *pPath);
|
|
void dbLoadMap(const char* pPath, int* pX, int* pY, int* pZ, short* pAngle, int* pSector, unsigned int* pCRC);
|
|
|
|
END_BLD_NS
|
|
|
|
// refactoring aids.
|
|
inline Blood::XWALL& walltype::xw() const
|
|
{
|
|
return Blood::xwall[extra];
|
|
}
|
|
|
|
inline Blood::XSECTOR& sectortype::xs() const
|
|
{
|
|
return Blood::xsector[extra];
|
|
}
|