public void RelayConfirmed(int uid)
{
//If someone gets back to us late, we ignore them.
if (CurrentState == ConnectionStateMachine.RELAY_SEARCH)
{
//Disconnect the previous relay
//If it's even still there
if (networking.SignaledPeers.ContainsKey(relayUID))
{
TryDisconnect(networking.SignaledPeers[relayUID], nameof(ConnectionLost), this, nameof(RelayLost));
}
//swap to new relay
relayUID = uid;
networking.SignaledPeers[relayUID].Connect(nameof(ConnectionLost), this, nameof(RelayLost));
if (initiator)
{
PeerConnection.CreateOffer();
}
CurrentState = ConnectionStateMachine.RELAY;
GD.Print("RELAY CONFIRMED");
Poll();
}
}
public void Construct(ServiceProvider provider, ConnectionStateMachine connMachine, UIManager uiManager)
{
_netManager = provider.networkManager;
_netDiscovery = provider.networkDiscovery;
_connMachine = connMachine;
_uiManager = uiManager;
}
public void Construct(ConnectionStateMachine connManager, ServiceProvider provider, UIManager uiManager, LobbyManager lobbyManager)
{
_connManager = connManager;
_networkManager = provider.networkManager;
_uiManager = uiManager;
_lobbyManager = lobbyManager;
}
//Networking is basically a singleton.
public SignaledPeer(int _UID, Networking networking, ConnectionStateMachine startingState, System.Timers.Timer _PollTimer, bool _initiator)
{
UID = _UID;
this.networking = networking;
CurrentState = startingState;
initiator = _initiator;
PollTimer = _PollTimer;
PollTimer.Elapsed += Poll;
PeerConnection = new WebRTCPeerConnection();
PeerConnection.Connect("session_description_created", this, "_OfferCreated");
PeerConnection.Connect("ice_candidate_created", this, "_IceCandidateCreated");
PeerConnection.Initialize(RTCInitializer);
//Setting up the voting mechanism.
PackedScene slushScene = GD.Load <PackedScene>("res://addons/PurePeerSignaling/SlushNode.tscn");
slushNode = (SlushNode)slushScene.Instance();
slushNode.Name = UID.ToString();
networking.GetNode("SlushNodes").AddChild(slushNode);
slushNode.proposal = false;
Connect(nameof(Delete), slushNode, "queue_free");
LastPing = DateTime.Now;
Log.Information("SignaledPeer {UID} created.", UID);
}
protected SessionState(UIManager manager, ConnectionStateMachine owner)
{
Manager = manager;
ScreenManager = manager.ScreenManager;
Owner = owner;
Blackboard = Owner.Blackboard;
}
public void Construct(GameStateMachine manager, LobbyManager lobbyManager, ConnectionStateMachine connManager, NetworkedGameManager netGameManager, GameSettings gameSettings)
{
_gameStateManager = manager;
_lobbyManager = lobbyManager;
_connManager = connManager;
_netGameManager = netGameManager;
_gameSettings = gameSettings;
}
public void RelayLost()
{
if (CurrentState == ConnectionStateMachine.RELAY)
{
CurrentState = ConnectionStateMachine.RELAY_SEARCH;
Poll();
}
}
public void Construct(EnvironmentSettings envSettings, PrefabManager prefabManager, GridManager gridManager, Track track, ConnectionStateMachine connManager)
{
_envSettings = envSettings;
_prefabManager = prefabManager;
_gridManager = gridManager;
_track = track;
_connManager = connManager;
}
// Start is called before the first frame update
void Start()
{
_stateMachine = new ConnectionStateMachine(this);
_stateMachine.OnEnable(ConnectionFSMStateEnum.StateEnum.START);
if (_playFab == null)
{
_playFab = GetComponent <PlayFabLogin>();
}
}
public void ResetConnection()
{
PeerConnection.Close();
PeerConnection.Initialize(RTCInitializer);
remoteReady = false;
localReady = false;
buffer = new List <BufferedCandidate>();
ShuffleRelayCandidates();
CurrentState = ConnectionStateMachine.RELAY_SEARCH;
Poll();
}
public void Construct(ConnectionStateMachine connMachine, GameStateMachine gameStateMachine, LobbyManager lobbyManager)
{
_connMachine = connMachine;
_gameStateMachine = gameStateMachine;
_lobbyManager = lobbyManager;
}
public void Construct(GameStateMachine gameStateManager, LobbyManager lobbyManager, ConnectionStateMachine connManager)
{
_gameStateManager = gameStateManager;
_lobbyManager = lobbyManager;
_connManager = connManager;
}
public void Construct(ConnectionStateMachine connManager, UIManager uiManager, GameStateMachine gameStateMachine)
{
_connManager = connManager;
_uiManager = uiManager;
_gameStateMachine = gameStateMachine;
}
public DefaultPlayState(UIManager manager, ConnectionStateMachine owner) : base(manager, owner)
{
}
// Start is called before the first frame update
void Start()
{
_stateMachine = new ConnectionStateMachine(this);
_stateMachine.OnEnable(ConnectionFSMStateEnum.StateEnum.START);
}
public void Construct(ConnectionStateMachine connManager, ServiceProvider provider, GameStateMachine gameStateMachine)
{
_connManager = connManager;
_networkManager = provider.networkManager;
_gameStateMachine = gameStateMachine;
}
public void Construct(ConnectionStateMachine connMachine)
{
_connMachine = connMachine;
}
public void Poll()
{
if (VOTE_TIME < (DateTime.Now - LastPing) && CurrentState != ConnectionStateMachine.MANUAL)
{
slushNode.proposal = true;
}
else
{
slushNode.proposal = false;
}
//If enough others have voted to DC this peer, DC immediately.
//Integer math is fine here, since the threshold is an integer anyways.
// GD.Print(slushNode.Name, " Votes: ", slushNode.consensus, slushNode.confidence0, " ", slushNode.confidence1);
if (slushNode.consensus && slushNode.confidence1 == 10)
{
DeleteSelf();
return;
}
switch (CurrentState)
{
case ConnectionStateMachine.NOMINAL:
if (RESET_TIME < (DateTime.Now - LastPing))
{
ResetConnection();
GD.Print("emitting CONNECTION LOST");
EmitSignal(nameof(ConnectionLost));
CurrentState = ConnectionStateMachine.RELAY_SEARCH;
}
break;
case ConnectionStateMachine.RELAY_SEARCH:
if (relayCandidates.Count == 0)
{
ShuffleRelayCandidates();
}
//If it's still zero, then there's no relay candidates
//so we should do nothing.
if (relayCandidates.Count != 0)
{
int nextCandidate = relayCandidates.Dequeue();
if (
!networking.SignaledPeers.ContainsKey(nextCandidate) ||
!(networking.SignaledPeers[nextCandidate].CurrentState == ConnectionStateMachine.NOMINAL)
)
{
break;
}
//No use testing a candidate that _we_ aren't even connected to.
//Realistically can only happen if someone leaves while you're joining,
//or if a peer that's still joining ends up here.
//So should be a very uncommon occurrence.
GD.Print("NEXT CANDIDATE:", nextCandidate);
networking.RpcId(nextCandidate, "CheckRelay", UID);
}
break;
}
if (networking.RTCMP.HasPeer(UID) && PeerConnection.GetConnectionState() == WebRTCPeerConnection.ConnectionState.Connected && CurrentState != ConnectionStateMachine.NOMINAL)
{
if (networking.SignaledPeers.ContainsKey(relayUID))
{
TryDisconnect(networking.SignaledPeers[relayUID], nameof(ConnectionLost), this, nameof(RelayLost));
}
LastPing = DateTime.Now;
CurrentState = ConnectionStateMachine.NOMINAL;
}
}
public void Construct(ConnectionStateMachine connMachine, ScoreManager scoreManager)
{
_connMachine = connMachine;
_scoreManager = scoreManager;
}
