/// <summary>
    /// shuts down the networking capabilities of netutil
    /// </summary>
    public void Shutdown()
    {
        // shut down hosts

        m_state  = NetUtilState.UNINITIALIZED;
        m_isHost = false;
        NetworkTransport.RemoveHost(m_host);
    }
    /// <summary>
    /// handles an incoming host info message
    /// </summary>
    private void HandleHostInfo(int connectionId, byte[] buffer, int size)
    {
        NetUtilHostState state = ConstructType <NetUtilHostState>(buffer, 1, size - 1);

        m_hostTime = state.time;
        m_salt     = state.salt;

        m_state = NetUtilState.CONNECTED;
    }
    /// <summary>
    /// attempts to connect to a similar peer
    /// </summary>
    /// <param name="t_ip">the address of the peer to connect to</param>
    public void Connect(string t_ip, int t_port = -1)
    {
        byte error = 0;

        if (t_port <= 0)
        {
            t_port = m_hostSocket;
        }
        m_hostId = NetworkTransport.Connect(m_host, t_ip, t_port, 0, out error);
        AddConnection(m_hostId, "host");

        m_state = NetUtilState.INITIALIZED;
    }
    /// <summary>
    /// sets up the networking capabilities of netutil
    /// </summary>
    private void Setup(NetUtilType t_type)
    {
        // set up network transport
        if (!NetworkTransport.IsStarted)
        {
            NetworkTransport.Init();
        }

        // set up network topology
        ConnectionConfig config = new ConnectionConfig();

        config.PacketSize   = 1024;
        config.FragmentSize = 512 - 128;
        m_lowSyncChannel    = config.AddChannel(QosType.Unreliable);
        m_highSyncChannel   = config.AddChannel(QosType.Reliable);
        m_messageChannel    = config.AddChannel(QosType.ReliableSequenced);
        HostTopology topology = new HostTopology(config, 16);

        // set up host

        switch (t_type)
        {
        case NetUtilType.LISTENER: {
            m_isHost = false;
            m_host   = NetworkTransport.AddHost(topology, m_clientSocket);
            byte error;
            NetworkTransport.SetBroadcastCredentials(m_host, m_gameId, m_majorVersion, m_minorVersion, out error);
        } break;

        case NetUtilType.HOST: {
            m_isHost = true;
            m_host   = NetworkTransport.AddHost(topology, m_hostSocket);
        } break;

        case NetUtilType.CLIENT: {
            m_isHost = false;
            m_host   = NetworkTransport.AddHost(topology);
        } break;
        }

        m_functionality = t_type;

        // set state bools

        m_state = NetUtilState.INITIALIZED;

        DebugConsole.Log("Socket opened");
    }
    /// <summary>
    /// handles connection messages
    /// </summary>
    /// <param name="connectionId">connection id the message came from</param>
    private void HandleConnect(int connectionId)
    {
        if (m_isHost)
        {
            if (!m_connections.ContainsKey(connectionId))
            {
                AddConnection(connectionId, "");
                byte error;

                NetUtilHostState state = new NetUtilHostState();

                state.time = m_hostTime;
                state.salt = ++m_salt;

                SendMessage(m_host, connectionId, m_messageChannel, NetUtilMessageType.HOST_INFO, state, out error);

                foreach (NetUtilObjectCreator creator in m_activeObjects.Values)
                {
                    SendMessage(m_host, connectionId, m_messageChannel, NetUtilMessageType.CREATE_OBJECT, creator, out error);
                }

                m_state = NetUtilState.CONNECTED;
            }
        }
        else
        {
            if (connectionId != m_hostId)
            {
                DebugConsole.Log("an unknown connection attempt has occured.");
            }
            else
            {
                SendMessage(NetUtilMessageType.CONNECTION_INFO, m_name);
            }
        }
    }