private void SpectateChatCmd(BasePlayer player, string command, string[] args)
{
if (permission.UserHasPermission(player.UserIDString, "CanSpecTate"))
{
if (!player.IsSpectating())
{
var target = (args.Length > 0 ? BasePlayer.Find(args[0])?.displayName : string.Empty);
if (string.IsNullOrEmpty(target) || target == player.displayName)
{
PrintToChat(player, "No target has been set");
return;
}
player.Die();
player.SetPlayerFlag(BasePlayer.PlayerFlags.Spectating, true);
player.gameObject.SetLayerRecursive(10);
player.CancelInvoke("MetabolismUpdate");
player.CancelInvoke("InventoryUpdate");
PrintToChat(player, "Started Spectating");
player.UpdateSpectateTarget(target);
player.SetPlayerFlag(BasePlayer.PlayerFlags.ThirdPersonViewmode, true);
}
else
{
player.SetParent(null, 0);
player.metabolism.Reset();
player.InvokeRepeating("InventoryUpdate", 1f, 0.1f * UnityEngine.Random.Range(0.99f, 1.01f));
player.SetPlayerFlag(BasePlayer.PlayerFlags.Spectating, false);
player.gameObject.SetLayerRecursive(17);
PrintToChat(player, "Stopped Spectating");
player.SetPlayerFlag(BasePlayer.PlayerFlags.ThirdPersonViewmode, false);
}
} else SendReply(player, "You don't have spectating permissions!");
}
void cmdChatTeamTP(BasePlayer player, string command, string[] args)
{
if (!Permission.HasPermission(player.userID, permissionModer))
{
SendReply(player, "У вас нет нужных превилегий!");
return;
}
if (!player.IsSpectating())
{
if (spectatingPlayers.Count == 0)
{
SendReply(player, "Подозреваемые еще не обнаружены!");
return;
}
var target = spectatingPlayers.First().Key;
spectatingPlayers.Remove(target);
if (target.IsDead())
{
SendReply(player, "Ошибка: игрок не найден или умер!");
return;
}
if (ReferenceEquals(target, player))
{
SendReply(player, "Следить за собой нельзя!");
return;
}
if (target.IsSpectating())
{
SendReply(player, "Подозреваемый наблюдает за кем-то");
return;
}
lastPositions[player.userID] = player.GetNetworkPosition();
// Prep player for spectate mode
var heldEntity = player.GetActiveItem()?.GetHeldEntity() as HeldEntity;
heldEntity?.SetHeld(false);
player.SetPlayerFlag(BasePlayer.PlayerFlags.Spectating, true);
// Put player in spectate mode
player.gameObject.SetLayerRecursive(10);
player.CancelInvoke("MetabolismUpdate");
player.CancelInvoke("InventoryUpdate");
player.ClearEntityQueue();
entitySnapshot.Invoke(player, new object[] { target });
player.gameObject.Identity();
player.SetParent(target);
player.SetPlayerFlag(BasePlayer.PlayerFlags.ThirdPersonViewmode, true);
player.Command("camoffset 0,1.3,0");
SendReply(player, "Слежка началась!");
}
else
{
SpectateFinish(player);
}
}
void ChatCommand(BasePlayer player, string command, string[] args)
{
if (!IsAllowed(player.UserIDString, permSpectate))
{
PrintToChat(player, Lang("NotAllowed", player.UserIDString));
return;
}
if (!player.IsSpectating())
{
var target = (args.Length > 0 ? BasePlayer.Find(args[0]) : null);
if (target == null || target == player)
{
PrintToChat(player, Lang("NoTargets", player.UserIDString));
return;
}
// Store current location before spectating
lastPositions.Add(player.UserIDString, player.transform.position);
// Put player in spectate mode
player.SetPlayerFlag(BasePlayer.PlayerFlags.Spectating, true);
player.gameObject.SetLayerRecursive(10);
player.CancelInvoke("MetabolismUpdate");
player.CancelInvoke("InventoryUpdate");
player.ClearEntityQueue();
entitySnapshot.Invoke(player, new object[] { target });
player.gameObject.Identity();
player.SetParent(target, 0);
// Notify player and store target name
PrintToChat(player, Lang("SpectateStart", player.UserIDString, target.displayName));
spectating.Add(player.UserIDString, target.displayName);
}
else
{
// Restore player to normal mode
player.SetParent(null, 0);
player.SetPlayerFlag(BasePlayer.PlayerFlags.Spectating, false);
player.gameObject.SetLayerRecursive(17);
player.metabolism.Reset();
player.InvokeRepeating("InventoryUpdate", 1f, 0.1f * UnityEngine.Random.Range(0.99f, 1.01f));
// Teleport to original location after spectating
var lastPosition = lastPositions[player.UserIDString];
rust.ForcePlayerPosition(player, lastPosition.x, lastPosition.y, lastPosition.z);
if (lastPositions.ContainsKey(player.UserIDString))
{
lastPositions.Remove(player.UserIDString);
}
// Notify player and clear target name
PrintToChat(player, Lang("SpectateStop", player.UserIDString, spectating[player.UserIDString]));
if (spectating.ContainsKey(player.UserIDString))
{
spectating.Remove(player.UserIDString);
}
}
}
private void StartSpectating(BasePlayer player, BasePlayer target)
{
if (!player.IsSpectating())
{
player.SetPlayerFlag(BasePlayer.PlayerFlags.Spectating, true);
player.gameObject.SetLayerRecursive(10);
player.CancelInvoke("MetabolismUpdate");
player.CancelInvoke("InventoryUpdate");
player.ClearEntityQueue();
entitySnapshot.Invoke(player, new object[] { target });
player.gameObject.Identity();
player.SetParent(target, 0);
}
}
void HidePlayer(BasePlayer player)
{
// Make the player invisible
player.SetPlayerFlag(BasePlayer.PlayerFlags.Spectating, true);
player.gameObject.SetLayerRecursive(10);
player.CancelInvoke("MetabolismUpdate");
player.CancelInvoke("InventoryUpdate");
// Set the player flags
SetPropFlags(player);
// Show the taunt button
TauntButton(player, null);
PrintToChat(player, PlayerHiding);
}
internal void OnPlayerDisconnected(BasePlayer player)
{
if (!Ready)
{
return;
}
player.CancelInvoke(_playerStatsActions[player.userID]);
_playerStatsActions.Remove(player.userID);
}
void SpectateChatCmd(BasePlayer player, string command, string[] args)
{
if (!HasPermission(player, "spectate.allowed"))
{
SendReply(player, NoPermission);
return;
}
if (!player.IsSpectating())
{
var target = (args.Length > 0 ? BasePlayer.Find(args[0])?.displayName : string.Empty);
if (string.IsNullOrEmpty(target) || target == player.displayName)
{
PrintToChat(player, NoTargets);
return;
}
// Put player in spectator mode
player.SetPlayerFlag(BasePlayer.PlayerFlags.Spectating, true);
player.gameObject.SetLayerRecursive(10);
player.CancelInvoke("MetabolismUpdate");
player.CancelInvoke("InventoryUpdate");
// Set spectate target
player.UpdateSpectateTarget(target);
// Set player to third-person view
player.SetPlayerFlag(BasePlayer.PlayerFlags.ThirdPersonViewmode, true);
PrintToChat(player, SpectateStart);
}
else
{
// Restore player to normal mode/view
player.SetParent(null, 0);
player.metabolism.Reset();
player.InvokeRepeating("InventoryUpdate", 1f, 0.1f * Random.Range(0.99f, 1.01f));
player.SetPlayerFlag(BasePlayer.PlayerFlags.Spectating, false);
player.gameObject.SetLayerRecursive(17);
player.SetPlayerFlag(BasePlayer.PlayerFlags.ThirdPersonViewmode, false);
PrintToChat(player, SpectateStop);
}
}
/////////////////////////////////////////
// Random functions
/////////////////////////////////////////
/*void ForcePlayerPosition(BasePlayer player, Vector3 destination)
* {
* player.transform.position = destination;
* player.ClientRPCPlayer(null, player, "ForcePositionTo", new object[] { destination });
* player.TransformChanged();
* }*/
static void PutToSleep(BasePlayer player)
{
if (!player.IsSleeping())
{
player.SetPlayerFlag(BasePlayer.PlayerFlags.Sleeping, true);
if (!BasePlayer.sleepingPlayerList.Contains(player))
{
BasePlayer.sleepingPlayerList.Add(player);
}
player.CancelInvoke("InventoryUpdate");
player.inventory.crafting.CancelAll(true);
}
}
internal void OnPlayerDisconnected(BasePlayer player)
{
if (!Ready)
{
return;
}
if (_playerStatsActions.TryGetValue(player.userID, out Action action))
{
player.CancelInvoke(action);
}
_playerStatsActions.Remove(player.userID);
_requestedClientPerf.Remove(player.userID);
}
private void StartSleeping(BasePlayer player)
{
if (player.IsSleeping())
{
return;
}
player.SetPlayerFlag(BasePlayer.PlayerFlags.Sleeping, true);
if (!BasePlayer.sleepingPlayerList.Contains(player))
{
BasePlayer.sleepingPlayerList.Add(player);
}
player.CancelInvoke("InventoryUpdate");
}
internal void OnPlayerInit(BasePlayer player)
{
if (!Ready)
{
return;
}
var action = new Action(() => GatherPlayerSecondStats(player));
if (_playerStatsActions.ContainsKey(player.userID))
{
player.CancelInvoke(_playerStatsActions[player.userID]);
}
_playerStatsActions[player.userID] = action;
player.InvokeRepeating(action, UnityEngine.Random.Range(0.5f, 1.5f), 1f);
}
internal void OnPlayerInit(BasePlayer player)
{
if (!Ready)
{
return;
}
var action = new Action(() => GatherPlayerSecondStats(player));
if (_playerStatsActions.TryGetValue(player.userID, out Action existingAction))
{
player.CancelInvoke(existingAction);
}
_playerStatsActions[player.userID] = action;
player.InvokeRepeating(action, UnityEngine.Random.Range(0.5f, 1.5f), 1f);
}
/*
* // In future create an Event, allow people to adjust certain resources to give certain amounts!
* public static void ResourceGatherMultiplier(int amount, BaseEntity receiver, ItemAmount itemAmt)
* {
* int newAmt = amount;
* if (receiver.ToPlayer() != null)
* newAmt = (int)((double)amount * World.GetInstance().ResourceGatherMultiplier);
*
* Item item = ItemManager.CreateByItemID(itemAmt.itemid, newAmt);
* receiver.GiveItem(item);
* }*/
public static void Respawn(BasePlayer player, bool newPos)
{
Player p = Server.GetPlayer(player);
RespawnEvent re = new RespawnEvent(p);
OnRespawn.OnNext(re);
++ServerPerformance.spawns;
if (newPos)
{
BasePlayer.SpawnPoint spawnPoint = ServerMgr.FindSpawnPoint();
player.transform.position = spawnPoint.pos;
player.transform.rotation = spawnPoint.rot;
}
if (re.ChangePos && re.SpawnPos != Vector3.zero)
{
player.transform.position = re.SpawnPos;
}
player.SetPlayerFlag(BasePlayer.PlayerFlags.Wounded, false);
player.SetPlayerFlag(BasePlayer.PlayerFlags.ReceivingSnapshot, true);
player.SetFieldValue("lastTickTime", 0f);
player.CancelInvoke("DieFromWounds");
player.StopSpectating();
player.UpdateNetworkGroup();
player.UpdatePlayerCollider(true, false);
player.StartSleeping();
player.Invoke("LifeStoryStart", 0f);
player.metabolism.Reset();
if (re.StartHealth < Single.Epsilon)
{
player.InitializeHealth(player.StartHealth(), player.StartMaxHealth());
}
else
{
player.InitializeHealth(re.StartHealth, player.StartMaxHealth());
}
if (re.GiveDefault)
{
player.inventory.GiveDefaultItems();
}
if (re.WakeUp)
{
player.EndSleeping();
}
}
private void StartSleeping(BasePlayer player)
{
if (player.IsSleeping())
{
return;
}
player.SetPlayerFlag(BasePlayer.PlayerFlags.Sleeping, true);
if (!BasePlayer.sleepingPlayerList.Contains(player))
{
BasePlayer.sleepingPlayerList.Add(player);
}
player.CancelInvoke("InventoryUpdate");
//player.inventory.crafting.CancelAll(true);
//player.UpdatePlayerCollider(true, false);
}
public static void On_Respawn(BasePlayer player, Vector3 pos, Quaternion quat)
{
Player p = Server.GetPlayer(player);
RespawnEvent re = new RespawnEvent(p, pos, quat);
OnNext("On_Respawn", re);
++ServerPerformance.spawns;
player.SetFieldValue("lastPositionValue", pos);
player.transform.position = re.SpawnPos;
player.transform.rotation = re.SpawnRot;
player.SetPlayerFlag(BasePlayer.PlayerFlags.Wounded, false);
player.SetPlayerFlag(BasePlayer.PlayerFlags.ReceivingSnapshot, true);
player.SetFieldValue("lastTickTime", 0f);
player.CancelInvoke("WoundingEnd");
player.StopSpectating();
player.UpdateNetworkGroup();
player.UpdatePlayerCollider(true, false);
player.StartSleeping();
player.Invoke("LifeStoryStart", 0f);
player.metabolism.Reset();
if (re.StartHealth < Single.Epsilon)
{
player.InitializeHealth(player.StartHealth(), player.StartMaxHealth());
}
else
{
player.InitializeHealth(re.StartHealth, player.StartMaxHealth());
}
if (re.GiveDefault)
{
player.inventory.GiveDefaultItems();
}
if (re.WakeUp)
{
player.EndSleeping();
}
player.SendNetworkUpdateImmediate(false);
player.ClientRPCPlayer(null, player, "StartLoading");
player.SendFullSnapshot();
player.SetPlayerFlag(BasePlayer.PlayerFlags.ReceivingSnapshot, false);
player.ClientRPCPlayer(null, player, "FinishLoading");
}
private void StartSpectating(BasePlayer player, BasePlayer target)
{
player.spectateFilter = "@123nofilter123";
player.SetPlayerFlag(BasePlayer.PlayerFlags.Spectating, true);
player.SetPlayerFlag(BasePlayer.PlayerFlags.ThirdPersonViewmode, true);
player.gameObject.SetLayerRecursive(10);
player.CancelInvoke("InventoryUpdate");
player.SendNetworkUpdateImmediate();
timer.In(0.5f, () =>
{
player.transform.position = target.transform.position;
player.SetParent(target, 0);
player.Command("client.camoffset", new object[] { new Vector3(0, 3.5f, 0) });
});
_SpectatorList.Add(player.userID);
}
void Heal(BasePlayer basePlayer)
{
//var basePlayer = player.Object as BasePlayer;
basePlayer.metabolism.bleeding.value = 0;
basePlayer.metabolism.calories.value = basePlayer.metabolism.calories.max;
basePlayer.metabolism.dirtyness.value = 0;
basePlayer.metabolism.hydration.value = basePlayer.metabolism.hydration.max;
basePlayer.metabolism.oxygen.value = 1;
basePlayer.metabolism.poison.value = 0;
basePlayer.metabolism.radiation_level.value = 0;
basePlayer.metabolism.radiation_poison.value = 0;
basePlayer.metabolism.wetness.value = 0;
basePlayer.SetPlayerFlag(BasePlayer.PlayerFlags.Wounded, false);
//basePlayer.CancelInvoke("WoundingEnd");
basePlayer.CancelInvoke("WoundingTick");
//basePlayer.Stop
//CancelInvoke("WoundingEnd");
basePlayer.Heal(100);
}
void ForcePlayerPos(BasePlayer player, Vector3 xyz, bool random)
{
player.SetPlayerFlag(BasePlayer.PlayerFlags.Sleeping, true);
if (!BasePlayer.sleepingPlayerList.Contains(player))
{
BasePlayer.sleepingPlayerList.Add(player);
}
player.CancelInvoke("InventoryUpdate");
player.inventory.crafting.CancelAll(true);
player.MovePosition(random ? GetGroundPosition(new Vector3(xyz.x, xyz.y + 50, xyz.z)) : xyz);
player.ClientRPCPlayer(null, player, "ForcePositionTo", xyz);
player.SetPlayerFlag(BasePlayer.PlayerFlags.ReceivingSnapshot, true);
player.UpdateNetworkGroup();
player.SendNetworkUpdateImmediate(false);
player.ClientRPCPlayer(null, player, "StartLoading");
player.SendFullSnapshot();
}
static void MovePlayerPosition(BasePlayer player, Vector3 destination)
{
player.SetPlayerFlag(BasePlayer.PlayerFlags.Sleeping, true);
if (!BasePlayer.sleepingPlayerList.Contains(player))
{
BasePlayer.sleepingPlayerList.Add(player);
}
player.CancelInvoke("InventoryUpdate");
player.inventory.crafting.CancelAll(true);
player.MovePosition(destination);
player.ClientRPCPlayer(null, player, "ForcePositionTo", destination);
player.SetPlayerFlag(BasePlayer.PlayerFlags.ReceivingSnapshot, true);
player.UpdateNetworkGroup();
player.SendNetworkUpdateImmediate(false);
player.ClientRPCPlayer(null, player, "StartLoading");
player.SendFullSnapshot();
}
private void ExecuteTeleport(BasePlayer player, Vector3 target)
{
if (player.net?.connection != null)
{
player.ClientRPCPlayer(null, player, "StartLoading");
}
if (!player.IsSleeping())
{
player.SetPlayerFlag(BasePlayer.PlayerFlags.Sleeping, true);
if (!BasePlayer.sleepingPlayerList.Contains(player))
{
BasePlayer.sleepingPlayerList.Add(player);
}
player.CancelInvoke("InventoryUpdate");
}
player.MovePosition(target);
if (player.net?.connection != null)
{
player.ClientRPCPlayer(null, player, "ForcePositionTo", target);
}
if (player.net?.connection != null)
{
player.SetPlayerFlag(BasePlayer.PlayerFlags.ReceivingSnapshot, true);
}
player.UpdateNetworkGroup();
//player.UpdatePlayerCollider(true);
player.SendNetworkUpdateImmediate(false);
if (player.net?.connection == null)
{
return;
}
try
{
player.ClearEntityQueue(null);
}
catch { }
player.SendFullSnapshot();
}
object LeaveEvent(BasePlayer player)
{
if (player.GetComponent <EventPlayer>() == null)
{
return("You are not currently in the Event.");
}
if (!EventPlayers.Contains(player.GetComponent <EventPlayer>()))
{
return("You are not currently in the Event.");
}
player.GetComponent <EventPlayer>().inEvent = false;
if (!EventEnded || !EventStarted)
{
BroadcastToChat(string.Format(MessagesEventLeft, player.displayName.ToString(), (EventPlayers.Count - 1).ToString()));
}
ZoneManager?.Call("RemovePlayerFromZoneKeepinlist", EventGameName, player);
if (EventStarted)
{
player.inventory.Strip();
RedeemInventory(player);
TeleportPlayerHome(player);
EventPlayers.Remove(player.GetComponent <EventPlayer>());
if (player.IsAlive())
{
player.SetPlayerFlag(BasePlayer.PlayerFlags.Wounded, false);
player.CancelInvoke("WoundingEnd");
player.health = 50f;
}
TryErasePlayer(player);
Interface.CallHook("OnEventLeavePost", new object[] { player });
}
else
{
EventPlayers.Remove(player.GetComponent <EventPlayer>());
GameObject.Destroy(player.GetComponent <EventPlayer>());
}
return(true);
}
private void SpectateCommand(IPlayer player, string command, string[] args)
{
if (player.IsServer)
{
Message(player, "PlayersOnly", command);
return;
}
if (!player.HasPermission(permUse))
{
Message(player, "NotAllowed", command);
return;
}
BasePlayer basePlayer = player.Object as BasePlayer;
if (basePlayer == null)
{
return;
}
if (!basePlayer.IsSpectating())
{
BasePlayer target = BasePlayer.Find(string.Join(" ", args.Select(v => v.ToString()).ToArray()));
if (target == null || target.IsDead())
{
Message(player, "NoValidTargets");
return;
}
if (ReferenceEquals(target, basePlayer))
{
Message(player, "SpectateSelf");
return;
}
if (target.IsSpectating())
{
Message(player, "TargetIsSpectating", target.displayName);
return;
}
// Store current location before spectating
if (!lastPositions.ContainsKey(player.Id))
{
lastPositions.Add(player.Id, basePlayer.transform.position);
}
else
{
lastPositions[player.Id] = basePlayer.transform.position;
}
// Prep player for spectate mode
HeldEntity heldEntity = basePlayer.GetActiveItem()?.GetHeldEntity() as HeldEntity;
heldEntity?.SetHeld(false);
// Put player in spectate mode
basePlayer.SetPlayerFlag(BasePlayer.PlayerFlags.Spectating, true);
basePlayer.gameObject.SetLayerRecursive(10);
basePlayer.CancelInvoke("MetabolismUpdate");
basePlayer.CancelInvoke("InventoryUpdate");
basePlayer.ClearEntityQueue();
basePlayer.SendEntitySnapshot(target);
basePlayer.gameObject.Identity();
basePlayer.SetParent(target);
basePlayer.SetPlayerFlag(BasePlayer.PlayerFlags.ThirdPersonViewmode, true);
player.Command("camoffset 0,1.3,0");
// Notify player and store target name
Message(player, "SpectateStart", target.displayName);
if (!spectating.ContainsKey(player.Id))
{
spectating.Add(player.Id, target.displayName);
}
else
{
spectating[player.Id] = target.displayName;
}
}
else
{
// Restore player to normal mode
player.Command("camoffset", "0,1,0");
basePlayer.SetParent(null);
basePlayer.SetPlayerFlag(BasePlayer.PlayerFlags.Spectating, false);
basePlayer.SetPlayerFlag(BasePlayer.PlayerFlags.ThirdPersonViewmode, false);
basePlayer.gameObject.SetLayerRecursive(17);
basePlayer.metabolism.Reset();
basePlayer.InvokeRepeating("InventoryUpdate", 1f, 0.1f * UnityEngine.Random.Range(0.99f, 1.01f));
// Restore player to previous state
basePlayer.StartSleeping();
HeldEntity heldEntity = basePlayer.GetActiveItem()?.GetHeldEntity() as HeldEntity;
heldEntity?.SetHeld(true);
// Teleport to original location after spectating
if (lastPositions.ContainsKey(player.Id))
{
Vector3 lastPosition = lastPositions[player.Id];
player.Teleport(lastPosition.x, lastPosition.y + 0.3f, lastPosition.z);
lastPositions.Remove(player.Id);
}
// Notify player and clear target name
if (spectating.ContainsKey(player.Id))
{
Message(player, "SpectateStop", spectating[player.Id]);
spectating.Remove(player.Id);
}
else
{
Message(player, "SpectateStop", "?");
}
}
}
void PutToSleep(BasePlayer player)
{
player.SetPlayerFlag(BasePlayer.PlayerFlags.Sleeping, true);
if(BasePlayer.sleepingPlayerList.Contains(player) == false) BasePlayer.sleepingPlayerList.Add(player);
player.CancelInvoke("InventoryUpdate");
player.inventory.crafting.CancelAll(true);
}
private void Teleport(BasePlayer player, Vector3 target, int countdown = 0)
{
if (player == null)
{
return;
}
if (countdown > 0)
{
player.ChatMessage($"Teleporting in {FormatTime(countdown)}");
timer.Once(countdown, () => Teleport(player, target));
return;
}
PlayerInfo info = playerInfo[player.userID];
string teleportFrom = CanTeleportFrom(player);
if (teleportFrom != null)
{
player.ChatMessage($"<color=#d00>ERROR</color> You cannot teleport from your current location ({teleportFrom}).");
return;
}
string teleportTo = CanTeleportTo(player, target);
if (teleportTo != null)
{
player.ChatMessage($"<color=#d00>ERROR</color> You cannot teleport to your home ({teleportTo}).");
return;
}
if (HasMinimumVipRank(info, "vip"))
{
info.AddCooldown("teleport_home", 60 * 5);
}
else
{
info.AddCooldown("teleport_home", 60 * 20);
}
if (player.net?.connection != null)
{
player.ClientRPCPlayer(null, player, "StartLoading");
}
if (!player.IsSleeping())
{
player.SetPlayerFlag(BasePlayer.PlayerFlags.Sleeping, true);
if (!BasePlayer.sleepingPlayerList.Contains(player))
{
BasePlayer.sleepingPlayerList.Add(player);
}
player.CancelInvoke("InventoryUpdate");
}
player.MovePosition(target);
if (player.net?.connection != null)
{
player.ClientRPCPlayer(null, player, "ForcePositionTo", target);
}
if (player.net?.connection != null)
{
player.SetPlayerFlag(BasePlayer.PlayerFlags.ReceivingSnapshot, true);
}
player.UpdateNetworkGroup();
//player.UpdatePlayerCollider(true);
player.SendNetworkUpdateImmediate(false);
if (player.net?.connection == null)
{
return;
}
try
{
player.ClearEntityQueue(null);
}
catch { }
player.SendFullSnapshot();
}
public static void On_Respawn(BasePlayer player, Vector3 pos, Quaternion quat)
{
Player p = Server.GetPlayer(player);
RespawnEvent re = new RespawnEvent(p, pos, quat);
OnNext("On_Respawn", re);
++ServerPerformance.spawns;
player.SetFieldValue("lastPositionValue", pos);
player.transform.position = re.SpawnPos;
player.transform.rotation = re.SpawnRot;
player.SetPlayerFlag(BasePlayer.PlayerFlags.Wounded, false);
player.SetPlayerFlag(BasePlayer.PlayerFlags.ReceivingSnapshot, true);
player.SetFieldValue("lastTickTime", 0f);
player.CancelInvoke("WoundingEnd");
player.StopSpectating();
player.UpdateNetworkGroup();
player.UpdatePlayerCollider(true, false);
player.StartSleeping();
player.Invoke("LifeStoryStart", 0f);
player.metabolism.Reset();
if (re.StartHealth < Single.Epsilon) {
player.InitializeHealth(player.StartHealth(), player.StartMaxHealth());
} else {
player.InitializeHealth(re.StartHealth, player.StartMaxHealth());
}
if (re.GiveDefault)
player.inventory.GiveDefaultItems();
if (re.WakeUp)
player.EndSleeping();
player.SendNetworkUpdateImmediate(false);
player.ClientRPCPlayer(null, player, "StartLoading");
player.SendFullSnapshot ();
player.SetPlayerFlag (BasePlayer.PlayerFlags.ReceivingSnapshot, false);
player.ClientRPCPlayer(null, player, "FinishLoading");
}
private void joinevent(BasePlayer player, string command, string[] args)
{
if (EventOpen && player.IsAlive() )
{
if((bool)checkCeiling.Call("isCeiling", new object[] { player })){
SendReply(player, "You need to be on the ground floor before teleporting to the event! (This avoids potential death on respawn)");
return;
}
// MeshBatchPhysics.Raycast(player.transform.position + new Vector3(0f, -1.15f, 0f), Vector3Down, out cachedRaycast, out cachedBoolean, out cachedhitInstance);
if (maxSpawns != 0 && EventPlayers.Count >= maxSpawns){
SendReply(player, "Event is full.");
return;
}
if (player.GetComponent<EventPlayer>())
{
if (EventPlayers.Contains(player.GetComponent<EventPlayer>())){
SendReply(player, "You are already in the event.");
return;
}
}
EventPlayer event_player = player.GetComponent<EventPlayer>();
if (event_player == null) event_player = player.gameObject.AddComponent<EventPlayer>();
event_player.inEvent = true;
event_player.enabled = true;
EventPlayers.Add(event_player);
if (player.IsWounded()){ // wounded prior to teleport
player.SetPlayerFlag(BasePlayer.PlayerFlags.Wounded, false);
player.CancelInvoke("WoundingEnd");
player.metabolism.bleeding.value = 0f;
}
player.CancelInvoke("InventoryUpdate"); // bug fix: players who were crafting joined with said crafting items/materials
player.inventory.crafting.CancelAll(true);
SaveHomeLocation(player);
SaveInventory(player);
player.inventory.Strip();
player.SetPlayerFlag(BasePlayer.PlayerFlags.VoiceMuted, true);
//Interface.CallHook("OnEventPlayerSpawn", new object[] { player });
event_player.spawnVec = spawns.First();
ForcePlayerPosition(player, event_player.spawnVec);
if (player.IsWounded()){ // wounded from teleport bug
player.SetPlayerFlag(BasePlayer.PlayerFlags.Wounded, false);
player.CancelInvoke("WoundingEnd");
player.metabolism.bleeding.value = 0f;
}
player.health = 100f;
if(!EventLimitPlayers)
spawns.Remove(event_player.spawnVec);
//updateGUI();
updateGUI(player);
BroadcastToChat(string.Format("{0} has joined the Event! (#<color=red>{1}</color>)", player.displayName, EventPlayers.Count.ToString()));
return;
}
else{
SendReply(player, "Event not open.");
return;
}
}
void Teleport(BasePlayer player, Vector3 destination)
{
player.SetPlayerFlag(BasePlayer.PlayerFlags.Sleeping, true);
if(!BasePlayer.sleepingPlayerList.Contains(player)) BasePlayer.sleepingPlayerList.Add(player);
player.CancelInvoke("InventoryUpdate");
player.inventory.crafting.CancelAll(true);
player.MovePosition(destination);
player.ClientRPCPlayer(null, player, "ForcePositionTo", destination, null, null, null, null);
player.TransformChanged();
player.SetPlayerFlag(BasePlayer.PlayerFlags.ReceivingSnapshot, true);
player.UpdateNetworkGroup();
player.SendNetworkUpdateImmediate(false);
player.ClientRPCPlayer(null, player, "StartLoading", null, null, null, null, null);
player.SendFullSnapshot();
}
void EjectPlayer(BasePlayer player)
{
if (player.IsAlive())
{
player.SetPlayerFlag(BasePlayer.PlayerFlags.Wounded, false);
player.CancelInvoke("WoundingEnd");
player.health = 100f;
player.metabolism.bleeding.value = 0f;
}
}
static void PutToSleep(BasePlayer player)
{
if (!player.IsSleeping())
{
player.SetPlayerFlag(BasePlayer.PlayerFlags.Sleeping, true);
if (!BasePlayer.sleepingPlayerList.Contains(player))
{
BasePlayer.sleepingPlayerList.Add(player);
}
player.CancelInvoke("InventoryUpdate");
player.inventory.crafting.CancelAll(true);
}
}
/*
// In future create an Event, allow people to adjust certain resources to give certain amounts!
public static void ResourceGatherMultiplier(int amount, BaseEntity receiver, ItemAmount itemAmt)
{
int newAmt = amount;
if (receiver.ToPlayer() != null)
newAmt = (int)((double)amount * World.GetInstance().ResourceGatherMultiplier);
Item item = ItemManager.CreateByItemID(itemAmt.itemid, newAmt);
receiver.GiveItem(item);
}*/
public static void Respawn(BasePlayer player, bool newPos)
{
Player p = Server.GetPlayer(player);
RespawnEvent re = new RespawnEvent(p);
OnRespawn.OnNext(re);
++ServerPerformance.spawns;
if (newPos) {
BasePlayer.SpawnPoint spawnPoint = ServerMgr.FindSpawnPoint();
player.transform.position = spawnPoint.pos;
player.transform.rotation = spawnPoint.rot;
}
if (re.ChangePos && re.SpawnPos != Vector3.zero) {
player.transform.position = re.SpawnPos;
}
player.SetPlayerFlag(BasePlayer.PlayerFlags.Wounded, false);
player.SetPlayerFlag(BasePlayer.PlayerFlags.ReceivingSnapshot, true);
player.SetFieldValue("lastTickTime", 0f);
player.CancelInvoke("DieFromWounds");
player.StopSpectating();
player.UpdateNetworkGroup();
player.UpdatePlayerCollider(true, false);
player.StartSleeping();
player.Invoke("LifeStoryStart", 0f);
player.metabolism.Reset();
if (re.StartHealth < Single.Epsilon) {
player.InitializeHealth(player.StartHealth(), player.StartMaxHealth());
} else {
player.InitializeHealth(re.StartHealth, player.StartMaxHealth());
}
if (re.GiveDefault)
player.inventory.GiveDefaultItems();
if (re.WakeUp)
player.EndSleeping();
}
/// <summary>
/// Called from <c>BasePlayer.RespawnAt(Vector3, Quaternion)</c> .
/// </summary>
public static void On_PlayerRespawn(BasePlayer basePlayer, Vector3 pos, Quaternion quat)
{
Player player = Server.GetPlayer(basePlayer);
var re = new RespawnEvent(player, pos, quat);
OnNext("On_PlayerRespawn", re);
basePlayer.SetPlayerFlag(BasePlayer.PlayerFlags.Wounded, false);
basePlayer.SetPlayerFlag(BasePlayer.PlayerFlags.HasBuildingPrivilege, false);
basePlayer.SetPlayerFlag(BasePlayer.PlayerFlags.InBuildingPrivilege, false);
basePlayer.SetPlayerFlag(BasePlayer.PlayerFlags.ReceivingSnapshot, true);
++ServerPerformance.spawns;
basePlayer.transform.position = re.SpawnPos;
basePlayer.transform.rotation = re.SpawnRot;
(basePlayer.GetFieldValue("tickInterpolator") as TickInterpolator).Reset(pos);
basePlayer.SetFieldValue("lastTickTime", 0f);
basePlayer.CancelInvoke("WoundingEnd");
basePlayer.StopSpectating();
basePlayer.UpdateNetworkGroup();
basePlayer.UpdatePlayerCollider(true, false);
basePlayer.StartSleeping();
basePlayer.Invoke("LifeStoryStart", 0f);
basePlayer.metabolism.Reset();
if (re.StartHealth < Single.Epsilon)
{
basePlayer.InitializeHealth(basePlayer.StartHealth(), basePlayer.StartMaxHealth());
}
else
{
basePlayer.InitializeHealth(re.StartHealth, basePlayer.StartMaxHealth());
}
if (re.GiveDefault)
{
basePlayer.inventory.GiveDefaultItems();
}
if (re.WakeUp)
{
basePlayer.EndSleeping();
}
basePlayer.SendNetworkUpdateImmediate(false);
basePlayer.ClearEntityQueue();
basePlayer.ClientRPCPlayer(null, basePlayer, "StartLoading");
if (basePlayer.IsConnected())
basePlayer.SendFullSnapshot();
// player.SetPlayerFlag (BasePlayer.PlayerFlags.ReceivingSnapshot, false);
// player.ClientRPCPlayer(null, player, "FinishLoading");
}
void TeleportPlayerPosition(BasePlayer player, Vector3 destination)
{
player.gameObject.AddComponent<EventPlayerTeleporting>();
player.SetPlayerFlag(BasePlayer.PlayerFlags.Sleeping, true);
if (!BasePlayer.sleepingPlayerList.Contains(player)) BasePlayer.sleepingPlayerList.Add(player);
player.CancelInvoke("InventoryUpdate");
player.inventory.crafting.CancelAll(true);
player.MovePosition(destination);
player.ClientRPCPlayer(null, player, "ForcePositionTo", destination, null, null, null, null);
player.TransformChanged();
player.SetPlayerFlag(BasePlayer.PlayerFlags.ReceivingSnapshot, true);
player.UpdateNetworkGroup();
player.SendNetworkUpdateImmediate(false);
player.ClientRPCPlayer(null, player, "StartLoading", null, null, null, null, null);
player.SendFullSnapshot();
timer.Once(3, () =>
{
UnityEngine.GameObject.Destroy(player.gameObject.GetComponent<EventPlayerTeleporting>());
});
}
