private void Awake()
 {
     interactionVolume = gameObject.transform.Find("Interaction Volume").GetComponent <InteractionVolume>();
     Client            = GameObject.Find("Network").GetComponent <UnityClient>();
     Assert.IsNotNull(interactionVolume);
     objManager = GameObject.Find("Network").GetComponent <NetworkObjectManager>();
 }
    private void Awake()
    {
        interactable = gameObject.GetComponent <Interactable>();
        if (interactable == null)
        {
            interactable = gameObject.AddComponent <Interactable>() as Interactable;
        }
        interactable.holdTime = pickupTime;
        interactable.afterUse.AddListener(OnInteractComplete);

        if (!playerController)
        {
            playerController = GameObject.FindGameObjectWithTag("LocalPlayer").GetComponent <LocalPlayerController>();
        }
        //playerController = GameObject.Find("Character").GetComponent<LocalPlayerController>();

        objManager = GameObject.Find("Network").GetComponent <NetworkObjectManager>();



        rb             = GetComponent <Rigidbody>();
        rb.isKinematic = false;
        cd             = GetComponent <Collider>();
        cd.enabled     = true;
    }
    protected virtual void Awake()
    {
        networkObjectManager = GetComponent <NetworkObjectManager>();
        playerManager        = new PlayerManager();
        netChannel           = new NetChannel(debugNetworkSettings);

        netChannel.PeerConnectedHandler    += OnPeerConnected;
        netChannel.PeerDisconnectedHandler += OnPeerDisconnected;
    }
    private void Awake()
    {
        objectManager = gameObject.GetComponent <NetworkObjectManager>();
        Assert.IsNotNull(objectManager);

        client = gameObject.GetComponent <UnityClient>();
        Assert.IsNotNull(client);

        client.MessageReceived += MessageReceived;
    }
    public ServerSimulation(
        float debugPhysicsErrorChance,
        PlayerManager playerManager,
        NetworkObjectManager networkObjectManager,
        Handler handler) : base(playerManager, networkObjectManager)
    {
        this.debugPhysicsErrorChance = debugPhysicsErrorChance;
        this.handler         = handler;
        playerInputProcessor = new PlayerInputProcessor();

        // Initialize timers.
        worldStateBroadcastTimer = new FixedTimer(Settings.ServerSendRate, BroadcastWorldState);
        worldStateBroadcastTimer.Start();
    }
    public ClientSimulation(
        Player localPlayer,
        PlayerManager playerManager,
        NetworkObjectManager networkObjectManager,
        Handler handler,
        int serverLatencyMs,
        uint initialWorldTick) : base(playerManager, networkObjectManager)
    {
        this.localPlayer = localPlayer;
        this.handler     = handler;

        // Setup the simulation adjuster, this delegate will be responsible for time-warping the client
        // simulation whenever we are too far ahead or behind the server simulation.
        simulationAdjuster = clientSimulationAdjuster = new ClientSimulationAdjuster();

        // Set the last-acknowledged server tick.
        lastServerWorldTick = initialWorldTick;

        // Extrapolate based on latency what our client tick should start at.
        WorldTick = clientSimulationAdjuster.GuessClientTick(initialWorldTick, serverLatencyMs);
    }
示例#7
0
        public void InitApplication()
        {
            KadEngine = new KadEngine();

            InitObjectManagers();

            try
            {
                Preference = PreferenceObjectManager.CreatePreference();
                Preference.Load();
            }
            catch
            {
                //TODO:Log
                Preference = PreferenceObjectManager.CreatePreference();
                Preference.Init();
            }

            Statistics = PreferenceObjectManager.CreateStatistics();
            Statistics.Load();

            SharedFiles = CoreObjectManager.CreateSharedFileList();

            ServerConnect            = CoreObjectManager.CreateServerConnect();
            ClientList               = CoreObjectManager.CreateClientList();
            UploadBandwidthThrottler = CoreObjectManager.CreateUploadBandwidthThrottler();

            UploadQueue           = CoreObjectManager.CreateUploadQueue();
            LastCommonRouteFinder = CoreObjectManager.CreateLastCommonRouteFinder();
            ServerList            = ED2KObjectManager.CreateED2KServerList();
            DownloadQueue         = CoreObjectManager.CreateDownloadQueue();
            IPFilter      = CoreObjectManager.CreateIPFilter();
            ClientCredits = CoreObjectManager.CreateClientCreditsList();

            KnownFiles = FileObjectManager.CreateKnownFileList();

            ListenSocket = NetworkObjectManager.CreateListenSocket();
            ClientUDP    = NetworkObjectManager.CreateClientUDPSocket();
        }
 void Awake()
 {
     Instance = this;
 }
示例#9
0
 protected BaseSimulation(PlayerManager playerManager, NetworkObjectManager networkObjectManager)
 {
     this.playerManager        = playerManager;
     this.networkObjectManager = networkObjectManager;
     interpController          = new InterpolationController();
 }