mirror of
https://github.com/ZDoom/qzdoom-gpl.git
synced 2024-11-15 16:51:31 +00:00
Merge commit '125afcf3defb901e23bd44d32fa86681ef1748f6' into scripting
Conflicts: src/p_local.h src/p_mobj.cpp src/thingdef/thingdef_codeptr.cpp wadsrc/static/actors/shared/inventory.txt
This commit is contained in:
Christoph Oelckers
commit
5207aa6cc0
51 changed files with 2598 additions and 2133 deletions
|
|
@ -360,6 +360,20 @@ static FColorCVar *cv_overlay[] = {
|
|||
&am_ovsecretsectorcolor
|
||||
};
|
||||
|
||||
CCMD(am_restorecolors)
|
||||
{
|
||||
for (unsigned i = 0; i < countof(cv_standard); i++)
|
||||
{
|
||||
cv_standard[i]->ResetToDefault();
|
||||
}
|
||||
for (unsigned i = 0; i < countof(cv_overlay); i++)
|
||||
{
|
||||
cv_overlay[i]->ResetToDefault();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
#define NOT_USED 1,0,0 // use almost black as indicator for an unused color
|
||||
|
||||
static unsigned char DoomColors[]= {
|
||||
|
|
|
|||
|
|
@ -420,7 +420,7 @@ CCMD (take)
|
|||
|
||||
CCMD (gameversion)
|
||||
{
|
||||
Printf ("%s @ %s\nCommit %s", GetVersionString(), GetGitTime(), GetGitHash());
|
||||
Printf ("%s @ %s\nCommit %s\n", GetVersionString(), GetGitTime(), GetGitHash());
|
||||
}
|
||||
|
||||
CCMD (print)
|
||||
|
|
|
|||
|
|
@ -145,6 +145,7 @@ static FCompatOption Options[] =
|
|||
{ "badangles", COMPATF2_BADANGLES, SLOT_COMPAT2 },
|
||||
{ "floormove", COMPATF2_FLOORMOVE, SLOT_COMPAT2 },
|
||||
{ "soundcutoff", COMPATF2_SOUNDCUTOFF, SLOT_COMPAT2 },
|
||||
{ "pointonline", COMPATF2_POINTONLINE, SLOT_COMPAT2 },
|
||||
|
||||
{ NULL, 0, 0 }
|
||||
};
|
||||
|
|
|
|||
|
|
@ -435,6 +435,11 @@ int FIWadManager::IdentifyVersion (TArray<FString> &wadfiles, const char *iwad,
|
|||
}
|
||||
}
|
||||
}
|
||||
TArray<FString> gog_paths = I_GetGogPaths();
|
||||
for (i = 0; i < gog_paths.Size(); ++i)
|
||||
{
|
||||
CheckIWAD (gog_paths[i], &wads[0]);
|
||||
}
|
||||
TArray<FString> steam_path = I_GetSteamPath();
|
||||
for (i = 0; i < steam_path.Size(); ++i)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -563,7 +563,7 @@ CUSTOM_CVAR(Int, compatmode, 0, CVAR_ARCHIVE|CVAR_NOINITCALL)
|
|||
COMPATF_TRACE|COMPATF_MISSILECLIP|COMPATF_SOUNDTARGET|COMPATF_NO_PASSMOBJ|COMPATF_LIMITPAIN|
|
||||
COMPATF_DEHHEALTH|COMPATF_INVISIBILITY|COMPATF_CROSSDROPOFF|COMPATF_CORPSEGIBS|COMPATF_HITSCAN|
|
||||
COMPATF_WALLRUN|COMPATF_NOTOSSDROPS|COMPATF_LIGHT|COMPATF_MASKEDMIDTEX;
|
||||
w = COMPATF2_BADANGLES|COMPATF2_FLOORMOVE;
|
||||
w = COMPATF2_BADANGLES|COMPATF2_FLOORMOVE|COMPATF2_POINTONLINE;
|
||||
break;
|
||||
|
||||
case 3: // Boom compat mode
|
||||
|
|
@ -582,6 +582,7 @@ CUSTOM_CVAR(Int, compatmode, 0, CVAR_ARCHIVE|CVAR_NOINITCALL)
|
|||
case 6: // Boom with some added settings to reenable some 'broken' behavior
|
||||
v = COMPATF_TRACE|COMPATF_SOUNDTARGET|COMPATF_BOOMSCROLL|COMPATF_MISSILECLIP|COMPATF_NO_PASSMOBJ|
|
||||
COMPATF_INVISIBILITY|COMPATF_CORPSEGIBS|COMPATF_HITSCAN|COMPATF_WALLRUN|COMPATF_NOTOSSDROPS;
|
||||
w = COMPATF2_POINTONLINE;
|
||||
break;
|
||||
|
||||
}
|
||||
|
|
@ -624,6 +625,7 @@ CVAR (Flag, compat_maskedmidtex, compatflags, COMPATF_MASKEDMIDTEX);
|
|||
CVAR (Flag, compat_badangles, compatflags2, COMPATF2_BADANGLES);
|
||||
CVAR (Flag, compat_floormove, compatflags2, COMPATF2_FLOORMOVE);
|
||||
CVAR (Flag, compat_soundcutoff, compatflags2, COMPATF2_SOUNDCUTOFF);
|
||||
CVAR (Flag, compat_pointonline, compatflags2, COMPATF2_POINTONLINE);
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
|
|
|
|||
|
|
@ -2082,6 +2082,33 @@ static int KillAll(PClassActor *cls)
|
|||
}
|
||||
return killcount;
|
||||
|
||||
}
|
||||
|
||||
static int RemoveClass(const PClass *cls)
|
||||
{
|
||||
AActor *actor;
|
||||
int removecount = 0;
|
||||
bool player = false;
|
||||
TThinkerIterator<AActor> iterator(cls);
|
||||
while ((actor = iterator.Next()))
|
||||
{
|
||||
if (actor->IsA(cls))
|
||||
{
|
||||
// [MC]Do not remove LIVE players.
|
||||
if (actor->player != NULL)
|
||||
{
|
||||
player = true;
|
||||
continue;
|
||||
}
|
||||
removecount++;
|
||||
actor->ClearCounters();
|
||||
actor->Destroy();
|
||||
}
|
||||
}
|
||||
if (player)
|
||||
Printf("Cannot remove live players!\n");
|
||||
return removecount;
|
||||
|
||||
}
|
||||
// [RH] Execute a special "ticcmd". The type byte should
|
||||
// have already been read, and the stream is positioned
|
||||
|
|
@ -2555,6 +2582,27 @@ void Net_DoCommand (int type, BYTE **stream, int player)
|
|||
|
||||
}
|
||||
break;
|
||||
case DEM_REMOVE:
|
||||
{
|
||||
char *classname = ReadString(stream);
|
||||
int removecount = 0;
|
||||
PClassActor *cls = PClass::FindActor(classname);
|
||||
if (cls != NULL && cls->IsKindOf(RUNTIME_CLASS(PClassActor)))
|
||||
{
|
||||
removecount = RemoveClass(cls);
|
||||
const PClass *cls_rep = cls->GetReplacement();
|
||||
if (cls != cls_rep)
|
||||
{
|
||||
removecount += RemoveClass(cls_rep);
|
||||
}
|
||||
Printf("Removed %d actors of type %s.\n", removecount, classname);
|
||||
}
|
||||
else
|
||||
{
|
||||
Printf("%s is not an actor class.\n", classname);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case DEM_CONVREPLY:
|
||||
case DEM_CONVCLOSE:
|
||||
|
|
@ -2680,6 +2728,7 @@ void Net_SkipCommand (int type, BYTE **stream)
|
|||
case DEM_SUMMONFRIEND:
|
||||
case DEM_SUMMONFOE:
|
||||
case DEM_SUMMONMBF:
|
||||
case DEM_REMOVE:
|
||||
case DEM_SPRAY:
|
||||
case DEM_MORPHEX:
|
||||
case DEM_KILLCLASSCHEAT:
|
||||
|
|
|
|||
|
|
@ -164,6 +164,7 @@ enum EDemoCommand
|
|||
DEM_RUNNAMEDSCRIPT, // 65 String: Script name, Byte: Arg count + Always flag; each arg is a 4-byte int
|
||||
DEM_REVERTCAMERA, // 66
|
||||
DEM_SETSLOTPNUM, // 67 Byte: player number, the rest is the same as DEM_SETSLOT
|
||||
DEM_REMOVE, // 68
|
||||
};
|
||||
|
||||
// The following are implemented by cht_DoCheat in m_cheat.cpp
|
||||
|
|
|
|||
|
|
@ -340,6 +340,7 @@ enum
|
|||
COMPATF2_BADANGLES = 1 << 0, // It is impossible to face directly NSEW.
|
||||
COMPATF2_FLOORMOVE = 1 << 1, // Use the same floor motion behavior as Doom.
|
||||
COMPATF2_SOUNDCUTOFF = 1 << 2, // Cut off sounds when an actor vanishes instead of making it owner-less
|
||||
COMPATF2_POINTONLINE = 1 << 3, // Use original but buggy P_PointOnLineSide() and P_PointOnDivlineSide()
|
||||
};
|
||||
|
||||
// Emulate old bugs for select maps. These are not exposed by a cvar
|
||||
|
|
|
|||
|
|
@ -135,7 +135,7 @@ CCMD (dumpmapthings)
|
|||
}
|
||||
else
|
||||
{
|
||||
Printf("%6d none", infos[i]->Key);
|
||||
Printf("%6d none\n", infos[i]->Key);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1791,8 +1791,14 @@ void G_ReadSnapshots (PNGHandle *png)
|
|||
DWORD snapver;
|
||||
|
||||
arc << snapver;
|
||||
arc << namelen;
|
||||
arc.Read (mapname, namelen);
|
||||
if (SaveVersion < 4508)
|
||||
{
|
||||
arc << namelen;
|
||||
arc.Read(mapname, namelen);
|
||||
mapname[namelen] = 0;
|
||||
MapName = mapname;
|
||||
}
|
||||
else arc << MapName;
|
||||
TheDefaultLevelInfo.snapshotVer = snapver;
|
||||
TheDefaultLevelInfo.snapshot = new FCompressedMemFile;
|
||||
TheDefaultLevelInfo.snapshot->Serialize (arc);
|
||||
|
|
|
|||
|
|
@ -1333,6 +1333,7 @@ MapFlagHandlers[] =
|
|||
{ "compat_badangles", MITYPE_COMPATFLAG, 0, COMPATF2_BADANGLES },
|
||||
{ "compat_floormove", MITYPE_COMPATFLAG, 0, COMPATF2_FLOORMOVE },
|
||||
{ "compat_soundcutoff", MITYPE_COMPATFLAG, 0, COMPATF2_SOUNDCUTOFF },
|
||||
{ "compat_pointonline", MITYPE_COMPATFLAG, 0, COMPATF2_POINTONLINE },
|
||||
{ "cd_start_track", MITYPE_EATNEXT, 0, 0 },
|
||||
{ "cd_end1_track", MITYPE_EATNEXT, 0, 0 },
|
||||
{ "cd_end2_track", MITYPE_EATNEXT, 0, 0 },
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ bool APowerupGiver::Use (bool pickup)
|
|||
power->Strength = Strength;
|
||||
}
|
||||
|
||||
power->ItemFlags |= ItemFlags & (IF_ALWAYSPICKUP|IF_ADDITIVETIME);
|
||||
power->ItemFlags |= ItemFlags & (IF_ALWAYSPICKUP|IF_ADDITIVETIME|IF_NOTELEPORTFREEZE);
|
||||
if (power->CallTryPickup (Owner))
|
||||
{
|
||||
return true;
|
||||
|
|
@ -342,6 +342,18 @@ void APowerup::OwnerDied ()
|
|||
Destroy ();
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
//
|
||||
// AInventory :: GetNoTeleportFreeze
|
||||
//
|
||||
//===========================================================================
|
||||
|
||||
bool APowerup::GetNoTeleportFreeze ()
|
||||
{
|
||||
if (ItemFlags & IF_NOTELEPORTFREEZE) return true;
|
||||
return Super::GetNoTeleportFreeze();
|
||||
}
|
||||
|
||||
// Invulnerability Powerup ---------------------------------------------------
|
||||
|
||||
IMPLEMENT_CLASS (APowerInvulnerable)
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@ public:
|
|||
virtual AInventory *CreateTossable ();
|
||||
virtual void Serialize (FArchive &arc);
|
||||
virtual void OwnerDied ();
|
||||
virtual bool GetNoTeleportFreeze();
|
||||
virtual PalEntry GetBlend ();
|
||||
virtual bool DrawPowerup (int x, int y);
|
||||
|
||||
|
|
|
|||
|
|
@ -896,6 +896,25 @@ fixed_t AInventory::GetSpeedFactor ()
|
|||
}
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
//
|
||||
// AInventory :: GetNoTeleportFreeze
|
||||
//
|
||||
//===========================================================================
|
||||
|
||||
bool AInventory::GetNoTeleportFreeze ()
|
||||
{
|
||||
// do not check the flag here because it's only active when used on PowerUps, not on PowerupGivers.
|
||||
if (Inventory != NULL)
|
||||
{
|
||||
return Inventory->GetNoTeleportFreeze();
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
//
|
||||
// AInventory :: AlterWeaponSprite
|
||||
|
|
|
|||
|
|
@ -128,6 +128,7 @@ enum
|
|||
IF_TOSSED = 1<<22, // Was spawned by P_DropItem (i.e. as a monster drop)
|
||||
IF_ALWAYSRESPAWN = 1<<23, // Always respawn, regardless of dmflag
|
||||
IF_TRANSFER = 1<<24, // All inventory items that the inventory item contains is also transfered to the pickuper
|
||||
IF_NOTELEPORTFREEZE = 1<<25, // does not 'freeze' the player right after teleporting.
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -205,6 +206,7 @@ public:
|
|||
virtual void AbsorbDamage (int damage, FName damageType, int &newdamage);
|
||||
virtual void ModifyDamage (int damage, FName damageType, int &newdamage, bool passive);
|
||||
virtual fixed_t GetSpeedFactor();
|
||||
virtual bool GetNoTeleportFreeze();
|
||||
virtual int AlterWeaponSprite (visstyle_t *vis);
|
||||
|
||||
virtual PalEntry GetBlend ();
|
||||
|
|
|
|||
|
|
@ -345,8 +345,8 @@ void UpdateJoystickMenu(IJoystickConfig *selected)
|
|||
for(unsigned i=0;i<opt->mItems.Size();i++)
|
||||
{
|
||||
delete opt->mItems[i];
|
||||
opt->mItems.Clear();
|
||||
}
|
||||
opt->mItems.Clear();
|
||||
|
||||
int i;
|
||||
int itemnum = -1;
|
||||
|
|
|
|||
|
|
@ -1145,18 +1145,3 @@ private:
|
|||
float mMaximum;
|
||||
float mStep;
|
||||
};
|
||||
#ifndef NO_IMP
|
||||
CCMD(am_restorecolors)
|
||||
{
|
||||
if (DMenu::CurrentMenu != NULL && DMenu::CurrentMenu->IsKindOf(RUNTIME_CLASS(DOptionMenu)))
|
||||
{
|
||||
DOptionMenu *m = (DOptionMenu*)DMenu::CurrentMenu;
|
||||
const FOptionMenuDescriptor *desc = m->GetDescriptor();
|
||||
// Find the color cvars by scanning the MapColors menu.
|
||||
for (unsigned i = 0; i < desc->mItems.Size(); ++i)
|
||||
{
|
||||
desc->mItems[i]->SetValue(FOptionMenuItemColorPicker::CPF_RESET, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright (C) 2013-2014 Nuke.YKT
|
||||
* Copyright (C) 2013-2015 Nuke.YKT(Alexey Khokholov)
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -27,53 +27,31 @@
|
|||
OPL2 ROMs.
|
||||
*/
|
||||
|
||||
//version 1.5
|
||||
//version 1.6
|
||||
|
||||
/* Changelog:
|
||||
v1.1:
|
||||
Vibrato's sign fix
|
||||
Vibrato's sign fix.
|
||||
v1.2:
|
||||
Operator key fix
|
||||
Corrected 4-operator mode
|
||||
Corrected rhythm mode
|
||||
Some small fixes
|
||||
v1.2.1:
|
||||
Small envelope generator fix
|
||||
Removed EX_Get function(not used)
|
||||
v1.3:
|
||||
Complete rewrite
|
||||
(Not released)
|
||||
v1.4:
|
||||
New envelope and waveform generator
|
||||
Operator key fix.
|
||||
Corrected 4-operator mode.
|
||||
Corrected rhythm mode.
|
||||
Some small fixes.
|
||||
v1.2.1:
|
||||
Small envelope generator fix.
|
||||
v1.3:
|
||||
Complete rewrite.
|
||||
v1.4:
|
||||
New envelope and waveform generator.
|
||||
Some small fixes.
|
||||
(Not released)
|
||||
v1.4.1:
|
||||
Envelope generator rate calculation fix
|
||||
(Not released)
|
||||
Envelope generator rate calculation fix.
|
||||
v1.4.2:
|
||||
Version for ZDoom.
|
||||
v1.5:
|
||||
Optimizations
|
||||
*/
|
||||
|
||||
|
||||
/* Verified:
|
||||
Noise generator.
|
||||
Waveform generator.
|
||||
Envelope generator increase table.
|
||||
Tremolo.
|
||||
*/
|
||||
|
||||
/* TODO:
|
||||
Verify:
|
||||
kslrom[15] value(is it 128?).
|
||||
Sustain level = 15.
|
||||
Vibrato, Phase generator.
|
||||
Rhythm part.
|
||||
Envelope generator state switching(decay->sustain when egt = 1 and decay->release).
|
||||
Feedback.
|
||||
Register write.
|
||||
4-operator.
|
||||
Optimizations.
|
||||
v1.6:
|
||||
Improved emulation output.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
|
|
@ -216,19 +194,17 @@ envelope_sinfunc envelope_sin[8] = {
|
|||
};
|
||||
|
||||
void envelope_gen_off(opl_slot *slott);
|
||||
void envelope_gen_change(opl_slot *slott);
|
||||
void envelope_gen_attack(opl_slot *slott);
|
||||
void envelope_gen_decay(opl_slot *slott);
|
||||
void envelope_gen_sustain(opl_slot *slott);
|
||||
void envelope_gen_release(opl_slot *slott);
|
||||
|
||||
envelope_genfunc envelope_gen[6] = {
|
||||
envelope_genfunc envelope_gen[5] = {
|
||||
envelope_gen_off,
|
||||
envelope_gen_attack,
|
||||
envelope_gen_decay,
|
||||
envelope_gen_sustain,
|
||||
envelope_gen_release,
|
||||
envelope_gen_change
|
||||
envelope_gen_release
|
||||
};
|
||||
|
||||
enum envelope_gen_num {
|
||||
|
|
@ -252,7 +228,7 @@ Bit8u envelope_calc_rate(opl_slot *slot, Bit8u reg_rate) {
|
|||
}
|
||||
|
||||
void envelope_update_ksl(opl_slot *slot) {
|
||||
Bit16s ksl = (kslrom[slot->channel->f_num >> 6] << 1) - ((slot->channel->block ^ 0x07) << 5) - 0x20;
|
||||
Bit16s ksl = (kslrom[slot->channel->f_num >> 6] << 2) - ((0x08 - slot->channel->block) << 5);
|
||||
if (ksl < 0) {
|
||||
ksl = 0;
|
||||
}
|
||||
|
|
@ -281,28 +257,25 @@ void envelope_gen_off(opl_slot *slot) {
|
|||
slot->eg_rout = 0x1ff;
|
||||
}
|
||||
|
||||
void envelope_gen_change(opl_slot *slot) {
|
||||
slot->eg_gen = slot->eg_gennext;
|
||||
envelope_update_rate(slot);
|
||||
}
|
||||
|
||||
void envelope_gen_attack(opl_slot *slot) {
|
||||
if (slot->eg_rout == 0x00) {
|
||||
slot->eg_gen = envelope_gen_num_decay;
|
||||
envelope_update_rate(slot);
|
||||
return;
|
||||
}
|
||||
slot->eg_rout += ((~slot->eg_rout) *slot->eg_inc) >> 3;
|
||||
if (slot->eg_rout < 0x00) {
|
||||
slot->eg_rout = 0x00;
|
||||
}
|
||||
if (!slot->eg_rout) {
|
||||
slot->eg_gen = envelope_gen_num_change;
|
||||
slot->eg_gennext = envelope_gen_num_decay;
|
||||
}
|
||||
}
|
||||
|
||||
void envelope_gen_decay(opl_slot *slot) {
|
||||
slot->eg_rout += slot->eg_inc;
|
||||
if (slot->eg_rout >= slot->reg_sl << 4) {
|
||||
slot->eg_gen = envelope_gen_num_change;
|
||||
slot->eg_gennext = envelope_gen_num_sustain;
|
||||
slot->eg_gen = envelope_gen_num_sustain;
|
||||
envelope_update_rate(slot);
|
||||
return;
|
||||
}
|
||||
slot->eg_rout += slot->eg_inc;
|
||||
}
|
||||
|
||||
void envelope_gen_sustain(opl_slot *slot) {
|
||||
|
|
@ -312,11 +285,13 @@ void envelope_gen_sustain(opl_slot *slot) {
|
|||
}
|
||||
|
||||
void envelope_gen_release(opl_slot *slot) {
|
||||
slot->eg_rout += slot->eg_inc;
|
||||
if (slot->eg_rout >= 0x1ff) {
|
||||
slot->eg_gen = envelope_gen_num_change;
|
||||
slot->eg_gennext = envelope_gen_num_off;
|
||||
slot->eg_gen = envelope_gen_num_off;
|
||||
slot->eg_rout = 0x1ff;
|
||||
envelope_update_rate(slot);
|
||||
return;
|
||||
}
|
||||
slot->eg_rout += slot->eg_inc;
|
||||
}
|
||||
|
||||
void envelope_calc(opl_slot *slot) {
|
||||
|
|
@ -324,10 +299,7 @@ void envelope_calc(opl_slot *slot) {
|
|||
rate_h = slot->eg_rate >> 2;
|
||||
rate_l = slot->eg_rate & 3;
|
||||
Bit8u inc = 0;
|
||||
if (slot->eg_gen == envelope_gen_num_attack && rate_h == 0x0f) {
|
||||
inc = 8;
|
||||
}
|
||||
else if (eg_incsh[rate_h] > 0) {
|
||||
if (eg_incsh[rate_h] > 0) {
|
||||
if ((slot->chip->timer & ((1 << eg_incsh[rate_h]) - 1)) == 0) {
|
||||
inc = eg_incstep[eg_incdesc[rate_h]][rate_l][((slot->chip->timer) >> eg_incsh[rate_h]) & 0x07];
|
||||
}
|
||||
|
|
@ -336,14 +308,19 @@ void envelope_calc(opl_slot *slot) {
|
|||
inc = eg_incstep[eg_incdesc[rate_h]][rate_l][slot->chip->timer & 0x07] << (-eg_incsh[rate_h]);
|
||||
}
|
||||
slot->eg_inc = inc;
|
||||
envelope_gen[slot->eg_gen](slot);
|
||||
slot->eg_out = slot->eg_rout + (slot->reg_tl << 2) + (slot->eg_ksl >> kslshift[slot->reg_ksl]) + *slot->trem;
|
||||
envelope_gen[slot->eg_gen](slot);
|
||||
}
|
||||
|
||||
void eg_keyon(opl_slot *slot, Bit8u type) {
|
||||
if (!slot->key) {
|
||||
slot->eg_gen = envelope_gen_num_change;
|
||||
slot->eg_gennext = envelope_gen_num_attack;
|
||||
slot->eg_gen = envelope_gen_num_attack;
|
||||
envelope_update_rate(slot);
|
||||
if ((slot->eg_rate >> 2) == 0x0f) {
|
||||
slot->eg_gen = envelope_gen_num_decay;
|
||||
envelope_update_rate(slot);
|
||||
slot->eg_rout = 0x00;
|
||||
}
|
||||
slot->pg_phase = 0x00;
|
||||
}
|
||||
slot->key |= type;
|
||||
|
|
@ -353,8 +330,8 @@ void eg_keyoff(opl_slot *slot, Bit8u type) {
|
|||
if (slot->key) {
|
||||
slot->key &= (~type);
|
||||
if (!slot->key) {
|
||||
slot->eg_gen = envelope_gen_num_change;
|
||||
slot->eg_gennext = envelope_gen_num_release;
|
||||
slot->eg_gen = envelope_gen_num_release;
|
||||
envelope_update_rate(slot);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -366,7 +343,7 @@ void eg_keyoff(opl_slot *slot, Bit8u type) {
|
|||
void pg_generate(opl_slot *slot) {
|
||||
Bit16u f_num = slot->channel->f_num;
|
||||
if (slot->reg_vib) {
|
||||
Bit8u f_num_high = f_num >> (7 + vib_table[(slot->chip->timer >> 10)&0x07] + (0x01 - slot->chip->dvb));
|
||||
Bit8u f_num_high = f_num >> (7 + vib_table[(slot->chip->timer >> 10) & 0x07] + (0x01 - slot->chip->dvb));
|
||||
f_num += f_num_high * vibsgn_table[(slot->chip->timer >> 10) & 0x07];
|
||||
}
|
||||
slot->pg_phase += (((f_num << slot->channel->block) >> 1) * mt[slot->reg_mult]) >> 1;
|
||||
|
|
@ -387,7 +364,7 @@ void n_generate(opl_chip *chip) {
|
|||
// Slot
|
||||
//
|
||||
|
||||
void slot_write20(opl_slot *slot,Bit8u data) {
|
||||
void slot_write20(opl_slot *slot, Bit8u data) {
|
||||
if ((data >> 7) & 0x01) {
|
||||
slot->trem = &slot->chip->tremval;
|
||||
}
|
||||
|
|
@ -434,14 +411,14 @@ void slot_generatephase(opl_slot *slot, Bit16u phase) {
|
|||
}
|
||||
|
||||
void slot_generate(opl_slot *slot) {
|
||||
slot->out = envelope_sin[slot->reg_wf]((slot->pg_phase >> 9) + (*slot->mod), slot->eg_out);
|
||||
slot->out = envelope_sin[slot->reg_wf]((Bit16u)(slot->pg_phase >> 9) + (*slot->mod), slot->eg_out);
|
||||
}
|
||||
|
||||
void slot_generatezm(opl_slot *slot) {
|
||||
slot->out = envelope_sin[slot->reg_wf]((slot->pg_phase >> 9), slot->eg_out);
|
||||
slot->out = envelope_sin[slot->reg_wf]((Bit16u)(slot->pg_phase >> 9), slot->eg_out);
|
||||
}
|
||||
|
||||
void slot_calgfb(opl_slot *slot) {
|
||||
void slot_calcfb(opl_slot *slot) {
|
||||
slot->prout[1] = slot->prout[0];
|
||||
slot->prout[0] = slot->out;
|
||||
if (slot->channel->fb != 0x00) {
|
||||
|
|
@ -461,57 +438,61 @@ void chan_setupalg(opl_channel *channel);
|
|||
void chan_updaterhythm(opl_chip *chip, Bit8u data) {
|
||||
chip->rhy = data & 0x3f;
|
||||
if (chip->rhy & 0x20) {
|
||||
chip->channel[6].out[0] = &chip->slot[13].out;
|
||||
chip->channel[6].out[1] = &chip->slot[13].out;
|
||||
chip->channel[6].out[2] = &chip->zeromod;
|
||||
chip->channel[6].out[3] = &chip->zeromod;
|
||||
chip->channel[7].out[0] = &chip->slot[14].out;
|
||||
chip->channel[7].out[1] = &chip->slot[14].out;
|
||||
chip->channel[7].out[2] = &chip->slot[15].out;
|
||||
chip->channel[7].out[3] = &chip->slot[15].out;
|
||||
chip->channel[8].out[0] = &chip->slot[16].out;
|
||||
chip->channel[8].out[1] = &chip->slot[16].out;
|
||||
chip->channel[8].out[2] = &chip->slot[17].out;
|
||||
chip->channel[8].out[3] = &chip->slot[17].out;
|
||||
opl_channel *channel6 = &chip->channel[6];
|
||||
opl_channel *channel7 = &chip->channel[7];
|
||||
opl_channel *channel8 = &chip->channel[8];
|
||||
channel6->out[0] = &channel6->slots[1]->out;
|
||||
channel6->out[1] = &channel6->slots[1]->out;
|
||||
channel6->out[2] = &chip->zeromod;
|
||||
channel6->out[3] = &chip->zeromod;
|
||||
channel7->out[0] = &channel7->slots[0]->out;
|
||||
channel7->out[1] = &channel7->slots[0]->out;
|
||||
channel7->out[2] = &channel7->slots[1]->out;
|
||||
channel7->out[3] = &channel7->slots[1]->out;
|
||||
channel8->out[0] = &channel8->slots[0]->out;
|
||||
channel8->out[1] = &channel8->slots[0]->out;
|
||||
channel8->out[2] = &channel8->slots[1]->out;
|
||||
channel8->out[3] = &channel8->slots[1]->out;
|
||||
for (Bit8u chnum = 6; chnum < 9; chnum++) {
|
||||
chip->channel[chnum].chtype = ch_drum;
|
||||
}
|
||||
chan_setupalg(channel6);
|
||||
//hh
|
||||
if (chip->rhy & 0x01) {
|
||||
eg_keyon(&chip->slot[14], egk_drum);
|
||||
eg_keyon(channel7->slots[0], egk_drum);
|
||||
}
|
||||
else {
|
||||
eg_keyoff(&chip->slot[14], egk_drum);
|
||||
eg_keyoff(channel7->slots[0], egk_drum);
|
||||
}
|
||||
//tc
|
||||
if (chip->rhy & 0x02) {
|
||||
eg_keyon(&chip->slot[17], egk_drum);
|
||||
eg_keyon(channel8->slots[1], egk_drum);
|
||||
}
|
||||
else {
|
||||
eg_keyoff(&chip->slot[17], egk_drum);
|
||||
eg_keyoff(channel8->slots[1], egk_drum);
|
||||
}
|
||||
//tom
|
||||
if (chip->rhy & 0x04) {
|
||||
eg_keyon(&chip->slot[16], egk_drum);
|
||||
eg_keyon(channel8->slots[0], egk_drum);
|
||||
}
|
||||
else {
|
||||
eg_keyoff(&chip->slot[16], egk_drum);
|
||||
eg_keyoff(channel8->slots[0], egk_drum);
|
||||
}
|
||||
//sd
|
||||
if (chip->rhy & 0x08) {
|
||||
eg_keyon(&chip->slot[15], egk_drum);
|
||||
eg_keyon(channel7->slots[1], egk_drum);
|
||||
}
|
||||
else {
|
||||
eg_keyoff(&chip->slot[15], egk_drum);
|
||||
eg_keyoff(channel7->slots[1], egk_drum);
|
||||
}
|
||||
//bd
|
||||
if (chip->rhy & 0x10) {
|
||||
eg_keyon(&chip->slot[12], egk_drum);
|
||||
eg_keyon(&chip->slot[13], egk_drum);
|
||||
eg_keyon(channel6->slots[0], egk_drum);
|
||||
eg_keyon(channel6->slots[1], egk_drum);
|
||||
}
|
||||
else {
|
||||
eg_keyoff(&chip->slot[12], egk_drum);
|
||||
eg_keyoff(&chip->slot[13], egk_drum);
|
||||
eg_keyoff(channel6->slots[0], egk_drum);
|
||||
eg_keyoff(channel6->slots[1], egk_drum);
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
|
@ -566,6 +547,16 @@ void chan_writeb0(opl_channel *channel, Bit8u data) {
|
|||
|
||||
void chan_setupalg(opl_channel *channel) {
|
||||
if (channel->chtype == ch_drum) {
|
||||
switch (channel->alg & 0x01) {
|
||||
case 0x00:
|
||||
channel->slots[0]->mod = &channel->slots[0]->fbmod;
|
||||
channel->slots[1]->mod = &channel->slots[0]->out;
|
||||
break;
|
||||
case 0x01:
|
||||
channel->slots[0]->mod = &channel->slots[0]->fbmod;
|
||||
channel->slots[1]->mod = &channel->chip->zeromod;
|
||||
break;
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (channel->alg & 0x08) {
|
||||
|
|
@ -672,49 +663,39 @@ void chan_writec0(opl_channel *channel, Bit8u data) {
|
|||
}
|
||||
}
|
||||
|
||||
void chan_generaterhythm(opl_chip *chip) {
|
||||
if (chip->rhy & 0x20) {
|
||||
opl_channel *channel6 = &chip->channel[6];
|
||||
opl_channel *channel7 = &chip->channel[7];
|
||||
opl_channel *channel8 = &chip->channel[8];
|
||||
slot_generate(channel6->slots[0]);
|
||||
slot_generate(channel6->slots[1]);
|
||||
Bit16u phase14 = channel7->slots[0]->pg_phase & 0x3ff;
|
||||
Bit16u phase17 = channel8->slots[1]->pg_phase & 0x3ff;
|
||||
Bit16u phase = 0x00;
|
||||
//hh tc phase bit
|
||||
Bit16u phasebit = ((phase14 & 0x08) | (((phase14 >> 5) ^ phase14) & 0x04) | (((phase17 >> 2) ^ phase17) & 0x08)) ? 0x01 : 0x00;
|
||||
//hh
|
||||
phase = (phasebit << 9) | (0x34 << ((phasebit ^ (chip->noise & 0x01) << 1)));
|
||||
slot_generatephase(channel7->slots[0], phase);
|
||||
//sd
|
||||
phase = (0x100 << ((phase14 >> 8) & 0x01)) ^ ((chip->noise & 0x01) << 8);
|
||||
slot_generatephase(channel7->slots[1], phase);
|
||||
//tt
|
||||
slot_generatezm(channel8->slots[0]);
|
||||
//tc
|
||||
phase = 0x100 | (phasebit << 9);
|
||||
slot_generatephase(channel8->slots[1], phase);
|
||||
}
|
||||
void chan_generaterhythm1(opl_chip *chip) {
|
||||
opl_channel *channel6 = &chip->channel[6];
|
||||
opl_channel *channel7 = &chip->channel[7];
|
||||
opl_channel *channel8 = &chip->channel[8];
|
||||
slot_generate(channel6->slots[0]);
|
||||
Bit16u phase14 = (channel7->slots[0]->pg_phase >> 9) & 0x3ff;
|
||||
Bit16u phase17 = (channel8->slots[1]->pg_phase >> 9) & 0x3ff;
|
||||
Bit16u phase = 0x00;
|
||||
//hh tc phase bit
|
||||
Bit16u phasebit = ((phase14 & 0x08) | (((phase14 >> 5) ^ phase14) & 0x04) | (((phase17 >> 2) ^ phase17) & 0x08)) ? 0x01 : 0x00;
|
||||
//hh
|
||||
phase = (phasebit << 9) | (0x34 << ((phasebit ^ (chip->noise & 0x01) << 1)));
|
||||
slot_generatephase(channel7->slots[0], phase);
|
||||
//tt
|
||||
slot_generatezm(channel8->slots[0]);
|
||||
}
|
||||
|
||||
void chan_generate(opl_channel *channel) {
|
||||
if (channel->chtype == ch_drum) {
|
||||
return;
|
||||
}
|
||||
if (channel->alg & 0x08) {
|
||||
return;
|
||||
}
|
||||
if (channel->alg & 0x04) {
|
||||
slot_generate(channel->pair->slots[0]);
|
||||
slot_generate(channel->pair->slots[1]);
|
||||
slot_generate(channel->slots[0]);
|
||||
slot_generate(channel->slots[1]);
|
||||
}
|
||||
else {
|
||||
slot_generate(channel->slots[0]);
|
||||
slot_generate(channel->slots[1]);
|
||||
}
|
||||
void chan_generaterhythm2(opl_chip *chip) {
|
||||
opl_channel *channel6 = &chip->channel[6];
|
||||
opl_channel *channel7 = &chip->channel[7];
|
||||
opl_channel *channel8 = &chip->channel[8];
|
||||
slot_generate(channel6->slots[1]);
|
||||
Bit16u phase14 = (channel7->slots[0]->pg_phase >> 9) & 0x3ff;
|
||||
Bit16u phase17 = (channel8->slots[1]->pg_phase >> 9) & 0x3ff;
|
||||
Bit16u phase = 0x00;
|
||||
//hh tc phase bit
|
||||
Bit16u phasebit = ((phase14 & 0x08) | (((phase14 >> 5) ^ phase14) & 0x04) | (((phase17 >> 2) ^ phase17) & 0x08)) ? 0x01 : 0x00;
|
||||
//sd
|
||||
phase = (0x100 << ((phase14 >> 8) & 0x01)) ^ ((chip->noise & 0x01) << 8);
|
||||
slot_generatephase(channel7->slots[1], phase);
|
||||
//tc
|
||||
phase = 0x100 | (phasebit << 9);
|
||||
slot_generatephase(channel8->slots[1], phase);
|
||||
}
|
||||
|
||||
void chan_enable(opl_channel *channel) {
|
||||
|
|
@ -782,21 +763,132 @@ Bit16s limshort(Bit32s a) {
|
|||
return (Bit16s)a;
|
||||
}
|
||||
|
||||
void chip_generate(opl_chip *chip, Bit16s *buff) {
|
||||
buff[1] = limshort(chip->mixbuff[1]);
|
||||
|
||||
for (Bit8u ii = 0; ii < 12; ii++) {
|
||||
slot_calcfb(&chip->slot[ii]);
|
||||
pg_generate(&chip->slot[ii]);
|
||||
envelope_calc(&chip->slot[ii]);
|
||||
slot_generate(&chip->slot[ii]);
|
||||
}
|
||||
|
||||
for (Bit8u ii = 12; ii < 15; ii++) {
|
||||
slot_calcfb(&chip->slot[ii]);
|
||||
pg_generate(&chip->slot[ii]);
|
||||
envelope_calc(&chip->slot[ii]);
|
||||
}
|
||||
|
||||
if (chip->rhy & 0x20) {
|
||||
chan_generaterhythm1(chip);
|
||||
}
|
||||
else {
|
||||
slot_generate(&chip->slot[12]);
|
||||
slot_generate(&chip->slot[13]);
|
||||
slot_generate(&chip->slot[14]);
|
||||
}
|
||||
|
||||
chip->mixbuff[0] = 0;
|
||||
for (Bit8u ii = 0; ii < 18; ii++) {
|
||||
Bit16s accm = 0;
|
||||
for (Bit8u jj = 0; jj < 4; jj++) {
|
||||
accm += *chip->channel[ii].out[jj];
|
||||
}
|
||||
if (chip->FullPan) {
|
||||
chip->mixbuff[0] += (Bit16s)(accm * chip->channel[ii].fcha);
|
||||
}
|
||||
else {
|
||||
chip->mixbuff[0] += (Bit16s)(accm & chip->channel[ii].cha);
|
||||
}
|
||||
}
|
||||
|
||||
for (Bit8u ii = 15; ii < 18; ii++) {
|
||||
slot_calcfb(&chip->slot[ii]);
|
||||
pg_generate(&chip->slot[ii]);
|
||||
envelope_calc(&chip->slot[ii]);
|
||||
}
|
||||
|
||||
if (chip->rhy & 0x20) {
|
||||
chan_generaterhythm2(chip);
|
||||
}
|
||||
else {
|
||||
slot_generate(&chip->slot[15]);
|
||||
slot_generate(&chip->slot[16]);
|
||||
slot_generate(&chip->slot[17]);
|
||||
}
|
||||
|
||||
buff[0] = limshort(chip->mixbuff[0]);
|
||||
|
||||
for (Bit8u ii = 18; ii < 33; ii++) {
|
||||
slot_calcfb(&chip->slot[ii]);
|
||||
pg_generate(&chip->slot[ii]);
|
||||
envelope_calc(&chip->slot[ii]);
|
||||
slot_generate(&chip->slot[ii]);
|
||||
}
|
||||
|
||||
chip->mixbuff[1] = 0;
|
||||
for (Bit8u ii = 0; ii < 18; ii++) {
|
||||
Bit16s accm = 0;
|
||||
for (Bit8u jj = 0; jj < 4; jj++) {
|
||||
accm += *chip->channel[ii].out[jj];
|
||||
}
|
||||
if (chip->FullPan) {
|
||||
chip->mixbuff[1] += (Bit16s)(accm * chip->channel[ii].fchb);
|
||||
}
|
||||
else {
|
||||
chip->mixbuff[1] += (Bit16s)(accm & chip->channel[ii].chb);
|
||||
}
|
||||
}
|
||||
|
||||
for (Bit8u ii = 33; ii < 36; ii++) {
|
||||
slot_calcfb(&chip->slot[ii]);
|
||||
pg_generate(&chip->slot[ii]);
|
||||
envelope_calc(&chip->slot[ii]);
|
||||
slot_generate(&chip->slot[ii]);
|
||||
}
|
||||
|
||||
n_generate(chip);
|
||||
|
||||
if ((chip->timer & 0x3f) == 0x3f) {
|
||||
if (!chip->tremdir) {
|
||||
if (chip->tremtval == 105) {
|
||||
chip->tremtval--;
|
||||
chip->tremdir = 1;
|
||||
}
|
||||
else {
|
||||
chip->tremtval++;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (chip->tremtval == 0) {
|
||||
chip->tremtval++;
|
||||
chip->tremdir = 0;
|
||||
}
|
||||
else {
|
||||
chip->tremtval--;
|
||||
}
|
||||
}
|
||||
chip->tremval = (chip->tremtval >> 2) >> ((1 - chip->dam) << 1);
|
||||
}
|
||||
|
||||
chip->timer++;
|
||||
}
|
||||
|
||||
void NukedOPL3::Reset() {
|
||||
memset(&opl3, 0, sizeof(opl_chip));
|
||||
for (Bit8u slotnum = 0; slotnum < 36; slotnum++) {
|
||||
opl3.slot[slotnum].channel = &opl3.channel[slotnum / 2];
|
||||
opl3.slot[slotnum].chip = &opl3;
|
||||
opl3.slot[slotnum].mod = &opl3.zeromod;
|
||||
opl3.slot[slotnum].eg_rout = 0x1ff;
|
||||
opl3.slot[slotnum].eg_out = 0x1ff;
|
||||
opl3.slot[slotnum].eg_gen = envelope_gen_num_off;
|
||||
opl3.slot[slotnum].eg_gennext = envelope_gen_num_off;
|
||||
opl3.slot[slotnum].trem = (Bit8u*)&opl3.zeromod;
|
||||
}
|
||||
for (Bit8u channum = 0; channum < 18; channum++) {
|
||||
opl3.channel[channum].slots[0] = &opl3.slot[2 * channum];
|
||||
opl3.channel[channum].slots[1] = &opl3.slot[2 * channum + 1];
|
||||
opl3.channel[channum].slots[0] = &opl3.slot[ch_slot[channum]];
|
||||
opl3.channel[channum].slots[1] = &opl3.slot[ch_slot[channum] + 3];
|
||||
opl3.slot[ch_slot[channum]].channel = &opl3.channel[channum];
|
||||
opl3.slot[ch_slot[channum] + 3].channel = &opl3.channel[channum];
|
||||
if ((channum % 9) < 3) {
|
||||
opl3.channel[channum].pair = &opl3.channel[channum + 3];
|
||||
}
|
||||
|
|
@ -816,6 +908,8 @@ void NukedOPL3::Reset() {
|
|||
chan_setupalg(&opl3.channel[channum]);
|
||||
}
|
||||
opl3.noise = 0x306600;
|
||||
opl3.timer = 0;
|
||||
opl3.FullPan = FullPan;
|
||||
}
|
||||
|
||||
void NukedOPL3::WriteReg(int reg, int v) {
|
||||
|
|
@ -903,58 +997,11 @@ void NukedOPL3::WriteReg(int reg, int v) {
|
|||
}
|
||||
|
||||
void NukedOPL3::Update(float* sndptr, int numsamples) {
|
||||
Bit32s outa, outb;
|
||||
Bit16s buffer[2];
|
||||
for (Bit32u i = 0; i < (Bit32u)numsamples; i++) {
|
||||
outa = 0;
|
||||
outb = 0;
|
||||
for (Bit8u ii = 0; ii < 36; ii++) {
|
||||
slot_calgfb(&opl3.slot[ii]);
|
||||
}
|
||||
chan_generaterhythm(&opl3);
|
||||
for (Bit8u ii = 0; ii < 18; ii++) {
|
||||
chan_generate(&opl3.channel[ii]);
|
||||
Bit16s accm = 0;
|
||||
for (Bit8u jj = 0; jj < 4; jj++) {
|
||||
accm += *opl3.channel[ii].out[jj];
|
||||
}
|
||||
if (FullPan) {
|
||||
outa += (Bit16s)(accm * opl3.channel[ii].fcha);
|
||||
outb += (Bit16s)(accm * opl3.channel[ii].fchb);
|
||||
}
|
||||
else {
|
||||
outa += (Bit16s)(accm & opl3.channel[ii].cha);
|
||||
outb += (Bit16s)(accm & opl3.channel[ii].chb);
|
||||
}
|
||||
}
|
||||
for (Bit8u ii = 0; ii < 36; ii++) {
|
||||
envelope_calc(&opl3.slot[ii]);
|
||||
pg_generate(&opl3.slot[ii]);
|
||||
}
|
||||
n_generate(&opl3);
|
||||
opl3.timer++;
|
||||
if (!(opl3.timer & 0x3f)) {
|
||||
if (!opl3.tremdir) {
|
||||
if (opl3.tremtval == 105) {
|
||||
opl3.tremtval--;
|
||||
opl3.tremdir = 1;
|
||||
}
|
||||
else {
|
||||
opl3.tremtval++;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (opl3.tremtval == 0) {
|
||||
opl3.tremtval++;
|
||||
opl3.tremdir = 0;
|
||||
}
|
||||
else {
|
||||
opl3.tremtval--;
|
||||
}
|
||||
}
|
||||
opl3.tremval = (opl3.tremtval >> 2) >> ((1 - opl3.dam) << 1);
|
||||
}
|
||||
*sndptr++ += (float)(outa / 10240.0);
|
||||
*sndptr++ += (float)(outb / 10240.0);
|
||||
chip_generate(&opl3, buffer);
|
||||
*sndptr++ += (float)(buffer[0] / 10240.0);
|
||||
*sndptr++ += (float)(buffer[1] / 10240.0);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright (C) 2013-2014 Nuke.YKT
|
||||
* Copyright (C) 2013-2015 Nuke.YKT(Alexey Khokholov)
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
|
|
@ -27,7 +27,7 @@
|
|||
OPL2 ROMs.
|
||||
*/
|
||||
|
||||
//version 1.5
|
||||
//version 1.6
|
||||
|
||||
#include "opl.h"
|
||||
#include "muslib.h"
|
||||
|
|
@ -116,7 +116,7 @@ static const Bit8u mt[16] = { 1, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 20, 24, 24,
|
|||
// ksl table
|
||||
//
|
||||
|
||||
static const Bit8u kslrom[16] = { 0, 64, 80, 90, 96, 102, 106, 110, 112, 116, 118, 120, 122, 124, 126, 127 };
|
||||
static const Bit8u kslrom[16] = { 0, 32, 40, 45, 48, 51, 53, 55, 56, 58, 59, 60, 61, 62, 63, 64 };
|
||||
|
||||
static const Bit8u kslshift[4] = { 8, 1, 2, 0 };
|
||||
|
||||
|
|
@ -133,7 +133,7 @@ static const Bit8s vibsgn_table[8] = { 1, 1, 1, 1, -1, -1, -1, -1 };
|
|||
|
||||
static const Bit8u eg_incstep[3][4][8] = {
|
||||
{ { 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0, 0 } },
|
||||
{ { 0, 1, 0, 1, 0, 1, 0, 1 }, { 1, 1, 0, 1, 0, 1, 0, 1 }, { 1, 1, 0, 1, 1, 1, 0, 1 }, { 1, 1, 1, 1, 1, 1, 0, 1 } },
|
||||
{ { 0, 1, 0, 1, 0, 1, 0, 1 }, { 0, 1, 0, 1, 1, 1, 0, 1 }, { 0, 1, 1, 1, 0, 1, 1, 1 }, { 0, 1, 1, 1, 1, 1, 1, 1 } },
|
||||
{ { 1, 1, 1, 1, 1, 1, 1, 1 }, { 2, 2, 1, 1, 1, 1, 1, 1 }, { 2, 2, 1, 1, 2, 2, 1, 1 }, { 2, 2, 2, 2, 2, 2, 1, 1 } }
|
||||
};
|
||||
|
||||
|
|
@ -149,8 +149,8 @@ static const Bit8s eg_incsh[16] = {
|
|||
// address decoding
|
||||
//
|
||||
|
||||
static const Bit8s ad_slot[0x20] = { 0, 2, 4, 1, 3, 5, -1, -1, 6, 8, 10, 7, 9, 11, -1, -1, 12, 14, 16, 13, 15, 17, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
|
||||
|
||||
static const Bit8s ad_slot[0x20] = { 0, 1, 2, 3, 4, 5, -1, -1, 6, 7, 8, 9, 10, 11, -1, -1, 12, 13, 14, 15, 16, 17, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
|
||||
static const Bit8u ch_slot[18] = { 0, 1, 2, 6, 7, 8, 12, 13, 14, 18, 19, 20, 24, 25, 26, 30, 31, 32 };
|
||||
|
||||
struct opl_chip;
|
||||
struct opl_slot;
|
||||
|
|
@ -167,7 +167,6 @@ struct opl_slot {
|
|||
Bit16s eg_out;
|
||||
Bit8u eg_inc;
|
||||
Bit8u eg_gen;
|
||||
Bit8u eg_gennext;
|
||||
Bit8u eg_rate;
|
||||
Bit8u eg_ksl;
|
||||
Bit8u *trem;
|
||||
|
|
@ -217,6 +216,8 @@ struct opl_chip {
|
|||
Bit8u tremdir;
|
||||
Bit32u noise;
|
||||
Bit16s zeromod;
|
||||
Bit32s mixbuff[2];
|
||||
Bit8u FullPan;
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -75,6 +75,7 @@
|
|||
#include "actorptrselect.h"
|
||||
#include "farchive.h"
|
||||
#include "decallib.h"
|
||||
#include "version.h"
|
||||
|
||||
#include "g_shared/a_pickups.h"
|
||||
|
||||
|
|
@ -1417,7 +1418,7 @@ FBehavior *FBehavior::StaticLoadModule (int lumpnum, FileReader *fr, int len)
|
|||
else
|
||||
{
|
||||
delete behavior;
|
||||
Printf(TEXTCOLOR_RED "%s: invalid ACS module", Wads.GetLumpFullName(lumpnum));
|
||||
Printf(TEXTCOLOR_RED "%s: invalid ACS module\n", Wads.GetLumpFullName(lumpnum));
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
|
@ -5854,6 +5855,7 @@ doplaysound: if (funcIndex == ACSF_PlayActorSound)
|
|||
int flags = args[5];
|
||||
const char *statename = argCount > 6 ? FBehavior::StaticLookupString(args[6]) : "";
|
||||
bool exact = argCount > 7 ? !!args[7] : false;
|
||||
fixed_t heightoffset = argCount > 8 ? args[8] : 0;
|
||||
|
||||
FState *state = argCount > 6 ? activator->GetClass()->FindStateByString(statename, exact) : 0;
|
||||
|
||||
|
|
@ -5871,7 +5873,7 @@ doplaysound: if (funcIndex == ACSF_PlayActorSound)
|
|||
if (!reference)
|
||||
return false;
|
||||
|
||||
if (P_Thing_Warp(activator, reference, xofs, yofs, zofs, angle, flags))
|
||||
if (P_Thing_Warp(activator, reference, xofs, yofs, zofs, angle, flags, heightoffset))
|
||||
{
|
||||
if (state && argCount > 6)
|
||||
{
|
||||
|
|
@ -6023,6 +6025,7 @@ int DLevelScript::RunScript ()
|
|||
int sp = 0;
|
||||
int *pc = this->pc;
|
||||
ACSFormat fmt = activeBehavior->GetFormat();
|
||||
FBehavior* const savedActiveBehavior = activeBehavior;
|
||||
unsigned int runaway = 0; // used to prevent infinite loops
|
||||
int pcd;
|
||||
FString work;
|
||||
|
|
@ -6056,6 +6059,7 @@ int DLevelScript::RunScript ()
|
|||
{
|
||||
default:
|
||||
Printf ("Unknown P-Code %d in %s\n", pcd, ScriptPresentation(script).GetChars());
|
||||
activeBehavior = savedActiveBehavior;
|
||||
// fall through
|
||||
case PCD_TERMINATE:
|
||||
DPrintf ("%s finished\n", ScriptPresentation(script).GetChars());
|
||||
|
|
@ -7262,9 +7266,9 @@ int DLevelScript::RunScript ()
|
|||
sp--;
|
||||
break;
|
||||
|
||||
case PCD_DROP:
|
||||
case PCD_SETRESULTVALUE:
|
||||
resultValue = STACK(1);
|
||||
case PCD_DROP: //fall through.
|
||||
sp--;
|
||||
break;
|
||||
|
||||
|
|
@ -8871,7 +8875,22 @@ scriptwait:
|
|||
break;
|
||||
|
||||
case PCD_STRLEN:
|
||||
STACK(1) = SDWORD(strlen(FBehavior::StaticLookupString (STACK(1))));
|
||||
{
|
||||
const char *str = FBehavior::StaticLookupString(STACK(1));
|
||||
if (str != NULL)
|
||||
{
|
||||
STACK(1) = SDWORD(strlen(str));
|
||||
break;
|
||||
}
|
||||
|
||||
static bool StrlenInvalidPrintedAlready = false;
|
||||
if (!StrlenInvalidPrintedAlready)
|
||||
{
|
||||
Printf(PRINT_BOLD, "Warning: ACS function strlen called with invalid string argument.\n");
|
||||
StrlenInvalidPrintedAlready = true;
|
||||
}
|
||||
STACK(1) = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
case PCD_GETCVAR:
|
||||
|
|
@ -9331,6 +9350,10 @@ scriptwait:
|
|||
}
|
||||
break;
|
||||
|
||||
case PCD_CONSOLECOMMAND:
|
||||
Printf (TEXTCOLOR_RED GAMENAME " doesn't support execution of console commands from scripts\n");
|
||||
sp -= 3;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -154,7 +154,7 @@ AActor *P_SpawnMissileZAimed (AActor *source, fixed_t z, AActor *dest, PClassAct
|
|||
AActor *P_SpawnPlayerMissile (AActor* source, PClassActor *type);
|
||||
AActor *P_SpawnPlayerMissile (AActor *source, PClassActor *type, angle_t angle);
|
||||
AActor *P_SpawnPlayerMissile (AActor *source, fixed_t x, fixed_t y, fixed_t z, PClassActor *type, angle_t angle,
|
||||
AActor **pLineTarget = NULL, AActor **MissileActor = NULL, bool nofreeaim = false);
|
||||
AActor **pLineTarget = NULL, AActor **MissileActor = NULL, bool nofreeaim = false, bool noautoaim = false);
|
||||
|
||||
void P_CheckFakeFloorTriggers (AActor *mo, fixed_t oldz, bool oldz_has_viewheight=false);
|
||||
|
||||
|
|
@ -180,7 +180,7 @@ bool P_Thing_Raise(AActor *thing, AActor *raiser);
|
|||
bool P_Thing_CanRaise(AActor *thing);
|
||||
PClassActor *P_GetSpawnableType(int spawnnum);
|
||||
void InitSpawnablesFromMapinfo();
|
||||
int P_Thing_Warp(AActor *caller, AActor *reference, fixed_t xofs, fixed_t yofs, fixed_t zofs, angle_t angle, int flags);
|
||||
int P_Thing_Warp(AActor *caller, AActor *reference, fixed_t xofs, fixed_t yofs, fixed_t zofs, angle_t angle, int flags, fixed_t heightoffset);
|
||||
|
||||
enum WARPF
|
||||
{
|
||||
|
|
@ -244,7 +244,11 @@ fixed_t P_AproxDistance (fixed_t dx, fixed_t dy);
|
|||
|
||||
inline int P_PointOnLineSide (fixed_t x, fixed_t y, const line_t *line)
|
||||
{
|
||||
return DMulScale32 (y-line->v1->y, line->dx, line->v1->x-x, line->dy) > 0;
|
||||
extern int P_VanillaPointOnLineSide(fixed_t x, fixed_t y, const line_t* line);
|
||||
|
||||
return i_compatflags2 & COMPATF2_POINTONLINE
|
||||
? P_VanillaPointOnLineSide(x, y, line)
|
||||
: DMulScale32 (y-line->v1->y, line->dx, line->v1->x-x, line->dy) > 0;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
|
|
@ -258,7 +262,11 @@ inline int P_PointOnLineSide (fixed_t x, fixed_t y, const line_t *line)
|
|||
|
||||
inline int P_PointOnDivlineSide (fixed_t x, fixed_t y, const divline_t *line)
|
||||
{
|
||||
return DMulScale32 (y-line->y, line->dx, line->x-x, line->dy) > 0;
|
||||
extern int P_VanillaPointOnDivlineSide(fixed_t x, fixed_t y, const divline_t* line);
|
||||
|
||||
return (i_compatflags2 & COMPATF2_POINTONLINE)
|
||||
? P_VanillaPointOnDivlineSide(x, y, line)
|
||||
: (DMulScale32 (y-line->y, line->dx, line->x-x, line->dy) > 0);
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
|
|
|
|||
|
|
@ -1013,6 +1013,10 @@ bool PIT_CheckThing(AActor *thing, FCheckPosition &tm)
|
|||
bool solid;
|
||||
int damage;
|
||||
|
||||
// don't clip against self
|
||||
if (thing == tm.thing)
|
||||
return true;
|
||||
|
||||
if (!((thing->flags & (MF_SOLID | MF_SPECIAL | MF_SHOOTABLE)) || thing->flags6 & MF6_TOUCHY))
|
||||
return true; // can't hit thing
|
||||
|
||||
|
|
@ -1020,10 +1024,6 @@ bool PIT_CheckThing(AActor *thing, FCheckPosition &tm)
|
|||
if (abs(thing->x - tm.x) >= blockdist || abs(thing->y - tm.y) >= blockdist)
|
||||
return true;
|
||||
|
||||
// don't clip against self
|
||||
if (thing == tm.thing)
|
||||
return true;
|
||||
|
||||
if ((thing->flags2 | tm.thing->flags2) & MF2_THRUACTORS)
|
||||
return true;
|
||||
|
||||
|
|
|
|||
|
|
@ -1523,3 +1523,92 @@ static AActor *RoughBlockCheck (AActor *mo, int index, void *param)
|
|||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
//
|
||||
// P_VanillaPointOnLineSide
|
||||
// P_PointOnLineSide() from the initial Doom source code release
|
||||
//
|
||||
//===========================================================================
|
||||
|
||||
int P_VanillaPointOnLineSide(fixed_t x, fixed_t y, const line_t* line)
|
||||
{
|
||||
fixed_t dx;
|
||||
fixed_t dy;
|
||||
fixed_t left;
|
||||
fixed_t right;
|
||||
|
||||
if (!line->dx)
|
||||
{
|
||||
if (x <= line->v1->x)
|
||||
return line->dy > 0;
|
||||
|
||||
return line->dy < 0;
|
||||
}
|
||||
if (!line->dy)
|
||||
{
|
||||
if (y <= line->v1->y)
|
||||
return line->dx < 0;
|
||||
|
||||
return line->dx > 0;
|
||||
}
|
||||
|
||||
dx = (x - line->v1->x);
|
||||
dy = (y - line->v1->y);
|
||||
|
||||
left = FixedMul ( line->dy>>FRACBITS , dx );
|
||||
right = FixedMul ( dy , line->dx>>FRACBITS );
|
||||
|
||||
if (right < left)
|
||||
return 0; // front side
|
||||
return 1; // back side
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
//
|
||||
// P_VanillaPointOnDivlineSide
|
||||
// P_PointOnDivlineSide() from the initial Doom source code release
|
||||
//
|
||||
//===========================================================================
|
||||
|
||||
int P_VanillaPointOnDivlineSide(fixed_t x, fixed_t y, const divline_t* line)
|
||||
{
|
||||
fixed_t dx;
|
||||
fixed_t dy;
|
||||
fixed_t left;
|
||||
fixed_t right;
|
||||
|
||||
if (!line->dx)
|
||||
{
|
||||
if (x <= line->x)
|
||||
return line->dy > 0;
|
||||
|
||||
return line->dy < 0;
|
||||
}
|
||||
if (!line->dy)
|
||||
{
|
||||
if (y <= line->y)
|
||||
return line->dx < 0;
|
||||
|
||||
return line->dx > 0;
|
||||
}
|
||||
|
||||
dx = (x - line->x);
|
||||
dy = (y - line->y);
|
||||
|
||||
// try to quickly decide by looking at sign bits
|
||||
if ( (line->dy ^ line->dx ^ dx ^ dy)&0x80000000 )
|
||||
{
|
||||
if ( (line->dy ^ dx) & 0x80000000 )
|
||||
return 1; // (left is negative)
|
||||
return 0;
|
||||
}
|
||||
|
||||
left = FixedMul ( line->dy>>8, dx>>8 );
|
||||
right = FixedMul ( dy>>8 , line->dx>>8 );
|
||||
|
||||
if (right < left)
|
||||
return 0; // front side
|
||||
return 1; // back side
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -6034,7 +6034,7 @@ AActor *P_SpawnPlayerMissile (AActor *source, PClassActor *type, angle_t angle)
|
|||
|
||||
AActor *P_SpawnPlayerMissile (AActor *source, fixed_t x, fixed_t y, fixed_t z,
|
||||
PClassActor *type, angle_t angle, AActor **pLineTarget, AActor **pMissileActor,
|
||||
bool nofreeaim)
|
||||
bool nofreeaim, bool noautoaim)
|
||||
{
|
||||
static const int angdiff[3] = { -1<<26, 1<<26, 0 };
|
||||
angle_t an = angle;
|
||||
|
|
@ -6047,7 +6047,7 @@ AActor *P_SpawnPlayerMissile (AActor *source, fixed_t x, fixed_t y, fixed_t z,
|
|||
{
|
||||
return NULL;
|
||||
}
|
||||
if (source->player && source->player->ReadyWeapon && (source->player->ReadyWeapon->WeaponFlags & WIF_NOAUTOAIM))
|
||||
if (source->player && source->player->ReadyWeapon && ((source->player->ReadyWeapon->WeaponFlags & WIF_NOAUTOAIM) || noautoaim))
|
||||
{
|
||||
// Keep exactly the same angle and pitch as the player's own aim
|
||||
an = angle;
|
||||
|
|
|
|||
|
|
@ -210,7 +210,7 @@ bool P_Teleport (AActor *thing, fixed_t x, fixed_t y, fixed_t z, angle_t angle,
|
|||
if (thing->player && (useFog || !keepOrientation) && bHaltVelocity)
|
||||
{
|
||||
// Freeze player for about .5 sec
|
||||
if (thing->Inventory == NULL || thing->Inventory->GetSpeedFactor() <= FRACUNIT)
|
||||
if (thing->Inventory == NULL || !thing->Inventory->GetNoTeleportFreeze())
|
||||
thing->reactiontime = 18;
|
||||
}
|
||||
if (thing->flags & MF_MISSILE)
|
||||
|
|
|
|||
|
|
@ -680,7 +680,7 @@ void InitSpawnablesFromMapinfo()
|
|||
}
|
||||
|
||||
|
||||
int P_Thing_Warp(AActor *caller, AActor *reference, fixed_t xofs, fixed_t yofs, fixed_t zofs, angle_t angle, int flags)
|
||||
int P_Thing_Warp(AActor *caller, AActor *reference, fixed_t xofs, fixed_t yofs, fixed_t zofs, angle_t angle, int flags, fixed_t heightoffset)
|
||||
{
|
||||
if (flags & WARPF_MOVEPTR)
|
||||
{
|
||||
|
|
@ -693,6 +693,9 @@ int P_Thing_Warp(AActor *caller, AActor *reference, fixed_t xofs, fixed_t yofs,
|
|||
fixed_t oldy = caller->y;
|
||||
fixed_t oldz = caller->z;
|
||||
|
||||
zofs += FixedMul(reference->height, heightoffset);
|
||||
|
||||
|
||||
if (!(flags & WARPF_ABSOLUTEANGLE))
|
||||
{
|
||||
angle += (flags & WARPF_USECALLERANGLE) ? caller->angle : reference->angle;
|
||||
|
|
@ -715,30 +718,13 @@ int P_Thing_Warp(AActor *caller, AActor *reference, fixed_t xofs, fixed_t yofs,
|
|||
if (flags & WARPF_TOFLOOR)
|
||||
{
|
||||
// set correct xy
|
||||
|
||||
// now the caller's floorz should be appropriate for the assigned xy-position
|
||||
// assigning position again with.
|
||||
// extra unlink, link and environment calculation
|
||||
caller->SetOrigin(
|
||||
reference->x + xofs,
|
||||
reference->y + yofs,
|
||||
reference->z);
|
||||
|
||||
// now the caller's floorz should be appropriate for the assigned xy-position
|
||||
// assigning position again with
|
||||
|
||||
if (zofs)
|
||||
{
|
||||
// extra unlink, link and environment calculation
|
||||
caller->SetOrigin(
|
||||
caller->x,
|
||||
caller->y,
|
||||
caller->floorz + zofs);
|
||||
}
|
||||
else
|
||||
{
|
||||
// if there is no offset, there should be no ill effect from moving down to the already defined floor
|
||||
|
||||
// A_Teleport does the same thing anyway
|
||||
caller->z = caller->floorz;
|
||||
}
|
||||
reference->floorz + zofs);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1645,12 +1645,15 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SkullPop)
|
|||
if (player != NULL)
|
||||
{
|
||||
player->mo = mo;
|
||||
if (player->camera == self)
|
||||
{
|
||||
player->camera = mo;
|
||||
}
|
||||
player->damagecount = 32;
|
||||
}
|
||||
for (int i = 0; i < MAXPLAYERS; ++i)
|
||||
{
|
||||
if (playeringame[i] && players[i].camera == self)
|
||||
{
|
||||
players[i].camera = mo;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -758,3 +758,9 @@ unsigned int I_MakeRNGSeed()
|
|||
}
|
||||
return seed;
|
||||
}
|
||||
|
||||
TArray<FString> I_GetGogPaths()
|
||||
{
|
||||
// GOG's Doom games are Windows only at the moment
|
||||
return TArray<FString>();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -124,6 +124,8 @@ int I_PickIWad (WadStuff *wads, int numwads, bool queryiwad, int defaultiwad);
|
|||
// directories for IWADs if the user purchased any through Steam.
|
||||
TArray<FString> I_GetSteamPath();
|
||||
|
||||
TArray<FString> I_GetGogPaths();
|
||||
|
||||
// The ini could not be saved at exit
|
||||
bool I_WriteIniFailed ();
|
||||
|
||||
|
|
|
|||
|
|
@ -771,7 +771,7 @@ bool FMODSoundRenderer::Init()
|
|||
}
|
||||
#endif
|
||||
|
||||
#ifndef _WIN32
|
||||
#if !defined _WIN32 && !defined __APPLE__
|
||||
// Try to load SDL output plugin
|
||||
result = Sys->setPluginPath(progdir); // Should we really look for it in the program directory?
|
||||
result = Sys->loadPlugin("liboutput_sdl.so", &OutputPlugin);
|
||||
|
|
|
|||
|
|
@ -1481,6 +1481,7 @@ enum FP_Flags
|
|||
{
|
||||
FPF_AIMATANGLE = 1,
|
||||
FPF_TRANSFERTRANSLATION = 2,
|
||||
FPF_NOAUTOAIM = 4,
|
||||
};
|
||||
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FireCustomMissile)
|
||||
{
|
||||
|
|
@ -1520,8 +1521,9 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FireCustomMissile)
|
|||
// Temporarily adjusts the pitch
|
||||
fixed_t saved_player_pitch = self->pitch;
|
||||
self->pitch -= pitch;
|
||||
AActor *misl = P_SpawnPlayerMissile (self, x, y, z, ti, shootangle, &linetarget);
|
||||
AActor * misl=P_SpawnPlayerMissile (self, x, y, z, ti, shootangle, &linetarget, NULL, false, (flags & FPF_NOAUTOAIM) != 0);
|
||||
self->pitch = saved_player_pitch;
|
||||
|
||||
// automatic handling of seeker missiles
|
||||
if (misl)
|
||||
{
|
||||
|
|
@ -2096,6 +2098,9 @@ enum SIX_Flags
|
|||
SIXF_ORIGINATOR = 0x00800000,
|
||||
SIXF_TRANSFERSPRITEFRAME = 0x01000000,
|
||||
SIXF_TRANSFERROLL = 0x02000000,
|
||||
SIXF_ISTARGET = 0x04000000,
|
||||
SIXF_ISMASTER = 0x08000000,
|
||||
SIXF_ISTRACER = 0x10000000,
|
||||
};
|
||||
|
||||
static bool InitSpawnedItem(AActor *self, AActor *mo, int flags)
|
||||
|
|
@ -2253,6 +2258,18 @@ static bool InitSpawnedItem(AActor *self, AActor *mo, int flags)
|
|||
mo->roll = self->roll;
|
||||
}
|
||||
|
||||
if (flags & SIXF_ISTARGET)
|
||||
{
|
||||
self->target = mo;
|
||||
}
|
||||
if (flags & SIXF_ISMASTER)
|
||||
{
|
||||
self->master = mo;
|
||||
}
|
||||
if (flags & SIXF_ISTRACER)
|
||||
{
|
||||
self->tracer = mo;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -3297,6 +3314,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Respawn)
|
|||
|
||||
self->flags |= MF_SOLID;
|
||||
self->height = self->GetDefault()->height;
|
||||
self->radius = self->GetDefault()->radius;
|
||||
CALL_ACTION(A_RestoreSpecialPosition, self);
|
||||
|
||||
if (flags & RSF_TELEFRAG)
|
||||
|
|
@ -5021,8 +5039,8 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Warp)
|
|||
PARAM_ANGLE_OPT(angle) { angle = 0; }
|
||||
PARAM_INT_OPT(flags) { flags = 0; }
|
||||
PARAM_STATE_OPT(success_state) { success_state = NULL; }
|
||||
|
||||
|
||||
PARAM_FIXED_OPT(heightoffset) { heightoffset = 0; }
|
||||
|
||||
AActor *reference;
|
||||
|
||||
if ((flags & WARPF_USETID))
|
||||
|
|
@ -5041,7 +5059,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Warp)
|
|||
return numret;
|
||||
}
|
||||
|
||||
if (P_Thing_Warp(self, reference, xofs, yofs, zofs, angle, flags))
|
||||
if (P_Thing_Warp(self, reference, xofs, yofs, zofs, angle, flags, heightoffset))
|
||||
{
|
||||
if (success_state)
|
||||
{
|
||||
|
|
@ -5409,7 +5427,6 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_DropItem)
|
|||
// A_SetSpeed
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetSpeed)
|
||||
{
|
||||
PARAM_ACTION_PROLOGUE;
|
||||
|
|
@ -5425,6 +5442,29 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetSpeed)
|
|||
return 0;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// A_SetFloatSpeed
|
||||
//
|
||||
//==========================================================================
|
||||
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetFloatSpeed)
|
||||
{
|
||||
PARAM_ACTION_PROLOGUE;
|
||||
PARAM_INT(speed);
|
||||
PARAM_INT_OPT(ptr) { ptr = AAPTR_DEFAULT; }
|
||||
|
||||
AActor *ref = COPY_AAPTR(self, ptr);
|
||||
|
||||
if (!ref)
|
||||
{
|
||||
ACTION_SET_RESULT(false);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ref->FloatSpeed = speed;
|
||||
return 0;
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
//
|
||||
// Common A_Damage handler
|
||||
|
|
@ -6110,6 +6150,27 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_JumpIfHigherOrLower)
|
|||
return numret;
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
// A_SetSpecies(str species, ptr)
|
||||
//
|
||||
// Sets the species of the calling actor('s pointer).
|
||||
//===========================================================================
|
||||
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetSpecies)
|
||||
{
|
||||
PARAM_ACTION_PROLOGUE;
|
||||
PARAM_NAME(species);
|
||||
PARAM_INT_OPT(ptr) { ptr = AAPTR_DEFAULT; }
|
||||
|
||||
AActor *mobj = COPY_AAPTR(self, ptr);
|
||||
if (!mobj)
|
||||
{
|
||||
ACTION_SET_RESULT(false);
|
||||
return 0;
|
||||
}
|
||||
|
||||
mobj->Species = species;
|
||||
return 0;
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
//
|
||||
|
|
@ -6152,3 +6213,4 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_SetRipMax)
|
|||
self->RipLevelMax = max;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -330,9 +330,11 @@ static FFlagDef InventoryFlagDefs[] =
|
|||
DEFINE_FLAG(IF, TOSSED, AInventory, ItemFlags),
|
||||
DEFINE_FLAG(IF, ALWAYSRESPAWN, AInventory, ItemFlags),
|
||||
DEFINE_FLAG(IF, TRANSFER, AInventory, ItemFlags),
|
||||
DEFINE_FLAG(IF, NOTELEPORTFREEZE, AInventory, ItemFlags),
|
||||
|
||||
DEFINE_DEPRECATED_FLAG(PICKUPFLASH),
|
||||
DEFINE_DEPRECATED_FLAG(INTERHUBSTRIP),};
|
||||
DEFINE_DEPRECATED_FLAG(INTERHUBSTRIP),
|
||||
};
|
||||
|
||||
static FFlagDef WeaponFlagDefs[] =
|
||||
{
|
||||
|
|
|
|||
|
|
@ -61,11 +61,11 @@ const char *GetVersionString();
|
|||
// Protocol version used in demos.
|
||||
// Bump it if you change existing DEM_ commands or add new ones.
|
||||
// Otherwise, it should be safe to leave it alone.
|
||||
#define DEMOGAMEVERSION 0x21B
|
||||
#define DEMOGAMEVERSION 0x21C
|
||||
|
||||
// Minimum demo version we can play.
|
||||
// Bump it whenever you change or remove existing DEM_ commands.
|
||||
#define MINDEMOVERSION 0x21B
|
||||
#define MINDEMOVERSION 0x21C
|
||||
|
||||
// SAVEVER is the version of the information stored in level snapshots.
|
||||
// Note that SAVEVER is not directly comparable to VERSION.
|
||||
|
|
@ -76,7 +76,7 @@ const char *GetVersionString();
|
|||
|
||||
// Use 4500 as the base git save version, since it's higher than the
|
||||
// SVN revision ever got.
|
||||
#define SAVEVER 4523
|
||||
#define SAVEVER 4524
|
||||
|
||||
#define SAVEVERSTRINGIFY2(x) #x
|
||||
#define SAVEVERSTRINGIFY(x) SAVEVERSTRINGIFY2(x)
|
||||
|
|
|
|||
|
|
@ -1959,9 +1959,9 @@ void WI_drawStats (void)
|
|||
}
|
||||
else
|
||||
{
|
||||
screen->DrawText (BigFont, CR_UNTRANSLATED, 50, 65, "KILLS", DTA_Clean, true, DTA_Shadow, true, TAG_DONE);
|
||||
screen->DrawText (BigFont, CR_UNTRANSLATED, 50, 90, "ITEMS", DTA_Clean, true, DTA_Shadow, true, TAG_DONE);
|
||||
screen->DrawText (BigFont, CR_UNTRANSLATED, 50, 115, "SECRETS", DTA_Clean, true, DTA_Shadow, true, TAG_DONE);
|
||||
screen->DrawText (BigFont, CR_UNTRANSLATED, 50, 65, GStrings("TXT_IMKILLS"), DTA_Clean, true, DTA_Shadow, true, TAG_DONE);
|
||||
screen->DrawText (BigFont, CR_UNTRANSLATED, 50, 90, GStrings("TXT_IMITEMS"), DTA_Clean, true, DTA_Shadow, true, TAG_DONE);
|
||||
screen->DrawText (BigFont, CR_UNTRANSLATED, 50, 115, GStrings("TXT_IMSECRETS"), DTA_Clean, true, DTA_Shadow, true, TAG_DONE);
|
||||
|
||||
int countpos = gameinfo.gametype==GAME_Strife? 285:270;
|
||||
if (sp_state >= 2)
|
||||
|
|
@ -1978,7 +1978,7 @@ void WI_drawStats (void)
|
|||
}
|
||||
if (sp_state >= 8)
|
||||
{
|
||||
screen->DrawText (BigFont, CR_UNTRANSLATED, 85, 160, "TIME",
|
||||
screen->DrawText (BigFont, CR_UNTRANSLATED, 85, 160, GStrings("TXT_IMTIME"),
|
||||
DTA_Clean, true, DTA_Shadow, true, TAG_DONE);
|
||||
WI_drawTime (249, 160, cnt_time);
|
||||
if (wi_showtotaltime)
|
||||
|
|
|
|||
|
|
@ -309,7 +309,7 @@ FDInputJoystick::~FDInputJoystick()
|
|||
{
|
||||
Joy_GenerateButtonEvents(Axes[0].ButtonValue, 0, 2, KEY_JOYAXIS1PLUS);
|
||||
}
|
||||
else
|
||||
else if (Axes.Size() > 1)
|
||||
{
|
||||
Joy_GenerateButtonEvents(Axes[1].ButtonValue, 0, 4, KEY_JOYAXIS1PLUS);
|
||||
for (i = 2; i < Axes.Size(); ++i)
|
||||
|
|
|
|||
|
|
@ -137,6 +137,7 @@ extern bool ConWindowHidden;
|
|||
// PUBLIC DATA DEFINITIONS -------------------------------------------------
|
||||
|
||||
CVAR (String, queryiwad_key, "shift", CVAR_GLOBALCONFIG|CVAR_ARCHIVE);
|
||||
CVAR (Bool, con_debugoutput, false, 0);
|
||||
|
||||
double PerfToSec, PerfToMillisec;
|
||||
UINT TimerPeriod;
|
||||
|
|
@ -1053,6 +1054,31 @@ static TArray<FString> bufferedConsoleStuff;
|
|||
|
||||
void I_PrintStr(const char *cp)
|
||||
{
|
||||
if (con_debugoutput)
|
||||
{
|
||||
// Strip out any color escape sequences before writing to debug output
|
||||
char * copy = new char[strlen(cp)+1];
|
||||
const char * srcp = cp;
|
||||
char * dstp = copy;
|
||||
|
||||
while (*srcp != 0)
|
||||
{
|
||||
if (*srcp!=0x1c && *srcp!=0x1d && *srcp!=0x1e && *srcp!=0x1f)
|
||||
{
|
||||
*dstp++=*srcp++;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (srcp[1]!=0) srcp+=2;
|
||||
else break;
|
||||
}
|
||||
}
|
||||
*dstp=0;
|
||||
|
||||
OutputDebugStringA(copy);
|
||||
delete [] copy;
|
||||
}
|
||||
|
||||
if (ConWindowHidden)
|
||||
{
|
||||
bufferedConsoleStuff.Push(cp);
|
||||
|
|
@ -1504,30 +1530,83 @@ int I_FindClose(void *handle)
|
|||
|
||||
static bool QueryPathKey(HKEY key, const char *keypath, const char *valname, FString &value)
|
||||
{
|
||||
HKEY steamkey;
|
||||
HKEY pathkey;
|
||||
DWORD pathtype;
|
||||
DWORD pathlen;
|
||||
LONG res;
|
||||
|
||||
if(ERROR_SUCCESS == RegOpenKeyEx(key, keypath, 0, KEY_QUERY_VALUE, &steamkey))
|
||||
if(ERROR_SUCCESS == RegOpenKeyEx(key, keypath, 0, KEY_QUERY_VALUE, &pathkey))
|
||||
{
|
||||
if (ERROR_SUCCESS == RegQueryValueEx(steamkey, valname, 0, &pathtype, NULL, &pathlen) &&
|
||||
if (ERROR_SUCCESS == RegQueryValueEx(pathkey, valname, 0, &pathtype, NULL, &pathlen) &&
|
||||
pathtype == REG_SZ && pathlen != 0)
|
||||
{
|
||||
// Don't include terminating null in count
|
||||
char *chars = value.LockNewBuffer(pathlen - 1);
|
||||
res = RegQueryValueEx(steamkey, valname, 0, NULL, (LPBYTE)chars, &pathlen);
|
||||
res = RegQueryValueEx(pathkey, valname, 0, NULL, (LPBYTE)chars, &pathlen);
|
||||
value.UnlockBuffer();
|
||||
if (res != ERROR_SUCCESS)
|
||||
{
|
||||
value = "";
|
||||
}
|
||||
}
|
||||
RegCloseKey(steamkey);
|
||||
RegCloseKey(pathkey);
|
||||
}
|
||||
return value.IsNotEmpty();
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// I_GetGogPaths
|
||||
//
|
||||
// Check the registry for GOG installation paths, so we can search for IWADs
|
||||
// that were bought from GOG.com. This is a bit different from the Steam
|
||||
// version because each game has its own independent installation path, no
|
||||
// such thing as <steamdir>/SteamApps/common/<GameName>.
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
TArray<FString> I_GetGogPaths()
|
||||
{
|
||||
TArray<FString> result;
|
||||
FString path;
|
||||
FString gamepath;
|
||||
|
||||
#ifdef _WIN64
|
||||
FString gogregistrypath = "Software\\Wow6432Node\\GOG.com\\Games";
|
||||
#else
|
||||
// If a 32-bit ZDoom runs on a 64-bit Windows, this will be transparently and
|
||||
// automatically redirected to the Wow6432Node address instead, so this address
|
||||
// should be safe to use in all cases.
|
||||
FString gogregistrypath = "Software\\GOG.com\\Games";
|
||||
#endif
|
||||
|
||||
// Look for Ultimate Doom
|
||||
gamepath = gogregistrypath + "\\1435827232";
|
||||
if (QueryPathKey(HKEY_LOCAL_MACHINE, gamepath.GetChars(), "Path", path))
|
||||
{
|
||||
result.Push(path); // directly in install folder
|
||||
}
|
||||
|
||||
// Look for Doom II
|
||||
gamepath = gogregistrypath + "\\1435848814";
|
||||
if (QueryPathKey(HKEY_LOCAL_MACHINE, gamepath.GetChars(), "Path", path))
|
||||
{
|
||||
result.Push(path + "/doom2"); // in a subdirectory
|
||||
// If direct support for the Master Levels is ever added, they are in path + /master/wads
|
||||
}
|
||||
|
||||
// Look for Final Doom
|
||||
gamepath = gogregistrypath + "\\1435848742";
|
||||
if (QueryPathKey(HKEY_LOCAL_MACHINE, gamepath.GetChars(), "Path", path))
|
||||
{
|
||||
// in subdirectories
|
||||
result.Push(path + "/TNT");
|
||||
result.Push(path + "/Plutonia");
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// I_GetSteamPath
|
||||
|
|
|
|||
|
|
@ -168,6 +168,9 @@ void I_SetWndProc();
|
|||
// directories for IWADs if the user purchased any through Steam.
|
||||
TArray<FString> I_GetSteamPath();
|
||||
|
||||
// [GZ] Same deal for GOG paths
|
||||
TArray<FString> I_GetGogPaths();
|
||||
|
||||
// Damn Microsoft for doing Get/SetWindowLongPtr half-assed. Instead of
|
||||
// giving them proper prototypes under Win32, they are just macros for
|
||||
// Get/SetWindowLong, meaning they take LONGs and not LONG_PTRs.
|
||||
|
|
|
|||
|
|
@ -583,6 +583,7 @@ void FString::SwapCase ()
|
|||
void FString::StripLeft ()
|
||||
{
|
||||
size_t max = Len(), i, j;
|
||||
if (max == 0) return;
|
||||
for (i = 0; i < max; ++i)
|
||||
{
|
||||
if (!isspace(Chars[i]))
|
||||
|
|
@ -613,6 +614,7 @@ void FString::StripLeft (const FString &charset)
|
|||
void FString::StripLeft (const char *charset)
|
||||
{
|
||||
size_t max = Len(), i, j;
|
||||
if (max == 0) return;
|
||||
for (i = 0; i < max; ++i)
|
||||
{
|
||||
if (!strchr (charset, Chars[i]))
|
||||
|
|
@ -665,6 +667,7 @@ void FString::StripRight (const FString &charset)
|
|||
void FString::StripRight (const char *charset)
|
||||
{
|
||||
size_t max = Len(), i;
|
||||
if (max == 0) return;
|
||||
for (i = max; i-- > 0; )
|
||||
{
|
||||
if (!strchr (charset, Chars[i]))
|
||||
|
|
@ -687,6 +690,7 @@ void FString::StripRight (const char *charset)
|
|||
void FString::StripLeftRight ()
|
||||
{
|
||||
size_t max = Len(), i, j, k;
|
||||
if (max == 0) return;
|
||||
for (i = 0; i < max; ++i)
|
||||
{
|
||||
if (!isspace(Chars[i]))
|
||||
|
|
@ -723,6 +727,7 @@ void FString::StripLeftRight (const FString &charset)
|
|||
void FString::StripLeftRight (const char *charset)
|
||||
{
|
||||
size_t max = Len(), i, j, k;
|
||||
if (max == 0) return;
|
||||
for (i = 0; i < max; ++i)
|
||||
{
|
||||
if (!strchr (charset, Chars[i]))
|
||||
|
|
|
|||
|
|
@ -217,7 +217,7 @@ ACTOR Actor native //: Thinker
|
|||
action native A_PlayerSkinCheck(state label);
|
||||
action native A_BasicAttack(int meleedamage, sound meleesound, class<actor> missiletype, float missileheight);
|
||||
action native A_Teleport(state teleportstate = "", class<SpecialSpot> targettype = "BossSpot", class<Actor> fogtype = "TeleportFog", int flags = 0, float mindist = 0, float maxdist = 0, int ptr = AAPTR_DEFAULT);
|
||||
action native A_Warp(int ptr_destination, float xofs = 0, float yofs = 0, float zofs = 0, float angle = 0, int flags = 0, state success_state = "");
|
||||
action native A_Warp(int ptr_destination, float xofs = 0, float yofs = 0, float zofs = 0, float angle = 0, int flags = 0, state success_state = "", float heightoffset = 0);
|
||||
action native A_ThrowGrenade(class<Actor> itemtype, float zheight = 0, float xyvel = 0, float zvel = 0, bool useammo = true);
|
||||
action native A_Weave(int xspeed, int yspeed, float xdist, float ydist);
|
||||
|
||||
|
|
@ -272,6 +272,7 @@ ACTOR Actor native //: Thinker
|
|||
action native A_SetDamageType(name damagetype);
|
||||
action native A_DropItem(class<Actor> item, int dropamount = -1, int chance = 256);
|
||||
action native A_SetSpeed(float speed, int ptr = AAPTR_DEFAULT);
|
||||
action native A_SetFloatSpeed(float speed, int ptr = AAPTR_DEFAULT);
|
||||
action native A_DamageSelf(int amount, name damagetype = "none", int flags = 0, class<Actor> filter = "None", name species = "None");
|
||||
action native A_DamageTarget(int amount, name damagetype = "none", int flags = 0, class<Actor> filter = "None", name species = "None");
|
||||
action native A_DamageMaster(int amount, name damagetype = "none", int flags = 0, class<Actor> filter = "None", name species = "None");
|
||||
|
|
@ -299,6 +300,7 @@ ACTOR Actor native //: Thinker
|
|||
action native A_SetHealth(int health, int ptr = AAPTR_DEFAULT);
|
||||
action native A_ResetHealth(int ptr = AAPTR_DEFAULT);
|
||||
action native A_JumpIfHigherOrLower(state high, state low, float offsethigh = 0, float offsetlow = 0, bool includeHeight = true, int ptr = AAPTR_TARGET);
|
||||
action native A_SetSpecies(name species, int ptr = AAPTR_DEFAULT);
|
||||
action native A_SetRipperLevel(int level);
|
||||
action native A_SetRipMin(int min);
|
||||
action native A_SetRipMax(int max);
|
||||
|
|
|
|||
|
|
@ -74,6 +74,9 @@ const int SXF_NOPOINTERS = 1 << 22;
|
|||
const int SXF_ORIGINATOR = 1 << 23;
|
||||
const int SXF_TRANSFERSPRITEFRAME = 1 << 24;
|
||||
const int SXF_TRANSFERROLL = 1 << 25;
|
||||
const int SXF_ISTARGET = 1 << 26;
|
||||
const int SXF_ISMASTER = 1 << 27;
|
||||
const int SXF_ISTRACER = 1 << 28;
|
||||
|
||||
// Flags for A_Chase
|
||||
const int CHF_FASTCHASE = 1;
|
||||
|
|
@ -185,6 +188,7 @@ const int CPF_STEALARMOR = 32;
|
|||
// Flags for A_CustomMissile
|
||||
const int FPF_AIMATANGLE = 1;
|
||||
const int FPF_TRANSFERTRANSLATION = 2;
|
||||
const int FPF_NOAUTOAIM = 4;
|
||||
|
||||
// Flags for A_Teleport
|
||||
enum
|
||||
|
|
|
|||
|
|
@ -30,9 +30,9 @@ ACTOR Fatso
|
|||
Missile:
|
||||
FATT G 20 A_FatRaise
|
||||
FATT H 10 BRIGHT A_FatAttack1
|
||||
FATT IG 5
|
||||
FATT IG 5 A_FaceTarget
|
||||
FATT H 10 BRIGHT A_FatAttack2
|
||||
FATT IG 5
|
||||
FATT IG 5 A_FaceTarget
|
||||
FATT H 10 BRIGHT A_FatAttack3
|
||||
FATT IG 5
|
||||
Goto See
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ ACTOR CommanderKeen
|
|||
KEEN AB 6
|
||||
KEEN C 6 A_Scream
|
||||
KEEN DEFGH 6
|
||||
KEEN I 6 A_NoBlocking
|
||||
KEEN I 6
|
||||
KEEN J 6
|
||||
KEEN K 6 A_KeenDie
|
||||
KEEN L -1
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
ACTOR SpiderMastermind
|
||||
{
|
||||
Health 3000
|
||||
Radius 100
|
||||
Radius 128
|
||||
Height 100
|
||||
Mass 1000
|
||||
Speed 12
|
||||
|
|
|
|||
|
|
@ -802,6 +802,7 @@ ACTOR BlasterPuff
|
|||
+NOGRAVITY
|
||||
+PUFFONACTORS
|
||||
RenderStyle Add
|
||||
SeeSound "weapons/blasterhit"
|
||||
States
|
||||
{
|
||||
Crash:
|
||||
|
|
|
|||
|
|
@ -121,12 +121,11 @@ ACTOR MummyFX1
|
|||
States
|
||||
{
|
||||
Spawn:
|
||||
FX15 A 1 Bright
|
||||
FX15 A 5 Bright A_PlaySound("mummy/head")
|
||||
FX15 B 5 Bright A_SeekerMissile(10,20)
|
||||
FX15 C 5 Bright
|
||||
FX15 B 5 Bright A_SeekerMissile(10,20)
|
||||
Goto Spawn+1
|
||||
Loop
|
||||
Death:
|
||||
FX15 DEFG 5 Bright
|
||||
Stop
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ ACTOR Inventory native
|
|||
action native A_JumpIfNoAmmo(state label);
|
||||
action native A_CustomPunch(int damage, bool norandom = false, int flags = CPF_USEAMMO, class<Actor> pufftype = "BulletPuff", float range = 0, float lifesteal = 0, int lifestealmax = 0, class<BasicArmorBonus> armorbonustype = "ArmorBonus");
|
||||
action native A_FireBullets(float/*angle*/ spread_xy, float/*angle*/ spread_z, int numbullets, int damageperbullet, class<Actor> pufftype = "BulletPuff", int flags = 1, float range = 0);
|
||||
action native A_FireCustomMissile(class<Actor> missiletype, float angle = 0, bool useammo = true, int spawnofs_xy = 0, float spawnheight = 0, bool aimatangle = false, float pitch = 0);
|
||||
action native A_FireCustomMissile(class<Actor> missiletype, float angle = 0, bool useammo = true, int spawnofs_xy = 0, float spawnheight = 0, int flags = 0, float pitch = 0);
|
||||
action native A_RailAttack(int damage, int spawnofs_xy = 0, bool useammo = true, color color1 = "", color color2 = "", int flags = 0, float maxdiff = 0, class<Actor> pufftype = "BulletPuff", float/*angle*/ spread_xy = 0, float/*angle*/ spread_z = 0, float range = 0, int duration = 0, float sparsity = 1.0, float driftspeed = 1.0, class<Actor> spawnclass = "none", float spawnofs_z = 0, int spiraloffset = 270);
|
||||
action native A_Light(int extralight);
|
||||
action native A_Light0();
|
||||
|
|
@ -225,6 +225,7 @@ ACTOR PowerWeaponLevel2 : Powerup native
|
|||
{
|
||||
Powerup.Duration -40
|
||||
Inventory.Icon "SPINBK0"
|
||||
+INVENTORY.NOTELEPORTFREEZE
|
||||
}
|
||||
|
||||
ACTOR PowerSpeed : Powerup native
|
||||
|
|
@ -232,6 +233,7 @@ ACTOR PowerSpeed : Powerup native
|
|||
Powerup.Duration -45
|
||||
Speed 1.5
|
||||
Inventory.Icon "SPBOOT0"
|
||||
+INVENTORY.NOTELEPORTFREEZE
|
||||
}
|
||||
|
||||
// Player Speed Trail (used by the Speed Powerup) ----------------------------
|
||||
|
|
|
|||
|
|
@ -55,6 +55,8 @@ A80E7EE40E0D0C76A6FBD242BE29FE27 // map15
|
|||
{
|
||||
stairs
|
||||
maskedmidtex
|
||||
corpsegibs
|
||||
vileghosts
|
||||
}
|
||||
|
||||
10E1E2B36302D31AC4AE68C84B5DC457 // Eternal Doom MAP28
|
||||
|
|
@ -125,7 +127,6 @@ BA530202AF0BA0C6CBAE6A0C7076FB72 // Requiem map04
|
|||
CBDFEFAC579A62DE8F1B48CA4A09D381 // gather2.wad map05 and darkside.wad map01
|
||||
C7A2FAFB0AFB2632C50AD625CDB50E51 // Reverie map18
|
||||
9E5724BC6135AA6F86EE54FD4D91F1E2 // Project X map14
|
||||
6DA6FCBA8089161BDEC6A1D3F6C8D60F // Eternal Doom map25
|
||||
01899825FFEAE016D39C02A7DA4B218F // Archie map01
|
||||
1D9F3AFDC2517C2E450491ED13896712 // Seej map01
|
||||
0AE745A3AB86D15FB2FB74489962C421 // 6pack2 map02
|
||||
|
|
@ -320,8 +321,7 @@ F481922F4881F74760F3C0437FD5EDD0 // map03
|
|||
|
||||
7C1913DEE396BA26CFF22A0E9369B7D2 // Nuke Mine, e1m2
|
||||
{
|
||||
clearlinespecial 1107
|
||||
clearlinespecial 1108
|
||||
pointonline
|
||||
}
|
||||
|
||||
5B862477519B21B30059A466F2FF6460 // Khorus, map08
|
||||
|
|
@ -396,3 +396,13 @@ A53AE580A4AF2B5D0B0893F86914781E // TNT: Evilution map31
|
|||
{
|
||||
setthingflags 470 2016
|
||||
}
|
||||
|
||||
D0139194F7817BF06F3988DFC47DB38D // Whispers of Satan map29
|
||||
{
|
||||
nopassover
|
||||
}
|
||||
|
||||
D7F6E9F08C39A17026349A04F8C0B0BE // Return to Hadron, e1m9
|
||||
{
|
||||
pointonline
|
||||
}
|
||||
|
|
|
|||
|
|
@ -534,7 +534,13 @@ SoundMap
|
|||
"skeleton/active",
|
||||
"skeleton/sight",
|
||||
"skeleton/attack",
|
||||
"misc/chat"
|
||||
"misc/chat",
|
||||
"dog/sight",
|
||||
"dog/attack",
|
||||
"dog/active",
|
||||
"dog/death",
|
||||
"dog/pain",
|
||||
|
||||
};
|
||||
|
||||
// Names of different actor types, in original Doom 2 order
|
||||
|
|
|
|||
|
|
@ -1281,6 +1281,14 @@ TXT_LEADBOOTSOFF = "LEAD BOOTS OFF";
|
|||
TXT_LIGHTER = "You feel lighter";
|
||||
TXT_GRAVITY = "Gravity weighs you down";
|
||||
|
||||
// Raven intermission
|
||||
|
||||
TXT_IMKILLS = "KILLS";
|
||||
TXT_IMITEMS = "ITEMS";
|
||||
TXT_IMSECRETS = "SECRETS";
|
||||
TXT_IMTIME = "TIME";
|
||||
|
||||
|
||||
RAVENQUITMSG = "ARE YOU SURE YOU WANT TO QUIT?";
|
||||
|
||||
// Hexen strings
|
||||
|
|
|
|||
|
|
@ -1303,6 +1303,7 @@ OptionMenu "CompatibilityOptions"
|
|||
Option "Find shortest textures like Doom", "compat_SHORTTEX", "YesNo"
|
||||
Option "Use buggier stair building", "compat_stairs", "YesNo"
|
||||
Option "Use Doom's floor motion behavior", "compat_floormove", "YesNo"
|
||||
Option "Use Doom's point-on-line algorithm", "compat_pointonline", "YesNo"
|
||||
|
||||
StaticText " "
|
||||
StaticText "Physics Behavior",1
|
||||
|
|
|
|||
Loading…
Reference in a new issue