public void RequestGameEnd(ServerPacketData packetData)
{
var sessionID = packetData.SessionID;
var roomObject = CheckRoomAndRoomUser(packetData.SessionID);
if (roomObject.Item1 == false)
{
return;
}
var room = roomObject.Item2;
if (room.IsGamming == false)
{
return;
}
var resPacket = new GameEndResPacket();
resPacket.Result = (Int16)ERROR_CODE.NONE;
resPacket.Decode(packetData.BodyData);
ServerNetwork.SendData(sessionID, (UInt16)CL_PACKET_ID.RES_GAME_END, resPacket.ToBytes());
room.Broadcast((UInt16)CL_PACKET_ID.NTF_GAME_END, null);
room.IsGamming = false;
}
private ServerNetwork CreateNetwork()
{
ServerNetwork network;
#region Apply CLI Options
//Options.ServerPort = StartupOptions.ValidPort(Options.ServerPort);
#endregion
#region Create Network
var assembly = Assembly.GetExecutingAssembly();
using (var stream = assembly.GetManifestResourceStream("Intersect.Server.private-intersect.bek"))
{
var rsaKey = EncryptionKey.FromStream <RsaKey>(stream ?? throw new InvalidOperationException());
Debug.Assert(rsaKey != null, "rsaKey != null");
network = new ServerNetwork(new NetworkConfiguration(Options.ServerPort), rsaKey.Parameters);
}
#endregion
#region Configure Packet Handlers
var packetHandler = new PacketHandler();
network.Handler = packetHandler.HandlePacket;
network.PreProcessHandler = packetHandler.PreProcessPacket;
#endregion
return(network);
}
// Start is called before the first frame update
void Start()
{
delete = false;
SN = GameObject.Find("ServerNetwork").GetComponent <ServerNetwork>();
Pos = Vector3.zero;
speed = 5.0f;
}
void Start()
{
_anim = GetComponent <Animator>();
_rb = GetComponent <Rigidbody>();
_view = GetComponent <PhotonView>();
_server = ServerNetwork.Instance;
}
void Start()
{
_rb = GetComponent <Rigidbody>();
_view = GetComponent <PhotonView>();
_server = ServerNetwork.Instance;
_boundary = FindObjectOfType <Boundary>();
}
public void NotifyInDisConnectClient(ServerPacketData requestData)
{
var sessionIndex = requestData.SessionIndex;
var user = UserMgr.GetUser(sessionIndex);
if (user != null)
{
var roomNum = user.RoomNumber;
if (roomNum != PacketDef.INVALID_ROOM_NUMBER)
{
var packet = new PKTInternalNtfRoomLeave()
{
RoomNumber = roomNum,
UserID = user.ID(),
};
var packetBodyData = MessagePackSerializer.Serialize(packet);
var internalPacket = new ServerPacketData();
internalPacket.Assign("", sessionIndex, (Int16)PACKETID.NTF_IN_ROOM_LEAVE, packetBodyData);
ServerNetwork.Distribute(internalPacket);
}
UserMgr.RemoveUser(sessionIndex);
}
MainServer.MainLogger.Debug($"Current Connected Session Count: {ServerNetwork.SessionCount}");
}
// Use this for initialization
void Start()
{
adminClients = new List <long>();
serverNet = GetComponent(typeof(ServerNetwork)) as ServerNetwork;
updateTimer = updateFrequency;
}
public void NotifyInDisConnectClient(ServerPacketData requestData)
{
var user = UserMgr.GetUserByNetSessionID(requestData.SessionID);
if (user != null)
{
var lobbyNum = user.RoomNumber;
if (lobbyNum != PacketDef.INVALID_LOBBY_NUMBER)
{
var packet = new PKTInternalNtfRoomLeave()
{
RoomNumber = lobbyNum,
UserID = user.ID,
};
var packetBodyData = packet.Encode();
var internalPacket = new ServerPacketData();
internalPacket.Assign(requestData.SessionID, (UInt16)SYS_PACKET_ID.NTF_IN_ROOM_LEAVE, packetBodyData);
ServerNetwork.Distribute(internalPacket);
}
UserMgr.RemoveUser(requestData.SessionID);
}
GameServer.MainLogger.Debug($"Current Connected Session Count: {ServerNetwork.SessionCount}");
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
ServerNetwork server = new ServerNetwork("127.0.0.1", 9080);
server.OnDataReceived = (guid, dataBytes) =>
{
Console.WriteLine(Encoding.UTF8.GetString(dataBytes));
};
server.OnSessionConnected = (guid) =>
{
Console.WriteLine("Client connected,guid = " + guid);
};
if (server.Start())
{
while (true)
{
server.DoUpdate(0.1f);
Random r = new Random();
var v = r.Next(0, 10);
if (v > 5)
{
server.Multicast(Encoding.UTF8.GetBytes("Server Send Data,v = " + v));
}
Thread.Sleep(100);
}
}
server.Dispose();
}
public override void _Ready()
{
_network = (ServerNetwork)GetNode("/root/PaintNetwork");
var buttonContainer = (Container)GetNode("CenterContainer/HBoxContainer/VBoxContainer");
_start = (Button)buttonContainer.GetNode("Start");
_stop = (Button)buttonContainer.GetNode("Stop");
_logContainer = (Container)GetNode("CenterContainer/HBoxContainer/ScrollContainer/VBoxContainer");
_start.Connect("pressed", this, nameof(StartNetwork));
_stop.Connect("pressed", this, nameof(StopNetwork));
_network.Connect(nameof(ServerNetwork.NetworkConnected), this, nameof(LogMessageTag),
new Godot.Collections.Array {
"NetworkConnected"
});
_network.Connect(nameof(ServerNetwork.NetworkDisconnected), this, nameof(LogMessageTag),
new Godot.Collections.Array {
"NetworkDisconnected"
});
_network.Connect(nameof(ServerNetwork.LobbyUpdate), this, nameof(LogLobby));
AddLogMessage("Test", "Message");
}
void Start()
{
_rb = GetComponent <Rigidbody>();
_view = GetComponent <PhotonView>();
_server = ServerNetwork.Instance;
_rb.velocity = transform.forward * speed;
_boundary = FindObjectOfType <Boundary>();
}
public void Create(ServerNetwork serverNetwork, int totalUserCount)
{
ServerNetworkRef = serverNetwork;
ServerManager = new ConnectServerManager();
RegistPacketHandler();
}
private void ListenStart()
{
SN = new ServerNetwork(Convert.ToInt32(Port.Text));
SN.Listen();
SN.Received += new ServerNetwork.ReceivedEventHandler(ServerReceived);
SN.Disconnected += new ServerNetwork.DisconnectedEventHandler(server_Disconnected);
}
void ServerReceived(ServerNetwork SN, Info i, byte[] packet)
{
byte[] by_header = new byte[2];
Array.Copy(packet, 0, by_header, 0, 2);
short header = BitConverter.ToInt16(by_header, 0);
string[] Rstr = Encoding.UTF8.GetString(packet, 2, packet.Length - 2).Split('|');
string ipad = i.RemoteAddress.Split(':')[0];
Console.WriteLine("서버: PacketReceiver");
switch (header)
{
case (int)NetworkHEADER.HANDSHAKE:
if (Rstr[0] != "csgokacserver")
{
i.Send(NetworkHEADER.DENIED, "");
return;
}
else
{
i.Send(NetworkHEADER.DOCONNECTION, ServerIP.Text + "|");
i.Send(NetworkHEADER.PLISTGET, "");
}
break;
case (int)NetworkHEADER.CONNECTION:
Console.WriteLine("서버: PacketReceiver - Case Connection");
if (Limitchk.Checked)
{
if (PlayerListView.Items.Count == 10)
{
i.Send(NetworkHEADER.DENIED, "");
}
else
{
Invoke(new _Add(Add), i, Rstr[0]);
Invoke(new _notification(notification), i.RemoteAddress.Split(':')[0], Rstr[0]);
}
}
else
{
Invoke(new _Add(Add), i, Rstr[0]);
Invoke(new _notification(notification), i.RemoteAddress.Split(':')[0], Rstr[0]);
}
break;
case (int)NetworkHEADER.PLISTGETRESPONSE:
string receive = @"" + Rstr[2];
Invoke(new _PLISTSAVE(PLISTSAVE), Rstr[0], Rstr[1], receive, ipad);
break;
case (int)NetworkHEADER.POLISTGETRESPONSE:
string receive2 = @"" + Rstr[2];
Invoke(new _POLISTSAVE(POLISTSAVE), Rstr[0], Rstr[1], receive2, Rstr[3], ipad);
break;
}
} // pid // prname // prpath // 파일이름
void ResponseLoginToClient(ERROR_CODE errorCode, string sessionID)
{
var resLogin = new LoginResPacket()
{
Result = (short)errorCode
};
ServerNetwork.SendData(sessionID, (UInt16)CL_PACKET_ID.RES_GAME_LOGIN, resLogin.ToBytes());
}
public void SetReferenceToSelf(Player p) //Funcion para asignar el serverReference
{
Instance = this; //Asigno el singleton
serverReference = p; //Asingo el serverReference con el jugador que me pasaron
if (!PhotonNetwork.IsMasterClient) //Sólo si no soy el server
{
_view.RPC("AddPlayer", serverReference, PhotonNetwork.LocalPlayer); //Llamo al server para agregarme como jugador.
}
}
private void Start()
{
_server = ServerNetwork.Instance;
_view = GetComponent <PhotonView>();
_rb = GetComponent <Rigidbody>();
_boundary = FindObjectOfType <Boundary>();
_audioSource = GetComponent <AudioSource>();
_currentLife = life;
}
public void Chatting(ServerNetwork serverNetwork, string userID, string chatMsg)
{
var notify = new JsonPacketNoticeChat() { Result = ERROR_CODE.NONE, UserID = userID, Chat = chatMsg };
UserList.ForEach(user =>
{
serverNetwork.Send<JsonPacketNoticeChat>(user.SessionID, PACKET_ID.NOTICE_CHAT, notify);
}
);
}
public void Init(ServerAppConfig appConfig, ServerNetwork serverNetwork, DB.DBManager dbManager)
{
ServerNetworkRef = serverNetwork;
DBManagerRef = dbManager;
UserManagerInst = new ConnectUserManager();
UserManagerInst.Init(appConfig.MaxTotalUserCount);
RegistPacketHandler();
}
public override void _Ready()
{
var network = new ServerNetwork
{
Name = "PaintNetwork"
};
GetTree().Root.AddChild(network);
// GetTree().ChangeScene("res://server/ServerUI.tscn");
}
public NetworkEntity(ClientManagerEntity clientManager, ushort port, RootEntity root) : base(root)
{
this.clientManager = clientManager;
server = new ServerNetwork();
server.Listen(port, 100);
server.SetMessageHandler(MessageType.Connect, ConnectHandler);
server.SetMessageHandler(MessageType.Disconnect, DisconnectHandler);
server.SetMessageHandler(MessageType.Timeout, TimeoutHandler);
server.SetMessageHandler(MessageType.Move, MoveHandler);
}
private void StartServerNetwork()
{
_isServer = true;
Server = new ServerNetwork();
Server.OnConnect += ServerOnClientConnect;
Server.OnDisconnect += ServerOnClientDisconnect;
Server.OnTimeout += ServerOnClientTimeout;
Server.OnReceive += ServerOnClientReceive;
Server.Listen(networkAddress, networkPort, maxConnections, maxChannels);
}
public void NotifyMustCloseToClient(ERROR_CODE errorCode, string sessionID)
{
var resLogin = new PKNtfMustClose()
{
Result = (short)errorCode
};
var bodyData = MessagePackSerializer.Serialize(resLogin);
var sendData = PacketToBytes.Make(PACKETID.NTF_MUST_CLOSE, bodyData);
ServerNetwork.SendData(sessionID, sendData);
}
void Start()
{
if (!_rb)
{
_rb = GetComponent <Rigidbody>();
}
_view = GetComponent <PhotonView>();
_server = ServerNetwork.Instance;
_boundary = FindObjectOfType <Boundary>();
_rb.angularVelocity = Random.insideUnitSphere * tumble;
}
public void ResponseLoginToClient(ERROR_CODE errorCode, string sessionID)
{
var resLogin = new PKTResLogin()
{
Result = (short)errorCode
};
var bodyData = MessagePackSerializer.Serialize(resLogin);
var sendData = PacketToBytes.Make(PACKETID.RES_LOGIN, bodyData);
ServerNetwork.SendData(sessionID, sendData);
}
void ResponseEnterRoomToClient(ERROR_CODE errorCode, string sessionID)
{
var resRoomEnter = new PKTResRoomEnter()
{
Result = (short)errorCode
};
var bodyData = MessagePackSerializer.Serialize(resRoomEnter);
var sendData = PacketToBytes.Make(PACKETID.RES_ROOM_ENTER, bodyData);
ServerNetwork.SendData(sessionID, sendData);
}
static void Main(string[] args)
{
int port = 3721;
ServerNetwork server = new ServerNetwork(port);
server.OnClientConnected = OnClientConnected;
server.OnClientDisconnected = OnClientDisconnected;
server.OnReceiveClientMessage = OnReceiveClientMessage;
while (true)
{
server.OneLoop();
}
}
public void Create(ServerNetwork serverNetwork, int maxLobbyCount, int maxLobbyUserCount)
{
ServerNetworkRef = serverNetwork;
var totalUserCount = maxLobbyCount * maxLobbyUserCount;
UserManager = new ConnectUserManager();
UserManager.Init(totalUserCount);
LobbyMgr = new LobbyManager();
LobbyMgr.CreateLobby(ServerNetworkRef, maxLobbyCount, maxLobbyUserCount);
RegistPacketHandler();
}
private void Dispose(bool disposing)
{
if (m_IsDisposed)
{
return;
}
if (m_ServerNetwork != null)
{
m_ServerNetwork.Disconnect();
m_ServerNetwork = null;
}
m_IsDisposed = true;
}
public void Chatting(ServerNetwork serverNetwork, string userID, string chatMsg)
{
if (UserList.Any(x => x.UserID == userID) == false)
{
return;
}
var notify = new JsonPacketNoticeChat() { UserID = userID, Chat = chatMsg };
/* UserList.ForEach(user =>
{
serverNetwork.Send<JsonPacketNoticeChat>(user.SessionID, PACKET_ID.NOTICE_CHAT, notify);
}
);*/
}
public void Init(int firstLobbyID, int lobbyCountPerWorkPacketProcess, ServerAppConfig appConfig, ServerNetwork serverNetwork)
{
ServerNetworkRef = serverNetwork;
for (var i = 0; i < lobbyCountPerWorkPacketProcess; ++i)
{
var lobbyID = (short)(i + firstLobbyID);
var lobby = new Lobby();
lobby.Init(lobbyID, appConfig.MaxLobbyUserCount);
LobbyList.Add(lobby);
}
}
public void CreateLobby(ServerNetwork serverNetwork, int lobbyCount, int maxUserCount)
{
ServerNetworkRef = serverNetwork;
for (var i = 0; i < lobbyCount; ++i)
{
var lobyIndex = (short)(i + 1);
var lobby = new Lobby();
lobby.Init(lobyIndex, maxUserCount);
LobbyList.Add(lobby);
}
}
public void Init(int firstLobbyID, int lobbyCountPerWorkPacketProcess, ServerAppConfig appConfig, ServerNetwork serverNetwork)
{
ServerNetworkRef = serverNetwork;
for (var i = 0; i < lobbyCountPerWorkPacketProcess; ++i)
{
var lobbyID = (short)(i + firstLobbyID);
var lobby = new Lobby();
lobby.Init(lobbyID, appConfig.MaxLobbyUserCount);
LobbyList.Add(lobby);
}
}
// Use this for initialization
void Awake()
{
instance = this;
// Initialization of the server network
ServerNetwork.port = portNumber;
if (serverNet == null)
{
serverNet = GetComponent <ServerNetwork>();
}
if (serverNet == null)
{
serverNet = (ServerNetwork)gameObject.AddComponent(typeof(ServerNetwork));
Debug.Log("ServerNetwork component added.");
}
}
public Gate()
{
frontendNetwork = new ServerNetwork(6888)
{
OnClientConnected = OnFrontendConnected,
OnClientMessageReceived = OnFrontendMessageReceived,
};
backendNetwork = new ServerNetwork(6999)
{
OnClientConnected = OnBackendConnected,
OnClientMessageReceived = OnBackendMessageReceived,
};
frontendNetwork.BeginAccept();
backendNetwork.BeginAccept();
}
public Gate(int frontPort, int backPort)
{
frontendNetwork = new ServerNetwork(frontPort)
{
OnClientConnected = OnFrontendConnected,
OnClientDisconnected = OnFrontendDisconnected,
OnClientMessageReceived = OnFrontendMessageReceived,
};
backendNetwork = new ServerNetwork(backPort)
{
OnClientConnected = OnBackendConnected,
OnClientDisconnected = OnBackendDisconnected,
OnClientMessageReceived = OnBackendMessageReceived,
};
frontendNetwork.BeginAccept();
backendNetwork.BeginAccept();
}
public void Chatting(ServerNetwork serverNetwork, string userID, string chatMsg)
{
if (UserList.Any(x => x.UserID == userID) == false)
{
return;
}
var notify = new JsonPacketNoticeChat()
{
UserID = userID, Chat = chatMsg
};
UserList.ForEach(user =>
{
serverNetwork.Send <JsonPacketNoticeChat>(user.SessionID, PACKET_ID.NOTICE_CHAT, notify);
}
);
}
public void Init(int index, int lobbyCountPerWorkPacketProcess, ServerAppConfig appConfig, ServerNetwork serverNetwork, DB.DBManager dbManager)
{
Index = index;
ServerNetworkRef = serverNetwork;
DBManagerRef = dbManager;
var firstLobbyID = ((Index - 1) * lobbyCountPerWorkPacketProcess) + 1;
if (Index != 1)
{
firstLobbyID = Index * lobbyCountPerWorkPacketProcess;
}
LobbyManagerInst = new Lobby.LobbyManager();
LobbyManagerInst.Init(firstLobbyID, lobbyCountPerWorkPacketProcess, appConfig, serverNetwork);
RegistPacketHandler();
IsThreadRunning = true;
ProcessThread = new System.Threading.Thread(this.Process);
ProcessThread.Start();
}
public void Init(ServerNetwork serverNetwork, ConnectServerManager serverManager)
{
ServerNetworkRef = serverNetwork;
ServerManagerRef = serverManager;
}
public void Init(ServerNetwork serverNetwork, DB.DBManager dbManager, ConnectUserManager userManager)
{
ServerNetworkRef = serverNetwork;
DBManagerRef = dbManager;
UserManagerRef = userManager;
}
public void Init(ServerNetwork serverNetwork, ConnectUserManager userManager, LobbyManager lobbyManager)
{
ServerNetworkRef = serverNetwork;
UserManagerRef = userManager;
LobbyManagerRef = lobbyManager;
}
public void Init(ServerNetwork serverNetwork, DB.DBManager dbManager, ChatServerLib.Lobby.LobbyManager lobbyManager)
{
ServerNetworkRef = serverNetwork;
DBManagerRef = dbManager;
LobbyManagerRef = lobbyManager;
}
