Ejemplo n.º 1
0
    // receives data from the server.
    void ReceiveDataFromServer()
    {
        // Time (float) - 4 bytes
        // Number of Players (Int) - 4 Bytes
        // Number of Active Item Boxes (Int) - 4 bytes
        // Players
        // Items

        // data to be sent out to clients.
        byte[] recData = client.client.GetReceiveBufferData();
        int    index   = 0;

        // list of other players
        List <RemotePlayer> otherPlayers = new List <RemotePlayer>(players);

        otherPlayers.Remove(localPlayer); // remove local player from list.

        // list of unmatched data. This should always be of size 1 since the controlled player getsi gnored..
        List <RemotePlayer.RemotePlayerData> unmatchedData = new List <RemotePlayer.RemotePlayerData>();

        // the list of found id values.
        List <int> foundIds = new List <int>();

        // values
        float time      = -1.0F;
        int   plyrCount = -1;
        int   itemCount = -1;

        // Timer
        {
            time = BitConverter.ToSingle(recData, index);

            // TODO: check to see if the difference is great enough to make a change.
            // sets time.
            timer.SetCurrentTimeValue(time);
            index += sizeof(float);
        }

        // Number of Players
        {
            plyrCount = BitConverter.ToInt32(recData, index);
            // TODO: check to see if number of players changed?
            index += sizeof(int);
        }

        // Number of Item Boxes
        {
            itemCount = BitConverter.ToInt32(recData, index);
            // TODO: adjust item box amount
            index += sizeof(int);
        }


        // Players - getting player data
        for (int i = 0; i < plyrCount; i++)
        {
            // the player count is different.
            // if (i >= otherPlayers.Count)
            //     continue;

            // gets data section
            byte[] pData = new byte[RemotePlayer.DATA_SIZE];
            Buffer.BlockCopy(recData, index, pData, 0, RemotePlayer.DATA_SIZE);
            index += pData.Length; // move onto next slot.

            // otherPlayers[i].ApplyData(pData);

            // converts data first before finding who it belongs to.
            RemotePlayer.RemotePlayerData rpd = RemotePlayer.BytesToRemotePlayerData(pData);

            // if the scale is 0, that means that no data was received.
            // you know this because under no circumstance should the scale EVER be zero.
            // TODO: this fix didn't stop the models swapping positions constantly.
            if (rpd.scale == Vector3.zero)
            {
                // since no data was received, skip.
                continue;
            }

            // if the id exists in the list, then it's that data has already been used.
            // as such, the data should be ignored.
            if (foundIds.Contains(rpd.idNumber))
            {
                continue;
            }

            // if the id number for the provided data is the same as that for the local player it is ignored.
            // The list otherPlayers will always be one less than plyrCount due to the local player already being removed.
            if (rpd.idNumber == localPlayer.idNumber)
            {
                continue;
            }

            // checks to see if the data matched.
            bool matched = false;

            // goes through list to find which player to put it on.
            // goes through all player data passed.
            for (int j = 0; j < otherPlayers.Count; j++)
            {
                // if the id numbers match, apply the data.
                if (otherPlayers[j].idNumber == rpd.idNumber)
                {
                    otherPlayers[j].ApplyData(rpd); // applies data
                    otherPlayers.RemoveAt(j);       // removes matched player
                    matched = true;                 // data matched.

                    // adds the id to the list so that you know the data hasn't been set twice.
                    foundIds.Add(rpd.idNumber);

                    break;
                }
            }

            // saves data if it did not find a match.
            if (matched == false)
            {
                unmatchedData.Add(rpd);
            }


            // applies the data.
            // otherPlayers[i].ApplyData(pData);
        }


        // unmatched data is applied to any remaining objects.
        if (unmatchedData.Count != 0 && otherPlayers.Count != 0)
        {
            // applies data based on placement in list.
            do
            {
                // this should match the id number, meaning that it shouldn't be matched here ever again.
                otherPlayers[0].ApplyData(unmatchedData[0]);
                unmatchedData.RemoveAt(0);
                otherPlayers.RemoveAt(0);
            }while (unmatchedData.Count != 0 && otherPlayers.Count != 0);

            // // applies data based on placement in list.
            // for(int i = 0; i < otherPlayers.Count && i < unmatchedData.Count; i++)
            // {
            //     otherPlayers[i].ApplyData(unmatchedData[i]);
            // }
        }

        // Item Box Data
        // TODO: turn off item spawner for client so that it doesn't make new items.
        if (itemSpawner != null) // item spawner must be available for this to work.
        {
            // disables the spawner
            // itemSpawner.spawnerEnabled = false;

            FieldItem[] activeItems = FindObjectsOfType <FieldItem>(false);
            List <FieldItem.FieldItemData> recItems = new List <FieldItem.FieldItemData>();
            int arrIndex = 0;

            // gets all item transformation data.
            for (int i = 0; i < itemCount; i++)
            {
                // gets data section
                byte[] iData = new byte[FieldItem.DATA_SIZE];
                Buffer.BlockCopy(recData, index, iData, 0, FieldItem.DATA_SIZE);
                recItems.Add(FieldItem.BytesToFieldItemData(iData)); // adds data to list.

                index += iData.Length;                               // move onto next slot.
            }

            // while the array index is less than the amount of active items and received items.
            while (arrIndex < activeItems.Length && arrIndex < recItems.Count)
            {
                activeItems[arrIndex].ApplyData(recItems[arrIndex]);
                arrIndex++; // increment.
            }

            // gets the instance
            ItemManager im = ItemManager.GetInstance();

            // more items on the field than there should be.
            if (arrIndex < activeItems.Length)
            {
                // returns the item, and increments it.
                while (arrIndex < activeItems.Length)
                {
                    im.ReturnItem(activeItems[arrIndex]);
                    arrIndex++;
                }
            }
            // less items on the field than there should be.
            else if (arrIndex < recItems.Count)
            {
                // gets a new item, and adds it in.
                while (arrIndex < recItems.Count)
                {
                    FieldItem fieldItem = im.GetItem();
                    fieldItem.ApplyData(recItems[arrIndex]);
                    arrIndex++;
                }
            }
        }
    }