public void DeleteSession(SessionInterface userSession)
{
UserSession session = userSession as UserSession;
session.onDisconnect -= DeleteSession;
userMediator.Remove(session);
}
private static void SendTestNetMessage()
{
SessionInterface sessionInterface = OnlineService.OnlineInterface?.SessionInterface;
if (sessionInterface != null)
{
TestMessage msg = new TestMessage();
msg.valueString = "test"; // 8 + 2
msg.valueInt = -10; // 4
msg.valueUInt = 50; // 4
msg.valueShort = -56; // 2
msg.valueUShort = 33; // 2
msg.valueBool = true; // 0.2
msg.valueByte = 12; // 1
msg.arrayOfInts = new int[] { 0, 1, 2 };
msg.listOfInts = new List <int> {
0, 1, 2
};
msg.cat = new TestMessageCat("FirstCat", 9);
msg.dog = new TestMessageDog("FirstDog", true);
msg.animal = new TestMessageDog("SurpriseDog!", false);
msg.animals = new TestMessageAnimal[]
{
new TestMessageAnimal("Giraffe")
, new TestMessageCat("Moustache", 99)
, new TestMessageDog("Bento", true)
};
sessionInterface.SendNetMessage(msg, sessionInterface.Connections);
}
}
protected override void OnUnbindedFromSession()
{
SessionInterface.OnConnectionAdded -= OnConnectionAdded;
SessionInterface.OnConnectionRemoved -= OnConnectionRemoved;
SessionInterface.UnregisterNetMessageReceiver <NetMessageClientHello>(OnClientHello);
_serverSession = null;
}
void UnbindFromSession()
{
OnUnbindedFromSession();
SessionInterface.OnTerminate -= OnSessionInterfaceTerminating;
SessionInterface = null;
}
public void Assign(SessionInterface defaultInterface)
{
MatchmakeUser matchedUser = defaultInterface as MatchmakeUser;
GameObject newPlayer = gameObjectManager.CreateGameObject(matchedUser.Nickname, false);
newPlayer.Tag = TAG.Character;
UserGameObjectIndexes.Add(newPlayer.id);
Scoreboard.AddNewEmptyPlayerScore(newPlayer.Name);
UserSession userSession = new UserSession();
userSession.UserNickname = matchedUser.Nickname;
userSession.TakeOver(matchedUser);
userMediator.Add(userSession);
UserInputProcess userInputProcess = newPlayer.AddComponent <UserInputProcess>();
userInputProcess.SetFence(this.mapCenter, this.mapHeight, this.mapWidth);
//Console.WriteLine(matchedUser.Nickname + "이가 게임에 참가했습니다.");
if (userMediator.GetSessionsCount() == Config.USER_COUNT_PER_ONE_GAME)
{
Start();
}
}
public void Assign(SessionInterface defaultInterface)
{
LoginUser newUser = new LoginUser();
newUser.TakeOver(defaultInterface);
newUser.Send(request_Nickname);
}
protected override void OnBindedToSession()
{
_serverSession = (SessionServerInterface)SessionInterface;
SessionInterface.OnConnectionAdded += OnConnectionAdded;
SessionInterface.OnConnectionRemoved += OnConnectionRemoved;
SessionInterface.RegisterNetMessageReceiver <NetMessageClientHello>(OnClientHello);
}
void ClearSessionInterface()
{
if (SessionInterface != null)
{
SessionInterface.OnTerminate -= OnSessionInterfaceTerminated;
SessionInterface = null;
}
}
public DriverClient(SessionInterface sessionInterface)
{
_sessionInterface = sessionInterface;
_sessionInterface.RegisterNetMessageReceiver <NetMessageSyncValue>(OnNetMessageReceived);
_sessionInterface.RegisterNetMessageReceiver <NetMessageDestroyValue>(OnNetMessageReceived);
_sessionInterface.RegisterNetMessageReceiver <NetMessageValueSyncComplete>(OnSyncComplete);
_sessionInterface.SendNetMessage(new NetMessageRequestValueSync(), _sessionInterface.Connections);
}
void Unhook()
{
if (_session != null)
{
_session.OnTerminate -= Unhook;
_session.OnBeginReceiveLargeDataTransfer -= OnBeginReceiveLargeDataTransfer;
_session = null;
}
}
protected override void OnCreate()
{
base.OnCreate();
_session = OnlineService.OnlineInterface?.SessionInterface;
_session.RegisterNetMessageReceiver <NetMessageInputSubmission>(OnNetMessageInputSubmission);
_constructTickSystem = World.GetOrCreateSystem <ConstructSimulationTickSystem>();
}
public void Assign(SessionInterface defaultInterface)
{
LoginUser src = defaultInterface as LoginUser;
MatchmakeUser user = new MatchmakeUser();
user.TakeOver(defaultInterface);
user.Nickname = src.Nickname;
Console.WriteLine("새로운 유저가 매치메이킹에 등록됨. " + user.Nickname);
}
public DriverServer(SessionInterface sessionInterface)
{
_sessionInterface = sessionInterface;
_sessionInterface.RegisterNetMessageReceiver <NetMessageRequestValueSync>(OnRequestValueSync);
foreach (SyncedValueContainer container in SyncedValues.s_Containers)
{
_sessionInterface.SendNetMessage(CreateSyncMessage(container), _sessionInterface.Connections);
}
}
public override void OnGameAwake()
{
base.OnGameAwake();
SessionInterface sessionInterface = OnlineService.OnlineInterface?.SessionInterface;
if (sessionInterface != null)
{
sessionInterface.RegisterNetMessageReceiver <TestMessage>(OnReceiveMessage);
}
}
protected override void OnDestroy()
{
base.OnDestroy();
SessionInterface sessionInterface = OnlineService.OnlineInterface?.SessionInterface;
if (sessionInterface != null)
{
sessionInterface.UnregisterNetMessageReceiver <TestMessage>(OnReceiveMessage);
}
}
public virtual void Dispose()
{
SessionInterface?.Dispose();
_network.OnDisconnectedFromSession -= OnDisconnectFromSession;
if (LOG)
#pragma warning disable CS0162 // Unreachable code detected
{
Log.Info("Online interface terminating");
}
#pragma warning restore CS0162 // Unreachable code detected
OnTerminate?.Invoke();
}
bool TryHook()
{
var online = OnlineService.OnlineInterface;
if (online != null)
{
var session = online.SessionInterface;
if (session != null)
{
session.OnBeginReceiveLargeDataTransfer += OnBeginReceiveLargeDataTransfer;
session.OnTerminate += Unhook;
_session = session;
return(true);
}
}
return(false);
}
public override void OnGameAwake()
{
#if UNITY_EDITOR
_localPlayerInfo.PlayerName = PlayerProfileService.Instance.PlayerName;
#else
_localPlayerInfo.PlayerName = SystemInfo.deviceName;
#endif
GameStateInGameOnline gameStateOnline = GameStateManager.GetCurrentGameState <GameStateInGameOnline>();
if (gameStateOnline != null && gameStateOnline.SessionInterface != null)
{
SessionInterface = gameStateOnline.SessionInterface;
BindToSession();
}
Internal_OnGameReady();
}
public void OpenSession(object sender, MouseButtonEventArgs e)
{
var user = ((ListViewItem)sender).Content;
int ID = ((SessionPanel)user).Session_ID;
bool Arch = ((SessionPanel)user).Archieved;
if (Arch)
{
SessionInterface archSession = new SessionInterface(ID, true);
archSession.Show();
archSession.DataChanged += CreateSession_DataChanged;
}
else
{
SessionInterface session = new SessionInterface(ID);
session.Show();
session.DataChanged += CreateSession_DataChanged;
}
}
public override void Enter(GameStateParam[] parameters)
{
base.Enter(parameters);
if (OnlineService.OnlineInterface == null)
{
GameStateManager.TransitionToState(_specificDefinition.gameStateIfDisconnect);
Log.Error("[GameStateInGameOnline] This game state requires an onlineInterface.");
return;
}
SessionInterface = OnlineService.OnlineInterface.SessionInterface;
if (SessionInterface == null)
{
GameStateManager.TransitionToState(_specificDefinition.gameStateIfDisconnect);
Log.Error("[GameStateInGameOnline] This game state requires a session interface.");
return;
}
SessionInterface = OnlineService.OnlineInterface.SessionInterface;
SessionInterface.OnTerminate += OnSessionInterfaceTerminated;
}
//private SpaceTimeDebugger.Clock _debugClock;
//private SpaceTimeDebugger.Stream _debugStreamQueueLength;
//private SpaceTimeDebugger.Stream _debugStreamTicksPerFrame;
//private SpaceTimeDebugger.Stream _debugStreamMaxQueueDuration;
protected override void OnCreate()
{
base.OnCreate();
_session = OnlineService.OnlineInterface?.SessionInterface;
if (_session == null)
{
throw new NullReferenceException();
}
if (!_session.IsClientType)
{
throw new Exception($"{nameof(ReceiveSimulationTickSystem)} expects the session interface to be of type 'Client'.");
}
_session.RegisterNetMessageReceiver <NetMessageSimTick>(OnNetMessageSimTick);
_tickSystem = World.GetOrCreateSystem <TickSimulationSystem>();
//_debugStreamQueueLength = SpaceTimeDebugger.CreateStream("Sim Tick Queue", Color.yellow);
//_debugStreamTicksPerFrame = SpaceTimeDebugger.CreateStream("Sim Ticks Per Frame", Color.magenta);
//_debugStreamMaxQueueDuration = SpaceTimeDebugger.CreateStream("Sim Tick Queue Max Duration", Color.cyan);
}
/// <summary>
/// DO NOT MODIFY THE BYTE[] DATA WILL THE TRANSFER IS ONGOING
/// </summary>
public SendViaManualPacketsOperation(byte[] data, INetworkInterfaceConnection destination, SessionInterface sessionInterface, string description = "")
: base(sessionInterface, destination, Transfers.s_NextTransferId++)
{
if (data.Length > Transfers.MAX_TRANSFER_SIZE)
{
throw new Exception($"Data transfer ({data.Length} bytes) cannot exceed {Transfers.MAX_TRANSFER_SIZE} bytes.");
}
_data = data;
int totalPacketCount = data.Length / Transfers.PAQUET_BYTE_ARRAY_SIZE;
if (data.Length % Transfers.PAQUET_BYTE_ARRAY_SIZE != 0)
{
totalPacketCount++;
}
_packetStates = new PacketState[totalPacketCount];
_remainingUnacknowledgedPackets = totalPacketCount;
Description = description;
}
/// <summary>
/// DO NOT MODIFY THE BYTE[] DATA WILL THE TRANSFER IS ONGOING
/// </summary>
public SendViaStreamChannelOperation(byte[] data, INetworkInterfaceConnection destination, SessionInterface sessionInterface, string description = "")
: base(sessionInterface, destination, Transfers.s_NextTransferId++)
{
if (data.Length > Transfers.MAX_TRANSFER_SIZE)
{
throw new Exception($"Data transfer ({data.Length} bytes) cannot exceed {Transfers.MAX_TRANSFER_SIZE} bytes.");
}
_data = data;
Description = description;
CurrentState = TransferState.NotStarted;
}
protected OnlineTransferCoroutineOperation(SessionInterface sessionInterface, INetworkInterfaceConnection destination, ushort transferId)
: base(sessionInterface, destination)
{
_transferId = transferId;
}
public NewPoint(SessionInterface sesinter, int sessionId) : this()
{
sessionID = sessionId;
this.sesinter = sesinter;
}
void OnSessionInterfaceTerminating()
{
SessionInterface = null;
}
public void Initialize(SessionInterface sessionInterface, ConstructSimulationTickSystem.ValidationDelegate simInputValidationMethod)
{
if (IsInitialized)
{
throw new Exception($"{nameof(SimulationControlSystemGroup)} is already initialized");
}
IsInitialized = true;
switch (sessionInterface)
{
case SessionClientInterface _: // Client
IsClient = true;
IsLocal = false;
IsServer = false;
break;
case null: // Local play
IsClient = false;
IsLocal = true;
IsServer = false;
break;
case SessionServerInterface _: // Server
IsClient = false;
IsLocal = false;
IsServer = true;
break;
}
_simulationWorldSystem = World.GetOrCreateSystem <SimulationWorldSystem>();
_simulationWorldSystem.ClearSimWorld();
_simulationWorldSystem.ReadyForEntityInjections = true;
World.GetOrCreateSystem <ViewSystemGroup>().Initialize(this);
ManualCreateAndAddSystem <SubmitSimulationInputSystem>();
ManualCreateAndAddSystem <LoadSimulationSceneSystem>();
ManualCreateAndAddSystem <SaveAndLoadSimulationSystem>();
ManualCreateAndAddSystem <ChecksumSystem>();
if (IsMaster)
{
ManualCreateAndAddSystem <ConstructSimulationTickSystem>().ValidationMethod = simInputValidationMethod;
}
if (IsClient)
{
ManualCreateAndAddSystem <ReceiveSimulationSyncSystem>();
ManualCreateAndAddSystem <ReceiveSimulationTickSystem>();
}
if (IsServer)
{
ManualCreateAndAddSystem <SendSimulationSyncSystem>();
ManualCreateAndAddSystem <SendSimulationTickSystem>();
ManualCreateAndAddSystem <ReceiveSimulationInputSystem>();
}
ManualCreateAndAddSystem <RequestChecksumSystem>(); // todo: move back to server
#if UNITY_EDITOR
// This is a hack to force the EntityDebugger to correctly update the list of displayed systems
{
PlayerLoopSystem playerLoop = PlayerLoop.GetCurrentPlayerLoop();
PlayerLoopSystem[] oldArray = playerLoop.subSystemList;
playerLoop.subSystemList = new PlayerLoopSystem[oldArray.Length];
Array.Copy(oldArray, 0, playerLoop.subSystemList, 0, oldArray.Length);
PlayerLoop.SetPlayerLoop(playerLoop);
}
#endif
}
private const float PROGRESS_UPDATE_INTERVAL = 2f; // update the uploader on the progress every 2s
public ReceiveViaStreamChannelOperation(NetMessageViaStreamChannelHeader transferHeader, INetworkInterfaceConnection source, SessionInterface sessionInterface)
: base(sessionInterface, source, transferHeader.TransferId)
{
_transferHeader = transferHeader;
CurrentState = TransferState.NotStarted;
}
protected OnlineComCoroutineOperation(SessionInterface sessionInterface, INetworkInterfaceConnection destination)
{
_sessionInterface = sessionInterface;
_connection = destination;
}
public static void SendNetMessage <T>(this SessionInterface sessionInterface, in T netMessage, params INetworkInterfaceConnection[] connections)
