mirror of
https://github.com/nzp-team/quakec.git
synced 2024-11-22 20:01:34 +00:00
368 lines
No EOL
10 KiB
C++
368 lines
No EOL
10 KiB
C++
/*
|
|
server/entities/spawn_points.qc
|
|
|
|
Code for Player Spawn points.
|
|
|
|
Copyright (C) 2021-2023 NZ:P Team
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
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:
|
|
|
|
Free Software Foundation, Inc.
|
|
59 Temple Place - Suite 330
|
|
Boston, MA 02111-1307, USA
|
|
|
|
*/
|
|
|
|
#define SPAWN_PLR_1 0
|
|
#define SPAWN_PLR_2 1
|
|
#define SPAWN_PLR_3 2
|
|
#define SPAWN_PLR_4 3
|
|
#define SPAWN_PLR_LEGACY 4
|
|
|
|
#define SPAWN_START_WEAPON W_COLT
|
|
#define SPAWN_START_MAG 8
|
|
#define SPAWN_START_AMMO 32
|
|
|
|
float player_spawns[5];
|
|
entity spawn_points[5];
|
|
string spawn_names[4];
|
|
|
|
//
|
|
// Spawns_ConvertOldClassnames()
|
|
// Renames old/legacy spawns to their
|
|
// newly assocated names.
|
|
//
|
|
void() Spawns_ConvertOldClassnames =
|
|
{
|
|
entity spawn_point;
|
|
|
|
spawn_point = find(world, classname, "info_player_tank");
|
|
if (spawn_point != world) spawn_point.classname = SPAWN_1_CLASS;
|
|
spawn_point = find(world, classname, "info_player_nikolai");
|
|
if (spawn_point != world) spawn_point.classname = SPAWN_2_CLASS;
|
|
spawn_point = find(world, classname, "info_player_takeo");
|
|
if (spawn_point != world) spawn_point.classname = SPAWN_3_CLASS;
|
|
spawn_point = find(world, classname, "info_player_doctor");
|
|
if (spawn_point != world) spawn_point.classname = SPAWN_4_CLASS;
|
|
};
|
|
|
|
//
|
|
// Spawns_EntIsInRange(which, units)
|
|
// Returns true if there is a solid entity
|
|
// within the provided units at a given
|
|
// entity's origin.
|
|
//
|
|
float(entity which, float units) Spawns_EntIsInRange =
|
|
{
|
|
float found_something = false;
|
|
|
|
entity ents_in_range = findradius(which.origin, units);
|
|
while(ents_in_range != world) {
|
|
if (ents_in_range != which &&
|
|
ents_in_range.solid != SOLID_NOT &&
|
|
ents_in_range.solid != SOLID_TRIGGER)
|
|
found_something = true;
|
|
|
|
ents_in_range = ents_in_range.chain;
|
|
}
|
|
|
|
return found_something;
|
|
}
|
|
|
|
//
|
|
// Spawns_PerformCheck(which, start_org, ...)
|
|
// Performs various checks at different positions
|
|
// for positioning of a spawn point if one is
|
|
// not provided by the map. Sets the origin if
|
|
// spot is valid.
|
|
//
|
|
float (entity which, vector start_org, vector dir,
|
|
float units, vector feet, vector head) Spawns_PerformCheck =
|
|
{
|
|
// Try moving the designated units
|
|
vector org = start_org + (dir * units);
|
|
which.origin = org;
|
|
which.solid = SOLID_BBOX;
|
|
setorigin(which, which.origin);
|
|
|
|
// If there's no ents in the way, check that we're
|
|
// not stuck inside a brush.
|
|
if (!Spawns_EntIsInRange(which, 64)) {
|
|
feet = start_org /*- '0 0 16'*/;
|
|
traceline (feet, feet + (dir * units), 0, spawn_points[SPAWN_PLR_1]);
|
|
|
|
// We were successfully able to trace at the feet.
|
|
if (trace_ent.classname == which.classname) {
|
|
// Now try the head.
|
|
head = start_org + '0 0 32';
|
|
traceline (head, head + (dir * units), 0, spawn_points[SPAWN_PLR_1]);
|
|
|
|
// Spot is viable, both feet and head are in same boundary.
|
|
if (trace_ent.classname == which.classname) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
//
|
|
// Spawns_SetAllNonSolid(ignore_first)
|
|
// Marks all spawn points as SOLID_NOT,
|
|
// use ignore_first to ommit player 1.
|
|
//
|
|
void(float ignore_first) Spawns_SetAllNonSolid =
|
|
{
|
|
float start;
|
|
|
|
if (ignore_first) start = 1;
|
|
else start = 0;
|
|
|
|
for(float i = start; i < 4; i++) {
|
|
if (spawn_points[i] == world)
|
|
continue;
|
|
|
|
spawn_points[i].solid = SOLID_NOT;
|
|
setorigin(spawn_points[i], spawn_points[i].origin);
|
|
}
|
|
};
|
|
|
|
//
|
|
// Spawns_SetAllSolid(ignore_first)
|
|
// Marks all spawn points as SOLID_BBOX,
|
|
// use ignore_first to ommit player 1.
|
|
//
|
|
void(float ignore_first) Spawns_SetAllSolid =
|
|
{
|
|
float start;
|
|
|
|
if (ignore_first) start = 1;
|
|
else start = 0;
|
|
|
|
for(float i = start; i < 4; i++) {
|
|
if (spawn_points[i] == world)
|
|
continue;
|
|
|
|
spawn_points[i].solid = SOLID_BBOX;
|
|
setorigin(spawn_points[i], spawn_points[i].origin);
|
|
}
|
|
};
|
|
|
|
//
|
|
// Spawns_FindViableSpawnSpot(which)
|
|
// Uses a simple "algorithm" for predicting
|
|
// potential viable spawn points, and calls
|
|
// Spawns_PerformCheck() to validate and
|
|
// set if able.
|
|
//
|
|
void(entity which) Spawns_FindViableSpawnSpot =
|
|
{
|
|
vector org = '0 0 0';
|
|
vector trace_feet = '0 0 0';
|
|
vector trace_head = '0 0 0';
|
|
|
|
// Always start with the "main" (player 1) spawn
|
|
vector start_origin = spawn_points[SPAWN_PLR_1].origin;
|
|
makevectors(spawn_points[SPAWN_PLR_1].angles);
|
|
|
|
// Spawn point determination "algorithm" is really simple --
|
|
// We have "ideal" positioning that looks like this:
|
|
// ---
|
|
// 3
|
|
// 2 1 4
|
|
// ---
|
|
// If any spot (other than 1) fails, try the next, when 4
|
|
// is reached, start from the left again with a larger
|
|
// distance from one, e.g.:
|
|
// ---
|
|
// 3
|
|
// 4 2 1
|
|
// ---
|
|
// We do this for 2 cycles (64 units, 128 units, 192 units)
|
|
// before giving up and just setting a spawn to slot 1, but
|
|
// this SHOULD never happen(?!).
|
|
|
|
float units = 64;
|
|
|
|
for (float i = 0; i < 2; i++) {
|
|
// Try moving to the "left".
|
|
if (Spawns_PerformCheck(which, start_origin, v_right, -units, trace_feet, trace_head)) {
|
|
Spawns_SetAllSolid(true);
|
|
return;
|
|
}
|
|
|
|
// Now "forward".
|
|
if (Spawns_PerformCheck(which, start_origin, v_forward, units, trace_feet, trace_head)) {
|
|
Spawns_SetAllSolid(true);
|
|
return;
|
|
}
|
|
|
|
// Now "right".
|
|
if (Spawns_PerformCheck(which, start_origin, v_right, units, trace_feet, trace_head)) {
|
|
Spawns_SetAllSolid(true);
|
|
return;
|
|
}
|
|
|
|
// Now "back".
|
|
if (Spawns_PerformCheck(which, start_origin, v_forward, -units, trace_feet, trace_head)) {
|
|
Spawns_SetAllSolid(true);
|
|
return;
|
|
}
|
|
|
|
// Increase the distance by 64 units and try again.
|
|
Spawns_SetAllNonSolid(true);
|
|
units += 64;
|
|
}
|
|
|
|
// Every attempt failed, just put them in the same
|
|
// spot as player one.
|
|
setorigin(which, start_origin);
|
|
bprint(PRINT_HIGH, "WARN: Unable to find viable player start position\n");
|
|
bprint(PRINT_HIGH, strcat(" for entity: ", which.classname));
|
|
bprint(PRINT_HIGH, "\n");
|
|
};
|
|
|
|
//
|
|
// Spawns_DropToFloor(who)
|
|
// Drops the spawn point to
|
|
// the floor.
|
|
//
|
|
void(entity who) Spawns_DropToFloor =
|
|
{
|
|
entity tempe = self;
|
|
self = who;
|
|
|
|
#ifdef FTE
|
|
|
|
droptofloor();
|
|
|
|
#else
|
|
|
|
droptofloor(0, 0);
|
|
|
|
#endif // FTE
|
|
|
|
self = tempe;
|
|
}
|
|
|
|
//
|
|
// Spawns_SetUpPoint(which)
|
|
// Sets up base stats for a Spawn
|
|
// Point such as size, and any fields
|
|
// not provided by map maker.
|
|
//
|
|
void(entity which) Spawns_SetUpPoint =
|
|
{
|
|
which.solid = SOLID_BBOX;
|
|
setsize(which, [-8, -8, -32], [8, 8, 40]);
|
|
Spawns_DropToFloor(which);
|
|
|
|
if (!which.weapon) {
|
|
which.weapon = SPAWN_START_WEAPON;
|
|
which.currentmag = SPAWN_START_MAG;
|
|
which.currentammo = SPAWN_START_AMMO;
|
|
}
|
|
};
|
|
|
|
//
|
|
// Spawns_FillMissing()
|
|
// Creates any missing Spawn Points,
|
|
// setting up their fields if necessary.
|
|
//
|
|
void() Spawns_FillMissing =
|
|
{
|
|
float i;
|
|
|
|
// Count how many spawnpoints we have.
|
|
for(i = 0; i < 4; i++) {
|
|
spawn_points[i] = find(world, classname, spawn_names[i]);
|
|
if (spawn_points[i] != world) {
|
|
player_spawns[i] = true;
|
|
Spawns_SetUpPoint(spawn_points[i]);
|
|
}
|
|
}
|
|
|
|
// Store the legacy spawn point as well (info_player_start).
|
|
spawn_points[SPAWN_PLR_LEGACY] = find(world, classname, "info_player_start");
|
|
if (spawn_points[SPAWN_PLR_LEGACY] != world) {
|
|
player_spawns[SPAWN_PLR_LEGACY] = true;
|
|
Spawns_SetUpPoint(spawn_points[SPAWN_PLR_LEGACY]);
|
|
Spawns_DropToFloor(spawn_points[i]);
|
|
}
|
|
|
|
// If there's no player 1 spawn or legacy spawn, crash.
|
|
if (player_spawns[SPAWN_PLR_LEGACY] == false &&
|
|
player_spawns[SPAWN_PLR_1] == false) {
|
|
error("Spawns_FillMissing: No spawn points set in level.\n");
|
|
return;
|
|
}
|
|
|
|
// If there's a legacy spawn, and a player 1 spawn,
|
|
// remove the legacy spawn.
|
|
if (player_spawns[SPAWN_PLR_LEGACY] == true &&
|
|
player_spawns[SPAWN_PLR_1] == true) {
|
|
remove(spawn_points[SPAWN_PLR_LEGACY]);
|
|
player_spawns[SPAWN_PLR_LEGACY] = false;
|
|
}
|
|
|
|
// Convert info_player_start to info_player_1_spawn
|
|
if (player_spawns[SPAWN_PLR_LEGACY] == true) {
|
|
spawn_points[SPAWN_PLR_LEGACY].classname = SPAWN_1_CLASS;
|
|
spawn_points[SPAWN_PLR_1] = spawn_points[SPAWN_PLR_LEGACY];
|
|
player_spawns[SPAWN_PLR_1] = true;
|
|
player_spawns[SPAWN_PLR_LEGACY] = false;
|
|
}
|
|
|
|
// Spawn points 2-4 if they dont exist
|
|
for(i = 1; i < 4; i++) {
|
|
if (player_spawns[i] == false) {
|
|
spawn_points[i] = spawn();
|
|
spawn_points[i].classname = spawn_names[i];
|
|
spawn_points[i].angles = spawn_points[SPAWN_PLR_1].angles;
|
|
Spawns_SetUpPoint(spawn_points[i]);
|
|
Spawns_FindViableSpawnSpot(spawn_points[i]);
|
|
}
|
|
}
|
|
|
|
Spawns_SetAllNonSolid(false);
|
|
};
|
|
|
|
//
|
|
// Spawns_SetUpClassnames()
|
|
// Fills the spawn_names[] array
|
|
// with the classnames for the
|
|
// associated index.
|
|
//
|
|
void() Spawns_SetUpClassnames =
|
|
{
|
|
spawn_names[0] = SPAWN_1_CLASS;
|
|
spawn_names[1] = SPAWN_2_CLASS;
|
|
spawn_names[2] = SPAWN_3_CLASS;
|
|
spawn_names[3] = SPAWN_4_CLASS;
|
|
};
|
|
|
|
//
|
|
// Spawns_Init()
|
|
// Provide backwards compatibility
|
|
// checks for old Spawn Points and
|
|
// creates any that are absent.
|
|
//
|
|
void() Spawns_Init =
|
|
{
|
|
Spawns_ConvertOldClassnames();
|
|
Spawns_SetUpClassnames();
|
|
Spawns_FillMissing();
|
|
}; |