static void EjectPlayer(Zone zone, PlayerClient player)
{
cachedDirection = player.lastKnownPosition - zone.transform.position;
player.lastKnownPosition = zone.transform.position + (cachedDirection / cachedDirection.magnitude * (zone.GetComponent<UnityEngine.SphereCollider>().radius + 2f));
management.TeleportPlayerToWorld(player.netPlayer, player.lastKnownPosition);
Interface.CallHook("IsCollidingEject",zone, player);
}
public static void DoPlayerConnected(PlayerClient player)
{
if (GameEvent.PlayerConnected != null)
{
GameEvent.PlayerConnected(player);
}
}
//public Player()
//{
// this.justDied = true;
//}
public Player(PlayerClient client)
{
Contract.Requires(client != null);
this.justDied = true;
this.ourPlayer = client;
this.connectedAt = DateTime.UtcNow.Ticks;
this.FixInventoryRef();
}
static bool hasTag(PlayerClient player, string tagname)
{
if (playerZones[player] == null) { return false; }
if (playerZones[player].Count == 0) { return false; }
fieldInfo = typeof(ZoneDefinition).GetField(tagname, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic);
foreach (Zone zone in playerZones[player])
{
if (fieldInfo.GetValue(zone.info) != null)
return true;
}
return false;
}
// Use this for initialization
void Start()
{
if (isClient && isLocalPlayer)
{
singleton = this;
pCommmon.isClientSingleton = true;
}
if (isServer && isClient && isLocalPlayer && hasAuthority)
{
singleton = this;
pCommmon.isClientSingleton = true;
}
}
public void Update()
{
if (PlayerClient.GetLocalPlayer() == null || PlayerClient.GetLocalPlayer().controllable == null)
{
return;
}
var player = PlayerClient.GetLocalPlayer().controllable.GetComponent <Character>();
if (player == null)
{
return;
}
enabled = false;
WorldEditor.Instance.AddRPC();
}
public Player(PlayerClient client)
{
this.disconnected = false;
this.justDied = true;
this.ourPlayer = client;
this.connectedAt = DateTime.UtcNow.Ticks;
this.connectedAt2 = System.Environment.TickCount;
this.uid = client.netUser.userID;
this.name = client.netUser.displayName;
this.ipaddr = client.netPlayer.externalIP;
this.FixInventoryRef();
this._CommandCancelList = new List <string>();
this._lastpost = Vector3.zero;
this._np = client.netUser.networkPlayer;
}
// Token: 0x06000639 RID: 1593 RVA: 0x000467B8 File Offset: 0x000449B8
public static GameObject GetLookObject(PlayerClient player, int layerMask = -1)
{
bool flag = player == null;
GameObject result;
if (flag)
{
result = null;
}
else
{
result = Helper.GetLookObject(player.controllable, -1);
}
return(result);
}
private void Update()
{
if (Test)
{
if (PlayerClient == null)
{
PlayerClient = GameObject.Find("XR Rig").GetComponent <PlayerClient>();
}
else
{
EmulateHead(PlayerClient.Head.transform.position, PlayerClient.Head.transform.rotation);
//EmulateHand(PlayerClient.LeftHand, PlayerClient.GetHandData(PlayerClient.LeftHand, PlayerClient.LeftHandSpellController);
}
}
}
private void StartPlugin()
{
if (rpc != null)
{
UnityEngine.Object.Destroy(rpc);
}
try
{
rpc = PlayerClient.GetLocalPlayer().gameObject.AddComponent <StackSizesRPC>();
}
catch (Exception ex)
{
Debug.LogError(ex.Message);
}
}
public void MotorChangeJoint()
{
var humanController = (HumanController)PlayerClient.GetLocalPlayer().controllable.character.controller;
_ccMotor = humanController.ccmotor;
_ccMotor.movement.setup.maxForwardSpeed *= 0.5f;
_ccMotor.movement.setup.maxSidewaysSpeed *= 0.5f;
_ccMotor.movement.setup.maxBackwardsSpeed *= 0.5f;
_ccMotor.movement.setup.maxGroundAcceleration *= 0.5f;
_ccMotor.movement.setup.maxAirAcceleration *= 0.5f;
_ccMotor.movement.setup.maxAirHorizontalSpeed *= 0.5f;
StartCoroutine(GetSoberJoint());
}
public void RespawnPlayer(PlayerClient player)
{
lock (sync) {
if (player.State != PlayerState.HasLevelLoaded && player.State != PlayerState.Dead)
{
return;
}
Vector3 pos = new Vector3(levelHandler.EventMap.GetSpawnPositionForMultiplayer(), LevelHandler.PlayerZ);
if (player.ProxyActor == null)
{
player.ProxyActor = new Player();
player.ProxyActor.Index = player.Index;
player.ProxyActor.OnActivated(new ActorActivationDetails {
LevelHandler = levelHandler,
Pos = pos,
Params = new[] { (ushort)player.PlayerType, (ushort)0 }
});
levelHandler.AddPlayer(player.ProxyActor);
}
else
{
if (player.ProxyActor.Health > 0)
{
player.ProxyActor.Transform.Pos = pos;
}
else
{
player.ProxyActor.Respawn(pos.Xy);
}
}
player.State = PlayerState.Spawned;
Send(new CreateControllablePlayer {
Index = player.Index,
Type = player.PlayerType,
Pos = pos,
Health = playerHealth,
Controllable = (serverState == ServerState.LevelRunning)
}, 11, player.Connection, NetDeliveryMethod.ReliableOrdered, PacketChannels.Main);
}
#if DEBUG
Log.Write(LogType.Verbose, "Respawning player #" + player.Index);
#endif
}
public IController Possess(PlayerClient player)
{
if (player == null)
{
throw new ArgumentException("Player cannot be null");
}
if (Player != null)
{
Player.ReadyForAction -= Play;
}
Player = player;
Player.ReadyForAction += Play;
currentState = BuildDfa();
return(this);
}
private static void InvestigateHandler()
{
for (int i = 0; i < GameHelper.Commands.Count; i++)
{
if (GameHelper.Commands[i].Ability == Abilities.Investigate)
{
int from = Convert.ToInt32(GameHelper.Commands[i].From);
int to = Convert.ToInt32(GameHelper.Commands[i].To);
PlayerClient playerClientFrom = GameplayServer.playerClients[from - 1];
PlayerClient playerClientTo = GameplayServer.playerClients[to - 1];
string message = $"Your target is a {playerClientTo.Role.Name}";
GameplayServer.Server.Send(playerClientFrom, message);
}
}
((Views.ServerTerminal)RunningWindows.GetWindow("ServerTerminal")).Terminal("Inves done");
}
public static Fougerite.Player FindByPlayerClient(PlayerClient pc)
{
if (pc == null)
{
return(null);
}
foreach (Fougerite.Player player in Fougerite.Server.GetServer().Players)
{
if (player != null && player.PlayerClient == pc)
{
return(player);
}
}
return(null);
}
public void PartialNameKick(ref ConsoleSystem.Arg Arguments, int id)
{
if (id == 0)
{
Util.sayUser(Arguments.argUser.networkPlayer, Core.Name, "Cancelled!");
return;
}
PList list = (PList)Core.kickWaitList[Arguments.argUser.userID];
PlayerClient client;
if (PlayerClient.FindByUserID(list.PlayerList[id].UserID, out client))
{
KickPlayer(client.netUser, Arguments.argUser);
}
}
void Start()
{
if (isLocalPlayer)
{
client = gameObject.AddComponent <PlayerClient> ();
}
else
{
observer = gameObject.AddComponent <PlayerObserver> ();
}
if (isServer)
{
server = gameObject.AddComponent <PlayerServer> ();
}
}
/// <summary>
/// Sends the file list to the server then closes the application.
/// </summary>
private static void SendFileListToServer()
{
try {
using (PlayerClient Client = new PlayerClient(App.Config.ServerPort)) {
string[] args = Environment.GetCommandLineArgs();
if (args.Length > 1)
{
Client.Playback.OpenMedia(args.GetPartOfArray(1, args.Length - 1));
}
}
}
catch (Exception e) {
PlayerUtils.ErrorMessageBox(App.Name, e.Message);
}
}
static void OnExitZone(Zone zone, PlayerClient player)
{
if (playerZones[player].Contains(zone))
{
playerZones[player].Remove(zone);
}
if (zone.info.leave_message != null)
{
SendMessage(player, zone.info.leave_message);
}
if (zone.keepInList.Contains(player))
{
AttractPlayer(zone, player);
}
Interface.CallHook("OnExitZone", zone.info.ID, player);
}
public bool GetLocationString(ref NetUser source, PlayerClient location, out string reply)
{
bool flag = false;
try
{
string[] v3 = location.lastKnownPosition.ToString("F").Trim(new char[] { '(', ')', ' ' }).Split(new char[] { ',' });
reply = string.Format("{3} Location: X:{0} Y:{1} Z:{2}", v3[0], v3[1], v3[2],
(location.netUser == source ? "Your" : string.Format("{0}'s", location.netUser.displayName)));
flag = true;
} catch (Exception)
{
reply = string.Empty;
}
return(flag);
}
public static Vector3 PlayerSpawning(PlayerClient pc, Vector3 pos, bool camp)
{
try
{
//Fougerite.Player player = Fougerite.Player.FindByPlayerClient(pc);
Fougerite.Player player = Fougerite.Server.Cache[pc.userID];
SpawnEvent se = new SpawnEvent(pos, camp);
if ((OnPlayerSpawning != null) && (player != null))
{
OnPlayerSpawning(player, se);
}
return(new Vector3(se.X, se.Y, se.Z));
}
catch { }
return(Vector3.zero);
}
public static void PlayerSpawned(PlayerClient pc, Vector3 pos, bool camp)
{
try
{
Fougerite.Player player = Fougerite.Player.FindByPlayerClient(pc);
SpawnEvent se = new SpawnEvent(pos, camp);
if ((OnPlayerSpawned != null) && (player != null))
{
OnPlayerSpawned(player, se);
}
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
static void Punish(PlayerClient player, string reason, bool kick, bool ban)
{
if (ban)
{
BanList.Add(player.userID, player.userName, reason);
BanList.Save();
Interface.CallHook("cmdBan", false, new string[] { player.netPlayer.externalIP.ToString(), reason });
Debug.Log(string.Format("{0} {1} was auto banned for {2}", player.userID.ToString(), player.userName.ToString(), reason));
}
AntiGlitchBroadcastAdmins(string.Format(playerGlitchDetectionBroadcast, player.userName.ToString()));
if (kick || ban)
{
player.netUser.Kick(NetError.Facepunch_Kick_Violation, true);
Debug.Log(string.Format("{0} {1} was auto kicked for {2}", player.userID.ToString(), player.userName.ToString(), reason));
}
}
private void Update()
{
if (!_Freezing)
{
return;
}
if (PlayerClient.GetLocalPlayer() != null && PlayerClient.GetLocalPlayer().controllable != null)
{
Character player = PlayerClient.GetLocalPlayer().controllable.GetComponent <Character>();
if (player != null)
{
player.lockMovement = true;
//player.lockLook = true;
}
}
}
public static void location(ref ConsoleSystem.Arg arg)
{
if (config.GetSetting("Commands", "location") == "false")
{
API.sayUser(arg.argUser.networkPlayer, "This feature has been disabled on this server");
return;
}
string partialNameOrIDInt = arg.argUser.displayName;
foreach (PlayerClient playerClient in PlayerClient.FindAllWithString(partialNameOrIDInt))
{
string s = "Location: X: " + (int)playerClient.lastKnownPosition.x + " Y: " + (int)playerClient.lastKnownPosition.y + " Z: " + (int)playerClient.lastKnownPosition.z;
arg.ReplyWith(s);
API.sayUser(arg.argUser.networkPlayer, "Your Location Is: X: " + (int)playerClient.lastKnownPosition.x + " Y: " + (int)playerClient.lastKnownPosition.y + " Z: " + (int)playerClient.lastKnownPosition.z);
}
}
public static void shareWith(PlayerClient senderClient, string[] args)
{
if (args.Count() > 1)
{
PlayerClient[] possibleTargets = Array.FindAll(Vars.AllPlayerClients.ToArray(), (PlayerClient pc) => pc.userName.Contains(args[1]));
if (possibleTargets.Count() == 0)
{
Broadcast.broadcastTo(senderClient.netPlayer, "No player names equal or contain '" + args[1] + "'.");
}
else if (possibleTargets.Count() > 1)
{
Broadcast.broadcastTo(senderClient.netPlayer, "Too many player names contain '" + args[1] + "'.");
}
else
{
PlayerClient targetClient = possibleTargets[0];
string senderUID = senderClient.userID.ToString();
string targetUID = targetClient.userID.ToString();
if (senderUID != null && targetUID != null && senderUID.Length == 17 && targetUID.Length == 17 && senderUID != targetUID)
{
if (Vars.sharingData.ContainsKey(senderUID))
{
if (!Vars.sharingData[senderUID].Contains(targetUID))
{
string oldVal = Vars.sharingData[senderUID];
Vars.sharingData[senderUID] = oldVal + ":" + targetUID;
Broadcast.noticeTo(senderClient.netPlayer, ":D", "Doors shared with " + targetClient.userName + ".");
Broadcast.noticeTo(targetClient.netPlayer, ":D", "You can now open " + senderClient.userName + "'s doors.");
Vars.addDoorData(senderUID, targetUID);
}
else
{
Broadcast.noticeTo(senderClient.netPlayer, ":D", "You have already shared doors with " + targetClient.userName + ".");
}
}
else
{
Vars.sharingData.Add(senderUID, targetUID);
Broadcast.noticeTo(senderClient.netPlayer, ":D", "Doors shared with " + targetClient.userName + ".");
Broadcast.noticeTo(targetClient.netPlayer, ":D", "You can now open " + senderClient.userName + "'s doors.");
Vars.addDoorData(senderUID, targetUID);
}
}
}
}
}
/**
* Pull specific info from a newly changed userinfo string into a more C
* freindly form.
*/
public static void SV_UserinfoChanged(client_t cl)
{
string val;
int i;
// call prog code to allow overrides
PlayerClient.ClientUserinfoChanged(cl.edict, cl.userinfo);
// name for C code
cl.name = Info.Info_ValueForKey(cl.userinfo, "name");
// mask off high bit
//TODO: masking for german umlaute
//for (i=0 ; i<sizeof(cl.name) ; i++)
// cl.name[i] &= 127;
// rate command
val = Info.Info_ValueForKey(cl.userinfo, "rate");
if (val.Length > 0)
{
i = Lib.atoi(val);
cl.rate = i;
if (cl.rate < 100)
{
cl.rate = 100;
}
if (cl.rate > 15000)
{
cl.rate = 15000;
}
}
else
{
cl.rate = 5000;
}
// msg command
val = Info.Info_ValueForKey(cl.userinfo, "msg");
if (val.Length > 0)
{
cl.messagelevel = Lib.atoi(val);
}
}
bool Ifinshack(NetUser userx)
{
PlayerClient playerclient = userx.playerClient;
Vector3 lastPosition = playerclient.lastKnownPosition;
Collider cachedCollider;
bool cachedBoolean;
Vector3 cachedvector3;
RaycastHit cachedRaycast;
Facepunch.MeshBatch.MeshBatchInstance cachedhitInstance;
DeployableObject cachedDeployable;
if (lastPosition == default(Vector3))
{
return(false);
}
if (!MeshBatchPhysics.Raycast(lastPosition + UnderPlayerAdjustement, Vector3Up, out cachedRaycast, out cachedBoolean, out cachedhitInstance))
{
return(false);
}
if (cachedhitInstance == null)
{
var cachedsack = "Wood_Shelter(Clone)";
var cachedLootableObject = cachedRaycast.collider.gameObject.name;
if (cachedLootableObject == cachedsack)
{
return(true);
}
return(false);
}
var cachedsack2 = "Wood_Shelter(Clone)";
if (cachedhitInstance.graphicalModel.ToString() == cachedsack2)
{
return(true);
}
if (cachedhitInstance.graphicalModel.ToString().Contains(cachedsack2))
{
return(true);
}
if (cachedhitInstance.graphicalModel.ToString() == null)
{
Debug.Log(cachedhitInstance.graphicalModel.ToString());
return(false);
}
return(false);
}
// Start is called before the first frame update
void Start()
{
Instance = this;
server = GameObject.Find("Server").GetComponent <PlayerClient>();
int count = transform.childCount;
for (int i = 0; i < count; i++)
{
var gObj = transform.GetChild(i).GetComponent <ButtonClientSelection>();
var gBtn = transform.GetChild(i).GetComponent <Button>();
gObj.DeselectPlayer1();
gObj.DeselectPlayer2();
gBtn.onClick.AddListener(() =>
{
if (!SelectCountryButton.interactable)
{
return;
}
if (SelectedPlayer2 != null)
{
SelectedPlayer2.DeselectPlayer2();
}
SelectedPlayer2 = gObj;
gObj.SelectPlayer2();
server.SendPlayer2Selection(gObj.name);
/// server.SendPlayer1Selection(gObj.name);
//Debug.Log(gObj.name);
});
}
//SelectPlayer1("PH");
SelectCountryButton.onClick.AddListener(() =>
{
if (SelectedPlayer2 != null)
{
string msg = "CLIENTACTION|SELECTCOUNTRY%" + SelectedPlayer2.name;
server.Send(msg, true);
//Debug.Log("country selected");
//SelectCountryButton.interactable = false;
//SelectCountryButton.transform.GetChild(0).GetComponent<Text>().text = "WAITING FOR OTHER PLAYER";
}
});
}
//Parse json from a file and run it through Player
//Returns output of Player.JsonCommand
private string TestJson(string filePath)
{
string json = ExtractJson(filePath);
List <JToken> finalList = new List <JToken>();
PlayerAdapter aiPlayer = new PlayerAdapter(true, _port);
PlayerClient client = new PlayerClient("localhost", _port);
_port++;
//Parse console input while testing
JsonTextReader reader = new JsonTextReader(new StringReader(json));
reader.SupportMultipleContent = true;
JsonSerializer serializer = new JsonSerializer();
JToken toAdd;
while (true)
{
//Parse console input while testing
if (!reader.Read())
{
break;
}
JToken jtoken = serializer.Deserialize <JToken>(reader);
try
{
toAdd = aiPlayer.JsonCommand(jtoken, "no name", "less dumb", 1);
if (toAdd.Type != JTokenType.Null)
{
finalList.Add(toAdd);
}
}
catch (InvalidJsonInputException)
{
finalList.Add("GO has gone crazy!");
break;
}
}
return(JsonConvert.SerializeObject(finalList));
}
public async Task PlayerClient_GetPlayer_PlayerReturned()
{
// 1. Arrange
HttpClient client = this.WebApplicationFactory.AddPlayer().CreateClient();
Func <String, String> resolver = api => "http://localhost";
IPlayerClient playerClient = new PlayerClient(resolver, client);
String token =
"eyJhbGciOiJSUzI1NiIsImtpZCI6ImVhZDQyNGJjNjI5MzU0NGM4MGFmZThhMDk2MzEyNjU2IiwidHlwIjoiSldUIn0.eyJuYmYiOjE1NzAyODk3MDksImV4cCI6MTU3MDI5MzMwOSwiaXNzIjoiaHR0cDovLzE5Mi4xNjguMS4xMzI6NTAwMSIsImF1ZCI6WyJodHRwOi8vMTkyLjE2OC4xLjEzMjo1MDAxL3Jlc291cmNlcyIsIm1hbmFnZW1lbnRhcGkiLCJzZWN1cmlydHlzZXJ2aWNlYXBpIl0sImNsaWVudF9pZCI6ImdvbGZoYW5kaWNhcC50ZXN0ZGF0YWdlbmVyYXRvciIsInNjb3BlIjpbIm1hbmFnZW1lbnRhcGkiLCJzZWN1cmlydHlzZXJ2aWNlYXBpIl19.vLfs2bOMXshW93nw5TTOqd6NPGNYpcrhcom8yZoYc9WGSuYH48VqM5BdbodEukNNJmgbV9wUVgoj1uGztlFfHGFA_q6IQfd3xZln_LIxju6ZNZs8qUyRXDTGxu0dlfF8STLfBUq469SsY9eNi1hBYFyNxl963OfKqDSHAdeBg9yNlwnbky1Tnsxobu9W33fLcjH0KoutlwTFV51UFUEKCBk0w1zsjaDVZacETn74t56y0CvMS7ZSN2_yyunq4JvoUsh3xM5lQ-gl23eQyo6l4QE4wukCS7U_Zr2dg8-EF63VKiCH-ZD49M76TD9kIIge-XIgHqa2Xf3S-FpLxXfEqw";
// 2. Act
GetPlayerResponse getPlayerResponse =
await playerClient.GetPlayer(token, TestData.PlayerId, CancellationToken.None);
// 3. Assert
getPlayerResponse.Id.ShouldBe(TestData.PlayerId);
}
public async Task GetShot()
{
var clientMock = new Mock <IPlayerHttpClient>();
var response = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("\"A1\"", Encoding.UTF8, "application/json")
};
var configMock = new Mock <IConfiguration>();
configMock.Setup(m => m["Timeouts:getReady"]).Returns("2345");
configMock.Setup(m => m["Timeouts:getShot"]).Returns("1234");
configMock.Setup(m => m["Timeouts:getShots"]).Returns("3456");
Expression <Func <HttpRequestMessage, bool> > check = message =>
message.RequestUri !.ToString() == "getShot?code=key" &&
message.Method == HttpMethod.Post &&
message.Content != null;
clientMock.Setup(m => m.SendAsync(It.Is(check), TimeSpan.FromMilliseconds(1234)))
.Callback <HttpRequestMessage, TimeSpan>((msg, to) =>
{
var shotRequest = msg.Content !.ReadFromJsonAsync <ShotRequest>().Result;
Assert.NotNull(shotRequest);
Assert.Equal("A1", shotRequest !.LastShot);
Assert.NotNull(shotRequest !.Board);
})
.ReturnsAsync(response);
var factoryMock = new Mock <IPlayerHttpClientFactory>();
factoryMock.Setup(m => m.GetHttpClient("https://someApi.com")).Returns(clientMock.Object);
var gameMock = new Mock <ISinglePlayerGame>();
gameMock.SetupGet(m => m.Log).Returns(new List <SinglePlayerGameLogRecord>());
gameMock.SetupGet(m => m.LastShot).Returns(new BoardIndex());
gameMock.SetupGet(m => m.ShootingBoard).Returns(new BoardContent());
var client = new PlayerClient(factoryMock.Object, configMock.Object);
var shot = await client.GetShot("https://someApi.com", gameMock.Object, "key");
factoryMock.VerifyAll();
Assert.Equal("A1", shot);
}
public void IncrementPlayerGems(int playerIndex, int count)
{
if (serverState != ServerState.LevelRunning)
{
return;
}
PlayerClient player = playersByIndex[playerIndex];
if (player == null)
{
return;
}
player.StatsGems += count;
// Number of laps is used only in Treasure Hunt mode
if (currentLevelType == MultiplayerLevelType.TreasureHunt)
{
SendToActivePlayers(new PlayerSetLaps {
Index = (byte)player.Index,
Laps = player.StatsGems,
LapsTotal = treasureHuntTotalGems
}, 4, NetDeliveryMethod.ReliableUnordered, PacketChannels.UnorderedUpdates);
if (player.StatsGems >= treasureHuntTotalGems)
{
// Player collected all gems
serverState = ServerState.LevelComplete;
countdown = 10f;
SendToActivePlayers(new PlayerSetControllable {
IsControllable = false
}, 3, NetDeliveryMethod.ReliableUnordered, PacketChannels.UnorderedUpdates);
Send(new ShowMessage {
Flags = 0x01,
Text = "\n\n\n\f[c:1]Winner!\n\n\f[s:70]You collected " + player.StatsGems + " gems."
}, 72, player.Connection, NetDeliveryMethod.ReliableUnordered, PacketChannels.UnorderedUpdates);
#if DEBUG
Log.Write(LogType.Verbose, "Player #" + player.Index + " collected all gems in " + TimeSpan.FromSeconds(NetTime.Now - levelStartTime));
#endif
}
}
}
void OnPlayerSpawn(PlayerClient player, bool useCamp, RustProto.Avatar avatar)
{
if (KitsConfig["autokit"] == null)
{
return;
}
if (avatar != null && avatar.HasPos && avatar.HasAng)
{
return;
}
object thereturn = Interface.GetMod().CallHook("canRedeemKit", new object[] { player.netUser });
if (thereturn == null)
{
timer.Once(0.01f, () => StripAndGiveKit(player.netUser, "autokit"));
}
}
public static void SV_DropClient(client_t drop)
{
MSG.WriteByte(drop.netchan.message, Defines.svc_disconnect);
if (drop.state == Defines.cs_spawned)
{
PlayerClient.ClientDisconnect(drop.edict);
}
if (drop.download != null)
{
FS.FreeFile(drop.download);
drop.download = null;
}
drop.state = Defines.cs_zombie;
drop.name = "";
}
public void Handle(PlayerClient nClient, QueueAccountPlayerMessage queue)
{
var client = Players.Find(p => p.Client == nClient);
if (client == null)
{
client = new ClientQueue(nClient);
Players.Add(client);
}
var position = (Players.IndexOf(client) + 1);
client.Client.SendMessage(FormatData(position, GetMaxSubscriber(), GetMaxNoSubscriber(), IsSubscribed(nClient.Infos.AccountId)));
if(!client.CanConnect) return;
client.Client.SendMessage("Adxprpgy\0Ac4\0AH601;1;75;1|602;1;75;1\0AlK0\0AQQuel+est+mon+joueur+de+football+pr%C3%A9f%C3%A9r%C3%A9+%3F");
Players.Remove(client);
}
public static void shareWith(PlayerClient senderClient, string[] args)
{
if (args.Count() > 1)
{
PlayerClient[] possibleTargets = Array.FindAll(PlayerClient.All.ToArray(), (PlayerClient pc) => pc.userName.Contains(args[1]));
if (possibleTargets.Count() == 0)
Broadcast.broadcastTo(senderClient.netPlayer, "No player names equal or contain '" + args[1] + "'.");
else if (possibleTargets.Count() > 1)
Broadcast.broadcastTo(senderClient.netPlayer, "Too many player names contain '" + args[1] + "'.");
else
{
PlayerClient targetClient = possibleTargets[0];
string senderUID = senderClient.userID.ToString();
string targetUID = targetClient.userID.ToString();
if (senderUID != null && targetUID != null && senderUID.Length == 17 && targetUID.Length == 17 && senderUID != targetUID)
{
if (Vars.sharingData.ContainsKey(senderUID))
{
if (!Vars.sharingData[senderUID].Contains(targetUID))
{
string oldVal = Vars.sharingData[senderUID];
Vars.sharingData[senderUID] = oldVal + ":" + targetUID;
Broadcast.noticeTo(senderClient.netPlayer, ":D", "Doors shared with " + targetClient.userName + ".");
Broadcast.noticeTo(targetClient.netPlayer, ":D", "You can now open " + senderClient.userName + "'s doors.");
Vars.addDoorData(senderUID, targetUID);
}
else
{
Broadcast.noticeTo(senderClient.netPlayer, ":D", "You have already shared doors with " + targetClient.userName + ".");
}
}
else
{
Vars.sharingData.Add(senderUID, targetUID);
Broadcast.noticeTo(senderClient.netPlayer, ":D", "Doors shared with " + targetClient.userName + ".");
Broadcast.noticeTo(targetClient.netPlayer, ":D", "You can now open " + senderClient.userName + "'s doors.");
Vars.addDoorData(senderUID, targetUID);
}
}
}
}
}
public static void sendToFaction(PlayerClient senderClient, string message)
{
Character senderChar;
Character.FindByUser(senderClient.userID, out senderChar);
string[] factionMembers = Array.Find(factions.ToArray(), (KeyValuePair<string, Dictionary<string, string>> kv) => kv.Value.ContainsKey(senderClient.userID.ToString())).Value.Keys.ToArray();
PlayerClient[] factionClients = Array.FindAll(AllPlayerClients.ToArray(), (PlayerClient pc) => factionMembers.Contains(pc.userID.ToString()));
foreach (PlayerClient targetClient in factionClients)
{
Broadcast.broadcastCustomTo(targetClient.netPlayer, "<F> " + senderClient.userName, message);
}
}
public static void reply(PlayerClient senderClient, string[] args)
{
if (args.Count() > 1)
{
string message = "";
int curIndex = 0;
List<string> messageList = new List<string>();
foreach (string s in args)
{
if (curIndex > 0)
{
messageList.Add(s);
}
curIndex++;
}
message = string.Join(" ", messageList.ToArray());
if (Vars.latestPM.ContainsKey(senderClient))
{
PlayerClient targetClient = Vars.latestPM[senderClient];
if (targetClient.netPlayer.isConnected)
{
message = Vars.replaceQuotes(message);
Vars.conLog.Chat("<PM FROM> " + senderClient.userName + ": " + message);
Vars.conLog.Chat("<PM TO> " + targetClient.userName + ": " + message);
string namePrefixTo = (Vars.nextToName ? "[PM to] " : "");
string msgPrefixTo = (!Vars.nextToName ? "[PM to] " : "");
string namePrefixFrom = (Vars.nextToName ? "[PM from] " : "");
string msgPrefixFrom = (!Vars.nextToName ? "[PM from] " : "");
ConsoleNetworker.SendClientCommand(senderClient.netPlayer, "chat.add \"" + namePrefixTo + targetClient.userName + "\" \"" + msgPrefixTo + message + "\"");
ConsoleNetworker.SendClientCommand(targetClient.netPlayer, "chat.add \"" + namePrefixFrom + senderClient.userName + "\" \"" + msgPrefixFrom + message + "\"");
}
else
{
broadcastTo(senderClient.netPlayer, "Player \"" + targetClient.userName + "\" is not online.");
}
}
else
{
broadcastTo(senderClient.netPlayer, "You do not have anyone to reply to.");
}
}
}
public static void sendToSurrounding(PlayerClient senderClient, string message)
{
Character senderChar;
Character.FindByUser(senderClient.userID, out senderChar);
Vector3 senderPos = senderChar.transform.position;
foreach (PlayerClient targetClient in AllPlayerClients)
{
Character targetChar;
Character.FindByUser(targetClient.userID, out targetChar);
Vector3 targetPos = targetChar.transform.position;
float distance = Vector3.Distance(senderPos, targetPos);
if (distance < directDistance)
{
Broadcast.broadcastCustomTo(targetClient.netPlayer, senderClient.userName, message);
}
}
}
private void OnPlayerSpawned(PlayerClient client)
{
var netUser = client.netUser;
if (!playerData.ContainsKey(netUser)) playerData.Add(netUser, new PlayerData());
playerData[netUser].character = client.controllable.GetComponent<Character>();
playerData[netUser].inventory = client.controllable.GetComponent<PlayerInventory>();
}
public static void showWarps(PlayerClient senderClient)
{
string rank = Vars.findRank(senderClient.userID.ToString());
Broadcast.broadcastTo(senderClient.netPlayer, "Available warps:", true);
Vars.listWarps(rank, senderClient);
}
public static void removerTool(PlayerClient senderClient, string[] args)
{
if (args.Count() > 1)
{
string mode = args[1];
string UID = senderClient.userID.ToString();
switch (mode)
{
case "on":
if (!destroyerList.Contains(UID))
{
if (ownershipList.Contains(UID))
{
Broadcast.broadcastTo(senderClient.netPlayer, "Ownership tool deactivated.");
ownershipList.Remove(UID);
}
Broadcast.broadcastTo(senderClient.netPlayer, "Remover tool activated. Hit AI or structures to delete them.");
destroyerList.Add(UID);
}
else
Broadcast.broadcastTo(senderClient.netPlayer, "You already have the remover tool activated.");
break;
case "off":
if (destroyerList.Contains(UID))
{
Broadcast.broadcastTo(senderClient.netPlayer, "Remover tool deactivated.");
destroyerList.Remove(UID);
}
else
Broadcast.broadcastTo(senderClient.netPlayer, "You do not have the remover tool activated.");
break;
}
}
}
public static void executeCMD(string playerName, string message, uLink.NetworkPlayer player, PlayerClient playerClient, Character playerChar)
{
string[] commandArgs = message.Split(' ');
string command = commandArgs[0];
if (Vars.totalCommands.Contains(command) || (playerChar.netUser.CanAdmin() && commandArgs[0] == "/reload"))
{
if (Vars.enabledCommands[Vars.findRank(playerClient.userID.ToString())].Contains(command) || (playerChar.netUser.CanAdmin() && commandArgs[0] == "/reload"))
{
if (Vars.enabledCommands[Vars.findRank(playerClient.userID.ToString())].Contains("/whitelist check") && message.StartsWith("/whitelist check"))
Vars.whitelistCheck(playerClient);
else if (Vars.enabledCommands[Vars.findRank(playerClient.userID.ToString())].Contains("/f safezone") && message.StartsWith("/f safezone"))
Vars.manageZones(playerClient, commandArgs, true);
else if (Vars.enabledCommands[Vars.findRank(playerClient.userID.ToString())].Contains("/f warzone") && message.StartsWith("/f warzone"))
Vars.manageZones(playerClient, commandArgs, false);
else if (Vars.enabledCommands[Vars.findRank(playerClient.userID.ToString())].Contains("/f build") && message.StartsWith("/f build"))
Vars.handleFactions(playerClient, commandArgs);
else
{
switch (command)
{
case "/client":
Vars.grabClient(playerClient, commandArgs);
break;
case "/clearinv":
Vars.clearPlayer(playerClient, commandArgs);
break;
case "/craft":
Vars.craftTool(playerClient, commandArgs);
break;
case "/vanish":
Vars.vanishTool(playerClient, commandArgs);
break;
case "/hide":
Vars.hideTool(playerClient, commandArgs);
break;
case "/dist":
Vars.showDistance(playerClient, commandArgs);
break;
case "/owner":
Vars.showOwner(playerClient, commandArgs);
break;
case "/removeall":
Vars.removerAllTool(playerClient, commandArgs);
break;
case "/remove":
Vars.removerTool(playerClient, commandArgs);
break;
case "/f":
Vars.handleFactions(playerClient, commandArgs);
break;
case "/r":
Broadcast.reply(playerClient, commandArgs);
break;
case "/rules":
Vars.showRules(playerClient);
break;
case "/players":
Vars.showPlayers(playerClient);
break;
case "/warps":
Vars.showWarps(playerClient);
break;
case "/kits":
Vars.showKits(playerClient);
break;
case "/feed":
Vars.feedPlayer(player, playerName, commandArgs);
break;
case "/heal":
Vars.healPlayer(player, playerName, commandArgs);
break;
case "/access":
Vars.giveAccess(playerClient, commandArgs);
break;
case "/version":
Broadcast.broadcastTo(player, "The server is running Rust Essentials v" + Vars.currentVersion + ".");
break;
case "/save":
Vars.save(playerClient);
break;
case "/saypop":
Vars.saypop(commandArgs);
break;
case "/tppos":
Vars.teleportPos(playerClient, commandArgs);
break;
case "/tphere":
Vars.teleportHere(playerClient, commandArgs);
break;
case "/tpaccept":
Vars.teleportAccept(playerClient, commandArgs);
break;
case "/tpdeny":
Vars.teleportDeny(playerClient, commandArgs);
break;
case "/tpa":
Vars.teleportRequest(playerClient, commandArgs);
break;
case "/tp":
Vars.teleport(playerClient, commandArgs);
break;
case "/history":
Vars.showHistory(playerClient, commandArgs);
break;
case "/unmute":
Vars.mute(playerClient, commandArgs, false);
break;
case "/mute":
Vars.mute(playerClient, commandArgs, true);
break;
case "/stop":
Vars.stopServer();
break;
case "/say":
Vars.say(commandArgs);
break;
case "/chan":
Vars.channels(playerClient, commandArgs);
break;
case "/kickall":
Vars.kickAll(playerClient);
break;
case "/whitelist":
Vars.whitelistPlayer(player, commandArgs);
break;
case "/reload":
Vars.reloadFile(player, commandArgs);
break;
case "/unban":
Vars.unbanPlayer(playerClient, commandArgs);
break;
case "/ban":
Vars.banPlayer(playerClient, commandArgs, false);
break;
case "/bane":
Vars.banPlayer(playerClient, commandArgs, true);
break;
case "/kick":
Vars.kickPlayer(playerClient, commandArgs, false);
break;
case "/kicke":
Vars.kickPlayer(playerClient, commandArgs, true);
break;
case "/daylength":
Vars.setDayLength(playerClient, commandArgs);
break;
case "/nightlength":
Vars.setNightLength(playerClient, commandArgs);
break;
case "/time":
Vars.setTime(playerClient, commandArgs);
break;
case "/join":
Vars.fakeJoin(playerClient, commandArgs);
break;
case "/leave":
Vars.fakeLeave(playerClient, commandArgs);
break;
case "/pos":
Vars.getPlayerPos(playerClient);
break;
case "/i":
Vars.createItem(playerClient, playerClient, commandArgs, message, true);
break;
case "/give":
Vars.createItem(playerClient, commandArgs, message);
break;
case "/giveall":
Vars.giveAll(playerClient, commandArgs);
break;
case "/random":
Vars.giveRandom(playerClient, commandArgs);
break;
case "/warp":
Vars.warpPlayer(playerClient, commandArgs);
break;
case "/kit":
Vars.giveKit(playerClient, commandArgs, message);
break;
case "/airdrop":
Vars.airdrop(player, commandArgs);
break;
case "/share":
Share.shareWith(playerClient, commandArgs);
break;
case "/unshare":
Share.unshareWith(playerClient, commandArgs);
break;
case "/pm":
Broadcast.sendPM(playerName, commandArgs);
break;
case "/online":
Broadcast.sendPlayers(player);
break;
case "/uid":
Vars.grabUID(playerClient, commandArgs);
break;
case "/god":
Vars.godMode(player, playerName, commandArgs, true);
break;
case "/ungod":
Vars.godMode(player, playerName, commandArgs, false);
break;
case "/fall":
Vars.setFall(player, commandArgs);
break;
case "/kill":
Vars.killTarget(player, commandArgs);
break;
case "/help":
Broadcast.help(player, commandArgs);
break;
}
}
}
else
{
Broadcast.noticeTo(player, ":(", "You do not have permission to do this.");
}
}
else
{
if (Vars.unknownCommand)
Broadcast.broadcastTo(player, "Unknown command \"" + command + "\"!");
}
}
public static void setTime(PlayerClient senderClient, string[] args)
{
if (args.Count() > 1)
{
try
{
float time = Convert.ToSingle(args[1]);
Time.setTime(time);
Broadcast.broadcastTo(senderClient.netPlayer, "Time set to " + time.ToString() + ".");
}
catch (Exception ex)
{
if (args[1] == "freeze")
{
Time.freezeTime(true);
Broadcast.broadcastTo(senderClient.netPlayer, "Time has been frozen.");
}
else if (args[1] == "unfreeze")
{
Time.freezeTime(false);
Broadcast.broadcastTo(senderClient.netPlayer, "Time has been unfrozen.");
}
else if (args[1] == "day")
{
Time.setDay();
Broadcast.broadcastTo(senderClient.netPlayer, "Time set to day.");
}
else if (args[1] == "night")
{
Time.setNight();
Broadcast.broadcastTo(senderClient.netPlayer, "Time set to night.");
}
else
{
Broadcast.broadcastTo(senderClient.netPlayer, "Unknown parameters \"" + string.Join(" ", args.ToArray()) + "\".");
}
}
}
else
{
Broadcast.broadcastTo(senderClient.netPlayer, "The time is currently " + Math.Round(Time.getTime(), 2) + ".");
}
}
public static void showDistance(PlayerClient senderClient, string[] args)
{
if (args.Count() > 1)
{
List<string> messageList = new List<string>();
int curIndex = 0;
foreach (string s in args)
{
if (curIndex > 0)
messageList.Add(s);
curIndex++;
}
string targetName = string.Join(" ", messageList.ToArray());
PlayerClient[] possibleTargets = Array.FindAll(AllPlayerClients.ToArray(), (PlayerClient pc) => pc.userName.Contains(targetName));
if (possibleTargets.Count() == 0)
Broadcast.broadcastTo(senderClient.netPlayer, "No players equal or contain \"" + targetName + "\".");
else if (possibleTargets.Count() > 1)
Broadcast.broadcastTo(senderClient.netPlayer, "Too many player names equal or contain \"" + targetName + "\".");
else
{
PlayerClient targetClient = possibleTargets[0];
Character targetChar;
Character.FindByUser(targetClient.userID, out targetChar);
Character senderChar;
Character.FindByUser(senderClient.userID, out senderChar);
Vector2 targetPos = new Vector2(targetChar.transform.position.x, targetChar.transform.position.z);
Vector2 senderPos = new Vector2(senderChar.transform.position.x, senderChar.transform.position.z);
Broadcast.broadcastTo(senderClient.netPlayer, "Distance: " + Vector2.Distance(targetPos, senderPos) + "m.");
}
}
}
private object OnClientSpeak(PlayerClient client, int total)
{
var players = (List<uLink.NetworkPlayer>)playerList.GetValue(null);
var num = Interface.CallHook("OnPlayerVoice", client.netUser, players);
playerList.SetValue(null, players);
return (num != null) ? (int) num : num;
}
void ShowTalker(uLink.NetworkPlayer player, PlayerClient p)
{
}
public static void showPlayers(PlayerClient senderClient)
{
Broadcast.broadcastTo(senderClient.netPlayer, "All online players:", true);
List<string> names = new List<string>();
List<string> names2 = new List<string>();
foreach (PlayerClient pc in AllPlayerClients.ToArray())
{
if (pc.userName.Length > 0)
names.Add(pc.userName);
}
List<string> otherNames = new List<string>();
while (names.Count > 0)
{
names2.Clear();
otherNames.Clear();
foreach (string s in names)
{
names2.Add(s);
otherNames.Add(s);
if ((string.Join(", ", names2.ToArray())).Length > 70)
{
names2.Remove(s);
otherNames.Remove(s);
break;
}
}
foreach (string s in otherNames)
{
names.Remove(s);
}
Broadcast.broadcastTo(senderClient.netPlayer, string.Join(", ", names2.ToArray()), true);
}
}
public static void showRules(PlayerClient senderClient)
{
if (motdList.ContainsKey("Rules"))
{
foreach (string s in motdList["Rules"])
{
Broadcast.broadcastTo(senderClient.netPlayer, s);
}
}
}
public static void save(PlayerClient senderClient)
{
try
{
ConsoleSystem.Run("save.all");
Broadcast.broadcastTo(senderClient.netPlayer, "All data has been saved.");
} catch (Exception ex)
{
Broadcast.broadcastTo(senderClient.netPlayer, ex.ToString());
}
}
public static void setNightLength(PlayerClient senderClient, string[] args)
{
if (args.Count() > 1)
{
try
{
if (!timeFrozen)
{
float length = Convert.ToSingle(args[1]);
Time.setNightLength(length);
Broadcast.broadcastTo(senderClient.netPlayer, "Night length set to " + length.ToString() + " minutes.");
}
else
{
Broadcast.broadcastTo(senderClient.netPlayer, "Time is currently frozen! Unfreeze time to change the night length.");
}
}
catch (Exception ex)
{
Broadcast.broadcastTo(senderClient.netPlayer, "Night length must be a number!");
conLog.Error("SNL: " + ex.ToString());
}
}
else
{
Broadcast.broadcastTo(senderClient.netPlayer, "The night length is currently " + Time.getDayLength() + ".");
}
}
public static void requestTimeout(PlayerClient targetClient, PlayerClient senderClient)
{
if (teleportRequests[targetClient].ContainsKey(senderClient))
{
teleportRequests[targetClient].Remove(senderClient);
Broadcast.broadcastTo(senderClient.netPlayer, "Request to teleport to " + targetClient.userName + " has timed out.");
}
}
public static void SetDeathReason(PlayerClient playerClient, ref DamageEvent damage)
{
try
{
if (playerClient != null)
{
if (playerClient.netPlayer != null)
{
if (NetCheck.PlayerValid(playerClient.netPlayer))
{
IDMain idMain = damage.attacker.idMain;
string message = "";
if (idMain != null)
{
idMain = idMain.idMain;
if (idMain is Character)
{
Character character = idMain as Character;
Controller playerControlledController = character.playerControlledController;
if (playerControlledController != null)
{
if (playerControlledController.playerClient == playerClient)
{
if (killList.Contains(playerClient))
{
killList.Remove(playerClient);
DeathScreen.SetReason(playerClient.netPlayer, "You fell victim to /kill");
Broadcast.broadcastAll(playerClient.userName + " fell victim to /kill.");
}
else
{
DeathScreen.SetReason(playerClient.netPlayer, "You killed yourself. You silly sod.");
if (Vars.suicideMessages)
{
message = Vars.suicideMessage.Replace("$VICTIM$", playerClient.userName);
Broadcast.broadcastAll(message);
}
}
return;
}
Character killerChar;
Character victimChar;
Character.FindByUser(playerControlledController.playerClient.userID, out killerChar);
Character.FindByUser(playerClient.userID, out victimChar);
Vector3 killerPos = killerChar.transform.position;
Vector3 victimPos = victimChar.transform.position;
double distance = Math.Round(Vector3.Distance(killerPos, victimPos));
WeaponImpact extraData = damage.extraData as WeaponImpact;
if (wasHit.Contains(playerClient))
{
wasHit.Remove(playerClient);
}
if (extraData != null)
{
if (Vars.murderMessages)
{
message = Vars.murderMessage.Replace("$VICTIM$", playerClient.userName).Replace("$KILLER$", playerControlledController.playerClient.userName).Replace("$WEAPON$", extraData.dataBlock.name).Replace("$PART$", BodyParts.GetNiceName(damage.bodyPart)).Replace("$DISTANCE$", Convert.ToString(distance) + "m");
Broadcast.broadcastAll(message);
}
DeathScreen.SetReason(playerClient.netPlayer, playerControlledController.playerClient.userName + " killed you using a " + extraData.dataBlock.name + " with a hit to your " + BodyParts.GetNiceName(damage.bodyPart));
return;
}
if (Vars.murderMessages)
{
message = Vars.murderMessageUnknown.Replace("$VICTIM$", playerClient.userName).Replace("$KILLER$", playerControlledController.playerClient.userName);
Broadcast.broadcastAll(message);
}
DeathScreen.SetReason(playerClient.netPlayer, playerControlledController.playerClient.userName + " killed you with a hit to your " + BodyParts.GetNiceName(damage.bodyPart));
return;
}
}
string killer = idMain.ToString();
if (killer.Contains("(Clone)"))
killer = killer.Substring(0, killer.IndexOf("(Clone)"));
switch (killer)
{
case "MutantBear":
killer = "Mutant Bear";
break;
case "MutantWolf":
killer = "Mutant Wolf";
break;
}
Character victimChar2;
Character.FindByUser(playerClient.userID, out victimChar2);
if (Vars.accidentMessages)
{
message = Vars.accidentMessage.Replace("$VICTIM$", victimChar2.netUser.displayName).Replace("$KILLER$", killer);
Broadcast.broadcastAll(message);
}
DeathScreen.SetReason(playerClient.netPlayer, "You were killed by a " + killer);
}
}
}
}
}
catch (Exception ex)
{
Vars.conLog.Error("SDR: " + ex.ToString());
}
}
public static void removeItem(PlayerClient playerClient, IInventoryItem item)
{
Inventory inventory = playerClient.controllable.GetComponent<Inventory>();
inventory.RemoveItem(item.slot);
}
private void OnPlayerSpawn(PlayerClient client, bool useCamp, RustProto.Avatar avatar)
{
HookCalled("OnPlayerSpawn");
// Print spawn location in console
Puts("Player " + client.netUser.displayName + " spawned at " + client.lastKnownPosition + ".");
Puts("Player did " + (useCamp ? "" : "not ") + "select a sleepingbag to spawn at.");
// Doing stuff with the player needs to wait until the next frame
NextTick(() =>
{
// Print start metabolism values in console
var player = client.controllable;
var character = player.character;
var metabolism = character.GetComponent<Metabolism>();
Puts(client.netUser.displayName + " currently has the following Metabolism values:");
Puts(" Health: " + character.health.ToString());
Puts(" Calories: " + metabolism.GetCalorieLevel().ToString());
Puts(" Radiation: " + metabolism.GetRadLevel().ToString());
// Give admin items for testing
if (client.netUser.CanAdmin())
{
var inventory = player.GetComponent<Inventory>();
var pref = Inventory.Slot.Preference.Define(Inventory.Slot.Kind.Belt, false, Inventory.Slot.KindFlags.Belt);
var item = DatablockDictionary.GetByName("Uber Hatchet");
inventory.AddItemAmount(item, 1, pref);
}
});
}
public static void showHistory(PlayerClient senderClient, string[] args)
{
if (args.Count() > 1)
{
try
{
int lineAmount = Convert.ToInt16(args[1]);
if (lineAmount > 50)
lineAmount = 50;
int curIndex = 0;
int goalIndex = historyGlobal.Count - lineAmount;
foreach (string s in historyGlobal)
{
if (curIndex >= goalIndex)
{
string playerName = s.Split(new string[] { "$:|:$" }, StringSplitOptions.None)[0].ToString();
string message = s.Split(new string[] { "$:|:$" }, StringSplitOptions.None)[1].ToString();
Broadcast.broadcastCustomTo(senderClient.netPlayer, playerName, message);
}
curIndex++;
}
}
catch (Exception ex)
{
Broadcast.broadcastTo(senderClient.netPlayer, "Line amount must be an integer!");
}
}
else
{
Broadcast.broadcastTo(senderClient.netPlayer, "You must specify a number, 1 - 50, of lines!");
}
}
public static void teleport(PlayerClient senderClient, string[] args)
{
if (args.Count() > 1)
{
RustServerManagement serverManagement = RustServerManagement.Get();
List<string> playerNameList = new List<string>();
int quotedNames = 0;
bool searchingQuotes = false;
int curIndex = 0;
foreach (string s in args)
{
if (curIndex > 0)
{
playerNameList.Add(s);
if (s.StartsWith("\"") && !searchingQuotes)
searchingQuotes = true;
if (playerNameList.Count > 1 && searchingQuotes && s.EndsWith("\""))
{
quotedNames++;
}
}
curIndex++;
}
string playerName = string.Join(" ", playerNameList.ToArray());
if (args.Count() == 2 || quotedNames == 1)
{
if (playerName.StartsWith("\"") && playerName.EndsWith("\""))
{
playerName = playerName.Substring(1, playerName.Length - 2);
PlayerClient[] possibleTargets = Array.FindAll(AllPlayerClients.ToArray(), (PlayerClient pc) => pc.userName.Equals(playerName));
if (possibleTargets.Count() == 0)
Broadcast.broadcastTo(senderClient.netPlayer, "No player names equal \"" + playerName + "\".");
else if (possibleTargets.Count() > 1)
Broadcast.broadcastTo(senderClient.netPlayer, "Too many player names equal \"" + playerName + "\".");
else
{
PlayerClient targetClient = possibleTargets[0];
Character senderChar;
Character.FindByUser(senderClient.userID, out senderChar);
Character targetChar;
Character.FindByUser(targetClient.userID, out targetChar);
Vector3 destination = targetChar.transform.position;
Vector3 oldDest = destination;
oldDest.y += 1;
if (Vector3.Distance(destination, senderChar.transform.position) > 375)
destination.y += 8;
serverManagement.TeleportPlayerToWorld(senderClient.netPlayer, destination);
TimerPlus tp = new TimerPlus();
tp.AutoReset = false;
tp.Interval = 500;
tp.Elapsed += ((sender, e) => teleportToWorldElapsed(senderClient.netPlayer, oldDest));
tp.Start();
Broadcast.broadcastTo(senderClient.netPlayer, "Teleporting to " + targetClient.userName + "...");
}
}
else
{
PlayerClient[] possibleTargets = Array.FindAll(AllPlayerClients.ToArray(), (PlayerClient pc) => pc.userName.Contains(playerName));
if (possibleTargets.Count() == 0)
Broadcast.broadcastTo(senderClient.netPlayer, "No player names equal or contain \"" + playerName + "\".");
else if (possibleTargets.Count() > 1)
Broadcast.broadcastTo(senderClient.netPlayer, "Too many player names contain \"" + playerName + "\".");
else
{
PlayerClient targetClient = possibleTargets[0];
Character senderChar;
Character.FindByUser(senderClient.userID, out senderChar);
Character targetChar;
Character.FindByUser(targetClient.userID, out targetChar);
Vector3 destination = targetChar.transform.position;
Vector3 oldDest = destination;
oldDest.y += 1;
if (Vector3.Distance(destination, senderChar.transform.position) > 375)
destination.y += 8;
serverManagement.TeleportPlayerToWorld(senderClient.netPlayer, destination);
TimerPlus tp = new TimerPlus();
tp.AutoReset = false;
tp.Interval = 500;
tp.Elapsed += ((sender, e) => teleportToWorldElapsed(senderClient.netPlayer, oldDest));
tp.Start();
Broadcast.broadcastTo(senderClient.netPlayer, "Teleporting to " + targetClient.userName + "...");
}
}
}
else
{
playerNameList.Clear();
curIndex = 0;
int lastIndex = -1;
if (args[1].Contains("\""))
{
bool hadQuote = false;
foreach (string s in args)
{
lastIndex++;
if (s.StartsWith("\"")) hadQuote = true;
if (hadQuote)
{
playerNameList.Add(s.Replace("\"", ""));
}
if (s.EndsWith("\""))
{
hadQuote = false;
break;
}
}
}
else
{
playerNameList.Add(args[1]);
lastIndex = 1;
}
playerName = string.Join(" ", playerNameList.ToArray());
PlayerClient[] possibleTargets = Array.FindAll(AllPlayerClients.ToArray(), (PlayerClient pc) => pc.userName.Contains(playerName));
if (possibleTargets.Count() == 0)
Broadcast.broadcastTo(senderClient.netPlayer, "No player names equal or contain \"" + playerName + "\".");
else if (possibleTargets.Count() > 1)
Broadcast.broadcastTo(senderClient.netPlayer, "Too many player names contain \"" + playerName + "\".");
else
{
PlayerClient targetClient = possibleTargets[0];
playerNameList.Clear();
if (args[lastIndex + 1].Contains("\""))
{
bool hadQuote = false;
curIndex = 0;
foreach (string s in args)
{
if (curIndex > lastIndex)
{
if (s.StartsWith("\"")) hadQuote = true;
if (hadQuote)
{
playerNameList.Add(s.Replace("\"", ""));
}
if (s.EndsWith("\""))
{
hadQuote = false;
break;
}
}
curIndex++;
}
}
else
{
playerNameList.Add(args[lastIndex + 1]);
}
playerName = string.Join(" ", playerNameList.ToArray());
PlayerClient[] otherTargets = Array.FindAll(AllPlayerClients.ToArray(), (PlayerClient pc) => pc.userName.Contains(playerName));
if (otherTargets.Count() == 0)
Broadcast.broadcastTo(senderClient.netPlayer, "No player names equal or contain \"" + playerName + "\".");
else if (otherTargets.Count() > 1)
Broadcast.broadcastTo(senderClient.netPlayer, "Too many player names contain \"" + playerName + "\".");
else
{
PlayerClient targetClient2 = otherTargets[0];
Character targetChar;
Character.FindByUser(targetClient.userID, out targetChar);
Character targetChar2;
Character.FindByUser(targetClient2.userID, out targetChar2);
Vector3 destination = targetChar2.transform.position;
Vector3 oldDest = destination;
oldDest.y += 1;
if (Vector3.Distance(destination, targetChar.transform.position) > 375)
destination.y += 8;
serverManagement.TeleportPlayerToWorld(targetClient.netPlayer, destination);
TimerPlus tp = new TimerPlus();
tp.AutoReset = false;
tp.Interval = 500;
tp.Elapsed += ((sender, e) => teleportToWorldElapsed(targetClient.netPlayer, oldDest));
tp.Start();
Broadcast.broadcastTo(senderClient.netPlayer, "Teleporting \"" + targetClient.userName + "\" to \"" + targetClient2.userName + "\"...");
}
}
}
}
}
void OnPlayerSpawn(PlayerClient player, bool useCamp, RustProto.Avatar avatar)
{
if (KitsConfig["autokit"] == null) return;
if (avatar != null && avatar.HasPos && avatar.HasAng) return;
object thereturn = Interface.GetMod().CallHook("canRedeemKit", new object[] { player.netUser });
if (thereturn == null)
{
timer.Once(0.01f, () => StripAndGiveKit(player.netUser, "autokit"));
}
}
public static void showOwner(PlayerClient senderClient, string[] args)
{
if (args.Count() > 1)
{
string mode = args[1];
string UID = senderClient.userID.ToString();
switch (mode)
{
case "on":
if (!ownershipList.Contains(UID))
{
if (destroyerList.Contains(UID))
{
Broadcast.broadcastTo(senderClient.netPlayer, "Remover tool deactivated.");
destroyerList.Remove(UID);
}
Broadcast.broadcastTo(senderClient.netPlayer, "Ownership tool activated. Hit structures to show who owns them.");
ownershipList.Add(UID);
}
else
Broadcast.broadcastTo(senderClient.netPlayer, "You already have the ownership tool activated.");
break;
case "off":
if (ownershipList.Contains(UID))
{
Broadcast.broadcastTo(senderClient.netPlayer, "Ownership tool deactivated.");
ownershipList.Remove(UID);
}
else
Broadcast.broadcastTo(senderClient.netPlayer, "You do not have the ownership tool activated.");
break;
default:
Broadcast.broadcastTo(senderClient.netPlayer, "Unknown argument \"" + mode + "\".");
break;
}
}
}
