mirror of
https://github.com/ZDoom/Raze.git
synced 2025-01-27 10:40:52 +00:00
5448f6ec2c
* DObjects may not be memset to 0. * There was still code trying to retrieve the player index with pointer artithmetic. With an array of pointers this does not work.
1050 lines
32 KiB
C++
1050 lines
32 KiB
C++
//-------------------------------------------------------------------------
|
|
/*
|
|
Copyright (C) 2010-2019 EDuke32 developers and contributors
|
|
Copyright (C) 2019 sirlemonhead, Nuke.YKT
|
|
This file is part of PCExhumed.
|
|
PCExhumed is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License version 2
|
|
as published by the Free Software Foundation.
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
See the GNU General Public License for more details.
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
//-------------------------------------------------------------------------
|
|
#include "ns.h"
|
|
#include "aistuff.h"
|
|
#include "engine.h"
|
|
#include "player.h"
|
|
#include "exhumed.h"
|
|
#include "view.h"
|
|
#include "sound.h"
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include "v_2ddrawer.h"
|
|
#include "sequence.h"
|
|
#include "gamehud.h"
|
|
|
|
BEGIN_PS_NS
|
|
|
|
|
|
Weapon WeaponInfo[] = {
|
|
{ "sword", { 0, 1, 3, 7, -1, 2, 4, 5, 6, 8, 9, 10 }, 0, 0, 0, true },
|
|
{ "pistol", { 0, 3, 2, 4, -1, 1, 0, 0, 0, 0, 0, 0 }, 1, 0, 1, false },
|
|
{ "m_60", { 0, 5, 6, 16, -1, 21, 0, 0, 0, 0, 0, 0 }, 2, 0, 1, false },
|
|
{ "flamer", { 0, 2, 5, 5, 6, 1, 0, 0, 0, 0, 0, 0 }, 3, 4, 1, false },
|
|
{ "grenade", { 0, 2, 3, 4, -1, 1, 0, 0, 0, 0, 0, 0 }, 4, 0, 1, true },
|
|
{ "cobra", { 0, 1, 2, 2, -1, 4, 0, 0, 0, 0, 0, 0 }, 5, 0, 1, true },
|
|
{ "ravolt", { 0, 1, 2, 3, -1, 4, 0, 0, 0, 0, 0, 0 }, 6, 0, 1, true },
|
|
{ "rothands",{ 0, 1, 2, -1, -1, -1, 0, 0, 0, 0, 0, 0 }, 7, 0, 0, true },
|
|
{ "dead", { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 0, 1, 0, false },
|
|
{ "deadex", { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 0, 1, 0, false },
|
|
{ "deadbrn", { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 0, 1, 0, false }
|
|
};
|
|
|
|
static const uint8_t nMinAmmo[] = { 0, 24, 51, 50, 1, 0, 0 };
|
|
static float lastavel;
|
|
int isRed = 0;
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
void SerializeGun(FSerializer& arc)
|
|
{
|
|
if (arc.BeginObject("gun"))
|
|
{
|
|
arc("isred", isRed).EndObject();
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
void RestoreMinAmmo(int nPlayer)
|
|
{
|
|
for (int i = 0; i < kMaxWeapons; i++)
|
|
{
|
|
if (i == kWeaponGrenade) {
|
|
continue;
|
|
}
|
|
|
|
if ((1 << i) & getPlayer(nPlayer)->nPlayerWeapons)
|
|
{
|
|
if (nMinAmmo[i] > getPlayer(nPlayer)->nAmmo[i]) {
|
|
getPlayer(nPlayer)->nAmmo[i] = nMinAmmo[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
CheckClip(nPlayer);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
void FillWeapons(int nPlayer)
|
|
{
|
|
getPlayer(nPlayer)->nPlayerWeapons = 0xFFFF; // turn on all bits
|
|
|
|
for (int i = 0; i < kMaxWeapons; i++)
|
|
{
|
|
if (WeaponInfo[i].d) {
|
|
getPlayer(nPlayer)->nAmmo[i] = 300;
|
|
}
|
|
}
|
|
|
|
CheckClip(nPlayer);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
void ResetPlayerWeapons(int nPlayer)
|
|
{
|
|
for (int i = 0; i < kMaxWeapons; i++)
|
|
{
|
|
getPlayer(nPlayer)->nAmmo[i] = 0;
|
|
}
|
|
|
|
getPlayer(nPlayer)->nCurrentWeapon = 0;
|
|
getPlayer(nPlayer)->nState = 0;
|
|
getPlayer(nPlayer)->nWeapFrame = 0;
|
|
|
|
getPlayer(nPlayer)->pPlayerGrenade = nullptr;
|
|
getPlayer(nPlayer)->nPlayerWeapons = 0x1; // turn on bit 1 only
|
|
}
|
|
|
|
void InitWeapons()
|
|
{
|
|
for (int i = 0; i < kMaxWeapons; i++) getPlayer(i)->pPlayerGrenade = nullptr;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
void SetNewWeapon(int nPlayer, int nWeapon)
|
|
{
|
|
if (nWeapon == kWeaponMummified)
|
|
{
|
|
getPlayer(nPlayer)->nLastWeapon = getPlayer(nPlayer)->nCurrentWeapon;
|
|
getPlayer(nPlayer)->bIsFiring = false;
|
|
getPlayer(nPlayer)->nState = 5;
|
|
SetPlayerMummified(nPlayer, true);
|
|
|
|
getPlayer(nPlayer)->nWeapFrame = 0;
|
|
}
|
|
else
|
|
{
|
|
if (nWeapon < 0)
|
|
{
|
|
getPlayer(nPlayer)->nPlayerOldWeapon = getPlayer(nPlayer)->nCurrentWeapon;
|
|
}
|
|
else if (nWeapon != kWeaponGrenade || getPlayer(nPlayer)->nAmmo[kWeaponGrenade] > 0)
|
|
{
|
|
int nCurrentWeapon = getPlayer(nPlayer)->nCurrentWeapon;
|
|
|
|
if (nCurrentWeapon != kWeaponMummified)
|
|
{
|
|
if (getPlayer(nPlayer)->bIsFiring || nWeapon == nCurrentWeapon) {
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
getPlayer(nPlayer)->nCurrentWeapon = nWeapon;
|
|
getPlayer(nPlayer)->nWeapFrame = 0;
|
|
}
|
|
}
|
|
else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
getPlayer(nPlayer)->nNextWeapon = nWeapon;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
void SetNewWeaponImmediate(int nPlayer, int nWeapon)
|
|
{
|
|
SetNewWeapon(nPlayer, nWeapon);
|
|
|
|
getPlayer(nPlayer)->nCurrentWeapon = nWeapon;
|
|
getPlayer(nPlayer)->nNextWeapon = -1;
|
|
getPlayer(nPlayer)->nWeapFrame = 0;
|
|
getPlayer(nPlayer)->nState = 0;
|
|
}
|
|
|
|
void SetNewWeaponIfBetter(int nPlayer, int nWeapon)
|
|
{
|
|
if (nWeapon > getPlayer(nPlayer)->nCurrentWeapon) {
|
|
SetNewWeapon(nPlayer, nWeapon);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
void SelectNewWeapon(int nPlayer)
|
|
{
|
|
int nWeapon = kWeaponRing; // start at the highest weapon number
|
|
|
|
uint16_t di = getPlayer(nPlayer)->nPlayerWeapons;
|
|
uint16_t dx = 0x40; // bit 7 turned on
|
|
|
|
while (dx)
|
|
{
|
|
if (di & dx)
|
|
{
|
|
// we have this weapon
|
|
if (!WeaponInfo[nWeapon].d || getPlayer(nPlayer)->nAmmo[WeaponInfo[nWeapon].nAmmoType])
|
|
break;
|
|
}
|
|
|
|
nWeapon--;
|
|
dx >>= 1;
|
|
}
|
|
|
|
if (nWeapon < 0)
|
|
nWeapon = kWeaponSword;
|
|
|
|
getPlayer(nPlayer)->bIsFiring = false;
|
|
|
|
SetNewWeapon(nPlayer, nWeapon);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
void SetWeaponStatus(int nPlayer)
|
|
{
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
uint8_t WeaponCanFire(int nPlayer)
|
|
{
|
|
int nWeapon = getPlayer(nPlayer)->nCurrentWeapon;
|
|
auto pSector =getPlayer(nPlayer)->pPlayerViewSect;
|
|
|
|
if (!(pSector->Flag & kSectUnderwater) || WeaponInfo[nWeapon].bFireUnderwater)
|
|
{
|
|
int nAmmoType = WeaponInfo[nWeapon].nAmmoType;
|
|
|
|
if (WeaponInfo[nWeapon].d <= getPlayer(nPlayer)->nAmmo[nAmmoType]) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// UNUSED
|
|
void ResetSwordSeqs()
|
|
{
|
|
WeaponInfo[kWeaponSword].b[2] = 3;
|
|
WeaponInfo[kWeaponSword].b[3] = 7;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
Collision CheckCloseRange(int nPlayer, DVector3& pos, sectortype* *ppSector)
|
|
{
|
|
auto pActor = getPlayer(nPlayer)->GetActor();
|
|
|
|
HitInfo hit{};
|
|
hitscan(pos, *ppSector, DVector3(pActor->spr.Angles.Yaw.ToVector() * 1024, 0 ), hit, CLIPMASK1);
|
|
|
|
const double ecx = 56.84; // bsin(150, -3)
|
|
double sqrtNum = (hit.hitpos.XY() - pos.XY()).LengthSquared();
|
|
|
|
Collision c;
|
|
c.setNone();
|
|
|
|
if (sqrtNum >= ecx * ecx)
|
|
return c;
|
|
|
|
pos = hit.hitpos;
|
|
*ppSector = hit.hitSector;
|
|
|
|
if (hit.actor()) {
|
|
c.setSprite(hit.actor());
|
|
}
|
|
if (hit.hitWall) {
|
|
c.setWall(wallindex(hit.hitWall));
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
void CheckClip(int nPlayer)
|
|
{
|
|
const auto pPlayer = getPlayer(nPlayer);
|
|
|
|
if (pPlayer->nPlayerClip <= 0)
|
|
pPlayer->nPlayerClip = min(pPlayer->nAmmo[kWeaponM60], (int16_t)100);
|
|
|
|
if (pPlayer->nPistolClip <= 0)
|
|
pPlayer->nPistolClip = min(pPlayer->nAmmo[kWeaponPistol], (int16_t)6);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
void MoveWeapons(int nPlayer)
|
|
{
|
|
const auto pPlayer = getPlayer(nPlayer);
|
|
|
|
static int dword_96E22 = 0;
|
|
|
|
int nSectFlag = pPlayer->pPlayerViewSect->Flag;
|
|
|
|
if ((nSectFlag & kSectUnderwater) && (totalmoves & 1)) {
|
|
return;
|
|
}
|
|
|
|
nPilotLightFrame++;
|
|
|
|
if (nPilotLightFrame >= nPilotLightCount)
|
|
nPilotLightFrame = 0;
|
|
|
|
if (!pPlayer->bIsFiring || (nSectFlag & kSectUnderwater))
|
|
pPlayer->nTemperature = 0;
|
|
|
|
auto pPlayerActor = pPlayer->GetActor();
|
|
int nWeapon = pPlayer->nCurrentWeapon;
|
|
|
|
if (nWeapon < -1)
|
|
{
|
|
if (pPlayer->nNextWeapon != -1)
|
|
{
|
|
pPlayer->nCurrentWeapon = pPlayer->nNextWeapon;
|
|
pPlayer->nState = 0;
|
|
pPlayer->nWeapFrame = 0;
|
|
pPlayer->nNextWeapon = -1;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
const auto nSeqFile = WeaponInfo[nWeapon].nSeqFile;
|
|
auto weapSeq = getSequence(nSeqFile, WeaponInfo[nWeapon].b[pPlayer->nState]);
|
|
auto seqFrame = weapSeq->frames.Data(pPlayer->nWeapFrame);
|
|
|
|
int var_1C = (pPlayer->nDouble > 0) + 1;
|
|
int frames = var_1C - 1;
|
|
|
|
for (frames = var_1C; frames > 0; frames--)
|
|
{
|
|
seqFrame->playSound(pPlayerActor);
|
|
|
|
pPlayer->nWeapFrame++;
|
|
|
|
dword_96E22++;
|
|
if (dword_96E22 >= 15) {
|
|
dword_96E22 = 0;
|
|
}
|
|
|
|
if (pPlayer->nWeapFrame >= weapSeq->frames.Size())
|
|
{
|
|
if (pPlayer->nNextWeapon == -1)
|
|
{
|
|
switch (pPlayer->nState)
|
|
{
|
|
default:
|
|
break;
|
|
|
|
case 0:
|
|
{
|
|
pPlayer->nState = 1;
|
|
SetWeaponStatus(nPlayer);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
if (pPlayer->bIsFiring)
|
|
{
|
|
if (!WeaponCanFire(nPlayer))
|
|
{
|
|
if (!dword_96E22) {
|
|
D3PlayFX(StaticSound[4], pPlayer->GetActor());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (nWeapon == kWeaponRing)
|
|
{
|
|
if (Ra[nPlayer].pTarget == nullptr)
|
|
break;
|
|
|
|
Ra[nPlayer].nAction = 0;
|
|
Ra[nPlayer].nFrame = 0;
|
|
Ra[nPlayer].nState = 1;
|
|
}
|
|
|
|
pPlayer->nState = 2;
|
|
|
|
if (nWeapon == 0)
|
|
break;
|
|
|
|
if (nWeapon == kWeaponGrenade)
|
|
{
|
|
BuildGrenade(nPlayer);
|
|
AddAmmo(nPlayer, 4, -1);
|
|
}
|
|
else if (nWeapon == kWeaponMummified)
|
|
{
|
|
ShootStaff(nPlayer);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
{
|
|
if (nWeapon == kWeaponPistol && pPlayer->nPistolClip <= 0)
|
|
{
|
|
pPlayer->nState = 3;
|
|
pPlayer->nWeapFrame = 0;
|
|
|
|
pPlayer->nPistolClip = min<int>(6, pPlayer->nAmmo[kWeaponPistol]);
|
|
break;
|
|
}
|
|
else if (nWeapon == kWeaponGrenade)
|
|
{
|
|
if (!pPlayer->bIsFiring)
|
|
{
|
|
pPlayer->nState = 3;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
pPlayer->nWeapFrame = weapSeq->frames.Size() - 1;
|
|
continue;
|
|
}
|
|
}
|
|
else if (nWeapon == kWeaponMummified)
|
|
{
|
|
pPlayer->nState = 0;
|
|
pPlayer->nCurrentWeapon = pPlayer->nLastWeapon;
|
|
|
|
nWeapon = pPlayer->nCurrentWeapon;
|
|
|
|
SetPlayerMummified(nPlayer, false);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// loc_26D88:
|
|
if (pPlayer->bIsFiring && WeaponCanFire(nPlayer))
|
|
{
|
|
if (nWeapon != kWeaponM60 && nWeapon != kWeaponPistol) {
|
|
pPlayer->nState = 3;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (WeaponInfo[nWeapon].b[4] == -1)
|
|
{
|
|
pPlayer->nState = 1;
|
|
}
|
|
else
|
|
{
|
|
if (nWeapon == kWeaponFlamer && (nSectFlag & kSectUnderwater))
|
|
{
|
|
pPlayer->nState = 1;
|
|
}
|
|
else
|
|
{
|
|
pPlayer->nState = 4;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
case 3:
|
|
case 9:
|
|
case 10:
|
|
case 11:
|
|
{
|
|
if (nWeapon == kWeaponMummified)
|
|
{
|
|
pPlayer->nCurrentWeapon = pPlayer->nLastWeapon;
|
|
|
|
nWeapon = pPlayer->nCurrentWeapon;
|
|
|
|
pPlayer->nState = 0;
|
|
break;
|
|
}
|
|
else if (nWeapon == kWeaponRing)
|
|
{
|
|
if (!WeaponInfo[nWeapon].d || pPlayer->nAmmo[WeaponInfo[nWeapon].nAmmoType])
|
|
{
|
|
if (!pPlayer->bIsFiring) {
|
|
pPlayer->nState = 1;
|
|
}
|
|
else {
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SelectNewWeapon(nPlayer);
|
|
}
|
|
|
|
Ra[nPlayer].nState = 0;
|
|
break;
|
|
}
|
|
else if (nWeapon == kWeaponM60)
|
|
{
|
|
CheckClip(nPlayer);
|
|
pPlayer->nState = 1;
|
|
break;
|
|
}
|
|
else if (nWeapon == kWeaponGrenade)
|
|
{
|
|
if (!WeaponInfo[nWeapon].d || pPlayer->nAmmo[WeaponInfo[nWeapon].nAmmoType])
|
|
{
|
|
pPlayer->nState = 0;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
SelectNewWeapon(nPlayer);
|
|
pPlayer->nState = 5;
|
|
|
|
pPlayer->nWeapFrame = getSequence(nSeqFile, WeaponInfo[kWeaponGrenade].b[0])->frames.Size() - 1; // CHECKME
|
|
goto loc_flag; // FIXME
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pPlayer->bIsFiring && WeaponCanFire(nPlayer)) {
|
|
pPlayer->nState = 2;
|
|
break;
|
|
}
|
|
|
|
if (WeaponInfo[nWeapon].b[4] == -1)
|
|
{
|
|
pPlayer->nState = 1;
|
|
break;
|
|
}
|
|
|
|
if (nWeapon == kWeaponFlamer && (nSectFlag & kSectUnderwater))
|
|
{
|
|
pPlayer->nState = 1;
|
|
}
|
|
else
|
|
{
|
|
pPlayer->nState = 4;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 4:
|
|
{
|
|
pPlayer->nState = 1;
|
|
break;
|
|
}
|
|
|
|
case 5:
|
|
{
|
|
pPlayer->nCurrentWeapon = pPlayer->nNextWeapon;
|
|
|
|
nWeapon = pPlayer->nCurrentWeapon;
|
|
|
|
pPlayer->nState = 0;
|
|
pPlayer->nNextWeapon = -1;
|
|
|
|
SetWeaponStatus(nPlayer);
|
|
break;
|
|
}
|
|
}
|
|
|
|
weapSeq = getSequence(WeaponInfo[nWeapon].nSeqFile, WeaponInfo[nWeapon].b[pPlayer->nState]);
|
|
pPlayer->nWeapFrame = 0;
|
|
}
|
|
else
|
|
{
|
|
if (pPlayer->nState == 5)
|
|
{
|
|
pPlayer->nCurrentWeapon = pPlayer->nNextWeapon;
|
|
|
|
nWeapon = pPlayer->nCurrentWeapon;
|
|
|
|
pPlayer->nNextWeapon = -1;
|
|
pPlayer->nState = 0;
|
|
}
|
|
else
|
|
{
|
|
pPlayer->nState = 5;
|
|
}
|
|
|
|
pPlayer->nWeapFrame = 0;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
loc_flag:
|
|
seqFrame = weapSeq->frames.Data(pPlayer->nWeapFrame);
|
|
|
|
if (((!(nSectFlag & kSectUnderwater)) || nWeapon == kWeaponRing) && (seqFrame->flags & 4))
|
|
{
|
|
BuildFlash(nPlayer, 512);
|
|
AddFlash(
|
|
pPlayerActor->sector(),
|
|
pPlayerActor->spr.pos,
|
|
0);
|
|
}
|
|
|
|
if (seqFrame->flags & 0x80)
|
|
{
|
|
int nAction = pPlayerActor->nAction;
|
|
|
|
int var_38 = 1;
|
|
|
|
if (nAction < 10 || nAction > 12) {
|
|
var_38 = 0;
|
|
}
|
|
|
|
if (nPlayer == nLocalPlayer) {
|
|
pPlayer->nPrevWeapBob = pPlayer->nWeapBob = 512;
|
|
}
|
|
|
|
if (nWeapon == kWeaponFlamer && (!(nSectFlag & kSectUnderwater)))
|
|
{
|
|
pPlayer->nTemperature++;
|
|
|
|
if (pPlayer->nTemperature > 50)
|
|
{
|
|
pPlayer->nTemperature = 0;
|
|
pPlayer->nState = 4;
|
|
pPlayer->nWeapFrame = 0;
|
|
}
|
|
}
|
|
|
|
int nAmmoType = WeaponInfo[nWeapon].nAmmoType;
|
|
DAngle nAngle = pPlayerActor->spr.Angles.Yaw;
|
|
auto thePos = pPlayerActor->spr.pos;
|
|
|
|
double nHeight = GetActorHeight(pPlayerActor) * -0.5;
|
|
|
|
if (nAction < 6)
|
|
{
|
|
nHeight -= 7;
|
|
}
|
|
else
|
|
{
|
|
if (!var_38)
|
|
{
|
|
nHeight += 4;
|
|
}
|
|
else {
|
|
nHeight -= 10;
|
|
}
|
|
}
|
|
|
|
auto pSectorB = pPlayerActor->sector();
|
|
|
|
switch (nWeapon)
|
|
{
|
|
// loc_27266:
|
|
case kWeaponSword:
|
|
{
|
|
nHeight += pPlayerActor->spr.Angles.Pitch.Tan() * 32.;
|
|
|
|
thePos.Z += nHeight;
|
|
|
|
int newState;
|
|
|
|
if (pPlayer->nState == 2) {
|
|
newState = 6;
|
|
}
|
|
else {
|
|
newState = 9;
|
|
}
|
|
|
|
auto cRange = CheckCloseRange(nPlayer, thePos, &pSectorB);
|
|
|
|
if (cRange.type != kHitNone)
|
|
{
|
|
int nDamage = BulletInfo[kWeaponSword].nDamage;
|
|
|
|
if (pPlayer->nDouble) {
|
|
nDamage *= 2;
|
|
}
|
|
|
|
//if (cRange.type != kHitNone)
|
|
{
|
|
if (cRange.type == kHitWall)
|
|
{
|
|
// loc_2730E:
|
|
newState += 2;
|
|
}
|
|
else if (cRange.type == kHitSprite)
|
|
{
|
|
auto pActor2 = cRange.actor();
|
|
|
|
if (pActor2->spr.cstat & (CSTAT_SPRITE_ALIGNMENT_WALL | CSTAT_SPRITE_ONE_SIDE))
|
|
{
|
|
newState += 2;
|
|
}
|
|
else if (pActor2->spr.statnum > 90 && pActor2->spr.statnum <= 199)
|
|
{
|
|
runlist_DamageEnemy(pActor2, pPlayerActor, nDamage);
|
|
|
|
if (pActor2->spr.statnum < 102) {
|
|
newState++;
|
|
}
|
|
else if (pActor2->spr.statnum == 102)
|
|
{
|
|
// loc_27370:
|
|
BuildAnim(nullptr, "poof", 0, thePos, pSectorB, 0.46875, 0);
|
|
}
|
|
else if (pActor2->spr.statnum == kStatExplodeTrigger) {
|
|
newState += 2;
|
|
}
|
|
else {
|
|
newState++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// loc_27370:
|
|
BuildAnim(nullptr, "poof", 0, thePos, pSectorB, 0.46875, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// loc_27399:
|
|
pPlayer->nState = newState;
|
|
pPlayer->nWeapFrame = 0;
|
|
break;
|
|
}
|
|
case kWeaponFlamer:
|
|
{
|
|
if (nSectFlag & kSectUnderwater)
|
|
{
|
|
DoBubbles(nPlayer);
|
|
pPlayer->nState = 1;
|
|
pPlayer->nWeapFrame = 0;
|
|
StopActorSound(pPlayerActor);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if (var_38) {
|
|
nHeight += 3;
|
|
}
|
|
else {
|
|
nHeight -= 10;
|
|
}
|
|
|
|
// fall through to case 1 (kWeaponPistol)
|
|
[[fallthrough]];
|
|
}
|
|
}
|
|
|
|
case kWeaponM60:
|
|
{
|
|
if (nWeapon == kWeaponM60) { // hack(?) to do fallthrough from kWeapon3 into kWeaponPistol without doing the nQuake[] change
|
|
pPlayer->nQuake = 0.5;
|
|
}
|
|
// fall through
|
|
[[fallthrough]];
|
|
}
|
|
case kWeaponPistol:
|
|
{
|
|
double h = pPlayerActor->spr.Angles.Pitch.Tan() * 2.;
|
|
nHeight += h;
|
|
|
|
DExhumedActor* target = nullptr;
|
|
if (pPlayer->pTarget != nullptr && Autoaim(nPlayer))
|
|
{
|
|
DExhumedActor* t = pPlayer->pTarget;
|
|
// only autoaim if target is in front of the player.
|
|
assert(t->sector());
|
|
DAngle angletotarget = (t->spr.pos - pPlayerActor->spr.pos).Angle();
|
|
DAngle anglediff = absangle(pPlayerActor->spr.Angles.Yaw, angletotarget);
|
|
if (anglediff < DAngle90)
|
|
{
|
|
target = t;
|
|
h = 0;
|
|
}
|
|
}
|
|
|
|
BuildBullet(pPlayerActor, nAmmoType, nHeight, nAngle, target, var_1C, -int(h * zworldtoint));
|
|
break;
|
|
}
|
|
|
|
case kWeaponGrenade:
|
|
{
|
|
ThrowGrenade(nPlayer, nHeight - 10, pPlayerActor->spr.Angles.Pitch.Tan());
|
|
break;
|
|
}
|
|
case kWeaponStaff:
|
|
{
|
|
BuildSnake(nPlayer, nHeight);
|
|
pPlayer->nQuake = 2.;
|
|
|
|
pPlayer->nThrust -= pPlayerActor->spr.Angles.Yaw.ToVector() * 2;
|
|
break;
|
|
}
|
|
case kWeaponRing:
|
|
break;
|
|
|
|
case kWeaponMummified:
|
|
{
|
|
int nDamage = BulletInfo[kWeaponMummified].nDamage;
|
|
if (pPlayer->nDouble) {
|
|
nDamage *= 2;
|
|
}
|
|
|
|
runlist_RadialDamageEnemy(pPlayerActor, nDamage, BulletInfo[kWeaponMummified].nRadius);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// end of switch, loc_2753E:
|
|
if (nWeapon < kWeaponMummified)
|
|
{
|
|
if (nWeapon != kWeaponGrenade)
|
|
{
|
|
if (WeaponInfo[nWeapon].d) {
|
|
AddAmmo(nPlayer, nAmmoType, -1);
|
|
}
|
|
|
|
if (nWeapon == kWeaponM60) {
|
|
pPlayer->nPlayerClip--;
|
|
}
|
|
else if (nWeapon == kWeaponPistol) {
|
|
pPlayer->nPistolClip--;
|
|
}
|
|
}
|
|
|
|
if (!WeaponInfo[nWeapon].d || pPlayer->nAmmo[WeaponInfo[nWeapon].nAmmoType])
|
|
{
|
|
if (nWeapon == kWeaponM60 && pPlayer->nPlayerClip <= 0)
|
|
{
|
|
pPlayer->nState = 3;
|
|
pPlayer->nWeapFrame = 0;
|
|
// goto loc_27609:
|
|
}
|
|
}
|
|
else if (nWeapon != kWeaponGrenade)
|
|
{
|
|
SelectNewWeapon(nPlayer);
|
|
// go to loc_27609:
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
void DrawWeapons(DExhumedPlayer* const pPlayer, double interpfrac)
|
|
{
|
|
const auto pPlayerActor = pPlayer->GetActor();
|
|
const int nWeapon = pPlayer->nCurrentWeapon;
|
|
|
|
if (bCamera || nWeapon < -1)
|
|
return;
|
|
|
|
const int nState = pPlayer->nState;
|
|
const int nShade = nWeapon < 0 ? pPlayerActor->spr.shade : pPlayerActor->sector()->ceilingshade;
|
|
const double nAlpha = pPlayer->nInvisible ? 0.3 : 1;
|
|
const auto weapSeqs = getFileSeqs(WeaponInfo[nWeapon].nSeqFile);
|
|
|
|
int nPal = kPalNormal;
|
|
|
|
if (pPlayer->nDouble)
|
|
{
|
|
if (isRed) {
|
|
nPal = kPalRedBrite;
|
|
}
|
|
|
|
isRed = isRed == 0;
|
|
}
|
|
|
|
nPal = RemapPLU(nPal);
|
|
|
|
const auto weaponOffsets = pPlayer->Angles.getWeaponOffsets(interpfrac);
|
|
const auto nAngle = weaponOffsets.second;
|
|
double xPos = 160 + weaponOffsets.first.X;
|
|
double yPos = 100 + weaponOffsets.first.Y;
|
|
|
|
double nFlameAng = interpolatedvalue(lastavel, pPlayer->cmd.ucmd.avel, interpfrac);
|
|
lastavel = pPlayer->cmd.ucmd.avel;
|
|
|
|
if (cl_weaponsway)
|
|
{
|
|
double nBobAngle = pPlayer->nWeapBob, nTotalVel = pPlayer->totalvel;
|
|
|
|
if (cl_hudinterpolation)
|
|
{
|
|
nBobAngle = interpolatedvalue<double>(pPlayer->nPrevWeapBob, pPlayer->nWeapBob, interpfrac);
|
|
nTotalVel = interpolatedvalue<double>(pPlayer->ototalvel, pPlayer->totalvel, interpfrac);
|
|
}
|
|
|
|
const auto xBob = nTotalVel * BobVal(nBobAngle + 512) * (nState == 1);
|
|
const auto yBob = nTotalVel * fabs(BobVal(nBobAngle));
|
|
|
|
nFlameAng += xBob;
|
|
xPos += xBob * 2.;
|
|
yPos += yBob;
|
|
}
|
|
else
|
|
{
|
|
pPlayer->nPrevWeapBob = pPlayer->nWeapBob = 512;
|
|
}
|
|
|
|
int nStat = false;
|
|
|
|
if (nWeapon == 3 && nState == 1)
|
|
{
|
|
if (!(pPlayer->pPlayerViewSect->Flag & kSectUnderwater))
|
|
{
|
|
seq_DrawPilotLightSeq(xPos, yPos, nFlameAng);
|
|
}
|
|
}
|
|
else if (nWeapon == 8 || nWeapon == 9)
|
|
{
|
|
nStat |= RS_ALIGN_R;
|
|
}
|
|
|
|
int nSeqOffset = WeaponInfo[nWeapon].b[nState];
|
|
int nFrame = pPlayer->nWeapFrame;
|
|
|
|
seq_DrawGunSequence(weapSeqs->Data(nSeqOffset)->frames[nFrame], xPos, yPos, nShade, nPal, nAngle, nAlpha, nStat);
|
|
|
|
int nClip = pPlayer->nPlayerClip;
|
|
|
|
if (nWeapon != kWeaponM60 || nClip <= 0)
|
|
return;
|
|
|
|
switch (nState)
|
|
{
|
|
case 0:
|
|
case 5:
|
|
{
|
|
static constexpr int offsetTable[2][4] = {
|
|
{1, 2, 3, 4},
|
|
{20, 19, 18, 17}
|
|
};
|
|
|
|
const auto& offsets = offsetTable[nState == 5];
|
|
|
|
if (nClip <= 3)
|
|
{
|
|
nSeqOffset = offsets[0];
|
|
}
|
|
else if (nClip <= 6)
|
|
{
|
|
nSeqOffset = offsets[1];
|
|
}
|
|
else if (nClip <= 25)
|
|
{
|
|
nSeqOffset = offsets[2];
|
|
}
|
|
else //if (nClip > 25)
|
|
{
|
|
nSeqOffset = offsets[3];
|
|
}
|
|
|
|
seq_DrawGunSequence(weapSeqs->Data(nSeqOffset)->frames[nFrame], xPos, yPos, nShade, nPal, nAngle, nAlpha);
|
|
return;
|
|
}
|
|
case 1:
|
|
case 2:
|
|
{
|
|
if (nState == 1)
|
|
nFrame = (nClip % 3) * 4;
|
|
|
|
seq_DrawGunSequence(weapSeqs->Data(8)->frames[nFrame], xPos, yPos, nShade, nPal, nAngle, nAlpha);
|
|
|
|
if (nClip <= 3) {
|
|
return;
|
|
}
|
|
|
|
seq_DrawGunSequence(weapSeqs->Data(9)->frames[nFrame], xPos, yPos, nShade, nPal, nAngle, nAlpha);
|
|
|
|
if (nClip <= 6) {
|
|
return;
|
|
}
|
|
|
|
seq_DrawGunSequence(weapSeqs->Data(10)->frames[nFrame], xPos, yPos, nShade, nPal, nAngle, nAlpha);
|
|
|
|
if (nClip <= 25) {
|
|
return;
|
|
}
|
|
|
|
seq_DrawGunSequence(weapSeqs->Data(11)->frames[nFrame], xPos, yPos, nShade, nPal, nAngle, nAlpha);
|
|
return;
|
|
}
|
|
default:
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
END_PS_NS
|