void Heal(PlayerSession player)
{
EntityStats stats = player.WorldPlayerEntity.GetComponent <EntityStats>();
stats.GetFluidEffect(EEntityFluidEffectType.ColdBar).SetValue(0f);
stats.GetFluidEffect(EEntityFluidEffectType.Radiation).SetValue(0f);
stats.GetFluidEffect(EEntityFluidEffectType.HeatBar).SetValue(0f);
stats.GetFluidEffect(EEntityFluidEffectType.Dampness).SetValue(0f);
stats.GetFluidEffect(EEntityFluidEffectType.Hungerbar).SetValue(0f);
stats.GetFluidEffect(EEntityFluidEffectType.Nutrition).SetValue(100f);
stats.GetFluidEffect(EEntityFluidEffectType.InternalTemperature).Reset(true);
stats.GetFluidEffect(EEntityFluidEffectType.ExternalTemperature).Reset(true);
stats.GetFluidEffect(EEntityFluidEffectType.Toxin).SetValue(0f);
stats.GetFluidEffect(EEntityFluidEffectType.Health).SetValue(100f);
stats.RemoveBinaryEffect(EEntityBinaryEffectType.BrokenLeg);
stats.RemoveBinaryEffect(EEntityBinaryEffectType.Wet);
}
void Heal(PlayerSession session, bool health = true)
{
EntityStats stats = session.WorldPlayerEntity.GetComponent <EntityStats>();
stats.GetFluidEffect(effect().TemperatureDelta).Reset(true);
stats.GetFluidEffect(effect().InternalTemperature).Reset(true);
stats.GetFluidEffect(effect().ExternalTemperature).Reset(true);
stats.GetFluidEffect(effect().Toxin).SetValue(0f);
if (health)
{
stats.GetFluidEffect(effect().Health).SetValue(100f);
}
foreach (var d in stats.GetBinaryEffects())
{
d.Value.Remove();
}
}
private void OnPlayerDeath(PlayerSession session, EntityEffectSourceData source)
{
if (permission.UserHasPermission(session.SteamId.ToString(), "admintools.godmode") || permission.UserHasPermission(session.SteamId.ToString(), "admintools.all") || session.IsAdmin)
{
string KillName = GetNameOfObject(source.EntitySource);
if (KillName != "")
{
string Killer = KillName.Replace("(P)", "");
if ((bool)Config["KillingInGodBan"] || (bool)Config["KillingInGodKick"])
{
PlayerSession person = GetSession(Killer);
if (person != null)
{
ulong ID = (ulong)person.SteamId;
if (Godlist.Contains(ID))
{
if ((bool)Config["LogKillingInGodMode"])
{
globallog.Add("[" + DateTime.Now + "] " + session.Identity.Name + " (" + session.SteamId + ") killed " + person.Identity.Name + " (" + person.SteamId + ") while in GodMode");
SaveGlobalLog();
}
if ((bool)Config["KillingInGodKick"])
{
GameManager.Instance.KickPlayer(ID.ToString(), Msg("godkill"));
}
if (!person.IsAdmin)
{
if ((bool)Config["KillingInGodBan"])
{
ConsoleManager.Instance.ExecuteCommand("ban " + ID);
GameManager.Instance.KickPlayer(ID.ToString(), Msg("godkill"));
}
}
}
}
}
}
if (Godlist.Contains((ulong)session.SteamId))
{
EntityStats stats = session.WorldPlayerEntity.GetComponent <EntityStats>();
timer.Once(0.1f, () =>
{
stats.GetFluidEffect(Singleton <RuntimeAssetManager> .Instance.RefList.EntityEffectDatabase.Health).SetValue(100f);
});
}
}
}
void InfamyCommand(PlayerSession session, string command, string[] args)
{
if (permission.UserHasPermission(session.SteamId.ToString(), "admintools.infamy") || permission.UserHasPermission(session.SteamId.ToString(), "admintools.all") || session.IsAdmin)
{
if (args.Length == 2)
{
float infamy = 0f;
try{ infamy = Convert.ToSingle(args[1]); }catch { hurt.SendChatMessage(session, Msg("notvalidnumber", session.SteamId.ToString()).Replace("{arg}", args[1])); return; }
if (args[0].ToLower() == "all")
{
foreach (PlayerSession ses in GameManager.Instance.GetSessions().Values)
{
if (ses.IsLoaded)
{
EntityStats stats = ses.WorldPlayerEntity.GetComponent <EntityStats>();
stats.GetFluidEffect(EEntityFluidEffectType.Infamy).SetValue(infamy);
}
}
hurt.SendChatMessage(session, Msg("infamyset", session.SteamId.ToString()).Replace("{player}", "All players").Replace("{infamy}", infamy.ToString()));
if ((bool)Config["LogInfamy"])
{
globallog.Add("[" + System.DateTime.Now + "] " + session.Name + " (" + session.SteamId.ToString() + ") set Infamy on ALL PLAYERS to " + infamy);
SaveGlobalLog();
}
}
else
{
PlayerSession target = GetSession(args[0]);
EntityStats stats = target.WorldPlayerEntity.GetComponent <EntityStats>();
stats.GetFluidEffect(EEntityFluidEffectType.Infamy).SetValue(infamy);
hurt.SendChatMessage(session, Msg("infamyset", session.SteamId.ToString()).Replace("{player}", target.Name + "'s").Replace("{infamy}", infamy.ToString()));
if ((bool)Config["LogInfamy"])
{
globallog.Add("[" + System.DateTime.Now + "] " + session.Name + " (" + session.SteamId.ToString() + ") set Infamy on " + target.Name + " (" + target.SteamId.ToString() + ") to " + infamy);
SaveGlobalLog();
}
}
}
else
{
hurt.SendChatMessage(session, Msg("infamyerror", session.SteamId.ToString()));
}
}
else
{
hurt.SendChatMessage(session, Msg("nopermission", session.SteamId.ToString()));
}
}
object OnPlayerDeath(PlayerSession session, EntityEffectSourceData source)
{
if (permission.UserHasPermission(session.SteamId.ToString(), "admintools.godmode") || permission.UserHasPermission(session.SteamId.ToString(), "admintools.all"))
{
string KillName = GetNameOfObject(source.EntitySource);
if (KillName != "")
{
string Killer = KillName.Replace("(P)", "");
if ((bool)Config["KillingInGodBan"] || (bool)Config["KillingInGodKick"])
{
PlayerSession person = GetSession(Killer);
if (person != null)
{
ulong ID = (ulong)person.SteamId;
if (Godlist.Contains(ID))
{
if ((bool)Config["KillingInGodKick"])
{
Singleton <GameManager> .Instance.KickPlayer(ID.ToString(), Msg("godkill"));
}
if (!person.IsAdmin)
{
if ((bool)Config["KillingInGodBan"])
{
ConsoleManager.Instance?.ExecuteCommand("ban " + ID);
Singleton <GameManager> .Instance.KickPlayer(ID.ToString(), Msg("godkill"));
}
}
}
}
}
}
if (Godlist.Contains((ulong)session.SteamId))
{
EntityStats stats = session.WorldPlayerEntity.GetComponent <EntityStats>();
timer.Once(0.1f, () =>
{
stats.GetFluidEffect(EEntityFluidEffectType.Health).SetValue(100f);
});
return(false);
}
}
return(null);
}
bool GiveRoll(PlayerSession session, string rollname)
{
Roll roll;
if (string.IsNullOrEmpty(rollname) || !storedData.Rolls.TryGetValue(rollname, out roll))
{
ShowMsg(session, Msg("GiveRoll_NotExist").Replace("{rollname}", rollname));
return(false);
}
var playerinv = session.WorldPlayerEntity.GetComponent <PlayerInventory>();
var amanager = Singleton <AlertManager> .Instance;
var itemmanager = Singleton <GlobalItemManager> .Instance;
var playerEntity = session.WorldPlayerEntity;
var rolledItem = new RollItem();
var rolledReplacement = new RollItem();
var rolledStat = new RollStat();
var rolledSpawn = new RollSpawn();
var ManagerInstance = GameManager.Instance;
var sumItemChance = 0;
var sumStatChance = 0;
var sumSpawnChance = 0;
var sumReplaceChance = 0;
var totalChance = 0;
var count = 0;
foreach (var rollem in roll.items)
{
sumItemChance += rollem.chance;
}
foreach (var rollstat in roll.stats)
{
sumStatChance += rollstat.chance;
}
foreach (var rollspawn in roll.spawns)
{
sumSpawnChance += rollspawn.chance;
}
foreach (var rollreplace in roll.replacements)
{
sumReplaceChance += rollreplace.chance;
}
totalChance = sumItemChance + sumStatChance + sumSpawnChance + sumReplaceChance;
if (totalChance == 0)
{
return(false);
}
var rnd = Core.Random.Range(1, totalChance);
if (rnd <= sumItemChance)
{
for (int i = 0; i < roll.items.Count && rolledItem.itemid == 0; i++)
{
count += roll.items[i].chance;
if (count >= rnd)
{
rolledItem = roll.items[i];
}
}
var item = itemmanager.GetItem(rolledItem.itemid);
var iitem = new ItemInstance(item, rolledItem.amount);
if (playerinv.Items[0] == null)
{
playerinv.Items[0] = iitem;
amanager.ItemReceivedServer(iitem.Item, iitem.StackSize, session.Player);
playerinv.Invalidate(false);
}
else
{
itemmanager.GiveItem(session.Player, itemmanager.GetItem(rolledItem.itemid), rolledItem.amount);
}
BroadcastMsg(Msg("GiveRoll_ItemGive")
.Replace("{player}", session.Name)
.Replace("{amount}", rolledItem.amount.ToString())
.Replace("{itemname}", item.GetNameKey().ToString().Split('/').Last()));
}
else if (rnd > sumItemChance && rnd <= sumStatChance + sumItemChance)
{
count = sumItemChance;
for (int i = 0; i < roll.stats.Count && rolledStat.type == 0; i++)
{
count += roll.stats[i].chance;
if (count >= rnd)
{
rolledStat = roll.stats[i];
}
}
EntityStats stats = session.WorldPlayerEntity.GetComponent <EntityStats>();
var currValue = stats.GetFluidEffect(rolledStat.type).GetValue();
var newValue = currValue + rolledStat.amount;
stats.GetFluidEffect(rolledStat.type).SetValue(newValue);
BroadcastMsg(Msg("GiveRoll_StatGive")
.Replace("{player}", session.Name)
.Replace("{amount}", rolledStat.amount.ToString())
.Replace("{stat}", rolledStat.type.ToString().ToLower()));
}
else if (rnd > sumItemChance + sumStatChance && rnd <= sumStatChance + sumItemChance + sumSpawnChance)
{
count = sumItemChance + sumStatChance;
GameObject Obj = new GameObject();
for (int i = 0; i < roll.spawns.Count && rolledSpawn.spawnName == null; i++)
{
count += roll.spawns[i].chance;
if (count >= rnd)
{
rolledSpawn = roll.spawns[i];
}
}
var iterations = 0;
var numberSpawned = 0;
for (numberSpawned = 0; numberSpawned < rolledSpawn.amount && iterations < rolledSpawn.amount * 100;)
{
Vector3 position = new Vector3(playerEntity.transform.position.x + Core.Random.Range(-10, 10),
playerEntity.transform.position.y + Core.Random.Range(0, 10),
playerEntity.transform.position.z + Core.Random.Range(-10, 10));
RaycastHit hitInfo;
Physics.Raycast(position, Vector3.down, out hitInfo);
{
Quaternion rotation = Quaternion.Euler(0.0f, (float)UnityEngine.Random.Range(0f, 360f), 0.0f);
rotation = Quaternion.FromToRotation(Vector3.down, hitInfo.normal) * rotation;
Obj = Singleton <HNetworkManager> .Instance.NetInstantiate(rolledSpawn.spawnName, hitInfo.point, Quaternion.identity, GameManager.GetSceneTime());
Destroy(Obj);
numberSpawned++;
}
iterations++;
}
BroadcastMsg(Msg("GiveRoll_SpawnGive")
.Replace("{player}", session.Name)
.Replace("{amount}", numberSpawned.ToString())
.Replace("{creature}", creatures[rolledSpawn.spawnName.ToLower()]));
}
else
{
var replacementFound = false;
count = sumStatChance + sumItemChance + sumSpawnChance;
for (int i = 0; i < roll.replacements.Count && rolledReplacement.itemid == 0; i++)
{
count += roll.replacements[i].chance;
if (count >= rnd)
{
rolledReplacement = roll.replacements[i];
}
}
if (playerinv.Items.Length > 0)
{
var noOfIterations = 0;
for (int i = Core.Random.Range(0, playerinv.Items.Length - 1); !replacementFound && noOfIterations < 1000; i = Core.Random.Range(0, playerinv.Items.Length - 1))
{
if (playerinv.Items[i] != null)
{
var item = itemmanager.GetItem(rolledReplacement.itemid);
var iitem = new ItemInstance(item, rolledReplacement.amount);
var replaceedItem = playerinv.Items[i];
playerinv.Items[i] = iitem;
amanager.ItemReceivedServer(iitem.Item, iitem.StackSize, session.Player);
playerinv.Invalidate(false);
replacementFound = true;
BroadcastMsg(Msg("GiveRoll_ItemReplace")
.Replace("{player}", session.Name)
.Replace("{amount1}", replaceedItem.StackSize.ToString())
.Replace("{itemname1}", replaceedItem.Item.GetNameKey().ToString().Split('/').Last())
.Replace("{amount2}", playerinv.Items[i].StackSize.ToString())
.Replace("{itemname2}", playerinv.Items[i].Item.GetNameKey().ToString().Split('/').Last()));
}
noOfIterations++;
}
}
}
return(true);
}
void HealAll()
{
foreach (PlayerSession session in GameManager.Instance.GetSessions().Values)
{
if (session != null && session.IsLoaded)
{
EntityStats stats = session.WorldPlayerEntity.GetComponent <EntityStats>();
stats.RemoveBinaryEffect(EEntityBinaryEffectType.Burning);
stats.GetFluidEffect(EEntityFluidEffectType.ColdBar).SetValue(0f);
stats.GetFluidEffect(EEntityFluidEffectType.Radiation).SetValue(0f);
stats.GetFluidEffect(EEntityFluidEffectType.HeatBar).SetValue(0f);
stats.GetFluidEffect(EEntityFluidEffectType.Dampness).SetValue(0f);
stats.GetFluidEffect(EEntityFluidEffectType.Hungerbar).SetValue(0f);
stats.GetFluidEffect(EEntityFluidEffectType.Nutrition).SetValue(100f);
stats.GetFluidEffect(EEntityFluidEffectType.InternalTemperature).SetValue(0f);
stats.GetFluidEffect(EEntityFluidEffectType.ExternalTemperature).SetValue(0f);
stats.GetFluidEffect(EEntityFluidEffectType.Toxin).SetValue(0f);
stats.GetFluidEffect(EEntityFluidEffectType.Health).SetValue(100f);
stats.RemoveBinaryEffect(EEntityBinaryEffectType.BrokenLeg);
stats.GetFluidEffect(EEntityFluidEffectType.ExternalTemperature).SetValue(0f);
stats.RemoveBinaryEffect(EEntityBinaryEffectType.HeatStroke);
stats.RemoveBinaryEffect(EEntityBinaryEffectType.SunBurn);
}
}
}
