public void StartSession(IP2PAddress address)
 {
     if (P2PSession.Instance != null)
     {
         P2PSession.Instance.Start(address);
     }
 }
Example #2
0
 public bool Start(IP2PAddress address)
 {
     this.StartInternal();
     if (P2PTransportLayer.Instance.GetLayerType() == ETransporLayerType.UNet)
     {
         P2PAddressUnet p2PAddressUnet = address as P2PAddressUnet;
         if (p2PAddressUnet.m_IP.Equals("localhost"))
         {
             p2PAddressUnet.m_IP = "127.0.0.1";
         }
         else if (p2PAddressUnet.m_IP.IndexOf(":") != -1 && !P2PSession.IsValidIpV6(p2PAddressUnet.m_IP) && P2PLogFilter.logError)
         {
             Debug.LogError("Invalid ipv6 address " + p2PAddressUnet.m_IP);
         }
     }
     this.SetGameVisibility(GreenHellGame.Instance.m_Settings.m_GameVisibility);
     this.m_LocalPeer.SetLocalHostId((short)P2PTransportLayer.Instance.AddHost(P2PSession.s_HostTopology, ref address));
     if (this.m_LocalPeer.GetLocalHostId() == P2PPeer.s_InvalidId)
     {
         if (P2PLogFilter.logError)
         {
             Debug.LogError("StartServer listen failed.");
         }
         return(false);
     }
     this.m_LocalPeer.m_Address = address;
     this.m_LocalPeer.SetHostId(this.m_LocalPeer.GetLocalHostId());
     if (P2PLogFilter.logDebug)
     {
         Debug.Log("P2PSession listen start with id: " + this.GetSessionId());
     }
     this.Status = P2PSession.ESessionStatus.Listening;
     return(true);
 }
Example #3
0
    public void GetConnectionInfo(int connection_id, out IP2PAddress address, out byte error)
    {
        address = new P2PAddressUnet();
        P2PAddressUnet p2PAddressUnet = (P2PAddressUnet)address;
        NetworkID      networkID;
        NodeID         nodeID;

        NetworkTransport.GetConnectionInfo((int)P2PSession.Instance.LocalPeer.GetLocalHostId(), connection_id, out p2PAddressUnet.m_IP, out p2PAddressUnet.m_Port, out networkID, out nodeID, out error);
    }
 public static void OnExternalLobbyJoinRequest(IP2PAddress address)
 {
     P2PTransportLayer.OnExternalLobbyJoinRequestDel onExternalLobbyJoinRequestEvent = P2PTransportLayer.OnExternalLobbyJoinRequestEvent;
     if (onExternalLobbyJoinRequestEvent == null)
     {
         return;
     }
     onExternalLobbyJoinRequestEvent(address);
 }
    public void GetConnectionInfo(int connection_id, out IP2PAddress address, out byte error)
    {
        CSteamID connectionSteamId = this.GetConnectionSteamId(connection_id);

        address = new P2PAddressSteam
        {
            m_SteamID = connectionSteamId
        };
        error = ((connectionSteamId == CSteamID.Nil) ? 2 : 0);
    }
 public string GetPlayerDisplayName(IP2PAddress address)
 {
     foreach (P2PLobbyMemberInfo p2PLobbyMemberInfo in this.m_LobbyMembers)
     {
         if (p2PLobbyMemberInfo.m_Address.Equals(address))
         {
             return(p2PLobbyMemberInfo.m_Name);
         }
     }
     return(SteamFriends.GetFriendPersonaName((address as P2PAddressSteam).m_SteamID));
 }
Example #7
0
    public int ConnectWithSimulator(IP2PAddress address, out byte error, ConnectionSimulatorConfig config)
    {
        P2PAddressUnet p2PAddressUnet = address as P2PAddressUnet;

        if (p2PAddressUnet != null)
        {
            return(NetworkTransport.ConnectWithSimulator((int)P2PSession.Instance.LocalPeer.GetLocalHostId(), p2PAddressUnet.m_IP, p2PAddressUnet.m_Port, 0, out error, config));
        }
        Debug.LogError(string.Format("Using invalid IP2PAddress type {0}", address.GetType()));
        error = 0;
        return(-1);
    }
Example #8
0
    public int AddHost(HostTopology topology, ref IP2PAddress address)
    {
        P2PAddressUnet p2PAddressUnet = address as P2PAddressUnet;

        if (p2PAddressUnet == null)
        {
            Debug.LogError(string.Format("Using invalid IP2PAddress type {0}", address.GetType()));
            return(-1);
        }
        if (p2PAddressUnet.m_IP.Empty())
        {
            return(NetworkTransport.AddHost(topology, p2PAddressUnet.m_Port));
        }
        return(NetworkTransport.AddHost(topology, p2PAddressUnet.m_Port, p2PAddressUnet.m_IP));
    }
Example #9
0
    public void Write(IP2PAddress addr)
    {
        ETransporLayerType layerType = P2PTransportLayer.Instance.GetLayerType();

        if (layerType == ETransporLayerType.UNet)
        {
            P2PAddressUnet p2PAddressUnet = addr as P2PAddressUnet;
            this.Write(p2PAddressUnet.m_IP);
            this.Write(p2PAddressUnet.m_Port);
            return;
        }
        if (layerType != ETransporLayerType.Steam)
        {
            throw new NotImplementedException();
        }
        P2PAddressSteam p2PAddressSteam = addr as P2PAddressSteam;

        this.Write(p2PAddressSteam.m_SteamID.m_SteamID);
    }
Example #10
0
 public void Connect(IP2PAddress address)
 {
     this.m_LocalPeer.SetHostId(P2PPeer.s_InvalidId);
     this.ConnectInternal(address);
 }
Example #11
0
    public int AddHostWithSimulator(HostTopology topology, int min_timeout, int max_timeout, ref IP2PAddress address)
    {
        P2PAddressUnet p2PAddressUnet = address as P2PAddressUnet;

        if (p2PAddressUnet != null)
        {
            return(NetworkTransport.AddHostWithSimulator(topology, min_timeout, max_timeout, p2PAddressUnet.m_Port));
        }
        Debug.LogError(string.Format("Using invalid IP2PAddress type {0}", address.GetType()));
        return(-1);
    }
Example #12
0
 public string GetPlayerDisplayName(IP2PAddress address)
 {
     return(string.Empty);
 }
Example #13
0
 public bool IsSameAddress(IP2PAddress addr)
 {
     return(this.m_Address.Equals(addr));
 }
 public int Connect(IP2PAddress address, out byte error)
 {
     error = 0;
     return(-1);
 }
 public int AddHostWithSimulator(HostTopology topology, int min_timeout, int max_timeout, ref IP2PAddress address)
 {
     return(this.AddHost(topology, ref address));
 }
 public int ConnectWithSimulator(IP2PAddress address, out byte error, ConnectionSimulatorConfig config)
 {
     return(this.Connect(address, out error));
 }
Example #17
0
 public void JoinLobby(IP2PAddress address)
 {
 }
Example #18
0
    private void ConnectInternal(IP2PAddress address)
    {
        this.StartInternal();
        this.m_AmIMaster = false;
        P2PAddressUnet p2PAddressUnet = address as P2PAddressUnet;

        if (p2PAddressUnet != null)
        {
            if (p2PAddressUnet.m_IP.Equals("localhost"))
            {
                p2PAddressUnet.m_IP = "127.0.0.1";
            }
            else if (p2PAddressUnet.m_IP.IndexOf(":") != -1 && !P2PSession.IsValidIpV6(p2PAddressUnet.m_IP) && P2PLogFilter.logError)
            {
                Debug.LogError("Invalid ipv6 address " + p2PAddressUnet.m_IP);
            }
        }
        int networkConnectionId;

        if (this.m_UseSimulator)
        {
            int num = this.m_SimulatedLatency / 3;
            if (num < 1)
            {
                num = 1;
            }
            if (P2PLogFilter.logDebug)
            {
                Debug.Log(string.Concat(new object[]
                {
                    "Connect Using Simulator ",
                    this.m_SimulatedLatency / 3,
                    "/",
                    this.m_SimulatedLatency
                }));
            }
            ConnectionSimulatorConfig config = new ConnectionSimulatorConfig(num, this.m_SimulatedLatency, num, this.m_SimulatedLatency, this.m_PacketLoss);
            byte b;
            networkConnectionId = P2PTransportLayer.Instance.ConnectWithSimulator(address, out b, config);
        }
        else
        {
            byte b;
            networkConnectionId = P2PTransportLayer.Instance.Connect(address, out b);
        }
        P2PConnection p2PConnection = (P2PConnection)Activator.CreateInstance(typeof(P2PConnection));

        p2PConnection.SetHandlers(this.m_MessageHandlers);
        P2PPeer p2PPeer = null;

        for (int i = 0; i < this.m_PendingPeers.Count; i++)
        {
            if (this.m_PendingPeers[i].IsSameAddress(address))
            {
                p2PPeer = this.m_PendingPeers[i];
                this.m_PendingPeers.RemoveAt(i);
                break;
            }
        }
        if (p2PPeer == null)
        {
            p2PPeer           = new P2PPeer();
            p2PPeer.m_Address = address;
        }
        if (!this.m_RemotePeersInternal.Contains(p2PPeer))
        {
            this.m_RemotePeersInternal.Add(p2PPeer);
        }
        p2PConnection.Initialize(p2PPeer, networkConnectionId, P2PSession.s_HostTopology);
        this.SetConnectionAtIndex(p2PConnection);
        if (this.Status == P2PSession.ESessionStatus.Idle)
        {
            this.Status = P2PSession.ESessionStatus.Connecting;
        }
    }
 public int AddHost(HostTopology topology, ref IP2PAddress address)
 {
     return(0);
 }