protected void finishInitialization()
{
lock (blocks)
{
if (!terrainReady)
{
return;
}
if (loaded)
{
return;
}
int x, y, z;
bool isServer = ServerNetworkManager.isServer();
List <Liquid> liquids = new List <Liquid>();
for (x = 0; x < size; x++)
{
for (y = 0; y < size; y++)
{
if (blocksModified == null || blocksModified[x, y] == null)
{
for (z = 0; z < size; z++)
{
blocks[x, y, z] = BlockFactory.create(new Coordinates(x + size * this.x, y + size * this.y, z + size * this.z), isServer, liquids);
}
}
else if (blocksModified[x, y] != null)
{
for (z = 0; z < size; z++)
{
if (!blocksModified[x, y][z])
{
blocks[x, y, z] = BlockFactory.create(new Coordinates(x + size * this.x, y + size * this.y, z + size * this.z), isServer, liquids);
}
}
}
}
}
foreach (Liquid liquid in liquids)
{
if (!fluids.ContainsKey(liquid.getPrefab()))
{
fluids.Add(liquid.getPrefab(), null);
MainThread.runAction(() => fluids[liquid.getPrefab()] = GameObject.Instantiate(liquid.getPrefab(), empty.transform).gameObject);
}
}
//Debug.Log("Loaded Chunk at " + coords);
foreach (KeyValuePair <Position, Block> pair in setBlockQueue)
{
setBlock(pair.Key, pair.Value, false);
}
recalculateFaceConnections();
MainThread.instantiateChunk(this);
loaded = true;
World.registerChunk(getCoordinates(), this);
//Profiler.EndSample();
}
}
/// <summary>
/// Create socket instance and listen to connections
/// </summary>
public static void StartListening()
{
try
{
Clients = new List <ConnectedObject>();
ServerSocket = ServerNetworkManager.StartListening();
Console.WriteLine($"Server running..");
while (true)
{
resetEvent.Reset();
// Start an asynchronous socket to listen for connections
ServerSocket.BeginAccept(new AsyncCallback(HandleClientConnect), ServerSocket);
// Wait until connection is made.
resetEvent.WaitOne();
}
}
catch (Exception ex)
{
Log.Error(ex.Message);
Console.WriteLine("Ooops, Somthing Wrong..");
}
}
public IEnumerator TestLoadScene_NetworkManager_NonNullObjectExpected()
{
SceneManager.LoadScene("MainMenuScene");
yield return(new WaitForSeconds(3));
MainMenuSceneInit initializer = GameObject.Find("Initializer").GetComponent <MainMenuSceneInit>();
initializer.ChangeScene("NewGameMapScene");
yield return(new WaitForSeconds(3));
GameApp gameApp = GameObject.Find("GameApp").GetComponent <GameApp>();
gameApp.PersistAllParameters(SceneManager.GetActiveScene().name);
gameApp.Parameters.Remove("ServerAddress");
gameApp.Parameters.Remove("ServerPort");
gameApp.Parameters.Add("ServerAddress", "127.0.0.1");
gameApp.Parameters.Add("ServerPort", "9994");
LevelLoader levelLoader = GameObject.Find("LevelLoader").GetComponent <LevelLoader>();
levelLoader.LoadLevel("NewGameScene");
yield return(new WaitForSeconds(3));
NewGameSceneInit newGameSceneInit = GameObject.Find("Initializer").GetComponent <NewGameSceneInit>();
newGameSceneInit.AddPlayer();
newGameSceneInit.AddPlayer();
ServerNetworkManager serverNetworkManager = GameObject.Find("ServerNetworkManager").GetComponent <ServerNetworkManager>();
Assert.IsNotNull(serverNetworkManager);
}
/*
* Get players' data from the menu input fields and pass to the gameApp
* So the data can be read by gameController afterwards
*/
public void Create()
{
List <GameApp.PlayerMenu> playerMenuList = new List <GameApp.PlayerMenu>();
foreach (GameObject player in playersToAddToGame)
{
string tempType;
if (player.transform.Find("PlayerTypeInput").GetComponent <Toggle>().isOn)
{
tempType = "L";
}
else
{
tempType = "R";
}
playerMenuList.Add(new GameApp.PlayerMenu {
name = player.transform.Find("PlayerNameInput").GetComponent <InputField>().text,
password = player.transform.Find("PlayerPassInput").GetComponent <InputField>().text,
race = "human",
playerType = tempType,
});
}
Debug.Log("NewGameSceneInit create, players: " + playerMenuList.Count);
gameApp.SavePlayersFromMenu(playerMenuList);
ServerNetworkManager serverNetworkManager = GameObject.Find("ServerNetworkManager").GetComponent <ServerNetworkManager>();
serverNetworkManager.SetupNewGame();
}
public IEnumerator TestYear_Next2Turns_2401Expected()
{
SceneManager.LoadScene("MainMenuScene");
yield return(new WaitForSeconds(3));
MainMenuSceneInit initializer = GameObject.Find("Initializer").GetComponent <MainMenuSceneInit>();
initializer.ChangeScene("NewGameMapScene");
yield return(new WaitForSeconds(3));
GameApp gameApp = GameObject.Find("GameApp").GetComponent <GameApp>();
gameApp.PersistAllParameters(SceneManager.GetActiveScene().name);
gameApp.Parameters.Remove("ServerAddress");
gameApp.Parameters.Remove("ServerPort");
gameApp.Parameters.Add("ServerAddress", "127.0.0.1");
gameApp.Parameters.Add("ServerPort", "9981");
LevelLoader levelLoader = GameObject.Find("LevelLoader").GetComponent <LevelLoader>();
levelLoader.LoadLevel("NewGameScene");
yield return(new WaitForSeconds(3));
NewGameSceneInit newGameSceneInit = GameObject.Find("Initializer").GetComponent <NewGameSceneInit>();
newGameSceneInit.AddPlayer();
newGameSceneInit.AddPlayer();
List <GameApp.PlayerMenu> playerMenuList = new List <GameApp.PlayerMenu>();
GameApp.PlayerMenu player1 = new GameApp.PlayerMenu
{
name = "player1",
password = "******",
race = "human",
playerType = "L"
};
GameApp.PlayerMenu player2 = new GameApp.PlayerMenu
{
name = "player12",
password = "******",
race = "human",
playerType = "L"
};
playerMenuList.Add(player1);
playerMenuList.Add(player2);
gameApp.SavePlayersFromMenu(playerMenuList);
ServerNetworkManager serverNetworkManager = GameObject.Find("ServerNetworkManager").GetComponent <ServerNetworkManager>();
serverNetworkManager.SetupNewGame();
yield return(new WaitForSeconds(3));
GameController gameController = GameObject.Find("GameController").GetComponent <GameController>();
gameController.NextTurn();
yield return(new WaitForSeconds(3));
gameController.NextTurn();
yield return(new WaitForSeconds(3));
Assert.AreEqual(gameController.year, 2401);
}
private void SetupChatHandlers()
{
try
{
if (m_chatHandlerSetup == true)
{
return;
}
var netManager = ServerNetworkManager.GetNetworkManager();
if (netManager == null)
{
return;
}
Action <ulong, string, ChatEntryTypeEnum> chatHook = ReceiveChatMessage;
ServerNetworkManager.Instance.RegisterChatReceiver(chatHook);
m_chatHandlerSetup = true;
}
catch (Exception ex)
{
LogManager.ErrorLog.WriteLine(ex);
}
}
void Start()
{
rayCast = GameObject.Find("PointerController").GetComponent <RayCast>();
inputManager = GameObject.Find("InputManager").GetComponent <InputManager>();
modHandler = GameObject.Find("ModHandler").GetComponent <ModHandler>();
networkManager = GameObject.Find("NetworkManager").GetComponent <ServerNetworkManager>();
}
void Start()
{
Application.targetFrameRate = 60;
Application.runInBackground = true;
clientDataManager = new ServerClientDataManager();
networkManager = new ServerNetworkManager(clientDataManager);
}
public void InformAllClientAboutCharacterDisconnect(ServerNetworkManager servNetworkManager, int connectionId)
{
DisconnectMessage m = new DisconnectMessage(connectionId);
foreach (Character player in allCharacters)
{
servNetworkManager.SendNetworkReliableMessage(m, player.ClientId);
}
}
public void start()
{
Logger.open();
loadConfigFiles();
initializeDatabase();
Terminal.start();
addr = new Address("localhost");
ServerNetworkManager.openSocket(addr);
}
public void HandlePlayerMessagesData(ServerNetworkManager servNetworkManager, Message message)
{
switch (message.GetNetworkMessageType())
{
case NetworkMessageType.Input:
HandlePlayerInput(servNetworkManager, message as InputMessage);
break;
}
}
public void generate()
{
if (!ServerNetworkManager.isServer())
{
ClientNetworkManager.requestChunk(getCoordinates());
}
else
{
ChunkManager.RequestChunkLoad(this);
}
}
protected void setBlock(Position p, Block b, bool recalculateConnections)
{
Debug.Log("set " + p + " to " + b + " from " + p.getBlock() + " in " + this);
if (!loaded)
{
setBlockQueue.Enqueue(new KeyValuePair <Position, Block>(p, b));
return;
}
lock (blocks)
{
if (b.getMeshID() >= 0 && b.isTransparent())
{
liquid = b as Liquid;
if (liquid != null && !fluids.ContainsKey(liquid.getPrefab()))
{
fluids.Add(liquid.getPrefab(), null);
MainThread.runAction(() => fluids[liquid.getPrefab()] = GameObject.Instantiate(liquid.getPrefab(), empty.transform).gameObject);
}
}
//Debug.Log("Updating block at " + p.getRelativeCoords() + " (" + p + ")");
ServerNetworkManager.updateBlock(p, b);
if (blocksModified == null)
{
blocksModified = new BitArray[size, size];
}
if (blocksModified[p.getRelativeX(), p.getRelativeY()] == null)
{
blocksModified[p.getRelativeX(), p.getRelativeY()] = new BitArray(size);
}
blocksModified[p.getRelativeX(), p.getRelativeY()][p.getRelativeZ()] = true;
untouchedChunk = false;
modifiedSinceSave = true;
fluidMeshRebuildingNeeded = fluidMeshRebuildingNeeded || blocks[p.getRelativeX(), p.getRelativeY(), p.getRelativeZ()] is Liquid;
terrainMeshRebuildingNeeded = terrainMeshRebuildingNeeded || blocks[p.getRelativeX(), p.getRelativeY(), p.getRelativeZ()] is Solid;
lock (blockChangeListeners)
{
blockChangeListeners.Remove(blocks[p.getRelativeX(), p.getRelativeY(), p.getRelativeZ()]);
}
blocks[p.getRelativeX(), p.getRelativeY(), p.getRelativeZ()] = b;
blockUpdated(b, true);
faceRecalculationNeeded = true;
if (recalculateConnections)
{
BackgroundThread.runAction(() => recalculateFaceConnections());
}
Debug.Log("now " + p.getBlock() + " | " + b);
}
}
public GatewayServer(string appId, int clientListeningPort, string broadcastRange, int listeningPort, string serverId, ServerType type)
{
GatewayServerConfig config = new GatewayServerConfig();
config.AppId = appId;
config.BroadcastRange = broadcastRange;
config.ClientListeningPort = clientListeningPort;
config.ListeningPort = listeningPort;
config.Serializer = ObjectFactory.CreateISerializeInstance();
config.ServerId = serverId;
config.ServerType = type;
NetworkManager = new GatewayNetworkManager2(config);
}
void Start()
{
rayCast = GameObject.Find("PointerController").GetComponent <RayCast>();
inputManager = GameObject.Find("InputManager").GetComponent <InputManager>();
modHandler = GameObject.Find("ModHandler").GetComponent <ModHandler>();
movableUIHandler = movableUI.GetComponent <MovableUIHandler>();
networkManager = GameObject.Find("NetworkManager").GetComponent <ServerNetworkManager>();
pointerController = GameObject.Find("PointerController");
isOnDrag = isClicked = false;
canClick = true;
}
private void InitForClient()
{
serverForClient = new ServerNetworkManager();
var server = new Plugins.Network.WebSocketServer();
server.Setup("0.0.0.0", 8730);
var serializer = new Plugins.ProtoSerializer();
serializer.getTypeFunc = (name) => { return(Type.GetType(name)); };
serializer.LoadProtoNum(typeof(Message.ProtoNum));
serverForClient.Init(server, serializer);
Debug.LogInfo("初始化网络监听（客户端） [{0}]", server.address);
}
private void InitForClient()
{
forClient = new ServerNetworkManager();
var listener = new Plugins.Network.WebSocketServer();
listener.Setup("0.0.0.0", NetConfig.LISTENER_PORT);
var serializer = new Plugins.ProtoSerializer();
serializer.getTypeFunc = (name) => { return(Type.GetType(name)); };
serializer.LoadProtoNum(typeof(Message.ProtoNum));
forClient.Init(listener, serializer);
Debug.LogInfo("初始化网络监听（客户端） [{0}]".FormatStr(listener.address));
}
void hostGame()
{
if (ServerNetworkManager.hostGame())
{
transform.Find("MenuPanel").gameObject.SetActive(false);
transform.Find("LoginPanel").gameObject.SetActive(true);
}
else
{
transform.Find("PopupPanel").gameObject.SetActive(true);
GameObject.Find("textPopup").GetComponent <Text>().text = "Error creating server";
}
}
private static void getInput()
{
while (Server.instance.isRunning)
{
string command = Console.ReadLine();
switch (command)
{
case "stop":
Logger.log("[Server]: Vypínání");
Server.instance.isRunning = false;
ServerNetworkManager.closeConnection();
Database.close();
Logger.close();
break;
case "help":
Console.WriteLine("books - ukáže jména všech knih");
Console.WriteLine("users - ukáže jména a e-maily čtenářů");
Console.WriteLine("admins - ukáže jména a e-maily administrátorů");
Console.WriteLine("stop - vypne server");
Console.WriteLine("help - úkáže pomoc");
break;
case "books":
foreach (Book b in Database.getBooks("", 0))
{
Console.WriteLine(b.name + " - " + b.author + " - " + b.ISBN);
}
break;
case "users":
foreach (Reader r in Database.getReaders("", 0, false))
{
Console.WriteLine(r.name + " - " + r.email + " ID: " + r.ID);
}
break;
case "admins":
foreach (Reader r in Database.getReaders("", 0, true))
{
Console.WriteLine(r.name + " - " + r.email + " ID: " + r.ID);
}
break;
default:
Console.WriteLine("Neznámý příkaz, použijte 'help' pro více informací");
break;
}
Thread.Sleep(1);
}
}
//server updates a block to client
private static void updateBlock(Field message)
{
if (ServerNetworkManager.isServer())
{
return;
}
Position pos = message.getField("pos").getCoordinates();
Block block = ChunkSerializer.deserializeBlock(message.getField("block").getBytes(), false);
if (pos.getChunk() != null)
{
MainThread.runAction(() => pos.getChunk().setBlock(pos, block));
}
}
public static void SendDataMessage(ulong steamId, long msgId, byte[] data)
{
string msgIdString = msgId.ToString( );
byte[] newData = new byte[data.Length + msgIdString.Length + 1];
newData[0] = (byte)msgIdString.Length;
for (int r = 0; r < msgIdString.Length; r++)
{
newData[r + 1] = (byte)msgIdString[r];
}
Buffer.BlockCopy(data, 0, newData, msgIdString.Length + 1, data.Length);
ServerNetworkManager.SendDataMessage(9000, newData, steamId);
}
public void deserialize(byte[] data, int length)
{
if (blocks == null)
{
blocks = new Block[size, size, size];
}
lock (blocks)
{
//Profiler.BeginSample("Loading chunks");
blocksModified = ChunkSerializer.deserializeBlocks(blocks, data, length, ServerNetworkManager.isServer());
deserialized = true;
untouchedChunk = length == 0;
finishInitialization();
}
}
void Start()
{
serverNetworkManager = ServerNetworkManager.Instance;
serverGameManager = ServerGameManager.Instance;
Entity.OnDeath += HandleEntityDeath;
Entity.OnDespawn += HandleEntityDespawn;
PlayerEvent.OnEventEnd += HandlePlayerEventEnd;
//register any entities already existing in the scene (for dev/testing convenience)
foreach (Entity entity in FindObjectsOfType <Entity>())
{
RegisterEntity(entity);
}
}
protected void Start()
{
serverNetworkManager = ServerNetworkManager.Instance;
GameState = new GameState(pointsToWin);
CapturePoints = FindObjectsOfType <CapturePoint>().ToList();
TeamSpawns = new Dictionary <ushort, TeamSpawn>();
foreach (TeamSpawn teamSpawn in FindObjectsOfType <TeamSpawn>())
{
TeamSpawns.Add(teamSpawn.teamId, teamSpawn);
GameState.teams.Add(teamSpawn.teamId, new Team(teamSpawn.teamId, teamSpawn.teamName, teamSpawn.teamColor));
}
}
void Start()
{
m_ServerNetworkManager = new ServerNetworkManager(new ServerConfig());
m_ServerNetworkManager.ConnectedEvent += Server_OnClientConnected;
m_ServerNetworkManager.DisconnectedEvent += Server_OnClientDisconnected;
m_ServerNetworkManager.RegisterHandler(TestMessage.MsgCode, ServerManager_TestMessage);
m_ClientNetworkManager = new ClientNetworkManager(new ClientConfig());
m_ClientNetworkManager.ConnectingEvent += ClientManager_Connecting;
m_ClientNetworkManager.ConnectingFailedEvent += ClientManager_ConnectingFailed;
m_ClientNetworkManager.ConnectedEvent += ClientManager_Connected;
m_ClientNetworkManager.DisconnectedEvent += ClientManager_Diconnected;
m_ClientNetworkManager.RegisterHandler(TestMessage.MsgCode, ClientManager_TestMessage);
Simulation();
}
private void StartServer()
{
GameObject managerObj = GameObject.FindGameObjectWithTag("NetworkManager");
if (managerObj == null)
{
managerObj = new GameObject("NetworkManager");
managerObj.tag = "NetworkManager";
}
networkManager = managerObj.AddComponent <ServerNetworkManager>();
mainMenu.DisableScreen();
waitScreen.Enable("Waiting for Master Server");
networkManager.OnServerReady += () => { waitScreen.Disable(); serverLobby.Enable(); };
networkManager.StartServer(serverName.text, serverDescription.text);
}
public static void SendDataMessage(ulong steamId, DataMessageType messageType, byte[] data)
{
//this may be unsafe, but whatever, my sanity requires the enum
long msgId = (long)messageType;
string msgIdString = msgId.ToString( );
byte[] newData = new byte[data.Length + msgIdString.Length + 1];
newData[0] = (byte)msgIdString.Length;
for (int r = 0; r < msgIdString.Length; r++)
{
newData[r + 1] = (byte)msgIdString[r];
}
Buffer.BlockCopy(data, 0, newData, msgIdString.Length + 1, data.Length);
ServerNetworkManager.SendDataMessage(9000, newData, steamId);
}
public ServerEngineConsole()
{
// Set console title
Console.Title = "Server";
// Initialize network
ServerNetworkManager = new ServerNetworkManager(this);
// Subscribe to network events //
ServerNetworkManager.onPlayerConnected += ServerNetworkManager_OnPlayerConnected;
ServerNetworkManager.onPlayerDisconnected += ServerNetworkManager_OnPlayerDisconnected;
ServerNetworkManager.onPlayerMove += ServerNetworkManager_OnPlayerMove;
ServerNetworkManager.onPlayerAttack += ServerNetworkManager_OnPlayerAttack;
ServerNetworkManager.Load();
}
public void logout()
{
connection.Close();
tcpClient.Close();
Account _oldAcc = acc;
acc = null;
if (ServerNetworkManager.isServer())
{
lock (ServerNetworkManager.clients)
{
ServerNetworkManager.clients.Remove(this);
foreach (Client c in ServerNetworkManager.clients)
{
c.userLoggedOut(_oldAcc);
}
}
}
}
void OnApplicationQuit()
{
lock (chunks)
{
shutdown();
if (ServerNetworkManager.isServer())
{
Account.saveAccounts();
ServerNetworkManager.shutdown();
}
ClientNetworkManager.shutdown();
BlockThread.shutdown();
BackgroundThread.shutdown();
foreach (Chunk c in chunks.Values)
{
c.unload();
}
ChunkManager.shutdown();
}
}
void Awake()
{
if (instance == null)
{
connections = new Dictionary <string, NetworkConnection>();
connectionsIsNew = new HashSet <NetworkConnection>();
levelLoader = GameObject.Find("LevelLoader").GetComponent <LevelLoader>();
gameApp = GameObject.Find("GameApp").GetComponent <GameApp>();
errorInfoPanel = GameObject.Find("ErrorInfoCanvas").GetComponent <ErrorInfoPanel>();
DontDestroyOnLoad(this.gameObject);
instance = this;
Debug.Log("Awake: " + this.gameObject);
}
else if (instance != this)
{
Destroy(gameObject);
}
}
public GameServer(string appId, int listeningPort, string broadcastRange, string serverId, ServerType type)
{
ServerId = serverId;
m_gtcTables = new GameTableCollection();
Random rng = new Random((int)DateTime.Now.Ticks + DateTime.Now.Month + DateTime.Now.Day);
for (int i = 0; i < 50; i++)
{
int smallBlind = rng.Next(10, 500);
m_gtcTables.Add(ObjectFactory.CreateIGameTableTableInstance(smallBlind, smallBlind * 2, 9, Guid.NewGuid().ToString(), "Texas Holdem Table " + i, ServerId));
}
GameServerConfig config = new GameServerConfig();
config.AppId = appId;
config.BroadcastRange = broadcastRange;
config.ListeningPort = listeningPort;
config.Serializer = ObjectFactory.CreateISerializeInstance();
config.ServerId = serverId;
config.ServerType = type;
config.Tables = m_gtcTables;
m_nmNetworkManager = new GameNetworkManager2(config);
}
public virtual void Awake() {
networkManager = (ServerNetworkManager) GameObject.FindGameObjectWithTag("NetworkManager").GetComponent<ServerNetworkManager>();
}
public ReceiveServerReferenceHandler(ServerNetworkManager manager, ServerMessageType target)
: base(manager, target)
{
}
public ServerReferenceRequestHandler(ServerNetworkManager manager, ServerMessageType target)
: base(manager, target)
{
}
