mirror of
https://github.com/ZDoom/qzdoom-gpl.git
synced 2024-12-11 12:51:27 +00:00
fbf8084999
- fixed PARAM_ACTION_PROLOGUE to assign correct types to the implicit pointers. It gave the actual class to the wrong one, which until now did not matter because all functions were using 'Actor', regardless of actual class association. - fixed the definition of IceChunk and removed some redundant code here. Since A_FreezeDeathChunks already calls SetState, which in turn calls the state's action function, there is no need to call it again explicitly.
457 lines
11 KiB
C++
457 lines
11 KiB
C++
/*
|
|
** a_specialspot.cpp
|
|
** Handling for special spot actors
|
|
** like BrainTargets, MaceSpawners etc.
|
|
**
|
|
**---------------------------------------------------------------------------
|
|
** Copyright 2008 Christoph Oelckers
|
|
** All rights reserved.
|
|
**
|
|
** Redistribution and use in source and binary forms, with or without
|
|
** modification, are permitted provided that the following conditions
|
|
** are met:
|
|
**
|
|
** 1. Redistributions of source code must retain the above copyright
|
|
** notice, this list of conditions and the following disclaimer.
|
|
** 2. Redistributions in binary form must reproduce the above copyright
|
|
** notice, this list of conditions and the following disclaimer in the
|
|
** documentation and/or other materials provided with the distribution.
|
|
** 3. The name of the author may not be used to endorse or promote products
|
|
** derived from this software without specific prior written permission.
|
|
**
|
|
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
**---------------------------------------------------------------------------
|
|
**
|
|
*/
|
|
#include "a_specialspot.h"
|
|
#include "m_random.h"
|
|
#include "p_local.h"
|
|
#include "statnums.h"
|
|
#include "i_system.h"
|
|
#include "doomstat.h"
|
|
#include "serializer.h"
|
|
#include "a_pickups.h"
|
|
|
|
static FRandom pr_spot ("SpecialSpot");
|
|
static FRandom pr_spawnmace ("SpawnMace");
|
|
|
|
IMPLEMENT_CLASS(DSpotState, false, false)
|
|
IMPLEMENT_CLASS(ASpecialSpot, false, false)
|
|
TObjPtr<DSpotState> DSpotState::SpotState;
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Spot list
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
struct FSpotList
|
|
{
|
|
PClassActor *Type;
|
|
TArray<ASpecialSpot*> Spots;
|
|
unsigned Index;
|
|
int SkipCount;
|
|
int numcalls;
|
|
|
|
FSpotList()
|
|
{
|
|
}
|
|
|
|
FSpotList(PClassActor *type)
|
|
{
|
|
Type = type;
|
|
Index = 0;
|
|
SkipCount = 0;
|
|
numcalls = 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool Add(ASpecialSpot *newspot)
|
|
{
|
|
for(unsigned i = 0; i < Spots.Size(); i++)
|
|
{
|
|
if (Spots[i] == newspot) return false;
|
|
}
|
|
Spots.Push(newspot);
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool Remove(ASpecialSpot *spot)
|
|
{
|
|
for(unsigned i = 0; i < Spots.Size(); i++)
|
|
{
|
|
if (Spots[i] == spot)
|
|
{
|
|
Spots.Delete(i);
|
|
if (Index > i) Index--;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
ASpecialSpot *GetNextInList(int skipcounter)
|
|
{
|
|
if (Spots.Size() > 0 && ++SkipCount > skipcounter)
|
|
{
|
|
SkipCount = 0;
|
|
|
|
ASpecialSpot *spot = Spots[Index];
|
|
if (++Index >= Spots.Size()) Index = 0;
|
|
numcalls++;
|
|
return spot;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
ASpecialSpot *GetSpotWithMinMaxDistance(double x, double y, double mindist, double maxdist)
|
|
{
|
|
if (Spots.Size() == 0) return NULL;
|
|
int i = pr_spot() % Spots.Size();
|
|
int initial = i;
|
|
|
|
double distance;
|
|
|
|
while (true)
|
|
{
|
|
distance = Spots[i]->Distance2D(x, y);
|
|
|
|
if ((distance >= mindist) && ((maxdist == 0) || (distance <= maxdist))) break;
|
|
|
|
i = (i+1) % Spots.Size();
|
|
if (i == initial) return NULL;
|
|
}
|
|
numcalls++;
|
|
return Spots[i];
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
ASpecialSpot *GetRandomSpot(bool onlyfirst)
|
|
{
|
|
if (Spots.Size() && !numcalls)
|
|
{
|
|
int i = pr_spot() % Spots.Size();
|
|
numcalls++;
|
|
return Spots[i];
|
|
}
|
|
else return NULL;
|
|
}
|
|
};
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
FSerializer &Serialize(FSerializer &arc, const char *key, FSpotList &list, FSpotList *def)
|
|
{
|
|
if (arc.BeginObject(key))
|
|
{
|
|
arc("type", list.Type)
|
|
("spots", list.Spots)
|
|
("index", list.Index)
|
|
("skipcount", list.SkipCount)
|
|
("numcalls", list.numcalls)
|
|
.EndObject();
|
|
}
|
|
return arc;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DSpotState::DSpotState ()
|
|
: DThinker (STAT_INFO)
|
|
{
|
|
if (SpotState)
|
|
{
|
|
I_Error ("Only one SpotState is allowed to exist at a time.\nCheck your code.");
|
|
}
|
|
else
|
|
{
|
|
SpotState = this;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void DSpotState::Destroy ()
|
|
{
|
|
SpotLists.Clear();
|
|
SpotLists.ShrinkToFit();
|
|
|
|
SpotState = NULL;
|
|
Super::Destroy();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void DSpotState::Tick ()
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DSpotState *DSpotState::GetSpotState(bool create)
|
|
{
|
|
if (SpotState == NULL && create) SpotState = new DSpotState;
|
|
return SpotState;
|
|
}
|
|
|
|
DEFINE_ACTION_FUNCTION(DSpotState, GetSpotState)
|
|
{
|
|
PARAM_PROLOGUE;
|
|
ACTION_RETURN_OBJECT(DSpotState::GetSpotState());
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
FSpotList *DSpotState::FindSpotList(PClassActor *type)
|
|
{
|
|
if (type == nullptr) return nullptr;
|
|
for(unsigned i = 0; i < SpotLists.Size(); i++)
|
|
{
|
|
if (SpotLists[i].Type == type) return &SpotLists[i];
|
|
}
|
|
return &SpotLists[SpotLists.Push(FSpotList(type))];
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool DSpotState::AddSpot(ASpecialSpot *spot)
|
|
{
|
|
FSpotList *list = FindSpotList(spot->GetClass());
|
|
if (list != NULL) return list->Add(spot);
|
|
return false;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
bool DSpotState::RemoveSpot(ASpecialSpot *spot)
|
|
{
|
|
FSpotList *list = FindSpotList(spot->GetClass());
|
|
if (list != NULL) return list->Remove(spot);
|
|
return false;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void DSpotState::Serialize(FSerializer &arc)
|
|
{
|
|
Super::Serialize(arc);
|
|
arc("spots", SpotLists);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
ASpecialSpot *DSpotState::GetNextInList(PClassActor *type, int skipcounter)
|
|
{
|
|
FSpotList *list = FindSpotList(type);
|
|
if (list != NULL) return list->GetNextInList(skipcounter);
|
|
return NULL;
|
|
}
|
|
|
|
DEFINE_ACTION_FUNCTION(DSpotState, GetNextInList)
|
|
{
|
|
PARAM_SELF_PROLOGUE(DSpotState);
|
|
PARAM_CLASS(type, AActor);
|
|
PARAM_INT(skipcounter);
|
|
ACTION_RETURN_OBJECT(self->GetNextInList(type, skipcounter));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
ASpecialSpot *DSpotState::GetSpotWithMinMaxDistance(PClassActor *type, double x, double y, double mindist, double maxdist)
|
|
{
|
|
FSpotList *list = FindSpotList(type);
|
|
if (list != NULL) return list->GetSpotWithMinMaxDistance(x, y, mindist, maxdist);
|
|
return NULL;
|
|
}
|
|
|
|
DEFINE_ACTION_FUNCTION(DSpotState, GetSpotWithMinMaxDistance)
|
|
{
|
|
PARAM_SELF_PROLOGUE(DSpotState);
|
|
PARAM_CLASS(type, AActor);
|
|
PARAM_FLOAT(x);
|
|
PARAM_FLOAT(y);
|
|
PARAM_FLOAT(mindist);
|
|
PARAM_FLOAT(maxdist);
|
|
ACTION_RETURN_OBJECT(self->GetSpotWithMinMaxDistance(type, x, y, mindist, maxdist));
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
ASpecialSpot *DSpotState::GetRandomSpot(PClassActor *type, bool onlyonce)
|
|
{
|
|
FSpotList *list = FindSpotList(type);
|
|
if (list != NULL) return list->GetRandomSpot(onlyonce);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void ASpecialSpot::BeginPlay()
|
|
{
|
|
DSpotState *state = DSpotState::GetSpotState();
|
|
if (state != NULL) state->AddSpot(this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void ASpecialSpot::Destroy()
|
|
{
|
|
DSpotState *state = DSpotState::GetSpotState(false);
|
|
if (state != NULL) state->RemoveSpot(this);
|
|
Super::Destroy();
|
|
}
|
|
|
|
// Mace spawn spot ----------------------------------------------------------
|
|
|
|
// Every mace spawn spot will execute this action. The first one
|
|
// will build a list of all mace spots in the level and spawn a
|
|
// mace. The rest of the spots will do nothing.
|
|
|
|
DEFINE_ACTION_FUNCTION(ASpecialSpot, A_SpawnSingleItem)
|
|
{
|
|
PARAM_SELF_PROLOGUE(ASpecialSpot);
|
|
PARAM_CLASS_NOT_NULL(cls, AActor);
|
|
PARAM_INT_DEF (fail_sp)
|
|
PARAM_INT_DEF (fail_co)
|
|
PARAM_INT_DEF (fail_dm)
|
|
|
|
AActor *spot = NULL;
|
|
DSpotState *state = DSpotState::GetSpotState();
|
|
|
|
if (state != NULL) spot = state->GetRandomSpot(self->GetClass(), true);
|
|
if (spot == NULL) return 0;
|
|
|
|
if (!multiplayer && pr_spawnmace() < fail_sp)
|
|
{ // Sometimes doesn't show up if not in deathmatch
|
|
return 0;
|
|
}
|
|
|
|
if (multiplayer && !deathmatch && pr_spawnmace() < fail_co)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (deathmatch && pr_spawnmace() < fail_dm)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (cls == NULL)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
AActor *spawned = Spawn(cls, self->Pos(), ALLOW_REPLACE);
|
|
|
|
if (spawned)
|
|
{
|
|
spawned->SetOrigin (spot->Pos(), false);
|
|
spawned->SetZ(spawned->floorz);
|
|
// We want this to respawn.
|
|
if (!(self->flags & MF_DROPPED))
|
|
{
|
|
spawned->flags &= ~MF_DROPPED;
|
|
}
|
|
if (spawned->IsKindOf(RUNTIME_CLASS(AInventory)))
|
|
{
|
|
static_cast<AInventory*>(spawned)->SpawnPointClass = self->GetClass();
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|