public virtual void Start(Report Report)
        {
            InitializeRazor();

            _report = Report;

            _filePath = Report.FilePath;
            _displayOrder = Report.DisplayOrder;
            _networkMode = Report.NetworkMode;

            Thread.CurrentThread.CurrentUICulture = Report.Culture;

            bool replaceExisting = Report.ReplaceExisting;

            if (!File.Exists(_filePath))
            {
                replaceExisting = true;
            }

            if (replaceExisting)
            {
                _extentSource = Extent.Source;
            }
            else
            {
                _extentSource = File.ReadAllText(_filePath);
            }

            _extentSource = _extentSource.Replace("<!--%SuiteStartedTime%-->", _report.StartTime.ToString());
        }

 public HandshakePacket(int protocolVersion, string hostname, ushort port, NetworkMode nextState)
 {
     ProtocolVersion = protocolVersion;
     ServerHostname = hostname;
     ServerPort = port;
     NextState = nextState;
 }

    void Start()
    {

#if UNITY_IOS
        serverConnect.SetActive(false);
        gameConnectPanel.gameObject.SetActive(false);
        connectPanel.gameObject.SetActive(true);
#endif
        //logLevel = LogFilter.FilterLevel.Debug;
        GameObject es = GameObject.Find("EventSystem");
        GameObject.DontDestroyOnLoad(es);
        isPause = false;
        SingletonNM = this;
        currentMode = NetworkMode.Level;
        selectedDifficulty = selectedDifficulty = LevelEnum.Unselected;
        //currentPanel = connectPanel;
        lobbyPlayerArray = new ArrayList(maxPlayers);
        gameplayerControllers = new ArrayList(maxPlayers);
        disconnectedPlayerControllers = new ArrayList(maxPlayers);
        userNameSet = new HashSet<string>();
        levels = new ArrayList(maxPlayers);
        for (int i = 0; i < maxPlayers; i++)
        {
            lobbyPlayerArray.Add(null);
            gameplayerControllers.Add(null);
            disconnectedPlayerControllers.Add(null);
            levels.Add(LevelEnum.Unselected);
        }

        lobbySystemStartSetting();
        citizenshipZeroTime = 0;
        //StartCoroutine(startLatency());
        //infoPanel.DisplayDisconnectError("Client error : ", StopClientClbk, ReconnectClinetClbk);
    }

 public HandshakePacket(int protocolVersion, string serverAddress, ushort port, NetworkMode nextState)
 {
     ProtocolVersion = protocolVersion;
     ServerAddress = serverAddress;
     Port = port;
     NextState = nextState;
 }

 public NetworkMode WritePacket(MinecraftStream stream, NetworkMode mode, PacketDirection direction)
 {
     stream.WriteVarInt(ProtocolVersion);
     stream.WriteString(ServerHostname);
     stream.WriteUInt16(ServerPort);
     stream.WriteVarInt((int)NextState);
     return NextState;
 }

 public NetworkMode ReadPacket(MinecraftStream stream, NetworkMode mode, PacketDirection direction)
 {
     ProtocolVersion = stream.ReadVarInt();
     ServerHostname = stream.ReadString();
     ServerPort = stream.ReadUInt16();
     NextState = (NetworkMode)stream.ReadVarInt();
     return NextState;
 }

        public ExtentReports(string FilePath, bool ReplaceExisting = true, DisplayOrder Order = DisplayOrder.OldestFirst, NetworkMode NetworkMode = NetworkMode.Online)
        {
            this.FilePath = FilePath;
            this.ReplaceExisting = ReplaceExisting;
            this.DisplayOrder = DisplayOrder;
            this.NetworkMode = NetworkMode;

            Attach(new HTMLReporter());
        }

 Network()
 {
     networkThread = null;
     mode = NetworkMode.HOST;
     chatBuffer = new System.Collections.Generic.Queue<Chat>();
     gameBuffer = new System.Collections.Generic.Queue<Action>();
     ip = "127.0.0.1";
     port = 10101;
     stream = null;
 }

 public Networking(Game game, ConnectionExitedDelegate ced, IPAddress ipAddress, int port, bool server)
 {
     this.game = game;
     this.ced = ced;
     this.ipAddress = ipAddress;
     if (server)
     {
         this.networkMode = NetworkMode.SERVER;
         this.server = new TCPServer(this, ipAddress, port);
     }
     else
     {
         this.networkMode = NetworkMode.CLIENT;
         this.client = new TCPClient(this, ced, ipAddress, port);
     }
 }

        public MinecraftStream(Stream stream, NetworkMode mode)
        {
            _stream = stream;
            Mode = mode;

            switch (Mode)
            {
                case NetworkMode.Modern:
                    _encoding = Encoding.UTF8;
                    break;

                case NetworkMode.Classic:
                    _encoding = Encoding.ASCII;
                    break;
            }
        }

    void Start()
    {
        node = NetworkNode.node;
        if (node == null) //if null, no networking, server controls it if there is networking
        {
            mode = NetworkMode.UNKNOWN;
            StartCoroutine(LocalGoalSpawning());
        }
        else if(node is Server)
        {
            mode = NetworkMode.LOCALSERVER;
            StartCoroutine(ServerGoalSpawning());
        }
        else if (node is Client)
        {
            mode = NetworkMode.REMOTECLIENT;
            node.Subscribe(this);
        }
	}

        /// <summary>
        /// Create a new Minecraft Instance
        /// </summary>
        /// <param name="login">The username to use when connecting to Minecraft</param>
        /// <param name="password">The password to use when connecting to Minecraft (Ignore if you are providing credentials)</param>
        /// <param name="mode"></param>
        /// <param name="nameVerification">To connect using Name Verification or not</param>
        /// <param name="serverSalt"></param>
        public IMinecraftClient Create(string login, string password, NetworkMode mode, bool nameVerification = false, string serverSalt = null)
        {
            ClientLogin = login;
            ClientPassword = password;
            UseLogin = nameVerification;
            Mode = mode;
            ServerSalt = serverSalt;

            AsyncReceiveHandlers = new Dictionary<Type, Action<IAsyncReceive>>();
            RegisterSupportedReceiveEvents();

            World = new World();
            Player = new Player();
            Entities = new Dictionary<int, Entity>();
            PlayersList = new Dictionary<string, short>();

            _networkHandler = new NetworkHandler();
            _networkHandler.Create(this);

            return this;
        }

    void Start()
    {
        node = NetworkNode.node;
        if (node == null) //if null, no networking, server controls it if there is networking
        {
            mode = NetworkMode.UNKNOWN;
        }
        else if (node is Server)
        {
            mode = NetworkMode.LOCALSERVER;
            node.Subscribe(this);
        }
        else if (node is Client)
        {
            mode = NetworkMode.REMOTECLIENT;
            node.Subscribe(this);
        }

        for (int i = 0; i < charactersData.Length; i++)
        {
            charactersData[i].characterID = i;
        }
    }