id/quake2-rerelease-dll
0
0
Fork 0
mirror of https://github.com/id-Software/quake2-rerelease-dll.git synced 2024-11-27 06:33:47 +00:00
Code Issues Projects Releases Packages Wiki Activity
quake2-rerelease-dll/rerelease/g_cmds.cpp

1754 lines
35 KiB
C++
Raw Permalink Normal View History

Initial commit
2023-08-07 19:47:28 +00:00
// Copyright (c) ZeniMax Media Inc.
// Licensed under the GNU General Public License 2.0.
#include "g_local.h"
#include "m_player.h"
Update 1 changes
2023-10-03 18:43:06 +00:00
void SelectNextItem(edict_t *ent, item_flags_t itflags, bool menu = true)
Initial commit
2023-08-07 19:47:28 +00:00
{
gclient_t *cl;
item_id_t i, index;
gitem_t *it;
cl = ent->client;
// ZOID
Update 1 changes
2023-10-03 18:43:06 +00:00
if (menu && cl->menu)
Initial commit
2023-08-07 19:47:28 +00:00
{
PMenu_Next(ent);
return;
}
Update 1 changes
2023-10-03 18:43:06 +00:00
else if (menu && cl->chase_target)
Initial commit
2023-08-07 19:47:28 +00:00
{
ChaseNext(ent);
return;
}
// ZOID
// scan for the next valid one
for (i = static_cast<item_id_t>(IT_NULL + 1); i <= IT_TOTAL; i = static_cast<item_id_t>(i + 1))
{
index = static_cast<item_id_t>((cl->pers.selected_item + i) % IT_TOTAL);
if (!cl->pers.inventory[index])
continue;
it = &itemlist[index];
if (!it->use)
continue;
if (!(it->flags & itflags))
continue;
cl->pers.selected_item = index;
cl->pers.selected_item_time = level.time + SELECTED_ITEM_TIME;
cl->ps.stats[STAT_SELECTED_ITEM_NAME] = CS_ITEMS + index;
return;
}
cl->pers.selected_item = IT_NULL;
}
void SelectPrevItem(edict_t *ent, item_flags_t itflags)
{
gclient_t *cl;
item_id_t i, index;
gitem_t *it;
cl = ent->client;
// ZOID
if (cl->menu)
{
PMenu_Prev(ent);
return;
}
else if (cl->chase_target)
{
ChasePrev(ent);
return;
}
// ZOID
// scan for the next valid one
for (i = static_cast<item_id_t>(IT_NULL + 1); i <= IT_TOTAL; i = static_cast<item_id_t>(i + 1))
{
index = static_cast<item_id_t>((cl->pers.selected_item + IT_TOTAL - i) % IT_TOTAL);
if (!cl->pers.inventory[index])
continue;
it = &itemlist[index];
if (!it->use)
continue;
if (!(it->flags & itflags))
continue;
cl->pers.selected_item = index;
cl->pers.selected_item_time = level.time + SELECTED_ITEM_TIME;
cl->ps.stats[STAT_SELECTED_ITEM_NAME] = CS_ITEMS + index;
return;
}
cl->pers.selected_item = IT_NULL;
}
void ValidateSelectedItem(edict_t *ent)
{
gclient_t *cl;
cl = ent->client;
if (cl->pers.inventory[cl->pers.selected_item])
return; // valid
Update 1 changes
2023-10-03 18:43:06 +00:00
SelectNextItem(ent, IF_ANY, false);
Initial commit
2023-08-07 19:47:28 +00:00
}
//=================================================================================
inline bool G_CheatCheck(edict_t *ent)
{
if (game.maxclients > 1 && !sv_cheats->integer)
{
gi.LocClient_Print(ent, PRINT_HIGH, "$g_need_cheats");
return false;
}
return true;
}
static void SpawnAndGiveItem(edict_t *ent, item_id_t id)
{
gitem_t *it = GetItemByIndex(id);
if (!it)
return;
edict_t *it_ent = G_Spawn();
it_ent->classname = it->classname;
SpawnItem(it_ent, it);
if (it_ent->inuse)
{
Touch_Item(it_ent, ent, null_trace, true);
if (it_ent->inuse)
G_FreeEdict(it_ent);
}
}
/*
==================
Cmd_Give_f
Give items to a client
==================
*/
void Cmd_Give_f(edict_t *ent)
{
const char *name;
gitem_t *it;
item_id_t index;
int i;
bool give_all;
edict_t *it_ent;
if (!G_CheatCheck(ent))
return;
name = gi.args();
if (Q_strcasecmp(name, "all") == 0)
give_all = true;
else
give_all = false;
if (give_all || Q_strcasecmp(gi.argv(1), "health") == 0)
{
if (gi.argc() == 3)
ent->health = atoi(gi.argv(2));
else
ent->health = ent->max_health;
if (!give_all)
return;
}
if (give_all || Q_strcasecmp(name, "weapons") == 0)
{
for (i = 0; i < IT_TOTAL; i++)
{
it = itemlist + i;
if (!it->pickup)
continue;
if (!(it->flags & IF_WEAPON))
continue;
ent->client->pers.inventory[i] += 1;
}
if (!give_all)
return;
}
if (give_all || Q_strcasecmp(name, "ammo") == 0)
{
if (give_all)
SpawnAndGiveItem(ent, IT_ITEM_PACK);
for (i = 0; i < IT_TOTAL; i++)
{
it = itemlist + i;
if (!it->pickup)
continue;
if (!(it->flags & IF_AMMO))
continue;
Add_Ammo(ent, it, 1000);
}
if (!give_all)
return;
}
if (give_all || Q_strcasecmp(name, "armor") == 0)
{
ent->client->pers.inventory[IT_ARMOR_JACKET] = 0;
ent->client->pers.inventory[IT_ARMOR_COMBAT] = 0;
ent->client->pers.inventory[IT_ARMOR_BODY] = GetItemByIndex(IT_ARMOR_BODY)->armor_info->max_count;
if (!give_all)
return;
}
if (give_all)
{
SpawnAndGiveItem(ent, IT_ITEM_POWER_SHIELD);
if (!give_all)
return;
}
if (give_all)
{
for (i = 0; i < IT_TOTAL; i++)
{
it = itemlist + i;
if (!it->pickup)
continue;
// ROGUE
if (it->flags & (IF_ARMOR | IF_WEAPON | IF_AMMO | IF_NOT_GIVEABLE | IF_TECH))
continue;
else if (it->pickup == CTFPickup_Flag)
continue;
else if ((it->flags & IF_HEALTH) && !it->use)
continue;
// ROGUE
ent->client->pers.inventory[i] = (it->flags & IF_KEY) ? 8 : 1;
}
G_CheckPowerArmor(ent);
ent->client->pers.power_cubes = 0xFF;
return;
}
it = FindItem(name);
if (!it)
{
name = gi.argv(1);
it = FindItem(name);
}
if (!it)
it = FindItemByClassname(name);
if (!it)
{
gi.LocClient_Print(ent, PRINT_HIGH, "$g_unknown_item");
return;
}
// ROGUE
if (it->flags & IF_NOT_GIVEABLE)
{
gi.LocClient_Print(ent, PRINT_HIGH, "$g_not_giveable");
return;
}
// ROGUE
index = it->id;
if (!it->pickup)
{
ent->client->pers.inventory[index] = 1;
return;
}
if (it->flags & IF_AMMO)
{
if (gi.argc() == 3)
ent->client->pers.inventory[index] = atoi(gi.argv(2));
else
ent->client->pers.inventory[index] += it->quantity;
}
else
{
it_ent = G_Spawn();
it_ent->classname = it->classname;
SpawnItem(it_ent, it);
// PMM - since some items don't actually spawn when you say to ..
if (!it_ent->inuse)
return;
// pmm
Touch_Item(it_ent, ent, null_trace, true);
if (it_ent->inuse)
G_FreeEdict(it_ent);
}
}
void Cmd_SetPOI_f(edict_t *self)
{
if (!G_CheatCheck(self))
return;
level.current_poi = self->s.origin;
level.valid_poi = true;
}
void Cmd_CheckPOI_f(edict_t *self)
{
if (!G_CheatCheck(self))
return;
if (!level.valid_poi)
return;
char visible_pvs = gi.inPVS(self->s.origin, level.current_poi, false) ? 'y' : 'n';
char visible_pvs_portals = gi.inPVS(self->s.origin, level.current_poi, true) ? 'y' : 'n';
char visible_phs = gi.inPHS(self->s.origin, level.current_poi, false) ? 'y' : 'n';
char visible_phs_portals = gi.inPHS(self->s.origin, level.current_poi, true) ? 'y' : 'n';
gi.Com_PrintFmt("pvs {} + portals {}, phs {} + portals {}\n", visible_pvs, visible_pvs_portals, visible_phs, visible_phs_portals);
}
// [Paril-KEX]
static void Cmd_Target_f(edict_t *ent)
{
if (!G_CheatCheck(ent))
return;
ent->target = gi.argv(1);
G_UseTargets(ent, ent);
ent->target = nullptr;
}
/*
==================
Cmd_God_f
Sets client to godmode
argv(0) god
==================
*/
void Cmd_God_f(edict_t *ent)
{
const char *msg;
if (!G_CheatCheck(ent))
return;
ent->flags ^= FL_GODMODE;
if (!(ent->flags & FL_GODMODE))
msg = "godmode OFF\n";
else
msg = "godmode ON\n";
gi.LocClient_Print(ent, PRINT_HIGH, msg);
}
void ED_ParseField(const char *key, const char *value, edict_t *ent);
/*
==================
Cmd_Immortal_f
Sets client to immortal - take damage but never go below 1 hp
argv(0) immortal
==================
*/
void Cmd_Immortal_f(edict_t *ent)
{
const char *msg;
if (!G_CheatCheck(ent))
return;
ent->flags ^= FL_IMMORTAL;
if (!(ent->flags & FL_IMMORTAL))
msg = "immortal OFF\n";
else
msg = "immortal ON\n";
gi.LocClient_Print(ent, PRINT_HIGH, msg);
}
/*
=================
Cmd_Spawn_f
Spawn class name
argv(0) spawn
argv(1) <classname>
argv(2+n) "key"...
argv(3+n) "value"...
=================
*/
void Cmd_Spawn_f(edict_t *ent)
{
if (!G_CheatCheck(ent))
return;
solid_t backup = ent->solid;
ent->solid = SOLID_NOT;
gi.linkentity(ent);
edict_t* other = G_Spawn();
other->classname = gi.argv(1);
other->s.origin = ent->s.origin + (AngleVectors(ent->s.angles).forward * 24.f);
other->s.angles[1] = ent->s.angles[1];
st = {};
if (gi.argc() > 3)
{
for (int i = 2; i < gi.argc(); i += 2)
ED_ParseField(gi.argv(i), gi.argv(i + 1), other);
}
ED_CallSpawn(other);
if (other->inuse)
{
vec3_t forward, end;
AngleVectors(ent->client->v_angle, forward, nullptr, nullptr);
end = ent->s.origin;
end[2] += ent->viewheight;
end += (forward * 8192);
trace_t tr = gi.traceline(ent->s.origin + vec3_t{0.f, 0.f, (float) ent->viewheight}, end, other, MASK_SHOT | CONTENTS_MONSTERCLIP);
other->s.origin = tr.endpos;
for (int32_t i = 0; i < 3; i++)
{
if (tr.plane.normal[i] > 0)
other->s.origin[i] -= other->mins[i] * tr.plane.normal[i];
else
other->s.origin[i] += other->maxs[i] * -tr.plane.normal[i];
}
while (gi.trace(other->s.origin, other->mins, other->maxs, other->s.origin, other,
MASK_SHOT | CONTENTS_MONSTERCLIP)
.startsolid)
{
float dx = other->mins[0] - other->maxs[0];
float dy = other->mins[1] - other->maxs[1];
other->s.origin += forward * -sqrtf(dx * dx + dy * dy);
if ((other->s.origin - ent->s.origin).dot(forward) < 0)
{
gi.Client_Print(ent, PRINT_HIGH, "Couldn't find a suitable spawn location\n");
G_FreeEdict(other);
break;
}
}
if (other->inuse)
gi.linkentity(other);
Update 1 changes
2023-10-03 18:43:06 +00:00
if ((other->svflags & SVF_MONSTER) && other->think)
Initial commit
2023-08-07 19:47:28 +00:00
other->think(other);
}
ent->solid = backup;
gi.linkentity(ent);
}
/*
=================
Cmd_Spawn_f
Telepo'
argv(0) teleport
argv(1) x
argv(2) y
argv(3) z
=================
*/
void Cmd_Teleport_f(edict_t *ent)
{
if (!G_CheatCheck(ent))
return;
if (gi.argc() < 4)
{
gi.LocClient_Print(ent, PRINT_HIGH, "Not enough args; teleport x y z\n");
return;
}
ent->s.origin[0] = (float) atof(gi.argv(1));
ent->s.origin[1] = (float) atof(gi.argv(2));
ent->s.origin[2] = (float) atof(gi.argv(3));
Update 1 changes
2023-10-03 18:43:06 +00:00
if (gi.argc() >= 4)
{
float pitch = (float) atof(gi.argv(4));
float yaw = (float) atof(gi.argv(5));
float roll = (float) atof(gi.argv(6));
vec3_t ang { pitch, yaw, roll };
ent->client->ps.pmove.delta_angles = ( ang - ent->client->resp.cmd_angles );
ent->client->ps.viewangles = {};
ent->client->v_angle = {};
}
Initial commit
2023-08-07 19:47:28 +00:00
gi.linkentity(ent);
}
/*
==================
Cmd_Notarget_f
Sets client to notarget
argv(0) notarget
==================
*/
void Cmd_Notarget_f(edict_t *ent)
{
const char *msg;
if (!G_CheatCheck(ent))
return;
ent->flags ^= FL_NOTARGET;
if (!(ent->flags & FL_NOTARGET))
msg = "notarget OFF\n";
else
msg = "notarget ON\n";
gi.LocClient_Print(ent, PRINT_HIGH, msg);
}
/*
==================
Cmd_Novisible_f
Sets client to "super notarget"
argv(0) notarget
==================
*/
void Cmd_Novisible_f(edict_t *ent)
{
const char *msg;
if (!G_CheatCheck(ent))
return;
ent->flags ^= FL_NOVISIBLE;
if (!(ent->flags & FL_NOVISIBLE))
msg = "novisible OFF\n";
else
msg = "novisible ON\n";
gi.LocClient_Print(ent, PRINT_HIGH, msg);
}
void Cmd_AlertAll_f(edict_t *ent)
{
if (!G_CheatCheck(ent))
return;
for (size_t i = 0; i < globals.num_edicts; i++)
{
edict_t *t = &g_edicts[i];
if (!t->inuse || t->health <= 0 || !(t->svflags & SVF_MONSTER))
continue;
t->enemy = ent;
FoundTarget(t);
}
}
/*
==================
Cmd_Noclip_f
argv(0) noclip
==================
*/
void Cmd_Noclip_f(edict_t *ent)
{
const char *msg;
if (!G_CheatCheck(ent))
return;
if (ent->movetype == MOVETYPE_NOCLIP)
{
ent->movetype = MOVETYPE_WALK;
msg = "noclip OFF\n";
}
else
{
ent->movetype = MOVETYPE_NOCLIP;
msg = "noclip ON\n";
}
gi.LocClient_Print(ent, PRINT_HIGH, msg);
}
/*
==================
Cmd_Use_f
Use an inventory item
==================
*/
void Cmd_Use_f(edict_t *ent)
{
item_id_t index;
gitem_t *it;
const char *s;
if (ent->health <= 0 || ent->deadflag)
return;
s = gi.args();
const char *cmd = gi.argv(0);
if (!Q_strcasecmp(cmd, "use_index") || !Q_strcasecmp(cmd, "use_index_only"))
{
it = GetItemByIndex((item_id_t) atoi(s));
}
else
{
it = FindItem(s);
}
if (!it)
{
gi.LocClient_Print(ent, PRINT_HIGH, "$g_unknown_item_name", s);
return;
}
if (!it->use)
{
gi.LocClient_Print(ent, PRINT_HIGH, "$g_item_not_usable");
return;
}
index = it->id;
// Paril: Use_Weapon handles weapon availability
if (!(it->flags & IF_WEAPON) && !ent->client->pers.inventory[index])
{
gi.LocClient_Print(ent, PRINT_HIGH, "$g_out_of_item", it->pickup_name);
return;
}
// allow weapon chains for use
ent->client->no_weapon_chains = !!strcmp(gi.argv(0), "use") && !!strcmp(gi.argv(0), "use_index");
it->use(ent, it);
ValidateSelectedItem(ent);
}
/*
==================
Cmd_Drop_f
Drop an inventory item
==================
*/
void Cmd_Drop_f(edict_t *ent)
{
item_id_t index;
gitem_t *it;
const char *s;
if (ent->health <= 0 || ent->deadflag)
return;
// ZOID--special case for tech powerups
Update 1 changes
2023-10-03 18:43:06 +00:00
if (Q_strcasecmp(gi.args(), "tech") == 0)
Initial commit
2023-08-07 19:47:28 +00:00
{
Update 1 changes
2023-10-03 18:43:06 +00:00
it = CTFWhat_Tech(ent);
if (it)
{
it->drop(ent, it);
ValidateSelectedItem(ent);
}
Initial commit
2023-08-07 19:47:28 +00:00
return;
}
// ZOID
s = gi.args();
const char *cmd = gi.argv(0);
if (!Q_strcasecmp(cmd, "drop_index"))
{
it = GetItemByIndex((item_id_t) atoi(s));
}
else
{
it = FindItem(s);
}
if (!it)
{
gi.LocClient_Print(ent, PRINT_HIGH, "Unknown item : {}\n", s);
return;
}
if (!it->drop)
{
gi.LocClient_Print(ent, PRINT_HIGH, "$g_item_not_droppable");
return;
}
index = it->id;
if (!ent->client->pers.inventory[index])
{
gi.LocClient_Print(ent, PRINT_HIGH, "$g_out_of_item", it->pickup_name);
return;
}
it->drop(ent, it);
ValidateSelectedItem(ent);
}
/*
=================
Cmd_Inven_f
=================
*/
void Cmd_Inven_f(edict_t *ent)
{
int i;
gclient_t *cl;
cl = ent->client;
cl->showscores = false;
cl->showhelp = false;
globals.server_flags &= ~SERVER_FLAG_SLOW_TIME;
// ZOID
if (ent->client->menu)
{
PMenu_Close(ent);
ent->client->update_chase = true;
return;
}
// ZOID
if (cl->showinventory)
{
cl->showinventory = false;
return;
}
// ZOID
if (G_TeamplayEnabled() && cl->resp.ctf_team == CTF_NOTEAM)
{
CTFOpenJoinMenu(ent);
return;
}
// ZOID
cl->showinventory = true;
gi.WriteByte(svc_inventory);
for (i = 0; i < IT_TOTAL; i++)
gi.WriteShort(cl->pers.inventory[i]);
for (; i < MAX_ITEMS; i++)
gi.WriteShort(0);
gi.unicast(ent, true);
}
/*
=================
Cmd_InvUse_f
=================
*/
void Cmd_InvUse_f(edict_t *ent)
{
gitem_t *it;
// ZOID
if (ent->client->menu)
{
PMenu_Select(ent);
return;
}
// ZOID
if (ent->health <= 0 || ent->deadflag)
return;
ValidateSelectedItem(ent);
if (ent->client->pers.selected_item == IT_NULL)
{
gi.LocClient_Print(ent, PRINT_HIGH, "$g_no_item_to_use");
return;
}
it = &itemlist[ent->client->pers.selected_item];
if (!it->use)
{
gi.LocClient_Print(ent, PRINT_HIGH, "$g_item_not_usable");
return;
}
// don't allow weapon chains for invuse
ent->client->no_weapon_chains = true;
it->use(ent, it);
ValidateSelectedItem(ent);
}
/*
=================
Cmd_WeapPrev_f
=================
*/
void Cmd_WeapPrev_f(edict_t *ent)
{
gclient_t *cl;
item_id_t i, index;
gitem_t *it;
item_id_t selected_weapon;
cl = ent->client;
if (ent->health <= 0 || ent->deadflag)
return;
if (!cl->pers.weapon)
return;
// don't allow weapon chains for weapprev
cl->no_weapon_chains = true;
selected_weapon = cl->pers.weapon->id;
// scan for the next valid one
for (i = static_cast<item_id_t>(IT_NULL + 1); i <= IT_TOTAL; i = static_cast<item_id_t>(i + 1))
{
// PMM - prevent scrolling through ALL weapons
index = static_cast<item_id_t>((selected_weapon + IT_TOTAL - i) % IT_TOTAL);
if (!cl->pers.inventory[index])
continue;
it = &itemlist[index];
if (!it->use)
continue;
if (!(it->flags & IF_WEAPON))
continue;
it->use(ent, it);
// ROGUE
if (cl->newweapon == it)
return; // successful
// ROGUE
}
}
/*
=================
Cmd_WeapNext_f
=================
*/
void Cmd_WeapNext_f(edict_t *ent)
{
gclient_t *cl;
item_id_t i, index;
gitem_t *it;
item_id_t selected_weapon;
cl = ent->client;
if (ent->health <= 0 || ent->deadflag)
return;
if (!cl->pers.weapon)
return;
// don't allow weapon chains for weapnext
cl->no_weapon_chains = true;
selected_weapon = cl->pers.weapon->id;
// scan for the next valid one
for (i = static_cast<item_id_t>(IT_NULL + 1); i <= IT_TOTAL; i = static_cast<item_id_t>(i + 1))
{
// PMM - prevent scrolling through ALL weapons
index = static_cast<item_id_t>((selected_weapon + i) % IT_TOTAL);
if (!cl->pers.inventory[index])
continue;
it = &itemlist[index];
if (!it->use)
continue;
if (!(it->flags & IF_WEAPON))
continue;
it->use(ent, it);
// PMM - prevent scrolling through ALL weapons
// ROGUE
if (cl->newweapon == it)
return;
// ROGUE
}
}
/*
=================
Cmd_WeapLast_f
=================
*/
void Cmd_WeapLast_f(edict_t *ent)
{
gclient_t *cl;
int index;
gitem_t *it;
cl = ent->client;
if (ent->health <= 0 || ent->deadflag)
return;
if (!cl->pers.weapon || !cl->pers.lastweapon)
return;
// don't allow weapon chains for weaplast
cl->no_weapon_chains = true;
index = cl->pers.lastweapon->id;
if (!cl->pers.inventory[index])
return;
it = &itemlist[index];
if (!it->use)
return;
if (!(it->flags & IF_WEAPON))
return;
it->use(ent, it);
}
/*
=================
Cmd_InvDrop_f
=================
*/
void Cmd_InvDrop_f(edict_t *ent)
{
gitem_t *it;
if (ent->health <= 0 || ent->deadflag)
return;
ValidateSelectedItem(ent);
if (ent->client->pers.selected_item == IT_NULL)
{
gi.LocClient_Print(ent, PRINT_HIGH, "$g_no_item_to_drop");
return;
}
it = &itemlist[ent->client->pers.selected_item];
if (!it->drop)
{
gi.LocClient_Print(ent, PRINT_HIGH, "$g_item_not_droppable");
return;
}
it->drop(ent, it);
ValidateSelectedItem(ent);
}
/*
=================
Cmd_Kill_f
=================
*/
void Cmd_Kill_f(edict_t *ent)
{
// ZOID
if (ent->client->resp.spectator)
return;
// ZOID
if ((level.time - ent->client->respawn_time) < 5_sec)
return;
ent->flags &= ~FL_GODMODE;
ent->health = 0;
// ROGUE
// make sure no trackers are still hurting us.
if (ent->client->tracker_pain_time)
RemoveAttackingPainDaemons(ent);
if (ent->client->owned_sphere)
{
G_FreeEdict(ent->client->owned_sphere);
ent->client->owned_sphere = nullptr;
}
// ROGUE
// [Paril-KEX] don't allow kill to take points away in TDM
player_die(ent, ent, ent, 100000, vec3_origin, { MOD_SUICIDE, !!teamplay->integer });
}
/*
=================
Cmd_Kill_AI_f
=================
*/
void Cmd_Kill_AI_f( edict_t * ent ) {
if ( !sv_cheats->integer ) {
gi.LocClient_Print( ent, PRINT_HIGH, "Kill_AI: Cheats Must Be Enabled!\n" );
return;
}
// except the one we're looking at...
edict_t *looked_at = nullptr;
vec3_t start = ent->s.origin + vec3_t{0.f, 0.f, (float) ent->viewheight};
vec3_t end = start + ent->client->v_forward * 1024.f;
looked_at = gi.traceline(start, end, ent, MASK_SHOT).ent;
const int numEdicts = globals.num_edicts;
for ( int edictIdx = 1; edictIdx < numEdicts; ++edictIdx )
{
edict_t * edict = &g_edicts[ edictIdx ];
if ( !edict->inuse || edict == looked_at ) {
continue;
}
if ( ( edict->svflags & SVF_MONSTER ) == 0 )
{
continue;
}
G_FreeEdict( edict );
}
gi.LocClient_Print( ent, PRINT_HIGH, "Kill_AI: All AI Are Dead...\n" );
}
/*
=================
Cmd_Where_f
=================
*/
void Cmd_Where_f( edict_t * ent ) {
if ( ent == nullptr || ent->client == nullptr ) {
return;
}
const vec3_t & origin = ent->s.origin;
std::string location;
Update 1 changes
2023-10-03 18:43:06 +00:00
fmt::format_to( std::back_inserter( location ), FMT_STRING( "{:.1f} {:.1f} {:.1f} {:.1f} {:.1f} {:.1f}\n" ), origin[ 0 ], origin[ 1 ], origin[ 2 ], ent->client->ps.viewangles[0], ent->client->ps.viewangles[1], ent->client->ps.viewangles[2] );
Initial commit
2023-08-07 19:47:28 +00:00
gi.LocClient_Print( ent, PRINT_HIGH, "Location: {}\n", location.c_str() );
gi.SendToClipBoard( location.c_str() );
}
/*
=================
Cmd_Clear_AI_Enemy_f
=================
*/
void Cmd_Clear_AI_Enemy_f( edict_t * ent ) {
if ( !sv_cheats->integer ) {
gi.LocClient_Print( ent, PRINT_HIGH, "Cmd_Clear_AI_Enemy: Cheats Must Be Enabled!\n" );
return;
}
const int numEdicts = globals.num_edicts;
for ( int edictIdx = 1; edictIdx < numEdicts; ++edictIdx ) {
edict_t * edict = &g_edicts[ edictIdx ];
if ( !edict->inuse ) {
continue;
}
if ( ( edict->svflags & SVF_MONSTER ) == 0 ) {
continue;
}
edict->monsterinfo.aiflags |= AI_FORGET_ENEMY;
}
gi.LocClient_Print( ent, PRINT_HIGH, "Cmd_Clear_AI_Enemy: Clear All AI Enemies...\n" );
}
/*
=================
Cmd_PutAway_f
=================
*/
void Cmd_PutAway_f(edict_t *ent)
{
ent->client->showscores = false;
ent->client->showhelp = false;
ent->client->showinventory = false;
globals.server_flags &= ~SERVER_FLAG_SLOW_TIME;
// ZOID
if (ent->client->menu)
PMenu_Close(ent);
ent->client->update_chase = true;
// ZOID
}
int PlayerSort(const void *a, const void *b)
{
int anum, bnum;
anum = *(const int *) a;
bnum = *(const int *) b;
anum = game.clients[anum].ps.stats[STAT_FRAGS];
bnum = game.clients[bnum].ps.stats[STAT_FRAGS];
if (anum < bnum)
return -1;
if (anum > bnum)
return 1;
return 0;
}
constexpr size_t MAX_IDEAL_PACKET_SIZE = 1024;
/*
=================
Cmd_Players_f
=================
*/
void Cmd_Players_f(edict_t *ent)
{
size_t i;
size_t count;
static std::string small, large;
int index[MAX_CLIENTS];
small.clear();
large.clear();
count = 0;
for (i = 0; i < game.maxclients; i++)
if (game.clients[i].pers.connected)
{
index[count] = i;
count++;
}
// sort by frags
qsort(index, count, sizeof(index[0]), PlayerSort);
// print information
large[0] = 0;
if (count)
{
for (i = 0; i < count; i++)
{
fmt::format_to(std::back_inserter(small), FMT_STRING("{:3} {}\n"), game.clients[index[i]].ps.stats[STAT_FRAGS],
game.clients[index[i]].pers.netname);
if (small.length() + large.length() > MAX_IDEAL_PACKET_SIZE - 50)
{ // can't print all of them in one packet
large += "...\n";
break;
}
large += small;
small.clear();
}
// remove the last newline
large.pop_back();
}
gi.LocClient_Print(ent, PRINT_HIGH | PRINT_NO_NOTIFY, "$g_players", large.c_str(), count);
}
bool CheckFlood(edict_t *ent)
{
int i;
gclient_t *cl;
if (flood_msgs->integer)
{
cl = ent->client;
if (level.time < cl->flood_locktill)
{
gi.LocClient_Print(ent, PRINT_HIGH, "$g_flood_cant_talk",
(cl->flood_locktill - level.time).seconds<int32_t>());
return true;
}
i = cl->flood_whenhead - flood_msgs->integer + 1;
if (i < 0)
i = (sizeof(cl->flood_when) / sizeof(cl->flood_when[0])) + i;
if (i >= q_countof(cl->flood_when))
i = 0;
if (cl->flood_when[i] && level.time - cl->flood_when[i] < gtime_t::from_sec(flood_persecond->value))
{
cl->flood_locktill = level.time + gtime_t::from_sec(flood_waitdelay->value);
gi.LocClient_Print(ent, PRINT_CHAT, "$g_flood_cant_talk",
flood_waitdelay->integer);
return true;
}
cl->flood_whenhead = (cl->flood_whenhead + 1) % (sizeof(cl->flood_when) / sizeof(cl->flood_when[0]));
cl->flood_when[cl->flood_whenhead] = level.time;
}
return false;
}
/*
=================
Cmd_Wave_f
=================
*/
void Cmd_Wave_f(edict_t *ent)
{
int i;
i = atoi(gi.argv(1));
// no dead or noclip waving
if (ent->deadflag || ent->movetype == MOVETYPE_NOCLIP)
return;
// can't wave when ducked
bool do_animate = ent->client->anim_priority <= ANIM_WAVE && !(ent->client->ps.pmove.pm_flags & PMF_DUCKED);
if (do_animate)
ent->client->anim_priority = ANIM_WAVE;
Update 1 changes
2023-10-03 18:43:06 +00:00
const char *other_notify_msg = nullptr, *other_notify_none_msg = nullptr;
Initial commit
2023-08-07 19:47:28 +00:00
vec3_t start, dir;
P_ProjectSource(ent, ent->client->v_angle, { 0, 0, 0 }, start, dir);
// see who we're aiming at
edict_t *aiming_at = nullptr;
float best_dist = -9999;
for (auto player : active_players())
{
if (player == ent)
continue;
vec3_t cdir = player->s.origin - start;
float dist = cdir.normalize();
float dot = ent->client->v_forward.dot(cdir);
if (dot < 0.97)
continue;
else if (dist < best_dist)
continue;
best_dist = dist;
aiming_at = player;
}
switch (i)
{
case GESTURE_FLIP_OFF:
other_notify_msg = "$g_flipoff_other";
other_notify_none_msg = "$g_flipoff_none";
if (do_animate)
{
ent->s.frame = FRAME_flip01 - 1;
ent->client->anim_end = FRAME_flip12;
}
break;
case GESTURE_SALUTE:
other_notify_msg = "$g_salute_other";
other_notify_none_msg = "$g_salute_none";
if (do_animate)
{
ent->s.frame = FRAME_salute01 - 1;
ent->client->anim_end = FRAME_salute11;
}
break;
case GESTURE_TAUNT:
other_notify_msg = "$g_taunt_other";
other_notify_none_msg = "$g_taunt_none";
if (do_animate)
{
ent->s.frame = FRAME_taunt01 - 1;
ent->client->anim_end = FRAME_taunt17;
}
break;
case GESTURE_WAVE:
other_notify_msg = "$g_wave_other";
other_notify_none_msg = "$g_wave_none";
if (do_animate)
{
ent->s.frame = FRAME_wave01 - 1;
ent->client->anim_end = FRAME_wave11;
}
break;
case GESTURE_POINT:
default:
other_notify_msg = "$g_point_other";
other_notify_none_msg = "$g_point_none";
if (do_animate)
{
ent->s.frame = FRAME_point01 - 1;
ent->client->anim_end = FRAME_point12;
}
break;
}
bool has_a_target = false;
if (i == GESTURE_POINT)
{
for (auto player : active_players())
{
if (player == ent)
continue;
else if (!OnSameTeam(ent, player))
continue;
has_a_target = true;
break;
}
}
if (i == GESTURE_POINT && has_a_target)
{
// don't do this stuff if we're flooding
if (CheckFlood(ent))
return;
trace_t tr = gi.traceline(start, start + (ent->client->v_forward * 2048), ent, MASK_SHOT & ~CONTENTS_WINDOW);
other_notify_msg = "$g_point_other_ping";
uint32_t key = GetUnicastKey();
if (tr.fraction != 1.0f)
{
// send to all teammates
for (auto player : active_players())
{
if (player != ent && !OnSameTeam(ent, player))
continue;
gi.WriteByte(svc_poi);
gi.WriteShort(POI_PING + (ent->s.number - 1));
gi.WriteShort(5000);
gi.WritePosition(tr.endpos);
Update 1 changes
2023-10-03 18:43:06 +00:00
gi.WriteShort(level.pic_ping);
Initial commit
2023-08-07 19:47:28 +00:00
gi.WriteByte(208);
gi.WriteByte(POI_FLAG_NONE);
gi.unicast(player, false);
gi.local_sound(player, CHAN_AUTO, gi.soundindex("misc/help_marker.wav"), 1.0f, ATTN_NONE, 0.0f, key);
gi.LocClient_Print(player, PRINT_HIGH, other_notify_msg, ent->client->pers.netname);
}
}
}
else
{
if (CheckFlood(ent))
return;
edict_t* targ = nullptr;
while ((targ = findradius(targ, ent->s.origin, 1024)) != nullptr)
{
if (ent == targ) continue;
if (!targ->client) continue;
if (!gi.inPVS(ent->s.origin, targ->s.origin, false)) continue;
if (aiming_at && other_notify_msg)
gi.LocClient_Print(targ, PRINT_TTS, other_notify_msg, ent->client->pers.netname, aiming_at->client->pers.netname);
else if (other_notify_none_msg)
gi.LocClient_Print(targ, PRINT_TTS, other_notify_none_msg, ent->client->pers.netname);
}
if (aiming_at && other_notify_msg)
gi.LocClient_Print(ent, PRINT_TTS, other_notify_msg, ent->client->pers.netname, aiming_at->client->pers.netname);
else if (other_notify_none_msg)
gi.LocClient_Print(ent, PRINT_TTS, other_notify_none_msg, ent->client->pers.netname);
}
ent->client->anim_time = 0_ms;
}
#ifndef KEX_Q2_GAME
/*
==================
Cmd_Say_f
NB: only used for non-Playfab stuff
==================
*/
void Cmd_Say_f(edict_t *ent, bool arg0)
{
edict_t *other;
const char *p_in;
static std::string text;
if (gi.argc() < 2 && !arg0)
return;
else if (CheckFlood(ent))
return;
text.clear();
fmt::format_to(std::back_inserter(text), FMT_STRING("{}: "), ent->client->pers.netname);
if (arg0)
{
text += gi.argv(0);
text += " ";
text += gi.args();
}
else
{
p_in = gi.args();
size_t in_len = strlen(p_in);
if (p_in[0] == '\"' && p_in[in_len - 1] == '\"')
text += std::string_view(p_in + 1, in_len - 2);
else
text += p_in;
}
// don't let text be too long for malicious reasons
if (text.length() > 150)
text.resize(150);
if (text.back() != '\n')
text.push_back('\n');
if (sv_dedicated->integer)
gi.Client_Print(nullptr, PRINT_CHAT, text.c_str());
for (uint32_t j = 1; j <= game.maxclients; j++)
{
other = &g_edicts[j];
if (!other->inuse)
continue;
if (!other->client)
continue;
gi.Client_Print(other, PRINT_CHAT, text.c_str());
}
}
#endif
void Cmd_PlayerList_f(edict_t *ent)
{
uint32_t i;
static std::string str, text;
edict_t *e2;
str.clear();
text.clear();
// connect time, ping, score, name
for (i = 0, e2 = g_edicts + 1; i < game.maxclients; i++, e2++)
{
if (!e2->inuse)
continue;
fmt::format_to(std::back_inserter(str), FMT_STRING("{:02}:{:02} {:4} {:3} {}{}\n"), (level.time - e2->client->resp.entertime).milliseconds() / 60000,
((level.time - e2->client->resp.entertime).milliseconds() % 60000) / 1000, e2->client->ping,
e2->client->resp.score, e2->client->pers.netname, e2->client->resp.spectator ? " (spectator)" : "");
if (text.length() + str.length() > MAX_IDEAL_PACKET_SIZE - 50)
{
text += "...\n";
break;
}
text += str;
}
if (text.length())
gi.Client_Print(ent, PRINT_HIGH, text.c_str());
}
void Cmd_Switchteam_f(edict_t* ent)
{
if (!G_TeamplayEnabled())
return;
// [Paril-KEX] in force-join, just do a regular team join.
if (g_teamplay_force_join->integer)
{
// check if we should even switch teams
edict_t *player;
uint32_t team1count = 0, team2count = 0;
ctfteam_t best_team;
for (uint32_t i = 1; i <= game.maxclients; i++)
{
player = &g_edicts[i];
// NB: we are counting ourselves in this one, unlike
// the other assign team func
if (!player->inuse)
continue;
switch (player->client->resp.ctf_team)
{
case CTF_TEAM1:
team1count++;
break;
case CTF_TEAM2:
team2count++;
break;
default:
break;
}
}
if (team1count < team2count)
best_team = CTF_TEAM1;
else
best_team = CTF_TEAM2;
if (ent->client->resp.ctf_team != best_team)
{
////
ent->svflags = SVF_NONE;
ent->flags &= ~FL_GODMODE;
ent->client->resp.ctf_team = best_team;
ent->client->resp.ctf_state = 0;
char value[MAX_INFO_VALUE] = { 0 };
gi.Info_ValueForKey(ent->client->pers.userinfo, "skin", value, sizeof(value));
CTFAssignSkin(ent, value);
// if anybody has a menu open, update it immediately
CTFDirtyTeamMenu();
if (ent->solid == SOLID_NOT)
{
// spectator
PutClientInServer(ent);
G_PostRespawn(ent);
gi.LocBroadcast_Print(PRINT_HIGH, "$g_joined_team",
ent->client->pers.netname, CTFTeamName(best_team));
return;
}
ent->health = 0;
player_die(ent, ent, ent, 100000, vec3_origin, { MOD_SUICIDE, true });
// don't even bother waiting for death frames
ent->deadflag = true;
respawn(ent);
ent->client->resp.score = 0;
gi.LocBroadcast_Print(PRINT_HIGH, "$g_changed_team",
ent->client->pers.netname, CTFTeamName(best_team));
}
return;
}
if (ent->client->resp.ctf_team != CTF_NOTEAM)
CTFObserver(ent);
if (!ent->client->menu)
CTFOpenJoinMenu(ent);
}
static void Cmd_ListMonsters_f(edict_t *ent)
{
if (!G_CheatCheck(ent))
return;
else if (!g_debug_monster_kills->integer)
return;
for (size_t i = 0; i < level.total_monsters; i++)
{
edict_t *e = level.monsters_registered[i];
if (!e || !e->inuse)
continue;
else if (!(e->svflags & SVF_MONSTER) || (e->monsterinfo.aiflags & AI_DO_NOT_COUNT))
continue;
else if (e->deadflag)
continue;
gi.Com_PrintFmt("{}\n", *e);
}
}
/*
=================
ClientCommand
=================
*/
void ClientCommand(edict_t *ent)
{
const char *cmd;
if (!ent->client)
return; // not fully in game yet
cmd = gi.argv(0);
if (Q_strcasecmp(cmd, "players") == 0)
{
Cmd_Players_f(ent);
return;
}
// [Paril-KEX] these have to go through the lobby system
#ifndef KEX_Q2_GAME
if (Q_strcasecmp(cmd, "say") == 0)
{
Cmd_Say_f(ent, false);
return;
}
if (Q_strcasecmp(cmd, "say_team") == 0 || Q_strcasecmp(cmd, "steam") == 0)
{
if (G_TeamplayEnabled())
CTFSay_Team(ent, gi.args());
else
Cmd_Say_f(ent, false);
return;
}
#endif
if (Q_strcasecmp(cmd, "score") == 0)
{
Cmd_Score_f(ent);
return;
}
if (Q_strcasecmp(cmd, "help") == 0)
{
Cmd_Help_f(ent);
return;
}
if (Q_strcasecmp(cmd, "listmonsters") == 0)
{
Cmd_ListMonsters_f(ent);
return;
}
if (level.intermissiontime)
return;
if ( Q_strcasecmp( cmd, "target" ) == 0 )
Cmd_Target_f( ent );
else if ( Q_strcasecmp( cmd, "use" ) == 0 || Q_strcasecmp( cmd, "use_only" ) == 0 ||
Q_strcasecmp( cmd, "use_index" ) == 0 || Q_strcasecmp( cmd, "use_index_only" ) == 0 )
Cmd_Use_f( ent );
else if ( Q_strcasecmp( cmd, "drop" ) == 0 ||
Q_strcasecmp( cmd, "drop_index" ) == 0 )
Cmd_Drop_f( ent );
else if ( Q_strcasecmp( cmd, "give" ) == 0 )
Cmd_Give_f( ent );
else if ( Q_strcasecmp( cmd, "god" ) == 0 )
Cmd_God_f( ent );
else if (Q_strcasecmp(cmd, "immortal") == 0)
Cmd_Immortal_f(ent);
else if ( Q_strcasecmp( cmd, "setpoi" ) == 0 )
Cmd_SetPOI_f( ent );
else if ( Q_strcasecmp( cmd, "checkpoi" ) == 0 )
Cmd_CheckPOI_f( ent );
// Paril: cheats to help with dev
else if ( Q_strcasecmp( cmd, "spawn" ) == 0 )
Cmd_Spawn_f( ent );
else if ( Q_strcasecmp( cmd, "teleport" ) == 0 )
Cmd_Teleport_f( ent );
else if ( Q_strcasecmp( cmd, "notarget" ) == 0 )
Cmd_Notarget_f( ent );
else if ( Q_strcasecmp( cmd, "novisible" ) == 0 )
Cmd_Novisible_f( ent );
else if ( Q_strcasecmp( cmd, "alertall" ) == 0 )
Cmd_AlertAll_f( ent );
else if ( Q_strcasecmp( cmd, "noclip" ) == 0 )
Cmd_Noclip_f( ent );
else if ( Q_strcasecmp( cmd, "inven" ) == 0 )
Cmd_Inven_f( ent );
else if ( Q_strcasecmp( cmd, "invnext" ) == 0 )
SelectNextItem( ent, IF_ANY );
else if ( Q_strcasecmp( cmd, "invprev" ) == 0 )
SelectPrevItem( ent, IF_ANY );
else if ( Q_strcasecmp( cmd, "invnextw" ) == 0 )
SelectNextItem( ent, IF_WEAPON );
else if ( Q_strcasecmp( cmd, "invprevw" ) == 0 )
SelectPrevItem( ent, IF_WEAPON );
else if ( Q_strcasecmp( cmd, "invnextp" ) == 0 )
SelectNextItem( ent, IF_POWERUP );
else if ( Q_strcasecmp( cmd, "invprevp" ) == 0 )
SelectPrevItem( ent, IF_POWERUP );
else if ( Q_strcasecmp( cmd, "invuse" ) == 0 )
Cmd_InvUse_f( ent );
else if ( Q_strcasecmp( cmd, "invdrop" ) == 0 )
Cmd_InvDrop_f( ent );
else if ( Q_strcasecmp( cmd, "weapprev" ) == 0 )
Cmd_WeapPrev_f( ent );
else if ( Q_strcasecmp( cmd, "weapnext" ) == 0 )
Cmd_WeapNext_f( ent );
else if ( Q_strcasecmp( cmd, "weaplast" ) == 0 || Q_strcasecmp( cmd, "lastweap" ) == 0 )
Cmd_WeapLast_f( ent );
else if ( Q_strcasecmp( cmd, "kill" ) == 0 )
Cmd_Kill_f( ent );
else if ( Q_strcasecmp( cmd, "kill_ai" ) == 0 )
Cmd_Kill_AI_f( ent );
else if ( Q_strcasecmp( cmd, "where" ) == 0 )
Cmd_Where_f( ent );
else if ( Q_strcasecmp( cmd, "clear_ai_enemy" ) == 0 )
Cmd_Clear_AI_Enemy_f( ent );
else if (Q_strcasecmp(cmd, "putaway") == 0)
Cmd_PutAway_f(ent);
else if (Q_strcasecmp(cmd, "wave") == 0)
Cmd_Wave_f(ent);
else if (Q_strcasecmp(cmd, "playerlist") == 0)
Cmd_PlayerList_f(ent);
// ZOID
else if (Q_strcasecmp(cmd, "team") == 0)
CTFTeam_f(ent);
else if (Q_strcasecmp(cmd, "id") == 0)
CTFID_f(ent);
else if (Q_strcasecmp(cmd, "yes") == 0)
CTFVoteYes(ent);
else if (Q_strcasecmp(cmd, "no") == 0)
CTFVoteNo(ent);
else if (Q_strcasecmp(cmd, "ready") == 0)
CTFReady(ent);
else if (Q_strcasecmp(cmd, "notready") == 0)
CTFNotReady(ent);
else if (Q_strcasecmp(cmd, "ghost") == 0)
CTFGhost(ent);
else if (Q_strcasecmp(cmd, "admin") == 0)
CTFAdmin(ent);
else if (Q_strcasecmp(cmd, "stats") == 0)
CTFStats(ent);
else if (Q_strcasecmp(cmd, "warp") == 0)
CTFWarp(ent);
else if (Q_strcasecmp(cmd, "boot") == 0)
CTFBoot(ent);
else if (Q_strcasecmp(cmd, "playerlist") == 0)
CTFPlayerList(ent);
else if (Q_strcasecmp(cmd, "observer") == 0)
CTFObserver(ent);
// ZOID
else if (Q_strcasecmp(cmd, "switchteam") == 0)
Cmd_Switchteam_f(ent);
#ifndef KEX_Q2_GAME
else // anything that doesn't match a command will be a chat
Cmd_Say_f(ent, true);
#else
// anything that doesn't match a command will inform them
else
gi.LocClient_Print(ent, PRINT_HIGH, "invalid game command \"{}\"\n", gi.argv(0));
#endif
}
Reference in a new issue Copy permalink