public void ServerInput(Snapshot snapshot)
{
if (!ServerMgr.Active)
{
return;
}
ServerMgr.Input(this.fd, snapshot, true);
}
protected void SendTextMessage(Player p, String text, ServerMgr server)
{
NetOutgoingMessage msg = server.CreateNetMessage();
msg.Write((int)PacketType.SHOW_ALLERT_MESSAGE);
msg.Write(text);
msg.Write(AlertMessageManager.TIME_INFINITE);
server.SendMessage(msg, p);
}
protected void SendPlayerScore(Player p, ServerMgr server)
{
NetOutgoingMessage msg = server.CreateNetMessage();
msg.Write((int)PacketType.PLAYER_SCORE_UPDATE);
msg.Write(p.GetId());
msg.Write(p.Data.MatchPoints);
msg.Write(p.Data.Score);
server.BroadcastMessage(msg);
}
public static void Postfix(ServerMgr __instance)
{
try
{
ModLoader.Scripts?.Update();
ModLoader.Scripts?.Broadcast("Update");
}
catch (Exception e)
{
Debug.LogException(e);
}
}
public static void reset(Arg args)
{
if ((bool)SingletonComponent <Climate> .Instance)
{
SingletonComponent <Climate> .Instance.WeatherOverrides.Reset();
if (args.IsServerside)
{
ServerMgr.SendReplicatedVars("weather.");
}
}
}
public virtual void OnMatchEnd(Player plr, GameEnd endType, float time, ServerMgr server)
{
if (endType != GameEnd.WIN_GAME)
{
return;
}
Player looser = players.Find(p => p.IsActivePlayer() && p.Data.HashId != plr.Data.HashId);
SetPlayedTogether(plr, looser);
RewardPlayers(plr, looser, server);
}
public void Input(Snapshot snapshot)
{
this.RunEvent(snapshot);
if (!ServerMgr.Active)
{
ClientMgr.Input(snapshot);
}
else
{
ServerMgr.Input(this.fd, snapshot, false);
}
}
public static void SendNewObject(ServerMgr serverMgr, ISceneObject obj)
{
if (!(obj is ISendable))
{
Logger.Error("Trying to send " + obj.GetType().Name + " but it is not ISendable");
return;
}
NetOutgoingMessage msg = serverMgr.CreateNetMessage();
(obj as ISendable).WriteObject(msg);
serverMgr.BroadcastMessage(msg);
}
public static void snapshot(Arg arg)
{
BasePlayer basePlayer = ArgEx.Player(arg);
if (!(basePlayer == null))
{
UnityEngine.Debug.Log("Sending full snapshot to " + basePlayer);
basePlayer.SendNetworkUpdateImmediate();
basePlayer.SendGlobalSnapshot();
basePlayer.SendFullSnapshot();
ServerMgr.SendReplicatedVars(basePlayer.net.connection);
}
}
public void Save()
{
try
{
var xml = ToXml(); //UTools.XmlHelper.XmlSerialize(this, Encoding.UTF8);
UTools.FileHelper.CreatePath(HeadInfo.Path);
UTools.FileHelper.WriteFileStr(PathName, xml);
ServerMgr.Save();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
/*
* // 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();
}
}
public static void Respawn(BasePlayer player, bool newPos)
{
++ServerPerformance.spawns;
if (newPos)
{
BasePlayer.SpawnPoint spawnPoint = ServerMgr.FindSpawnPoint();
player.transform.position = spawnPoint.pos;
player.transform.rotation = spawnPoint.rot;
}
player.supressSnapshots = true;
player.StopSpectating();
player.UpdateNetworkGroup();
player.UpdatePlayerCollider(true, false);
player.StartSleeping();
player.metabolism.Reset();
player.inventory.GiveDefaultItems();
player.SendFullSnapshot();
}
public static IGameLevel CreateNewGameLevel(ServerMgr mgr, GameLevel lvl)
{
IGameLevel newLvl = null;
switch (lvl)
{
case GameLevel.BASIC_MAP:
newLvl = new LevelBasic(mgr);
break;
case GameLevel.SURVIVAL_MAP:
newLvl = new LevelSurvival(mgr);
break;
// testovaci
case GameLevel.TEST_EMPTY:
newLvl = new LevelTestEmpty(mgr);
break;
case GameLevel.TEST_BASE_COLLISIONS:
newLvl = new LevelTestBaseCollisions(mgr);
break;
case GameLevel.TEST_POWERUPS:
newLvl = new LevelTestPoweUp(mgr);
break;
case GameLevel.TEST_STATIC_OBJ:
newLvl = new LevelTestStaticObjects(mgr);
break;
case GameLevel.TEST_PARTICLES:
newLvl = new LevelTestParticles(mgr);
break;
case GameLevel.TEST_BURNING_ASTEROIDS:
newLvl = new LevelTestBurningAsteroids(mgr);
break;
}
return(newLvl);
}
protected override void RewardPlayers(Player winner, Player looser, ServerMgr server)
{
winner.Data.WonMatches++;
int scoreWin = ComputeScoreWinner(winner, looser, server.Time);
int scoreLoose = ComputeScoreLooser(looser, winner, server.Time);
winner.Data.Score += scoreWin;
looser.Data.Score += scoreLoose;
SendPlayerScore(winner, server);
SendPlayerScore(looser, server);
SendTextMessage(winner, String.Format(Strings.Culture, Strings.mm_victory_reward, scoreWin), server);
SendTextMessage(looser, String.Format(Strings.Culture, Strings.mm_lost_reward, scoreLoose), server);
foreach (Player p in players)
{
p.Data.MatchPoints = 0;
if (!p.IsActivePlayer())
{
RewardSpectator(winner, p, scoreWin, scoreLoose, server.Time, server);
}
}
}
void OnDestroy()
{
Ins = null;
}
public LevelTestBaseCollisions(ServerMgr serverMgr) : base(serverMgr)
{
}
public LevelTestParticles(ServerMgr serverMgr)
: base(serverMgr)
{
rand = mgr.GetRandomGenerator();
}
void Awake()
{
Ins = this;
ServerSocketMgr.RegistRecMsg(Default.CMD_KB, () => new Cmd4RecKB());
ServerSocketMgr.RegistRecMsg(Default.CMD_MOUSE, () => new Cmd4RecMouse());
}
public static IEnumerator StartServer(bool doLoad, string saveFileOverride, bool allowOutOfDateSaves)
{
float single = UnityEngine.Time.timeScale;
if (ConVar.Time.pausewhileloading)
{
UnityEngine.Time.timeScale = 0f;
}
RCon.Initialize();
BaseEntity.Query.Server = new BaseEntity.Query.EntityTree(8096f);
if (SingletonComponent <WorldSetup> .Instance)
{
yield return(SingletonComponent <WorldSetup> .Instance.StartCoroutine(SingletonComponent <WorldSetup> .Instance.InitCoroutine()));
}
if (SingletonComponent <DynamicNavMesh> .Instance && SingletonComponent <DynamicNavMesh> .Instance.enabled && !AiManager.nav_disable)
{
yield return(SingletonComponent <DynamicNavMesh> .Instance.StartCoroutine(SingletonComponent <DynamicNavMesh> .Instance.UpdateNavMeshAndWait()));
}
if (SingletonComponent <AiManager> .Instance && SingletonComponent <AiManager> .Instance.enabled)
{
SingletonComponent <AiManager> .Instance.Initialize();
if (!AiManager.nav_disable && AI.npc_enable && TerrainMeta.Path != null)
{
foreach (MonumentInfo monument in TerrainMeta.Path.Monuments)
{
if (!monument.HasNavmesh)
{
continue;
}
yield return(monument.StartCoroutine(monument.GetMonumentNavMesh().UpdateNavMeshAndWait()));
}
}
}
GameObject gameObject = GameManager.server.CreatePrefab("assets/bundled/prefabs/system/server.prefab", true);
UnityEngine.Object.DontDestroyOnLoad(gameObject);
ServerMgr component = gameObject.GetComponent <ServerMgr>();
component.Initialize(doLoad, saveFileOverride, allowOutOfDateSaves, false);
yield return(CoroutineEx.waitForSecondsRealtime(0.1f));
ColliderGrid.RefreshAll();
yield return(CoroutineEx.waitForSecondsRealtime(0.1f));
SaveRestore.InitializeEntityLinks();
yield return(CoroutineEx.waitForSecondsRealtime(0.1f));
SaveRestore.InitializeEntitySupports();
yield return(CoroutineEx.waitForSecondsRealtime(0.1f));
SaveRestore.InitializeEntityConditionals();
yield return(CoroutineEx.waitForSecondsRealtime(0.1f));
ColliderGrid.RefreshAll();
yield return(CoroutineEx.waitForSecondsRealtime(0.1f));
SaveRestore.GetSaveCache();
yield return(CoroutineEx.waitForSecondsRealtime(0.1f));
component.OpenConnection();
if (ConVar.Time.pausewhileloading)
{
UnityEngine.Time.timeScale = single;
}
Bootstrap.WriteToLog("Server startup complete");
}
protected virtual void RewardPlayers(Player winner, Player looser, ServerMgr server)
{
}
public LevelTestEmpty(ServerMgr serverMgr) : base(serverMgr)
{
}
public void OnMatchEnd(Player plr, GameEnd endType, float totalTime, ServerMgr server)
{
}
/// <summary>
/// Initializes a new instance of the RustServer class
/// </summary>
public RustServer()
{
mgr = ServerMgr.Instance;
}
public static void restart(ConsoleSystem.Arg args)
{
ServerMgr.RestartServer(args.GetString(1, string.Empty), args.GetInt(0, 300));
}
/// <summary>
/// Initializes a new instance of the RustServer class
/// </summary>
public RustServer()
{
mgr = ServerMgr.Instance;
}
public LevelTestPoweUp(ServerMgr serverMgr) : base(serverMgr)
{
events.AddEvent(1, new Event(0.2f, EventType.REPEATABLE, new Action(() => GameLevelManager.CreateAndSendNewStatPowerup(mgr))));
}
public LevelBasic(ServerMgr serverMgr) : base(serverMgr)
{
events.AddEvent((int)Events.ADDITIONAL_ASTEROID, new Event(SharedDef.NEW_ASTEROID_TIMER, EventType.REPEATABLE, new Action(() => CreateAndSendAdditionalAsteroid())));
events.AddEvent((int)Events.NEW_STAT_POWERUP, new Event(1, EventType.REPEATABLE, new Action(() => CreateAndSendNewStatPowerup())));
}
static bool Prefix(ServerMgr serverMgr)
{
if (!SteamServer.IsValid)
{
return(false);
}
using (TimeWarning.New("UpdateServerInformation", 0))
{
SteamServer.ServerName = ConVar.Server.hostname;
SteamServer.MaxPlayers = ConVar.Server.maxplayers;
SteamServer.Passworded = false;
SteamServer.MapName = global::World.Name;
string text = "stok";
if (serverMgr.Restarting)
{
text = "strst";
}
string text2 = string.Format("born{0}", Epoch.FromDateTime(global::SaveRestore.SaveCreatedTime));
string text3 = string.Format("gm{0}", global::ServerMgr.GamemodeName());
SteamServer.GameTags = string.Format("mp{0},cp{1},qp{5},v{2}{3},h{4},{6},{7},{8}", new object[]
{
ConVar.Server.maxplayers,
global::BasePlayer.activePlayerList.Count,
typeof(Protocol).GetFields().Single(x => x.Name == "network").GetRawConstantValue(),
ConVar.Server.pve ? ",pve" : string.Empty,
AssemblyHash,
SingletonComponent <global::ServerMgr> .Instance.connectionQueue.Queued,
text,
text2,
text3
});
Interface.CallHook("IOnUpdateServerInformation");
if (ConVar.Server.description != null && ConVar.Server.description.Length > 100)
{
string[] array = ConVar.Server.description.SplitToChunks(100).ToArray <string>();
Interface.CallHook("IOnUpdateServerDescription");
for (int i = 0; i < 16; i++)
{
if (i < array.Length)
{
SteamServer.SetKey(string.Format("description_{0:00}", i), array[i]);
}
else
{
SteamServer.SetKey(string.Format("description_{0:00}", i), string.Empty);
}
}
}
else
{
SteamServer.SetKey("description_0", ConVar.Server.description);
for (int j = 1; j < 16; j++)
{
SteamServer.SetKey(string.Format("description_{0:00}", j), string.Empty);
}
}
SteamServer.SetKey("hash", AssemblyHash);
SteamServer.SetKey("world.seed", global::World.Seed.ToString());
SteamServer.SetKey("world.size", global::World.Size.ToString());
SteamServer.SetKey("pve", ConVar.Server.pve.ToString());
SteamServer.SetKey("headerimage", ConVar.Server.headerimage);
SteamServer.SetKey("url", ConVar.Server.url);
SteamServer.SetKey("gmn", global::ServerMgr.GamemodeName());
SteamServer.SetKey("gmt", global::ServerMgr.GamemodeTitle());
SteamServer.SetKey("gmd", global::ServerMgr.GamemodeDesc());
SteamServer.SetKey("gmu", global::ServerMgr.GamemodeUrl());
SteamServer.SetKey("uptime", ((int)UnityEngine.Time.realtimeSinceStartup).ToString());
SteamServer.SetKey("gc_mb", global::Performance.report.memoryAllocations.ToString());
SteamServer.SetKey("gc_cl", global::Performance.report.memoryCollections.ToString());
SteamServer.SetKey("fps", global::Performance.report.frameRate.ToString());
SteamServer.SetKey("fps_avg", global::Performance.report.frameRateAverage.ToString("0.00"));
SteamServer.SetKey("ent_cnt", global::BaseNetworkable.serverEntities.Count.ToString());
SteamServer.SetKey("build", BuildInfo.Current.Scm.ChangeId);
}
return(false);
}
public static IEnumerator StartServer(bool doLoad, string saveFileOverride, bool allowOutOfDateSaves)
{
float timeScale = UnityEngine.Time.timeScale;
if (ConVar.Time.pausewhileloading)
{
UnityEngine.Time.timeScale = 0f;
}
RCon.Initialize();
BaseEntity.Query.Server = new BaseEntity.Query.EntityTree(8096f);
if ((bool)SingletonComponent <WorldSetup> .Instance)
{
yield return(SingletonComponent <WorldSetup> .Instance.StartCoroutine(SingletonComponent <WorldSetup> .Instance.InitCoroutine()));
}
if ((bool)SingletonComponent <DynamicNavMesh> .Instance && SingletonComponent <DynamicNavMesh> .Instance.enabled && !AiManager.nav_disable)
{
yield return(SingletonComponent <DynamicNavMesh> .Instance.StartCoroutine(SingletonComponent <DynamicNavMesh> .Instance.UpdateNavMeshAndWait()));
}
if ((bool)SingletonComponent <AiManager> .Instance && SingletonComponent <AiManager> .Instance.enabled)
{
SingletonComponent <AiManager> .Instance.Initialize();
if (!AiManager.nav_disable && AI.npc_enable && TerrainMeta.Path != null)
{
foreach (MonumentInfo monument in TerrainMeta.Path.Monuments)
{
if (monument.HasNavmesh)
{
yield return(monument.StartCoroutine(monument.GetMonumentNavMesh().UpdateNavMeshAndWait()));
}
}
if ((bool)TerrainMeta.Path && (bool)TerrainMeta.Path.DungeonRoot)
{
DungeonNavmesh dungeonNavmesh = TerrainMeta.Path.DungeonRoot.AddComponent <DungeonNavmesh>();
dungeonNavmesh.NavMeshCollectGeometry = NavMeshCollectGeometry.PhysicsColliders;
dungeonNavmesh.LayerMask = 65537;
yield return(dungeonNavmesh.StartCoroutine(dungeonNavmesh.UpdateNavMeshAndWait()));
}
else
{
Debug.LogError("Failed to find DungeonRoot, NOT generating Dungeon navmesh");
}
}
}
GameObject gameObject = GameManager.server.CreatePrefab("assets/bundled/prefabs/system/server.prefab");
Object.DontDestroyOnLoad(gameObject);
ServerMgr serverMgr = gameObject.GetComponent <ServerMgr>();
serverMgr.Initialize(doLoad, saveFileOverride, allowOutOfDateSaves);
yield return(CoroutineEx.waitForSecondsRealtime(0.1f));
SaveRestore.InitializeEntityLinks();
yield return(CoroutineEx.waitForSecondsRealtime(0.1f));
SaveRestore.InitializeEntitySupports();
yield return(CoroutineEx.waitForSecondsRealtime(0.1f));
SaveRestore.InitializeEntityConditionals();
yield return(CoroutineEx.waitForSecondsRealtime(0.1f));
SaveRestore.GetSaveCache();
yield return(CoroutineEx.waitForSecondsRealtime(0.1f));
BaseGameMode.CreateGameMode();
yield return(CoroutineEx.waitForSecondsRealtime(0.1f));
serverMgr.OpenConnection();
CompanionServer.Server.Initialize();
using (BenchmarkTimer.New("Boombox.LoadStations"))
{
BoomBox.LoadStations();
}
if (ConVar.Time.pausewhileloading)
{
UnityEngine.Time.timeScale = timeScale;
}
WriteToLog("Server startup complete");
}
public static IEnumerator StartServer(
bool doLoad,
string saveFileOverride,
bool allowOutOfDateSaves)
{
float timeScale = Time.get_timeScale();
if (Time.pausewhileloading)
{
Time.set_timeScale(0.0f);
}
RCon.Initialize();
BaseEntity.Query.Server = new BaseEntity.Query.EntityTree(8096f);
if (Object.op_Implicit((Object)SingletonComponent <WorldSetup> .Instance))
{
yield return((object)((MonoBehaviour)SingletonComponent <WorldSetup> .Instance).StartCoroutine(((WorldSetup)SingletonComponent <WorldSetup> .Instance).InitCoroutine()));
}
if (Object.op_Implicit((Object)SingletonComponent <DynamicNavMesh> .Instance) && ((Behaviour)SingletonComponent <DynamicNavMesh> .Instance).get_enabled() && !AiManager.nav_disable)
{
yield return((object)((MonoBehaviour)SingletonComponent <DynamicNavMesh> .Instance).StartCoroutine(((DynamicNavMesh)SingletonComponent <DynamicNavMesh> .Instance).UpdateNavMeshAndWait()));
}
if (Object.op_Implicit((Object)SingletonComponent <AiManager> .Instance) && ((Behaviour)SingletonComponent <AiManager> .Instance).get_enabled())
{
((AiManager)SingletonComponent <AiManager> .Instance).Initialize();
if (!AiManager.nav_disable && AI.npc_enable && Object.op_Inequality((Object)TerrainMeta.Path, (Object)null))
{
foreach (MonumentInfo monument in TerrainMeta.Path.Monuments)
{
if (monument.HasNavmesh)
{
yield return((object)monument.StartCoroutine(monument.GetMonumentNavMesh().UpdateNavMeshAndWait()));
}
}
}
}
GameObject prefab = GameManager.server.CreatePrefab("assets/bundled/prefabs/system/server.prefab", true);
Object.DontDestroyOnLoad((Object)prefab);
ServerMgr serverMgr = (ServerMgr)prefab.GetComponent <ServerMgr>();
serverMgr.Initialize(doLoad, saveFileOverride, allowOutOfDateSaves, false);
yield return((object)CoroutineEx.waitForSecondsRealtime(0.1f));
ColliderGrid.RefreshAll();
yield return((object)CoroutineEx.waitForSecondsRealtime(0.1f));
SaveRestore.InitializeEntityLinks();
yield return((object)CoroutineEx.waitForSecondsRealtime(0.1f));
SaveRestore.InitializeEntitySupports();
yield return((object)CoroutineEx.waitForSecondsRealtime(0.1f));
SaveRestore.InitializeEntityConditionals();
yield return((object)CoroutineEx.waitForSecondsRealtime(0.1f));
ColliderGrid.RefreshAll();
yield return((object)CoroutineEx.waitForSecondsRealtime(0.1f));
SaveRestore.GetSaveCache();
yield return((object)CoroutineEx.waitForSecondsRealtime(0.1f));
serverMgr.OpenConnection();
if (Time.pausewhileloading)
{
Time.set_timeScale(timeScale);
}
Bootstrap.WriteToLog("Server startup complete");
}
public LevelTestBurningAsteroids(ServerMgr serverMgr)
: base(serverMgr)
{
}
