jackz/sourcemod-plugins
1
0
Fork 0
mirror of https://github.com/Jackzmc/sourcemod-plugins.git synced 2025-05-05 16:43:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
sourcemod-plugins/scripting/include/hats/hats.sp
Jackz 79d37bdd34 Updates
2024-07-13 21:27:08 -05:00

846 lines
31 KiB
SourcePawn
Raw Blame History

enum hatFlags {
HAT_NONE = 0,
HAT_POCKET = 1,
HAT_REVERSED = 2,
HAT_COMMANDABLE = 4,
HAT_RAINBOW = 8,
HAT_PRESET = 16
}
enum struct HatInstance {
int entity; // The entity REFERENCE
int visibleEntity; // Thee visible entity REF
Handle yeetGroundTimer;
// Original data for entity
float orgPos[3];
float orgAng[3];
float offset[3];
float angles[3];
int collisionGroup;
int solidType;
int moveType;
float scale;
int flags;
float rainbowColor[3];
int rainbowTicks;
bool rainbowReverse;
char attachPoint[32];
}
enum hatFeatures {
HatConfig_None = 0,
HatConfig_PlayerHats = 1,
HatConfig_RespectAdminImmunity = 2,
HatConfig_FakeHat = 4,
HatConfig_NoSaferoomHats = 8,
HatConfig_PlayerHatConsent = 16,
HatConfig_InfectedHats = 32,
HatConfig_ReversedHats = 64,
HatConfig_DeleteThrownHats = 128
}
char ActivePreset[MAXPLAYERS+1][32];
int lastHatRequestTime[MAXPLAYERS+1];
HatInstance hatData[MAXPLAYERS+1];
StringMap g_HatPresets;
#define MAX_FORBIDDEN_CLASSNAMES 15
char FORBIDDEN_CLASSNAMES[MAX_FORBIDDEN_CLASSNAMES][] = {
"prop_door_rotating_checkpoint",
"env_physics_blocker",
"env_player_blocker",
"func_brush",
"func_simpleladder",
"prop_door_rotating",
"func_button",
"func_elevator",
"func_button_timed",
"func_tracktrain",
"func_movelinear",
// "infected",
"func_lod",
"func_door",
"prop_ragdoll",
"move_rope"
};
#define MAX_FORBIDDEN_MODELS 2
char FORBIDDEN_MODELS[MAX_FORBIDDEN_MODELS][] = {
"models/props_vehicles/c130.mdl",
"models/props_vehicles/helicopter_rescue.mdl"
};
#define MAX_REVERSE_CLASSNAMES 2
// Classnames that should automatically trigger reverse infected
static char REVERSE_CLASSNAMES[MAX_REVERSE_CLASSNAMES][] = {
"infected",
"func_movelinear",
};
Action Command_DoAHat(int client, int args) {
int hatter = GetHatter(client);
if(hatter > 0) {
ClearHat(hatter, HasFlag(hatter, HAT_REVERSED));
PrintToChat(hatter, "[Hats] %N has unhatted themselves", client);
return Plugin_Handled;
}
static char cmdName[8];
GetCmdArg(0, cmdName, sizeof(cmdName));
AdminId adminId = GetUserAdmin(client);
bool isForced = adminId != INVALID_ADMIN_ID && StrEqual(cmdName, "sm_hatf");
if(cvar_sm_hats_enabled.IntValue == 1) {
if(adminId == INVALID_ADMIN_ID) {
PrintToChat(client, "[Hats] Hats are for admins only");
return Plugin_Handled;
} else if(!adminId.HasFlag(Admin_Custom2)) {
PrintToChat(client, "[Hats] You do not have permission");
return Plugin_Handled;
}
} else if(cvar_sm_hats_enabled.IntValue == 0) {
ReplyToCommand(client, "[Hats] Hats are disabled");
return Plugin_Handled;
} else if(GetClientTeam(client) != 2 && ~cvar_sm_hats_flags.IntValue & view_as<int>(HatConfig_InfectedHats)) {
PrintToChat(client, "[Hats] Hats are only available for survivors.");
return Plugin_Handled;
}
int entity = GetHat(client);
if(entity > 0) {
if(HasFlag(client, HAT_PRESET)) {
PrintToChat(client, "[Hats] Your hat is a preset, use /hatp to remove it.");
return Plugin_Handled;
}
char arg[4];
GetCmdArg(1, arg, sizeof(arg));
if(arg[0] == 'e') {
ReplyToCommand(client, "\t\t\"origin\"\t\"%f %f %f\"", hatData[client].offset[0], hatData[client].offset[1], hatData[client].offset[2]);
ReplyToCommand(client, "\t\t\"angles\"\t\"%f %f %f\"", hatData[client].angles[0], hatData[client].angles[1], hatData[client].angles[2]);
return Plugin_Handled;
} else if(arg[0] == 'v') {
ReplyToCommand(client, "Flags: %d", hatData[client].flags);
// ReplyToCommand(client, "CurOffset: %f %f %f", );
return Plugin_Handled;
} else if(arg[0] == 'a') {
ShowAttachPointMenu(client);
return Plugin_Handled;
}
// int orgEntity = entity;
if(HasFlag(client, HAT_REVERSED)) {
entity = client;
}
ClearParent(entity);
if(arg[0] == 's') {
char sizeStr[4];
GetCmdArg(2, sizeStr, sizeof(sizeStr));
float size = StringToFloat(sizeStr);
if(size == 0.0) {
ReplyToCommand(client, "[Hats] Invalid size");
return Plugin_Handled;
}
if(HasEntProp(entity, Prop_Send, "m_flModelScale"))
SetEntPropFloat(entity, Prop_Send, "m_flModelScale", size);
else
PrintHintText(client, "Hat does not support scaling");
// Change the size of it's parent instead
int child = -1;
while((child = FindEntityByClassname(child, "*")) != INVALID_ENT_REFERENCE )
{
int parent = GetEntPropEnt(child, Prop_Data, "m_pParent");
if(parent == entity) {
if(HasEntProp(child, Prop_Send, "m_flModelScale")) {
PrintToConsole(client, "found child %d for %d", child, entity);
SetEntPropFloat(child, Prop_Send, "m_flModelScale", size);
} else {
PrintToChat(client, "Child %d for %d cannot be scaled", child, entity);
}
break;
}
}
// Reattach entity:
EquipHat(client, entity);
return Plugin_Handled;
} else if(arg[0] == 'r' && arg[1] == 'a') {
SetFlag(client, HAT_RAINBOW);
hatData[client].rainbowTicks = 0;
hatData[client].rainbowReverse = false;
hatData[client].rainbowColor[0] = 0.0;
hatData[client].rainbowColor[1] = 255.0;
hatData[client].rainbowColor[2] = 255.0;
EquipHat(client, entity);
ReplyToCommand(client, "Rainbow hats enabled");
return Plugin_Handled;
}
// Re-enable physics and restore collision/solidity
AcceptEntityInput(entity, "EnableMotion");
SetEntProp(entity, Prop_Send, "m_CollisionGroup", hatData[client].collisionGroup);
SetEntProp(entity, Prop_Send, "m_nSolidType", hatData[client].solidType);
// Remove frozen flag (only "infected" and "witch" are frozen, but just incase:)
int flags = GetEntityFlags(entity) & ~FL_FROZEN;
SetEntityFlags(entity, flags);
// Clear visible hats (HatConfig_FakeHat is enabled)
int visibleEntity = EntRefToEntIndex(hatData[client].visibleEntity);
SDKUnhook(entity, SDKHook_SetTransmit, OnRealTransmit);
if(visibleEntity > 0) {
SDKUnhook(visibleEntity, SDKHook_SetTransmit, OnVisibleTransmit);
RemoveEntity(visibleEntity);
hatData[client].visibleEntity = INVALID_ENT_REFERENCE;
}
// Grant temp god & remove after time
tempGod[client] = true;
if(client <= MaxClients) {
SDKHook(client, SDKHook_OnTakeDamageAlive, OnTakeDamageAlive);
CreateTimer(2.0, Timer_RemoveGod, GetClientUserId(client));
}
if(entity <= MaxClients) {
SDKHook(entity, SDKHook_OnTakeDamageAlive, OnTakeDamageAlive);
CreateTimer(2.0, Timer_RemoveGod, GetClientUserId(entity));
}
// Restore movement:
if(entity <= MaxClients) {
// If player, remove roll & and just default to WALK movetype
hatData[client].orgAng[2] = 0.0;
SetEntityMoveType(entity, MOVETYPE_WALK);
} else {
// If not player, then just use whatever they were pre-hat
SetEntProp(entity, Prop_Send, "movetype", hatData[client].moveType);
}
if(arg[0] == 'y') { // Hat yeeting:
char classname[16];
GetEntityClassname(entity, classname, sizeof(classname));
if(StrEqual(classname, "prop_dynamic")) {
ReplyToCommand(client, "You cannot yeet this prop (it has no physics)");
return Plugin_Handled;
}
GetClientEyeAngles(client, hatData[client].orgAng);
GetClientAbsOrigin(client, hatData[client].orgPos);
hatData[client].orgPos[2] += 45.0;
float ang[3], vel[3];
// Calculate the angle to throw at
GetClientEyeAngles(client, ang);
ang[2] = 0.0;
if(ang[0] > 0.0) ang[0] = -ang[0];
// ang[0] = -45.0;
// Calculate velocity to throw based on direction
vel[0] = Cosine(DegToRad(ang[1])) * GetRandomFloat(1300.0, 1700.0);
vel[1] = Sine(DegToRad(ang[1])) * GetRandomFloat(1300.0, 1700.0);
vel[2] = GetRandomFloat(700.0, 900.0);
if(entity <= MaxClients) {
// For players, use the built in fling function
TeleportEntity(entity, hatData[client].orgPos, hatData[client].orgAng, NULL_VECTOR);
L4D2_CTerrorPlayer_Fling(entity, client, vel);
} /*else if(visibleEntity > 0) {
PrintToChat(client, "Yeeting fake car...");
ClearParent(visibleEntity);
SetEntProp(visibleEntity, Prop_Send, "movetype", 6);
AcceptEntityInput(visibleEntity, "EnableMotion");
TeleportEntity(entity, OUT_OF_BOUNDS, hatData[client].orgAng, NULL_VECTOR);
TeleportEntity(visibleEntity, hatData[client].orgPos, hatData[client].orgAng, vel);
DataPack pack;
CreateDataTimer(4.0, Timer_PropYeetEnd, pack);
pack.WriteCell(hatData[client].entity);
pack.WriteCell(hatData[client].visibleEntity);
pack.WriteCell(hatData[client].collisionGroup);
pack.WriteCell(hatData[client].solidType);
pack.WriteCell(hatData[client].moveType);
hatData[client].visibleEntity = INVALID_ENT_REFERENCE;
hatData[client].entity = INVALID_ENT_REFERENCE;
} */ else {
// For actual props, offset it 35 units above and 80 units infront to reduce collision-incaps and then throw
GetHorizontalPositionFromClient(client, 80.0, hatData[client].orgPos);
hatData[client].orgPos[2] += 35.0;
TeleportEntity(entity, hatData[client].orgPos, hatData[client].orgAng, vel);
// Sleep the physics after enoug time for it to most likely have landed
if(hatData[client].yeetGroundTimer != null) {
// TODO: FIX null issue
delete hatData[client].yeetGroundTimer;
}
DataPack pack1;
hatData[client].yeetGroundTimer = CreateDataTimer(0.5, Timer_GroundKill, pack1, TIMER_REPEAT | TIMER_FLAG_NO_MAPCHANGE);
pack1.WriteCell(hatData[client].entity);
pack1.WriteCell(GetClientUserId(client));
DataPack pack2;
CreateDataTimer(7.7, Timer_PropSleep, pack2);
pack2.WriteCell(hatData[client].entity);
pack2.WriteCell(GetClientUserId(client));
}
PrintToChat(client, "[Hats] Yeeted hat");
hatData[client].entity = INVALID_ENT_REFERENCE;
return Plugin_Handled;
} else if(arg[0] == 'c') {
float pos[3];
// Grabs a cursor position with some checks to prevent placing into (in)visible walls
if(GetSmartCursorLocation(client, pos)) {
if(CanHatBePlaced(client, pos)) {
if(entity <= MaxClients)
L4D_WarpToValidPositionIfStuck(entity);
hatData[client].orgPos = pos;
TeleportEntity(entity, hatData[client].orgPos, hatData[client].orgAng, NULL_VECTOR);
PrintToChat(client, "[Hats] Placed hat on cursor.");
}
} else {
PrintToChat(client, "[Hats] Could not find cursor position.");
}
} else if(arg[0] == 'p' || (entity <= MaxClients && arg[0] != 'r')) {
// Place the hat down on the cursor if specified OR if entity is hat
float pos[3], ang[3];
if(HasFlag(client, HAT_REVERSED)) {
// If we are reversed, then place ourselves where our "hatter" is
GetClientEyePosition(entity, hatData[client].orgPos);
GetClientEyeAngles(entity, hatData[client].orgAng);
TeleportEntity(client, hatData[client].orgPos, hatData[client].orgAng, NULL_VECTOR);
PrintToChat(entity, "[Hats] Placed hat in front of you.");
} else {
// If we are normal, then get position infront of us, offset by model size
GetClientEyePosition(client, pos);
GetClientEyeAngles(client, ang);
GetHorizontalPositionFromOrigin(pos, ang, 80.0, pos);
ang[0] = 0.0;
float mins[3];
GetEntPropVector(entity, Prop_Data, "m_vecMins", mins);
pos[2] += mins[2];
// Find the nearest ground (raytrace bottom->up)
FindGround(pos, pos);
// Check if the destination is acceptable (not saferooms if enabled)
if(CanHatBePlaced(client, pos)) {
hatData[client].orgPos = pos;
hatData[client].orgAng = ang;
TeleportEntity(entity, hatData[client].orgPos, hatData[client].orgAng, NULL_VECTOR);
PrintToChat(client, "[Hats] Placed hat in front of you.");
}
}
} else if(arg[0] == 'd') {
// Use the new wall editor
Editor[client].Reset();
Editor[client].entity = EntIndexToEntRef(entity);
Editor[client].SetMode(MOVE_ORIGIN);
PrintToChat(client, "\x04[Hats] \x01Beta Prop Mover active for \x04%d", entity);
} else {
PrintToChat(client, "[Hats] Restored hat to its original position.");
}
// Restore the scale pre-hat
if(hatData[client].scale > 0 && HasEntProp(entity, Prop_Send, "m_flModelScale"))
SetEntPropFloat(entity, Prop_Send, "m_flModelScale", hatData[client].scale);
// If no other options performed, then restore to original position and remove our reference
AcceptEntityInput(entity, "Sleep");
TeleportEntity(entity, hatData[client].orgPos, hatData[client].orgAng, NULL_VECTOR);
hatData[client].entity = INVALID_ENT_REFERENCE;
} else {
// Find a new hatable entity
int flags = 0;
entity = GetLookingEntity(client, Filter_ValidHats);
if(entity <= 0) {
PrintCenterText(client, "[Hats] No entity found");
return Plugin_Handled;
} else if(entity == EntRefToEntIndex(Editor[client].entity)) {
// Prevent making an entity you editing a hat
return Plugin_Handled;
} else if(!isForced && cvar_sm_hats_max_distance.FloatValue > 0.0 && entity >= MaxClients) {
float posP[3], posE[3];
GetClientEyePosition(client, posP);
GetEntPropVector(entity, Prop_Data, "m_vecOrigin", posE);
if(GetVectorDistance(posP, posE) > cvar_sm_hats_max_distance.FloatValue) {
PrintCenterText(client, "[Hats] Entity too far away");
return Plugin_Handled;
}
}
// Make hat reversed if 'r' passed in
char arg[4];
if(args > 0) {
GetCmdArg(1, arg, sizeof(arg));
if(arg[0] == 'r') {
flags |= view_as<int>(HAT_REVERSED);
}
}
int parent = GetEntPropEnt(entity, Prop_Data, "m_hParent");
if(parent > 0 && entity > MaxClients) {
PrintToConsole(client, "[Hats] Selected a child entity, selecting parent (child %d -> parent %d)", entity, parent);
entity = parent;
} else if(entity <= MaxClients) { // Checks for hatting a player entity
if(IsFakeClient(entity) && L4D_GetIdlePlayerOfBot(entity) > 0) {
PrintToChat(client, "[Hats] Cannot hat idle bots");
return Plugin_Handled;
} else if(!isForced && GetClientTeam(entity) != 2 && ~cvar_sm_hats_flags.IntValue & view_as<int>(HatConfig_InfectedHats)) {
PrintToChat(client, "[Hats] Cannot make enemy a hat... it's dangerous");
return Plugin_Handled;
} else if(entity == EntRefToEntIndex(Editor[client].entity)) {
// Old check left in in case you hatting child entity
PrintToChat(client, "[Hats] You are currently editing this entity");
return Plugin_Handled;
} else if(inSaferoom[client] && cvar_sm_hats_flags.IntValue & view_as<int>(HatConfig_NoSaferoomHats)) {
PrintToChat(client, "[Hats] Hats are not allowed in the saferoom");
return Plugin_Handled;
} else if(!IsPlayerAlive(entity) || GetEntProp(entity, Prop_Send, "m_isHangingFromLedge") || L4D_IsPlayerCapped(entity)) {
PrintToChat(client, "[Hats] Player is either dead, hanging, or in the process of dying.");
return Plugin_Handled;
} else if(EntRefToEntIndex(hatData[entity].entity) == entity || EntRefToEntIndex(hatData[entity].entity) == client) {
PrintToChat(client, "[Hats] Woah you can't be making a black hole, jesus be careful.");
return Plugin_Handled;
} else if(~cvar_sm_hats_flags.IntValue & view_as<int>(HatConfig_PlayerHats)) {
PrintToChat(client, "[Hats] Player hats are disabled");
return Plugin_Handled;
} else if(!CanTarget(entity)) {
PrintToChat(client, "[Hats] Player has disabled player hats for themselves.");
return Plugin_Handled;
} else if(!CanTarget(client)) {
PrintToChat(client, "[Hats] Cannot hat a player when you have player hats turned off");
return Plugin_Handled;
} else if(cvar_sm_hats_flags.IntValue & view_as<int>(HatConfig_RespectAdminImmunity)) {
AdminId targetAdmin = GetUserAdmin(entity);
AdminId clientAdmin = GetUserAdmin(client);
if(targetAdmin != INVALID_ADMIN_ID && clientAdmin == INVALID_ADMIN_ID) {
PrintToChat(client, "[Hats] Cannot target an admin");
return Plugin_Handled;
} else if(targetAdmin != INVALID_ADMIN_ID && targetAdmin.ImmunityLevel > clientAdmin.ImmunityLevel) {
PrintToChat(client, "[Hats] Cannot target %N, they are immune to you", entity);
return Plugin_Handled;
}
}
if(!isForced &&
!IsFakeClient(entity) &&
cvar_sm_hats_flags.IntValue & view_as<int>(HatConfig_PlayerHatConsent) &&
~flags & view_as<int>(HAT_REVERSED)
) {
int lastRequestDiff = GetTime() - lastHatRequestTime[client];
if(lastRequestDiff < PLAYER_HAT_REQUEST_COOLDOWN) {
PrintToChat(client, "[Hats] Player hat under %d seconds cooldown", PLAYER_HAT_REQUEST_COOLDOWN - lastRequestDiff);
return Plugin_Handled;
}
Menu menu = new Menu(HatConsentHandler);
menu.SetTitle("%N: Requests to hat you", client);
char id[8];
Format(id, sizeof(id), "%d|1", GetClientUserId(client));
menu.AddItem(id, "Accept");
Format(id, sizeof(id), "%d|0", GetClientUserId(client));
menu.AddItem(id, "Reject");
menu.Display(entity, 12);
PrintHintText(client, "Sent hat request to %N", entity);
PrintToChat(entity, "[Hats] %N requests to hat you, 1 to Accept, 2 to Reject. Expires in 12 seconds.", client);
return Plugin_Handled;
}
}
char classname[64];
GetEntityClassname(entity, classname, sizeof(classname));
// Check for any class that should always be reversed
if(~flags & view_as<int>(HAT_REVERSED)) {
for(int i = 0; i < MAX_REVERSE_CLASSNAMES; i++) {
if(StrEqual(REVERSE_CLASSNAMES[i], classname)) {
flags |= view_as<int>(HAT_REVERSED);
break;
}
}
}
EquipHat(client, entity, classname, flags);
}
return Plugin_Handled;
}
#define MAX_ATTACHMENT_POINTS 20
char ATTACHMENT_POINTS[MAX_ATTACHMENT_POINTS][] = {
"eyes",
"molotov",
"pills",
"grenade",
"primary",
"medkit",
"melee",
"survivor_light",
"bleedout",
"forward",
"survivor_neck",
"muzzle_flash",
"spine",
"legL",
"legR",
"thighL",
"thighR",
"lfoot",
"rfoot",
"mouth",
};
void ShowAttachPointMenu(int client) {
Menu menu = new Menu(AttachPointHandler);
menu.SetTitle("Choose an attach point");
for(int i = 0; i < MAX_ATTACHMENT_POINTS; i++) {
menu.AddItem(ATTACHMENT_POINTS[i], ATTACHMENT_POINTS[i]);
}
menu.Display(client, 0);
}
int AttachPointHandler(Menu menu, MenuAction action, int client, int param2) {
if (action == MenuAction_Select) {
char attachPoint[32];
menu.GetItem(param2, attachPoint, sizeof(attachPoint));
if(!HasHat(client)) {
ReplyToCommand(client, "No hat is equipped");
} else {
int hat = GetHat(client);
char classname[32];
GetEntityClassname(hat, classname, sizeof(classname));
EquipHat(client, hat, classname, hatData[client].flags, attachPoint);
CReplyToCommand(client, "Attachment point set to {olive}%s", attachPoint);
}
} else if (action == MenuAction_End)
delete menu;
return 0;
}
// Handles consent that a person to be hatted by another player
int HatConsentHandler(Menu menu, MenuAction action, int target, int param2) {
if (action == MenuAction_Select) {
char info[8];
menu.GetItem(param2, info, sizeof(info));
char str[2][8];
ExplodeString(info, "|", str, 2, 8, false);
int activator = GetClientOfUserId(StringToInt(str[0]));
int hatAction = StringToInt(str[1]);
if(activator == 0) {
ReplyToCommand(target, "Player has disconnected");
return 0;
} else if(hatAction == 1) {
if(EntRefToEntIndex(hatData[target].entity) == activator )
PrintToChat(activator, "[Hats] Woah you can't be making a black hole, jesus be careful.");
else
EquipHat(activator, target, "player", 0);
} else {
ClientCommand(activator, "play player/orch_hit_csharp_short.wav");
PrintHintText(activator, "%N refused your request", target);
lastHatRequestTime[activator] = GetTime();
}
} else if (action == MenuAction_End)
delete menu;
return 0;
}
bool IsHatsEnabled(int client) {
return (cvar_sm_hats_enabled.IntValue == 1 && GetUserAdmin(client) != INVALID_ADMIN_ID) || cvar_sm_hats_enabled.IntValue == 2
}
void ClearHats() {
for(int i = 1; i <= MaxClients; i++) {
if(HasHat(i)) {
ClearHat(i, false);
}
if(IsClientConnected(i) && IsClientInGame(i)) SetEntityMoveType(i, MOVETYPE_WALK);
}
}
void ClearHat(int i, bool restore = false) {
int entity = EntRefToEntIndex(hatData[i].entity);
int visibleEntity = EntRefToEntIndex(hatData[i].visibleEntity);
int modifyEntity = HasFlag(i, HAT_REVERSED) ? i : entity;
if(visibleEntity > 0) {
SDKUnhook(visibleEntity, SDKHook_SetTransmit, OnVisibleTransmit);
RemoveEntity(visibleEntity);
}
if(modifyEntity > 0) {
SDKUnhook(modifyEntity, SDKHook_SetTransmit, OnRealTransmit);
ClearParent(modifyEntity);
} else {
return;
}
int flags = GetEntityFlags(entity) & ~FL_FROZEN;
SetEntityFlags(entity, flags);
// if(HasEntProp(entity, Prop_Send, "m_flModelScale"))
// SetEntPropFloat(entity, Prop_Send, "m_flModelScale", 1.0);
SetEntProp(modifyEntity, Prop_Send, "m_CollisionGroup", hatData[i].collisionGroup);
// SetEntProp(modifyEntity, Prop_Send, "m_nSolidType", hatData[i].solidType);
SetEntProp(modifyEntity, Prop_Send, "movetype", hatData[i].moveType);
hatData[i].entity = INVALID_ENT_REFERENCE;
hatData[i].visibleEntity = INVALID_ENT_REFERENCE;
if(HasFlag(i, HAT_REVERSED)) {
entity = i;
i = modifyEntity;
}
if(entity <= MAXPLAYERS) {
AcceptEntityInput(entity, "EnableLedgeHang");
}
if(restore) {
// If hat is a player, override original position to hat wearer's
if(entity <= MAXPLAYERS && HasEntProp(i, Prop_Send, "m_vecOrigin")) {
GetEntPropVector(i, Prop_Send, "m_vecOrigin", hatData[i].orgPos);
}
// Restore to original position
if(HasFlag(i, HAT_REVERSED)) {
TeleportEntity(i, hatData[i].orgPos, hatData[i].orgAng, NULL_VECTOR);
} else {
TeleportEntity(entity, hatData[i].orgPos, hatData[i].orgAng, NULL_VECTOR);
}
}
}
bool HasHat(int client) {
return GetHat(client) > 0;
}
int GetHat(int client) {
if(hatData[client].entity == INVALID_ENT_REFERENCE) return -1;
int index = EntRefToEntIndex(hatData[client].entity);
if(index <= 0) return -1;
if(!IsValidEntity(index)) return -1;
return index;
}
int GetHatter(int client) {
for(int i = 1; i <= MaxClients; i++) {
if(EntRefToEntIndex(hatData[i].entity) == client) {
return i;
}
}
return -1;
}
bool CanTarget(int victim) {
static char buf[2];
noHatVictimCookie.Get(victim, buf, sizeof(buf));
return StringToInt(buf) == 0;
}
bool IsHatAllowedInSaferoom(int client) {
if(L4D_IsMissionFinalMap()) return true;
if(HasFlag(client, HAT_PRESET)) return true;
char name[32];
GetEntityClassname(hatData[client].entity, name, sizeof(name));
// Don't allow non-weapons in saferoom
if(StrEqual(name, "prop_physics") || StrEqual(name, "prop_dynamic")) {
GetEntPropString(hatData[client].entity, Prop_Data, "m_ModelName", name, sizeof(name));
if(StrContains(name, "gnome") != -1 || StrContains(name, "propanecanist") != -1) {
return true;
}
float mins[3], maxs[3];
GetEntPropVector(hatData[client].entity, Prop_Data, "m_vecMins", mins);
GetEntPropVector(hatData[client].entity, Prop_Data, "m_vecMaxs", maxs);
PrintToConsoleAll("Dropping hat for %N: prop_something (%s) (min %.0f,%.0f,%.0f) (max %.0f,%.0f,%.0f)", client, name, mins[0], mins[1], mins[2], maxs[0], maxs[1], maxs[2]);
return false;
} else if(StrEqual(name, "player") || StrContains(name, "weapon_") > -1 || StrContains(name, "upgrade_") > -1) {
return true;
}
PrintToConsole(client, "Dropping hat: %s", name);
return false;
}
bool IsHatAllowed(int client) {
char name[32];
GetEntityClassname(hatData[client].entity, name, sizeof(name));
if(StrEqual(name, "prop_physics") || StrEqual(name, "prop_dynamic")) {
GetEntPropString(hatData[client].entity, Prop_Data, "m_ModelName", name, sizeof(name));
if(StrContains(name, "models/props_vehicles/c130.mdl") != -1) {
return false;
}
}
return true;
}
bool CanHatBePlaced(int client, const float pos[3]) {
if(cvar_sm_hats_flags.IntValue & view_as<int>(HatConfig_NoSaferoomHats)) {
if(IsHatAllowedInSaferoom(client)) return true;
Address nav = L4D_GetNearestNavArea(pos, 200.0);
if(nav != Address_Null) {
int spawnFlags = L4D_GetNavArea_SpawnAttributes(nav) ;
if(spawnFlags & NAV_SPAWN_CHECKPOINT) {
PrintToServer("\"%L\" tried to place hat in saferoom, denied.", client);
PrintToChat(client, "[Hats] Hat is not allowed in saferoom and has been returned.");
return false;
}
}
}
return true;
}
void SetFlag(int client, hatFlags flag) {
hatData[client].flags |= view_as<int>(flag);
}
bool HasFlag(int client, hatFlags flag) {
return hatData[client].flags & view_as<int>(flag) != 0;
}
void EquipHat(int client, int entity, const char[] classname = "", int flags = HAT_NONE, const char[] attachPoint = "eyes") {
if(HasHat(client))
ClearHat(client, true);
// Player specific tweaks
int visibleEntity;
if(entity == 0) {
ThrowError("Attempted to equip world (client = %d)", client);
return;
}
hatData[client].entity = EntIndexToEntRef(entity);
int modifyEntity = HasFlag(client, HAT_REVERSED) ? client : entity;
hatData[client].collisionGroup = GetEntProp(modifyEntity, Prop_Send, "m_CollisionGroup");
hatData[client].solidType = GetEntProp(modifyEntity, Prop_Send, "m_nSolidType");
hatData[client].moveType = GetEntProp(modifyEntity, Prop_Send, "movetype");
strcopy(hatData[client].attachPoint, 32, attachPoint);
if(client <= MaxClients) SDKHook(client, SDKHook_OnTakeDamageAlive, OnTakeDamageAlive);
if(entity <= MaxClients) SDKHook(entity, SDKHook_OnTakeDamageAlive, OnTakeDamageAlive);
if(modifyEntity <= MaxClients) {
AcceptEntityInput(modifyEntity, "DisableLedgeHang");
} else if(cvar_sm_hats_flags.IntValue & view_as<int>(HatConfig_FakeHat)) {
return;
// char model[64];
// GetEntPropString(entity, Prop_Data, "m_ModelName", model, sizeof(model));
// visibleEntity = CreateEntityByName("prop_dynamic");
// DispatchKeyValue(visibleEntity, "model", model);
// DispatchKeyValue(visibleEntity, "disableshadows", "1");
// DispatchSpawn(visibleEntity);
// SetEntProp(visibleEntity, Prop_Send, "m_CollisionGroup", 1);
// hatData[client].visibleEntity = EntIndexToEntRef(visibleEntity);
// SDKHook(visibleEntity, SDKHook_SetTransmit, OnVisibleTransmit);
// SDKHook(entity, SDKHook_SetTransmit, OnRealTransmit);
}
SDKHook(client, SDKHook_OnTakeDamageAlive, OnTakeDamageAlive);
// Temp remove the hat to be yoinked by another player
for(int i = 1; i <= MaxClients; i++) {
if(i != client && EntRefToEntIndex(hatData[i].entity) == entity) {
ClearHat(i);
}
}
// Called on initial hat
if(classname[0] != '\0') {
if(entity <= MaxClients && !IsFakeClient(entity)) {
PrintToChat(entity, "[Hats] %N has hatted you, type /hat to dismount at any time", client);
}
// Reset things:
hatData[client].flags = 0;
hatData[client].offset[0] = hatData[client].offset[1] = hatData[client].offset[2] = 0.0;
hatData[client].angles[0] = hatData[client].angles[1] = hatData[client].angles[2] = 0.0;
if(flags & view_as<int>(HAT_PRESET)) {
hatData[client].flags |= view_as<int>(HAT_PRESET);
}
if(modifyEntity <= MaxClients) {
if(HasFlag(client, HAT_REVERSED)) {
hatData[client].offset[2] += 7.2;
} else {
hatData[client].offset[2] += 4.2;
}
} else {
float mins[3], maxs[3];
GetEntPropVector(modifyEntity, Prop_Send, "m_vecMaxs", maxs);
GetEntPropVector(modifyEntity, Prop_Send, "m_vecMins", mins);
PrintToServer("%s mins: %f height:%f", classname, mins[2], maxs[2] - mins[2]);
if(StrContains(classname, "weapon_molotov") > -1 || StrContains(classname, "weapon_pipe_bomb") > -1 || StrContains(classname, "weapon_vomitjar") > -1) {
hatData[client].offset[2] += 10.0;
} else {
hatData[client].offset[2] += 10.0 + mins[2];
}
}
if(cvar_sm_hats_flags.IntValue & view_as<int>(HatConfig_ReversedHats) && flags & view_as<int>(HAT_REVERSED)) {
SetFlag(client, HAT_REVERSED);
if(StrEqual(classname, "infected") || (entity <= MaxClients && IsFakeClient(entity))) {
SetFlag(client, HAT_COMMANDABLE);
}
PrintToChat(client, "[Hats] Set yourself as %s (%d)'s hat", classname, entity);
if(entity <= MaxClients) {
LogAction(client, entity, "\"%L\" made themselves \"%L\" (%s)'s hat (%d, %d)", client, entity, classname, entity, visibleEntity);
PrintToChat(entity, "[Hats] %N has set themselves as your hat", client);
}
} else {
// TODO: freeze tank
if(StrEqual(classname, "infected") || StrEqual(classname, "witch") || (entity <= MaxClients && GetClientTeam(entity) == 3 && L4D2_GetPlayerZombieClass(entity) == L4D2ZombieClass_Tank)) {
int eflags = GetEntityFlags(entity) | FL_FROZEN;
SetEntityFlags(entity, eflags);
hatData[client].offset[2] = 36.0;
}
if(entity <= MaxClients)
PrintToChat(client, "[Hats] Set %N (%d) as a hat", entity, entity);
else
PrintToChat(client, "[Hats] Set %s (%d) as a hat", classname, entity);
if(entity <= MaxClients)
LogAction(client, entity, "\"%L\" picked up \"%L\" (%s) as a hat (%d, %d)", client, entity, classname, entity, visibleEntity);
else
LogAction(client, -1, "\"%L\" picked up %s as a hat (%d, %d)", client, classname, entity, visibleEntity);
}
hatData[client].scale = -1.0;
}
AcceptEntityInput(modifyEntity, "DisableMotion");
// Get the data (position, angle, movement shit)
GetEntPropVector(modifyEntity, Prop_Send, "m_vecOrigin", hatData[client].orgPos);
GetEntPropVector(modifyEntity, Prop_Send, "m_angRotation", hatData[client].orgAng);
hatData[client].collisionGroup = GetEntProp(modifyEntity, Prop_Send, "m_CollisionGroup");
hatData[client].solidType = GetEntProp(modifyEntity, Prop_Send, "m_nSolidType");
hatData[client].moveType = GetEntProp(modifyEntity, Prop_Send, "movetype");
if(!HasFlag(client, HAT_POCKET)) {
// TeleportEntity(entity, EMPTY_ANG, EMPTY_ANG, NULL_VECTOR);
if(HasFlag(client, HAT_REVERSED)) {
SetParent(client, entity);
if(StrEqual(classname, "infected")) {
SetParentAttachment(modifyEntity, "head", true);
TeleportEntity(modifyEntity, hatData[client].offset, hatData[client].angles, NULL_VECTOR);
SetParentAttachment(modifyEntity, "head", true);
} else {
SetParentAttachment(modifyEntity, attachPoint, true);
TeleportEntity(modifyEntity, hatData[client].offset, hatData[client].angles, NULL_VECTOR);
SetParentAttachment(modifyEntity, attachPoint, true);
}
if(HasFlag(client, HAT_COMMANDABLE)) {
ChooseRandomPosition(hatData[client].offset);
L4D2_CommandABot(entity, client, BOT_CMD_MOVE, hatData[client].offset);
}
} else {
SetParent(entity, client);
SetParentAttachment(modifyEntity, attachPoint, true);
TeleportEntity(modifyEntity, hatData[client].offset, hatData[client].angles, NULL_VECTOR);
SetParentAttachment(modifyEntity, attachPoint, true);
}
if(visibleEntity > 0) {
SetParent(visibleEntity, client);
SetParentAttachment(visibleEntity, attachPoint, true);
hatData[client].offset[2] += 10.0;
TeleportEntity(visibleEntity, hatData[client].offset, hatData[client].angles, NULL_VECTOR);
SetParentAttachment(visibleEntity, attachPoint, true);
#if defined DEBUG_HAT_SHOW_FAKE
L4D2_SetEntityGlow(visibleEntity, L4D2Glow_Constant, 0, 0, color2, false);
#endif
}
#if defined DEBUG_HAT_SHOW_FAKE
L4D2_SetEntityGlow(modifyEntity, L4D2Glow_Constant, 0, 0, color, false);
#endif
// SetEntProp(modifyEntity, Prop_Send, "m_nSolidType", 0);
SetEntProp(modifyEntity, Prop_Send, "m_CollisionGroup", 1);
SetEntProp(modifyEntity, Prop_Send, "movetype", MOVETYPE_NONE);
}
}
Reference in a new issue View git blame Copy permalink