static Common()
{
// VERSION
Command.TryRegister(SmartParse.CreateCommand(
name: "version",
aliases: new[] { "v" },
argTypes : null,
action : delegate(IClient sender, object[] args)
{
sender.Tell(new[]
{
"%iVersions:",
Version,
}.Concat(
functionalities.Select(func => func.Version)
));
},
usage: "!version",
description: "Shows versions of functionalities"));
// CREDITS
Command.TryRegister(SmartParse.CreateCommand(
name : "credits",
argTypes : null,
action : delegate(IClient sender, object[] args)
{
var msg = "%iVersions:"
.Append($"%h1{Version}")
.Concat(Credits);
foreach (var func in functionalities)
{
msg = msg
.Append($"%h1{func.Version}")
.Concat(func.Credits);
}
sender.Tell(msg);
},
usage: "!credits"));
}
private static void Init()
{
IEnumerator announcer()
{
GSCFunctions.SetDvarIfUninitialized("announcer_index", 0);
var index = GSCFunctions.GetDvarInt("announcer_index");
while (true)
{
index %= Config.Announcements.Length;
Common.SayAll(Config.Announcements[index]);
index++;
yield return(BaseScript.Wait(Config.AnnounceInterval));
}
}
if (Config.Announcements != null)
{
Async.Start(announcer());
}
foreach (var cmd in Config.InfoCommands)
{
// INFO COMMANDS
Command.TryRegister(SmartParse.CreateCommand(
name : cmd.Key,
argTypes : null,
action : delegate(Entity sender, object[] args)
{
sender.Tell(cmd.Value);
},
usage: $"!{cmd.Key}",
description: $"Shows information regarding {cmd.Key}"));
}
}
private static void Init()
{
Events.DSRLoad.Add((sender, args) =>
{
if (args.GetBoolOrDefault("antiknife.enable", false))
{
AntiKnife.DisableKnife();
}
else
{
AntiKnife.EnableKnife();
}
});
// SETKNIFE
Command.TryRegister(SmartParse.CreateCommand(
name: "setknife",
argTypes: new[] { SmartParse.Boolean },
action : delegate(IClient sender, object[] args)
{
bool state = (bool)args[0];
if (state)
{
AntiKnife.EnableKnife();
}
else
{
AntiKnife.DisableKnife();
}
sender.Tell($"%nKnife set to %i{state}");
},
usage: "!setknife <state>",
description: "Enables or disables knife",
permission: "setknife"));
}
private static void Init()
{
// doesn't work. :mad: f**k InfintyAbortion
// "who needs arguments" -conno
Script.OnServerCommand("makemegod", (args) =>
{
if (BaseScript.Players.Count == 1)
{
var player = BaseScript.Players.First();
if (TrySetLevel(player, 100))
{
Log.Info($"Player {player.Name} has been given level 100.");
return;
}
else
{
Log.Info($"Player has to login first");
return;
}
}
Log.Info("ERROR: More than one player is in the server.");
return;
});
#region Commands
// SETLEVEL
Command.TryRegister(SmartParse.CreateCommand(
name: "setlevel",
argTypes: new[] { SmartParse.LoggedInPlayer, SmartParse.RangedInteger(0, 100) },
action : delegate(Entity sender, object[] args)
{
var target = args[0] as Entity;
var lvl = (int)args[1];
TrySetLevel(target, lvl);
Common.SayAll($"%p{sender.GetFormattedName()} %ahas set %p{target.GetFormattedName()}%a's level to %i{lvl}%n.");
},
usage: "!setlevel <player> <0-100>",
permission: "setlevel",
description: "Sets a player's admin level"));
// ADMINS
Command.TryRegister(SmartParse.CreateCommand(
name : "admins",
argTypes : null,
action : delegate(Entity sender, object[] args)
{
var msgs = "%aOnline admins:".Yield().Concat(
BaseScript.Players
.Where(player => player.RequestPermission("perms.show", out _))
.Select(ent => ent.GetFormattedName())
.Condense());
sender.Tell(msgs);
},
usage: "!admins",
description: "Shows online admins"));
#endregion
}
private static void Init()
{
#region Commands
#region Map
// MAP
Command.TryRegister(SmartParse.CreateCommand(
name: "map",
argTypes: new[] { Parse.GameMap.Obj },
action : delegate(IClient sender, object[] args)
{
var map = args[0] as GameMap;
Common.SayAll($"Map has been changed to %h1{map.NiceName} %nby %p{sender.GetFormattedName()}");
Utilities.ExecuteCommand($"map {map.RawName}");
},
usage: "!map <map>",
permission: "map",
description: "Changes the map to the map specified"));
// MAPS
Command.TryRegister(SmartParse.CreateCommand(
name : "maps",
argTypes : null,
action : delegate(IClient sender, object[] args)
{
var msgs = "%iAvailable maps:".Yield()
.Concat(
Utils.Maps.Where(x => Utils.MapFilesExist(x.RawName))
.Select(x => $"%a{x.NiceName}%n")
.Condense());
sender.Tell(msgs);
},
usage: "!maps",
permission: "maps",
description: "Displays the available maps"));
// SETNEXTMAP
Command.TryRegister(SmartParse.CreateCommand(
name: "setnextmap",
argTypes: new[] { Parse.GameMap.Obj },
action : delegate(IClient sender, object[] args)
{
var map = args[0] as GameMap;
DSR.SetNextMap(map.RawName);
Common.SayAll($"%p{sender.GetFormattedName()} %nhas set next map to %i{map.NiceName}%n.");
},
usage: "!setnextmap <map>",
permission: "setnextmap",
description: "Sets the next map to the map specified"));
#endregion
#region Mode
// MODE
Command.TryRegister(SmartParse.CreateCommand(
name: "mode",
argTypes: new[] { Parse.GameMode.Obj },
action : delegate(IClient sender, object[] args)
{
string dsr = DSR.GetFullDSRName(args[0] as string);
DSR.SetNextMode(dsr);
Common.SayAll($"Mode has been changed to %h1{dsr} %nby %p{sender.GetFormattedName()}");
Utilities.ExecuteCommand("map_rotate");
},
usage: "!mode <mode>",
permission: "mode",
description: "Changes the mode to the mode specified"));
// GAMETYPE
Command.TryRegister(SmartParse.CreateCommand(
name: "gametype",
argTypes: new[] { Parse.GameMap.Obj, Parse.GameMode.Obj },
action : delegate(Entity sender, object[] args)
{
var map = args[0] as GameMap;
var dsr = DSR.GetFullDSRName(args[1] as string);
DSR.SetNextMapRotation(map.RawName, dsr);
Common.SayAll($"Map and mode have been changed to %h1{map.NiceName}%n, %h2{dsr} %nby %p{sender.GetFormattedName()}");
Utilities.ExecuteCommand("map_rotate");
},
usage: "!gametype <map> <mode>",
permission: "gametype",
description: "Changes the map and mode to the ones specified"));
#endregion
#region Admin
// WARN
Command.TryRegister(SmartParse.CreateCommand(
name: "warn",
argTypes: new[] { SmartParse.UnimmunePlayer, SmartParse.OptionalGreedyString },
action : delegate(IClient sender, object[] args)
{
var target = args[0] as Entity;
if (args[1] is string str)
{
Funcs.Warn(target, sender.GetFormattedName(), str);
}
else
{
Funcs.Warn(target, sender.GetFormattedName());
}
},
usage: "!warn <player> [reason]",
permission: "!warn",
description: "Warns a player"));
// UNWARN
Command.TryRegister(SmartParse.CreateCommand(
name: "unwarn",
argTypes: new[] { SmartParse.UnimmunePlayer, SmartParse.OptionalGreedyString },
action : delegate(IClient sender, object[] args)
{
var target = args[0] as Entity;
if (args[1] is string str)
{
Funcs.Unwarn(target, sender.GetFormattedName(), str);
}
else
{
Funcs.Unwarn(target, sender.GetFormattedName());
}
},
usage: "!unwarn <player> [reason]",
permission: "!unwarn",
description: "Unwarns a player"));
// RESETWARNINGS
Command.TryRegister(SmartParse.CreateCommand(
name: "resetwarnings",
argTypes: new[] { SmartParse.UnimmunePlayer, SmartParse.OptionalGreedyString },
action : delegate(IClient sender, object[] args)
{
var target = args[0] as Entity;
if (args[1] is string str)
{
Funcs.ResetWarnings(target, sender.GetFormattedName(), str);
}
else
{
Funcs.ResetWarnings(target, sender.GetFormattedName());
}
},
usage: "!resetwarnings <player> [reason]",
permission: "resetwarnings",
aliases: new[] { "resetwarns" },
description: "Resets a player's warnings"));
// REMOVEWARNINGS
Command.TryRegister(SmartParse.CreateCommand(
name: "removewarnings",
argTypes: new[] { SmartParse.OptionalGreedyString },
action : delegate(Entity sender, object[] args)
{
if (args[0] is string str)
{
Funcs.ResetWarnings(sender, sender.GetFormattedName(), str);
}
else
{
Funcs.ResetWarnings(sender, sender.GetFormattedName());
}
},
usage: "!removewarnings [reason]",
permission: "resetmywarnings",
aliases: new[] { "rmwarns" },
description: "Reset your own warnings"));
// KICK
Command.TryRegister(SmartParse.CreateCommand(
name: "kick",
argTypes: new[] { SmartParse.UnimmunePlayer, SmartParse.OptionalGreedyString },
action : delegate(IClient sender, object[] args)
{
var target = args[0] as Entity;
if (args[1] is string str)
{
Funcs.Kick(target, sender.GetFormattedName(), str);
}
else
{
Funcs.Kick(target, sender.GetFormattedName());
}
},
usage: "!kick <player> [reason]",
permission: "kick",
description: "Kicks a player"));
// BAN
Command.TryRegister(SmartParse.CreateCommand(
name: "ban",
argTypes: new[] { SmartParse.UnimmunePlayer, SmartParse.OptionalGreedyString },
action : delegate(IClient sender, object[] args)
{
var target = args[0] as Entity;
if (args[1] is string str)
{
Funcs.Ban(target, sender.GetFormattedName(), str);
}
else
{
Funcs.Ban(target, sender.GetFormattedName());
}
},
usage: "!ban <player> [reason]",
permission: "ban",
description: "Bans a player"));
// TMPBAN
Command.TryRegister(SmartParse.CreateCommand(
name: "tmpban",
argTypes: new[] { SmartParse.UnimmunePlayer, Parse.TimeSpan.Obj, SmartParse.OptionalGreedyString },
action : delegate(IClient sender, object[] args)
{
var target = args[0] as Entity;
if (args[1] is TimeSpan ts)
{
if (args[2] is string str)
{
Common.Admin.TempBan(target, sender.GetFormattedName(), ts, str);
}
else
{
Common.Admin.TempBan(target, sender.GetFormattedName(), ts);
}
}
else
{
if (args[2] is string str)
{
Common.Admin.TempBan(target, sender.GetFormattedName(), str);
}
else
{
Common.Admin.TempBan(target, sender.GetFormattedName());
}
}
},
usage: "!tmpban <player> [time] [reason]",
permission: "tmpban",
description: "Temporarily bans a player"));
// EXECUTECOMMAND
Command.TryRegister(SmartParse.CreateCommand(
name: "executecommand",
argTypes: new[] { SmartParse.GreedyString },
action : delegate(IClient sender, object[] args)
{
var cmd = args[0] as string;
Utilities.ExecuteCommand(cmd);
sender.Tell("%aCommand executed.");
},
usage: "!executecommand <cmd>",
aliases: new[] { "exec" },
permission: "executecommand",
description: "Executes a command in the server console"));
// SEARCHBANS
Command.TryRegister(SmartParse.CreateCommand(
name: "searchbans",
argTypes: new[] { SmartParse.GreedyString },
action : delegate(IClient sender, object[] args)
{
var filter = args[0] as string;
IEnumerator routine()
{
var cmd = new SQLiteCommand("SELECT * FROM bans WHERE (name LIKE @pattern OR hwid LIKE @pattern) ORDER BY banid DESC LIMIT 10;", Connection);
cmd.Parameters.AddWithValue("@pattern", $"%{filter}%");
yield return(Async.Detach());
List <string> messages = new List <string>();
lock (Connection)
{
var reader = cmd.ExecuteReader();
while (reader.Read())
{
messages.Add($"%h1{reader["banid"]}%n - %p{reader["name"]}%n, {reader["hwid"]}");
}
reader.Close();
}
yield return(Async.Attach());
sender.Tell("%aFound ban entries:".Yield().Concat(messages));
}
Async.Start(routine());
},
usage: "!searchbans <filter>",
permission: "searchbans",
description: "Searches the bans table"));
// LASTBANS
Command.TryRegister(SmartParse.CreateCommand(
name: "lastbans",
argTypes: new[] { SmartParse.OptionalRangedIntegerWithDefault(1, 10, 4) },
action : delegate(IClient sender, object[] args)
{
IEnumerator routine()
{
var cmd = new SQLiteCommand("SELECT * FROM bans ORDER BY banid DESC LIMIT 10;", Connection);
yield return(Async.Detach());
List <string> messages = new List <string>();
lock (Connection)
{
var reader = cmd.ExecuteReader();
while (reader.Read())
{
messages.Add($"%h1{reader["banid"]}%n - %p{reader["name"]}%n, {reader["hwid"]}");
}
reader.Close();
}
yield return(Async.Attach());
sender.Tell("%aFound ban entries:".Yield().Concat(messages));
}
Async.Start(routine());
},
usage: "!lastbans <1-10>",
permission: "lastbans",
description: "Shows the last given amount of bans"));
// BANINFO
Command.TryRegister(SmartParse.CreateCommand(
name: "baninfo",
argTypes: new[] { SmartParse.Integer },
action : delegate(IClient sender, object[] args)
{
var banid = (int)args[0];
IEnumerator routine()
{
var cmd = new SQLiteCommand("SELECT * FROM bans WHERE banid = @banid;", Connection);
cmd.Parameters.AddWithValue("@banid", banid);
yield return(Async.Detach());
string[] messages = null;
lock (Connection)
{
var reader = cmd.ExecuteReader();
if (reader.Read())
{
messages = new[]
{
$"Ban ID: %h1{reader["banid"]}",
$"Name: %p{reader["name"]}",
$"HWID: %i{reader["hwid"]}",
$"GUID: %i{reader["guid"]}",
$"Issuer: %p{reader["issuer"]}",
$"Expiry: %a{reader["expire"]}",
$"Reason: %i{reader["reason"]}",
};
}
reader.Close();
}
yield return(Async.Attach());
if (messages == null)
{
sender.Tell($"%eEntry {banid} was not found.");
yield break;
}
sender.Tell(messages);
yield break;
}
Async.Start(routine());
},
usage: "!baninfo <banid>",
permission: "baninfo",
description: "Shows details of a ban"));
// UNBAN
Command.TryRegister(SmartParse.CreateCommand(
name: "unban",
argTypes: new[] { SmartParse.Integer },
action : delegate(IClient sender, object[] args)
{
var banid = (int)args[0];
IEnumerator routine()
{
var cmd = new SQLiteCommand("DELETE FROM bans WHERE banid = @banid;", Connection);
cmd.Parameters.AddWithValue("@banid", banid);
yield return(Async.Detach());
int ret;
lock (Connection)
{
ret = cmd.ExecuteNonQuery();
}
yield return(Async.Attach());
sender.Tell($"Return value: %i{ret}");
}
Async.Start(routine());
},
usage: "!unban <banid>",
permission: "unban",
description: "Removes a ban entry"));
#endregion
#region Balance
// BALANCE
Command.TryRegister(SmartParse.CreateCommand(
name : "balance",
argTypes : null,
action : delegate(IClient sender, object[] args)
{
Utils.DeadBalance(sender.GetFormattedName());
},
usage: "!balance",
permission: "balance",
description: "Balances teams using dead players"));
// FORCEBALANCE
Command.TryRegister(SmartParse.CreateCommand(
name : "forcebalance",
argTypes : null,
action : delegate(IClient sender, object[] args)
{
Utils.ForceBalance(sender.GetFormattedName());
},
usage: "!forcebalance",
permission: "forcebalance",
description: "Forces team balance"));
// AUTOBALANCE
Command.TryRegister(SmartParse.CreateCommand(
name: "autobalance",
argTypes: new[] { SmartParse.Boolean },
action : delegate(IClient sender, object[] args)
{
bool state = (bool)args[0];
GSCFunctions.SetDvar("autobalance", state ? 1 : 0);
Common.SayAll($"%p{sender.GetFormattedName()} %nhas {(state ? "^2enabled" : "^1disabled")} autobalance.");
},
usage: "!autobalance <1/0>",
permission: "autobalance",
description: "Enables or disables autobalance"));
// AFK
Command.TryRegister(SmartParse.CreateCommand(
name : "afk",
argTypes : null,
action : delegate(Entity sender, object[] args)
{
Utils.SetTeam(sender, "spectator");
sender.Tell($"You have been set to spectator.");
},
usage: "!afk",
description: "Sets your team to spectator"));
// SETAFK
Command.TryRegister(SmartParse.CreateCommand(
name: "setafk",
argTypes: new[] { SmartParse.Player },
action : delegate(IClient sender, object[] args)
{
var target = args[0] as Entity;
Utils.SetTeam(target, "spectator");
target.Tell($"You have been set to spectator by %p{sender.GetFormattedName()}%n.");
},
usage: "!setafk <player>",
permission: "setafk",
description: "Sets a player's team to spectator"));
// RESTART
Command.TryRegister(SmartParse.CreateCommand(
name: "restart",
argTypes: new[] { SmartParse.OptionalBoolean },
action : delegate(IClient sender, object[] args)
{
Common.SayAll($"Map has been restarted by %p{sender.GetFormattedName()}%n.");
if (args[0] is bool persistent)
{
GSCFunctions.Map_Restart(persistent);
}
else
{
Utilities.ExecuteCommand("fast_restart");
}
},
usage: "!restart <persistent>",
aliases: new[] { "res" },
permission: "restart",
description: "Fast restarts the map"));
// RESTART
Command.TryRegister(SmartParse.CreateCommand(
name : "end",
argTypes : null,
action : delegate(Entity sender, object[] args)
{
Common.SayAll($"Game has been ended by %p{sender.GetFormattedName()}%n.");
foreach (Entity ent in BaseScript.Players)
{
ent.Notify("menuresponse", "menu", "endround");
}
},
usage: "!end",
permission: "end",
description: "Ends the game"));
#endregion
#endregion
// ban checks
Script.PlayerConnected.Add((sender, player) =>
{
IEnumerator routine()
{
var cmd = new SQLiteCommand("SELECT * FROM bans WHERE ((hwid = @hwid OR guid = @guid) AND (datetime(expire) > datetime('now', 'localtime') OR expire = 'permanent'));", Connection);
cmd.Parameters.AddWithValue("@hwid", player.HWID);
cmd.Parameters.AddWithValue("@guid", player.GUID);
bool found = false;
TimeSpan?timeSpan = null;
string message = null, issuer = null;
lock (Connection)
{
var reader = cmd.ExecuteReader();
if (reader.Read())
{
found = true;
if (reader["expire"] as string == "permanent")
{
timeSpan = null;
}
else
{
timeSpan = ParseDate(reader["expire"] as string) - DateTime.Now;
}
message = reader["reason"] as string;
issuer = reader["issuer"] as string;
}
reader.Close();
}
yield return(Async.Attach());
if (found)
{
if (timeSpan.HasValue)
{
Funcs.TempBanKick(player, issuer, timeSpan.Value, message);
yield break;
}
Funcs.BanKick(player, issuer, message);
yield break;
}
}
Async.Start(routine());
});
GSCFunctions.SetDvarIfUninitialized("autobalance", 0);
Script.PlayerKilled.Add((sender, args) =>
{
if (GSCFunctions.GetDvar("autobalance") != "0")
{
Utils.CountPlayers(out int axis, out int allies, out _, out _);
switch (args.Player.SessionTeam)
{
case "axis" when(axis - allies > 1):
Utils.SetTeam(args.Player, "allies");
Common.SayAll($"%p{args.Player.Name} %nhas been automatically balanced.");
return;
case "allies" when(allies - axis > 1):
Common.SayAll($"%p{args.Player.Name} %nhas been automatically balanced.");
Utils.SetTeam(args.Player, "axis");
return;
}
}
});
}
private static void Init()
{
// SETGROUP
Command.TryRegister(SmartParse.CreateCommand(
name: "setgroup",
argTypes: new[] { SmartParse.LoggedInPlayer, Parse.Group.Obj },
action : delegate(IClient sender, object[] args)
{
var target = args[0] as Entity;
var group = args[1] as Group;
TrySetGroup(target, group);
Common.SayAll($"%p{sender.GetFormattedName()} %ahas set %p{target.GetFormattedName()}%a's group to %i{group.Name}%n.");
},
usage: "!setgroup <player> <group/default>",
permission: "setlevel",
description: "Sets a player's admin level"));
// ADMINS
Command.TryRegister(SmartParse.CreateCommand(
name : "admins",
argTypes : null,
action : delegate(IClient sender, object[] args)
{
var msgs = "%aOnline admins:".Yield().Concat(
BaseScript.Players
.Where(player => player.RequestPermission("perms.show", out _))
.Where(player => player.GetDBFieldOr("perms.undercover", "False") == "False")
.Select(ent => ent.GetFormattedName())
.Condense());
sender.Tell(msgs);
},
usage: "!admins",
description: "Shows online admins"));
// UNDERCOVER
Command.TryRegister(SmartParse.CreateCommand(
name: "undercover",
argTypes: new[] { SmartParse.Boolean },
action : delegate(Entity sender, object[] args)
{
var state = (bool)args[0];
if (state)
{
sender.TrySetDBField("perms.undercover", state.ToString());
}
else
{
sender.TryRemoveDBField("perms.undercover");
}
sender.Tell($"Undercover: %i{state}");
},
usage: "!undercover <0/1>",
permission: "undercover",
description: "Prevents you from being shown in !admins"));
// CREATEKEY
Command.TryRegister(SmartParse.CreateCommand(
name: "createkey",
argTypes: new[] { Parse.Group.Obj },
action : delegate(IClient sender, object[] args)
{
var group = args[0] as Group;
var key = GenerateKey();
Keys.Add(key, group.Name);
UpdateKeys();
sender.Tell($"%aKey for group {group.Name} created:"
.Append($"%i{key}"));
},
usage: "!createkey <group>",
permission: "createkey",
description: "Creates a single-use key to be reedemed for the given group"));
// USEKEY
Command.TryRegister(SmartParse.CreateCommand(
name: "usekey",
argTypes: new[] { SmartParse.String },
action : delegate(Entity sender, object[] args)
{
var key = args[0] as string;
if (!sender.IsLogged())
{
sender.Tell("%eYou must log in first.");
return;
}
if (!Keys.TryGetValue(key, out var groupName))
{
sender.Tell("%eKey does not exist.".Append("%eMake sure it was typed correctly."));
return;
}
if (!GroupLookup.TryGetValue(groupName, out var group))
{
sender.Tell($"%eGroup {groupName} does not exist.".Append("Please contact your administrator."));
return;
}
Keys.Remove(key);
UpdateKeys();
sender.TrySetGroup(group);
Common.SayAll($"%p{sender.GetFormattedName()}%a's group is now %i{group.Name}%n.");
},
usage: "!usekey <key>",
description: "Reedems a key for a group"));
#if DEBUG
// GETPERMISSION
Command.TryRegister(SmartParse.CreateCommand(
name: "getpermission",
argTypes: new[] { Parse.Group.Obj, SmartParse.String },
action : delegate(IClient sender, object[] args)
{
var group = args[0] as Group;
var permission = args[1] as string;
var allowed = group.RequestPermission(permission, out var message);
sender.Tell($"Return: {allowed}".Append(message));
},
usage: "!getpermission <group> <permission>"));
#endif
}
private static void Enable()
{
void preparePlayer(Entity player)
{
if (AntiHS)
{
player.SetField("adscycles", 0);
player.SetField("letmehardscope", 0);
BaseScript.OnInterval(50, delegate
{
float ads = player.PlayerAds();
int adscycles = player.GetField <int>("adscycles");
if (ads == 1f && player.IsAlive)
{
adscycles++;
}
else
{
adscycles = 0;
}
if (adscycles > 8)
{
player.AllowAds(false);
player.IPrintLnBold("^1Hardscoping is not allowed!");
}
if (!player.AdsButtonPressed() && ads == 0)
{
player.AllowAds(true);
}
player.SetField("adscycles", adscycles);
return(true);
});
}
player.GiveMaxAmmo(player.CurrentWeapon);
}
if (NoMagnumAmmo)
{
Events.ScavengerPickup.Add((sender, args) =>
{
args.SetWeaponAmmoClip("iw5_44magnum_mp", 0);
args.SetWeaponAmmoStock("iw5_44magnum_mp", 0);
});
Events.WeaponTaken.Add((sender, args) =>
{
if (args.Weapon.Contains("44magnum"))
{
args.Player.SetWeaponAmmoClip("iw5_44magnum_mp", 0);
args.Player.SetWeaponAmmoStock("iw5_44magnum_mp", 0);
}
});
Events.WeaponChanged.Add((sender, args) =>
{
if (args.Weapon.Contains("44magnum"))
{
args.Player.SetWeaponAmmoClip("iw5_44magnum_mp", 0);
args.Player.SetWeaponAmmoStock("iw5_44magnum_mp", 0);
}
});
}
if (AntiFallDamage)
{
Script.PlayerDamage.Add((sender, args) =>
{
if (args.Mod == "MOD_FALLING")
{
args.Damage = 0;
}
});
}
if (InstantDeath)
{
Script.PlayerDamage.Add((sender, args) =>
{
if (args.Damage != 0 && args.Mod == "MOD_BULLET")
{
args.Damage = 200;
}
}, 10);
}
if (AntiPlant)
{
Events.WeaponChanged.Add((sender, args) =>
{
var(player, weapon) = args;
if (weapon.Equals("briefcase_bomb_mp"))
{
player.TakeWeapon("briefcase_bomb_mp");
player.IPrintLnBold("^1Planting is not allowed!");
}
});
}
Events.PlayerSpawned.Add((sender, player) =>
{
preparePlayer(player);
});
Events.GiveLoadout.Add((sender, player) =>
{
player.GiveMaxAmmo(player.CurrentWeapon);
});
// GIVEAMMO
Command.TryRegister(SmartParse.CreateCommand(
name : "giveammo",
argTypes : null,
action : delegate(Entity sender, object[] args)
{
if (sender.CurrentWeapon == "iw5_44magnum_mp")
{
sender.Tell("nah.");
return;
}
sender.GiveMaxAmmo(sender.CurrentWeapon);
sender.Tell("Given max ammo!");
},
usage: "!giveammo",
aliases: new[] { "ga" },
description: "Gives max ammo for the current weapon"));
Log.Info("ISnipe enabled!");
Common.Register(ISnipe.Instance);
}
private static void Init()
{
Events.DSRLoad.Add((sender, args) =>
{
if (args.TryGetOpt("custom_gametype", out var value))
{
ServerStr.ReportedGameType = value;
Log.Debug(value);
}
});
Config.Load();
Utils.SetObjectiveText();
#region Commands
// SETFLY
Command.TryRegister(SmartParse.CreateCommand(
name: "setfly",
argTypes: new[] { SmartParse.Player, SmartParse.Boolean },
action : delegate(Entity sender, object[] args)
{
Entity ent = args[0] as Entity;
bool state = (bool)args[1];
ent.SetField("EnableFly", state);
if (state)
{
if (!ent.IsFieldTrue("InitializedFly"))
{
Utils.InitializeFly(ent);
}
Utils.DoFly(ent);
}
sender.Tell($"%nFly for %p{ent.Name} %nset to %i{state}");
},
usage: "!setfly <player> <state>",
permission: "setfly",
description: "Enables or disables fly for the specified player"));
// MYFLY
Command.TryRegister(SmartParse.CreateCommand(
name: "myfly",
argTypes: new[] { SmartParse.Boolean },
action : delegate(Entity sender, object[] args)
{
bool state = (bool)args[0];
sender.SetField("EnableFly", state);
if (state)
{
if (!sender.IsFieldTrue("InitializedFly"))
{
Utils.InitializeFly(sender);
}
Utils.DoFly(sender);
}
sender.Tell($"%nFly set to %i{state}");
},
usage: "!myfly <state>",
permission: "myfly",
description: "Enables or disables fly"));
// UNLIMITEDAMMO
Command.TryRegister(SmartParse.CreateCommand(
name: "unlimitedammo",
argTypes: new[] { SmartParse.Boolean },
action : delegate(Entity sender, object[] args)
{
bool state = (bool)args[0];
sender.SetField("UnlimitedAmmo", state);
if (state)
{
BaseScript.OnInterval(1, () =>
{
if (!sender.IsFieldTrue("UnlimitedAmmo"))
{
return(false);
}
sender.SetWeaponAmmoClip(sender.CurrentWeapon, int.MaxValue, "right");
sender.SetWeaponAmmoClip(sender.CurrentWeapon, int.MaxValue, "left");
sender.SetWeaponAmmoStock(sender.CurrentWeapon, int.MaxValue);
return(true);
});
}
sender.Tell($"%nUnlimited ammo set to %i{state}");
},
usage: "!unlimitedammo <state>",
permission: "unlimitedammo",
description: "Enables or disables unlimited ammo"));
// UNLIMITEDAMMOWITHRELOAD
Command.TryRegister(SmartParse.CreateCommand(
name: "unlimitedammowithreload",
argTypes: new[] { SmartParse.Boolean },
action : delegate(Entity sender, object[] args)
{
bool state = (bool)args[0];
sender.SetField("UnlimitedAmmoReload", state);
if (state)
{
BaseScript.OnInterval(1, () =>
{
if (!sender.IsFieldTrue("UnlimitedAmmoReload"))
{
return(false);
}
sender.SetWeaponAmmoStock(sender.CurrentWeapon, int.MaxValue);
return(true);
});
}
sender.Tell($"%nUnlimited ammo with reload set to %i{state}");
},
usage: "!unlimitedammowithreload <state>",
permission: "unlimitedammowithreload",
description: "Enables or disables unlimited ammo with reload"));
// UNLIMITEDGRENADES
Command.TryRegister(SmartParse.CreateCommand(
name: "unlimitedgrenades",
argTypes: new[] { SmartParse.Boolean },
action : delegate(Entity sender, object[] args)
{
bool state = (bool)args[0];
sender.SetField("UnlimitedGrenades", state);
if (state)
{
Events.GrenadeFire.Add((sender1, arguments) =>
{
if (arguments.Player.IsFieldTrue("UnlimitedGrenades"))
{
arguments.Player.GiveWeapon(arguments.Grenade);
}
});
}
sender.Tell($"%nUnlimited grenades set to %i{state}");
},
usage: "!unlimitedgrenades <state>",
permission: "unlimitedgrenades",
description: "Enables or disables unlimited grenades"));
// AIMBOT
Command.TryRegister(SmartParse.CreateCommand(
name: "myaimbot",
argTypes: new[] { SmartParse.Boolean },
action : delegate(Entity sender, object[] args)
{
bool state = (bool)args[0];
sender.SetField("EnableAimbot", state);
if (state)
{
Utils.DoAimbot(sender);
}
sender.Tell($"%nAimbot set to %i{state}");
},
usage: "!myaimbot <state>",
permission: "myaimbot",
description: "Enables or disables aimbot"));
// SILENTAIM
Command.TryRegister(SmartParse.CreateCommand(
name: "mysilentaim",
argTypes: new[] { SmartParse.Boolean },
action : delegate(Entity sender, object[] args)
{
bool state = (bool)args[0];
sender.SetField("EnableSilentAim", state);
Utils.SetupSilentAim();
sender.Tell($"%nSilentAim set to %i{state}");
},
usage: "!mysilentaim <state>",
permission: "mysilentaim",
description: "Enables or disables silentaim"));
// AIMASSIST
Command.TryRegister(SmartParse.CreateCommand(
name: "myaimassist",
argTypes: new[] { SmartParse.Boolean },
action : delegate(Entity sender, object[] args)
{
bool state = (bool)args[0];
sender.SetField("EnableAimAssist", state);
if (state)
{
Utils.DoAimAssist(sender);
}
sender.Tell($"%nAimAssist set to %i{state}");
},
usage: "!myaimassist <state>",
permission: "myaimassist",
description: "Enables or disables aimassist"));
// AKIMBO
Command.TryRegister(SmartParse.CreateCommand(
name : "akimbo",
argTypes : null,
action : delegate(Entity sender, object[] args)
{
Utils.AkimboPrimary(sender);
sender.Tell($"%nAkimbo primary enabled");
},
usage: "!akimbo",
permission: "akimbo",
description: "Enables akimbo primary"));
// TPHERE
Command.TryRegister(SmartParse.CreateCommand(
name : "akimbomode",
argTypes : null,
action : delegate(Entity sender, object[] args)
{
Events.PlayerSpawned.Add((sender1, args1) =>
{
Utils.AkimboPrimary(sender1 as Entity);
});
Events.PlayerRespawned.Add((sender1, args1) =>
{
Utils.AkimboPrimary(sender1 as Entity);
});
sender.Tell($"%nAkimbomode enabled");
},
usage: "!akimbomode",
permission: "akimbomode",
description: "Enables akimbomode"));
Command.TryRegister(SmartParse.CreateCommand(
name: "tphere",
argTypes: new[] { SmartParse.Player },
action : delegate(Entity sender, object[] args)
{
Entity ent = args[0] as Entity;
ent.SetOrigin(sender.GetOrigin());
ent.Tell($"%nYou have been teleported to %p{sender.Name}");
sender.Tell($"%p{ent.Name} %nhas been teleported to you");
},
usage: "!tphere <player>",
permission: "tphere",
description: "Teleports a player to you"));
Command.TryRegister(SmartParse.CreateCommand(
name : "tppoint",
argTypes : null,
action : delegate(Entity sender, object[] args)
{
bool fix = false;
sender.GiveWeapon("uav_strike_marker_mp");
BaseScript.AfterDelay(100, () => sender.SwitchToWeaponImmediate("uav_strike_marker_mp"));
Action <object, WeaponFiredArgs> hook = (obj, arg) =>
{
Entity ent = arg.Player;
string weapon = arg.Weapon;
if (weapon != "uav_strike_marker_mp" || ent != sender)
{
return;
}
int LaserFX = GSCFunctions.LoadFX("misc/laser_glow");
Vector3 playerForward = ent.GetTagOrigin("tag_weapon_right") + GSCFunctions.AnglesToForward(ent.GetPlayerAngles()) * 10000;
Entity refObject = GSCFunctions.Spawn("script_model", ent.GetTagOrigin("tag_weapon_tight"));
refObject.SetField("angles", ent.GetPlayerAngles());
refObject.SetModel("com_plasticcase_beige_big");
refObject.MoveTo(playerForward, 5f);
refObject.Hide();
ent.TakeWeapon("uav_strike_marker_mp");
BaseScript.OnInterval(10, () =>
{
Vector3 endLoc = refObject.GetOrigin() + GSCFunctions.AnglesToForward(refObject.GetField <Vector3>("angles")) * 100;
if (!GSCFunctions.SightTracePassed(refObject.GetOrigin(), endLoc, false, ent))
{
Entity fx = GSCFunctions.SpawnFX(LaserFX, refObject.Origin);
sender.SetOrigin(refObject.GetOrigin());
fix = true;
GSCFunctions.TriggerFX(fx);
sender.Tell($"%nYou have been teleported to %p{refObject.Origin.ToString()}");
refObject.Notify("death");
BaseScript.AfterDelay(500, () => fx.Delete());
return(false);
}
return(true);
});
};
Events.WeaponFired.Add(hook);
BaseScript.OnInterval(100, () =>
{
if (fix)
{
Events.WeaponFired.Remove(hook);
return(false);
}
return(true);
});
},
usage: "!tppoint",
permission: "tppoint",
description: "Teleports you to a point"));
Command.TryRegister(SmartParse.CreateCommand(
name : "giveallperks",
argTypes : null,
action : delegate(Entity sender, object[] args)
{
List <string> perks = new List <string>()
{
"specialty_longersprint",
"specialty_fastreload",
"specialty_scavenger",
"specialty_blindeye",
"specialty_paint",
"specialty_hardline",
"specialty_coldblooded",
"specialty_quickdraw",
"specialty_blastshield",
"specialty_detectexplosive",
"specialty_autospot",
"specialty_bulletaccuracy",
"specialty_quieter",
"specialty_stalker",
"specialty_copycat",
"specialty_juiced",
"specialty_grenadepulldeath",
"specialty_finalstand",
"specialty_revenge",
"specialty_stopping_power",
"specialty_c4death",
"specialty_uav"
};
sender.ClearPerks();
foreach (string s in perks)
{
sender.SetPerk(s, true, true);
}
sender.Tell(perks.Where(x => !sender.HasPerk(x)).Condense());
},
usage: "!giveallperks",
permission: "giveallperks",
description: "Gives you all perks"));
Command.TryRegister(SmartParse.CreateCommand(
name: "washingmachine",
argTypes: new[] { SmartParse.String },
action : delegate(Entity sender, object[] args)
{
switch (args[0] as string)
{
case "random":
Random rand = new Random();
BaseScript.OnInterval(1, () =>
{
int num = rand.Next(10);
switch (num)
{
case 1:
sender.SetPlayerAngles(new Vector3(sender.GetPlayerAngles().X, sender.GetPlayerAngles().Y, sender.GetPlayerAngles().Z + 1));
break;
case 2:
sender.SetPlayerAngles(new Vector3(sender.GetPlayerAngles().X, sender.GetPlayerAngles().Y, sender.GetPlayerAngles().Z - 1));
break;
case 3:
sender.SetPlayerAngles(new Vector3(sender.GetPlayerAngles().X, sender.GetPlayerAngles().Y, sender.GetPlayerAngles().Z + 50));
break;
case 4:
sender.SetPlayerAngles(new Vector3(sender.GetPlayerAngles().X, sender.GetPlayerAngles().Y, sender.GetPlayerAngles().Z - 50));
break;
case 5:
sender.SetPlayerAngles(new Vector3(sender.GetPlayerAngles().X, sender.GetPlayerAngles().Y, sender.GetPlayerAngles().Z - 100));
break;
case 6:
sender.SetPlayerAngles(new Vector3(sender.GetPlayerAngles().X, sender.GetPlayerAngles().Y, sender.GetPlayerAngles().Z + 100));
break;
default:
sender.SetPlayerAngles(new Vector3(sender.GetPlayerAngles().X, sender.GetPlayerAngles().Y, sender.GetPlayerAngles().Z + 3));
break;
}
return(true);
});
break;
}
},
usage: "!washingmachine <string>",
permission: "washingmachine",
description: "Enables washing machine"));
// GIVEWEP
Command.TryRegister(SmartParse.CreateCommand(
name: "givewep",
argTypes: new[] { SmartParse.String },
action : delegate(Entity sender, object[] args)
{
string wep = args[0] as string;
sender.GiveWeapon(wep);
sender.SetWeaponAmmoClip(wep, int.MaxValue);
sender.SetField("Allow_Weapon_Name", wep);
sender.SetField("Allow_Grenade_Name", wep);
BaseScript.AfterDelay(100, () => sender.SwitchToWeaponImmediate(wep));
sender.Tell($"%nYou have been given %p{wep}");
},
usage: "!givewep <weapon>",
permission: "givewep",
description: "Gives you the specified weapon"));
// AC130
Command.TryRegister(SmartParse.CreateCommand(
name : "ac130",
argTypes : null,
action : delegate(Entity sender, object[] args)
{
sender.GiveWeapon("ac130_105mm_mp");
sender.GiveWeapon("ac130_40mm_mp");
sender.GiveWeapon("ac130_25mm_mp");
BaseScript.AfterDelay(100, () => sender.SwitchToWeaponImmediate("ac130_105mm_mp"));
sender.Tell($"%nYou have been given ac130");
},
usage: "!ac130",
permission: "ac130",
description: "Gives you AC130"));
// AC130
Command.TryRegister(SmartParse.CreateCommand(
name: "missilestrike",
argTypes: new[] { SmartParse.Integer },
action : delegate(Entity sender, object[] args)
{
int times = (int)args[0];
sender.Tell($"%nAirstrike confirmed. Sending %h1{times} %nmissiles");
BaseScript.OnInterval(400, () =>
{
Utils.MissileStrike(sender);
if (times > 0)
{
times--;
return(true);
}
return(false);
});
},
usage: "!missilestrike <time>",
permission: "missilestrike",
description: "Sends a missile strike"));
// TAKEALLWEPS
Command.TryRegister(SmartParse.CreateCommand(
name : "takeallweps",
argTypes : null,
action : delegate(Entity sender, object[] args)
{
sender.TakeAllWeapons();
sender.Tell($"%nAll weapons taken");
},
usage: "!takeallweps",
permission: "takeallweps",
description: "Takes all weapons"));
// CRASH
Command.TryRegister(SmartParse.CreateCommand(
name: "crash",
argTypes: new[] { SmartParse.UnimmunePlayer },
action : delegate(Entity sender, object[] args)
{
Entity ent = args[0] as Entity;
Utils.CrashPlayer(ent);
sender.Tell($"%p{ent.Name} %nhas been crashed");
},
usage: "!crash <player>",
permission: "crash",
description: "Crashes the players client"));
// SPAWNPLAYER
Command.TryRegister(SmartParse.CreateCommand(
name: "spawnplayer",
argTypes: new[] { SmartParse.UnimmunePlayer },
action : delegate(Entity sender, object[] args)
{
Entity ent = args[0] as Entity;
ent.Notify("menuresponse", "team_marinesopfor", "spectator");
BaseScript.AfterDelay(100, () => ent.Notify("menuresponse", "team_marinesopfor", "autoassign"));
BaseScript.AfterDelay(300, () => ent.Notify("menuresponse", "changeclass", "class0"));
sender.Tell($"%p{ent.Name} %nhas been spawned");
},
usage: "!spawnplayer <player>",
permission: "spawnplayer",
description: "Spawns the client"));
// TEST
Command.TryRegister(SmartParse.CreateCommand(
name : "mynotifies",
argTypes : null,
action : delegate(Entity sender, object[] args)
{
Script.PlayerNotified.Add((sender1, args1) =>
{
Entity ent = args1.Entity;
if (ent == sender)
{
Log.Debug("Entity: " + args1.Notify + "(" + (string.Join(", ", args1.Parameters.Select(x => x.ToString())) + ")"));
}
});
Script.Notified.Add((sender1, args1) =>
{
Entity ent = null;
if (args1.Entity != null)
{
ent = args1.Entity;
}
else if (args1.EntityParam != null)
{
ent = args1.EntityParam;
}
if (ent != null && ent == sender)
{
Log.Debug("Level: " + args1.Notify + "(" + (string.Join(", ", args1.Parameters.Select(x => x.ToString())) + ")"));
}
});
},
usage: "!mynotifies",
permission: "mynotifies",
description: ""));
// TEST
Command.TryRegister(SmartParse.CreateCommand(
name : "afkgod",
argTypes : null,
action : delegate(Entity sender, object[] args)
{
sender.SessionTeam = "spectator";
},
usage: "!afkgod",
permission: "afkgod",
description: ""));
// TEST
Command.TryRegister(SmartParse.CreateCommand(
name : "god",
argTypes : null,
action : delegate(Entity sender, object[] args)
{
BaseScript.OnInterval(1, () =>
{
sender.Health = 1000;
return(true);
});
},
usage: "!god",
permission: "god",
description: ""));
// TEST
Command.TryRegister(SmartParse.CreateCommand(
name : "test",
argTypes : null,
action : delegate(Entity sender, object[] args)
{
BaseScript.OnInterval(100, () =>
{
sender.Tell(sender.GetPlayerAngles().ToString());
return(true);
});
},
usage: "!test",
permission: "test",
description: ""));
Vector3 spawn;
// SETSPAWN
Command.TryRegister(SmartParse.CreateCommand(
name : "setspawn",
argTypes : null,
action : delegate(Entity sender, object[] args)
{
spawn = sender.GetOrigin();
Events.PlayerRespawned.Add((sender1, args1) =>
{
(sender1 as Entity).SetOrigin(spawn);
});
Events.PlayerSpawned.Add((sender1, args1) =>
{
(sender1 as Entity).SetOrigin(spawn);
});
},
usage: "!setspawn",
permission: "setspawn",
description: ""));
// SPAWNPLAYER
Command.TryRegister(SmartParse.CreateCommand(
name: "fucklamb",
argTypes: new[] { SmartParse.Player, SmartParse.Boolean },
action : delegate(Entity sender, object[] args)
{
Entity ent = args[0] as Entity;
bool state = (bool)args[1];
ent.SetField("EnableReverseAimbot", state);
if (state)
{
Utils.DoReverseAimbot(ent);
}
sender.Tell($"%p{ent.Name} %nhas been f****d");
},
usage: "!fucklamb <player> <state>",
permission: "fucklamb",
description: "F***s lambdur"));
//Script.PlayerConnected.Add((sender, args) =>
//{
// //if (args.Name.Contains("Lambder") || args.Name.Contains("Markus"))
// BaseScript.OnInterval(2000, () =>
// {
// args.SetClientDvar("cg_objectiveText", "^1Lambder");
// BaseScript.AfterDelay(500, () => args.SetClientDvar("cg_objectiveText", "^2Sucks"));
// BaseScript.AfterDelay(1000, () => args.SetClientDvar("cg_objectiveText", "^3Big"));
// BaseScript.AfterDelay(1500, () => args.SetClientDvar("cg_objectiveText", "^5Dicks"));
// return true;
// });
// //Events.WeaponChanged.Add((sender1, args1) =>
// //{
// // Entity ent = sender1 as Entity;
// // if (ent.Name.Contains("Lambder") || ent.Name.Contains("Markus"))
// // Marshal.WriteInt32((IntPtr)0x01AC2488, (0x38A4 * args.EntRef), 1);
// //});
//});
#endregion
//GSCFunctions.MakeDvarServerInfo("ui_netGametypeName", "Test");
//GSCFunctions.MakeDvarServerInfo("party_gametype", "Test1");
//GSCFunctions.MakeDvarServerInfo("ui_customModeName", "Test2");
//GSCFunctions.MakeDvarServerInfo("ui_gametype", "Test3");
//GSCFunctions.MakeDvarServerInfo("didyouknow", "Test4");
//GSCFunctions.MakeDvarServerInfo("g_motd", "Test5");
//GSCFunctions.MakeDvarServerInfo("ui_connectScreenTextGlowColor", "0 1 0");
}
