mirror of
https://github.com/ZDoom/qzdoom-gpl.git
synced 2024-11-19 02:20:57 +00:00
7e7ab6b4ec
- Added multiple-choice sound sequences. These overcome one of the major
deficiences of the Hexen-inherited SNDSEQ system while still being Hexen
compatible: Custom door sounds can now use different opening and closing
sequences, for both normal and blazing speeds.
- Added a serializer for TArray.
- Added a countof macro to doomtype.h. See the1's blog to find out why
it's implemented the way it is.
<http://blogs.msdn.com/the1/articles/210011.aspx>
- Added a new method to FRandom for getting random numbers larger than 255,
which lets me:
- Fixed: SNDSEQ delayrand commands could delay for no more than 255 tics.
- Fixed: If you're going to have sector_t.SoundTarget, then they need to
be included in the pointer cleanup scans.
- Ported back newer name code from 2.1.
- Fixed: Using -warp with only one parameter in Doom and Heretic to
select a map on episode 1 no longer worked.
- New: Loading a multiplayer save now restores the players based on
their names rather than on their connection order. Using connection
order was sensible when -net was the only way to start a network game,
but with -host/-join, it's not so nice. Also, if there aren't enough
players in the save, then the extra players will be spawned normally,
so you can continue a saved game with more players than you started it
with.
- Added some new SNDSEQ commands to make it possible to define Heretic's
ambient sounds in SNDSEQ: volumerel, volumerand, slot, randomsequence,
delayonce, and restart. With these, it is basically possible to obsolete
all of the $ambient SNDINFO commands.
- Fixed: Sound sequences would only execute one command each time they were
ticked.
- Fixed: No bounds checking was done on the volume sound sequences played at.
- Fixed: The tic parameter to playloop was useless and caused it to
act like a redundant playrepeat. I have removed all the logic that
caused playloop to play repeating sounds, and now it acts like an
infinite sequence of play/delay commands until the sequence is
stopped.
- Fixed: Sound sequences were ticked every frame, not every tic, so all
the delay commands were timed incorrectly and varied depending on your
framerate. Since this is useful for restarting looping sounds that got
cut off, I have not changed this. Instead, the delay commands now
record the tic when execution should resume, not the number of tics
left to delay.
SVN r57 (trunk)
126 lines
4.4 KiB
C++
126 lines
4.4 KiB
C++
#ifndef NAME_H
|
|
#define NAME_H
|
|
|
|
#include "zstring.h"
|
|
#include "tarray.h"
|
|
|
|
enum ENamedName
|
|
{
|
|
#define xx(n) NAME_##n,
|
|
#include "namedef.h"
|
|
#undef xx
|
|
};
|
|
|
|
class name
|
|
{
|
|
public:
|
|
name () : Index(0) {}
|
|
name (const char *text) { Index = FindName (text, false); }
|
|
name (const string &text) { Index = FindName (text.GetChars(), false); }
|
|
name (const char *text, bool noCreate) { Index = FindName (text, noCreate); }
|
|
name (const string &text, bool noCreate) { Index = FindName (text.GetChars(), noCreate); }
|
|
name (const name &other) { Index = other.Index; }
|
|
name (ENamedName index) { Index = index; }
|
|
// ~name () {} // Names can be added but never removed.
|
|
|
|
int GetIndex() const { return Index; }
|
|
operator int() const { return Index; }
|
|
const string &GetText() const { return NameArray[Index].Text; }
|
|
const char *GetChars() const { return NameArray[Index].Text.GetChars(); }
|
|
|
|
name &operator = (const char *text) { Index = FindName (text, false); return *this; }
|
|
name &operator = (const string &text) { Index = FindName (text.GetChars(), false); return *this; }
|
|
name &operator = (const name &other) { Index = other.Index; return *this; }
|
|
name &operator = (ENamedName index) { Index = index; return *this; }
|
|
|
|
int SetName (const char *text, bool noCreate) { return Index = FindName (text, false); }
|
|
int SetName (const string &text, bool noCreate) { return Index = FindName (text.GetChars(), false); }
|
|
|
|
bool IsValidName() const { return (unsigned int)Index < NameArray.Size(); }
|
|
|
|
// Note that the comparison operators compare the names' indices, not
|
|
// their text, so they cannot be used to do a lexicographical sort.
|
|
bool operator == (const name &other) const { return Index == other.Index; }
|
|
bool operator != (const name &other) const { return Index != other.Index; }
|
|
bool operator < (const name &other) const { return Index < other.Index; }
|
|
bool operator <= (const name &other) const { return Index <= other.Index; }
|
|
bool operator > (const name &other) const { return Index > other.Index; }
|
|
bool operator >= (const name &other) const { return Index >= other.Index; }
|
|
|
|
bool operator == (ENamedName index) const { return Index == index; }
|
|
bool operator != (ENamedName index) const { return Index != index; }
|
|
bool operator < (ENamedName index) const { return Index < index; }
|
|
bool operator <= (ENamedName index) const { return Index <= index; }
|
|
bool operator > (ENamedName index) const { return Index > index; }
|
|
bool operator >= (ENamedName index) const { return Index >= index; }
|
|
|
|
private:
|
|
int Index;
|
|
|
|
enum { HASH_SIZE = 256 };
|
|
|
|
struct MainName
|
|
{
|
|
MainName (int next);
|
|
MainName (const MainName &other) : Text(other.Text), NextHash(other.NextHash) {}
|
|
MainName () {}
|
|
string Text;
|
|
int NextHash;
|
|
|
|
void *operator new (size_t size, MainName *addr)
|
|
{
|
|
return addr;
|
|
}
|
|
void operator delete (void *, MainName *)
|
|
{
|
|
}
|
|
};
|
|
static TArray<MainName> NameArray;
|
|
static int Buckets[HASH_SIZE];
|
|
static int FindName (const char *text, bool noCreate);
|
|
static void InitBuckets ();
|
|
static bool Inited;
|
|
|
|
#ifndef __GNUC__
|
|
template<> friend bool NeedsDestructor<MainName> () { return true; }
|
|
|
|
template<> friend void CopyForTArray<MainName> (MainName &dst, MainName &src)
|
|
{
|
|
dst.NextHash = src.NextHash;
|
|
CopyForTArray (dst.Text, src.Text);
|
|
}
|
|
template<> friend void ConstructInTArray<MainName> (MainName *dst, const MainName &src)
|
|
{
|
|
new (dst) name::MainName(src);
|
|
}
|
|
template<> friend void ConstructEmptyInTArray<MainName> (MainName *dst)
|
|
{
|
|
new (dst) name::MainName;
|
|
}
|
|
#else
|
|
template<class MainName> friend inline bool NeedsDestructor ();
|
|
template<class MainName> friend inline void CopyForTArray (MainName &dst, MainName &src);
|
|
template<class MainName> friend inline void ConstructInTArray (MainName *dst, const MainName &src);
|
|
template<class MainName> friend inline void ConstructEmptyInTArray (MainName *dst);
|
|
#endif
|
|
};
|
|
|
|
#ifdef __GNUC__
|
|
template<> inline bool NeedsDestructor<name::MainName> () { return true; }
|
|
|
|
template<> inline void CopyForTArray<name::MainName> (name::MainName &dst, name::MainName &src)
|
|
{
|
|
dst.NextHash = src.NextHash;
|
|
CopyForTArray (dst.Text, src.Text);
|
|
}
|
|
template<> inline void ConstructInTArray<name::MainName> (name::MainName *dst, const name::MainName &src)
|
|
{
|
|
new (dst) name::MainName(src);
|
|
}
|
|
template<> inline void ConstructEmptyInTArray<name::MainName> (name::MainName *dst)
|
|
{
|
|
new (dst) name::MainName;
|
|
}
|
|
#endif
|
|
|
|
#endif
|